第P1周：Pytorch实现mnist手写数字识别

于 2024-09-29 11:57:44 发布
阅读量410 收藏 15
点赞数 7
分类专栏： 机器学习365学习 文章标签： pytorch 人工智能 cnn 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DLearner/article/details/142630762
版权

文章目录

FROM

  • 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
  • 🍖 原作者：K同学啊

我的环境

  • 语言环境：Python 3.8.10
  • 开发工具：Jupyter Lab
  • 深度学习环境：
    • torch==1.12.1+cu113
    • torchvision==0.13.1+cu113

1. 准备知识

1.1 检查环境

import torch  # 导入PyTorch库，用于构建深度学习模型
import torch.nn as nn  # 导入torch.nn模块，包含构建神经网络所需的类和函数
import matplotlib.pyplot as plt  # 导入matplotlib.pyplot模块，用于数据可视化
import torchvision  # 导入torchvision库，包含处理图像和视频的工具和预训练模型

# 设置硬件设备，如果有GPU则使用，没有则使用cpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  # 检查系统是否有可用的GPU，如果有则使用GPU，否则使用CPU
device  # 打印当前设备，以确认是使用GPU还是CPU

输出：
输出

1.2 数据导入

torchvision.datasets.MNIST
torchvision.datasets是Pytorch自带的一个数据库，可以通过代码在线下载数据。

这行代码是用于加载MNIST数据集的。MNIST是一个大型的手写数字数据库，常用于训练各种图像处理系统。代码中的参数含义如下：

  • root: 数据集的本地存储路径。
  • train: 布尔值，如果为True，则加载训练集；如果为False，则加载测试集。
  • transform: 一个可选的transform，用于对图像进行预处理操作，例如缩放、裁剪等。这里设置为None，表示不进行任何预处理。
  • target_transform: 一个可选的transform，用于对标签进行预处理操作。这里设置为None，表示不进行任何预处理。
  • download: 布尔值，如果为True，则从网上下载数据集并存储到root指定的路径；如果为False，则假定数据集已经存在于该路径下。
torchvision.datasets.MNIST(  # 调用torchvision中的MNIST数据集类
    root,  # 指定数据集的存储路径
    train=True,  # 指定加载训练集，如果设置为False，则加载测试集
    transform=None,  # 指定如何对图像进行预处理，例如缩放、裁剪等，这里设置为None，表示不进行预处理
    target_transform=None,  # 指定如何对标签进行预处理，这里设置为None，表示不进行预处理
    download=False  # 指定是否需要下载数据集，如果数据集已经存在于root路径下，则设置为False
)

train_ds = torchvision.datasets.MNIST(  # 创建MNIST训练集数据对象
    'data',  # 指定数据集的存储路径
    train=True,  # 指定加载训练集
    transform=torchvision.transforms.ToTensor(),  # 指定预处理操作，将图像转换为Tensor
    download=True  # 如果数据集不存在，则下载数据集
)

test_ds = torchvision.datasets.MNIST(  # 创建MNIST测试集数据对象
    'data',  # 指定数据集的存储路径
    train=False,  # 指定加载测试集
    transform=torchvision.transforms.ToTensor(),  # 指定预处理操作，将图像转换为Tensor
    download=True  # 如果数据集不存在，则下载数据集
)

输出：
[图片]

torch.utils.data.DataLoader
torch.utils.data.DataLoader是Pytorch自带的一个数据加载器，结合了数据集和取样器，并且可以提供多个线程处理数据集。

torch.utils.data.DataLoader(
    dataset,  # 要加载的数据集对象
    batch_size=1,  # 每个批次的样本数，默认为1
    shuffle=None,  # 是否在每个epoch开始时打乱数据，默认为None，根据sampler和batch_sampler的设置决定
    sampler=None,  # 定义从数据集中抽取样本的策略，如果设置了sampler，则shuffle应为False
    batch_sampler=None,  # 与sampler类似，但返回的是样本索引的批次
    num_workers=0,  # 加载数据时使用的进程数，0表示单进程，正整数表示多进程
    collate_fn=None,  # 决定如何将多个样本合并为一个批次的函数，默认为'default_collate'
    pin_memory=False,  # 如果设置为True，则在将数据从CPU传输到GPU之前，先将数据放到CUDA固定内存中
    drop_last=False,  # 如果为True，则在数据集大小不能被batch_size整除时，丢弃最后一个不完整的批次
    timeout=0,  # 如果大于0，则设置为非零超时时间，用于数据加载
    worker_init_fn=None,  # 每个工作进程启动时调用的函数
    multiprocessing_context=None,  # 用于数据加载进程的多进程上下文
    generator=None,  # 当使用随机采样时使用的随机数生成器
    *,  # 确保以下参数必须作为关键字参数传递
    prefetch_factor=2,  # 数据加载器的预取因子，用于控制预取的数据量
    persistent_workers=False,  # 如果为True，则在所有数据加载完成后，工作进程不会退出
    pin_memory_device='',  # 指定用于pin_memory的设备，默认为CPU
)
  • dataset: 你想要加载的数据集对象。
  • batch_size: 通常设置为大于1的整数，这样可以在每个批次中加载多个样本。
  • shuffle=True: 在训练过程中通常设置为True，以便每个epoch数据都是随机的。
  • num_workers: 在多核CPU上设置大于0的值可以加速数据加载。
  • collate_fn: 可以自定义，用于处理最后的数据整理。
  • pin_memory=True: 如果你在使用GPU，并且希望加速数据从CPU到GPU的传输，可以设置为True。
batch_size = 32  # 设置每个批次的大小为32

train_dl = torch.utils.data.DataLoader(  # 创建训练集的DataLoader
    train_ds,  # 使用之前创建的MNIST训练集数据对象
    batch_size=batch_size,  # 设置每个批次的大小为32
    shuffle=True  # 设置为True，以便在每个epoch开始时打乱数据
)

test_dl = torch.utils.data.DataLoader(  # 创建测试集的DataLoader
    test_ds,  # 使用之前创建的MNIST测试集数据对象
    batch_size=batch_size  # 设置每个批次的大小为32
)

# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
imgs, labels = next(iter(train_dl))  # 从训练集的DataLoader中获取一个批次的数据和标签
imgs.shape  # 打印图像数据的shape

输出：
[图片]

这段代码做了以下几件事情：

  1. 设置批次大小：将batch_size设置为32，这意味着每个批次将包含32个样本。
  2. 创建训练集DataLoader：
  • train_dl = torch.utils.data.DataLoader(...): 创建一个用于训练集的DataLoader对象。
  • train_ds: 使用之前创建的MNIST训练集数据对象。
  • batch_size=batch_size: 设置每个批次的大小为32。
  • shuffle=True: 设置为True，以便在每个epoch开始时打乱数据。
  1. 创建测试集DataLoader：
  • test_dl = torch.utils.data.DataLoader(...): 创建一个用于测试集的DataLoader对象。
  • test_ds: 使用之前创建的MNIST测试集数据对象。
  • batch_size=batch_size: 设置每个批次的大小为32。
  1. 查看数据格式：
  • imgs, labels = next(iter(train_dl)): 从训练集的DataLoader中获取一个批次的数据和标签。
  • imgs.shape: 打印图像数据的shape，以查看数据的维度。
    对于MNIST数据集，图像是灰度的，所以channel为1，height和weight都是28。因此，imgs的形状应该是[32, 1, 28, 28]，其中32是批次大小，1是通道数，28x28是图像的尺寸。

1.3 数据可视化

squeeze()函数的功能是从矩阵shape中，去掉维度为1的。例如一个矩阵是的shape是（5, 1），使用过这个函数后，结果为（5, ）。

import numpy as np  # 导入NumPy库，用于进行科学计算

# 指定图片大小，图像大小为20宽、5高的绘图(单位为英寸inch)
plt.figure(figsize=(20, 5))  # 设置绘图窗口的大小

for i, imgs in enumerate(imgs[:20]):  # 遍历前20张图像
    # 维度缩减，将图像的维度从[1, 28, 28]变为[28, 28]
    npimg = np.squeeze(imgs.numpy())  # 使用numpy.squeeze()函数去除单维度条目

    # 将整个figure分成2行10列，绘制第i+1个子图。
    plt.subplot(2, 10, i+1)  # 创建子图，2行10列的布局，当前是第i+1个位置

    # 显示图像，cmap=plt.cm.binary表示使用二值颜色映射
    plt.imshow(npimg, cmap=plt.cm.binary)

    # 关闭坐标轴
    plt.axis('off')

# 显示绘制的图像

输出：
[图片]

2. 构建简单的CNN网络

卷积神经网络（CNN）是一种深度学习模型，广泛应用于图像识别、分类和分割等任务。下面是一些主要组件的详细说明：

  1. 卷积层 (nn.Conv2d)
  • 作用：用于提取图像的特征。通过学习图像中局部区域的特征，卷积层可以捕捉到图像的局部特征。
  • 参数：
    • in_channels：输入图像的通道数（例如，RGB图像的通道数为3）。
    • out_channels：输出图像的通道数，即卷积核（过滤器）的数量。
    • kernel_size：卷积核的大小，通常是一个元组或整数，如(3, 3)。
  1. 池化层 (nn.MaxPool2d)
  • 作用：用于降低特征图的空间尺寸，减少计算量和防止过拟合。池化层通常跟在卷积层后面。
  • 参数：
    • kernel_size：池化窗口的大小。
  1. 激活函数 (nn.ReLU)
  • 作用：引入非线性，使得模型可以学习和模拟更复杂的函数。ReLU（Rectified Linear Unit）是最常用的激活函数之一，定义为f(x) = max(0, x)。
  • 优点：计算简单，收敛速度快。
  1. 全连接层 (nn.Linear)
  • 作用：在CNN中，全连接层通常用于最终的分类或回归任务。在特征提取的最后阶段，全连接层将学习到的高级特征映射到最终的输出类别。
  • 参数：
    • in_features：输入特征的数量。
    • out_features：输出特征的数量，即类别数或你想要的输出维度。
  1. 序列模型 (nn.Sequential)
  • 作用：按顺序包含一系列的模块，使得模型的构建更加直观和简单。在nn.Sequential中定义的模块将按照它们被添加的顺序执行。
  • 用法：非常适合构建简单的线性堆叠模型。
    [图片]
import torch.nn.functional as F  # 导入PyTorch的函数库，用于提供一些常用的函数，如ReLU和池化操作

num_classes = 10  # 定义图片的类别数，例如在MNIST数据集中有10个数字类别

class Model(nn.Module):  # 定义一个名为Model的类，继承自nn.Module
    def __init__(self):  # 类的初始化函数
        super().__init__()  # 调用父类的初始化函数
        # 特征提取网络
        # 添加第一层卷积层，输入通道数为1，输出通道数为32，卷积核大小为3x3
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3) 
        # 添加第一层池化层，池化核大小为2x2 
        self.pool1 = nn.MaxPool2d(2)    
        # 添加第二层卷积层，输入通道数为32，输出通道数为64，卷积核大小为3x3                
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3) 
        # 添加第二层池化层，池化核大小为2x2
        self.pool2 = nn.MaxPool2d(2)                 
        
        # 分类网络
        # 添加第一层全连接层，输入特征数为1600，输出特征数为64
        self.fc1 = nn.Linear(1600, 64) 
        # 添加第二层全连接层，输入特征数为64，输出特征数为类别数         
        self.fc2 = nn.Linear(64, num_classes)  

    # 前向传播
    def forward(self, x):  # 定义前向传播函数
        # 通过第一层卷积层，然后应用ReLU激活函数，最后通过第一层池化层
        x = self.pool1(F.relu(self.conv1(x)))  
        # 通过第二层卷积层，然后应用ReLU激活函数，最后通过第二层池化层
        x = self.pool2(F.relu(self.conv2(x)))  

        x = torch.flatten(x, start_dim=1)  # 将特征图展平为一维向量，以便输入到全连接层

        x = F.relu(self.fc1(x))  # 通过第一层全连接层，并应用ReLU激活函数
        x = self.fc2(x)  # 通过第二层全连接层，得到最终的分类结果

        return x  # 返回网络的输出

首先通过两个卷积层和池化层来提取图像的特征，然后将特征图展平，并通过两层全连接层进行分类。F.relu用于应用ReLU激活函数，torch.flatten用于将多维特征图展平为一维向量。最后，模型输出一个长度为num_classes的向量，表示每个类别的预测概率。
代码中self.fc1的输入特征数设置为1600，这是基于假设的输入特征图大小。实际的输入特征数需要根据卷积层和池化层之后的输出特征图大小来确定。如果输入图像的尺寸或网络结构发生变化，这个数值可能需要相应地调整。
打印并加载模型：

from torchinfo import summary  # 导入summary函数，这个函数可以打印出模型的详细信息。

# 将模型转移到GPU中（我们模型运行均在GPU中进行）
model = Model().to(device)  # 创建模型实例并将其转移到之前定义的设备（GPU或CPU）

summary(model)  # 打印模型的摘要

输出：
在这里插入图片描述

3. 模型训练

3.1 设置超参数

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-2 # 学习率
opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)
  • nn.CrossEntropyLoss() 是PyTorch中的交叉熵损失函数，它通常用于多分类问题。这个损失函数结合了nn.LogSoftmax()和nn.NLLLoss()，即它首先应用对数softmax函数，然后计算负对数似然损失（Negative Log Likelihood Loss）。
  • 学习率是优化算法中的一个重要参数，它决定了模型在训练过程中参数更新的幅度。如果学习率设置得过大，可能会导致训练过程中的梯度爆炸，从而无法收敛；如果学习率设置得过小，可能会导致训练过程缓慢，甚至陷入局部最优。
  • torch.optim.SGD 是PyTorch中的随机梯度下降（Stochastic Gradient Descent）优化器。
  • model.parameters() 是一个生成器，它返回模型中所有可训练的参数。
  • lr=learn_rate 设置优化器的学习率为之前定义的learn_rate。

3.2 训练函数

  1. optimizer.zero_grad()
  • 这个函数用于清零（重置）模型所有参数的梯度。在PyTorch中，梯度是累加的，因此每次进行参数更新前，都需要将梯度清零，以避免将上次迭代的梯度累积到本次迭代中。
  • 这一步通常在每次迭代的开始进行，以确保每次计算的梯度都是当前批次数据的梯度，而不是累积的梯度。
  1. loss.backward()
  • 这个函数用于进行反向传播。在PyTorch中，当您对一个Tensor调用.backward()方法时，会自动计算这个Tensor的梯度，并且沿着计算图反向传播，直到所有的叶子节点（即模型的参数）。
  • loss.backward()会将损失函数关于模型参数的梯度计算出来，并将这些梯度保存到对应参数的.grad属性中。
  • 需要注意的是，只有设置了requires_grad=True的Tensor才会在反向传播中计算梯度。
  1. optimizer.step()
  • 这个函数用于根据计算出的梯度更新模型的参数。在调用optimizer.step()之前，需要确保已经调用了loss.backward()来计算梯度。
  • optimizer.step()会根据优化器的算法（例如SGD、Adam等）和学习率来更新参数的值，实现模型的学习。
    optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是tensor.backward()方法产生的。
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小，例如MNIST数据集有60000张图片
    # 计算批次数目，例如MNIST数据集有60000张图片，批次大小为32，则有1875个批次
    num_batches = len(dataloader)  

    train_loss, train_acc = 0, 0  # 初始化训练损失和准确率
    
    for X, y in dataloader:  # 遍历数据加载器，获取每个批次的图片和标签
        X, y = X.to(device), y.to(device)  # 将图片和标签转移到指定的设备（GPU或CPU）
        
        # 计算预测误差
        pred = model(X)          # 前向传播，获取模型的预测输出
        loss = loss_fn(pred, y)  # 计算模型预测输出和真实标签之间的损失
        
        # 反向传播和优化
        optimizer.zero_grad()   # 清零模型参数的梯度
        loss.backward()         # 反向传播，计算梯度
        optimizer.step()        # 根据梯度更新模型参数
        
        # 记录准确率和损失
        # 计算预测正确的数量
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()  # 累加损失值
            
    train_acc  /= size   # 计算平均准确率
    train_loss /= num_batches   # 计算平均损失

    return train_acc, train_loss  # 返回训练过程中的平均准确率和平均损失

pred.argmax(1) == y 计算的是预测类别是否与真实类别一致，结果是一个布尔类型的Tensor，当预测正确时为 True，预测错误时为False。通过 .type(torch.float) 将其转换为浮点数，这样就可以进行求和操作，得到正确预测的数量。最后，将正确预测的数量除以数据集的总大小，得到平均准确率。

3.3 测试函数

def test(dataloader, model, loss_fn):

# 测试集的大小，例如MNIST数据集有10000张图片
    size = len(dataloader.dataset)  
    # 计算批次数目，例如10000张图片，批次大小为32，则有312.5个批次，实际取整为313
    num_batches = len(dataloader)    
    

    test_loss, test_acc = 0, 0  # 初始化测试损失和准确率
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():  # 使用torch.no_grad()上下文管理器，停止计算和存储梯度
        for imgs, target in dataloader:  # 遍历数据加载器，获取每个批次的图片和标签
            # 将图片和标签转移到指定的设备（GPU或CPU）
            imgs, target = imgs.to(device), target.to(device)
            
            # 计算损失
            target_pred = model(imgs)  # 前向传播，获取模型的预测输出
            loss = loss_fn(target_pred, target)  # 计算模型预测输出和真实标签之间的损失
            
            test_loss += loss.item()  # 累加损失值
            # 计算预测正确的数量
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()  

    test_acc /= size  # 计算平均准确率
    test_loss /= num_batches  # 计算平均损失

    return test_acc, test_loss  # 返回测试过程中的平均准确率和平均损失

with torch.no_grad(): 是一个上下文管理器，它告诉PyTorch在该块内部不跟踪梯度，因此不会计算梯度，这样可以减少内存消耗并加速计算。因为在测试过程中，我们不需要进行反向传播和参数更新。
target_pred.argmax(1) == target 计算的是预测类别是否与真实类别一致，结果是一个布尔类型的Tensor，当预测正确时为 True，预测错误时为 False。通过 .type(torch.float) 将其转换为浮点数，这样就可以进行求和操作，得到正确预测的数量。最后，将正确预测的数量除以数据集的总大小，得到平均准确率。

3.4 训练

# 设置训练周期数为5
epochs = 5

# 初始化用于存储每个epoch训练损失的列表
train_loss = []
# 初始化用于存储每个epoch训练准确率的列表
train_acc = []
# 初始化用于存储每个epoch测试损失的列表
test_loss = []
# 初始化用于存储每个epoch测试准确率的列表
test_acc = []

# 开始训练循环
for epoch in range(epochs):
    # 设置模型到训练模式
    model.train()
    # 训练模型，并返回当前epoch的训练准确率和损失
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
    
    # 设置模型到评估模式
    model.eval()
    # 测试模型，并返回当前epoch的测试准确率和损失
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    
    # 将训练准确率和损失添加到对应的列表中
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    # 将测试准确率和损失添加到对应的列表中
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    
    # 定义输出格式模板
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}')
    # 打印当前epoch的进度信息
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
# 训练完成后打印'Done'
print('Done')

输出：
在这里插入图片描述

4. 结果可视化

import matplotlib.pyplot as plt  # 导入matplotlib的pyplot模块，用于数据可视化
# 隐藏警告
import warnings
warnings.filterwarnings("ignore")  # 忽略警告信息，避免绘图时出现警告提示

# 设置matplotlib的配置参数
plt.rcParams['font.sans-serif'] = ['SimHei']  # 设置中文字体，使得图表可以正常显示中文
plt.rcParams['axes.unicode_minus'] = False    # 设置正常显示负号
plt.rcParams['figure.dpi'] = 100               # 设置图像的分辨率

epochs_range = range(epochs)  # 创建一个从0到epochs-1的范围，用于x轴的刻度

# 设置图像大小
plt.figure(figsize=(12, 3))
# 创建一个1行2列的子图布局，并定位到第1个子图
plt.subplot(1, 2, 1)

# 在第1个子图上绘制训练和测试的准确率曲线
plt.plot(epochs_range, train_acc, label='Training Accuracy')  # 绘制训练准确率
plt.plot(epochs_range, test_acc, label='Test Accuracy')       # 绘制测试准确率
plt.legend(loc='lower right')  # 添加图例，位置在右下角
plt.title('Training and Validation Accuracy')  # 设置子图的标题

# 创建一个1行2列的子图布局，并定位到第2个子图
plt.subplot(1, 2, 2)
# 在第2个子图上绘制训练和测试的损失曲线
plt.plot(epochs_range, train_loss, label='Training Loss')  # 绘制训练损失
plt.plot(epochs_range, test_loss, label='Test Loss')       # 绘制测试损失
plt.legend(loc='upper right')  # 添加图例，位置在右上角
plt.title('Training and Validation Loss')  # 设置子图的标题

# 显示绘制的图像
plt.show()

输出：
[图片]

5. 神经网络程序说明

在这里插入图片描述

DLearner
关注
专栏目录
Pytorch入门实战 | 第P1周：实现mnist手写数字识别
“365天深度学习训练营”报名进行中～
09-17 2118
可以起到特征提取器的作用，最后一层的全连接层也可以认为是输出层，传入参数为输入特征数和输出特征数（输入特征数由特征提取网络计算得到，如果不会计算可以直接运行网络，报错中会提示输入特征数的大小，下方网络中第一个全连接层的输入特征数为1600）更具体地说，损失函数loss是由模型的所有权重w经过一系列运算得到的，若某个w的requires_grads为True，则w的所有上层参数（后面层的权重w）的.grad_fn属性中就保存了对应的运算，然后在使用。，否则的话，有输入数据，即使不训练，它也会改变权值。
深度学习第P1周：Pytorch实现mnist手写数字识别
weixin_43414521的博客
06-25 1201
- **🍨 本文为中的学习记录博客📌第P1周：实现mnist手写数字识别📌🍻拔高（可选）这是第一篇教案，也是深度学习的入门案例，我们或许可以按照下面的步骤进行学习。
深度学习训练营第P1周：Pytorch实现mnist手写数字识别
qq_36142659的博客
05-24 826
这个项目使我初步了解了pytorch的使用，和初步应用了cnn进行图片分类，初步了解了cnn的原理。
(深度学习记录）第P1周：Pytorch实现mnist手写数字识别
liuyiqi1的博客
04-26 217
第P1周的学习主要集中在使用PyTorch框架实现了经典的MNIST手写数字识别任务。通过这个项目，我学到了如何用PyTorch加载和预处理数据集、构建神经网络模型、定义损失函数和优化器，并进行模型训练和评估。
Pytorch实战 | 第P1周：实现mnist手写数字识别
weixin_47272689的博客
11-18 511
Pytorch实战
深度学习pytorch实战第P1周：实现mnist手写数字识别
m0_55259388的博客
03-28 1752
（2）自己摆烂太久了，自驱力太差，要改正，自己要有计划（3）希望自己能端正心态，好好的去学，坚持下去MNIST手写数字数据集来源于是美国国家标准与技术研究所，是著名的公开数据集之一。（下载后需解压）。我们一般会采用这行代码直接调用，这样就比较简单MNIST手写数字数据集中包含了70000张图片，其中60000张为训练数据，10000为测试数据，70000张图片均是28*28，数据集样本如下：如果我们把每一张图片中的像素转换为向量，则得到长度为28*28=784的向量。因此我们可以把训练集看成是一个。
第一周：使用PyTorch实现mnist手写数字识别
weixin_47918905的博客
03-26 669
MNIST手写数字数据集来源于是美国国家标准与技术研究所，是著名的公开数据集之一。数据集中的数字图片是由250个不同职业的人纯手写绘制，数据集获取的网址为：MNIST handwritten digit database, Yann LeCun, Corinna Cortes and Chris Burges（下载后需解压）。MNIST手写数字数据集中包含了70000张图片，其中60000张为训练数据，10000为测试数据，70000张图片均是28*28。
Pytorch入门实战第一周：实现mnist手写数字识别
weixin_46620278的博客
03-12 1228
🍨本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客K同学啊语言：python3、Pytorch框架编辑器：pycharm2020深度学习环境：torch1.12.1+cu113torchvision.datasets是Pytorch自带的数据库，用户可以通过代码在线下载数据，这里使用的是torchvision.datasets中的MNIST数据集参数说明：root。
深度学习第P1周： 实现mnist手写数字识别
a52022920的专栏
09-27 1331
365天深度学习训练营-第P1周： 实现mnist手写数字识别
深度学习第2周：用PyTorch进行Mnist手写数字识别
BingxxXXxx的博客
03-30 428
定义了一个名为ConvNet的卷积神经网络模型，包含两个卷积层、一个最大池化层和一个全连接层。nn.Module 是 PyTorch 中的一个类，用于定义神经网络模型。所有的神经网络模型都应该继承自 nn.Module 类，并实现init和 forward 方法。init方法用于初始化模型的各个层，而 forward 方法定义了模型的前向传播过程。通过继承 nn.Module 类，我们可以方便地使用 PyTorch 提供的各种层和函数来构建自己的神经网络模型。
第P1周：实现mnist手写数字识别，我的练习心得
m0_68797203的博客
05-15 174
train_acc +=(pred.argmax(1)==y).type(torch.float).sum().item()#type(torch.float)将类型改为tensor的浮点型，pred.argmax(1)表示输出概率最大的pred。在训练过程中，通常需要将训练数据分成多个批次进行处理，可以使用 next(iter()) 操作从数据集迭代器中获取每个批次的数据。nping=np.squeeze(imgs.numpy())#将矩阵中维度为1的去掉，从(1, 28, 28)变成(28, 28)
59 双向循环神经网络_by《李沐:动手学深度学习v2》pytorch版
buyaotutou的博客
09-28 463
双向循环神经网络通过反向更新的隐藏层来利用方向时间信息通常用来对序列抽取特征、填空，而不是预测未来提出的，。让我们看看这样一个网络的细节。对于任意时间步ttt，给定一个小批量的输入数据Xt∈Rn×dXt​∈Rn×d（样本数nnn，每个示例中的输入数ddd），并且令隐藏层激活函数为ϕ\phiϕ。在双向架构中，我们设该时间步的前向和反向隐状态分别为H→t∈Rn×hHt​∈Rn×h和H←t∈Rn×。
Pytorch实现Transformer
2301_81989837的博客
09-24 866
首先实现这个部分是因为不论解码器还是编码器都需要这一部分。首先我们假设归一化（LayerNorm）已经做好了。因为我们不确定是Encoder还是Decoder，所以用sublayer传入来作为上一层。接下来实现LayerNorm这一串代码很简单，就是公式的实现而已，注意要把a_2和b_2作为可以学习的变量。
新手小白怎么通过云服务器跑pytorch？
petaexpress的博客
09-25 376
安装PyTorch的步骤可以根据不同的操作系统和需求有所差异，通过云服务器运行PyTorch的过程主要包括选择GPU云服务器平台、配置服务器环境、部署和运行PyTorch模型、优化性能等步骤。
PyTorch自定义学习率调度器实现指南
deephub
09-25 4385
实现自定义学习率调度器后，下一步是将其集成到训练流程中。# 定义模型（此处使用简单的线性模型作为示例）# 初始化优化器# 初始化自定义学习率调度器# 训练循环# 在每个epoch结束时更新学习率# 记录当前学习率（用于监控）定义模型和优化器。使用之前实现的初始化学习率调度器。在每个训练epoch中：- 执行标准的前向传播、损失计算和反向传播步骤。- 调用更新模型参数。- 在epoch结束时调用更新学习率。使用获取并记录当前学习率，用于监控训练过程。
pytorch千问模型源码分析
LIjin_1006的博客
09-28 578
self.num_key_value_groups = self.num_heads // self.num_key_value_heads # 比例。# (b,h,q_len,dk)-->(b,h,q_len,h,dk),之后.contiguous()转为内存连续存储。# (b,q_len,q_h,dk)-->(b,q_h,q_len,dk),transpose:换轴(转置)# 用于生成旋转位置嵌入。# 键/值序列长度：kv_seq_len 是键和值向量的长度，这是因为键和值向量代表的是相同的序列。
动手学深度学习（李沐）PyTorch 第 4 章 多层感知机
m0_51448653的博客
09-28 712
实现这一惩罚最方便的方法是对所有项求平方后并将它们求和。参数：w：通常是神经网络的权重向量（或矩阵），也可以是任何需要正则化的参数。w 是一个 torch.Tensor 对象，它可以是模型中的权重张量。w.pow(2)：w.pow(2) 表示对张量 w 中的每个元素进行 平方运算。实际上，这等价于对张量 w 中每个权重求平方：w^2=w x w这个操作是逐元素的，生成一个新的张量，其元素是原来w中每个元素的平方。是对w.pow(2)结果的所有元素进行 求和。这个操作会返回一个标量。
PyTorch 模型保存与加载的三种常用方式
最新发布
Hoper-J的博客
09-28 400
训练一个神经网络可能需要数小时甚至数天的时间，你需要认知到一点：时间是非常宝贵的，目前3090云服务器租赁一天的价格为 37.92 元。如果你的代码没有保存模型的模块，那就先不要开始，因为不保存基本等于没跑，你的效果再好也没有办法直接呈现给别人。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值