神经网络来袭!划重点:60分钟入门,这是最深入浅出的一次

  1. 云栖社区>
  2. 博客>
  3. 正文

神经网络来袭!划重点:60分钟入门,这是最深入浅出的一次

初商 2019-08-04 23:35:00 浏览281

神经网络


神经网络可以使用torch.nn包构建。

现在对PyTorch的自动求导机制(autograd)有所了解,nn 依赖autograd来定义模型和区分它们。一个nn.Module包括layers和返回输出值的forword(input)方法。

例如:下面的这个图片分类的神经网络。

image.png

这是一个简单的前馈神经网络。

它接收输入,一个接一个地通过几个层馈送,然后最后给出输出。

一个神经网络的典型训练程序如下:

定义具有可学习参数(或权重)的神经网络

迭代输入数据集

通过网络进行过程输入

计算损失(输出的正确程度有多远)

向神经网络参数回传梯度

更新网络中的参数权重,通常使用简单的更新规则:weight = weight - learning_rate* gradient

1.定义网络

我们开始定义网络:

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


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        #卷积层, '1'表示输入图片的为单通道,'6'表示输出通道数,'5'表示卷积核 5*5
        #核心
        self.conv1 = nn.Conv2d(1, 6, 5)
        # '6'表示输入数据通道,16个输出,'5'表示卷积核 5*5 
        self.conv2 = nn.Conv2d(6, 16, 5)
    
        #映射层/全连接层:y = Wx+b
        # 为什么是16*5*5呢? 这是全连接层的第一个函数。
        # 经过卷积、池化后最后输出的结果是16个大小为5*5的图像.
        #第一次卷积:图片大小 = (32-5+1)/1 = 28
        #第一次池化:图片大小 = 28/2 = 14
        #第二次卷积:图片大小 = (14-5+1)/1 =10
        #第二次池化:图片大小 = 10/2 = 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):
        #在由多个输入平面组成哦输入信号上应用2D最大池化。
        #(2,2)表示的是池化操作的步幅
        x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))
        #如果大小是正方形,则只能指定一个数字
        x = F.max_pool2d(F.relu(self.conv2(x)),2)
        #将一个多维数据转成N行一列的数据。
        x = x.view(-1,self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x =self.fc3(x)
        return x
            
        
    def num_flat_features(self,x):
        size = x.size()[1:]
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

net = Net()
print(net)

image.png

只定义了forward函数,backward函数(计算梯度的位置)通过使用autograd被自动定义了。你可以在forward函数中使用任何Tensor的运算操作。

模型中可学习的变量通过net.parameters()返回。

params = list(net.parameters())
print(len(params))
print(params[0].size())   # conv1's.weight

image.png

随机生成一个32 32的输入。注意: 这个网络(LeNet)的预期输入大小是 32 32。为了在个网络使用MNIST数据,请将数据集中的图像调整到32 * 32。

input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)

先将参数(parameters)的梯度缓存设置0,再随机生成一个梯度。

net.zero_grad()
out.backward(torch.randn(1,10))

注意:

torch.nn 只支持小批量数据。所有的torch.nn包都只支持输入样本为总样本的一小批,不支持单个样本。

例如:nn.Conv2d的输入必须是4维的张量,形如:nSamples x nChannels x Height x Width。

如果只有一个样本,必须使用input.unsqueeze(0)将batchsize设置为1

在继续之前,让我们来回顾一下之前见过的类

回顾:

torch.Tensor 多维数组支持自动求导操作与backward()类似。

nn.Module 神经网络模块。方便的方式封装参数, 帮助将其移动到GPU, 导出, 加载等.

nn.Parameter Tensor的一种,在被指定为 Module 的属性时,会自动被注册为一个参数。

autograd.Function 实现 autograd 操作的向前和向后定义..每个 Tensor 操作, 至少创建一个 Function 节点, 连接到创建 Tensor的函数, 并编码它的历史

到这里, 我们已完成:

定义一个神经网络

处理输入并反向传播

还剩下:

计算损失函数

更新网络的权重

2.损失函数

损失函数采用 (output,target) 输入对, 并计算预测输出结果与实际目标的距离。

在 nn 包下有几种不同的损失函数. 一个简单的损失函数是: nn.MSELoss 计算输出和目标之间的均方误差。

如下例:

output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

image.png

现在, 如果你沿着 loss 反向传播的方向使用 .grad_fn 属性, 你将会看到一个如下所示的计算图:

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d -> view -> linear -> relu -> linear -> relu -> linear -> MSELoss -> loss

所以, 当我们调用 loss.backward(), 整个图与损失是有区别的, 图中的所有变量都将用 .grad 梯度累加它们的变量.

为了说明, 让我们向后走几步:

print(loss.grad_fn)  # MSELoss
print(loss.grad_fn.next_functions[0][0])  # Linear
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

image.png

3.反向传播

为了反向传播误差, 我们所要做的就是 loss.backward(). 你需要清除现有的梯度, 否则梯度会累加之前的梯度。

现在我们使用 loss.backward(), 看看反向传播之前和之后 conv1 的梯度。

net.zero_grad()     # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

image.png

现在,我们已经知道怎么使用损失函数了。

稍后阅读:

神经网络类库中包含很多模块和损失函数,形成深度神经网络模块。完整的文件列表在http://t.cn/EIPR3z1

接下来唯一要学习的是:

更新网络的权重。

4.更新权重

时间中使用的最简单的更新规则是随机梯度下降(SGD):

weight = weight - learning_rate * gradient

我们可以使用简单的python代码实现:

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data * learning_rate)

但是,当你使用神经网络时,你可能想使用SGD,Nesterov-SGD,Adam,RMSProp等不同的更新规则。为了实现这些,我们建立了一个包: torch.optim ,实现了以上所有的方法。使用非常的简单:

import torch.optim as optim

#构建优化器
optimizer = optim.SGD(net.parameters(), lr=0.01)

#训练时循环的语句:
optimizer.zero_grad()   # 将梯度缓存清零。
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # 更新权重

注意:

观察如何使用手动设置梯度清零 optimizer.zero_grad() . 需要手动清零的原因在 Backprop_ 中已经说明了(梯度会累加之前的梯度)。

Type Markdown and LaTeX: α2