零基础学习人工智能—Python—Pytorch学习（九）

前言

本文主要介绍卷积神经网络的使用的下半部分。
另外，上篇文章增加了一点代码注释，主要是解释（w-f+2p）/s+1这个公式的使用。
所以，要是这篇文章的代码看不太懂，可以翻一下上篇文章。
【重要】我在回头重看这系列时，发现很多地方写的不好，所以做了修改，其中主要是《零基础学习人工智能—Python—Pytorch学习（七）》，如果这篇文章看不懂，可以重看一下系列文章七。

代码实现

之前，我们已经学习了概念，在结合我们以前学习的知识，我们可以直接阅读下面代码了。
代码里使用了，dataset.CIFAR10数据集。
CIFAR-10 数据集由 60000 张 32x32 彩色图像组成，共分为 10 个不同的类别，分别是飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船和卡车。
每个类别包含 6000 张图像，其中 50000 张用于训练，10000 张用于测试。

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
import torch.nn.functional as F #nn不好使时，在这里找激活函数
# device config
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# hyper parameters
input_size = 784  # 28x28
hidden_size = 100
num_classes = 10
batch_size = 100
learning_rate = 0.001
num_epochs = 2

 
transform = transforms.Compose(
    [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

train_dataset = torchvision.datasets.CIFAR10(
    root='./data', train=True, download=True, transform=transform)

test_dataset = torchvision.datasets.CIFAR10(
    root='./data', train=False, download=True, transform=transform)
 
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=False)
print('每份100个，被分成多少份：', len(test_loader))


classes = ('plane', 'car', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck')


class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet,self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16*5*5, 120) #这个在forward里解释
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        print("x.shape:", x.shape) # x.shape: torch.Size([100, 3, 32, 32])
        x = self.pool(F.relu(self.conv1(x)))
        # 这里x已经变成 torch.Size([100, 6, 14, 14])
        x = self.pool(F.relu(self.conv2(x)))
        print("两次卷积两次池化后的x.shape:", x.shape)
        x = x.view(-1, 16*5*5)  # 这里的16*5*5就是x的后面3个维度相乘
        x = F.relu(self.fc1(x))  # fc1定义时，inputx已经是16*5*5了
        print("一次全连接后的x.shape:", x.shape)
        x = F.relu(self.fc2(x))
        print("二次全连接后的x.shape:", x.shape)
        x = self.fc3(x)
        print("三次全连接后的x.shape:", x.shape)
        # 这里使用了两次隐藏层，一次是120，一次是84，最后才转换成10
        # 下面的rossEntropyLoss包含Softmax，所以这里就不用调用了
        return x



model = ConvNet().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)


n_total_steps = len(train_loader)

for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
      
        images = images.to(device)  #移动到设备上计算，有gpu用gpu计算，没有用cpu计算
        labels = labels.to(device)
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)
        print("loss.item()",loss.item())  # 输出 2.300053596496582
        # Backward and optimize
        optimizer.zero_grad()
        loss.backward() # 执行逆向传播 会使用criterion的函数关系求偏导，然后把x的值，带入偏导公式求值，然后再乘以loss，得到新x值
        optimizer.step()
        print(f'Epoch [{epoch}/{num_epochs}], Step [{i+1}/{n_total_steps}], Loss: {loss.item():.4f}')
        print('=========')
print('Finished Training')


# test
with torch.no_grad():
    n_correct = 0
    n_samples = 0
    n_class_correct = [0 for i in range(10)] #生成 10 个 0 的列表
    n_class_samples = [0 for i in range(10)]
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)
        print('test-images.shape：', images.shape)
        outputs = model(images)
        # max returns(value ,index)
        _, predicted = torch.max(outputs, 1)
        n_samples += labels.size(0)
        n_correct += (predicted == labels).sum().item()
        for i in range(batch_size):
            label = labels[i]
            # print("label:",label) #这里存的是 0~9的数字 输出就是这样的 label: tensor(2) predicted[i]也是这样的数
            pred = predicted[i]
            if (label == pred):
                n_class_correct[label] += 1
            n_class_samples[label] += 1
    acc = 100.0*n_correct/n_samples  # 计算正确率
    print(f'accuracy ={acc}')
    
    for i in range(10):
        acc = 100.0*n_class_correct[i]/n_class_samples[i]
        print(f'Accuracy of {classes[i]}: {acc} %')

运行结果如下：

accuracy =10.26
Accuracy of plane: 0.0 %
Accuracy of car: 0.0 %
Accuracy of bird: 0.0 %
Accuracy of cat: 0.0 %
Accuracy of deer: 0.0 %
Accuracy of dog: 0.0 %
Accuracy of frog: 0.0 %
Accuracy of horse: 0.0 %
Accuracy of ship: 89.6 %
Accuracy of truck: 13.0 %