基于基因表达量预测患者患病状态的DNN神经网络模型

导入所需模块

import torch import torch.nn as nn import torch.optim as optim import pandas as pd from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler

读取数据

定义Excel文件路径

data_path = 'C:\Users\lenovo\Desktop\HIV\DNN神经网络测试\data1.xlsx'

读取Excel表格

df = pd.read_excel(data_path)

提取特征和标签

X = df.iloc[:, 1:].values y = df.iloc[:, 0].values

对特征进行标准化处理

sc = StandardScaler() X = sc.fit_transform(X)

将标签转换为tensor类型

y = torch.tensor(y, dtype=torch.long)

划分训练集和测试集

将所有数据作为训练集

X_train = X y_train = y

定义模型

定义第一个模型

class Model1(nn.Module): def init(self, input_size, hidden_size, output_size): super(Model1, self).init() self.fc1 = nn.Linear(input_size, hidden_size) self.fc2 = nn.Linear(hidden_size, hidden_size) self.fc3 = nn.Linear(hidden_size, hidden_size) self.fc4 = nn.Linear(hidden_size, hidden_size) self.fc5 = nn.Linear(hidden_size, hidden_size) self.fc6 = nn.Linear(hidden_size, hidden_size) self.fc7 = nn.Linear(hidden_size, hidden_size) self.fc8 = nn.Linear(hidden_size, output_size) self.dropout = nn.Dropout(p=0.2)

def forward(self, x):
    x = torch.relu(self.fc1(x))
    x = self.dropout(x)
    x = torch.relu(self.fc2(x))
    x = self.dropout(x)
    x = torch.relu(self.fc3(x))
    x = self.dropout(x)
    x = torch.relu(self.fc4(x))
    x = self.dropout(x)
    x = torch.relu(self.fc5(x))
    x = self.dropout(x)
    x = torch.relu(self.fc6(x))
    x = self.dropout(x)
    x = torch.relu(self.fc7(x))
    x = self.dropout(x)
    x = self.fc8(x)
    return x

定义第二个模型

class Model2(nn.Module): def init(self, input_size, hidden_size, output_size): super(Model2, self).init() self.fc1 = nn.Linear(input_size, hidden_size) self.fc2 = nn.Linear(hidden_size, hidden_size) self.fc3 = nn.Linear(hidden_size, hidden_size) self.fc4 = nn.Linear(hidden_size, hidden_size) self.fc5 = nn.Linear(hidden_size, hidden_size) self.fc6 = nn.Linear(hidden_size, hidden_size) self.fc7 = nn.Linear(hidden_size, hidden_size) self.fc8 = nn.Linear(hidden_size, output_size) self.dropout = nn.Dropout(p=0.2)

def forward(self, x):
    x = torch.relu(self.fc1(x))
    x = self.dropout(x)
    x = torch.relu(self.fc2(x))
    x = self.dropout(x)
    x = torch.relu(self.fc3(x))
    x = self.dropout(x)
    x = torch.relu(self.fc4(x))
    x = self.dropout(x)
    x = torch.relu(self.fc5(x))
    x = self.dropout(x)
    x = torch.relu(self.fc6(x))
    x = self.dropout(x)
    x = torch.relu(self.fc7(x))
    x = self.dropout(x)
    x = self.fc8(x)
    return x

定义第三个模型

class Model3(nn.Module): def init(self, input_size, hidden_size, output_size): super(Model3, self).init() self.fc1 = nn.Linear(input_size, hidden_size) self.fc2 = nn.Linear(hidden_size, hidden_size) self.fc3 = nn.Linear(hidden_size, hidden_size) self.fc4 = nn.Linear(hidden_size, hidden_size) self.fc5 = nn.Linear(hidden_size, hidden_size) self.fc6 = nn.Linear(hidden_size, hidden_size) self.fc7 = nn.Linear(hidden_size, hidden_size) self.fc8 = nn.Linear(hidden_size, output_size) self.dropout = nn.Dropout(p=0.2)

def forward(self, x):
    x = torch.relu(self.fc1(x))
    x = self.dropout(x)
    x = torch.relu(self.fc2(x))
    x = self.dropout(x)
    x = torch.relu(self.fc3(x))
    x = self.dropout(x)
    x = torch.relu(self.fc4(x))
    x = self.dropout(x)
    x = torch.relu(self.fc5(x))
    x = self.dropout(x)
    x = torch.relu(self.fc6(x))
    x = self.dropout(x)
    x = torch.relu(self.fc7(x))
    x = self.dropout(x)
    x = self.fc8(x)
    return x

定义训练函数

def train(model, optimizer, criterion, X_train, y_train, epochs): # 将数据转换为tensor类型 X_train = torch.tensor(X_train, dtype=torch.float32) y_train = torch.tensor(y_train, dtype=torch.long)

# 开始训练
for epoch in range(epochs):
    # 模型训练
    model.train()
    optimizer.zero_grad()
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    loss.backward()
    optimizer.step()

    # 打印训练过程信息
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch + 1, epochs, loss.item()))

定义准确率函数

def accuracy(model, X, y): outputs = model(X) _, predicted = torch.max(outputs.data, 1) correct = (predicted == y).sum().item() total = y.size(0) acc = 100 * correct / total return acc

模型训练

第一次调用第一个模型

input_size = X_train.shape[1] hidden_size = 256 output_size = 8 model1 = Model1(input_size, hidden_size, output_size) optimizer1 = optim.Adam(model1.parameters(), lr=0.001) criterion1 = nn.CrossEntropyLoss() epochs = 100 train(model1, optimizer1, criterion1, X_train, y_train, epochs)

第二次调用第二个模型

input_size = output_size hidden_size = 128 output_size = 4 model2 = Model2(input_size, hidden_size, output_size) optimizer2 = optim.Adam(model2.parameters(), lr=0.001) criterion2 = nn.CrossEntropyLoss() epochs = 100 X_train = model1(X_train).detach().numpy() train(model2, optimizer2, criterion2, X_train, y_train, epochs)

第三次调用第三个模型

input_size = output_size hidden_size = 64 output_size = 2 model3 = Model3(input_size, hidden_size, output_size) optimizer3 = optim.Adam(model3.parameters(), lr=0.001) criterion3 = nn.CrossEntropyLoss() epochs = 100 X_train = model2(X_train).detach().numpy() train(model3, optimizer3, criterion3, X_train, y_train, epochs)

模型评估

评估模型3的准确率

X_test = torch.tensor(X_test, dtype=torch.float32) model3.eval() with torch.no_grad(): test_acc = accuracy(model3, X_test, y_test) print('Test Acc: {:.2f}%'.format(test_acc))