焦作市网站建设_网站建设公司_悬停效果_seo优化

一、准备工作

导入所需的依赖库：

# 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)