基于PyTorch的深度神经网络模型训练：HIV数据分类案例

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

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

# 对数据进行标准化处理
scaler = StandardScaler()
data.iloc[:, 1:] = scaler.fit_transform(data.iloc[:, 1:])

# 定义第一个模型
class Model1(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(Model1, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(p=0.5)
        self.fc2 = nn.Linear(hidden_size, num_classes)

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

# 定义第二个模型
class Model2(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(Model2, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(p=0.5)
        self.fc2 = nn.Linear(hidden_size, num_classes)
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.dropout(out)
        out = self.fc2(out)
        out = self.softmax(out)
        return out

# 设置模型参数
input_size = len(data.columns) - 1
hidden_size = 256
num_classes1 = 4
num_classes2 = 2
learning_rate = 0.001
num_epochs = 100

# 定义第一个模型
model1 = Model1(input_size, hidden_size, num_classes1)

# 定义损失函数和优化器
criterion1 = nn.CrossEntropyLoss()
optimizer1 = optim.Adam(model1.parameters(), lr=learning_rate)

# 训练第一个模型
for epoch in range(num_epochs):
    inputs = torch.Tensor(data.iloc[:, 1:].values)
    targets = torch.Tensor(data.iloc[:, 0].values).long()
    optimizer1.zero_grad()
    outputs = model1(inputs)
    loss = criterion1(outputs, targets)
    loss.backward()
    optimizer1.step()
    if (epoch+1) % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

    # 计算第一个模型的准确率
    _, predicted = torch.max(outputs.data, 1)
    total = targets.size(0)
    correct = (predicted == targets).sum().item()
    accuracy = correct / total
    print('Accuracy of the first model: {:.2f}%'.format(accuracy * 100))

# 第一个模型的输出作为第二个模型的输入
inputs = model1(inputs).detach()

# 定义第二个模型
model2 = Model2(num_classes1, hidden_size, num_classes2)

# 定义损失函数和优化器
criterion2 = nn.CrossEntropyLoss()
optimizer2 = optim.Adam(model2.parameters(), lr=learning_rate)

# 训练第二个模型
for epoch in range(num_epochs):
    optimizer2.zero_grad()
    outputs = model2(inputs)
    loss = criterion2(outputs, targets)
    loss.backward()
    optimizer2.step()
    if (epoch+1) % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

    # 计算第二个模型的准确率
    _, predicted = torch.max(outputs.data, 1)
    total = targets.size(0)
    correct = (predicted == targets).sum().item()
    accuracy = correct / total
    print('Accuracy of the second model: {:.2f}%'.format(accuracy * 100))

# 输出最后一次训练得到每个样本所对应的概率
outputs = model2(inputs)
probabilities = outputs.detach().numpy()

print(probabilities)