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講