机器学习05,用 scikit-learn 做加州房价预测的完整入门工程

目录

一、本章内容概览

二、完整项目

1、明确问题和数据

1、1.数据来源

1、2.数据理解

1、2.1*数据字段

1、2.2*数据观察

1、2.3*特征关系

1、3.什么是RMSE

[1、3.1*RMSE 的核心优势:](#1、3.1*RMSE 的核心优势:)

1、3.2*使用

1、4.真正挑战

[1、4.1* 非线性关系强](#1、4.1* 非线性关系强)

1、4.2*地理信息重要但原始经纬度不好用

[1、4.3* 重尾分布](#1、4.3* 重尾分布)

1、4.4*特征量纲差异大

1、4.5*过拟合风险高

1、4.6*测试集只能用一次

2、读取数据并做初步检查

3、构造收入分类列,用于分层抽样

3、1.分层抽样

4、划分训练集和测试集

5、设计特征工程方案

5、1.为什么需要特征工程

5、2.设计原则

5、3.流水线

5、3.1*分类特征流水线

SimpleImputer(strategy="most_frequent")

OneHotEncoder(handle_unknown="ignore")

[handle_unknown="ignore" 的作用:](#handle_unknown="ignore" 的作用:)

[为什么不用 LabelEncoder 或 OrdinalEncoder?](#为什么不用 LabelEncoder 或 OrdinalEncoder?)

5、3.2*比率流水线

SimpleImputer(strategy="median")

[FunctionTransformer(column_ratio, ...)](#FunctionTransformer(column_ratio, ...))

feature_names_out=ratio_name

StandardScaler()

5、3.3*对数变换流水线

为什么做对数变换

[FunctionTransformer(np.log, feature_names_out="one-to-one")](#FunctionTransformer(np.log, feature_names_out="one-to-one"))

[SimpleImputer 和 StandardScaler](#SimpleImputer 和 StandardScaler)

5、4.地理聚类相似度

[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 而不是直接输出距离?)

5、5.默认数值流水线

6、搭建预处理流水线preprocessing

7、用线性回归建立基线模型

8、用决策树回归观察过拟合

8、1.决策树

9、引入K折交叉验证

10、尝试更强的模型:随机森林

三个核心机制

11、超参数微调

本工程要调的两个超参数

[fit 内部发生了什么?](#fit 内部发生了什么?)

[关键:每次 clone 都是全新的](#关键:每次 clone 都是全新的)

[为什么调 n_clusters 会重新训练 KMeans?](#为什么调 n_clusters 会重新训练 KMeans?)

12、最终模型在测试集上评估

13、工程收尾与可扩展方向

整体项目代码:


一、本章内容概览

从数据读取、分层划分、特征工程流水线,到模型训练、评价、交叉验证、超参数微调、最终测试评估。

整体流程可以概括为:

  1. 读数据并构造收入分类列

    用 pd.cut 把 median_income 分成 1~5 类,作为分层抽样的依据。

  2. 分层划分训练集/测试集

    用 train_test_split(..., stratify=income_cat) 保证训练集和测试集收入分布一致,然后删掉临时分类列。

  3. 分离特征和标签

    housing 是特征,housing_labels 是房价 median_house_value。

  4. 搭建预处理流水线 preprocessing

    包括:

    • 分类列:众数填充 + OneHotEncoder

    • 比率特征:total_bedrooms/total_rooms、total_rooms/households、population/households

    • 对数变换:对重尾数值特征做 np.log,再标准化

    • 地理位置:自定义 ClusterSimilarity,用 KMeans 聚类 + RBF 核计算房屋到聚类中心的相似度

    • 剩余数值列:中位数填充 + 标准化

      最终把原始特征转换成约 24 列特征。

  5. 模型选择与评价

    • 线性回归:RMSE 较大,表现为欠拟合

    • 决策树回归:训练集预测几乎完全正确,表现为过拟合

    • 随机森林回归:用交叉验证评估,效果更好但仍有 40000+ 误差

  6. K 折交叉验证

    用 cross_val_score(..., scoring="neg_root_mean_squared_error", cv=10) 验证决策树、随机森林的真实泛化能力,说明不能只看训练集预测结果。

  7. 超参数微调

    用 GridSearchCV 对随机森林流水线调参:

    • preprocessing__geo__n_clusters

    • random_forest__max_features

      还提到可用 RandomizedSearchCV 做随机搜索,但更耗时。

  8. 最终模型评估

    用 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 的核心优势:
  1. 和房价同单位:RMSE = 50000,意思是"平均而言预测误差约 5 万美元",直观。

  2. 惩罚大误差:因为先平方,一个误差 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.分层抽样

先把总体按某个关键特征分成若干层,然后从每一层里按比例抽样,保证训练集和测试集在每一层的比例与原始数据一致。

选分层变量要满足两个条件:

  1. 和标签强相关 :收入是房价最强的驱动因素,median_income 和 median_house_value 相关性很高

  2. 是连续变量,需要先离散化 :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、设计特征工程方案

这是整个工程的核心。原始特征需要转换成模型能用的数值特征。

主要包括:

  1. 分类特征处理

    • ocean_proximity 是 object 类型

    • 用众数填充缺失值

    • 用 OneHotEncoder(handle_unknown="ignore") 编码

  2. 比率特征

    • total_bedrooms / total_rooms

    • total_rooms / households

    • population / households

    • 用 FunctionTransformer 自定义比率转换

  3. 对数变换

    • 对重尾数值特征做 np.log

    • 包括 total_bedrooms、total_rooms、population、households、median_income

    • 目的:减小重尾分布影响

  4. 地理聚类特征

    • 自定义 ClusterSimilarity

    • 对 latitude、longitude 做 KMeans 聚类

    • 用 RBF 核计算每个样本到各聚类中心的相似度

    • 输出 Cluster 0 similarity 到 Cluster 9 similarity

  5. 剩余数值列

    • 中位数填充

    • 标准化 StandardScaler

关键概念:Pipeline、ColumnTransformer、自定义 Transformer、数据泄漏。

5、1.为什么需要特征工程

原始列 问题 不处理会怎样
ocean_proximity 字符串 sklearn 直接报错
total_bedrooms 有 207 个缺失 大多数模型报错或结果异常
total_rooms、population 右偏严重、有极端大值 线性模型被大值主导,树模型分裂不优
median_income 量纲特殊、被截断 和房价的非线性关系学不到
latitude、longitude 地理坐标,直接数值意义弱 模型学不到"靠近海岸贵"
total_rooms、households 等 都是规模量,单独看信息弱 应该组合成比率

所以需要一套特征工程流水线,把原始列转换成信息量更高的数值特征。

5、2.设计原则

  1. 每个变换只解决一个问题:缺失填充、编码、对数、标准化、比率、地理相似度,各司其职

  2. 用 Pipeline 封装 :每一步都是 sklearn transformer,可 fit/transform,可组合

  3. 拟合只在训练集上做 :fit 只看训练集,避免数据泄漏

  4. 可复用到测试集和新数据 :同一个 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) 是你能接受的最简单模型。它的作用是:

  1. 提供参照:后面决策树、随机森林的 RMSE 必须比基线低,否则复杂模型白搭

  2. 暴露问题:如果基线 RMSE 很大,说明任务本身难,或者特征工程不够

  3. 快速验证流水线 :如果线性回归都跑不通,说明 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万

决策树训练的核心是递归地找最佳切分点:

  1. 在当前节点,遍历所有特征和所有可能阈值

  2. 对每个候选切分,把样本分成左右两组

  3. 计算切分后的"不纯度"下降多少

  4. 选下降最多的切分

  5. 对左右子节点递归重复,直到满足停止条件

回归树常用的不纯度指标是 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)
相关推荐
伞伞悦读25 分钟前
【第86期】分类指标与错误成本对照的实验与排查
大数据·人工智能·机器学习
深兰科技34 分钟前
走出进博展馆寻AI方案,巴西政商联合体参访深兰科技洽商中巴产业数字化合作
人工智能·typescript·深兰科技·中巴产业数字化·巴西政商联合体·ai方案·进博会
美团技术团队35 分钟前
EMNLP 2026 | 美团技术团队学术论文精选
人工智能
Summer-Bright43 分钟前
企业落地智能体,供应链签名还是空白:1862 个 MCP 服务器无认证裸奔
服务器·人工智能·github·mcp
ZhengEnCi1 小时前
Agent 只输出计划不调用工具怎么办:从终止信号错位到结果验收的四层防线
人工智能·agent
xsd202411181 小时前
把模型从 FP32 压到 INT8:PTQ、QAT 与 PyTorch 量化全链路
人工智能
AI源码1 小时前
基于机器学习的优衣库销售预测与决策系统
人工智能·机器学习
可夫小子2 小时前
13 条数据跑出 65.87 分:这场 48 小时真机挑战赛,拆穿了具身智能的落地真相
人工智能
大模型真好玩2 小时前
做好真人分身却不知道拍什么?8个视频应用场景直接抄
人工智能·agent·deepseek