sklearn学习（一）

学习网站

http://scikit-learn.org/stable/tutorial/basic/tutorial.html#machine-learning-the-problem-setting

内容

一般来说，学习问题可以被分为几大类：

监督学习（supervised learing）。数据包括一些我们可以预测的属性。
非监督学习（unsupervised learning）。数据有一堆输入向量，但是没有给输出的目标值。

监督学习分为：

分类（classification）:当样本属于两个或者更多的数据的时候，我们可以通过学习一些贴好标签的数据，然后去预测一些没有给出标签的数据。（离散问题（discrete））
回归（regression）：当希望预测的结果是一个或者多个连续的变量的时候，这就是回归。

非监督学习分为：

聚类（clustering）:目标去发现一些有相似特征的类。
密度估计（Density estimation）：描述一些输入数据的特征信息
数据降维：将高维数据降维到低维数据

一般将数据集分为训练集和测试集

sklearn内有一些标准数据，例如：iris(鸢尾花)，手写数字数据为了分类，然后，还有波斯顿房价数据为了回归。

以导入iris数据为例

导入数据：

from sklearn import datasets
iris = datasets.load_iris()

数据集是有点像字典的类。包括一些数据，还有元数据。这些数据被存在.data中。内容是一个n个例子，还有n个特征的array。在监督学习的问题中，一个或者是更多的响应数据被存.target中。

关于数据的操作具体的可以在下面的网址中找到。

http://scikit-learn.org/stable/datasets/index.html#datasets

关于上面的.data和.target是什么意思：

例如：

print(iris.data)

输出：（数据较多，就截取一部分）

[[5.1 3.5 1.4 0.2][4.9 3.  1.4 0.2][4.7 3.2 1.3 0.2][4.6 3.1 1.5 0.2]...[6.3 2.5 5.  1.9][6.5 3.  5.2 2. ][6.2 3.4 5.4 2.3][5.9 3.  5.1 1.8]]

print(iris.target)

输出：


[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 22 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 22 2]

学习和预测

在数字数据集中，任务是预测一个图片，然后给出预测的数字。数字集合包括有0到9。

在sklearn中，对于分类器的估计是一个python类。实现了两个方法fit(X,y)和predict(T)

一个估计类的例子的sklearn.svm.SVC是实现了支持向量机的分类器。分类器的构造函数会需要一些参数（我们称之为超参数）。从现在起，我们认为这个评估器，就是一个黑盒子。

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

这里，我们给的时候是给了固定的参数，但是还有两种设置参数的方式。
grid-search http://scikit-learn.org/stable/modules/grid_search.html#grid-search
cross-validation http://scikit-learn.org/stable/modules/cross_validation.html#cross-validation

我们称评估器为clf，因为它是一个分类器。它必须要从模型中学习。这项被完成是通过fit方法。

数字预测代码

from sklearn import svm
from sklearn import datasetsdigits = datasets.load_digits()
clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(digits.data[:-1], digits.target[:-1])
print("pridict:", clf.predict(digits.data[-1:]))
print("actually:", digits.target[-1:])

输出：

pridict: [8]
actually: [8]

注意：
选最后一个数据的时候要 digits.data[-1:] 这样方式。主要是为了使得在外面包一层，因为测试数据可能不止一个。所以，当必须要以集合的形式传进去。否者就会报下面的错误。

ValueError: Expected 2D array, got 1D array instead:
array=[ 0.  0. 10. 14.  8.  1.  0.  0.  0.  2. 16. 14.  6.  1.  0.  0.  0.  0.15. 15.  8. 15.  0.  0.  0.  0.  5. 16. 16. 10.  0.  0.  0.  0. 12. 15.15. 12.  0.  0.  0.  4. 16.  6.  4. 16.  6.  0.  0.  8. 16. 10.  8. 16.8.  0.  0.  1.  8. 12. 14. 12.  1.  0.].
Reshape your data either using array.reshape(-1, 1) if your data has a single feature or array.reshape(1, -1) if it contains a single sample.

可以来看下到底最后一个数据是怎么样的：

其实确实有点像是8。

plt语句的最后一个参数含义是为了将这个变成灰色。否则颜色有点奇怪。

代码:

from sklearn import svm
from sklearn import datasets
import matplotlib.pyplot as pltdigits = datasets.load_digits()
clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(digits.data[:-1], digits.target[:-1])
print("pridict:", clf.predict(digits.data[-1:]))
print("actually:", digits.target[-1:])plt.imshow(digits.images[-1], cmap=plt.cm.gray_r)  # 变灰色plt.show()

模型可持续性

相信很多哥们都遇到这样的问题，训练一个模型需要很久的时间，但是如果，一开始就已经有了这样的模型之后，以后就直接调用，岂不是美滋滋？所以，python原生的这样的操作。

pickle库

from sklearn import svm
from sklearn import datasets
import pickledigits = datasets.load_digits()
clf = svm.SVC(gamma=0.001, C=100.)
clf.fit(digits.data[:-1], digits.target[:-1])
print("pridict:", clf.predict(digits.data[-1:]))
print("actually:", digits.target[-1:])s = pickle.dumps(clf)clf2 = pickle.loads(s)print(clf2.predict(digits.data[-1:]))

输出为;

pridict: [8]
actually: [8]
[8]

当然是可以保存为文件类型：

with open('clf', 'wb') as f:pickle.dump(clf, f)with open('clf', 'rb') as f:clf2 = pickle.load(f)print(clf2.predict(digits.data[-1:]))

用上面的代码来替换掉之前的 dumps还有loads也是可以。

当然，这样就在代码上多出一个这样的文件。不过可以被移植了，算是一个优点。

其实文件取什么名字都没有什么多大意义的。当然啦，选什么类型这种东西，对于程序员来说也是这样的，因为本质上都是二进制文件。

在sklearn中，除了python原生的pickle可以使用，还可以使用sklearn自带的joblib

joblib.dump(clf, 'clf2')
clf2 = joblib.load('clf2')
print(clf2.predict(digits.data[-1:]))

用这个代码代替之前的那段代码也是可以的。
而且， joblib对于处理大数据的时候会比pickle更有效（不过我还没有试过）。不过至少，我觉得写起来效率会比pickle更高。但是，就是没有在代码间的那种先放着，然后之后再做处理的操作。（虽然我目前还没意识到，为什么需要有这种操作。。。）

但是学好pickle也是很重要的，因为基本所有的数据都是可以用这个来做。在python上的课扩展性会更强点。

sklearn使用公约

类型转变：

除非特殊情况，否则，输入转变到float64

重新fit和更新超参数（Hyper-parameters）

超参数可以被更新，通过sklearn.pipeline.Pipeline.set_params方法。
只需要再调用一次fit之后，就会覆盖掉之前学习的效果。

比如下面的代码：

import numpy as np
from sklearn.svm import SVCrng = 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)
print(clf.predict(X_test))
clf.set_params(kernel='rbf').fit(X, y)
print(clf.predict(X_test))

输出是：

[1 0 1 1 0]
[0 0 0 1 0]

注意到，分类器这里重新设置了SVC的核函数。当然，设置了不同的核函数之后，最后的预测效果也不一样了。

不过考虑到，这是因为数据本身就是随机出来的效果。所以，在这里本身蕴含的信息就是一个混乱的。所以，根据不同的核函数的时候，就导致了很大的误差。实际应用中的效果应该是，就算是有效果，但是效果也不应该是这么明显的。

Multiclass vs. multilabel fitting

采用multiclass 中的分类器，学习和预测任务，是依赖于fit的时候的目标类型。

例如下面的这个代码：

from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import LabelBinarizerX = [[1, 2], [2, 4], [4, 5], [3, 2], [3, 1]]
y = [0, 0, 1, 1, 2]classif = OneVsRestClassifier(estimator=SVC(random_state=0))
print(classif.fit(X, y).predict(X))# 数据二进制化
y = LabelBinarizer().fit_transform(y)
print(classif.fit(X, y).predict(X))

输出：

[0 0 1 1 2]
[[1 0 0][1 0 0][0 1 0][0 0 0][0 0 0]]

但是y的被转变之后的数据是

[[1 0 0][1 0 0][0 1 0][0 1 0][0 0 1]]

注意到后面两行的数据是不一样的，都是全0，表示的是，没有一个匹配到。

但是，如果是多个标签的情况下：

比如说，下面的这个y就是一个多标签的问题。

后面的输出矩阵，其实就转换成了一个bool值问题。即表示某个元素存在与否。

from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import MultiLabelBinarizer
X = [[1, 2], [2, 4], [4, 5], [3, 2], [3, 1]]
y = [[0, 1], [0, 2], [1, 3], [0, 2, 3], [2, 4]]classif = OneVsRestClassifier(estimator=SVC(random_state=0))
# 数据二进制化
y = MultiLabelBinarizer().fit_transform(y)
print(classif.fit(X, y).predict(X))

输出为：

[[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]]

然后，我们看原来的y值为

[[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]]