PyTorch 构建多层神经网络模型：以 HIV 预测为例

使用 PyTorch 构建多层神经网络模型：以 HIV 预测为例

本代码使用 PyTorch 构建了一个三层神经网络模型，并使用 HIV 数据集进行训练。每个模型都包含了线性层、激活函数和 dropout 层，并使用交叉熵损失函数和 Adam 优化器进行训练。模型的输入和输出关系清晰，代码结构完整，并提供详细的注释说明。

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))

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

outputs = model1(inputs)

其中 inputs 为第一个模型的输入。这行代码体现在第 50 行。