Machine Learning Mastery Sklearn 教程（七）

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

Python 中用于分类的感知机算法

原文：https://machinelearningmastery.com/perceptron-algorithm-for-classification-in-python/

感知机是一种用于二进制分类任务的线性机器学习算法。

它可以被认为是第一种也是最简单的人工神经网络。这绝对不是“深度”学习，而是一个重要的组成部分。

像逻辑回归一样，它可以在特征空间中快速学习两类分类任务的线性分离，尽管与逻辑回归不同，它使用随机梯度下降优化算法学习，并且不预测校准概率。

在本教程中，您将发现感知机分类机器学习算法。

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

• 感知机分类器是一种线性算法，可以应用于二进制分类任务。
• 如何使用带有 Sklearn 的感知机模型进行拟合、评估和预测。
• 如何在给定的数据集上调整感知机算法的超参数。

我们开始吧。

Python 中分类的感知机算法
图片由贝琳达·诺维卡提供，保留部分权利。

教程概述

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

1. 感知机算法
2. 带有 Scikit 的感知机-学习
3. 调整感知机超参数

感知机算法

感知机算法是一种两类(二进制)分类机器学习算法。

这是一种神经网络模型，也许是最简单的神经网络模型。

它由单个节点或神经元组成，以一行数据作为输入，并预测一个类标签。这是通过计算输入和偏差(设置为 1)的加权和来实现的。模型输入的加权和称为激活。

• 激活 =权重*输入+偏置

如果激活高于 0.0，模型将输出 1.0；否则，它将输出 0.0。

• 预测 1 :如果激活> 0.0
• 预测 0 :如果激活< = 0.0

假设输入乘以模型系数，如线性回归和逻辑回归，在使用模型之前对数据进行规范化或标准化是一个很好的做法。

感知机是一种线性分类算法。这意味着它学习一个决策边界，该边界使用特征空间中的一条线(称为超平面)分隔两个类。因此，它适用于那些类可以被线或线性模型很好地分开的问题，称为线性可分的。

模型的系数被称为输入权重，并使用随机梯度下降优化算法进行训练。

训练数据集中的示例一次一个地显示给模型，模型进行预测，并计算误差。然后更新模型的权重以减少示例的误差。这称为感知机更新规则。对训练数据集中的所有示例重复该过程，称为时期。然后，这个使用例子更新模型的过程会重复很多个时期。

每批使用一小部分误差更新模型权重，该比例由称为学习率的超参数控制，通常设置为小值。这是为了确保学习不会发生得太快，导致可能较低的技能模型，称为模型权重优化(搜索)过程的过早收敛。

• 权重(t + 1) =权重(t) +学习率*(预期 _i–预测 _) *输入 _ I

当模型产生的误差降至较低水平或不再改善，或者执行了最大数量的时期时，停止训练。

模型权重的初始值被设置为小的随机值。此外，训练数据集在每个训练时期之前被打乱。这是通过设计来加速和改进模型训练过程。因此，学习算法是随机的，每次运行时可能会获得不同的结果。因此，使用重复评估和报告平均分类精确率来总结算法在数据集上的表现是一种很好的做法。

学习速率和训练时期的数量是算法的超参数，可以使用试探法或超参数调整来设置。

有关感知机算法的更多信息，请参见教程:

• 如何在 Python 中从头实现感知机算法

现在我们已经熟悉了感知机算法，让我们探索如何在 Python 中使用该算法。

带有 Scikit 的感知机-学习

感知机算法可通过感知机类在 Sklearn Python 机器学习库中获得。

该课程允许您配置学习率( eta0 )，默认为 1.0。

...
# define model
model = Perceptron(eta0=1.0)

该实现还允许您配置训练时期的总数( max_iter ，默认为 1，000。

...
# define model
model = Perceptron(max_iter=1000)

感知机算法的 Sklearn 实现还提供了您可能想要探索的其他配置选项，例如提前停止和使用惩罚损失。

我们可以用一个工作示例来演示感知机分类器。

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

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

该示例创建并汇总数据集。

# 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,)

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

我们将使用默认配置。

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

下面列出了评估用于合成二进制分类任务的感知机模型的完整示例。

# evaluate a perceptron 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.linear_model import Perceptron
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)
# define model
model = Perceptron()
# 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 倍交叉验证的三次重复的平均准确性。

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

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

Mean Accuracy: 0.847 (0.052)

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

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

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

# make a prediction with a perceptron model on the dataset
from sklearn.datasets import make_classification
from sklearn.linear_model import Perceptron
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)
# define model
model = Perceptron()
# 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

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

调整感知机超参数

感知机算法的超参数必须针对您的特定数据集进行配置。

也许最重要的超参数是学习率。

较高的学习率可以使模型学习得更快，但代价可能是较低的技能。较小的学习速率可以产生表现更好的模型，但可能需要很长时间来训练模型。

您可以在教程中了解关于探索学习率的更多信息:

• 训练深度学习神经网络时如何配置学习速率

通常在一个小值(如 1e-4(或更小)和 1.0 之间的对数标度上测试学习速率。在这种情况下，我们将测试以下值:

...
# define grid
grid = dict()
grid['eta0'] = [0.0001, 0.001, 0.01, 0.1, 1.0]

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

# grid search learning rate for the perceptron
from sklearn.datasets import make_classification
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.linear_model import Perceptron
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)
# define model
model = Perceptron()
# define model evaluation method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# define grid
grid = dict()
grid['eta0'] = [0.0001, 0.001, 0.01, 0.1, 1.0]
# 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_)
# summarize all
means = results.cv_results_['mean_test_score']
params = results.cv_results_['params']
for mean, param in zip(means, params):
    print(">%.3f with: %r" % (mean, param))

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

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

在这种情况下，我们可以看到，比默认值更小的学习速率导致更好的表现，学习速率 0.0001 和 0.001 都实现了大约 85.7%的分类准确率，而默认值 1.0 实现了大约 84.7%的准确率。

Mean Accuracy: 0.857
Config: {'eta0': 0.0001}
>0.857 with: {'eta0': 0.0001}
>0.857 with: {'eta0': 0.001}
>0.853 with: {'eta0': 0.01}
>0.847 with: {'eta0': 0.1}
>0.847 with: {'eta0': 1.0}

另一个重要的超参数是使用多少个时期来训练模型。

这可能取决于训练数据集，并且可能有很大差异。同样，我们将在 1 到 1e+4 之间的对数标度上探索配置值。

...
# define grid
grid = dict()
grid['max_iter'] = [1, 10, 100, 1000, 10000]

我们将使用上一次搜索中发现的 0.0001 的良好学习率。

...
# define model
model = Perceptron(eta0=0.0001)

下面列出了网格搜索训练时期数量的完整示例。

# grid search total epochs for the perceptron
from sklearn.datasets import make_classification
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.linear_model import Perceptron
# define dataset
X, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)
# define model
model = Perceptron(eta0=0.0001)
# define model evaluation method
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
# define grid
grid = dict()
grid['max_iter'] = [1, 10, 100, 1000, 10000]
# 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_)
# summarize all
means = results.cv_results_['mean_test_score']
params = results.cv_results_['params']
for mean, param in zip(means, params):
    print(">%.3f with: %r" % (mean, param))

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

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

在这种情况下，我们可以看到 10 到 10，000 个纪元导致了大约相同的分类精确率。一个有趣的例外是探索同时配置学习速率和训练时期的数量，看看是否能取得更好的结果。

Mean Accuracy: 0.857
Config: {'max_iter': 10}
>0.850 with: {'max_iter': 1}
>0.857 with: {'max_iter': 10}
>0.857 with: {'max_iter': 100}
>0.857 with: {'max_iter': 1000}
>0.857 with: {'max_iter': 10000}

进一步阅读

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

教程

• 如何在 Python 中从头开始实现感知机算法
• 了解学习率对神经网络表现的影响
• 训练深度学习神经网络时如何配置学习速率

书

• 用于模式识别的神经网络，1995。
• 模式识别与机器学习，2006。
• 人工智能:现代方法，第 3 版，2015 年。

蜜蜂

• sklearn.linear_model。感知机 API 。

文章

• 感知，维基百科。
• 感知机(书)，维基百科。

摘要

在本教程中，您发现了感知机分类机器学习算法。

具体来说，您了解到:

• 感知机分类器是一种线性算法，可以应用于二进制分类任务。
• 如何使用带有 Sklearn 的感知机模型进行拟合、评估和预测。
• 如何在给定的数据集上调整感知机算法的超参数。

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

使用 Python 绘制机器学习算法的决策表面

原文：https://machinelearningmastery.com/plot-a-decision-surface-for-machine-learning/

最后更新于 2020 年 8 月 26 日

分类算法学习如何给例子分配类标签，尽管它们的决策可能看起来不透明。

理解分类算法所做决策的一个流行诊断是决策表面。这是一个曲线图，显示了拟合机器学习算法如何预测输入特征空间上的粗糙网格。

决策表面图是一个强大的工具，用于了解给定模型“”如何看待”预测任务，以及它如何决定按类别标签划分输入特征空间。

在本教程中，您将发现如何为分类机器学习算法绘制决策图。

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

• 决策表面是一种诊断工具，用于了解分类算法如何划分特征空间。
• 如何为机器学习算法绘制使用清晰类标签的决策图？
• 如何使用预测概率绘制和解释决策表面？

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

我们开始吧。

用 Python 绘制机器学习算法的决策图
图片由托尼·韦伯斯特提供，保留部分权利。

教程概述

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

1. 决策表面
2. 数据集和模型
3. 绘制决策图

决策表面

分类机器学习算法学习给输入示例分配标签。

考虑用于定义连续输入特征空间的分类任务的数字输入特征。

我们可以考虑在特征空间上定义轴或尺寸的每个输入特征。两个输入要素将定义一个平面要素空间，点代表输入空间中的输入坐标。如果有三个输入变量，特征空间将是三维体积。

空间中的每个点都可以分配一个类别标签。就二维特征空间而言，我们可以认为刨子上的每个点根据其指定的类别具有不同的颜色。

分类算法的目标是学习如何划分特征空间，以便将标签正确分配给特征空间中的点，或者至少尽可能正确。

这是对分类预测建模的一个有用的几何理解。我们可以更进一步。

一旦分类机器学习算法划分了一个特征空间，我们就可以在任意网格上对特征空间中的每个点进行分类，从而了解算法选择如何划分特征空间。

这被称为决策表面或决策边界，它为理解分类预测建模任务上的模型提供了诊断工具。

虽然“表面的概念暗示了二维特征空间，但是该方法可以用于具有多于二维的特征空间，其中为每对输入特征创建表面。

现在我们已经熟悉了什么是决策表面，接下来，让我们定义一个数据集和模型，稍后我们将探索决策表面。

数据集和模型

在本节中，我们将定义一个分类任务和预测模型来学习该任务。

综合分类数据集

我们可以使用 make_blobs() Sklearn 函数定义一个分类任务，该分类任务具有一个二维类数值特征空间，每个点被分配两个类标签中的一个，例如二进制分类任务。

...
# generate dataset
X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=1, cluster_std=3)

一旦定义，我们就可以创建特征空间的散点图，第一个特征定义 x 轴，第二个特征定义 y 轴，每个样本表示为特征空间中的一个点。

然后，我们可以根据散点图中的点的类别标签将它们着色为 0 或 1。

...
# create scatter plot for samples from each class
for class_value in range(2):
	# get row indexes for samples with this class
	row_ix = where(y == class_value)
	# create scatter of these samples
	pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
# show the plot
pyplot.show()

下面列出了定义和绘制综合分类数据集的完整示例。

# generate binary classification dataset and plot
from numpy import where
from matplotlib import pyplot
from sklearn.datasets import make_blobs
# generate dataset
X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=1, cluster_std=3)
# create scatter plot for samples from each class
for class_value in range(2):
	# get row indexes for samples with this class
	row_ix = where(y == class_value)
	# create scatter of these samples
	pyplot.scatter(X[row_ix, 0], X[row_ix, 1])
# show the plot
pyplot.show()

运行该示例会创建数据集，然后将数据集绘制为散点图，其中的点由类标签着色。

我们可以看到这两个类的例子之间有明显的区别，我们可以想象机器学习模型如何画一条线来区分这两个类，例如，也许一条对角线正好穿过这两组的中间。

基于 2D 特征空间的二值分类数据集散点图

拟合分类预测模型

我们现在可以在数据集上拟合一个模型。

在这种情况下，我们将拟合逻辑回归算法，因为我们可以预测清晰的类标签和概率，这两者都可以在我们的决策表面中使用。

我们可以定义模型，然后将其拟合到训练数据集中。

...
# define the model
model = LogisticRegression()
# fit the model
model.fit(X, y)

一旦定义，我们可以使用该模型对训练数据集进行预测，以了解它在划分训练数据集的特征空间和分配标签方面的学习程度。

...
# make predictions
yhat = model.predict(X)

可以使用分类精确率来评估预测。

...
# evaluate the predictions
acc = accuracy_score(y, yhat)
print('Accuracy: %.3f' % acc)

将这些联系在一起，下面列出了在合成二进制分类数据集上拟合和评估模型的完整示例。

# example of fitting and evaluating a model on the classification dataset
from sklearn.datasets import make_blobs
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
# generate dataset
X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=1, cluster_std=3)
# define the model
model = LogisticRegression()
# fit the model
model.fit(X, y)
# make predictions
yhat = model.predict(X)
# evaluate the predictions
acc = accuracy_score(y, yhat)
print('Accuracy: %.3f' % acc)

运行该示例符合模型，并对每个示例进行预测。

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

在这种情况下，我们可以看到该模型实现了大约 97.2%的表现。

Accuracy: 0.972

现在我们已经有了数据集和模型，让我们来探索如何开发决策表面。

绘制决策图

我们可以通过在训练数据集上拟合一个模型来创建一个决策表面，然后使用该模型对输入域中的值网格进行预测。

一旦我们有了预测网格，我们就可以绘制值和它们的类标签。

如果采用足够精细的网格，可以使用散点图。更好的方法是使用等高线图，它可以在点之间插入颜色。

可以使用 contourf() Matplotlib 功能。

这需要几个步骤。

首先，我们需要定义一个跨越特征空间的点网格。

为此，我们可以找到每个要素的最小值和最大值，并将网格扩展一步，以确保覆盖整个要素空间。

...
# define bounds of the domain
min1, max1 = X[:, 0].min()-1, X[:, 0].max()+1
min2, max2 = X[:, 1].min()-1, X[:, 1].max()+1

然后，我们可以使用保证()函数以选定的分辨率在每个维度上创建一个统一的样本。在这种情况下，我们将使用 0.1 的分辨率。

...
# define the x and y scale
x1grid = arange(min1, max1, 0.1)
x2grid = arange(min2, max2, 0.1)

现在我们需要把它变成一个网格。

我们可以使用 meshgrid() NumPy 函数从这两个向量创建一个网格。

如果第一个特征 x1 是特征空间的 x 轴，那么对于 y 轴上的每个点，我们需要一行网格的 x1 值。

同样，如果我们将 x2 作为特征空间的 y 轴，那么我们需要 x 轴上每个点的一列 x2 值。

meshgrid() 函数会为我们完成这个操作，根据需要为我们复制行和列。它为两个输入向量返回两个网格。x 值的第一个网格和 y 值的第二个网格，在要素空间中以适当大小的行和列网格组织。

...
# create all of the lines and rows of the grid
xx, yy = meshgrid(x1grid, x2grid)

然后我们需要展平网格来创建样本，我们可以将这些样本输入模型并进行预测。

为此，首先，我们将每个网格展平为一个向量。

...
# flatten each grid to a vector
r1, r2 = xx.flatten(), yy.flatten()
r1, r2 = r1.reshape((len(r1), 1)), r2.reshape((len(r2), 1))

然后，我们将向量作为输入数据集中的列并排堆叠，例如，像我们的原始训练数据集一样，但分辨率要高得多。

...
# horizontal stack vectors to create x1,x2 input for the model
grid = hstack((r1,r2))

然后，我们可以将其输入到我们的模型中，并获得网格中每个点的预测。

...
# make predictions for the grid
yhat = model.predict(grid)
# reshape the predictions back into a grid

目前为止，一切顺利。

正如我们的模型所预测的那样，我们有一个跨越要素空间和类标签的值网格。

接下来，我们需要将数值网格绘制为等高线图。

contourf()函数为每个轴取单独的网格，就像我们之前调用 meshgrid() 返回的一样。太好了。

所以我们可以使用之前准备的 xx 和 yy ，简单的将模型中的预测( yhat )重塑成相同的形状。

...
# reshape the predictions back into a grid
zz = yhat.reshape(xx.shape)

然后，我们用双色色图绘制决策表面。

...
# plot the grid of x, y and z values as a surface
pyplot.contourf(xx, yy, zz, cmap='Paired')

然后，我们可以在顶部绘制数据集的实际点，以查看它们被逻辑回归决策表面分隔的程度。

下面列出了在我们的合成二进制分类数据集上绘制逻辑回归模型决策表面的完整示例。

# decision surface for logistic regression on a binary classification dataset
from numpy import where
from numpy import meshgrid
from numpy import arange
from numpy import hstack
from sklearn.datasets import make_blobs
from sklearn.linear_model import LogisticRegression
from matplotlib import pyplot
# generate dataset
X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=1, cluster_std=3)
# define bounds of the domain
min1, max1 = X[:, 0].min()-1, X[:, 0].max()+1
min2, max2 = X[:, 1].min()-1, X[:, 1].max()+1
# define the x and y scale
x1grid = arange(min1, max1, 0.1)
x2grid = arange(min2, max2, 0.1)
# create all of the lines and rows of the grid
xx, yy = meshgrid(x1grid, x2grid)
# flatten each grid to a vector
r1, r2 = xx.flatten(), yy.flatten()
r1, r2 = r1.reshape((len(r1), 1)), r2.reshape((len(r2), 1))
# horizontal stack vectors to create x1,x2 input for the model
grid = hstack((r1,r2))
# define the model
model = LogisticRegression()
# fit the model
model.fit(X, y)
# make predictions for the grid
yhat = model.predict(grid)
# reshape the predictions back into a grid
zz = yhat.reshape(xx.shape)
# plot the grid of x, y and z values as a surface
pyplot.contourf(xx, yy, zz, cmap='Paired')
# create scatter plot for samples from each class
for class_value in range(2):
	# get row indexes for samples with this class
	row_ix = where(y == class_value)
	# create scatter of these samples
	pyplot.scatter(X[row_ix, 0], X[row_ix, 1], cmap='Paired')
# show the plot
pyplot.show()

运行该示例符合模型，并使用它来预测整个要素空间的值网格的结果，并将结果绘制为等高线图。

我们可以看到，正如我们可能已经怀疑的那样，逻辑回归使用直线划分特征空间。毕竟是线性模型；这是它能做的一切。

创建一个决策表几乎就像魔术一样。它提供了模型如何学习任务的即时和有意义的洞察。

尝试不同的算法，比如 SVM 或决策树。
在下面的评论中发布你的地图作为链接！

二元分类任务的逻辑回归决策表面

我们可以通过使用模型来预测概率而不是类标签来增加决策表面的深度。

...
# make predictions for the grid
yhat = model.predict_proba(grid)
# keep just the probabilities for class 0
yhat = yhat[:, 0]

绘制时，我们可以看到要素空间中的每个点属于每个类别标签的置信度或可能性，如模型所示。

我们可以使用一个不同的颜色图，它有层次，并显示一个图例，这样我们就可以解释颜色。

...
# plot the grid of x, y and z values as a surface
c = pyplot.contourf(xx, yy, zz, cmap='RdBu')
# add a legend, called a color bar
pyplot.colorbar(c)

下面列出了使用概率创建决策表面的完整示例。

# probability decision surface for logistic regression on a binary classification dataset
from numpy import where
from numpy import meshgrid
from numpy import arange
from numpy import hstack
from sklearn.datasets import make_blobs
from sklearn.linear_model import LogisticRegression
from matplotlib import pyplot
# generate dataset
X, y = make_blobs(n_samples=1000, centers=2, n_features=2, random_state=1, cluster_std=3)
# define bounds of the domain
min1, max1 = X[:, 0].min()-1, X[:, 0].max()+1
min2, max2 = X[:, 1].min()-1, X[:, 1].max()+1
# define the x and y scale
x1grid = arange(min1, max1, 0.1)
x2grid = arange(min2, max2, 0.1)
# create all of the lines and rows of the grid
xx, yy = meshgrid(x1grid, x2grid)
# flatten each grid to a vector
r1, r2 = xx.flatten(), yy.flatten()
r1, r2 = r1.reshape((len(r1), 1)), r2.reshape((len(r2), 1))
# horizontal stack vectors to create x1,x2 input for the model
grid = hstack((r1,r2))
# define the model
model = LogisticRegression()
# fit the model
model.fit(X, y)
# make predictions for the grid
yhat = model.predict_proba(grid)
# keep just the probabilities for class 0
yhat = yhat[:, 0]
# reshape the predictions back into a grid
zz = yhat.reshape(xx.shape)
# plot the grid of x, y and z values as a surface
c = pyplot.contourf(xx, yy, zz, cmap='RdBu')
# add a legend, called a color bar
pyplot.colorbar(c)
# create scatter plot for samples from each class
for class_value in range(2):
	# get row indexes for samples with this class
	row_ix = where(y == class_value)
	# create scatter of these samples
	pyplot.scatter(X[row_ix, 0], X[row_ix, 1], cmap='Paired')
# show the plot
pyplot.show()

运行该示例可以预测要素空间中网格上每个点的类成员概率，并绘制结果图。

在这里，我们可以看到，给定特征空间的那个区域中的采样噪声，模型在域的中间附近是不确定的(较浅的颜色)。我们还可以看到，模型在域的左下半部分和右上半部分非常自信(全彩)。

总之，清晰的类和概率决策表面是强大的诊断工具，有助于理解您的模型以及它如何为您的预测建模任务划分特征空间。

二元分类任务逻辑回归的概率决策表面

进一步阅读

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

• matplot lib . pyplot . contour API。
• Matplotlib 彩色地图
• num py . mesh grid API。
• 在虹膜数据集上绘制决策树的决策表面，sklearn 示例。

摘要

在本教程中，您发现了如何为分类机器学习算法绘制决策图。

具体来说，您了解到:

• 决策表面是一种诊断工具，用于了解分类算法如何划分特征空间。
• 如何为机器学习算法绘制使用清晰类标签的决策图？
• 如何使用预测概率绘制和解释决策表面？

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

使用 Python 和 Pandas 为机器学习准备数据

原文： machinelearningmastery.com/prepare-data-for-machine-learning-in-python-with-pandas/

如果您使用 Python 栈来学习和应用机器学习，那么您将要用于数据分析和数据操作的库是 Pandas。

这篇文章为您提供了熊猫库的快速介绍，并指出了正确的入门方向。

用于数据分析的熊猫。
照 gzlu ，保留一些权利。

Python 中的数据分析

Python SciPy 栈通常适用于科学计算。它提供了强大的库来处理网格数据（如 NumPy）和绘图（如 matplotlib）。直到最近，套件中缺少的一个部件才是处理数据的好库。

数据通常不是以易于使用的形式出现的。处理机器学习等数据驱动问题的很大一部分是数据分析和数据调整。

• 数据分析：这是使用统计和数据可视化等工具，通过了解数据来更好地理解问题。
• Data Munging ：这是将原始数据转换为表格的过程，以便适合您的工作，如数据分析或机器学习。

传统上，您必须在 Python 中拼凑自己的脚本工具链来执行这些任务。

如今，如果您在 Python 中搜索数据分析，则无法避免了解 Pandas。它已迅速成为 Python 中数据处理的首选库。

什么是熊猫？

Pandas 是一个用于数据分析和数据操作的 Python 库。它将缺少的部分添加到 SciPy 框架以处理数据。

熊猫是由 Wes McKinney 于 2008 年创建的，主要用于量化金融工作。因此，它在处理时间序列数据和图表方面具有坚实的基础。

您使用 Pandas 将数据加载到 Python 中并执行数据分析任务。它非常适合处理表格数据，如来自关系数据库的数据或来自电子表格的数据。

Wes 描述了 Pandas 对 crate 的看法：用于任何语言的最强大，最灵活的开源数据分析和操作工具。

如果只是为了让您自己的数据分析工作变得更容易，那么这项令人钦佩的任务就是让您想要支持他的事业。

熊猫特色

熊猫是一种乐趣。

根据我的经验，它简单，优雅，直观。来自 R，成语和操作是熟悉和相关的。

Pandas 构建在 SciPy 栈中的标准库之上。它使用 NumPy 进行快速数组处理，并为 StatsModels 的一些统计操作和 Matplotlib 的图表提供方便的包装。

鉴于库在金融领域的开始，人们非常关注时间序列。它还非常关注用于处理标准网格数据的数据帧。数据处理是此类库的核心要求，速度已成为优先事项。它速度快，提供数据结构和操作，如索引和稀疏性处理。

需要注意的一些重要功能包括“

• 操纵：移动列，切片，整形，合并，连接，过滤等。
• 时间序列处理：对日期/时间，重采样，移动窗口和数据集自动对齐的操作。
• 缺少数据处理：自动排除，删除，替换，插入缺失值
• 分组操作：SQL like group by。
• 分层索引：数据结构级别，对按列有效组织数据非常有用。
• 摘要统计：快速而强大的数据汇总统计。
• 可视化：简化了对数据结构图的访问，例如直方图，箱形图，一般图和散点图。

Pandas 在许可许可证（Simplified BSD）下可用，并且可以与 SciPy 的其余部分一起轻松安装。

熊猫资源

这是对熊猫库的快速介绍，还有更多需要学习的内容。安装库，获取数据集并开始尝试。没有更好的入门方式。

访问 Pandas 主页并阅读库愿景和功能。您也可以查看项目的 github 页面。

一个很好的起点是教程列表，其中包括指向网络上的烹饪书，课程和各种着名的 IPython 笔记本的链接。

最后，对我来说，我住在 API 文档中。

文件

我发现论文可以很好地概述开源库，特别是在 Python 和 R 生态系统中。请查看以下论文，了解熊猫的全部内容。

• Python 中统计计算的数据结构
• pandas：用于数据分析和统计的基础 Python 库

影片

YouTube 上有很多关于人们在自己的数据和会议上展示 Pandas 的精彩视频。

一个很好的起点是 Wes 自己 10 分钟的熊猫之旅。看一看。这是一个很小的时间序列数据，但它是一个伟大而快速的概述。您还可以查看他的 IPython 笔记本进行本次巡演。

图书

最后，Wes 是 Python 中关于数据分析的权威书籍的作者。如果你想认真练习，还要考虑抓住这本书。它被称为：用于数据分析的 Python：与 Pandas，NumPy 和 IPython 进行数据争夺。

如何使用 Python 和 Scikit-Learn 为机器学习准备数据

原文： machinelearningmastery.com/prepare-data-machine-learning-python-scikit-learn/

许多机器学习算法都会对您的数据做出假设。

以这种方式准备数据通常是一个非常好的主意，以便最好地将问题的结构暴露给您打算使用的机器学习算法。

在这篇文章中，您将了解如何使用 scikit-learn 为 Python 中的机器学习准备数据。

让我们开始吧。

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

如何使用 Scikit-Learn
照片由 Vinoth Chandar 为 Python 机器学习准备数据，保留一些权利。

需要数据预处理

您几乎总是需要预处理数据。这是必需的步骤。

困难在于不同的算法对您的数据做出不同的假设，并且可能需要不同的变换。此外，当您遵循所有规则并准备数据时，有时算法可以在不进行预处理的情况下提供更好的结果。

通常，我建议您创建许多不同的视图和数据转换，然后在数据集的每个视图上运行一些算法。这将有助于您清除哪些数据转换可能更好地暴露您的问题结构。

预处理机器学习秘籍

本节列出了 4 种用于机器学习的不同数据预处理秘籍。

所有秘籍都设计为完整且独立的。

您可以将它们直接复制并粘贴到项目中并开始工作。

Pima 印度糖尿病数据集用于每个秘籍。这是一个二分类问题，其中所有属性都是数字的，并且具有不同的比例。这是可以从预处理中受益的数据集的一个很好的例子。

您可以在 UCI 机器学习库网页上了解有关此数据集的更多信息（更新：从此处下载）。

每个秘籍都遵循相同的结构：

1. 从 URL 加载数据集。
2. 将数据集拆分为输入和输出变量以进行机器学习。
3. 对输入变量应用预处理变换。
4. 总结数据以显示更改。

变换的计算方式使它们可以应用于您的训练数据以及将来可能拥有的任何数据样本。

scikit-learn 文档提供了有关如何使用各种不同预处理方法的一些信息。您可以在此处查看 scikit-learn 中的预处理 API。

1.重缩放数据

当您的数据由具有不同比例的属性组成时，许多机器学习算法可以从重缩放属性中受益，所有属性具有相同的比例。

这通常被称为归一化，并且属性通常被重缩放到 0 和 1 之间的范围。这对于在诸如梯度下降的机器学习算法的核心中使用的优化算法是有用的。对于使用诸如回归和神经网络之类的输入以及使用诸如 K 最近邻 之类的距离度量的算法的算法，它也是有用的。

您可以使用 MinMaxScaler 类使用 scikit-learn 重缩放数据。

# Rescale data (between 0 and 1)
import pandas
import scipy
import numpy
from sklearn.preprocessing import MinMaxScaler
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
# separate array into input and output components
X = array[:,0:8]
Y = array[:,8]
scaler = MinMaxScaler(feature_range=(0, 1))
rescaledX = scaler.fit_transform(X)
# summarize transformed data
numpy.set_printoptions(precision=3)
print(rescaledX[0:5,:])

重新缩放后，您可以看到所有值都在 0 到 1 之间。

[[ 0.353  0.744  0.59   0.354  0\.     0.501  0.234  0.483]
 [ 0.059  0.427  0.541  0.293  0\.     0.396  0.117  0.167]
 [ 0.471  0.92   0.525  0\.     0\.     0.347  0.254  0.183]
 [ 0.059  0.447  0.541  0.232  0.111  0.419  0.038  0\.   ]
 [ 0\.     0.688  0.328  0.354  0.199  0.642  0.944  0.2  ]]

2.标准化数据

标准化是一种有用的技术，可以使用高斯分布转换属性，并将不同的均值和标准差转换为平均值为 0 且标准差为 1 的标准高斯分布。

它最适合于在输入变量中假设高斯分布并且对重新缩放的数据更好地工作的技术，例如线性回归，逻辑回归和线性判别分析。

您可以使用 StandardScaler 类使用 scikit-learn 标准化数据。

# Standardize data (0 mean, 1 stdev)
from sklearn.preprocessing import StandardScaler
import pandas
import numpy
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
# separate array into input and output components
X = array[:,0:8]
Y = array[:,8]
scaler = StandardScaler().fit(X)
rescaledX = scaler.transform(X)
# summarize transformed data
numpy.set_printoptions(precision=3)
print(rescaledX[0:5,:])

现在，每个属性的值的平均值为 0，标准差为 1。

[[ 0.64   0.848  0.15   0.907 -0.693  0.204  0.468  1.426]
 [-0.845 -1.123 -0.161  0.531 -0.693 -0.684 -0.365 -0.191]
 [ 1.234  1.944 -0.264 -1.288 -0.693 -1.103  0.604 -0.106]
 [-0.845 -0.998 -0.161  0.155  0.123 -0.494 -0.921 -1.042]
 [-1.142  0.504 -1.505  0.907  0.766  1.41   5.485 -0.02 ]]

3.规范化数据

scikit-learn 中的规范化是指将每个观察（行）重新缩放为长度为 1（在线性代数中称为单位范数）。

当使用加权输入值的算法（如神经网络和使用距离测量的算法，如 K 最近邻）时，此预处理对于具有不同比例属性的稀疏数据集（大量零）非常有用。

您可以使用 Normalizer 类通过 scikit-learn 对 Python 中的数据进行规范化。

# Normalize data (length of 1)
from sklearn.preprocessing import Normalizer
import pandas
import numpy
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
# separate array into input and output components
X = array[:,0:8]
Y = array[:,8]
scaler = Normalizer().fit(X)
normalizedX = scaler.transform(X)
# summarize transformed data
numpy.set_printoptions(precision=3)
print(normalizedX[0:5,:])

行被标准化为长度 1。

[[ 0.034  0.828  0.403  0.196  0\.     0.188  0.004  0.28 ]
 [ 0.008  0.716  0.556  0.244  0\.     0.224  0.003  0.261]
 [ 0.04   0.924  0.323  0\.     0\.     0.118  0.003  0.162]
 [ 0.007  0.588  0.436  0.152  0.622  0.186  0.001  0.139]
 [ 0\.     0.596  0.174  0.152  0.731  0.188  0.01   0.144]]

4.二值化数据（制作二进制）

您可以使用二进制阈值转换数据。高于阈值的所有值都标记为 1，所有等于或低于的值都标记为 0。

这称为二值化数据或阈值数据。当你有想要制作清晰价值的概率时，它会很有用。它在特征工程中很有用，并且您希望添加指示有意义的内容的新功能。

您可以使用 scikit-learn 与 Binarizer 类在 Python 中创建新的二进制属性。

# binarization
from sklearn.preprocessing import Binarizer
import pandas
import numpy
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
# separate array into input and output components
X = array[:,0:8]
Y = array[:,8]
binarizer = Binarizer(threshold=0.0).fit(X)
binaryX = binarizer.transform(X)
# summarize transformed data
numpy.set_printoptions(precision=3)
print(binaryX[0:5,:])

您可以看到所有等于或小于 0 的值都标记为 0，而所有高于 0 的值都标记为 1。

[[ 1\.  1\.  1\.  1\.  0\.  1\.  1\.  1.]
 [ 1\.  1\.  1\.  1\.  0\.  1\.  1\.  1.]
 [ 1\.  1\.  1\.  0\.  0\.  1\.  1\.  1.]
 [ 1\.  1\.  1\.  1\.  1\.  1\.  1\.  1.]
 [ 0\.  1\.  1\.  1\.  1\.  1\.  1\.  1.]]

摘要

在这篇文章中，您了解了如何使用 scikit-learn 为 Python 中的机器学习准备数据。

你现在有秘籍：

• 重缩放数据。
• 标准化数据。
• 规范化数据。
• 二值化数据。

此帖子的操作步骤是键入或复制并粘贴每个秘籍，熟悉 scikit-learn 中的数据预处理。

您对 Python 或本文中的数据预处理有任何疑问吗？在评论中提问，我会尽力回答。

项目聚焦：使用 Artem Yankov 在 Python 中推荐事件

原文： machinelearningmastery.com/project-spotlight-with-artem-yankov/

这是 Artem Yankov 的项目聚焦。

你能介绍一下自己吗？

我叫 Artem Yankov，过去 3 年我曾在 Badgeville 担任软件工程师。我在那里使用 Ruby 和 Scala，虽然我之前的背景包括使用各种语言，如：汇编，C / C ++，Python，Clojure 和 JS。

我喜欢黑客攻击小项目并探索不同的领域，例如我看过的两个几乎随机的领域是机器人和恶意软件分析。我不能说我成了专家，但我确实有很多乐趣。我制造的一个小型机器人看起来非常难看，但它可以通过 MS Kinect “看到”它来反映我的手臂动作。

直到去年我完成 Andrew Ng 关于 Coursera 的课程并且我真的很喜欢它时，我根本没有做任何机器学习。

你的项目叫什么，它做了什么？

该项目名为 hapsradar.com ，它是一个活动推荐网站，专注于现在或不久的将来发生的事情。

我是一个可怕的周末计划者，我常常想知道如果我突然决定在我的家/互联网之外做一些事情该怎么办。我发现正在发生的事情的典型算法是访问 meetup.com 和 eventbrite 等网站，浏览大量类别，点击大量按钮并阅读当前事件列表。

因此，当我完成机器学习课程并开始寻找项目来练习我的技能时，我认为我可以通过从这些网站获取事件列表然后根据我喜欢的方式构建推荐来真正自动化此事件搜索过程。

HapsRadar by Artem Yankov

该网站非常简约，目前只提供来自两个网站的活动： meetup.com 和 eventbrite.com 。用户需要在推荐引擎启动之前评估至少 100 个事件。然后它每晚运行并使用用户喜欢/不喜欢进行训练，然后尝试预测用户可能喜欢的事件。

你是怎么开始的？

我的开始只是因为我想练习我的机器学习技巧，并让我更有趣，我选择解决一个真正的问题。经过一番评估后，我决定使用 python 作为我的推荐人。这是我使用的工具：

• 熊猫
• Scikit-Learn
• PostgreSQL
• Scala / PlayFramework （用于事件提取器和网站）

使用 meetup.com 和 eventbrite.com 提供的标准 API 获取事件并存储在 postgresql 中。在我开始使用爬虫之前，我通过电子邮件仔细检查了我是否可以做这样的事情，特别是因为我想每天运行这些爬虫来保持我的数据库更新所有事件。

这些人非常好，eventbrite 甚至没有任何问题地提高了我的 API 速率限制。 meetup.com 有一个很好的流媒体 API，允许您订阅所有发生的变化。我想抓住 yelp.com ，因为他们有事件列表，但是他们完全禁止这样做。

在我第一次删除数据后，我构建了一个简单的站点，在给定的邮政编码的某个范围内显示事件（我目前只为美国提取事件）。

现在是推荐部分。构建我的功能的主要材料是事件标题和事件描述。我决定事件发生的时间，或者离家多远的事情都不会增加很多价值，因为我只想简单回答一下问题：这个事件是否与我的兴趣有关？

想法＃1。预测主题

一些获取的事件具有标签或类别，其中一些没有。

最初我认为我应该尝试使用标记事件来预测未标记事件的标记，然后将它们用作训练功能。花了一些时间后，我认为这可能不是一个好主意。大多数标记事件只有 1-3 个标记，它们通常非常不准确甚至完全随机。

我认为 eventbrite 允许客户输入任何标签作为标签，而人们不太善于提出好话。此外，每个事件的标签数量通常较低，即使您使用人工智能，也不足以判断事件

当然，有可能找到已经准确分类的文本并将其用于预测主题，但这又提出了许多其他问题：在何处获取机密文本？与我的活动描述有多相关？我应该使用多少个标签？所以我决定找到另一个想法。

想法＃2。 LDA 主题建模

经过一些研究，我发现了一个名为 gensim 的真棒 python 库，它实现了 LDA（ Latent Dirichlet Allocation ）用于主题建模。

值得注意的是，这里使用主题并不意味着用英语定义的主题，如“体育”，“音乐”或“编程”。 LDA 中的主题是对单词的概率分布。粗略地说，它发现了具有一定概率的单词集合。每个这样的集群都是一个“主题”。然后，您可以为模型提供新文档，并为其推断主题。

使用 LDA 非常简单。首先，我通过删除停止英语单词，逗号，html 标签等来清理文档（在我的案例文档中是事件的描述和标题）。然后我根据所有事件描述构建字典：

来自 gensim import corpora 的，模型 dct = corpora.Dictionary（clean_documents）

然后我过滤非常罕见的单词

dct.filter_extremes(no_below=2)

要训​​练模型，所有文件都需要转换成文字袋：

corpus = [dct.doc2bow(doc) for doc in clean_documents]

然后像这样创建模型

lda = ldamodel.LdaModel(corpus=corpus, id2word=dct, num_topics=num_topics)

其中 num_topics 是需要在文档上建模的许多主题。在我的情况下它是 100.然后将任何文字袋形式的文件转换为稀疏矩阵形式的主题表示：

x = lda[doc_bow]

所以现在我可以为任何给定的事件获得一个特征矩阵，我可以很容易地为用户评分的事件获得一个训练矩阵：

docs_bow = [dct.doc2bow（doc）for doc in rated_events] X_train = [lda [doc_bow] for doc_bow in docs_bow]

这似乎或多或少是不错的解决方案，使用 SVM（支持向量机）分类器我得到了大约 85％的准确度，当我查看预测事件对我来说它确实看起来非常准确。

注意：并非所有分类器都支持稀疏矩阵，有时您需要将其转换为完整矩阵。 Gensim 有办法做到这一点。

gensim.matutils.sparse2full(sparse_matrix, num_topics)

想法＃3。 TF-IDF 向量化器

我想尝试构建特征的另一个想法是 TF-IDF 向量化器。

Scikit-learn 支持开箱即用，它正在做的是根据文档中该单词的频率除以文档中单词的频率为文档中的每个单词分配权重。文件的语料库。因此，如果您经常看到这个词的重量会很低，并且可以滤除噪音。要从所有文档中构建向量化器：

来自 sklearn.feature_extraction.text 的导入 TfidfVectorizer vectorizer = TfidfVectorizer（max_df = 0.5，sublinear_tf = True，stop_words ='english'） vectorizer.fit（all_events）

然后将给定的文档集转换为 TF-IDF 表示：

X_train = vectorizer.transform(rated_events)

现在，当我尝试将其提供给真正花费很长时间的分类器时，结果很糟糕。这实际上并不令人意外，因为在这种情况下，几乎每个单词都是一个特征。所以我开始寻找一种方法来选择表现最佳的功能。

Scikit-learn 提供方法 SelectKBest ，你可以传递评分函数和许多功能来选择它，它为你执行魔术。对于得分，我使用 chi2（[卡方检验](http://en.wikipedia.org/wiki/卡方 _test)），我不会说你到底为什么。我只是凭经验发现它在我的情况下表现得更好，并在我的 todo 桶中“研究了 chi2 背后的理论”。

来自 sklearn.feature_selection import SelectKBest，chi2 num_features = 100 ch2 = SelectKBest（chi2，k = num_features） X_train = ch2.fit_transform（X_train，y_train）.toarray（）

就是这样。 X_train 是我的训练集。

训练分类器

我不高兴承认这一点，但我选择的分类器并没有多少科学参与。我只是试了一堆，然后选择表现最好的那一个。就我而言，它是 SVM。至于我用网格搜索选择最好的参数，所有 scikit-learn 提供开箱即用的参数。在代码中它看起来像这样：

clf = svm.SVC（） params = dict（gamma = [0.001,0.01,0.1,0.2,1,10,100]，C = [1,10,100,1000]，kernel = [“linear “，”rb“]） clf = grid_search.GridSearchCV（clf，param_grid = params，cv = 5，scoring ='f1'）

我选择 f1-score 作为评分方法只是因为它是我或多或少了解的那个。网格搜索将尝试上述参数的所有组合，执行交叉验证并找到表现最佳的参数。

我尝试将这个分类器提供给 X_train，主题是用 LDA 和 TF-IDF + Chi2 建模的。两者表现相似，但主观上看起来像 TF-IDF + Chi2 解决方案产生了更好的预测。我对 v1 的结果非常满意，并花费了其余的时间来修复网站的 UI。

你做了哪些有趣的发现？

我学到的一件事是，如果你正在建立一个推荐系统，并期望你的用户一次来评价一堆东西，那么它可以工作 - 你错了。

我在我的朋友们上试过这个网站，虽然评分过程对我来说似乎非常简单和快速，但是很难让他们花几分钟点击“喜欢”按钮。虽然没关系，因为我的主要目标是练习技能并为自己构建一个工具，我想如果我想从中做出更大的东西，我需要弄清楚如何使评级过程更简单。

我学到的另一件事是，为了提高效率，我需要更多地理解算法。当您了解自己在做什么时，调整参数会更有趣。

你想在项目上做什么？

我目前的主要问题是 UI。我想保持简约，但我需要弄清楚如何使评级过程更有趣和方便。事件浏览也可能更好。

完成这部分后，我正在考虑寻找新的事件来源：会议，音乐会等。也许我会为此添加一个移动应用程序。

学到更多

• 项目： hapsradar.com

由于阿尔乔姆。

你有机器学习方面的项目吗？

如果你有一个使用机器学习的侧面项目，并希望像 Artem 一样被推荐，请与我联系。

PyCaret 机器学习的温和介绍

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

PyCaret 是一个 Python 开源机器学习库，旨在使在机器学习项目中执行标准任务变得容易。

它是 R 语言中 Caret 机器学习包的 Python 版本，之所以受欢迎，是因为它允许只需几行代码就可以在给定的数据集上评估、比较和调整模型。

PyCaret 库提供了这些功能，允许 Python 中的机器学习从业者通过单个函数调用在分类或回归数据集上抽查一套标准的机器学习算法。

在本教程中，您将发现用于机器学习的 PyCaret Python 开源库。

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

• PyCaret 是 r .中流行且广泛使用的 Caret 机器学习包的 Python 版本
• 如何使用 PyCaret 轻松评估和比较数据集上的标准机器学习模型。
• 如何使用 PyCaret 轻松调整表现良好的机器学习模型的超参数。

我们开始吧。

机器学习用 PyCaret 的温和介绍
托马斯摄，版权所有。

教程概述

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

1. 什么是 PyCaret？
2. 声纳数据集
3. 比较机器学习模型
4. 调整机器学习模型

什么是 PyCaret？

PyCaret 是一个开源的 Python 机器学习库，灵感来自于 caret R 包。

脱字符号包的目标是自动化评估和比较分类和回归的机器学习算法的主要步骤。该库的主要好处是，只需很少的代码行和很少的手动配置就可以完成很多工作。PyCaret 库将这些功能带到了 Python 中。

PyCaret 是 Python 中的一个开源、低代码的机器学习库，旨在减少从假设到洞察的周期时间。它非常适合经验丰富的数据科学家，他们希望通过在工作流中使用 PyCaret 来提高 ML 实验的生产率，或者适合公民数据科学家和那些对数据科学不太了解或没有编码背景的人。

——pycaret 主页

PyCaret 库自动化了机器学习项目的许多步骤，例如:

• 定义要执行的数据转换(设置())
• 评估和比较标准模型( compare_models() )
• 调谐模型超参数( tune_model() )

以及更多不限于创建集成、保存模型和部署模型的功能。

PyCaret 库有大量使用该应用编程接口的文档；您可以从这里开始:

• PyCaret 主页

在本教程中，我们不会探索该库的所有功能；相反，我们将专注于简单的机器学习模型比较和超参数调整。

您可以使用 Python 包管理器安装 PyCaret，例如 pip。例如:

pip install pycaret

安装后，我们可以通过打印已安装的版本来确认库在您的开发环境中可用并且工作正常。

# check pycaret version
import pycaret
print('PyCaret: %s' % pycaret.__version__)

运行该示例将加载 PyCaret 库并打印安装的版本号。

您的版本号应该相同或更高。

PyCaret: 2.0.0

如果您需要为您的系统安装 PyCaret 的帮助，您可以在此处查看安装说明:

• PyCaret 安装说明

现在我们已经熟悉了 PyCaret 是什么，让我们来探索如何在机器学习项目中使用它。

声纳数据集

我们将使用声纳标准二进制分类数据集。您可以在这里了解更多信息:

• 声纳数据集(声纳. csv)
• 声纳数据集详细信息(声纳.名称)

我们可以直接从网址下载数据集，并将其作为熊猫数据框架加载。

...
# define the location of the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
# load the dataset
df = read_csv(url, header=None)
# summarize the shape of the dataset
print(df.shape)

PyCaret 似乎要求数据集有列名，而我们的数据集没有列名，所以我们可以直接将列号设置为列名。

...
# set column names as the column number
n_cols = df.shape[1]
df.columns = [str(i) for i in range(n_cols)]

最后，我们可以总结前几行数据。

...
# summarize the first few rows of data
print(df.head())

将这些联系在一起，下面列出了加载和总结声纳数据集的完整示例。

# load the sonar dataset
from pandas import read_csv
# define the location of the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
# load the dataset
df = read_csv(url, header=None)
# summarize the shape of the dataset
print(df.shape)
# set column names as the column number
n_cols = df.shape[1]
df.columns = [str(i) for i in range(n_cols)]
# summarize the first few rows of data
print(df.head())

运行该示例首先加载数据集并报告形状，显示它有 208 行和 61 列。

然后打印前五行，显示输入变量都是数字，目标变量是列“60”并带有字符串标签。

(208, 61)
0 1 2 3 4 ... 56 57 58 59 60
0 0.0200 0.0371 0.0428 0.0207 0.0954 ... 0.0180 0.0084 0.0090 0.0032 R
1 0.0453 0.0523 0.0843 0.0689 0.1183 ... 0.0140 0.0049 0.0052 0.0044 R
2 0.0262 0.0582 0.1099 0.1083 0.0974 ... 0.0316 0.0164 0.0095 0.0078 R
3 0.0100 0.0171 0.0623 0.0205 0.0205 ... 0.0050 0.0044 0.0040 0.0117 R
4 0.0762 0.0666 0.0481 0.0394 0.0590 ... 0.0072 0.0048 0.0107 0.0094 R

接下来，我们可以使用 PyCaret 来评估和比较一套标准的机器学习算法，以快速发现什么在这个数据集上运行良好。

用于比较机器学习模型的 PyCaret

在本节中，我们将评估和比较标准机器学习模型在声纳分类数据集上的表现。

首先，我们必须通过 setup()函数用 PyCaret 库设置数据集。这要求我们提供 Pandas DataFrame，并指定包含目标变量的列的名称。

setup() 功能还允许您配置简单的数据准备，例如缩放、幂变换、缺失数据处理和 PCA 变换。

我们将指定数据、目标变量，并关闭 HTML 输出、详细输出和用户反馈请求。

...
# setup the dataset
grid = setup(data=df, target=df.columns[-1], html=False, silent=True, verbose=False)

接下来，我们可以通过调用 compare_models() 函数来比较标准机器学习模型。

默认情况下，它将使用 10 倍交叉验证来评估模型，根据分类精确率对结果进行排序，并返回单个最佳模型。

这些都是不错的违约，我们不需要改变什么。

...
# evaluate models and compare models
best = compare_models()

调用 compare_models() 函数还会报告一个结果表，该表总结了所有被评估的模型及其表现。

最后，我们可以报告表现最佳的模型及其配置。

将这些联系在一起，下面列出了在声纳分类数据集上评估一套标准模型的完整示例。

# compare machine learning algorithms on the sonar classification dataset
from pandas import read_csv
from pycaret.classification import setup
from pycaret.classification import compare_models
# define the location of the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
# load the dataset
df = read_csv(url, header=None)
# set column names as the column number
n_cols = df.shape[1]
df.columns = [str(i) for i in range(n_cols)]
# setup the dataset
grid = setup(data=df, target=df.columns[-1], html=False, silent=True, verbose=False)
# evaluate models and compare models
best = compare_models()
# report the best model
print(best)

运行该示例将加载数据集，配置 PyCaret 库，评估一套标准模型，并报告为数据集找到的最佳模型。

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

在这种情况下，我们可以看到“额外树分类器”在数据集上具有最好的准确性，得分约为 86.95%。

然后我们可以看到所使用的模型的配置，看起来它使用了默认的超参数值。

                              Model  Accuracy     AUC  Recall   Prec.      F1  \
0            Extra Trees Classifier    0.8695  0.9497  0.8571  0.8778  0.8631
1               CatBoost Classifier    0.8695  0.9548  0.8143  0.9177  0.8508
2   Light Gradient Boosting Machine    0.8219  0.9096  0.8000  0.8327  0.8012
3      Gradient Boosting Classifier    0.8010  0.8801  0.7690  0.8110  0.7805
4              Ada Boost Classifier    0.8000  0.8474  0.7952  0.8071  0.7890
5            K Neighbors Classifier    0.7995  0.8613  0.7405  0.8276  0.7773
6         Extreme Gradient Boosting    0.7995  0.8934  0.7833  0.8095  0.7802
7          Random Forest Classifier    0.7662  0.8778  0.6976  0.8024  0.7345
8          Decision Tree Classifier    0.7533  0.7524  0.7119  0.7655  0.7213
9                  Ridge Classifier    0.7448  0.0000  0.6952  0.7574  0.7135
10                      Naive Bayes    0.7214  0.8159  0.8286  0.6700  0.7308
11              SVM - Linear Kernel    0.7181  0.0000  0.6286  0.7146  0.6309
12              Logistic Regression    0.7100  0.8104  0.6357  0.7263  0.6634
13     Linear Discriminant Analysis    0.6924  0.7510  0.6667  0.6762  0.6628
14  Quadratic Discriminant Analysis    0.5800  0.6308  0.1095  0.5000  0.1750

     Kappa     MCC  TT (Sec)
0   0.7383  0.7446    0.1415
1   0.7368  0.7552    1.9930
2   0.6410  0.6581    0.0134
3   0.5989  0.6090    0.1413
4   0.5979  0.6123    0.0726
5   0.5957  0.6038    0.0019
6   0.5970  0.6132    0.0287
7   0.5277  0.5438    0.1107
8   0.5028  0.5192    0.0035
9   0.4870  0.5003    0.0030
10  0.4488  0.4752    0.0019
11  0.4235  0.4609    0.0024
12  0.4143  0.4285    0.0059
13  0.3825  0.3927    0.0034
14  0.1172  0.1792    0.0033
ExtraTreesClassifier(bootstrap=False, ccp_alpha=0.0, class_weight=None,
                     criterion='gini', max_depth=None, max_features='auto',
                     max_leaf_nodes=None, max_samples=None,
                     min_impurity_decrease=0.0, min_impurity_split=None,
                     min_samples_leaf=1, min_samples_split=2,
                     min_weight_fraction_leaf=0.0, n_estimators=100, n_jobs=-1,
                     oob_score=False, random_state=2728, verbose=0,
                     warm_start=False)

我们可以直接使用这种配置，在整个数据集上拟合一个模型，并使用它对新数据进行预测。

我们还可以使用结果表来了解在数据集上表现良好的模型类型，在本例中是决策树的集合。

现在我们已经熟悉了如何使用 PyCaret 比较机器学习模型，让我们看看如何使用该库来调整模型超参数。

调整机器学习模型

在本节中，我们将在声纳分类数据集上调整机器学习模型的超参数。

我们必须像以前比较模型时那样加载和设置数据集。

...
# setup the dataset
grid = setup(data=df, target=df.columns[-1], html=False, silent=True, verbose=False)

我们可以使用 PyCaret 库中的 tune_model() 函数来调整模型超参数。

该函数将模型的一个实例作为输入进行调整，并知道自动调整哪些超参数。执行模型超参数的随机搜索，并且可以通过“ n_iter ”参数控制评估的总数。

默认情况下，该功能将优化“精确率”，并将使用 10 倍交叉验证来评估每个配置的表现，尽管这个合理的默认配置可以更改。

我们可以对额外的树分类器执行如下随机搜索:

...
# tune model hyperparameters
best = tune_model(ExtraTreesClassifier(), n_iter=200)

该函数将返回表现最佳的模型，可直接使用或打印该模型来确定所选的超参数。

它还将打印 k 折叠交叉验证中最佳配置的结果表(例如 10 次折叠)。

将这些联系在一起，下面列出了在声纳数据集上调整额外树分类器的超参数的完整示例。

# tune model hyperparameters on the sonar classification dataset
from pandas import read_csv
from sklearn.ensemble import ExtraTreesClassifier
from pycaret.classification import setup
from pycaret.classification import tune_model
# define the location of the dataset
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv'
# load the dataset
df = read_csv(url, header=None)
# set column names as the column number
n_cols = df.shape[1]
df.columns = [str(i) for i in range(n_cols)]
# setup the dataset
grid = setup(data=df, target=df.columns[-1], html=False, silent=True, verbose=False)
# tune model hyperparameters
best = tune_model(ExtraTreesClassifier(), n_iter=200, choose_better=True)
# report the best model
print(best)

运行该示例首先加载数据集并配置 PyCaret 库。

然后执行网格搜索，报告跨 10 倍交叉验证的最佳配置表现和平均精确率。

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

在这种情况下，我们可以看到，随机搜索找到了一个准确率约为 75.29%的配置，这并不比上一部分的默认配置好，后者的得分约为 86.95%。

      Accuracy     AUC  Recall   Prec.      F1   Kappa     MCC
0       0.8667  1.0000  1.0000  0.7778  0.8750  0.7368  0.7638
1       0.6667  0.8393  0.4286  0.7500  0.5455  0.3119  0.3425
2       0.6667  0.8036  0.2857  1.0000  0.4444  0.2991  0.4193
3       0.7333  0.7321  0.4286  1.0000  0.6000  0.4444  0.5345
4       0.6667  0.5714  0.2857  1.0000  0.4444  0.2991  0.4193
5       0.8571  0.8750  0.6667  1.0000  0.8000  0.6957  0.7303
6       0.8571  0.9583  0.6667  1.0000  0.8000  0.6957  0.7303
7       0.7857  0.8776  0.5714  1.0000  0.7273  0.5714  0.6325
8       0.6429  0.7959  0.2857  1.0000  0.4444  0.2857  0.4082
9       0.7857  0.8163  0.5714  1.0000  0.7273  0.5714  0.6325
Mean    0.7529  0.8270  0.5190  0.9528  0.6408  0.4911  0.5613
SD      0.0846  0.1132  0.2145  0.0946  0.1571  0.1753  0.1485
ExtraTreesClassifier(bootstrap=False, ccp_alpha=0.0, class_weight=None,
                     criterion='gini', max_depth=1, max_features='auto',
                     max_leaf_nodes=None, max_samples=None,
                     min_impurity_decrease=0.0, min_impurity_split=None,
                     min_samples_leaf=4, min_samples_split=2,
                     min_weight_fraction_leaf=0.0, n_estimators=120,
                     n_jobs=None, oob_score=False, random_state=None, verbose=0,
                     warm_start=False)

我们可以通过指定 tune_model() 函数搜索哪些超参数和搜索哪些范围来改进网格搜索。

进一步阅读

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

• PyCaret 主页
• R 脱字符号包主页
• PyCaret 安装说明

摘要

在本教程中，您发现了用于机器学习的 PyCaret Python 开源库。

具体来说，您了解到:

• PyCaret 是 r .中流行且广泛使用的 Caret 机器学习包的 Python 版本
• 如何使用 PyCaret 轻松评估和比较数据集上的标准机器学习模型。
• 如何使用 PyCaret 轻松调整表现良好的机器学习模型的超参数。

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

机器学习中的 Python 生态系统

原文： machinelearningmastery.com/python-ecosystem-machine-learning/

Python 生态系统正在发展，可能成为机器学习的主要平台。

采用 Python 进行机器学习的主要原因是因为它是一种通用编程语言，可以用于研究和开发以及生产。

在这篇文章中，您将发现用于机器学习的 Python 生态系统。

用于机器学习的 Python 生态系统
照片由 Stewart Black 拍摄，保留一些权利。

蟒蛇

Python 是一种通用的解释型编程语言。它易于学习和使用，主要是因为语言侧重于可读性。

Python 的 Zen 中包含了 Python 的哲学，其中包括以下短语：

• 美丽胜过丑陋。
• 显式优于隐式。
• 简单比复杂更好。
• 复杂比复杂更好。
• Flat 优于嵌套。
• 稀疏优于密集。
• 可读性很重要。

您可以通过键入以下内容在 Python 环境中查看 Python 的完整 Zen：

import this

它是一种流行语言，一直出现在 StackOverflow 调查中的前 10 种编程语言中（例如 2015 年调查结果）。它是一种动态语言，非常适合交互式开发和快速原型设计，具有支持大型应用程序开发的能力。

它还广泛用于机器学习和数据科学，因为它具有出色的库支持，并且因为它是一种通用编程语言（与 R 或 Matlab 不同）。例如，请参阅 2011 年 Kaggle 平台调查结果和 KDD Nuggets 2015 工具调查结果的结果。

这是一个简单而非常重要的考虑因素。

这意味着您可以使用您在操作中使用的相同编程语言执行研究和开发（确定要使用的模型）。大大简化了从开发到运营的过渡。

SciPy 的

SciPy 是一个用于数学，科学和工程的 Python 库生态系统。它是 Python 的附加组件，您需要进行机器学习。

SciPy 生态系统由以下与机器学习相关的核心模块组成：

• NumPy ：SciPy 的基础，可让您有效地处理数组中的数据。
• Matplotlib ：允许您从数据创建二维图表和图表。
• pandas ：用于组织和分析数据的工具和数据结构。

要在 Python 中进行机器学习，您必须安装并熟悉 SciPy。特别：

• 您将使用 Pandas 加载探索并更好地了解您的数据。
• 您将使用 Matplotlib（以及其他框架中的 Matplotlib 包装器）来创建数据的图表和图表。
• 您将把数据准备为 NumPy 数组，以便在机器学习算法中进行建模。

您可以在帖子中了解更多关于熊猫的信息使用 Pandas 和使用 Pandas 快速和脏数据分析为 Python 机器学习准备数据。

scikit 学习

scikit-learn 库是如何在 python 中开发和练习机器学习的。

它建立在 SciPy 生态系统的基础之上。名称“scikit”表明它是一个 SciPy 插件或工具包。您可以查看完整的 SciKits 列表。

该库的重点是用于分类，回归，聚类等的机器学习算法。它还为相关任务提供工具，例如评估模型，调整参数和预处理数据。

与 Python 和 SciPy 一样，scikit-learn 是开源的，在 BSD 许可下可以商业使用。这意味着您可以了解机器学习，开发模型并将它们投入到具有相同生态系统和代码的操作中。使用 scikit-learn 的一个有力理由。

您可以在帖子 A scntle introduction to scikit-learn 中了解更多关于 scikit-learn 的信息。

Python 生态系统安装

有多种方法可以安装 Python 生态系统用于机器学习。在本节中，我们将介绍如何安装用于机器学习的 Python 生态系统。

如何安装 Python

第一步是安装 Python。我更喜欢使用和推荐 Python 2.7。

这将特定于您的平台。有关说明，请参阅 Python 初学者指南中的下载 Python 。

安装完成后，您可以确认安装是否成功。打开命令行并键入：

python --version

您应该看到如下响应：

Python 2.7.11

如何安装 SciPy

安装 SciPy 的方法有很多种。例如，两种流行的方法是在您的平台上使用包管理（例如，RedHat 上的 yum 或 OS X 上的 macport）或使用像 pip 这样的 Python 包管理工具。

SciPy 文档非常出色，涵盖了页面上许多不同平台的操作说明安装 SciPy Stack 。

安装 SciPy 时，请确保至少安装以下软件包：

• SciPy 的
• numpy 的
• matplotlib
• 大熊猫

安装后，您可以确认安装是否成功。通过在命令行键入“python”打开 python 交互式环境，然后键入并运行以下 python 代码以打印已安装库的版本。

# 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__)

在发布时我的工作站上看到以下输出。

scipy: 0.17.0
numpy: 1.10.4
matplotlib: 1.5.1
pandas: 0.17.1

你看到什么输出？在评论中发布。

如果您有错误，可能需要查阅适用于您的平台的文档。

如何安装 scikit-learn

我建议您使用相同的方法安装 scikit-learn，就像您以前安装 SciPy 一样。

有安装 scikit-learn 的说明，但它们仅限于使用 Python pip 和 conda 包管理器。

与 SciPy 一样，您可以确认 scikit-learn 已成功安装。启动 Python 交互式环境，键​​入并运行以下代码。

# scikit-learn
import sklearn
print('sklearn: %s' % sklearn.__version__)

它将打印安装的 scikit-learn 库的版本。在我的工作站上，我看到以下输出：

sklearn: 0.17.1

如何安装生态系统：一种更简单的方法

如果您对在计算机上安装软件没有信心，可以选择更方便的选项。

有一个名为 Anaconda 的发行版，您可以免费下载和安装。

它支持 Microsoft Windows，Mac OS X 和 Linux 三个主要平台。

它包括 Python，SciPy 和 scikit-learn。使用 Python 环境学习，练习和使用机器学习所需的一切。

摘要

在这篇文章中，您发现了用于机器学习的 Python 生态系统。

你了解到：

• Python 和它越来越多地用于机器学习。
• SciPy 及其为 NumPy，Matplotlib 和 Pandas 提供的功能。
• scikit-learn 提供所有机器学习算法。

您还学习了如何在工作站上安装用于机器学习的 Python 生态系统。

你对机器学习的 Python 或这篇文章有什么疑问吗？在评论中提出您的问题，我会尽力回答。

Python 是应用机器学习的成长平台

原文： machinelearningmastery.com/python-growing-platform-applied-machine-learning/

你应该为这份工作挑选合适的工具。

您正在处理的特定预测性建模问题应该规定要使用的特定编程语言，库甚至机器学习算法。

但是，如果您刚刚开始并寻找一个学习和练习机器学习的平台怎么办？

在这篇文章中，您将发现 Python 是应用机器学习的增长平台，可能在采用和可能性方面超过和推翻 R.

阅读这篇文章后你会知道：

• Python 机器学习的搜索量正在快速增长，并且已经超过了 R.
• Python 机器学习工作的百分比正在增长，并且已经超过了 R.
• 近 50％的受访专业人士使用 Python 并且不断增长。

让我们开始吧。

用于机器学习的 Python 正在增长

让我们看一下 3 个区域，我们可以看到 Python 用于机器学习的增长：

1. 搜索量。
2. 招聘广告。
3. 专业工具使用。

Python 机器学习搜索量正在增长

搜索量可能表示学生，工程师和其他从业者正在搜索信息以开始或深入了解该主题。

Google 提供了一个名为 Google 趋势的工具，可以深入了解关键字随时间的搜索量。

我们可以研究 2004 年到 2016 年（过去 12 年）“Python 机器学习”的增长。以下是此期间搜索量变化的图表：

Python 机器学习搜索流量的增长

我们可以看到，趋势向上开始于 2012 年，从 2015 年开始陡升，可能受到 TensorFlow 等 Python 深度学习工具的推动。

我们也可以将其与 R 机器学习的搜索量进行对比，我们可以看到，从 2015 年中期开始，Python 机器学习已经击败了 R.

Python 机器学习与 R 机器学习搜索量

蓝色表示“Python 机器学习”，红色表示“R 机器学习”。

Python 机器学习工作正在增长

确实是一个求职网站，就像 Google 趋势一样，它们显示了与关键字匹配的招聘广告数量。

我们可以调查过去 4 年对“蟒蛇机器学习工作”的需求。

Python 机器学习工作的增长

我们可以看到沿 x 轴的时间以及与关键字匹配的职位发布百分比。该图显示了 2012 年至 2015 年的近乎线性增长，2016 年曲棍球棒增加。

我们还可以比较 python 和 R 的招聘广告。

Python 机器学习工作与 R 机器学习工作

蓝色显示“Python 机器学习”，橙色显示“R 机器学习”。

与 Google 搜索量相比，我们看到了更为明显的故事。 Indeed.com 提供的招聘广告百分比表明，至少自 2012 年以来，对于机器学习技能的需求一直主导着 R 机器学习技能，近年来差距只有扩大。

KDNuggets 调查结果：更多人使用 Python 进行机器学习

通过查看 KDnuggets 软件调查结果的结果，我们可以深入了解机器学习从业者使用的工具。

以下是 2016 年业绩报价：

R 仍然是领先的工具，拥有 49％的份额，但 Python 增长更快，几乎赶上了 R.

• Gregory Piatetsky

民意调查跟踪机器学习和数据科学专业人员使用的工具，参与者可以选择多个工具（这是我期望的标准）

以下是过去 4 年中用于机器学习的 Python 的增长：

2016   45.8%
2015   30.3%
2014   19.5%
2013   13.3%

下面是这种增长的情节。

KDNuggets 民意调查结果 - 使用 Python.png 的专业人员百分比

我们可以看到近乎线性的增长趋势，2016 年使用的 Python 仅占不到 50％的专业人士。

值得注意的是，近年来，民意调查的参与者人数也从数百人增加到数千人，参与者是自我选择的。

有趣的是，scikit-learn 也在投票中单独出现，占 17.2％。

有关更多信息，请参阅： KDnuggets 2016 年软件调查结果。

O’Reilly 调查结果：更多人使用 Python 进行机器学习

O’Reilly 每年进行一次数据科学薪酬调查。

他们从专业数据科学家和机器学习从业者那里收集了大量数据，并将结果呈现在非常好的报告中。例如，这里是 2016 年数据科学薪资调查报告 [查看 PDF 报告]。

该调查跟踪从业者的工具使用情况，以及 KDNuggets 数据。

引用 2016 年报告的主要发现，我们可以看到 Python 在数据科学工资中发挥着重要作用。

Python 和 Spark 是最有助于薪水的工具之一。

• 2016 年第 1 页数据科学薪酬调查报告。

回顾调查结果，我们可以看到过去 4 年中使用 Python 生态系统进行机器学习的类似增长趋势。

2016   54%
2015   51%
2014   42% (interpreted from graph)
2013   40%

再次，我们可以描绘这种增长。

O’Reilly 民意调查结果 - 使用 Python.png 的专业人士百分比

有趣的是，2016 年的结果与 KDNuggets 民意调查结果非常相似。

行情

您可以找到支持互联网上任何位置的报价。

拿一粒盐报价。尽管如此，报价可以是有洞察力的，提高和支持点。

让我们先来看看新闻网站和博客中有关机器学习 Python 发展的一些樱桃摘要。

新闻报价

Python 在过去几年中已成为数据科学编程的领导者。虽然仍然有很多人使用 R，SPSS，Julia 或其他几种流行语言，但 Python 在该领域的日益普及在其数据科学库的发展中显而易见。

• Katharine Jarmul，数据科学入门：如何使用 Python“大数据”，Dataconomy

我们的研究表明，Python 是最流行的数据科学分析语言之一，超过三分之一（36％）的组织使用它。

• Dave Menninger，大数据在 Strata + Hadoop World 2016 增长，SmartDataCollective

…过去几年中，已经出现了大量尖端的，商业上可用的机器学习框架，包括非常成功的 scikit-learn Python 库和广为人知的库版本，如 Google 的 Tensorflow 和 Microsoft Research 的 CNTK。

• Josh Schwartz，机器学习不再仅仅是专家，哈佛商业评论

请注意，scikit-learn，TensorFlow 和 CNTK 都是 Python 机器学习库。

Python 功能多样，简单易学，功能强大，因为它在各种环境中都很有用，其中一些与数据科学无关。 R 是一个专门的环境，可以优化数据分析，但更难学习。如果你坚持使用 R 而不是使用 Python，你将获得更多报酬

• Roger Huang，数据科学性感：你的 Python 和 R 指南，哪一个最好，TheNextWeb

Quora 行情

以下是从 Quora 问题中使用 Python 进行机器学习的一些樱桃选择引文。

Python 如果是一种流行的科学语言和机器学习的后起之秀。如果能从 R 中获取数据分析，我会感到惊讶，但 NumPy 中的矩阵处理可能会挑战 MATLAB，而像 IPython 这样的通信工具非常具有吸引力，是未来再现性的一个步骤。我认为用于机器学习和数据分析的 SciPy 栈可以用于一次性项目（如论文），而像 scikit-learn 这样的框架可能已经足够成熟，可以用于生产系统。

• 生产工程师 Aswath Muralidharan。响应 Quora 问题“机器学习的前 5 种编程语言是什么？ “

我还推荐 Python，因为它是一种非常棒的全面编程语言，对于绘制代码片段和探索数据非常有用（使用 IPython shell），非常适合在分析流程链中记录步骤和结果（IPython Notebook），为几乎所有机器学习目标提供了大量库，甚至可以针对生产系统实现进行优化。在我看来，在任何这些类别中都有一些优于 Python 的语言 - 但它们都没有提供这种多功能性。

• Benedikt Koehler，创始人兼 CEO DataLion。回答 Quora 问题“第一次学习机器学习时使用的最佳语言是什么？ “

[…]这是因为语言可以为那些只想快速完成某些事情的人创造一个富有成效的环境。包装 C 库相当容易，而 C ++是可行的。这使 Python 可以访问各种现有代码。当实现事物时，语言也不会妨碍。在许多方面，它使编码“再次有趣”，适用于各种任务。

• Shawn Masters，工程副总裁。响应 Quora 问题“ Python 会变得像 Java 一样流行，因为 Python 用于机器学习吗？ “

在我看来，Python 真正支配这一类别。快速搜索几乎所有人工智能，机器学习，NLP 或数据分析主题，再加上“Python”，将返回有用的，积极维护的库的示例。

• 程序员 Ryan Hill。回答 Quora 问题“哪种编程语言拥有最好的机器学习库存储库？ “

摘要

在这篇文章中，您发现 Python 是应用机器学习的增长平台。

具体来说，您了解到：

• 对机器学习感兴趣的 Python 人数大于 R 并且正在增长。
• 为 Python 机器学习技能发布的作业数量大于 R 并且还在增长。
• 使用 Python 的受访数据科学专业人员数量逐年增长。

这是否影响了您开始使用
Python 生态系统进行机器学习的决定？
在下面的评论中分享您的想法。

Python 机器学习书籍

原文： machinelearningmastery.com/python-machine-learning-books/

Python 是一种非常流行的机器学习语言。

Python 中的机器学习库和框架（特别是围绕 SciPy 栈）正在快速成熟。它们可能不像 R 那样功能丰富，但它们足够强大，适用于中小规模的生产实现。

如果你是一个想要进入机器学习的 Python 程序员，或者你通常有兴趣通过 Python 进入机器学习，那么我想用这篇文章指出一些你可能会觉得对你的旅程有用的重要书籍。

这绝不是一本完整的书籍清单，但我认为如果你对 Python 中的机器学习感兴趣，那么你应该选择这些书籍。

Python 中的机器学习

使用 Python 构建机器学习系统（2013）：掌握使用 Python 进行机器学习的艺术，并使用此强化实践指南构建有效的机器学习系统。

学习 scikit-learn：Python 中的机器学习（2013）：通过使用 Python 和开源 scikit-learn 库将它们应用于实际问题，体验机器学习技术的好处。

机器学习在行动（2012）：机器学习在行动是一本独特的书，它将机器学习的基础理论与构建日常数据分析工具的实际现实相结合。您将使用灵活的 Python 编程语言来构建实现数据分类，预测，建议和更高级功能（如摘要和简化）的算法的程序。

编程集体智慧：构建智能 Web 2.0 应用程序（2007）：这本引人入胜的书演示了如何构建 Web 2.0 应用程序以挖掘人们创建的大量数据互联网。

机器学习：算法视角（2011）：该领域已经准备好了一个文本，不仅演示了如何使用构成机器学习方法的算法，还提供了理解如何以及为什么需要的背景这些算法有效。机器学习：算法视角就是文本。

Python 中的专业机器学习

挖掘社交网络：数据挖掘 Facebook，Twitter，LinkedIn，Google +，GitHub 等（2013）：您将学习如何获取，分析和总结来自社交网络各个角落的数据，包括 Facebook，Twitter，LinkedIn，Google +，GitHub，电子邮件，网站和博客。

Python 自然语言处理（2009）：本书提供了一个高度可访问的自然语言处理介绍，该领域支持各种语言技术，从预测文本和电子邮件过滤到自动摘要和翻译。

使用 Python 编程计算机视觉：用于分析图像的工具和算法（2012）：如果您想要对计算机视觉的基础理论和算法有基本的了解，那么这种实践性的介绍是理想的起点。当您遵循用 Python 编写的清晰示例时，您将学习对象识别，3D 重建，立体成像，增强现实和其他计算机视觉应用程序的技术。

用于数据分析的 Python：与 Pandas，NumPy 和 IPython 进行数据争夺（2012）：它也是一个实用的，现代的 Python 科学计算入门，专为数据量身定制密集的应用程序。这是一本关于 Python 语言部分的书和有效解决大量数据分析问题所需的库。本书不是对使用 Python 作为实现语言的分析方法的阐述。

我是否错过了必读的 Python 机器学习书？发表评论并告诉我。

Python 机器学习迷你课程

原文： machinelearningmastery.com/python-machine-learning-mini-course/

_14 天内从开发人员到机器学习从业者 _

Python 是应用机器学习增长最快的平台之一。

在这个迷你课程中，您将了解如何入门，构建准确的模型，并在 14 天内使用 Python 自信地完成预测性建模机器学习项目。

这是一个重要且重要的帖子。您可能想要将其加入书签。

让我们开始吧。

• 2016 年 10 月更新：更新了 sklearn v0.18 的示例。
• 2018 年 2 月更新：更新 Python 和库版本。
• 更新 March / 2018 ：添加了备用链接以下载某些数据集，因为原件似乎已被删除。

Python 机器学习迷你课程
摄影： Dave Young ，保留一些权利。

这个迷你课程是谁？

在我们开始之前，让我们确保您在正确的位置。

以下列表提供了有关本课程设计对象的一般指导原则。

如果你没有完全匹配这些点，请不要惊慌，你可能只需要在一个或另一个区域刷新以跟上。

• 开发人员知道如何编写一些代码。这意味着一旦您了解基本语法，就可以获得像 Python 这样的新编程语言。这并不意味着你是一个向导编码器，只是你可以毫不费力地遵循基本的 C 语言。
• 知道一点机器学习的开发人员。这意味着您了解机器学习的基础知识，如交叉验证，一些算法和偏方差权衡。这并不意味着你是一个机器学习博士，只是你知道地标或知道在哪里查找它们。

这个迷你课程既不是 Python 的教科书，也不是机器学习的教科书。

它将把你从一个知道一点机器学习的开发人员带到一个开发人员，他可以使用 Python 生态系统获得结果，这是一个不断上升的专业机器学习平台。

迷你课程概述

这个迷你课程分为 14 节课。

您可以每天完成一节课（推荐）或在一天内完成所有课程（硬核！）。这取决于你有空的时间和你的热情程度。

以下是 14 个课程，通过 Python 中的机器学习，可以帮助您开始并提高工作效率：

• 第 1 课：下载并安装 Python 和 SciPy 生态系统。
• 第 2 课：在 Python，NumPy，Matplotlib 和 Pandas 中徘徊。
• 第 3 课：从 CSV 加载数据。
• 第 4 课：通过描述性统计理解数据。
• 第 5 课：用可视化理解数据。
• 第 6 课：通过预处理数据准备建模。
• 第 7 课：采用重采样方法的算法评估。
• 第 8 课：算法评估指标。
• 第 9 课：采样检查算法。
• 第 10 课：模型比较和选择。
• 第 11 课：通过算法调整提高准确度。
• 第 12 课：通过集合预测提高准确度。
• 第 13 课：完成并保存你的模型。
• 第 14 课：Hello World 端到端项目。

每节课可能需要 60 秒或 30 分钟。花点时间，按照自己的进度完成课程。在下面的评论中提出问题甚至发布结果。

课程期望你去学习如何做事。我会给你提示，但每节课的部分内容是强迫你学习去哪里寻求 Python 平台的帮助（提示，我直接在这个博客上有所有的答案，使用搜索特征）。

我确实在早期课程中提供了更多帮助，因为我希望你建立一些自信和惯性。

挂在那里，不要放弃！

第 1 课：下载并安装 Python 和 SciPy

在您访问平台之前，您无法开始使用 Python 进行机器学习。

今天的课程很简单，您必须在计算机上下载并安装 Python 3.6 平台。

访问 Python 主页并下载适用于您的操作系统（Linux，OS X 或 Windows）的 Python。在您的计算机上安装 Python。您可能需要使用特定于平台的软件包管理器，例如 OS X 上的 macport 或 RedHat Linux 上的 yum。

您还需要安装 SciPy 平台和 scikit-learn 库。我建议使用与安装 Python 相同的方法。

您可以使用 Anaconda 一次安装（更容易）。推荐给初学者。

通过在命令行键入“python”，首次启动 Python。

使用以下代码检查您需要的所有版本：

# 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__))

如果有任何错误，请停止。现在是时候解决它们了。

需要帮忙？看本教程：

• 如何使用 Anaconda 设置用于机器学习和深度学习的 Python 环境

第 2 课：在 Python，NumPy，Matplotlib 和 Pandas 中解决。

您需要能够读取和编写基本的 Python 脚本。

作为开发人员，您可以非常快速地学习新的编程语言。 Python 区分大小写，使用散列（＃）进行注释，并使用空格来表示代码块（空白很重要）。

今天的任务是在 Python 交互式环境中练习 Python 编程语言的基本语法和重要的 SciPy 数据结构。

• 练习分配，使用 Python 中的列表和流控制。
• 练习使用 NumPy 数组。
• 练习在 Matplotlib 中创建简单的图。
• 练习使用 Pandas Series 和 DataFrames。

例如，下面是创建 Pandas DataFrame 的简单示例。

# dataframe
import numpy
import pandas
myarray = numpy.array([[1, 2, 3], [4, 5, 6]])
rownames = ['a', 'b']
colnames = ['one', 'two', 'three']
mydataframe = pandas.DataFrame(myarray, index=rownames, columns=colnames)
print(mydataframe)

第 3 课：从 CSV 加载数据

机器学习算法需要数据。您可以从 CSV 文件加载自己的数据，但是当您开始使用 Python 进行机器学习时，您应该在标准机器学习数据集上练习。

今天课程的任务是将数据加载到 Python 中以及查找和加载标准机器学习数据集。

有许多优秀的 CSV 格式标准机器学习数据集，您可以在 UCI 机器学习库上下载和练习。

• 使用标准库中的 CSV.reader（）练习将 CSV 文件加载到 Python 中。
• 练习使用 NumPy 和 numpy.loadtxt（）函数加载 CSV 文件。
• 练习使用 Pandas 和 pandas.read_csv（）函数加载 CSV 文件。

为了帮助您入门，下面是一个片段，它将直接从 UCI 机器学习库使用 Pandas 加载 Pima 印第安人糖尿病数据集。

# 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)

做得好到目前为止！在那里挂。

到目前为止有任何问题吗？在评论中提问。

第 4 课：使用描述性统计量理解数据

将数据加载到 Python 后，您需要能够理解它。

您可以越好地理解数据，您可以构建的模型越好，越准确。理解数据的第一步是使用描述性统计。

今天，您的课程是学习如何使用描述性统计量来理解您的数据。我建议使用 Pandas DataFrame 上提供的辅助函数。

• 使用 **head（）**功能了解您的数据，查看前几行。
• 使用 shape 属性查看数据的尺寸。
• 使用 dtypes 属性查看每个属性的数据类型。
• 使用 **describe（）**功能查看数据分布。
• 使用 **corr（）**函数计算变量之间的成对相关性。

以下示例加载 Pima 印第安人糖尿病数据集的开始并总结每个属性的分布。

# Statistical Summary
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)
description = data.describe()
print(description)

试一试！

第 5 课：使用可视化理解数据

从昨天的课程开始，您必须花时间更好地了解您的数据。

提高对数据理解的第二种方法是使用数据可视化技术（例如绘图）。

今天，您的课程是学习如何在 Python 中使用绘图来理解单独的属性及其交互。同样，我建议使用 Pandas DataFrame 上提供的辅助函数。

• 使用 **hist（）**功能创建每个属性的直方图。
• 使用**图（kind =‘box’）**功能创建每个属性的盒须图。
• 使用 **pandas.scatter_matrix（）**函数创建所有属性的成对散点图。

例如，下面的代码片段将加载糖尿病数据集并创建数据集的散点图矩阵。

# Scatter Plot Matrix
import matplotlib.pyplot as plt
import pandas
from pandas.plotting import scatter_matrix
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)
scatter_matrix(data)
plt.show()

样本散点图矩阵

第 6 课：通过预处理数据准备建模

您的原始数据可能未设置为建模的最佳形状。

有时您需要预处理数据，以便最好地将数据中问题的固有结构呈现给建模算法。在今天的课程中，您将使用 scikit-learn 提供的预处理功能。

scikit-learn 库提供了两种用于转换数据的标准习语。每种变换在不同情况下都很有用：拟合和多变换以及组合拟合和变换。

您可以使用许多技术来准备建模数据。例如，尝试以下某些操作

• 使用比例和中心选项标准化数值数据（例如，平均值为 0，标准差为 1）。
• 使用范围选项标准化数值数据（例如，范围为 0-1）。
• 探索更高级的功能工程，例如二值化。

例如，下面的代码片段加载 Pima Indians 糖尿病数据集，计算标准化数据所需的参数，然后创建输入数据的标准化副本。

# Standardize data (0 mean, 1 stdev)
from sklearn.preprocessing import StandardScaler
import pandas
import numpy
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pandas.read_csv(url, names=names)
array = dataframe.values
# separate array into input and output components
X = array[:,0:8]
Y = array[:,8]
scaler = StandardScaler().fit(X)
rescaledX = scaler.transform(X)
# summarize transformed data
numpy.set_printoptions(precision=3)
print(rescaledX[0:5,:])

第 7 课：使用重采样方法进行算法评估

用于训练机器学习算法的数据集称为训练数据集。用于训练算法的数据集不能用于为您提供有关新数据模型准确率的可靠估计。这是一个很大的问题，因为创建模型的整个想法是对新数据做出预测。

您可以使用称为重采样方法的统计方法将训练数据集拆分为子集，一些用于训练模型，另一些则用于估计模型对未见数据的准确率。

今天课程的目标是练习使用 scikit-learn 中提供的不同重采样方法，例如：

• 将数据集拆分为训练和测试集。
• 使用 k 折交叉验证估算算法的准确率。
• 使用留一交叉验证估算算法的准确率。

下面的片段使用 scikit-learn 使用 10 倍交叉验证来估计 Pima Indians 糖尿病数据集开始时 逻辑回归算法的准确率。

# Evaluate using Cross Validation
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
kfold = KFold(n_splits=10, random_state=7)
model = LogisticRegression()
results = cross_val_score(model, X, Y, cv=kfold)
print("Accuracy: %.3f%% (%.3f%%)") % (results.mean()*100.0, results.std()*100.0)

你得到了什么准确度？请在评论中告诉我。

您是否意识到这是中途点？做得好！

第 8 课：算法评估指标

您可以使用许多不同的度量标准来评估数据集上的机器学习算法的技能。

您可以通过 **cross_validation.cross_val_score（）**函数在 scikit-learn 中指定用于测试工具的度量标准，默认值可用于回归和分类问题。今天课程的目标是练习使用 scikit-learn 包中提供的不同算法表现指标。

• 练习在分类问题上使用 Accuracy 和 LogLoss 指标。
• 练习生成混淆矩阵和分类报告。
• 练习在回归问题上使用 RMSE 和 RSquared 指标。

下面的片段演示了计算皮马印第安人糖尿病数据集开始时的 LogLoss 指标。

# Cross Validation Classification LogLoss
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
kfold = KFold(n_splits=10, random_state=7)
model = LogisticRegression()
scoring = 'neg_log_loss'
results = cross_val_score(model, X, Y, cv=kfold, scoring=scoring)
print("Logloss: %.3f (%.3f)") % (results.mean(), results.std())

你得到了什么日志损失？请在评论中告诉我。

第 9 课：采样检查算法

您不可能事先知道哪种算法在您的数据上表现最佳。

你必须使用反复试验的过程来发现它。我称这种点检算法。 scikit-learn 库提供了许多机器学习算法和工具的接口，用于比较这些算法的估计精度。

在本课程中，您必须练习现场检查不同的机器学习算法。

• 点检数据集上的线性算法（例如线性回归，逻辑回归和线性判别分析）。
• 在数据集上检查一些非线性算法（例如 KNN，SVM 和 CART）。
• 在数据集上对一些复杂的集成算法进行抽查（例如随机森林和随机梯度增强）。

例如，下面的片段在波士顿房价数据集上点检查 K 最近邻 算法。

# KNN Regression
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.neighbors import KNeighborsRegressor
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.data"
names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV']
dataframe = read_csv(url, delim_whitespace=True, names=names)
array = dataframe.values
X = array[:,0:13]
Y = array[:,13]
kfold = KFold(n_splits=10, random_state=7)
model = KNeighborsRegressor()
scoring = 'neg_mean_squared_error'
results = cross_val_score(model, X, Y, cv=kfold, scoring=scoring)
print(results.mean())

你得到的误差是什么意思？请在评论中告诉我。

第 10 课：模型比较和选择

现在您已了解如何在数据集上查看机器学习算法，您需要知道如何比较不同算法的估计表现并选择最佳模型。

在今天的课程中，您将练习比较 Python 中的机器学习算法与 scikit-learn 的准确率。

• 在数据集上比较线性算法。
• 在数据集上比较非线性算法。
• 将相同算法的不同配置相互比较。
• 创建比较算法的结果图。

以下示例将 Pima Indians 糖尿病数据集开始时的 逻辑回归和线性判别分析相互比较。

# Compare Algorithms
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
# prepare models
models = []
models.append(('LR', LogisticRegression()))
models.append(('LDA', LinearDiscriminantAnalysis()))
# evaluate each model in turn
results = []
names = []
scoring = 'accuracy'
for name, model in models:
	kfold = KFold(n_splits=10, random_state=7)
	cv_results = cross_val_score(model, X, Y, cv=kfold, scoring=scoring)
	results.append(cv_results)
	names.append(name)
	msg = "%s: %f (%f)" % (name, cv_results.mean(), cv_results.std())
	print(msg)

哪种算法效果更好？你能做得更好吗？请在评论中告诉我。

第 11 课：通过算法调整提高准确率

一旦找到一个或两个在数据集上表现良好的算法，您可能希望提高这些模型的表现。

提高算法表现的一种方法是将其参数调整为特定数据集。

scikit-learn 库提供了两种搜索机器学习算法参数组合的方法。今天课程的目标是练习每一个。

• 使用您指定的网格搜索调整算法的参数。
• 使用随机搜索调整算法的参数。

下面使用的片段是在皮马印第安人糖尿病数据集开始时使用网格搜索岭回归算法的示例。

# Grid Search for Algorithm Tuning
from pandas import read_csv
import numpy
from sklearn.linear_model import Ridge
from sklearn.model_selection import GridSearchCV
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
alphas = numpy.array([1,0.1,0.01,0.001,0.0001,0])
param_grid = dict(alpha=alphas)
model = Ridge()
grid = GridSearchCV(estimator=model, param_grid=param_grid)
grid.fit(X, Y)
print(grid.best_score_)
print(grid.best_estimator_.alpha)

哪些参数达到了最佳效果？你能做得更好吗？请在评论中告诉我。

第 12 课：使用集合预测提高准确率

另一种可以提高模型表现的方法是组合多个模型的预测。

有些型号提供内置的这种功能，例如用于装袋的随机森林和用于增强的随机梯度增强。另一种称为投票的集合可用于将来自多个不同模型的预测组合在一起。

在今天的课程中，您将练习使用整体方法。

• 使用随机森林和额外树木算法练习套袋合奏。
• 使用梯度增强机和 AdaBoost 算法练习增强乐团。
• 通过将多个模型的预测结合在一起来实践投票合奏。

下面的代码片段演示了如何在皮马印第安人糖尿病数据集中使用随机森林算法（袋装决策树集合）。

# Random Forest Classification
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
num_trees = 100
max_features = 3
kfold = KFold(n_splits=10, random_state=7)
model = RandomForestClassifier(n_estimators=num_trees, max_features=max_features)
results = cross_val_score(model, X, Y, cv=kfold)
print(results.mean())

你能设计一个更好的合奏吗？请在评论中告诉我。

第 13 课：完成并保存模型

一旦在机器学习问题上找到了表现良好的模型，就需要完成它。

在今天的课程中，您将练习与完成模型相关的任务。

练习使用您的模型对新数据做出预测（在训练和测试期间看不到的数据）。
练习保存训练有素的模型进行归档并重新加载。

例如，下面的代码段显示了如何创建 逻辑回归模型，将其保存到文件，然后稍后加载并对未见数据做出预测。

# Save Model Using Pickle
from pandas import read_csv
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
import pickle
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = read_csv(url, names=names)
array = dataframe.values
X = array[:,0:8]
Y = array[:,8]
test_size = 0.33
seed = 7
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)
# Fit the model on 33%
model = LogisticRegression()
model.fit(X_train, Y_train)
# save the model to disk
filename = 'finalized_model.sav'
pickle.dump(model, open(filename, 'wb'))

# some time later...

# load the model from disk
loaded_model = pickle.load(open(filename, 'rb'))
result = loaded_model.score(X_test, Y_test)
print(result)

第 14 课：Hello World 端到端项目

您现在知道如何完成预测性建模机器学习问题的每个任务。

在今天的课程中，您需要练习将各个部分组合在一起，并通过端到端的标准机器学习数据集进行操作。

完成虹膜数据集端到端（机器学习的 hello 世界）

这包括以下步骤：

1. 使用描述性统计和可视化了解您的数据。
2. 预处理数据以最好地揭示问题的结构。
3. 使用您自己的测试工具对许多算法进行抽查。
4. 使用算法参数调整改善结果。
5. 使用集合方法改善结果。
6. 最终确定模型以备将来使用。

慢慢来，并记录您的结果。

你用的是什么型号的？你得到了什么结果？请在评论中告诉我。

结束！

（_ 看你有多远 _）

你做到了。做得好！

花点时间回顾一下你到底有多远。

• 您开始对机器学习感兴趣，并希望能够使用 Python 练习和应用机器学习。
• 您下载，安装并启动了 Python，这可能是第一次并开始熟悉该语言的语法。
• 在一些课程中，您慢慢地，稳定地学习了预测性建模机器学习项目的标准任务如何映射到 Python 平台上。
• 基于常见机器学习任务的秘籍，您使用 Python 端到端地完成了第一次机器学习问题。
• 使用标准模板，您收集的秘籍和经验现在能够自己完成新的和不同的预测性建模机器学习问题。

不要轻视这一点，你在很短的时间内走了很长的路。

这只是您使用 Python 进行机器学习之旅的开始。继续练习和发展你的技能。

摘要

你是如何使用迷你课程的？
你喜欢这个迷你课吗？

你有任何问题吗？有没有任何问题？
让我知道。在下面发表评论。