神经网络

神经网络

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

定义网络

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

1. class Net(nn.Module):    
2.     def __init__(self):    
3.         super(Net,self).__init__()    
4.         self.conv1 = nn.Conv2d(1,6,5)    
5.         self.conv2 = nn.Conv2d(6,16,5)    
6.     
7.         self.fc1 = nn.Linear(16*5*5,120)    
8.         self.fc2 = nn.Linear(120,84)    
9.         self.fc3 = nn.Linear(84,10)    
10.     def forward(self,x):    
11.         x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))    
12.         x = F.max_pool2d(F.relu(self.conv2(x)),2)    
13.         x = x.view(x.size()[0],-1)    
14.         x = F.relu(self.fc1(x))    
15.         x = F.relu(self.fc2(x))    
16.         x = self.fc3(x)    
17.         return x    
18. net = Net()    
19. print(net)    
20. '''''''Net(  
21.   (conv1): Conv1d(1, 6, kernel_size=(5,), stride=(1,))  
22.   (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))  
23.   (fc1): Linear(in_features=400, out_features=120, bias=True)  
24.   (fc2): Linear(in_features=120, out_features=84, bias=True)  
25.   (fc3): Linear(in_features=84, out_features=10, bias=True)  
26. )'''     

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

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

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

损失函数

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

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

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

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

优化器

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

 

1. import torch.optim as optim    
2. #建立一个优化器，指定要调参的参数和学习率    
3. optimizer = optim.SGD(net.parameters(),lr = 0.01)    
4. #梯度清零    
5. optimizer.zero_grad()    
6. #计算损失    
7. output = net(input)    
8. loss = criterion(output,target)    
9. #反向传播    
10. loss.backward()    
11. #更新参数    
12. optimizer.step()    

转载于:https://www.cnblogs.com/monkeyT/p/9765876.html