pytorch深度学习-CNN Ressidual Net

pytorch深度学习-CNN Ressidual Net

 [1,  300] loss: 0.730
 [1,  600] loss: 0.221
 [1,  900] loss: 0.148
Accuracy on test set: 96 % 
 [2,  300] loss: 0.124
 [2,  600] loss: 0.103
 [2,  900] loss: 0.093
Accuracy on test set: 97 % 
 [3,  300] loss: 0.084
 [3,  600] loss: 0.078
 [3,  900] loss: 0.074
Accuracy on test set: 97 % 
 [4,  300] loss: 0.069
 [4,  600] loss: 0.067
 [4,  900] loss: 0.060
Accuracy on test set: 98 % 
 [5,  300] loss: 0.056
 [5,  600] loss: 0.055
 [5,  900] loss: 0.057
Accuracy on test set: 98 % 
 [6,  300] loss: 0.051
 [6,  600] loss: 0.047
 [6,  900] loss: 0.050
Accuracy on test set: 98 % 
 [7,  300] loss: 0.044
 [7,  600] loss: 0.043
 [7,  900] loss: 0.044
Accuracy on test set: 98 % 
 [8,  300] loss: 0.042
 [8,  600] loss: 0.042
 [8,  900] loss: 0.040
Accuracy on test set: 98 % 
 [9,  300] loss: 0.037
 [9,  600] loss: 0.039
 [9,  900] loss: 0.036
Accuracy on test set: 98 % 
 [10,  300] loss: 0.035
 [10,  600] loss: 0.033
 [10,  900] loss: 0.036
Accuracy on test set: 98 % 

Process finished with exit code 0

Ressidual Net残差网络代码

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


#step1 准备数据集

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.137,),(0.3081,))
])

train_dataset = datasets.MNIST(root='../dataset/mnist',
                               train=True,
                               download=True,
                               transform=transform)

train_loder = DataLoader(train_dataset,
                         shuffle=True,
                         batch_size=batch_size)

test_dataset = datasets.MNIST(root='../dataset/mnist',
                               train=False,
                               download=True,
                               transform=transform)

test_loder = DataLoader(test_dataset,
                        shuffle=False,
                        batch_size=batch_size)

#step2 搭建网络
class ResidualBlock(nn.Module):
    def __init__(self,channels):
        super(ResidualBlock, self).__init__()
        self.channels = channels
        self.conv1 = nn.Conv2d(channels,channels,
                               kernel_size=3,padding=1)
        self.conv2 = nn.Conv2d(channels,channels,
                               kernel_size=3,padding=1)

    def forward(self,x):
        y = F.relu(self.conv1(x))
        y = self.conv2(y)
        return F.relu(x+y)    #先求和，后激活

class Net(nn.Module):
    # convolution -> pooling -> inception
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1,16,kernel_size=5)   #卷积层
        self.conv2 = nn.Conv2d(16,32,kernel_size=5)
        self.mp = nn.MaxPool2d(2)

        self.rblock1 = ResidualBlock(16)
        self.rblock2 = ResidualBlock(32)

        self.fc = torch.nn.Linear(512,10)      #full connecting 全连接层

    def forward(self,x):
        in_size = x.size(0)
        x = self.mp(F.relu(self.conv1(x)))
        x = self.rblock1(x)
        x = self.mp(F.relu(self.conv2(x)))
        x = self.rblock2(x)                    # 88
        x = x.view(in_size,-1)
        x = self.fc(x)
        return x

model = Net()

device = torch.device("cuda:0" if torch.cuda.is_available() else"cpu")
model.to(device)

criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(),lr=0.01)


#step3 训练
def train(epoch):
    running_loss = 0.0
    for batch_idx,data in enumerate(train_loder,0):
        inputs,target = data
        inputs,target = inputs.to(device),target.to(device)
        optimizer.zero_grad()    #梯度清零

        #forward + backward + update
        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_loder:
            inputs,target = data
            inputs, target = inputs.to(device), target.to(device)
            outputs = model(inputs)
            _,predicted = torch.max(outputs.data,dim=1)
            total += target.size(0)
            correct += (predicted == target).sum().item()
    print('Accuracy on test set: %d %% '%(100 * correct / total))

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