跳至主要内容
Ctrl+K
scikit-learn homepage
  • 安装
  • 用户指南
  • API
  • 示例
  • 社区
    • 入门
    • 发布历史
    • 词汇表
    • 开发
    • 常见问题
    • 支持
    • 相关项目
    • 路线图
    • 治理
    • 关于我们
  • GitHub
  • 安装
  • 用户指南
  • API
  • 示例
  • 社区
  • 入门
  • 发布历史
  • 词汇表
  • 开发
  • 常见问题
  • 支持
  • 相关项目
  • 路线图
  • 治理
  • 关于我们
  • GitHub

章节导航

  • 发布亮点
    • scikit-learn 1.5 发布亮点
    • scikit-learn 1.4 发布亮点
    • scikit-learn 1.3 发布亮点
    • scikit-learn 1.2 发布亮点
    • scikit-learn 1.1 发布亮点
    • scikit-learn 1.0 发布亮点
    • scikit-learn 0.24 发布亮点
    • scikit-learn 0.23 发布亮点
    • scikit-learn 0.22 发布亮点
  • 双向聚类
    • 谱双向聚类算法演示
    • 谱共聚类算法演示
    • 使用谱共聚类算法对文档进行双向聚类
  • 校准
    • 分类器校准比较
    • 概率校准曲线
    • 三分类概率校准
    • 分类器的概率校准
  • 分类
    • 分类器比较
    • 带协方差椭球的线性判别分析和二次判别分析
    • 用于分类的正态、Ledoit-Wolf 和 OAS 线性判别分析
    • 绘制分类概率图
    • 识别手写数字
  • 聚类
    • 手写数字数据上的 K 均值聚类演示
    • 硬币图像上的结构化 Ward 层次聚类演示
    • 均值漂移聚类算法演示
    • 聚类性能评估中的随机调整
    • 带结构和不带结构的凝聚聚类
    • 使用不同指标的凝聚聚类
    • K-Means++ 初始化示例
    • 二分 K 均值和常规 K 均值性能比较
    • 使用 K 均值进行颜色量化
    • 比较 BIRCH 和 MiniBatchKMeans
    • 比较玩具数据集上的不同聚类算法
    • 比较玩具数据集上的不同层次链接方法
    • K 均值和 MiniBatchKMeans 聚类算法的比较
    • DBSCAN 聚类算法演示
    • HDBSCAN 聚类算法演示
    • OPTICS 聚类算法演示
    • 近邻传播聚类算法演示
    • K 均值假设演示
    • K 均值初始化影响的实证评估
    • 特征凝聚
    • 特征凝聚与单变量选择
    • 层次聚类:结构化与非结构化 Ward
    • 归纳聚类
    • K 均值聚类
    • 人脸部分字典的在线学习
    • 绘制层次聚类树状图
    • 将希腊硬币图片分割成区域
    • 使用轮廓分析选择 K 均值聚类的簇数
    • 用于图像分割的谱聚类
    • 数字二维嵌入上的各种凝聚聚类
    • 矢量量化示例
  • 协方差估计
    • Ledoit-Wolf 与 OAS 估计
    • 鲁棒协方差估计和马氏距离相关性
    • 鲁棒协方差估计与经验协方差估计
    • 收缩协方差估计:LedoitWolf 与 OAS 和最大似然
    • 稀疏逆协方差估计
  • 交叉分解
    • 比较交叉分解方法
    • 主成分回归与偏最小二乘回归
  • 数据集示例
    • 绘制随机生成的分类数据集
    • 绘制随机生成的多标签数据集
    • 数字数据集
    • 鸢尾花数据集
  • 决策树
    • 决策树回归
    • 多输出决策树回归
    • 绘制在鸢尾花数据集上训练的决策树的决策面
    • 使用成本复杂度剪枝对决策树进行后剪枝
    • 了解决策树结构
  • 分解
    • 使用 FastICA 进行盲源分离
    • LDA 和 PCA 的 Iris 数据集二维投影比较
    • 人脸数据集分解
    • 因子分析(带旋转)以可视化模式
    • 二维点云上的 FastICA
    • 使用字典学习进行图像去噪
    • 增量 PCA
    • 核 PCA
    • 使用概率 PCA 和因子分析 (FA) 进行模型选择
    • 使用 Iris 数据集的 PCA 示例
    • 使用预先计算的字典进行稀疏编码
  • 开发估算器
    • __sklearn_is_fitted__ 作为开发者 API
  • 集成方法
    • 梯度提升中的分类特征支持
    • 使用堆叠组合预测器
    • 比较随机森林和直方图梯度提升模型
    • 比较随机森林和多输出元估计器
    • 使用 AdaBoost 进行决策树回归
    • 梯度提升中的提前停止
    • 树的森林的特征重要性
    • 使用树的集成进行特征转换
    • 直方图梯度提升树中的特征
    • 梯度提升袋外估计
    • 梯度提升回归
    • 梯度提升正则化
    • 使用完全随机树进行哈希特征转换
    • IsolationForest 示例
    • 单调约束
    • 多类 AdaBoost 决策树
    • 随机森林的 OOB 错误
    • 并行树的森林的像素重要性
    • 绘制由 VotingClassifier 计算的类概率
    • 绘制个体和投票回归预测
    • 绘制 VotingClassifier 的决策边界
    • 绘制虹膜数据集上树的集成的决策面
    • 梯度提升回归的预测区间
    • 单个估计器与 Bagging:偏差-方差分解
    • 二分类 AdaBoost
  • 基于真实世界数据集的示例
    • 压缩感知:使用 L1 先验 (Lasso) 进行断层扫描重建
    • 使用特征脸和 SVM 进行人脸识别示例
    • 使用核 PCA 进行图像去噪
    • 用于时间序列预测的滞后特征
    • 模型复杂性影响
    • 文本文件的核外分类
    • 真实数据集上的异常值检测
    • 预测延迟
    • 物种分布建模
    • 与时间相关的特征工程
    • 使用非负矩阵分解和潜在狄利克雷分配进行主题提取
    • 可视化股票市场结构
    • 维基百科主特征向量
  • 特征选择
    • F 检验和互信息的比较
    • 基于模型和顺序的特征选择
    • 管道 ANOVA SVM
    • 递归特征消除
    • 使用交叉验证进行递归特征消除
    • 单变量特征选择
  • 高斯混合模型
    • 变分贝叶斯高斯混合的浓度先验类型分析
    • 高斯混合的密度估计
    • GMM 初始化方法
    • GMM 协方差
    • 高斯混合模型椭球
    • 高斯混合模型选择
    • 高斯混合模型正弦曲线
  • 机器学习中的高斯过程
    • 高斯过程回归 (GPR) 估计数据噪声水平的能力
    • 核岭回归和高斯过程回归的比较
    • 使用高斯过程回归 (GPR) 预测莫纳罗亚数据集上的 CO2 水平
    • 高斯过程回归:基本入门示例
    • 虹膜数据集上的高斯过程分类 (GPC)
    • 离散数据结构上的高斯过程
    • XOR 数据集上的高斯过程分类 (GPC) 说明
    • 不同核的先验和后验高斯过程的说明
    • 高斯过程分类 (GPC) 的等概率线
    • 使用高斯过程分类 (GPC) 进行概率预测
  • 广义线性模型
    • 比较线性贝叶斯回归器
    • 比较各种在线求解器
    • 使用贝叶斯岭回归进行曲线拟合
    • 随机梯度下降的提前停止
    • 使用预先计算的 Gram 矩阵和加权样本拟合弹性网络
    • 在具有强异常值的数据集上比较 HuberRegressor 与 Ridge
    • 使用多任务 Lasso 进行联合特征选择
    • 逻辑回归中的 L1 惩罚和稀疏性
    • 用于稀疏信号的基于 L1 的模型
    • Lasso 和弹性网络
    • 通过信息标准进行 Lasso 模型选择
    • Lasso 模型选择:AIC-BIC / 交叉验证
    • 在密集和稀疏数据上的 Lasso
    • 使用 LARS 的 Lasso 路径
    • 线性回归示例
    • 逻辑回归三分类器
    • 逻辑函数
    • 使用多项式逻辑回归 + L1 进行 MNIST 分类
    • 在 20newsgroups 上的多类稀疏逻辑回归
    • 非负最小二乘法
    • 单类 SVM 与使用随机梯度下降的单类 SVM
    • 普通最小二乘法和岭回归方差
    • 正交匹配追踪
    • 绘制岭系数作为正则化函数
    • 在鸢尾花数据集上绘制多类 SGD
    • 绘制多项式和一对多逻辑回归
    • 泊松回归和非正态损失
    • 多项式和样条插值
    • 分位数回归
    • L1- 逻辑回归的正则化路径
    • 岭系数作为 L2 正则化的函数
    • 稳健线性估计器拟合
    • 使用 RANSAC 进行稳健线性模型估计
    • SGD:最大间隔超平面
    • SGD:惩罚
    • SGD:加权样本
    • SGD:凸损失函数
    • 稀疏性示例:仅拟合特征 1 和 2
    • 泰尔森回归
    • 保险索赔的 Tweedie 回归
  • 检查
    • 线性模型系数解释中的常见陷阱
    • 机器学习推断因果关系的失败
    • 部分依赖图和个体条件期望图
    • 排列重要性与随机森林特征重要性 (MDI)
    • 具有多重共线性或相关特征的排列重要性
  • 核近似
    • 使用多项式核近似进行可扩展学习
  • 流形学习
    • 流形学习方法的比较
    • 在断裂球体上的流形学习方法
    • 手写数字的流形学习:局部线性嵌入、等度量映射…
    • 多维缩放
    • 瑞士卷和瑞士孔降维
    • t-SNE:不同困惑度值对形状的影响
  • 杂项
    • 使用部分依赖进行高级绘图
    • 比较玩具数据集上异常值检测的异常检测算法
    • 核岭回归与 SVR 的比较
    • 显示管道
    • 显示估计器和复杂管道
    • 异常值检测估计器的评估
    • RBF 核的显式特征映射近似
    • 使用多输出估计器进行人脸补全
    • 介绍 set_output API
    • 保序回归
    • 元数据路由
    • 多标签分类
    • 使用可视化 API 绘制 ROC 曲线
    • 使用随机投影进行嵌入的 Johnson-Lindenstrauss 界
    • 使用显示对象进行可视化
  • 缺失值插补
    • 在构建估计器之前插补缺失值
    • 使用 IterativeImputer 的变体插补缺失值
  • 模型选择
    • 平衡模型复杂度和交叉验证得分
    • 类别似然比用于度量分类性能
    • 比较随机搜索和网格搜索以进行超参数估计
    • 网格搜索和连续减半之间的比较
    • 混淆矩阵
    • 使用交叉验证的网格搜索的自定义重新拟合策略
    • 在 cross_val_score 和 GridSearchCV 上进行多指标评估的演示
    • 检测错误权衡 (DET) 曲线
    • 多类别接收者操作特征 (ROC)
    • 嵌套与非嵌套交叉验证
    • 绘制交叉验证预测
    • 绘制学习曲线并检查模型的可扩展性
    • 绘制验证曲线
    • 事后调整决策函数的阈值
    • 针对成本敏感型学习对决策阈值进行后调整
    • 精确率-召回率
    • 使用交叉验证的接收者操作特征 (ROC)
    • 文本特征提取和评估的示例管道
    • 使用网格搜索对模型进行统计比较
    • 连续减半迭代
    • 使用排列检验分类分数的显著性
    • 训练误差与测试误差
    • 欠拟合与过拟合
    • 可视化 scikit-learn 中的交叉验证行为
  • 多类别方法
    • 多类别训练元估计器概述
  • 多输出方法
    • 使用分类器链进行多标签分类
  • 最近邻
    • TSNE 中的近似最近邻
    • 缓存最近邻
    • 比较使用和不使用邻域成分分析的最近邻
    • 使用邻域成分分析进行降维
    • 物种分布的核密度估计
    • 核密度估计
    • 最近质心分类
    • 最近邻分类
    • 最近邻回归
    • 邻域成分分析图解
    • 使用局部异常因子 (LOF) 进行新颖性检测
    • 使用局部异常因子 (LOF) 进行异常值检测
    • 简单一维核密度估计
  • 神经网络
    • 比较 MLPClassifier 的随机学习策略
    • 用于数字分类的受限玻尔兹曼机特征
    • 多层感知器中的不同正则化
    • MNIST 上 MLP 权重的可视化
  • 管道和组合估计器
    • 具有异构数据源的列转换器
    • 具有混合类型的列转换器
    • 连接多种特征提取方法
    • 转换回归模型中目标的影响
    • 流水线:链接 PCA 和逻辑回归
    • 使用 Pipeline 和 GridSearchCV 选择降维
  • 预处理
    • 比较不同缩放器对具有异常值的数据的影响
    • 将目标编码器与其他编码器进行比较
    • 演示 KBinsDiscretizer 的不同策略
    • 特征离散化
    • 特征缩放的重要性
    • 将数据映射到正态分布
    • 目标编码器的内部交叉拟合
    • 使用 KBinsDiscretizer 对连续特征进行离散化
  • 半监督分类
    • 半监督分类器与 SVM 在 Iris 数据集上的决策边界
    • 改变自训练阈值的影响
    • 标签传播数字主动学习
    • 标签传播数字:演示性能
    • 标签传播学习复杂结构
    • 文本数据集上的半监督分类
  • 支持向量机
    • 使用非线性核 (RBF) 的一类 SVM
    • 使用不同的 SVM 核绘制分类边界
    • 在鸢尾花数据集中绘制不同的 SVM 分类器
    • 在 LinearSVC 中绘制支持向量
    • RBF SVM 参数
    • SVM 间隔示例
    • SVM 平局决胜示例
    • 使用自定义核的 SVM
    • SVM-Anova:具有单变量特征选择的 SVM
    • SVM:最大间隔分离超平面
    • SVM:非平衡类的分离超平面
    • SVM:加权样本
    • 缩放 SVC 的正则化参数
    • 使用线性和非线性核的支持向量回归 (SVR)
  • 教程练习
    • 糖尿病数据集交叉验证练习
    • 数字分类练习
    • SVM 练习
  • 处理文本文档
    • 使用稀疏特征对文本文档进行分类
    • 使用 k 均值对文本文档进行聚类
    • FeatureHasher 和 DictVectorizer 比较
  • 示例
  • 基于真实世界数据集的示例
  • 与时间相关的...

与时间相关的特征工程#

本笔记本介绍了不同的策略,以利用与时间相关的特征来完成高度依赖于商业周期(天、周、月)和年度季节周期的自行车共享需求回归任务。

在此过程中,我们将介绍如何使用 sklearn.preprocessing.SplineTransformer 类及其 extrapolation="periodic" 选项执行周期性特征工程。

自行车共享需求数据集的数据探索#

我们首先从 OpenML 存储库加载数据。

from sklearn.datasets import fetch_openml

bike_sharing = fetch_openml("Bike_Sharing_Demand", version=2, as_frame=True)
df = bike_sharing.frame

为了快速了解数据的周期性模式,让我们看一下一周内每小时的平均需求。

请注意,一周从周日的周末开始。我们可以清楚地区分工作日早上和晚上的通勤模式,以及周末的休闲自行车使用模式,在一天中的中间时段需求峰值更为分散。

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(12, 4))
average_week_demand = df.groupby(["weekday", "hour"])["count"].mean()
average_week_demand.plot(ax=ax)
_ = ax.set(
    title="Average hourly bike demand during the week",
    xticks=[i * 24 for i in range(7)],
    xticklabels=["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
    xlabel="Time of the week",
    ylabel="Number of bike rentals",
)
Average hourly bike demand during the week

预测问题的目标是每小时自行车租赁的绝对数量。

df["count"].max()
977

让我们重新调整目标变量(每小时自行车租赁数量)的比例,以预测相对需求,以便更容易将平均绝对误差解释为最大需求的一部分。

注意

本笔记本中使用的模型的拟合方法都最小化均方误差以估计条件均值。但是,绝对误差将估计条件中位数。

然而,在讨论中报告测试集的性能指标时,我们选择关注平均绝对误差而不是(均方根)均方误差,因为它更易于解释。但是请注意,在本研究中,一个指标的最佳模型也是另一个指标的最佳模型。

y = df["count"] / df["count"].max()
fig, ax = plt.subplots(figsize=(12, 4))
y.hist(bins=30, ax=ax)
_ = ax.set(
    xlabel="Fraction of rented fleet demand",
    ylabel="Number of hours",
)
plot cyclical feature engineering

输入特征数据框是描述天气条件的按时间注释的小时日志。它包括数值变量和分类变量。请注意,时间信息已被扩展到几个补充列中。

X = df.drop("count", axis="columns")
X
季节 年份 月份 小时 假期 工作日 工作日 天气 温度 体感温度 湿度 风速
0 春天 0 1 0 假 6 假 晴朗 9.84 14.395 0.81 0.0000
1 春天 0 1 1 假 6 假 晴朗 9.02 13.635 0.80 0.0000
2 春天 0 1 2 假 6 假 晴朗 9.02 13.635 0.80 0.0000
3 春天 0 1 3 假 6 假 晴朗 9.84 14.395 0.75 0.0000
4 春天 0 1 4 假 6 假 晴朗 9.84 14.395 0.75 0.0000
... ... ... ... ... ... ... ... ... ... ... ... ...
17374 春天 1 12 19 假 1 真 有雾 10.66 12.880 0.60 11.0014
17375 春天 1 12 20 假 1 真 有雾 10.66 12.880 0.60 11.0014
17376 春天 1 12 21 假 1 真 晴朗 10.66 12.880 0.60 11.0014
17377 春天 1 12 22 假 1 真 晴朗 10.66 13.635 0.56 8.9981
17378 春天 1 12 23 假 1 真 晴朗 10.66 13.635 0.65 8.9981

17379 行 × 12 列



注意

如果时间信息仅作为日期或日期时间列存在,我们可以使用 pandas 将其扩展为一天中的小时、一周中的天、一月中的天、一年中的月:https://pandas.ac.cn/pandas-docs/stable/user_guide/timeseries.html#time-date-components

我们现在从 "weather" 开始,探究分类变量的分布。

X["weather"].value_counts()
weather
clear         11413
misty          4544
rain           1419
heavy_rain        3
Name: count, dtype: int64

由于只有 3 个 "heavy_rain" 事件,我们不能使用此类别来训练具有交叉验证的机器学习模型。相反,我们通过将它们折叠到 "rain" 类别中来简化表示。

X["weather"] = (
    X["weather"]
    .astype(object)
    .replace(to_replace="heavy_rain", value="rain")
    .astype("category")
)
X["weather"].value_counts()
weather
clear    11413
misty     4544
rain      1422
Name: count, dtype: int64

正如预期的那样,"season" 变量是平衡的。

X["season"].value_counts()
season
fall      4496
summer    4409
spring    4242
winter    4232
Name: count, dtype: int64

基于时间的交叉验证#

由于数据集是按时间排序的事件日志(每小时需求),因此我们将使用时间敏感的交叉验证拆分器来尽可能真实地评估我们的需求预测模型。我们在拆分的训练侧和测试侧之间使用 2 天的间隔。我们还限制了训练集的大小,以使 CV 折叠的性能更加稳定。

1000 个测试数据点应该足以量化模型的性能。这表示不到一个半月的连续测试数据。

from sklearn.model_selection import TimeSeriesSplit

ts_cv = TimeSeriesSplit(
    n_splits=5,
    gap=48,
    max_train_size=10000,
    test_size=1000,
)

让我们手动检查各种拆分,以检查 TimeSeriesSplit 是否按预期工作,从第一个拆分开始。

all_splits = list(ts_cv.split(X, y))
train_0, test_0 = all_splits[0]
X.iloc[test_0]
季节 年份 月份 小时 假期 工作日 工作日 天气 温度 体感温度 湿度 风速
12379 夏天 1 6 0 假 2 真 晴朗 22.14 25.760 0.68 27.9993
12380 夏天 1 6 1 假 2 真 有雾 21.32 25.000 0.77 22.0028
12381 夏天 1 6 2 假 2 真 雨 21.32 25.000 0.72 19.9995
12382 夏天 1 6 3 假 2 真 雨 20.50 24.240 0.82 12.9980
12383 夏天 1 6 4 假 2 真 雨 20.50 24.240 0.82 12.9980
... ... ... ... ... ... ... ... ... ... ... ... ...
13374 秋天 1 7 11 假 1 真 晴朗 34.44 40.150 0.53 15.0013
13375 秋天 1 7 12 假 1 真 晴朗 34.44 39.395 0.49 8.9981
13376 秋天 1 7 13 假 1 真 晴朗 34.44 39.395 0.49 19.0012
13377 秋天 1 7 14 假 1 真 晴朗 36.08 40.910 0.42 7.0015
13378 秋天 1 7 15 假 1 真 晴朗 35.26 40.150 0.47 16.9979

1000 行 × 12 列



X.iloc[train_0]
季节 年份 月份 小时 假期 工作日 工作日 天气 温度 体感温度 湿度 风速
2331 夏天 0 4 1 假 2 真 有雾 25.42 31.060 0.50 6.0032
2332 夏天 0 4 2 假 2 真 有雾 24.60 31.060 0.53 8.9981
2333 夏天 0 4 3 假 2 真 有雾 23.78 27.275 0.56 8.9981
2334 夏天 0 4 4 假 2 真 有雾 22.96 26.515 0.64 8.9981
2335 夏天 0 4 5 假 2 真 有雾 22.14 25.760 0.68 8.9981
... ... ... ... ... ... ... ... ... ... ... ... ...
12326 夏天 1 6 19 假 6 假 晴朗 26.24 31.060 0.36 11.0014
12327 夏天 1 6 20 假 6 假 晴朗 25.42 31.060 0.35 19.0012
12328 夏天 1 6 21 假 6 假 晴朗 24.60 31.060 0.40 7.0015
12329 夏天 1 6 22 假 6 假 晴朗 23.78 27.275 0.46 8.9981
12330 夏天 1 6 23 假 6 假 晴朗 22.96 26.515 0.52 7.0015

10000 行 × 12 列



我们现在检查最后一个拆分。

train_4, test_4 = all_splits[4]
X.iloc[test_4]
季节 年份 月份 小时 假期 工作日 工作日 天气 温度 体感温度 湿度 风速
16379 冬天 1 11 5 假 2 真 有雾 13.94 16.665 0.66 8.9981
16380 冬天 1 11 6 假 2 真 有雾 13.94 16.665 0.71 11.0014
16381 冬天 1 11 7 假 2 真 晴朗 13.12 16.665 0.76 6.0032
16382 冬天 1 11 8 假 2 真 晴朗 13.94 16.665 0.71 8.9981
16383 冬天 1 11 9 假 2 真 有雾 14.76 18.940 0.71 0.0000
... ... ... ... ... ... ... ... ... ... ... ... ...
17374 春天 1 12 19 假 1 真 有雾 10.66 12.880 0.60 11.0014
17375 春天 1 12 20 假 1 真 有雾 10.66 12.880 0.60 11.0014
17376 春天 1 12 21 假 1 真 晴朗 10.66 12.880 0.60 11.0014
17377 春天 1 12 22 假 1 真 晴朗 10.66 13.635 0.56 8.9981
17378 春天 1 12 23 假 1 真 晴朗 10.66 13.635 0.65 8.9981

1000 行 × 12 列



X.iloc[train_4]
季节 年份 月份 小时 假期 工作日 工作日 天气 温度 体感温度 湿度 风速
6331 冬天 0 9 9 假 1 真 有雾 26.24 28.790 0.89 12.9980
6332 冬天 0 9 10 假 1 真 有雾 26.24 28.790 0.89 12.9980
6333 冬天 0 9 11 假 1 真 晴朗 27.88 31.820 0.79 15.0013
6334 冬天 0 9 12 假 1 真 有雾 27.88 31.820 0.79 11.0014
6335 冬天 0 9 13 假 1 真 有雾 28.70 33.335 0.74 11.0014
... ... ... ... ... ... ... ... ... ... ... ... ...
16326 冬天 1 11 0 假 0 假 有雾 12.30 15.150 0.70 11.0014
16327 冬天 1 11 1 假 0 假 晴朗 12.30 14.395 0.70 12.9980
16328 冬天 1 11 2 假 0 假 晴朗 11.48 14.395 0.81 7.0015
16329 冬天 1 11 3 假 0 假 有雾 12.30 15.150 0.81 11.0014
16330 冬天 1 11 4 假 0 假 有雾 12.30 14.395 0.81 12.9980

10000 行 × 12 列



一切都很好。我们现在准备好进行一些预测建模了!

梯度提升#

只要样本数量足够大,使用决策树的梯度提升回归通常足够灵活,可以有效地处理混合了分类和数值特征的异构表格数据。

在这里,我们使用现代的 HistGradientBoostingRegressor,它本身就支持分类特征。因此,我们只需要设置 categorical_features="from_dtype",以便将具有分类 dtype 的特征视为分类特征。作为参考,我们根据 dtype 从数据框中提取分类特征。内部树使用专用的树拆分规则来处理这些特征。

数值变量不需要预处理,为了简单起见,我们只尝试此模型的默认超参数。

from sklearn.compose import ColumnTransformer
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.model_selection import cross_validate
from sklearn.pipeline import make_pipeline

gbrt = HistGradientBoostingRegressor(categorical_features="from_dtype", random_state=42)
categorical_columns = X.columns[X.dtypes == "category"]
print("Categorical features:", categorical_columns.tolist())
Categorical features: ['season', 'holiday', 'workingday', 'weather']

让我们使用 5 个基于时间的交叉验证拆分的平均相对需求的平均绝对误差来评估我们的梯度提升模型。

import numpy as np


def evaluate(model, X, y, cv, model_prop=None, model_step=None):
    cv_results = cross_validate(
        model,
        X,
        y,
        cv=cv,
        scoring=["neg_mean_absolute_error", "neg_root_mean_squared_error"],
        return_estimator=model_prop is not None,
    )
    if model_prop is not None:
        if model_step is not None:
            values = [
                getattr(m[model_step], model_prop) for m in cv_results["estimator"]
            ]
        else:
            values = [getattr(m, model_prop) for m in cv_results["estimator"]]
        print(f"Mean model.{model_prop} = {np.mean(values)}")
    mae = -cv_results["test_neg_mean_absolute_error"]
    rmse = -cv_results["test_neg_root_mean_squared_error"]
    print(
        f"Mean Absolute Error:     {mae.mean():.3f} +/- {mae.std():.3f}\n"
        f"Root Mean Squared Error: {rmse.mean():.3f} +/- {rmse.std():.3f}"
    )


evaluate(gbrt, X, y, cv=ts_cv, model_prop="n_iter_")
Mean model.n_iter_ = 100.0
Mean Absolute Error:     0.044 +/- 0.003
Root Mean Squared Error: 0.068 +/- 0.005

我们看到我们将 max_iter 设置得足够大,以便提前停止。

该模型的平均误差约为最大需求的 4% 到 5%。对于第一次试验来说,这已经很不错了,无需任何超参数调整!我们只需要明确分类变量。请注意,时间相关特征按原样传递,即无需处理它们。但这对于基于树的模型来说不是什么大问题,因为它们可以学习序数输入特征和目标之间的非单调关系。

正如我们将在下面看到的那样,线性回归模型并非如此。

朴素线性回归#

与线性模型一样,分类变量需要进行独热编码。为了保持一致性,我们使用 MinMaxScaler 将数值特征缩放到相同的 0-1 范围,尽管在这种情况下,它不会对结果产生太大影响,因为它们已经在可比较的范围内。

from sklearn.linear_model import RidgeCV
from sklearn.preprocessing import MinMaxScaler, OneHotEncoder

one_hot_encoder = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
alphas = np.logspace(-6, 6, 25)
naive_linear_pipeline = make_pipeline(
    ColumnTransformer(
        transformers=[
            ("categorical", one_hot_encoder, categorical_columns),
        ],
        remainder=MinMaxScaler(),
    ),
    RidgeCV(alphas=alphas),
)


evaluate(
    naive_linear_pipeline, X, y, cv=ts_cv, model_prop="alpha_", model_step="ridgecv"
)
Mean model.alpha_ = 2.7298221281347033
Mean Absolute Error:     0.142 +/- 0.014
Root Mean Squared Error: 0.184 +/- 0.020

肯定的是,选择的 alpha_ 在我们指定的范围内。

性能不佳:平均误差约为最大需求的 14%。这比梯度提升模型的平均误差高出三倍多。我们可以怀疑,周期性时间相关特征的朴素原始编码(仅进行最小-最大缩放)可能会阻止线性回归模型正确利用时间信息:线性回归不会自动对输入特征和目标之间的非单调关系进行建模。必须在输入中设计非线性项。

例如,"hour" 特征的原始数值编码会阻止线性模型识别早上 6 点到 8 点的小时数增加应该对自行车租赁数量产生强烈的积极影响,而晚上 6 点到 8 点的类似幅度增加应该对预测的自行车租赁数量产生强烈的负面影响。

时间步长作为类别#

由于时间特征使用整数以离散方式编码(“小时”特征中有 24 个唯一值),因此我们可以决定使用独热编码将这些特征视为分类变量,从而忽略小时值排序所暗示的任何假设。

对时间特征使用独热编码为线性模型提供了更大的灵活性,因为我们为每个离散时间级别引入了一个额外的特征。

one_hot_linear_pipeline = make_pipeline(
    ColumnTransformer(
        transformers=[
            ("categorical", one_hot_encoder, categorical_columns),
            ("one_hot_time", one_hot_encoder, ["hour", "weekday", "month"]),
        ],
        remainder=MinMaxScaler(),
    ),
    RidgeCV(alphas=alphas),
)

evaluate(one_hot_linear_pipeline, X, y, cv=ts_cv)
Mean Absolute Error:     0.099 +/- 0.011
Root Mean Squared Error: 0.131 +/- 0.011

此模型的平均错误率为 10%,这比使用时间特征的原始(序数)编码要好得多,证实了我们的直觉,即线性回归模型受益于增加的灵活性,而不会以单调的方式处理时间进程。

但是,这会引入大量的新特征。如果一天中的时间以自当天开始以来的分钟数而不是小时数表示,则独热编码将引入 1440 个特征而不是 24 个。这可能会导致一些严重的过拟合。为了避免这种情况,我们可以改用 sklearn.preprocessing.KBinsDiscretizer 来重新调整细粒度序数或数值变量的级别数,同时仍然受益于独热编码的非单调表达优势。

最后,我们还观察到独热编码完全忽略了小时级别的顺序,而这可能是某种程度上保留归纳偏差的一种有趣方法。在下文中,我们将尝试探索平滑、非单调的编码,在局部保留时间特征的相对顺序。

三角函数特征#

作为第一次尝试,我们可以尝试使用具有匹配周期的正弦和余弦变换对每个周期性特征进行编码。

每个序数时间特征都被转换为 2 个特征,这两个特征一起以非单调的方式编码等效信息,更重要的是,在周期范围的第一个值和最后一个值之间没有任何跳跃。

from sklearn.preprocessing import FunctionTransformer


def sin_transformer(period):
    return FunctionTransformer(lambda x: np.sin(x / period * 2 * np.pi))


def cos_transformer(period):
    return FunctionTransformer(lambda x: np.cos(x / period * 2 * np.pi))

让我们通过一些超出 hour=23 的外推合成小时数据来可视化此特征扩展的效果

import pandas as pd

hour_df = pd.DataFrame(
    np.arange(26).reshape(-1, 1),
    columns=["hour"],
)
hour_df["hour_sin"] = sin_transformer(24).fit_transform(hour_df)["hour"]
hour_df["hour_cos"] = cos_transformer(24).fit_transform(hour_df)["hour"]
hour_df.plot(x="hour")
_ = plt.title("Trigonometric encoding for the 'hour' feature")
Trigonometric encoding for the 'hour' feature

让我们使用一个二维散点图,其中小时数编码为颜色,以便更好地了解这种表示如何将一天中的 24 小时映射到二维空间,类似于某种 24 小时版本的模拟时钟。请注意,“第 25”个小时由于正弦/余弦表示的周期性而映射回第 1 个小时。

fig, ax = plt.subplots(figsize=(7, 5))
sp = ax.scatter(hour_df["hour_sin"], hour_df["hour_cos"], c=hour_df["hour"])
ax.set(
    xlabel="sin(hour)",
    ylabel="cos(hour)",
)
_ = fig.colorbar(sp)
plot cyclical feature engineering

我们现在可以使用此策略构建特征提取管道

cyclic_cossin_transformer = ColumnTransformer(
    transformers=[
        ("categorical", one_hot_encoder, categorical_columns),
        ("month_sin", sin_transformer(12), ["month"]),
        ("month_cos", cos_transformer(12), ["month"]),
        ("weekday_sin", sin_transformer(7), ["weekday"]),
        ("weekday_cos", cos_transformer(7), ["weekday"]),
        ("hour_sin", sin_transformer(24), ["hour"]),
        ("hour_cos", cos_transformer(24), ["hour"]),
    ],
    remainder=MinMaxScaler(),
)
cyclic_cossin_linear_pipeline = make_pipeline(
    cyclic_cossin_transformer,
    RidgeCV(alphas=alphas),
)
evaluate(cyclic_cossin_linear_pipeline, X, y, cv=ts_cv)
Mean Absolute Error:     0.125 +/- 0.014
Root Mean Squared Error: 0.166 +/- 0.020

我们使用这种简单特征工程的线性回归模型的性能比使用原始序数时间特征稍好,但比使用独热编码时间特征差。我们将在本笔记本的末尾进一步分析造成这种令人失望的结果的可能原因。

周期样条特征#

我们可以尝试使用样条变换对周期性时间相关特征进行另一种编码,该变换具有足够多的样条,因此与正弦/余弦变换相比,扩展特征的数量更多

from sklearn.preprocessing import SplineTransformer


def periodic_spline_transformer(period, n_splines=None, degree=3):
    if n_splines is None:
        n_splines = period
    n_knots = n_splines + 1  # periodic and include_bias is True
    return SplineTransformer(
        degree=degree,
        n_knots=n_knots,
        knots=np.linspace(0, period, n_knots).reshape(n_knots, 1),
        extrapolation="periodic",
        include_bias=True,
    )

同样,让我们通过一些超出 hour=23 的外推合成小时数据来可视化此特征扩展的效果

hour_df = pd.DataFrame(
    np.linspace(0, 26, 1000).reshape(-1, 1),
    columns=["hour"],
)
splines = periodic_spline_transformer(24, n_splines=12).fit_transform(hour_df)
splines_df = pd.DataFrame(
    splines,
    columns=[f"spline_{i}" for i in range(splines.shape[1])],
)
pd.concat([hour_df, splines_df], axis="columns").plot(x="hour", cmap=plt.cm.tab20b)
_ = plt.title("Periodic spline-based encoding for the 'hour' feature")
Periodic spline-based encoding for the 'hour' feature

由于使用了 extrapolation="periodic" 参数,我们观察到特征编码在午夜之后外推时保持平滑。

我们现在可以使用这种替代的周期性特征工程策略构建预测管道。

可以使用比这些序数值的离散级别更少的样条。这使得基于样条的编码比独热编码更有效,同时保留了大部分表达能力

cyclic_spline_transformer = ColumnTransformer(
    transformers=[
        ("categorical", one_hot_encoder, categorical_columns),
        ("cyclic_month", periodic_spline_transformer(12, n_splines=6), ["month"]),
        ("cyclic_weekday", periodic_spline_transformer(7, n_splines=3), ["weekday"]),
        ("cyclic_hour", periodic_spline_transformer(24, n_splines=12), ["hour"]),
    ],
    remainder=MinMaxScaler(),
)
cyclic_spline_linear_pipeline = make_pipeline(
    cyclic_spline_transformer,
    RidgeCV(alphas=alphas),
)
evaluate(cyclic_spline_linear_pipeline, X, y, cv=ts_cv)
Mean Absolute Error:     0.097 +/- 0.011
Root Mean Squared Error: 0.132 +/- 0.013

样条特征使线性模型能够成功利用周期性时间相关特征,并将误差从最大需求的约 14% 降低到约 10%,这与我们使用独热编码特征观察到的结果相似。

特征对线性模型预测影响的定性分析#

在这里,我们想可视化特征工程选择对时间相关预测形状的影响。

为此,我们考虑一个任意的基于时间的分割,以比较一系列保留数据点的预测。

naive_linear_pipeline.fit(X.iloc[train_0], y.iloc[train_0])
naive_linear_predictions = naive_linear_pipeline.predict(X.iloc[test_0])

one_hot_linear_pipeline.fit(X.iloc[train_0], y.iloc[train_0])
one_hot_linear_predictions = one_hot_linear_pipeline.predict(X.iloc[test_0])

cyclic_cossin_linear_pipeline.fit(X.iloc[train_0], y.iloc[train_0])
cyclic_cossin_linear_predictions = cyclic_cossin_linear_pipeline.predict(X.iloc[test_0])

cyclic_spline_linear_pipeline.fit(X.iloc[train_0], y.iloc[train_0])
cyclic_spline_linear_predictions = cyclic_spline_linear_pipeline.predict(X.iloc[test_0])

我们通过放大测试集的最后 96 小时(4 天)来可视化这些预测,以获得一些定性见解

last_hours = slice(-96, None)
fig, ax = plt.subplots(figsize=(12, 4))
fig.suptitle("Predictions by linear models")
ax.plot(
    y.iloc[test_0].values[last_hours],
    "x-",
    alpha=0.2,
    label="Actual demand",
    color="black",
)
ax.plot(naive_linear_predictions[last_hours], "x-", label="Ordinal time features")
ax.plot(
    cyclic_cossin_linear_predictions[last_hours],
    "x-",
    label="Trigonometric time features",
)
ax.plot(
    cyclic_spline_linear_predictions[last_hours],
    "x-",
    label="Spline-based time features",
)
ax.plot(
    one_hot_linear_predictions[last_hours],
    "x-",
    label="One-hot time features",
)
_ = ax.legend()
Predictions by linear models

我们可以从上图中得出以下结论

  • 原始序数时间相关特征 存在问题,因为它们没有捕捉到自然周期性:我们观察到在每天结束时,当小时特征从 23 变回 0 时,预测会出现很大的跳跃。我们预计在每周或每年结束时也会出现类似的现象。

  • 正如预期的那样,三角函数特征(正弦和余弦)在午夜没有这些不连续性,但线性回归模型无法利用这些特征来正确模拟日内变化。对高次谐波使用三角函数特征或对具有不同相位的自然周期使用额外的三角函数特征可能会解决这个问题。

  • 周期样条特征 一次性解决了这两个问题:通过使用 12 个样条,它们使线性模型能够专注于特定的小时数,从而赋予线性模型更大的表达能力。此外,extrapolation="periodic" 选项强制在 hour=23 和 hour=0 之间进行平滑表示。

  • 独热编码特征 的行为类似于周期样条特征,但更尖锐:例如,它们可以更好地模拟工作日早上的高峰,因为这个高峰持续时间不到一个小时。然而,我们将在下文中看到,对线性模型有利的因素对表达能力更强的模型不一定有利。

我们还可以比较每个特征工程管道提取的特征数量

naive_linear_pipeline[:-1].transform(X).shape
(17379, 19)
one_hot_linear_pipeline[:-1].transform(X).shape
(17379, 59)
cyclic_cossin_linear_pipeline[:-1].transform(X).shape
(17379, 22)
cyclic_spline_linear_pipeline[:-1].transform(X).shape
(17379, 37)

这证实了独热编码和样条编码策略为时间表示创建了比其他方法更多的特征,这反过来又为下游线性模型提供了更大的灵活性(自由度)以避免欠拟合。

最后,我们观察到没有任何线性模型可以逼近真实的自行车租赁需求,尤其是在工作日高峰时段可能非常尖锐但在周末则平坦得多的高峰时段:基于样条或独热编码的最准确的线性模型倾向于预测即使在周末也会出现与通勤相关的自行车租赁高峰,并且低估了工作日期间与通勤相关的事件。

这些系统性预测误差揭示了一种欠拟合的形式,可以用特征之间缺乏交互项来解释,例如“工作日”和从“小时”派生的特征。这个问题将在下一节中解决。

使用样条和多项式特征对成对交互进行建模#

线性模型不会自动捕获输入特征之间的交互效应。对于某些特征(例如由 SplineTransformer(或独热编码或分箱)构造的特征)来说,即使它们略微非线性,也无济于事。

但是,可以在粗粒度样条编码的小时数上使用 PolynomialFeatures 类来显式地对“工作日”/“小时数”交互进行建模,而不会引入太多新变量。

from sklearn.pipeline import FeatureUnion
from sklearn.preprocessing import PolynomialFeatures

hour_workday_interaction = make_pipeline(
    ColumnTransformer(
        [
            ("cyclic_hour", periodic_spline_transformer(24, n_splines=8), ["hour"]),
            ("workingday", FunctionTransformer(lambda x: x == "True"), ["workingday"]),
        ]
    ),
    PolynomialFeatures(degree=2, interaction_only=True, include_bias=False),
)

然后,将这些特征与先前在基于样条的流水线中计算的特征相结合。通过显式地对这种成对交互进行建模,我们可以观察到性能的显著提高。

cyclic_spline_interactions_pipeline = make_pipeline(
    FeatureUnion(
        [
            ("marginal", cyclic_spline_transformer),
            ("interactions", hour_workday_interaction),
        ]
    ),
    RidgeCV(alphas=alphas),
)
evaluate(cyclic_spline_interactions_pipeline, X, y, cv=ts_cv)
Mean Absolute Error:     0.078 +/- 0.009
Root Mean Squared Error: 0.104 +/- 0.009

使用核函数对非线性特征交互进行建模#

之前的分析强调了对 "workingday" 和 "hours" 之间的交互进行建模的需求。我们想要建模的这种非线性交互的另一个例子可能是降雨的影响,例如,降雨在工作日和周末及节假日的影响可能不同。

为了对所有这些交互进行建模,我们可以在基于样条的扩展之后,对所有边缘特征一次性使用多项式扩展。但是,这将创建大量的特征,这会导致过拟合和计算上的可处理性问题。

或者,我们可以使用 Nyström 方法来计算近似的多项式核扩展。让我们尝试后者。

from sklearn.kernel_approximation import Nystroem

cyclic_spline_poly_pipeline = make_pipeline(
    cyclic_spline_transformer,
    Nystroem(kernel="poly", degree=2, n_components=300, random_state=0),
    RidgeCV(alphas=alphas),
)
evaluate(cyclic_spline_poly_pipeline, X, y, cv=ts_cv)
Mean Absolute Error:     0.053 +/- 0.002
Root Mean Squared Error: 0.076 +/- 0.004

我们观察到,该模型几乎可以与梯度提升树的性能相媲美,平均误差约为最大需求的 5%。

请注意,虽然此流水线的最后一步是线性回归模型,但中间步骤(例如样条特征提取和 Nyström 核近似)是高度非线性的。因此,复合流水线比具有原始特征的简单线性回归模型更具表达力。

为了完整起见,我们还评估了独热编码和核近似的组合。

one_hot_poly_pipeline = make_pipeline(
    ColumnTransformer(
        transformers=[
            ("categorical", one_hot_encoder, categorical_columns),
            ("one_hot_time", one_hot_encoder, ["hour", "weekday", "month"]),
        ],
        remainder="passthrough",
    ),
    Nystroem(kernel="poly", degree=2, n_components=300, random_state=0),
    RidgeCV(alphas=alphas),
)
evaluate(one_hot_poly_pipeline, X, y, cv=ts_cv)
Mean Absolute Error:     0.082 +/- 0.006
Root Mean Squared Error: 0.111 +/- 0.011

虽然在使用线性模型时,独热编码特征与基于样条的特征相比具有竞争力,但在使用非线性核的低秩近似时,情况不再如此:这可以通过以下事实来解释:样条特征更平滑,并且允许核近似找到更具表达力的决策函数。

现在,让我们定性地看一下核模型和梯度提升树的预测结果,它们应该能够更好地对特征之间的非线性交互进行建模。

gbrt.fit(X.iloc[train_0], y.iloc[train_0])
gbrt_predictions = gbrt.predict(X.iloc[test_0])

one_hot_poly_pipeline.fit(X.iloc[train_0], y.iloc[train_0])
one_hot_poly_predictions = one_hot_poly_pipeline.predict(X.iloc[test_0])

cyclic_spline_poly_pipeline.fit(X.iloc[train_0], y.iloc[train_0])
cyclic_spline_poly_predictions = cyclic_spline_poly_pipeline.predict(X.iloc[test_0])

我们再次放大测试集的最后 4 天。

last_hours = slice(-96, None)
fig, ax = plt.subplots(figsize=(12, 4))
fig.suptitle("Predictions by non-linear regression models")
ax.plot(
    y.iloc[test_0].values[last_hours],
    "x-",
    alpha=0.2,
    label="Actual demand",
    color="black",
)
ax.plot(
    gbrt_predictions[last_hours],
    "x-",
    label="Gradient Boosted Trees",
)
ax.plot(
    one_hot_poly_predictions[last_hours],
    "x-",
    label="One-hot + polynomial kernel",
)
ax.plot(
    cyclic_spline_poly_predictions[last_hours],
    "x-",
    label="Splines + polynomial kernel",
)
_ = ax.legend()
Predictions by non-linear regression models

首先,请注意,树可以自然地对非线性特征交互进行建模,因为默认情况下,决策树允许增长到超过 2 层的深度。

在这里,我们可以观察到样条特征和非线性核的组合效果很好,几乎可以与梯度提升回归树的精度相媲美。

相反,独热编码的时间特征在低秩核模型中的表现不佳。特别是,与竞争模型相比,它们显著高估了低需求时段。

我们还观察到,没有任何模型能够成功预测工作日高峰时段的一些峰值租金。可能需要访问其他特征才能进一步提高预测的准确性。例如,能够访问任何时间点的车队地理分布或因需要维修而无法使用的自行车比例将非常有用。

最后,让我们使用真实值与预测需求散点图,更定量地看一下这三个模型的预测误差。

from sklearn.metrics import PredictionErrorDisplay

fig, axes = plt.subplots(nrows=2, ncols=3, figsize=(13, 7), sharex=True, sharey="row")
fig.suptitle("Non-linear regression models", y=1.0)
predictions = [
    one_hot_poly_predictions,
    cyclic_spline_poly_predictions,
    gbrt_predictions,
]
labels = [
    "One hot +\npolynomial kernel",
    "Splines +\npolynomial kernel",
    "Gradient Boosted\nTrees",
]
plot_kinds = ["actual_vs_predicted", "residual_vs_predicted"]
for axis_idx, kind in enumerate(plot_kinds):
    for ax, pred, label in zip(axes[axis_idx], predictions, labels):
        disp = PredictionErrorDisplay.from_predictions(
            y_true=y.iloc[test_0],
            y_pred=pred,
            kind=kind,
            scatter_kwargs={"alpha": 0.3},
            ax=ax,
        )
        ax.set_xticks(np.linspace(0, 1, num=5))
        if axis_idx == 0:
            ax.set_yticks(np.linspace(0, 1, num=5))
            ax.legend(
                ["Best model", label],
                loc="upper center",
                bbox_to_anchor=(0.5, 1.3),
                ncol=2,
            )
        ax.set_aspect("equal", adjustable="box")
plt.show()
Non-linear regression models

此可视化结果证实了我们在上一张图中得出的结论。

所有模型都低估了高需求事件(工作日高峰时段),但梯度提升的程度略低。梯度提升平均而言可以很好地预测低需求事件,而独热多项式回归流水线似乎系统地高估了该状态下的需求。总体而言,梯度提升树的预测比核模型更接近对角线。

结束语#

我们注意到,如果使用更多组件(更高秩的核近似),我们可以获得稍微更好的核模型结果,但代价是拟合和预测时间更长。对于较大的 n_components 值,独热编码特征的性能甚至可以与样条特征相匹配。

Nystroem + RidgeCV 回归器也可以替换为具有一层或两层隐藏层的 MLPRegressor,并且我们本可以获得非常相似的结果。

我们在本案例研究中使用的数据集是按小时采样的。但是,基于循环样条的特征可以使用更精细的时间分辨率(例如,每分钟而不是每小时进行一次测量)非常有效地对一天中的时间或一周中的时间进行建模,而无需引入更多特征。独热编码时间表示则不具备这种灵活性。

最后,在本笔记本中,我们使用了 RidgeCV,因为它从计算的角度来看非常有效。但是,它将目标变量建模为具有恒定方差的高斯随机变量。对于正回归问题,使用泊松或伽马分布可能更有意义。这可以通过使用 GridSearchCV(TweedieRegressor(power=2), param_grid({"alpha": alphas})) 代替 RidgeCV 来实现。

脚本总运行时间:(0 分 15.488 秒)

相关示例

时间序列预测的滞后特征

时间序列预测的滞后特征

梯度提升中的分类特征支持

梯度提升中的分类特征支持

多项式和样条插值

多项式和样条插值

部分依赖图和个体条件期望图

部分依赖图和个体条件期望图

由 Sphinx-Gallery 生成的图库

上一页

物种分布建模

下一页

使用非负矩阵分解和潜在狄利克雷分配进行主题提取

本页内容
  • 自行车共享需求数据集的数据探索
  • 基于时间的交叉验证
  • 梯度提升
  • 朴素线性回归
  • 时间步长作为类别
  • 三角函数特征
  • 周期性样条特征
  • 特征对线性模型预测影响的定性分析
  • 使用样条和多项式特征对成对交互进行建模
  • 使用核函数对非线性特征交互进行建模
  • 结束语
下载源代码
下载 Jupyter 笔记本
Launch JupyterLite
Launch binder

© 版权所有 2007 - 2024,scikit-learn 开发人员(BSD 许可证)。