009_wz_ledr_pytorch深度学习实战_第十讲——卷积神经网络（CNN）基础篇

一、目的

使用CNN网络对Mnist进行分类。

二、编程

我们使用pytorch框架。

搭建两个卷积层、两个池化层、一个全连接层来实现。

1、每一个卷积核它的通道数量要求和输入通道数量是一样的。这种卷积核的总数有多少个和你输出通道的数量是一样的。

2、卷积(convolution)后，C(Channels)变，W(width)和H(Height)可变可不变，取决于是否padding。subsampling(或pooling)后，C不变，W和H变。

3、卷积层：保留图像的空间信息。

4、卷积层要求输入输出是四维张量(B,C,W,H)，全连接层的输入与输出都是二维张量(B,Input_feature)。

5、卷积(线性变换)，激活函数(非线性变换)，池化；这个过程若干次后，view打平，进入全连接层~

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


# 准备数据集
batch_size = 64
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])

train_data = datasets.MNIST(root='./dataset/mnist', train=True, transform=transform, download=True)
train_loader = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True, num_workers=0)
test_data = datasets.MNIST(root='./dataset/mnist', train=False, transform=transform, download=True)
test_loader = DataLoader(dataset=test_data, batch_size=batch_size, shuffle=True, num_workers=0)

# 搭建网络模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=10, kernel_size=5)
        self.conv2 = torch.nn.Conv2d(in_channels=10, out_channels=20, kernel_size=5)
        self.pooling = torch.nn.MaxPool2d(kernel_size=2)
        self.fc = torch.nn.Linear(320, 10)

    def forward(self, x):
        batch_size = x.shape[0]
        # 卷积后池化
        x = self.pooling(F.relu(self.conv1(x)))
        x = self.pooling(F.relu(self.conv2(x)))
        x = x.view(batch_size, -1)
        x = self.fc(x)

        return x


model = Net()

# 构建损失函数和优化器
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), momentum=0.5, lr=0.01)

# 训练
def train(epoch):
    train_loss = 0.
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %d],loss=%.3f' % (epoch+1, batch_idx+1, train_loss/300))
            train_loss = 0.

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


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

损失下降如下

[1, 300],loss=0.606
[1, 600],loss=0.192
[1, 900],loss=0.139
accuracy on the test set: 96%
[2, 300],loss=0.110
[2, 600],loss=0.099
[2, 900],loss=0.093
accuracy on the test set: 97%
[3, 300],loss=0.082
[3, 600],loss=0.076
[3, 900],loss=0.071
accuracy on the test set: 97%
[4, 300],loss=0.067
[4, 600],loss=0.063
[4, 900],loss=0.064
accuracy on the test set: 98%
[5, 300],loss=0.060
[5, 600],loss=0.055
[5, 900],loss=0.056
accuracy on the test set: 98%
[6, 300],loss=0.047
[6, 600],loss=0.046
[6, 900],loss=0.060
accuracy on the test set: 98%
[7, 300],loss=0.048
[7, 600],loss=0.046
[7, 900],loss=0.045
accuracy on the test set: 98%
[8, 300],loss=0.042
[8, 600],loss=0.045
[8, 900],loss=0.043
accuracy on the test set: 98%
[9, 300],loss=0.039
[9, 600],loss=0.038
[9, 900],loss=0.045
accuracy on the test set: 98%
[10, 300],loss=0.037
[10, 600],loss=0.038
[10, 900],loss=0.039
accuracy on the test set: 98%
           

在之前的单纯全连接神经网络上生生的将错误率降低了1/3.

下面是课后作业：

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=10, kernel_size=5)
        self.conv2 = torch.nn.Conv2d(in_channels=10, out_channels=20, kernel_size=3)
        self.conv3 = torch.nn.Conv2d(in_channels=20, out_channels=30, kernel_size=2)
        self.pooling = torch.nn.MaxPool2d(kernel_size=2)
        self.l1 = torch.nn.Linear(120, 64)
        self.l2 = torch.nn.Linear(64, 32)
        self.l3 = torch.nn.Linear(32, 10)

    def forward(self, x):
        batch_size = x.shape[0]
        # 卷积后池化
        x = self.pooling(F.relu(self.conv1(x)))
        x = self.pooling(F.relu(self.conv2(x)))
        x = self.pooling(F.relu(self.conv3(x)))
        x = x.view(batch_size, -1)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = self.l3(x)

        return x
           

这个效果可能会更好一点，我的显卡驱动有点问题，cpu跑太慢没有跑。

三、参考

pytorch深度学习实践

PyTorch 深度学习实践 第10讲