使用python编写DNN神经网络根据基因的表达量来预测患者是否患病并且满足以下要求：1读入Excel表格第一行为患者状态标志state1为患病0为正常和基因名称第0列为患者是否患病的真值其余列为各基因及其表达量2定义两个模型3模型的各项参数可调4模型调用分为两次第一次调用第一个模型输入为基因的个数输出为4分类5第二次调用第二个模型第二个模型输入为第一个模型的输出输出为是否患病7给出详细注释8模型

由于任务较为复杂，建议将代码分为几个部分逐步实现。

第一步，读入Excel表格，进行数据预处理和标准化。

import pandas as pd
import numpy as np
import torch
from sklearn.preprocessing import StandardScaler

# 读入Excel表格
data = pd.read_excel('C:\\Users\\lenovo\\Desktop\\HIV\\GSE6740GSE50011基因降低\\output_data.xlsx')
# 提取标签
labels = data['state']
# 删除标签列和基因名称列
data = data.drop(columns=['state', 'symbol'])
# 标准化数据
scaler = StandardScaler()
data = scaler.fit_transform(data)
# 转换为pytorch tensor
data = torch.tensor(data, dtype=torch.float32)
labels = torch.tensor(labels.values, dtype=torch.int64)

第二步，定义第一个模型。该模型输入基因的个数，输出为4分类。

import torch.nn as nn
import torch.nn.functional as F

class Model1(nn.Module):
    def __init__(self, input_size, output_size):
        super(Model1, self).__init__()
        self.fc1 = nn.Linear(input_size, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, output_size)
        self.dropout = nn.Dropout(p=0.5)
        
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = F.relu(self.fc2(x))
        x = self.dropout(x)
        x = self.fc3(x)
        return x

第三步，定义第二个模型。该模型输入为第一个模型的输出，输出为是否患病。

class Model2(nn.Module):
    def __init__(self, input_size, output_size):
        super(Model2, self).__init__()
        self.fc1 = nn.Linear(input_size, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, output_size)
        self.dropout = nn.Dropout(p=0.5)
        
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = F.relu(self.fc2(x))
        x = self.dropout(x)
        x = torch.sigmoid(self.fc3(x))
        return x

第四步，定义模型训练函数。该函数输入为模型、数据、标签、优化器、损失函数和训练次数，输出为每次训练的准确率和损失值。

def train_model(model, data, labels, optimizer, criterion, num_epochs):
    for epoch in range(num_epochs):
        # 前向传播
        outputs1 = model.fc3(F.relu(model.fc2(F.relu(model.fc1(data)))))
        outputs2 = model(outputs1)
        # 计算损失和准确率
        loss = criterion(outputs2, labels.float().unsqueeze(1))
        accuracy = ((outputs2 > 0.5).squeeze().int() == labels).sum().float() / len(labels)
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 输出结果
        print('Epoch [{}/{}], Loss: {:.4f}, Accuracy: {:.4f}'.format(epoch+1, num_epochs, loss.item(), accuracy.item()))

第五步，定义贝叶斯优化函数。该函数输入为模型、数据、标签、优化器、损失函数和训练次数，输出为最优超参数。

from bayes_opt import BayesianOptimization

def optimize_model(model, data, labels, criterion, num_epochs):
    def train_model_and_return_accuracy(learning_rate, weight_decay):
        optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
        train_model(model, data, labels, optimizer, criterion, num_epochs)
        outputs1 = model.fc3(F.relu(model.fc2(F.relu(model.fc1(data)))))
        outputs2 = model(outputs1)
        accuracy = ((outputs2 > 0.5).squeeze().int() == labels).sum().float() / len(labels)
        return accuracy.item()
    optimizer = BayesianOptimization(
        f=train_model_and_return_accuracy,
        pbounds={'learning_rate': (1e-4, 1e-2), 'weight_decay': (1e-6, 1e-4)},
        verbose=2
    )
    optimizer.maximize(n_iter=10)
    return optimizer.max

最后，调用以上函数进行模型训练和优化。

# 定义第一个模型
model1 = Model1(input_size=data.shape[1], output_size=4)
criterion1 = nn.CrossEntropyLoss()
# 进行贝叶斯优化
best_hyperparameters1 = optimize_model(model1, data, labels, criterion1, 50)
# 重新定义模型，并使用最优超参数
model1 = Model1(input_size=data.shape[1], output_size=4)
optimizer1 = torch.optim.Adam(model1.parameters(), lr=best_hyperparameters1['params']['learning_rate'], weight_decay=best_hyperparameters1['params']['weight_decay'])
# 训练第一个模型
train_model(model1, data, labels, optimizer1, criterion1, 100)

# 定义第二个模型
model2 = Model2(input_size=4, output_size=1)
criterion2 = nn.BCELoss()
# 进行贝叶斯优化
best_hyperparameters2 = optimize_model(model2, model1(data).detach(), labels, criterion2, 50)
# 重新定义模型，并使用最优超参数
model2 = Model2(input_size=4, output_size=1)
optimizer2 = torch.optim.Adam(model2.parameters(), lr=best_hyperparameters2['params']['learning_rate'], weight_decay=best_hyperparameters2['params']['weight_decay'])
# 训练第二个模型
train_model(model2, model1(data).detach(), labels, optimizer2, criterion2, 100)