Pytorch中自定义net实现回归算法

在使用PyTorch进行回归算法的实现时，我们需要进行以下几个步骤：

1、导入必要的库：

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

2、定义神经网络模型

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(1, 10)
        self.fc2 = nn.Linear(10, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

3、定义训练函数

def train(model, criterion, optimizer, train_loader, device):
    model.train()  # set model to training mode

    train_loss = 0.0
    for batch_idx, (inputs, targets) in enumerate(train_loader):
        # move data to device
        inputs, targets = inputs.to(device), targets.to(device)

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

        train_loss += loss.item()

    train_loss /= len(train_loader.dataset)

    print("Train set: Average loss: {:.4f}".format(train_loss))

4、定义测试函数

def test(model, criterion, test_loader, device):
    model.eval()  # set model to evaluation mode

    test_loss = 0.0
    with torch.no_grad():
        for batch_idx, (inputs, targets) in enumerate(test_loader):
            # move data to device
            inputs, targets = inputs.to(device), targets.to(device)

            # compute model predictions
            outputs = model(inputs)

            # compute loss
            loss = criterion(outputs, targets)
            test_loss += loss.item()

        test_loss /= len(test_loader.dataset)

        print("Test set: Average loss: {:.4f}".format(test_loss))

5、设置随机种子以保证重复性

6、生成训练数据

x_train = np.random.rand(100, 1).astype(np.float32)
y_train = x_train ** 2 + 0.1 * np.random.randn(100, 1).astype(np.float32)

7、生成测试数据

x_test = np.random.rand(50, 1).astype(np.float32)
y_test = x_test ** 2 + 0.1 * np.random.randn(50, 1).astype(np.float32)

8、为训练和测试数据创建 pytch 数据加载器对象

train_dataset = torch.utils.data.TensorDataset(torch.from_numpy(x_train), torch.from_numpy(y_train))
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=10, shuffle=True)
test_dataset = torch.utils.data.TensorDataset(torch.from_numpy(x_test), torch.from_numpy(y_test))
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=10, shuffle=True)

9、创建神经网络模型、损失函数和优化器

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

10、将模型和数据移动到 GPU

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

11、对模型进行固定次数的训练

num_epochs = 50
for epoch in range(num_epochs):
    print("Epoch {}/{}".format(epoch + 1, num_epochs))
    train(model, criterion, optimizer, train_loader, device)
    test(model, criterion, test_loader, device)

测试结果显示：