使用贝叶斯优化调参的深度神经网络 HIV 二分类模型

该代码使用神经网络模型进行二分类任务，并使用贝叶斯优化寻找最优参数。

读取数据：使用pandas库读取Excel格式的数据文件，并将数据分为特征X和标签y。
数据标准化：使用StandardScaler对特征进行标准化处理。
定义数据集类：自定义数据集类，继承自torch.utils.data.Dataset，用于将数据转化为PyTorch可用的数据集。
定义模型：自定义神经网络模型，继承自torch.nn.Module，包含4个全连接层和1个注意力层，其中每个全连接层之间使用ReLU激活函数，输出层使用Softmax激活函数。注意力层使用一个线性层和一个Softmax激活函数来计算出每个特征的权重，然后将这些特征加权求和。最终输出层的结果是一个2维向量，用于进行二分类任务。
定义训练函数：使用定义好的神经网络模型进行训练，包括定义损失函数和优化器，以及训练过程中的迭代操作。训练函数使用训练集进行训练，并返回训练后的准确度。
使用贝叶斯优化寻找最优参数：使用BayesianOptimization调用训练函数train，定义参数搜索范围和优化目标，然后进行参数搜索，寻找最优参数。
输出最优参数和最优结果：输出最优参数和最优结果。

代码详细解释：

import pandas as pd
from sklearn.preprocessing import StandardScaler
from bayes_opt import BayesianOptimization
import torch
from torch import nn, optim
from torch.utils.data import Dataset, DataLoader

# 读取数据
data = pd.read_excel(r'C:\Users\lenovo\Desktop\HIV\DNN神经网络测试\data1.xlsx', header=0)
X = data.iloc[:, 1:].values
y = data.iloc[:, 0].values

# 数据标准化
sc = StandardScaler()
X = sc.fit_transform(X)


# 定义数据集类
class HIVDataset(Dataset):
    def __init__(self, X, y):
        self.X = torch.tensor(X, dtype=torch.float32)
        self.y = torch.tensor(y, dtype=torch.float32)

    def __getitem__(self, index):
        return self.X[index], self.y[index]

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


# 定义模型
class DNN(nn.Module):
    def __init__(self, input_dim, output_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, output_dim)
        self.relu = nn.ReLU()
        self.softmax = nn.Softmax(dim=1)
        self.attention = nn.Sequential(
            nn.Linear(hidden_dim3, 1),
            nn.Softmax(dim=0)
        )

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.relu(self.fc3(x))
        attn_weight = self.attention(x)
        x = x * attn_weight
        x = self.fc4(x)
        x = self.softmax(x)
        return x


# 定义训练函数
def train(hidden_dim1, hidden_dim2, hidden_dim3, lr, weight_decay):
    # 定义模型
    model = DNN(input_dim=X.shape[1], output_dim=2,
                hidden_dim1=int(hidden_dim1), hidden_dim2=int(hidden_dim2), hidden_dim3=int(hidden_dim3))
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)
    # 定义数据集和数据加载器
    dataset = HIVDataset(X, y)
    loader = DataLoader(dataset, batch_size=32, shuffle=True)
    # 开始训练
    for epoch in range(50):
        running_loss = 0.0
        correct = 0
        total = 0
        for batch_x, batch_y in loader:
            optimizer.zero_grad()
            outputs = model(batch_x)
            loss = criterion(outputs, batch_y.long())
            loss.backward()
            optimizer.step()
            _, predicted = torch.max(outputs.data, 1)
            total += batch_y.size(0)
            correct += (predicted == batch_y).sum().item()
            running_loss += loss.item() * batch_y.size(0)
        epoch_loss = running_loss / total
        epoch_acc = correct / total
        print('Epoch [{}/{}], Loss: {:.4f}, Accuracy: {:.4f}'.format(epoch + 1, 50, epoch_loss, epoch_acc))
    return epoch_acc


# 使用贝叶斯优化寻找最优参数
pbounds = {'hidden_dim1': (10, 100), 'hidden_dim2': (10, 100), 'hidden_dim3': (10, 100), 'lr': (0.0001, 0.1),
           'weight_decay': (0, 0.1)}
optimizer = BayesianOptimization(f=train, pbounds=pbounds)
optimizer.maximize(init_points=5, n_iter=10)

# 输出最优参数和最优结果
print('Maximum accuracy value: {:.4f}'.format(optimizer.max['target']))
print('Best parameters: ', optimizer.max['params'])