机器学习 线性回归

# 导入所需的库
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的形状

1.

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

2.

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

3.

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

4.

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

5.

print(x_values):输出 x_values

6.

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()  # 创建一个均方误差损失函数

1.

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

2.

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

3.

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

4.

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

5.

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

6.

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

7.

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

8.

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

9.

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'))  # 从文件加载模型参数

1.

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

2.

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

3.

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

4.

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

5.

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

6.

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

7.

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

8.

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

9.

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`加载模型参数。

你可能感兴趣的:(机器学习,pytorch)