第R9周：阿尔兹海默症诊断（优化特征选择版）

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊

文章目录

1、导入数据
2、数据处理
2.1 患病占比
2.2 相关性分析
2.3 年龄与患病探究

3、特征选择
4、构建数据集
4.1 数据集划分与标准化
4.2 构建加载

5、构建模型
6、模型训练
6.1 构建训练函数
6.2 构建测试函数
6.3 设置超参数

7、模型训练
8、模型评估
8.1 结果图
8.2 混淆矩阵

电脑环境：
语言环境：Python 3.8.0
深度学习：torch 2.5.1+cu124

1、导入数据

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']
plt.rcParams['axes.unicode_minus'] = False
data_df = pd.read_csv('alzheimers_disease_data.csv')
data_df.head()

在这里插入图片描述

# 标签中文化
data_df.rename(columns={"Age": "年龄", "Gender": "性别", "Ethnicity": "种族", "EducationLevel": "教育水平", "BMI": "身体质量指数 (BMI)", "Smoking": "吸烟状况", "AlcoholConsumption": "酒精摄入量", "PhysicalActivity": "体育活动时间", 
                        "DietQuality": "饮食质量评分", "SleepQuality": "睡眠质量评分", "FamilyHistoryAlzheimers": "家族阿尔兹海默症病史", "CardiovascularDisease": "心血管疾病", "Diabetes": "糖尿病", "Depression": "抑郁病史", "HeadInjury": "头部受伤", "Hypertension": "高血压", 
                        "SystolicBP": "收缩压", "DiastolicBP": "舒张压", "CholesterolTotal": "胆固醇总量", "CholesterolLDL": "低密度脂蛋白胆固醇", "CholesterolHDL": "高密度脂蛋白胆固醇", "CholesterolTriglycerides": "甘油三酯", "MMSE": "简易精神状况检查得分", "FunctionalAssessment": "功能评估得分", "MemoryComplaints": "记忆抱怨", 
                        "BehavioralProblems": "行为问题", "ADL": "日常生活活动得分", "Confusion": "混乱与定向障碍", "Disorientation": "迷失方向", "PersonalityChanges": "人格变化", "DifficultyCompletingTasks": "完成任务困难", "Forgetfulness": "健忘", "Diagnosis": "诊断状态", "DoctorInCharge": "主治医生"},inplace=True)
data_df.columns

2、数据处理

data_df.isnull().sum()

	0
PatientID	0
年龄	0
性别	0
种族	0
教育水平	0
身体质量指数 (BMI)	0
吸烟状况	0
酒精摄入量	0
体育活动时间	0
饮食质量评分	0
睡眠质量评分	0
家族阿尔兹海默症病史	0
心血管疾病	0
糖尿病	0
抑郁病史	0
头部受伤	0
高血压	0
收缩压	0
舒张压	0
胆固醇总量	0
低密度脂蛋白胆固醇	0
高密度脂蛋白胆固醇	0
甘油三酯	0
简易精神状况检查得分	0
功能评估得分	0
记忆抱怨	0
行为问题	0
日常生活活动得分	0
混乱与定向障碍	0
迷失方向	0
人格变化	0
完成任务困难	0
健忘	0
诊断状态	0
主治医生	0

dtype: int64

from sklearn.preprocessing import LabelEncoder

# 创建LabelEncoder 实例
label_encoder = LabelEncoder()

# 对非数值型列进行标签编码
data_df['主治医生'] = label_encoder.fit_transform(data_df['主治医生'])

data_df.head()

	PatientID	年龄	性别	种族	教育水平	身体质量指数 (BMI)	吸烟状况	酒精摄入量	体育活动时间	饮食质量评分	...	记忆抱怨	行为问题	日常生活活动得分	混乱与定向障碍	迷失方向	人格变化	完成任务困难	健忘	诊断状态	主治医生
0	4751	73	0	0	2	22.927749	0	13.297218	6.327112	1.347214	...	0	0	1.725883	0	0	0	1	0	0	0
1	4752	89	0	0	0	26.827681	0	4.542524	7.619885	0.518767	...	0	0	2.592424	0	0	0	0	1	0	0
2	4753	73	0	3	1	17.795882	0	19.555085	7.844988	1.826335	...	0	0	7.119548	0	1	0	1	0	0	0
3	4754	74	1	0	1	33.800817	1	12.209266	8.428001	7.435604	...	0	1	6.481226	0	0	0	0	0	0	0
4	4755	89	0	0	0	20.716974	0	18.454356	6.310461	0.795498	...	0	0	0.014691	0	0	1	1	0	0	0
5 rows × 35 columns

2.1 患病占比

# 计算是否患病，人数
counts = data_df["诊断状态"].value_counts()
# 计算百分比
sizes = counts / counts.sum() * 100

# 绘制环形图
fig, ax = plt. subplots()
wedges, texts, autotexts = ax.pie(sizes, labels=sizes.index, autopct='%1.2ff%%', startangle=90, wedgeprops=dict(width=0.3))
plt.title("患病占比(1患病，Q没有患病)")
plt.show()

在这里插入图片描述

2.2 相关性分析

plt.figure(figsize=(40,35))
sns.heatmap(data_df.corr(), annot=True, fmt=".2f")
plt.show( )

在这里插入图片描述

2.3 年龄与患病探究

data_df['年龄'].min(), data_df['年龄'].max()

代码输出

(60, 90)

# 计算每一个年龄段患病人数
age_bins = range(60, 91)
grouped = data_df.groupby('年龄').agg({'诊断状态':['sum', 'size']})
grouped.columns=['患病','总人数']
grouped['不患病'] = grouped['总人数'] - grouped['患病'] #计算不患病的
# 设置绘图风格
sns.set(style="whitegrid")
plt.figure(figsize=(12, 5))
# 获取x轴标签（即年龄）
x = grouped.index.astype(str) # 将年龄转换为字符串格式便于显示
# 画图
plt.bar(x, grouped ["不患病"], 0.35, label="不患病", color='skyblue')
plt.bar(x,grouped["患病"], 0.35, label="患病", color='salmon')
# 设置标题
plt.title('患病年龄分布')
plt. xlabel("年龄")
plt.ylabel('人数')
plt.legend()
# 展示
plt.tight_layout()
plt.show()

在这里插入图片描述

3、特征选择

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report

data = data_df.copy()
X = data_df.iloc[:, 1:-2]
y = data_df.iloc[:, -2]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 标准化
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
# 模型创建
tree = DecisionTreeClassifier()
tree.fit(X_train, y_train)
pred = tree.predict(X_test)
reporter = classification_report(y_test, pred)
print(reporter)

代码输出

             precision    recall  f1-score   support

           0       0.93      0.92      0.93       277
           1       0.86      0.87      0.87       153

    accuracy                           0.90       430
   macro avg       0.90      0.90      0.90       430
weighted avg       0.90      0.90      0.90       430

# 特征展示
feature_importances = tree.feature_importances_
features_rf = pd.DataFrame({'特征':X.columns, '重要度': feature_importances})
features_rf.sort_values(by='重要度', ascending=False, inplace=True)
plt.figure(figsize=(20,10))
sns.barplot(x='重要度', y='特征', data=features_rf)
plt.xlabel('重要度')
plt.ylabel('特征')
plt.title('随机森林特征图')
plt.show()

在这里插入图片描述

from sklearn.feature_selection import RFE

# 使用 RFE 来选择特征
rfe_selector = RFE(estimator=tree, n_features_to_select=20)
rfe_selector.fit(X, y)
X_new = rfe_selector.transform(X)
feature_names = np.array(X.columns)
selected_feature_names = feature_names[rfe_selector. support_]
print(selected_feature_names)

代码输出

['年龄' '种族' '身体质量指数 (BMI)' '酒精摄入量' '体育活动时间' '饮食质量评分' '睡眠质量评分' '心血管疾病' '糖尿病'
 '收缩压' '舒张压' '胆固醇总量' '低密度脂蛋白胆固醇' '高密度脂蛋白胆固醇' '甘油三酯' '简易精神状况检查得分' '功能评估得分'
 '记忆抱怨' '行为问题' '日常生活活动得分']

4、构建数据集

4.1 数据集划分与标准化

feature_selection =['年龄','种族', '教育水平', '身体质量指数 (BMI)', '酒精摄入量', '体育活动时间', '饮食质量评分', '睡眠质量评分', '心血管疾病',
 '收缩压', '舒张压' ,'胆固醇总量' ,'低密度脂蛋白胆固醇' ,'高密度脂蛋白胆固醇', '甘油三酯', '简易精神状况检查得分', '功能评估得分',
 '记忆抱怨' ,'行为问题', '日常生活活动得分']
X = data_df[feature_selection]

# 标准化，标准化其实对应连续性数据，分类数据不适合，由于特征中只有种族是分类数
sc = StandardScaler()
X = sc.fit_transform(X)

X = torch.tensor(np.array(X), dtype=torch.float32)
y = torch.tensor(np.array(y), dtype=torch.long)
# 再次讲行特征诜择
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train.shape, y_train.shape

代码输出

(torch.Size([1719, 20]), torch.Size([1719]))

4.2 构建加载

batch_size = 32
train_dl = DataLoader(
    TensorDataset(X_train, y_train),
    batch_size=batch_size,
    shuffle=True)
test_dl = DataLoader(
    TensorDataset(X_test, y_test),
    batch_size=batch_size,
    shuffle=False)

5、构建模型

class Rnn_Model(nn.Module):
    def __init__(self):
        super().__init__()

        self.rnn = nn.RNN(input_size=20, hidden_size=200, num_layers=1, batch_first=True)
        self.fc1 = nn.Linear(200, 50)
        self.fc2 = nn.Linear(50, 2)

    def forward(self, x):
        x, hidden1 = self.rnn(x)
        x          = self.fc1(x)
        x            = self.fc2(x)
        return x

device = 'cpu'
model = Rnn_Model().to(device)
model

6、模型训练

6.1 构建训练函数

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小
    num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率

    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)

        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失

        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新

        # 记录acc与loss
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc  /= size
    train_loss /= num_batches

    return train_acc, train_loss

6.2 构建测试函数

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小
    num_batches = len(dataloader)          # 批次数目, (size/batch_size，向上取整)
    test_loss, test_acc = 0, 0

    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc  /= size
    test_loss /= num_batches

    return test_acc, test_loss

6.3 设置超参数

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-4
opt = torch.optim.Adam(model.parameters(), lr= learn_rate)

7、模型训练

epochs     = 50

train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

for epoch in range(epochs):

    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    # 获取当前的学习率
    lr = opt.state_dict()['param_groups'][0]['lr']

    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss,
                          epoch_test_acc*100, epoch_test_loss, lr))

print('Done')

模型输出

Epoch: 1, Train_acc:64.1%, Train_loss:0.655, Test_acc:66.0%, Test_loss:0.611, Lr:1.00E-04
Epoch: 2, Train_acc:67.9%, Train_loss:0.583, Test_acc:70.5%, Test_loss:0.560, Lr:1.00E-04
Epoch: 3, Train_acc:75.6%, Train_loss:0.530, Test_acc:75.3%, Test_loss:0.512, Lr:1.00E-04
Epoch: 4, Train_acc:78.5%, Train_loss:0.481, Test_acc:80.7%, Test_loss:0.463, Lr:1.00E-04
Epoch: 5, Train_acc:82.1%, Train_loss:0.435, Test_acc:81.9%, Test_loss:0.426, Lr:1.00E-04
Epoch: 6, Train_acc:83.3%, Train_loss:0.410, Test_acc:84.4%, Test_loss:0.407, Lr:1.00E-04
Epoch: 7, Train_acc:83.5%, Train_loss:0.390, Test_acc:84.4%, Test_loss:0.398, Lr:1.00E-04
Epoch: 8, Train_acc:84.1%, Train_loss:0.381, Test_acc:84.2%, Test_loss:0.394, Lr:1.00E-04
Epoch: 9, Train_acc:84.0%, Train_loss:0.377, Test_acc:84.0%, Test_loss:0.395, Lr:1.00E-04
Epoch:10, Train_acc:84.6%, Train_loss:0.378, Test_acc:83.7%, Test_loss:0.396, Lr:1.00E-04
Epoch:11, Train_acc:84.2%, Train_loss:0.372, Test_acc:85.1%, Test_loss:0.400, Lr:1.00E-04
Epoch:12, Train_acc:84.7%, Train_loss:0.373, Test_acc:84.2%, Test_loss:0.396, Lr:1.00E-04
Epoch:13, Train_acc:85.0%, Train_loss:0.372, Test_acc:84.4%, Test_loss:0.395, Lr:1.00E-04
Epoch:14, Train_acc:84.5%, Train_loss:0.372, Test_acc:84.4%, Test_loss:0.398, Lr:1.00E-04
Epoch:15, Train_acc:84.5%, Train_loss:0.373, Test_acc:83.7%, Test_loss:0.398, Lr:1.00E-04
Epoch:16, Train_acc:84.6%, Train_loss:0.374, Test_acc:83.5%, Test_loss:0.397, Lr:1.00E-04
Epoch:17, Train_acc:84.9%, Train_loss:0.372, Test_acc:83.7%, Test_loss:0.395, Lr:1.00E-04
Epoch:18, Train_acc:84.8%, Train_loss:0.370, Test_acc:84.7%, Test_loss:0.395, Lr:1.00E-04
Epoch:19, Train_acc:84.8%, Train_loss:0.371, Test_acc:84.0%, Test_loss:0.398, Lr:1.00E-04
Epoch:20, Train_acc:84.9%, Train_loss:0.371, Test_acc:83.7%, Test_loss:0.400, Lr:1.00E-04
Epoch:21, Train_acc:84.8%, Train_loss:0.371, Test_acc:84.7%, Test_loss:0.398, Lr:1.00E-04
Epoch:22, Train_acc:85.0%, Train_loss:0.371, Test_acc:84.2%, Test_loss:0.398, Lr:1.00E-04
Epoch:23, Train_acc:84.7%, Train_loss:0.371, Test_acc:84.4%, Test_loss:0.397, Lr:1.00E-04
Epoch:24, Train_acc:85.2%, Train_loss:0.371, Test_acc:84.2%, Test_loss:0.398, Lr:1.00E-04
Epoch:25, Train_acc:84.6%, Train_loss:0.371, Test_acc:84.4%, Test_loss:0.396, Lr:1.00E-04
Epoch:26, Train_acc:84.6%, Train_loss:0.374, Test_acc:84.4%, Test_loss:0.395, Lr:1.00E-04
Epoch:27, Train_acc:84.8%, Train_loss:0.370, Test_acc:84.0%, Test_loss:0.395, Lr:1.00E-04
Epoch:28, Train_acc:85.2%, Train_loss:0.368, Test_acc:84.2%, Test_loss:0.394, Lr:1.00E-04
Epoch:29, Train_acc:85.0%, Train_loss:0.372, Test_acc:82.8%, Test_loss:0.395, Lr:1.00E-04
Epoch:30, Train_acc:84.8%, Train_loss:0.371, Test_acc:83.5%, Test_loss:0.399, Lr:1.00E-04
Epoch:31, Train_acc:84.9%, Train_loss:0.369, Test_acc:84.0%, Test_loss:0.401, Lr:1.00E-04
Epoch:32, Train_acc:84.9%, Train_loss:0.372, Test_acc:84.7%, Test_loss:0.398, Lr:1.00E-04
Epoch:33, Train_acc:84.6%, Train_loss:0.372, Test_acc:84.0%, Test_loss:0.397, Lr:1.00E-04
Epoch:34, Train_acc:85.1%, Train_loss:0.369, Test_acc:84.7%, Test_loss:0.396, Lr:1.00E-04
Epoch:35, Train_acc:84.8%, Train_loss:0.371, Test_acc:84.2%, Test_loss:0.396, Lr:1.00E-04
Epoch:36, Train_acc:84.7%, Train_loss:0.372, Test_acc:84.0%, Test_loss:0.394, Lr:1.00E-04
Epoch:37, Train_acc:84.5%, Train_loss:0.367, Test_acc:84.2%, Test_loss:0.396, Lr:1.00E-04
Epoch:38, Train_acc:84.6%, Train_loss:0.374, Test_acc:84.2%, Test_loss:0.396, Lr:1.00E-04
Epoch:39, Train_acc:85.2%, Train_loss:0.368, Test_acc:84.2%, Test_loss:0.401, Lr:1.00E-04
Epoch:40, Train_acc:84.4%, Train_loss:0.373, Test_acc:84.4%, Test_loss:0.393, Lr:1.00E-04
Epoch:41, Train_acc:84.9%, Train_loss:0.369, Test_acc:83.7%, Test_loss:0.396, Lr:1.00E-04
Epoch:42, Train_acc:84.6%, Train_loss:0.368, Test_acc:84.0%, Test_loss:0.396, Lr:1.00E-04
Epoch:43, Train_acc:84.6%, Train_loss:0.372, Test_acc:83.7%, Test_loss:0.399, Lr:1.00E-04
Epoch:44, Train_acc:85.7%, Train_loss:0.369, Test_acc:84.0%, Test_loss:0.403, Lr:1.00E-04
Epoch:45, Train_acc:85.7%, Train_loss:0.372, Test_acc:84.0%, Test_loss:0.401, Lr:1.00E-04
Epoch:46, Train_acc:84.9%, Train_loss:0.371, Test_acc:83.7%, Test_loss:0.400, Lr:1.00E-04
Epoch:47, Train_acc:85.0%, Train_loss:0.368, Test_acc:83.7%, Test_loss:0.403, Lr:1.00E-04
Epoch:48, Train_acc:84.9%, Train_loss:0.371, Test_acc:84.4%, Test_loss:0.399, Lr:1.00E-04
Epoch:49, Train_acc:85.2%, Train_loss:0.371, Test_acc:84.2%, Test_loss:0.401, Lr:1.00E-04
Epoch:50, Train_acc:85.2%, Train_loss:0.372, Test_acc:84.0%, Test_loss:0.400, Lr:1.00E-04
Done

8、模型评估

8.1 结果图

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

from datetime import datetime
current_time = datetime.now()

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training Accuracy')
plt.xlabel(current_time)

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training=Loss')
plt.show()

在这里插入图片描述

8.2 混淆矩阵

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

pred = model(X_test.to(device)).argmax(1).cpu().numpy()

# 计算混淆矩阵
cm = confusion_matrix(y_test, pred)

plt.figure(figsize=(6,5))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')

# 标题
plt.title('Confusion Matrix', fontsize=12)
plt.xlabel('Predicted Label', fontsize=12)
plt.ylabel('True Labels', fontsize=10)

# 调整布局防止重叠
plt.tight_layout()

# 显示图形
plt.show()