【Pytorch】MNIST 手写数字识别及FCN ，RESNET论文阅读

最新推荐文章于 2024-08-18 13:45:00 发布

Adversary☆

最新推荐文章于 2024-08-18 13:45:00 发布

阅读量96

点赞数

文章标签： pytorch 人工智能 python

本文链接：https://blog.csdn.net/2302_79403486/article/details/134613352

版权

import os
os.environ['KMP_DUPLICATE_LIB_OK']='True'

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

"""
卷积运算 使用mnist数据集，和10-4，11类似的，只是这里：1.输出训练轮的acc 2.模型上使用torch.nn.Sequential
"""
# Super parameter ------------------------------------------------------------------------------------
batch_size = 64
learning_rate = 0.01
momentum = 0.5
EPOCH = 10

# Prepare dataset ------------------------------------------------------------------------------------
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
# softmax归一化指数函数(https://blog.csdn.net/lz_peter/article/details/84574716),其中0.1307是mean均值和0.3081是std标准差

train_dataset = datasets.MNIST(root='./data/mnist', train=True, transform=transform)  # 本地没有就加上download=True
test_dataset = datasets.MNIST(root='./data/mnist', train=False, transform=transform)  # train=True训练集，=False测试集
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

fig = plt.figure()
for i in range(12):
    plt.subplot(3, 4, i+1)
    plt.tight_layout()
    plt.imshow(train_dataset.train_data[i], cmap='gray', interpolation='none')
    plt.title("Labels: {}".format(train_dataset.train_labels[i]))
    plt.xticks([])
    plt.yticks([])
plt.show()


# 训练集乱序，测试集有序
# Design model using class ------------------------------------------------------------------------------
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Sequential(
            torch.nn.Conv2d(1, 10, kernel_size=5),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2),
        )
        self.conv2 = torch.nn.Sequential(
            torch.nn.Conv2d(10, 20, kernel_size=5),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2),
        )
        self.fc = torch.nn.Sequential(
            torch.nn.Linear(320, 50),
            torch.nn.Linear(50, 10),
        )

    def forward(self, x):
        batch_size = x.size(0)
        x = self.conv1(x)  # 一层卷积层,一层池化层,一层激活层(图是先卷积后激活再池化，差别不大)
        x = self.conv2(x)  # 再来一次
        x = x.view(batch_size, -1)  # flatten 变成全连接网络需要的输入 (batch, 20,4,4) ==> (batch,320), -1 此处自动算出的是320
        x = self.fc(x)
        return x  # 最后输出的是维度为10的，也就是（对应数学符号的0~9）


model = Net()


# Construct loss and optimizer ------------------------------------------------------------------------------
criterion = torch.nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)  # lr学习率，momentum冲量


# Train and Test CLASS --------------------------------------------------------------------------------------
# 把单独的一轮一环封装在函数类里
def train(epoch):
    running_loss = 0.0  # 这整个epoch的loss清零
    running_total = 0
    running_correct = 0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()

        # forward + backward + update
        outputs = model(inputs)
        loss = criterion(outputs, target)

        loss.backward()
        optimizer.step()

        # 把运行中的loss累加起来，为了下面300次一除
        running_loss += loss.item()
        # 把运行中的准确率acc算出来
        _, predicted = torch.max(outputs.data, dim=1)
        running_total += inputs.shape[0]
        running_correct += (predicted == target).sum().item()

        if batch_idx % 300 == 299:  # 不想要每一次都出loss，浪费时间，选择每300次出一个平均损失,和准确率
            print('[%d, %5d]: loss: %.3f , acc: %.2f %%'
                  % (epoch + 1, batch_idx + 1, running_loss / 300, 100 * running_correct / running_total))
            running_loss = 0.0  # 这小批300的loss清零
            running_total = 0
            running_correct = 0  # 这小批300的acc清零

        # torch.save(model.state_dict(), './model_Mnist.pth')
        # torch.save(optimizer.state_dict(), './optimizer_Mnist.pth')


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)  # dim = 1 列是第0个维度，行是第1个维度，沿着行(第1个维度)去找1.最大值和2.最大值的下标
            total += labels.size(0)  # 张量之间的比较运算
            correct += (predicted == labels).sum().item()
    acc = correct / total
    print('[%d / %d]: Accuracy on test set: %.1f %% ' % (epoch+1, EPOCH, 100 * acc))  # 求测试的准确率，正确数/总数
    return acc


# Start train and Test --------------------------------------------------------------------------------------
if __name__ == '__main__':
    acc_list_test = []
    for epoch in range(EPOCH):
        train(epoch)
        # if epoch % 10 == 9:  #每训练10轮 测试1次
        acc_test = test()
        acc_list_test.append(acc_test)

    plt.plot(acc_list_test)
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy On TestSet')
    plt.show()

执行结果

D:\anaconda3\envs\pytorch\python.exeC:\Users\Administrator\PycharmProjects\pythonProject\test.3.py

[1, 300]: loss: 0.768 , acc: 77.79 %
[1, 600]: loss: 0.223 , acc: 93.43 %
[1, 900]: loss: 0.154 , acc: 95.50 %
[1 / 10]: Accuracy on test set: 95.8 %
[2, 300]: loss: 0.118 , acc: 96.56 %
[2, 600]: loss: 0.105 , acc: 96.92 %
[2, 900]: loss: 0.097 , acc: 97.10 %
[2 / 10]: Accuracy on test set: 97.7 %
[3, 300]: loss: 0.081 , acc: 97.59 %
[3, 600]: loss: 0.085 , acc: 97.45 %
[3, 900]: loss: 0.076 , acc: 97.63 %
[3 / 10]: Accuracy on test set: 98.1 %
[4, 300]: loss: 0.065 , acc: 97.94 %
[4, 600]: loss: 0.072 , acc: 97.86 %
[4, 900]: loss: 0.071 , acc: 97.94 %
[4 / 10]: Accuracy on test set: 98.2 %
[5, 300]: loss: 0.062 , acc: 98.21 %
[5, 600]: loss: 0.059 , acc: 98.22 %
[5, 900]: loss: 0.062 , acc: 98.10 %
[5 / 10]: Accuracy on test set: 98.6 %
[6, 300]: loss: 0.054 , acc: 98.27 %
[6, 600]: loss: 0.054 , acc: 98.23 %
[6, 900]: loss: 0.056 , acc: 98.35 %
[6 / 10]: Accuracy on test set: 98.4 %
[7, 300]: loss: 0.052 , acc: 98.49 %
[7, 600]: loss: 0.048 , acc: 98.52 %
[7, 900]: loss: 0.048 , acc: 98.45 %
[7 / 10]: Accuracy on test set: 98.6 %
[8, 300]: loss: 0.044 , acc: 98.62 %
[8, 600]: loss: 0.044 , acc: 98.67 %
[8, 900]: loss: 0.047 , acc: 98.56 %
[8 / 10]: Accuracy on test set: 98.6 %
[9, 300]: loss: 0.040 , acc: 98.81 %
[9, 600]: loss: 0.041 , acc: 98.69 %
[9, 900]: loss: 0.043 , acc: 98.56 %
[9 / 10]: Accuracy on test set: 98.7 %
[10, 300]: loss: 0.038 , acc: 98.81 %
[10, 600]: loss: 0.037 , acc: 98.81 %
[10, 900]: loss: 0.041 , acc: 98.82 %
[10 / 10]: Accuracy on test set: 98.5 %

进程已结束，退出代码为 0

【FCN论文阅读】

创新点：

【1】端到端、像素到像素训练方式下的卷积神经网络超过了所有现有语义分割方向最先进的技术。
【2】将分类网络改编为全卷积网络，并通过微调将其学习到的表征转移到分割任务中。
【3】定义了一个新的全卷积网络（FCN）用于分割，它结合了特征层次的层，并细化了输出的空间精度。
【4】通过反卷积进行上采样。
【5】通过添加跳跃架构来产生准确精细的分割结果。而且将精细层和粗层结合起来，可以让模型做出尊重全局结构的局部预测。

具体方法：

【1】构建了全卷积网络，输入任意尺寸的图像，经过有效推理和学习得到相同尺寸的输出。
【2】将当代分类网络改编为全卷积网络，并通过微调将其学习到的表征转移到分割任务中。
【3】定义了一个跳跃架构，将来自深度、粗糙层的语义信息与来自浅层、精细层的外观信息相结合，以产生准确、详细的分割。
【4】融合了跨层的特征，定义了一个非线性的局部到全局表示，对其进行了端到端的调整。
【5】通过上采样进行学习，以及与跳跃层融合结合使用。
【6】通过添加跳跃来解决输出粗糙这个问题，这些跳跃将最终预测层与具有更细步幅的较低层结合起来。

【Resnet论文阅读】

创新点：

【1】提出了一个残差学习框架，以简化比以前使用的深度大得多的网络的训练。通过引入深度残差学习框架来解决退化问题。
【2】快捷连接的引入使得网络可以通过学习残差函数来提升性能，有效地解决了深度神经网络中的退化问题。
【3】通过使用“快捷连接”，可以实现F ( x ) + x F(x)+x的公式。在这种情况下，快捷连接简单地执行恒等映射，它们的输出被添加到堆叠层的输出。

具体方法：

【1】提出了一个残差学习框架，以简化比以前使用的深度大得多的网络的训练。通过引入深度残差学习框架来解决退化问题。
【2】明确地将重新表述为参考层输入的学习残差函数，而不是学习未参的函数。
【3】不是希望每几个堆叠层直接拟合一个期望的底层映射，而是明确地让这些层拟合一个残差映射。
【4】通过步幅为2的卷积层直接执行降采样。网络以一个全局平均池化层和一个带有softmax的1000路全连接层结束。
【5】插入快捷连接，将网络转换为对应的残差版本。
【6】将构建块修改为瓶颈设计。

#学习Pytorch进入专业领域的第一次任务记录#