60分钟闪学pytorch深度学习记录3

三、神经网络

 

 

1、定义神经网络

 

（2）使用torch.nn定义网络各层

### 三、Define the network

## 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 input image channel, 6 output channels, 5x5 square convolution kernel
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120) # 5*5 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 specify with a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = torch.flatten(x, 1) # flatten all dimensions except the batch dimension
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
net = Net()
print(net)
    
        

运行结果：
 

Net(
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 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）net.parameters() 返回网络各层参数： 

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

运行结果：

10
torch.Size([6, 1, 5, 5])

（3）输入随机数据进行测试，并进行反向传播

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

# 运行结果：
tensor([[ 0.0816,  0.0910, -0.1318, -0.0368,  0.0250, -0.0686, -0.0759, -0.0197,
          0.1066, -0.0995]], grad_fn=<AddmmBackward>)


# Zero the gradient buffers of all parameters and backprops with random gradients:

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

 2 、损失函数

 

（1）

## 2、Loss Function
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)


# 运行结果：
tensor(1.9062, grad_fn=<MseLossBackward>)

（2）grad_fn属性

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



# 运行结果：
<MseLossBackward object at 0x000001E64F293490>
<AddmmBackward object at 0x000001E64F293EB0>
<AccumulateGrad object at 0x000001E64F293490>

 

3、反向传播算法实现：

 

## 3、Backprop
net.zero_grad()  # zeros 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)

# 运行结果：
conv1.bias.grad before backward
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([ 0.0125,  0.0229,  0.0059, -0.0018, -0.0086, -0.0051])

 

 4、参数更新：

 

## 4、 Update the weights
# Stochastic Gradient Descent(SCD)
# weight = weight - learning_rate * gradient

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



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

参考资料：

 

https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#sphx-glr-beginner-blitz-neural-networks-tutorial-py