昇思25天学习打卡营第7天 | 模型训练

最新推荐文章于 2024-07-16 13:28:07 发布

loveisastory

最新推荐文章于 2024-07-16 13:28:07 发布

阅读量776

点赞数 14

分类专栏： LLM 文章标签：人工智能数据管道神经网络超参数损失函数优化器模型训练

本文链接：https://blog.csdn.net/u014255803/article/details/140080609

版权

LLM 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1. 模型训练

模型训练一般分为四个步骤：

构建数据集。
定义神经网络模型。
定义超参、损失函数及优化器。
输入数据集进行训练与评估。

我们有了数据集和模型后，可以进行模型的训练与评估。

1.1 导入依赖

# 导入依赖
# 导入mindspore库，这是华为推出的一个开源深度学习框架，用于构建和训练神经网络。
import mindspore

# 从mindspore库中导入nn模块，这个模块包含了构建神经网络所需的各种层和函数。
from mindspore import nn

# 从mindspore的dataset模块中导入vision和transforms子模块，用于数据变换。
# vision模块提供了一些常用的图像处理方法，如裁剪、翻转等。
# transforms模块提供了一些用于数据增强和预处理的函数。
from mindspore.dataset import vision, transforms
# 从mindspore的dataset模块中导入MnistDataset类，用于加载和解析MNIST数据集。
from mindspore.dataset import MnistDataset

# Download data from open datasets
# 导入download模块中的download函数，用于从互联网上下载公开的数据集。
from download import download

1.2 构建数据集

首先从数据集 Dataset下载数据，构建数据集。

# 定义一个URL变量，指向MindSpore官网提供的MNIST数据集压缩文件的地址
# MNIST是一个手写数字识别的数据集，包含60000个训练样本和10000个测试样本。
url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/" \
      "notebook/datasets/MNIST_Data.zip"

# 调用之前导入的download函数，使用该函数从指定的URL下载文件
# 第一个参数是文件的URL
# 第二个参数是下载后文件的保存路径，这里使用了当前目录（"."）作为保存路径
# 第三个参数指定了下载文件的类型，这里是"zip"表示下载的是一个ZIP压缩文件
# 第四个参数replace=True表示如果文件已经存在，将会覆盖旧的文件
path = download(url, "./", kind="zip", replace=True)

# 定义一个数据管道函数，用于加载和处理MNIST数据集
# 函数内部首先定义了一系列图像变换，包括缩放、标准化和维度转换。
# 然后，它定义了一个标签变换，将标签数据类型转换为mindspore.int32。
# 接着，函数加载MNIST数据集，并应用这些变换。
# 最后，它将数据集划分为指定批量大小的小批量数据，并返回处理后的数据集。
def datapipe(path, batch_size):
    
    # 创建一个图像变换列表，包括以下步骤：
    # 1. Rescale: 将图像像素值缩放到[0, 1]范围
    # 2. Normalize: 对图像进行标准化处理，使用MNIST数据集的均值和标准差
    # 3. HWC2CHW: 将图像的维度从Height x Width x Channel (HWC)转换为Channel x Height x Width (CHW)
    image_transforms = [
        vision.Rescale(1.0 / 255.0, 0),
        vision.Normalize(mean=(0.1307,), std=(0.3081,)),
        vision.HWC2CHW()
    ]

    # 定义一个标签变换，将标签数据类型转换为mindspore.int32
    label_transform = transforms.TypeCast(mindspore.int32)

    # 加载MNIST数据集，指定数据集的路径
    dataset = MnistDataset(path)

    # 对数据集中的图像应用之前定义的图像变换
    dataset = dataset.map(image_transforms, 'image')

    # 对数据集中的标签应用之前定义的标签变换
    dataset = dataset.map(label_transform, 'label')

    # 将数据集划分为批量大小为batch_size的小批量数据
    dataset = dataset.batch(batch_size)

    # 返回处理后的数据集
    return dataset

# 使用datapipe函数创建训练数据集，指定数据集路径和批量大小为64
train_dataset = datapipe('MNIST_Data/train', batch_size=64)

# 使用datapipe函数创建测试数据集，指定数据集路径和批量大小为64
test_dataset = datapipe('MNIST_Data/test', batch_size=64)

输出：

Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/MNIST_Data.zip (10.3 MB)

file_sizes: 100%|██████████████████████████| 10.8M/10.8M [00:00<00:00, 98.5MB/s]
Extracting zip file...
Successfully downloaded / unzipped to ./

1.3 定义神经网络模型

从网络构建中加载代码，构建一个神经网络模型。

# 定义一个神经网络类Network，它继承自mindspore.nn.Cell类，用于图像分类任务，例如MNIST手写数字识别。
# 网络结构包括一个展平层（Flatten），它将输入图像展平为一维向量，
# 然后是三个全连接层（Dense），每个全连接层后面跟着一个ReLU激活函数。
# 最后一个全连接层输出10个节点的logits，对应于10个类别的预测。
class Network(nn.Cell):
    

    def __init__(self):
        # 类的初始化方法，调用父类的初始化方法
        super().__init__()
        # 创建一个Flatten层，用于将输入的图像数据展平为一维向量
        self.flatten = nn.Flatten()
        # 创建一个SequentialCell，它包含一个层序列，用于定义神经网络的结构
        # 这个序列包括三个全连接层（Dense），每个全连接层之后是一个ReLU激活函数
        # 第一个全连接层将28*28个输入节点映射到512个节点
        # 第二个全连接层将512个节点映射到512个节点
        # 第三个全连接层将512个节点映射到10个节点，对应于10个类别的输出
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512),
            nn.ReLU(),
            nn.Dense(512, 512),
            nn.ReLU(),
            nn.Dense(512, 10)
        )

    def construct(self, x):
        # 定义网络的前向传播过程
        # 将输入x通过Flatten层展平为一维向量
        x = self.flatten(x)
        # 将展平后的向量通过之前定义的层序列（全连接层和ReLU激活函数）
        logits = self.dense_relu_sequential(x)
        # 返回最后一个全连接层的输出，即模型的logits（未归一化的预测值）
        return logits

# 创建Network类的实例，即构建了一个可以用于训练和预测的神经网络模型
model = Network()

1.4 定义超参、损失函数和优化器

1.4.1 超参

超参（Hyperparameters）是可以调整的参数，可以控制模型训练优化的过程，不同的超参数值可能会影响模型训练和收敛速度。目前深度学习模型多采用批量随机梯度下降算法进行优化，随机梯度下降算法的原理如下：

$w_{t+1}=w_{t}-\eta \frac{1}{n} \sum_{x \in \mathcal{B}} \nabla l\left(x, w_{t}\right)$

这个公式的含义是权重向量 $w$ 在时间步 $t$ 到 $t + 1$ 的更新。是通过计算学习率乘以批量B中所有样本在权重 $w_t$ 下，损失函数 $l$ 对输入 $x$ 的平均梯度得到的。

公式中， $n$ 是批量 $B$ 中的样量数量，即批量大小（batch size）， $η$ 是学习率（learning rate）。另外， $w_{t}$ 为训练轮次 $t$ 中的权重参数， $\nabla l$ 为损失函数的导数。除了梯度本身，这几个因子直接决定了模型的权重更新，从优化本身来看，它们是影响模型性能收敛最重要的参数。一般会定义以下超参用于训练：

训练轮次（epoch）：训练时遍历数据集的次数。
批次大小（batch size）：数据集进行分批读取训练，设定每个批次数据的大小。batch size过小，花费时间多，同时梯度震荡严重，不利于收敛；batch size过大，不同batch的梯度方向没有任何变化，容易陷入局部极小值，因此需要选择合适的batch size，可以有效提高模型精度、全局收敛。
学习率（learning rate）：如果学习率偏小，会导致收敛的速度变慢，如果学习率偏大，则可能会导致训练不收敛等不可预测的结果。梯度下降法被广泛应用在最小化模型误差的参数优化算法上。梯度下降法通过多次迭代，并在每一步中最小化损失函数来预估模型的参数。学习率就是在迭代过程中，会控制模型的学习进度。学习率应该足够小，以确保参数更新的方向是逐渐逼近最优解的；但同时也要足够大，以避免收敛过慢。常用的学习率有如下几种：
- 固定学习率：这种方法简单直接，但是可能不够灵活，常见的固定学习率包括0.1、0.01等。
- 自适应学习率：这种方法可以根据训练过程中的误差或梯度信息动态调整学习率。例如，Adam优化器会根据梯度的方差自动调整学习率。
- 阶梯学习率：这种方法将学习过程分为多个阶段，每个阶段采用不同的学习率。例如，开始时可以使用较大的学习率快速收敛，然后逐渐减小学习率以防止过拟合。

# 设置训练过程中的epochs数量，3意味着模型将训练三次。
# 增加epoch的数量可以增加模型的训练时间，但也可能提高模型的性能。
epochs = 3
# 设置每个批次的样本数量
# 较小的批量大小可能会导致训练过程更加不稳定，但可能有助于防止过拟合。
# 较大的批量大小可能会提供更稳定的梯度估计，但需要更多的内存。
batch_size = 64
# 设置学习率，1e-2是科学计数法表示的0.01
# 这是一个相对较高的学习率，通常在训练初期使用较高的学习率可以帮助模型快速收敛，
# 但随着训练的进行，可能会需要减小学习率以获得更好的性能。
learning_rate = 1e-2

1.4.2 损失函数

损失函数（loss function）用于评估模型的预测值（logits）和目标值（targets）之间的误差。训练模型时，随机初始化的神经网络模型开始时会预测出错误的结果。损失函数会评估预测结果与目标值的相异程度，模型训练的目标即为降低损失函数求得的误差。

常见的损失函数包括用于回归任务的nn.MSELoss（均方误差损失函数）和用于分类的nn.NLLLoss（负对数似然损失函数）等。 nn.CrossEntropyLoss 结合了nn.LogSoftmax和nn.NLLLoss，可以对logits 进行归一化并计算预测误差。

# 定义一个交叉熵损失函数，用于多类别分类任务
loss_fn = nn.CrossEntropyLoss()

1.4.3 优化器

模型优化（Optimization）是在每个训练步骤中调整模型参数以减少模型误差的过程。MindSpore提供多种优化算法的实现，称之为优化器（Optimizer）。优化器内部定义了模型的参数优化过程（即梯度如何更新至模型参数），所有优化逻辑都封装在优化器对象中。在这里，我们使用SGD（Stochastic Gradient Descent）优化器。

SGD工作原理：

随机性：与传统的批量梯度下降（Batch Gradient Descent，BGD）不同，SGD不是使用整个数据集来计算梯度，而是随机选择数据集中的一个样本或者一个小的样本子集（批量）来计算梯度。这种随机性有助于模型在训练过程中探索不同的数据点，从而可能找到更优的参数值。
梯度计算：对每个选定的样本或批量，SGD计算损失函数相对于模型参数的梯度。梯度是一个向量，其方向是函数增长最快的方向，大小是增长的速度。
参数更新：根据计算得到的梯度，SGD对模型参数进行更新。参数更新方向与梯度相反，大小由学习率决定。学习率是一个超参数，控制每次迭代中参数更新的幅度。
迭代过程：SGD重复上述步骤，每次迭代都使用随机选定的样本或批量来更新参数。随着迭代的进行，模型参数逐渐调整，以减少损失函数的值，从而提高模型的性能。

我们通过model.trainable_params()方法获得模型的可训练参数，并传入学习率超参来初始化优化器。

# 创建一个SGD优化器实例，用于训练模型，最小化损失函数
# model.trainable_params() 是一个生成器，它返回模型中所有可训练参数的列表。
# learning_rate 是SGD算法中的学习率，它控制参数更新的幅度。
# 每次迭代时，优化器会根据当前的梯度更新模型的参数
optimizer = nn.SGD(model.trainable_params(), learning_rate=learning_rate)

在训练过程中，通过微分函数可计算获得参数对应的梯度，将其传入优化器中即可实现参数优化，具体形态如下：

grads = grad_fn(inputs)

optimizer(grads)

1.5 训练与评估

设置了超参、损失函数和优化器后，我们就可以循环输入数据来训练模型。一次数据集的完整迭代循环称为一轮（epoch）。每轮执行训练时包括两个步骤：

训练：迭代训练数据集，并尝试收敛到最佳参数。
验证/测试：迭代测试数据集，以检查模型性能是否提升。

接下来我们定义用于训练的train_loop函数和用于测试的test_loop函数。
使用函数式自动微分，需先定义正向函数forward_fn，使用value_and_grad获得微分函数grad_fn。然后，我们将微分函数和优化器的执行封装为train_step函数，接下来循环迭代数据集进行训练即可。

# 定义前向传播函数
def forward_fn(data, label):
    # 使用模型对输入数据进行前向计算，得到logits
    logits = model(data)
    # 使用损失函数计算损失，输入是logits和真实标签
    loss = loss_fn(logits, label)
    # 返回损失和logits
    return loss, logits

# 获取梯度计算函数
grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)

# 定义一步训练函数
def train_step(data, label):
    # 使用梯度计算函数计算损失和梯度
    (loss, _), grads = grad_fn(data, label)
    # 使用优化器更新模型参数
    optimizer(grads)
    # 返回损失
    return loss

# 定义训练循环函数，需要传入模型和训练数据
def train_loop(model, dataset):
    # 获取训练数据集的大小
    size = dataset.get_dataset_size()
    # 设置模型为训练模式
    model.set_train()
    # 遍历数据集的生成器，创建一个迭代器
    for batch, (data, label) in enumerate(dataset.create_tuple_iterator()):
        # 执行一步训练，计算损失
        loss = train_step(data, label)

        # 如果当前批次是每100个批次打印一次损失，以便监控训练过程
        if batch % 100 == 0:
            # 将损失转换为numpy数组以便打印
            loss, current = loss.asnumpy(), batch
            # 打印损失和当前批次
            print(f"loss: {loss:>7f}  [{current:>3d}/{size:>3d}]")

test_loop函数同样需循环遍历数据集，调用模型计算loss和Accuray并返回最终结果。

# 定义测试循环函数，需要传入模型，测试数据集和损失函数
def test_loop(model, dataset, loss_fn):
    # 获取测试数据集的大小
    num_batches = dataset.get_dataset_size()
    # 设置模型为评估模式
    model.set_train(False)
    # 初始化计数器
    total, test_loss, correct = 0, 0, 0
    # 遍历数据集的生成器，创建一个迭代器
    for data, label in dataset.create_tuple_iterator():
        # 使用模型对输入数据进行前向计算，得到预测结果
        pred = model(data)
        # 累加样本数量
        total += len(data)
        # 累加损失
        test_loss += loss_fn(pred, label).asnumpy()
        # 计算正确预测的数量
        correct += (pred.argmax(1) == label).asnumpy().sum()
    # 计算平均损失
    test_loss /= num_batches
    # 计算准确率
    correct /= total
    # 打印测试结果
    print(f"Test: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

# 训练循环
for t in range(epochs):
    # 打印当前epoch的信息
    print(f"Epoch {t+1}\n-------------------------------")
    # 调用训练循环函数，传入模型和训练数据集
    train_loop(model, train_dataset)
    # 调用测试循环函数，传入模型、测试数据集和损失函数
    test_loop(model, test_dataset, loss_fn)
# 训练完成
print("Done!")