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') x = data.iloc[:, 1:].values # 获取基因表达量 y = data.iloc[:, 0].values # 获取患者状态标志

数据标准化

scaler = StandardScaler() x = scaler.fit_transform(x)

定义第一个模型

class FirstModel(nn.Module): def init(self, input_size, hidden_size, output_size): super(FirstModel, self).init() self.fc1 = nn.Linear(input_size, hidden_size) self.fc2 = nn.Linear(hidden_size, hidden_size) self.fc3 = nn.Linear(hidden_size, output_size) self.dropout = nn.Dropout(p=0.5) self.relu = nn.ReLU()

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

定义第二个模型

class SecondModel(nn.Module): def init(self, input_size, hidden_size, output_size): super(SecondModel, self).init() self.fc1 = nn.Linear(input_size, hidden_size) self.fc2 = nn.Linear(hidden_size, hidden_size) self.fc3 = nn.Linear(hidden_size, output_size) self.dropout = nn.Dropout(p=0.5) self.relu = nn.ReLU()

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

定义训练函数

def train(model, criterion, optimizer, x, y): model.train() running_loss = 0.0 running_corrects = 0

for inputs, labels in zip(x, y):
    inputs = torch.from_numpy(inputs).float()
    labels = torch.tensor(labels).long()

    optimizer.zero_grad()

    outputs = model(inputs)
    loss = criterion(outputs, labels)
    _, preds = torch.max(outputs, 1)

    loss.backward()
    optimizer.step()

    running_loss += loss.item() * inputs.size(0)
    running_corrects += torch.sum(preds == labels)

epoch_loss = running_loss / len(y)
epoch_acc = running_corrects.double() / len(y)

return epoch_loss, epoch_acc

定义参数

input_size = len(data.columns) - 1 # 输入大小为基因个数 hidden_size = 64 output_size = 4 lr = 0.01 num_epochs = 100

训练第一个模型

first_model = FirstModel(input_size, hidden_size, output_size) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(first_model.parameters(), lr=lr, momentum=0.9)

for epoch in range(num_epochs): epoch_loss, epoch_acc = train(first_model, criterion, optimizer, x, y) print('First Model: Epoch [{}/{}], Loss: {:.4f}, Acc: {:.4f}'.format(epoch+1, num_epochs, epoch_loss, epoch_acc))

获取第一个模型的输出

output1 = [] for inputs in x: inputs = torch.from_numpy(inputs).float() outputs = first_model(inputs) output1.append(outputs)

将第一个模型的输出作为第二个模型的输入

input2 = torch.stack(output1).detach().numpy()

定义参数

input_size = output_size hidden_size = 32 output_size = 2 lr = 0.01 num_epochs = 100

训练第二个模型

second_model = SecondModel(input_size, hidden_size, output_size) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(second_model.parameters(), lr=lr, momentum=0.9)

for epoch in range(num_epochs): epoch_loss, epoch_acc = train(second_model, criterion, optimizer, input2, y) print('Second Model: Epoch [{}/{}], Loss: {:.4f}, Acc: {:.4f}'.format(epoch+1, num_epochs, epoch_loss, epoch_acc))

获取第二个模型的输出

output2 = [] for inputs in input2: inputs = torch.from_numpy(inputs).float() outputs = second_model(inputs) output2.append(outputs)

将第二个模型的输出作为每个样本所对应的概率输出

prob = nn.functional.softmax(torch.stack(output2), dim=1).detach().numpy()