sklearn学习（一）

ゞ浴缸里的玫瑰 2022-05-14 00:43 287阅读 0赞

## 学习网站 ##

> [http://scikit-learn.org/stable/tutorial/basic/tutorial.html\#machine-learning-the-problem-setting][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][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 0
     0 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 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 1 1 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 2 2 2 2 2 2 2 2 2 2 2 2 2
     2 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][http_scikit-learn.org_stable_modules_grid_search.html_grid-search]  
> cross-validation [http://scikit-learn.org/stable/modules/cross\_validation.html\#cross-validation][http_scikit-learn.org_stable_modules_cross_validation.html_cross-validation]

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

**数字预测代码**

from sklearn import svm
    from sklearn import datasets
    
    digits = 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.

**可以来看下到底最后一个数据是怎么样的：**  
![这里写图片描述][70]

其实确实有点像是8。

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

**代码:**

from sklearn import svm
    from sklearn import datasets
    import matplotlib.pyplot as plt
    
    digits = 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 pickle
    
    digits = 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 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)
    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 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))
    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]]

[http_scikit-learn.org_stable_tutorial_basic_tutorial.html_machine-learning-the-problem-setting]: http://scikit-learn.org/stable/tutorial/basic/tutorial.html#machine-learning-the-problem-setting
[http_scikit-learn.org_stable_datasets_index.html_datasets]: http://scikit-learn.org/stable/datasets/index.html#datasets
[http_scikit-learn.org_stable_modules_grid_search.html_grid-search]: http://scikit-learn.org/stable/modules/grid_search.html#grid-search
[http_scikit-learn.org_stable_modules_cross_validation.html_cross-validation]: http://scikit-learn.org/stable/modules/cross_validation.html#cross-validation
[70]: /images/20220514/f82ebb9515a647e4918d2b2e75ecd356.png