Pandas数据预处理与机器学习实战：从清洗到收入预测模型-代码聚汇网

Pandas数据预处理与机器学习实战：从清洗到收入预测模型

BugEnigma·2026-09-05·阅读 21 GEO检测（免费）

数据预处理PandasNumPy

|难度：普通|阅读约 22 分钟

1. 别急着调参：先把手头的数据变成算法能“吃”的样子

走到第八讲，NumPy和Pandas的底子应该已经打得差不多了。前面几讲我们折腾过数组、DataFrame、缺失值清洗、分组聚合，说实话，那些才是整个数据分析流程里最磨人的部分。到了机器学习这一步，反而轻松不少——因为算法是现成的，你真正要操心的核心问题只有一个：怎么把手头这份“不听话”的业务数据，变成模型能直接消费的矩阵。

这一讲的定位很明确：用NumPy和Pandas做数据预处理，然后用scikit-learn跑通线性回归和决策树两个经典模型。不需要推导复杂的数学公式，也不需要手写梯度下降，你只要搞清楚每个环节在干什么、为什么这么干，后面调参、换模型都是顺水推舟的事。

先说一个很多人绕进去的误区：以为机器学习就是从from sklearn.linear_model import LinearRegression开始的。实际项目里，算法调用只占整个流程的五分之一不到。你把Excel表导进来，发现日期列是字符串、收入列有缺失值、地区列是中文文本——这些才是真正决定模型上限的地方。所以这一讲我会把数据准备的比重拉高，模型部分反而讲得“糙”一点，重点放在“为什么这么做”而不是“API怎么调”。

学完这一讲，你应该能独立完成这样一条链路：读入数据 → 清洗与类型转换 → 特征编码 → 切分训练测试集 → 训练模型 → 评估指标 → 简单调参。整个过程用的就是你手头这辆“老马车”——NumPy负责底层数组运算，Pandas负责表结构和清洗，sklearn只在你最后需要时出来收个尾。这种组合的好处是：即使脱离机器学习框架，你依然能理解每个数据变换背后的含义，不至于变成只会调包的“API调用师”。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 环境与数据准备：少走弯路，从装对包开始

2.1 版本兼容问题：numpy、pandas和sklearn的“三角关系”

很多人一上来就pip install numpy pandas sklearn，结果跑代码时被一堆报错劝退。这里先解决几个高频坑。首先是numpy和Python版本的匹配。由于numpy的预编译wheel要求特定CPU指令集，如果你的机器本身不支持某些优化指令，会出现类似RuntimeError: numpy was built with baseline optimizations: (x86_v2) but your这样的报错。这不是你代码的问题，是numpy版本与CPU不匹配。解决办法很简单：强制安装旧版或纯源码版本，比如在Windows上直接pip install numpy==1.26.4，或者去官网下载对应Python版本的wheel文件手动安装。

其次是pandas和numpy的兼容。因为pandas底层大量依赖numpy的C扩展，numpy版本太新或太旧都会导致pandas某些方法异常。我个人的测试经验是：Python 3.9配numpy 1.23.5 + pandas 2.0.3 + scikit-learn 1.3.2这一套组合非常稳，在Windows和Linux上都没出过大问题。Python 3.11以上建议直接装最新版numpy和pandas，但要注意，如果遇到Importerror: numba needs numpy 2.4 or less. Got numpy 2.5.这种报错，说明你的numpy版本超过了某些依赖库的限制，降级numpy即可。

最后是scikit-learn和pandas之间的接口变化。老版本sklearn接受DataFrame输入时会自动识别列名，新版本也支持，但要求列名必须是字符串。如果你之前的DataFrame列名是数字或者含有特殊符号，训练时会报特征名不匹配的错误。保险做法是在训练前统一df.columns = [str(c) for c in df.columns]。

2.2 用Pandas造一份可复现的演示数据集

为了避免“巧妇难为无米之炊”，我建议你直接构造一份带点“脏乱差”特征的数据来练手。下面这份数据是我专门为这一讲设计的，模拟的是某公司员工收入预测场景——正好对应热词里那个“收入预测”的案例。生成数据的代码很简单，但它包含了真实数据分析中常见的三类问题：列类型不对、文本类别特征、缺失值。

python复制import numpy as np
import pandas as pd

rng = np.random.default_rng(42)
n = 1000

df = pd.DataFrame({
    'age': rng.integers(22, 60, n),
    'years_experience': rng.integers(0, 35, n),
    'education': rng.choice(['高中', '本科', '硕士', '博士'], n, p=[0.2, 0.4, 0.3, 0.1]),
    'city': rng.choice(['一线', '二线', '三线'], n, p=[0.4, 0.35, 0.25]),
    'department': rng.choice(['技术', '产品', '运营', '市场'], n),
    'monthly_income': np.nan
})

# 真实逻辑：收入由经验、教育、城市决定，再加点噪声
base = 8000
df['monthly_income'] = (
    base
    + df['years_experience'] * 800
    + df['education'].map({'高中': 0, '本科': 1000, '硕士': 2500, '博士': 5000})
    + df['city'].map({'一线': 3000, '二线': 1000, '三线': 0})
    + rng.normal(0, 1500, n)
)

# 人为制造缺失值
missing_idx = rng.choice(n, 50, replace=False)
df.loc[missing_idx, 'monthly_income'] = np.nan

df.head()

这份数据把收入定成了“经验×800 + 学历补贴 + 城市补贴 + 噪声”，背后隐藏的线性关系非常清晰，方便你回头验证模型学到的系数是否接近真实值。

2.3 预处理四板斧：类型修正、缺失值处理、文本编码、特征选择

拿到这份数据，跟着下面四步走，基本能应付绝大多数表格类数据。

第一步，看类型。 用df.dtypes跑一遍，把明显不对的列修正过来。比如日期列如果是字符串，要用pd.to_datetime转换；收入列如果有千分位逗号，要先去掉逗号再转成float。这一步看似简单，但漏掉一个对象类型的数值列，模型会直接报错或者把它当作类别特征处理，结果完全跑偏。

第二步，处理缺失值。 数值列的缺失值我一般用中位数填充，因为中位数对异常值不敏感，比均值更稳。类别列的缺失值可以填众数，或者直接新增一个“缺失”类别，让模型自己学。千万别一上来就dropna，样本本来就少，删一行就少一行信息。填充之后记得验证一下：df.isnull().sum() 应该全部是0。

第三步，文本编码。 这也是热词里被翻了无数次牌子的“pandas 数据类型转换”的实用场景。分类变量分两种情况：

有序类别（比如学历高中<本科<硕士<博士），用df['education'].map()映射成整数，1、2、3、4，模型能理解大小关系。
无序类别（比如城市、部门），用pd.get_dummies(df, columns=['city', 'department'], drop_first=True)做独热编码。drop_first=True的意思是：有K个类别就生成K-1个哑变量，防止多重共线性，这个细节很多教程都没讲。

第四步，特征选择。 我习惯先跑一个两行代码的快速相关性分析：

python复制corr_matrix = df.corr(numeric_only=True)
corr_matrix['monthly_income'].sort_values(ascending=False)

相关性不是因果，但能帮你快速过滤掉明显没用的列。如果两列相关系数超过0.8（比如“工作年限”和“年龄”经常高度相关），建议只保留业务意义更强的那一个，避免共线性干扰模型系数的解释。

3. 线性回归：先手写一遍原理，再用sklearn写一遍实现

3.1 为什么线性回归是机器学习的第一课

原因特别朴素：它简单、透明、解释性强。你训练完一个模型，可以把每个特征的系数直接打印出来——“工作年限每增加1年，月收入平均增加800元”——这种判断业务人员能直接看懂，不像神经网络那样是个“黑盒”。热词里出现过的“物理约束的机器学习”，很多时候也是在回归模型里加入业务先验知识，但理解基础线性回归是必经之路。

从数学上理解线性回归，核心就一句话：找到一组权重w，让y_pred = X·w + b与真实y之间的误差最小。误差怎么度量？常用的是均方误差MSE，即(1/n) * Σ(y - y_pred)^2。为什么要平方而不是取绝对值？两个原因：一是平方处处可导，方便用梯度下降求极值；二是它放大了大误差的影响，模型自然会优先把那些偏差很大的样本纠正回来。

3.2 用NumPy手写解析解：20行代码看透最小二乘

正规方程（Normal Equation）是线性回归的闭式解，不需要迭代，一步到位：

python复制# 把DataFrame转成numpy矩阵，加一列1作为截距项
X_raw = df[['age', 'years_experience']].copy()
# 我们先用这两个数值特征跑通流程
X = X_raw.values.astype(float)
y = df['monthly_income'].values.astype(float)

# 处理缺失值：直接丢掉，后续再讲更优雅的方式
mask = ~np.isnan(y)
X, y = X[mask], y[mask]

# 添加偏置列（全1）
X_b = np.c_[np.ones((X.shape[0], 1)), X]

# 正规方程：w = (X^T X)^(-1) X^T y
w = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y
print("截距:", w[0])
print("系数:", w[1:])

np.c_是NumPy里按列拼接的写法，等同于np.hstack，用来给特征矩阵加上一列全1，以此实现截距。@是矩阵乘法运算符，等价于np.dot。

系数打印出来后，你应该看到年龄的系数很小（因为收入本身跟年龄没有直接关系，年龄是通过影响经验年限才间接影响收入），而经验年限的系数接近800。这一步能让你直观体会到“相关性不等于因果性”——年龄和目标变量可能有一定相关性，但在控制经验年限后，净效应很小。

3.3 用sklearn实现：接口统一，省心省力

上面手写一遍是为了让你理解内部原理，真正业务里直接用sklearn即可。这里有一个pandas与sklearn衔接的小细节必须时刻记住：sklearn只接受二维数组，切片时别省掉两个方括号。

python复制from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

features = ['age', 'years_experience']
X = df[features].values
y = df['monthly_income'].values

# 去掉y中的缺失值对应行
valid = ~np.isnan(y)
X, y = X[valid], y[valid]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

model = LinearRegression()
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
print("MSE:", mean_squared_error(y_test, y_pred))
print("R2:", r2_score(y_test, y_pred))
print("系数:", model.coef_)
print("截距:", model.intercept_)

注意：这里我只用了两个数值特征，所以准确率一般。等我们把“学历”和“城市”编码进去之后，R2会明显提升，这正好演示了特征工程的作用。

3.4 回归模型的评估：MSE、RMSE、MAE、R2怎么选

这是个面试高频考点，也是实际项目里大家各说各话的地方。我的建议很简单：

指标	计算公式	特点与使用场景
MSE	Σ(y - ŷ)² / n	平方放大误差，对异常值敏感；梯度计算方便
RMSE	√MSE	与y同量纲，直接反映平均预测偏差；最常用
MAE	Σ\|y - ŷ\| / n	对异常值不敏感，反映平均绝对偏差
R2	1 - SS_res / SS_tot	解释方差比例，0.9以上说明模型抓住了大部分规律

我的个人习惯是：优先报RMSE，因为它有实际业务含义。比如“我们的收入预测模型平均偏差是1450元”，业务方一听就明白。R2用来做模型之间的横向比较，但别迷信R2无限接近1的场景，那八成是过拟合了，测试集上会现原形。

4. 决策树：可解释性方面的王者，和回归是两种思路

4.1 从“猜年龄”游戏理解决策树的工作方式

决策树的原理特别像玩“猜年龄”的游戏：对方心里想一个数，你问“大于50吗”“小于30吗”，每问一句就缩小范围，直到最终锁定答案。决策树训练的过程，本质上就是自动找到“最有效的那批问题”——每个节点从所有特征里挑一个最优特征，以及该特征的最优切分点，使得切分后节点内部的“纯度”提升最大。

这里“纯度”的衡量指标主要是信息增益。信息增益 = 父节点的熵 - 子节点加权熵之和。熵越大说明数据越混乱（类别越均匀），熵越小说明数据越纯（偏向某一类）。每次分裂时，算法挑选能让信息增益最大的特征和阈值。你不需要手动实现熵的计算，但理解这个逻辑对后面看树的可视化、做剪枝非常重要——你看到某个节点根据“years_experience <= 2.5”切分，就能明白：在样本里，工作年限2.5年左右的收入规律差异最大，值得作为第一刀。

4.2 用Pandas处理分类特征后，训练一棵收入预测决策树

先完整走一遍用Pandas做特征编码、再训练决策树的流程。这里我们把收入变成二分类：月收入是否超过12000元，变成“高收入 / 普通收入”预测问题。

python复制from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

df_ml = df.dropna(subset=['monthly_income']).copy()
df_ml['high_income'] = (df_ml['monthly_income'] > 12000).astype(int)

# 有序类别 -> 整数
edu_map = {'高中': 0, '本科': 1, '硕士': 2, '博士': 3}
df_ml['edu_level'] = df_ml['education'].map(edu_map)

# 无序类别 -> 独热编码
city_dummies = pd.get_dummies(df_ml['city'], prefix='city', drop_first=True)
dept_dummies = pd.get_dummies(df_ml['department'], prefix='dept', drop_first=True)

features = pd.concat([
    df_ml[['age', 'years_experience', 'edu_level']],
    city_dummies,
    dept_dummies
], axis=1)

X_train, X_test, y_train, y_test = train_test_split(
    features, df_ml['high_income'], test_size=0.2, random_state=42
)

clf = DecisionTreeClassifier(max_depth=4, min_samples_leaf=10, random_state=42)
clf.fit(X_train, y_train)

print("训练集准确率:", clf.score(X_train, y_train))
print("测试集准确率:", clf.score(X_test, y_test))

这里选max_depth=4和min_samples_leaf=10是有意为之的。不限制深度的话，决策树会疯狂分裂直到每个叶子节点都“很纯”，训练集准确率可能直接到98%，但测试集掉到70%——这就是典型的过拟合。限制深度和叶子最小样本数，本质上是给模型“砍树”，让每个叶子节点有足够多的样本支撑，提高泛化能力。

4.3 把树画出来：看到分叉，才能真正理解模型

决策树最大的优势就是可以可视化。用一行plot_tree画出来，对比用NumPy手写矩阵、用Pandas硬造特征时的理解深度，完全不是一个层级。

python复制plt.figure(figsize=(20, 12))
plot_tree(clf, filled=True, feature_names=features.columns, 
          class_names=['普通', '高收入'], rounded=True, fontsize=9)
plt.savefig('decision_tree_visual.png', dpi=150, bbox_inches='tight')

你会看到根节点从years_experience <= 2.5开始切分——说明工作年限是预测高收入最重要的特征。往下一层可能出现edu_level <= 2.5（即硕士以下/硕士及以上）。如果树里出现了某个城市的特征，说明城市对收入分层有额外解释力。这种可视化，是线性回归的系数表给不了的直观体验。

4.4 决策树剪枝：信息增益背后的“奥卡姆剃刀”

热词里“决策树剪枝面试题”被反复搜索，这里系统捋一遍。剪枝分两种：

预剪枝（前剪枝）：在构建树时提前停止分裂。手段包括设置max_depth、min_samples_split、min_samples_leaf、max_features。优点：简单高效，训练时间短；缺点：容易“短视”，比如当前节点的分裂增益不大但后续分裂会显著提升，一次性砍掉可能损失性能。
后剪枝（后剪枝）：先把树完整长出来，再自底向上判断，如果剪掉某个子树后验证集误差不升反降或持平，就剪掉。常用方法有代价复杂度剪枝（CCP，Cost Complexity Pruning），对应sklearn的ccp_alpha参数。后剪枝通常比预剪枝效果更好，但计算开销大。

面试题的经典答法是：剪枝目的不是单纯提高训练集精度，而是为了提高泛化能力、防止过拟合、增强可解释性。工作年限、教育水平、城市这些特征，如果树一直长到叶子节点只剩一两个样本，那些分裂规则大概率是噪声，没有实际业务价值。

4.5 从单棵树到随机森林：多棵树的“民主投票”

单棵决策树的缺点很明显：方差大。训练数据的微小扰动可能导致完全不同的树结构。业界最常见的解决办法就是集成学习——训练多棵树，让它们“投票”决定最终结果，这就是随机森林（Random Forest）。

随机森林比单棵决策树好在哪？两个核心机制：随机样本抽样（bootstrap）和随机特征选择。每棵树用不同的样本子集、不同的特征子集训练，虽然单棵树可能“偏科”，但集成起来就能取长补短。用sklearn实现随机森林只需改一行代码：

python复制from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=200, max_depth=6, 
                            min_samples_leaf=5, random_state=42)
rf.fit(X_train, y_train)
print("RF测试集准确率:", rf.score(X_test, y_test))

# 特征重要性
importance = pd.Series(rf.feature_importances_, index=features.columns).sort_values(ascending=False)
print(importance.head(10))

跑完你会发现：随机森林的测试集准确率通常比单棵树高2到5个百分点。但要注意，n_estimators不是越大越好，超过某阈值后收益骤降，还白白增加训练时间。一般200到500就够用了。

5. 模型评估与调参：准确率不是唯一标准，防止过拟合才是硬功夫

5.1 训练集和测试集划分的正确姿势

train_test_split是人尽皆知的API，但用对的人不多。三个容易出错的地方：

一，随机种子要固定。 random_state=42里那个42没有魔法含义，就是让每次运行结果一致。如果你不设置，每次运行划分结果都不同，你辛辛苦苦调好的参数，换个划分就失效，等于白调。业务上大量使用随机种子还会导致“复现困难”，别人拿你的代码跑不出相同结果，这是协作的大忌。

二，分层抽样。 如果数据类别不平衡（比如高收入人群只占10%），建议把stratify=y加上。它保证训练集和测试集里正例比例与原始数据一致。否则可能训练集里高收入样本被分走大部分，测试集里几乎没有正样本，准确率评估完全失真。

三，时间序列数据不能用随机划分。 如果你在预测股票、销量这类带时间属性的数据，必须坚持“按时间切分”——前80%的时间段做训练，后20%做测试。用随机切分透露“未来信息”给模型，测试成绩虚高，上线立刻拉胯。

5.2 回归与分类场景下的评估指标选择：准召率、F1、AUC

分类问题的评估比回归复杂，因为“准确率”并不总是可靠的指标。假如数据里95%都是普通收入、只有5%是高收入，模型“无脑”预测所有样本为普通，准确率也有95%。但这对业务没有任何价值。所以分类要关注更细的指标：

精确率（Precision）：预测为“高收入”的样本里，真高收入的比例。它回答“模型说是高收入的，靠谱吗？”
召回率（Recall）：真实高收入里，被模型找出来的比例。它回答“高收入人群里，模型漏掉了多少？”
F1分数：精确率和召回率的调和平均数。

精确率和召回率天然存在矛盾。你放宽阈值，模型就会逮到更多高收入样本（召回率升），但混进来的噪声也多（精确率降）；你收紧阈值，精确率升但召回率降。F1把两者均衡起来，作为单数字指标很方便。如果你更看重“别把普通人误判为高收入”，就重点看精确率；如果更在意“把高收入的人都找出来”，就盯着召回率。

python复制from sklearn.metrics import classification_report, confusion_matrix

print(classification_report(y_test, rf.predict(X_test)))
print(confusion_matrix(y_test, rf.predict(X_test)))

classification_report会一次性输出Precision、Recall、F1、support。那些不求甚解的人以为打印出来就算完事了，实际上把表格逐行看明白才是项目复盘的基础。

5.3 用交叉验证拉平“运气误差”

单次划分测试集有个问题：如果恰好把最好预测的那些样本分到测试集，模型表现得就好；分基线了，模型表现就差。交叉验证就是反复切分、反复验证的平均结果，能更稳定地反映模型真实水平。“k折交叉验证”就是把数据切成K份，每次用K-1份训练、1份验证，轮换K次，最后取平均。sklearn里两行搞定：

python复制from sklearn.model_selection import cross_val_score

scores = cross_val_score(RandomForestClassifier(n_estimators=200, random_state=42), 
                         features, df_ml['high_income'], cv=5, scoring='accuracy')
print("5折交叉验证分数:", scores)
print("平均分数:", scores.mean())

我见过大量“模型调参后测试集分数涨了2个点”的汇报，一追问用的什么数据划分，发现就是一次train_test_split的抖动。交叉验证会把这种水分挤掉不少。热词里“机器学习期末复习”“机器学习课程环境搭建”的出现频率很高，说明不少人是冲着应付考试来的——那交叉验证更是必考知识点，务必自己跑通一遍。

5.4 调参方向：max_depth、min_samples_leaf、n_estimators

最后给一套实用的调参顺序，这些参数不是玄学，每调一个都有明确的目的：

第一，max_depth。 树的深度直接决定模型复杂度。深度过浅（比如1）模型欠拟合；深度过深（比如20）几乎肯定过拟合。经验上，从3到10之间按步长1搜索即可。

第二，min_samples_leaf。 它控制叶子节点的最小样本数。值越大，树越保守，泛化越好。我从5开始试，业务数据量小的时候甚至可以试20到30。

第三，n_estimators。 随机森林里的树数量。数量增加通常不会让模型变差，但边际收益递减。先用200跑一遍，如果资源允许再试500，对比一下提升幅度再做决定。

python复制from sklearn.model_selection import GridSearchCV

param_grid = {
    'max_depth': [3, 5, 7, 9],
    'min_samples_leaf': [5, 10, 20]
}

grid = GridSearchCV(
    RandomForestClassifier(n_estimators=200, random_state=42),
    param_grid, cv=5, scoring='f1', n_jobs=-1
)
grid.fit(features, df_ml['high_income'])

print("最优参数:", grid.best_params_)
print("最优F1:", grid.best_score_)

GridSearchCV是常用的网格搜索工具，它替你执行“参数排列组合 × 交叉验证”的全套循环。走完这一步，你就有了自己的一套调参方法论，而不是靠猜。

5.5 特征重要性的解读：业务方最喜欢问的那个问题

模型训练完之后，业务方最爱问的问题是：“到底什么因素最影响收入？”这时特征重要性就是最好的回答。随机森林的feature_importances_会告诉你每个特征对预测的贡献比例，所有的重要性加起来等于1。拿我们这份数据跑出来，大概率是years_experience最高，其次是edu_level和city_一线。这种结论能够用数据说话，说服力远超“我猜工作年限很重要”。

但必须提醒一句：特征重要性的第二特征与第一特征存在相关性时，权重会分摊。如果两个高度相关，它的重要性会被低估。这个问题在树模型里没有完美解法，你能做的是提前检查相关性，该删的删掉，并在汇报时加一句“由于特征相关性，重要性排序只能作为参考，不能完全代表因果贡献”。

6. 完整流程串联：从Pandas DataFrame到决策树模型，一条龙演示

到这里，所有零件都备齐了，最后把完整流程从头到尾跑一遍。你需要一份“躺着也能复现”的模板，以后做任何表格类数据建模，直接往上套。

python复制import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import mean_squared_error, r2_score, classification_report
from sklearn.tree import DecisionTreeClassifier, plot_tree

# ============ 1. 数据读取与清洗 ============
# data = pd.read_excel('data.xlsx')  # 实际业务中替换成你的数据
data = df_ml.copy()

# 类型修正（示例：把字符串收入转成数值）
# data['income'] = pd.to_numeric(data['income'].str.replace(',', ''), errors='coerce')

# ============ 2. 特征工程 ============
data['edu_level'] = data['education'].map({'高中': 0, '本科': 1, '硕士': 2, '博士': 3})
city_dummies = pd.get_dummies(data['city'], prefix='city', drop_first=True)
dept_dummies = pd.get_dummies(data['department'], prefix='dept', drop_first=True)

features = pd.concat([
    data[['age', 'years_experience', 'edu_level']],
    city_dummies,
    dept_dummies
], axis=1)
target_reg = data['monthly_income']
target_clf = (data['monthly_income'] > 12000).astype(int)

# ============ 3. 数据划分 ============
X_train, X_test, y_train, y_test = train_test_split(
    features, target_clf, test_size=0.2, stratify=target_clf, random_state=42
)

# ============ 4. 模型训练与评估 ============
model = RandomForestClassifier(n_estimators=200, max_depth=6, min_samples_leaf=5, random_state=42)
model.fit(X_train, y_train)
print("测试集准确率:", model.score(X_test, y_test))
print(classification_report(y_test, model.predict(X_test)))

# 5折交叉验证
cv_scores = cross_val_score(model, features, target_clf, cv=5)
print("交叉验证平均准确率:", cv_scores.mean())

# ============ 5. 输出特征重要性 ============
importance = pd.Series(model.feature_importances_, index=features.columns).sort_values(ascending=False)
print(importance)

这段代码可以直接存成脚本。以后接手任何分类任务，从第二步开始换特征、换目标，最快十几分钟就能出第一版结果，后续再根据评估指标迭代。

但完整流程不止于“跑通”——还有两件事必须在此刻做掉：

第一，保存模型。 训练一次模型可能很快，但测试集的随机性、调参过程都在消耗时间。用joblib.dump(model, 'income_model.pkl')把模型存下来，下次直接加载预测新数据，不用重新训练。

第二，持续监控数据分布。 训练时的数据分布可能三个月后就变了，模型难免“断崖式失效”。工业界的做法是定期用最新数据重新评估模型，发现评估指标掉得厉害就触发重训。这个“模型生命周期管理”观念，越早养成越好。

7. 避坑指南与实用建议：这八讲最值得反复看的几个细节

7.1 RuntimeError: numpy was built with baseline optimizations

这个词条在热搜里出现频率不低。它本质是numpy的预编译包与CPU指令集版本不匹配导致的。常见于以下几类机器：老旧的Intel CPU、部分虚拟化环境、某些云服务器实例。解决办法按优先级排序：

升级numpy到最新版，通常官方wheel已经支持多版本指令集。
如果升级失败，降级到numpy 1.24以下的老版本，它们对不同CPU的兼容性更稳。
终极方案是pip install numpy --no-binary :all:，强制从源码编译安装，耗时但一定兼容。编译需要提前装好Python开发环境和C编译器（Windows上装Visual Studio Build Tools，Linux装build-essential）。

7.2 “numpy怎么打开”和pandas包安装的核心坑

“numpy怎么打开”这类热词，背后一般是新手卡在环境变量或IDE路径上。凡是import时报ModuleNotFoundError，先检查一个问题：你在哪个Python环境里装包？用哪个Python环境跑代码？这两个必须一致。在PyCharm里，右下角能看到当前解释器路径；在VS Code里，右下角或者命令面板Python: Select Interpreter可以选。装包优先用pip配镜像源，国内用户建议pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple，能省很多等待时间。

7.3 pandas数据类型转换和drop的实战细节

astype是最常用的类型转换方法，但遇到“12,000”这种带逗号的字符串会直接报错。正确姿势是先用str.replace(',', '')清理，再pd.to_numeric(..., errors='coerce')。注意errors='coerce'这个参数：无法转换的会被置为NaN，而不是直接抛异常，非常适合批量处理不规则数据。

df.drop高频使用的场景是删行或删列。删列默认axis=1，删行默认axis=0，很容易记反。我的口诀是“行行出状元，列列有水平”——axis=0是行，axis=1是列。还有inplace=True是原地修改，不写就会返回新DataFrame而原表不变，新手经常踩这个坑。

7.4 最后一个实用建议：先跑通，再优化

这一讲内容信息密度很大，如果你是从第一篇开始跟下来的老读者，这时候应该有一个自己的“机器学习工具箱”了：NumPy做矩阵运算、Pandas做数据处理、sklearn做模型训练、matplotlib做可视化。遇到新数据集，先走一遍完整流程，出一版结果；有反应了，再回头优化特征，或调参提高指标。千万不要从一开始就追求“完美模型”——没有一个模型一次就能调出最优点，迭代才是常态。

另外，建议把这些代码整理成一份独立的“数据科学模板脚本”，每次拿到数据直接改列名和清洗逻辑，两周后你会感谢当时认真写注释的自己。要记住，这一讲的每个案例、每个报错，我都真实踩过。你现在花半小时跑通一遍，将来可能会省下不止一晚上的排查时间。