Machine Learning Mastery Sklearn 教程（八）

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

使用 Pandas 的快速和肮脏的数据分析

原文： machinelearningmastery.com/quick-and-dirty-data-analysis-with-pandas/

在为建模选择和准备数据之前，您需要了解您必须从哪开始。

如果您正在使用 Python 栈进行机器学习，那么可以用来更好地理解数据的库是 Pandas。

在这篇文章中，您将发现一些快速而肮脏的 Pandas 秘籍，以提高您对数据结构，分布和关系的理解。

• 更新 March / 2018 ：添加了备用链接以下载数据集，因为原始图像已被删除。

数据分析

数据分析是关于询问和回答有关您数据的问题。

作为机器学习从业者，您可能不熟悉您所在的领域。拥有主题专家是理想的，但这并不总是可行的。

当您使用标准机器学习数据集，咨询或处理竞争数据集学习应用机器学习时，这些问题也适用。

您需要激发有关您可以追求的数据的问题。您需要更好地了解您拥有的数据。您可以通过汇总和可视化数据来实现。

熊猫

Pandas Python 库专为快速数据分析和操作而构建。如果您在其他平台（如 R）上完成此任务，那么它既简单又熟悉。

Pandas 的优势似乎在数据处理方面，但它带有非常方便易用的数据分析工具，为 statsmodels 中的标准统计方法和 matplotlib 中的图形方法提供包装器。

糖尿病的发病

我们需要一个小数据集，您可以使用它来探索使用 Pandas 的不同数据分析秘籍。

UIC 机器学习库提供了大量不同的标准机器学习数据集，您可以使用它们来学习和实践应用的机器学习。我最喜欢的是皮马印第安人糖尿病数据集。

该数据集使用其医疗记录中的详细信息描述了女性皮马印第安人中糖尿病发病的发生或缺乏。 （更新：从这里下载）。下载数据集并将其保存到当前工作目录中，名称为 pima-indians-diabetes.data 。

总结数据

我们将从了解我们拥有的数据开始，通过查看它的结构。

加载数据

首先将 CSV 数据从文件作为数据帧加载到内存中。我们知道所提供数据的名称，因此我们将在从文件加载数据时设置这些名称。

Python

import pandas as pd
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = pd.read_csv('pima-indians-diabetes.data', names=names)

了解有关 Pandas IO 功能和 read_csv 功能的更多信息。

描述数据

我们现在可以看一下数据的形状。

我们可以通过直接打印数据框来查看前 60 行数据。

Python

print(data)

我们可以看到所有数据都是数字的，最后的类值是我们想要做出预测的因变量。

在数据转储结束时，我们可以看到数据框本身的描述为 768 行和 9 列。所以现在我们已经了解了数据的形状。

接下来，我们可以通过查看摘要统计量来了解每个属性的分布情况。

Python

print(data.describe())

这将显示数据框中每个属性的详细分布信息表。具体来说：计数，平均值，标准差，最小值，最大值，第 25 个，第 50 个（中位数），第 75 个百分点。

我们可以查看这些统计量并开始注意有关我们问题的有趣事实。如平均怀孕次数为 3.8，最小年龄为 21 岁，有些人的体重指数为 0，这是不可能的，并且有迹象表明某些属性值应标记为缺失。

了解有关 DataFrame 上描述函数的更多信息。

可视化数据

图表更能说明属性的分布和关系。

然而，重要的是要花时间并首先审查统计量。每当您以不同的方式查看数据时，您就会打开自己，注意到不同的方面，并可能对问题有不同的见解。

Pandas 使用 matplotlib 创建图形并提供方便的功能。您可以详细了解 Pandas 中的数据可视化。

特征分布

要审查的第一个简单属性是每个属性的分布。

我们可以通过查看 box 和 whisker 图来开始并查看每个属性的传播。

Python

import matplotlib.pyplot as plt
pd.options.display.mpl_style = 'default'
data.boxplot()

此片段将绘制图形的样式（通过 matplotlib）更改为默认样式，该样式看起来更好。

属性框和胡须图

我们可以看到 test 属性有很多异常值。我们还可以看到 plas 属性似乎具有相对均匀的正态分布。我们还可以通过将值离散化为桶来查看每个属性的分布，并将每个桶中的频率作为直方图进行检查。

Python

data.hist()

这使您可以记录属性分布的有趣属性，例如 pres 和 skin 等属性的可能正态分布。

属性直方图矩阵

您可以在 DataFrame 上查看有关 boxplot 和 hist 函数的更多详细信息

特征级关系

探索的下一个重要关系是 class 属性的每个属性。

一种方法是可视化每个类的数据实例的属性分布以及注释和差异。您可以为每个属性生成直方图矩阵，为每个类值生成一个直方图矩阵，如下所示：

Python

data.groupby('class').hist()

数据按类属性（两组）分组，然后为每个组中的属性创建直方图矩阵。结果是两个图像。

0 类的属性直方图矩阵

1 类属性直方图矩阵

这有助于指出类之间的分布差异，如 plas 属性的分布。

您可以更好地对同一图表中每个类的属性值进行对比

data.groupby('class').plas.hist(alpha=0.4)

这将按类别对数据进行分组，仅绘制等离子体的直方图，其中红色的类值为 0，蓝色的类值为 1。你可以看到一个类似形状的正态分布，但是一个转变。此属性可能有助于区分类。

每个类的重叠属性直方图

您可以在 DataFrame 上阅读有关 groupby 函数的更多信息。

特征 - 特征关系

探索的最后一个重要关系是属性之间的关系。

我们可以通过查看每对属性的交互分布来查看属性之间的关系。

Python

from pandas.plotting import scatter_matrix
scatter_matrix(data, alpha=0.2, figsize=(6, 6), diagonal='kde')

这使用构建函数来创建所有属性与所有属性的散点图矩阵。每个属性相对于自身绘制的对角线显示了属性的核密度估计。

属性散点图矩阵

这是一个强大的情节，可以从中获得关于数据的大量灵感。例如，我们可以看到年龄和 preg 之间可能的相关性以及皮肤和质量之间的另一种可能的关系。

摘要

我们在这篇文章中介绍了很多内容。

我们开始研究快速和脏的单行程序，以便以 CSV 格式加载我们的数据并使用汇总统计量对其进行描述。

接下来，我们研究了绘制数据以揭示有趣结构的各种不同方法。我们查看了框中的数据分布以及晶须图和直方图，然后我们查看了与类属性相比的属性分布，最后查看了成对散点图中属性之间的关系。

使用 Python 的半径邻居分类器算法

原文：https://machinelearningmastery.com/radius-neighbors-classifier-algorithm-with-python/

半径邻居分类器是一种分类机器学习算法。

它是 k 近邻算法的扩展，使用新示例半径内的所有示例而不是 k 近邻进行预测。

因此，基于半径的选择邻居的方法更适合于稀疏数据，防止在特征空间中较远的例子对预测做出贡献。

在本教程中，您将发现半径邻居分类器分类机器学习算法。

完成本教程后，您将知道:

• 最近半径近邻分类器是 k 近邻分类算法的简单扩展。
• 如何使用带有 Sklearn 的半径邻居分类器模型进行拟合、评估和预测。
• 如何在给定数据集上调整半径邻居分类器算法的超参数。

我们开始吧。

带 Python 的半径邻居分类器算法
图片由 J .特里普克提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 半径邻居分类器
2. 基于 Sklearn 的半径邻居分类器
3. 调整半径邻居分类器超参数

半径邻居分类器

半径邻居是一种分类机器学习算法。

它基于 k 近邻算法，或称 kNN。kNN 包括获取整个训练数据集并存储它。然后，在预测时，为我们要预测的每个新示例定位训练数据集中 k 个最接近的示例。然后，来自 k 个邻居的模式(最常见的值)类别标签被分配给新示例。

有关 k 近邻算法的更多信息，请参见教程:

• 从头开始开发 Python 中的 k 近邻

半径邻居分类器的相似之处在于，训练包括存储整个训练数据集。预测期间使用训练数据集的方式不同。

半径邻居分类器不是定位 k 邻居，而是定位训练数据集中新示例给定半径内的所有示例。半径邻居随后被用于对新示例进行预测。

半径是在特征空间中定义的，并且通常假设输入变量是数字，并且被缩放到 0-1 的范围，例如归一化。

基于半径的邻居定位方法适用于那些希望邻居的贡献与特征空间中的示例密度成比例的数据集。

给定固定的半径，特征空间的密集区域将贡献更多的信息，而稀疏区域将贡献更少的信息。后一种情况是最理想的，并且它防止在特征空间中距离新示例很远的示例对预测做出贡献。

因此，半径邻居分类器可能更适合于存在特征空间稀疏区域的预测问题。

假设半径在要素空间的所有维度上都是固定的，随着输入要素数量的增加，半径的有效性会降低，这将导致要素空间中的示例越来越分散。这个属性被称为维度的诅咒。

基于 Sklearn 的半径邻居分类器

半径邻居分类器可通过半径邻居分类器类在 Sklearn Python 机器学习库中获得。

该类允许您通过“半径”参数指定进行预测时使用的半径大小，该参数默认为 1.0。

...
# create the model
model = RadiusNeighborsClassifier(radius=1.0)

另一个重要的超参数是“权重”参数，该参数控制邻居是以一致的方式对预测做出贡献，还是与该示例的距离(距离)成反比。默认情况下使用统一重量。

...
# create the model
model = RadiusNeighborsClassifier(weights='uniform')

我们可以用一个工作示例来演示半径邻居分类器。

首先，让我们定义一个综合分类数据集。

我们将使用 make_classification()函数创建一个包含 1000 个示例的数据集，每个示例有 20 个输入变量。

下面的示例创建并汇总了数据集。

# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# summarize the dataset
print(X.shape, y.shape)

运行该示例将创建数据集，并确认数据集的行数和列数。

(1000, 20) (1000,)

我们可以通过repeated stratifiedfold 类使用重复的分层 k 折交叉验证来拟合和评估半径邻居分类器模型。我们将在测试装具中使用 10 次折叠和三次重复。

我们将使用默认配置。

...
# create the model
model = RadiusNeighborsClassifier()

在准备和使用模型之前，对特征空间进行缩放是很重要的。

我们可以通过使用最小最大缩放器来归一化输入特征，并使用管道来首先应用缩放，然后使用模型。

...
# define model
model = RadiusNeighborsClassifier()
# create pipeline
pipeline = Pipeline(steps=[('norm', MinMaxScaler()),('model',model)])

下面列出了为合成二进制分类任务评估半径邻居分类器模型的完整示例。

# evaluate an radius neighbors classifier model on the dataset
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import RadiusNeighborsClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# define model
model = RadiusNeighborsClassifier()
# create pipeline
pipeline = Pipeline(steps=[('norm', MinMaxScaler()),('model',model)])
# define model evaluation method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate model
scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize result
print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

运行该示例在合成数据集上评估半径邻居分类器算法，并报告 10 倍交叉验证的三次重复的平均准确性。

鉴于学习算法的随机性，您的具体结果可能会有所不同。考虑运行这个例子几次。

在这种情况下，我们可以看到模型达到了大约 75.4%的平均精确率。

Mean Accuracy: 0.754 (0.042)

我们可能会决定使用半径邻居分类器作为最终模型，并对新数据进行预测。

这可以通过在所有可用数据上拟合模型管道并调用传递新数据行的 predict() 函数来实现。

我们可以用下面列出的完整示例来演示这一点。

# make a prediction with a radius neighbors classifier model on the dataset
from sklearn.datasets import make_classification
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import RadiusNeighborsClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# define model
model = RadiusNeighborsClassifier()
# create pipeline
pipeline = Pipeline(steps=[('norm', MinMaxScaler()),('model',model)])
# fit model
pipeline.fit(X, y)
# define new data
row = [2.47475454,0.40165523,1.68081787,2.88940715,0.91704519,-3.07950644,4.39961206,0.72464273,-4.86563631,-6.06338084,-1.22209949,-0.4699618,1.01222748,-0.6899355,-0.53000581,6.86966784,-3.27211075,-6.59044146,-2.21290585,-3.139579]
# make a prediction
yhat = pipeline.predict([row])
# summarize prediction
print('Predicted Class: %d' % yhat)

运行该示例符合模型，并对新的数据行进行类别标签预测。

Predicted Class: 0

接下来，我们可以看看配置模型超参数。

调整半径邻居分类器超参数

必须为您的特定数据集配置半径邻居分类器方法的超参数。

也许最重要的超参数是通过“半径”参数控制的半径。测试一系列值是个好主意，可能在 1.0 左右。

我们将在合成数据集上探索 0.8 到 1.5 之间的值，网格为 0.01。

...
# define grid
grid = dict()
grid['model__radius'] = arange(0.8, 1.5, 0.01)

请注意，我们正在管线内对半径邻居分类器的“半径超参数进行网格搜索，其中模型名为“模型”，因此半径参数通过带有双下划线( __ )分隔符的模型- >半径访问，例如“模型 __ 半径”。

下面的例子使用 GridSearchCV 类和我们定义的值网格来演示这一点。

# grid search radius for radius neighbors classifier
from numpy import arange
from sklearn.datasets import make_classification
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import RadiusNeighborsClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# define model
model = RadiusNeighborsClassifier()
# create pipeline
pipeline = Pipeline(steps=[('norm', MinMaxScaler()),('model',model)])
# define model evaluation method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# define grid
grid = dict()
grid['model__radius'] = arange(0.8, 1.5, 0.01)
# define search
search = GridSearchCV(pipeline, grid, scoring='accuracy', cv=cv, n_jobs=-1)
# perform the search
results = search.fit(X, y)
# summarize
print('Mean Accuracy: %.3f' % results.best_score_)
print('Config: %s' % results.best_params_)

运行该示例将使用重复的交叉验证来评估配置的每个组合。

鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。

在这种情况下，我们可以看到，使用 0.8 的半径获得了更好的结果，精确率约为 87.2%，而前面示例中的半径为 1.0，精确率约为 75.4%。

Mean Accuracy: 0.872
Config: {'model__radius': 0.8}

另一个关键超参数是半径中的示例通过“权重”参数对预测做出贡献的方式。这可以设置为“制服”(默认)、“距离”为逆距离，或自定义功能。

我们可以测试这两个内置权重，看看半径为 0.8 时哪个表现更好。

...
# define grid
grid = dict()
grid['model__weights'] = ['uniform', 'distance']

下面列出了完整的示例。

# grid search weights for radius neighbors classifier
from sklearn.datasets import make_classification
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import RadiusNeighborsClassifier
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# define model
model = RadiusNeighborsClassifier(radius=0.8)
# create pipeline
pipeline = Pipeline(steps=[('norm', MinMaxScaler()),('model',model)])
# define model evaluation method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# define grid
grid = dict()
grid['model__weights'] = ['uniform', 'distance']
# define search
search = GridSearchCV(pipeline, grid, scoring='accuracy', cv=cv, n_jobs=-1)
# perform the search
results = search.fit(X, y)
# summarize
print('Mean Accuracy: %.3f' % results.best_score_)
print('Config: %s' % results.best_params_)

运行该示例符合模型，并使用交叉验证发现给出最佳结果的超参数。

鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。

在这种情况下，我们可以看到平均分类准确率从上一个示例中的 87.2%左右的“T0”统一权重提升到本例中的 89.3%左右的“T2”距离权重。

Mean Accuracy: 0.893
Config: {'model__weights': 'distance'}

您可能希望探索的另一个度量是通过默认为“闵可夫斯基的“度量参数使用的距离度量。

将结果与‘欧几里德距离’和‘T2 街区’进行比较可能会很有趣。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• k-机器学习的最近邻
• 从头开始开发 Python 中的 k 近邻

书

• 应用预测建模，2013。
• R中应用的统计学习导论，2014。

蜜蜂

• 最近邻居，sci kit-学习用户指南。
• sklearn . neights . radiusNeightosclassifier API。
• sklearn . pipeline . pipeline API。
• 硬化。预处理。MinMaxScaler API 。

文章

• k 近邻算法，维基百科。
• 维度的诅咒，维基百科。

摘要

在本教程中，您发现了半径邻居分类器分类机器学习算法。

具体来说，您了解到:

• 最近半径近邻分类器是 k 近邻分类算法的简单扩展。
• 如何使用带有 Sklearn 的半径邻居分类器模型进行拟合、评估和预测。
• 如何在给定数据集上调整半径邻居分类器算法的超参数。

你有什么问题吗？
在下面的评论中提问，我会尽力回答。*

机器学习的回归度量

原文：https://machinelearningmastery.com/regression-metrics-for-machine-learning/

最后更新于 2021 年 2 月 16 日

回归是指涉及预测数值的预测建模问题。

它不同于涉及预测类别标签的分类。与分类不同，您不能使用分类精确率来评估回归模型所做的预测。

相反，您必须使用专门为评估回归问题预测而设计的误差度量。

在本教程中，您将发现如何为回归预测建模项目计算误差度量。

完成本教程后，您将知道:

• 回归预测建模是那些涉及预测数值的问题。
• 回归的度量包括计算误差分数来总结模型的预测技巧。
• 如何计算和报告均方误差、均方根误差和平均绝对误差。

我们开始吧。

机器学习的回归度量
图片由盖尔·瓦罗库提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 回归预测建模
2. 评估回归模型
3. 回归的度量
   1. 均方误差
   2. 均方根误差
   3. 绝对平均误差

回归预测建模

预测建模是使用历史数据开发模型的问题，以便在我们没有答案的情况下对新数据进行预测。

预测建模可以描述为从输入变量(X)到输出变量(y)近似映射函数(f)的数学问题。这就是所谓的函数近似问题。

建模算法的工作是在给定可用时间和资源的情况下，找到我们能找到的最佳映射函数。

有关应用机器学习中近似函数的更多信息，请参见文章:

• 机器学习算法如何工作

回归预测建模是将映射函数( f )从输入变量( X )近似为连续输出变量( y )的任务。

回归不同于分类，分类涉及预测类别或类别标签。

有关分类和回归之间区别的更多信息，请参见教程:

• 机器学习中分类和回归的区别

连续输出变量是一个实值，例如一个整数值或浮点值。这些通常是数量，例如数量和大小。

例如，一栋房子可能会以特定的美元价值出售，可能在 10 万至 20 万美元的范围内。

• 回归问题需要预测一个量。
• 回归可以有实值或离散输入变量。
• 具有多个输入变量的问题通常称为多元回归问题。
• 输入变量按时间排序的回归问题称为时间序列预测问题。

现在我们已经熟悉了回归预测建模，让我们看看如何评估回归模型。

评估回归模型

回归预测建模项目初学者的一个常见问题是:

如何计算回归模型的准确性？

准确性(例如分类准确性)是分类的一种度量，而不是回归。

我们无法计算回归模型的精确率。

回归模型的技巧或表现必须作为这些预测中的错误报告。

仔细想想，这是有道理的。如果你预测的是一个数字值，比如身高或美元金额，你不会想知道模型是否准确预测了这个值(这在实践中可能很难做到)；相反，我们想知道预测值与期望值有多接近。

误差正好解决了这个问题，并总结了预测值与期望值的平均接近程度。

有三种误差度量通常用于评估和报告回归模型的表现；它们是:

• 均方误差。
• 均方根误差(RMSE)。
• 平均绝对误差

回归还有许多其他的度量标准，尽管这些是最常用的。您可以在这里看到 Sklearn Python 机器学习库支持的回归度量的完整列表:

• Sklearn API:回归度量。

在下一节中，让我们依次仔细看看每一个。

回归的度量

在这一节中，我们将进一步了解回归模型的流行指标，以及如何为您的预测建模项目计算这些指标。

均方误差

均方误差，简称 MSE，是回归问题的一种流行误差度量。

对于使用回归问题的最小二乘框架拟合或优化的算法，这也是一个重要的损失函数。这里的最小二乘是指最小化预测值和期望值之间的均方误差。

均方误差计算为数据集中预测目标值和预期目标值之间的平方差的平均值。

• MSE = 1/n * I 与 n 之和(y _ I–yhat_i)²)

其中 y_i 是数据集中的第 I 个期望值， yhat_i 是第 I 个预测值。这两个值之间的差值被平方，这具有去除符号的效果，导致正误差值。

平方还具有放大或放大大误差的效果。也就是说，预测值和期望值之间的差异越大，产生的正误差平方就越大。当使用均方误差作为损失函数时，这具有“T0”惩罚“T1”模型更大误差的效果。它还具有“T2”惩罚“T3”模型的效果，即在用作指标时夸大平均误差分数。

我们可以创建一个图来了解预测误差的变化如何影响平方误差。

下面的例子给出了一个由所有 1.0 值和预测组成的小的人为数据集，范围从完美(1.0)到错误(0.0)，增量为 0.1。计算并绘制每个预测值和期望值之间的平方误差，以显示平方误差的二次增加。

...
# calculate error
err = (expected[i] - predicted[i])**2

下面列出了完整的示例。

# example of increase in mean squared error
from matplotlib import pyplot
from sklearn.metrics import mean_squared_error
# real value
expected = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
# predicted value
predicted = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0]
# calculate errors
errors = list()
for i in range(len(expected)):
	# calculate error
	err = (expected[i] - predicted[i])**2
	# store error
	errors.append(err)
	# report error
	print('>%.1f, %.1f = %.3f' % (expected[i], predicted[i], err))
# plot errors
pyplot.plot(errors)
pyplot.xticks(ticks=[i for i in range(len(errors))], labels=predicted)
pyplot.xlabel('Predicted Value')
pyplot.ylabel('Mean Squared Error')
pyplot.show()

运行该示例首先报告每种情况下的期望值、预测值和平方误差。

我们可以看到误差上升得很快，比线性(直线)上升得更快。

>1.0, 1.0 = 0.000
>1.0, 0.9 = 0.010
>1.0, 0.8 = 0.040
>1.0, 0.7 = 0.090
>1.0, 0.6 = 0.160
>1.0, 0.5 = 0.250
>1.0, 0.4 = 0.360
>1.0, 0.3 = 0.490
>1.0, 0.2 = 0.640
>1.0, 0.1 = 0.810
>1.0, 0.0 = 1.000

创建一个线图，显示随着预期值和预测值之间的差异增加，平方误差值的曲线或超线性增加。

曲线不是直线，因为我们可能天真地认为它是误差度量。

预测误差平方增加的线图

对单个误差项进行平均，这样我们就可以报告模型在进行预测时通常会产生多少误差，而不是针对给定的示例。

均方误差的单位是平方单位。

例如，如果你的目标值代表“美元，那么均线将是“平方美元这可能会让利益相关者感到困惑；因此，在报告结果时，通常使用均方根误差来代替(将在下一节中讨论)。

可以使用 Sklearn 库中的均方误差()函数计算预期值和预测值之间的均方误差。

该函数采用一维数组或期望值和预测值的列表，并返回均方误差值。

...
# calculate errors
errors = mean_squared_error(expected, predicted)

下面的例子给出了一个计算设计的期望值和预测值之间的均方误差的例子。

# example of calculate the mean squared error
from sklearn.metrics import mean_squared_error
# real value
expected = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
# predicted value
predicted = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0]
# calculate errors
errors = mean_squared_error(expected, predicted)
# report error
print(errors)

运行该示例计算并打印均方误差。

0.35000000000000003

完美的均方误差值为 0.0，这意味着所有预测都与期望值完全匹配。

这几乎从来都不是这样，如果真的发生了，这表明您的预测建模问题微不足道。

一个好的均方误差是相对于你的特定数据集的。

最好首先使用简单的预测模型为数据集建立基线均方误差，例如从训练数据集中预测平均目标值。一个比简单模型的均方误差更好的模型是有技巧的。

均方根误差

均方根误差，或 RMSE，是均方误差的延伸。

重要的是，计算误差的平方根，这意味着 RMSE 的单位与被预测的目标值的原始单位相同。

例如，如果你的目标变量有单位“美元”，那么 RMSE 误差分数也会有单位“美元”，而不是像 MSE 一样有单位“平方美元”。

因此，通常使用均方误差损失来训练回归预测模型，并使用 RMSE 来评估和报告其表现。

RMSE 可以计算如下:

• RMSE = sqrt(1/n * I 与 n 之和(y _ I–yhat_i)²)

其中 y_i 为数据集中第 I 个期望值， yhat_i 为第 I 个预测值， sqrt() 为平方根函数。

我们可以用最小均方误差来重申 RMSE:

• RMSE = sqrt(姆塞)

请注意，RMSE 不能计算为均方误差值的平方根的平均值。这是初学者常犯的错误，是詹森不等式的例子。

你可能还记得平方根是平方运算的倒数。MSE 使用平方运算来移除每个误差值的符号，并惩罚较大的误差。平方根反转这个操作，虽然它确保结果保持正。

可以使用 Sklearn 库中的均方误差()函数计算预期值和预测值之间的均方根误差。

默认情况下，该函数计算均方误差，但我们可以将其配置为通过将“平方”参数设置为假来计算均方误差的平方根。

该函数采用一维数组或期望值和预测值的列表，并返回均方误差值。

...
# calculate errors
errors = mean_squared_error(expected, predicted, squared=False)

下面的例子给出了一个计算设计的期望值和预测值之间的均方根误差的例子。

# example of calculate the root mean squared error
from sklearn.metrics import mean_squared_error
# real value
expected = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
# predicted value
predicted = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0]
# calculate errors
errors = mean_squared_error(expected, predicted, squared=False)
# report error
print(errors)

运行该示例计算并打印均方根误差。

0.5916079783099616

完美的 RMSE 值为 0.0，这意味着所有预测都与期望值完全匹配。

这几乎从来都不是这样，如果真的发生了，这表明您的预测建模问题微不足道。

一个好的 RMSE 是相对于你的特定数据集的。

最好首先使用简单的预测模型为数据集建立基线 RMSE，例如从训练数据集预测平均目标值。一个比 RMSE 的幼稚模型更能获得 RMSE 奖的模型是有技巧的。

绝对平均误差

平均绝对误差，或 MAE，是一个流行的度量标准，因为像 RMSE 一样，误差分数的单位与被预测的目标值的单位相匹配。

与 RMSE 不同，房利美的变化是线性的，因此是直观的。

也就是说，MSE 和 RMSE 对较大误差的惩罚比对较小误差的惩罚更大，夸大或放大了平均误差分数。这是由于误差值的平方。MAE 不会对不同类型的错误给予或多或少的权重，相反，分数会随着错误的增加而线性增加。

顾名思义，MAE 分数的计算是绝对误差值的平均值。绝对值或 abs() 是一个数学函数，它只是使一个数为正。因此，预期值和预测值之间的差异可能是正的或负的，并且在计算 MAE 时被迫为正。

MAE 可以计算如下:

• 资产净值对资产净值之和(y _ I–yhat _ I)

其中 y_i 是数据集中的第 I 个期望值， yhat_i 是第 I 个预测值， abs() 是绝对函数。

我们可以创建一个图来了解预测误差的变化如何影响 MAE。

下面的例子给出了一个由所有 1.0 值和预测组成的小的人为数据集，范围从完美(1.0)到错误(0.0)，增量为 0.1。计算并绘制每个预测值和期望值之间的绝对误差，以显示误差的线性增加。

...
# calculate error
err = abs((expected[i] - predicted[i]))

下面列出了完整的示例。

# plot of the increase of mean absolute error with prediction error
from matplotlib import pyplot
from sklearn.metrics import mean_squared_error
# real value
expected = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
# predicted value
predicted = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0]
# calculate errors
errors = list()
for i in range(len(expected)):
	# calculate error
	err = abs((expected[i] - predicted[i]))
	# store error
	errors.append(err)
	# report error
	print('>%.1f, %.1f = %.3f' % (expected[i], predicted[i], err))
# plot errors
pyplot.plot(errors)
pyplot.xticks(ticks=[i for i in range(len(errors))], labels=predicted)
pyplot.xlabel('Predicted Value')
pyplot.ylabel('Mean Absolute Error')
pyplot.show()

运行该示例首先报告每个案例的期望值、预测值和绝对误差。

我们可以看到误差线性上升，直观易懂。

>1.0, 1.0 = 0.000
>1.0, 0.9 = 0.100
>1.0, 0.8 = 0.200
>1.0, 0.7 = 0.300
>1.0, 0.6 = 0.400
>1.0, 0.5 = 0.500
>1.0, 0.4 = 0.600
>1.0, 0.3 = 0.700
>1.0, 0.2 = 0.800
>1.0, 0.1 = 0.900
>1.0, 0.0 = 1.000

创建一个线图，显示当预期值和预测值之间的差值增加时，绝对误差值的直线或线性增加。

预测绝对误差增加的线图

可以使用 Sklearn 库中的 mean_absolute_error()函数来计算预期值和预测值之间的平均绝对误差。

该函数采用一维数组或期望值和预测值的列表，并返回平均绝对误差值。

...
# calculate errors
errors = mean_absolute_error(expected, predicted)

下面的例子给出了一个计算设计的期望值和预测值之间的平均绝对误差的例子。

# example of calculate the mean absolute error
from sklearn.metrics import mean_absolute_error
# real value
expected = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
# predicted value
predicted = [1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0]
# calculate errors
errors = mean_absolute_error(expected, predicted)
# report error
print(errors)

运行该示例计算并打印平均绝对误差。

0.5

完美的平均绝对误差值为 0.0，这意味着所有预测都与期望值完全匹配。

这几乎从来都不是这样，如果真的发生了，这表明您的预测建模问题微不足道。

一个好的 MAE 是与你的特定数据集相关的。

最好首先使用简单的预测模型为数据集建立基线 MAE，例如从训练数据集预测平均目标值。一个比朴素模型的 MAE 更好地实现 MAE 的模型是有技巧的。

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• 机器学习算法如何工作
• 机器学习中分类和回归的区别

蜜蜂

• Sklearn API:回归度量。
• sci kit-学习用户指南第 3.3.4 节。回归指标。
• sklearn . metrics . mean _ squared _ error API。
• 均值 _ 绝对 _ 误差 API 。

文章

• 均方误差，维基百科。
• 均方根偏差，维基百科。
• 平均绝对误差，维基百科。
• 决定系数，维基百科。

摘要

在本教程中，您发现了如何计算回归预测建模项目的误差。

具体来说，您了解到:

• 回归预测建模是那些涉及预测数值的问题。
• 回归的度量包括计算误差分数来总结模型的预测技巧。
• 如何计算和报告均方误差、均方根误差和平均绝对误差。

你有什么问题吗？
在下面的评论中提问，我会尽力回答。

Python 中用于模型评估的重复 k 折交叉验证

原文：https://machinelearningmastery.com/repeated-k-fold-cross-validation-with-python/

最后更新于 2020 年 8 月 26 日

k-fold 交叉验证过程是一种评估数据集上机器学习算法或配置表现的标准方法。

k 倍交叉验证程序的一次运行可能会导致模型表现的噪声估计。不同的数据分割可能会导致截然不同的结果。

重复的 k 折交叉验证提供了一种提高机器学习模型估计表现的方法。这包括多次重复交叉验证程序，并报告所有运行的所有折叠的平均结果。该平均结果有望成为数据集上模型的真实未知潜在平均表现的更准确估计，使用标准误差进行计算。

在本教程中，您将发现模型评估的重复 k 倍交叉验证。

完成本教程后，您将知道:

• k 倍交叉验证单次运行报告的平均表现可能会有噪声。
• 重复的 k 折交叉验证提供了一种减少平均模型表现估计误差的方法。
• 如何在 Python 中使用重复的 k 折交叉验证来评估机器学习模型。

用我的新书Python 机器学习精通启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

Python 中模型评估的重复 k-Fold 交叉验证
图片由 lina smith 提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. k 折叠交叉验证
2. 重复 k 折叠交叉验证
3. Python 中重复的 k 折叠交叉验证

k 折叠交叉验证

使用 k 折交叉验证在数据集上评估机器学习模型是很常见的。

k 折叠交叉验证过程将有限的数据集分成 k 个不重叠的折叠。k 个折叠中的每一个都有机会用作保留测试集，而所有其他折叠一起用作训练数据集。在 k 个保持测试集上，对总共 k 个模型进行拟合和评估，并报告平均表现。

有关 k-fold 交叉验证过程的更多信息，请参见教程:

• k 倍交叉验证的温和介绍

使用 Sklearn 机器学习库可以轻松实现 k-fold 交叉验证过程。

首先，让我们定义一个可以作为本教程基础的综合分类数据集。

make_classification()函数可用于创建合成二进制分类数据集。我们将配置它生成 1000 个样本，每个样本有 20 个输入特征，其中 15 个有助于目标变量。

下面的示例创建并汇总了数据集。

# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# summarize the dataset
print(X.shape, y.shape)

运行该示例会创建数据集，并确认它包含 1，000 个样本和 10 个输入变量。

伪随机数发生器的固定种子确保我们每次生成数据集时获得相同的样本。

(1000, 20) (1000,)

接下来，我们可以使用 k-fold 交叉验证来评估这个数据集上的模型。

我们将评估一个logisticreduce模型，并使用 KFold 类执行交叉验证，配置为洗牌数据集并设置 k=10，这是一个流行的默认值。

cross_val_score()函数将用于执行评估，获取数据集和交叉验证配置，并返回为每个折叠计算的分数列表。

下面列出了完整的示例。

# evaluate a logistic regression model using k-fold cross-validation
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
# create dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# prepare the cross-validation procedure
cv = KFold(n_splits=10, random_state=1, shuffle=True)
# create model
model = LogisticRegression()
# evaluate model
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

运行该示例会创建数据集，然后使用 10 倍交叉验证对其进行逻辑回归模型评估。然后报告数据集的平均分类精确率。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到该模型实现了大约 86.8%的估计分类准确率。

Accuracy: 0.868 (0.032)

现在我们已经熟悉了 k-fold 交叉验证，让我们看看重复该过程的扩展。

重复 k 折叠交叉验证

通过 k 倍交叉验证对模型表现的估计可能会有噪声。

这意味着每次运行该过程时，可以实现将数据集分成 k 个不同的折叠，而表现分数的分布也可能不同，从而导致模型表现的不同平均估计。

从一次 k 倍交叉验证到另一次 k 倍交叉验证的估计表现差异取决于所使用的模型和数据集本身。

模型表现的噪声估计可能令人沮丧，因为可能不清楚应该使用哪个结果来比较和选择最终模型来解决问题。

降低估计模型表现中的噪声的一个解决方案是增加 k 值。这将减少模型估计表现的偏差，尽管会增加方差:例如，将结果更多地与评估中使用的特定数据集联系起来。

另一种方法是多次重复 k 折叠交叉验证过程，并报告所有折叠和所有重复的平均表现。这种方法通常被称为重复的 k 倍交叉验证。

…重复的 k-fold 交叉验证将程序重复【…】次。例如，如果 10 倍交叉验证重复 5 次，将使用 50 个不同的搁置集来评估模型功效。

—第 70 页，应用预测建模，2013 年。

重要的是，k-fold 交叉验证过程的每个重复必须在分割成不同折叠的同一数据集上执行。

重复 k 折交叉验证的好处是以拟合和评估更多模型为代价来改进平均模型表现的估计。

常见的重复数包括 3、5 和 10。例如，如果使用 10 倍交叉验证的 3 次重复来估计模型表现，这意味着需要拟合和评估(3 * 10)或 30 个不同的模型。

• 合适的:对于小数据集和简单模型(如线性)。

因此，这种方法适用于计算成本不高的小型到中等规模的数据集和/或模型。这表明该方法可能适用于线性模型，而不适用于像深度学习神经网络这样的慢拟合模型。

像 k-fold 交叉验证本身一样，重复的 k-fold 交叉验证很容易并行化，其中每个折叠或每个重复的交叉验证过程可以在不同的内核或不同的机器上执行。

Python 中重复的 k 折叠交叉验证

Sklearn Python 机器学习库通过 RepeatedKFold 类提供了重复 k 折交叉验证的实现。

主要参数是折叠数( n_splits )，即 k 折叠交叉验证中的“ k ”，以及重复数( n_repeats )。

k 的良好默认值是 k=10。

重复次数的良好默认值取决于数据集上模型表现估计的噪声程度。值为 3、5 或 10 的重复可能是一个好的开始。可能不需要超过 10 次的重复。

...
# prepare the cross-validation procedure
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)

下面的例子演示了我们的测试数据集的重复 k 倍交叉验证。

# evaluate a logistic regression model using repeated k-fold cross-validation
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import RepeatedKFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
# create dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# prepare the cross-validation procedure
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# create model
model = LogisticRegression()
# evaluate model
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# report performance
print('Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))

运行该示例会创建数据集，然后使用具有三次重复的 10 倍交叉验证对数据集的逻辑回归模型进行评估。然后报告数据集的平均分类精确率。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到模型实现了大约 86.7%的估计分类准确率，这低于之前报告的 86.8%的单次运行结果。这可能表明单次运行结果可能是乐观的，三次重复的结果可能是对真实均值模型表现的更好估计。

Accuracy: 0.867 (0.031)

重复 k 倍交叉验证的预期是，重复平均值将是比单一 k 倍交叉验证程序的结果更可靠的模型表现估计。

这可能意味着更少的统计噪声。

衡量这一点的一种方法是比较不同重复次数下平均成绩的分布。

我们可以想象，数据集上的模型有一个真正未知的潜在平均表现，重复的 k 倍交叉验证运行估计了这个平均值。我们可以使用称为标准误差的统计工具，根据真正未知的潜在平均表现来估计平均表现的误差。

标准误差可以为给定样本量提供误差量或误差传播的指示，该误差量或误差传播可以从样本均值到潜在的未知总体均值。

标准误差可以计算如下:

• 标准误差=样本标准偏差/ sqrt(重复次数)

我们可以使用 sem() scipy 函数计算样品的标准误差。

理想情况下，我们希望选择与其他重复次数相比，既能最小化标准误差又能稳定平均估计表现的重复次数。

下面的例子通过用 10 倍交叉验证报告模型表现来证明这一点，该过程重复 1 到 15 次。

考虑到大数定律，我们预计程序的更多重复将导致平均模型表现的更精确估计。虽然，这些试验不是独立的，所以潜在的统计原理变得具有挑战性。

# compare the number of repeats for repeated k-fold cross-validation
from scipy.stats import sem
from numpy import mean
from numpy import std
from sklearn.datasets import make_classification
from sklearn.model_selection import RepeatedKFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from matplotlib import pyplot

# evaluate a model with a given number of repeats
def evaluate_model(X, y, repeats):
	# prepare the cross-validation procedure
	cv = RepeatedKFold(n_splits=10, n_repeats=repeats, random_state=1)
	# create model
	model = LogisticRegression()
	# evaluate model
	scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
	return scores

# create dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=1)
# configurations to test
repeats = range(1,16)
results = list()
for r in repeats:
	# evaluate using a given number of repeats
	scores = evaluate_model(X, y, r)
	# summarize
	print('>%d mean=%.4f se=%.3f' % (r, mean(scores), sem(scores)))
	# store
	results.append(scores)
# plot the results
pyplot.boxplot(results, labels=[str(r) for r in repeats], showmeans=True)
pyplot.show()

运行该示例使用不同重复次数的 10 倍交叉验证来报告平均和标准误差分类精确率。

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

在这种情况下，我们可以看到，与其他结果相比，一个重复的默认值似乎是乐观的，准确率约为 86.80%，而不是 86.73%，并且随着重复次数的不同而降低。

我们可以看到平均值似乎在 86.5%左右。我们可以将此作为模型表现的稳定估计值，然后依次选择 5 或 6 个看起来最接近此值的重复。

查看标准误差，我们可以看到它随着重复次数的增加而减少，并在大约 9 或 10 次重复时稳定在大约 0.003 的值，尽管 5 次重复达到 0.005 的标准误差，是单次重复的一半。

>1 mean=0.8680 se=0.011
>2 mean=0.8675 se=0.008
>3 mean=0.8673 se=0.006
>4 mean=0.8670 se=0.006
>5 mean=0.8658 se=0.005
>6 mean=0.8655 se=0.004
>7 mean=0.8651 se=0.004
>8 mean=0.8651 se=0.004
>9 mean=0.8656 se=0.003
>10 mean=0.8658 se=0.003
>11 mean=0.8655 se=0.003
>12 mean=0.8654 se=0.003
>13 mean=0.8652 se=0.003
>14 mean=0.8651 se=0.003
>15 mean=0.8653 se=0.003

创建一个方框和触须图来总结每个重复次数的分数分布。

橙色线表示分布的中间值，绿色三角形表示算术平均值。如果这些符号(值)一致，则表明存在合理的对称分布，平均值可以很好地捕捉中心趋势。

这可能会为您的测试工具选择合适的重复次数提供额外的启发。

考虑到这一点，对这个选择的测试工具和算法使用五次重复似乎是一个不错的选择。

k 倍交叉验证的分类准确度与重复次数的方框图和须图

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• k 倍交叉验证的温和介绍
• 如何固定不平衡分类的 k 折交叉验证

蜜蜂

• sklearn.model_selection。KFold API 。
• sklearn.model_selection。重复应用编程接口。
• sklearn.model_selection。离开应用编程接口。
• sklearn . model _ selection . cross _ val _ score API。

文章

• 交叉验证(统计)，维基百科。
• 标准错误，维基百科。

摘要

在本教程中，您发现了模型评估的重复 k 倍交叉验证。

具体来说，您了解到:

• k 倍交叉验证单次运行报告的平均表现可能会有噪声。
• 重复的 k 折交叉验证提供了一种减少平均模型表现估计误差的方法。
• 如何在 Python 中使用重复的 k 折交叉验证来评估机器学习模型。

你有什么问题吗？
在下面的评论中提问，我会尽力回答。

使用 Python 和 Scikit-Learn 重缩放机器学习数据

原文： machinelearningmastery.com/rescaling-data-for-machine-learning-in-python-with-scikit-learn/

在构建模型之前，必须准备好数据。 数据准备过程可以包括三个步骤：数据选择，数据预处理和数据转换。

在这篇文章中，您将发现两种简单的数据转换方法，您可以使用 scikit-learn 将这些方法应用于 Python 中的数据。

更新：有关更新的示例集，请参阅此帖子。

数据重缩放
照片由 Quinn Dombrowski 拍摄，保留一些权利。

数据重新缩放

您的预处理数据可能包含各种数量的比例混合的属性，如美元，千克和销售量。

如果数据属性具有相同的比例，许多机器学习方法期望或更有效。两种流行的数据缩放方法是标准化和标准化。

数据规范化

规范化是指将实值数字属性重新缩放到 0 和 1 范围内。

缩放依赖于值的大小的模型的输入属性是有用的，例如 k-最近邻居中使用的距离度量以及回归中的系数的准备。

以下示例演示了 Iris 花数据集的数据标准化。

Normalize the data attributes for the Iris dataset Python

# Normalize the data attributes for the Iris dataset.
from sklearn.datasets import load_iris
from sklearn import preprocessing
# load the iris dataset
iris = load_iris()
print(iris.data.shape)
# separate the data from the target attributes
X = iris.data
y = iris.target
# normalize the data attributes
normalized_X = preprocessing.normalize(X)

有关更多信息，请参阅 API 文档中的规范化函数。

数据标准化

标准化是指将每个属性的分布转换为平均值为零，标准差为 1（单位方差）。

标准化依赖于诸如高斯过程之类的属性分布的模型的属性是有用的。

以下示例演示了 Iris 花数据集的数据标准化。

Standardize the data attributes for the Iris dataset Python

# Standardize the data attributes for the Iris dataset.
from sklearn.datasets import load_iris
from sklearn import preprocessing
# load the Iris dataset
iris = load_iris()
print(iris.data.shape)
# separate the data and target attributes
X = iris.data
y = iris.target
# standardize the data attributes
standardized_X = preprocessing.scale(X)

有关更多信息，请参阅 API 文档中的比例功能。

提示：使用哪种方法

在应用数据之前，很难知道重缩放数据是否会提高算法的表现。如果经常可以，但并非总是如此。

一个很好的建议是创建数据集的重新缩放副本，并使用您的测试工具和一些您想要检查的算法将它们相互竞争。这可以快速突出显示使用给定模型重新缩放数据的好处（或缺少），以及哪种重新缩放方法可能值得进一步调查。

摘要

在应用机器学习算法之前，数据重新缩放是数据准备的重要部分。

在这篇文章中，您发现数据重新缩放适用于应用机器学习的过程和两种方法：规范化和标准化，您可以使用 scikit-learn 库在 Python 中重新缩放数据。

Update: See this post for a more up to date set of examples.

标准机器学习数据集的最佳结果

原文：https://machinelearningmastery.com/results-for-standard-classification-and-regression-machine-learning-datasets/

最后更新于 2020 年 8 月 28 日

初学机器学习的人在小的真实数据集上练习是很重要的。

所谓的标准机器学习数据集包含实际的观察结果，适合记忆，并且被很好地研究和理解。因此，初学者可以使用它们来快速测试、探索和实践数据准备和建模技术。

从业者可以确认他们是否具备在标准机器学习数据集上获得良好结果所需的数据技能。好的结果是高于给定数据集技术上可能的第 80 或第 90 百分位结果的结果。

从业者在标准机器学习数据集上开发的技能可以为处理更大、更具挑战性的项目提供基础。

在这篇文章中，你将发现用于分类和回归的标准机器学习数据集，以及你可能期望在每个数据集上获得的基线和良好结果。

看完这篇文章，你会知道:

• 标准机器学习数据集的重要性。
• 如何在标准机器学习数据集上系统地评估模型？
• 用于分类和回归的标准数据集，以及每个数据集的基线和预期良好表现。

用我的新书Python 机器学习精通启动你的项目，包括分步教程和所有示例的 Python 源代码文件。

我们开始吧。

• 更新 Jun/2020 :增加了玻璃和马绞痛数据集的改进结果。
• 更新 2020 年 8 月:增加了马绞痛、房屋和汽车进口的更好结果(感谢德拉戈斯斯坦)

标准分类和回归机器学习数据集的结果
图片由 Don Dearing 提供，保留部分权利。

概观

本教程分为七个部分；它们是:

1. 小型机器学习数据集的价值
2. 标准机器学习数据集的定义
3. 标准机器学习数据集
4. 标准数据集的良好结果
5. 模型评估方法
6. 分类数据集的结果
   1. 二元分类数据集
      1. 电离层
      2. 皮马印度糖尿病
      3. 声纳
      4. 威斯康星州乳腺癌
      5. 马绞痛
   2. 多类分类数据集
      1. 鸢尾花
      2. 玻璃
      3. 葡萄酒
      4. 小麦种子
7. 回归数据集的结果
   1. 房屋
   2. 汽车保险
   3. 鲍鱼
   4. 汽车进口

小型机器学习数据集的价值

有许多用于分类和回归预测建模问题的小型机器学习数据集经常被重用。

有时，数据集被用作演示机器学习或数据准备技术的基础。其他时候，它们被用作比较不同技术的基础。

这些数据集是在应用机器学习的早期收集并公开提供的，当时数据和真实世界的数据集很少。因此，它们已经成为一个标准或经典，仅仅是因为它们的广泛采用和重用，而不是因为对问题的任何内在兴趣。

在其中一个数据集上找到一个好的模型并不意味着你已经“解决了”这个一般性的问题。此外，一些数据集可能包含可能被认为有问题或文化不敏感的名称或指标(，这很可能不是收集数据时的意图)。因此，它们有时也被称为“T4”玩具“T5”数据集。

这样的数据集对于机器学习算法的比较点并不真正有用，因为大多数经验实验几乎不可能重现。

然而，这样的数据集在今天的应用机器学习领域是有价值的。即使在标准机器学习库、大数据和大量数据的时代。

它们之所以有价值，主要有三个原因；它们是:

1. 数据集是真实的。
2. 数据集很小。
3. 数据集是理解的。

真实数据集与虚构数据集相比非常有用，因为它们杂乱无章。可能存在测量误差、缺失值、错误标记的示例等等。这些问题中的一些或全部必须被搜索和解决，并且是我们在自己的项目中可能遇到的一些属性。

小数据集与可能有数千兆字节大小的大数据集相比非常有用。小数据集可以很容易地放入内存中，并允许轻松快速地测试和探索许多不同的数据可视化、数据准备和建模算法。测试想法和获得反馈的速度对于初学者来说至关重要，而小数据集恰恰促进了这一点。

与新的或新创建的数据集相比，理解的数据集非常有用。特征被很好地定义，特征的单位被指定，数据的来源是已知的，并且数据集已经在几十个、几百个，以及在某些情况下几千个研究项目和论文中被很好地研究。这提供了一个可以比较和评估结果的环境，一个在全新领域中不可用的属性。

鉴于这些属性，我强烈建议机器学习初学者(以及对特定技术不熟悉的实践者)从标准机器学习数据集开始。

标准机器学习数据集的定义

我想更进一步，定义一个“标准”机器学习数据集的一些更具体的属性。

标准机器学习数据集具有以下属性。

• 少于 10，000 行(样本)。
• 少于 100 列(功能)。
• 最后一列是目标变量。
• 以 CSV 格式存储在单个文件中，没有标题行。
• 缺少用问号字符('？'标记的值)
• 有可能取得比天真更好的结果。

现在我们已经对数据集有了一个清晰的定义，让我们来看看一个“好的结果意味着什么。

标准机器学习数据集

如果数据集经常用于书籍、研究论文、教程、演示文稿等，则它是标准的机器学习数据集。

这些所谓的经典或标准机器学习数据集的最佳存储库是加州大学欧文分校(UCI)的机器学习存储库。该网站按类型对数据集进行分类，并提供关于每个数据集的数据和附加信息的下载以及相关论文的参考。

我为每种问题类型选择了五个或更少的数据集作为起点。

本文中使用的所有标准数据集都可以在 GitHub 上找到:

• 机器学习掌握数据集

还为每个数据集和数据集的其他详细信息(所谓的“”)提供下载链接。名称“文件”)。

每个代码示例都会自动为您下载给定的数据集。如果这是一个问题，您可以手动下载 CSV 文件，将其放在与代码示例相同的目录中，然后更改代码示例以使用文件名而不是网址。

例如:

...
# load dataset
dataframe = read_csv('ionosphere.csv', header=None)

标准数据集的良好结果

初学者在使用标准机器学习数据集时面临的一个挑战是什么代表了一个好的结果。

一般来说，如果一个模型能够展示出比简单方法更好的表现，比如预测分类中的多数类或者回归中的平均值，那么这个模型就是有技巧的。这称为基线模型或表现基线，它提供了特定于数据集的相对表现度量。您可以在此了解更多信息:

• 如何知道你的机器学习模型是否有好的表现

假设我们现在有了一种方法来确定模型对数据集是否有技巧，初学者仍然对给定数据集的表现上限感兴趣。这是了解你在应用机器学习过程中是否“T0”变好所必需的信息。

好并不意味着完美的预测。所有的模型都会有预测误差，完美的预测是不可能的(易处理？)在真实数据集上。

为数据集定义“好的”或“最好的”结果具有挑战性，因为它通常取决于模型评估方法，特别是评估中使用的数据集和库的版本。

好意味着在给定可用资源的情况下，足够好。通常，这意味着在给定无限的技能、时间和计算资源的情况下，技能得分可能高于数据集的第 80 或第 90 个百分点。

在本教程中，您将发现如何计算基线表现以及每个数据集上可能的“好的”(接近最佳)表现。您还将发现如何指定用于实现表现的数据准备和模型。

没有解释如何做到这一点，而是给出了一个简短的 Python 代码示例，您可以使用它来重现基线和良好的结果。

模型评估方法

评估方法简单快速，一般推荐在处理小型预测建模问题时使用。

程序评估如下:

• 使用 10 倍交叉验证对模型进行评估。
• 评估程序重复三次。
• 交叉验证拆分的随机种子是重复数(1、2 或 3)。

这产生了模型表现的 30 个估计，从中可以计算出平均值和标准偏差来总结给定模型的表现。

使用重复编号作为每个交叉验证拆分的种子，可确保在数据集上评估的每个算法获得相同的数据拆分，从而确保公平的直接比较。

使用 Sklearn Python 机器学习库，下面的示例可用于评估给定的模型(或 Pipeline )。repeated stratifiedfold类定义了用于分类的折叠和重复次数， cross_val_score()函数定义了分数并执行评估，返回一个分数列表，从中可以计算出平均值和标准偏差。

...
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')

对于回归，我们可以使用 RepeatedKFold 类和 MAE 分数。

...
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')

所报告的“好”分数是我个人的一套“在给定数据集脚本上快速获得好结果的最好成绩。我认为这些分数代表了在每个数据集上可以达到的好分数，也许在每个数据集可能达到的第 90 或 95 个百分点，如果不是更好的话。

也就是说，我并不是说它们是最好的分数，因为我没有对表现良好的模型进行超参数调整。我把这个留给感兴趣的从业者做练习。如果从业者能够处理给定的数据集，获得最高百分分数足以证明其能力，则不需要最佳分数。

注:我会随着自己个人脚本的完善，取得更好的成绩，更新成绩和模型。

对于一个数据集你能得到更好的分数吗？
我很想知道。在下面的评论中分享你的模型和分数，我会尽量重现并更新帖子(并给你满分！)

让我们开始吧。

分类数据集的结果

分类是一个预测建模问题，它预测给定一个或多个输入变量的一个标签。

分类任务的基线模型是预测多数标签的模型。这可以在 Sklearn 中使用带有“最频繁策略的 DummyClassifier 类来实现；例如:

...
model = DummyClassifier(strategy='most_frequent')

分类模型的标准评估是分类精确率，尽管这对于不平衡和一些多类问题并不理想。尽管如此，不管是好是坏，这个分数将被使用(现在)。

准确性报告为 0 (0%或无技能)和 1 (100%或完美技能)之间的分数。

有两种主要类型的分类任务:二进制和多类分类，根据给定数据集要预测的标签数量分为两个或两个以上。鉴于分类任务在机器学习中的流行，我们将分别处理这两种分类问题。

二元分类数据集

在本节中，我们将回顾以下二元分类预测建模数据集的基线和良好表现:

1. 电离层
2. 皮马印度糖尿病
3. 声纳
4. 威斯康星州乳腺癌
5. 马绞痛

电离层

• 下载:电离层. csv
• 详情:电离层.名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Ionosphere
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.dummy import DummyClassifier
from sklearn.svm import SVC
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/ionosphere.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# evaluate naive
naive = DummyClassifier(strategy='most_frequent')
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = SVC(kernel='rbf', gamma='scale', C=10)
steps = [('s',StandardScaler()), ('n',MinMaxScaler()), ('m',model)]
pipeline = Pipeline(steps=steps)
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (351, 34), (351,)
Baseline: 0.641 (0.006)
Good: 0.948 (0.033)

皮马印度糖尿病

• 下载:pima-印度人-diabetes.csv
• 详情:皮马-印第安人-糖尿病.名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Pima Indian Diabetes
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# evaluate naive
naive = DummyClassifier(strategy='most_frequent')
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = LogisticRegression(solver='newton-cg',penalty='l2',C=1)
m_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (768, 8), (768,)
Baseline: 0.651 (0.003)
Good: 0.774 (0.055)

声纳

• 下载: sonar.csv
• 详情:声纳.名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Sonar
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PowerTransformer
from sklearn.dummy import DummyClassifier
from sklearn.neighbors import KNeighborsClassifier
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# evaluate naive
naive = DummyClassifier(strategy='most_frequent')
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = KNeighborsClassifier(n_neighbors=2, metric='minkowski', weights='distance')
steps = [('p',PowerTransformer()), ('m',model)]
pipeline = Pipeline(steps=steps)
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (208, 60), (208,)
Baseline: 0.534 (0.012)
Good: 0.882 (0.071)

威斯康星州乳腺癌

• 下载:乳腺癌-威斯康星. csv
• 详情:乳腺癌-威斯康星.名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Wisconsin Breast Cancer
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PowerTransformer
from sklearn.impute import SimpleImputer
from sklearn.dummy import DummyClassifier
from sklearn.svm import SVC
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/breast-cancer-wisconsin.csv'
dataframe = read_csv(url, header=None, na_values='?')
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# evaluate naive
naive = DummyClassifier(strategy='most_frequent')
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = SVC(kernel='sigmoid', gamma='scale', C=0.1)
steps = [('i',SimpleImputer(strategy='median')), ('p',PowerTransformer()), ('m',model)]
pipeline = Pipeline(steps=steps)
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (699, 9), (699,)
Baseline: 0.655 (0.003)
Good: 0.973 (0.019)

马绞痛

• 下载:马绞痛 csv
• 详情:马绞痛名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例(归功于 Dragos Stan)。

# baseline and good result for Horse Colic
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.dummy import DummyClassifier
from xgboost import XGBClassifier
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/horse-colic.csv'
dataframe = read_csv(url, header=None, na_values='?')
data = dataframe.values
ix = [i for i in range(data.shape[1]) if i != 23]
X, y = data[:, ix], data[:, 23]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# evaluate naive
naive = DummyClassifier(strategy='most_frequent')
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = XGBClassifier(colsample_bylevel=0.9, colsample_bytree=0.9, importance_type='gain', learning_rate=0.01, max_depth=4, n_estimators=200, reg_alpha=0.1, reg_lambda=0.5, subsample=1.0)
imputer = SimpleImputer(strategy='median')
pipeline = Pipeline(steps=[('i', imputer), ('m', model)])
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (300, 27), (300,)
Baseline: 0.637 (0.010)
Good: 0.893 (0.057)

多类分类数据集

在本节中，我们将回顾以下多类分类预测建模数据集的基线和良好表现:

1. 鸢尾花
2. 玻璃
3. 葡萄酒
4. 小麦种子

鸢尾花

• 下载: iris.csv
• 详细信息:iris . name

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Iris
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PowerTransformer
from sklearn.dummy import DummyClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# evaluate naive
naive = DummyClassifier(strategy='most_frequent')
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = LinearDiscriminantAnalysis()
steps = [('p',PowerTransformer()), ('m',model)]
pipeline = Pipeline(steps=steps)
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (150, 4), (150,)
Baseline: 0.333 (0.000)
Good: 0.980 (0.039)

玻璃

• 下载: glass.csv
• 详情:玻璃名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

注意:测试工具从 10 倍交叉验证更改为 5 倍交叉验证，以确保每一倍都有所有类的示例，并避免警告消息。

# baseline and good result for Glass
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import RandomForestClassifier
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/glass.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# evaluate naive
naive = DummyClassifier(strategy='most_frequent')
cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
weights = {0:1.0, 1:1.0, 2:2.0, 3:2.0, 4:2.0, 5:2.0}
model = RandomForestClassifier(n_estimators=1000, class_weight=weights, max_features=2)
m_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (214, 9), (214,)
Baseline: 0.355 (0.009)
Good: 0.815 (0.048)

葡萄酒

• 下载: wine.csv
• 详情:葡萄酒.名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Wine
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.dummy import DummyClassifier
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/wine.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# evaluate naive
naive = DummyClassifier(strategy='most_frequent')
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = QuadraticDiscriminantAnalysis()
steps = [('s',StandardScaler()), ('n',MinMaxScaler()), ('m',model)]
pipeline = Pipeline(steps=steps)
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (178, 13), (178,)
Baseline: 0.399 (0.017)
Good: 0.992 (0.020)

小麦种子

• 下载:小麦种子. csv
• 详情:小麦种子.名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Wine
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import RidgeClassifier
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/wheat-seeds.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = LabelEncoder().fit_transform(y.astype('str'))
# evaluate naive
naive = DummyClassifier(strategy='most_frequent')
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = RidgeClassifier(alpha=0.2)
steps = [('s',StandardScaler()), ('m',model)]
pipeline = Pipeline(steps=steps)
m_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (210, 7), (210,)
Baseline: 0.333 (0.000)
Good: 0.973 (0.036)

回归数据集的结果

回归是一个预测建模问题，它预测给定一个或多个输入变量的数值。

分类任务的基线模型是预测平均值或中值的模型。这可以在 Sklearn 中使用dummymergressor类使用“中位数策略来实现；例如:

...
model = DummyRegressor(strategy='median')

回归模型的标准评估是平均绝对误差(MAE)，尽管这对于所有回归问题来说并不理想。尽管如此，不管是好是坏，这个分数将被使用(现在)。

MAE 被报告为 0(完美技能)和非常大的数字或无穷大(无技能)之间的错误分数。

在本节中，我们将回顾以下回归预测建模数据集的基线和良好表现:

1. 房屋
2. 汽车保险
3. 鲍鱼
4. 汽车进口

房屋

• 下载: housing.csv
• 详情:房屋名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Housing
from numpy import mean
from numpy import std
from numpy import absolute
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.dummy import DummyRegressor
from xgboost import XGBRegressor
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = y.astype('float32')
# evaluate naive
naive = DummyRegressor(strategy='median')
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
n_scores = absolute(n_scores)
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = XGBRegressor(colsample_bylevel=0.4, colsample_bynode=0.6, colsample_bytree=1.0, learning_rate=0.06, max_depth=5, n_estimators=700, subsample=0.8)
m_scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
m_scores = absolute(m_scores)
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (506, 13), (506,)
Baseline: 6.544 (0.754)
Good: 1.928 (0.292)

汽车保险

• 下载:车险. csv
• 详情:车险.名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Auto Insurance
from numpy import mean
from numpy import std
from numpy import absolute
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.pipeline import Pipeline
from sklearn.compose import TransformedTargetRegressor
from sklearn.preprocessing import PowerTransformer
from sklearn.dummy import DummyRegressor
from sklearn.linear_model import HuberRegressor
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
X = X.astype('float32')
y = y.astype('float32')
# evaluate naive
naive = DummyRegressor(strategy='median')
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(naive, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
n_scores = absolute(n_scores)
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = HuberRegressor(epsilon=1.0, alpha=0.001)
steps = [('p',PowerTransformer()), ('m',model)]
pipeline = Pipeline(steps=steps)
target = TransformedTargetRegressor(regressor=pipeline, transformer=PowerTransformer())
m_scores = cross_val_score(target, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
m_scores = absolute(m_scores)
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (63, 1), (63,)
Baseline: 66.624 (19.303)
Good: 28.358 (9.747)

鲍鱼

• 下载:鲍鱼. csv
• 详情:鲍鱼.名称

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Abalone
from numpy import mean
from numpy import std
from numpy import absolute
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.pipeline import Pipeline
from sklearn.compose import TransformedTargetRegressor
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import PowerTransformer
from sklearn.compose import ColumnTransformer
from sklearn.dummy import DummyRegressor
from sklearn.svm import SVR
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/abalone.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
# minimally prepare dataset
y = y.astype('float32')
# evaluate naive
naive = DummyRegressor(strategy='median')
transform = ColumnTransformer(transformers=[('c', OneHotEncoder(), [0])], remainder='passthrough')
pipeline = Pipeline(steps=[('ColumnTransformer',transform), ('Model',naive)])
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(pipeline, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
n_scores = absolute(n_scores)
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = SVR(kernel='rbf',gamma='scale',C=10)
target = TransformedTargetRegressor(regressor=model, transformer=PowerTransformer(), check_inverse=False)
pipeline = Pipeline(steps=[('ColumnTransformer',transform), ('Model',target)])
m_scores = cross_val_score(pipeline, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
m_scores = absolute(m_scores)
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (4177, 8), (4177,)
Baseline: 2.363 (0.116)
Good: 1.460 (0.075)

汽车进口

• 下载: auto_imports.csv
• 详细信息:auto _ imports . name

下面列出了在该数据集上实现基线和良好结果的完整代码示例。

# baseline and good result for Auto Imports
from numpy import mean
from numpy import std
from numpy import absolute
from pandas import read_csv
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.dummy import DummyRegressor
from xgboost import XGBRegressor
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto_imports.csv'
dataframe = read_csv(url, header=None, na_values='?')
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print('Shape: %s, %s' % (X.shape,y.shape))
y = y.astype('float32')
# evaluate naive
naive = DummyRegressor(strategy='median')
cat_ix = [2,3,4,5,6,7,8,14,15,17]
num_ix = [0,1,9,10,11,12,13,16,18,19,20,21,22,23,24]
steps = [('c', Pipeline(steps=[('s',SimpleImputer(strategy='most_frequent')),('oe',OneHotEncoder(handle_unknown='ignore'))]), cat_ix), ('n', SimpleImputer(strategy='median'), num_ix)]
transform = ColumnTransformer(transformers=steps, remainder='passthrough')
pipeline = Pipeline(steps=[('ColumnTransformer',transform), ('Model',naive)])
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
n_scores = cross_val_score(pipeline, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
n_scores = absolute(n_scores)
print('Baseline: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))
# evaluate model
model = XGBRegressor(colsample_bylevel=0.2, colsample_bytree=0.6, learning_rate=0.05, max_depth=6, n_estimators=200, subsample=0.8)
pipeline = Pipeline(steps=[('ColumnTransformer',transform), ('Model',model)])
m_scores = cross_val_score(pipeline, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1, error_score='raise')
m_scores = absolute(m_scores)
print('Good: %.3f (%.3f)' % (mean(m_scores), std(m_scores)))

注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。

运行该示例，您应该会看到以下结果。

Shape: (201, 25), (201,)
Baseline: 5509.486 (1440.942)
Good: 1361.965 (290.236)

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

教程

• 如何知道你的机器学习模型是否有好的表现

文章

• UCI 机器学习资源库
• Statlog 数据集:结果比较，wodzisaw Duch。
• 用于分类的数据集:结果比较，wodzisaw Duch。
• 机器学习，神经和统计分类，1994。
• 机器学习，神经和统计分类，主页，1994。
• 数据集加载实用程序，Sklearn 。

摘要

在这篇文章中，您发现了用于分类和回归的标准机器学习数据集，以及人们可能期望在每个数据集上实现的基线和良好结果。

具体来说，您了解到:

• 标准机器学习数据集的重要性。
• 如何在标准机器学习数据集上系统地评估模型？
• 用于分类和回归的标准数据集，以及每个数据集的基线和预期良好表现。

我错过了你最喜欢的数据集吗？
在评论里告诉我，我会给它算个分，甚至可能加到这个帖子里。

对于一个数据集你能得到更好的分数吗？
我很想知道；在下面的评论中分享你的模型和分数，我会试着重现它并更新帖子(并给你完全的信任！)

你有什么问题吗？
在下面的评论中提问，我会尽力回答。

如何在 Python 中开发岭回归模型

原文：https://machinelearningmastery.com/ridge-regression-with-python/

最后更新于 2020 年 10 月 11 日

回归是一项建模任务，包括预测给定输入的数值。

线性回归是回归的标准算法，假设输入和目标变量之间存在线性关系。线性回归的扩展调用了在训练期间对损失函数增加惩罚，这鼓励具有较小系数值的更简单的模型。这些扩展被称为正则化线性回归或惩罚线性回归。

岭回归是一种流行的正则化线性回归，包括 L2 惩罚。这具有缩小那些对预测任务贡献不大的输入变量的系数的效果。

在本教程中，您将发现如何在 Python 中开发和评估岭回归模型。

完成本教程后，您将知道:

• 岭回归是线性回归的扩展，它在训练期间给损失函数增加了正则化惩罚。
• 如何评估岭回归模型并使用最终模型对新数据进行预测。
• 如何通过网格搜索和自动为新数据集配置岭回归模型。

我们开始吧。

• 更新 2020 年 10 月:更新网格搜索程序中的代码，以匹配描述。

如何在 Python 中开发岭回归模型
图片由 Susanne Nilsson 提供，保留部分权利。

教程概述

本教程分为三个部分；它们是:

1. 里脊回归
2. 岭回归的例子
3. 调谐脊超参数

里脊回归

线性回归是指假设输入变量和目标变量之间存在线性关系的模型。

对于单个输入变量，这种关系是一条线，对于更高的维度，这种关系可以被认为是连接输入变量和目标变量的超平面。模型的系数是通过优化过程找到的，该过程寻求最小化预测值( yhat )和预期目标值( y )之间的误差平方和。

• 损失=总和 i=0 至 n(y _ I–yhat_i)²

线性回归的一个问题是模型的估计系数会变大，使模型对输入敏感，并且可能不稳定。对于观测值很少(样本)或样本数比输入预测值( p )或变量(所谓的 p > > n 问题)少( n )的问题尤其如此。

解决回归模型稳定性的一种方法是改变损失函数，以包括具有大系数的模型的额外成本。在训练过程中使用这些修正损失函数的线性回归模型统称为惩罚线性回归。

一种流行的惩罚是基于系数值平方之和(β)来惩罚模型。这被称为 L2 处罚。

• l2 _ 罚分=总和 j=0 至 p beta_j²

L2 惩罚最小化了所有系数的大小，尽管它通过允许任何系数的值变为零来防止从模型中移除任何系数。

这种惩罚的效果是，只有当上证综指按比例减少时，参数估计才被允许变大。实际上，随着λ罚值变大，这种方法将估计值缩小到 0(这些技术有时被称为“缩小方法”)。

—第 123 页，应用预测建模，2013 年。

这种惩罚可以加到线性回归的代价函数中，称为 Tikhonov 正则化(作者之后)，或者更一般地称为岭回归。

使用名为“λ”的超参数来控制损失函数的惩罚权重。默认值 1.0 将会完全加权该惩罚；值 0 不包括罚款。很小的λ值，如 1e-3 或更小，是常见的。

• ridge _ loss = loss+(λ* L2 _ pension)

现在我们已经熟悉了岭惩罚回归，让我们来看看一个成功的例子。

岭回归的例子

在本节中，我们将演示如何使用岭回归算法。

首先，让我们介绍一个标准回归数据集。我们将使用房屋数据集。

外壳数据集是一个标准的机器学习数据集，包括 506 行数据，有 13 个数字输入变量和一个数字目标变量。

使用三次重复的重复分层 10 倍交叉验证的测试工具，一个简单的模型可以获得大约 6.6 的平均绝对误差(MAE)。一个表现最好的模型可以在大约 1.9 的相同测试线束上实现 MAE。这提供了此数据集的预期表现范围。

该数据集包括预测美国波士顿郊区的房价。

• 房屋数据集(housing.csv)
• 房屋描述(房屋名称)

不需要下载数据集；我们将自动下载它作为我们工作示例的一部分。

下面的示例将数据集下载并加载为熊猫数据框，并总结了数据集的形状和前五行数据。

# load and summarize the housing dataset
from pandas import read_csv
from matplotlib import pyplot
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
# summarize shape
print(dataframe.shape)
# summarize first few lines
print(dataframe.head())

运行该示例确认了 506 行数据、13 个输入变量和一个数字目标变量(总共 14 个)。我们还可以看到，所有的输入变量都是数字。

(506, 14)
        0     1     2   3      4      5   ...  8      9     10      11    12    13
0  0.00632  18.0  2.31   0  0.538  6.575  ...   1  296.0  15.3  396.90  4.98  24.0
1  0.02731   0.0  7.07   0  0.469  6.421  ...   2  242.0  17.8  396.90  9.14  21.6
2  0.02729   0.0  7.07   0  0.469  7.185  ...   2  242.0  17.8  392.83  4.03  34.7
3  0.03237   0.0  2.18   0  0.458  6.998  ...   3  222.0  18.7  394.63  2.94  33.4
4  0.06905   0.0  2.18   0  0.458  7.147  ...   3  222.0  18.7  396.90  5.33  36.2

[5 rows x 14 columns]

Sklearn Python 机器学习库通过岭类提供了岭回归算法的实现。

令人困惑的是，在定义类时，lambda 术语可以通过“ alpha ”参数进行配置。默认值为 1.0 或全额罚款。

...
# define model
model = Ridge(alpha=1.0)

我们可以使用重复 10 倍交叉验证来评估住房数据集上的岭回归模型，并报告数据集上的平均绝对误差(MAE)。

# evaluate an ridge regression model on the dataset
from numpy import mean
from numpy import std
from numpy import absolute
from pandas import read_csv
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedKFold
from sklearn.linear_model import Ridge
# load the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
# define model
model = Ridge(alpha=1.0)
# define model evaluation method
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate model
scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# force scores to be positive
scores = absolute(scores)
print('Mean MAE: %.3f (%.3f)' % (mean(scores), std(scores)))

运行该示例评估住房数据集上的岭回归算法，并报告 10 倍交叉验证的三次重复的平均 MAE。

鉴于学习算法的随机性，您的具体结果可能会有所不同。考虑运行这个例子几次。

在这种情况下，我们可以看到模型实现了大约 3.382 的 MAE。

Mean MAE: 3.382 (0.519)

我们可能会决定使用岭回归作为我们的最终模型，并对新数据进行预测。

这可以通过在所有可用数据上拟合模型并调用 predict() 函数，传入新的数据行来实现。

我们可以用下面列出的完整示例来演示这一点。

# make a prediction with a ridge regression model on the dataset
from pandas import read_csv
from sklearn.linear_model import Ridge
# load the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
# define model
model = Ridge(alpha=1.0)
# fit model
model.fit(X, y)
# define new data
row = [0.00632,18.00,2.310,0,0.5380,6.5750,65.20,4.0900,1,296.0,15.30,396.90,4.98]
# make a prediction
yhat = model.predict([row])
# summarize prediction
print('Predicted: %.3f' % yhat)

运行该示例符合模型，并对新的数据行进行预测。

Predicted: 30.253

接下来，我们可以看看配置模型超参数。

调谐脊超参数

我们如何知道α= 1.0的默认超参数适合我们的数据集？

我们没有。

相反，测试一套不同的配置并发现什么最适合我们的数据集是一个很好的做法。

一种方法是在对数标度上从 1e-5 到 100 的范围内网格搜索α值，并发现什么最适合数据集。另一种方法是测试 0.0 到 1.0 之间的值，网格间距为 0.01。在这种情况下，我们将尝试后者。

下面的例子使用 GridSearchCV 类和我们定义的值网格来演示这一点。

# grid search hyperparameters for ridge regression
from numpy import arange
from pandas import read_csv
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RepeatedKFold
from sklearn.linear_model import Ridge
# load the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
# define model
model = Ridge()
# define model evaluation method
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# define grid
grid = dict()
grid['alpha'] = arange(0, 1, 0.01)
# define search
search = GridSearchCV(model, grid, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# perform the search
results = search.fit(X, y)
# summarize
print('MAE: %.3f' % results.best_score_)
print('Config: %s' % results.best_params_)

运行该示例将使用重复的交叉验证来评估配置的每个组合。

鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。

在这种情况下，我们可以看到我们获得了比默认的 3.379 vs. 3.382 稍好的结果。忽略标志；出于优化目的，该库使 MAE 为负。

我们可以看到模型给惩罚分配了一个 0.51 的α权重。

MAE: -3.379
Config: {'alpha': 0.51}

Sklearn 库还提供了一个内置的算法版本，可以通过 RidgeCV 类自动找到好的超参数。

为了使用这个类，它适合于训练数据集并用于进行预测。在训练过程中，它会自动调整超参数值。

默认情况下，模型将只测试α值(0.1，1.0，10.0)。我们可以通过设置“阿尔法”参数，将它更改为 0 到 1 之间的值网格，间距为 0.01，就像我们在前面的示例中所做的那样。

下面的例子演示了这一点。

# use automatically configured the ridge regression algorithm
from numpy import arange
from pandas import read_csv
from sklearn.linear_model import RidgeCV
from sklearn.model_selection import RepeatedKFold
# load the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
# define model evaluation method
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# define model
model = RidgeCV(alphas=arange(0, 1, 0.01), cv=cv, scoring='neg_mean_absolute_error')
# fit model
model.fit(X, y)
# summarize chosen configuration
print('alpha: %f' % model.alpha_)

运行该示例符合模型，并使用交叉验证发现给出最佳结果的超参数。

鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。

在这种情况下，我们可以看到模型选择了我们通过手动网格搜索找到的α= 0.51的相同超参数。

alpha: 0.510000

进一步阅读

如果您想更深入地了解这个主题，本节将提供更多资源。

书

• 统计学习的要素，2016。
• 应用预测建模，2013。

蜜蜂

• sklearn.linear_model。山脊 API 。
• sklearn.linear_model。里奇韦原料药。
• 线性模型，sci kit-学习。

文章

• Tikhonov 正则化，维基百科。

摘要

在本教程中，您发现了如何在 Python 中开发和评估岭回归模型。

具体来说，您了解到:

• 岭回归是线性回归的扩展，它在训练期间给损失函数增加了正则化惩罚。
• 如何评估岭回归模型并使用最终模型对新数据进行预测。
• 如何通过网格搜索和自动为新数据集配置岭回归模型。

你有什么问题吗？
在下面的评论中提问，我会尽力回答。