机器学习：基于PyTorch搭建神经网络

1，PyTorch安装

1.1，不需切换版本

前往PyTorch官网，找到对应自己显卡版本的PyTorch安装命令。

PyTorch只对CUDA版本有要求，对于cudnn没有要求，甚至不需要安装。查看方式如下：

1.2，切换CUDA版本

前往NVIDA官网（CUDA Toolkit Archive | NVIDIA Developer）下载指定版本。

安装路径自定义，其他的默认，最后还需要在系统变量中添加如下内容：

验证方式：

2，PyTorch基础知识

2.1，构造Tensor

Tensor是PyTorch中用来存储多维矩阵数据的数据结构，和NumPy中的naddary比较类似，但Tensor能够使用GPU来加速运算。

在PyTorch中构造Tensor方式有很多：

#生成随机Tensor
import torch
x = torch.Tensor(2, 3)
print(x)
================================================
tensor([[-7.5173e-01,  9.3731e-38, -1.5563e-04],
        [ 9.3731e-38, -4.4988e-05,  9.3731e-38]])

#利用list构造Tensor
import torch
x = torch.Tensor([1,2,3])
print(x)
y = torch.Tensor([[1,2,3],[6,5,4]])
print(y)
===================================
tensor([1., 2., 3.])
tensor([[1., 2., 3.],
        [6., 5., 4.]])

import torch
#随机元素值0~1之间矩阵
x= torch.rand(3,3)
print(x)
#元素全部为0的矩阵
x= torch.zeros(3,3)
print(x)
#元素全部为1的矩阵
x= torch.ones(3,3)
print(x)
==================================
tensor([[0.3766, 0.8037, 0.7080],
        [0.9064, 0.4387, 0.0712],
        [0.0787, 0.1682, 0.7385]])
tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])
tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]])

获取一个Tensor的大小：

x = torch.ones(3, 3)
print(x.size())
====================
torch.Size([3, 3])

2.2，Tensor操作

在PyTorch中我们可以方便地进行一些数学运算和矩阵操作，比如矩阵可以直接乘以一个数字，再加上另外一个矩阵：

x=torch.ones(2,3)
y=torch.ones(2,3)*2
print(x+y)
print(torch.add(x,y))
print(x.add_(y))
print(x*y)

PS：add_()会原地修改Tensor x的值。在PyTorch中，任何原地修改Tensor内容的操作都会在方法名后加一个下划线作为后缀，例如：x.copy_(y)、x.t_()，这些都会改变x的值。

Tensor也支持NumPy中各种切片操作，比如操作矩阵的某一列：

x = torch.ones(3, 3)
x[:, 1] = x[:, 1] + 2
print(x)
====================
tensor([[3., 3., 3.],
        [1., 1., 1.],
        [1., 1., 1.]])

另外，可以使用torch.view()来改变矩阵的形状（同NumPy中的reshape）：

x = torch.ones(3, 3)
x=x.view(1,9)
print(x)
==============================================
tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1.]])

2.3，Tensor和NumPy array间的转化

Torch的Tensor和NumPy的array可以非常方便地进行相互转化。但是需要注意的是，它们会共享内存的地址，所以修改其中一个会导致另外一个也发生改变。

import torch
x = torch.ones(2, 3)
print(x)
y = x.numpy()
print(y)
x.add_(2)
print(y)
z = torch.from_numpy(y)
print(z)
========================
tensor([[1., 1., 1.],
        [1., 1., 1.]])
[[1. 1. 1.]
 [1. 1. 1.]]
[[3. 3. 3.]
 [3. 3. 3.]]
tensor([[3., 3., 3.],
        [3., 3., 3.]])

2.4，Autograd：自动梯度

在任何深度学习框架中，都需要一个计算误差的梯度并进行反向传播的机制，这对于构建神经网络模型至关重要。在PyTorch中，这个机制是由Autograd包实现的，其中提供了对Tensor上的所有操作进行自动求导操作。

Variale类是Autograd包中最核心的一个类，它包装了一个Tensor，并且支持几乎所有定义在Tensor上的操作。我们可以通过.data属性访问原始的Tensor。

import torch
from torch.autograd import Variable
x = Variable(torch.ones(2, 2) * 2, requires_grad=True)
print(x)
print(x.data)
=====================================================
tensor([[2., 2.],
        [2., 2.]], requires_grad=True)
tensor([[2., 2.],
        [2., 2.]])

我们传入了一个Tensor，并设置requires_grad参数为True。只有一个Variable的requires_grad为True，我们才能求出关于它的梯度。

x = Variable(torch.ones(2, 2) * 2, requires_grad=True)
y = 2 * (x * x) + 5 * x
print(y)
=============================
tensor([[18., 18.],
        [18., 18.]], grad_fn=<AddBackward0>)

 可以看作一个关于的函数，它关于  的梯度  的表达式我们可以通过计算得到：。现在中的每一个元素值都是 ，将其带入  得到值 。

import torch
from torch.autograd import Variable
x = Variable(torch.ones(2, 2) * 2, requires_grad=True)
y = 2 * (x * x) + 5 * x
y=y.sum()
y.backward()
print(x.grad)
=====================
tensor([[13., 13.],
        [13., 13.]])

在PyTorch中，当我们计算完成之后，可以通过调用.backward()方法来自动计算梯度。现在我们需要计算的是y关于x的梯度，所以我们调用y.backward()。而计算得到的梯度会存储到Variable x的.grad属性中。

3，PyTorch中搭建神经网络

3.1，定义神经网络

在PyTorch中，神经网络的构件主要使用torch.nn包。我们定义的神经网络需要继承内置的nn.Module类，nn.Module类给我们提供了很多定义好的功能，一般情况下我们只需要定义自己的网络模型结构及前向方法。

import torch
import torch.nn.functional as F
import torch.nn as nn


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()  # 定义一个神经网络
        self.conv1 = nn.Conv2d(3, 6, 5)  # 两个卷积层，三个全连接层
        self.conv2 = nn.Conv2d(6, 16, 5)  # 输入3个通道，输出6个通道，卷积核5*5
        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 输入84维，输出10维
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    # 在init中我们值定义了搭建网络的层，但没有真正定义网络的结构
    # 真正的输入输出关系是在forward()方法中定义的，控制数据在网络中的流动方式
    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), 2)  # 激活函数ReLU，先经过一个卷积层，然后一个全连接层
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

PS：torch.nn中要求输入的数据是一个mini-batch，因为我们的图像数据（CIFAR-10）本身是3维的，所以forward()的输入x是4维的，在经过两个卷积层之后还是4维的Tensor，所以在输入后面的全连接层之前我们先使用.view()方法将其转化为2维的Tensor。

这样就定义好了我们自己的神经网络，接下来我们可以创建这个神经网络的实例，并打印出来。

if __name__ == '__main__':
    net = Net()
    print(net)  #神经网络结果
============================
Net(
  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)

神经网络模型中可以训练的参数由net.parameters()返回，在我们刚才定义的网络中，共有10个参数，分别对应于5个层的weight参数和bias参数（权重和偏执）。比如前面两个分别是第1个卷积层conv1的weight参数和bias参数，我们可以通过打印出来的参数的size确定这一点。

params = list(net.parameters())
print(len(params))
print(params[0].size())
print(params[1].size())
===============================
10
torch.Size([6, 3, 5, 5])
torch.Size([6])

我们也可以直接通过层和参数的名字访问具体的参数，比如net.conv1.weight是第一个卷积层conv1的weight参数。另外，我们可以看到，这些模型参数的requires_grad是默认的True，这意味着后面可以计算关于这些参数的梯度并用梯度来更新这些参数。

当然，如果我们想要固定网络中的某些层的参数不更新，那么可以设置这部分网络对应的参数的requires_grad为False，这样在方向求梯度过程中就不会计算这些参数对应的梯度了。

print(net.conv1.weight.size())
print(net.conv1.bias.size())
print(net.conv1.weight.requires_grad)
=====================================
torch.Size([6, 3, 5, 5])
torch.Size([6])
True

定义好了神经网络，让我们来看一下如何调用这个神经网络获取输出。前面提到的，我们这边需要的输入数据是4维的。同时，在PyTorch里神经网络的输入样本作为示例。有了输入数据之后，可以直接将其传入神经网络得到输出，实际上调用我们定义的net.forward()方法。可以看到，神经网络的输出也是一个Variable，共有10维，和我们预期的一致。

input = Variable(torch.rand(1,3,32,32))
output = net(input)
print(output)
================================================================================
tensor([[ 0.1417,  0.0634, -0.0652, -0.0445,  0.0899,  0.0334,  0.0029, -0.0582,
          0.0845,  0.1239]], grad_fn=<AddmmBackward>)

3.2，训练神经网络

要训练神经网络，我们首先需要定义一个损失函数，我们训练的目的就是通过调整神经网络模型的参数来最小化这个损失函数。1个损失函数输入神经网络的预测输出和样本真实标签，然后返回1个值评测输出距离真实标签的远近程度。在torch.nn包中，有很多定义好的损失函数，比如nn.MSELoss、nn.L1Loss、nn.CrossEntropyLoss等。因为我们是在训练1个多分类模型，所以使用交叉熵损失函数nn.CrossEntropyLoss。

criterion = nn.CrossEntropyLoss()

假设刚才随机生成的按个输入样本input为例，假设它对应的真实标签是4，而我们刚才已经得到了它通过神经网络之后的输出output，那么我们就可以直接把它们输入刚才选择的损失函数计算得到loss。需要注意，损失函数的输入outpur和label都要求是Variable，输出loss也是一个Variable。

if __name__ == '__main__':
    net = Net()
    criterion = nn.CrossEntropyLoss()
    input = Variable(torch.rand(1, 3, 32, 32))
    output = net(input)
    print(output)
    label = Variable(torch.LongTensor([4]))
    print(label)
    loss = criterion(output,label)
    print(loss)
================================================================================
tensor([[ 0.1201,  0.0682,  0.0639,  0.0945, -0.0587,  0.0728,  0.0730,  0.1388,
         -0.0845,  0.1373]], grad_fn=<AddmmBackward>)
tensor([4])
tensor(2.4264, grad_fn=<NllLossBackward>)

在定义玩损失函数之后，我们还需要最小化这个损失函数是准备采用的优化方法。这时候我们需要用到torch.optim包，里面已经实现了各种常用的优化方法，比如SGD、Nesterov-SGD、Adam、RMSProp等，一般我们从中选择就可以了。我们选择带动量的随机梯度下降法，并将需要训练的模型参数作为第一个参数传入，同时设定学习速率参数lr=0.001，动量参数momentun=0.9。

import torch.optim as optim
optimizer = optim.SGD(net.parameters(),lr=0.001,momentum=0.9)

定义好损失函数和优化方法，我们就可以训练更新神经网络的参数了。在更新之前，我们先挑一个参数看一下：

print(net.conv1.bias)
==============================
Parameter containing:
tensor([ 0.0416, -0.0456, -0.0261,  0.0349, -0.0015, -0.0484],
       requires_grad=True)

参数训练更新主要包含两步，首先我们调用loss.backward()自动计算loss关于所有可训练参数的梯度，然后执行optimizer.step()，根据上一步计算得到的梯度更新参数。需要注意，在调用backward()计算梯度之前，我们一般需要先调用optimizer.zero_grad()将所有参数的梯度置为0，因为backward()计算得到的梯度是积累到原有的梯度之上的。

if __name__ == '__main__':
    net = Net()
    print(net.conv1.bias)
    criterion = nn.CrossEntropyLoss()  # 损失函数
    input = Variable(torch.rand(1, 3, 32, 32))
    output = net(input)
    print(output)
    label = Variable(torch.LongTensor([4]))
    loss = criterion(output, label)
    print(loss)
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
    optimizer.zero_grad()
    loss.backward() #计算梯度
    optimizer.step()
    print(net.conv1.bias)
===========================================
Parameter containing:
tensor([ 0.0580,  0.0789,  0.0258, -0.0612, -0.0216,  0.0890],
       requires_grad=True)
tensor([[-0.0903, -0.0205,  0.0408, -0.0373,  0.0255,  0.0164,  0.1519,  0.1117,
         -0.1146, -0.0415]], grad_fn=<AddmmBackward>)
tensor(2.2844, grad_fn=<NllLossBackward>)
Parameter containing:
tensor([ 0.0580,  0.0789,  0.0258, -0.0613, -0.0216,  0.0891],
       requires_grad=True)

由于样本集就一个样本，并且没有迭代循环，故该变量极小。

3.3，在CIFAR-10数据集上进行训练和测试

首先我们需要获取CIFAR-10数据集，并对数据进行必要的预处理。有一个torchvision包已经为我们收好了各种常用的图像数据集，比如：Imagenet、CIFAR-10、MNIST等，并提供了非常方便的加载和预处理的功能。

import torch.utils.data
import torchvision
import torchvision.transforms as transforms
transform = transforms.Compose(
    [transforms.ToTensor(),transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))]
)
transform = transforms.Compose(
    [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
)
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,shuffle=True, num_workers=0)  # windows 下线程参数设为 0 安全
testset = torchvision.datasets.CIFAR10(root='./data', train=False,download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,shuffle=False, num_workers=0)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

我们来看几张 CIFAR10 的图片样例， 分别是 frog、cat、deer、frog， 32 X 32 的像素，看起来是有些模糊。

import matplotlib.pyplot as plt
import numpy as np
# functions to show an image
def imshow(img):
    img = img / 2 + 0.5  # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()
# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()
# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

数据准备好之后，我们就可以开始真正的训练了。我们会多次遍历训练数据集，每次取出一个mini-batch（设置为4）的数据，根据mini-batch的数据执行更新神经网络。

构建神经网络：

import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

定义损失函数及优化器：

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

训练模型：

• 先通过 optimizer.zero_grad() 把梯度清理干净，防止受之前遗留梯度的影响。
• outputs = net(inputs), 把图片数据送到网络里面，得到预测结果。
• loss = criterion(outputs, labels), 计算当前 batch 的损失值。
• loss.backward()，执行链式求导，计算梯度。
• optimizer.step()，通过4中计算出来的梯度，更新每个可训练权重。

net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

for epoch in range(5):

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        inputs, labels = Variable(inputs), Variable(labels)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 6000 == 5999:
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 6000))
            running_loss = 0.0

print('Finished Training')

可以看到，随着训练过程的推进，损失函数在慢慢变小，说明神经网络的输出在慢慢接近真实标签。

模型验证：我们在测试集上看一下模型预测的准确率，在预测时，我们将模型输出的10个值中最大的那个对应的类别作为模型的预测类别，

# 测试模型
correct = 0
total = 0
for data in testloader:
    images, labels = data
    outputs = net(Variable(images))
    # 返回可能性最大的索引 -> 输出标签
    _, predicted = torch.max(outputs, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))
==============================================
Accuracy of the network on the 10000 test images: 62 %

考虑到一共有10个类别，如果预测一个类别，准确期望在0.1，我们结果为62%，说明经过训练的网络确实学到了一些东西。下面计算我们的神经网络在每个类别上的分类准确率：

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
for data in testloader:
    images, labels = data
    outputs = net(Variable(images))
    _, predicted = torch.max(outputs.data, 1)
    c = (predicted == labels).squeeze()
    for i in range(4):  # mini-batch's size = 4
        label = labels[i]
        class_correct[label] += c[i]
        class_total[label] += 1

for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]
    ))
=========================================
Accuracy of plane : 69 %
Accuracy of   car : 66 %
Accuracy of  bird : 58 %
Accuracy of   cat : 35 %
Accuracy of  deer : 54 %
Accuracy of   dog : 56 %
Accuracy of  frog : 70 %
Accuracy of horse : 73 %
Accuracy of  ship : 71 %
Accuracy of truck : 67 %

3.4，模型的保存和加载

神经网络的训练往往是比较耗时的，特别是在模型比较复杂、数据量比较大的时候，所以我们经常会希望将训练好的模型保存到文件供以后使用。这时我们可以调用网络的state_dict()方法，该方法会以字典的形式返回模型的所有参数。字典的key是模型参数的名字，字典的value是存储对应参数具体数值的Tensor。

print(net.state_dict().keys())
print(net.state_dict()['conv1.bias'])
============================================================================
odict_keys(['conv1.weight', 'conv1.bias', 'conv2.weight', 'conv2.bias', 'fc1.weight', 'fc1.bias', 'fc2.weight', 'fc2.bias', 'fc3.weight', 'fc3.bias'])
tensor([ 0.0970, -0.3732, -0.6456, -0.3526,  0.4653, -0.4466])

接下来我们可以进一步使用torch.save()将state_dict()返回的模型参数保存到文件之后需要使用的时候，可以先用torch.load()从文件中读取模型参数，再用load_state_dict()方法将参数加载到神经网络模型中。

torch.save(net.state_dict(), './data/' + 'model.pt')
net.load_state_dict(torch.load('./data/' + 'model.pt'))

3.5，代码

import torch.utils.data
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.autograd import Variable
import torch.optim as optim

transform = transforms.Compose(
    [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
)
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=0)  # windows 下线程参数设为 0 安全
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=0)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()  # 定义一个神经网络
        self.conv1 = nn.Conv2d(3, 6, 5)  # 两个卷积层，三个全连接层
        self.conv2 = nn.Conv2d(6, 16, 5)  # 输入3个通道，输出6个通道，卷积核5*5
        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 输入84维，输出10维
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    # 在init中我们值定义了搭建网络的层，但没有真正定义网络的结构
    # 真正的输入输出关系是在forward()方法中定义的，控制数据在网络中的流动方式
    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), 2)  # 激活函数ReLU，先经过一个卷积层，然后一个全连接层
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
# 训练模型
# for epoch in range(5):
#
#     running_loss = 0.0
#     for i, data in enumerate(trainloader, 0):
#         inputs, labels = data
#         inputs, labels = Variable(inputs), Variable(labels)
#         optimizer.zero_grad()
#         outputs = net(inputs)
#         loss = criterion(outputs, labels)
#         loss.backward()
#         optimizer.step()
#         running_loss += loss.item()
#         if i % 6000 == 5999:
#             print('[%d, %5d] loss: %.3f' %
#                   (epoch + 1, i + 1, running_loss / 6000))
#             running_loss = 0.0

print('Finished Training')
# 保存训练好的模型
#torch.save(net.state_dict(), './data/' + 'model.pt')
net.load_state_dict(torch.load('./data/' + 'model.pt'))
print(net.state_dict().keys())
print(net.state_dict()['conv1.bias'])

# 测试模型
# correct = 0
# total = 0
# for data in testloader:
#     images, labels = data
#     outputs = net(Variable(images))
#     # 返回可能性最大的索引 -> 输出标签
#     _, predicted = torch.max(outputs, 1)
#     total += labels.size(0)
#     correct += (predicted == labels).sum()
#
# print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))
# class_correct = list(0. for i in range(10))
# class_total = list(0. for i in range(10))
# for data in testloader:
#     images, labels = data
#     outputs = net(Variable(images))
#     _, predicted = torch.max(outputs.data, 1)
#     c = (predicted == labels).squeeze()
#     for i in range(4):  # mini-batch's size = 4
#         label = labels[i]
#         class_correct[label] += c[i]
#         class_total[label] += 1
#
# for i in range(10):
#     print('Accuracy of %5s : %2d %%' % (
#         classes[i], 100 * class_correct[i] / class_total[i]
#     ))