使用 PyTorch 构建多层神经网络模型进行分类

本代码示例展示了如何使用 PyTorch 构建多层神经网络模型进行分类，并对数据进行预处理、训练和评估。代码中包含三个模型，每个模型都基于上一个模型的输出作为输入，最终实现更复杂的分类任务。

导入所需库

import torch
import torch.nn as nn
import pandas as pd
from sklearn import preprocessing

读取数据

# 读入Excel表格
data = pd.read_excel('C:\Users\lenovo\Desktop\HIV\DNN神经网络测试\data1.xlsx')

# 数据标准化
data.iloc[:, 1:] = preprocessing.scale(data.iloc[:, 1:])

# 划分数据集
X = torch.tensor(data.iloc[:, 1:].values, dtype=torch.float32)
y = torch.tensor(data.iloc[:, 0].values, dtype=torch.long)
train_data = torch.utils.data.TensorDataset(X, y)
train_loader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)

定义模型

第一个模型

# 定义第一个模型
class Model1(nn.Module):
    def __init__(self):
        super(Model1, self).__init__()
        self.fc1 = nn.Linear(16, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 8)
        self.dropout = nn.Dropout(p=0.5)

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

第二个模型

# 定义第二个模型
class Model2(nn.Module):
    def __init__(self):
        super(Model2, self).__init__()
        self.fc1 = nn.Linear(8, 32)
        self.fc2 = nn.Linear(32, 16)
        self.fc3 = nn.Linear(16, 4)
        self.dropout = nn.Dropout(p=0.5)

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

第三个模型

# 定义第三个模型
class Model3(nn.Module):
    def __init__(self):
        super(Model3, self).__init__()
        self.fc1 = nn.Linear(4, 2)

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

初始化模型

# 初始化三个模型
model1 = Model1()
model2 = Model2()
model3 = Model3()

定义损失函数和优化器

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer1 = torch.optim.Adam(model1.parameters(), lr=0.001)
optimizer2 = torch.optim.Adam(model2.parameters(), lr=0.001)
optimizer3 = torch.optim.Adam(model3.parameters(), lr=0.001)

训练模型

训练第一个模型

# 训练第一个模型
for epoch in range(100):
    running_loss = 0.0
    total = 0
    correct = 0
    for i, data in enumerate(train_loader):
        inputs, labels = data
        optimizer1.zero_grad()
        outputs = model1(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer1.step()

        running_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Epoch: %d, Loss: %.3f, Accuracy: %.3f' % (epoch + 1, running_loss / len(train_loader), correct / total))

训练第二个模型

# 训练第二个模型
train_X = []
train_y = []
with torch.no_grad():
    for data in train_loader:
        inputs, labels = data
        outputs = model1(inputs)
        train_X.append(outputs)
        train_y.append(labels)
train_X = torch.cat(train_X, 0)
train_y = torch.cat(train_y, 0)

train_data2 = torch.utils.data.TensorDataset(train_X, train_y)
train_loader2 = torch.utils.data.DataLoader(train_data2, batch_size=64, shuffle=True)

for epoch in range(100):
    running_loss = 0.0
    total = 0
    correct = 0
    for i, data in enumerate(train_loader2):
        inputs, labels = data
        optimizer2.zero_grad()
        outputs = model2(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer2.step()

        running_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Epoch: %d, Loss: %.3f, Accuracy: %.3f' % (epoch + 1, running_loss / len(train_loader2), correct / total))

训练第三个模型

# 训练第三个模型
train_X2 = []
train_y2 = []
with torch.no_grad():
    for data in train_loader2:
        inputs, labels = data
        outputs = model2(inputs)
        train_X2.append(outputs)
        train_y2.append(labels)
train_X2 = torch.cat(train_X2, 0)
train_y2 = torch.cat(train_y2, 0)

train_data3 = torch.utils.data.TensorDataset(train_X2, train_y2)
train_loader3 = torch.utils.data.DataLoader(train_data3, batch_size=64, shuffle=True)

for epoch in range(100):
    running_loss = 0.0
    total = 0
    correct = 0
    for i, data in enumerate(train_loader3):
        inputs, labels = data
        optimizer3.zero_grad()
        outputs = model3(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer3.step()

        running_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Epoch: %d, Loss: %.3f, Accuracy: %.3f' % (epoch + 1, running_loss / len(train_loader3), correct / total))

模型连接

上述代码中，第二个模型的输入为第一个模型的输出，体现在以下代码中：

train_X = []
train_y = []
with torch.no_grad():
    for data in train_loader:
        inputs, labels = data
        outputs = model1(inputs)
        train_X.append(outputs)
        train_y.append(labels)
train_X = torch.cat(train_X, 0)
train_y = torch.cat(train_y, 0)

train_data2 = torch.utils.data.TensorDataset(train_X, train_y)
train_loader2 = torch.utils.data.DataLoader(train_data2, batch_size=64, shuffle=True)

其中，第一个模型的输出通过train_X.append(outputs)添加到train_X中，然后将train_X和train_y作为第二个模型的训练数据train_data2的输入。train_loader2是train_data2的数据加载器。

同理，第三个模型的输入为第二个模型的输出，通过类似的方式进行训练。这种多层模型的设计可以实现更复杂的分类任务。

总结

本代码示例展示了如何使用 PyTorch 构建多层神经网络模型进行分类，并对数据进行预处理、训练和评估。通过将模型的输出作为下一个模型的输入，可以实现更复杂的分类任务。