PyTorch教程

莫烦PyTorch教程笔记整理

一、PyTorch神经网络基础

1.Torch和Numpy

Torch中的tensor与Numpy中的数组非常类似，二者的基本操作类似，可以相互转换：
将Numpy数组转换为Torch的tensortorch.from_numpy(numpy_array)
将Torch的tensor转换为Numpy数组在torch_tensor.numpy()

代码示例

import torch
import numpy as np

np_data = np.arange(6).reshape((2, 3))  # Numpy数组
torch_data = torch.from_numpy(np_data)  # 将Numpy数组转换为Torch的tensor
tensor2array = torch_data.numpy()   # 将Torch的tensor转换为Numpy数组

Torch中的数学运算也与Numpy类似。

# abs 绝对值计算
data = [-1, -2, 1, 2]
tensor = torch.FloatTensor(data)  # 转换成32位浮点 tensor
print(np.abs(data))          # [1 2 1 2]
print(torch.abs(tensor)      # [1 2 1 2]

# sin   三角函数 sin
print(np.sin(data))       # [-0.84147098 -0.90929743  0.84147098  0.90929743]
print(torch.sin(tensor))  # [-0.8415 -0.9093  0.8415  0.9093]

# mean  均值
print(np.mean(data))          # 0.0
print(torch.mean(tensor))     # 0.0

注意：Torch中的矩阵点乘（.dot()）与Numpy中不同。
在Torch中想要实现矩阵点乘，可以利用torch.mm(tensor1,tensor2)，其功能与np.matmul(arr1,arr2)相同；
Numpy中计算矩阵点乘，还可用arr1.dot(arr2)实现，而Torch中tensor1.dot(tensor2)会将两个tensor展成一维然后对应位相乘再相加，只返回一个值。

# matrix multiplication 矩阵点乘
data = [[1,2], [3,4]]
tensor = torch.FloatTensor(data)  # 转换成32位浮点 tensor
# correct method
print(
    '\nnumpy: ', np.matmul(data, data),     # [[7, 10], [15, 22]]
    '\ntorch: ', torch.mm(tensor, tensor)   # [[7, 10], [15, 22]]
)

# !!!!  下面是错误的方法 !!!!
data = np.array(data)
print(
    '\nnumpy: ', data.dot(data),        # [[7, 10], [15, 22]] 在numpy 中可行
    '\ntorch: ', tensor.dot(tensor)     # torch 会转换成 [1,2,3,4].dot(1,2,3,4) = 30.0
)

2.变量

在 Torch 中的 Variable 就是一个存放会变化的值（tensor）的地理位置.

定义变量

import torch
from torch.autograd import Variable # torch 中 Variable 模块

# 先生鸡蛋
tensor = torch.FloatTensor([[1,2],[3,4]])
# 把鸡蛋放到篮子里, requires_grad是参不参与误差反向传播, 要不要计算梯度
variable = Variable(tensor, requires_grad=True)

变量的计算与梯度
如果用一个 Variable 进行计算, 那返回的也是一个同类型的 Variable.
Variable在计算时，会逐步搭建计算图，用于反向传播

v_out = torch.mean(variable*variable)
v_out.backward()    # 模拟 v_out 的误差反向传递
print(variable.grad)    # 初始 Variable 的梯度
'''
 0.5000  1.0000
 1.5000  2.0000
'''

获取 Variable 里面的数据
直接访问Variable，获取的是Variable形式的数据，在很多情况下用不了，需要利用variable.data将它转换为tensor

2.激励函数

PyTorch中的激励函数都在 torch.nn.functional 模块中，常用的有relu, sigmoid, tanh, softplus等。

import torch
import torch.nn.functional as F     # 激励函数都在这
from torch.autograd import Variable

x = torch.linspace(-5, 5, 200)  # x data (tensor), shape=(100, 1)
x = Variable(x)

# 几种常用的激励函数
y_relu = F.relu(x)
y_sigmoid = F.sigmoid(x)
y_tanh = F.tanh(x)
y_softplus = F.softplus(x)
# y_softmax = F.softmax(x)  softmax比较特殊, 不能直接显示, 不过他是关于概率的, 用于分类

二、搭建简单的神经网络

1.回归

import torch
import torch.nn.functional as F     # 激励函数都在这

# 假数据
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)  # x data (tensor), shape=(100, 1)
y = x.pow(2) + 0.2*torch.rand(x.size())                 # noisy y data (tensor), shape=(100, 1)

# 搭建网络
class Net(torch.nn.Module):  # 继承 torch 的 Module
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()     # 继承 __init__ 功能
        # 定义每层用什么样的形式
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隐藏层线性输出
        self.predict = torch.nn.Linear(n_hidden, n_output)   # 输出层线性输出

    def forward(self, x):   # 这同时也是 Module 中的 forward 功能
        # 正向传播输入值, 神经网络分析出输出值
        x = F.relu(self.hidden(x))      # 激励函数(隐藏层的线性值)
        x = self.predict(x)             # 输出值
        return x

net = Net(n_feature=1, n_hidden=10, n_output=1)

print(net)  # net 的结构
"""
Net (
  (hidden): Linear (1 -> 10)
  (predict): Linear (10 -> 1)
)
"""

# 训练
# optimizer 是训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)  # 传入 net 的所有参数, 学习率
loss_func = torch.nn.MSELoss()      # 预测值和真实值的误差计算公式 (均方差)

for t in range(100):
    prediction = net(x)     # 喂给 net 训练数据 x, 输出预测值

    loss = loss_func(prediction, y)     # 计算两者的误差

    optimizer.zero_grad()   # 清空上一步的残余更新参数值
    loss.backward()         # 误差反向传播, 计算参数更新值
    optimizer.step()        # 将参数更新值施加到 net 的 parameters 上

2.分类

import torch
import torch.nn.functional as F     # 激励函数都在这

# 假数据
n_data = torch.ones(100, 2)         # 数据的基本形态
x0 = torch.normal(2*n_data, 1)      # 类型0 x data (tensor), shape=(100, 2)
y0 = torch.zeros(100)               # 类型0 y data (tensor), shape=(100, )
x1 = torch.normal(-2*n_data, 1)     # 类型1 x data (tensor), shape=(100, 1)
y1 = torch.ones(100)                # 类型1 y data (tensor), shape=(100, )

# 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
x = torch.cat((x0, x1), 0).type(torch.FloatTensor)  # FloatTensor = 32-bit floating
y = torch.cat((y0, y1), ).type(torch.LongTensor)    # LongTensor = 64-bit integer

# 搭建网络
class Net(torch.nn.Module):     # 继承 torch 的 Module
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()     # 继承 __init__ 功能
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隐藏层线性输出
        self.out = torch.nn.Linear(n_hidden, n_output)       # 输出层线性输出

    def forward(self, x):
        # 正向传播输入值, 神经网络分析出输出值
        x = F.relu(self.hidden(x))      # 激励函数(隐藏层的线性值)
        x = self.out(x)                 # 输出值, 但是这个不是预测值, 预测值还需要再另外计算
        return x

net = Net(n_feature=2, n_hidden=10, n_output=2) # 几个类别就几个 output

print(net)  # net 的结构
"""
Net (
  (hidden): Linear (2 -> 10)
  (out): Linear (10 -> 2)
)
"""

# 训练
# optimizer 是训练的工具
optimizer = torch.optim.SGD(net.parameters(), lr=0.02)  # 传入 net 的所有参数, 学习率
# 算误差的时候, 注意真实值!不是! one-hot 形式的, 而是1D Tensor, (batch,)
# 但是预测值是2D tensor (batch, n_classes)
loss_func = torch.nn.CrossEntropyLoss()

for t in range(100):
    out = net(x)     # 喂给 net 训练数据 x, 输出分析值

    loss = loss_func(out, y)     # 计算两者的误差

    optimizer.zero_grad()   # 清空上一步的残余更新参数值
    loss.backward()         # 误差反向传播, 计算参数更新值
    optimizer.step()        # 将参数更新值施加到 net 的 parameters 上

3.搭建网络的两种方法

建立一个Class来搭建网络

class Net(torch.nn.Module):
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隐藏层
        self.predict = torch.nn.Linear(n_hidden, n_output)   # 输出层

    def forward(self, x):    # 前向传播过程
        x = F.relu(self.hidden(x))
        x = self.predict(x)
        return x

net1 = Net(1, 10, 1)   # 这是我们用这种方式搭建的 net1

利用torch.nn模块快速搭建网络

net2 = torch.nn.Sequential(
    torch.nn.Linear(1, 10),
    torch.nn.ReLU(),
    torch.nn.Linear(10, 1)
)

比较两种方法

print(net1)
"""
Net (
  (hidden): Linear (1 -> 10)
  (predict): Linear (10 -> 1)
)
"""
print(net2)
"""
Sequential (
  (0): Linear (1 -> 10)
  (1): ReLU ()
  (2): Linear (10 -> 1)
)
"""

net2 多显示了一些内容, 它把激励函数也一同纳入进去了, 但是 net1 中, 激励函数实际上是在 forward() 功能中才被调用的。这也就说明了, 相比 net2, net1 的好处就是, 可以根据个人需要更加个性化前向传播过程。

4.模型的保存和提取

模型的保存有两种方式：
（1）保存整个网络及参数 torch.save(net1, 'net.pkl') ；
（2）只保存网络的参数，而不保存网络结构，速度快, 占内存少 torch.save(net1.state_dict(), 'net_params.pkl') 。
相应的，模型的提取同样有两种方式：
（1）提取整个网络及参数 net2 = torch.load('net.pkl') net.pkl中保存的也必须是整个网络；
（2）只提取网络的参数：需要先建立网络，然后提取参数

def restore_params():
    # 新建 net3，应与提取的网络的结构相同
    net3 = torch.nn.Sequential(
        torch.nn.Linear(1, 10),
        torch.nn.ReLU(),
        torch.nn.Linear(10, 1)
    )

    # 将保存的参数复制到 net3
    net3.load_state_dict(torch.load('net_params.pkl'))

5.批训练

Torch 中提供了的 DataLoader 能来包装自己的数据, 进行批训练。
将自己的 (numpy array 或其他) 数据形式装换成 Tensor, 然后再放进这个包装器中。
DataLoader 它能帮你有效地迭代数据。

import torch
import torch.utils.data as Data

BATCH_SIZE = 5      # 批训练的数据个数

x = torch.linspace(1, 10, 10)       # x data (torch tensor)
y = torch.linspace(10, 1, 10)       # y data (torch tensor)

# 先转换成 torch 能识别的 Dataset
torch_dataset = Data.TensorDataset(data_tensor=x, target_tensor=y)

# 把 dataset 放入 DataLoader
loader = Data.DataLoader(
    dataset=torch_dataset,      # torch TensorDataset format
    batch_size=BATCH_SIZE,      # mini batch size
    shuffle=True,               # 要不要打乱数据 (打乱比较好)
    num_workers=2,              # 多线程来读数据
)

for epoch in range(3):   # 训练所有!整套!数据 3 次
    for step, (batch_x, batch_y) in enumerate(loader):  # 每一步 loader 释放一小批数据用来学习
        # 假设这里就是你训练的地方...

        # 打出来一些数据
        print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
              batch_x.numpy(), '| batch y: ', batch_y.numpy())

"""
Epoch:  0 | Step:  0 | batch x:  [ 6.  7.  2.  3.  1.] | batch y:  [  5.   4.   9.   8.  10.]
Epoch:  0 | Step:  1 | batch x:  [  9.  10.   4.   8.   5.] | batch y:  [ 2.  1.  7.  3.  6.]
Epoch:  1 | Step:  0 | batch x:  [  3.   4.   2.   9.  10.] | batch y:  [ 8.  7.  9.  2.  1.]
Epoch:  1 | Step:  1 | batch x:  [ 1.  7.  8.  5.  6.] | batch y:  [ 10.   4.   3.   6.   5.]
Epoch:  2 | Step:  0 | batch x:  [ 3.  9.  2.  6.  7.] | batch y:  [ 8.  2.  9.  5.  4.]
Epoch:  2 | Step:  1 | batch x:  [ 10.   4.   8.   1.   5.] | batch y:  [  1.   7.   3.  10.   6.]
"""

如果在批训练时，最后一个批次中剩下的数据数量不足batch_size，DataLoader 会返回剩下的所有数据。