使用Python和贝叶斯优化构建DNN神经网络，基于基因表达量预测患者疾病状态

以下是实现代码：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from sklearn.metrics import roc_curve, auc
from bayes_opt import BayesianOptimization
import pandas as pd
import matplotlib.pyplot as plt

# 定义数据集类
class GeneDataset(Dataset):
    def __init__(self, data):
        self.data = data

    def __getitem__(self, index):
        return torch.Tensor(self.data.loc[index][1:]), torch.LongTensor([self.data.loc[index][0]])

    def __len__(self):
        return len(self.data)

# 定义神经网络模型
class DNN(nn.Module):
    def __init__(self, input_dim, hidden_dim1, hidden_dim2, hidden_dim3):
        super(DNN, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim1)
        self.fc2 = nn.Linear(hidden_dim1, hidden_dim2)
        self.fc3 = nn.Linear(hidden_dim2, hidden_dim3)
        self.fc4 = nn.Linear(hidden_dim3, 2)
        self.attention = nn.Sequential(
            nn.Linear(hidden_dim3, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        out1 = torch.relu(self.fc1(x))
        out2 = torch.relu(self.fc2(out1))
        out3 = torch.relu(self.fc3(out2))
        attention_weights = self.attention(out3)  # 注意力权重
        out4 = self.fc4(out3)
        out = attention_weights * out4  # 加入注意力机制
        return out

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam

# 定义超参数搜索范围
pbounds = {
    'input_dim': (16, 32),
    'hidden_dim1': (8, 32),
    'hidden_dim2': (8, 32),
    'hidden_dim3': (8, 32),
    'lr': (0.001, 0.01),
}

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

# 定义模型训练函数
def train_model(input_dim, hidden_dim1, hidden_dim2, hidden_dim3, lr):
    # 划分数据集
    trainset = GeneDataset(data)
    trainloader = DataLoader(trainset, batch_size=32, shuffle=True)

    # 定义模型
    model = DNN(input_dim, hidden_dim1, hidden_dim2, hidden_dim3)

    # 定义优化器
    optimizer = optim.Adam(model.parameters(), lr=lr)

    # 模型训练
    for epoch in range(50):
        running_loss = 0.0
        correct = 0
        total = 0
        for i, data in enumerate(trainloader, 0):
            inputs, labels = data
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels.squeeze())
            loss.backward()
            optimizer.step()

            # 统计训练过程中的准确率和损失
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels.squeeze()).sum().item()
            running_loss += loss.item()

        # 输出训练过程中的准确率和损失
        acc = 100 * correct / total
        loss = running_loss / len(trainloader)
        print('Epoch %d, Acc: %.2f %%, Loss: %.4f' % (epoch, acc, loss))

    # 计算模型在训练集上的ROC曲线和AUC值
    y_true = []
    y_score = []
    with torch.no_grad():
        for i, data in enumerate(trainloader, 0):
            inputs, labels = data
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            y_true += labels.squeeze().tolist()
            y_score += outputs[:, 1].tolist()
    fpr, tpr, _ = roc_curve(y_true, y_score, pos_label=1)
    roc_auc = auc(fpr, tpr)

    return roc_auc

# 使用贝叶斯优化搜索最优超参数
optimizer = BayesianOptimization(
    f=train_model,
    pbounds=pbounds,
    verbose=2,
    random_state=1,
)
optimizer.maximize(init_points=10, n_iter=30)

# 输出最优超参数
print(optimizer.max)

# 绘制准确率和损失的变化图
history = optimizer.res
acc_history = [x['target'] for x in history]
loss_history = [x['params']['loss'] for x in history]
plt.plot(acc_history, label='Accuracy')
plt.plot(loss_history, label='Loss')
plt.xlabel('Iteration')
plt.ylabel('Value')
plt.legend()
plt.show()

# 绘制ROC曲线
params = optimizer.max['params']
model = DNN(int(params['input_dim']), int(params['hidden_dim1']), int(params['hidden_dim2']), int(params['hidden_dim3']))
trainset = GeneDataset(data)
trainloader = DataLoader(trainset, batch_size=32, shuffle=True)
optimizer = optim.Adam(model.parameters(), lr=params['lr'])
for epoch in range(50):
    running_loss = 0.0
    correct = 0
    total = 0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels.squeeze())
        loss.backward()
        optimizer.step()
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels.squeeze()).sum().item()
    running_loss += loss.item()
acc = 100 * correct / total
y_true = []
y_score = []
with torch.no_grad():
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        y_true += labels.squeeze().tolist()
        y_score += outputs[:, 1].tolist()
fpr, tpr, _ = roc_curve(y_true, y_score, pos_label=1)
roc_auc = auc(fpr, tpr)
plt.plot(fpr, tpr, label='ROC curve (AUC = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], 'k--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC curve')
plt.legend(loc="lower right")
plt.show()