DAY23

知识点回顾

1.转化器与估计器

转换器（transformer）用于预处理/特征提取、常见的转换器包括数据缩放器（如StandardScaler、MinMaxScaler）、特征选择器（如SelectKBest、PCA）、特征提取器（如CountVectorizer、TF-IDFVectorizer）等。

# 导入StandardScaler转换器
from sklearn.preprocessing import StandardScaler

# 初始化转换器
scaler = StandardScaler()

# 1. 学习训练数据的缩放规则（计算均值和标准差）,本身不存储数据
scaler.fit(X_train)

# 2. 应用规则到训练数据和测试数据
X_train_scaled = scaler.transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 也可以使用fit_transform一步完成
# X_train_scaled = scaler.fit_transform(X_train)

估计器（Estimator）是实现机器学习算法的对象或类。它用于拟合（fit）数据并进行预测（predict）。常见的估计器包括分类器（classifier）、回归器（regresser）、聚类器（clusterer）。

from sklearn.linear_model import LinearRegression
# 创建一个回归器
model = LinearRegression()
# 在训练集上训练模型
model.fit(X_train_scaled, y_train)
# 对测试集进行预测
y_pred = model.predict(X_test_scaled)

2.管道工程

机器学习的管道（Pipeline）机制通过将多个转换器和估计器按顺序连接在一起，可以构建一个完整的数据处理和模型训练流程。在管道机制中，可以使用Pipeline类来组织和连接不同的转换器和估计器。Pipeline类提供了一种简单的方式来定义和管理机器学习任务的流程。

2.1 分离特征和标签，划分数据集

# --- 分离特征和标签 (使用原始数据) ---
y = data['Credit Default'] # 标签
X = data.drop(['Credit Default'], axis=1) # 特征 (axis=1 表示按列删除)

print("\n特征和标签分离完成。")
print("特征 X 的形状:", X.shape)
print("标签 y 的形状:", y.shape)

# --- 划分训练集和测试集 (在任何预处理之前划分) ---
# 按照8:2划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 80%训练集，20%测试集

print("\n数据集划分完成 (预处理之前)。")
print("X_train 形状:", X_train.shape)
print("X_test 形状:", X_test.shape)
print("y_train 形状:", y_train.shape)
print("y_test 形状:", y_test.shape)

2.2 ColumnTransformer

# --- 定义不同列的类型和它们对应的预处理步骤 ---
# 这些定义是基于原始数据 X 的列类型来确定的

# 识别原始的 object 列 (对应你原代码中的 discrete_features 在预处理前)
object_cols = X.select_dtypes(include=['object']).columns.tolist()
# 识别原始的非 object 列 (通常是数值列)
numeric_cols = X.select_dtypes(exclude=['object']).columns.tolist()


# 有序分类特征 (对应你之前的标签编码)
# 注意：OrdinalEncoder默认编码为0, 1, 2... 对应你之前的1, 2, 3...需要在模型解释时注意
# 这里的类别顺序需要和你之前映射的顺序一致
ordinal_features = ['Home Ownership', 'Years in current job', 'Term']
# 定义每个有序特征的类别顺序，这个顺序决定了编码后的数值大小
ordinal_categories = [
    ['Own Home', 'Rent', 'Have Mortgage', 'Home Mortgage'], # Home Ownership 的顺序 (对应1, 2, 3, 4)
    ['< 1 year', '1 year', '2 years', '3 years', '4 years', '5 years', '6 years', '7 years', '8 years', '9 years', '10+ years'], # Years in current job 的顺序 (对应1-11)
    ['Short Term', 'Long Term'] # Term 的顺序 (对应0, 1)
]
# 构建处理有序特征的 Pipeline: 先填充缺失值，再进行有序编码
ordinal_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')), # 用众数填充分类特征的缺失值
    ('encoder', OrdinalEncoder(categories=ordinal_categories, handle_unknown='use_encoded_value', unknown_value=-1)) # 进行有序编码
])
print("有序特征处理 Pipeline 定义完成。")


# 标称分类特征 (对应你之前的独热编码)
nominal_features = ['Purpose'] # 使用原始列名
# 构建处理标称特征的 Pipeline: 先填充缺失值，再进行独热编码
nominal_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')), # 用众数填充分类特征的缺失值
    ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False)) # 进行独热编码, sparse_output=False 使输出为密集数组
])
print("标称特征处理 Pipeline 定义完成。")


# 连续特征 (对应你之前的众数填充 + 添加标准化)
# 从所有列中排除掉分类特征，得到连续特征列表
# continuous_features = X.columns.difference(object_cols).tolist() # 原始X中非object类型的列
# 也可以直接从所有列中排除已知的有序和标称特征
continuous_features = [f for f in X.columns if f not in ordinal_features + nominal_features]

# 构建处理连续特征的 Pipeline: 先填充缺失值，再进行标准化
continuous_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')), # 用众数填充缺失值 (复现你的原始逻辑)
    ('scaler', StandardScaler()) # 标准化，一个好的实践 (如果你严格复刻原代码，可以移除这步)
])
print("连续特征处理 Pipeline 定义完成。")

# --- 构建 ColumnTransformer ---
# 将不同的预处理应用于不同的列子集，构造一个完备的转化器
# ColumnTransformer 接收一个 transformers 列表，每个元素是 (名称, 转换器对象, 列名列表)
preprocessor = ColumnTransformer(
    transformers=[
        ('ordinal', ordinal_transformer, ordinal_features), # 对 ordinal_features 列应用 ordinal_transformer
        ('nominal', nominal_transformer, nominal_features), # 对 nominal_features 列应用 nominal_transformer
        ('continuous', continuous_transformer, continuous_features) # 对 continuous_features 列应用 continuous_transformer
    ],
    remainder='passthrough' # 如何处理没有在上面列表中指定的列。
                           # 'passthrough' 表示保留这些列，不做任何处理。
                           # 'drop' 表示丢弃这些列。
)

print("\nColumnTransformer (预处理器) 定义完成。")
# print(preprocessor) # 可以打印 preprocessor 对象看看它的结构

# --- 1. 使用 Pipeline 在划分好的训练集和测试集上评估 ---
# 完全模仿你原代码的第一个评估步骤

print("\n--- 1. 默认参数随机森林 (训练集 -> 测试集) ---") # 使用你原代码的输出文本
# import time # 引入 time 库 (已在文件顶部引入)

start_time = time.time() # 记录开始时间

# 在原始的 X_train, y_train 上拟合整个Pipeline
# Pipeline会自动按顺序执行 preprocessor 的 fit_transform(X_train)，
# 然后用处理后的数据和 y_train 拟合 classifier
pipeline.fit(X_train, y_train)

# 在原始的 X_test 上进行预测
# Pipeline会自动按顺序执行 preprocessor 的 transform(X_test)，
# 然后用处理后的数据进行 classifier 的 predict
pipeline_pred = pipeline.predict(X_test)

end_time = time.time() # 记录结束时间

print(f"训练与预测耗时: {end_time - start_time:.4f} 秒") # 使用你原代码的输出格式

print("\n默认随机森林 在测试集上的分类报告：") # 使用你原代码的输出文本
print(classification_report(y_test, pipeline_pred))
print("默认随机森林 在测试集上的混淆矩阵：") # 使用你原代码的输出文本
print(confusion_matrix(y_test, pipeline_pred))

六个核心组件：

---

1) Pipeline(steps=[('name', transformer), ...])

Pipeline 的参数你只用到了一个：steps

• steps：一个按顺序执行的列表，每项是 ('名字', 组件对象)

  • '名字'：随便起，用来引用这一步（尤其网格搜索/调参时用）

  • "最后一步"如果是模型，一般叫 classifier / model；中间步骤是各种 transformer

Pipeline 自己不做计算，它只是负责按顺序调用：

• fit()：从前到后 fit（前面步骤 fit+transform；最后模型 fit）

• predict()：前面步骤 transform；最后模型 predict

---

2) SimpleImputer(strategy='most_frequent')

你用到的参数：

strategy

缺失值用什么规则填：

• 'most_frequent'：众数（类别特征常用）

• 'mean'：均值（数值特征常用，默认通常是它）

• 'median'：中位数（数值特征常用，抗异常值）

• 'constant'：固定值（比如填 "Missing" 或 0）

  SimpleImputer(strategy='constant', fill_value='Missing')

你这里为什么写 most_frequent？

因为 ordinal/nominal 都是分类列，用众数填最常见。

如果"缺失本身有含义"，比起众数更推荐 constant + 'Missing'。

---

3) OrdinalEncoder(categories=..., handle_unknown=..., unknown_value=...)

你用到的参数：

categories=ordinal_categories

这是最重要的：指定每一列类别的顺序 。
OrdinalEncoder 会按你给的顺序编码成 0,1,2...

例如你写的 Home Ownership：
['Own Home','Rent','Have Mortgage','Home Mortgage']

会变成：

• Own Home → 0

• Rent → 1

• Have Mortgage → 2

• Home Mortgage → 3

如果你不写 categories=，它会自己按字母顺序/出现顺序去决定编码，就不再是你想要的"有序"了。

handle_unknown='use_encoded_value'

测试集/新数据来了一个"没在 categories 里出现的类别"怎么办？

• 'error'（默认）：直接报错

• 'use_encoded_value'：不要报错，用你指定的 unknown_value

unknown_value=-1

当出现未知类别时，用 -1 代表它。

注意：-1 会让模型觉得"未知类别比所有已知类别都小"。

树模型一般还能接受；线性模型可能更敏感。

---

4) OneHotEncoder(handle_unknown='ignore', sparse_output=False)

你用到的参数：

handle_unknown='ignore'

测试集来了训练没见过的新类别怎么办？

• 'error'（默认）：报错

• 'ignore'：不报错，这个新类别会变成"全 0"（相当于模型当它不存在）

这在真实数据里非常常用，能避免上线崩。

sparse_output=False（旧版叫 sparse=False）

• True（常见默认）：输出稀疏矩阵（更省内存）

• False：输出普通的密集数组（更直观，但占内存）

如果类别很多（上百上千），一般别关 sparse。

---

5) StandardScaler()

你这段没传参数（都走默认）。它做的是：

• 每列减均值 / 除标准差 → 标准化成均值 0 方差 1

常见"你可能会看到"的参数（你没用到）：

• with_mean=True/False：是否减均值（稀疏矩阵时通常不能减均值）

• with_std=True/False：是否除标准差

对 RandomForest 通常不需要 scaler，但加了也不一定错（前提是输入都是数值）。

---

6) ColumnTransformer(transformers=[...], remainder='passthrough')

你用到的参数：

transformers=[('名字', transformer, 列列表), ...]

• '名字'：随便起

• transformer：可以是 Pipeline，也可以是单个 transformer

• 列列表：告诉它哪些列走这条分支

它的作用就是：不同列走不同处理，最后把结果拼在一起。

remainder='passthrough'

没被你列在 transformers 里的列怎么办？

• 'drop'：丢掉（更安全）

• 'passthrough'：原样保留（有时会导致你不小心把某些字符串列直接拼进来，引发后续模型报错）