机器学习：问题设置

源自： http://scikit-learn.org/stable/tutorial/basic/tutorial.html

Machine learning: the problem setting

In general, a learning problem considers a set of n samples of data and then tries to predict properties of unknown data. If each sample is more than a single number and, for instance, a multi-dimensional entry (aka multivariate data), it is said to have several attributes or features.
一般来说，学习问题需要考虑一组n个样本的数据，然后尝试预测未知数据的属性。如果每个样本不止一个数字，例如，多维条目（也称为多元数据），则称其具有多个属性或特征
We can separate learning problems in a few large categories:
我们可以将学习问题分为几大类：
supervised learning, in which the data comes with additional attributes that we want to predict (Click here to go to the scikit-learn supervised learning page).This problem can be either:
监督学习，其中数据带有我们想要预测的其它属性（。。。）
classification: samples belong to two or more classes and we want to learn from already labeled data how to predict the class of unlabeled data. An example of classification problem would be the handwritten digit recognition example, in which the aim is to assign each input vector to one of a finite number of discrete categories. Another way to think of classification is as a discrete (as opposed to continuous) form of supervised learning where one has a limited number of categories and for each of the n samples provided, one is to try to label them with the correct category or class.
分类：样本属于两个或多个类，我们想从已经标记的数据去预测未标记数据的类。分类问题的一个例子是手写数字识别的例子，其目的是将每个输入向量分配给有限的离散类别之一。另一种考虑分类的方法是作为一种离散的形式的监督学习，其中一个分类的数量有限，对于提供n个样本中的每一个，一个是试图用正确的分类或类别来标记他们
regression: if the desired output consists of one or more continuous variables, then the task is called regression. An example of a regression problem would be the prediction of the length of a salmon as a function of its age and weight.
回归：如果需要的输出由一个或多个连续的变量组成，则该任务称为回归。一个递归问题的例子是鲑鱼的长度作为其年龄和体重的函数的预测
unsupervised learning, in which the training data consists of a set of input vectors x without any corresponding target values. The goal in such problems may be to discover groups of similar examples within the data, where it is called clustering, or to determine the distribution of data within the input space, known as density estimation, or to project the data from a high-dimensional space down to two or three dimensions for the purpose of visualization (Click here to go to the Scikit-Learn unsupervised learning page).
无监督学习，其中训练数据由一组没有任何相应目标值的输入向量组成。这些问题的目标可能是发现数据中类似例子的集合，称为聚类，或者确定输入空间内的数据分布，称为密度估计，或者为了可视化效果将数据从高维空间投影到二维或三维
Training set and testing set
训练集和测试集
Machine learning is about learning some properties of a data set and applying them to new data. This is why a common practice in machine learning to evaluate an algorithm is to split the data at hand into two sets, one that we call the training set on which we learn data properties and one that we call the testing set on which we test these properties.
机器学习是关于学习数据集的一些属性并应用到新数据。这就是为什么机器学习中评估算法的一个常见做法是将手头的数据分成两组，一种称为训练集，我们学习数据属性
Loading an example dataset
加载示例数据集
scikit-learn comes with a few standard datasets, for instance the iris and digits datasets for classification and the boston house prices dataset for regression.
scikit-learn 带有一些标准数据集，例如用于分类的虹膜和数字数据集以及用于回归的波士顿房价数据集
In the following, we start a Python interpreter from our shell and then load the iris and digits datasets. Our notational convention is that $ denotes the shell prompt while >>> denotes the Python interpreter prompt:
在下面，我们从我们的shell启动一个python解释器，然后加载虹膜和数字数据集。我们的符号约定是$表示shell提示符，而>>>表示Python解释器提示符.
$ python
>>> from sklearn import datasets
>>> iris = datasets.load_iris()
>>> digits = datasets.load_digits()
A dataset is a dictionary-like object that holds all the data and some metadata about the data. This data is stored in the .data member, which is a n_samples, n_features array. In the case of supervised problem, one or more response variables are stored in the .target member. More details on the different datasets can be found in the dedicated section.
数据集是类似字典的对象,它保存所有的数据和关于数据
For instance, in the case of the digits dataset, digits.data gives access to the features that can be used to classify the digits samples:

>>>
>>> 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.]]
and digits.target gives the ground truth for the digit dataset, that is the number corresponding to each digit image that we are trying to learn:
digit.target 给出了数字数据集的基本事实，也就是我们要学习的每个数字图像对应的数字
>>>
>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
Shape of the data arrays
The data is always a 2D array, shape (n_samples, n_features), although the original data may have had a different shape. In the case of the digits, each original sample is an image of shape (8, 8) and can be accessed using:
数据阵列的形状
这些数据通常是一个二维数组，虽然原始数据可能有不同的形状。在数字的情况下，每个原始样本都是形状（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.]])
The simple example on this dataset illustrates how starting from the original problem one can shape the data for consumption in scikit-learn.
Loading from external datasets
这个数据集的一个简单的例子说明了如何从原始问题开始，可以在scikit-learn中使用数据进行消费
从外部数据集加载
To load from an external dataset, please refer to loading external datasets.
Learning and predicting
要从外部数据集加载，请阅读加载外部数据集
学习和预测
In the case of the digits dataset, the task is to predict, given an image, which digit it represents. We are given samples of each of the 10 possible classes (the digits zero through nine) on which we fit an estimator to be able to predict the classes to which unseen samples belong.
在数字数据集的情况下，任务是预测给定的图像，它代表了哪个数字。我们给出了10个可能类别（从0到9的数字）中的每一个的样本，我们拟合了一个估计器能够预测未看见的样本属于的类别
In scikit-learn, an estimator for classification is a Python object that implements the methods fit(X, y) and predict(T).
An example of an estimator is the class sklearn.svm.SVC that implements support vector classification. The constructor of an estimator takes as arguments the parameters of the model, but for the time being, we will consider the estimator as a black box:
在scikit-learn中，分类估计器是一个python对象，实现了fit(x,y)和predict(T)方法
估计器的一个例子是实现支持向量分类的sklearn.svm.SVC类。估计器的构造函数将模型的参数作为参数，但是暂时我们会把估计器看做一个黑盒子：
>>>
>>> from sklearn import svm
>>> clf = svm.SVC(gamma=0.001, C=100.)
Choosing the parameters of the model
In this example we set the value of gamma manually. It is possible to automatically find good values for the parameters by using tools such as grid search and cross validation.
选择模型的参数
在这个例子中我们手动设置了gamma的值。通过使用网格搜索和交叉验证等工具，可以自动找到合适的值。
We call our estimator instance clf, as it is a classifier. It now must be fitted to the model, that is, it must learn from the model. This is done by passing our training set to the fit method. As a training set, let us use all the images of our dataset apart from the last one. We select this training set with the [:-1] Python syntax, which produces a new array that contains all but the last entry of digits.data:
我们称之为估计器实例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)
Now you can predict new values, in particular, we can ask to the classifier what is the digit of our last image in the digits dataset, which we have not used to train the classifier:
现在你可以预测新的值了，特别是可以向分类器询问数字数据集中最后一个图像的数字是什么，我们还没有用它来训练分类器:
>>>
>>> clf.predict(digits.data[-1:])
array([8])
The corresponding image is the following:
../../_images/sphx_glr_plot_digits_last_image_001.png
As you can see, it is a challenging task: the images are of poor resolution. Do you agree with the classifier?
A complete example of this classification problem is available as an example that you can run and study: Recognizing hand-written digits.

相应的图像如下：
正如你所看到的，这是一个具有挑战性的任务：图像分辨率差。你同意分类器吗？
这个分类问题的一个完整的例子可以作为一个例子，你可以运行和学习：识别书写数字。

Model persistence
It is possible to save a model in the scikit by using Python’s built-in persistence model, namely pickle:
模型持久性：
通过使用Python的内置持久化模型（即pickle）,可以在scikit中保存模型：
>>>
>>> from sklearn import svm
>>> from sklearn import datasets
>>> clf = svm.SVC()
>>> 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='auto', 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
In the specific case of the scikit, it may be more interesting to use joblib’s replacement of pickle (joblib.dump & joblib.load), which is more efficient on big data, but can only pickle to the disk and not to a string:
在scikit的特定情况下，使用joblib替换pickle可能会更有趣，这对于大数据更有效，但只能pickle到磁盘，而不是字符串
>>>
>>> from sklearn.externals import joblib
>>> joblib.dump(clf, 'filename.pkl')
Later you can load back the pickled model (possibly in another Python process) with:
>>>
>>> clf = joblib.load('filename.pkl')
Note joblib.dump and joblib.load functions also accept file-like object instead of filenames. More information on data persistence with Joblib is available here.
Note that pickle has some security and maintainability issues. Please refer to section Model persistence for more detailed information about model persistence with scikit-learn.
注意 joblib.dump 和joblib.load函数也接受文件类对象而不是文件名。有关Joblib数据持久性的更多信息，请点击这里。
请注意 pickle有一些安全性和可维护性问题。
Conventions

scikit-learn estimators follow certain rules to make their behavior more predictive.
Type casting

Unless otherwise specified, input will be cast to float64:
约定
scikit-learn 估计器遵循一定的规则使他们的行为更具有预测性。
类型铸造
除非另有规定，输入将被转换为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')
In this example, X is float32, which is cast to float64 by fit_transform(X).
Regression targets are cast to float64, classification targets are maintained:
在这个例子中，X是float32,它被fit_transform(X)强制转换为float64。
回归目标被转换成float64，维护分类目标：
>>>
>>> from sklearn import datasets
>>> from sklearn.svm import SVC
>>> iris = datasets.load_iris()
>>> clf = SVC()
>>> 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='auto', 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='auto', 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']
Here, the first predict() returns an integer array, since iris.target (an integer array) was used in fit. The second predict() returns a string array, since iris.target_names was for fitting.
Refitting and updating parameters
在这里，因为iris.target(一个整型数组)在fit中被使用，第一个predict()返回一个整型数组。第二个predict()返回一个字符串数组，是因为iris.target_names是拟合的。
改装和更新参数
Hyper-parameters of an estimator can be updated after it has been constructed via the sklearn.pipeline.Pipeline.set_params method. Calling fit() more than once will overwrite what was learned by any previous fit():
估计器的超参数可以在通过sklearn.pipeline.Pipeline.set_params方法构建后更新。不止一次调用fit()会覆盖之前fit()所学到的内容：
>>>
>>> import numpy as np
>>> from sklearn.svm import SVC

>>> rng = np.random.RandomState(0)
>>> X = rng.rand(100, 10)
>>> y = rng.binomial(1, 0.5, 100)
>>> X_test = rng.rand(5, 10)

>>> 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', kernel='linear',
 max_iter=-1, probability=False, random_state=None, shrinking=True,
 tol=0.001, verbose=False)
>>> clf.predict(X_test)
array([1, 0, 1, 1, 0])

>>> clf.set_params(kernel='rbf').fit(X, y)
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
 decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',
 max_iter=-1, probability=False, random_state=None, shrinking=True,
 tol=0.001, verbose=False)
>>> clf.predict(X_test)
array([0, 0, 0, 1, 0])
Here, the default kernel rbf is first changed to linear after the estimator has been constructed via SVC(), and changed back to rbf to refit the estimator and to make a second prediction.
在这里，在通过SVC（）构造估计器后，默认的内核rbf首先被改变为线性，并且改回到rbf以改装估计器并且进行第二次预测。
Multiclass vs. multilabel fitting
多类和多标签拟合
When using multiclass classifiers, the learning and prediction task that is performed is dependent on the format of the target data fit upon:
当使用多类分类器是，执行学习和预测任务取决于适合的目标数据的格式
>>>
>>> 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(random_state=0))
>>> classif.fit(X, y).predict(X)
array([0, 0, 1, 1, 2])
In the above case, the classifier is fit on a 1d array of multiclass labels and the predict() method therefore provides corresponding multiclass predictions. It is also possible to fit upon a 2d array of binary label indicators:
在上面的情况下，分类器适合于多类标签的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]])
Here, the classifier is fit() on a 2d binary label representation of y, using the LabelBinarizer. In this case predict() returns a 2d array representing the corresponding multilabel predictions.
Note that the fourth and fifth instances returned all zeroes, indicating that they matched none of the three labels fit upon. With multilabel outputs, it is similarly possible for an instance to be assigned multiple labels:
在这里，使用LabelBinarizer，分类器在y的2d二进制标签表示上是fit()。在这种情况下predict()返回一个代表相应多标记预测的二维数组
>> 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, 1, 0],
      [0, 0, 1, 0, 1]])
In this case, the classifier is fit upon instances each assigned multiple labels. The MultiLabelBinarizer is used to binarize the 2d array of multilabels to fit upon. As a result, predict() returns a 2d array with multiple predicted labels for each instance.
在这种情况下，分类器是使用于每个分配多个标签的实例。MultiLableBinarizer 是用于对二维多标签数组进行二进制化以适应。结果，predict()为每个实例返回一个多预测标签的二维数组。