DAY 23 pipeline管道

最新推荐文章于 2025-05-12 23:45:52 发布

Ayanamii丶

最新推荐文章于 2025-05-12 23:45:52 发布

阅读量411

点赞数 12

分类专栏： PYTHON学习打卡集合文章标签： python 学习

本文链接：https://blog.csdn.net/Era_mo/article/details/147894251

版权

PYTHON学习打卡集合专栏收录该内容

22 篇文章

订阅专栏

知识回顾:

转化器和估计器的概念
管道工程
ColumnTransformer和Pipeline类

作业：

整理下全部逻辑的先后顺序，看看能不能制作出适合所有机器学习的通用pipeline

输入:

# 导入基础库
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import time # 导入 time 库
import warnings

# 忽略警告
warnings.filterwarnings("ignore")

# 设置中文字体和负号正常显示
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

# 导入 Pipeline 和相关预处理工具
from sklearn.pipeline import Pipeline # 用于创建机器学习工作流
from sklearn.compose import ColumnTransformer # 用于将不同的预处理应用于不同的列
from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder, StandardScaler # 用于数据预处理（有序编码、独热编码、标准化）
from sklearn.impute import SimpleImputer # 用于处理缺失值

# 导入机器学习模型和评估工具
from sklearn.ensemble import RandomForestClassifier # 随机森林分类器
from sklearn.metrics import classification_report, confusion_matrix # 用于评估分类器性能
from sklearn.model_selection import train_test_split # 用于划分训练集和测试集


# --- 加载原始数据 ---
# 我们加载原始数据，不对其进行任何手动预处理
data = pd.read_csv(r'heart.csv')

print("原始数据加载完成，形状为:", data.shape)
# print(data.head()) # 可以打印前几行看看原始数据

# --- 分离特征和标签 (使用原始数据) ---
y = data['target'] # 标签
X = data.drop(['target'], axis=1) # 特征 (axis=1 表示按列删除)
# thal 标签编码
# --- 删除以下手动预处理部分 ---
# 这里我们不再手动处理 thal 列，而是在 Pipeline 中进行处理
# thal_mapping = {
#     1: 1,
#     2: 2,
#     3: 3,
# }
# data['thal'] = data['thal'].map(thal_mapping)
# # slope的独热编码，记得需要将bool类型转换为数值
# data = pd.get_dummies(data, columns=['slope'])
# data2 = pd.read_csv(r"heart.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就是独热编码后的特征名
# print(list_final) # 打印出来的就是独热编码后的特征名



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)



# --- 定义不同列的类型和它们对应的预处理步骤 ---
# 这些定义是基于原始数据 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 = ['thal']
# 定义每个有序特征的类别顺序，这个顺序决定了编码后的数值大小
ordinal_categories = [
    [0,1, 2, 3],  # thal

]
# 构建处理有序特征的 Pipeline: 先填充缺失值，再进行有序编码
ordinal_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),  # 用众数填充缺失值
    ('encoder', OrdinalEncoder(categories=ordinal_categories))  # 有序编码
    
])
# 构建处理数值特征的 Pipeline: 先填充缺失值，再进行标准化
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),  # 用中位数填充缺失值
    ('scaler', StandardScaler())  # 标准化
])
print("有序特征处理 Pipeline 定义完成。")

# 标称分类特征 (对应你之前的独热编码)
# 注意：这里的独热编码会自动处理缺失值
nominal_features = ['slope']  #  使用原始列名
nominal_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),  # 用众数填充缺失值
    ('encoder', OneHotEncoder(handle_unknown='ignore'))  # 独热编码

])
print("标称特征处理 Pipeline 定义完成。")

# 连续特征 (对应你之前的众数填充 + 添加标准化)
# 从所有列中排除掉分类特征，得到连续特征列表
# continuous_features = X.columns.difference(object_cols).tolist() # 原始X中非object类型的列
# 也可以直接从所有列中排除已知的有序和标称特征
continuous_features = X.columns.difference(ordinal_features + nominal_features).tolist() # 原始X中非object类型的列
# 这里的连续特征不需要额外处理，因为它们已经在 numeric_transformer 中处理了
continuous_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),  # 用众数填充缺失值
    ('scaler', StandardScaler())  # 标准化
])
print("连续特征处理 Pipeline 定义完成。")

# --- 构建 ColumnTransformer ---
# 将不同的预处理应用于不同的列子集，构造一个完备的转化器
# ColumnTransformer 接收一个 transformers 列表，每个元素是 (名称, 转换器对象, 列名列表)
preprocessor = ColumnTransformer(
    transformers=[
        ('ordinal', ordinal_transformer, ordinal_features),  # 处理有序特征
        ('nominal', nominal_transformer, nominal_features),  # 处理标称特征
        ('continuous', continuous_transformer, continuous_features)  # 处理连续特征
    ], 
    remainder='passthrough'  # 保留没有在transformers中指定的列（如果存在的话），或者 'drop' 丢弃

)
print("ColumnTransformer 定义完成。")
print(preprocessor) # 可以打印 preprocessor 对象看看它的结构

# --- 构建完整的 Pipeline ---
# 将预处理器和模型串联起来
# 使用你原代码中 RandomForestClassifier 的默认参数和 random_state，这里的参数用到了元组这个数据结构
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),  # 第一步：应用所有的预处理 (ColumnTransformer) 
    ('classifier', RandomForestClassifier(random_state=42))  # 第二步：随机森林分类器
])
print("Pipeline 定义完成。")
# --- 训练模型 ---
print("\n--- 1. 默认参数随机森林 (训练集 -> 测试集) ---") # 使用你原代码的输出文本
start_time = time.time() # 记录开始时间
# 在原始的 X_train 上拟合整个Pipeline
# Pipeline会自动按顺序执行preprocessor的fit_transform(X_train)，然后用处理后的数据拟合classifier
pipeline.fit(X_train, y_train)
# 在原始的 X_test 上进行预测
# Pipeline会自动按顺序执行preprocessor的transform(X_test)，然后用处理后的数据进行预测
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))

输出：

原始数据加载完成，形状为: (303, 14)

特征和标签分离完成。
特征 X 的形状: (303, 13)
标签 y 的形状: (303,)

数据集划分完成 (预处理之前)。
X_train 形状: (242, 13)
X_test 形状: (61, 13)
y_train 形状: (242,)
y_test 形状: (61,)
有序特征处理 Pipeline 定义完成。
标称特征处理 Pipeline 定义完成。
连续特征处理 Pipeline 定义完成。
ColumnTransformer 定义完成。
ColumnTransformer(remainder='passthrough',
                  transformers=[('ordinal',
                                 Pipeline(steps=[('imputer',
                                                  SimpleImputer(strategy='most_frequent')),
                                                 ('encoder',
                                                  OrdinalEncoder(categories=[[0,
                                                                              1,
                                                                              2,
                                                                              3]]))]),
                                 ['thal']),
                                ('nominal',
                                 Pipeline(steps=[('imputer',
                                                  SimpleImputer(strategy='most_frequent')),
                                                 ('encoder',
                                                  OneHotEncoder(handle_unknown='ignore'))]),
                                 ['slope']),
                                ('continuous',
                                 Pipeline(steps=[('imputer',
                                                  SimpleImputer(strategy='most_frequent')),
                                                 ('scaler', StandardScaler())]),
                                 ['age', 'ca', 'chol', 'cp', 'exang', 'fbs',
                                  'oldpeak', 'restecg', 'sex', 'thalach',
                                  'trestbps'])])
Pipeline 定义完成。

--- 1. 默认参数随机森林 (训练集 -> 测试集) ---
训练与预测耗时: 0.1251 秒

默认随机森林 在测试集上的分类报告：
              precision    recall  f1-score   support

           0       0.89      0.83      0.86        29
           1       0.85      0.91      0.88        32

    accuracy                           0.87        61
   macro avg       0.87      0.87      0.87        61
weighted avg       0.87      0.87      0.87        61

默认随机森林 在测试集上的混淆矩阵：
[[24  5]
 [ 3 29]]