《pytorch深度学习实战》第10讲作业

最新推荐文章于 2026-01-04 17:49:55 发布

原创最新推荐文章于 2026-01-04 17:49:55 发布 · 1k 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#pytorch #深度学习 #神经网络

PyTorch 专栏收录该内容

24 篇文章

订阅专栏

该博客介绍了使用3x3和5x5卷积神经网络，结合2x2和3x3池化层在MNIST数据集上的图像识别实验。模型包括两层全连接层，通过ReLU激活函数进行训练。在不使用ReLU的情况下，模型的最佳准确率为98.99%，而使用ReLU时准确率在98.67%-98.63%之间。博客还展示了训练和测试过程，并给出了训练损失和准确率随时间变化的图表。

3x3和5x5的卷积神经网络
2x2和3x3的池化层
全连接层2层
图像化过程
结果输出：98.77%

没有Linear均不使用Relu激活，ACC_Max = 0.9899
# 一个Linear均使用Relu激活，ACC_Max = 0.9867
# 两个Linear均使用Relu激活，ACC_Max = 0.9863

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

#1.prepare dataset
#2.design model using class
#3.construct loss and optimizer
#4.training cycle+test

#1.准备数据集

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))#均值，标准化
])
train_dataset = datasets.MNIST(root='./dataset/mnist',
                               train=True,
                               transform=transform,
                               download=True)
print(train_dataset[0])
test_dataset = datasets.MNIST(root='./dataset/mnist',
                              train=False,
                              transform=transform,
                              download=True)

train_loader = DataLoader(dataset=train_dataset,
                          batch_size=32,
                          shuffle=True)
test_loader = DataLoader(dataset=test_dataset,
                         batch_size=32,
                         shuffle=False)

#2.设计模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=3)
        self.conv3 = torch.nn.Conv2d(20, 40, kernel_size=3)

        self.pooling1 = torch.nn.MaxPool2d(kernel_size=2, stride=2)
        self.pooling2 = torch.nn.MaxPool2d(kernel_size=3, stride=3)

        self.fc1 = torch.nn.Linear(40, 20)
        self.fc2 = torch.nn.Linear(20, 10)


    def forward(self, x):
        batch_size = x.size(0)
        x = F.relu(self.pooling1(self.conv1(x))) # 10x12x12
        x = F.relu(self.pooling1(self.conv2(x))) # 20x5x5
        x = F.relu(self.pooling2(self.conv3(x))) # 40x1x1
        x = x.view(batch_size, -1)
        x = self.fc1(x) # 20x1x1
        x = self.fc2(x) # 10x1x1

        return x

model = Net()
# 开启显卡
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# model.to(device)

#3.构建loss和optimzer
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

#4.循环
def train(epoch):
    running_loss = 0.0
    for batch_idx, (inputs, target) in enumerate(train_loader):
        # inputs, target = inputs.to(device), target.to(device) #显卡加速

        optimizer.zero_grad()

        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_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        print('Accuracy on test set: %d %%' % (100*correct / total))
    return correct / total

if __name__ == '__main__':
    epoch_list = []
    acc_list = []

    for epoch in range(10):
        train(epoch)
        acc = test()
        epoch_list.append(epoch)
        acc_list.append(acc)
        # if epoch % 10 == 9:
        #     test()
    import os
    os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
    plt.plot(epoch_list, acc_list)
    plt.xlabel('epoch')
    plt.ylabel('accuracy')
    plt.show()