PyTorch 深度学习实践 第11讲：卷积 神经网络（高级篇）

第11讲：卷积 神经网络（高级篇）

视频教程
1.GoogleNet的Inception


1.inception Module包含(Convolution, Pooling, Softmax, Other)

代码说明：

1. 先使用类对Inception Moudel进行封装
2. 使用类封装模型计算过程：（卷积层，inception块，卷积层，inception块，全连接层）
3. 训练集，测试集(forward, backward, update)

import torch
import torch.nn as nn
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

#1.prepare dataset 

batch_size = 64
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]) # 归一化,均值和方差
 
train_dataset = datasets.MNIST(root='../dataset/mnist/', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist/', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)

#2.design model using class
class InceptionA(nn.Module):
    def __init__(self, in_channels):
    #定义通道的块
        super(InceptionA, self).__init__()
        self.branch1x1 = nn.Conv2d(in_channels, 16, kernel_size=1)
 
        self.branch5x5_1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        self.branch5x5_2 = nn.Conv2d(16, 24, kernel_size=5, padding=2)
 
        self.branch3x3_1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        self.branch3x3_2 = nn.Conv2d(16, 24, kernel_size=3, padding=1)
        self.branch3x3_3 = nn.Conv2d(24, 24, kernel_size=3, padding=1)
 
        self.branch_pool = nn.Conv2d(in_channels, 24, kernel_size=1)
    
    def forward(self, x):
    #计算过程
        branch1x1 = self.branch1x1(x)
        
        branch5x5 = self.branch5x5_1(x)
        branch5x5 = self.branch5x5_2(branch5x5)
        
        branch3x3 = self.branch3x3_1(x)
        branch3x3 = self.branch3x3_2(branch3x3)
        branch3x3 = self.branch3x3_3(branch3x3)

        branch_pool = F.avg_pool2d(x, kernel_size = 3, stride = 1, padding=1)
        branch_pool = self.branch_pool(branch_pool)
        
        outputs = [branch1x1, branch5x5, branch3x3, branch_pool]
        #将这些块放在一个列表中
        return torch.cat(outputs, dim = 1)
        # b,c,w,h  c对应的是dim=1
        #然后沿着dim = 1（channel)纬度拼接

#3.design Net using class
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(88, 20, kernel_size=5)
        
        self.incep1 = InceptionA(in_channels=10) # 与conv1 中的10对应
        self.incep2 = InceptionA(in_channels=20) # 与conv2 中的20对应
 
        self.mp = nn.MaxPool2d(2)
        self.fc = nn.Linear(1408, 10) 
        
    def forward(self, x):
        in_size = x.size(0)
        x = F.relu(self.mp(self.conv1(x)))
        #首先是1个卷积层(conv,maxpooling,relu)：输入通道10
        x = self.incep1(x)
        #然后inceptionA模块(输出的channels是24+16+24+24=88)
        x = F.relu(self.mp(self.conv2(x)))
        #接着又是一个卷积层(conv,mp,relu)#输出通道20
        x = self.incep2(x)#输出通道20
        x = x.view(in_size, -1)
		#转成向量，连接一个全连接层(fc)。
        x = self.fc(x)
        return x
model =  Net()

#4.construct loss and optimizer
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

#5.training cycle forward, backward, update
def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()
 
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
 
        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch+1, batch_idx+1, running_loss/300))
            running_loss = 0.0

def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('accuracy on test set: %d %% ' % (100*correct/total))

if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()

[1, 300] loss: 1.008
[1, 600] loss: 0.206
[1, 900] loss: 0.150
accuracy on test set: 96 %
[2, 300] loss: 0.110
[2, 600] loss: 0.109
[2, 900] loss: 0.099
accuracy on test set: 97 %
[3, 300] loss: 0.078
[3, 600] loss: 0.082
[3, 900] loss: 0.076
accuracy on test set: 97 %
[4, 300] loss: 0.065
[4, 600] loss: 0.066
[4, 900] loss: 0.066
accuracy on test set: 98 %
[5, 300] loss: 0.057
[5, 600] loss: 0.057
[5, 900] loss: 0.058
accuracy on test set: 98 %
[6, 300] loss: 0.048
[6, 600] loss: 0.052
[6, 900] loss: 0.054
accuracy on test set: 98 %
[7, 300] loss: 0.045
[7, 600] loss: 0.046
[7, 900] loss: 0.049
accuracy on test set: 98 %
[8, 300] loss: 0.040
[8, 600] loss: 0.045
[8, 900] loss: 0.043
accuracy on test set: 98 %
[9, 300] loss: 0.039
[9, 600] loss: 0.040
[9, 900] loss: 0.040
accuracy on test set: 98 %
[10, 300] loss: 0.035
[10, 600] loss: 0.039
[10, 900] loss: 0.036
accuracy on test set: 98 %
参考