小白入门Pytorch:实战训练一

东太极

于 2023-09-29 21:24:28 发布

阅读量116

点赞数

文章标签： pytorch 人工智能 python

本文链接：https://blog.csdn.net/2302_76301332/article/details/133419813

版权

本文为🔗小白入门Pytorch内部限免文章
参考本文所写记录性文章，请在文章开头注明以下内容，复制粘贴即可

🍨 本文为🔗小白入门Pytorch中的学习记录博客
🍦 参考文章：【小白入门Pytorch】mnist手写数字识别
🍖 原作者：K同学啊
K同学啊

一、前期准备¶

1.查看版本
import torch

print(torch.__version__) # 查看pytorch版本
2.0.1+cu118
2.设置GPU，哈哈哈，我没有
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

device
3.导入数据
MNIST是一个手写体数字的图片数据集，由美国国家标准与技术研究所（National Institute of Standards and Technology，NIST）发起并整理，包含来自250个不同人手写数字的图片。该数据集的收集目的是希望通过算法，实现对手写数字的识别。数据集中的图片规格为28像素×28像素，每个像素点用无符号数表示，图像大小为2828。数据集的训练集包含60000个样本，测试集包含10000个样本。

该数据集自1998年起，被广泛地应用于机器学习和深度学习领域，例如线性分类器（Linear Classifiers）、K-近邻算法（K-Nearest Neighbors）、支持向量机（SVMs）、神经网络（Neural Nets）、卷积神经网络（Convolutional Nets）等算法，用来测试算法的效果。

MNIST数据集官网提供了数据集的下载，主要包括四个文件：训练集和测试集的图片数据和标签数据。官网上的MNIST训练集标签的格式为offset，其中offset是偏置，记录这个字段起始位置在这串数据的第几个字节。

总的来说，MNIST是一个经典的手写数字数据集，被广泛应用于机器学习和深度学习领域，对于手写数字识别算法的评估和训练有着重要的意义。

原文介绍
使用dataset下载MNIST数据集，并划分好训练集与测试集

使用dataloader加载数据，并设置好基本的batch_size

⭐ torchvision.datasets.MNIST详解

torchvision.datasets是Pytorch自带的一个数据库，我们可以通过代码在线下载数据，这里使用的是torchvision.datasets中的MNIST数据集。

函数原型：
torchvision.datasets.MNIST(root, train=True, transform=None, target_transform=None, download=False)
参数说明：
root (string) ：数据地址
train (string) ：True = 训练集，False = 测试集
download (bool,optional) : 如果为True，从互联网上下载数据集，并把数据集放在root目录下。
transform (callable, optional )：这里的参数选择一个你想要的数据转化函数，直接完成数据转化
target_transform (callable,optional) ：接受目标并对其进行转换的函数/转换。
train_ds = torchvision.datasets.MNIST('data', 
                                      train=True, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)

test_ds  = torchvision.datasets.MNIST('data', 
                                      train=False, 
                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                      download=True)
想法
使用PyTorch的torchvision库来加载MNIST数据集的代码创建一个训练数据集（train_ds）和一个测试数据集（test_ds）。'data'是存储数据集的目录，'train=True'表示我们想要加载训练数据集，'transform=torchvision.transforms.ToTensor()'将数据转换为PyTorch的Tensor类型。'download=True'表示如果数据集不存在，会自动下载。

torch.utils.data.DataLoader详解

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

函数原型：

torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None, generator=None, *, prefetch_factor=2, persistent_workers=False, pin_memory_device='')

参数说明：

dataset(string) ：加载的数据集
batch_size (int,optional) ：每批加载的样本大小（默认值：1）
shuffle(bool,optional) : 如果为True，每个epoch重新排列数据。
sampler (Sampler or iterable, optional) ：定义从数据集中抽取样本的策略。可以是任何实现了 len 的 Iterable。如果指定，则不得指定 shuffle 。
batch_sampler (Sampler or iterable, optional) ：类似于sampler，但一次返回一批索引。与 batch_size、shuffle、sampler 和 drop_last 互斥。
num_workers(int,optional) ：用于数据加载的子进程数。 0 表示数据将在主进程中加载（默认值：0）。
pin_memory (bool,optional) : 如果为 True，数据加载器将在返回之前将张量复制到设备/CUDA 固定内存中。如果数据元素是自定义类型，或者collate_fn返回一个自定义类型的批次。
drop_last(bool,optional) : 如果数据集大小不能被批次大小整除，则设置为 True 以删除最后一个不完整的批次。如果 False 并且数据集的大小不能被批大小整除，则最后一批将保留。（默认值：False）
timeout(numeric,optional) : 设置数据读取的超时时间，超过这个时间还没读取到数据的话就会报错。（默认值：0）
worker_init_fn(callable,optional) ：如果不是 None，这将在步长之后和数据加载之前在每个工作子进程上调用，并使用工作 id（[0，num_workers - 1] 中的一个 int）的顺序逐个导入。（默认：None）
batch_size = 32

train_dl = torch.utils.data.DataLoader(train_ds, 
                                       batch_size=batch_size, 
                                       shuffle=True)

test_dl  = torch.utils.data.DataLoader(test_ds, 
                                       batch_size=batch_size)
# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。
imgs, labels = next(iter(train_dl))
imgs.shape
使用PyTorch库来处理MNIST数据集，并使用DataLoader来创建一个训练数据加载器和测试数据加载器。

DataLoader的目的是为了在训练和测试过程中提供可迭代的对象，以便于你可以在每个训练批次(batch)中获取数据。

batch_size = 32，这意味着在每个训练批次中，你会获取32个图像和对应的标签。

使用next(iter(train_dl))时，从训练数据加载器中获取了一个批次的数据。这个批次的数据应该是一个包含图像和标签的元组。

imgs.shape是用来获取图像数据的形状。根据你的代码，imgs应该是一个包含图像数据的张量(tensor)，其形状应该是[batch_size, channel, height, weight]。

3. 数据可视化
squeeze()函数的功能是从矩阵shape中，去掉维度为1的。例如一个矩阵是的shape是（5, 1），使用过这个函数后，结果为（5, ）。
import numpy as np

 # 指定图片大小，图像大小为20宽、5高的绘图(单位为英寸inch)
plt.figure(figsize=(20, 5)) 
for i, imgs in enumerate(imgs[:20]):
    # 维度缩减
    npimg = np.squeeze(imgs.numpy())
    # 将整个figure分成2行10列，绘制第i+1个子图。
    plt.subplot(2, 10, i+1)
    plt.imshow(npimg, cmap=plt.cm.binary)
    plt.axis('off')
import numpy as np: 这行代码导入了NumPy库，并用np作为别名。NumPy是一个用于处理数组和矩阵的库，常用于处理大规模的数据。
plt.figure(figsize=(20, 5)): 这行代码创建了一个新的图形窗口，并指定其大小为20英寸宽，5英寸高。
for i, imgs in enumerate(imgs[:20]):: 这行代码使用enumerate函数对imgs列表的前20个元素进行循环。enumerate函数会返回每个元素的索引和值。
npimg = np.squeeze(imgs.numpy()): 这行代码将imgs（应该是一个NumPy数组）转换为NumPy数组，并尝试删除额外的维度。如果imgs是一个二维数组，那么np.squeeze不会有任何效果。如果是一个一维数组，它将会尝试通过增加一个额外的维度（在第0个维度，即“行”）来转换它。
plt.subplot(2, 10, i+1): 这行代码将当前的图形窗口划分为2行10列的网格，并设置当前活动的子图为第i+1个子图。
plt.imshow(npimg, cmap=plt.cm.binary): 这行代码在当前活动的子图中显示npimg。cmap=plt.cm.binary指定了颜色映射为二值颜色映射。

二、构建简单的CNN网络

对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。

nn.Conv2d为卷积层，用于提取图片的特征，传入参数为输入channel，输出channel，池化核大小
nn.MaxPool2d为池化层，进行下采样，用更高层的抽象表示图像特征，传入参数为池化核大小
nn.ReLU为激活函数，使模型可以拟合非线性数据
nn.Linear为全连接层，可以起到特征提取器的作用，最后一层的全连接层也可以认为是输出层，传入参数为输入特征数和输出特征数（输入特征数由特征提取网络计算得到，如果不会计算可以直接运行网络，报错中会提示输入特征数的大小，下方网络中第一个全连接层的输入特征数为1600）
nn.Sequential可以按构造顺序连接网络，在初始化阶段就设定好网络结构，不需要在前向传播中重新写一遍

想法

这是一个简单卷积神经网络（Convolutional Neural Network，CNN）模型，用于图像分类任务。这个模型包含两个主要部分：特征提取网络和分类网络。

特征提取网络：由两个卷积层（conv1和conv2）和两个最大池化层（pool1和pool2）组成。第一层卷积层将输入图像的每个像素转化为32个特征，然后通过池化层减小特征图的尺寸。第二层卷积层进一步提取更高级的特征，并再次通过池化层减小特征图的尺寸。
分类网络：由两个全连接层（fc1和fc2）组成。全连接层fc1将上一级的特征图展平后转化为64维的向量，然后通过全连接层fc2将其转化为10维向量，对应10个类别。

前向传播（forward）函数定义了输入数据x在这个网络中的流动方式。首先，数据通过特征提取网络提取特征，然后将这些特征传递给全连接层进行分类。

三、训练模型¶

1. 设置超参数
loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-2 # 学习率
opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)
2. 编写训练函数

1. optimizer.zero_grad()

函数会遍历模型的所有参数，通过内置方法截断反向传播的梯度流，再将每个参数的梯度值设为0，即上一次的梯度记录被清空。

2. loss.backward()

PyTorch的反向传播(即tensor.backward())是通过autograd包来实现的，autograd包会根据tensor进行过的数学运算来自动计算其对应的梯度。

具体来说，torch.tensor是autograd包的基础类，如果你设置tensor的requires_grads为True，就会开始跟踪这个tensor上面的所有运算，如果你做完运算后使用tensor.backward()，所有的梯度就会自动运算，tensor的梯度将会累加到它的.grad属性里面去。

更具体地说，损失函数loss是由模型的所有权重w经过一系列运算得到的，若某个w的requires_grads为True，则w的所有上层参数（后面层的权重w）的.grad_fn属性中就保存了对应的运算，然后在使用loss.backward()后，会一层层的反向传播计算每个w的梯度值，并保存到该w的.grad属性中。

如果没有进行tensor.backward()的话，梯度值将会是None，因此loss.backward()要写在optimizer.step()之前。

3. optimizer.step()

step()函数的作用是执行一次优化步骤，通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的，所以在执行optimizer.step()函数前应先执行loss.backward()函数来计算梯度。

注意：optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是tensor.backward()方法产生的。
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片
    num_batches = len(dataloader)   # 批次数目，1875（60000/32）

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    
    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)
        
        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新
        
        # 记录acc与loss
        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) 返回数组 pred 在第一个轴（即行）上最大值所在的索引。这通常用于多类分类问题中，其中 pred 是一个包含预测概率的二维数组，每行表示一个样本的预测概率分布。
(pred.argmax(1) == y)是一个布尔值，其中等号是否成立代表对应样本的预测是否正确（True 表示正确，False 表示错误）。

(pred.argmax(1) == y).type(torch.float).sum().item()表示计算预测正确的样本数量，并将其作为一个标量值返回。这通常用于评估分类模型的准确率或计算分类问题的正确预测数量。

.type(torch.float)是将布尔数组的数据类型转换为浮点数类型，即将 True 转换为 1.0，将 False 转换为 0.0。
.sum()是对数组中的元素求和，计算出预测正确的样本数量。
.item()将求和结果转换为标量值，以便在 Python 中使用或打印。

解释

函数定义:

def train(dataloader, model, loss_fn, optimizer):：定义了一个名为train的函数，它接受四个参数：数据加载器dataloader、要训练的模型model、计算损失的函数loss_fn和模型参数优化器optimizer。

数据集大小和批次数:

size = len(dataloader.dataset): 这行代码获取训练集的大小，即图片的总数量。
num_batches = len(dataloader): 这行代码计算了数据加载器的长度，也就是将要处理的批次数。批次数是训练过程中将数据分批次输入模型的数量。

初始化训练损失和准确度:

train_loss, train_acc = 0, 0: 初始化两个变量，分别用于记录训练过程中的总损失和总准确度。

循环处理数据:

for X, y in dataloader:：使用数据加载器dataloader进行迭代，每次迭代返回一对(X, y)，其中X是输入数据，y是对应的标签。
X, y = X.to(device), y.to(device): 这行代码将输入数据X和标签y移动到指定设备上（通常是GPU或CPU）。

前向传播和计算损失:

pred = model(X): 将输入数据X通过模型model得到预测结果pred。
loss = loss_fn(pred, y): 使用损失函数loss_fn计算预测结果pred和真实标签y之间的损失。

反向传播和优化:

optimizer.zero_grad(): 这一行是清零优化器梯度的操作。在PyTorch中，梯度是在反向传播时累积的，因此每次训练迭代开始时，梯度应该被归零。
loss.backward(): 执行反向传播，计算损失关于模型参数的梯度。
optimizer.step(): 使用优化器自动更新模型参数。

记录损失和准确度:

train_acc += (pred.argmax(1) == y).type(torch.float).sum().item(): 这行代码计算并累积训练过程中的准确度。pred.argmax(1)返回每个输入数据的最大概率对应的类别，与真实标签y比较后得到一个布尔值，然后求和并转换为浮点数，最后取元素值得到累积的准确度。
train_loss += loss.item(): 这行代码计算并累积训练过程中的总损失。.item()将最后一个批次（可能是一个）的损失转换为Python数值。

平均损失和准确度:

train_acc /= size 和 train_loss /= num_batches: 这两行代码将累积的准确度和损失除以它们各自的总数，得到平均准确度和平均损失。
返回结果:
return train_acc, train_loss: 函数返回训练过程中的平均准确度和平均损失。

3. 编写测试函数¶

测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器
def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小，一共10000张图片
    num_batches = len(dataloader)          # 批次数目，313（10000/32=312.5，向上取整）
    test_loss, test_acc = 0, 0
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)
            
            # 计算loss
            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
解释
def test (dataloader, model, loss_fn):：定义一个名为test的函数，它接受三个参数：数据加载器dataloader、模型model和损失函数loss_fn。
size = len(dataloader.dataset): 这行代码获取测试集的大小。
num_batches = len(dataloader): 这行代码计算了数据加载器的长度，也就是将要处理的批次数。
test_loss, test_acc = 0, 0: 初始化两个变量，用于记录测试过程中的总损失和总准确度。
with torch.no_grad(): 这个上下文管理器关闭了梯度计算，这可以节省内存，因为测试阶段我们不需要计算梯度。
for imgs, target in dataloader:：对数据加载器中的每个批次进行迭代，imgs是输入数据，target是对应的标签。
imgs, target = imgs.to(device), target.to(device): 这行代码将输入数据和标签移动到指定设备上（通常是GPU或CPU）。
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(): 累积准确度。这里，target_pred.argmax(1)返回每个输入数据的最大概率对应的类别，与真实标签比较后得到一个布尔值（0或1），然后求和并转换为浮点数，最后取元素值得到累积的准确度。
test_acc /= size 和 test_loss /= num_batches: 这两行代码分别将累积的准确度和损失除以它们的总数，得到平均准确度和平均损失。
return test_acc, test_loss: 返回平均准确度和平均损失。
4. 正式训练

1. model.train()

model.train()的作用是启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和Dropout，需要在训练时添加model.train()。model.train()是保证BN层能够用到每一批数据的均值和方差。对于Dropout，model.train()是随机取一部分网络连接来训练更新参数。

2. model.eval()

model.eval()的作用是不启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和Dropout，在测试时添加model.eval()。model.eval()是保证BN层能够用全部训练数据的均值和方差，即测试过程中要保证BN层的均值和方差不变。对于Dropout，model.eval()是利用到了所有网络连接，即不进行随机舍弃神经元。

训练完train样本后，生成的模型model要用来测试样本。在model(test)之前，需要加上model.eval()，否则的话，有输入数据，即使不训练，它也会改变权值。这是model中含有BN层和Dropout所带来的的性质。
epochs     = 5
train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
    
    model.eval()
    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}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')
五，可视化

东太极

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
小白入门Pytorch:实战训练一

本文为🔗小白入门Pytorch内部限免文章参考本文所写记录性文章，请在文章开头注明以下内容，复制粘贴即可参数说明：使用PyTorch库来处理MNIST数据集，并使用来创建一个训练数据加载器和测试数据加载器。的目的是为了在训练和测试过程中提供可迭代的对象，以便于你可以在每个训练批次(batch)中获取数据。，这意味着在每个训练批次中，你会获取32个图像和对应的标签。使用时，从训练数据加载器中获取了一个批次的数据。这个批次的数据应该是一个包含图像和标签的元组。是用来获取图像数据的形状。根据你的代码，
复制链接

扫一扫