Day22/23-CSDN博客

本文链接：https://blog.csdn.net/2503_90872377/article/details/147928475

Day22:titanic数据集处理

PassengerId	乘客编号
Survived	是否幸存（0表示未幸存，1表示幸存）
Pclass	乘客舱位等级（1表示一等舱，2表示二等舱，3表示三等舱）
Name	乘客姓名
Sex	性别
Age	年龄
SibSp	同乘的兄弟姐妹或配偶数量
Parch	同乘的父母或子女数量
Ticket	票号
Fare	票价
Cabin	舱室号
Embarked	登船港口

导入库

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix,precision_score,f1_score,recall_score
from imblearn.over_sampling import SMOTE
from sklearn.metrics import accuracy_score
from lightgbm import LGBMClassifier
import matplotlib.pyplot as plt
import seaborn as sns
import shap
import warnings
# 忽略警告
warnings.filterwarnings("ignore")
 
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

读取数据

plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
train_data = pd.read_csv('train.csv')
test_data = pd.read_csv('test.csv')
train_data

结果：

数据处理

#删除无关列 乘客编号、名字、
drop_columns = ['Name','Ticket','PassengerId','Cabin']
train_data = train_data.drop(drop_columns,axis=1)
test_data = test_data.drop(drop_columns,axis=1)

# 性别0-1编码
train_data['Sex'] = train_data['Sex'].map({'female': 0, 'male': 1})
test_data['Sex'] = test_data['Sex'].map({'female': 0, 'male': 1})
train_data
#找连续变量借助select_dtypes方法。
continuous_features = train_data.select_dtypes(include=['float64', 'int64']).columns.tolist()
continuous_features

#填补缺失值（对年龄中位数）
imputer_median = SimpleImputer(strategy='median')
train_data['Age'] = imputer_median.fit_transform(train_data[['Age']])
train_data.isnull().sum()
#分离离散特征
discrete_features = ['Pclass', 'Sex', 'SibSp', 'Parch', 'Embarked']
# 离散特征独热编码
encoded_df = pd.get_dummies(train_data[discrete_features], drop_first=True)
 #_df表示datafame
# 连续特征标准化
scaler = StandardScaler()
scaled_continuous = scaler.fit_transform(train_data[continuous_features])
scaled_df = pd.DataFrame(scaled_continuous, columns=continuous_features)
 
# 合并所有特征
X = pd.concat([scaled_df, encoded_df], axis=1)
y = train_data['Survived']
#划分训练测试机
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

可视化

plt.figure(figsize=(15, 10))
 
# 连续特征分布
plt.subplot(2, 2, 1)
data['Sex'].hist(bins=30)
plt.title('Age Distribution')
 
plt.subplot(2, 2, 2)
data['Embarked'].hist(bins=30)
plt.title('Fare Distribution')
 
# 离散特征与生存率关系
plt.subplot(2, 2, 3)
data.groupby('Pclass')['Survived'].mean().plot(kind='bar')
plt.title('Survival Rate by Pclass')
plt.ylabel('Survival Rate')
 
plt.subplot(2, 2, 4)
data.groupby('Sex')['Survived'].mean().plot(kind='bar')
plt.title('Survival Rate by Sex')
plt.ylabel('Survival Rate')
 
plt.tight_layout()
plt.show()

SMOTE过采样训练模型

import time
import numpy as np
from imblearn.over_sampling import SMOTE
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report
from sklearn.metrics import classification_report, confusion_matrix
import time
# SMOTE 过采样
X_train_smote, y_train_smote = SMOTE(random_state=42).fit_resample(X_train, y_train)
print("SMOTE过采样后训练集的形状：", X_train_smote.shape, y_train_smote.shape)
 
# 训练随机森林模型并计时
start_time = time.time()
rf_pred_smote = RandomForestClassifier(random_state=42).fit(X_train_smote, y_train_smote).predict(X_test)
end_time = time.time()
print(f"SMOTE过采样后训练与预测耗时: {end_time - start_time:.4f} 秒")
 
# 输出评估结果
print("\nSMOTE过采样后随机森林 在测试集上的分类报告：")
print(classification_report(y_test, rf_pred_smote))
print("SMOTE过采样后随机森林 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, rf_pred_smote))

结果：

SMOTE过采样后训练集的形状： (888, 8) (888,)
SMOTE过采样后训练与预测耗时: 0.1240 秒

SMOTE过采样后随机森林 在测试集上的分类报告：
              precision    recall  f1-score   support

           0       0.85      0.81      0.83       105
           1       0.75      0.80      0.77        74

    accuracy                           0.80       179
   macro avg       0.80      0.80      0.80       179
weighted avg       0.81      0.80      0.81       179

SMOTE过采样后随机森林 在测试集上的混淆矩阵：
[[85 20]
 [15 59]]

调参分析指标

#调参
rf_param_grid = {
    'n_estimators': [100, 200],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 5, ]
}
rf_grid_search = GridSearchCV(RandomForestClassifier(random_state=42), rf_param_grid, cv=5)
rf_grid_search.fit(X_train, y_train)
rf_best_model = rf_grid_search.best_estimator_
rf_pred = rf_best_model.predict(X_test)
 
print("\n随机森林（调参后） 分类报告：")
print(classification_report(y_test, rf_pred))
print("随机森林（调参后） 混淆矩阵：")
print(confusion_matrix(y_test, rf_pred))
 
rf_accuracy = accuracy_score(y_test, rf_pred)
rf_precision = precision_score(y_test, rf_pred)
rf_recall = recall_score(y_test, rf_pred)
rf_f1 = f1_score(y_test, rf_pred)
print("随机森林（调参后） 模型评估指标：")
print(f"准确率: {rf_accuracy:.4f}")
print(f"精确率: {rf_precision:.4f}")
print(f"召回率: {rf_recall:.4f}")
print(f"F1 值: {rf_f1:.4f}")
best_rf = rf_grid_search.best_estimator_

随机森林（调参后） 分类报告：
              precision    recall  f1-score   support

           0       0.82      0.89      0.85       105
           1       0.82      0.73      0.77        74

    accuracy                           0.82       179
   macro avg       0.82      0.81      0.81       179
weighted avg       0.82      0.82      0.82       179

随机森林（调参后） 混淆矩阵：
[[93 12]
 [20 54]]
随机森林（调参后） 模型评估指标：
准确率: 0.8212
精确率: 0.8182
召回率: 0.7297
F1 值: 0.7714

SHAP可解释性分析

#SHAP分析
explainer = shap.TreeExplainer(best_rf)
shap_values = explainer.shap_values(X_test)
# --- 1. SHAP 特征重要性条形图 (Summary Plot - Bar) ---
shap.summary_plot(shap_values[:, :, 0], X_test, plot_type="bar",show=False)
plt.title("SHAP Feature Importance (Bar Plot)")
plt.show()

# --- 2. SHAP 依赖图 (Dependence Plot) ---
print("--- 2. SHAP 依赖图 ---")
shap.dependence_plot(0, shap_values[:, :, 0], X_test, show=False)
plt.title("SHAP Dependence Plot")
plt.show()

# --- 3. SHAP 单个样本解释图 (Force Plot) ---
print("--- 3. SHAP 单个样本解释图 ---")
plt.figure(figsize=(15, 4))
shap.force_plot(explainer.expected_value[0],
                shap_values[0][:, 0],
                X_test.iloc[0,:],
                matplotlib=True,
                show=False,
                text_rotation=30)
plt.title("SHAP Force Plot for Single Sample", pad=20)
plt.tight_layout()
plt.show()

DAY 23 pipeline管道

知识回顾:

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

作业：

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

（一）简介

在机器学习中，通常会按照一定的顺序对数据进行预处理、特征提取、模型训练和模型评估等步骤，以实现机器学习模型的训练和评估。为了方便管理这些步骤，我们可以使用pipeline来构建一个完整的机器学习流水线。

pipeline是一个用于组合多个估计器（estimator）的 estimator，它实现了一个流水线，其中每个估计器都按照一定的顺序执行。在pipeline中，每个估计器都实现了fit和transform方法，fit方法用于训练模型，transform方法用于对数据进行预处理和特征提取。

转换器

转换器（transformer）是一个用于对数据进行预处理和特征提取的 estimator，它实现一个 transform 方法，用于对数据进行预处理和特征提取。转换器通常用于对数据进行预处理，例如对数据进行归一化、标准化、缺失值填充等。转换器可以在训练集上学习转换规则，并在训练集之外的新数据上应用这些规则。

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

估计器

估计器（Estimator）是实现机器学习算法的对象或类。它用于拟合（fit）数据并进行预测（predict）估计器的主要方法是fit和predict。fit方法用于根据输入数据学习模型的参数和规律，而predict方法用于对新的未标记样本进行预测。估计器的特点是有状态的，即它们在训练过程中存储了关于数据的状态信息，以便在预测阶段使用。

常见的估计器包括分类器（classifier）、回归器（regresser）、聚类器（clusterer）。

总结

机器学习的管道（Pipeline）机制通过将多个转换器和估计器按顺序连接在一起，可以构建一个完整的数据处理和模型训练流程。在管道机制中，可以使用Pipeline类来组织和连接不同的转换器和估计器。优点在于：参数集在新数据集（比如测试集）上的重复使用。且代码看上去更加简洁明确。这也意味着，很多个不同的数据集，只要处理成管道的输入形式，后续的代码就可以复用。

Pipeline最大的价值和核心应用场景之一，就是与交叉验证和网格搜索等结合使用

（二）代码对比

无pipeline代码

# 先运行之前预处理好的代码
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表示直接在原数据上修改。

# 最开始也说了 很多调参函数自带交叉验证，甚至是必选的参数，你如果想要不交叉反而实现起来会麻烦很多
# 所以这里我们还是只划分一次数据集
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))

有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 # 用于将不同的预处理应用于不同的列，之前是对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))

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

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

           0       0.77      0.97      0.85      1059
           1       0.78      0.29      0.42       441

    accuracy                           0.77      1500
   macro avg       0.77      0.63      0.64      1500
weighted avg       0.77      0.77      0.73      1500

默认随机森林 在测试集上的混淆矩阵：
[[1023   36]
 [ 313  128]]

（三）尝试通用pipeline

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.compose import make_column_selector
from sklearn.base import BaseEstimator, TransformerMixin
 
# 定义数值型和类别型特征的预处理步骤
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),  # 填充缺失值
    ('scaler', StandardScaler())  # 标准化
])
 
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),  # 填充缺失值
    ('onehot', OneHotEncoder(handle_unknown='ignore'))  # 独热编码
])
 
# 使用ColumnTransformer组合不同类型的预处理
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, make_column_selector(dtype_include=['int64', 'float64'])),
        ('cat', categorical_transformer, make_column_selector(dtype_include=['object', 'category']))
    ])
 
# 创建完整的pipeline，包含预处理、特征选择和模型
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),  # 数据预处理
    ('feature_selection', SelectKBest(score_func=f_classif, k=10)),  # 特征选择
    ('classifier', RandomForestClassifier())  # 分类器
])

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

# 加载数据
data = pd.read_csv('data.csv')
X = data.drop('Target', axis=1)
y = data['Target']

# 拆分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建pipeline（可替换为任意sklearn模型）
pipeline = create_ml_pipeline(
    estimator=LogisticRegression(max_iter=1000),
    k_features=10
)

# 训练和预测
pipeline.fit(X_train, y_train)
score = pipeline.score(X_test, y_test)
print(f"模型准确率: {score:.2%}")

@浙大疏锦行