初级机器学习从业者在小型真实世界数据集上进行练习至关重要。
所谓的标准机器学习数据集包含实际观测值，适合内存，并且经过充分研究和理解。因此，初级从业者可以使用它们来快速测试、探索和练习数据准备及建模技术。
从业者可以确认他们是否具备在标准机器学习数据集上取得良好结果所需的数据技能。良好结果是指优于给定数据集可能达到的技术上限的第80或90个百分位的结果。
从业者在标准机器学习数据集上培养的技能可以为应对更大、更具挑战性的项目奠定基础。
在本帖中，您将发现用于分类和回归的标准机器学习数据集，以及您可能期望在每个数据集上达到的基线结果和良好结果。
阅读本文后，你将了解：
- 标准机器学习数据集的重要性。
- 如何在标准机器学习数据集上系统地评估模型。
- 分类和回归的标准数据集以及预期在每个数据集上达到的基线和良好性能。
通过我的新书 《Python机器学习精通》 开启您的项目，书中包含分步教程和所有示例的Python源代码文件。
让我们开始吧。
- 2020年6月更新：为玻璃和马匹结肠数据集添加了改进的结果。
- 2020年8月更新：为马匹结肠、住房和汽车进口数据集添加了更好的结果（感谢 Dragos Stan）
标准分类和回归机器学习数据集的结果
照片作者：Don Dearing，部分权利保留。
概述
本教程分为七个部分，它们是：
- 小型机器学习数据集的价值
- 标准机器学习数据集的定义
- 标准机器学习数据集
- 标准数据集的良好结果
- 模型评估方法
- 分类数据集的结果
- 二元分类数据集
- 电离层
- 皮马印第安人糖尿病
- 声纳
- 威斯康星乳腺癌
- 马匹结肠
- 多类分类数据集
- 鸢尾花
- 玻璃
- 葡萄酒
- 小麦种子
- 二元分类数据集
- 回归数据集的结果
- 住房
- 汽车保险
- 鲍鱼
- 汽车进口
小型机器学习数据集的价值
有许多用于分类和回归预测建模问题的、经常被重复使用的、小型机器学习数据集。
有时，这些数据集被用作演示机器学习或数据准备技术的基准。其他时候，它们被用作比较不同技术的基准。
这些数据集是在应用机器学习早期收集并公开的，当时数据和真实世界数据集稀缺。因此，它们因广泛采用和重复使用而成为标准或经典，而不是因为问题本身有内在的趣味性。
在这些数据集上找到一个好模型并不意味着您已经“解决”了普遍问题。此外，其中一些数据集可能包含被认为可疑或在文化上不敏感的名称或指标（这在收集数据时很可能不是意图）。因此，它们有时也被称为“玩具”数据集。
这些数据集对于机器学习算法的比较点来说并不是真正有用，因为几乎不可能重现大多数经验性实验。
尽管如此，这些数据集在今天的应用机器学习领域仍然很有价值。即使在标准机器学习库、大数据和数据丰富时代也是如此。
它们之所以有价值，主要有三个原因；它们是：
- 数据集是真实的。
- 数据集是小的。
- 数据集是被理解的。
与人为构造的数据集相比，真实数据集很有用，因为它们很混乱。可能存在（并且确实存在）测量错误、缺失值、标记错误示例等。其中一些或所有问题都必须进行查找和解决，这些都是我们在自己的项目中工作时可能遇到的一些属性。
与可能达许多千兆字节大小的大型数据集相比，小型数据集很有用。小型数据集可以轻松地放入内存，并可以轻松快速地测试和探索许多不同的数据可视化、数据准备和建模算法。测试想法和获得反馈的速度对初学者至关重要，而小型数据集恰好促进了这一点。
与新创建或最近创建的数据集相比，被理解的数据集很有用。特征定义明确，指定了特征单位，已知数据来源，并且数据集在几十、几百甚至数千个研究项目和论文中得到了充分研究。这提供了一个可以比较和评估结果的上下文，这是全新领域所不具备的属性。
鉴于这些属性，我强烈主张机器学习初学者（以及对特定技术不熟悉的从业者）从标准机器学习数据集开始。
标准机器学习数据集的定义
我想更进一步，为“标准”机器学习数据集定义一些更具体的属性。
标准机器学习数据集具有以下属性。
- 行数（样本数）少于10,000行。
- 列数（特征数）少于100列。
- 最后一列是目标变量。
- 以CSV格式存储在单个文件中，无标题行。
- 缺失值用问号字符（‘？’）标记。
- 可以获得优于朴素结果的结果。
既然我们有了数据集的清晰定义，让我们看看“良好”结果意味着什么。
标准机器学习数据集
如果一个数据集经常出现在书籍、研究论文、教程、演示文稿等中，那么它就是一个标准机器学习数据集。
这些所谓的经典或标准机器学习数据集的最佳存储库是加州大学欧文分校（UCI）机器学习存储库。该网站按类型对数据集进行分类，并提供数据下载以及关于每个数据集的额外信息以及相关的论文引用。
我选择了每个问题类型不超过五个数据集作为起点。
本文使用的所有标准数据集均在此 GitHub 链接提供：
每个数据集也提供了下载链接，以及关于数据集的更多详细信息（所谓的“*.name*”文件）。
每个代码示例都会自动为您下载给定的数据集。如果这是个问题，您可以手动下载 CSV 文件，将其放在代码示例的同一目录中，然后更改代码示例以使用文件名而不是 URL。
例如
|
1 2 3 |
... # 加载数据集 dataframe = read_csv('ionosphere.csv', header=None) |
标准数据集的良好结果
初学者在使用标准机器学习数据集时面临的挑战是，什么是良好结果。
一般来说，如果一个模型能够展示出优于朴素方法（例如，在分类中预测多数类，或在回归中预测均值）的性能，那么它就是一个有技能的模型。这被称为基线模型或性能基线，它提供了特定于数据集的相对性能度量。您可以在此处了解更多信息。
鉴于我们现在有了一种确定模型是否在数据集中具有技能的方法，初学者仍然对给定数据集的性能上限感兴趣。这是了解您是否在应用机器学习过程中“做得越来越好”所必需的信息。
良好并不意味着完美预测。所有模型都会有预测错误，并且在真实世界的数据集中不可能（或难以实现？）完美预测。
定义数据集的“良好”或“最佳”结果具有挑战性，因为它通常取决于模型评估方法，尤其取决于评估中使用的─数据集和库的版本。
良好意味着“足够好”，考虑到可用资源。通常，这意味着技能分数高于给定数据集在无限的技能、时间和计算资源下可能达到的第80或90个百分位。
在本教程中，您将发现如何计算基线性能以及在每个数据集上可能达到的“良好”（接近最佳）性能。您还将发现如何指定数据准备和用于实现性能的模型。
与其解释如何做到这一点，不如提供一个简短的 Python 代码示例，您可以使用它来重现基线和良好结果。
模型评估方法
评估方法简单快捷，并且通常推荐用于处理小型预测建模问题。
该过程评估如下：
- 模型使用10折交叉验证进行评估。
- 评估过程重复三次。
- 交叉验证分割的随机种子是重复次数（1、2或3）。
这样就可以得到30个模型性能的估计值，从中可以计算出均值和标准差来总结给定模型的性能。
使用重复次数作为每次交叉验证分割的种子，可以确保在数据集上评估的每个算法都获得相同的数据分割，从而确保公平的直接比较。
使用 scikit-learn Python 机器学习库，下面的示例可用于评估给定的模型（或Pipeline）。RepeatedStratifiedKFold 类定义了折数和重复次数以用于分类，而cross_val_score()函数定义了分数并执行评估，然后返回一个分数列表，从中可以计算均值和标准差。
|
1 2 3 |
... 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分数。
|
1 2 3 |
... 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个百分位，甚至更高。
话虽如此，我并不声称它们是最佳分数，因为我还没有对表现良好的模型进行超参数调整。我将这项任务留给有兴趣的从业者。如果从业者能够处理给定的数据集，那么获得顶级百分位分数就足以证明能力，最佳分数不是必需的。
注意：随着我改进个人脚本并获得更好的分数，我将更新结果和模型。
您能获得更好的分数吗？
我很想知道。请在下方评论中分享您的模型和分数，我将尝试重现它并更新帖子（并为您争取全部荣誉！）
让我们开始吧。
分类数据集的结果
分类是一个预测建模问题，它根据一个或多个输入变量预测一个标签。
分类任务的基线模型是预测多数标签的模型。这可以在 scikit-learn 中使用 'most_frequent' 策略的 DummyClassifier 类来实现；例如：
|
1 2 |
... model = DummyClassifier(strategy='most_frequent') |
分类模型的标准评估是分类准确率，尽管对于不平衡和某些多类问题来说，这并非理想。尽管如此，无论好坏，这个分数都将被使用（目前）。
准确率报告为介于0（0%或无技能）和1（100%或完美技能）之间的分数。
根据给定数据集要预测的标签数量，分类任务主要有两种类型：二元分类和多类分类，分别对应于两个或两个以上的标签。鉴于分类任务在机器学习中的普遍性，我们将分别处理分类问题的这两种子类型。
二元分类数据集
在本节中，我们将回顾以下二元分类预测建模数据集的基线和良好性能：
- 电离层
- 皮马印第安人糖尿病
- 声纳
- 威斯康星乳腺癌
- 马匹结肠
电离层
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
# 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 从 sklearn.预处理 导入 MinMaxScaler from sklearn.dummy import DummyClassifier from sklearn.svm import SVC # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = LabelEncoder().fit_transform(y.astype('str')) # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
Shape: (351, 34), (351,) Baseline: 0.641 (0.006) Good: 0.948 (0.033) |
皮马印第安人糖尿病
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
# 皮马印第安人糖尿病的基线和良好结果 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 从 sklearn.线性模型 导入 LogisticRegression # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = LabelEncoder().fit_transform(y.astype('str')) # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
Shape: (768, 8), (768,) Baseline: 0.651 (0.003) Good: 0.774 (0.055) |
声纳
- 下载：sonar.csv
- 详情：sonar.names
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
# 声纳的基线和良好结果 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 # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = LabelEncoder().fit_transform(y.astype('str')) # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
Shape: (208, 60), (208,) Baseline: 0.534 (0.012) Good: 0.882 (0.071) |
威斯康星乳腺癌
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
# 威斯康星乳腺癌的基线和良好结果 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 # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = LabelEncoder().fit_transform(y.astype('str')) # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
Shape: (699, 9), (699,) Baseline: 0.655 (0.003) Good: 0.973 (0.019) |
马匹结肠
下面列出了在该数据集上获得基线和良好结果的完整代码示例（归功于 Dragos Stan）。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
# 马匹结肠的基线和良好结果 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 # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = LabelEncoder().fit_transform(y.astype('str')) # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
Shape: (300, 27), (300,) Baseline: 0.637 (0.010) Good: 0.893 (0.057) |
多类分类数据集
在本节中，我们将回顾以下多类分类预测建模数据集的基线和良好性能：
- 鸢尾花
- 玻璃
- 葡萄酒
- 小麦种子
鸢尾花
- 下载：iris.csv
- 详情：iris.names
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
# 鸢尾花数据集的基线和良好结果 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 # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = LabelEncoder().fit_transform(y.astype('str')) # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
Shape: (150, 4), (150,) Baseline: 0.333 (0.000) Good: 0.980 (0.039) |
玻璃
- 下载：glass.csv
- 详情：glass.names
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
注意：测试框架从10折交叉验证改为5折交叉验证，以确保每个折都有所有类别的示例并避免警告消息。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
# 玻璃数据集的基线和良好结果 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 # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = LabelEncoder().fit_transform(y.astype('str')) # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
形状：(214, 9), (214,) 基线：0.355 (0.009) 良好：0.815 (0.048) |
葡萄酒
- 下载：wine.csv
- 详情：wine.names
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
# 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 从 sklearn.预处理 导入 MinMaxScaler from sklearn.dummy import DummyClassifier from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = LabelEncoder().fit_transform(y.astype('str')) # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
形状：(178, 13), (178,) 基线：0.399 (0.017) 良好：0.992 (0.020) |
小麦种子
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
# 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 # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = LabelEncoder().fit_transform(y.astype('str')) # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
形状：(210, 7), (210,) Baseline: 0.333 (0.000) 良好：0.973 (0.036) |
回归数据集的结果
回归是预测建模问题，它根据一个或多个输入变量预测一个数值。
分类任务的基线模型是预测均值或中位数的模型。这可以通过 scikit-learn 中的 DummyRegressor 类并使用“median”策略来实现；例如：
|
1 2 |
... model = DummyRegressor(strategy='median') |
回归模型的标准评估是平均绝对误差 (MAE)，尽管这并不适用于所有回归问题。不过，无论好坏，此分数（目前）都将被使用。
MAE 被报告为误差分数，介于 0（完美技能）和非常大的数字或无穷大（无技能）之间。
在本节中，我们将回顾以下回归预测建模数据集上的基线和良好性能：
- 住房
- 汽车保险
- 鲍鱼
- 汽车进口
住房
- 下载：housing.csv
- 详情：housing.names
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
# 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 # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = y.astype('float32') # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
形状：(506, 13), (506,) 基线：6.544 (0.754) 良好：1.928 (0.292) |
汽车保险
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
# 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 # 加载数据集 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)) # 最少地准备数据集 X = X.astype('float32') y = y.astype('float32') # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
形状：(63, 1), (63,) 基线：66.624 (19.303) 良好：28.358 (9.747) |
鲍鱼
- 下载：abalone.csv
- 详情：abalone.names
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
# 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 # 加载数据集 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)) # 最少地准备数据集 y = y.astype('float32') # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
形状：(4177, 8), (4177,) 基线：2.363 (0.116) 良好：1.460 (0.075) |
汽车进口
下面列出了在该数据集上获得基线和良好结果的完整代码示例。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
# 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 # 加载数据集 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') # 评估朴素模型 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))) # 评估模型 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))) |
注意：由于算法或评估过程的随机性，或者数值精度的差异，您的结果可能会有所不同。请考虑多次运行示例并比较平均结果。
运行示例，您应该会看到以下结果。
|
1 2 3 |
形状：(201, 25), (201,) 基线：5509.486 (1440.942) 良好：1361.965 (290.236) |
进一步阅读
如果您想深入了解，本节提供了更多关于该主题的资源。
教程
文章
- UCI 机器学习存储库
- Statlog 数据集：结果比较，Włodzisław Duch。
- 用于分类的数据集：结果比较，Włodzisław Duch。
- 机器学习、神经网络和统计分类, 1994.
- 机器学习、神经网络和统计分类，主页, 1994.
- 数据集加载实用程序，scikit-learn.
总结
在本文中，您了解了标准的机器学习分类和回归数据集，以及您可以在每个数据集上预期的基线和良好结果。
具体来说，你学到了：
- 标准机器学习数据集的重要性。
- 如何在标准机器学习数据集上系统地评估模型。
- 分类和回归的标准数据集以及预期在每个数据集上达到的基线和良好性能。
我错过了您最喜欢的数据集吗？
请在评论中告诉我，我会为您计算分数，或者甚至将其添加到本文中。
您能获得更好的分数吗？
我很想知道；请在下面的评论中分享您的模型和分数，我会尝试重现它并更新本文（并完全归功于您！）。
你有什么问题吗？
在下面的评论中提出你的问题，我会尽力回答。
发现 Python 中的快速机器学习！
在几分钟内开发您自己的模型
...只需几行 scikit-learn 代码
在我的新电子书中学习如何操作
精通 Python 机器学习
涵盖自学教程和端到端项目，例如
加载数据、可视化、建模、调优等等...
最终将机器学习带入
您自己的项目
跳过学术理论。只看结果。
将 ionospehere 的 C 参数更改为 20 可以稍微提高分数 (0.95)。与 0.948 相比，仅略微提高到 0.950。
我们应该这样做吗，还是会过拟合？我很想了解这个问题。
我们应该进行网格搜索并尝试获得最佳准确性吗？
model = SVC(kernel=’rbf’, gamma=’scale’, C=20)
非常好！
不，稳健的测试框架表明可能没有过拟合。
是的，网格搜索是个好主意！
为什么要使用这些代码行？
# 最少地准备数据集
X = X.astype(‘float32’)
y = LabelEncoder().fit_transform(y.astype(‘str’))
另外，看起来所有这些数据集都需要常规技术（编码、超参数调优、填充），但无需使用任何特征工程。您是否认为这个结论对于大多数数据集（例如 Kaggle 的数据集）是正确的？
提前感谢，
Moshik
这会将输入强制转换为浮点数（如果它们是整数）并将类标签进行标签编码，无论它们的格式如何。
不一定在所有情况下都如此，但通过将解决方案的复杂性推给模型而不是数据准备，您可以很快获得“良好”的结果。
您好，我注意到 housing 的链接有一个小错误（指向 wine 数据集）
正确的链接如下：
https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv
请，我借此机会问您，您是否知道在哪里可以找到更复杂的问题以及迄今为止获得的最佳解决方案，但有可能下载与他们使用的完全相同的数据集。
一种最先进的技术，但使用的是用于训练其模型的的数据集。
谢谢，
Gioel
谢谢，已修复！
也许是 Kaggle？
对于分类变量，我们可以在 LabelEncoder 之前使用 SimpleImputer 吗？
如果我们不将分类变量转换为数字，是否可以进行填充？
我尝试运行下面的代码，它给了我错误，你能帮帮我吗，我将非常感激
numerical_x = reduced_df.select_dtypes(include=[‘int64’, ‘float64’]).columns
categorical_x = reduced_df.select_dtypes(include=[‘object’, ‘bool’]).columns
steps = [(‘c’, Pipeline(steps=[(‘catimp’,SimpleImputer(strategy=’most_frequent’),
(‘ohe’,OneHotEncoder(handle_unknown=’ignore’)),)]), categorical_x),
(‘n’, Pipeline(steps=[(‘numimp’,SimpleImputer(strategy=’median’)),(‘sts’,StandardScaler())]), numerical_x)]
col_transform = ColumnTransformer(transformers=steps,remainder=’passthrough’)
dt= DecisionTreeClassifier()
pl= Pipeline(steps=[(‘prep’,col_transform), (‘dt’, dt)])
pl.fit(reduced_df,y_train)
ERROR
fit_params_steps = {name: {} for name, step in self.steps
ValueError: 要解包的值太多 (预期为2)
是的。
您也可以将缺失值视为一个标签并对其进行编码。
嗨，Jason！
Horse-colic 数据集，SimpleImputer(strategy = ‘median’)，看起来 XGBClassifier 提供了更好的准确性，模型如下。
所有其他分类数据集（使用 XGBoost）要么相同，要么非常接近，除了 Ionosphere，我尝试了几近一切但未能超过 93.8%。
Horse-colic
准确率：89.22% (5.94%)
XGBClassifier(base_score=None, booster=None, colsample_bylevel=0.9,
colsample_bynode=None, colsample_bytree=0.9, gamma=None,
gpu_id=None, importance_type=’gain’, interaction_constraints=None,
learning_rate=0.01, max_delta_step=None, max_depth=4,
min_child_weight=None, missing=nan, monotone_constraints=None,
n_estimators=200, n_jobs=None, num_parallel_tree=None,
random_state=None, reg_alpha=0.1, reg_lambda=0.5,
scale_pos_weight=None, subsample=1.0, tree_method=None,
validate_parameters=None, verbosity=None)
非常好的工作！感谢您分享您的发现。
我已更新示例并完全归功于您。
嗨，Jason，
我通过使用 XGBoost 和 GridSearchCV (7 个参数) 和 cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1) 进行超参数调优，在回归数据集上取得了一些小改进！
1. Housing：结果：1.917 (0.297)
XGBRegressor(base_score=None, booster=None, colsample_bylevel=0.4,
colsample_bynode=0.6, colsample_bytree=1.0, gamma=None,
gpu_id=None, importance_type=’gain’, interaction_constraints=None,
learning_rate=0.06, max_delta_step=None, max_depth=5,
min_child_weight=None, missing=nan, monotone_constraints=None,
n_estimators=700, n_jobs=None, num_parallel_tree=None,
random_state=None, reg_alpha=0.0, reg_lambda=1.0,
scale_pos_weight=None, subsample=0.8, tree_method=None,
validate_parameters=None, verbosity=None)
2. auto_imports
– NaN：SimpleImputer(strategy=’most_frequent’)
– 分类变量编码器：LabelEncoder()
– 分类变量的独热编码：pd.get_dummies(…., drop_first = True)
结果：1376.289 (304.522)
XGBRegressor(base_score=None, booster=None, colsample_bylevel=0.2,
colsample_bynode=1.0, colsample_bytree=0.6, gamma=None,
gpu_id=None, importance_type=’gain’, interaction_constraints=None,
learning_rate=0.05, max_delta_step=None, max_depth=6,
min_child_weight=None, missing=nan, monotone_constraints=None,
n_estimators=200, n_jobs=None, num_parallel_tree=None,
random_state=None, reg_alpha=0.0, reg_lambda=1.0,
scale_pos_weight=None, subsample=0.8, tree_method=None,
validate_parameters=None, verbosity=None)
此致，
Dragos
很酷，干得好！
更新：已添加到文章中。
你好，
对于 sonar.csv，当我使用 SVC 而不是 KNeighborsClassifiers 时，我获得了良好结果：0.899 (0.068)，而 KNeighborsClassifiers 提供了良好结果：0.893 (0.049)
我不知道在特定情况或数据类型下应该使用哪种模型。您能否解释或指向一个提供此类信息的资源？
谢谢，
Anand