使用PyTorch进行线性回归

线性回归是机器学习中的一种基础算法，其目的是拟合一条直线来预测一个连续的目标变量。 在本教程中，我们将使用PyTorch来实现一个简单的线性回归模型。

数据集

我们将使用一个由两个特征和一个目标变量组成的数据集。我们可以使用NumPy来生成数据集。

import numpy as np

# Generate random data
np.random.seed(42)
x = np.random.rand(100, 2)
# Add bias term
x = np.hstack((np.ones((len(x), 1)), x))
y = 3 * x[:, [1]] - 2 * x[:, [2]] + 1 + 0.2 * np.random.randn(100, 1)

这个数据集包含100个样本。每个样本都有两个特征和一个目标变量。我们还使用了np.random.seed方法来使数据可重现。

模型

PyTorch中的线性回归模型可以通过使用nn.Linear类来定义：

import torch.nn as nn

model = nn.Linear(2, 1)

这个模型包含一个输入大小为2，输出大小为1的全连接层。我们可以使用model.parameters()来访问该模型的参数，该方法将返回一个可迭代对象，其中包含模型的权重和偏差项。

损失函数和优化器

我们将使用MSE（均方误差）作为损失函数，并使用SGD（随机梯度下降）作为优化器。可以使用PyTorch中的预定义函数来实例化这些对象：

import torch.optim as optim

criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

这将创建一个MSE损失函数和一个SGD优化器，其中学习率为0.1。

训练模型

现在我们已经定义了模型，损失函数和优化器，我们可以通过训练模型来学习数据集中的模式。在每个epoch中，我们将数据集传递给模型并计算模型的输出。然后，我们将输出与实际目标变量进行比较，并计算损失。最后，我们使用优化器来更新模型的参数以最小化损失。

num_epochs = 1000

for epoch in range(num_epochs):
    # Forward pass
    outputs = model(x_tensor)

    # Compute loss
    loss = criterion(outputs, y_tensor)

    # Backward pass and optimize
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    # Print progress
    if (epoch+1) % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

我们首先定义了训练的epoch数，然后使用for循环来执行训练。在for循环中，我们首先执行前向传递并计算损失。然后，我们执行后向传递以计算梯度，并使用优化器来更新模型的参数。最后，我们记录进度并在每个100 epoch后打印损失。

结果可视化

完成训练后，我们可以使用Matplotlib来可视化模型的输出和数据集的真实值。

import matplotlib.pyplot as plt

# Plot predicted and true values
plt.scatter(x[:,1], y)
plt.plot(x[:,1], outputs.detach().numpy(), color='red')
plt.show()

这将创建一个散点图，其中蓝点表示数据集的真实值，红线表示模型的预测值。

完整代码

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# Generate random data
np.random.seed(42)
x = np.random.rand(100, 2)
x = np.hstack((np.ones((len(x), 1)), x))
y = 3 * x[:, [1]] - 2 * x[:, [2]] + 1 + 0.2 * np.random.randn(100, 1)

# Convert data to PyTorch tensors
x_tensor = torch.from_numpy(x).float()
y_tensor = torch.from_numpy(y).float()

# Define model
model = nn.Linear(2, 1)

# Define loss function and optimizer
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# Train model
num_epochs = 1000

for epoch in range(num_epochs):
    # Forward pass
    outputs = model(x_tensor)

    # Compute loss
    loss = criterion(outputs, y_tensor)

    # Backward pass and optimize
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    # Print progress
    if (epoch+1) % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# Plot predicted and true values
plt.scatter(x[:,1], y)
plt.plot(x[:,1], outputs.detach().numpy(), color='red')
plt.show()

输出：

Epoch [100/1000], Loss: 0.0385
Epoch [200/1000], Loss: 0.0256
Epoch [300/1000], Loss: 0.0177
Epoch [400/1000], Loss: 0.0127
Epoch [500/1000], Loss: 0.0094
Epoch [600/1000], Loss: 0.0071
Epoch [700/1000], Loss: 0.0055
Epoch [800/1000], Loss: 0.0043
Epoch [900/1000], Loss: 0.0035
Epoch [1000/1000], Loss: 0.0029