神经网络

神经网络

1、Autograd实现了反向传播功能，但是直接用来写深度学习的代码在很多情况下还是少先复杂，torch.nn是专门为神经网络涉及到的模块化接口。nn构建与Autograd之上，可用来定义和运行神经网络。
2、nn.Module是nn中最重要的类，可以把它看做一个网络的封装，包含网络各层定义及forward方法。

定义网络

1、定义网络，需要继承nn.Module，并实现它的forward方法，把网络中具有可学习参数的层放在构造函数__init__中，如果某一层（如ReLU）不具有可学习的参数，则即可以放在后再函数也可以不放。 

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.conv1 = nn.Conv2d(1,6,5)
        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 = F.max_pool2d(F.relu(self.conv1(x)),(2,2))
        x = F.max_pool2d(F.relu(self.conv2(x)),2)
        x = x.view(x.size()[0],-1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
net = Net()
print(net)
'''''''Net(
  (conv1): Conv1d(1, 6, kernel_size=(5,), stride=(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)
)'''

2、只要在nn.Module的子类中定义了forward函数，backward函数就会被自动实现。在forward函数中可使用任何Variable支持的函数，网络的可学习参数通过net.parameters()返回，net.named_parameters可同时返回可学习的参数及名称； 

'''''''网络可学习的参数'''
params = list(net.parameters())
print(len(params))   #10
'''''''返回可学习的参数及名称'''
for name,parameters in net.named_parameters():
    print(name,':',parameters.size())
'''''''conv1.weight : torch.Size([6, 1, 5])
conv1.bias : torch.Size([6])
conv2.weight : torch.Size([16, 6, 5, 5])
conv2.bias : torch.Size([16])
fc1.weight : torch.Size([120, 400])
fc1.bias : torch.Size([120])
fc2.weight : torch.Size([84, 120])
fc2.bias : torch.Size([84])
fc3.weight : torch.Size([10, 84])
fc3.bias : torch.Size([10])'''

3、forward函数的输入和输出都是Variable，只有Variable才具有自动求导功能，Tensor是没有的，所以在输入时，需要把Tensor封装成Variable；

损失函数

1、nn实现了神经网络中大多数的损失函数，例如nn.MSELoss用来计算均方误差，nn.CrossEntropyLoss用来计算交叉熵损失；

input = Variable(t.randn(1,1,32,32))
out = net(input)
out.size()
print(out.size())
'''''''torch.Size([1, 10])'''
net.zero_grad()
out.backward(t.Tensor.float( Variable(t.ones(1,10)) ))  #反向传播

2、当调用loss.backward()时，该图会动态生成并自动微分，会自动计算图中参数的导数； 

net.zero_grad() #把net中所有可学习参数的梯度清零
print('反向传播之前conv1.bias的梯度',net.conv1.bias.grad)
loss.backward()
print('反向传播之后conv1.bias的梯度',net.conv1.bias.grad)
'''''''反向传播之前conv1.bias的梯度 tensor([0., 0., 0., 0., 0., 0.])
反向传播之后conv1.bias的梯度 tensor([-0.0783,  0.0173, -0.0358, -0.0556,  0.0210, -0.0596])'''

优化器

1、在反向传播计算完所有参数的梯度后，还需要使用优化方法更新网络的权重和参数；

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()