【PyTorch入门】(三)神经网络(Neural Networks)

29 篇文章 2 订阅
3 篇文章 0 订阅

官网。更新于2019.06.13。

可以用torch.nn包构建神经网络。看完这篇文章应该对autograd有了一定的了解,nn是基于autograd定义和求导模型的。一个nn.Module包括层以及用于返回outputforward(input)方法。

比如,对于如下数字图像分类网络(convnet):

在这里插入图片描述
这是一个简单的前向传播网络。给定输入后,传入几层级联的卷积层,最后给出输出。

一个典型的神经网络训练过程为:

  • 定义含有可学习参数(或权重)的神经网络
  • 在一个数据集下构成的输入中迭代
  • 通过网络处理输入
  • 计算损失(输出距离正确值有多远)
  • 反向传递梯度给网络的参数
  • 更新网络权重,通常根据一个简单的更新法则:weight = weight - learning_rate * gradient

网络定义

定义一个网络:

在这里插入图片描述
可以直接复制下面的代码创建*.py文件:

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 input image channel, 6 output channels, 3x3 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        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:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
print(net)

结果:
在这里插入图片描述

用户只需要定义forward函数,而backward函数(计算梯度的部分)是通过autrograd自动定义的。可以在forward中应用任何张量操作。

模型中的可学习参数 通过net.parameters()返回:

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

终端结果:
在这里插入图片描述

下面试一个随机的32x32的输入。注意:这个网络(LeNet)的期望输入是32x32,如果要在MNIST数据集上应用这个网络,需要将数据集的图片resize到32x32。

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

终端结果:
在这里插入图片描述

使所有参数的梯度缓存置零,并用随机梯度反向传播:

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

注意,torch.nn只支持mini-batch。完整的torch.nn包仅支持mini-batch格式的输入样本,而不支持单个样本。比如,nn.Conv2d需要一个4D的张量为输入,尺寸是nSamples x nChannels x Height x Width。如果只有一个样本,需要用input.unsqueeze(0)来增加一个虚拟的batch维度。

在进一步处理之前,先重述一下目前看到的classes。

Recap:

  • torch.Tensor——多维度array,支持backward()等autograd操作,内部也存储了相对于tensor的梯度。
  • nn.Module——神经网络模型,方便封装参数、移至GPU、加载、输出等。
  • nn.Parameter——张亮的一种,可以以一个模型的属性的形式自动注册为参数。
  • autograd.Function——autograd操作前向和反向传播定义的实施、每个张量操作都创建了已至少一个Function节点,连接了创造函数的张量并编码其历史。

到目前为止我们已经了解了神经网络模型的定义、输入的处理和调用反向传播。下面来看一下损失的计算和网络权重的更新。

损失函数

损失函数接受(output, target)对作为输入,计算二者之间的距离。nn包内有几种不同的损失函数,一个比较简单的是n.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)

终端结果:
在这里插入图片描述
此时,如果跟踪反向传播方向的loss,用其.grad_fn属性,就能够看到类似下图这样的损失计算流程:

在这里插入图片描述
所以,在调用loss.backward时,整个图都对于损失被求导了,所有图内的张量(requires_grad=True)都有其对应的.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

在这里插入图片描述

Backprop

对误差的反向传播只需要用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)

终端输出:
在这里插入图片描述
接下来看一下如何利用损失函数。

扩展阅读: 神经网络包包括了各种模块和损失函数,文件可以看这里

下面来看最后一个内容,更新模型权重。

Update the weights

最简单的更新准则是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、Nesterove-SGD、Adam、RMSProp等,就可以用一个内置的包torch.optim来应用这些方法。调用方式非常简单:

import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad()   # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # Does the update

注意: 观察提读缓存是怎样需要手动通过·optimizer.zero_grad()`设置成0的。这是因为梯度会向Backprop部分所述进行积累。

代码总运行时间:3.092秒。

更多内容,欢迎加入星球讨论。
在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值