scikit-learn对机器学习的介绍

scikit-learn对机器学习的介绍

在本节中，我们将介绍 我们在整个scikit-learn中使用的机器学习词汇，并给出一个简单的学习示例。

机器学习：问题设置

通常，学习问题考虑一组n 个数据样本，然后尝试预测未知数据的属性。如果每个样本不止一个数字，例如，多维条目（也称为多变量 数据），则称其具有多个属性或特征。

学习问题分为几类：

监督学习，其中数据带有我们想要预测的其他属性（点击此处 转到scikit-learn监督学习页面）。这个问题可以是：

分类：样本属于两个或更多类，我们希望从已标记的数据中学习如何预测未标记数据的类别。分类问题的一个例子是手写数字识别，其中目的是将每个输入矢量分配给有限数量的离散类别之一。考虑分类的另一种方式是作为一种离散（相对于连续）形式的监督学习，其中一种类型的类别有限，并且对于所提供的n个样本中的每一个，一种是尝试用正确的类别或类别标记它们。 。
回归：如果所需的输出由一个或多个连续变量组成，则该任务称为回归。回归问题的一个例子是预测鲑鱼的长度作为其年龄和体重的函数。
无监督学习，其中训练数据由一组输入向量x组成，没有任何相应的目标值。这些问题的目标可能是发现数据中的类似示例组，称为聚类，或确定输入空间内的数据分布，称为 密度估计，或从高维投影数据为了可视化的目的，将空间缩小到两维或三维 （单击此处 转到Scikit-Learn无监督学习页面）。

训练集和测试集
机器学习是关于学习数据集的一些属性，然后针对另一个数据集测试这些属性。机器学习的一种常见做法是通过将数据集拆分为两个来评估算法。我们将其中一组称为训练集，我们在其中学习一些属性; 我们将另一组称为测试集，我们在其上测试学习的属性。

加载示例数据集

scikit-learn附带一些标准数据集，例如 用于分类的 iris和digits数据集以及用于回归的波士顿房价数据集。

在下文中，我们从shell启动Python解释器，然后加载iris和digits数据集。我们的符号约定是 $表示shell提示符，同时>>>表示Python解释器提示符：

$ python
>>> from sklearn import datasets
>>> iris = datasets.load_iris()
>>> digits = datasets.load_digits()

数据集是一个类似字典的对象，它包含所有数据和一些有关数据的元数据。此数据存储在.data成员中，该成员是一个数组。在监督问题的情况下，一个或多个响应变量存储在成员中。有关不同数据集的更多详细信息，请参见专用部分。n_samples,n_features.target

例如，在数字数据集的情况下digits.data，可以访问可用于对数字样本进行分类的功能：

>>> print(digits.data)  
[[ 0.   0.   5. ...   0.   0.   0.]
 [ 0.   0.   0. ...  10.   0.   0.]
 [ 0.   0.   0. ...  16.   9.   0.]
 ...
 [ 0.   0.   1. ...   6.   0.   0.]
 [ 0.   0.   2. ...  12.   0.   0.]
 [ 0.   0.  10. ...  12.   1.   0.]]

并digits.target给出数字数据集的基本事实，即我们试图学习的每个数字图像对应的数字：

>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])

数据数组的形状

尽管原始数据可能具有不同的形状，但数据始终是2D阵列形状。在数字的情况下，每个原始样本是形状的图像，可以使用以下方法访问：(n_samples, n_features)(8, 8)

 >>> digits.images[0]  
    array([[  0.,   0.,   5.,  13.,   9.,   1.,   0.,   0.],
           [  0.,   0.,  13.,  15.,  10.,  15.,   5.,   0.],
           [  0.,   3.,  15.,   2.,   0.,  11.,   8.,   0.],
           [  0.,   4.,  12.,   0.,   0.,   8.,   8.,   0.],
           [  0.,   5.,   8.,   0.,   0.,   9.,   8.,   0.],
           [  0.,   4.,  11.,   0.,   1.,  12.,   7.,   0.],
           [  0.,   2.,  14.,   5.,  10.,  12.,   0.,   0.],
           [  0.,   0.,   6.,  13.,  10.,   0.,   0.,   0.]])

这个数据集上的简单示例说明了如何从原始问题开始，可以在scikit-learn中对数据进行整形。

从外部数据集加载

要从外部数据集加载，请参阅加载外部数据集。

学习和预测

在数字数据集的情况下，任务是在给定图像的情况下预测它代表的数字。我们给予每个上，我们在10级可能的类（数字0到9）的样品适合的 估计要能预测 到看不见的样本所属的类。

在scikit-learn中，用于分类的估计器是一个实现方法和的方法的Python对象。fit(X, y)predict(T)

估计器的一个示例是sklearn.svm.SVC实现支持向量分类的类。估算器的构造函数将模型的参数作为参数。

现在，我们将估算器视为一个黑盒子：

>>> from sklearn import svm
>>> clf = svm.SVC(gamma=0.001, C=100.)

选择模型的参数

在此示例中，我们设置gamma手动值。要为这些参数找到合适的值，我们可以使用网格搜索和交叉验证等工具。

clf（用于分类器）估计实例首次拟合至该模型; 也就是说，它必须从模型中学习。这是通过将我们的训练集传递给fit方法来完成的。对于训练集，我们将使用来自数据集的所有图像，除了最后一张图像，我们将为预测保留这些图像。我们使用[:-1]Python语法选择训练集，该语法生成一个新数组，其中包含除以下项之外的所有项digits.data：

>>> clf.fit(digits.data[:-1], digits.target[:-1])  
SVC(C=100.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma=0.001, kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

现在您可以预测新值。在这种情况下，您将预测使用最后一张图片digits.data。通过预测，您将确定训练集中与最后一个图像最匹配的图像。

>>> clf.predict(digits.data[-1:])
array([8])

相应的图片是：添加链接描述

正如您所看到的，这是一项具有挑战性的任务：毕竟，图像的分辨率很低。你同意分类器吗？

可以使用此分类问题的完整示例作为您可以运行和学习的示例： 识别手写数字。

模型持久性

通过使用Python的内置持久性模型pickle，可以在scikit-learn中保存模型：

>>> from sklearn import svm
>>> from sklearn import datasets
>>> clf = svm.SVC(gamma='scale')
>>> iris = datasets.load_iris()
>>> X, y = iris.data, iris.target
>>> clf.fit(X, y)  
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

>>> import pickle
>>> s = pickle.dumps(clf)
>>> clf2 = pickle.loads(s)
>>> clf2.predict(X[0:1])
array([0])
>>> y[0]
0

在scikit-learn的特定情况下，使用joblib替换pickle（joblib.dump＆joblib.load）可能更有趣，这对于大数据更有效但它只能腌制到磁盘而不是字符串：

>>> from joblib import dump, load
>>> dump(clf, 'filename.joblib') 

稍后，您可以使用以下命令重新加载pickled模型（可能在另一个Python进程中）

>>> clf  =  load （'filename.joblib' ）

注意 joblib.dump和joblib.load函数也接受类文件对象而不是文件名。有关使用Joblib的数据持久性的更多信息，请参见此处。

请注意，pickle存在一些安全性和可维护性问题。有关使用scikit-learn的模型持久性的更多详细信息，请参阅模型持久性一节。

约定

scikit-learn估算器遵循某些规则，使其行为更具预测性。这些在通用术语和API元素的术语表中有更详细的描述。

类型转换

除非另有说明，否则输入将被转换为float64：

>>> import numpy as np
>>> from sklearn import random_projection

>>> rng = np.random.RandomState(0)
>>> X = rng.rand(10, 2000)
>>> X = np.array(X, dtype='float32')
>>> X.dtype
dtype('float32')

>>> transformer = random_projection.GaussianRandomProjection()
>>> X_new = transformer.fit_transform(X)
>>> X_new.dtype
dtype('float64')

在这个例子中，X是float32，被施放float64的 fit_transform(X)。

投射回归目标float64并保持分类目标：

>>>
>>> from sklearn import datasets
>>> from sklearn.svm import SVC
>>> iris = datasets.load_iris()
>>> clf = SVC(gamma='scale')
>>> clf.fit(iris.data, iris.target)  
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

>>> list(clf.predict(iris.data[:3]))
[0, 0, 0]

>>> clf.fit(iris.data, iris.target_names[iris.target])  
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

>>> list(clf.predict(iris.data[:3]))  
['setosa', 'setosa', 'setosa']

这里，第一个predict()返回一个整数数组，因为iris.target （整数数组）用于fit。第二个predict()返回一个字符串数组，因为iris.target_names是为了拟合。

改装和更新参数

估计器的超参数可以在通过set_params（）方法构造之后更新。fit()多次呼叫将覆盖以前的学习内容fit()：

>>>
>>> import numpy as np
>>> from sklearn.datasets import load_iris
>>> from sklearn.svm import SVC
>>> X, y = load_iris(return_X_y=True)

>>> clf = SVC()
>>> clf.set_params(kernel='linear').fit(X, y)  
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
  kernel='linear', max_iter=-1, probability=False, random_state=None,
  shrinking=True, tol=0.001, verbose=False)
>>> clf.predict(X[:5])
array([0, 0, 0, 0, 0])

>>> clf.set_params(kernel='rbf', gamma='scale').fit(X, y)  
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)
>>> clf.predict(X[:5])
array([0, 0, 0, 0, 0])

这里，在构造估计器之后，rbf首先将默认内核更改为linearvia SVC.set_params()，然后将其更改回rbf以重新构造估计器并进行第二次预测。

多类与多标签拟合

使用时，执行的学习和预测任务取决于适合的目标数据的格式：multiclass classifiers

>>>
>>> from sklearn.svm import SVC
>>> from sklearn.multiclass import OneVsRestClassifier
>>> from sklearn.preprocessing import LabelBinarizer

>>> X = [[1, 2], [2, 4], [4, 5], [3, 2], [3, 1]]
    >>> y = [0, 0, 1, 1, 2]

>>> classif = OneVsRestClassifier(estimator=SVC(gamma='scale',
...                                             random_state=0))
>>> classif.fit(X, y).predict(X)
array([0, 0, 1, 1, 2])

在上面的情况中，分类器适合于1d多类标签阵列，predict()因此该方法提供相应的多类预测。它也可以适用于二维标签指示符的二维数组：:

>>>
>>> y = LabelBinarizer().fit_transform(y)
>>> classif.fit(X, y).predict(X)
array([[1, 0, 0],
       [1, 0, 0],
       [0, 1, 0],
       [0, 0, 0],
       [0, 0, 0]])

这里，分类器是fit() 上的2D二进制标记表示y，使用LabelBinarizer。在这种情况下，predict()返回表示相应多标记预测的2d数组。

请注意，第四个和第五个实例返回全零，表示它们不匹配三个标签fit。使用多标签输出，同样可以为实例分配多个标签：

>>>
>>> from sklearn.preprocessing import MultiLabelBinarizer
>>> y = [[0, 1], [0, 2], [1, 3], [0, 2, 3], [2, 4]]
>>> y = MultiLabelBinarizer().fit_transform(y)
>>> classif.fit(X, y).predict(X)
array([[1, 1, 0, 0, 0],
       [1, 0, 1, 0, 0],
       [0, 1, 0, 1, 0],
       [1, 0, 1, 0, 0],
       [1, 0, 1, 0, 0]])

在这种情况下，分类器适合于每个分配了多个标签的实例。所述MultiLabelBinarizer用于multilabels的2D阵列以二进制化fit时。因此， predict()返回具有每个实例的多个预测标签的二维数组。