Python Machine Learning 第4章实战:使用 scikit-learn 构建高质量训练数据集(缺失值处理、类别编码、特征缩放与特征选择)

原创2026-10-14 13:06:031,991 阅读
文章标签:示例工程教程机器学习深度学习

Python Machine Learning 第4章实战:使用 scikit-learn 构建高质量训练数据集(缺失值处理、类别编码、特征缩放与特征选择)

本章是《Python Machine Learning(第3版)》代码仓库中 ch04/README.md 对应的核心实战章节,围绕"构建良好训练数据集(Data Preprocessing)"这一主题,完整演示了从原始表格数据到可训练机器学习模型之间的全部预处理链路:缺失值识别与填补、类别特征(名义型/序数型)编码、训练集/测试集划分、特征缩放、正则化驱动的特征选择、序列特征选择(SBS),以及用随机森林评估特征重要性。仓库在 ch04/ch04.py 中提供了与 Jupyter Notebook ch04/ch04.ipynb 完全对等的逐段可运行代码,并以 ch04/wine.data(178 条样本、13 个化学成分特征、3 个类别)作为贯穿全章的演示数据。读完本文,你将能够独立完成"数据清洗 → 特征工程 → 特征选择 → 模型评估"的完整数据科学工作流,并掌握 scikit-learn 估计器(estimator)API 的 fit/transform 调用范式。

环境准备与代码运行方式

在开始预处理之前,请先确保本地 Python 环境满足本书要求的核心依赖版本(详见 ch01/README.md 中的安装说明):

  • NumPy >= 1.17.4
  • SciPy >= 1.3.1
  • scikit-learn >= 0.22.0
  • matplotlib >= 3.1.0
  • pandas >= 0.25.3

推荐通过 Jupyter Notebook 交互式运行本章代码。使用 Anaconda 发行版时,只需一条命令安装:

conda install jupyter notebook

然后在包含 .ipynb 文件的目录中启动:

jupyter notebook

浏览器中即可导航到 ch04 目录打开 ch04.ipynb。如果不想使用 Notebook,也可以直接阅读或运行纯 Python 脚本版本 ch04/ch04.py——两种形式包含完全相同的代码与注释。本章代码所需的全部导入如下(对应 ch04/ch04.py):

import pandas as pd
from io import StringIO
import sys
from sklearn.impute import SimpleImputer
import numpy as np
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
from sklearn.base import clone
from itertools import combinations
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel

处理缺失数据

在表格数据中识别缺失值

先构造一个带缺失值的 CSV 字符串样本,用 pandas.read_csv 读取为 DataFrame(对应 ch04/ch04.py):

csv_data = '''A,B,C,D
1.0,2.0,3.0,4.0
5.0,6.0,,8.0
10.0,11.0,12.0,'''

if (sys.version_info < (3, 0)):
    csv_data = unicode(csv_data)   # Python 2.7 需要转换为 unicode

df = pd.read_csv(StringIO(csv_data))

用 df.isnull().sum() 可以按列统计缺失值数量,再用 df.values 取出底层的 NumPy 数组——预处理管道中几乎所有 scikit-learn 估计器都只接受 NumPy 数组,因此这一转换是后续所有步骤的前提。

删除含缺失值的样本或特征

df.dropna() 系列方法是删除缺失数据最直接的手段,可组合多种参数使用:

# 删除包含缺失值的行(axis=0 为默认值)
df.dropna(axis=0)

# 删除包含缺失值的列
df.dropna(axis=1)

# 仅当整行全部为 NaN 时才删除
df.dropna(how='all')

# 仅保留至少包含 4 个真实数值的行
df.dropna(thresh=4)

# 仅当指定列(这里是 'C')出现 NaN 时才删除该行
df.dropna(subset=['C'])

参数语义小结:axis 控制按行(0)还是按列(1)删除;how='all' 表示只在整行/整列全缺失时删除;thresh 要求行/列中至少保留的非空值数量;subset 则限定只在指定列中检测 NaN。删除策略简单高效,但会丢弃数据,因此更适合缺失比例很低的情形。

使用 SimpleImputer 填补缺失值

更稳妥的做法是用统计量填补(imputation)。scikit-learn 的 SimpleImputer 是本章使用的标准工具(对应 ch04/ch04.py):

imr = SimpleImputer(missing_values=np.nan, strategy='mean')
imr = imr.fit(df.values)
imputed_data = imr.transform(df.values)

其中 missing_values=np.nan 指定 NaN 为缺失标记,strategy='mean' 表示用每列的均值填补。等价的 pandas 写法是 df.fillna(df.mean())。SimpleImputer 的 strategy 参数除 'mean' 外,还支持 'median'(中位数)、'most_frequent'(众数)以及 'constant'(配合 fill_value 指定固定值)——具体选择取决于数据分布与业务语义。

理解 scikit-learn 估计器 API

SimpleImputer 的用法体现了 scikit-learn 的统一设计范式,全章所有预处理与模型对象都遵循同一契约:

  • fit(X, y):在训练数据上学习参数(如各列的均值),不产生变换输出;
  • transform(X):用学习到的参数对数据做实际变换;
  • fit_transform(X, y):在训练数据上一次完成"学习+变换"的便捷方法。

对模型估计器(如 LogisticRegression、KNeighborsClassifier)而言,fit 完成训练,predict 进行预测,score 返回准确率。注意:测试数据只能用训练阶段 fit 得到的参数进行 transform,绝不能用测试集重新 fit,这是避免数据泄漏(data leakage)的关键原则,在本章后面的特征缩放部分会再次强调。

处理类别数据

名义特征与序数特征

类别特征分为两类,处理方式完全不同:

  • 名义特征(nominal):类别之间没有内在顺序,如颜色 green/red/blue,直接用整数编码(如 0/1/2)会引入虚假的大小关系;
  • 序数特征(ordinal):类别之间有明确次序,如尺码 M < L < XL,应按顺序映射为整数。

本章用如下示例 DataFrame 演示两类特征的处理(对应 ch04/ch04.py):

df = pd.DataFrame([['green', 'M', 10.1, 'class2'],
                   ['red', 'L', 13.5, 'class1'],
                   ['blue', 'XL', 15.3, 'class2']])
df.columns = ['color', 'size', 'price', 'classlabel']

其中 color 是名义特征,size 是序数特征,classlabel 是类别标签。

映射序数特征

用字典 + map 方法把序数尺码映射为有序整数,并可以随时反向映射回原始标签(对应 ch04/ch04.py):

size_mapping = {'XL': 3,
                'L': 2,
                'M': 1}

df['size'] = df['size'].map(size_mapping)

# 反向映射:由整数还原为原始尺码
inv_size_mapping = {v: k for k, v in size_mapping.items()}
df['size'].map(inv_size_mapping)

这种字典映射完全由业务语义决定次序,比自动编码更可控。

编码类别标签

类别标签也需要从字符串编码为整数。可以先手动构建映射字典(对应 ch04/ch04.py):

class_mapping = {label: idx for idx, label in enumerate(np.unique(df['classlabel']))}
df['classlabel'] = df['classlabel'].map(class_mapping)

# 反向映射
inv_class_mapping = {v: k for k, v in class_mapping.items()}
df['classlabel'] = df['classlabel'].map(inv_class_mapping)

也可以直接使用 scikit-learn 的 LabelEncoder,支持 fit_transform 与 inverse_transform(对应 ch04/ch04.py):

class_le = LabelEncoder()
y = class_le.fit_transform(df['classlabel'].values)

class_le.inverse_transform(y)

对名义特征执行独热编码

名义特征若直接用 LabelEncoder 编码为 0/1/2,模型会误以为存在数值大小关系。因此必须使用独热编码(one-hot encoding),把每个类别展开为独立的 0/1 指示向量。本章依次演示了三种实现(对应 ch04/ch04.py)。

先看"先 LabelEncoder 再独热"的过渡写法:

X = df[['color', 'size', 'price']].values
color_le = LabelEncoder()
X[:, 0] = color_le.fit_transform(X[:, 0])

然后是更规范的做法——直接用 OneHotEncoder,并注意用 reshape(-1, 1) 将一维数组变为列向量:

X = df[['color', 'size', 'price']].values
color_ohe = OneHotEncoder()
color_ohe.fit_transform(X[:, 0].reshape(-1, 1)).toarray()

更完整的工程写法是用 ColumnTransformer 在同一管道中混合处理多列:对第 0 列做独热编码,第 1、2 列原样透传:

X = df[['color', 'size', 'price']].values
c_transf = ColumnTransformer([('onehot', OneHotEncoder(), [0]),
                              ('nothing', 'passthrough', [1, 2])])
c_transf.fit_transform(X).astype(float)

pandas 也提供了极简的独热编码方式 pd.get_dummies:

pd.get_dummies(df[['price', 'color', 'size']])

多重共线性警示:独热编码会为每个名义特征额外引入一个"冗余"的指示变量,导致特征之间完全线性相关(dummy variable trap),影响某些模型(如线性模型)的稳定性。消除方法是在生成时丢弃第一个类别:

# pandas 版本
pd.get_dummies(df[['price', 'color', 'size']], drop_first=True)

# scikit-learn 版本:OneHotEncoder 的 drop='first' 参数
color_ohe = OneHotEncoder(categories='auto', drop='first')
c_transf = ColumnTransformer([('onehot', color_ohe, [0]),
                              ('nothing', 'passthrough', [1, 2])])
c_transf.fit_transform(X).astype(float)

可选:序数特征的值阈值编码

如果序数特征相邻类别之间的数值差异不确定,可以改用 0/1 阈值编码(threshold encoding)。例如把 size(M/L/XL)拆成两个布尔特征 "x > M" 与 "x > L"(对应 ch04/ch04.py):

df['x > M'] = df['size'].apply(lambda x: 1 if x in {'L', 'XL'} else 0)
df['x > L'] = df['size'].apply(lambda x: 1 if x == 'XL' else 0)
del df['size']

划分训练集与测试集

本章的实战数据是 UCI Wine 数据集,仓库中提供了离线副本 ch04/wine.data(178 行,每行含 1 个类别标签 + 13 个化学成分特征),以及说明文件 ch04/wine.names.txt。原始 notebook 默认从 UCI 官网在线读取,若网络不可用,可取消注释改用本地文件:

df_wine = pd.read_csv('https://archive.ics.uci.edu/'
                      'ml/machine-learning-databases/wine/wine.data',
                      header=None)

# 若 UCI 仓库暂时不可用,改用本地数据:
# df_wine = pd.read_csv('wine.data', header=None)

df_wine.columns = ['Class label', 'Alcohol', 'Malic acid', 'Ash',
                   'Alcalinity of ash', 'Magnesium', 'Total phenols',
                   'Flavanoids', 'Nonflavanoid phenols', 'Proanthocyanins',
                   'Color intensity', 'Hue', 'OD280/OD315 of diluted wines',
                   'Proline']

print('Class labels', np.unique(df_wine['Class label']))
df_wine.head()

用 train_test_split 划分 70% 训练 / 30% 测试,并通过 stratify=y 保持类别比例一致(分层抽样,对应 ch04/ch04.py):

X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values

X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size=0.3,
                                                    random_state=0,
                                                    stratify=y)

random_state=0 保证可复现;stratify=y 在不平衡数据上尤为重要,可避免某个类别在小测试集中被意外抽空。

将特征缩放到同一尺度

特征单位差异(如 Wine 数据中 Proline 的数值范围远大于其他特征)会主导基于距离或梯度的模型。本章介绍两种缩放器,均遵循"只在训练集上 fit"的 API 原则(对应 ch04/ch04.py):

# 归一化(normalization):缩放到 [0, 1] 区间
mms = MinMaxScaler()
X_train_norm = mms.fit_transform(X_train)
X_test_norm = mms.transform(X_test)

# 标准化(standardization):均值为 0、标准差为 1
stdsc = StandardScaler()
X_train_std = stdsc.fit_transform(X_train)
X_test_std = stdsc.transform(X_test)

两者公式差异可用一个小数组直观验证(对应 ch04/ch04.py):

ex = np.array([0, 1, 2, 3, 4, 5])

# 标准化:(x - mean) / std
print('standardized:', (ex - ex.mean()) / ex.std())

# 归一化:(x - min) / (max - min)
print('normalized:', (ex - ex.min()) / (ex.max() - ex.min()))

注意一个易被忽略的细节:pandas 的 std() 默认使用 ddof=1(样本标准差),而 NumPy 的 std() 与 StandardScaler 默认使用 ddof=0(总体标准差),两者计算结果在小样本上略有差异(ch04/ch04.py 的注释明确指出了这一点)。归一化对离群点敏感、不改变数据分布形态;标准化不受尺度影响且对离群点更稳健,因此实践中标准化(z-score)通常更受推荐。

选择有意义的特征

L1 与 L2 正则化:对模型复杂度的惩罚

特征过多会带来过拟合风险。正则化通过在损失函数中追加惩罚项约束模型复杂度:

  • L2 正则化(Ridge):惩罚项为权重平方和,使权重整体变小但不为 0,各特征仍保留;
  • L1 正则化(Lasso):惩罚项为权重绝对值之和,会将不重要的权重精确压缩为 0,天然具备特征选择能力。

L2 正则化的几何解释

从几何上看,L2 约束对应权重空间中一个圆形可行域,损失函数等值线与圆相切时切点通常不在坐标轴上,因此权重被整体收缩但不会被清零;而 L1 约束是菱形可行域,其顶点位于坐标轴上,等值线更易在顶点处相切,从而产生稀疏解。这一直观差异正是 L1 能用于特征选择的原因。相关示意图见 notebook 中的 04_04.png 与 04_05.png(对应 cell 76-78)。

用 L1 正则化得到稀疏解

在 scikit-learn 中,对支持 L1 的模型只需设置 penalty='l1'(对应 ch04/ch04.py):

LogisticRegression(penalty='l1', solver='liblinear', multi_class='ovr')

# 应用于标准化后的 Wine 数据
lr = LogisticRegression(penalty='l1', C=1.0, solver='liblinear', multi_class='ovr')
lr.fit(X_train_std, y_train)
print('Training accuracy:', lr.score(X_train_std, y_train))
print('Test accuracy:', lr.score(X_test_std, y_test))

参数说明:C 是正则化强度的倒数(C=1.0 为默认值),增大 C 削弱正则化(权重更自由),减小 C 增强正则化(权重被压缩、稀疏性更强);solver='liblinear' 是支持 L1 惩罚的求解器;multi_class='ovr' 采用一对多(one-vs-rest)策略处理三分类。训练后可通过 lr.coef_ 查看 13 个特征的权重系数,其中被置为 0 的系数对应的特征即被 L1 自动剔除;lr.coef_[lr.coef_ != 0].shape 可直接统计非零系数的个数。

notebook 还演示了扫描 C 从 10^-4 到 10^5 的完整网格,绘制"正则化强度 vs 各特征权重系数"的轨迹图,直观展示随着正则化增强(C 减小)权重向 0 收缩的过程(ch04/ch04.py)。

序列特征选择算法(SBS)

L1 正则化对线性模型有效,但对黑盒模型(如 k 近邻)不适用。为此本章实现了一个贪心的**后向序列选择(Sequential Backward Selection, SBS)**算法类 SBS(对应 ch04/ch04.py):

class SBS():
    def __init__(self, estimator, k_features, scoring=accuracy_score,
                 test_size=0.25, random_state=1):
        self.scoring = scoring
        self.estimator = clone(estimator)
        self.k_features = k_features
        self.test_size = test_size
        self.random_state = random_state

    def fit(self, X, y):
        X_train, X_test, y_train, y_test = \
            train_test_split(X, y, test_size=self.test_size,
                             random_state=self.random_state)

        dim = X_train.shape[1]
        self.indices_ = tuple(range(dim))
        self.subsets_ = [self.indices_]
        score = self._calc_score(X_train, y_train,
                                 X_test, y_test, self.indices_)
        self.scores_ = [score]

        while dim > self.k_features:
            scores = []
            subsets = []

            for p in combinations(self.indices_, r=dim - 1):
                score = self._calc_score(X_train, y_train,
                                         X_test, y_test, p)
                scores.append(score)
                subsets.append(p)

            best = np.argmax(scores)
            self.indices_ = subsets[best]
            self.subsets_.append(self.indices_)
            dim -= 1

            self.scores_.append(scores[best])
        self.k_score_ = self.scores_[-1]

        return self

    def transform(self, X):
        return X[:, self.indices_]

    def _calc_score(self, X_train, y_train, X_test, y_test, indices):
        self.estimator.fit(X_train[:, indices], y_train)
        y_pred = self.estimator.predict(X_test[:, indices])
        score = self.scoring(y_test, y_pred)
        return score

算法原理:从全部特征出发,每一轮遍历"删除一个特征"的所有组合,在内部划分的验证集上用 accuracy_score 评估模型性能,贪心保留性能最优的子集,直到特征数降到目标值 k_features。实现中的几个要点:

  • clone(estimator) 深拷贝估计器,避免在多次评估中污染原模型参数;
  • itertools.combinations 枚举所有候选子集;
  • self.subsets_ 记录每轮选中的特征下标,self.scores_ 记录对应准确率,self.k_score_ 保存最终目标子集的得分。

将 SBS 应用到标准化后的 Wine 数据(对应 ch04/ch04.py):

knn = KNeighborsClassifier(n_neighbors=5)

sbs = SBS(knn, k_features=1)
sbs.fit(X_train_std, y_train)

# 绘制不同特征子集大小的准确率曲线
k_feat = [len(k) for k in sbs.subsets_]
plt.plot(k_feat, sbs.scores_, marker='o')
plt.ylim([0.7, 1.02])
plt.ylabel('Accuracy')
plt.xlabel('Number of features')
plt.grid()
plt.tight_layout()
plt.show()

# 查看第 10 轮(5 个特征)选出的特征下标
k3 = list(sbs.subsets_[10])
print(df_wine.columns[1:][k3])

# 对比全特征与精选特征下的 KNN 性能
knn.fit(X_train_std, y_train)
print('Training accuracy:', knn.score(X_train_std, y_train))
print('Test accuracy:', knn.score(X_test_std, y_test))

knn.fit(X_train_std[:, k3], y_train)
print('Training accuracy:', knn.score(X_train_std[:, k3], y_train))
print('Test accuracy:', knn.score(X_train_std[:, k3], y_test))

通过曲线可以看出,特征数减少到一定程度后测试准确率反而提升或持平——这正是特征选择降低过拟合的直接证据。

用随机森林评估特征重要性

最后一种方法借助随机森林的袋外特征重要性(feature_importances_)来衡量每个特征对分类的贡献(对应 ch04/ch04.py):

feat_labels = df_wine.columns[1:]

forest = RandomForestClassifier(n_estimators=500,
                                random_state=1)

forest.fit(X_train, y_train)
importances = forest.feature_importances_

indices = np.argsort(importances)[::-1]

for f in range(X_train.shape[1]):
    print("%2d) %-*s %f" % (f + 1, 30,
                            feat_labels[indices[f]],
                            importances[indices[f]]))

plt.title('Feature Importance')
plt.bar(range(X_train.shape[1]),
        importances[indices],
        align='center')
plt.xticks(range(X_train.shape[1]),
           feat_labels[indices], rotation=90)
plt.xlim([-1, X_train.shape[1]])
plt.tight_layout()
plt.show()

注意:随机森林可以直接在未标准化的训练数据 X_train 上训练(树模型不依赖特征尺度)。feature_importances_ 基于基尼不纯度下降量计算,数值越大表示该特征越重要。随后可用 SelectFromModel 按阈值自动筛选特征:

sfm = SelectFromModel(forest, threshold=0.1, prefit=True)
X_selected = sfm.transform(X_train)
print('Number of features that meet this threshold criterion:',
      X_selected.shape[1])

threshold=0.1 表示只保留重要性得分不低于 0.1 的特征;prefit=True 表示直接使用已训练好的 forest 而不再内部拟合。据 ch04/ch04.py 的演示,Wine 数据中有 3 个特征满足该阈值条件。

小结

本章构建了一条完整的预处理流水线:先用 isnull().sum() 发现缺失、dropna 或 SimpleImputer 处理缺失;再用字典映射/LabelEncoder/OneHotEncoder(配合 ColumnTransformer 与 drop='first')完成序数与名义特征编码;随后以 train_test_split(..., stratify=y) 分层划分数据集,并用 StandardScaler/MinMaxScaler 统一特征尺度;最后从"L1 正则化稀疏解 → SBS 序列选择 → 随机森林特征重要性"三个角度筛选有意义的特征,在 ch04/wine.data 上验证"更少特征、同样甚至更好的泛化性能"。贯穿全章的方法论是 scikit-learn 的估计器契约(fit/transform 分离、仅用训练集学习参数),它保证了整条管道可复现、可避免数据泄漏。所有代码均可直接在 ch04/ch04.py 或 ch04/ch04.ipynb 中运行验证。

登录后查看全文
python-machine-learning-book-3rd-edition