Pytorch基础理论和简单的神经网络实现

2022-09-23

字数统计: 5.1k字 | 阅读时长: 21分

× 文章目录

1. 1. Pytorch的基础知识
2. 2. 热身：用numpy实现两层神经网络
3. 3. Pytorch一步一步的替代上面的网络
4. 4. 教你的网络玩FizzBuzz小游戏

Pytorch官方文档：https://pytorch.org/docs/stable/torch.html?

1. Pytorch的基础知识

1.1 什么是Pytorch？

PyTorch是一个基于Python的科学计算库，它有以下特点:

类似于NumPy，但是它可以使用GPU
可以用它定义深度学习模型，可以灵活地进行深度学习模型的训练和使用
1.2 Tensors

Tensor类似与NumPy的ndarray，唯一的区别是Tensor可以在GPU上加速运算。

下面实际演练一下Tensor的一些构造方式：

# 导入Pytorch
import torch

# 构造一个未初始化的5 * 3的矩阵
x = torch.empty(5, 3)    # 5行3列的未初始化Tensor

# 构造一个随机初始化的矩阵
x = torch.rand(5, 3)  # 5行3列的随机初始化Tensor， 都在0-1之间

# 构造一个全部为0， 类型为long的矩阵
x = torch.zeros(5, 3, dtype=torch.long)   # dtype属性可以指定类型 5行3列的全0tensor

# 从数据中直接构造tensor
x = torch.tensor([5.5, 3])   # tensor([5.5000, 3.0000])

# 可以从一个已有的Tensor构建一个tensor
# 这些方法会重用原来的Tensor的特征，例如数据类型，除非提供新的数据
x = x.new_ones(5, 3, dtype=torch.double)  # 5行3列全1Tensor
y = torch.randn_like(x, dtype=torch.float)  # y也是5行3列

# 得到Tensor的形状
x.size()
x.shape()

1.3 演示一些简单运算

# 加法运算
x = x.new_ones(5, 3, dtype=torch.double)  # new_* methods take in sizes
y = torch.rand(5, 3)
print(x+y)
print(torch.add(x,y))  # 另一种加法的写法

# 加法： 把输出作为一个变量
result = torch.empty(5,3)
torch.add(x, y, out=result)
print(result)

# in-place加法
y.add_(x)
print(y)   # 这时候是y本身加上了x

"""任何in-place的运算都会以``_``结尾。举例来说：``x.copy_(y)``, ``x.t_()``, 会改变 ``x``"""

各种类似NumPy的indexing都可以在PyTorch tensor上面使用。

# 切片
print(x[:,1])

# Resizing:如果希望resize/reshape一个tensor，可以使用torch.view
x = torch.randn(4,4)
y = x.view(16)   # 相当与成了一维的了
z = x.view(-1, 8)  # the size -1 is inferred from other dimensions

# 如果有一个只有一个元素的tensor，使用.item()方法可以把里面的value变成Python数值
x = torch.randn(1)
print(x)   # tensor([0.4276])
print(x.item())  # 0.4276

更多阅读

各种Tensor operations, 包括transposing, indexing, slicing,mathematical operations, linear algebra, random numbers在
https://pytorch.org/docs/torch.

1.4 Numpy和Tensor之间的转化

在Torch Tensor和Numpy array之间的转化非常容易
Torch Tensor和Numpy array会共享内存，所以改变其中一项也会改变另一项
把Torch Tensor转变成Numpy array 函数张量.numpy()
Numpy array 转变成Torch Tensor 用 torch.from_numpy(array)

"""Torch Tensor 转变成Numpy array"""
a = torch.ones(5)
print(a)   # tensor([1., 1., 1., 1., 1.])
b = a.numpy()
print(b)   # [1. 1. 1. 1. 1.]

# 改变numpy里面的数值
a.add_(1)
print(a)    # tensor([2., 2., 2., 2., 2.])
print(b)     # [2. 2. 2. 2. 2.]

"""Numpy array转成Torch Tensor"""
a = np.ones(5)
b = torch.from_numpy(a)
print(a)   # [1. 1. 1. 1. 1.]
print(b)    # tensor([1., 1., 1., 1., 1.])

np.add(a, 1, out=a)  # 这个是在原内存上操作
print(a)  # [2. 2. 2. 2. 2.]
print(b)   # tensor([2., 2., 2., 2., 2.])  

a = a + 1   # 这个是新开辟了一块空间，注意和上面区分
print(a)   # [3. 3. 3. 3. 3.]
print(b)   # tensor([2., 2., 2., 2., 2.])

所有的CPU上的Tensor都支持转成numpy或者从numpy转成Tensor

1.5 CUDA Tensors

如果有GPU的话，我们可以使用.to方法，Tensor被移动到别的device上去

if torch.cuda.is_available():
    device = torch.device("cuda")   # 一个GPU对象
    y = torch.ones_like(x, device=device)
    x = x.to(device)   # x从CPU移到GPU
    z = x + y
    print(z)      # 这是在GPU上完成的加法运算，结果存到z
    print(z.to("cpu", toch.double)  # 把z从GPU移到CPU

一个Tensor在GPU上，是无法直接转成numpy的，需要先转到CPU上

1 2	# y.data.numpy() 这个会报错 y.to("cpu").data.numpy()

把模型搬到GPU上 (如果想用GPU，需要把东西搬到GPU上去)

1	model = model.cuda()

2. 热身：用numpy实现两层神经网络

numpy ndarray是一个普通的n维array。它不知道任何关于深度学习或者梯度(gradient)的知识，也不知道计算图(computation graph)，只是一种用来计算数学运算的数据结构。

我们实现的神经网络长下面这个样子，我已经标注好了参数的维度，并且也把计算过程写了一下：

下面我们根据上面的计算过程，用numpy一步步的实现这个网络：

# 定义样本数，输入层，隐藏层，输出层的参数
N, D_in, H, D_out = 64, 1000, 100, 10

# 创造训练样本x,y  这里随机产生
x = np.random.randn(N, D_in)
y = np.random.randn(N, D_out)

# 随机初始化参数w1， w2
w1 = np.random.randn(D_in, H)
w2 = np.random.randn(H, D_out)

# 下面就是实现神经网络的计算过程
learning_rate = 1e-6
epochs = 500
for epoch in range(epochs):
    # 前向传播
    h = x.dot(w1)
    h_relu = np.maximum(h, 0)
    y_pred = h_relu.dot(w2)
    
    # 计算损失
    loss = np.square(y_pred-y).sum()
    print(epoch, loss)
    
    # 反向传播
    # w2的梯度
    grad_y_pred = 2.0 * (y_pred-y)
    grad_w2 = h_relu.T.dot(grad_y_pred)
    # w1的梯度
    grad_h_relu = grad_y_pred.dot(w2.T)
    grad_h = grad_h_relu.copy()
    grad_h[h<0] = 0
    grad_w1 = x.T.dot(grad_h)
    
    # 更新参数
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2

这样就完成了numpy手写两层神经网络的过程。可以运行一下，会发现loss值随着迭代次数的增加，会减小。

但是你会发现，上面这个过程很复杂的，尤其是反向传播那块，得需要自己小心翼翼的求导数。

所以，我们下面看看Pytorch版本是如何一步一步的取代numpy版本的代码的。（你会享受下面的过程 😉）

3. Pytorch一步一步的替代上面的网络

3.1 Pytorch: Tensors

这次我们使用PyTorch tensors来创建前向神经网络，计算损失，以及反向传播。(也就是先把numpy的写法，换成tensor的写法）

一个PyTorch Tensor很像一个numpy的ndarray。但是它和numpy ndarray最大的区别是，PyTorch Tensor可以在CPU或者GPU上运算。如果想要在GPU上运算，就需要把Tensor换成cuda类型。

# 定义输入，中间，输出层的个数和上面一样
N, D_in, H, D_out = 64, 1000, 100, 10

# 随机创建训练数据   这里的np.random.randn换成Pytorch的写法
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)

# 初始化权重
w1 = torch.randn(D_in, H)
w2 = torch.randn(H, D_out)

#下面训练网络，和上面版本过程一致，只不过有些地方换成了Pytorch的写法而已
learnint_rate = 1e-6
epochs = 500

for epoch in range(epochs):
    # 前向传播   矩阵的点乘这里换成了mm
    h = x.mm(w1)
    h_relu = h.clamp(min=0)     # 这个张量里面换成了clamp操作，来保证元素取值控制在区间内
    y_pred = h_relu.mm(w2)

    # 计算损失   这里要使用张量的item()取出值来
    loss = (y_pred-y).pow(2).sum().item()
    print(epoch, loss)
    
    # 反向传播, 转置操作换成了t(). copy()换成了clone()
    # compute the gradient
    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] = 0
    grad_w1 = x.t().mm(grad_h)
    
    # 更新参数
    w1 -= learning_rate  * grad_w1
    w2 -= learning_rate * grad_w2

这一块，没有太大的改变，只不过是把numpy的数组操作，换成了相应的张量运算，下面我们看看Pytorch一个强大的地方：自动求导，这时候你会发现代码简洁了很多。

3.2 Pytorch: Tensor 和 autograd

PyTorch的一个重要功能就是autograd，也就是说只要定义了forward pass(前向神经网络)，计算了loss之后，PyTorch可以自动求导计算模型所有参数的梯度。

一个PyTorch的Tensor表示计算图中的一个节点。如果x是一个Tensor并且x.requires_grad=True那么x.grad是另一个储存着x当前梯度(相对于一个scalar，常常是loss)的向量。

我们再改动上面代码之前，先看一个简单的自动求导的例子：

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

y.backward()      # 求导只需这一句话

print(w.grad)    # tensor(1.)   也就是x
print(b.grad)    # tensor(1.)    b求导本身为1
print(x.grad)     # tensor(2.)   也就是w

好了，我们尝试引进Pytorch的自动求导机制

# 这里依然不变
N, D_in, H, D_out = 64, 1000, 100, 10   # N表示训练数据的个数， D_in表示输入的特征数 H是中间层，

# 随机创建一下训练数据   这里也不变
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)

# 这里随机初始化权重，需要requires_grad=True  需要保留梯度
w1 = torch.randn(D_in, H, requires_grad=True)
w2 = torch.randn(H, D_out, requires_grad=True)

# 开始神经网络计算
learning_rate = 1e-6
epoches = 500

for epoch in range(epoches):
    # 前向传播，简单精简一下
    y_pred = x.mm(w1).clamp(min=0).mm(w2)
    
    # 计算损失和上面一样
    loss = (y_pred-y).pow(2).sum()
    print(epoch, loss.item())

    # 反向传播  这里我们使用自动求导机制，一句话就搞定
    loss.backward()

    # 更新参数，注意，这时候我们不需要计算w的梯度了，所以得关上梯度计算
    with torch.no_grad():
        w1 -= learning_rate * w1.grad
        w2 -= learning_rate * w2.grad
        
        # 这里还有个关键的地方，就是Pytorch的求导机制是默认采用累加的方式，也就是每一代求完梯度，不会自动清零，下一代的梯度是前一代加上本一代的梯度，这时候就错了，所以我们得自动每一代之后，梯度清零
        w1.grad.zero_()
        w2.grad.zero_()

好了，这个版本的两层神经网络计算，就简单一些了，反向传播过程只需要一句话就搞定了。

但是那两个小问题要注意：

更新参数的时候，我们如果不需要求参数的梯度，我们应该关上梯度计算，这样会节省内存空间
Pytorch的求导机制默认是累加，我们需要每一代之后，参数的导数给它清零

好了，我们已经知道了Pytorch的自动求导机制，.backward()。这时候，会把前面声明时需要求导的参数的导数保存在相应的.grad变量中，我们可以直接使用。下面我们看还能不能精简，哈哈，能的，前向传播也可以通过模型的方式。

3.3 Pytorch: nn

这次我们使用PyTorch中nn这个库来构建网络。用PyTorch autograd来构建计算图和计算gradients，然后PyTorch会帮我们自动计算gradient。

# 这次先导入nn的库
import torch.nn as nn

# 定义输入，中间，输出层的单元数量
N, D_in, H, D_out = 64, 1000, 100, 10   # N表示训练数据的个数， D_in表示输入的特征数 H是中间层，

# 创建训练数据，和上面一样
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)

# 这里我们不定义w了，使用nn建立一个模型进行前向传播的过程计算,这里建模型，就类似于Keras的Sequential了，非常方便
model = torch.nn.Sequential(
    torch.nn.Linear(D_in, H),
    torch.nn.ReLU(),
    torch.nn.Linear(H, D_out)
)

# 这里我们初始化一下子我们的参数(这一步非关键，但是初始化完了之后发现训练的效果好，你可以对比看看，不加这两句的话增大学习率也可以)
torch.nn.init.normal_(model[0].weight)
torch.nn.init.normal_(model[2].weight)

# 开始神经网络的计算
loss_fn = nn.MSELoss(reduction='sum')
learning_rate = 1e-6

for it in range(500):
    # 前向传播，建立模型即可, 也是一句话搞定
    y_pred = model(x)
    
    # 计算损失  这里的损失函数用Pytorch版
    loss = loss_fn(y_pred, y)
    print(it, loss.item())

    # 参数导数归0，然后反向传播，这里会计算所有需要求导参数的梯度保存到一个参数列表中
    model.zero_grad()
    loss.backward()

    # 更新参数, 这个地方注意，使用model之后，反向传播得到的参数会在一个参数列表中model.parameters() 我们需要在这里面求出参数来进行改变
    with torch.no_grad():
        for param in model.parameters():  # param (tensor, grad)的形式
            param -= learning_rate * param.grad

这一个版本中，我们使用了Pytorch里面的nn模型，替换了numpy手写的前向传播部分，然后用换了一下损失函数计算方式，然后借助Pytorch的自动求导机制完成了反向传播部分。我们还有差一个地方，就成了全自动模式，那就是更新参数了。下一步我们把这个也换掉。

3.4 Pytorch:optim

这一次我们不再手动更新模型的weights,而是使用optim这个包来帮助我们更新参数。 optim这个package提供了各种不同的模型优化方法，包括SGD+momentum, RMSProp, Adam等等。

# 定义输入输出层的个数 和上面一样
N, D_in, H, D_out = 64, 1000, 100, 10

# 创造训练集
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)

# 定义模型
model = torch.nn.Sequential(
    torch.nn.Linear(D_in, H),
    torch.nn.ReLU(),
    torch.nn.Linear(H, D_out)
)

# 如果训练效果不好，也可以加上这两句试试，深度学习有点玄学
#torch.nn.init.normal_(model[0].weight)
#torch.nn.init.normal_(model[2].weight)

# 开始神经网络的计算,但是这里我们使用优化器帮我们更新参数
learning_rate = 1e-6
loss_fn = torch.nn.MSELoss(reduction='sum')
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

for it in range(500):
    # 前向传播
    y_pred = model(x)

    # 计算损失
    loss = loss_fn(y_pred, y)
    print(it, loss.item())

    # 梯度清零, 然后反向传播
    optimizer.zero_grad()
    loss.backward()

    # 更新参数，这里只需要一句话
    optimizer.step()

好了，我们基本上大功告成，已经把numpy的两层神经网络的计算换成了Pytorch版本了，换完之后，我们会发现，原来我们需要的复杂运算，在Pytorch里面只需要几句话就搞定了。

简单总结一下上面的替换过程：

首先，我们把把numpy的计算形式换成了tensor的计算形式，形成第一个版本
然后，我们使用Pytorch的自动求导机制loss.backward()替换了反向传播过程，形成了第二个版本
然后，我们使用Pytorch的nn模型，建立model，替换了前向传播，并且调用了Pytorch写好的损失函数替换了计算损失的过程
最后，我们使用optim库里面的优化函数，替换了更新参数的过程

这样，Pytorch的两层神经网络完毕。

但是，仍然有一个问题，就是nn.Sequential就类似于Keras的Sequential，只能类似堆积木般的一层一层往上堆，线性模块。不太擅长搭建复杂的模型，所以Keras那边有一个model系列。而对应Pytorch里面，我们也有对应的解决办法，那就是自定义nn.Modules模型。我们接着往下看。

3.5 Pytorch: 自定义nn Modules

我们可以定义一个模型，这个模型继承自nn.Module类。如果需要定义一个比Sequential模型更加复杂的模型，就需要定义nn.Module模型。

# 我们定义一个两层的神经网络类，这个继承与nn.Module模块
class TwoLayerNet(torch.nn.Module):
    
    # 定义成员层
    def __init__(self, D_in, H, D_out):
        super(TwoLayerNet, self).__init__()
        self.liner1 = torch.nn.Linear(D_in, H)
        self.linear2 = torch.nn.Linear(H, D_out)
    
    # 定义前向传播
    def forward(self, x):
        h_relu = self.linear1(x).clamp(min=0)
        y_pred = self.linear2(h_relu)
        return y_pred

# 这样就定义了一个二层神经网络的类

N, D_in, H, D_out = 64, 1000, 100, 10

x = torch.randn(N, D_in)
y = torch.randn(N, D_out)

# 定义一个模型
model = TwoLayer(D_in, H, D_out)

# 开始计算神经网络
criterion = torch.nn.MSELoss(reduction='sum')
optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)

for it in range(500):
    # 前向传播
    y_pred = model(x)

    # 计算损失
    loss = criterion(y_pred, y)
    print(it, loss)

    # 反向传播, 更新参数
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

看完这个，你会发现，这啥？这不基本上啥也没改吗？无非就是把model的定义写成了一个类的形式，看起来还不如nn.Sequential搭建起来简单，但是，我们发现了吗？这个写法更加灵活了，我们可以在类里面的forward函数中，自定义任何复杂结构的神经网络。而前面的Sequential，灵活性不够，这个就类似于Keras的Sequential和Model这两种方式的定义神经网络的方法。 Pytorch这里也是给出了两种，一般简单的网络，Sequential就可以搞定，但是复杂的，我们还得用下面这个写法，所以习惯了就好。如果对于Keras好奇，我也正在写关于Keras的一个系列，那个读完之后会有一种修仙的快感 😉

好了，我们已经会用Pytorch搭建神经网络了，下面亲手搭一个神经网络，教你的神经网络玩个游戏吧，看看表现咋样？

4. 教你的网络玩FizzBuzz小游戏

FizzBuzz是一个简单的小游戏。游戏规则如下：从1开始往上数数，当遇到3的倍数的时候，说fizz，当遇到5的倍数，说buzz，当遇到15的倍数，就说fizzbuzz，其他情况下则正常数数。

这个就类似于我们酒席上玩的那个数数游戏，只不过是个简化版，你看到规则之后，转念一想，这还不简单，分分钟写个程序，按照这个规则从1-1000遍历，遇到3的倍数，输出fizz，遇到5的倍数，输出buzz，遇到15的倍数，输出fizzbuzz。其他情况正常输出。哈哈哈，你真这么写，我也无语，但那不是你机器玩的，那是你玩的，我们的目的是搭建一个网络，让网络玩这个游戏。看看网络怎么玩？

分下面几个步骤：

1.我们先写一个编码函数，就是传进一个数，如果是3的倍数，返回1，是5的倍数，返回2，是15的倍数，返回3，其他情况返回0，这个好写吧：

def fizz_buzz_endode(i):
    if i % 15 == 0: return 3
    elif i % 5 == 0: return 2
    elif i % 3 == 0: return 1
    else: return 0

2.我们写一个解码函数，就是根据上面的返回数，我们得到fuzz,buzz还是别的

1 2	def fizz_buzz_decode(i, prediction): return [str(i), "fizz", "buzz", "fizzbuzz"][prediction]

3.我们定义模型的输入，由于我们是数数，但是训练模型的时候，我们得把数转换成特征的方式网络才能懂，所以这里采用二进制的编码形式

import numpy as np
import torch

NUM_DIGITS = 10

def binary_encode(i, num_digits):
    return np.array([i >> d & 1 for d in range(num_digits)]

# 准备训练集
trX = torch.Tensor([binary_encode(i, NUM_DIGITS) for i in range(101, 2 ** NUM_DIGITS)])
trY = torch.Tensor([fizz_buzz_encode(i) for i in range(101, 2 ** NUM_DIGITS)])

4.然后用Pytorch定义模型，这实际上是一个4分类的问题，就是输入数字，看看模型输出的是哪一个类别。

NUM_HIDDEN = 100
model = torch.nn.Sequential(
    torch.nn.Linear(NUM_DIGITS, NUM_HIDDEN),
    torch.nn.ReLU(),
    torch.nn.Linear(NUM_HIDDEN, 4)
)

5.模型的训练

为了让我们的模型学会FizzBuzz这个游戏，我们需要定义一个损失函数，和一个优化算法。

这个优化算法会不断优化（降低）损失函数，使得模型的在该任务上取得尽可能低的损失值。
损失值低往往表示我们的模型表现好，损失值高表示我们的模型表现差。
由于FizzBuzz游戏本质上是一个分类问题，我们选用Cross Entropyy Loss函数。
优化函数我们选用Stochastic Gradient Descent。

loss_fn = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr = 0.05)
BATCH_SIZE = 128

for epoch in range(10000):
    for start in range(0, len(trX), BATCH_SIZE):
        end = start + BATCH_SIZE
        batchX = trX[start:end]
        batchY = trY[start:end]

        y_pred = model(batchX)
        loss = loss_fn(y_pred, batchY)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    loss = loss_fn(model(trX),trY).item()
    print(epoch, loss)

6.最后用我们训练好的模型尝试在1-100上玩FIZZBUZZ游戏

testX = torch.Tensor([binary_encode(i, NUM_DIGITS) for i in range(1, 101)])
with torch.no_grad():
    testY = model(testX)
predictions = zip(range(1, 101), list(testY.max(1)[1].data.tolist()))

print([fizz_buzz_decode(i, x) for (i, x) in predictions])

我们可以看一下网络玩的结果：

我们对比一下真实情况，看看网络错了多少：

1 2	print(np.sum(testY.max(1)[1].numpy() == np.array([fizz_buzz_encode(i) for i in range(1,101)]))) testY.max(1)[1].numpy() == np.array([fizz_buzz_encode(i) for i in range(1,101)])

我们可以发现，100个数，模型错了7个，对了93个数，还算可以吧，毕竟只是单层的网络，你可以换成多层或者调调参数试试会不会好一些。（我加了一层60个单元的隐藏，然后特征长度改成了15，这样稍微简单一改，模型就到了100%的效果，并且只需要1000次迭代），你也可以试试其他的，既然有这么好的机会，好好利用，改改参数学习率啥的，换换优化方法啥的都可以