基于Resnet18的minist手写数字分类

项目大体实现功能：

• 数据集准备：准备MNIST数据集。这个数据集包含了手写数字的灰度图像，每张图像的大小为28x28像素。将数据集分为训练集和测试集，通常使用60,000张图像进行训练，10,000张图像用于测试。

• 模型选择：由于MNIST是一个相对简单的图像分类问题，可以选择使用较小的ResNet模型，如ResNet-18或ResNet-34。这些模型具有较少的层和参数，适合处理小规模图像。

• 模型搭建：根据选择的ResNet模型架构，搭建网络结构。ResNet的核心是残差块（residual block），可以根据网络深度使用多个残差块堆叠起来构建整个网络。

• 数据预处理：对于MNIST数据集，通常进行简单的预处理操作，如将像素值归一化到0到1之间，并将图像从灰度转换为RGB格式（因为ResNet通常接受3通道输入）。还可以添加一些数据增强技术，如随机旋转、平移和翻转，以增加数据的多样性。

• 损失函数和优化器：对于MNIST的多类别分类任务，可以选择交叉熵损失函数作为模型的损失函数。针对优化器，常见的选择是使用随机梯度下降（SGD）或Adam优化器。

• 训练模型：使用训练集对模型进行训练。需要定义适当的训练循环，包括前向传播、计算损失、反向传播和参数更新。通过调整超参数（如学习率、批次大小和训练迭代次数），优化模型的性能。

• 模型评估：使用测试集评估训练得到的模型的性能。计算模型在测试集上的准确率、精确率、召回率等指标，了解模型在未见过的数据上的表现。

  (If possible)

• 超参数调优：尝试不同的超参数组合，如学习率、批次大小、正则化参数等，通过验证集的性能来选择最佳的超参数设置。这有助于提高模型的泛化能力。

• 结果分析和改进：分析模型在训练和测试集上的表现，并尝试改进模型性能。

项目总架构：

main.py：这是项目的主要入口文件，用于执行整个训练和测试流程

model.py：这个文件包含了ResNet模型的定义。在这里定义ResNet的网络结构、残差块等

data_loader.py：这个文件负责数据集的加载和预处理。

train.py：这个文件包含训练过程的代码。编写训练循环，包括前向传播、计算损失、反向传播和参数更新等

test.py：这个文件包含测试过程的代码。在这里编写测试循环，用于评估训练好的模型在测试集上的性能。

utils.py：这个文件可以包含一些辅助函数或工具函数

config.py：配置文件 ，用于保存和管理项目的超参数、路径、模型配置。

代码(附注释)

moudel.py

实现了一个ResNet-18模型，用于图像分类。ResNet模型采用残差连接解决深层网络中的梯度消失和信息丢失问题，通过堆叠残差块构建深层网络。模型包含卷积、池化、批归一化和全连接层，能够对输入图像进行特征提取和分类预测。

from utils import *
from data_loader import *
import torch.nn as nn
import torch.nn.functional as F

class BasicBlock(nn.Module):
    expansion = 1  # 基本块的扩展系数。在ResNet中，基本块的输出通道数是输入通道数的expansion倍

    def __init__(self, in_channels, out_channels, stride=1, downsample=None):  # downsample下采样层
        super(BasicBlock, self).__init__()
        self.conv1 = conv3x3(in_channels, out_channels, stride)  # 3x3卷积层，它将输入特征图转换为具有out_channels通道数的特征图。步幅由stride参数指定
        self.bn1 = nn.BatchNorm2d(out_channels)  # 2D批归一化层，用于归一化卷积层的输出
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = conv3x3(out_channels, out_channels)
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.downsample = downsample  # 可选的下采样层，用于匹配输入和输出的维度，以便能够进行残差连接
        self.stride = stride

    def forward(self, x):
        residual = x  # 将输入x保存为residual，以便后续将其添加到卷积块的输出上，形成残差连接

        y = self.conv1(x)
        y = self.bn1(y)
        y = self.relu(y)

        y = self.conv2(y)
        y = self.bn2(y)

        if self.downsample is not None:  # 检查是否存在下采样操作
            residual = self.downsample(x)  # 果存在下采样操作，对输入x进行下采样，得到residual作为残差

        y += residual  # 将残差residual与经过卷积和批归一化后的特征图y相加，实现残差连接
        y = self.relu(y)

        return y


class ResNet(nn.Module):

    def __init__(self, block, layers, num_classes, grayscale):
        self.in_channels = 64  # 初始输入通道数为64
        if grayscale:  # 如果grayscale为True，则将输入通道数in_dim设置为1，表示灰度图像；
            in_dim = 1
        else:  # 否则，设置为3，表示RGB图像
            in_dim = 3
        super(ResNet, self).__init__()  # 调用父类nn.Module的初始化方法
        self.conv1 = nn.Conv2d(in_dim, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)  # inplace=True表示在原地执行操作，节省内存
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self._make_layer(block, 64, layers[0])  # layers->残差快数量
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
        self.avgpool = nn.AvgPool2d(7, stride=1)
        self.fc = nn.Linear(512 * block.expansion, num_classes)  # 定义全连接层fc，输入特征数量为512 * block.expansion，输出特征数量为num_classes，用于分类任务

        for m in self.modules():  # 遍历ResNet模型的所有模块
            if isinstance(m, nn.Conv2d):  # 如果当前模块是nn.Conv2d类型的
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels  # 计算卷积核的参数数量
                m.weight.data.normal_(0, (2. / n) ** .5)  # 使用计算得到的卷积核参数数量（n）来对卷积核权重进行初始化，采用的是均值为0，标准差为(2. / n) ** .5的正态分布
            elif isinstance(m, nn.BatchNorm2d):  # 如果当前模块是nn.BatchNorm2d类型的
                m.weight.data.fill_(1)  # 将批归一化层的权重初始化为1
                m.bias.data.zero_()  # 将批归一化层的偏置项初始化为0

    def _make_layer(self, block, out_channels, blocks, stride=1):  # 定义构建残差层的过程。它接受块类型block、输出通道数out_channels、块的数量blocks和步幅stride作为参数
        downsample = None
        if stride != 1 or self.in_channels != out_channels * block.expansion:  # 如果步幅不为1或输入通道数与输出通道数不匹配
            downsample = nn.Sequential(                                        # 创建下采样层downsample，由一个1x1卷积层和一个批归一化层组成(为了解决在残差连接中输入和输出尺寸不匹配的问题)
                nn.Conv2d(self.in_channels, out_channels * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels * block.expansion),
            )

        layers = []  # 初始化层列表
        layers.append(block(self.in_channels, out_channels, stride, downsample))  # 将第一个残差块添加到层列表中，并更新输入通道数
        self.in_channels = out_channels * block.expansion  # 更新输入通道数为当前输出通道数乘以块的扩展系数
        '''
           为什么第一颗残差快单独考虑：

           第一个残差块的输入是经过初始卷积操作得到的特征图，输入尺寸与后续的残差块的输入尺寸不同。

           第一个残差块之后的残差块（layer1，layer2，layer3，layer4）的输入通道数与输出通道数是一致的，因为在每个残差块内部已经通过卷积操作将输入通道数进行了调整。

           而第一个残差块的输入通道数则由初始卷积操作的输出通道数决定，通常为64。

           因此，为了适应这个特殊情况，需要单独将第一个残差块添加到层列表中，并更新self.inchannels变量，使其与第一个残差块的输出通道数保持一致。

           这样在后续的残差块中，self.inchannels的值就会与输出通道数自动匹配，确保网络的连续性和正确性。
        '''
        for i in range(1, blocks):  # 迭代构建剩余的残差块
            layers.append(block(self.in_channels, out_channels))

        return nn.Sequential(*layers)  # 将层列表转换为顺序容器nn.Sequential并返回

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)
    # 以下通过残差层向前传播
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        # because MNIST is already 1x1 here:
        # disable avg pooling
        # x = self.avgpool(x)

        x = x.view(x.size(0), -1)  # 将特征图展平为向量
        logits = self.fc(x)  # 通过全连接层计算预测的logits
        probas = F.softmax(logits, dim=1)  # 对logits进行softmax操作得到预测概率
        return logits, probas


def resnet18(num_classes):
    model = ResNet(block=BasicBlock,
                   layers=[2, 2, 2, 2],  # 有四个残差层，每个残差层都由两个块组成
                   num_classes=NUM_CLASSES,
                   grayscale=GRAYSCALE)
    return model

train.py

训练给定模型，更新模型的权重，计算损失和准确率，并在训练过程中进行打印和记录

from model import *
import time
import torch
import torch.nn.functional as F

def trainModel(model, optimizer, scheduler):

    start_time = time.time()
    for epoch in range(NUM_EPOCHS):

        model.train()  #  将模型设置为训练模式，启用Batch Normalization和Dropout层
        for batch_idx, (features, targets) in enumerate(train_loader):  # 迭代训练数据集，使用enumerate(train_loader)函数返回一个可迭代的对象，
                                                                        # 其中每次迭代返回一个包含两个元素的元组(batch_idx, (features, targets))
            features = features.to(DEVICE)
            targets = targets.to(DEVICE)

            logits, probas = model(features)  # 将输入特征features作为模型的输入，调用模型对象model进行前向传播计算
            cost = F.cross_entropy(logits, targets)
            # 清零优化器的梯度缓存
            optimizer.zero_grad()
            # 反向传播并计算梯度
            cost.backward()
            # 更新权重
            optimizer.step()

            if not batch_idx % 50:
                print('Epoch: %03d/%03d | Batch %04d/%04d | Cost: %.4f' % (epoch+1, NUM_EPOCHS, batch_idx, len(train_loader), cost))

        model.eval()  # 将模型设置为评估模式，禁用Batch Normalization和Dropout层
        with torch.set_grad_enabled(False):  # 关闭梯度计算，节省内存
            print('Epoch: %03d/%03d | Train: %.3f%%' % (
                epoch + 1, NUM_EPOCHS,
                compute_accuracy(model, train_loader, device=DEVICE)))
        scheduler.step()
        print('Time elapsed: %.2f min' % ((time.time() - start_time) / 60))

    print('Total Training Time: %.2f min' % ((time.time() - start_time) / 60))

test.py

定义了一个测试和展示模型结果的函数test_and_show。测试给定模型在测试数据集上的准确率，并展示其中第一个样本（7）的图像和模型对该样本的预测结果

from model import *
import numpy as np
import torch
import matplotlib.pyplot as plt

def test_and_show(model):
    with torch.set_grad_enabled(False):  # 关闭梯度计算。这可以节省内存，因为在测试阶段不需要计算梯度
        print('Test accuracy: %.2f%%' % (compute_accuracy(model, test_loader, device=DEVICE)))
    for batch_idx, (features, targets) in enumerate(test_loader):

        features = features
        targets = targets
        break

    nhwc_img = np.transpose(features[0], axes=(1, 2, 0))
    nhw_img = np.squeeze(nhwc_img.numpy(), axis=2)  # 从张量中挤压（squeeze）掉大小为1的维度。在这里，我们将挤压掉通道维度，得到一个形状为(H, W)的灰度图像
    plt.imshow(nhw_img, cmap='Greys')
    plt.show()

    model.eval()

    logits, probas = model(features.to(DEVICE)[0, None])  # 对第一个样本进行模型的前向传播，得到预测的logits和概率
    print('Probability 7 =  %.2f%%' % (probas[0][7] * 100))  # 获取类别7的概率值,[0] 表示取出第一个样本的预测结果,[7] 表示取出预测结果中的第 8 个元素（0在识别范围）

utils.py

第一个函数conv3x3用于创建一个3x3的卷积层。该函数接受输入通道数in_channels、输出通道数out_channels和步幅Mystride作为参数，并返回一个卷积层对象。

第二个函数compute_accuracy用于计算模型在给定数据加载器data_loader上的准确率

import torch
import torch.nn as nn


def conv3x3(in_channels, out_channels, Mystride=1):
    return nn.Conv2d(in_channels, out_channels, kernel_size=3,
                     stride=Mystride,padding=1,bias=False)


def compute_accuracy(model, data_loader, device):
    correct_pred, num_examples = 0, 0  # 记录正确预测的样本数和总样本数
    for i, (features, targets) in enumerate(data_loader):  # 使用enumerate遍历data_loader，以获取索引(i)和数据批次(features，targets)
        features = features.to(device)
        targets = targets.to(device)

        logits, probas = model(features)  # 对输入特征进行模型的前向传播，得到预测的logits和概率
        _, predicted_labels = torch.max(probas, 1)  # 在probas张量的第二个维度(dim=1)上找到最大概率的索引，表示预测的类标签。最大概率的实际值被舍弃（用_表示）
        num_examples += targets.size(0)  # 将当前批次的大小（即批次中的样本数）添加到num_examples变量中，增加总样本数
        correct_pred += (predicted_labels == targets).sum()  # 过将预测的标签与目标标签进行比较，并计算匹配的数量，统计正确预测的样本数
    return correct_pred.float() / num_examples * 100  # 通过将正确预测的样本数除以总样本数，计算准确率，并乘以100转换为百分比

config.py

一些参数放里面，方便调整

import torch

# Hyperparameters
RANDOM_SEED = 1  # 设置随机数生成器的种子
LEARNING_RATE = 0.001
BATCH_SIZE = 128
NUM_EPOCHS = 100

# Architecture
NUM_FEATURES = 28*28  # 输入数据的特征数量,MNIST数据集中的图像大小为28x28，所以特征数量为28x28=784
NUM_CLASSES = 10

# Other
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
GRAYSCALE = True  # 输入数据是否为灰度图像

dataloader.py

用PyTorch提供的torchvision.datasets和torch.utils.data.DataLoader模块加载和处理数据集

from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision import transforms
from config import *   # 引用config里全部参数

# 定义数据增强的转换操作
train_transform = transforms.Compose([
    transforms.RandomResizedCrop(32),  # 对图像进行随机裁剪，将其大小调整为指定的尺寸，随机裁剪可以提取图像的不同部分，增加数据的多样性。
    transforms.RandomHorizontalFlip(),  # 以一定的概率对图像进行随机水平翻转。通过翻转图像，可以增加数据的多样性，使模型更具鲁棒性
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5], std=[0.5])  # 对图像进行标准化处理，使其像素值在均值为0，标准差为1的范围内。标准化可以帮助模型更好地学习数据的分布，加速训练过程
])

train_dataset = datasets.MNIST(root='data',  # 指定数据集的保存路径
                               train=True,  # 加载训练集
                               transform=train_transform,  # 应用数据增强
                               download=True)  # 如果数据集不存在，则自动从网上下载数据集

test_dataset = datasets.MNIST(root='data',
                              train=False,  # 加载测试集
                              transform=transforms.ToTensor())  # 将数据转换为Tensor类型

# 数据加载器
train_loader = DataLoader(dataset=train_dataset,
                          batch_size=BATCH_SIZE,
                          shuffle=True)  # 每个epoch开始时，对数据进行洗牌，以增加训练的随机性

test_loader = DataLoader(dataset=test_dataset,
                         batch_size=BATCH_SIZE,
                         shuffle=False)

#检查数据集
'''
for images, labels in train_loader:
    print('Image batch dimensions: ', images.shape)
    print('Image label dimensions: ', labels.shape)
    break
'''

main.py

from train import *
from test import *

device = torch.device(DEVICE)
torch.manual_seed(RANDOM_SEED)

model = resnet18(NUM_CLASSES)
model.to(DEVICE)

# optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)  如果用adam优化器就不需要再设置学习率调度器了（adam自带）
# p.s用adam效果好的多..但是为了多运用一点优化技巧就手动加优化了😭

optimizer = torch.optim.SGD(model.parameters(), lr=LEARNING_RATE)  # 优化器
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)  # 学习率调度器

print("training on ", device)
trainModel(model=model, optimizer=optimizer, scheduler=scheduler)

test_and_show(model=model)