[人工智能]深度学习实验（四）——卷积神经网络编程

深度学习实验四:卷积神经网络编程

本次实验练习使用torch.nn中的类设计一个卷积神经网络进行MNIST手写体数字图像分类。

name = 'x'#填写你的姓名
sid = 'B02014152'#填写你的学号

print('姓名:%s, 学号:%s'%(name, sid))

姓名:x, 学号:B02014152

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

1. 设计CNN类

从torch.nn.Module派生一个子类CNN，表示一个卷积神经网络;

请合理设计网络各个层，尝试使用不同的结构，比如skip connection, batch normalization,group convolution等。

你的网络模型中至少有2个卷积层、2个聚合层。

#在下面添加代码，实现卷积神经网络,用于识别MNIST手写体数字
# conv1 = nn.Conv2d(in_channels = 3, out_channels = 16, kernel_size = 3, padding = 0) # Valid Conv
# conv2 = nn.Conv2d(in_channels = 3, out_channels = 16, kernel_size = 3, padding = 1) # Same Conv
# conv3 = nn.Conv2d(in_channels = 3, out_channels = 16, kernel_size = 3, padding = 2) # Full Conv

class CNN(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.convd1 = nn.Conv2d(in_channels = 1, out_channels = 10, kernel_size = 3, padding = 0)
        self.pool1 = torch.nn.MaxPool2d(kernel_size= 2, stride= 2)
        self.convd2 = nn.Conv2d(in_channels = 10, out_channels = 20, kernel_size = 3, padding = 0)
        self.pool2 = torch.nn.MaxPool2d(kernel_size= 2, stride= 2)
        self.fc = torch.nn.Linear(500, 10)

    def forward(self, x):
        x.cuda()
        batch_size = x.size(0)
        z1 = self.pool1(self.convd1(x))
        a1 = F.relu(z1)
        z2 = self.pool2(self.convd2(a1))
        a2 = F.relu(z2)
        a2 = a2.view(batch_size, -1)
        a2 = self.fc(a2)
        # a2 = F.softmax(a2, dim=0)
        return a2

#测试MLP类
X = torch.rand((32,1,28,28),dtype = torch.float32)
net = CNN()
Y = net(X)
print(Y)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In [482], line 4
      2 X = torch.rand((32,1,28,28),dtype = torch.float32)
      3 net = CNN()
----> 4 Y = net(X)
      5 print(Y)


File ~\AppData\Roaming\Python\Python38\site-packages\torch\nn\modules\module.py:727, in Module._call_impl(self, *input, **kwargs)
    725     result = self._slow_forward(*input, **kwargs)
    726 else:
--> 727     result = self.forward(*input, **kwargs)
    728 for hook in itertools.chain(
    729         _global_forward_hooks.values(),
    730         self._forward_hooks.values()):
    731     hook_result = hook(self, input, result)


Cell In [481], line 19, in CNN.forward(self, x)
     17 batch_size = x.size(0)
     18 x = nn.BatchNorm2d(num_features=1)
---> 19 z1 = self.pool1(self.convd1(x))
     20 a1 = F.relu(z1)
     21 z2 = self.pool2(self.convd2(a1))


File ~\AppData\Roaming\Python\Python38\site-packages\torch\nn\modules\module.py:727, in Module._call_impl(self, *input, **kwargs)
    725     result = self._slow_forward(*input, **kwargs)
    726 else:
--> 727     result = self.forward(*input, **kwargs)
    728 for hook in itertools.chain(
    729         _global_forward_hooks.values(),
    730         self._forward_hooks.values()):
    731     hook_result = hook(self, input, result)


File ~\AppData\Roaming\Python\Python38\site-packages\torch\nn\modules\conv.py:423, in Conv2d.forward(self, input)
    422 def forward(self, input: Tensor) -> Tensor:
--> 423     return self._conv_forward(input, self.weight)


File ~\AppData\Roaming\Python\Python38\site-packages\torch\nn\modules\conv.py:419, in Conv2d._conv_forward(self, input, weight)
    415 if self.padding_mode != 'zeros':
    416     return F.conv2d(F.pad(input, self._reversed_padding_repeated_twice, mode=self.padding_mode),
    417                     weight, self.bias, self.stride,
    418                     _pair(0), self.dilation, self.groups)
--> 419 return F.conv2d(input, weight, self.bias, self.stride,
    420                 self.padding, self.dilation, self.groups)


TypeError: conv2d(): argument 'input' (position 1) must be Tensor, not BatchNorm2d

Y.shape

torch.Size([32, 10])

#了解MLP中的参数
for name,param in net.named_parameters():
    print(name,':',param.size())

convd1.weight : torch.Size([10, 1, 3, 3])
convd1.bias : torch.Size([10])
convd2.weight : torch.Size([20, 10, 3, 3])
convd2.bias : torch.Size([20])
fc.weight : torch.Size([10, 500])
fc.bias : torch.Size([10])

#输出模型
print(net)

CNN(
  (convd1): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1))
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (convd2): Conv2d(10, 20, kernel_size=(3, 3), stride=(1, 1))
  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (fc): Linear(in_features=500, out_features=10, bias=True)
)

#用torchsummary输出模型结构
# !pip install -i https://pypi.tuna.tsinghua.edu.cn/simple torchsummary

from torchsummary import summary

summary(net.cuda(), input_size = (1,28,28))

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1           [-1, 10, 26, 26]             100
         MaxPool2d-2           [-1, 10, 13, 13]               0
            Conv2d-3           [-1, 20, 11, 11]           1,820
         MaxPool2d-4             [-1, 20, 5, 5]               0
            Linear-5                   [-1, 10]           5,010
================================================================
Total params: 6,930
Trainable params: 6,930
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.09
Params size (MB): 0.03
Estimated Total Size (MB): 0.12
----------------------------------------------------------------

2.训练模型

2.1 第一步，对数据做预处理

MNIST图像的像素取值范围是[0,1]，先把值域改变为[-1,1]. 在PyTorch中，可以使用torchvision.transforms.Normalize类处理。

from torchvision import datasets,transforms

#构造一个变换，将像素值范围变换到[-1,1]
normalizer =  transforms.Normalize((0.5,), (0.5,))#一行代码

#定义一个变换序列transform，包含两个变换：第一个将PIL图像转换为张量，第二个是normalizer

transform = transforms.Compose([transforms.ToTensor(), normalizer]) #一行代码

2.2 第二步，构造训练集，加入预处理

data_path = '../data/'
mnist_train = datasets.MNIST(data_path,download=False,train = True,transform = transform)
mnist_test =  datasets.MNIST(data_path,download=False,train = False,transform = transform)

2.3 第三步，构造加载器

batch_size = 32 #可以自己定义batch_size大小
train_loader = torch.utils.data.DataLoader(mnist_train, batch_size = batch_size, shuffle = True)
test_loader = torch.utils.data.DataLoader(mnist_test, batch_size = batch_size, shuffle = False)

#从加载器里获取一批样本，并输出样本张量的形状
imgs,labels = iter(train_loader).next()#一行样本

imgs.shape

torch.Size([32, 1, 28, 28])

labels.shape

torch.Size([32])

2.4 第四步，训练模型

注意：训练卷积神经网络时，网络的输入是四维张量，尺寸为$N\times C\times H\times W$，分别表示张量

def Train(model, loader, epochs, lr = 0.1):
    epsilon = 1e-6
    
    #将model置于train模式
    #一行代码
    net.train()

    
    #定义合适的优化器
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)#一行代码
    
    #定义损失函数
    loss = F.cross_entropy#一行代码
    
    #请在下面完成训练代码
    #请在迭代过程中每100次迭代，输出一次损失
    loss0 = 0
    for epoch in range(epochs):
        for it,(imgs, labels) in enumerate(loader):
            #1. zero_grads
            #请用一行代码实现
            optimizer.zero_grad()
            imgs, labels = imgs.cuda(), labels.cuda()

            #2. F.P.前向传播
            #请用一行代码实现
            logits = model(imgs)

            #3. 计算损失            
            loss1 = loss(logits, labels)#请用一行代码实现
            
            if(abs(loss1.item() - loss0)<epsilon):
                break
                
            loss0 = loss1.item()
                
            if it%100==0:
                print('epoch %d, iter %d, loss = %f\n'%(epoch,it,loss1.item()))
                
            #4. 后向传播
            #请用一行代码实现
            loss1.backward()
            
            #5. 梯度下降
            #请用一行代码实现.
            optimizer.step()

    
            
    return model            

#训练模型

model = CNN()
model = model.cuda()

model = Train(model, test_loader, 10)

epoch 0, iter 0, loss = 2.317181

epoch 0, iter 100, loss = 1.612653

epoch 0, iter 200, loss = 0.475313

epoch 0, iter 300, loss = 0.267556

epoch 1, iter 0, loss = 0.272252

epoch 1, iter 100, loss = 0.387812

epoch 1, iter 200, loss = 0.248591

epoch 1, iter 300, loss = 0.130585

epoch 2, iter 0, loss = 0.101499

epoch 2, iter 100, loss = 0.289020

epoch 2, iter 200, loss = 0.127526

epoch 2, iter 300, loss = 0.072299

epoch 3, iter 0, loss = 0.069821

epoch 3, iter 100, loss = 0.237272

epoch 3, iter 200, loss = 0.073975

epoch 3, iter 300, loss = 0.052888

epoch 4, iter 0, loss = 0.055265

epoch 4, iter 100, loss = 0.210844

epoch 4, iter 200, loss = 0.046827

epoch 4, iter 300, loss = 0.046028

epoch 5, iter 0, loss = 0.044145

epoch 5, iter 100, loss = 0.192648

epoch 5, iter 200, loss = 0.031938

epoch 5, iter 300, loss = 0.042316

epoch 6, iter 0, loss = 0.036941

epoch 6, iter 100, loss = 0.179299

epoch 6, iter 200, loss = 0.023668

epoch 6, iter 300, loss = 0.039010

epoch 7, iter 0, loss = 0.032049

epoch 7, iter 100, loss = 0.168726

epoch 7, iter 200, loss = 0.018773

epoch 7, iter 300, loss = 0.036361

epoch 8, iter 0, loss = 0.027803

epoch 8, iter 100, loss = 0.158944

epoch 8, iter 200, loss = 0.015419

epoch 8, iter 300, loss = 0.034879

epoch 9, iter 0, loss = 0.024135

epoch 9, iter 100, loss = 0.149009

epoch 9, iter 200, loss = 0.012855

epoch 9, iter 300, loss = 0.033128

?

2.5 第五步，测试模型

#编写模型测试过程
def Evaluate(model, loader):
    model.eval()
    correct = 0
    counts = 0
    for imgs, labels in loader:
        imgs, labels = imgs.cuda(), labels.cuda()
        logits = model(imgs)
        yhat = logits.argmax(dim = 1)
        correct = correct + (yhat==labels).sum().item()
        counts = counts + imgs.size(0)
    
    accuracy = correct / counts
    
    return accuracy

acc = Evaluate(model,test_loader)
print('Accuracy = %f'%(acc))

Accuracy = 0.974000

imgs,labels  = next(iter(test_loader))
imgs, labels = imgs.cuda(), labels.cuda()

logits = model(imgs)

imgs, labels = imgs.cpu(), labels.cpu()

yhat = logits.argmax(dim = 1)

plt.figure(figsize = (16,10))
for i in range(imgs.size(0)):
    plt.subplot(4,8,i+1)
    plt.imshow(imgs[i].squeeze()/2+0.5,cmap = 'gray')
    plt.axis('off')
    plt.title('GT=%d, Pred = %d'%(labels[i],yhat[i]))
    
plt.show()

?