基于PyTorch构建神经网络预测模型

建立一个基于PyTorch的神经网络模型来预测输出，可以遵循以下步骤：

1. 定义问题：首先明确问题是回归问题还是分类问题。如果输出是连续的数值，则可能是一个回归问题；如果输出是离散值，则可能是一个分类问题。

2. 准备数据集：确保数据集已经被清洗和预处理，包括标准化或归一化，以及划分训练集、验证集和测试集。

3. 定义模型：使用PyTorch定义一个神经网络模型。对于一个具有5个输入和1个输出的模型，你可以定义一个简单的全连接层（也称为线性层）的网络。

4. 定义损失函数和优化器：对于回归问题，通常使用均方误差（MSE）作为损失函数。优化器可以选择Adam或SGD。

5. 训练模型：使用训练数据来训练模型，同时监控验证集上的性能以避免过拟合。

6. 评估模型：在测试集上评估模型的性能，使用适当的评估指标，如MSE或RMSE。

7. 模型调优：根据需要调整模型结构或超参数，以改进模型性能。

本例中，输入数据存储在txt文档中，500行，每行6个数据，空格间隔，前5个为输入，最后1个为输出。测试数据存储在另一个txt文档中，100行，每行6个数据，空格间隔，前5个为输入，最后1个为输出。

以下代码实现，建立神经网络模型，读取数据进行训练，训练结束后保存整个模型对象：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
​
# 定义神经网络模型
class Net(nn.Module):
    def __init__(self, input_size, output_size):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(input_size, 128)  # 第一个隐藏层
        self.fc2 = nn.Linear(128, 64)         # 第二个隐藏层
        self.fc3 = nn.Linear(64, output_size)  # 输出层
​
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x
​
# 读取数据并存储到列表中
file_path = r'xxx.txt'
data_list = []
with open(file_path, 'r') as file:
    for line in file:
        values = line.strip().split()
        data_list.append(list(map(float, values)))
​
# 将数据分为输入和输出
input_size = 5  # 5个输入
output_size = 1  # 1个输出
inputs = torch.tensor([data[:-1] for data in data_list], dtype=torch.float32)
outputs = torch.tensor([data[-1] for data in data_list], dtype=torch.float32)
​
# 创建数据加载器
batch_size = 10
dataset = TensorDataset(inputs, outputs)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
​
# 实例化模型
model = Net(input_size, output_size)
​
# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
​
# 训练模型
num_epochs = 10000  # 训练100个周期
for epoch in range(num_epochs):
    model.train()  # 设置模型为训练模式
    running_loss = 0.0
    for inputs_batch, outputs_batch in dataloader:
        optimizer.zero_grad()  # 清除之前的梯度
        outputs_pred = model(inputs_batch)  # 前向传播
        loss = criterion(outputs_pred, outputs_batch.view(-1, 1))  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新权重
        running_loss += loss.item()
    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {running_loss/len(dataloader)}')
​
# 评估模型（可选）
model.eval()  # 设置模型为评估模式
with torch.no_grad():
    for inputs_batch, outputs_batch in dataloader:
        outputs_pred = model(inputs_batch)
        loss = criterion(outputs_pred, outputs_batch.view(-1, 1))
        print(f'Test Loss: {loss.item()}')
model_path = r'xxx.pth'
# 保存整个模型对象
torch.save(model, model_path)

以下代码实现，保存整个模型对象与测试数据，进行预测，并把预测结果保存到txt文档中。

import torch
import torch.nn as nn
import numpy as np
# 定义神经网络模型
class Net(nn.Module):
    def __init__(self, input_size, output_size):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(input_size, 128)  # 第一个隐藏层
        self.fc2 = nn.Linear(128, 64)         # 第二个隐藏层
        self.fc3 = nn.Linear(64, output_size)  # 输出层
​
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x
# 加载保存的模型权重
model_path = r'xxx.pth'
model = torch.load(model_path)
# 设置模型为评估模式
model.eval()
​
# 读取测试数据
file_path = r'xxx.txt'
test_data_list = []
with open(file_path, 'r') as file:
    for line in file:
        values = line.strip().split()
        test_data_list.append(list(map(float, values)))
​
# 将测试数据分为输入和输出
test_inputs = torch.tensor([data[:-1] for data in test_data_list], dtype=torch.float32)
test_outputs_actual = torch.tensor([data[-1] for data in test_data_list], dtype=torch.float32)
​
# 可选：创建一个TensorDataset和DataLoader来批量处理数据
# test_dataset = TensorDataset(test_inputs, test_outputs_actual)
# test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
​
# 进行预测
predictions = []
with torch.no_grad():
    # 如果使用DataLoader
    # for inputs_batch in test_dataloader:
    #     outputs_pred = model(inputs_batch)
    #     predictions.extend(outputs_pred.cpu().numpy())
    
    # 如果不使用DataLoader，一次性预测所有数据
    outputs_pred = model(test_inputs)
    predictions.extend(outputs_pred.cpu().numpy())
​
# 打印预测结果
print(predictions)
# 使用np.savetxt保存数组到文本文件
np.savetxt('output.txt', predictions, fmt='%f', delimiter=' ')
# 如果需要，可以计算模型性能指标，例如MSE
mse_loss = torch.nn.MSELoss()
test_loss = mse_loss(outputs_pred, test_outputs_actual.view(-1, 1))
print(f'Test MSE Loss: {test_loss.item()}')