深度学习——卷积神经网络实现手写数字识别

一、准备工作

导入所需的依赖库：

# import torch
# print(torch.__version__)
 
'''
 MNIST包含70000张手写数字图像：60000用于训练，10000用于测试
 图像是灰度的，28×28像素的，并且居中的，以减少预处理和加快运行
'''
import torch
from torch import nn    #导入神经网络模块
from torch.utils.data import DataLoader  #数据包管理工具，打包数据
from torchvision import  datasets  #封装了很多与图像相关的模型，数据集
from torchvision.transforms import ToTensor  #数据转换，张量，将其他类型的数据转换为tensor张量，numpy array

torch：PyTorch 的核心包，提供张量运算和深度学习构建的基础。

nn：神经网络模块，用于搭建层结构（卷积层、全连接层等）。

DataLoader：数据加载器，可以自动打包数据，支持批量读取。

datasets：提供常用的数据集（如 MNIST、CIFAR10）。

ToTensor：将图片转换为张量格式，方便神经网络使用。

二、加载数据集

'''下载训练数据集（包含训练图片+标签）'''
training_data = datasets.MNIST(
    root="data", 
    train=True, 
    download=True, 
    transform=ToTensor(), 
)   
 
'''下载测试数据集（包含测试图片+标签）'''
test_data = datasets.MNIST(
    root="data", 
    train=False, 
    download=True, 
    transform=ToTensor(), 
)   
print(len(training_data))

三、数据可视化（非必须）

from matplotlib import  pyplot as plt
figure = plt.figure()
for i in range(9):
    img,label = training_data[i+59000]
    figure.add_subplot(3,3,i+1)
    plt.title(label)
    plt.axis("off")
    plt.imshow(img.squeeze(),cmap='gray')
    a = img.squeeze()
plt.show()

四、创建数据加载器

train_dataloader = DataLoader(training_data, batch_size=64)  # 是一个类，现在初始化了，但没开始打包，训练开始才打包
test_dataloader = DataLoader(test_data, batch_size=64)
for X, y in test_dataloader:
    print(f"Shape of X [N, C, H, W]: {X.shape}")  # N:批次大小, C:通道数(灰度图为1), H:高度, W:宽度
    print(f"Shape of y: {y.shape} {y.dtype}")     # 标签的形状和数据类型
    break

device = ("cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu")
print(f"using{device} device")

train_dataloader = DataLoader(training_data, batch_size=64)表示现在是一个类，初始化了，但没开始打包，训练开始才打包

batch_size=64：每次从数据集中读取 64 张图片作为一个批次

for X, y in test_dataloader:

print(f"Shape of X [N, C, H, W]: {X.shape}") # N:批次大小, C:通道数(灰度图为1), H:高度, W:宽度

print(f"Shape of y: {y.shape} {y.dtype}") # 标签的形状和数据类型

break # 只查看一个批次

上述代码是用来查看加载器中一个批次的数据形状

五、选择运行设备

选择选用CPU或者GPU

device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device")

• cuda：表示选择使用 NVIDIA GPU。

• mps：Apple M 系列芯片的 GPU。

• cpu：若电脑种没有 GPU，则使用 CPU

六、定义卷积神经网络（CNN）

''' 定义神经网络  类的继承这种方式'''
class CNN(nn.Module): 
    def __init__(self):   
        super(CNN,self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(1,16,3,1,1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 16, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(16, 32, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(32, 32, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2), )
        self.conv3 = nn.Sequential(
            nn.Conv2d(32, 64, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(64, 64, 3, 1, 1),
            nn.ReLU(),
        )
        self.out = nn.Linear(64*7*7,10)
 
    def forward(self,x):  
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)  
        x = x.view(x.size(0), -1) 
        output = self.out(x)
        return output
 
model = CNN().to(device)
print(model)

模型结构说明：

输入1*28*28（64 张图片作为一个批次。故 64*1*28*28）

conv1（一维）：卷积 + ReLU + 池化 → 输出 16*14*14

conv2（二维）：多层卷积 + ReLU + 池化 → 输出 32*7*7

conv3（三维）：卷积层 → 输出 64*7*7

Linear 全连接层：输入 64*7*7，输出 10（对应 0~9 的数字分类）。

七、训练函数

def train(dataloader,model,loss_fn,optimizer):
    model.train() 
    batch_size_num = 1
    for X,y in dataloader:              
        X,y = X.to(device),y.to(device) 
        pred = model.forward(X)         
        loss = loss_fn(pred,y)          
 
        optimizer.zero_grad()           
        loss.backward()                 
        optimizer.step()                
 
        loss_value = loss.item()        
        if batch_size_num %100 ==0:
            print(f"loss: {loss_value:>7f} [number:{batch_size_num}]")
        batch_size_num += 1

1. 前向传播：计算预测结果 pred。

2. 计算损失：loss_fn(pred,y)。

3. 反向传播：loss.backward() 计算梯度。

4. 参数更新：optimizer.step()

八、测试函数

def Test(dataloader,model,loss_fn):
    size = len(dataloader.dataset)  
    num_batches = len(dataloader)  
    model.eval()        
    test_loss,correct =0,0
    with torch.no_grad():       
        for X,y in dataloader:
            X,y = X.to(device),y.to(device)
            pred = model.forward(X)
            test_loss += loss_fn(pred,y).item() 
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches 
    correct /= size  
    print(f"Test result: \n Accuracy:{(100*correct)}%, Avg loss:{test_loss}")

九、定义损失函数和优化器

loss_fn = nn.CrossEntropyLoss()  
optimizer = torch.optim.Adam(model.parameters(),lr=0.005) 

• CrossEntropyLoss：常用于分类任务。

• Adam 优化器：比 SGD 收敛更快。

十、训练模型和测试

epochs = 10
for t in range(epochs):
    print(f"epoch {t+1}\n---------------")
    train(train_dataloader,model,loss_fn,optimizer)
print("Done!")
Test(test_dataloader,model,loss_fn)