机器学习线性回归

小小宇宙中微子

于 2023-11-26 23:20:26 发布

阅读量981

点赞数 22

文章标签：机器学习 pytorch

本文链接：https://blog.csdn.net/m0_73887414/article/details/134635132

版权

# 导入所需的库
import numpy as np  # 用于处理数值计算的库
import torch  # 用于深度学习的库（PyTorch）
import torch.nn as nn  # 用于实现各种神经网络的库（PyTorch）

# 生成x_values和y_values
x_values = [i for i in range(11)]  # 生成一个从0到10的列表
x_train = np.array(x_values, dtype=np.float32)  # 将x_values转换为浮点数np数组
x_train = x_train.reshape(-1, 1)  # 将数组形状转换为行数为1，列数为11的二维数组
print(x_values)  # 输出x_values
print(x_train.shape)  # 输出x_train的形状

y_values = [2 * i + 1 for i in x_values]  # 生成y_values列表，每个元素是x_values中对应元素的2倍加1
y_train = np.array(y_values, dtype=np.float32)  # 将y_values转换为浮点数np数组
y_train = y_train.reshape(-1, 1)  # 将数组形状转换为行数为1，列数为11的二维数组
print(y_values)  # 输出y_values
print(y_train.shape)  # 输出y_train的形状


# 定义线性回归模型
class LinearRegressionModel(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(LinearRegressionModel, self).__init__()  # 调用父类构造函数
        self.linear = nn.Linear(input_dim, output_dim)  # 创建一个线性层

    def forward(self, x):
        out = self.linear(x)  # 传递x通过线性层
        return out  # 返回线性层的输出


# 设置输入和输出维度
input_dim = 1
output_dim = 1
model = LinearRegressionModel(input_dim, output_dim)  # 创建一个线性回归模型实例
print(torch.cuda.is_available())  # 输出是否支持GPU计算
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  # 设置设备，如果有GPU则使用GPU，否则使用CPU
model.to(device)  # 将模型移动到所选设备上


# 设置超参数
epochs = 1000  # 训练迭代次数
learning_rate = 0.01  # 学习率
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)  # 创建一个随机梯度下降优化器
criterion = nn.MSELoss()  # 创建一个均方误差损失函数


# 训练模型
for epoch in range(epochs):
    epoch += 1  # 增加 epoch 计数
    inputs = torch.from_numpy(x_train).to(device)  # 将x_train转换为张量并移动到所选设备上
    labels = torch.from_numpy(y_train).to(device)  # 将y_train转换为张量并移动到所选设备上

    optimizer.zero_grad()  # 清空上一步梯度

    outputs = model(inputs)  # 向前传播

    loss = criterion(outputs, labels)  # 计算损失
    loss.backward()  # 向后传播
    optimizer.step()  # 更新模型参数

    if epoch % 50 == 0:  # 每50个epoch打印一次损失值
        print('epoch{}, loss{}'.format(epoch, loss.item()))


# 保存和加载模型
torch.save(model.state_dict(), 'model.pkl')  # 保存模型参数
model.load_state_dict(torch.load('model.pkl'))  # 从文件加载模型参数

前置概念

1. 前向传播（forward propagation）

在深度学习中，前向传播（forward propagation）是指在神经网络中，信息从输入层传到输出层的过程。在训练神经网络时，前向传播包括以下步骤：

1. 将输入数据输入网络。
2. 网络中的每一层都执行特定的计算，并传递到下一层，直到最后一层。
3. 最后一层的输出是预测结果，也被称为假设（hypothesis）。

在每一层中，神经元接收来自前一层的输入，然后进行一些计算，例如加权求和、激活函数（如ReLU、tanh等），并将结果传递给下一层。这个过程不断重复，直到到达输出层。

前向传播的目的是计算模型对于给定输入的预测结果。在训练过程中，我们会使用一个损失函数来衡量预测结果与真实标签之间的差异，然后通过反向传播（backpropagation）来调整网络中的参数，以减小损失函数值。

2.反向传播

反向传播（backpropagation）是深度学习中一种重要的算法，用于训练神经网络。反向传播的目的是通过对损失函数进行梯度下降（gradient descent），从而调整网络中的参数，以减小损失函数值。

反向传播主要包括以下步骤：

1. 选取一个损失函数，如均方误差（Mean Squared Error，MSE），来衡量模型对于给定输入的预测结果与真实标签之间的差异。
2. 初始化网络中的参数（权重和偏置项）。通常情况下，参数会随机初始化。
3. 前向传播：将输入数据输入网络，并计算损失函数。
4. 反向传播：从输出层开始，反向计算每一层的梯度。在这个过程中，我们使用微分求导来计算损失函数关于各层参数的偏导数。
5. 参数更新：使用学习率（learning rate）和梯度来更新参数。通常情况下，我们会将参数沿着梯度的反方向进行调整，从而使损失函数减小。
6. 重复步骤3到5，直到模型收敛（即损失函数值的变化很小）或达到预设的迭代次数。

通过反向传播算法，我们可以对神经网络中的参数进行有效的优化，从而提高模型的预测性能。需要注意的是，反向传播过程中需要计算很多梯度，因此对于计算资源的需求较高。在深度学习的发展过程中，许多算法和框架都对反向传播过程进行了优化，以实现更高效的训练。

分段详解：

import numpy as np  # 用于处理数值计算的库
import torch  # 用于深度学习的库（PyTorch）
import torch.nn as nn  # 用于实现各种神经网络的库（PyTorch）

x_values = [i for i in range(11)]  # 生成一个从0到10的列表
x_train = np.array(x_values, dtype=np.float32)  # 将x_values转换为浮点数np数组
x_train = x_train.reshape(-1, 1)  # 将数组形状转换为行数为1，列数为11的二维数组
print(x_values)  # 输出x_values
print(x_train.shape)  # 输出x_train的形状

y_values = [2 * i + 1 for i in x_values]  # 生成y_values列表，每个元素是x_values中对应元素的2倍加1
y_train = np.array(y_values, dtype=np.float32)  # 将y_values转换为浮点数np数组
y_train = y_train.reshape(-1, 1)  # 将数组形状转换为行数为1，列数为11的二维数组
print(y_values)  # 输出y_values
print(y_train.shape)  # 输出y_train的形状

import numpy as np 和 import torch：导入所需的库。numpy 是一个用于处理数值计算的库，而 torch 是一个用于深度学习的库，它包含了各种用于构建和训练神经网络的模块。

x_values = [i for i in range(11)]：生成一个从0到10的列表。这是一个Python列表推导式，它生成了一个包含0到10的整数的列表。

x_train = np.array(x_values, dtype=np.float32)：将 x_values 转换为一个浮点数 numpy 数组。np.array 是一个 numpy 库中的函数，用于将输入数据转换为 numpy 数组。dtype=np.float32 设置了数组的数据类型为32位浮点数。

x_train = x_train.reshape(-1, 1)：将 x_train 数组的形状转换为行数为1，列数为11的二维数组。reshape 是一个 numpy 库中的函数，用于调整数组的形状。-1 表示自动计算数组的另一个维度，使得重塑后的数组具有与原来数组相同的元素数量。

print(x_values)：输出 x_values。

print(x_train.shape)：输出 x_train 的形状。

接下来的几行代码类似，生成了 y_values 和 y_train 数组，这里不再赘述。

class LinearRegressionModel(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(LinearRegressionModel, self).__init__()  # 调用父类构造函数
        self.linear = nn.Linear(input_dim, output_dim)  # 创建一个线性层

    def forward(self, x):
        out = self.linear(x)  # 传递x通过线性层
        return out  # 返回线性层的输出


input_dim = 1
output_dim = 1
model = LinearRegressionModel(input_dim, output_dim)  # 创建一个线性回归模型实例
print(torch.cuda.is_available())  # 输出是否支持GPU计算
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  # 设置设备，如果有GPU则使用GPU，否则使用CPU
model.to(device)  # 将模型移动到所选设备上


# 设置超参数
epochs = 1000  # 训练迭代次数
learning_rate = 0.01  # 学习率
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)  # 创建一个随机梯度下降优化器
criterion = nn.MSELoss()  # 创建一个均方误差损失函数

class LinearRegressionModel(nn.Module)：定义了一个名为 LinearRegressionModel 的类，它继承自 nn.Module。这是一个PyTorch中的抽象类，用于定义神经网络模块。

__init__：构造函数，在创建 LinearRegressionModel 的实例时被调用。它定义了一个线性层 (self.linear)，该层将输入 feature 的数量 (input_dim) 映射到输出 feature 的数量 (output_dim)。

def forward(self, x)：定义了网络的向前传播机制。这里，它只是简单地通过线性层传递输入 x，然后返回输出。

input_dim = 1 和 output_dim = 1：设置模型输入和输出的维度。在这个例子中，输入和输出都是单个特征，所以它们的维度都是1。

model = LinearRegressionModel(input_dim, output_dim)：创建了 LinearRegressionModel 的一个实例。

print(torch.cuda.is_available())：检查是否支持 GPU 计算。

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")：设置设备。如果有 GPU 可用，则使用 GPU，否则使用 CPU。

model.to(device)：将模型移动到所选设备上。

epochs = 1000：设置训练迭代次数为1000。

10.

learning_rate = 0.01：设置学习率为0.01。学习率决定了梯度下降过程中每一步更新的大小。

11.

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)：创建了一个随机梯度下降（SGD）优化器，用于在训练过程中更新模型参数。

12.

criterion = nn.MSELoss()：创建了一个均方误差（MSE）损失函数。这是回归问题中常用的损失函数之一，它度量预测值和真实值之差的平方和，然后求平均。

for epoch in range(epochs):
    epoch += 1  # 增加 epoch 计数
    inputs = torch.from_numpy(x_train).to(device)  # 将x_train转换为张量并移动到所选设备上
    labels = torch.from_numpy(y_train).to(device)  # 将y_train转换为张量并移动到所选设备上

    optimizer.zero_grad()  # 清空上一步梯度

    outputs = model(inputs)  # 向前传播

    loss = criterion(outputs, labels)  # 计算损失
    loss.backward()  # 向后传播
    optimizer.step()  # 更新模型参数

    if epoch % 50 == 0:  # 每50个epoch打印一次损失值
        print('epoch{}, loss{}'.format(epoch, loss.item()))


# 保存和加载模型
torch.save(model.state_dict(), 'model.pkl')  # 保存模型参数
model.load_state_dict(torch.load('model.pkl'))  # 从文件加载模型参数

for epoch in range(epochs)：训练循环。epochs 是在前面定义的训练迭代次数。这里使用了 PyTorch 的自动梯度系统，该系统允许你方便的构建深度学习模型并训练它们。

epoch += 1：增加 epoch 计数。一个 epoch 表示整个数据集的一次向前和向后传播过程。

inputs = torch.from_numpy(x_train).to(device)：将 x_train 转换为张量，并将其移动到所选设备上。torch.from_numpy 将 numpy 数组转换为 torch 张量，而 to 方法将张量移动到指定的设备上。

labels = torch.from_numpy(y_train).to(device)：将 y_train 转换为张量，并将其移动到所选设备上。

optimizer.zero_grad()：清空上一步梯度。在反向传播之前，需要将梯度清零，以确保每一步都是从零梯度开始。

outputs = model(inputs)：将 inputs 传递给模型进行向前传播，得到预测值 outputs。

loss = criterion(outputs, labels)：将 outputs 与真实标签 labels 进行比较，计算损失。

loss.backward()：进行反向传播。PyTorch 会自动计算损失相对于模型参数的梯度。

optimizer.step()：使用优化器（SGD）来更新模型参数。

10.

if epoch % 50 == 0：每50个 epoch 打印一次损失值。这是为了在训练过程中提供一些关于模型性能的反馈。

11.

torch.save(model.state_dict(), 'model.pkl')：将模型的参数保存到一个名为 model.pkl 的文件中。

12.

model.load_state_dict(torch.load('model.pkl'))：从文件中加载模型的参数，以便在之后的测试中使用。

总结

这代码是一段使用PyTorch框架实现线性回归模型的Python代码。首先，它定义了一个名为`LinearRegressionModel`的类，该类继承了`nn.Module`类，并定义了一个线性层。然后，它生成了一些模拟数据点`x_values`和`y_values`，并将这些数据转换为PyTorch张量。接下来，代码创建了一个`LinearRegressionModel`实例，并将其移动到选择的设备（CPU或GPU）。

在训练循环中，代码首先将输入和张量转换为所选设备，并清零梯度。然后，它通过模型的线性层传递输入，计算损失，进行反向传播，并更新模型参数。这些步骤每50个周期打印一次损失值。最后，代码使用`torch.save`保存模型参数，并使用`torch.load`加载模型参数。

小小宇宙中微子

关注

22
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
1
评论
机器学习线性回归

然后，它通过模型的线性层传递输入，计算损失，进行反向传播，并更新模型参数。在训练过程中，我们会使用一个损失函数来衡量预测结果与真实标签之间的差异，然后通过反向传播（backpropagation）来调整网络中的参数，以减小损失函数值。反向传播的目的是通过对损失函数进行梯度下降（gradient descent），从而调整网络中的参数，以减小损失函数值。在每一层中，神经元接收来自前一层的输入，然后进行一些计算，例如加权求和、激活函数（如ReLU、tanh等），并将结果传递给下一层。：增加 epoch 计数。
复制链接

扫一扫