Today, learn the construction of convolutional neural network

One 、 Construct convolution neural network to process mnist Data sets

        1.1 get data

        Build training set and test set respectively （ Verification set ）; use DataLoader To get data iteratively ：

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import matplotlib.pyplot as plt
from torchvision import datasets,transforms
import numpy as np

# Define super parameters 
input_size = 28         # The image size is 28*28
num_classes = 10        # Number of types of labels 
num_epochs = 3          # The total cycle of training 
batch_size = 64         # Number of batches 

# Training set , Here is based on datasets Inside Mnist Module read 
train_dataset = datasets.MNIST(root='./data',
                               train=True,
                               transform=transforms.ToTensor(),
                               download=True)
# Test set 
test_dataset = datasets.MNIST(root='./data',
                              train=False,
                              transform=transforms.ToTensor())

# structure batch data 
train_loader = torch.utils.data.DataLoader(dataset = train_dataset,
                                           batch_size = batch_size,
                                           shuffle = True)
test_loader = torch.utils.data.DataLoader(dataset = test_dataset,
                                          batch_size = batch_size,
                                          shuffle = True)

        1.2 Convolution network module construction

        General convolution ,relu layer , The pooling layer can be written as a package ; Note that the final result of convolution is the characteristic graph , You need to convert the graph into a vector to do classification or regression tasks ： 

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.conv1 = nn.Sequential(         # Input is （1,28,28）
            nn.Conv2d(
                in_channels=1,              # The channel number , The grayscale image here is 1
                out_channels=16,            # To get several characteristic graphs , That is, the number of convolution kernels 
                kernel_size=5,              # Convolution kernel size 
                stride=1,                   # step 
                padding=2,                  # If you want the convolution size to be the same as the original , Need to set up padding=（kernel_size-1)/2 if stride=1
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),    # The output is （16,14,14）
        )
        self.conv2 = nn.Sequential(         # Input is (16,14,14)
            nn.Conv2d(16,32,5,1,2),
            nn.ReLU(),
            nn.MaxPool2d(2),                # Output is （32,7,7）
        )
        self.out = nn.Linear(32*7*7,10)

    def forward(self,x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size(0),-1)            #flatten operation , The result is ：（batch_size,32*7*7）
        print(x.size())
        out = self.out(x)
        return out

 1.3 Training network models

# Set the accuracy function as the evaluation standard 
def accuracy(predictions,labels):
    pred = torch.max(predictions.data,1)[1]
    rights = pred.eq(labels.data.view_as(pred)).sum()
    return rights, len(labels)

# Instantiation 
net = CNN()
# Loss function 
criterion = nn.CrossEntropyLoss()
# Optimizer 
optimizer = optim.Adam(net.parameters(),lr=0.001)

# Start the training cycle 
for epoch in range(num_epochs):
    # At present epoch The results are preserved 
    train_rights = []

    for batch_idx, (data,target) in enumerate(train_loader):        # Cycle each batch in the container 
        net.train()
        output = net(data)
        loss = criterion(output,target)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        right = accuracy(output,target)
        train_rights.append(right)

        if batch_idx % 100 == 0:
            net.eval()
            val_rights = []

            for (data,target) in test_loader:
                output = net(data)
                right = accuracy(output,target)
                val_rights.append(right)

            # Accuracy calculation 
            train_r = (sum([tup[0] for tup in train_rights]),sum([tup[1] for tup in train_rights]))
            val_r = (sum([tup[0] for tup in val_rights]),sum([tup[1] for tup in val_rights]))

            print(' At present epoch:{} [{}/{} ({:.0f}%)]\t Loss ：{:.6f}\t Training set accuracy ：{:.2f}%\t Test set accuracy ：{:.2f}%'.format(
                epoch, batch_idx * batch_size, len(train_loader.dataset),
                100. * batch_idx / len(train_loader),
                loss.data,
                100. * train_r[0].numpy() / train_r[1],
                100. * val_r[0].numpy() / val_r[1],
            ))