导入所需的库

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

读入Excel表格

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

获取基因名称

gene_names = data.columns[1:]

获取患者状态标志

state = data['state'].values

获取基因表达量

gene_data = data[gene_names].values

数据标准化

scaler = StandardScaler() gene_data = scaler.fit_transform(gene_data)

定义第一个模型

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

第一次调用第一个模型，输入为基因的个数，输出为4分类

input_size = len(gene_names) hidden_size = 100 num_classes = 4 model1 = Model1(input_size, hidden_size, num_classes)

定义损失函数和优化器

criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model1.parameters(), lr=0.01)

训练第一个模型

num_epochs = 50 for epoch in range(num_epochs): # 将数据转换成torch张量 inputs = torch.from_numpy(gene_data).float() targets = torch.from_numpy(state).long()

# 前向传播
outputs = model1(inputs)
loss = criterion(outputs, targets)

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

# 输出训练过程中的准确率和损失值
total = targets.size(0)
_, predicted = torch.max(outputs.data, 1)
correct = (predicted == targets).sum().item()
accuracy = correct / total
print('Epoch [{}/{}], Loss: {:.4f}, Accuracy: {:.2f}%'.format(epoch+1, num_epochs, loss.item(), accuracy*100))

第二次调用第二个模型，第二个模型为二分类模型即患者是否患病，输入为第一个模型的输出

input_size = num_classes hidden_size = 50 num_classes = 2 model2 = Model2(input_size, hidden_size, num_classes)

定义损失函数和优化器

criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model2.parameters(), lr=0.01)

训练第二个模型

num_epochs = 50 for epoch in range(num_epochs): # 将第一个模型的输出作为输入 inputs = torch.from_numpy(outputs.detach().numpy()).float() targets = torch.from_numpy(state).long()

# 前向传播
outputs = model2(inputs)
loss = criterion(outputs, targets)

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

# 输出训练过程中的准确率和损失值
total = targets.size(0)
_, predicted = torch.max(outputs.data, 1)
correct = (predicted == targets).sum().item()
accuracy = correct / total
print('Epoch [{}/{}], Loss: {:.4f}, Accuracy: {:.2f}%'.format(epoch+1, num_epochs, loss.item(), accuracy*100))