Machine Learning Mastery Sklearn 教程（五）
如何在 Python 中开发 LASSO 回归模型
最后更新于 2021 年 10 月 6 日
回归是一项建模任务，包括预测给定输入的数值。
线性回归是回归的标准算法，假设输入和目标变量之间存在线性关系。线性回归的扩展调用了在训练期间对损失函数增加惩罚，这鼓励具有较小系数值的更简单的模型。这些扩展被称为正则化线性回归或惩罚线性回归。
套索回归是一种流行的正则化线性回归，包括 L1 惩罚。这具有缩小那些对预测任务贡献不大的输入变量的系数的效果。这种损失允许一些系数值达到零值，从而允许从模型中有效地移除输入变量，提供了一种自动特征选择。
在本教程中，您将发现如何在 Python 中开发和评估套索回归模型。
完成本教程后，您将知道:
- 套索回归是线性回归的扩展，它在训练期间给损失函数增加了正则化惩罚。
- 如何评估套索回归模型并使用最终模型对新数据进行预测。
- 如何通过网格搜索和自动为新数据集配置套索回归模型。
我们开始吧。
如何用 Python 开发 LASSO 回归模型 图片由菲尔杜比提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 套索回归
- 套索回归的例子
- 调谐套索超参数
套索回归
线性回归是指假设输入变量和目标变量之间存在线性关系的模型。
对于单个输入变量，这种关系是一条线，对于更高的维度，这种关系可以被认为是连接输入变量和目标变量的超平面。模型的系数是通过优化过程找到的，该过程寻求最小化预测值( yhat )和预期目标值( y )之间的误差平方和。
- 损失=总和 i=0 至 n(y _ I–yhat_i)²
线性回归的一个问题是模型的估计系数会变大，使模型对输入敏感，并且可能不稳定。对于观测值很少(样本)或样本数比输入预测值( p )或变量(所谓的 p > > n 问题)少( n )的问题尤其如此。
解决回归模型稳定性的一种方法是改变损失函数，以包括具有大系数的模型的额外成本。在训练过程中使用这些修正损失函数的线性回归模型统称为惩罚线性回归。
一种流行的惩罚是基于绝对系数值的总和来惩罚模型。这被称为 L1 惩罚。L1 惩罚使所有系数的大小最小化，并允许一些系数最小化到零值，这从模型中移除了预测器。
- l1 _ 罚分=总和 j=0 至 p ABS(β_ j)
L1 罚函数最小化了所有系数的大小，并允许任何系数达到零值，从而有效地从模型中移除输入特征。
这是一种自动特征选择。
…惩罚绝对值的结果是，对于λ的某个值，某些参数实际上被设置为 0。因此套索产生同时使用正则化来改进模型和进行特征选择的模型。
—第 125 页，应用预测建模，2013 年。
这种惩罚可以加到线性回归的成本函数中，称为最小绝对收缩和选择算子正则化 (LASSO)，或者更常见的是，简称为“ Lasso ”(带标题情况)。
岭回归的一种流行替代方法是最小绝对收缩和选择算子模型，通常称为套索。
—第 124 页，应用预测建模，2013 年。
使用名为“λ”的超参数来控制损失函数的惩罚权重。默认值 1.0 将给予处罚全部权重；值 0 不包括罚款。非常小的λ值，例如 1e-3 或更小，是常见的。
- lasso _ loss = loss+(λ* L1 _ 罚分)
现在我们已经熟悉了 Lasso 惩罚回归，让我们来看看一个成功的例子。
套索回归的例子
在本节中，我们将演示如何使用套索回归算法。
首先，让我们介绍一个标准回归数据集。我们将使用房屋数据集。
外壳数据集是一个标准的机器学习数据集，包括 506 行数据，有 13 个数字输入变量和一个数字目标变量。
使用三次重复的重复分层 10 倍交叉验证的测试工具，一个简单的模型可以获得大约 6.6 的平均绝对误差(MAE)。一个表现最好的模型可以在大约 1.9 的相同测试线束上实现 MAE。这提供了此数据集的预期表现范围。
该数据集包括预测美国波士顿市郊住宅区的房价。
不需要下载数据集；我们将自动下载它作为我们工作示例的一部分。
下面的示例将数据集下载并加载为熊猫数据框，并总结了数据集的形状和前五行数据。
# 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 = Lasso(alpha=1.0)
我们可以使用重复 10 倍交叉验证来评估房屋数据集上的套索回归模型，并报告数据集上的平均绝对误差(MAE)。
# evaluate an lasso 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 Lasso
# 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 = Lasso(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.711 的 MAE。
Mean MAE: 3.711 (0.549)
我们可能会决定使用套索回归作为我们的最终模型，并根据新数据进行预测。
这可以通过在所有可用数据上拟合模型并调用 predict() 函数，传入新的数据行来实现。
我们可以用下面列出的一个完整的例子来演示这一点。
# make a prediction with a lasso regression model on the dataset
from pandas import read_csv
from sklearn.linear_model import Lasso
# 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 = Lasso(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.998
接下来，我们可以看看配置模型超参数。
调谐套索超参数
我们如何知道α= 1.0的默认超参数适合我们的数据集？
我们没有。
相反，测试一套不同的配置并发现什么最适合我们的数据集是一个很好的做法。
一种方法是在对数 10 标度上网格搜索从 1e-5 到 100 的α值，并发现什么最适合数据集。另一种方法是测试 0.0 到 1.0 之间的值，网格间距为 0.01。在这种情况下，我们将尝试后者。
下面的例子使用 GridSearchCV 类和我们定义的值网格来演示这一点。
# grid search hyperparameters for lasso 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 Lasso
# 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 = Lasso()
# 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_)
运行该示例将使用重复的交叉验证来评估配置的每个组合。
鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。
您可能会看到一些可以安全忽略的警告，例如:
Objective did not converge. You might want to increase the number of iterations.
在这种情况下，我们可以看到我们获得了比默认的 3.379 vs. 3.711 稍好的结果。忽略标志；出于优化目的，该库使 MAE 为负。
我们可以看到模型给惩罚分配了一个 0.01 的α权重。
MAE: -3.379
Config: {'alpha': 0.01}
Sklearn 库还提供了一个内置的算法版本，可以通过 LassoCV 类自动找到好的超参数。
为了使用该类，模型按照正常方式适合训练数据集，并且在训练过程中自动调整超参数。然后，拟合模型可用于进行预测。
默认情况下，模型将测试 100 个α值。我们可以通过设置“阿尔法”参数，将它更改为 0 到 1 之间的值网格，间距为 0.01，就像我们在前面的示例中所做的那样。
下面的例子演示了这一点。
# use automatically configured the lasso regression algorithm
from numpy import arange
from pandas import read_csv
from sklearn.linear_model import LassoCV
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 = LassoCV(alphas=arange(0, 1, 0.01), cv=cv, n_jobs=-1)
# fit model
model.fit(X, y)
# summarize chosen configuration
print('alpha: %f' % model.alpha_)
运行该示例符合模型，并使用交叉验证发现给出最佳结果的超参数。
鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。
在这种情况下，我们可以看到模型选择了α= 0.0 的超参数。这与我们通过手动网格搜索发现的不同，可能是由于搜索或选择配置的系统方式。
alpha: 0.000000
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
书
蜜蜂
文章
摘要
在本教程中，您发现了如何在 Python 中开发和评估套索回归模型。
具体来说，您了解到:
- 套索回归是线性回归的扩展，它在训练期间给损失函数增加了正则化惩罚。
- 如何评估套索回归模型并使用最终模型对新数据进行预测。
- 如何通过网格搜索和自动为新数据集配置套索回归模型。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
Python 线性判别分析
线性判别分析是一种线性分类机器学习算法。
该算法包括基于每个输入变量的观测值的特定分布，为每个类开发一个概率模型。然后，通过计算一个新例子属于每个类别的条件概率并选择具有最高概率的类别来对其进行分类。
因此，这是一个相对简单的概率分类模型，它对每个输入变量的分布做出了强有力的假设，尽管它可以做出有效的预测，即使这些预期被违反(例如，它优雅地失败了)。
在本教程中，您将发现 Python 中的线性判别分析分类机器学习算法。
完成本教程后，您将知道:
- 线性判别分析是一种简单的线性机器学习分类算法。
- 如何使用 Sklearn 的线性判别分析模型进行拟合、评估和预测。
- 如何在给定数据集上调整线性判别分析算法的超参数。
我们开始吧。
用 Python 进行线性判别分析 图片由密海 Lucîț 提供，保留部分权利。
教程概述
本教程分为三个部分；它们是:
- 线性判别分析
- 基于 Sklearn 的线性判别分析
- 调整线性判别分析超参数
线性判别分析
线性判别分析，简称 LDA，是一种分类机器学习算法。
它的工作原理是按类别标签计算输入要素的汇总统计数据，如平均值和标准偏差。这些统计数据表示从训练数据中学习到的模型。在实践中，线性代数运算被用来通过矩阵分解有效地计算所需的量。
根据每个输入要素的值，通过估计新示例属于每个类别标签的概率来进行预测。然后将产生最大概率的类分配给该示例。因此，LDA 可以被认为是贝叶斯定理在分类中的简单应用。
线性判别分析假设输入变量是数值型的正态分布，并且它们具有相同的方差(分布)。如果不是这样，可能需要将数据转换为高斯分布，并在建模之前对数据进行标准化或规范化。
LDA 分类器是假设每个类别内的观测值来自具有特定类别均值向量和共同方差的正态分布而产生的
—第 142 页，R中应用的统计学习介绍，2014。
它还假设输入变量不相关；如果是，PCA 变换可能有助于消除线性相关性。
……从业者在使用 LDA 之前，应对数据进行特别严格的预处理。我们建议对预测值进行居中和缩放，并移除接近零的方差预测值。
—第 293 页，应用预测建模，2013 年。
然而，该模型可以表现良好，即使违反了这些期望。
LDA 模型自然是多类的。这意味着它支持两类分类问题，并且可以扩展到两类以上(多类分类)，而无需修改或增加。
它是一种线性分类算法，就像逻辑回归一样。这意味着类在特征空间中由线或超平面分隔。该方法的扩展可以用于允许其他形状，如二次判别分析(QDA)，它允许在决策边界弯曲的形状。
……与 LDA 不同，QDA 假设每个类都有自己的协方差矩阵。
—第 149 页，R中应用的统计学习介绍，2014。
现在我们已经熟悉了 LDA，让我们看看如何使用 Sklearn 库来拟合和评估模型。
基于 Sklearn 的线性判别分析
线性判别分析可通过线性判别分析类在 Sklearn Python 机器学习库中获得。
该方法可以在没有配置的情况下直接使用，尽管该实现确实提供了自定义参数，例如选择求解器和使用惩罚。
...
# create the lda model
model = LinearDiscriminantAnalysis()
我们可以用一个实例来说明线性判别分析方法。
首先，让我们定义一个综合分类数据集。
我们将使用 make_classification()函数创建一个包含 1000 个示例的数据集，每个示例有 10 个输入变量。
该示例创建并汇总数据集。
# test classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)
# summarize the dataset
print(X.shape, y.shape)
运行该示例将创建数据集，并确认数据集的行数和列数。
(1000, 10) (1000,)
我们可以通过重复分层 k 折交叉验证类来拟合和评估线性判别分析模型。我们将在测试装具中使用 10 次折叠和三次重复。
下面列出了评估综合二元分类任务的线性判别分析模型的完整示例。
# evaluate a lda 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.discriminant_analysis import LinearDiscriminantAnalysis
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)
# define model
model = LinearDiscriminantAnalysis()
# define model evaluation method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# evaluate model
scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)
# summarize result
print('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))
运行该示例评估合成数据集上的线性判别分析算法，并报告 10 倍交叉验证的三次重复的平均准确性。
鉴于学习算法的随机性，您的具体结果可能会有所不同。考虑运行这个例子几次。
在这种情况下，我们可以看到模型实现了大约 89.3%的平均精确率。
Mean Accuracy: 0.893 (0.033)
我们可能会决定使用线性判别分析作为我们的最终模型，并对新数据进行预测。
这可以通过在所有可用数据上拟合模型并调用 predict()函数传入新的数据行来实现。
我们可以用下面列出的完整示例来演示这一点。
# make a prediction with a lda model on the dataset
from sklearn.datasets import make_classification
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)
# define model
model = LinearDiscriminantAnalysis()
# fit model
model.fit(X, y)
# define new data
row = [0.12777556,-3.64400522,-2.23268854,-1.82114386,1.75466361,0.1243966,1.03397657,2.35822076,1.01001752,0.56768485]
# make a prediction
yhat = model.predict([row])
# summarize prediction
print('Predicted Class: %d' % yhat)
运行该示例符合模型，并对新的数据行进行类别标签预测。
Predicted Class: 1
接下来，我们可以看看如何配置模型超参数。
调整线性判别分析超参数
必须为特定数据集配置线性判别分析方法的超参数。
一个重要的超参数是解算器，它默认为“ svd ”，但也可以设置为支持收缩能力的解算器的其他值。
下面的示例使用带有不同解算器值的网格的网格分类来演示这一点。
# grid search solver for lda
from sklearn.datasets import make_classification
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)
# define model
model = LinearDiscriminantAnalysis()
# define model evaluation method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# define grid
grid = dict()
grid['solver'] = ['svd', 'lsqr', 'eigen']
# define search
search = GridSearchCV(model, 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_)
运行该示例将使用重复的交叉验证来评估配置的每个组合。
鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。
在这种情况下，我们可以看到，与其他内置解算器相比，默认的 SVD 解算器的表现最好。
Mean Accuracy: 0.893
Config: {'solver': 'svd'}
接下来，我们可以探索在模型中使用收缩是否会提高表现。
收缩给模型增加了一种惩罚，作为一种正则化，降低了模型的复杂性。
正则化以潜在增加的偏差为代价，减少了与基于样本的估计相关的方差。这种偏差方差权衡通常由一个或多个(置信程度)参数调节，这些参数控制朝向“似是而非”的一组(总体)参数值的偏差强度。
——正则化判别分析，1989。
这可以通过“收缩”参数设置，并且可以设置为 0 到 1 之间的值。我们将在间距为 0.01 的网格上测试值。
为了使用惩罚，必须选择支持此功能的解算器，例如“特征值或“ lsqr ”。在这种情况下，我们将使用后者。
下面列出了调整收缩超参数的完整示例。
# grid search shrinkage for lda
from numpy import arange
from sklearn.datasets import make_classification
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)
# define model
model = LinearDiscriminantAnalysis(solver='lsqr')
# define model evaluation method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# define grid
grid = dict()
grid['shrinkage'] = arange(0, 1, 0.01)
# define search
search = GridSearchCV(model, 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_)
运行该示例将使用重复的交叉验证来评估配置的每个组合。
鉴于学习算法的随机性，您的具体结果可能会有所不同。试着运行这个例子几次。
在这种情况下，我们可以看到使用收缩将表现从大约 89.3%略微提升到大约 89.4%，值为 0.02。
Mean Accuracy: 0.894
Config: {'shrinkage': 0.02}
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
报纸
- 正则化判别分析，1989。
书
蜜蜂
文章
摘要
在本教程中，您发现了 Python 中的线性判别分析分类机器学习算法。
具体来说，您了解到:
- 线性判别分析是一种简单的线性机器学习分类算法。
- 如何使用 Sklearn 的线性判别分析模型进行拟合、评估和预测。
- 如何在给定数据集上调整线性判别分析算法的超参数。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
如何使用 Python 3 为机器学习开发创建 Linux 虚拟机
原文：
machinelearningmastery.com/linux-virtual-machine-machine-learning-development-python-3/
Linux 是使用 Python 进行机器学习开发的绝佳环境。
这些工具可以快速轻松地安装，您可以直接开发和运行大型模型。
在本教程中，您将了解如何使用 Python 创建和设置 Linux 虚拟机以进行机器学习。
完成本教程后，您将了解：
- 如何下载和安装 VirtualBox 以管理虚拟机。
- 如何下载和设置 Fedora Linux。
- 如何在 Python 3 中为机器学习安装 SciPy 环境。
如果您的基本操作系统是 Windows，Mac OS X 和 Linux，则本教程适用。
让我们开始吧。
Linux 虚拟机的好处
您可能希望使用 Linux 虚拟机进行 Python 机器学习开发有很多原因。
例如，下面列出了使用虚拟机的 5 大优势：
- 使用系统上不可用的工具（如果您使用的是 Windows）。
- 在不影响本地环境的情况下安装和使用机器学习工具（例如，使用 Python 3 工具）。
- 为不同的项目（Python2 和 Python3）提供高度自定义的环境。
- 保存机器的状态并准确地拾取您离开的位置（从机器跳到机器）。
- 与其他开发人员共享开发环境（设置一次并重复使用多次）。
也许最有利的一点是第一个，能够轻松使用您的环境不支持的机器学习工具。
我是 OS X 用户，即使可以使用brew和macports安装机器学习工具，我仍然发现设置和使用 Linux 虚拟机进行机器学习开发更容易。
概观
本教程分为 3 个部分：
- 下载并安装 VirtualBox。
- 在虚拟机中下载并安装 Fedora Linux。
- 安装 Python 机器学习环境
1.下载并安装 VirtualBox
VirtualBox 是一个免费的开源平台，用于创建和管理虚拟机。
安装后，只要您有要安装的 ISO 映像或 CD，就可以创建所需的所有虚拟机。
- 1.访问 VirtualBox.org
- 2.单击“_ 下载 VirtualBox_ ”以访问下载页面。
下载 VirtualBox
- 3.选择工作站的二进制文件。
- 4.安装系统软件并按照安装说明进行操作。
安装 VirtualBox
- 5.打开 VirtualBox 软件并确认其有效。
启动 VirtualBox
2.下载并安装 Fedora Linux
我之所以选择 Fedora Linux ，是因为我认为它比一些更友好，更温和的 Linux。
它是 RedHat Linux 的前沿，适用于工作站和开发人员。
2.1 下载 Fedora ISO 映像
让我们首先下载 Fedora Linux 的 ISO。在这种情况下，64 位版本的 Fedora 25。
- 1.访问 GetFedora.org 。
- 2.单击“_ 工作站 _”以访问工作站页面。
- 3.单击“_ 立即下载 _”以访问下载页面。
- 4.在“其他下载”下单击“ _64 位 1.3GB 实时图像 _”
下载 Fedora
- 5.您现在应该拥有一个名为的 ISO 文件：
- “ Fedora-Workstation-Live-x86_64-25-1.3.iso ”。
我们现在准备在 VirtualBox 中创建 VM。
2.2 创建 Fedora 虚拟机
现在，让我们在 VirtualBox 中创建 Fedora 虚拟机。
- 1.打开 VirtualBox 软件。
- 2.单击“
New”按钮。 - 3.选择名称和操作系统。
- 名称： Fedora25
- 类型： Linux
- 版本： Fedora（64 位）
- 点击“_ 继续 _”
创建 Fedora VM 名称和操作系统
- 4.配置内存大小
- 2048
- 5.配置硬盘
- 立即创建虚拟硬盘
- 硬盘文件类型
- VDI（VirtualBox 磁盘映像）
- 存储在物理硬盘上
- 动态分配
- 文件位置和大小： 10GB
我们现在准备从 ISO 映像安装 Fedora。
2.3 安装 Fedora Linux
现在，让我们在新的虚拟机上安装 Fedora Linux。
- 1.选择新虚拟机，然后单击“_ 启动 _”按钮。
- 2.单击文件夹图标，然后选择 Fedora ISO 文件：
- “ Fedora-Workstation-Live-x86_64-25-1.3.iso ”。
安装 Fedora
- 3.单击“_ 启动 _”按钮。
- 4.选择第一个选项“_ 启动 Fedora-Live-Workstation-Live 25_ ”，然后按 _ 确认 _ 键。
- 5.点击“
Esc”键跳过检查。 - 6.选择“_ 实时系统用户 _”。
- 7.选择“_ 安装到硬盘 _”。
将 Fedora 安装到硬盘驱动器
- 8.完成“_ 语言选择 _”（英文）
- 9.完成“_ 安装目的地 _”（“ ATA VBOX HARDDISK ”）。
- 您可能需要等待一分钟才能让 VM 创建硬盘。
在虚拟硬盘上安装
- 10.单击“_ 开始安装 _”。
- 11.设置 root 密码。
- 12.为自己创建一个用户。
- 记下用户名和密码（以便稍后使用）。
- 勾选“_ 使该用户管理员 _”（这样您就可以安装软件）。
创建一个新用户
- 13.等待安装完成......（5 分钟？）
- 14.单击“_ 退出 _”，单击右上角的电源图标;选择关机。
2.4 完成 Fedora Linux 安装
已经安装了 Fedora Linux;让我们完成安装并准备好使用它。
- 1.在 VirtualBox 中选择 Fedora25 VM，在“
Storage”下，单击“ Optical Drive ”。- 选择“_ 从虚拟驱动器 _ 中删除磁盘”以弹出 ISO 映像。
- 2.单击“
Start”按钮启动 Fedora Linux 安装。 - 3.以您创建的用户身份登录。
Fedora 以新用户身份登录
- 4.完成安装
- 选择语言“_ 英语 _”
- 点击“_ 下一个 _”
- 选择键盘“
US” - 点击“_ 下一个 _”
- 配置隐私
- 点击“_ 下一个 _”
- 连接您的在线帐户
- 点击“_ 跳过 _”
- 点击“_ 开始使用 Fedora_ ”
- 5.关闭自动启动的帮助系统。
我们现在有一个 Fedora Linux 虚拟机准备安装新软件。
3.安装 Python 机器学习环境
Fedora 使用 Gnome 3 作为窗口管理器。
Gnome 3 与之前版本的 Gnome 完全不同;您可以使用内置帮助系统学习如何四处走动。
3.1 安装 Python 环境
让我们首先安装所需的 Python 库以进行机器学习开发。
- 1.打开终端。
- 点击“_ 活动 _”
- 输入“_ 终端 _”
- 单击图标或按 Enter 键
启动终端
- 2.确认已安装 Python3。
类型：
python3 --version
Python3 版本
- 3.安装 Python 机器学习环境。特别：
- NumPy 的
- SciPy 的
- 熊猫
- Matplotlib
- Statsmodels
- Scikit-学习
DNF 是软件安装系统，正式为 yum。第一次运行dnf时，它会更新软件包数据库，这可能需要一分钟。
Type:
sudo dnf install python3-numpy python3-scipy python3-scikit-learn python3-pandas python3-matplotlib python3-statsmodels
出现提示时输入密码。
按“y”和“_ 进入 _”按钮提示确认安装。
3.2 确认 Python 环境
现在已经安装了环境，我们可以通过打印每个所需库的版本来确认它。
- 1.打开 Gedit。
- 点击“_ 活动 _”
- 输入“
gedit” - 单击图标或按 Enter 键
- 2.键入以下脚本并将其另存为主目录中的
versions.py。
# scipy
import scipy
print('scipy: %s' % scipy.__version__)
# numpy
import numpy
print('numpy: %s' % numpy.__version__)
# matplotlib
import matplotlib
print('matplotlib: %s' % matplotlib.__version__)
# pandas
import pandas
print('pandas: %s' % pandas.__version__)
# scikit-learn
import sklearn
print('sklearn: %s' % sklearn.__version__)
# statsmodels
import statsmodels
print('statsmodels: %s' % statsmodels.__version__)
没有复制粘贴支持;您可能希望在 VM 中打开 Firefox 并导航到此页面并将脚本复制粘贴到 Gedit 窗口中。
编写版本脚本
- 3.在终端中运行脚本。
Type:
python3 versions.py
Python3 检查库版本
使用 VM 的提示
本节列出了使用 VM 进行机器学习开发的一些技巧。
- 复制粘贴和文件夹共享。这些功能需要在 Linux VM 中安装“ Guest Additions ”。我无法正确安装，因此不使用这些功能。如果你愿意，你可以尝试;让我知道你在评论中的表现。
- 使用 GitHub 。我建议将所有代码存储在 GitHub 中，并检查 VM 中的代码。它使得代码和资产进出 VM 更加容易。
- 使用 Sublime 。我认为 sublime 是 Linux 上用于开发的优秀文本编辑器，至少比 Gedit 更好。
- 将 AWS 用于大型作业。您可以使用相同的步骤在 Amazon Web Services 上设置 Fedora Linux，以便在云中运行大型模型。
- VM Tools 。您可以通过关闭窗口随时保存 VM。您还可以随时获取 VM 的快照并返回快照。如果要对文件系统进行大量更改，这将非常有用。
- Python2 。您可以在 Linux 中轻松地将 Python2 与 Python 3 一起安装，并使用 python（而不是 python3）二进制文件或使用替代方法在两者之间切换。
- 笔记本。考虑在 VM 内部运行笔记本服务器并打开防火墙，以便可以从 VM 外部的主工作站连接和运行。
你有任何提示要分享吗？请在评论中告诉我。
进一步阅读
如果您不熟悉本教程中使用的工具，下面是一些可供进一步阅读的资源。
- VirtualBox 用户手册
- Fedora 文档
- Fedora Wiki （关于常见主题的大量帮助）
- SciPy 主页
- Scikit-Learn Homepage
摘要
在本教程中，您了解了如何为 Python 机器学习开发设置 Linux 虚拟机。
具体来说，你学到了：
- 如何下载和安装用于管理虚拟机的 VirtualBox 免费开源软件。
- 如何下载和安装 Fedora Linux，这是一个面向开发人员的友好 Linux 发行版。
- 如何安装和测试 Python3 环境以进行机器学习开发。
你完成了教程吗？ 请在下面的评论中告诉我它是怎么回事。
如何在 Python 中加载机器学习数据
原文：
machinelearningmastery.com/load-machine-learning-data-python/
您必须能够在启动机器学习项目之前加载数据。
机器学习数据最常见的格式是 CSV 文件。有许多方法可以在 Python 中加载 CSV 文件。
在这篇文章中，您将发现可以用来在 Python 中加载机器学习数据的不同方法。
让我们开始吧。
- 2017 年 3 月更新：更改从二进制（'rb'）到 ASCII（'rt）的加载。
- 更新 March / 2018 ：添加了备用链接以下载数据集，因为原始图像已被删除。
- 更新 March / 2018 ：更新了来自 URL 示例的 NumPy 加载，以便与 Python 3 一起工作。
如何在 Python 中加载机器学习数据 照片由 Ann Larie Valentine ，保留一些权利。
加载 CSV 数据时的注意事项
从 CSV 文件加载机器学习数据时需要考虑许多因素。
作为参考，您可以通过查看标题为通用格式和逗号分隔值（CSV）文件的 MIME 类型的评论的 CSV 请求，了解有关 CSV 文件期望的大量信息。
CSV 文件标题
您的数据是否有文件头？
如果是这样，这可以帮助自动为每列数据分配名称。如果没有，您可能需要手动命名属性。
无论哪种方式，您都应明确指定 CSV 文件在加载数据时是否具有文件头。
评论
您的数据有评论吗？
CSV 文件中的注释在行的开头用散列（“＃”）表示。
如果您的文件中有注释，则根据用于加载数据的方法，您可能需要指明是否期望注释以及期望表示注释行的字符。
分隔符
用于分隔字段中值的标准分隔符是逗号（“，”）字符。
您的文件可以使用不同的分隔符，如 tab（“\ t”），在这种情况下，您必须明确指定它。
行情
有时字段值可以包含空格。在这些 CSV 文件中，通常会引用值。
默认引号字符是双引号“\”“。可以使用其他字符，您必须指定文件中使用的引号字符。
机器学习数据加载秘籍
每个秘籍都是独立的。
这意味着您可以将其复制并粘贴到项目中并立即使用。
如果您对这些秘籍或建议的改进有任何疑问，请发表评论，我会尽力回答。
使用 Python 标准库加载 CSV
Python API 提供模块CSV和函数 reader（），可用于加载 CSV 文件。
加载后，将 CSV 数据转换为 NumPy 数组并将其用于机器学习。
例如，您可以将 Pima Indians 数据集下载到您的本地目录（更新：从这里下载）。所有字段都是数字，没有标题行。运行下面的秘籍将加载 CSV 文件并将其转换为 NumPy 数组。
# Load CSV (using python)
import csv
import numpy
filename = 'pima-indians-diabetes.data.csv'
raw_data = open(filename, 'rt')
reader = csv.reader(raw_data, delimiter=',', quoting=csv.QUOTE_NONE)
x = list(reader)
data = numpy.array(x).astype('float')
print(data.shape)
该示例加载一个对象，该对象可以遍历数据的每一行，并且可以轻松转换为 NumPy 数组。运行该示例将打印数组的形状。
(768, 9)
有关csv.reader()函数的更多信息，请参阅 Python API 文档中的 CSV 文件读取和写入。
使用 NumPy 加载 CSV 文件
您可以使用 NumPy 和numpy.loadtxt()功能加载 CSV 数据。
此函数假定没有标题行，并且所有数据都具有相同的格式。下面的示例假定文件 pima-indians-diabetes.data.csv 位于您当前的工作目录中。
# Load CSV
import numpy
filename = 'pima-indians-diabetes.data.csv'
raw_data = open(filename, 'rt')
data = numpy.loadtxt(raw_data, delimiter=",")
print(data.shape)
运行该示例将加载文件为 numpy.ndarray 并打印数据的形状：
(768, 9)
可以修改此示例以直接从 URL 加载相同的数据集，如下所示：
注意：此示例假设您使用的是 Python 3。
# Load CSV from URL using NumPy
from numpy import loadtxt
from urllib.request import urlopen
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv'
raw_data = urlopen(url)
dataset = loadtxt(raw_data, delimiter=",")
print(dataset.shape)
同样，运行该示例会产生相同的结果形状。
(768, 9)
有关 numpy.loadtxt（）函数的更多信息，请参阅 API 文档（numpy 版本 1.10）。
使用 Pandas 加载 CSV 文件
您可以使用 Pandas 和pandas.read_csv()功能加载 CSV 数据。
此功能非常灵活，可能是我推荐的加载机器学习数据的方法。该函数返回一个 pandas.DataFrame ，您可以立即开始汇总和绘图。
以下示例假定' pima-indians-diabetes.data.csv '文件位于当前工作目录中。
# Load CSV using Pandas
import pandas
filename = 'pima-indians-diabetes.data.csv'
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = pandas.read_csv(filename, names=names)
print(data.shape)
请注意，在此示例中，我们明确指定 DataFrame 的每个属性的名称。运行该示例显示数据的形状：
(768, 9)
我们还可以修改此示例以直接从 URL 加载 CSV 数据。
# Load CSV using Pandas from URL
import pandas
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
data = pandas.read_csv(url, names=names)
print(data.shape)
再次，运行该示例下载 CSV 文件，解析它并显示加载的 DataFrame 的形状。
(768, 9)
要了解有关 pandas.read_csv（）功能的更多信息，请参阅 API 文档。
摘要
在这篇文章中，您了解了如何使用 Python 加载机器学习数据。
您学习了三种可以使用的特定技术：
- 使用 Python 标准库加载 CSV。
- 使用 NumPy 加载 CSV 文件。
- 使用 Pandas 加载 CSV 文件。
此帖子的操作步骤是键入或复制并粘贴每个秘籍，并熟悉可以在 Python 中加载机器学习数据的不同方法。
您是否有任何关于在 Python 或此帖中加载机器学习数据的问题？在评论中提出您的问题，我会尽力回答。
用于评估机器学习算法的 LOOCV
最后更新于 2020 年 8 月 26 日
当机器学习算法用于对未用于训练模型的数据进行预测时，使用留一交叉验证或 LOOCV 程序来估计机器学习算法的表现。
这是一个计算成本很高的过程，尽管它会产生模型表现的可靠且无偏的估计。虽然使用起来很简单，也不需要指定配置，但是有时不应该使用该过程，例如当您有一个非常大的数据集或一个计算成本很高的模型要评估时。
在本教程中，您将发现如何使用省去交叉验证来评估机器学习模型。
完成本教程后，您将知道:
- 当您有一个小数据集，或者当模型表现的准确估计比方法的计算成本更重要时，省略交叉验证过程是合适的。
- 如何使用 Sklearn 机器学习库执行省去交叉验证程序。
- 如何使用留一交叉验证评估用于分类和回归的机器学习算法。
用我的新书Python 机器学习精通启动你的项目，包括分步教程和所有示例的 Python 源代码文件。
我们开始吧。
LOOCV 评价机器学习算法 图片由希瑟·哈维提供，版权所有。
教程概述
本教程分为三个部分；它们是:
- LOOCV 模型评价
- 科学工具包中的 LOOCV 程序-学习
- LOOCV 评估机器学习模型
- LOOCV 分类协会
- 回归的 LOOCV
LOOCV 模型评价
交叉验证，或 k 倍交叉验证，是在对模型训练期间未使用的数据进行预测时，用于估计机器学习算法表现的过程。
交叉验证有一个超参数“ k ”，它控制数据集被分割成的子集的数量。分割后，每个子集都有机会用作测试集，而所有其他子集一起用作训练数据集。
这意味着 k 折交叉验证涉及拟合和评估 k 模型。这反过来提供了模型在数据集上的表现的 k 个估计，可以使用汇总统计数据(如平均值和标准偏差)来报告。然后，该分数可用于比较并最终选择用作数据集的“最终模型”的模型和配置。
k 的典型值为 k=3、k=5 和 k=10，其中 10 代表最常见的值。这是因为，给定广泛的测试，与其他 k 值和单一训练测试分割相比，10 倍交叉验证在模型表现估计中提供了低计算成本和低偏差的良好平衡。
有关 k-fold 交叉验证的更多信息，请参见教程:
留一交叉验证，或 LOOCV，是 k 倍交叉验证的一种配置，其中 k 被设置为数据集中的示例数。
LOOCV 是 k 倍交叉验证的极端版本，计算成本最高。它要求为训练数据集中的每个示例创建和评估一个模型。
如此多的拟合和评估模型的好处是对模型表现的更可靠的估计，因为每一行数据都有机会表示整个测试数据集。
考虑到计算成本，LOOCV 不适合非常大的数据集，如超过数万或数十万个例子，也不适合拟合成本高的模型，如神经网络。
- 不要使用 LOOCV :大数据集或昂贵的模型来适应。
给定模型表现的改进估计，当模型表现的精确估计是关键时，LOOCV 是合适的。当数据集很小时，例如少于数千个示例时，这种情况尤其明显，这可能导致训练过程中的模型过拟合以及对模型表现的有偏差的估计。
此外，假设没有使用训练数据集的采样，这种估计过程是确定性的，不像训练测试分割和其他 k 倍交叉验证确认那样提供模型表现的随机估计。
- 使用 LOOCV :小数据集或当估计模型表现至关重要时。
一旦使用 LOOCV 评估了模型，并选择了最终模型和配置，最终模型就适合所有可用数据，并用于对新数据进行预测。
现在我们已经熟悉了 LOOCV 过程，让我们看看如何在 Python 中使用该方法。
科学工具包中的 LOOCV 程序-学习
scikit-leave Python 机器学习库通过 LeaveOneOut 类提供了 LOOCV 的实现。
该方法没有配置，因此，没有提供任何参数来创建类的实例。
...
# create loocv procedure
cv = LeaveOneOut()
创建后，可以调用 split() 函数并提供要枚举的数据集。
每次迭代将从提供的数据集中返回可用于训练和测试集的行索引。
...
for train_ix, test_ix in cv.split(X):
...
这些索引可用于数据集数组的输入( X )和输出( y )列，以分割数据集。
...
# split data
X_train, X_test = X[train_ix, :], X[test_ix, :]
y_train, y_test = y[train_ix], y[test_ix]
训练集可用于拟合模型，测试集可用于通过首先进行预测并根据预测值和期望值计算表现度量来评估模型。
...
# fit model
model = RandomForestClassifier(random_state=1)
model.fit(X_train, y_train)
# evaluate model
yhat = model.predict(X_test)
可以从每个评估中保存分数，并且可以呈现模型表现的最终平均估计。
我们可以将这些联系在一起，并演示如何使用 LOOCV 评估一个用于合成二进制分类数据集的 RandomForestClassifier 模型，该数据集是使用 make_blobs()函数创建的。
下面列出了完整的示例。
# loocv to manually evaluate the performance of a random forest classifier
from sklearn.datasets import make_blobs
from sklearn.model_selection import LeaveOneOut
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
# create dataset
X, y = make_blobs(n_samples=100, random_state=1)
# create loocv procedure
cv = LeaveOneOut()
# enumerate splits
y_true, y_pred = list(), list()
for train_ix, test_ix in cv.split(X):
# split data
X_train, X_test = X[train_ix, :], X[test_ix, :]
y_train, y_test = y[train_ix], y[test_ix]
# fit model
model = RandomForestClassifier(random_state=1)
model.fit(X_train, y_train)
# evaluate model
yhat = model.predict(X_test)
# store
y_true.append(y_test[0])
y_pred.append(yhat[0])
# calculate accuracy
acc = accuracy_score(y_true, y_pred)
print('Accuracy: %.3f' % acc)
手动运行该示例可以估计合成数据集上随机森林分类器的表现。
假设数据集有 100 个示例，这意味着创建了数据集的 100 个训练/测试拆分，数据集的每一行都有机会用作测试集。同样，创建并评估了 100 个模型。
然后报告所有预测的分类准确率，在这种情况下为 99%。
Accuracy: 0.990
手动枚举折叠的缺点是速度慢，并且包含大量可能引入错误的代码。
使用 LOOCV 评估模型的另一种方法是使用 cross_val_score()函数。
该函数通过“ cv ”参数获取模型、数据集和实例化的 LOOCV 对象集。然后返回准确度分数的样本，可通过计算平均值和标准偏差进行汇总。
我们还可以将“ n_jobs ”参数设置为-1 来使用所有的 CPU 内核，大大降低了拟合和评估这么多模型的计算成本。
下面的例子演示了在同一合成数据集上使用 LOOCV 使用 cross_val_score() 函数评估随机森林分类器。
# loocv to automatically evaluate the performance of a random forest classifier
from numpy import mean
from numpy import std
from sklearn.datasets import make_blobs
from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier
# create dataset
X, y = make_blobs(n_samples=100, random_state=1)
# create loocv procedure
cv = LeaveOneOut()
# create model
model = RandomForestClassifier(random_state=1)
# 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)))
运行该示例会自动估计合成数据集上随机森林分类器的表现。
所有折叠的平均分类精确率与我们之前的手动估计相匹配。
Accuracy: 0.990 (0.099)
现在我们已经熟悉了如何使用 LeaveOneOut 类，让我们看看如何使用它来评估真实数据集上的机器学习模型。
LOOCV 评估机器学习模型
在本节中，我们将探索使用 LOOCV 过程来评估标准分类和回归预测建模数据集上的机器学习模型。
LOOCV 分类协会
我们将演示如何使用 LOOCV 评估声纳数据集上的随机森林算法。
声纳数据集是一个标准的机器学习数据集，包括 208 行具有 60 个数字输入变量的数据和一个具有两个类值的目标变量，例如二进制分类。
该数据集包括预测声纳回波显示的是岩石还是模拟地雷。
不需要下载数据集；我们将自动下载它作为我们工作示例的一部分。
下面的示例下载数据集并总结其形状。
# summarize the sonar dataset
from pandas import read_csv
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
dataframe = read_csv(url, header=None)
# split into input and output elements
data = dataframe.values
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)
运行该示例会下载数据集，并将其拆分为输入和输出元素。不出所料，我们可以看到有 208 行数据，60 个输入变量。
(208, 60) (208,)
我们现在可以用 LOOCV 来评估一个模型。
首先，加载的数据集必须分成输入和输出组件。
...
# split into inputs and outputs
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)
接下来，我们定义 LOOCV 程序。
...
# create loocv procedure
cv = LeaveOneOut()
然后我们可以定义要评估的模型。
...
# create model
model = RandomForestClassifier(random_state=1)
然后使用 cross_val_score() 函数枚举褶皱，拟合模型，然后进行预测和评估。然后，我们可以报告模型表现的平均值和标准偏差。
...
# 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)))
将这些联系在一起，完整的示例如下所示。
# loocv evaluate random forest on the sonar dataset
from numpy import mean
from numpy import std
from pandas import read_csv
from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# split into inputs and outputs
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)
# create loocv procedure
cv = LeaveOneOut()
# create model
model = RandomForestClassifier(random_state=1)
# 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)))
运行该示例首先加载数据集，并确认输入和输出元素中的行数。
注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
然后使用 LOOCV 对模型进行评估，当对新数据进行预测时，估计的表现具有大约 82.2%的准确性。
(208, 60) (208,)
Accuracy: 0.822 (0.382)
回归的 LOOCV
我们将演示如何使用 LOOCV 评估住房数据集上的随机森林算法。
外壳数据集是一个标准的机器学习数据集，包括 506 行数据，有 13 个数字输入变量和一个数字目标变量。
该数据集包括预测美国波士顿郊区的房价。
不需要下载数据集；我们将自动下载它作为我们工作示例的一部分。
以下示例将数据集下载并加载为熊猫数据框，并总结了数据集的形状。
# load and summarize the housing dataset
from pandas import read_csv
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
# summarize shape
print(dataframe.shape)
运行该示例确认了 506 行数据、13 个输入变量和单个数值目标变量(总共 14 个)。
(506, 14)
我们现在可以用 LOOCV 来评估一个模型。
首先，加载的数据集必须分成输入和输出组件。
...
# split into inputs and outputs
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)
接下来，我们定义 LOOCV 程序。
...
# create loocv procedure
cv = LeaveOneOut()
然后我们可以定义要评估的模型。
...
# create model
model = RandomForestRegressor(random_state=1)
然后使用 cross_val_score() 函数枚举褶皱，拟合模型，然后进行预测和评估。然后，我们可以报告模型表现的平均值和标准偏差。
在这种情况下，我们使用适用于回归的平均绝对误差(MAE)表现指标。
...
# evaluate model
scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# force positive
scores = absolute(scores)
# report performance
print('MAE: %.3f (%.3f)' % (mean(scores), std(scores)))
将这些联系在一起，完整的示例如下所示。
# loocv evaluate random forest on the housing dataset
from numpy import mean
from numpy import std
from numpy import absolute
from pandas import read_csv
from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestRegressor
# load dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv'
dataframe = read_csv(url, header=None)
data = dataframe.values
# split into inputs and outputs
X, y = data[:, :-1], data[:, -1]
print(X.shape, y.shape)
# create loocv procedure
cv = LeaveOneOut()
# create model
model = RandomForestRegressor(random_state=1)
# evaluate model
scores = cross_val_score(model, X, y, scoring='neg_mean_absolute_error', cv=cv, n_jobs=-1)
# force positive
scores = absolute(scores)
# report performance
print('MAE: %.3f (%.3f)' % (mean(scores), std(scores)))
运行该示例首先加载数据集，并确认输入和输出元素中的行数。
注:考虑到算法或评估程序的随机性，或数值精确率的差异，您的结果可能会有所不同。考虑运行该示例几次，并比较平均结果。
该模型使用 LOOCV 进行评估，在对新数据进行预测时，该模型的表现平均绝对误差约为 2.180(千美元)。
(506, 13) (506,)
MAE: 2.180 (2.346)
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
教程
蜜蜂
- 交叉验证:评估评估者绩效，Sklearn 。
- sklearn.model_selection。离开应用编程接口。
- sklearn . model _ selection . cross _ val _ score API。
摘要
在本教程中，您发现了如何使用省去交叉验证来评估机器学习模型。
具体来说，您了解到:
- 当您有一个小数据集，或者当模型表现的准确估计比方法的计算成本更重要时，省略交叉验证过程是合适的。
- 如何使用 Sklearn 机器学习库执行省去交叉验证程序。
- 如何使用留一交叉验证评估用于分类和回归的机器学习算法。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
您在 Python 中的第一个逐步的机器学习项目
原文：
machinelearningmastery.com/machine-learning-in-python-step-by-step/
你想用 Python 做机器学习，但是你开始时遇到了麻烦吗？
在这篇文章中，您将使用 Python 完成您的第一个机器学习项目。
在本分步教程中，您将：
- 下载并安装 Python SciPy 并获得最有用的 Python 机器学习包。
- 加载数据集并使用统计摘要和数据可视化了解其结构。
- 创建 6 个机器学习模型，挑选最佳并建立准确率可靠的信心。
如果您是一名机器学习初学者，并希望最终开始使用 Python，那么本教程就是为您设计的。
让我们开始吧！
- 2017 年 1 月更新：已更新，以反映版本 0.18 中 scikit-learn API 的更改。
- 2017 年 3 月更新：添加了帮助设置 Python 环境的链接。
- Update Apr / 2018 ：添加了一些有关随机性和预测的有用链接。
- Update Sep / 2018 ：由于 UCI 变得不可靠，添加了我自己托管的数据集版本的链接。
- 2002 年 2 月更新：更新以解决使用 SVM 和 逻辑回归的 sklearn API 版本 0.20+的警告，还更新了结果和图表。
您在 Python 中的第一个机器学习项目循序渐进 照片由 cosmoflash ，保留一些权利。
如何在 Python 中启动机器学习？
学习机器学习的最好方法是设计和完成小项目。
入门时 Python 可能会令人生畏
Python 是一种流行且强大的解释语言。与 R 不同，Python 是一种完整的语言和平台，可用于研究和开发以及开发生产系统。
还有许多模块和库可供选择，提供了多种方法来完成每项任务。它可以感到压倒性的。
开始使用 Python 进行机器学习的最佳方法是完成一个项目。
- 它将强制您安装并启动 Python 解释器（至少）。
- 它将为您提供如何逐步完成小项目的鸟瞰图。
- 它会给你信心，也许会继续你自己的小项目。
初学者需要一个小型的端到端项目
书籍和课程令人沮丧。它们为您提供了大量的秘籍和片段，但您永远不会看到它们如何组合在一起。
当您将机器学习应用于您自己的数据集时，您正在处理一个项目。
机器学习项目可能不是线性的，但它有许多众所周知的步骤：
- 定义问题。
- 准备数据。
- 评估算法。
- 改善结果。
- 目前的结果。
真正与新平台或工具达成协议的最佳方式是端到端地完成机器学习项目并涵盖关键步骤。即，从加载数据，汇总数据，评估算法和做出一些预测。
如果可以这样做，则可以使用可在数据集之后的数据集上使用的模板。一旦您更有信心，您可以填写差距，例如进一步的数据准备和改进结果任务。
你好机器学习世界
开始使用新工具的最佳小项目是虹膜花的分类（例如虹膜数据集）。
这是一个很好的项目，因为它非常了解。
- 属性是数字，因此您必须弄清楚如何加载和处理数据。
- 这是一个分类问题，允许您练习一种更简单的监督学习算法。
- 这是一个多类别的分类问题（多名义），可能需要一些专门的处理。
- 它只有 4 个属性和 150 行，这意味着它很小，很容易适合内存（和屏幕或 A4 页面）。
- 所有数字属性都具有相同的单位和相同的比例，不需要任何特殊的缩放或变换即可开始。
让我们开始使用 Python 的 hello world 机器学习项目。
Python 中的机器学习：循序渐进教程
（从这里开始）
在本节中，我们将通过端到端的小型机器学习项目进行工作。
以下是我们将要介绍的内容概述：
- 安装 Python 和 SciPy 平台。
- 加载数据集。
- 总结数据集。
- 可视化数据集。
- 评估一些算法。
- 做一些预测。
慢慢来。完成每个步骤。
尝试自己输入命令或复制并粘贴命令以加快速度。
如果您有任何疑问，请在帖子底部留言。
1.下载，安装和启动 Python SciPy
如果尚未安装，请在您的系统上安装 Python 和 SciPy 平台。
我不想详细介绍这个，因为其他人已经有了。这已经非常简单，特别是如果您是开发人员。如果您确实需要帮助，请在评论中提问。
1.1 安装 SciPy 库
本教程假定 Python 版本为 2.7 或 3.5+。
您需要安装 5 个密钥库。下面是本教程所需的 Python SciPy 库列表：
- SciPy 的
- numpy 的
- matplotlib
- 大熊猫
- sklearn
有许多方法可以安装这些库。我最好的建议是选择一种方法，然后在安装每个库时保持一致。
scipy 安装页面提供了在多个不同平台上安装上述库的优秀说明，例如 Linux，mac OS X 和 Windows。如果您有任何疑问或疑问，请参阅本指南，数千人已经关注。
- 在 Mac OS X 上，您可以使用 macport 来安装 Python 2.7 和这些库。有关 macports 的更多信息，请参阅主页。
- 在 Linux 上，您可以使用您的包管理器，例如 Fedora 上的 yum 来安装 RPM。
如果你在 Windows 上或者你没有信心，我会建议你安装免费版的 Anaconda ，其中包括你需要的一切。
注意：本教程假设您安装了 scikit-learn 版本 0.18 或更高版本。
需要更多帮助？请参阅以下教程之一：
- 如何使用 Anaconda 设置用于机器学习和深度学习的 Python 环境
- 如何使用 Python 3 为机器学习开发创建 Linux 虚拟机
1.2 启动 Python 并检查版本
确保您的 Python 环境已成功安装并按预期工作是一个好主意。
下面的脚本将帮助您测试您的环境。它导入本教程中所需的每个库并打印该版本。
打开命令行并启动 python 解释器：
python
我建议直接在解释器中工作或编写脚本并在命令行上运行它们，而不是大编辑器和 IDE。保持简单，专注于机器学习而不是工具链。
键入或复制并粘贴以下脚本：
# Check the versions of libraries
# Python version
import sys
print('Python: {}'.format(sys.version))
# scipy
import scipy
print('scipy: {}'.format(scipy.__version__))
# numpy
import numpy
print('numpy: {}'.format(numpy.__version__))
# matplotlib
import matplotlib
print('matplotlib: {}'.format(matplotlib.__version__))
# pandas
import pandas
print('pandas: {}'.format(pandas.__version__))
# scikit-learn
import sklearn
print('sklearn: {}'.format(sklearn.__version__))
这是我在 OS X 工作站上获得的输出：
Python: 3.6.8 (default, Dec 30 2018, 13:01:55)
[GCC 4.2.1 Compatible Apple LLVM 9.1.0 (clang-902.0.39.2)]
scipy: 1.1.0
numpy: 1.15.4
matplotlib: 3.0.2
pandas: 0.23.4
sklearn: 0.20.2
将上述输出与您的版本进行比较。
理想情况下，您的版本应该匹配或更新。 API 不会快速更改，因此如果您只是背后的几个版本，请不要太担心，本教程中的所有内容很可能仍适用于您。
如果您收到错误，请停止。现在是时候解决它了。
如果您无法干净地运行上述脚本，则无法完成本教程。
我最好的建议是谷歌搜索你的错误信息或在 Stack Exchange 上发帖提问。
2.加载数据
我们将使用虹膜花数据集。这个数据集很有名，因为它几乎被所有人用作机器学习和统计中的“hello world”数据集。
该数据集包含 150 个鸢尾花的观察结果。以厘米为单位的花有四列测量值。第五列是观察到的花的种类。所有观察到的花属于三种物种之一。
您可以在维基百科上了解有关此数据集的更多信息。
在此步骤中，我们将从 CSV 文件 URL 加载虹膜数据。
2.1 导入库
首先，让我们导入我们将在本教程中使用的所有模块，函数和对象。
# Load libraries
import pandas
from pandas.plotting import scatter_matrix
import matplotlib.pyplot as plt
from sklearn import model_selection
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
一切都应该加载没有错误。如果您有错误，请停止。在继续之前，您需要一个有效的 SciPy 环境。请参阅上面有关设置环境的建议。
2.2 加载数据集
我们可以直接从 UCI 机器学习库加载数据。
我们正在使用 pandas 来加载数据。我们还将使用 pandas 来探索数据，包括描述性统计和数据可视化。
请注意，我们在加载数据时指定每列的名称。这将有助于我们以后探索数据。
# Load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv"
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
dataset = pandas.read_csv(url, names=names)
数据集应该加载而不会发生意外。
如果确实存在网络问题，可以将 iris.csv 文件下载到工作目录中，并使用相同的方法加载它，将 URL 更改为本地文件名。
3.总结数据集
现在是时候看看数据了。
在这一步中，我们将以几种不同的方式来看看数据：
- 数据集的维度。
- 窥视数据本身。
- 所有属性的统计摘要。
- 按类变量细分数据。
别担心，每次查看数据都是一个命令。这些是有用的命令，您可以在将来的项目中反复使用这些命令。
3.1 数据集的维度
我们可以快速了解数据包含多少个实例（行）和多少属性（列）以及 shape 属性。
# shape
print(dataset.shape)
您应该看到 150 个实例和 5 个属性：
(150, 5)
3.2 查看数据
实际观察您的数据也是一个好主意。
# head
print(dataset.head(20))
您应该看到数据的前 20 行：
sepal-length sepal-width petal-length petal-width class
0 5.1 3.5 1.4 0.2 Iris-setosa
1 4.9 3.0 1.4 0.2 Iris-setosa
2 4.7 3.2 1.3 0.2 Iris-setosa
3 4.6 3.1 1.5 0.2 Iris-setosa
4 5.0 3.6 1.4 0.2 Iris-setosa
5 5.4 3.9 1.7 0.4 Iris-setosa
6 4.6 3.4 1.4 0.3 Iris-setosa
7 5.0 3.4 1.5 0.2 Iris-setosa
8 4.4 2.9 1.4 0.2 Iris-setosa
9 4.9 3.1 1.5 0.1 Iris-setosa
10 5.4 3.7 1.5 0.2 Iris-setosa
11 4.8 3.4 1.6 0.2 Iris-setosa
12 4.8 3.0 1.4 0.1 Iris-setosa
13 4.3 3.0 1.1 0.1 Iris-setosa
14 5.8 4.0 1.2 0.2 Iris-setosa
15 5.7 4.4 1.5 0.4 Iris-setosa
16 5.4 3.9 1.3 0.4 Iris-setosa
17 5.1 3.5 1.4 0.3 Iris-setosa
18 5.7 3.8 1.7 0.3 Iris-setosa
19 5.1 3.8 1.5 0.3 Iris-setosa
3.3 统计摘要
现在我们可以看一下每个属性的摘要。
这包括计数，平均值，最小值和最大值以及一些百分位数。
# descriptions
print(dataset.describe())
我们可以看到所有数值都具有相同的比例（厘米）和 0 到 8 厘米之间的相似范围。
sepal-length sepal-width petal-length petal-width
count 150.000000 150.000000 150.000000 150.000000
mean 5.843333 3.054000 3.758667 1.198667
std 0.828066 0.433594 1.764420 0.763161
min 4.300000 2.000000 1.000000 0.100000
25% 5.100000 2.800000 1.600000 0.300000
50% 5.800000 3.000000 4.350000 1.300000
75% 6.400000 3.300000 5.100000 1.800000
max 7.900000 4.400000 6.900000 2.500000
3.4 类分布
现在让我们看一下属于每个类的实例（行）数。我们可以将其视为绝对计数。
# class distribution
print(dataset.groupby('class').size())
我们可以看到每个类具有相同数量的实例（数据集的 50％或 33％）。
class
Iris-setosa 50
Iris-versicolor 50
Iris-virginica 50
4.数据可视化
我们现在对数据有一个基本的想法。我们需要通过一些可视化来扩展它。
我们将看两种类型的图：
- 单变量图可以更好地理解每个属性。
- 多变量图可以更好地理解属性之间的关系。
4.1 单变量图
我们从一些单变量图开始，即每个变量的图。
鉴于输入变量是数字，我们可以创建每个的框和晶须图。
# box and whisker plots
dataset.plot(kind='box', subplots=True, layout=(2,2), sharex=False, sharey=False)
plt.show()
这使我们更清楚地了解输入属性的分布：
鸢尾花数据集的每个输入变量的框和晶须图
我们还可以创建每个输入变量的直方图，以了解分布。
# histograms
dataset.hist()
plt.show()
看起来可能有两个输入变量具有高斯分布。这很有用，因为我们可以使用可以利用这个假设的算法。
鸢尾花数据集的每个输入变量的直方图
4.2 多变量图
现在我们可以看看变量之间的相互作用。
首先，让我们看一下所有属性对的散点图。这有助于发现输入变量之间的结构化关系。
# scatter plot matrix
scatter_matrix(dataset)
plt.show()
注意一些属性对的对角分组。这表明高度相关性和可预测的关系。
鸢尾花数据集的每个输入变量的散点图矩阵
5.评估一些算法
现在是时候创建一些数据模型并估计它们对看不见的数据的准确率。
以下是我们将在此步骤中介绍的内容：
- 分离出验证数据集。
- 设置测试工具以使用 10 倍交叉验证。
- 建立 5 种不同的模型来预测花卉测量的物种
- 选择最佳型号。
5.1 创建验证数据集
我们需要知道我们创建的模型是好的。
稍后，我们将使用统计方法来估计我们在看不见的数据上创建的模型的准确率。我们还希望通过对实际看不见的数据进行评估，对未见数据的最佳模型的准确率进行更具体的估计。
也就是说，我们将阻止算法无法看到的一些数据，我们将使用这些数据来获得关于最佳模型实际精确度的第二个独立概念。
我们将加载的数据集分成两部分，其中 80％将用于训练我们的模型，20％我们将作为验证数据集。
# Split-out validation dataset
array = dataset.values
X = array[:,0:4]
Y = array[:,4]
validation_size = 0.20
seed = 7
X_train, X_validation, Y_train, Y_validation = model_selection.train_test_split(X, Y, test_size=validation_size, random_state=seed)
您现在在X_train和Y_train中有训练数据用于准备模型，X_validation和Y_validation设置我们以后可以使用。
请注意，我们使用 python 切片来选择 NumPy 数组中的列。如果这对您来说是新手，您可能需要查看此帖子：
5.2 测试线束
我们将使用 10 倍交叉验证来估计准确率。
这会将我们的数据集分成 10 个部分，在 9 上训练并在 1 上进行测试，并重复训练测试分割的所有组合。
# Test options and evaluation metric
seed = 7
scoring = 'accuracy'
具体随机种子无关紧要，请在此处了解有关伪随机数生成器的更多信息：
我们使用'_ 准确度 _'的度量来评估模型。这是正确预测的实例数除以数据集中实例总数乘以 100 得到百分比（例如 95％准确）的比率。我们将在运行构建时使用 _ 评分 _ 变量，然后评估每个模型。
5.3 构建模型
我们不知道哪个算法可以解决此问题或使用哪些配置。我们从图中得出一个概念，即某些类在某些维度上可以部分线性分离，因此我们期望得到普遍良好的结果。
让我们评估 6 种不同的算法：
- 逻辑回归（LR）
- 线性判别分析（LDA）
- K 最近邻（KNN）。
- 分类和回归树（CART）。
- 高斯朴素贝叶斯（NB）。
- 支持向量机（SVM）。
这是简单线性（LR 和 LDA），非线性（KNN，CART，NB 和 SVM）算法的良好混合。我们在每次运行之前重置随机数种子，以确保使用完全相同的数据分割执行每个算法的评估。它确保结果可直接比较。
让我们构建和评估我们的模型：
# Spot Check Algorithms
models = []
models.append(('LR', LogisticRegression(solver='liblinear', multi_class='ovr')))
models.append(('LDA', LinearDiscriminantAnalysis()))
models.append(('KNN', KNeighborsClassifier()))
models.append(('CART', DecisionTreeClassifier()))
models.append(('NB', GaussianNB()))
models.append(('SVM', SVC(gamma='auto')))
# evaluate each model in turn
results = []
names = []
for name, model in models:
kfold = model_selection.KFold(n_splits=10, random_state=seed)
cv_results = model_selection.cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)
results.append(cv_results)
names.append(name)
msg = "%s: %f (%f)" % (name, cv_results.mean(), cv_results.std())
print(msg)
5.4 选择最佳模型
我们现在有 6 个模型和精度估计。我们需要将模型相互比较并选择最准确的模型。
运行上面的示例，我们得到以下原始结果：
LR: 0.966667 (0.040825)
LDA: 0.975000 (0.038188)
KNN: 0.983333 (0.033333)
CART: 0.975000 (0.038188)
NB: 0.975000 (0.053359)
SVM: 0.991667 (0.025000)
请注意，您的结果可能会有所不同。有关详细信息，请参阅帖子：
在这种情况下，我们可以看到支持向量机（SVM）看起来具有最大的估计准确度分数。
我们还可以创建模型评估结果的图表，并比较每个模型的传播和平均准确度。每种算法都有一组精确度测量值，因为每种算法都被评估了 10 次（10 次交叉验证）。
# Compare Algorithms
fig = plt.figure()
fig.suptitle('Algorithm Comparison')
ax = fig.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(names)
plt.show()
您可以看到盒子和须状图在该范围的顶部被压扁，许多样品达到 100％的准确度。
鸢尾花数据集上的盒子和晶须图比较机器学习算法
6.做出预测
KNN 算法非常简单，是基于我们测试的精确模型。现在我们想要了解模型在验证集上的准确率。
这将使我们对最佳模型的准确率进行独立的最终检查。保留验证集非常有用，以防您在训练过程中出现问题，例如过拟合训练集或数据泄漏。两者都会导致过于乐观的结果。
我们可以直接在验证集上运行 KNN 模型，并将结果汇总为最终准确度分数，混淆矩阵和分类报告。
# Make predictions on validation dataset
knn = KNeighborsClassifier()
knn.fit(X_train, Y_train)
predictions = knn.predict(X_validation)
print(accuracy_score(Y_validation, predictions))
print(confusion_matrix(Y_validation, predictions))
print(classification_report(Y_validation, predictions))
我们可以看到精度为 0.9 或 90％。混淆矩阵提供了三个错误的指示。最后，分类报告按精度，召回，f1 分数和支持显示每个类别的细分，显示出优异的结果（授予验证数据集很小）。
0.9
[[ 7 0 0]
[ 0 11 1]
[ 0 2 9]]
precision recall f1-score support
Iris-setosa 1.00 1.00 1.00 7
Iris-versicolor 0.85 0.92 0.88 12
Iris-virginica 0.90 0.82 0.86 11
micro avg 0.90 0.90 0.90 30
macro avg 0.92 0.91 0.91 30
weighted avg 0.90 0.90 0.90 30
您可以在此处了解有关如何做出预测和预测概率的更多信息：
- 如何用 scikit-learn 做出预测
你可以用 Python 做机器学习
完成上面的教程。最多需要 5 到 10 分钟！
你不需要了解一切。 （至少现在不是）您的目标是端到端地完成教程并获得结果。您无需了解第一遍的所有内容。随时记下您的问题。在 Python 中大量使用 _ 帮助（“FunctionName”）_ 帮助语法来了解您正在使用的所有函数。
你不需要知道算法如何工作。了解限制以及如何配置机器学习算法非常重要。但是学习算法可以在以后学习。您需要在很长一段时间内慢慢构建此算法知识。今天，首先要熟悉平台。
你不需要成为 Python 程序员。如果您是新手，Python 语言的语法可以很直观。与其他语言一样，重点关注函数调用（例如 _ 函数（）_）和赋值（例如 a =“b”）。这将帮助您完成大部分工作。您是一名开发人员，您知道如何快速掌握语言的基础知识。刚开始并稍后深入了解细节。
您不需要成为机器学习专家。您可以稍后了解各种算法的优点和局限性，有很多帖子可供您稍后阅读，以了解机器学习项目的步骤以及使用交叉验证评估准确率的重要性。
机器学习项目中的其他步骤怎么样？我们没有涵盖机器学习项目中的所有步骤，因为这是您的第一个项目，我们需要关注关键步骤。即，加载数据，查看数据，评估一些算法并做出一些预测。在后面的教程中，我们可以查看其他数据准备和结果改进任务。
摘要
在这篇文章中，您逐步了解了如何使用 Python 完成第一个机器学习项目。
您发现完成一个小型端到端项目从加载数据到做出预测是熟悉新平台的最佳方式。
你的下一步
你是否完成了本教程？
- 完成上面的教程。
- 列出您的任何问题。
- 搜索或研究答案。
- 请记住，您可以使用 Python 中的 _ 帮助（“FunctionName”）_ 来获取任何函数的帮助。
你有问题吗？ 在下面的评论中发布。
机器学习建模管道的温和介绍
应用机器学习通常专注于寻找在给定数据集上表现良好或最好的单一模型。
模型的有效使用将需要输入数据的适当准备和模型的超参数调整。
准备数据、调整模型和转换预测所需的线性步骤序列统称为建模管道。像 Sklearn Python 库这样的现代机器学习库允许正确(没有数据泄漏)和一致地(在评估和预测期间)定义和使用这一系列步骤。
然而，使用建模管道可能会让初学者感到困惑，因为这需要改变应用机器学习过程的视角。
在本教程中，您将发现应用机器学习的建模管道。
完成本教程后，您将知道:
- 应用机器学习关注的不仅仅是找到一个表现良好的模型；它还需要找到适当的数据准备步骤和预测后处理步骤的顺序。
- 总的来说，解决预测建模问题所需的操作可以被视为称为建模管道的原子单元。
- 从建模管道的角度来探讨应用机器学习需要从评估特定模型配置到转换和算法序列的思维转变。
我们开始吧。
机器学习建模管道简介 图片由黄杰提供，版权所有。
教程概述
本教程分为三个部分；它们是:
- 找到一个熟练的模型是不够的
- 什么是建模管道？
- 建模管道的含义
找到一个熟练的模型是不够的
应用机器学习是发现对给定预测建模数据集表现最佳的模型的过程。
其实不止这些。
除了发现哪个模型在数据集上表现最好之外，您还必须发现:
- 数据转换最好地将问题的未知底层结构暴露给学习算法。
- 模型超参数，产生所选模型的良好或最佳配置。
还可能有额外的考虑，例如转换模型所做预测的技术，如阈值移动或预测概率的模型校准。
因此，通常认为应用机器学习是一个跨数据转换、模型和模型配置的大型组合搜索问题。
这在实践中可能非常具有挑战性，因为它要求一个或多个数据准备方案、模型、模型配置和任何预测转换方案的顺序必须在给定的测试工具上一致且正确地评估。
虽然有些棘手，但通过简单的训练测试分割就可以处理，但是当使用 k 倍交叉验证甚至重复 k 倍交叉验证时，就变得相当难以处理了。
解决方案是使用建模管道来保持一切正常。
什么是建模管道？
管道是数据准备选项、建模操作和预测转换操作的线性序列。
它允许指定、评估步骤序列，并将其用作原子单位。
- 流水线:数据准备和建模步骤的线性序列，可以被视为一个原子单元。
为了阐明这个想法，让我们看两个简单的例子:
第一个示例使用输入变量的数据标准化，并符合逻辑回归模型:
- [输入]、[标准化]、[逻辑回归]、[预测]
第二个示例标准化输入变量，应用 RFE 特征选择，并拟合支持向量机。
- [输入]，[标准化]，[RFE]，[SVM]，[预测]
你可以想象其他建模管道的例子。
作为一个原子单元，可以使用首选的重采样方案来评估流水线，例如训练测试分割或 k 倍交叉验证。
这很重要，主要有两个原因:
- 避免数据泄露。
- 一致性和再现性。
建模管道避免了最常见类型的数据泄漏，在这种情况下，数据准备技术(如缩放输入值)应用于整个数据集。这是数据泄漏，因为它与训练数据集共享测试数据集的知识(例如有助于平均或最大已知值的观测值)，这反过来可能导致过于乐观的模型表现。
相反，数据转换必须仅在训练数据集上准备，然后应用于训练数据集、测试数据集、验证数据集以及在与模型一起使用之前需要转换的任何其他数据集。
建模管道确保执行的数据准备操作序列是可再现的。
如果没有建模管道，数据准备步骤可以手动执行两次:一次用于评估模型，一次用于进行预测。在这两种情况下，对序列的任何更改都必须保持一致，否则差异将影响模型的能力和技能。
管道确保操作顺序只定义一次，并在用于模型评估或进行预测时保持一致。
Python Sklearn 机器学习库通过 Pipeline 类提供机器学习建模管道。
您可以在本教程中了解有关如何使用此管道应用编程接口的更多信息:
建模管道的含义
建模管道是机器学习实践者的重要工具。
然而，在使用它们时，必须考虑一些重要的影响。
初学者在使用管道时的主要困惑在于理解管道学到了什么或者管道发现了什么具体的配置。
例如，管道可以使用自动配置自身的数据转换，例如用于特征选择的 RFECV 技术。
- 当评估使用自动配置的数据转换的管道时，它选择什么配置？或者当安装这条管道作为进行预测的最终模型时，它选择了什么配置？
答案是，没关系。
另一个例子是使用超参数调整作为管道的最后一步。
网格搜索将对管线中任何先前变换步骤提供的数据执行，然后将使用该数据搜索模型的最佳超参数组合，然后用数据上的那些超参数拟合模型。
- 当评估网格搜索模型超参数的管道时，它选择什么配置？或者当安装这条管道作为进行预测的最终模型时，它选择了什么配置？
答案又是，没关系。
答案适用于在管道末端使用阈值移动或概率校准步骤的情况。
原因与我们不关心所选模型的具体内部结构或系数的原因相同。
例如，在评估逻辑回归模型时，我们不需要为了选择模型而检查每一轮 k 倍交叉验证中选择的系数。相反，我们专注于它不寻常的预测技巧
同样，当使用逻辑回归模型作为对新数据进行预测的最终模型时，在进行预测之前，我们不需要检查在整个数据集上拟合模型时选择的系数。
我们可以检查和发现模型用作分析练习的系数，但这不会影响模型的选择和使用。
当考虑建模管道时，同样的答案也适用。
我们不关心管道中的数据转换会自动选择哪些功能。当使用网格搜索作为建模管道的最后一步时，我们也不关心为模型选择了哪些超参数。
在所有三种情况下:单一模型、具有自动特征选择的管道和具有网格搜索的管道，我们正在评估作为原子单元的“模型或“建模管道”。
管道允许我们作为机器学习实践者提升一个抽象层次，不太关心算法的具体结果，而更关心一系列过程的能力。
因此，我们可以专注于评估算法在数据集上的能力，而不是算法的产品，即模型。一旦我们有了对管道的估计，我们就可以应用它，并相信我们将获得类似的平均表现。
这是思维的转变，可能需要一些时间来适应。
也是现代 AutoML(自动机器学习)技术背后的哲学，将应用机器学习视为一个大的组合搜索问题。
进一步阅读
如果您想更深入地了解这个主题，本节将提供更多资源。
摘要
在本教程中，您发现了应用机器学习的建模管道。
具体来说，您了解到:
- 应用机器学习关注的不仅仅是找到一个表现良好的模型；它还需要找到适当的数据准备步骤和预测后处理步骤的顺序。
- 总的来说，解决预测建模问题所需的操作可以被视为称为建模管道的原子单元。
- 从建模管道的角度来探讨应用机器学习需要从评估特定模型配置到转换和算法序列的思维转变。
你有什么问题吗？ 在下面的评论中提问，我会尽力回答。
如何使用 scikit-learn 做出预测
原文：
machinelearningmastery.com/make-predictions-scikit-learn/
如何使用 Python 中的 scikit-learn 模型预测分类或回归结果
。
一旦您在 scikit-learn 中选择并适合最终的机器学习模型，您就可以使用它来对新数据实例做出预测。
初学者对如何做到这一点有一些困惑。我经常看到以下问题：
如何在 scikit-learn 中使用我的模型做出预测？
在本教程中，您将了解如何使用 scikit-learn Python 库中的最终机器学习模型进行分类和回归预测。
完成本教程后，您将了解：
- 如何最终确定模型以便为预测做好准备。
- 如何在 scikit-learn 中进行类和概率预测。
- 如何在 scikit-learn 中进行回归预测。
让我们开始吧。
机器学习中向量规范的温和介绍 Cosimo 的照片，保留一些权利。
教程概述
本教程分为 3 个部分;他们是：
- 首先完成您的模型
- 如何用分类模型预测
- 如何用回归模型预测
1.首先完成您的模型
在做出预测之前，必须训练最终模型。
您可能使用 k 折交叉验证或训练/测试分割数据来训练模型。这样做是为了让您估计模型对样本外数据的技能，例如：新数据。
这些模型已达到目的，现在可以丢弃。
您现在必须在所有可用数据上训练最终模型。
您可以在此处了解有关如何训练最终模型的更多信息：
2.如何用分类模型预测
分类问题是模型学习输入要素和作为标签的输出要素之间的映射的问题，例如“_ 垃圾邮件 ”和“ 不是垃圾邮件 _”。
下面是针对简单二分类问题的最终 LogisticRegression 模型的示例代码。
虽然我们在本教程中使用LogisticRegression，但在 scikit-learn 中几乎所有的分类算法都可以使用相同的函数。
# example of training a final classification model
from sklearn.linear_model import LogisticRegression
from sklearn.datasets.samples_generator import make_blobs
# generate 2d classification dataset
X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
# fit final model
model = LogisticRegression()
model.fit(X, y)
完成模型后，您可能希望将模型保存到文件，例如通过泡菜。保存后，您可以随时加载模型并使用它做出预测。有关此示例，请参阅帖子：
- 用 scikit-learn 在 Python 中保存和加载机器学习模型
为简单起见，我们将跳过本教程中的示例。
我们可能希望使用最终模型进行两种类型的分类预测;它们是阶级预测和概率预测。
阶级预测
类预测是：给定最终模型和一个或多个数据实例，预测数据实例的类。
我们不知道新数据的结果类。这就是我们首先需要模型的原因。
我们可以使用predict()函数在 scikit-learn 中使用我们最终的分类模型来预测新数据实例的类。
例如，我们在名为Xnew的数组中有一个或多个数据实例。这可以传递给我们模型上的predict()函数，以预测数组中每个实例的类值。
Xnew = [[...], [...]]
ynew = model.predict(Xnew)
多类预测
让我们通过一次预测多个数据实例的示例来具体化。
# example of training a final classification model
from sklearn.linear_model import LogisticRegression
from sklearn.datasets.samples_generator import make_blobs
# generate 2d classification dataset
X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
# fit final model
model = LogisticRegression()
model.fit(X, y)
# new instances where we do not know the answer
Xnew, _ = make_blobs(n_samples=3, centers=2, n_features=2, random_state=1)
# make a prediction
ynew = model.predict(Xnew)
# show the inputs and predicted outputs
for i in range(len(Xnew)):
print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))
运行该示例预测三个新数据实例的类，然后将数据和预测一起打印。
X=[-0.79415228 2.10495117], Predicted=0
X=[-8.25290074 -4.71455545], Predicted=1
X=[-2.18773166 3.33352125], Predicted=0
单一类预测
如果您只有一个新数据实例，则可以将此数据包装为predict()函数;例如：
# example of making a single class prediction
from sklearn.linear_model import LogisticRegression
from sklearn.datasets.samples_generator import make_blobs
# generate 2d classification dataset
X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
# fit final model
model = LogisticRegression()
model.fit(X, y)
# define one new instance
Xnew = [[-0.79415228, 2.10495117]]
# make a prediction
ynew = model.predict(Xnew)
print("X=%s, Predicted=%s" % (Xnew[0], ynew[0]))
运行该示例将打印单个实例和预测类。
X=[-0.79415228, 2.10495117], Predicted=0
关于类标签的注释
准备好数据后，您将把域中的类值（例如字符串）映射到整数值。您可能使用过 LabelEncoder 。
此LabelEncoder可用于通过inverse_transform()函数将整数转换回字符串值。
因此，您可能希望在拟合最终模型时保存（pickle）用于编码 y 值的LabelEncoder。
概率预测
您可能希望进行的另一种类型的预测是数据实例属于每个类的概率。
这被称为概率预测，其中给定新实例，模型将每个结果类的概率返回为 0 和 1 之间的值。
您可以通过调用predict_proba()函数在 scikit-learn 中进行这些类型的预测，例如：
Xnew = [[...], [...]]
ynew = model.predict_proba(Xnew)
此功能仅适用于能够进行概率预测的分类模型，这是大多数但不是所有模型。
以下示例对数据实例的Xnew数组中的每个示例进行概率预测。
# example of making multiple probability predictions
from sklearn.linear_model import LogisticRegression
from sklearn.datasets.samples_generator import make_blobs
# generate 2d classification dataset
X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
# fit final model
model = LogisticRegression()
model.fit(X, y)
# new instances where we do not know the answer
Xnew, _ = make_blobs(n_samples=3, centers=2, n_features=2, random_state=1)
# make a prediction
ynew = model.predict_proba(Xnew)
# show the inputs and predicted probabilities
for i in range(len(Xnew)):
print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))
运行实例进行概率预测，然后打印输入数据实例以及每个实例属于第一和第二类（0 和 1）的概率。
X=[-0.79415228 2.10495117], Predicted=[0.94556472 0.05443528]
X=[-8.25290074 -4.71455545], Predicted=[3.60980873e-04 9.99639019e-01]
X=[-2.18773166 3.33352125], Predicted=[0.98437415 0.01562585]
如果您想向用户提供专家解释的概率，这在您的应用程序中会有所帮助。
3.如何用回归模型预测
回归是一种监督学习问题，在给定输入示例的情况下，模型学习映射到合适的输出量，例如“0.1”和“0.2”等。
下面是最终的LinearRegression模型的示例。同样，用于进行回归预测的函数适用于 scikit-learn 中可用的所有回归模型。
# example of training a final regression model
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
# generate regression dataset
X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)
# fit final model
model = LinearRegression()
model.fit(X, y)
我们可以通过在最终模型上调用predict()函数来使用最终的回归模型预测数量。
与分类一样，predict（）函数采用一个或多个数据实例的列表或数组。
多元回归预测
下面的示例演示了如何对具有未知预期结果的多个数据实例进行回归预测。
# example of training a final regression model
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
# generate regression dataset
X, y = make_regression(n_samples=100, n_features=2, noise=0.1)
# fit final model
model = LinearRegression()
model.fit(X, y)
# new instances where we do not know the answer
Xnew, _ = make_regression(n_samples=3, n_features=2, noise=0.1, random_state=1)
# make a prediction
ynew = model.predict(Xnew)
# show the inputs and predicted outputs
for i in range(len(Xnew)):
print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))
运行该示例会进行多次预测，然后并排打印输入和预测以供审阅。
X=[-1.07296862 -0.52817175], Predicted=-61.32459258381131
X=[-0.61175641 1.62434536], Predicted=-30.922508147981667
X=[-2.3015387 0.86540763], Predicted=-127.34448527071137
单回归预测
可以使用相同的函数来对单个数据实例做出预测，只要它适当地包装在周围的列表或数组中即可。
例如：
# example of training a final regression model
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
# generate regression dataset
X, y = make_regression(n_samples=100, n_features=2, noise=0.1)
# fit final model
model = LinearRegression()
model.fit(X, y)
# define one new data instance
Xnew = [[-1.07296862, -0.52817175]]
# make a prediction
ynew = model.predict(Xnew)
# show the inputs and predicted outputs
print("X=%s, Predicted=%s" % (Xnew[0], ynew[0]))
运行该示例进行单个预测并打印数据实例和预测以供审阅。
X=[-1.07296862, -0.52817175], Predicted=-77.17947088762787
进一步阅读
如果您希望深入了解，本节将提供有关该主题的更多资源。
- 如何训练最终机器学习模型
- 用 scikit-learn 在 Python 中保存和加载机器学习模型
- scikit-learn API 参考
摘要
在本教程中，您了解了如何使用 scikit-learn Python 库中的最终机器学习模型进行分类和回归预测。
具体来说，你学到了：
- 如何最终确定模型以便为预测做好准备。
- 如何在 scikit-learn 中进行类和概率预测。
- 如何在 scikit-learn 中进行回归预测。
你有任何问题吗？ 在下面的评论中提出您的问题，我会尽力回答。
