使用 Python 和 PyTorch 构建带注意力机制的 DNN 模型预测 HIV 感染

本项目使用 Python 和 PyTorch 构建了一个深度神经网络 (DNN) 模型，利用基因表达量预测患者是否感染 HIV。模型包含注意力机制，并提供详细注释，包括数据预处理、模型架构、训练和测试过程。

1. 数据预处理

读取 Excel 表格，第一行为患者状态标志 state（1 为患病，0 为正常）和 16 个基因名称，第 0 列为患者是否患病的真值，其余列为基因的表达量。
数据路径为 'C:\Users\lenovo\Desktop\HIV\DNN神经网络测试\output_data.xlsx'。

import torch
from torch.utils.data import DataLoader, Dataset
import pandas as pd
import numpy as np

# 定义数据集类
class HIVDataset(Dataset):
    def __init__(self, data_path):
        data = pd.read_excel(data_path)
        self.X = data.iloc[:, 1:].values.astype(np.float32)
        self.Y = data.iloc[:, 0].values.astype(np.int64)

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

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

2. 模型架构

模型为二分类模型，判断是否患病。
包含三个隐藏层，神经元个数分别为：8、4、8。
加入注意力机制。

# 定义模型
class DNNModel(torch.nn.Module):
    def __init__(self):
        super(DNNModel, self).__init__()
        self.linear1 = torch.nn.Linear(16, 8)
        self.linear2 = torch.nn.Linear(8, 4)
        self.linear3 = torch.nn.Linear(4, 8)
        self.linear4 = torch.nn.Linear(8, 2)
        self.relu = torch.nn.ReLU()
        self.softmax = torch.nn.Softmax(dim=1)
        self.attention = torch.nn.MultiheadAttention(8, 2)

    def forward(self, x):
        # 注意力机制
        output, _ = self.attention(x, x, x)
        output = self.linear1(output)
        output = self.relu(output)
        output = self.linear2(output)
        output = self.relu(output)
        output = self.linear3(output)
        output = self.relu(output)
        output = self.linear4(output)
        output = self.softmax(output)
        return output

3. 训练和测试

将数据划分为训练集和测试集，比例为 8:2。
采用 Adam 优化器，损失函数为交叉熵损失。
在训练过程中，输出每次训练的准确率和损失值。
在测试阶段，输出模型的最终准确率和损失值。

# 定义训练函数
def train(model, optimizer, criterion, train_loader, device):
    model.train()
    train_loss = 0
    train_correct = 0
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        train_loss += loss.item()
        pred = output.argmax(dim=1, keepdim=True)
        train_correct += pred.eq(target.view_as(pred)).sum().item()
        loss.backward()
        optimizer.step()
    train_loss /= len(train_loader.dataset)
    train_acc = 100. * train_correct / len(train_loader.dataset)
    print('Train set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)'.format(
        train_loss, train_correct, len(train_loader.dataset), train_acc))
    return train_loss, train_acc

# 定义测试函数
def test(model, criterion, test_loader, device):
    model.eval()
    test_loss = 0
    test_correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += criterion(output, target).item()
            pred = output.argmax(dim=1, keepdim=True)
            test_correct += pred.eq(target.view_as(pred)).sum().item()
    test_loss /= len(test_loader.dataset)
    test_acc = 100. * test_correct / len(test_loader.dataset)
    print('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)'.format(
        test_loss, test_correct, len(test_loader.dataset), test_acc))
    return test_loss, test_acc

# 定义主函数
def main():
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    data_path = 'C:\Users\lenovo\Desktop\HIV\DNN神经网络测试\output_data.xlsx'
    dataset = HIVDataset(data_path)
    train_size = int(0.8 * len(dataset))
    test_size = len(dataset) - train_size
    train_set, test_set = torch.utils.data.random_split(dataset, [train_size, test_size])
    train_loader = DataLoader(train_set, batch_size=32, shuffle=True)
    test_loader = DataLoader(test_set, batch_size=32, shuffle=True)
    model = DNNModel().to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    criterion = torch.nn.CrossEntropyLoss()
    for epoch in range(1, 101):
        print('Epoch {}:'.format(epoch))
        train_loss, train_acc = train(model, optimizer, criterion, train_loader, device)
        test_loss, test_acc = test(model, criterion, test_loader, device)
    # 输出最后一次训练的预测结果
    model.eval()
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            prob = output[:, 1].cpu().numpy()
            print('Probabilities:', prob)

if __name__ == '__main__':
    main()

4. 输出结果

输出最后一次训练得到的每个样本的概率。

该项目提供了一个完整的解决方案，使用 Python 和 PyTorch 构建一个 DNN 模型，并利用注意力机制来预测 HIV 感染。代码清晰易懂，并提供详细注释。你可以根据自己的需求对代码进行修改和扩展。

使用 Python 和 PyTorch 构建带注意力机制的 DNN 模型预测 HIV 感染