0%

Sklearn学习笔记

10 min read   |   2.3k words Posted on Edited on In
Sklearn学习笔记

参考:
sklearnm官方文档

Sklearn 简介

sklearn 是什么

python机器学习的包

安装

使用pip

pip install scikit-learn
sudo python3 -m pip install scikit-learn

使用Anaconda

conda install scikit-learn

sklearn学习方法

流程图

官方提供的流程图

常用属性/方法

data
  1. 训练数据，一般用train来表示
  2. 训练数据的分类属性，一般用target来表示
  3. 测试数据，一般用test来表示
  4. 测试数据的真实分类属性，用于评估分类器性能，一般用expected来表示

model

  1. 学习数据，一般用fit()
  2. 预测数据，一般用predict()
  3. 评价模型准确度，一般用score()

Example

  1. 演示数据类型

    1
    2
    3
    4
    5
    6
    #以下程序将输出sklearn库中内置的bosten数据
    from sklearn import datasets

    house_test=datasets.load_boston()
    print(house_test.data[:20])
    print(house_test.target[:20])

  2. 使用系统数据和模型预测示例

    1
    2
    3
    4
    5
    6
    7
    8
    from sklearn.model_selection import train_test_split
    from sklearn import linear_model
    lr = linear_model.LinearRegression()
    house_test=datasets.load_boston()
    X_train, X_test, y_train, y_test = train_test_split(house_test.data, house_test.target, test_size=0.3)
    lr.fit(X_train, y_train)
    print(lr.predict(X_test)[:10])
    print(y_test[:10])

标准化/归一化/正则化

标准化/规范化

概念

数据的标准化是将数据按比例缩放，使之落入一个小的特定区间。由于信用指标体系的各个指标度量单位是不同的，为了能够将指标参与评价计算，需要对指标进行规范化处理，通过函数变换将其数值映射到某个数值区间。

算法

  1. z-score标准化(或零－均值标准化)（常用）
    　y=(x-X的平均值)／X的标准差=(x-mean)/std
    优点：当X的最大值和最小值未知，或孤立点左右了最大－最小规范化时，该方法有用

  2. 最小－最大规范化(线性变换)
    y=( (x-MinValue) / (MaxValue-MinValue) )(new_MaxValue-new_MinValue)+new_minValue

  3. 小数定标规范化：通过移动X的小数位置来进行规范化
    　 y= x/10的j次方　　(其中,j使得Max(|y|) <1的最小整数

  4. 对数Logistic模式：
    新数据=1/（1+e^(-原数据)）

  5. 模糊量化模式：
    新数据=1/2+1/2sin[派3.1415/（极大值-极小值）*（X-（极大值-极小值）/2） ] X为原数据

示例

  1. 使用sklearn.preprocessing.scale() 可以直接将给定数据进行标准化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #经常操作的参数为axis，以m * n矩阵举例：
    #axis 不设置值，对 m*n 个数求均值，返回一个实数
    #axis = 0：压缩行，对各列求均值，返回 1* n 矩阵
    #axis =1 ：压缩列，对各行求均值，返回 m *1 矩阵
    from sklearn import preprocessing
    import numpy as np
    X = np.array([[ 1., -1.,  2.],
                  [ 2.,  0.,  0.],
                  [ 0.,  1., -1.]])
    print(X.mean(axis=0))
    X_scaled = preprocessing.scale(X)
    print(X_scaled.mean(axis=0))

  2. 标准化对准确率的影响

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    from __future__ import print_function
    from sklearn import preprocessing
    from sklearn.model_selection import train_test_split
    from sklearn.datasets.samples_generator import make_classification
    from sklearn.svm import SVC
    import matplotlib.pyplot as plt
    	
    X, y = make_classification(n_samples=300, n_features=2 , n_redundant=0, n_informative=2,
    random_state=22, n_clusters_per_class=1, scale=100)
    plt.scatter(X[:, 0], X[:, 1], c=y)
    plt.show()
    X = preprocessing.scale(X) # normalization step
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.3)
    clf = SVC()
    clf.fit(X_train, y_train)
    print(clf.score(X_test, y_test))

归一化

概念

  1. 把数变为（0，1）之间的小数
    主要是为了数据处理方便提出来的，把数据映射到0～1范围之内处理，更加便捷快速。
  2. 把有量纲表达式变为无量纲表达式
    归一化是一种简化计算的方式，即将有量纲的表达式，经过变换，化为无量纲的表达式，成为纯量。

算法

  1. 线性转换
    　 y=(x-MinValue)/(MaxValue-MinValue)

  2. 对数函数转换：
    y=log10(x)

  3. 反余切函数转换
    y=atan(x)*2/PI

  4. 线性也与对数函数结合
    式(1)将输入值换算为[-1,1]区间的值，

    在输出层用式(2)换算回初始值，其中和分别表示训练样本集中负荷的最大值和最小值

正则化

概念

正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1），如果后面要使用如二次型（点积）或者其它核方法计算两个样本之间的相似性这个方法会很有用。

Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（l1-norm,l2-norm）等于1。
p-范数的计算公式：||X||p=(|x1|^p+|x2|^p+…+|xn|^p)^1/p

该方法主要应用于文本分类和聚类中。例如，对于两个TF-IDF向量的l2-norm进行点积，就可以得到这两个向量的余弦相似性。

在sklearn中

  1. 可以使用preprocessing.normalize()函数对指定数据进行转换
  2. processing.Normalizer()类实现对训练集和测试集的拟合和转换

Cross-validation

概念

cross validation大概的意思是：对于原始数据我们要将其一部分分为train_data，一部分分为test_data。train_data用于训练，test_data用于测试准确率。在test_data上测试的结果叫做validation_error。将一个算法作用于一个原始数据，我们不可能只做出随机的划分一次train和test_data，然后得到一个validation_error，就作为衡量这个算法好坏的标准。因为这样存在偶然性。我们必须好多次的随机的划分train_data和test_data，分别在其上面算出各自的validation_error。这样就有一组validation_error，根据这一组validation_error，就可以较好的准确的衡量算法的好坏

在sklearn中

sklearn中的cross validation模块，最主要的函数是如下函数：
sklearn.cross_validation.cross_val_score:他的调用形式是scores = cross_validation.cross_val_score(clf, raw_data, raw_target, cv=5, score_func=None)
参数解释：
clf:表示的是不同的分类器，可以是任何的分类器。比如支持向量机分类器。clf = svm.SVC(kernel=’linear’, C=1)；
raw_data：原始数据；
raw_target:原始类别标号；
cv：代表的就是不同的cross validation的方法了。引用scikit-learn上的一句话（When the cv argument is an integer, cross_val_score uses the KFold or StratifiedKFold strategies by default, the latter being used if the estimator derives from ClassifierMixin.）如果cv是一个int数字的话，那么默认使用的是KFold或者StratifiedKFold交叉，如果如果指定了类别标签则使用的是StratifiedKFold。
cross_val_score:这个函数的返回值就是对于每次不同的的划分raw_data时，在test_data上得到的分类的准确率。至于准确率的算法可以通过score_func参数指定，如果不指定的话，是用clf默认自带的准确率算法。

示例

  1. 使用系统默认数据集演示交叉验证

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    from sklearn.datasets import load_iris # iris数据集
    from sklearn.model_selection import train_test_split # 分割数据模块
    from sklearn.neighbors import KNeighborsClassifier # K最近邻(kNN，k-NearestNeighbor)分类算法
    from sklearn.cross_validation import cross_val_score # K折交叉验证模块

    #加载iris数据集
    iris = load_iris()
    X = iris.data
    y = iris.target

    #分割数据并
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=4)

    #建立模型
    knn = KNeighborsClassifier()

    #训练模型
    knn.fit(X_train, y_train)

    #使用K折交叉验证模块
    scores = cross_val_score(knn, X, y, cv=5, scoring='accuracy')
    print(scores)
    #print(scores.mean())
    #将准确率打印出
    print(knn.score(X_test, y_test))

  2. 为模交叉验证选择合适的参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    from sklearn.datasets import load_iris # iris数据集
    from sklearn.neighbors import KNeighborsClassifier # K最近邻(kNN，k-NearestNeighbor)分类算法
    from sklearn.cross_validation import cross_val_score # K折交叉验证模块
    import matplotlib.pyplot as plt

    #加载iris数据集
    iris = load_iris()
    X = iris.data
    y = iris.target


    k_range=range(1,10)
    k_loss=[]
    k_score=[]
    for k in k_range:
        #建立模型
        knn = KNeighborsClassifier(n_neighbors=k)

        #使用K折交叉验证模块
        scores = cross_val_score(knn, X, y, cv=5, scoring='accuracy')
        loss = -cross_val_score(knn, X, y, cv=5, scoring='neg_mean_squared_error')#'neg_mean_squared_error' 'mean_squared_error'
        k_loss.append(loss.mean())
        k_score.append(scores.mean()) #add mean of the scores
        

    plt.figure(1)
    plt.subplot(121)
    plt.plot(k_range,k_loss)
    plt.xlabel('Value from loss ,the best k of KNN id %d'%(k_loss.index(min(k_loss))))
    plt.ylabel('Error')
    #plt.figure(2)
    plt.subplot(122)
    plt.plot(k_range,k_score)
    plt.xlabel('Value from loss ,the best k of KNN id %d'%(k_score.index(min(k_score))))
    plt.ylabel('score')
    plt.show()

curve fit

参数选择中，或许会存在过拟合与欠拟合的问题，给模型选择合适参数，对结果准确率起着至关重要的作用。
举栗子

  1. 可视化特定gamma参数对SVC的影响

    • 设置gamma=0.01

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      from sklearn.learning_curve import learning_curve
      from sklearn.datasets import load_digits
      from sklearn.svm import SVC
      import matplotlib.pyplot as plt
      import numpy as np

      digits=load_digits()
      X=digits.data
      Y=digits.target

      train_sizes, train_loss, test_loss= learning_curve(SVC(gamma=0.01), X, Y,cv=10,scoring='neg_mean_squared_error',
      train_sizes=[0.1, 0.25, 0.5, 0.75, 1])
      train_loss_mean = -np.mean(train_loss, axis=1)
      test_loss_mean = -np.mean(test_loss, axis=1)
      	
      plt.plot(train_sizes, train_loss_mean, 'o-', color="r",
      label="Training")
      plt.plot(train_sizes, test_loss_mean, 'o-', color="g",
      label="Test-Cross-validation")
      	
      plt.xlabel("Training examples")
      plt.ylabel("Loss")
      plt.legend(loc="best")
      plt.show()

    • 设置gamma=0.001

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      from sklearn.learning_curve import learning_curve
      from sklearn.datasets import load_digits
      from sklearn.svm import SVC
      import matplotlib.pyplot as plt
      import numpy as np

      digits=load_digits()
      X=digits.data
      Y=digits.target

      train_sizes, train_loss, test_loss= learning_curve(SVC(gamma=0.001), X, Y,cv=10,scoring='neg_mean_squared_error',
      train_sizes=[0.1, 0.25, 0.5, 0.75, 1])
      train_loss_mean = -np.mean(train_loss, axis=1)
      test_loss_mean = -np.mean(test_loss, axis=1)
      	
      plt.plot(train_sizes, train_loss_mean, 'o-', color="r",
      label="Training")
      plt.plot(train_sizes, test_loss_mean, 'o-', color="g",
      label="Test-Cross-validation")
      	
      plt.xlabel("Training examples")
      plt.ylabel("Loss")
      plt.legend(loc="best")
      plt.show()

  2. 给模型选择合适的参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    from sklearn.learning_curve import validation_curve
    from sklearn.datasets import load_digits
    from sklearn.svm import SVC
    import matplotlib.pyplot as plt
    import numpy as np

    digits=load_digits()
    X=digits.data
    Y=digits.target

    param_range=np.logspace(-6,-2.3,5)
    train_loss, test_loss= validation_curve(SVC(), X, Y,param_name='gamma',param_range=param_range,cv=10,scoring='neg_mean_squared_error')
    train_loss_mean = -np.mean(train_loss, axis=1)
    test_loss_mean = -np.mean(test_loss, axis=1)
    	
    plt.plot(param_range, train_loss_mean, 'o-', color="r",
    label="Training")
    plt.plot(param_range, test_loss_mean, 'o-', color="g",
    label="Test-Cross-validation")
    	
    plt.xlabel("gamma")
    plt.ylabel("Loss")
    plt.legend(loc="best")
    plt.show()
坚持原创技术分享，您的支持将鼓励我继续创作！