【机器学习】中参数是怎么被训练的

在机器学习中，参数的训练过程通常是通过优化算法进行的。一般有以下几个步骤：

1.初始化参数：

首先，需要为模型的参数赋初值。这可以是随机初始化或者使用一些预训练的权重。

2.前向传播：

使用当前参数对训练数据进行前向传播，计算模型的输出。这个输出与实际标签之间的差距通常由损失函数来衡量。

3.计算损失：

损失函数度量模型输出与实际标签之间的差异。优化的目标是最小化这个损失。

4.反向传播：

反向传播是通过链式法则计算损失对参数的梯度。梯度是损失函数对于参数的变化率，它告诉我们应该朝着哪个方向更新参数以减小损失。

5.参数更新：

使用梯度下降或其他优化算法来更新参数。梯度下降通过沿着梯度的反方向调整参数，从而使损失减小。

6.重复步骤2到步骤5

直到模型收敛或达到预定的训练轮数。
这个过程中，学习率是一个关键的超参数。学习率决定了在每次迭代中参数更新的幅度。如果学习率过大，可能会导致模型无法收敛；如果学习率过小，训练可能会非常缓慢。

一个例子

让我们以一个简单的线性回归模型为例子来说明参数在训练过程中的不断改变过程。线性回归模型的目标是拟合数据集中的点到一条直线上。
假设我们有一个简单的数据集，包含一些(x, y)的点：

数据集：
(1, 2)
(2, 3)
(3, 4)

我们的线性回归模型的方程为 y = mx + b，其中 m 是斜率，b 是截距。我们的目标是找到最佳的 m 和 b，使得模型能够很好地拟合这些点。

初始化参数：

随机选择一些初始值，比如 m = 1 和 b = 0。

前向传播：

使用当前参数进行前向传播，计算模型的预测输出。对于每个数据点 (x, y)，我们计算 y_pred = mx + b。

计算损失：

使用损失函数（例如均方误差）计算模型预测值与实际值之间的差异，即损失。

反向传播：

计算损失对参数 m 和 b 的梯度，表示损失函数关于这些参数的变化率。

参数更新：

使用梯度下降更新参数。新的参数值可以通过当前参数减去学习率乘以梯度得到。
例如，m_new = m - learning_rate * gradient_m，b_new = b - learning_rate * gradient_b。

重复：

重复步骤2到步骤5，直到模型收敛或达到预定的训练轮数。

在每次迭代中，参数 m 和 b 都会根据梯度下降不断更新，使得模型逐渐逼近数据集中的点。这个过程会一直持续，直到达到停止条件为止。最终，模型的参数将调整到能够最好地拟合数据的值。

代码实现

第一个版本为 不调用pytorch 的版本

import numpy as np

# 生成简单的数据集
X = np.array([1, 2, 3])
y = np.array([2, 3, 4])

# 初始化参数
m = 1  # 初始斜率
b = 0  # 初始截距
learning_rate = 0.01  # 学习率
epochs = 1000  # 训练轮数

# 训练模型
for epoch in range(epochs):
    # 前向传播
    y_pred = m * X + b
    
    # 计算损失（均方误差）
    loss = np.mean((y_pred - y)**2)
    
    # 反向传播，计算梯度
    gradient_m = np.mean(2 * X * (y_pred - y))
    gradient_b = np.mean(2 * (y_pred - y))
    
    # 参数更新
    m = m - learning_rate * gradient_m
    b = b - learning_rate * gradient_b
    
    # 打印每轮的损失
    if epoch % 100 == 0:
        print(f"Epoch {epoch}, Loss: {loss}")

# 打印最终的参数值
print(f"Final parameters: m = {m}, b = {b}")

第二个版本为 调用pytorch中forward函数 的版本

import torch
import torch.nn as nn
import torch.optim as optim

# 转换数据为PyTorch张量
X = torch.tensor([1, 2, 3], dtype=torch.float32).view(-1, 1)
y = torch.tensor([2, 3, 4], dtype=torch.float32).view(-1, 1)

# 定义线性回归模型
class LinearRegression(nn.Module):
    def __init__(self):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(1, 1)  # 输入维度为1，输出维度为1

    def forward(self, x):# 此处定义了模型返回一个线性层，注意此线性层中的参数a、b是随机初始化的
        return self.linear(x)  
# 初始化模型、损失函数和优化器
model = LinearRegression()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
epochs = 1000
for epoch in range(epochs):
    # 前向传播
    y_pred = model(X)

    # 计算损失
    loss = criterion(y_pred, y)

    # 反向传播和参数更新
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    # 打印每轮的损失
    if epoch % 100 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item()}")

# 打印最终的参数值
with torch.no_grad():
    for name, param in model.named_parameters():
        print(f"{name}: {param.item()}")

注意在使用pytorch的版本中

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

这三句代码是使用PyTorch进行反向传播和参数更新的关键步骤，它们分别对应于：

optimizer.zero_grad(): 将模型参数的梯度归零。在PyTorch中，梯度是在反向传播过程中累积的，因此在每次迭代之前需要清零梯度，以避免梯度叠加。

loss.backward(): 执行反向传播。这一步计算损失相对于模型参数的梯度。PyTorch中的autograd模块会自动跟踪所有在张量上执行的操作，并构建计算图，从而使得可以轻松地计算梯度。

optimizer.step(): 根据梯度更新模型参数。优化器根据计算得到的梯度来更新模型的权重和偏置，从而降低损失。

这些步骤共同构成了训练循环的一次迭代。在整个训练过程中，这些步骤会被重复执行多次，直到模型收敛到一个较好的状态或者达到指定的训练轮数。

反向传播和前向传播

前向传播和反向传播是深度学习中训练神经网络的两个基本步骤，它们分别用于计算模型的输出和调整模型的参数。以下是它们的区别：

前向传播（Forward Propagation）：

定义： 在前向传播中，输入数据通过网络的各层，逐层进行计算，直到产生最终的输出。这是模型从输入到输出的正向流程。

过程： 对于每一层，前向传播将输入通过权重矩阵的乘法，加上偏置，然后应用激活函数，产生下一层的输入。这一过程一直持续到达输出层，产生最终的预测结果。
目的： 前向传播的目的是计算模型的预测输出，以便与真实标签比较并计算损失。

反向传播（Backward Propagation）：

定义： 反向传播是训练模型的过程，通过计算损失函数对模型参数的梯度，然后利用梯度下降等优化算法来调整模型参数。
过程： 反向传播从损失函数开始，计算损失函数对每个模型参数的偏导数（梯度）。然后，这些梯度信息反向传播回模型的每一层，用于调整权重和偏置。
目的： 反向传播的目的是根据损失来调整模型参数，使得模型的输出更接近真实标签，从而最小化损失。
在训练过程中，前向传播和反向传播交替进行多次。前向传播计算模型的预测输出和损失，而反向传播使用损失计算梯度并更新模型参数。这个迭代的过程一直进行，直到模型达到令人满意的性能。