#!/usr/bin/env python

coding: utf-8

In[1]:

get_ipython().magic(u’matplotlib’)

神经网络的典型训练过程如下：

1：定义包含一些参数（或者权重）的神经网络模型

2：在数据集上迭代，

3：通过神经网络处理输入

4：计算损失，输出值和正确值的插值大小

5：将梯度反向传播会回网络的参数

6：更新网络的参数，主要使用如下的更新原则：weight = weight - learning_rate * gradient

# 定义网络

In[2]:

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

class Net(nn.Module): #继承父类，nn.Module类
def init(self): #初始化函数
super(Net,self).init() #继承nn.Model类的初始化函数
# 1 input image channel, 6 output channels, 5x5 square convolution
# kernel 网络核心
self.conv1 = nn.Conv2d(1,6,5) # in_channels, out_channels, kernel_size（int or tuple）
self.conv2 = nn.Conv2d(6,16,5)
# an affine operation: y = Wx + b ，映射函数
self.fc1 = nn.Linear(1655,120)
self.fc2 = nn.Linear(120,84)
self.fc3 = nn.Linear(84,10)

def forward(self,x):
    # 最大池（2,2）窗口
    x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))  #这个好像是使用一个激活函数把每个层的结果输出，给下一个层
    # 如果大小是正方形，只需指定一个数字
    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):
    print("size_x = ",x.size())
    size = x.size()[1:]    # 除batch维度外的所有维度
    num_features = 1
    for s in size:
        num_features *= s
    return num_features

net = Net()
print(net)

在模型中必须定义forward函数，backwar函数（用来计算梯度）会被autograd自动创建。可以在forward使用任何针对Tensor的操作

net.parameters 返回可被学习的参数（权重）列表和值：

In[3]:

params = list(net.parameters())

print(params)

print(len(params))
print(params[0].size())

测试随机输入的32 * 32，注：这个网络（LeNet）期望的输入值是32 * 32，如果使用mnister数据集来训练这个网络，请把图片大小调整为32 * 32：

In[4]:

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

将所有参数的梯度缓存清零，然后进行随机梯度的反向传播：

In[5]:

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

Note:

torch.nn 只支持小批量输入。整个 torch.nn 包都只支持小批量样本，而不支持单个样本。 例如，nn.Conv2d 接受一个4维的张量， 每一维分别是sSamples * nChannels * Height * Width（样本数*通道数*高*宽）。 如果你有单个样本，只需使用 input.unsqueeze(0) 来添加其它的维数

在继续之前，我们回顾一下到目前为止用到的类。

回顾:

torch.Tensor：一个用过自动调用 backward()实现支持自动梯度计算的 多维数组 ， 并且保存关于这个向量的梯度 w.r.t.

nn.Module：神经网络模块。封装参数、移动到GPU上运行、导出、加载等。

nn.Parameter：一种变量，当把它赋值给一个Module时，被 自动 地注册为一个参数。

autograd.Function：实现一个自动求导操作的前向和反向定义，每个变量操作至少创建一个函数节点，每一个Tensor的操作都回创建一个接到创建Tensor和 编码其历史 的函数的Function节点。

重点如下：

定义一个网络

处理输入，调用backword

还剩：

计算损失

更新网络权重

# 损失函数：

一个损失函数接收一对（out,target）作为输入，计算一个值计算网络的输出和目标值差多少；

output为网络的输出，target为实际值。

nn中包含许多损失函数。nn.MSELoss是一个比较简单的损失函数，他计算网络输出和目标值之间的均方误差。例如：

In[7]:

output = net(input_data)
target = torch.randn(10) # 随机值作为案例实际值
print("target: ",target)
print("target.size() = ", target.size())
target = target.view(1,-1) # 使target和output的shape相同,从（101）的size改成（110）
ceriterion = nn.MSELoss()
loss = ceriterion(output,target)
print(loss)

为了说明，让我们向后退几步：

In[8]:

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

# 反向传播

调用loss.backward()来获取反向传播的误差； 但是在调用前需要清除已存的梯度，否则梯度将被累加到已存在的梯度 ； 现在我们将查看conv1层的偏差（bias）项在反向传播前后的梯度。

In[9]:

net.zero_grad #清除梯度
print(‘conv1.bias.grad before backward’)
print(net.conv1.bias.grad)
loss.backward()
print(‘conv1.bias.grad after backward’)
print(net.conv1.bias.grad)

# 更新权重：

在实践中最简单的权重更新规则是随机梯度下降（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等，PyTorch中构建了一个包torch.optim实现了所有的这些规则。 使用它们非常简单:`

In[10]:

import torch.optim as optim

create your optimizer

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

#in your trainingg loop
optimizer.zero_grad() #zero the gradient buffers
out = net(input_data)
loss = ceriterion(out,target)
print("loss = ",loss)
loss.backward()
optimizer.step #does the update