山花落尽，我心犹青

1
pip install pandas numpy matplotlib seaborn scikit-learn xgboost lightgbm catboost torch
2

3
# 如果上面的命令太慢，用清华镜像源：
4
pip install pandas numpy matplotlib seaborn scikit-learn xgboost lightgbm catboost torch -i https://pypi.tuna.tsinghua.edu.cn/simple

1
# ========== 基础库 ==========
2
import pandas as pd               # pd 是约定的缩写，后面所有 pandas 操作用 pd.xxx
3
import numpy as np                # np 是约定的缩写
4
import matplotlib.pyplot as plt   # plt 是约定的缩写
5
import seaborn as sns             # 高级画图库
6
import warnings
7
warnings.filterwarnings('ignore') # 忽略警告信息，让输出更干净
8

9
# ========== 预处理 & 特征选择 ==========
10
from sklearn.preprocessing import StandardScaler, LabelEncoder
11
from sklearn.feature_selection import SelectKBest, f_classif, mutual_info_classif
12
from sklearn.decomposition import PCA
13

14
# ========== 无监督学习 ==========
15
from sklearn.cluster import KMeans, DBSCAN
16

17
# ========== 监督学习 ==========
18
from sklearn.svm import SVC
19
from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
20
from sklearn.ensemble import RandomForestClassifier
21

22
# ========== 模型评估 & 数据划分 ==========
23
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
24
from sklearn.metrics import (accuracy_score, classification_report,
25
                             confusion_matrix, silhouette_score,
26
                             davies_bouldin_score)
27

28
# ========== 三大 Boosting ==========
29
from xgboost import XGBClassifier
30
from lightgbm import LGBMClassifier
31
from catboost import CatBoostClassifier
32

33
# ========== 深度学习 ==========
34
import torch
35
import torch.nn as nn
36
import torch.optim as optim
37
from torch.utils.data import DataLoader, TensorDataset

1
# pd.read_csv() 是最常用的函数，把 CSV 变成 DataFrame（表格）
2
df = pd.read_csv('bcg_data.csv')
3

4
# 如果你的 CSV 和 Python 文件不在同一目录，写完整路径：
5
# df = pd.read_csv(r'D:\Users\Jay\Desktop\机器学习\期末\bcg_data.csv')
6
# 注意：路径前面的 r 表示"原始字符串"，避免 \ 被当成转义符

1
# 看前 5 行
2
df.head()
3
# df.head(10)  看前 10 行
4

5
# 看后 5 行
6
df.tail()
7

8
# 看数据形状：(行数, 列数)
9
df.shape
10
# 输出类似 (10890, 31)，表示 10890 行，31 列
11

12
# 看列名
13
df.columns.tolist()
14
# .tolist() 把列名转成列表，方便复制
15

16
# 看每列的数据类型
17
df.dtypes
18
# int64 是整数，float64 是小数（浮点数），object 是文本
19

20
# 看基本统计信息（均值、标准差、最小值、最大值等）
21
df.describe()
22
# 这个函数非常重要！可以快速发现异常值

1
# 每一列有多少缺失值
2
df.isnull().sum()
3
# isnull() 判断每个格子是否为空，sum() 把 True 的数量加起来
4

5
# 缺失值占总数的比例
6
df.isnull().sum() / len(df) * 100
7
# len(df) 是总行数，乘以 100 得到百分比

1
# 设置中文显示（Windows 用 SimHei，Mac 用 Arial Unicode MS）
2
plt.rcParams['font.sans-serif'] = ['SimHei']
3
plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题
4

5
# 画所有列的分布直方图
6
df.hist(figsize=(20, 20), bins=50)
7
# figsize 是图片大小（英寸），bins 是柱子数量
8
plt.tight_layout()  # 自动调整子图间距
9
plt.show()
10

11
# 画相关系数热力图（看哪些特征彼此相关）
12
plt.figure(figsize=(20, 16))
13
# 只选数值列计算相关性
14
corr = df.corr()
15
sns.heatmap(corr, annot=False, cmap='coolwarm', center=0)
16
# annot=True 会在格子里写数字（列太多会很挤，所以这里用 False）
17
# cmap 是颜色主题，center=0 让 0 是白色
18
plt.title('特征相关系数热力图')
19
plt.show()

1
# 方法一：用该列的均值填充
2
df.fillna(df.mean(), inplace=True)
3
# fillna() 填充空值，df.mean() 计算每列的均值
4
# inplace=True 表示直接在原数据上修改，不需要重新赋值
5

6
# 方法二：用中位数填充（如果数据有极端值，中位数更好）
7
# df.fillna(df.median(), inplace=True)
8

9
# 方法三：直接删除有空值的行
10
# df.dropna(inplace=True)

1
# 有些计算会产生无穷大，需要替换
2
df.replace([np.inf, -np.inf], np.nan, inplace=True)
3
# 先把 inf 变成 nan
4
df.fillna(df.mean(), inplace=True)
5
# 再用均值填充

1
# StandardScaler：把每列变成 均值=0、标准差=1 的分布
2
scaler = StandardScaler()
3
# 先拟合（计算均值和标准差），再转换
4
df_scaled = scaler.fit_transform(df)
5
# fit_transform 返回的是 numpy 数组，不是 DataFrame
6

7
# 转回 DataFrame（方便后续操作）
8
df_scaled = pd.DataFrame(df_scaled, columns=df.columns)
9
# pd.DataFrame(数据, columns=列名) 把数组变成 DataFrame
10

11
# 查看标准化后的数据
12
df_scaled.describe()
13
# 现在每列的 mean 应该接近 0，std 接近 1

1
from sklearn.feature_selection import VarianceThreshold
2

3
# 方差接近 0 的特征意味着这一列的值几乎不变，没有区分能力
4
selector = VarianceThreshold(threshold=0.01)
5
# threshold 是阈值，方差小于这个值的特征会被删除
6
selector.fit(df_scaled)
7

8
# 查看哪些特征被保留了
9
selected_features = df_scaled.columns[selector.get_support()].tolist()
10
print(f'保留的特征 ({len(selected_features)}/31):')
11
print(selected_features)
12

13
# 获取保留后的数据
14
df_filtered = pd.DataFrame(selector.transform(df_scaled),
15
                           columns=selected_features)

1
# 计算相关系数矩阵
2
corr_matrix = df_scaled.corr().abs()
3
# .abs() 取绝对值，因为我们只关心相关程度，不关心正负
4

5
# 找出相关系数 > 0.95 的特征对
6
high_corr_cols = []
7
# 只检查上三角矩阵（避免重复）
8
upper_tri = corr_matrix.where(
9
    np.triu(np.ones(corr_matrix.shape), k=1).astype(bool)
10
)
11

12
for col in upper_tri.columns:
13
    # any() 检查这一列是否有 True
14
    if (upper_tri[col] > 0.95).any():
15
        high_corr_cols.append(col)
16

17
print(f'高度相关的特征（建议删除）: {high_corr_cols}')
18

19
# 删除高度相关的特征
20
df_selected = df_scaled.drop(columns=high_corr_cols)
21
# drop(columns=...) 删除指定的列

1
# 假设 y 是标签（后面聚类会创建）
2
# selector = SelectKBest(score_func=f_classif, k=15)
3
# # f_classif 是 ANOVA F 检验，k=15 表示选 15 个最好的特征
4
# X_selected = selector.fit_transform(X, y)
5
#
6
# # 查看选中的特征
7
# selected_mask = selector.get_support()
8
# selected_features = X.columns[selected_mask].tolist()
9
# print(f'选中的特征: {selected_features}')
10
#
11
# # 每个特征的得分
12
# feature_scores = pd.DataFrame({
13
#     '特征': X.columns,
14
#     '得分': selector.scores_
15
# }).sort_values('得分', ascending=False)
16
# print(feature_scores)

1
# 先看需要多少主成分才能保留 95% 的信息
2
pca = PCA()
3
pca.fit(df_scaled)
4

5
# 画累计解释方差图
6
plt.figure(figsize=(10, 6))
7
plt.plot(range(1, len(pca.explained_variance_ratio_) + 1),
8
         np.cumsum(pca.explained_variance_ratio_), 'bo-')
9
# cumsum 是累计求和
10
plt.axhline(y=0.95, color='r', linestyle='--', label='95% 阈值')
11
plt.xlabel('主成分数量')
12
plt.ylabel('累计解释方差比例')
13
plt.legend()
14
plt.show()
15

16
# 根据图选择合适的主成分数量，比如 10
17
pca = PCA(n_components=10)
18
df_pca = pca.fit_transform(df_scaled)
19
df_pca = pd.DataFrame(df_pca, columns=[f'PC{i+1}' for i in range(10)])
20
# [f'PC{i+1}' for i in range(10)] 生成 ['PC1', 'PC2', ..., 'PC10']
21

22
print(f'前 10 个主成分保留了 {pca.explained_variance_ratio_.sum():.2%} 的信息')
23
# :.2% 表示以百分比形式显示，保留两位小数

1
# 尝试 K=1 到 K=15，记录每个 K 的误差
2
inertia_list = []  # 惯性值，即所有点到其簇中心距离的平方和
3

4
for k in range(1, 16):
5
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
6
    # n_clusters=k：想要分几个簇
7
    # random_state=42：固定随机种子，让结果可复现
8
    # n_init=10：用不同初始点跑 10 次，选最好的
9
    kmeans.fit(df_scaled)
10
    inertia_list.append(kmeans.inertia_)
11

12
# 画肘部图
13
plt.figure(figsize=(10, 6))
14
plt.plot(range(1, 16), inertia_list, 'bo-')
15
plt.xlabel('K 值（簇的数量）')
16
plt.ylabel('惯性值（Inertia）')
17
plt.title('肘部法则 - 选择最佳 K 值')
18
plt.show()

1
from sklearn.metrics import silhouette_score
2

3
silhouette_scores = []
4

5
for k in range(2, 11):  # 轮廓系数需要至少 2 个簇
6
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
7
    labels = kmeans.fit_predict(df_scaled)
8
    # fit_predict 既训练又返回标签
9
    score = silhouette_score(df_scaled, labels)
10
    silhouette_scores.append(score)
11

12
# 画轮廓系数图
13
plt.figure(figsize=(10, 6))
14
plt.plot(range(2, 11), silhouette_scores, 'ro-')
15
plt.xlabel('K 值')
16
plt.ylabel('轮廓系数')
17
plt.title('轮廓系数 - 选择最佳 K 值')
18
plt.show()
19

20
# 最佳 K 值
21
best_k = range(2, 11)[np.argmax(silhouette_scores)]
22
print(f'轮廓系数最高的 K 值: {best_k}')

1
# 用你确定的 K 值（这里假设 K=3，根据你的肘部图和轮廓系数调整）
2
k_best = 3
3
kmeans = KMeans(n_clusters=k_best, random_state=42, n_init=10)
4
kmeans_labels = kmeans.fit_predict(df_scaled)
5

6
# 查看每个簇有多少样本
7
unique, counts = np.unique(kmeans_labels, return_counts=True)
8
# np.unique 返回不重复的值和它们的计数
9
for cluster, count in zip(unique, counts):
10
    print(f'簇 {cluster}: {count} 个样本 ({count/len(kmeans_labels)*100:.1f}%)')
11

12
# 把聚类标签加到数据中
13
df['kmeans_cluster'] = kmeans_labels
14
df_scaled['kmeans_cluster'] = kmeans_labels

1
# 降到 2 维便于画图
2
pca_2d = PCA(n_components=2)
3
df_2d = pca_2d.fit_transform(df_scaled.drop(columns=['kmeans_cluster']))
4

5
plt.figure(figsize=(10, 8))
6
scatter = plt.scatter(df_2d[:, 0], df_2d[:, 1],
7
                      c=kmeans_labels, cmap='viridis', alpha=0.6, s=10)
8
# c：颜色依据，cmap：颜色主题，alpha：透明度，s：点的大小
9
plt.colorbar(scatter, label='簇')
10
plt.xlabel(f'PC1 ({pca_2d.explained_variance_ratio_[0]:.1%})')
11
plt.ylabel(f'PC2 ({pca_2d.explained_variance_ratio_[1]:.1%})')
12
plt.title('KMeans 聚类结果 (PCA 2D 可视化)')
13
plt.show()

1
# 按簇分组，看每一列在不同簇中的均值
2
cluster_profile = df.groupby('kmeans_cluster').mean()
3
# groupby().mean() 按某个列分组，然后计算其他列的均值
4
print(cluster_profile.T)  # .T 转置，行变列，方便看
5

6
# 画出每个簇的特征雷达图（选几个重要特征）
7
# 或画箱线图看某个特征在不同簇中的分布
8
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
9
axes = axes.flatten()
10
# 选 6 个特征画分布
11
for i, col in enumerate(df.columns[:6]):
12
    df.boxplot(column=col, by='kmeans_cluster', ax=axes[i])
13
    axes[i].set_title(col)
14
    axes[i].set_xlabel('簇')
15
plt.suptitle('')
16
plt.tight_layout()
17
plt.show()

1
from sklearn.neighbors import NearestNeighbors
2

3
# 找每个点的第 k 近邻的距离
4
k = 5  # 一般用 min_samples 的值
5
neigh = NearestNeighbors(n_neighbors=k)
6
neigh.fit(df_scaled)
7
distances, _ = neigh.kneighbors(df_scaled)
8
# distances 每一行是该点的 k 个最近邻居的距离
9
# 我们取第 k 近的距离（即最远的那个邻居的距离）
10
k_distances = np.sort(distances[:, -1])  # [:, -1] 取最后一列，即第 k 近的距离
11

12
# 画 k 距离图
13
plt.figure(figsize=(12, 6))
14
plt.plot(k_distances)
15
plt.xlabel('数据点（按距离排序）')
16
plt.ylabel(f'到第 {k} 近邻的距离')
17
plt.title('K-距离图（用于选择 eps）')
18
plt.axhline(y=np.percentile(k_distances, 90), color='r', linestyle='--',
19
            label='90% 分位数')
20
plt.legend()
21
plt.show()

1
# 根据 K-距离图选择合适的 eps（这里用 0.5 做示例，请根据你的图调整）
2
dbscan = DBSCAN(eps=0.5, min_samples=10)
3
dbscan_labels = dbscan.fit_predict(df_scaled)
4

5
# 查看结果
6
n_clusters = len(set(dbscan_labels)) - (1 if -1 in dbscan_labels else 0)
7
n_noise = list(dbscan_labels).count(-1)
8
print(f'发现的簇数量: {n_clusters}')
9
print(f'噪声点数量: {n_noise} ({n_noise/len(dbscan_labels)*100:.1f}%)')
10

11
# 每个簇的样本数
12
for label in sorted(set(dbscan_labels)):
13
    count = list(dbscan_labels).count(label)
14
    if label == -1:
15
        print(f'噪声: {count} 个样本')
16
    else:
17
        print(f'簇 {label}: {count} 个样本')

1
# 如果簇太少或噪声太多，调整参数：
2
# 增大 eps → 更多点被包含，簇变大变少
3
# 减小 eps → 更严格的邻域条件，簇变小变多，噪声增加
4
# 减小 min_samples → 更容易形成簇
5
# 增大 min_samples → 更难形成簇
6

7
# 尝试不同参数组合
8
param_list = [
9
    (0.3, 5), (0.5, 5), (0.7, 5),
10
    (0.3, 10), (0.5, 10), (0.7, 10),
11
    (1.0, 10), (1.5, 10),
12
]
13

14
for eps, min_samp in param_list:
15
    db = DBSCAN(eps=eps, min_samples=min_samp)
16
    labels = db.fit_predict(df_scaled)
17
    n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
18
    n_noise = list(labels).count(-1)
19
    print(f'eps={eps}, min_samples={min_samp}: '
20
          f'{n_clusters} 个簇, {n_noise} 个噪声点')
21

22
# 选最好的一组参数做最终结果
23
dbscan = DBSCAN(eps=你选的eps, min_samples=你选的min_samples)
24
dbscan_labels = dbscan.fit_predict(df_scaled)
25

26
# 保存标签
27
df['dbscan_cluster'] = dbscan_labels
28
df_scaled['dbscan_cluster'] = dbscan_labels

1
# 降到 2 维画图
2
pca_db = PCA(n_components=2)
3
df_db_2d = pca_db.fit_transform(df_scaled.drop(columns=['dbscan_cluster', 'kmeans_cluster'],
4
                                                 errors='ignore'))
5

6
plt.figure(figsize=(10, 8))
7
# 噪声点用黑色，其他用不同颜色
8
scatter = plt.scatter(df_db_2d[:, 0], df_db_2d[:, 1],
9
                      c=dbscan_labels, cmap='tab10', alpha=0.6, s=10)
10
plt.colorbar(scatter, label='簇 (-1 表示噪声)')
11
plt.xlabel(f'PC1')
12
plt.ylabel(f'PC2')
13
plt.title('DBSCAN 聚类结果 (PCA 2D 可视化)')
14
plt.show()

1
# X：特征矩阵（所有 31 列原始特征）
2
X = df_scaled.drop(columns=['kmeans_cluster', 'dbscan_cluster'], errors='ignore')
3

4
# y：标签（用 KMeans 的聚类结果）
5
y = df_scaled['kmeans_cluster'].astype(int)
6
# astype(int) 把标签转成整数
7

8
# 如果 KMeans 结果不好，尝试用 DBSCAN 的标签
9
# 但要去掉噪声点（标签=-1）
10
# mask = df['dbscan_cluster'] != -1
11
# X = X[mask]
12
# y = df['dbscan_cluster'][mask].astype(int)
13

14
print(f'X 的形状: {X.shape}')
15
print(f'y 的形状: {y.shape}')
16
print(f'y 的分布:\n{y.value_counts()}')
17
# value_counts() 统计每个值出现了多少次

1
X_train, X_test, y_train, y_test = train_test_split(
2
    X, y,
3
    test_size=0.2,      # 20% 的数据用于测试
4
    random_state=42,     # 固定随机种子
5
    stratify=y           # 保持训练集和测试集的类别比例一致
6
)
7
# train_test_split 返回 4 个值，按顺序接收
8
# X_train：训练集特征
9
# X_test：测试集特征
10
# y_train：训练集标签
11
# y_test：测试集标签
12

13
print(f'训练集: {X_train.shape[0]} 个样本')
14
print(f'测试集: {X_test.shape[0]} 个样本')

1
# ========== SelectKBest：选最好的 K 个特征 ==========
2
selector = SelectKBest(score_func=f_classif, k=15)
3
# f_classif 使用 ANOVA F 检验
4
selector.fit(X_train, y_train)
5

6
# 每个特征的得分，按从高到低排序
7
feature_scores = pd.DataFrame({
8
    '特征': X.columns,
9
    'F值': selector.scores_,
10
    'P值': selector.pvalues_
11
}).sort_values('F值', ascending=False)
12
print('特征重要性排名（前15）:')
13
print(feature_scores.head(15))
14

15
# 获取选中的特征
16
selected_features = X.columns[selector.get_support()].tolist()
17
print(f'\n选中的特征: {selected_features}')
18

19
# 用选中的特征重新构造数据
20
X_train_selected = selector.transform(X_train)
21
X_test_selected = selector.transform(X_test)
22
print(f'特征选择后的形状: {X_train_selected.shape}')

1
# 随机森林可以给出特征重要性
2
rf = RandomForestClassifier(n_estimators=100, random_state=42)
3
rf.fit(X_train, y_train)
4

5
# 特征重要性
6
feature_importance = pd.DataFrame({
7
    '特征': X.columns,
8
    '重要性': rf.feature_importances_
9
}).sort_values('重要性', ascending=False)
10
print('随机森林特征重要性排名（前15）:')
11
print(feature_importance.head(15))
12

13
# 画特征重要性图
14
plt.figure(figsize=(12, 8))
15
plt.barh(feature_importance['特征'][:15][::-1],
16
         feature_importance['重要性'][:15][::-1])
17
# [::-1] 反转顺序，让最大的在上面
18
plt.xlabel('重要性')
19
plt.title('随机森林 - 特征重要性 Top 15')
20
plt.tight_layout()
21
plt.show()

1
# 创建 SVM 分类器
2
svm = SVC(kernel='rbf',          # 核函数：'rbf'（高斯核）、'linear'（线性）、'poly'（多项式）
3
          C=1.0,                  # 正则化参数：越大越不允许分错，越小容错越多
4
          gamma='scale',          # 核函数系数：'scale' 自动计算，'auto' 或用数值
5
          random_state=42)
6

7
# 训练
8
svm.fit(X_train_selected, y_train)
9

10
# 预测
11
y_pred_svm = svm.predict(X_test_selected)
12

13
# 计算准确率
14
accuracy_svm = accuracy_score(y_test, y_pred_svm)
15
print(f'SVM 准确率: {accuracy_svm:.4f} ({accuracy_svm*100:.2f}%)')
16
# :.4f 表示保留 4 位小数

1
# 分类报告（精确率、召回率、F1 分数）
2
print('\n分类报告:')
3
print(classification_report(y_test, y_pred_svm))
4

5
# 混淆矩阵
6
cm = confusion_matrix(y_test, y_pred_svm)
7
print('\n混淆矩阵:')
8
print(cm)
9

10
# 画混淆矩阵热力图
11
plt.figure(figsize=(8, 6))
12
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
13
# annot=True 显示数字，fmt='d' 整数格式
14
plt.xlabel('预测标签')
15
plt.ylabel('真实标签')
16
plt.title(f'SVM 混淆矩阵 (Accuracy: {accuracy_svm:.2%})')
17
plt.show()

1
# 定义要尝试的参数组合
2
param_grid = {
3
    'C': [0.1, 1, 10, 100],
4
    'gamma': ['scale', 'auto', 0.1, 0.01, 0.001],
5
    'kernel': ['rbf', 'linear']
6
}
7

8
# 网格搜索
9
grid_svm = GridSearchCV(
10
    SVC(random_state=42),
11
    param_grid,
12
    cv=3,              # 3 折交叉验证
13
    scoring='accuracy', # 用准确率作为评价标准
14
    n_jobs=-1,          # 并行计算，-1 表示用所有 CPU
15
    verbose=1           # 显示进度
16
)
17
grid_svm.fit(X_train_selected, y_train)
18

19
print(f'最佳参数: {grid_svm.best_params_}')
20
print(f'最佳交叉验证准确率: {grid_svm.best_score_:.4f}')
21

22
# 用最佳模型预测
23
y_pred_best_svm = grid_svm.best_estimator_.predict(X_test_selected)
24
accuracy_best_svm = accuracy_score(y_test, y_pred_best_svm)
25
print(f'调参后 SVM 测试集准确率: {accuracy_best_svm:.4f}')

1
# 创建 XGBoost 分类器
2
xgb = XGBClassifier(
3
    n_estimators=100,       # 树的数量
4
    max_depth=6,            # 每棵树的最大深度
5
    learning_rate=0.1,      # 学习率（每棵树的贡献权重）
6
    subsample=0.8,          # 每棵树随机采样 80% 的数据
7
    colsample_bytree=0.8,   # 每棵树随机采样 80% 的特征
8
    random_state=42,
9
    eval_metric='mlogloss', # 评估指标：多分类对数损失
10
    use_label_encoder=False # 新版 xgboost 需要这个
11
)
12

13
# 训练
14
xgb.fit(X_train_selected, y_train)
15

16
# 预测
17
y_pred_xgb = xgb.predict(X_test_selected)
18
accuracy_xgb = accuracy_score(y_test, y_pred_xgb)
19
print(f'XGBoost 准确率: {accuracy_xgb:.4f} ({accuracy_xgb*100:.2f}%)')
20

21
print('\n分类报告:')
22
print(classification_report(y_test, y_pred_xgb))

1
# 画特征重要性
2
plt.figure(figsize=(12, 8))
3
# xgb.feature_importances_ 给出每个特征的重要性分数
4
importance_df = pd.DataFrame({
5
    '特征': selected_features,
6
    '重要性': xgb.feature_importances_
7
}).sort_values('重要性', ascending=True)
8

9
plt.barh(importance_df['特征'], importance_df['重要性'])
10
plt.xlabel('重要性')
11
plt.title('XGBoost 特征重要性')
12
plt.tight_layout()
13
plt.show()

1
# 简化版网格搜索
2
param_grid_xgb = {
3
    'max_depth': [3, 5, 7],
4
    'learning_rate': [0.01, 0.1, 0.3],
5
    'n_estimators': [100, 200],
6
}
7

8
grid_xgb = GridSearchCV(
9
    XGBClassifier(random_state=42, eval_metric='mlogloss', use_label_encoder=False),
10
    param_grid_xgb,
11
    cv=3,
12
    scoring='accuracy',
13
    n_jobs=-1,
14
    verbose=1
15
)
16
grid_xgb.fit(X_train_selected, y_train)
17

18
print(f'最佳参数: {grid_xgb.best_params_}')
19
print(f'最佳交叉验证准确率: {grid_xgb.best_score_:.4f}')
20

21
best_xgb = grid_xgb.best_estimator_
22
y_pred_best_xgb = best_xgb.predict(X_test_selected)
23
accuracy_best_xgb = accuracy_score(y_test, y_pred_best_xgb)
24
print(f'调参后 XGBoost 准确率: {accuracy_best_xgb:.4f}')

1
# 创建 LightGBM 分类器
2
lgb = LGBMClassifier(
3
    n_estimators=100,
4
    max_depth=6,
5
    learning_rate=0.1,
6
    subsample=0.8,
7
    colsample_bytree=0.8,
8
    random_state=42,
9
    verbose=-1  # -1 表示不输出训练信息
10
)
11

12
# 训练
13
lgb.fit(X_train_selected, y_train)
14

15
# 预测
16
y_pred_lgb = lgb.predict(X_test_selected)
17
accuracy_lgb = accuracy_score(y_test, y_pred_lgb)
18
print(f'LightGBM 准确率: {accuracy_lgb:.4f} ({accuracy_lgb*100:.2f}%)')
19

20
print('\n分类报告:')
21
print(classification_report(y_test, y_pred_lgb))

1
plt.figure(figsize=(12, 8))
2
importance_lgb = pd.DataFrame({
3
    '特征': selected_features,
4
    '重要性': lgb.feature_importances_
5
}).sort_values('重要性', ascending=True)
6

7
plt.barh(importance_lgb['特征'], importance_lgb['重要性'])
8
plt.xlabel('重要性')
9
plt.title('LightGBM 特征重要性')
10
plt.tight_layout()
11
plt.show()

1
param_grid_lgb = {
2
    'max_depth': [3, 5, 7],
3
    'learning_rate': [0.01, 0.1, 0.3],
4
    'n_estimators': [100, 200],
5
    'num_leaves': [31, 63, 127],  # LightGBM 特有参数，控制叶子数量
6
}
7

8
grid_lgb = GridSearchCV(
9
    LGBMClassifier(random_state=42, verbose=-1),
10
    param_grid_lgb,
11
    cv=3,
12
    scoring='accuracy',
13
    n_jobs=-1,
14
    verbose=1
15
)
16
grid_lgb.fit(X_train_selected, y_train)
17

18
print(f'最佳参数: {grid_lgb.best_params_}')
19
best_lgb = grid_lgb.best_estimator_
20
y_pred_best_lgb = best_lgb.predict(X_test_selected)
21
accuracy_best_lgb = accuracy_score(y_test, y_pred_best_lgb)
22
print(f'调参后 LightGBM 准确率: {accuracy_best_lgb:.4f}')

1
# 创建 CatBoost 分类器
2
cat = CatBoostClassifier(
3
    iterations=100,          # 等同于 n_estimators
4
    depth=6,                 # 等同于 max_depth
5
    learning_rate=0.1,
6
    random_seed=42,
7
    verbose=0,               # 0 表示不输出训练信息
8
    thread_count=-1          # 使用所有 CPU 核心
9
)
10

11
# 训练
12
cat.fit(X_train_selected, y_train)
13

14
# 预测
15
y_pred_cat = cat.predict(X_test_selected)
16
# 注意：CatBoost 的 predict 返回的是 1D 数组，需要 ravel()
17
y_pred_cat = y_pred_cat.ravel()
18
accuracy_cat = accuracy_score(y_test, y_pred_cat)
19
print(f'CatBoost 准确率: {accuracy_cat:.4f} ({accuracy_cat*100:.2f}%)')
20

21
print('\n分类报告:')
22
print(classification_report(y_test, y_pred_cat))

1
plt.figure(figsize=(12, 8))
2
importance_cat = pd.DataFrame({
3
    '特征': selected_features,
4
    '重要性': cat.feature_importances_
5
}).sort_values('重要性', ascending=True)
6

7
plt.barh(importance_cat['特征'], importance_cat['重要性'])
8
plt.xlabel('重要性')
9
plt.title('CatBoost 特征重要性')
10
plt.tight_layout()
11
plt.show()

1
# PyTorch 需要 numpy 数组或 tensor
2
X_train_tensor = torch.FloatTensor(X_train_selected)
3
# FloatTensor：浮点数张量
4
y_train_tensor = torch.LongTensor(y_train.values)
5
# LongTensor：整数张量（用于分类标签）
6
X_test_tensor = torch.FloatTensor(X_test_selected)
7
y_test_tensor = torch.LongTensor(y_test.values)
8

9
# 创建 DataLoader（批量加载数据）
10
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
11
# TensorDataset 把特征和标签打包在一起
12
test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
13

14
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
15
# batch_size=64：每次取 64 个样本训练
16
# shuffle=True：每个 epoch 打乱数据顺序
17
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

1
class MLP(nn.Module):
2
    """多层感知机"""
3
    def __init__(self, input_dim, hidden_dim, output_dim):
4
        super(MLP, self).__init__()
5
        # nn.Sequential 把多个层串在一起
6
        self.model = nn.Sequential(
7
            nn.Linear(input_dim, hidden_dim),   # 全连接层 1：输入 → 隐藏
8
            nn.ReLU(),                            # ReLU 激活函数
9
            nn.Dropout(0.3),                      # Dropout：随机丢弃 30% 神经元，防过拟合
10
            nn.Linear(hidden_dim, hidden_dim),  # 全连接层 2：隐藏 → 隐藏
11
            nn.ReLU(),
12
            nn.Dropout(0.3),
13
            nn.Linear(hidden_dim, output_dim)   # 全连接层 3：隐藏 → 输出
14
        )
15

16
    def forward(self, x):
17
        # 前向传播：数据从输入到输出的流向
18
        return self.model(x)
19

20
# 实例化模型
21
input_dim = X_train_selected.shape[1]  # 输入维度 = 特征数量
22
hidden_dim = 128                         # 隐藏层神经元数量（可调整）
23
output_dim = len(np.unique(y))           # 输出维度 = 类别数量
24

25
model = MLP(input_dim, hidden_dim, output_dim)
26
print(model)

1
# 损失函数：交叉熵（分类问题的标准选择）
2
criterion = nn.CrossEntropyLoss()
3
# CrossEntropyLoss = log(Softmax) + NLLLoss
4
# 它会自动对模型输出做 softmax 再计算损失
5

6
# 优化器：Adam（目前最常用的优化器）
7
optimizer = optim.Adam(model.parameters(), lr=0.001)
8
# model.parameters() 返回模型所有可训练的参数
9
# lr=0.001 是学习率

1
num_epochs = 50  # 完整遍历整个训练集的次数
2
train_losses = []
3
test_accuracies = []
4

5
for epoch in range(num_epochs):
6
    # ===== 训练阶段 =====
7
    model.train()  # 切换到训练模式（启用 Dropout）
8
    total_loss = 0
9

10
    for batch_X, batch_y in train_loader:
11
        # 前向传播
12
        outputs = model(batch_X)
13
        loss = criterion(outputs, batch_y)
14

15
        # 反向传播（三大步骤）
16
        optimizer.zero_grad()   # 1. 清空之前的梯度
17
        loss.backward()         # 2. 计算梯度
18
        optimizer.step()        # 3. 更新参数
19

20
        total_loss += loss.item()
21
        # loss.item() 把 PyTorch 的 loss 值转成 Python 数字
22

23
    avg_loss = total_loss / len(train_loader)
24
    train_losses.append(avg_loss)
25

26
    # ===== 测试阶段 =====
27
    model.eval()  # 切换到评估模式（关闭 Dropout）
28
    correct = 0
29
    total = 0
30

31
    with torch.no_grad():  # 不计算梯度，节省内存和加速
32
        for batch_X, batch_y in test_loader:
33
            outputs = model(batch_X)
34
            _, predicted = torch.max(outputs, 1)
35
            # torch.max(outputs, 1) 返回 (最大值, 最大值的索引)
36
            # 索引就是预测的类别
37
            total += batch_y.size(0)
38
            correct += (predicted == batch_y).sum().item()
39

40
    accuracy = correct / total
41
    test_accuracies.append(accuracy)
42

43
    if (epoch + 1) % 10 == 0:  # 每 10 轮打印一次
44
        print(f'Epoch [{epoch+1}/{num_epochs}], '
45
              f'Loss: {avg_loss:.4f}, '
46
              f'Test Accuracy: {accuracy:.4f}')
47

48
print(f'\nMLP 最终测试准确率: {test_accuracies[-1]*100:.2f}%')

1
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
2

3
# 损失曲线
4
ax1.plot(train_losses)
5
ax1.set_xlabel('Epoch')
6
ax1.set_ylabel('Loss')
7
ax1.set_title('训练损失曲线')
8

9
# 准确率曲线
10
ax2.plot(test_accuracies)
11
ax2.set_xlabel('Epoch')
12
ax2.set_ylabel('Accuracy')
13
ax2.set_title('测试准确率曲线')
14

15
plt.tight_layout()
16
plt.show()

1
# ===== Entropy 决策树 =====
2
dt_entropy = DecisionTreeClassifier(
3
    criterion='entropy',    # 用信息增益（基于熵）来分裂
4
    max_depth=5,            # 树的最大深度（限制深度可以防止过拟合，也让规则更简洁）
5
    min_samples_split=50,   # 一个节点至少要有 50 个样本才能继续分裂
6
    min_samples_leaf=20,    # 叶子节点至少要有 20 个样本
7
    random_state=42
8
)
9

10
dt_entropy.fit(X_train_selected, y_train)
11

12
# 预测和评估
13
y_pred_entropy = dt_entropy.predict(X_test_selected)
14
accuracy_entropy = accuracy_score(y_test, y_pred_entropy)
15
print(f'决策树 (Entropy) 准确率: {accuracy_entropy:.4f} ({accuracy_entropy*100:.2f}%)')
16
print(f'树的深度: {dt_entropy.get_depth()}')
17
print(f'叶子节点数量: {dt_entropy.get_n_leaves()}')

1
# ===== Gini 决策树 =====
2
dt_gini = DecisionTreeClassifier(
3
    criterion='gini',       # 用基尼系数来分裂
4
    max_depth=5,
5
    min_samples_split=50,
6
    min_samples_leaf=20,
7
    random_state=42
8
)
9

10
dt_gini.fit(X_train_selected, y_train)
11

12
y_pred_gini = dt_gini.predict(X_test_selected)
13
accuracy_gini = accuracy_score(y_test, y_pred_gini)
14
print(f'决策树 (Gini) 准确率: {accuracy_gini:.4f} ({accuracy_gini*100:.2f}%)')
15
print(f'树的深度: {dt_gini.get_depth()}')
16
print(f'叶子节点数量: {dt_gini.get_n_leaves()}')

1
# 用特征的原始名字导出规则
2
# export_text 把决策树转成可读的文本规则
3
rules_entropy = export_text(dt_entropy,
4
                            feature_names=list(selected_features))
5
print("=" * 60)
6
print("===== Entropy 决策树规则 =====")
7
print("=" * 60)
8
print(rules_entropy)
9

10
print("\n\n")
11

12
rules_gini = export_text(dt_gini,
13
                         feature_names=list(selected_features))
14
print("=" * 60)
15
print("===== Gini 决策树规则 =====")
16
print("=" * 60)
17
print(rules_gini)

1
# ===== 画 Entropy 决策树 =====
2
plt.figure(figsize=(25, 15))
3
plot_tree(dt_entropy,
4
          feature_names=list(selected_features),
5
          class_names=[f'类别{i}' for i in sorted(y.unique())],
6
          filled=True,           # 用颜色填充节点
7
          rounded=True,          # 圆角节点
8
          fontsize=10,
9
          proportion=True)       # 按比例显示样本数
10
plt.title('决策树 (Entropy / 信息熵)', fontsize=16)
11
plt.tight_layout()
12
plt.savefig('decision_tree_entropy.png', dpi=150)  # 保存图片
13
plt.show()
14

15
# ===== 画 Gini 决策树 =====
16
plt.figure(figsize=(25, 15))
17
plot_tree(dt_gini,
18
          feature_names=list(selected_features),
19
          class_names=[f'类别{i}' for i in sorted(y.unique())],
20
          filled=True,
21
          rounded=True,
22
          fontsize=10,
23
          proportion=True)
24
plt.title('决策树 (Gini / 基尼系数)', fontsize=16)
25
plt.tight_layout()
26
plt.savefig('decision_tree_gini.png', dpi=150)
27
plt.show()

1
# 比较 Entropy 和 Gini 树的特征重要性
2
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
3

4
# df[::1] 反转顺序，让高的在上
5
imp_entropy = pd.DataFrame({
6
    '特征': list(selected_features),
7
    '重要性': dt_entropy.feature_importances_
8
}).sort_values('重要性', ascending=True)
9

10
ax1.barh(imp_entropy['特征'], imp_entropy['重要性'])
11
ax1.set_title('Entropy 决策树 - 特征重要性')
12
ax1.set_xlabel('重要性')
13

14
imp_gini = pd.DataFrame({
15
    '特征': list(selected_features),
16
    '重要性': dt_gini.feature_importances_
17
}).sort_values('重要性', ascending=True)
18

19
ax2.barh(imp_gini['特征'], imp_gini['重要性'])
20
ax2.set_title('Gini 决策树 - 特征重要性')
21
ax2.set_xlabel('重要性')
22

23
plt.tight_layout()
24
plt.show()

1
# 看看不同 max_depth 对准确率的影响
2
depths = range(2, 16)
3
entropy_scores = []
4
gini_scores = []
5

6
for d in depths:
7
    dt_e = DecisionTreeClassifier(criterion='entropy', max_depth=d, random_state=42)
8
    dt_e.fit(X_train_selected, y_train)
9
    entropy_scores.append(accuracy_score(y_test, dt_e.predict(X_test_selected)))
10

11
    dt_g = DecisionTreeClassifier(criterion='gini', max_depth=d, random_state=42)
12
    dt_g.fit(X_train_selected, y_train)
13
    gini_scores.append(accuracy_score(y_test, dt_g.predict(X_test_selected)))
14

15
plt.figure(figsize=(12, 6))
16
plt.plot(depths, entropy_scores, 'bo-', label='Entropy')
17
plt.plot(depths, gini_scores, 'ro-', label='Gini')
18
plt.xlabel('max_depth（树的最大深度）')
19
plt.ylabel('准确率')
20
plt.title('不同深度下的决策树准确率对比')
21
plt.legend()
22
plt.grid(True, alpha=0.3)
23
plt.show()