Python训练营打卡 Day23

于 2025-05-20 00:13:59 发布
阅读量817 收藏 14
点赞数 18
分类专栏： python训练营学习打卡 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64617880/article/details/148025898
版权

pipeline管道（机器学习流水线）

知识回顾:

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

作业：

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

——————————————————————————————————————————

一、转化器和估计器的概念

一套完整的机器学习建模流程如下：

在机器学习中，转换器（Transformer）和估计器（Estimator）是两个重要的概念，它们可以结合在一起构建一个完整的机器学习流程。

pipeline，在机器学习领域可译为“管道”或“流水线”

在机器学习中，pipeline 是一种将多个处理步骤串联起来的机制，用于简化和自动化数据处理和模型训练的流程。

它可以将数据预处理、特征选择、模型训练等步骤封装在一起，使整个过程更加高效和易于管理。

1、转换器

转换器（Transformer）是一种用于数据转换和预处理的对象或类。它接受输入数据，并对其进行某种形式的变换。转换器通常用于数据的特征工程，包括特征缩放、特征选择、特征提取等操作。

转换器的主要方法是 fit 和 transform。

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

实例化：

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

# 创建一个StandardScaler转换器
scaler = StandardScaler()

# 在训练集上学习转换规则
scaler.fit(X_train)

# 对训练集和测试集进行特征缩放
X_train_scaled = scaler.transform(X_train)
X_test_scaled = scaler.transform(X_test)

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

 

2、估计器

估计器（Estimator）是实现机器学习算法的对象或类。它用于拟合（fit）数据并进行预测（predict）。估计器是机器学习模型的基本组成部分，用于从数据中学习模式、进行预测和进行模型评估。

估计器的主要方法是 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)

二、管道

机器学习的管道(Pipeline)机制通过将多个转换器和估计器按顺序连接在一起，可以构建一个完整的数据处理和模型训练流程。Pipeline类提供了一种简单的方式来定义和管理机器学习任务的流程。很多个不同的数据集，只要处理成管道的输入形式，后续的代码就可以复用。(这里为我们未来的python文件拆分做铺垫)，也就是把很多个类和函数操作写进一个新的pipeline中。

三、pipeline的代码教学

1、导入库和数据加载

# 导入基础库
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('data.csv')

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

新的部分为：

# 导入 Pipeline 和相关预处理工具

from sklearn.pipeline import Pipeline # 用于创建机器学习工作流

from sklearn.compose import ColumnTransformer # 用于将不同的预处理应用于不同的列

from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder, StandardScaler # 用于数据预处理（有序编码、独热编码、标准化）

from sklearn.impute import SimpleImputer # 用于处理缺失值

 

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

# --- 分离特征和标签 (使用原始数据) ---
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)

注意，这一步划分数据集已经完成。 

 

3、定义预处理步骤

（1）Colum Transformer 的核心

i. 基于原始数据X的列类型确定定义
# 识别原始的 object 列 
object_cols = X.select_dtypes(include=['object']).columns.tolist()
# 识别原始的非 object 列 (通常是数值列)
numeric_cols = X.select_dtypes(exclude=['object']).columns.tolist()

对应原先的代码：

discrete_features = data.select_dtypes(include=['object']).columns.tolist()

continuous_features = data.select_dtypes(include=['float64','int64']).columns.tolist()

ii. 有序分类特征
# 注意：OrdinalEncoder默认编码为0, 1, 2... 之前代码为1, 2, 3...需要在模型解释时注意
# 这里的类别顺序需要和之前映射的顺序一致

ordinal_features = ['Home Ownership', 'Years in current job', 'Term']
# 定义每个有序特征的类别顺序，这个顺序决定了编码后的数值大小

ordinal_categories = [
    # Home Ownership 的顺序 (对应1, 2, 3, 4)：
    ['Own Home', 'Rent', 'Have Mortgage', 'Home Mortgage'], 

    # Years in current job 的顺序 (对应1-11)：
    ['< 1 year', '1 year', '2 years', '3 years', '4 years', '5 years', '6 years', '7 years', '8 years', '9 years', '10+ years'], 

    # Term 的顺序 (对应0, 1)：
    ['Short Term', 'Long Term'] 
]

对应原先的代码：

# 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)

# 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()  #把筛选出来的列名转换成列表

iii. 构建处理有序特征的pipeline
# 构建处理有序特征的 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 定义完成。")

对应原先的缺失值补全代码：

for feature in continuous_features:    

    mode_value = data[feature].mode()[0]            #获取该列的众数。

    data[feature].fillna(mode_value, inplace=True)          #用众数填充该列的缺失值，inplace=True表示直接在原数据上修改。

iv. 标称分类特征、构建处理标称特征的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 定义完成。")

对应原先的代码：

# （Purpose没有缺失值故无处理缺失值的代码）

#   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就是独热编码后的特征名

v. 得到连续特征列表
continuous_features = [f for f in X.columns if f not in ordinal_features + nominal_features]

无原先对应代码 

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

对应原先的代码：

# 标准化数据

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

vii. 构建 ColumnTransformer
# --- 构建 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 对象看看它的结构

运行结果：ColumnTransformer (预处理器) 定义完成。

（2） 构建完整pipeline

# --- 构建完整的 Pipeline ---
# 将预处理器和模型串联起来
# 使用原代码中 RandomForestClassifier 的默认参数和 random_state
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor), # 第一步：应用所有的预处理 (我们刚刚定义的 ColumnTransformer 对象)
    ('classifier', RandomForestClassifier(random_state=42)) # 第二步：随机森林分类器 (使用默认参数和指定的 random_state)
])

print("\n完整的 Pipeline 定义完成。")
# print(pipeline) # 可以打印 pipeline 对象看看它的结构

 

4、使用pipeline进行训练和评估

# --- 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))

有用的代码是这两行：

pipeline.fit(X_train, y_train)

pipeline_pred = pipeline.predict(X_test)

对应原先的代码：

# --- 1. 默认参数的随机森林 ---
rf_model = RandomForestClassifier(random_state=42)
rf_model.fit(X_train, y_train) # 在训练集上训练
rf_pred = rf_model.predict(X_test) # 在测试集上预测

四、代码汇总 

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 # 用于将不同的预处理应用于不同的列，之前是对datafame的某一列手动处理，如果在pipeline中直接用standardScaler等函数就会对所有列处理，所以要用到这个工具
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, accuracy_score, precision_score, recall_score, f1_score
from sklearn.model_selection import train_test_split # 只导入 train_test_split


# --- 加载原始数据 ---
data = pd.read_csv('data.csv')


# Pipeline 将直接处理分割后的原始数据 X_train, X_test
# 原手动预处理步骤 (将被Pipeline替代):
# Home Ownership 标签编码
# Years in current job 标签编码
# Purpose 独热编码
# Term 0 - 1 映射并重命名
# 连续特征用众数补全


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

# --- 划分训练集和测试集 (在任何预处理之前划分) ---
# X_train 和 X_test 现在是原始数据中划分出来的部分，不包含你之前的任何手动预处理结果
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# --- 定义不同列的类型和它们对应的预处理步骤 (这些将被放入 Pipeline 的 ColumnTransformer 中) ---
# 这些定义是基于原始数据 X 的列类型来确定的

# 识别原始的 object 列 (对应你原代码中的 discrete_features 在预处理前)
object_cols = X.select_dtypes(include=['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)
]
# 先用众数填充分类特征的缺失值，然后进行有序编码
ordinal_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')), # 用众数填充分类特征的缺失值
    ('encoder', OrdinalEncoder(categories=ordinal_categories, handle_unknown='use_encoded_value', unknown_value=-1))
])


# 分类特征 
nominal_features = ['Purpose'] # 使用原始列名
# 先用众数填充分类特征的缺失值，然后进行独热编码
nominal_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')), # 用众数填充分类特征的缺失值
    ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False)) # sparse_output=False 使输出为密集数组
])


# 连续特征
# 从X的列中排除掉分类特征，得到连续特征列表
continuous_features = X.columns.difference(object_cols).tolist() # 原始X中非object类型的列

# 先用众数填充缺失值，然后进行标准化
continuous_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')), # 用众数填充缺失值 (复现你的原始逻辑)
    ('scaler', StandardScaler()) # 标准化，一个好的实践
])

# --- 构建 ColumnTransformer ---
# 将不同的预处理应用于不同的列子集，构造一个完备的转化器
preprocessor = ColumnTransformer(
    transformers=[
        ('ordinal', ordinal_transformer, ordinal_features),
        ('nominal', nominal_transformer, nominal_features),
        ('continuous', continuous_transformer, continuous_features)
    ],
    remainder='passthrough' # 保留没有在transformers中指定的列（如果存在的话），或者 'drop' 丢弃
)

# --- 构建完整的 Pipeline ---
# 将预处理器和模型串联起来
# 使用你原代码中 RandomForestClassifier 的默认参数和 random_state，这里的参数用到了元组这个数据结构
pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor), # 第一步：应用所有的预处理 (ColumnTransformer)
    ('classifier', RandomForestClassifier(random_state=42)) # 第二步：随机森林分类器
])

# --- 1. 使用 Pipeline 在划分好的训练集和测试集上评估 ---

print("--- 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))

 

@浙大疏锦行

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值