pytroch教程（一）

pytroch基础使用

深度学习模型

回归问题（线性回归、逻辑回归）；分类问题
神经网络：SNN、 ANN、 **CNN、RNN、LSTM、GRU **…
拓展的模型：Seq2Seq with Attention、TCN、DBN

用pyTroch构建模型框架

1、主流的工具

pyTroch：动态计算图——通俗易懂，接近原生python代码
Tensorflow：静态计算图

2、应用

图像——分类ResNet、识别；自然语言处理——翻译、情感分析、问答系统GPT2

3、构建模型

输入——> 模型（架构+超参数）——> 输出

一、入门

一、tensor张量

tensors类似于Numpy的ndarrays，可以使用GPU进行计算

构造一个5*3的矩阵，不进行初始化

x=torch.empty(5,3)   #随机数填充，没有大小范围

构造一个随机初始化的矩阵

 x = torch.rand(5, 3)

构造一个矩阵全为 0，而且指定数据类型

 x = torch.zeros(5, 3, dtype=torch.long)

构造一个张量，直接使用数据

 x = torch.tensor([5.5, 3])

创建一个 tensor 基于已经存在的 tensor

 x = x.new_ones(5, 3, dtype=torch.double)  #.new_ones重用原来的信息x = torch.randn_like(x, dtype=torch.float)  #随机产生一个跟上一个向量形状相同的向量

获得tensor的维度

x.size()  或者 x.shape()

二、简单运算

1、加法

x = torch.rand(5, 3)
y = torch.rand(5, 3)
1、z = x+y)    #z = 两个tensor相加，其 形状与x、y相同
2、z = torch.add(x,y)
3、y.add_(x)   #会把相加的结果保存在y
note：任何的in_place运算都是以下划线结尾，如 x.copy_(y)  会将结果放于x上

2、改变大小

改变大小：如果想改变一个 tensor 的大小或者形状，可以使用 torch.view

x = torch.randn(4, 4)
y = x.view(16)
z = x.view(-1, 8)  # 必须可以整除

3、获取value

如果有一个元素 tensor ，使用 .item() 来获得这个 value

x = torch.randn(1)
print(x.item())  #获得数值 而不是tensor

4、numpy和pytorch的转换

1、将tensor转换成array：

a = torch.ones(5)    # tensor([1,1,1,1,1])
b = a.numpy()    # 将tensor a转换成了：array([1,1,1,1,1])

2、改变b的某一个值

b[1] = 9    # array([1,9,1,1,1])
print(a)    # tensor([1,9,1,1,1])   把a的值也改变了
note：Torch tensor和Numpy array之间共享内存，因此改变其中一项也会改变另一项

3、将numpy array转换成 torch tensor

a = np.ones(5)  # a: array([1,1,1,1,1])
b = torch.from_numpy(a)  # b: tensor([1,1,1,1,1])

5、CUDA Tensor

使用.to方法，Tensor可以被移动到别的device上

if torch.cuda.is_available():device = torch.device("cuda")y = torch.ones_like(x,device = device)x = x..to(device)z = x + yprint(z.to("cpu", torch.double))    #从GPU转到cpu

若是个GPU tensor ，则不能直接转成array，要先移动到cpu   numpy只能在cpu上计算

y.to("cpu").data.numpy()

三、实现两层神经网络

全连接的ReLU神经网络，一个隐藏层，没有bias；用来从x预测y，使用L2 Loss
这一实现完全使用numpy来计算前向神经网络 loss 和反向传播——forward pass – loss – backward pass

# 使用numpy
#定义一下参数：
N, D_in, H，D_out  = 64, 1000, 10, 10
#随机创建训练数据
x = np.random.randn(N, D_in)
x = np.random.randn(N, D_out)
w1 =  np.random.randn(D_in, H)
w2 =  np.random.randn(H,D_out)
#设置学习率
learing_rate = le-6
for t in range(500):
#forward passh = x.dot(w1)  # N*Hh_relu = np.maximum(h,0)  # N*Hy_pred = h_relu.dot(w2)   # N*D_out
#lossloss = np.square(y_pred - y).sum()print(t,loss)
#backward pass  求导grad_y_pred = 2.0 * ( y_pred - y)grad_w2 = h_relu.T.dot(grad_y_pred)grad_h_relu = grad_y_pred.dot(w2.T)grad_h = grad_h_relu.copy()grad_h[h<0] = 0grad_w1 = x.T.dot(grad_h)
#更新weightsw1 -= learning_rate * grad_w1w2 -= learning_rate *grad_w2

// 使用pyTorch  只是一些运算的方法不同
#定义一下参数：
N = 64
D_in = 1000
H = 10
D_out = 10
#随机创建训练数据
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)
w1 = torch.randn(D_in, H)
w2 = torch.randn(H,D_out)
#设置学习率
learning_rate = 1e-6
for t in range(500):
#forward passh = x.mm(w1)  # N*Hh_relu = h.clamp(min=0)  # N*Hy_pred = h_relu.mm(w2)   # N*D_out
#lossloss =(y_pred - y).pow(2).sum().item()print(t,loss)
#backward pass  求导grad_y_pred = 2.0 * ( y_pred - y)grad_w2 = h_relu.t().mm(grad_y_pred)grad_h_relu = grad_y_pred.mm(w2.T)grad_h = grad_h_relu.clone()grad_h[h<0] = 0grad_w1 = x.t().mm(grad_h)
#更新weightsw1 -= learning_rate * grad_w1w2 -= learning_rate *grad_w2

pytorch简单的antograd功能

x = torch.tensor(1. , requires_grad= True)
w = torch.tensor(2. , requires_grad= True)
b = torch.tensor(3. , requires_grad= True)
y = w*x + b  # == loss
y.backward()   #自动计算所有梯度
print(y.grad, w.grad, x.grad, b.grad)
# out: None tensor(1.) tensor(2.) tensor(1.)

#精简代码
N, D_in, H，D_out  = 64, 1000, 10, 10
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)
w1 = torch.randn(D_in, H, requires_grad=True)
w2 = torch.randn(H,D_out, requires_grad=True)
#设置学习率
learning_rate = 1e-6
for t in range(10):
#forward passy_pred = x.mm(w1).clamp(min=0).mm(w2)
#lossloss =(y_pred - y).pow(2).sum()loss.backward()print(loss, w1.grad, w2.grad)with torch.no_grad():w1 -= learning_rate * w1.gradw2 -= learning_rate * w2.gradw1.grad.zero_()w2.grad.zero_()

之后介绍使用torch.nn神经网络