目录
[1、3.1*RMSE 的核心优势:](#1、3.1*RMSE 的核心优势:)
[1、4.1* 非线性关系强](#1、4.1* 非线性关系强)
[1、4.3* 重尾分布](#1、4.3* 重尾分布)
SimpleImputer(strategy="most_frequent")
OneHotEncoder(handle_unknown="ignore")
[handle_unknown="ignore" 的作用:](#handle_unknown="ignore" 的作用:)
[为什么不用 LabelEncoder 或 OrdinalEncoder?](#为什么不用 LabelEncoder 或 OrdinalEncoder?)
SimpleImputer(strategy="median")
[FunctionTransformer(column_ratio, ...)](#FunctionTransformer(column_ratio, ...))
[FunctionTransformer(np.log, feature_names_out="one-to-one")](#FunctionTransformer(np.log, feature_names_out="one-to-one"))
[SimpleImputer 和 StandardScaler](#SimpleImputer 和 StandardScaler)
[5、4.1 *要解决什么问题?](#5、4.1 *要解决什么问题?)
[5、4.2* 两步走:KMeans 聚类 + RBF 相似度](#5、4.2* 两步走:KMeans 聚类 + RBF 相似度)
[5、4.3 为什么继承 BaseEstimator, TransformerMixin?](#5、4.3 为什么继承 BaseEstimator, TransformerMixin?)
[5、4.4* init:只保存参数,不做计算](#5、4.4* init:只保存参数,不做计算)
[5、4.5* fit:训练 KMeans](#5、4.5* fit:训练 KMeans)
[5、4.6* transform:计算 RBF 相似度](#5、4.6* transform:计算 RBF 相似度)
[5、4.7* get_feature_names_out:生成列名](#5、4.7* get_feature_names_out:生成列名)
[5、4.8* 为什么用 RBF 而不是直接输出距离?](#5、4.8* 为什么用 RBF 而不是直接输出距离?)
[fit 内部发生了什么?](#fit 内部发生了什么?)
[关键:每次 clone 都是全新的](#关键:每次 clone 都是全新的)
[为什么调 n_clusters 会重新训练 KMeans?](#为什么调 n_clusters 会重新训练 KMeans?)
一、本章内容概览
从数据读取、分层划分、特征工程流水线,到模型训练、评价、交叉验证、超参数微调、最终测试评估。
整体流程可以概括为:
-
读数据并构造收入分类列
用
pd.cut把median_income分成 1~5 类,作为分层抽样的依据。 -
分层划分训练集/测试集
用
train_test_split(..., stratify=income_cat)保证训练集和测试集收入分布一致,然后删掉临时分类列。 -
分离特征和标签
housing是特征,housing_labels是房价median_house_value。 -
搭建预处理流水线
preprocessing包括:
-
分类列:众数填充 + OneHotEncoder
-
比率特征:
total_bedrooms/total_rooms、total_rooms/households、population/households -
对数变换:对重尾数值特征做
np.log,再标准化 -
地理位置:自定义
ClusterSimilarity,用 KMeans 聚类 + RBF 核计算房屋到聚类中心的相似度 -
剩余数值列:中位数填充 + 标准化
最终把原始特征转换成约 24 列特征。
-
-
模型选择与评价
-
线性回归:RMSE 较大,表现为欠拟合
-
决策树回归:训练集预测几乎完全正确,表现为过拟合
-
随机森林回归:用交叉验证评估,效果更好但仍有 40000+ 误差
-
-
K 折交叉验证
用
cross_val_score(..., scoring="neg_root_mean_squared_error", cv=10)验证决策树、随机森林的真实泛化能力,说明不能只看训练集预测结果。 -
超参数微调
用
GridSearchCV对随机森林流水线调参:-
preprocessing__geo__n_clusters -
random_forest__max_features还提到可用
RandomizedSearchCV做随机搜索,但更耗时。
-
-
最终模型评估
用
grid_search.best_estimator_得到最优模型,在测试集上预测并用root_mean_squared_error计算最终 RMSE。
二、完整项目
1、明确问题和数据
-
任务类型:监督学习中的回归问题
-
目标变量:
median_house_value,房屋中位价 -
特征:人口、收入、房间数、经纬度、靠近海洋程度等
-
评价指标:RMSE,均方根误差
-
需要理解:RMSE 越小越好;它和标签同单位,便于解释
1、1.数据来源
这是经典的 California Housing 数据集,来自 1990 年美国人口普查。每个样本是一个"街区组"(block group),大约 600~3000 人。
1、2.数据理解
1、2.1*数据字段
| 列名 | 含义 | 类型 | 备注 |
|---|---|---|---|
longitude |
经度 | 数值 | 地理位置 |
latitude |
纬度 | 数值 | 地理位置 |
housing_median_age |
房屋中位年龄 | 数值 | 越老越小 |
total_rooms |
街区总房间数 | 数值 | 规模相关 |
total_bedrooms |
街区总卧室数 | 数值 | 有缺失值 |
population |
街区人口 | 数值 | 规模相关 |
households |
街区家庭数 | 数值 | 规模相关 |
median_income |
收入中位数 | 数值 | 量纲特殊,需注意 |
ocean_proximity |
靠近海洋程度 | 类别 | 如 <1H OCEAN、INLAND |
median_house_value |
房屋中位价 | 数值 | 标签 y |
1、2.2*数据观察
观察 1:total_bedrooms 有缺失值
后面流水线里要用 SimpleImputer(strategy="median") 填充。这是第 5 步要处理的事。
观察 2:ocean_proximity 是类别特征
模型不能直接吃字符串,必须 OneHotEncoder 编码。这是第 5 步分类流水线要处理的事。
观察 3:median_income 不是普通数值
它的单位是"万美元"量级,但被截断过,实际值大致在 0.5~15 之间。它和房价关系最强,后面会被单独做对数变换。
1、2.3*特征关系
原始特征里有很多"规模类"特征:
-
total_rooms -
total_bedrooms -
population -
households
它们都随街区大小变化,直接使用意义不大。更有信息量的是比率:
-
每户房间数 =
total_rooms / households -
卧室占比 =
total_bedrooms / total_rooms -
每户人口 =
population / households
这就是后面 ratio_pipeline 要构造的特征。这一步先知道"为什么需要构造比率特征"。
1、3.什么是RMSE
Root Mean Squared Error,均方根误差

其中:
-
yiyi:第 i 个样本的真实房价
-
y^iy^i:第 i 个样本的预测房价
-
nn:样本数
1、3.1*RMSE 的核心优势:
-
和房价同单位:RMSE = 50000,意思是"平均而言预测误差约 5 万美元",直观。
-
惩罚大误差:因为先平方,一个误差 10 万的样本比 10 个误差 1 万的样本影响更大。房价预测里"离谱预测"代价高,所以合理。
1、3.2*使用
from sklearn.metrics import root_mean_squared_error
rmse = root_mean_squared_error(y_true, y_pred)
1、4.真正挑战
1、4.1* 非线性关系强
房价和收入不是简单线性关系。收入翻倍,房价不一定翻倍;高收入区可能因为地段、学区、海景而溢价。线性回归会欠拟合,第 7 步会看到。
1、4.2*地理信息重要但原始经纬度不好用
latitude、longitude 直接丢进模型,模型很难学到"靠近海岸线贵""靠近市中心贵"。所以第 5 步用 KMeans 聚类 + RBF 相似度,把"地理位置"转换成"到若干热点区域的相似度"。
1、4.3* 重尾分布
total_rooms、population、median_income 等特征分布右偏严重,少数大值会拉偏模型。所以第 5 步做 np.log 变换。
1、4.4*特征量纲差异大
median_income 在 0~15,population 可能上万。不标准化,线性模型和距离类算法会被大数值特征主导。所以第 5 步统一 StandardScaler。
1、4.5*过拟合风险高
决策树可以记住训练集,训练集 RMSE 接近 0,但泛化差。第 8~9 步会亲眼看到这个现象。
1、4.6*测试集只能用一次
调参、选模型都在训练集内部做(交叉验证),测试集只在第 12 步最终评估用一次。反复用测试集调参 = 测试集泄漏,最终 RMSE 会过于乐观。
2、读取数据并做初步检查
-
用
pandas.read_csv读取data/housing.csv -
查看数据形状、列名、缺失值、类别列、数值列
-
重点认识:
-
median_income -
median_house_value -
ocean_proximity -
latitude、longitude -
total_bedrooms有缺失值
-
产出:确认数据基本情况,知道哪些列需要特殊处理。
import pandas as pd
# 读取数据
housing_full = pd.read_csv('data/housing.csv')
# 初步检查
print("形状:", housing_full.shape)
print("\n前 5 行:")
print(housing_full.head())
print("\n列类型与缺失:")
print(housing_full.info())
print("\n数值列统计:")
print(housing_full.describe())
print("\n类别列分布:")
print(housing_full["ocean_proximity"].value_counts())
print("\n缺失值汇总:")
print(housing_full.isnull().sum())
3、构造收入分类列,用于分层抽样
-
用
pd.cut把median_income分成 1~5 类:[0, 1.5, 3.0, 4.5, 6.0, inf]
-
新增
income_cat列 -
目的:让训练集和测试集的收入分布一致
-
注意:
income_cat只是抽样辅助列,划分完要删除
关键概念:分层抽样 stratified sampling。
housing_full["income_cat"] = pd.cut(housing_full["median_income"],
bins=[0., 1.5, 3.0, 4.5, 6., np.inf],
labels=[1, 2, 3, 4, 5])
3、1.分层抽样
先把总体按某个关键特征分成若干层,然后从每一层里按比例抽样,保证训练集和测试集在每一层的比例与原始数据一致。
选分层变量要满足两个条件:
-
和标签强相关 :收入是房价最强的驱动因素,
median_income和median_house_value相关性很高 -
是连续变量,需要先离散化 :
train_test_split的stratify参数要求传入的是类别标签,不能直接传连续值
所以做法是:先把 median_income 切成 5 个区间,变成类别 1~5,再用这个类别做分层。
如果选 ocean_proximity 分层,虽然它也是类别,但它和房价的相关性不如收入强,而且 ISLAND 只有 5 个样本,分层后测试集里可能一个都没有,反而引入新问题。
4、划分训练集和测试集
-
用
train_test_split -
参数:
-
test_size=0.2 -
stratify=housing_full["income_cat"] -
random_state=42
-
-
划分后删除
income_cat -
从训练集分离:
-
housing:特征矩阵 -
housing_labels:标签向量
-
产出:strat_train_set、strat_test_set、housing、housing_labels。
strat_train_set, strat_test_set = train_test_split(
housing_full, test_size=0.2,
stratify=housing_full["income_cat"],
random_state=42) # stratify使train_test_split 会保证:训练集和测试集里,每个类别的比例与原始数据一致。
for _set in (strat_train_set, strat_test_set):
_set.drop('income_cat', axis=1, inplace=True)
"""
它的使命结束
保留会和 median_income 信息冗余
后续流水线不需要它
"""
housing = strat_train_set.drop("median_house_value", axis=1) #(x)
# 从训练集删除标签列 median_house_value,剩下的就是特征。
housing_labels = strat_train_set["median_house_value"].copy() # (y)
"""
housing_labels 是 strat_train_set 某一列的视图(view),不是独立副本。后续如果对 strat_train_set 做原地修改(比如填充缺失值、删除列),可能影响 housing_labels,导致标签被意外改动。
加 .copy() 后,housing_labels 是独立对象,和原 DataFrame 解耦,安全。
"""
5、设计特征工程方案
这是整个工程的核心。原始特征需要转换成模型能用的数值特征。
主要包括:
-
分类特征处理
-
ocean_proximity是 object 类型 -
用众数填充缺失值
-
用
OneHotEncoder(handle_unknown="ignore")编码
-
-
比率特征
-
total_bedrooms / total_rooms -
total_rooms / households -
population / households -
用
FunctionTransformer自定义比率转换
-
-
对数变换
-
对重尾数值特征做
np.log -
包括
total_bedrooms、total_rooms、population、households、median_income -
目的:减小重尾分布影响
-
-
地理聚类特征
-
自定义
ClusterSimilarity -
对
latitude、longitude做 KMeans 聚类 -
用 RBF 核计算每个样本到各聚类中心的相似度
-
输出
Cluster 0 similarity到Cluster 9 similarity
-
-
剩余数值列
-
中位数填充
-
标准化
StandardScaler
-
关键概念:Pipeline、ColumnTransformer、自定义 Transformer、数据泄漏。
5、1.为什么需要特征工程
| 原始列 | 问题 | 不处理会怎样 |
|---|---|---|
ocean_proximity |
字符串 | sklearn 直接报错 |
total_bedrooms |
有 207 个缺失 | 大多数模型报错或结果异常 |
total_rooms、population |
右偏严重、有极端大值 | 线性模型被大值主导,树模型分裂不优 |
median_income |
量纲特殊、被截断 | 和房价的非线性关系学不到 |
latitude、longitude |
地理坐标,直接数值意义弱 | 模型学不到"靠近海岸贵" |
total_rooms、households 等 |
都是规模量,单独看信息弱 | 应该组合成比率 |
所以需要一套特征工程流水线,把原始列转换成信息量更高的数值特征。
5、2.设计原则
-
每个变换只解决一个问题:缺失填充、编码、对数、标准化、比率、地理相似度,各司其职
-
用 Pipeline 封装 :每一步都是 sklearn transformer,可
fit/transform,可组合 -
拟合只在训练集上做 :
fit只看训练集,避免数据泄漏 -
可复用到测试集和新数据 :同一个
preprocessing对象,训练集fit_transform,测试集只transform
5、3.流水线
5、3.1*分类特征流水线
cat_pipeline = make_pipeline(
SimpleImputer(strategy="most_frequent"),
OneHotEncoder(handle_unknown="ignore"))
处理:
<1H OCEAN, INLAND, NEAR OCEAN, NEAR BAY, ISLAND
SimpleImputer(strategy="most_frequent")
-
用出现次数最多的类别填充缺失值
-
本工程
ocean_proximity其实没有缺失,但加这一层是防御性写法 -
为什么不用
median?分类列没有中位数概念 -
为什么不用
constant填"missing"?也可以,但most_frequent更简单,且本工程无缺失
OneHotEncoder(handle_unknown="ignore")
原始:ocean_proximity = "NEAR BAY"
编码后:
<1H OCEAN: 0
INLAND: 0
NEAR OCEAN:0
NEAR BAY: 1
ISLAND: 0
handle_unknown="ignore" 的作用:
-
训练时见过 5 个类别,编码器记住这 5 个
-
如果测试集或新数据出现第 6 个类别(训练时没见过的),默认会报错
-
ignore表示:未知类别全部编成 0,不报错
这是生产环境的必备设置。本工程测试集不会出现新类别,但写上更稳健。
为什么不用 LabelEncoder 或 OrdinalEncoder?
-
LabelEncoder把类别编成 0~4,会引入"大小关系"的假象(INLAND=1、NEAR BAY=3,模型可能误以为 3 > 1) -
OrdinalEncoder同理,适合有序类别(如"小/中/大") -
ocean_proximity是无序类别,必须用 One-Hot
5、3.2*比率流水线
def column_ratio(X):
return X[:, [0]] / X[:, [1]]
def ratio_name(function_transformer, feature_names_in):
return ["ratio"]
def ratio_pipeline():
return make_pipeline(
SimpleImputer(strategy="median"),
FunctionTransformer(column_ratio, feature_names_out=ratio_name),
StandardScaler())
total_rooms、total_bedrooms、population、households 都是规模量,随街区大小变化。直接看"总房间数 3000"意义不大,因为可能是 100 户的大街区,也可能是 10 户的豪宅区。
真正有信息量的是比率:
| 比率 | 含义 | 对应列 |
|---|---|---|
total_bedrooms / total_rooms |
卧室占比 | bedrooms |
total_rooms / households |
每户房间数 | rooms_per_house |
population / households |
每户人口 | people_per_house |
SimpleImputer(strategy="median")
比率流水线处理的第一列是 total_bedrooms,它有 207 个缺失,所以先用中位数填充。
注意:ColumnTransformer 把选中的列传给 ratio_pipeline 时,传入的是一个 2 列的子矩阵 。SimpleImputer 会对这两列分别填中位数。由于 total_rooms 无缺失,实际只对 total_bedrooms 生效。
FunctionTransformer(column_ratio, ...)
FunctionTransformer 把任意 Python 函数包装成 sklearn transformer。
def column_ratio(X):
return X[:, [0]] / X[:, [1]]
-
X是 numpy 数组,形状(n_samples, 2) -
X[:, [0]]取第 0 列,保持二维(n_samples, 1) -
X[:, [1]]取第 1 列 -
相除得到比率,形状
(n_samples, 1)
注意 X[:, [0]] 用双括号,保持二维。如果写成 X[:, 0],会变成一维 (n_samples,),后续 StandardScaler 会报错。
feature_names_out=ratio_name
FunctionTransformer 默认不生成有意义的列名。feature_names_out 指定一个函数,决定输出列名。
def ratio_name(function_transformer, feature_names_in):
return ["ratio"]
-
function_transformer:当前的FunctionTransformer对象 -
feature_names_in:输入列名 -
返回值:输出列名列表
三条比率流水线都输出 "ratio",但 ColumnTransformer 会用前缀区分:
-
bedrooms__ratio -
rooms_per_house__ratio -
people_per_house__ratio
StandardScaler()
标准化:减去均值,除以标准差。

-
比率值量纲不同:卧室占比约 0~1,每户房间数约 1~20
-
线性模型和距离类算法对大数值敏感
-
标准化后各特征尺度一致,训练更稳定
注意:StandardScaler 的 fit 只在训练集上算 μ 和 σ,测试集用训练集的 μ、σ 做 transform。这是 Pipeline 自动保证的,避免数据泄漏。
5、3.3*对数变换流水线
log_pipeline = make_pipeline(
SimpleImputer(strategy="median"),
FunctionTransformer(np.log, feature_names_out="one-to-one"),
StandardScaler())
处理:
"total_bedrooms", "total_rooms", "population", "households", "median_income"
为什么做对数变换
第 2 步 describe() 已经看到:这些列右偏严重,有极端大值。
以 total_rooms 为例:
-
mean ≈ 2636
-
max = 39320
-
少数极大值会把分布拉出长尾
右偏分布对模型的影响:
-
线性模型:极端值会大幅拉动回归线,拟合不稳定
-
树模型:分裂点被极端值影响,分裂不优
-
距离类算法:极端值主导距离计算
对数变换 y=ln(x)y=ln(x) 的作用:
-
压缩大值,拉伸小值
-
把右偏分布拉近正态
-
减小极端值影响
FunctionTransformer(np.log, feature_names_out="one-to-one")
-
np.log:直接传 numpy 的对数函数 -
feature_names_out="one-to-one":输入 5 列,输出 5 列,列名保持原名
如果某些值是 0 或负数,np.log 会得到 -inf 或 nan。本工程这些列最小值都 ≥ 1,安全。真实工程里可以用 np.log1p(即 log(1+x))兜底。
SimpleImputer 和 StandardScaler
-
SimpleImputer(strategy="median"):total_bedrooms有缺失,用中位数填充 -
StandardScaler():对数变换后仍要标准化,因为不同列的对数值范围仍有差异
5、4.地理聚类相似度
class ClusterSimilarity(BaseEstimator, TransformerMixin):
def __init__(self, n_clusters=10, gamma=1.0, random_state=None):
self.n_clusters = n_clusters
self.gamma = gamma
self.random_state = random_state
def fit(self, X, y=None, sample_weight=None):
self.kmeans_ = KMeans(self.n_clusters, n_init=10,
random_state=self.random_state)
self.kmeans_.fit(X, sample_weight=sample_weight)
return self
def transform(self, X):
return rbf_kernel(X, self.kmeans_.cluster_centers_, gamma=self.gamma)
def get_feature_names_out(self, names=None):
return [f"Cluster {i} similarity" for i in range(self.n_clusters)]
5、4.1 *要解决什么问题?
latitude、longitude 是地理坐标。直接把两个数值丢进模型,模型很难学到:
-
"靠近海岸线贵"
-
"靠近旧金山/洛杉矶贵"
-
"内陆便宜"
因为经纬度和房价的关系是高度非线性、局部性的。线性模型学不到,树模型需要很多次分裂才能近似。
更好的做法:把"地理位置"转换成"到若干热点区域的相似度"。
5、4.2* 两步走:KMeans 聚类 + RBF 相似度
第一步:KMeans 聚类
-
对训练集的
(latitude, longitude)做 KMeans,聚成n_clusters=10类 -
得到 10 个聚类中心,代表 10 个"地理热点区域"
-
这些中心可能是旧金山、洛杉矶、圣地亚哥、内陆某区域等
第二步:RBF 核相似度
对每个样本,计算它到 10 个聚类中心的相似度:

其中:
-
xx:样本的经纬度
-
cici:第 i 个聚类中心
-
γγ:控制相似度衰减速度,本工程
gamma=1.0 -
∥x−ci∥2∥x−ci∥2:欧氏距离平方
性质:
-
样本离中心越近,相似度越接近 1
-
样本离中心越远,相似度越接近 0
-
每个样本得到 10 个相似度值,构成 10 维特征
这样,模型看到的不再是"经度 -122.23、纬度 37.88",而是"到旧金山热点相似度 0.95、到洛杉矶热点相似度 0.02、......"。地理信息被显式表达。
5、4.3 为什么继承 BaseEstimator, TransformerMixin?
这是 sklearn 自定义 transformer 的标准写法:
| 父类 | 作用 |
|---|---|
BaseEstimator |
提供 get_params、set_params,支持 GridSearchCV 调参 |
TransformerMixin |
提供 fit_transform 方法,自动调用 fit 再 transform |
没有这两个父类,ClusterSimilarity 就不能放进 Pipeline,也不能被 GridSearchCV 调参。
5、4.4* __init__:只保存参数,不做计算
python
def __init__(self, n_clusters=10, gamma=1.0, random_state=None):
self.n_clusters = n_clusters
self.gamma = gamma
self.random_state = random_state
sklearn 约定:__init__ 只保存参数到同名属性,不做任何计算 。真正的计算在 fit 里做。这样 get_params/set_params 才能正确工作,GridSearchCV 才能调参。
5、4.5* fit:训练 KMeans
def fit(self, X, y=None, sample_weight=None):
self.kmeans_ = KMeans(self.n_clusters, n_init=10,
random_state=self.random_state)
self.kmeans_.fit(X, sample_weight=sample_weight)
return self
逐行:
-
X:形状(n_samples, 2),两列是latitude、longitude -
y=None:transformer 的fit签名要求接受y,但这里不用 -
sample_weight=None:可选样本权重,本工程不传 -
self.kmeans_:带下划线结尾,sklearn 约定表示"fit 后产生的属性" -
KMeans(self.n_clusters, n_init=10, random_state=...):-
n_clusters=10:聚 10 类 -
n_init=10:用 10 组不同初始中心跑 KMeans,取最好的。新版 sklearn 默认n_init="auto",这里显式写 10 更明确 -
random_state:固定随机种子,保证可复现
-
-
return self:sklearn 约定,fit必须返回self,这样才能链式调用
为什么 kmeans_ 带下划线?
sklearn 约定:fit 之前不存在的属性,fit 之后才产生,用下划线结尾命名。这样 check_is_fitted 能判断是否已训练。
5、4.6* transform:计算 RBF 相似度
def transform(self, X):
return rbf_kernel(X, self.kmeans_.cluster_centers_, gamma=self.gamma)
-
X:形状(n_samples, 2) -
self.kmeans_.cluster_centers_:形状(10, 2),10 个聚类中心 -
rbf_kernel(X, centers, gamma):计算 X 中每个样本到每个中心的 RBF 相似度,返回形状(n_samples, 10)
rbf_kernel 来自 sklearn.metrics.pairwise,公式:
K(x,c)=exp(−γ∥x−c∥2)K(x,c)=exp(−γ∥x−c∥2)
输出 10 列,每列是一个聚类中心的相似度。
注意 :transform 里用的是 self.kmeans_.cluster_centers_,这是 fit 时训练好的中心。测试集 transform 时,用的是训练集的中心,不是重新聚类。这保证了训练集和测试集特征空间一致。
5、4.7* get_feature_names_out:生成列名
def get_feature_names_out(self, names=None):
return [f"Cluster {i} similarity" for i in range(self.n_clusters)]
返回 10 个列名:Cluster 0 similarity 到 Cluster 9 similarity。
ColumnTransformer 会加前缀,最终列名是 geo__Cluster 0 similarity 等。
这个方法不是必须的,但有了它,preprocessing.get_feature_names_out() 能输出完整列名,方便调试和特征重要性分析。
5、4.8* 为什么用 RBF 而不是直接输出距离?
直接输出到 10 个中心的欧氏距离也可以,但:
-
距离是无界的,可能很大,需要额外标准化
-
RBF 相似度在 0~1 之间,天然归一化
-
RBF 是非线性变换,能表达"距离近时相似度高、距离远时迅速衰减"的局部性
gamma 控制衰减速度:
-
gamma大:相似度衰减快,只有很近的样本才相似 -
gamma小:相似度衰减慢,影响范围大 -
本工程
gamma=1.0,配合经纬度量级(约 -124~-114、32~42),效果合理
5、5.默认数值流水线
default_num_pipeline = make_pipeline(SimpleImputer(strategy="median"),
StandardScaler())
ColumnTransformer 的 remainder=default_num_pipeline 表示:没有被前面任何 transformer 选中的列,用这个流水线处理。
本工程中,9 列原始特征里:
-
被选中的:
total_bedrooms、total_rooms、households、population、median_income、latitude、longitude、ocean_proximity -
没被选中的:
housing_median_age
所以 remainder 实际只处理 housing_median_age 一列。
6、搭建预处理流水线preprocessing
-
用
ColumnTransformer组合多个子流水线:-
bedrooms:比率流水线 -
rooms_per_house:比率流水线 -
people_per_house:比率流水线 -
log:对数 + 标准化流水线 -
geo:地理聚类相似度 -
cat:分类流水线 -
remainder:剩余数值列默认处理
-
-
最终把原始特征转换成约 24 列特征
产出:一个可复用的 preprocessing 对象。
输入 housing: (16512, 9)
│
├─ ["total_bedrooms", "total_rooms"]
│ → ratio_pipeline.fit_transform
│ → (16512, 1) bedrooms__ratio
│
├─ ["total_rooms", "households"]
│ → ratio_pipeline.fit_transform
│ → (16512, 1) rooms_per_house__ratio
│
├─ ["population", "households"]
│ → ratio_pipeline.fit_transform
│ → (16512, 1) people_per_house__ratio
│
├─ [5 列数值]
│ → log_pipeline.fit_transform
│ → (16512, 5) log__*
│
├─ ["latitude", "longitude"]
│ → cluster_simil.fit_transform
│ → (16512, 10) geo__Cluster 0~9 similarity
│
├─ make_column_selector(object) → ["ocean_proximity"]
│ → cat_pipeline.fit_transform
│ → (16512, 5) cat__ocean_proximity_*
│
└─ remainder → ["housing_median_age"]
→ default_num_pipeline.fit_transform
→ (16512, 1) remainder__housing_median_age
hstack 拼接
▼
输出: (16512, 24)
7、用线性回归建立基线模型
-
用
make_pipeline(preprocessing, LinearRegression()) -
在训练集上
fit -
在训练集上
predict -
用
root_mean_squared_error计算 RMSE -
观察现象:预测值和真实房价差距较大,属于欠拟合
关键概念:基线模型、欠拟合、RMSE。
lin_reg = make_pipeline(preprocessing, LinearRegression())
lin_reg.fit(housing, housing_labels)
housing_predictions = lin_reg.predict(housing)
print(housing_predictions[:5].round(-2))
print(housing_labels[:5].round(-2))
print("评价指标(RMSE)", root_mean_squared_error(housing_labels, housing_predictions))
基线模型(baseline model) 是你能接受的最简单模型。它的作用是:
-
提供参照:后面决策树、随机森林的 RMSE 必须比基线低,否则复杂模型白搭
-
暴露问题:如果基线 RMSE 很大,说明任务本身难,或者特征工程不够
-
快速验证流水线 :如果线性回归都跑不通,说明
preprocessing有 bug
| 模型 | 优点 | 为什么先不用 |
|---|---|---|
| 线性回归 | 最简单、最快、可解释、无超参数 | ------ |
| 决策树 | 能拟合非线性 | 容易过拟合,第 8 步才讲 |
| 随机森林 | 效果好 | 慢,且需要先有基线对比 |
| 神经网络 | 表达力强 | 太复杂,小数据容易过拟合 |
正确评估顺序:
训练集 RMSE → 判断是否欠拟合/过拟合
交叉验证 RMSE → 判断泛化能力(第 9 步)
测试集 RMSE → 最终评估(第 12 步,只用一次)
8、用决策树回归观察过拟合
-
用
DecisionTreeRegressor(random_state=42) -
同样接入预处理流水线
-
在训练集上训练和预测
-
观察现象:训练集预测几乎完全正确,RMSE 很小
-
这不是好现象,而是过拟合
关键概念:过拟合、训练集评价的局限性。
8、1.决策树
决策树通过一系列"如果...就..."的判断,把特征空间切成很多小块,每个小块用一个常数(该块训练样本标签的均值)作为预测值。
median_income <= 3.5?
/ \
是 / \ 否
/ \
latitude <= 34.0? median_income <= 6.0?
/ \ / \
是/ \否 是/ \否
/ \ / \
预测 12万 预测 18万 预测 25万 预测 40万
决策树训练的核心是递归地找最佳切分点:
-
在当前节点,遍历所有特征和所有可能阈值
-
对每个候选切分,把样本分成左右两组
-
计算切分后的"不纯度"下降多少
-
选下降最多的切分
-
对左右子节点递归重复,直到满足停止条件
回归树常用的不纯度指标是 MSE:

切分质量用加权 MSE 下降衡量:

选 ΔΔ 最大的切分。
DecisionTreeRegressor 默认参数下,没有显式停止条件:
| 参数 | 默认值 | 含义 |
|---|---|---|
max_depth |
None |
不限制深度 |
min_samples_split |
2 |
至少 2 个样本才继续切 |
min_samples_leaf |
1 |
叶子至少 1 个样本 |
max_leaf_nodes |
None |
不限制叶子数 |
min_impurity_decrease |
0.0 |
不要求不纯度必须下降 |
这意味着:树会一直切,直到每个叶子只剩 1 个样本,或者所有叶子内标签完全相同。
这就是过拟合的根源。训练集 16512 个样本,树可以切出接近 16512 个叶子,每个叶子记住一个样本的标签,训练集 MSE 接近 0。
9、引入K折交叉验证
-
用
cross_val_score -
参数:
-
scoring="neg_root_mean_squared_error" -
cv=10
-
-
对决策树做 10 折交叉验证
-
结果说明:决策树在未见过的数据上误差很大,确认过拟合
-
注意:
neg_root_mean_squared_error是负值,需要加负号变正
关键概念:交叉验证、泛化误差、为什么不能只看训练集 RMSE。
训练集 RMSE:模型在"见过的数据"上的误差
泛化误差: 模型在"没见过的数据"上的误差
我们真正关心的是泛化误差 ,但训练集 RMSE 只是它的一个过于乐观的估计。模型越复杂,训练集 RMSE 越乐观,和泛化误差差距越大。
K折交叉验证:
把训练集分成 K 份(折),每次拿 1 份做验证,其余 K-1 份做训练,重复 K 次,得到 K 个验证误差,取平均。
# tree_reg = make_pipeline(preprocessing,
# DecisionTreeRegressor(random_state=42))
# tree_rmses = -cross_val_score(tree_reg, housing, housing_labels,
# scoring="neg_root_mean_squared_error", cv=10)
# print(tree_rmses)
10、尝试更强的模型:随机森林
-
用
RandomForestRegressor(random_state=42) -
接入同一个预处理流水线
-
用交叉验证评估
-
对比线性回归、决策树、随机森林
-
观察:随机森林通常明显优于单棵决策树,但仍有 40000+ 的 RMSE
关键概念:集成学习、随机森林、模型选择。
随机森林 = 很多棵决策树 + 样本随机 + 特征随机 + 预测取平均。
三个核心机制
机制 1:Bootstrap 采样(样本随机)
每棵树训练时,从训练集有放回地抽 16512 个样本(和原训练集同样大小)。
-
有些样本被抽中多次
-
约 36.8% 的样本一次都没被抽中,称为袋外样本(Out-of-Bag, OOB)
数学:每个样本一次都不被抽中的概率是 (1−1/n)n≈e−1≈0.368(1−1/n)n≈e−1≈0.368。
机制 2:特征随机
每次切分节点时,不从全部 24 个特征里选最佳切分 ,而是从随机子集里选。
RandomForestRegressor 默认:
-
max_features=1.0:回归任务默认用全部特征(这一点和分类任务不同) -
但即使
max_features=1.0,bootstrap 采样仍然引入随机性
实际工程中常设 max_features 为较小值(如 sqrt(24) ≈ 5 或更小),进一步降低树间相关性。
机制 3:预测取平均
回归任务:所有树的预测值算术平均。

其中 BB 是树的数量(n_estimators,默认 100)
# forest_reg = make_pipeline(preprocessing,
# RandomForestRegressor(random_state=42))
# forest_rmses = -cross_val_score(forest_reg, housing, housing_labels,
# scoring="neg_root_mean_squared_error", cv=10)
# print(forest_rmses)
11、超参数微调
-
-
preprocessing -
random_forest
-
-
调参对象:
-
preprocessing__geo__n_clusters -
random_forest__max_features
-
-
参数网格示例:
-
n_clusters:[5, 8, 10]和[10, 15] -
max_features:[4, 6, 8]和[6, 8, 10]
-
-
用
cv=3交叉验证 -
输出:
-
grid_search.best_params_ -
grid_search.best_score_
-
可选进阶:RandomizedSearchCV 随机搜索。
关键概念:超参数、网格搜索、交叉验证调参、流水线参数命名 步骤名__参数名。
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import Pipeline
full_pipeline = Pipeline([
("preprocessing", preprocessing),
("random_forest", RandomForestRegressor(random_state=42)),
])
param_grid = [
{'preprocessing__geo__n_clusters': [5, 8, 10],
'random_forest__max_features': [4, 6, 8]},
{'preprocessing__geo__n_clusters': [10, 15],
'random_forest__max_features': [6, 8, 10]},
]
grid_search = GridSearchCV(full_pipeline, param_grid, cv=3,
scoring='neg_root_mean_squared_error')
grid_search.fit(housing, housing_labels)
print(grid_search.best_params_)
print(grid_search.best_score_)
| 变量 | 含义 |
|---|---|
grid_search |
搜索器,内部保存所有尝试结果 |
grid_search.best_params_ |
最佳参数组合 |
grid_search.best_score_ |
最佳交叉验证分数 |
grid_search.best_estimator_ |
用最佳参数重新训练的模型(第 12 步用) |
随机森林默认 max_features=1.0,即每次切分用全部 24 个特征。这导致:
-
每棵树看到的特征几乎一样
-
树间相关性 ρρ 高
-
平均降方差效果打折
调小 max_features 后:
-
每棵树关注不同特征子集
-
树间相关性降低
-
平均后方差更低,泛化更好
但 max_features 太小也不行:每棵树太弱,偏差上升。所以存在一个最优值,需要搜索。
本工程要调的两个超参数
| 超参数 | 路径 | 含义 | 候选值 |
|---|---|---|---|
n_clusters |
preprocessing__geo__n_clusters |
地理聚类数 | 5, 8, 10, 15 |
max_features |
random_forest__max_features |
每次切分考虑的特征数 | 4, 6, 8, 10 |
为什么调 n_clusters?
第 5 步的 ClusterSimilarity(n_clusters=10) 是拍脑袋选的。10 个地理热点是否合理?5 个可能太粗,15 个可能太细。搜索能找到更合适的粒度。
为什么调 max_features?
这是随机森林最核心的正则化参数。调小降相关性,调大保留单树能力。需要平衡。
为什么不调 n_estimators?
n_estimators 增大只会降低方差,不会导致过拟合,收益递减。默认 100 通常够用,调到 200~500 收益很小,但计算成本线性增长。所以优先调 max_features 和 n_clusters。
- 双下划线
__:sklearn 参数路径分隔符
fit 内部发生了什么?
grid_search.fit(housing, housing_labels)
1. 展开 param_grid,得到 15 个参数组合
[
{'n_clusters': 5, 'max_features': 4},
{'n_clusters': 5, 'max_features': 6},
...
{'n_clusters': 15, 'max_features': 10},
]
2. 对每个组合:
a. clone(full_pipeline)
b. set_params(**组合) # 设置参数
c. 做 3 折交叉验证:
- 每折:fit 训练部分,评估验证部分
- 得到 3 个负 RMSE
d. 计算平均负 RMSE
e. 记录
3. 比较 15 个组合的平均分,选最高的
→ best_params_
→ best_score_
4. refit=True:
用 best_params_ 在整个训练集上重新 fit
→ best_estimator_
关键:每次 clone 都是全新的
GridSearchCV 对每个组合都 clone 一个新流水线,不复用之前的状态。这保证:
-
不同组合之间互不干扰
-
StandardScaler、KMeans等每次重新fit -
没有数据泄漏
为什么调 n_clusters 会重新训练 KMeans?
n_clusters 是 ClusterSimilarity.__init__ 的参数。当 set_params(preprocessing__geo__n_clusters=5) 时:
-
ColumnTransformer把geo这条 transformer 的n_clusters设为 5 -
下一折
fit时,ClusterSimilarity.fit用n_clusters=5重新跑 KMeans -
生成 5 个聚类中心,而不是 10 个
-
输出特征从 10 列变成 5 列
所以调 n_clusters 不仅改聚类数,还改输出特征维度 。这也是为什么 preprocessing 必须在每折内重新 fit。
12、最终模型在测试集上评估
-
取
grid_search.best_estimator_作为最终模型 -
从
strat_test_set分离:-
X_test -
y_test
-
-
用最终模型预测
-
用
root_mean_squared_error(y_test, final_predictions)计算测试集 RMSE -
这个结果才是对最终泛化能力的估计
关键概念:测试集只用于最终评估、不能反复调参、避免测试集泄漏。
final_model = grid_search.best_estimator_ # 最优的估计器
# 将特征矩阵 和 标签向量 分开
X_test = strat_test_set.drop("median_house_value", axis=1)
y_test = strat_test_set["median_house_value"].copy()
final_predictions = final_model.predict(X_test) # 预测
final_rmse = root_mean_squared_error(y_test, final_predictions) # 评估
print(final_rmse)
第 1 步:明确问题
监督学习回归,目标 median_house_value,指标 RMSE
第 2 步:读数据
20640 行 10 列,total_bedrooms 有缺失,ocean_proximity 是类别
第 3 步:构造 income_cat
为分层抽样准备
第 4 步:分层划分
训练集 16512,测试集 4128,测试集冻起来
第 5 步:设计特征工程
分类编码、比率、对数、地理聚类、标准化
第 6 步:组装 preprocessing
ColumnTransformer,9 列 → 24 列
第 7 步:线性回归
训练集 RMSE ≈ 68000,欠拟合
第 8 步:决策树
训练集 RMSE ≈ 0,过拟合
第 9 步:交叉验证
决策树 RMSE ≈ 67153,确认过拟合
第 10 步:随机森林
交叉验证 RMSE ≈ 48000,明显改善
第 11 步:GridSearchCV 调参
best_params_ = {n_clusters: 10, max_features: 6}
交叉验证 RMSE ≈ 47500
第 12 步:测试集最终评估
final_rmse ≈ 47500,相对误差约 23%
→ 工程结束
13、工程收尾与可扩展方向
-
保存模型:
joblib.dump -
保存预处理流水线
-
新数据预测流程
-
可扩展:
-
特征重要性分析
-
误差分析
-
更细的调参
-
模型持久化
-
部署为 API
-
整体项目代码:
import pandas as pd
import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.cluster import KMeans
from sklearn.compose import ColumnTransformer, make_column_selector
from sklearn.ensemble import RandomForestRegressor
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LinearRegression
from sklearn.metrics import root_mean_squared_error
from sklearn.metrics.pairwise import rbf_kernel
from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold, GridSearchCV
from sklearn.pipeline import make_pipeline, Pipeline
from sklearn.preprocessing import OneHotEncoder, FunctionTransformer, StandardScaler
from sklearn.tree import DecisionTreeRegressor
# 1、获取数据
housing_full = pd.read_csv('data/housing.csv')
# 3、分层抽样
housing_full["income_cat"] = pd.cut(housing_full["median_income"],
bins = [0,1.5,3.0,4.5,6,np.inf],
labels = [1,2,3,4,5])
# 4、划分数据集和测试集
strat_train_set,strat_test_set = train_test_split(
housing_full,
test_size=0.2,
stratify=housing_full["income_cat"],
random_state=42)
for _set in (strat_train_set,strat_test_set):
_set.drop('income_cat', axis=1, inplace=True)
housing = strat_train_set.drop('median_house_value', axis=1)
housing_labels = strat_train_set['median_house_value'].copy()
# 5、设计特征工程方案
class ClusterSimilarity(BaseEstimator, TransformerMixin):
def __init__(self, n_clusters=10, gamma=1.0, random_state=None):
self.n_clusters = n_clusters
self.gamma = gamma
self.random_state = random_state
def fit(self, X, y=None,sample_weight=None):
self.kmeans = KMeans(self.n_clusters,
n_init=10,
random_state=self.random_state)
self.kmeans_.fit(X,sample_weight=sample_weight)
return self
def transform(self,X):
return rbf_kernel(X,self.kmeans_.clusters_,gamma=self.gamma)
def get_feature_name_out(self,names=None):
return [f"Cluster {i} similarity" for i in range(self.n_clusters)]
cluster_simil = ClusterSimilarity(n_clusters = 10,gamma=1.,random_state=42)
cat_pipeline = make_pipeline(
SimpleImputer(strategy='most_frequent'),
OneHotEncoder(handle_unknown='ignore')
)
def column_ratio(X):
return X[:, [0]] / X[:, [1]]
def ratio_name(function_transformer,feature_names_in):
return ['ratio']
def ratio_pipeline():
return make_pipeline(
SimpleImputer(strategy="median"),
FunctionTransformer(column_ratio, feature_names_out=ratio_name),
StandardScaler())
log_pipeline = make_pipeline(
SimpleImputer(strategy="median"),
FunctionTransformer(np.log, feature_names_out="one-to-one"),
StandardScaler())
default_num_pipeline = make_pipeline(SimpleImputer(strategy="median"),
StandardScaler())
# 6、搭建预处理流水线preprocessing
preprocessing = ColumnTransformer([
("bedrooms", ratio_pipeline(), ["total_bedrooms", "total_rooms"]),
("rooms_per_house", ratio_pipeline(), ["total_rooms", "households"]),
("people_per_house", ratio_pipeline(), ["population", "households"]),
("log", log_pipeline, ["total_bedrooms", "total_rooms", "population",
"households", "median_income"]),
("geo", cluster_simil, ["latitude", "longitude"]),
("cat", cat_pipeline, make_column_selector(dtype_include=object)),
],
remainder=default_num_pipeline)
# # 7 线性回归
# lin_reg = make_pipeline(preprocessing,
# LinearRegression())
# lin_reg.fit(housing, housing_labels)
# housing_prediction = lin_reg.predict(housing)
# print(housing_prediction[:5].round(-2))
# print(housing_labels[:5].round(-2))
# # 8 决策树
# tree_reg = make_pipeline(preprocessing, DecisionTreeRegressor(random_state=42))
# tree_reg.fit(housing, housing_labels)
# housing_prediction = tree_reg.predict(housing)
# print(housing_prediction[:5].round(-2))
# print(housing_labels[:5].round(-2))
# # 9 K折交叉验证
# tree_reg = make_pipeline(preprocessing,
# DecisionTreeRegressor(random_state=42))
# tree_rmses = -cross_val_score(tree_reg, housing, housing_labels,
# scoring="neg_root_mean_squared_error", cv=10)
# print(tree_rmses)
# 10、尝试更强的模型--随机森林
# forest_reg = make_pipeline(preprocessing,
# RandomForestRegressor(random_state=42))
# forest_rmses = -cross_val_score(forest_reg, housing, housing_labels,
# scoring="neg_root_mean_squared_error", cv=10)
# print(forest_rmses)
# 11、超参数微调
# 流水线 两条各取了一个参数进行微调 本次只微调n_clusters max_features
full_pipeline = Pipeline([
("preprocessing", preprocessing),
("random_forest", RandomForestRegressor(random_state=42)),
])
param_grid = [
{'preprocessing__geo__n_clusters': [5, 8, 10],
'random_forest__max_features': [4, 6, 8]},
{'preprocessing__geo__n_clusters': [10, 15],
'random_forest__max_features': [6, 8, 10]},
]
grid_search = GridSearchCV(full_pipeline, param_grid, cv=3,
scoring='neg_root_mean_squared_error')
grid_search.fit(housing, housing_labels)
print(grid_search.best_params_)
print(grid_search.best_score_)
"""from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint
param_distribs = {'preprocessing__geo__n_clusters': randint(low=3, high=50),
'random_forest__max_features': randint(low=2, high=20)}
rnd_search = RandomizedSearchCV(
full_pipeline, param_distributions=param_distribs, n_iter=10, cv=3,
scoring='neg_root_mean_squared_error', random_state=42)
rnd_search.fit(housing, housing_labels)"""
# 12、确定最终模型
final_model = grid_search.best_estimator_ # 最优的估计器
# 将特征矩阵 和 标签向量 分开
X_test = strat_test_set.drop("median_house_value", axis=1)
y_test = strat_test_set["median_house_value"].copy()
final_predictions = final_model.predict(X_test) # 预测
final_rmse = root_mean_squared_error(y_test, final_predictions) # 评估
print(final_rmse)