pytorch训练神经网络模型

本文使用PyTorch框架来构建一个神经网络，该网络能够对数据进行分类

首先从某个数据库中加载数据，然后进行预处理，包括标签编码和特征缩放。接着，定义了一个简单的前馈神经网络模型，并使用交叉熵损失函数和Adam优化器来训练模型。最后，评估了模型在测试集上的性能，并将训练好的模型参数保存在当前目录下的torch_model.pth中

代码实现：

import numpy as np
from get_data import get_database
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split

# 定义一个包含四个全连接层的简单神经网络模型
class Net(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(input_dim, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 32)
        self.fc4 = nn.Linear(32, output_dim)
        self.relu = nn.ReLU()
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.relu(self.fc3(x))
        x = self.softmax(self.fc4(x))
        return x

if __name__ == '__main__':
    X, y = get_database('you database')  # 替换为你存放数据的数据库名称

    # 使用LabelEncoder将字符串标签转换为整数标签
    label_encoder = LabelEncoder()
    y_encoded = label_encoder.fit_transform(y)

    # 数据预处理：将特征进行标准化
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)

    # 将数据转换为PyTorch的张量
    X_tensor = torch.tensor(X_scaled, dtype=torch.float32)
    y_tensor = torch.tensor(y_encoded, dtype=torch.int64)

    # 使用 train_test_split() 函数将数据拆分成训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(X_tensor, y_tensor, test_size=0.2)

    # 定义神经网络模型
    input_dim = X_train.shape[1]
    output_dim = len(label_encoder.classes_)
    print("input_dim:", input_dim, "output_dim:", output_dim)

    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    # 训练模型
    num_epochs = 20
    batch_size = 64
    for epoch in range(num_epochs):
        for i in range(0, len(X_train), batch_size):
            inputs = X_train[i:i+batch_size]
            labels = y_train[i:i+batch_size]

            # 前向传播
            outputs = model(inputs)

            # 计算损失
            loss = criterion(outputs, labels)

            # 反向传播和优化
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            # 打印每个epoch的损失
            print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch + 1, num_epochs, loss.item()))

        # 在测试集上评估模型
        with torch.no_grad():
            outputs = model(X_test)
            _, predicted = torch.max(outputs, 1)
            accuracy = (predicted == y_test).sum().item() / len(y_test)
            print('Test Accuracy: {:.2f}%'.format(accuracy * 100))

        # 保存模型
        torch.save(model.state_dict(), 'torch_model.pth')
        # 加载训练好的模型参数
        model.load_state_dict(torch.load('torch_model.pth'))
        # 设置模型为评估模式
        model.eval()
        # 准备输入数据
        input_data = torch.Tensor(np.array(X_test))
        # 进行推理
        with torch.no_grad():
            output = model(input_data)

        # 输出为模型的预测结果
        # print(output)
        _, predicted = torch.max(output, 1)
        print(y_test)
        print(predicted)

整个神经网络的构建和训练过程都是基于PyTorch框架进行的，运行代码，得到的模型的参数会保存到文件torch_model.pth中

如果你还没有下载安装torch，可以直接在终端输入以下命令下载安装：

pip install torch -i https://pypi.tuna.tsinghua.edu.cn/simple

但是以上方式下载可能会很慢，你可以先下载好torch-1.10.2-cp38-cp38-win_amd64.whl到本地，之后再在终端pip下载他（下载时要带上你下载torch-1.10.2-cp38-cp38-win_amd64.whl时存放的路径）

下载地址：torch安装包