Python训练打卡Day21

常见的降维算法：

# 先运行预处理阶段的代码
import pandas as pd
import pandas as pd    #用于数据处理和分析，可处理表格数据。
import numpy as np     #用于数值计算，提供了高效的数组操作。
import matplotlib.pyplot as plt    #用于绘制各种类型的图表
import seaborn as sns   #基于matplotlib的高级绘图库，能绘制更美观的统计图形。
import warnings
warnings.filterwarnings("ignore")# 设置中文字体（解决中文显示问题）
plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows系统常用黑体字体
plt.rcParams['axes.unicode_minus'] = False    # 正常显示负号
data = pd.read_csv('data.csv')    #读取数据# 先筛选字符串变量 
discrete_features = data.select_dtypes(include=['object']).columns.tolist()
# Home Ownership 标签编码
home_ownership_mapping = {'Own Home': 1,'Rent': 2,'Have Mortgage': 3,'Home Mortgage': 4
}
data['Home Ownership'] = data['Home Ownership'].map(home_ownership_mapping)# Years in current job 标签编码
years_in_job_mapping = {'< 1 year': 1,'1 year': 2,'2 years': 3,'3 years': 4,'4 years': 5,'5 years': 6,'6 years': 7,'7 years': 8,'8 years': 9,'9 years': 10,'10+ years': 11
}
data['Years in current job'] = data['Years in current job'].map(years_in_job_mapping)# Purpose 独热编码，记得需要将bool类型转换为数值
data = pd.get_dummies(data, columns=['Purpose'])
data2 = pd.read_csv("data.csv") # 重新读取数据，用来做列名对比
list_final = [] # 新建一个空列表，用于存放独热编码后新增的特征名
for i in data.columns:if i not in data2.columns:list_final.append(i) # 这里打印出来的就是独热编码后的特征名
for i in list_final:data[i] = data[i].astype(int) # 这里的i就是独热编码后的特征名# Term 0 - 1 映射
term_mapping = {'Short Term': 0,'Long Term': 1
}
data['Term'] = data['Term'].map(term_mapping)
data.rename(columns={'Term': 'Long Term'}, inplace=True) # 重命名列
continuous_features = data.select_dtypes(include=['int64', 'float64']).columns.tolist()  #把筛选出来的列名转换成列表# 连续特征用中位数补全
for feature in continuous_features:     mode_value = data[feature].mode()[0]            #获取该列的众数。data[feature].fillna(mode_value, inplace=True)          #用众数填充该列的缺失值，inplace=True表示直接在原数据上修改。# 最开始也说了 很多调参函数自带交叉验证，甚至是必选的参数，你如果想要不交叉反而实现起来会麻烦很多
# 所以这里我们还是只划分一次数据集data.drop(columns=['Id'], inplace=True) # 删除 Loan ID 列
data.info() # 查看数据集的信息，包括数据类型和缺失值情况

此时有31个特征，进行特征降维，提到特征降维一般默认的是无监督降维，这种方法只需要特征数据本身。同时还有有监督的方法。

1.无监督降维 (Unsupervised Dimensionality Reduction)

        定义：这类算法在降维过程中**不使用**任何关于数据样本的标签信息（比如类别标签、目标值等）。它们仅仅根据数据点本身的分布、方差、相关性、局部结构等特性来寻找低维表示。

        输入：只有特征矩阵 `X`

        目标：

        留数据中尽可能多的方差（如 PCA）。

        保留数据的局部或全局流形结构（如 LLE, Isomap, t-SNE, UMAP）。

        找到能够有效重构原始数据的紧凑表示（如 Autoencoder）。

         找到统计上独立的成分（如 ICA）。

        典型算法：

        PCA (Principal Component Analysis)** / **SVD (Singular Value Decomposition)

        t-SNE (t-distributed Stochastic Neighbor Embedding)

        UMAP (Uniform Manifold Approximation and Projection)

        LLE (Locally Linear Embedding)

        Isomap (Isometric Mapping)

        Autoencoders (基本形式)

        ICA (Independent Component Analysis)

2.有监督降维(Supervised Dimensionality Reduction)

        定义：这类算法在降维过程中**会利用**数据样本的标签信息（通常是类别标签 `y`）。它们的目标是找到一个低维子空间，在这个子空间中，不同类别的数据点能够被更好地分离开，或者说，这个低维表示更有利于后续的分类（或回归）任务。

        输入：特征矩阵 `X` **和** 对应的标签向量 `y`

        目标：

       最大化不同类别之间的可分性，同时最小化同一类别内部的离散度（如 LDA）。

        找到对预测目标变量 `y` 最有信息量的特征组合。

        典型算法：

        LDA (Linear Discriminant Analysis)：这是最经典的监督降维算法。它寻找的投影方向能够最大化类间散度与类内散度之比。

        还有一些其他的，比如 NCA (Neighbourhood Components Analysis)，但 LDA 是最主要的代表。

        举个例子来说明：

        PCA (无监督)：如果你有一堆人脸图片，PCA会尝试找到那些能最好地概括所有人脸变化的“主脸”（特征向量），比如脸型、鼻子大小等，它不关心这些人脸属于谁。

        LDA (有监督)：如果你有一堆人脸图片，并且你知道每张图片属于哪个人（标签）。LDA会尝试找到那些能最好地区分不同人的人脸特征组合。比如，如果A和B的脸型很像，但眼睛差别很大，LDA可能会更强调眼睛的特征，即使脸型方差更大。PCA是利用最大化方差来实现无监督降维，而LDA则是在此基础上，加入了类别信息，其优化目标就变成了类间差异最大化和类内差异最小化。

        PCA等无监督降维方法的目标是保留数据的最大方差，这些方差大的方向不一定是对分类最有用的方向。因此，在分类任务中，LDA通常比PCA更直接有效。

        

from sklearn.model_selection import train_test_split
X = data.drop(['Credit Default'], axis=1)  # 特征，axis=1表示按列删除
y = data['Credit Default'] # 标签from sklearn.model_selection import train_test_split
X = data.drop(['Credit Default'], axis=1)  # 特征，axis=1表示按列删除
y = data['Credit Default'] # 标签
# 按照8:2划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  # 80%训练集，20%测试集from sklearn.ensemble import RandomForestClassifier #随机森林分类器from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # 用于评估分类器性能的指标
from sklearn.metrics import classification_report, confusion_matrix #用于生成分类报告和混淆矩阵
import warnings #用于忽略警告信息
warnings.filterwarnings("ignore") # 忽略所有警告信息
# --- 1. 默认参数的随机森林 ---
# 评估基准模型，这里确实不需要验证集
print("--- 1. 默认参数随机森林 (训练集 -> 测试集) ---")
import time # 这里介绍一个新的库，time库，主要用于时间相关的操作，因为调参需要很长时间，记录下会帮助后人知道大概的时长
start_time = time.time() # 记录开始时间
rf_model = RandomForestClassifier(random_state=42)
rf_model.fit(X_train, y_train) # 在训练集上训练
rf_pred = rf_model.predict(X_test) # 在测试集上预测
end_time = time.time() # 记录结束时间print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\n默认随机森林 在测试集上的分类报告：")
print(classification_report(y_test, rf_pred))
print("默认随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred))

# # umap-learn 是一个用于降维和可视化的库，特别适合处理高维数据。它使用了一种基于流形学习的算法，可以有效地将高维数据嵌入到低维空间中，同时保持数据的局部结构。
# !pip install umap-learn -i https://pypi.tuna.tsinghua.edu.cn/simple

# 确保这些库已导入，你的原始代码中可能已经包含了部分
import time
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler # 特征缩放
from sklearn.decomposition import PCA # 主成分分析
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA # 线性判别分析
# UMAP 需要单独安装: pip install umap-learn
import umap # 如果安装了 umap-learn，可以这样导入from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix# 你的 X_train, X_test, y_train, y_test 应该已经根据你的代码准备好了
# 我们假设你的随机森林模型参数与基准模型一致，以便比较降维效果
# rf_params = {'random_state': 42} # 如果你的基准模型有其他参数，也在这里定义
# 为了直接比较，我们使用默认的 RandomForestClassifier 参数，除了 random_state

主成分分析 (PCA:寻找最大方差方向)

        PCA可以被看作是将SVD应用于经过均值中心化的数据矩阵，并对其结果进行特定解释的一种方法。主成分分析 (PCA) 的核心思想是识别数据中方差最大的方向（即主成分）。然后，它将数据投影到由这些最重要的主成分构成的新的、维度更低子空间上。这样做的目的是在降低数据维度的同时，尽可能多地保留原始数据中的“信息”（通过方差来衡量）。新的特征（主成分）是原始特征的线性组合，并且它们之间是正交的（不相关）。

可以将PCA视为：

1.  对数据进行均值中心化。

2.  对中心化后的数据进行SVD。

3.  使用SVD得到的右奇异向量 V 作为主成分方向。

4.  使用奇异值 S 来评估每个主成分的重要性（解释的方差）。

5.  使用 U*S（或 X_centered * V）来获得降维后的数据表示。

        PCA主要适用于那些你认为最重要的信息可以通过数据方差来捕获，并且数据结构主要是线性的情况。

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
import time
import numpy as np # 确保numpy导入# 假设 X_train, X_test, y_train, y_test 已经准备好了print(f"\n--- 2. PCA 降维 + 随机森林 (不使用 Pipeline) ---")# 步骤 1: 特征缩放
scaler_pca = StandardScaler()
X_train_scaled_pca = scaler_pca.fit_transform(X_train)
X_test_scaled_pca = scaler_pca.transform(X_test) # 使用在训练集上fit的scaler# 步骤 2: PCA降维
# 选择降到10维，或者你可以根据解释方差来选择，例如：
pca_expl = PCA(random_state=42)
pca_expl.fit(X_train_scaled_pca)
cumsum_variance = np.cumsum(pca_expl.explained_variance_ratio_)
n_components_to_keep_95_var = np.argmax(cumsum_variance >= 0.95) + 1
print(f"为了保留95%的方差，需要的主成分数量: {n_components_to_keep_95_var}")#--- 2. PCA 降维 + 随机森林 (不使用 Pipeline) ---
#为了保留95%的方差，需要的主成分数量: 26

# 我们测试下降低到10维的效果
n_components_pca = 10
pca_manual = PCA(n_components=n_components_pca, random_state=42)X_train_pca = pca_manual.fit_transform(X_train_scaled_pca)
X_test_pca = pca_manual.transform(X_test_scaled_pca) # 使用在训练集上fit的pcaprint(f"PCA降维后，训练集形状: {X_train_pca.shape}, 测试集形状: {X_test_pca.shape}")
start_time_pca_manual = time.time()
# 步骤 3: 训练随机森林分类器
rf_model_pca = RandomForestClassifier(random_state=42)
rf_model_pca.fit(X_train_pca, y_train)# 步骤 4: 在测试集上预测
rf_pred_pca_manual = rf_model_pca.predict(X_test_pca)
end_time_pca_manual = time.time()print(f"手动PCA降维后，训练与预测耗时: {end_time_pca_manual - start_time_pca_manual:.4f} 秒")print("\n手动 PCA + 随机森林 在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_pca_manual))
print("手动 PCA + 随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_pca_manual))

t-分布随机邻域嵌入 (t-SNE)

        t-SNE：保持高维数据的局部邻域结构，用于可视化。t-SNE 是一种强大的非线性降维技术，主要用于高维数据的可视化。它通过在低维空间中保持高维空间中数据点之间的局部相似性（邻域关系）来工作。与PCA关注全局方差不同，t-SNE 更关注局部细节。理解它的超参数（尤其是困惑度）和结果的正确解读方式非常重要。

from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
import time
import numpy as np
import matplotlib.pyplot as plt # 用于可选的可视化
import seaborn as sns # 用于可选的可视化# 假设 X_train, X_test, y_train, y_test 已经准备好了
# 并且你的 X_train, X_test 是DataFrame或Numpy Arrayprint(f"\n--- 3. t-SNE 降维 + 随机森林  ---")
print("       标准 t-SNE 主要用于可视化，直接用于分类器输入可能效果不佳。")# 步骤 1: 特征缩放
scaler_tsne = StandardScaler()
X_train_scaled_tsne = scaler_tsne.fit_transform(X_train)
X_test_scaled_tsne = scaler_tsne.transform(X_test) # 使用在训练集上fit的scaler# 步骤 2: t-SNE 降维
# 我们将降维到与PCA相同的维度（例如10维）或者一个适合分类的较低维度。
# t-SNE通常用于2D/3D可视化，但也可以降到更高维度。
# 然而，降到与PCA一样的维度（比如10维）对于t-SNE来说可能不是其优势所在，
# 并且计算成本会显著增加，因为高维t-SNE的优化更困难。
# 为了与PCA的 n_components=10 对比，我们这里也尝试降到10维。
# 但请注意，这可能非常耗时，且效果不一定好。
# 通常如果用t-SNE做分类的预处理（不常见），可能会选择非常低的维度（如2或3）。# n_components_tsne = 10 # 与PCA的例子保持一致，但计算量会很大
n_components_tsne = 2    # 更典型的t-SNE用于分类的维度，如果想快速看到结果# 如果你想严格对比PCA的10维，可以将这里改为10，但会很慢# 对训练集进行 fit_transform
tsne_model_train = TSNE(n_components=n_components_tsne,perplexity=30,    # 常用的困惑度值n_iter=1000,      # 足够的迭代次数init='pca',       # 使用PCA初始化，通常更稳定learning_rate='auto', # 自动学习率 (sklearn >= 1.2)random_state=42,  # 保证结果可复现n_jobs=-1)        # 使用所有CPU核心
print("正在对训练集进行 t-SNE fit_transform...")
start_tsne_fit_train = time.time()
X_train_tsne = tsne_model_train.fit_transform(X_train_scaled_tsne)
end_tsne_fit_train = time.time()
print(f"训练集 t-SNE fit_transform 完成，耗时: {end_tsne_fit_train - start_tsne_fit_train:.2f} 秒")# 对测试集进行 fit_transform
# 再次强调：这是独立于训练集的变换
tsne_model_test = TSNE(n_components=n_components_tsne,perplexity=30,n_iter=1000,init='pca',learning_rate='auto',random_state=42, # 保持参数一致，但数据不同，结果也不同n_jobs=-1)
print("正在对测试集进行 t-SNE fit_transform...")
start_tsne_fit_test = time.time()
X_test_tsne = tsne_model_test.fit_transform(X_test_scaled_tsne) # 注意这里是 X_test_scaled_tsne
end_tsne_fit_test = time.time()
print(f"测试集 t-SNE fit_transform 完成，耗时: {end_tsne_fit_test - start_tsne_fit_test:.2f} 秒")print(f"t-SNE降维后，训练集形状: {X_train_tsne.shape}, 测试集形状: {X_test_tsne.shape}")start_time_tsne_rf = time.time()
# 步骤 3: 训练随机森林分类器
rf_model_tsne = RandomForestClassifier(random_state=42)
rf_model_tsne.fit(X_train_tsne, y_train)# 步骤 4: 在测试集上预测
rf_pred_tsne_manual = rf_model_tsne.predict(X_test_tsne)
end_time_tsne_rf = time.time()print(f"t-SNE降维数据上，随机森林训练与预测耗时: {end_time_tsne_rf - start_time_tsne_rf:.4f} 秒")
total_tsne_time = (end_tsne_fit_train - start_tsne_fit_train) + \(end_tsne_fit_test - start_tsne_fit_test) + \(end_time_tsne_rf - start_time_tsne_rf)
print(f"t-SNE 总耗时 (包括两次fit_transform和RF): {total_tsne_time:.2f} 秒")print("\n手动 t-SNE + 随机森林 在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_tsne_manual))
print("手动 t-SNE + 随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_tsne_manual))

线性判别分析 (Linear Discriminant Analysis, LDA)

        LDA 是一种利用类别标签信息来寻找最佳类别分离投影的降维方法，其降维的潜力直接与类别数量挂钩。

        

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
import time
import numpy as np
# 假设你已经导入了 matplotlib 和 seaborn 用于绘图 (如果需要)
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D # 如果需要3D绘图
import seaborn as snsprint(f"\n--- 4. LDA 降维 + 随机森林 ---")# 步骤 1: 特征缩放
scaler_lda = StandardScaler()
X_train_scaled_lda = scaler_lda.fit_transform(X_train)
X_test_scaled_lda = scaler_lda.transform(X_test) # 使用在训练集上fit的scaler# 步骤 2: LDA 降维
n_features = X_train_scaled_lda.shape[1]
if hasattr(y_train, 'nunique'):n_classes = y_train.nunique()
elif isinstance(y_train, np.ndarray):n_classes = len(np.unique(y_train))
else:n_classes = len(set(y_train))max_lda_components = min(n_features, n_classes - 1)# 设置目标降维维度
n_components_lda_target = 10if max_lda_components < 1:print(f"LDA 不适用，因为类别数 ({n_classes})太少，无法产生至少1个判别组件。")X_train_lda = X_train_scaled_lda.copy() # 使用缩放后的原始特征X_test_lda = X_test_scaled_lda.copy()   # 使用缩放后的原始特征actual_n_components_lda = n_featuresprint("将使用缩放后的原始特征进行后续操作。")
else:# 实际使用的组件数不能超过LDA的上限，也不能超过我们的目标（如果目标更小）actual_n_components_lda = min(n_components_lda_target, max_lda_components)if actual_n_components_lda < 1: # 这种情况理论上不会发生，因为上面已经检查了 max_lda_components < 1print(f"计算得到的实际LDA组件数 ({actual_n_components_lda}) 小于1，LDA不适用。")X_train_lda = X_train_scaled_lda.copy()X_test_lda = X_test_scaled_lda.copy()actual_n_components_lda = n_featuresprint("将使用缩放后的原始特征进行后续操作。")else:print(f"原始特征数: {n_features}, 类别数: {n_classes}")print(f"LDA 最多可降至 {max_lda_components} 维。")print(f"目标降维维度: {n_components_lda_target} 维。")print(f"本次 LDA 将实际降至 {actual_n_components_lda} 维。")lda_manual = LinearDiscriminantAnalysis(n_components=actual_n_components_lda, solver='svd')X_train_lda = lda_manual.fit_transform(X_train_scaled_lda, y_train)X_test_lda = lda_manual.transform(X_test_scaled_lda)print(f"LDA降维后，训练集形状: {X_train_lda.shape}, 测试集形状: {X_test_lda.shape}")start_time_lda_rf = time.time()
# 步骤 3: 训练随机森林分类器
rf_model_lda = RandomForestClassifier(random_state=42)
rf_model_lda.fit(X_train_lda, y_train)# 步骤 4: 在测试集上预测
rf_pred_lda_manual = rf_model_lda.predict(X_test_lda)
end_time_lda_rf = time.time()print(f"LDA降维数据上，随机森林训练与预测耗时: {end_time_lda_rf - start_time_lda_rf:.4f} 秒")print("\n手动 LDA + 随机森林 在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_lda_manual))
print("手动 LDA + 随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_lda_manual))

@浙大疏锦行