sklearn_sklearn svm 调参 - CSDN
精华内容
参与话题
  • Python之Sklearn使用教程

    万次阅读 多人点赞 2018-04-15 19:49:27
    1.Sklearn简介 Scikit-learn(sklearn)是机器学习中常用的第三方模块,对常用的机器学习方法进行了封装,包括回归(Regression)、降维(Dimensionality Reduction)、分类(Classfication)、聚类(Clustering)等方法。当...

    1.Sklearn简介

    Scikit-learn(sklearn)是机器学习中常用的第三方模块,对常用的机器学习方法进行了封装,包括回归(Regression)、降维(Dimensionality Reduction)、分类(Classfication)、聚类(Clustering)等方法。当我们面临机器学习问题时,便可根据下图来选择相应的方法。Sklearn具有以下特点:

    • 简单高效的数据挖掘和数据分析工具

    • 让每个人能够在复杂环境中重复使用

    • 建立NumPy、Scipy、MatPlotLib之上

    01

    2.Sklearn安装

    Sklearn安装要求Python(>=2.7 or >=3.3)NumPy (>= 1.8.2)SciPy (>= 0.13.3)。如果已经安装NumPy和SciPy,安装scikit-learn可以使用pip install -U scikit-learn

    3.Sklearn通用学习模式

    Sklearn中包含众多机器学习方法,但各种学习方法大致相同,我们在这里介绍Sklearn通用学习模式。首先引入需要训练的数据,Sklearn自带部分数据集,也可以通过相应方法进行构造,4.Sklearn datasets中我们会介绍如何构造数据。然后选择相应机器学习方法进行训练,训练过程中可以通过一些技巧调整参数,使得学习准确率更高。模型训练完成之后便可预测新数据,然后我们还可以通过MatPlotLib等方法来直观的展示数据。另外还可以将我们已训练好的Model进行保存,方便移动到其他平台,不必重新训练。

    from sklearn import datasets#引入数据集,sklearn包含众多数据集
    from sklearn.model_selection import train_test_split#将数据分为测试集和训练集
    from sklearn.neighbors import KNeighborsClassifier#利用邻近点方式训练数据
    
    ###引入数据###
    iris=datasets.load_iris()#引入iris鸢尾花数据,iris数据包含4个特征变量
    iris_X=iris.data#特征变量
    iris_y=iris.target#目标值
    X_train,X_test,y_train,y_test=train_test_split(iris_X,iris_y,test_size=0.3)#利用train_test_split进行将训练集和测试集进行分开,test_size占30%
    print(y_train)#我们看到训练数据的特征值分为3类
    '''
    [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]
     '''
    
    ###训练数据###
    knn=KNeighborsClassifier()#引入训练方法
    knn.fit(X_train,y_train)#进行填充测试数据进行训练
    
    ###预测数据###
    print(knn.predict(X_test))#预测特征值
    '''
    [1 1 1 0 2 2 1 1 1 0 0 0 2 2 0 1 2 2 0 1 0 0 0 0 0 0 2 1 0 0 0 1 0 2 0 2 0
     1 2 1 0 0 1 0 2]
    '''
    print(y_test)#真实特征值
    '''
    [1 1 1 0 1 2 1 1 1 0 0 0 2 2 0 1 2 2 0 1 0 0 0 0 0 0 2 1 0 0 0 1 0 2 0 2 0
     1 2 1 0 0 1 0 2]
    '''
    

    4.Sklearn datasets

    Sklearn提供一些标准数据,我们不必再从其他网站寻找数据进行训练。例如我们上面用来训练的load_iris数据,可以很方便的返回数据特征变量和目标值。除了引入数据之外,我们还可以通过load_sample_images()来引入图片。

    02

    除了sklearn提供的一些数据之外,还可以自己来构造一些数据帮助我们学习。

    from sklearn import datasets#引入数据集
    #构造的各种参数可以根据自己需要调整
    X,y=datasets.make_regression(n_samples=100,n_features=1,n_targets=1,noise=1)
    
    ###绘制构造的数据###
    import matplotlib.pyplot as plt
    plt.figure()
    plt.scatter(X,y)
    plt.show()
    

    03

    5.Sklearn Model的属性和功能

    数据训练完成之后得到模型,我们可以根据不同模型得到相应的属性和功能,并将其输出得到直观结果。假如通过线性回归训练之后得到线性函数y=0.3x+1,我们可通过_coef得到模型的系数为0.3,通过_intercept得到模型的截距为1。

    from sklearn import datasets
    from sklearn.linear_model import LinearRegression#引入线性回归模型
    
    ###引入数据###
    load_data=datasets.load_boston()
    data_X=load_data.data
    data_y=load_data.target
    print(data_X.shape)
    #(506, 13)data_X共13个特征变量
    
    ###训练数据###
    model=LinearRegression()
    model.fit(data_X,data_y)
    model.predict(data_X[:4,:])#预测前4个数据
    
    ###属性和功能###
    print(model.coef_)
    '''
    [ -1.07170557e-01   4.63952195e-02   2.08602395e-02   2.68856140e+00
      -1.77957587e+01   3.80475246e+00   7.51061703e-04  -1.47575880e+00
       3.05655038e-01  -1.23293463e-02  -9.53463555e-01   9.39251272e-03
      -5.25466633e-01]
    '''
    print(model.intercept_)
    #36.4911032804
    print(model.get_params())#得到模型的参数
    #{'copy_X': True, 'normalize': False, 'n_jobs': 1, 'fit_intercept': True}
    print(model.score(data_X,data_y))#对训练情况进行打分
    #0.740607742865
    

    6.Sklearn数据预处理

    数据集的标准化对于大部分机器学习算法来说都是一种常规要求,如果单个特征没有或多或少地接近于标准正态分布,那么它可能并不能在项目中表现出很好的性能。在实际情况中,我们经常忽略特征的分布形状,直接去均值来对某个特征进行中心化,再通过除以非常量特征(non-constant features)的标准差进行缩放。

    例如, 许多学习算法中目标函数的基础都是假设所有的特征都是零均值并且具有同一阶数上的方差(比如径向基函数、支持向量机以及L1L2正则化项等)。如果某个特征的方差比其他特征大几个数量级,那么它就会在学习算法中占据主导位置,导致学习器并不能像我们说期望的那样,从其他特征中学习。例如我们可以通过Scale将数据缩放,达到标准化的目的。

    from sklearn import preprocessing
    import numpy as np
    a=np.array([[10,2.7,3.6],
                [-100,5,-2],
                [120,20,40]],dtype=np.float64)
    print(a)
    print(preprocessing.scale(a))#将值的相差度减小
    '''
    [[  10.     2.7    3.6]
     [-100.     5.    -2. ]
     [ 120.    20.    40
    [[ 0.         -0.85170713 -0.55138018]
     [-1.22474487 -0.55187146 -0.852133  ]
     [ 1.22474487  1.40357859  1.40351318]]
    '''
    

    我们来看下预处理前和预处理预处理后的差别,预处理之前模型评分为0.511111111111,预处理后模型评分为0.933333333333,可以看到预处理对模型评分有很大程度的提升。

    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
    
    ###生成的数据如下图所示###
    plt.figure
    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()
    
    ###利用minmax方式对数据进行规范化###
    X=preprocessing.minmax_scale(X)#feature_range=(-1,1)可设置重置范围
    X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.3)
    clf=SVC()
    clf.fit(X_train,y_train)
    print(clf.score(X_test,y_test))
    #0.933333333333
    #没有规范化之前我们的训练分数为0.511111111111,规范化后为0.933333333333,准确度有很大提升
    

    04

    7.交叉验证

    交叉验证的基本思想是将原始数据进行分组,一部分做为训练集来训练模型,另一部分做为测试集来评价模型。交叉验证用于评估模型的预测性能,尤其是训练好的模型在新数据上的表现,可以在一定程度上减小过拟合。还可以从有限的数据中获取尽可能多的有效信息。

    机器学习任务中,拿到数据后,我们首先会将原始数据集分为三部分:训练集、验证集和测试集。 训练集用于训练模型,验证集用于模型的参数选择配置,测试集对于模型来说是未知数据,用于评估模型的泛化能力。不同的划分会得到不同的最终模型。

    以前我们是直接将数据分割成70%的训练数据和测试数据,现在我们利用K折交叉验证分割数据,首先将数据分为5组,然后再从5组数据之中选择不同数据进行训练。

    05

    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.neighbors import KNeighborsClassifier
    
    ###引入数据###
    iris=load_iris()
    X=iris.data
    y=iris.target
    
    ###训练数据###
    X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.3)
    #引入交叉验证,数据分为5组进行训练
    from sklearn.model_selection import cross_val_score
    knn=KNeighborsClassifier(n_neighbors=5)#选择邻近的5个点
    scores=cross_val_score(knn,X,y,cv=5,scoring='accuracy')#评分方式为accuracy
    print(scores)#每组的评分结果
    #[ 0.96666667  1.          0.93333333  0.96666667  1.        ]5组数据
    print(scores.mean())#平均评分结果
    #0.973333333333
    

    那么是否n_neighbor=5便是最好呢,我们来调整参数来看模型最终训练分数。

    from sklearn import datasets
    from sklearn.model_selection import train_test_split
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.model_selection import cross_val_score#引入交叉验证
    import  matplotlib.pyplot as plt
    ###引入数据###
    iris=datasets.load_iris()
    X=iris.data
    y=iris.target
    ###设置n_neighbors的值为1到30,通过绘图来看训练分数###
    k_range=range(1,31)
    k_score=[]
    for k in k_range:
        knn=KNeighborsClassifier(n_neighbors=k)
        scores=cross_val_score(knn,X,y,cv=10,scoring='accuracy')#for classfication
        k_score.append(scores.mean())
    plt.figure()
    plt.plot(k_range,k_score)
    plt.xlabel('Value of k for KNN')
    plt.ylabel('CrossValidation accuracy')
    plt.show()
    #K过大会带来过拟合问题,我们可以选择12-18之间的值
    

    我们可以看到n_neighbor在12-18之间评分比较高,实际项目之中我们可以通过这种方式来选择不同参数。另外我们还可以选择2-fold Cross Validation,Leave-One-Out Cross Validation等方法来分割数据,比较不同方法和参数得到最优结果。

    06

    我们将上述代码中的循环部分改变一下,评分函数改为neg_mean_squared_error,便得到对于不同参数时的损失函数。

    for k in k_range:
        knn=KNeighborsClassifier(n_neighbors=k)
        loss=-cross_val_score(knn,X,y,cv=10,scoring='neg_mean_squared_error')# for regression
        k_score.append(loss.mean())
    

    07

    8.过拟合问题

    什么是过拟合问题呢?例如下面这张图片,黑色线已经可以很好的分类出红色点和蓝色点,但是在机器学习过程中,模型过于纠结准确度,便形成了绿色线的结果。然后在预测测试数据集结果的过程中往往会浪费很多时间并且准确率不是太好。

    08

    我们先举例如何辨别overfitting问题。Sklearn.learning_curve中的learning curve可以很直观的看出Model学习的进度,对比发现有没有过拟合。

    from sklearn.model_selection 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_size表示记录学习过程中的某一步,比如在10%,25%...的过程中记录一下
    train_size,train_loss,test_loss=learning_curve(
        SVC(gamma=0.1),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.figure()
    #将每一步进行打印出来
    plt.plot(train_size,train_loss_mean,'o-',color='r',label='Training')
    plt.plot(train_size,test_loss_mean,'o-',color='g',label='Cross-validation')
    plt.legend('best')
    plt.show()
    

    09

    如果我们改变gamma的值,那么会改变相应的Loss函数。损失函数便在10左右停留,此时便能直观的看出过拟合。
    10

    下面我们通过修改gamma参数来修正过拟合问题。

    from sklearn.model_selection import  validation_curve#将learning_curve改为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来观察Loss函数情况
    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.figure()
    plt.plot(param_range,train_loss_mean,'o-',color='r',label='Training')
    plt.plot(param_range,test_loss_mean,'o-',color='g',label='Cross-validation')
    plt.xlabel('gamma')
    plt.ylabel('loss')
    plt.legend(loc='best')
    plt.show()
    

    通过改变不同的gamma值我们可以看到Loss函数的变化情况。从图中可以看到,如果gamma的值大于0.001便会出现过拟合的问题,那么我们构建模型时gamma参数设置应该小于0.001。

    11

    9.保存模型

    我们花费很长时间用来训练数据,调整参数,得到最优模型。但如果改变平台,我们还需要重新训练数据和修正参数来得到模型,将会非常的浪费时间。此时我们可以先将model保存起来,然后便可以很方便的将模型迁移。

    from sklearn import svm
    from sklearn import datasets
    
    #引入和训练数据
    iris=datasets.load_iris()
    X,y=iris.data,iris.target
    clf=svm.SVC()
    clf.fit(X,y)
    
    #引入sklearn中自带的保存模块
    from sklearn.externals import joblib
    #保存model
    joblib.dump(clf,'sklearn_save/clf.pkl')
    
    #重新加载model,只有保存一次后才能加载model
    clf3=joblib.load('sklearn_save/clf.pkl')
    print(clf3.predict(X[0:1]))
    #存放model能够更快的获得以前的结果
    

    参考链接

    此文档整理自莫烦sklearn视频教程,链接为https://morvanzhou.github.io/tutorials/machine-learning/sklearn/。
    

    更多内容请关注公众号’谓之小一’,若有疑问可在公众号后台提问,随时回答,欢迎关注,内容转载请注明出处。
    推广

    展开全文
  • scikit-learn,又写作sklearn,是一个开源的基于python语言的机器学习工具包。它通过NumPy, SciPy和Matplotlib等python数值计算的库实现高效的算法应用,并且涵盖了几乎所有主流机器学习算法。 学完本章能掌握知识点...
  • sklearn学习总结(超全面)

    万次阅读 多人点赞 2018-03-09 12:38:56
    sklearn的官网链接http://scikit-learn.org/stable/index.html# 目录 1. 分类、回归 2. 降维 3. 模型评估与选择 4. 数据预处理 大类 小类 适用问题 实现 说明 ...

    前言

    sklearn想必不用我多介绍了,一句话,她是机器学习领域中最知名的python模块之一,若想要在机器学习领域有一番建树,必绕不开sklearn

    sklearn的官网链接http://scikit-learn.org/stable/index.html#

    首先,放上一张官网上的sklearn的结构图:
    在这里插入图片描述

    目录

    1. 分类、回归

    2. 降维

    3. 模型评估与选择

    4. 数据预处理

    大类 小类 适用问题 实现 说明
    分类、回归
    1.1 广义线性模型 1.1.1 普通最小二乘法 回归 sklearn.linear_model.LinearRegression
    注:本节中所有的回归模型皆为线性回归模型 1.1.2 Ridge/岭回归 回归 sklearn.linear_model.Ridge 解决两类回归问题:
    一是样本少于变量个数
    二是变量间存在共线性
    1.1.3 Lasso 回归 sklearn.linear_model.Lasso 适合特征较少的数据
    1.1.4 Multi-task Lasso 回归 sklearn.linear_model.MultiTaskLasso y值不是一元的回归问题
    1.1.5 Elastic Net 回归 sklearn.linear_model.ElasticNet 结合了Ridge和Lasso
    1.1.6 Multi-task Elastic Net 回归 sklearn.linear_model.MultiTaskElasticNet y值不是一元的回归问题
    1.1.7 Least Angle Regression(LARS) 回归 sklearn.linear_model.Lars 适合高维数据
    1.1.8 LARS Lasso 回归 sklearn.linear_model.LassoLars (1)适合高维数据使用
    (2)LARS算法实现的lasso模型
    1.1.9 Orthogonal Matching Pursuit (OMP) 回归 sklearn.linear_model.OrthogonalMatchingPursuit 基于贪心算法实现
    1.1.10 贝叶斯回归 回归 sklearn.linear_model.BayesianRidge
    sklearn.linear_model.ARDRegression
    优点: (1)适用于手边数据(2)可用于在估计过程中包含正规化参数
    缺点:耗时
    1.1.11 Logistic regression 分类 sklearn.linear_model.LogisticRegression
    1.1.12 SGD(随机梯度下降法) 分类
    /回归
    sklearn.linear_model.SGDClassifier
    sklearn.linear_model.SGDRegressor
    适用于大规模数据
    1.1.13 Perceptron 分类 sklearn.linear_model.Perceptron 适用于大规模数据
    1.1.14 Passive Aggressive Algorithms 分类
    /回归
    sklearn.linear_model.
    PassiveAggressiveClassifier


    sklearn.linear_model.
    PassiveAggressiveRegressor
    适用于大规模数据
    1.1.15 Huber Regression 回归 sklearn.linear_model.HuberRegressor 能够处理数据中有异常值的情况
    1.1.16 多项式回归 回归 sklearn.preprocessing.PolynomialFeatures 通过PolynomialFeatures将非线性特征转化成多项式形式,再用线性模型进行处理
    1.2 线性和二次判别分析 1.2.1 LDA 分类/降维 sklearn.discriminant_analysis.
    LinearDiscriminantAnalysis
    1.2.2 QDA 分类 sklearn.discriminant_analysis.
    QuadraticDiscriminantAnalysis
    1.3 核岭回归 简称KRR 回归 sklearn.kernel_ridge.KernelRidge 将核技巧应用到岭回归(1.1.2)中,以实现非线性回归
    1.4 支持向量机 1.4.1 SVC,NuSVC,LinearSVC 分类 sklearn.svm.SVC
    sklearn.svm.NuSVC
    sklearn.svm.LinearSVC
    SVC可用于非线性分类,可指定核函数;
    NuSVC与SVC唯一的不同是可控制支持向量的个数;
    LinearSVC用于线性分类
    1.4.2 SVR,NuSVR,LinearSVR 回归 sklearn.svm.SVR
    sklearn.svm.NuSVR
    sklearn.svm.LinearSVR
    同上,将"分类"变成"回归"即可
    1.4.3 OneClassSVM 异常检测 sklearn.svm.OneClassSVM 无监督实现异常值检测
    1.5 随机梯度下降 同1.1.12
    1.6 最近邻 1.6.1 Unsupervised Nearest Neighbors sklearn.neighbors.NearestNeighbors 无监督实现K近邻的寻找
    1.6.2 Nearest Neighbors Classification 分类 sklearn.neighbors.KNeighborsClassifier
    sklearn.neighbors.RadiusNeighborsClassifier
    (1)不太适用于高维数据
    (2)两种实现只是距离度量不一样,后者更适合非均匀的采样
    1.6.3 Nearest Neighbors Regression 回归 sklearn.neighbors.KNeighborsRegressor
    sklearn.neighbors.RadiusNeighborsRegressor
    同上
    1.6.5 Nearest Centroid Classifier 分类 sklearn.neighbors.NearestCentroid 每个类对应一个质心,测试样本被分类到距离最近的质心所在的类别
    1.7 高斯过程(GP/GPML) 1.7.1 GPR 回归 sklearn.gaussian_process.
    GaussianProcessRegressor
    与KRR一样使用了核技巧
    1.7.3 GPC 分类 sklearn.gaussian_process.
    GaussianProcessClassifier
    1.8 交叉分解 实现算法:CCA和PLS 用来计算两个多元数据集的线性关系,当预测数据比观测数据有更多的变量时,用PLS更好
    1.9 朴素贝叶斯 1.9.1 高斯朴素贝叶斯 分类 sklearn.naive_bayes.GaussianNB 处理特征是连续型变量的情况
    1.9.2 多项式朴素贝叶斯 分类 sklearn.naive_bayes.MultinomialNB 最常见,要求特征是离散数据
    1.9.3 伯努利朴素贝叶斯 分类 sklearn.naive_bayes.BernoulliNB 要求特征是离散的,且为布尔类型,即true和false,或者1和0
    1.10 决策树 1.10.1 Classification 分类 sklearn.tree.DecisionTreeClassifier
    1.10.2 Regression 回归 sklearn.tree.DecisionTreeRegressor
    1.11 集成方法 1.11.1 Bagging 分类/回归 sklearn.ensemble.BaggingClassifier
    sklearn.ensemble.BaggingRegressor
    可以指定基学习器,默认为决策树
    注:1和2属于集成方法中的并行化方法,3和4属于序列化方法 1.11.2 Forests of randomized trees 分类/回归 RandomForest(RF,随机森林):
    sklearn.ensemble.RandomForestClassifier
    sklearn.ensemble.RandomForestRegressor
    ExtraTrees(RF改进):
    sklearn.ensemble.ExtraTreesClassifier
    sklearn.ensemble.ExtraTreesRegressor
    基学习器为决策树
    1.11.3 AdaBoost 分类/回归 sklearn.ensemble.AdaBoostClassifier
    sklearn.ensemble.AdaBoostRegressor
    可以指定基学习器,默认为决策树
    号外:最近特别火的两个梯度提升算法,LightGBM和XGBoost
    (XGBoost提供了sklearn接口)
    1.11.4 Gradient Tree Boosting 分类/回归 GBDT:
    sklearn.ensemble.GradientBoostingClassifier
    GBRT:
    sklearn.ensemble.GradientBoostingRegressor
    基学习器为决策树
    1.11.5 Voting Classifier 分类 sklearn.ensemble.VotingClassifier 须指定基学习器
    1.12 多类与多标签算法 sklearn中的分类算法都默认支持多类分类,其中LinearSVC、 LogisticRegression和GaussianProcessClassifier在进行多类分类时需指定参数multi_class
    1.13 特征选择 1.13.1 过滤法之方差选择法 特征选择 sklearn.feature_selection.VarianceThreshold 特征选择方法分为3种:过滤法、包裹法和嵌入法。过滤法不用考虑后续学习器
    1.13.2 过滤法之卡方检验 特征选择 sklearn.feature_selection.SelectKBest
    1.13.3 包裹法之递归特征消除法 特征选择 sklearn.feature_selection.RFE 包裹法需考虑后续学习器,参数中需输入基学习器
    1.13.4 嵌入法 特征选择 sklearn.feature_selection.SelectFromModel 嵌入法是过滤法和嵌入法的结合,参数中也需输入基学习器
    1.14 半监督 1.14.1 Label Propagation 分类/回归 sklearn.semi_supervised.LabelPropagation
    sklearn.semi_supervised.LabelSpreading
    1.15 保序回归 回归 sklearn.isotonic.IsotonicRegression
    1.16 概率校准 在执行分类时,获得预测的标签的概率
    1.17 神经网络模型 (待写)
    降维
    2.5 降维 2.5.1 主成分分析 降维 PCA:
    sklearn.decomposition.PCA
    IPCA:
    sklearn.decomposition.IncrementalPCA
    KPCA:
    sklearn.decomposition.KernelPCA
    SPCA:
    sklearn.decomposition.SparsePCA
    (1)IPCA比PCA有更好的内存效率,适合超大规模降维。
    (2)KPCA可以进行非线性降维
    (3)SPCA是PCA的变体,降维后返回最佳的稀疏矩阵
    2.5.2 截断奇异值分解 降维 sklearn.decomposition.TruncatedSVD 可以直接对scipy.sparse矩阵处理
    2.5.3 字典学习 sklearn.decomposition.SparseCoder
    sklearn.decomposition.DictionaryLearning
    SparseCoder实现稀疏编码,DictionaryLearning实现字典学习
    模型评估与选择
    3.1 交叉验证/CV 3.1.1 分割训练集和测试集 sklearn.model_selection.train_test_split
    3.1.2 通过交叉验证评估score sklearn.model_selection.cross_val_score score对应性能度量,分类问题默认为accuracy_score,回归问题默认为r2_score
    3.1.3 留一法LOO sklearn.model_selection.LeaveOneOut CV的特例
    3.1.4 留P法LPO sklearn.model_selection.LeavePOut CV的特例
    3.2 调参 3.2.1 网格搜索 sklearn.model_selection.GridSearchCV 最常用的调参方法。可传入学习器、学习器参数范围、性能度量score(默认为accuracy_score或r2_score )等
    3.2.2 随机搜索 sklearn.model_selection.RandomizedSearchCV 参数传入同上
    3.3 性能度量 3.3.1 分类度量 对应交叉验证和调参中的score
    3.3.2 回归度量
    3.3.3 聚类度量
    3.4 模型持久性 使用pickle存放模型,可以使模型不用重复训练
    3.5 验证曲线 3.5.1 验证曲线 sklearn.model_selection.validation_curve 横轴为某个参数的值,纵轴为模型得分
    3.5.2 学习曲线 sklearn.model_selection.learning_curve 横轴为训练数据大小,纵轴为模型得分
    数据预处理
    4.3 数据预处理 4.3.1 标准化 数据预处理 标准化:
    sklearn.preprocessing.scale
    sklearn.preprocessing.StandardScaler
    scale与StandardScaler都是将将特征转化成标准正态分布(即均值为0,方差为1),且都可以处理scipy.sparse矩阵,但一般选择后者
    数据预处理
    区间缩放:
    sklearn.preprocessing.MinMaxScaler
    sklearn.preprocessing.MaxAbsScale
    MinMaxScaler默认为0-1缩放,MaxAbsScaler可以处理scipy.sparse矩阵
    4.3.2 非线性转换 数据预处理 sklearn.preprocessing.QuantileTransformer 可以更少的受异常值的影响
    4.3.3 归一化 数据预处理 sklearn.preprocessing.Normalizer 将行向量转换为单位向量,目的在于样本向量在点乘运算或其他核函数计算相似性时,拥有统一的标准
    4.3.4 二值化 数据预处理 sklearn.preprocessing.Binarizer 通过设置阈值对定量特征处理,获取布尔值
    4.3.5 哑编码 数据预处理 sklearn.preprocessing.OneHotEncoder 对定性特征编码。也可用pandas.get_dummies实现
    4.3.6 缺失值计算 数据预处理 sklearn.preprocessing.Imputer 可用三种方式填充缺失值,均值(默认)、中位数和众数。也可用pandas.fillna实现
    4.3.7 多项式转换 数据预处理 sklearn.preprocessing.PolynomialFeatures
    4.3.8 自定义转换 数据预处理 sklearn.preprocessing.FunctionTransformer

    我的github上也有,欢迎大家去看

    展开全文
  • 非常详细的sklearn介绍

    万次阅读 多人点赞 2019-11-12 08:30:00
    0引言Sklearn (全称 Scikit-Learn) 是基于 Python 语言的机器学习工具。它建立在 NumPy, SciPy, Pandas 和 Matplot...
        
    0
    引言

    Sklearn (全称 Scikit-Learn) 是基于 Python 语言的机器学习工具。它建立在 NumPy, SciPy, Pandas 和 Matplotlib 之上,里面的 API 的设计非常好,所有对象的接口简单,很适合新手上路。

    在 Sklearn 里面有六大任务模块:分别是分类、回归、聚类、降维、模型选择和预处理,如下图从其官网的截屏。

    640?wx_fmt=png

    要使用上述六大模块的方法,可以用以下的伪代码,注意 import 后面我用的都是一些通用名称,如 SomeClassifierSomeRegressorSomeModel,具体化的名称由具体问题而定,比如

    • SomeClassifier = RandomForestClassifier

    • SomeRegressor = LinearRegression

    • SomeModel = KMeans, PCA

    • SomeModel = GridSearchCV, OneHotEncoder

    上面具体化的例子分别是随机森林分类器、线性回归器、K 均值聚类、主成分分析、网格追踪法、独热编码。

    分类 (Classification)
    from sklearn import SomeClassifier	
    from sklearn.linear_model import SomeClassifier	
    from sklearn.ensemble import SomeClassifier
    回归 (Regression)
    from sklearn import SomeRegressor	
    from sklearn.linear_model import SomeRegressor	
    from sklearn.ensemble import SomeRegressor
    聚类 (Clustering)
    from sklearn.cluster import SomeModel
    降维 (Dimensionality Reduction)
    from sklearn.decomposition import SomeModel
    模型选择 (Model Selection)
    from sklearn.model_selection import SomeModel
    预处理 (Preprocessing)
    from sklearn.preprocessing import SomeModel

    SomeClassifier, SomeRegressor, SomeModel 其实都叫做估计器 (estimator),就像 Python 里「万物皆对象」那样,Sklearn 里「万物皆估计器」。

    此外,Sklearn 里面还有很多自带数据集供,引入它们的伪代码如下。

    数据集 (Dataset)
    from sklearn.datasets import SomeData


    本贴我们用以下思路来讲解:

    • 第一章介绍机器学习,从定义出发引出机器学习四要素:数据、任务、性能度量模型。加这一章的原因是不把机器学习相关概念弄清楚之后很难完全弄明白 Sklearn。

       

    • 第二章介绍 Sklearn,从其 API 设计原理出发分析其五大特点:一致性、可检验、标准类、可组合默认值。最后再分析 Sklearn 里面自带数据以及储存格式。

    • 第三章介绍 Sklearn 里面的三大核心 API,包括估计器、预测器转换器。这一章的内容最重要,几乎所有模型都会用到这三大 API。

    • 第四章介绍 Sklearn 里面的高级 API,即估计器,有可以大大简化代码量的流水线 (Pipeline 估计器),有集成模型 (Ensemble 估计器)、有多类别-多标签-多输出分类模型 (Multiclass 和 Multioutput 估计器) 和模型选择工具 (Model Selection 估计器)。

    本帖目录如下:

    很多介绍 Sklearn 的文章是不会像我这么详细介绍「机器学习」里的概念的,但是不弄清出这些概念或术语,学 Sklearn 只是走马观花,只看到表面,抓不到实质。

    建议认真仔细读第一章!

    建议认真仔细读第一章!

    建议认真仔细读第一章!

    1
    机器学习简介

    1.1

    定义和组成元素

    什么是机器学习?字面上来讲就是 (人用) 计算机来学习。谈起机器学习就一定要提起汤姆米切尔 (Tom M.Mitchell),就像谈起音乐就会提起贝多芬,谈起篮球就会提起迈克尔乔丹,谈起电影就会提起莱昂纳多迪卡普里奥。米切尔对机器学习定义的原话是:

    A computer program is said to learn from experience E with respect to some class of tasks  T and performance measure P if its performance at  tasks in T, as measured by P, improves with experience E.

    整段英文有点抽象难懂对吗?首先注意到两个词 computer program 和 learn,翻译成中文就是机器 (计算机程序) 和学习,再把上面英译中:

    假设用性能度量 P 来评估机器在某类任务 T 的性能,若该机器通利用经验 E 在任务 T 中改善其性能 P,那么可以说机器对经验 E 进行了学习。

    在该定义中,除了核心词机器和学习,还有关键词经验 E,性能度量 P 和任务 T。在计算机系统中,通常经验 E 是以数据 D 的形式存在,而机器学习就是给定不同的任务 T 从数据中产生模型 M,模型 M 的好坏就用性能度量 P 来评估。

    由上述机器学习的定义可知机器学习包含四个元素

    • 数据 (Data)

    • 任务 (Task)

    • 性能度量 (Quality Metric)

    • 模型 (Model)

    640?wx_fmt=png

    下面四小节分别介绍数据、任务、性能度量和模型。

    1.2

    数据

    数据 (data) 是经验的另一种说法,也是信息的载体。数据可分为

    1. 结构化数据和非结构化数据 (按数据具体类型划分)

    2. 原始数据和加工数据 (按数据表达形式划分)

    3. 样本内数据和样本外数据 (按数据统计性质划分)

    结构化和非结构化

    结构化数据 (structured data) 是由二维表结构来逻辑表达和实现的数据。非结构化数据是没有预定义的数据,不便用数据库二维表来表现的数据。

    非结构化数据

    非结构化数据包括图片,文字,语音和视屏等如下图。

    640?wx_fmt=png

    对于以上的非结构数据,相关应用实例有

    • 深度学习的卷积神经网络 (convolutional neural network, CNN) 对图像数据做人脸识别或物体分类

    • 深度学习的循环神经网络 (recurrent neural network, RNN) 对语音数据做语音识别或机器对话,对文字数据做文本生成或阅读理解

    • 增强学习的阿尔法狗 (AlphaGo) 对棋谱数据学习无数遍最终打败了围棋世界冠军李世石和柯洁

     

    计算机追根到底还是只能最有效率的处理数值型的结构化数据,如何从原始数据加工成计算机可应用的数据会在后面讲明。

    结构化数据

    机器学习模型主要使用的是结构化数据,即二维的数据表。非结构化数据可以转换成结构化数据,比如把

    • 图像类数据里像素张量重塑成一维数组

    • 文本类数据用独热编码转成二维数组

    对于结构化数据,我们用勒布朗詹姆斯 (Lebron James) 四场比赛的数据举例。

    640?wx_fmt=png

    下面术语大家在深入了解机器学习前一定要弄清楚:

     

    • 每行的记录 (这是一场比赛詹姆斯的个人统计) ,称为一个示例 (instance)

    • 反映对象在某方面的性质,例如得分,篮板,助攻,称为特征 (feature) 或输入(input)

    • 特征上的取值,例如「示例 1」对应的 27, 10, 12 称为特征值 (feature value)

    • 关于示例结果的信息,例如赢,称为标签 (label) 或输出 (output)

    • 包含标签信息的示例,则称为样例 (example),即样例 = (特征, 标签)

    • 从数据中学得模型的过程称为学习 (learning) 或训练 (training)

    • 在训练数据中,每个样例称为训练样例 (training example),整个集合称为训练集(training set)

    原始和加工

    计算机处理数值型的结构型数据最有效率,但是现实世界到处出是原始数据,分为两类

    • 非结构数据比如图片和文字型数据 (情况一)

    • 结构型数据的分类型变量 (情况二)

     

    图像性数据

    拿情况一的图片为例,通过特定函数 imread 将彩色图片用 RGB 像素表示出来,再按红绿蓝的顺序,将所有像素排成一个数值列向量 (column vector),而计算机可以接受这样的输入。具体转换过程见下图。

    640?wx_fmt=png

    文本型数据

    推特 (twitter) 的每条推文 (tweet) 规定只能发 280 个字符。在编码推文时,将 280 个字符的序列用独热编码 (one-hot encoding) 到包含 128 个字符的 ASCII 表,如下所示。

    640?wx_fmt=png

    这样,每条推文都可以编码为 2 维张量形状 (280, 128),比如一条 tweet 是 “I love python :)”,这句话映射到 ASCII 表变成:

    640?wx_fmt=png

    如果收集到 1 百万条推文,那么整个数据集的形状为 (1000000, 280, 128)。传统机器学习的对率回归可以来做情感分析。

    分类型变量

    篮球比赛结果非输即赢,是一个二类 (binary class) 变量

    640?wx_fmt=png

    二类变量用「0-1编码」,比如比赛结果= {赢, 输} 表示成 y= [1 0 0 1],1 代表赢,0 代表输。

    而足球比赛结果是有赢、平、输三种,是一个多类 (multi-class) 变量。

    640?wx_fmt=png

    多类变量分别用 0, 1, 2 来表示,那么 y = [0 1 0 2]。但更常见的是用独热编码 (one-hot encoding),即

    640?wx_fmt=png

    样本内和样本外

    在统计中,把研究对象的全体称为总体 (population),而把组成总体的各个元素称为个体,把从总体中抽取的若干个体称为样本 (sample)。

    640?wx_fmt=jpeg

    举个调查中国男性平均身高的例子:

    • 全国的男性就是总体

    • 每个男性是个体

     

    普查所有男性金钱花费和时间成本太高,通常会抽取若干男性作为样本,计算样本里的男性平均身高作为总体里的所有男性平均身高的推理 (inference)。

    统计学中做的事情就是用样本数据的统计 (statistics) 来推出总体数据的参数 (parameter)。样本数据也叫做样本内数据,除样本内数据之外的总体数据叫做样本外数据。

     

    在机器学习中,样本内和样本外数据的定义稍微有些不同,如下图:

    640?wx_fmt=png

    样本内数据是用来训练模型的数据,也叫训练数据。它们是已知的,可计算统计的。

    样本外数据是未来的没见过的新数据。它们是未知的,不可计算统计的。

    机器学习在样本内数据训练模型用来预测:

    • 样本内预测:根据训练模型对样本内数据进行预测,可与已知标签比较来评估模型表现

    • 样本外预测:根据训练模型对样本外数据进行预测,不能与未知的标签比较

    1.3

    任务

    根据学习的任务模式 (训练数据是否有标签),机器学习可分为四大类:

    1. 有监督学习 (有标签)

    2. 无监督学习 (无标签)

    3. 半监督学习 (有部分标签)

    4. 增强学习 (有评级标签)

    深度学习只是一种方法,而不是任务模式,因此与上面四类不属于同一个维度,但是深度学习与它们可以叠加成:深度有监督学习、深度非监督学习、深度半监督学习和深度增强学习。迁移学习也是一种方法,也可以分类为有监督迁移学习、非监督迁移学习、半监督迁移学习和增强迁移学习。

    下图画出机器学习各类之间的关系。

    640?wx_fmt=png

    由于 Sklearn 里面模型主要处理「有监督学习」和「无监督学习」两类,我们接下来也只讨论这两类。

    有监督学习

    有监督学习 (supervised learning) 利用输入数据及其对应标签来训练模型。这种学习方法类似学生通过研究问题和参考答案来学习,在掌握问题和答案之间的对应关系后,学生可自己给出相似新问题的答案了。

     

    在有监督学习中,数据 = (特征,标签),而其主要任务是分类和回归。以上述詹姆斯的个人统计为例。

    分类

    如果预测的是离散值 (discrete value),例如比赛结果赢或输,此类学习任务称为分类 (classification)。

    640?wx_fmt=png

    回归

    如果预测的是连续值 (continuous value),例如詹姆斯效率 65.1, 70.3 等等,此类学习任务称为回归 (regression)。

    640?wx_fmt=png

    无监督学习

    无监督学习 (unsupervised learning) 是找出输入数据的模式。比如,它可以根据电影的各种特征做聚类,用这种方法收集数据为电影推荐系统提供标签。此外无监督学习还可以降低数据的维度,它可以帮助我们更好的理解数据。

     

    在无监督学习中,数据 = (特征,)。

    聚类

    除了根据詹姆斯个人统计来预测骑士队输赢或者个人效率值外,我们还可以对该数据做聚类 (clustering),即将训练集中的数据分成若干组,每组成为一个簇 (cluster)。

    640?wx_fmt=png

    假设聚类方法将数据聚成二个簇 A 和 B,如下图

    640?wx_fmt=png

    后来发现簇 A 代表赢,簇 B 代表输。聚类的用处就是可以找到一个潜在的原因来解释为什么样例 1 和 3 可以赢球。难道真的是只要詹姆斯三双就可以赢球?

    降维

    注:下面对降维的理解不是那么严谨,只为了让小白对降维大概有个概念。

    詹姆斯完整统计数据还有抢断、盖帽和犯规,但这些对预测比赛输赢、效率值都没什么用,因此可以通过降维的方法将其去除。

    640?wx_fmt=png

    1.4

    性能度量

    回归和分类任务中最常见的误差函数以及一些有用的性能度量如下。

    640?wx_fmt=png

    回归任务的误差函数估量在数据集 D 上模型的连续型预测值 h(x) 与连续型真实值 y 的距离,h(x) 和 y 可以取任意实数。误差函数是一个非负实值函数,通常使用 ED[h] 来表示。图表展示如下。

    640?wx_fmt=png

    640?wx_fmt=png

    分类任务的误差函数估量在数据集 D 上模型的离散型预测值 h(x) 与离散型真实值 y 的不一致程度,惯例是 y 和 h(x) 取±1,比如正类取 1 负类取 -1。图表展示如下。

    640?wx_fmt=png

    640?wx_fmt=png

    除上述损失函数之外,分类任务还有很多其他有用的性能度量。

     

    错误率:分类错误的样本数占样本总数的比例称为错误率 (error rate),相应的分类正确的样本数占样本总数的比例称为精度 (accuracy)。在 10 个样本中有 2 个样本分类错误,则错误率为 20%,而精度为 80%。

     

    查准率和查全率:错误率和精度虽然常用,但是不能满足所有任务需求。假定用训练好的模型预测骑士赢球,显然,错误率衡量了多少比赛实际是赢球但预测成输球。但是若我们关心的是“预测出的比赛中有多少是赢球”,或“赢球的比赛中有多少被预测出了”,那么错误率这个单一指标显然就不够用了,这时需要引进更为细分的性能度量,即查准率 (precision) 和查全率 (recall)。

    其他概念比如混淆矩阵、ROC、AUC 我们再下帖的实例用到时再细讲。

    1.5

    模型

    有监督模型如下图所示:

    640?wx_fmt=png

    无监督模型包括各种聚类分析 (KMeans, DBSCAN)、主成分分析 (PCA)、独立成分分析 (ICA)、隐含狄利克雷分配 (LDA) 等等。


    如要了解更多机器学习的细节,请参考本帖次条的〖机器学习帖子汇总〗,里面是我写的所有关于「有监督学习」的内容。

    费了这么多时间来介绍机器学习,无非就是让大家在使用 Sklearn 时知道自己在做什么,知道那些概念在说什么就够了。

    2
    Sklearn 数据

    Sklearn 和之前讨论的 NumPy, SciPy, Pandas, Matplotlib 相似,就是一个处理特殊任务的包,Sklearn 就是处理机器学习 (有监督学习和无监督学习) 的包,更精确的说,它里面有六个任务模块和一个数据引入模块

    • 有监督学习的分类任务

    • 有监督学习的回归任务

    • 无监督学习的聚类任务

    • 无监督学习的降维任务

    • 数据预处理任务

    • 模型选择任务

    • 数据引入

    本节就来看看 Sklearn 里数据格式和自带数据集。

    2.1

    数据格式

    在 Sklean 里,模型能即用的数据有两种形式:

    1. Numpy 二维数组 (ndarray) 的稠密数据 (dense data),通常都是这种格式。

    2. SciPy 矩阵 (scipy.sparse.matrix) 的稀疏数据 (sparse data),比如文本分析每个单词 (字典有 100000 个词) 做独热编码得到矩阵有很多 0,这时用 ndarray 就不合适了,太耗内存。

    上述数据在机器学习中通常用符号 X 表示,是模型自变量。它的大小 = [样本数, 特征数],图下图所示。该房屋数据有 21000 条包括平方英尺,卧室数,楼层,日期,翻新年份等等 21 栏。该数据形状为 [21000, 21]

    640?wx_fmt=png

    有监督学习除了需要特征 X 还需要标签 y,而 y 通常就是 Numpy 一维数组,无监督学习没有 y。

    2.2

    自带数据集

    Sklearn 里面有很多自带数据集供用户使用。

    特例描述

    640?wx_fmt=png

    数据集包括 150 条鸢尾花的四个特征 (萼片长/宽和花瓣长/宽) 和三个类别。在盘 Seaborn 时是从 csv 文件读取的,本帖从 Sklearn 里面的 datasets 模块中引入,代码如下:

    from sklearn.datasets import load_iris	
    iris = load_iris()

    数据是以「字典」格式存储的,看看 iris 的键有哪些。

    iris.keys()

    dict_keys(['data', 'target', 
               'target_names', 'DESCR',
               'feature_names', 'filename'])

    键里面的名称解释如下:

    • data:特征值 (数组)

    • target:标签值 (数组)

    • target_names:标签 (列表)

    • DESCR:数据集描述

    • feature_names:特征 (列表)

    • filename:iris.csv 文件路径

    具体感受一下 iris 数据中特征的大小、名称和前五个示例。

    n_samples, n_features = iris.data.shape	
    print((n_samples, n_features))	
    print(iris.feature_names)	
    iris.data[0:5]
    (150, 4)
    
    ['sepal length (cm)', 'sepal width (cm)', 
     'petal length (cm)', 'petal width (cm)']
    
    array([[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],
           [5. , 3.6, 1.4, 0.2]])

    150 个样本,4 个特征,没毛病!再感受一下标签的大小、名称和全部示例。

    print(iris.target.shape)	
    print(iris.target_names)	
    iris.target
    (150,)
    
    ['setosa' 'versicolor' 'virginica']
    
    array([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])

    150 个标签,3 类别 (分别用 0, 1, 2 数值来代表 setosaversicolorvirginica)。

    用 Pandas 的 DataFrame (将 X 和 y 合并) 和 Seaborn 的 pairplot (看每个特征之间的关系) 来用表格和图来展示一下数据集的内容。

    640

    Pandas DataFrame

    iris_data = pd.DataFrame( iris.data, 	
                              columns=iris.feature_names )	
    iris_data['species'] = iris.target_names[iris.target]	
    iris_data.head(3).append(iris_data.tail(3))

    640?wx_fmt=png

    640

    Seaborn Pairplot

    sns.pairplot( iris_data, hue='species', palette='husl' );

    640?wx_fmt=png

    正规引入

    看完鸢尾花的 iris 数据展示后,现在来看看 Sklearn 三种引入数据形式。

    1. 打包好的数据:对于小数据集,用 sklearn.datasets.load_*

    2. 分流下载数据:对于大数据集,用 sklearn.datasets.fetch_*

    3. 随机创建数据:为了快速展示,用 sklearn.datasets.make_*

    上面这个星号 * 是什么意思,指的是具体文件名,敲完

    • datasets.load_<TAB>

    • datasets.fetch_<TAB>

    • datasets.make_<TAB>

    点击键盘上的 <TAB> 键就可以看到很多完整的文件名,看下面动图就明白了。

    640?wx_fmt=gif

    Load 一个数字小数据集 digits?

    digits = datasets.load_digits()	
    digits.keys()
    dict_keys(['data', 'target', 'target_names',
               'images', 'DESCR'])

    Fetch 一个加州房屋大数据集 california_housing?

    california_housing = datasets.fetch_california_housing()	
    california_housing.keys()
    dict_keys(['data', 'target', 
               'feature_names', 'DESCR'])

    Make 一个高斯分位数数据集 gaussian_quantile

    gaussian_quantiles = datasets.make_gaussian_quantiles()	
    type(gaussian_quantiles), len(gaussian_quantiles)
    (tuple, 2)

    3
    核心 API

    Sklearn 里万物皆估计器。估计器是个非常抽象的叫法,可把它不严谨的当成一个模型 (用来回归、分类、聚类、降维),或当成一套流程 (预处理、网格最终)。

    本节三大 API 其实都是估计器:

    1. 估计器 (estimator) 当然是估计器

    2. 预测器 (predictor) 是具有预测功能的估计器

    3. 转换器 (transformer) 是具有转换功能的估计器

    这三句看似废话,其实蕴藏了很多内容。其实我对第 1 点这个估计器的起名不太满意,我觉得应该叫拟合器 (fitter) - 具有拟合功能的估计器。看完这一节你就会明白「拟合器」这种叫法更合理。

    3.1

    估计器

    定义:任何可以基于数据集对一些参数进行估计的对象都被称为估计器。

    两个核心点:1. 需要输入数据,2. 可以估计参数。估计器首先被创建,然后被拟合。

    创建估计器:需要设置一组超参数,比如

    • 线性回归里超参数 normalize=True

    • K 均值里超参数 n_clusters=3

    在创建好的估计器 model 可以直接访问这些超参数,用 . 符号。

    • model.normalize

    • model.n_clusters

    但 model 中有很多超参数,你不可能一开始都知道要设置什么值,没设置的用 Sklearn 会给个合理的默认值,因此新手不用担心。

    拟合估计器:需要训练集。在有监督学习中的代码范式为

        model.fit( X_train, y_train )

    在无监督学习中的代码范式为

        model.fit( X_train )

    拟合之后可以访问 model 里学到的参数,比如线性回归里的特征前的系数 coef_,或 K 均值里聚类标签 labels_

    • model.coef_

    • model.labels_

    说了这么多抽象的东西,现在展示有监督学习的「线性回归」和无监督学习的「K 均值」的具体例子。

    线性回归

    首先从 sklearn 下的 linear_model 中引入 LinearRegression,再创建估计器起名 model,设置超参数 normalize 为 True,指的在每个特征值上做标准化,这样会加速数值运算。

    from sklearn.linear_model import LinearRegression	
    
    	
    model = LinearRegression(normalize=True)	
    model

    640?wx_fmt=png

    创建完后的估计器会显示所有的超参数,比如我们设置好的 normalize=True,其他没设置的都是去默认值,比如 n_jobs=None 是只用一个核,你可以将其设为 2 就是两核并行,甚至设为 -1 就是电脑里所有核并行。

    自己创建一个简单数据集 (没有噪声完全线性) 只为了讲解估计器里面的特征。

    x = np.arange(10)	
    y = 2 * x + 1	
    plt.plot( x, y, 'o' );

    640?wx_fmt=png

    还记得 Sklearn 里模型要求特征 X 是个两维变量么 (样本数×特征数)?但在本例中 X 是一维,因为我们用 np.newaxis 加一个维度,它做的事情就是把 [1, 2, 3] 转成 [[1],[2],[3]]。再把 X 和 y 丢进 fit() 函数来拟合线性模型的参数。

    X = x[:, np.newaxis]	
    model.fit( X, y )

    640?wx_fmt=png

    拟合完后的估计器和创建完的样子看起来一样,但是已经用「model.param_」可以访问到学好的参数了,展示如下。

    print( model.coef_ )	
    print( model.intercept_ )
    [2.]
    1.0

    斜率为 2,截距为 1,没毛病。和访问超参数时不一样,注意访问参数要加一个下划线 _。

    K 均值

    首先从 sklearn 下的 cluster 中引入 KMeans,再创建估计器起名 model,设置超参数 n_cluster 为 3 (为了展示方便而我们知道用的 iris 数据集有 3 类,实际上应该选不同数量的 n_cluster,根据 elbow 图来决定,下帖细讲)。

    再者,iris 数据里是有标签 y 的,我们假装没有 y 才能无监督的聚类啊,要不然应该做有监督的分类的。

    from sklearn.cluster import KMeans	
    
    	
    model = KMeans( n_clusters=3 )	
    model

    640?wx_fmt=png

    创建完后的估计器会显示所有的超参数,比如我们设置好的 n_cluster=3,其他没设置的都是去默认值,比如 max_iter=300 是最多迭代次数为 300,算法不收敛也停了。

    还记得 iris 里的特征有四个吗 (萼片长、萼片宽、花瓣长、花瓣宽)?四维特征很难可视化,因此我们只取两个特征 (萼片长、萼片宽) 来做聚类并且可视化结果。注意下面代码 X = iris.data[:,0:2]

    X = iris.data[:,0:2]	
    model.fit(X)

    640?wx_fmt=png

    拟合完后的估计器和创建完的样子看起来一样,但是已经用「model.param_」可以访问到学好的参数了,展示如下。

    print( model.cluster_centers_, '\n')	
    print( model.labels_, '\n' )	
    print( model.inertia_, '\n')	
    print( iris.target )

    640?wx_fmt=png

    有点乱,解释一下 KMeans 模型这几个参数:

    • model.cluster_centers_:簇中心。三个簇那么有三个坐标。

    • model.labels_:聚类后的标签

    • model.inertia_:所有点到对应的簇中心的距离平方和 (越小越好)

    需要强调的是真实标签 iris.label 和聚类标签 model.labels_ 看起来差的很远。类别 0 都一致,但是类别 1 和 2 弄反了,这是因为在 KMeans 算法里标注的类别索引和真实类别索引不一样 (我现在也没找到什么方法能够让它们一致)。

    640?wx_fmt=png

    640?wx_fmt=png

    小结

    虽然上面以有监督学习的 LinearRegression 和无监督学习的 KMeans 举例,但实际上你可以将它们替换成其他别的模型,比如有监督学习的 LogisticRegression 和无监督学习的 DBSCAN。它们都是「估计器」,因此都有 fit() 方法。使用它们的通用伪代码如下:

    # 有监督学习	
    from sklearn.xxx import SomeModel	
    # xxx 可以是 linear_model 或 ensemble 等	
    
    	
    model = SomeModel( hyperparameter )	
    model.fit( X, y )
    # 无监督学习	
    from sklearn.xxx import SomeModel	
    # xxx 可以是 cluster 或 decomposition 等	
    
    	
    model = SomeModel( hyperparameter )	
    model.fit( X )

    3.2

    预测器

    定义:预测器在估计器上做了一个延展,延展出预测的功能。

    两个核心点:1. 基于学到的参数预测,2. 预测有很多指标。最常见的就是 predict() 函数:

    • model.predict(X_test)评估模型在新数据上的表现

    • model.predict(X_train)确认模型在老数据上的表现

    因为要做预测,首先将数据分成 80:20 的训练集 (X_train, y_train) 和测试集 (X_test, y_test),在用从训练集上拟合 fit() 的模型在测试集上预测 predict()

    from sklearn.datasets import load_iris	
    iris = load_iris()
    from sklearn.model_selection import train_test_split	
    
    	
    X_train, X_test, y_train, y_test 	
    = train_test_split( iris['data'], 	
                        iris['target'], 	
                        test_size=0.2 )	
    
    	
    print( 'The size of X_train is ', X_train.shape )	
    print( 'The size of y_train is ', y_train.shape )	
    print( 'The size of X_test is ', X_test.shape )	
    print( 'The size of y_test is ', y_test.shape )
    The size of X_train is (120, 4)
    The size of y_train is (120,)
    The size of X_test is (30, 4)
    The size of y_test is (30,)

    让我们来看个有监督学习的「对率回归」和继续上节无监督学习的「K 均值」的例子。

    对率回归

    首先从 sklearn 下的 linear_model 中引入 LogisticRegression,再创建估计器起名 model,设置超参数 mutli_class 为 multinomial 因为有三种鸢尾花,是个多分类问题。

    接着再训练集上拟合参数,这时估计器 model 里面已经可以访问这些参数了。

    640?wx_fmt=png

    640?wx_fmt=png

    predict & predict_proba

    对于分类问题,我们不仅想知道预测的类别是什么,有时还想知道预测该类别的信心如何。前者用 predict(),后者用 predict_proba()

    代码如下,在测试集上比较预测标签 y_pred 和真实标签 y_test 发现它们完全吻合,准确率 100% (iris 数据太简单 u1F61D.png)。

    y_pred = model.predict( X_test )	
    p_pred = model.predict_proba( X_test )	
    print( y_test, '\n' )	
    print( y_pred, '\n' )	
    print( p_pred )

    640?wx_fmt=png

    解释一下 p_pred - 测试集里有 30 个数据,鸢尾花有 3 类,因此 predict_proba() 生成一个 30×3 的数组,每行的概率加起来为 1。

    为了验证我们的理解,我们看 Sklearn 是不是把「每行中最大概率值对应的那一类」作为预测结果。

    s = ['Class 1 Prob', 'Class 2 Prob', 'Class 3 Prob']	
    prob_DF = pd.DataFrame( p_pred, columns=s )	
    prob_DF['Predicted Class'] = y_pred	
    prob_DF.head()

    640?wx_fmt=png

    是的!前三行 Class 1 Prob 最大,预测是第一类;第四行 Class 2 Prob 最大,预测是第二类;第四行 Class 3 Prob 最大,预测是第三类。

    score & decision_function

    预测器里还有额外的两个函数可以使用。在分类问题中

    • score() 返回的是分类准确率

    • decision_function() 返回的是每个样例在每个类下的分数值

    print( model.score( X_test, y_test ) )	
    print( np.sum(y_pred==y_test)/len(y_test) )
    1.0
    1.0
    decision_score = model.decision_function( X_test )	
    print( decision_score )

    640?wx_fmt=png

    为了验证我们的理解,我们看 Sklearn 是不是把「每行中最高得分值对应的那一类」作为预测结果。

    s = ['Class 1 Score', 'Class 2 Score', 'Class 3 Score']	
    decision_DF = pd.DataFrame( decision_score, columns=s )	
    decision_DF['Predicted Class'] = y_pred	
    decision_DF.tail()

    640?wx_fmt=png

    是的!前两行 Class 3 Score 最大,预测是第三类;后三行 Class 1 Score 最大,预测是第一类。

    K 均值

    继续上一节的 KMeans 模型,首先用 fit() 训练。

    640?wx_fmt=png

    再用 predict() 在测试集上预测出类别 inx_pred,和真实标签 y_test 比对。再次强调,inx_pred 和 y_test 给三个类别的索引定义是不同的。

    idx_pred = model.predict( X_test[:,0:2] )	
    print( index_pred )	
    print( y_test )

    640?wx_fmt=png

    最后画出两幅图 (都是在测试集上),左图是根据聚类预测的标签画出散点图,而右图是根据真实标签画出散点图,对比两幅图看很像,聚类的效果也不错。

    640?wx_fmt=png

    640?wx_fmt=png

    KMeans 模型里也有 score() 函数,输出是值是它要优化的目标函数的对数。

    model.score( X_test[:,0:2] )
    -9.662259042197803

    小节

    估计器都有 fit() 方法,预测器都有 predict() 和 score() 方法,言外之意不是每个预测器都有 predict_proba() 和 decision_function() 方法,这个在用的时候查查官方文档就清楚了 (比如 RandomForestClassifier 就没有 decision_function() 方法)。

    使用它们的通用伪代码如下:

    # 有监督学习	
    from sklearn.xxx import SomeModel	
    # xxx 可以是 linear_model 或 ensemble 等	
    
    	
    model = SomeModel( hyperparameter )	
    model.fit( X, y )	
    y_pred = model.predict( X_new )	
    s = model.score( X_new )
    # 无监督学习	
    from sklearn.xxx import SomeModel	
    # xxx 可以是 cluster 或 decomposition 等	
    
    	
    model = SomeModel( hyperparameter )	
    model.fit( X )	
    idx_pred = model.predict( X_new )	
    s = model.score( X_new )

    3.3

    转换器

    定义:转换器也是一种估计器,两者都带拟合功能,但估计器做完拟合来预测,而转换器做完拟合来转换。

    核心点:估计器里 fit + predict,转换器里 fit + transform。

    本节介绍两大类转换器

    1. 将分类型变量 (categorical) 编码成数值型变量 (numerical)

    2. 规范化 (normalize) 或标准化 (standardize) 数值型变量

    分类型变量编码

    640

    LabelEncoder & OrdinalEncoder

    LabelEncoder 和 OrdinalEncoder 都可以将字符转成数字,但是

    • LabelEncoder  的输入是一维,比如 1d ndarray

    • OrdinalEncoder  的输入是二维,比如 DataFrame

    首先给出要编码的列表 enc 和要解码的列表 dec

    enc = ['win','draw','lose','win']	
    dec = ['draw','draw','win']

    从 sklearn 下的 preprocessing 中引入 LabelEncoder,再创建转换器起名 LE,不需要设置任何超参数。 

    from sklearn.preprocessing import LabelEncoder	
    LE = LabelEncoder()	
    
    	
    print( LE.fit(enc) )	
    print( LE.classes_ )	
    print( LE.transform(dec) )
    LabelEncoder()
    ['draw' 'lose' 'win']
    [0 0 2]

    上面结果解释如下

    • 第 4 行转换器 fit 之后还是转换器,只不过从数据 enc 上学到了些东西

    • 第 5 行的 LE.classes_ 就是学到的东西之一,系统把 'draw', 'lose', 'win' 分别赋予 0, 1, 2

    • 第 6 行用学到的东西来解码 ['draw','draw','win'] 得到 [0 0 2]

    除了LabelEncoder 能编码,OrdinalEncoder 也可以。首先从 sklearn 下的 preprocessing 中引入 OrdinalEncoder,再创建转换器起名 OE,不需要设置任何超参数。 下面结果和上面类似,就不再多解释了。

    from sklearn.preprocessing import OrdinalEncoder	
    OE = OrdinalEncoder()	
    
    	
    enc_DF = pd.DataFrame(enc)	
    dec_DF = pd.DataFrame(dec)	
    
    	
    print( OE.fit(enc_DF) )	
    print( OE.categories_ )	
    print( OE.transform(dec_DF) )
    OrdinalEncoder(categories='auto', dtype=<class 'numpy.float64'>)
    
    [array(['draw', 'lose', 'win'], dtype=object)]
    
    [[0.]
    [0.]
    [2.]]


    上面这种编码的问题是,机器学习算法会认为两个临近的值比两个疏远的值要更相似。显然这样不对 (比如,0 和 1 比 0 和 2 距离更近,难道 draw 和 win 比 draw 和 lose更相似?)。

    要解决这个问题,一个常见的方法是给每个分类创建一个二元属性,即独热编码 (one-hot encoding)。如何用它看下段。

    640

    OneHotEncoder

    独热编码其实就是把一个整数用向量的形式表现。下图就是对数字 0-9 做独热编码。

    640?wx_fmt=png

    转换器 OneHotEncoder 可以接受两种类型的输入:

    1. 用 LabelEncoder 编码好的一维数组

    2. DataFrame 


    一. 用 LabelEncoder 编码好的一维数组 (元素为整数),重塑 (用 reshape(-1,1)) 成二维数组作为 OneHotEncoder 输入。

    from sklearn.preprocessing import OneHotEncoder	
    OHE = OneHotEncoder()	
    
    	
    num = LE.fit_transform( enc )	
    print( num )	
    OHE_y = OHE.fit_transform( num.reshape(-1,1) )	
    OHE_y
    [2 0 1 2]
    
    <4x3 sparse matrix of type 
    '<class 'numpy.float64'>'
    with 4 stored elements 
    in Compressed Sparse Row format>

    上面结果解释如下

    • 第 5 行打印出编码结果 [2 0 1 2]

    • 第 6 行将其转成独热形式,输出是一个「稀疏矩阵」形式,因为实操中通常类别很多,因此就一步到位用稀疏矩阵来节省内存

    想看该矩阵里具体内容,用 toarray() 函数。

    OHE_y.toarray()
    array([[0., 0., 1.],
           [1., 0., 0.],
           [0., 1., 0.],
           [0., 0., 1.]])


    二. 用 DataFrame作为 OneHotEncoder 输入。

    OHE = OneHotEncoder()	
    OHE.fit_transform( enc_DF ).toarray()
    array([[0., 0., 1.],
           [1., 0., 0.],
           [0., 1., 0.],
           [0., 0., 1.]])

    和上面结果类似,不解释了。

    特征缩放

    数据要做的最重要的转换之一是特征缩放 (feature scaling)。当输入的数值的量刚不同时,机器学习算法的性能都不会好。

    具体来说,对于某个特征,我们有两种方法:

     

    • 标准化 (standardization):每个维度的特征减去该特征均值,除以该维度的标准差。

    • 规范化 (normalization):每个维度的特征减去该特征最小值,除以该特征的最大值与最小值之差。

    640?wx_fmt=png

    640

    MinMaxScaler

    整套转换器「先创建再 fit 在 transform」的流程应该很清楚了。自己读下面代码看看是不是秒懂。唯一需要注意的就是输入 X 要求是两维。

    from sklearn.preprocessing import MinMaxScaler	
    
    	
    X = np.array( [0, 0.5, 1, 1.5, 2, 100] )	
    
    	
    X_scale = MinMaxScaler().fit_transform( X.reshape(-1,1) )	
    X_scale
    array([[0. ],
           [0.005],
           [0.01 ],
           [0.015],
           [0.02 ],
           [1. ]])

    640

    StandardScaler

    牢记转换器「先创建再 fit 在 transform」的流程就行了。

    from sklearn.preprocessing import StandardScaler	
    
    	
    X_scale = StandardScaler().fit_transform( X.reshape(-1,1) )	
    X_scale
    array([[-0.47424487],
           [-0.46069502],
           [-0.44714517],
           [-0.43359531],
           [-0.42004546],
           [ 2.23572584]])

    警示: fit() 函数只能作用在训练集上,千万不要作用在测试集上,要不然你就犯了数据窥探的错误了!拿标准化举例,用训练集 fit 出来的均值标准差参数,来对测试集做标准化。

    4
    高级 API

    Sklearn 里核心 API 接口是估计器,那高级 API 接口就是元估计器 (meta-estimator),即由很多基估计器 (base estimator) 组合成的估计器。

        meta_model( base_model )

    本节讨论五大元估计器,分别带集成功能的 ensemble,多分类和多标签的 multiclass,多输出的 multioutput,选择模型的 model_selection,和流水线的 pipeline

    • ensemble.BaggingClassifier

    • ensemble.VotingClassifier

    • multiclass.OneVsOneClassifier

    • multiclass.OneVsRestClassifier

    • multioutput.MultiOutputClassifier

    • model_selection.GridSearchCV

    • model_selection.RandomizedSearchCV

    • pipeline.Pipeline

    在下面五节,我们会用的鸢尾花数据 iris 和数字数据 digits,还有一些自己创建的数据。

    4.1

    Ensemble 估计器

    • 分类器统计每个子分类器的预测类别数,再用「多数投票」原则得到最终预测。

    • 回归器计算每个子回归器的预测平均值。

    最常用的 Ensemble 估计器排列如下:

    • AdaBoostClassifier: 逐步提升分类器

    • AdaBoostRegressor: 逐步提升回归器

    • BaggingClassifier: 装袋分类器

    • BaggingRegressor: 装袋回归器

    • GradientBoostingClassifier: 梯度提升分类器

    • GradientBoostingRegressor: 梯度提升回归器

    • RandomForestClassifier: 随机森林分类器

    • RandomForestRegressor: 随机森林回归器

    • VotingClassifier: 投票分类器

    • VotingRegressor: 投票回归器

    我们用鸢尾花数据 iris,拿

    • 同质估计器 RandomForestClassifier 

    • 异质估计器 VotingClassifier 

    来举例。首先将数据分成 80:20 的训练集和测试集,并引入 metrics 来计算各种性能指标。

    from sklearn.datasets import load_iris	
    iris = load_iris()
    from sklearn.model_selection import train_test_split	
    from sklearn import metrics	
    
    	
    X_train, X_test, y_train, y_test 	
    = train_test_split( iris['data'], 	
                        iris['target'], 	
                        test_size=0.2 )

    640

    RandomForestClassifier

    RandomForestClassifier  通过控制 n_estimators 超参数来决定基估计器的个数,本例是 4 棵决策树 (森林由树组成);此外每棵树的最大树深为 5 (max_depth=5)。

    from sklearn.ensemble import RandomForestClassifier	
    
    	
    RF = RandomForestClassifier( n_estimators=4, max_depth=5 )	
    RF.fit( X_train, y_train )

    640?wx_fmt=png

    估计器有 fit(),元估计器当然也有 fit()。在估计器那一套又可以照搬到元估计器 (起名 RF) 上了。看看 RF 里包含的估计器个数和其本身。

    print( RF.n_estimators )	
    RF.estimators_

    640?wx_fmt=png

    拟合 RF 完再做预测,用 metrics  里面的 accuracy_score 来计算准确率。训练准确率 98.33%,测试准确率 100%。

    print ( "RF - Accuracy (Train):  %.4g" % 	
            metrics.accuracy_score(y_train, RF.predict(X_train)) )	
    print ( "RF - Accuracy (Test):  %.4g" % 	
            metrics.accuracy_score(y_test, RF.predict(X_test)) )
    RF - Accuracy (Train): 0.9833
    RF - Accuracy (Test): 1

    640

    VotingClassifier

    和随机森林由同质分类器「决策树」不同,投票分类器由若干个异质分类器组成。下例用 VotingClassifier 建立个含有对率回归 (LR)、随机森林 (RF) 和高斯朴素贝叶斯 (GNB) 三个分类器的集成模型。

    RandomForestClassifier  的基分类器只能是决策树,因此只用通过控制 n_estimators 超参数来决定树的个数,而 VotingClassifier 的基分类器要实实在在的输入其本身。

    640?wx_fmt=png

    640?wx_fmt=png

    看看 Ensemble 里包含的估计器个数和其本身。

    print( len(Ensemble.estimators_) )	
    Ensemble.estimators_

    640?wx_fmt=png

    比如元估计器和它三个组成元素的表现。还是集成后的 Ensemble 表现最好。

    LR.fit( X_train, y_train )	
    RF.fit( X_train, y_train )	
    GNB.fit( X_train, y_train )

    640?wx_fmt=png

    LR - Accuracy (Train): 0.975
    RF - Accuracy (Train): 0.9833
    GNB - Accuracy (Train): 0.95
    Ensemble - Accuracy (Train): 0.9833
    
    LR - Accuracy (Test): 1
    RF - Accuracy (Test): 1
    GNB - Accuracy (Test): 1
    Ensemble - Accuracy (Test): 1

    4.2

    Multiclass 估计器

    sklearn.multiclass 可以处理多类别 (multi-class) 的多标签 (multi-label) 的分类问题。

    从小节 4.2 到 4.4,我们都会使用数字数据集 digits。首先将数据分成 80:20 的训练集和测试集。

    from sklearn.datasets import load_digits	
    
    	
    digits = load_digits()	
    digits.keys()
    dict_keys(['data', 'target', 'target_names', 
               'images', 'DESCR'])

    X_train, X_test, y_train, y_test 	
    = train_test_split( digits['data'],	
                        digits['target'],	
                        test_size=0.2 )	
    
    	
    print( 'The size of X_train is ', X_train.shape )	
    print( 'The size of y_train is ', y_train.shape )	
    print( 'The size of X_test is ', X_test.shape )	
    print( 'The size of y_test is ', y_test.shape )
    The size of X_train is (1437, 64)
    The size of y_train is (1437,)
    The size of X_test is (360, 64)
    The size of y_test is (360,)

    训练集和测试集分别有 1437 和 360 张图像。每张照片是包含 8×8 的像素,将其打平 (flatten) 把 2 维的 8×8 重塑成 1 维的 64。

    看看训练集中前 100 张图片和对应的标签 (左下角蓝色小字)。像素很低 (为了我们跑模型快些),但基本上还是能看清。

    640?wx_fmt=png

    640?wx_fmt=png

    多类别分类

    手写数字有 0-9 十类,但手头上只有两分类估计器 (比如像支撑向量机) 怎么用呢?我们可以采取下面三种常见策略:

    • 一对一 (One vs One, OvO):一个分类器用来处理数字 0 和数字 1,一个用来处理数字 0 和数字 2,一个用来处理数字 1 和 2,以此类推。N 个类需要 N(N-1)/2 个分类器。

    • 一对其他 (One vs All, OvA):训练 10 个二分类器,每一个对应一个数字,第一个分类 1 和「非1」,第二个分类 2 和「非2」,以此类推。N 个类需要 N 个分类器。

    640

    OneVsOneClassifier

    考虑一个具体天气多分类问题,天气可以是晴天、阴天和雨天,在 OvO 中,三个分类器为 f1 , f2 和 f3 。

    • f1 负责分类三角形和正方形

    • f2 负责分类三角形和圆形

    • f3 负责分类圆形和正方形

    结果如下

    • f1 预测 ▲

    • f2 预测 ▲ 

    • f3 预测 ●

    根据多数原则得到的结合预测为 ●,如下图所示。

    640?wx_fmt=png

    回到数字分类问题上,代码如下:

    640?wx_fmt=png

    10 类 45 个 OvO 分类器,没错,10*9/2 = 45。

    print( len(ovo_lr.estimators_) )	
    ovo_lr.estimators_

    640?wx_fmt=png

    训练集分类全对,测试集准确率 98%。

    640?wx_fmt=png

    640

    OneVsRestClassifier

    在 OvA 中,把数据分成“某个”和“其他”

     

    • 图一,某个 = 三角形,其他 = 正方形和圆形

    • 图二,某个 = 正方形,其他 = 三角形和圆形

    • 图三,某个 = 圆形,其他 = 三角形和正方形

    三分类分解成三个二分类,对应的分类器为 f1 , f2 和 f3 。

    • f1 预测负类,即预测 ● 和 ◼

    • f2 预测负类,即预测 ▲ 和 ●

    • f3 预测正类,即预测 ●

    三个分类器都预测了 ●,根据多数原则得到的预测是 ●。

    640?wx_fmt=png

    回到数字分类问题上,代码如下:

    640?wx_fmt=png

    10 类 45 个 OvA 分类器,没错。

    print( len(ova_lr.estimators_) )	
    ova_lr.estimators_

    640?wx_fmt=png

    训练集准确率几乎 100%,测试集准确率 96%。

    640?wx_fmt=png

    多标签分类

    到目前为止,所有的样例都总是被分配到仅一个类。有些情况下,你也许想让分类器给一个样例输出多个类别。在无人驾驶的应用中,在下图识别出有车和指示牌,没有交通灯和人。

    640?wx_fmt=png

    我们不打算深入物体识别。先看一个简单点的例子,仅仅是为了阐明「多标签分类」的原理。在手写数字的例子上,我们特意为每个数字设计了多标签:

    • 标签 1 - 奇数、偶数

    • 标签 2 - 小于等于 4,大于 4

    再建立多标签 y_train_multilabel,代码如下 (OneVsRestClassifier 也可以用来做多标签分类):

    from sklearn.multiclass import OneVsRestClassifier	
    
    	
    y_train_multilabel 	
    = np.c_[ y_train%2==0, y_train<=4 ]	
    print(y_train_multilabel)
    [[ True True]
     [False False]
     [False False]
     ...
     [False False]
     [False False]
     [False False]]

    看下图训练集第 1 和 2 个图片是数字 4 和 5,对应上面两标签当然是

    • [True True]:4 是偶数小于等于 4

    • [False False]:5 不是偶数大于 4

    640?wx_fmt=png

    训练模型,只不过这时用的是 y_train_multilabel

    640?wx_fmt=png

    有两个估计器,每个对应一个标签。

    print( len(ova_ml.estimators_) )	
    ova_ml.estimators_

    640?wx_fmt=png

    展示一下测试集上 100 张图片。

    640?wx_fmt=png

    640?wx_fmt=png

    第一张图片是数字 2,它是偶数 (标签 1 为 true),小于等于 4 (标签 2 为 true)。

    print( y_test[:1] )	
    print( ova_ml.predict(X_test[:1,:]) )
    [2]
    [[1 1]]

    4.3

    Multioutput 估计器

    sklearn.multioutput 可以处理多输出 (multi-output) 的分类问题。

    多输出分类是多标签分类的泛化,在这里每一个标签可以是多类别 (大于两个类别) 的。一个例子就是预测图片每一个像素(标签) 的像素值是多少 (从 0 到 255 的 256 个类别)。

    640?wx_fmt=png

    Multioutput 估计器有两个:

    • MultiOutputRegressor: 多输出回归   

    • MultiOutputClassifier: 多输出分类

    本节只关注多输出分类。

    640

    MultiOutputClassifier

    首先引入 MultiOutputClassifier 和 RandomForestClassifier。你看,这两个都是元估计器,因此在 Sklearn 里面估计器可以随意组合。

    from sklearn.multioutput import MultiOutputClassifier	
    from sklearn.ensemble import RandomForestClassifier

    在手写数字的例子上,我们也为特意每个数字设计了多标签而且每个标签的类别都大于二。

    • 标签 1 - 小于等于 4,4 和 7 之间,大于等于 7 (三类)

    • 标签 2 - 数字本身 (十类)

    代码如下:

    640?wx_fmt=png

    用含有 100 棵决策树的随机森林来解决这个多输入分类问题。

    640?wx_fmt=png

    看看这个模型在测试集前五张照片上的预测。

    MO.predict( X_test[:5,:] )
    array([[0, 2],
           [0, 2],
           [0, 0],
           [2, 9],
           [1, 5]])

    这个 ndarray 第一列是标签 1 的类别,第二列是标签 2 的类别。预测结果是这五张照片分别显示数字 2, 2, 0, 9, 5 (标签 2),它们前三个数 2, 2, 0 都小于等于 4 (标签 1 第一类),第四个数 9 大于等于 7 (标签 1 第二类),而第五个数 5 在 4 和 7 之间 (标签 1 第三类)。

    再看看真实标签。

    y_test_1st = y_test.copy()	
    y_test_1st[ y_test<=4 ] = 0	
    y_test_1st[ np.logical_and(y_test>4, y_test<7) ] = 1	
    y_test_1st[ y_test>=7 ] = 2	
    
    	
    y_test_multioutput 	
    = np.c_[ y_test_1st, y_test ]	
    
    	
    y_test_multioutput[:5]
    array([[0, 2],
           [0, 2],
           [0, 0],
           [2, 9],
           [1, 5]])

    相当好!

    4.4

    Model Selection 估计器

    模型选择 (Model Selction) 在机器学习非常重要,它主要用于评估模型表现,常见的 Model Selection 估计器有以下几个:

    • cross_validate: 评估交叉验证的表现。

    • learning_curve: 建立学习曲线。   

    • GridSearchCV: 用交叉验证从网格中一组超参数搜索出最佳超参数。

    • RandomizedSearchCV用交叉验证从一组随机超参数搜索出最佳超参数。

    本小节关注调节超参数的两个估计器,即上面列出的最后两个。它们都要用到交叉验证,先来了解一下这个知识点。

    交叉验证
    K-折交叉验证集 (K-fold cross validation set),就是把整个数据集平均但随机分成 K 份,每份大概包含 m/K 个数据 (m 是总数据数)。
    在这 K 份,每次选 1 份作为训练集在拟合参数 wλ,把参数用在剩下 K-1 份验证集上计算误差。由于遍历了这 K 份数据,因此该操作称为交叉验证。
    如何通过选择交叉验证误差来选择模型描述如下。

    640?wx_fmt=png

    接下来我们来看这两个调参的估计器,网格追踪和随机追踪。

    640?wx_fmt=png

    网格追踪参数 1 在 [1, 10, 100, 1000] 中取值,参数 2 在 [0.01, 0.1, 1 10] 中取值,注意并不是等间距取值。模型在所有 16 个组合跑,选取一对对应最小交叉验证误差的参数。

    随机追踪:根据指定分布随机搜索,可以选择独立于参数个数,比如 log(参数 1) 服从 0 到 3 的均匀分布, log(参数 2) 服从 -2 到 1 的均匀分布。此外,会设定一个预算参数。

    原理讲清楚了,看代码吧。

    640?wx_fmt=png

    640?wx_fmt=png

    解释一下代码:

    • 前 10 行就是引入各种包,并准备好 X 和 y,创建一个含 20 个决策树的随机森林模型,那么它有超参数最大树深、最多特征数、最小可分裂样本数、和分裂标准。

    • 第 12-27 行是运行随机追踪,关键点是建立了一个参数分布 (param_dist),而且还预先设定了个迭代组数 n_iter_search=20

    • 第 22-42 行是运行网格追踪,关键点是建立了一个参数网格 (param_grid)。

    解释一下运行结果:

    • 第一行输出每种追踪法运行的多少次和花的时间。

    • 第二行输出最佳超参数的组合。

    • 第三行输出最高得分。

    由上面结果可知,随机追踪网格追踪用更短时间内找到一组超参数,获得了更高的得分。

    4.5

    Pipeline 估计器

    Pipeline 估计器又叫流水线,把各种估计器串联 (Pipeline) 或并联 (FeatureUnion) 的方式组成一条龙服务。用好了它真的能大大提高效率。

    640

    Pipeline

    Pipeline 将若干个估计器按顺序连在一起,比如

        特征提取 -> 降维 -> 拟合 -> 预测

    在整个 Pipeline 中,它的属性永远和最后一个估计器属性一样

    • 如果最后一个估计器是预测器,那么 Pipeline 是预测器

    • 如果最后一个估计器是转换器,那么 Pipeline 是转换器

    下面用一个简单例子来说明如果用 Pipeline 来做「先填补缺失值-再标准化」这两步的。先生成含缺失值 NaN 的数据 X。

    640?wx_fmt=png

    首先引入 Pipeline,再引入

    • 处理缺失值的转换器 SimpleImputer

    • 做规划化的转换器 MinMaxScaler

    640?wx_fmt=png

    第 4-7 行创建了流水线,范式非常简单,就在 Pipeline() 里一个输入「含名称的估计器的列表」。SimpleImputer 起名叫 imputeMinMaxScaler起名叫 normalize

    由于最后一个估计器是转换器,因此 pipe 也是个转换器。写好了就可以那它来做「先填补缺失值-再标准化」的重复工作了。

    看看运行结果,值都被填满了,而且两列也被标准化了。

    640?wx_fmt=png

    来验证上面流水线的参数,我们可以按顺序来运行这两个转换器,结果是一样的。

    640?wx_fmt=png

    640?wx_fmt=png

    640

    FeatureUnion

    如果我们想在一个节点同时运行几个估计器,我们可用 FeatureUnion。下例首先建立一个 DataFrame

    • 前两列智力 IQ 和脾气 temper 都是分类型变量

    • 后两列收入 income 和身高 height 都是数值型变量

    • 每列中都有缺失值

    640?wx_fmt=png

    640?wx_fmt=png

    我们现在按下列步骤来清洗数据。

    • 对分类型变量:获取 -> 中位数填充 -> 独热编码

    • 对数值型变量:获取 -> 均值填充 -> 标准化

    上面两步是平行进行的。

    首先我们自己定义一个从 DataFrame 里面获取每列的类,起名叫 DataFrameSelector

    知识点

    640?wx_fmt=png


    代码不难,主要就是 transform 函数中,将输入的 DataFrame X 根据属性名称来获取其值。

    接下来建立一个流水线 full_pipe,它并联着两个流水线

    • categorical_pipe 处理分类型变量

      • DataFrameSelector 用来获取

      • SimpleImputer 用出现最多的值来填充 None

      • OneHotEncoder 来编码返回非稀疏矩阵

    numeric_pipe 处理数值型变量

    • DataFrameSelector 用来获取

    • SimpleImputer 用均值来填充 NaN

    • normalize 来规范化数值

    下面代码非常漂亮。

    640?wx_fmt=png

    将结果打印出来,齐活!

    X_proc = full_pipe.fit_transform( X )	
    print( X_proc )
    [[1.         0.12 0. 1. 0. 0. 1. ]
     [0.77777778 0.72 1. 0. 0. 1. 0. ]
     [0.55555556 0.48 1. 0. 0. 0. 1. ]
     [0.         0.52 0. 0. 1. 1. 0. ]
     [0.04444444 1.   0. 1. 0. 1. 0. ]
     [0.11111111 0.   1. 0. 0. 1. 0. ]
     [0.08888889 0.92 0. 1. 0. 1. 0. ]
     [0.34166667 0.52 0. 1. 0. 1. 0. ]
     [0.15555556 0.4  0. 1. 0. 1. 0. ]]

    5
    总结

    Sklearn 里面设计 API 遵循五大原则。

    一致性

    所有对象的接口一致且简单,在「估计器」中

    • 创建:model = Constructor(hyperparam)

    • 拟参:

      • 有监督学习 - model.fit(X_train, y_train)

      • 无监督学习 - model.fit(X_train)

    在「预测器」中

    • 有监督学习里预测标签:y_pred = model.predict(X_test)

    • 无监督学习里识别模式:idx_pred = model.predict( Xtest)

    在「转换器」中

    • 创建:trm = Constructor(hyperparam)

    • 获参:trm.fit(X_train)

    • 转换:X_trm = trm.transform(X_train)

    可检验

    所有估计器里设置的超参数学到的参数都可以通过实例的变量直接访问来检验其值,区别是超参数的名称最后没有下划线 _,而参数的名称最后有下划线 _。举例如下:

    • 通例:model.hyperparameter

    • 特例:SVC.kernel

    • 通例:model.parameter_

    • 特例:SVC.support_vectors_

    标准类

    Sklearn 模型接受的数据集的格式只能是「Numpy 数组」和「Scipy 稀疏矩阵」。超参数的格式只能是「字符」和「数值」。

    不接受其他的类!

    可组成

    模块都能重复「连在一起」或「并在一起」使用,比如两种形式流水线 (pipeline)

    1. 任意转换器序列 

    2. 任意转换器序列 + 估计器

    有默认

    Sklearn 给大多超参数提供了合理的默认值,大大降低了建模的难度。


    结合本帖讲的总结一套机器学习的初级框架:

    确定任务:是「有监督」的分类或回归?还是「无监督」的聚类或降维?确定好后基本就能知道用 Sklearn 里哪些模型了。

    数据预处理:这步最繁琐,要处理缺失值、异常值;要编码分类型变量;要正规化或标准化数值型变量,等等。但是有了 Pipeline 神器一切变得简单高效。

    训练和评估:这步最简单,训练用估计器 fit() 先拟合,评估用预测器 predict() 来评估。

    选择模型:启动 Model Selection 估计器里的 GridSearchCV 和 RandomizedSearchCV,选择得分最高的那组超参数 (即模型)。


    本帖讲的东西有点抽象,但最核心的东西就是弄懂估计器以及元估计器的原理。剩下的就是 1) 了解各种模型,2) 知道模型中每个参数的含义,3) 查阅 Sklearn 官方文档。非深度的机器学习不像深度学习有那么多调参技巧 (tuning trick),按照上面那套框架足够了。

    欢迎扫码添加小编的微信,一起交流学习(请备注自己专业方向):

    640?wx_fmt=jpeg

    展开全文
  • sklearn库的学习

    万次阅读 多人点赞 2017-12-24 15:14:43
    sklearn入门,sklearn库结构

    网上有很多关于sklearn的学习教程,大部分都是简单的讲清楚某一个方面。其实最好的教程就是官方文档(http://scikit-learn.org/stable/),但是官方文档讲述的太过于详细,同时很多人对官方文档的理解和结构认识上都不能很好的把握。我写这篇文章的目的是想用一篇文章讲清楚整个sklearn库,我会讲清楚怎么样用这个库,而不是讲清楚每一个知识点。(授人以鱼不如授人以渔)(本文很多都是从实践的角度出发,也仅仅只代表我个人的认识)
    本篇文章主要从两个方面出发:1,介绍sklearn官方文档的类容和结构;2,从机器学习重要步骤出发讲清楚sklearn的使用方法。

    一、sklearn官方文档的类容和结构
    1,机器学习的认识:从实践的角度出发,机器学学习要做的工作就是在我们有的一个数据集上建立一个或者多个模型,然后对我们的模型进行优化和评估。我们将会在sklearn中看到下图各个模块到底是什么,怎么用。
    这里写图片描述

    2,sklearn库官方文档结构:
    下图表示:官方文档有很多模块:
    tutorials:是一个官方教程,可以理解快速上手教程,但是看完感觉并没有很快。
    user guide(用户指南):这里对每一个算法有详细的介绍
    API:这里是库调用的方法
    FAQ:常见问题
    contributing:贡献,还介绍最新的一些代码,功能。
    (下面三个就跟没有用了)
    这里写图片描述
    总结:一般的做法是API里面找到你要调用的方法,然后可以查看方法参数的情况和使用情况。也可以在指南里面找到具体的解释。

    3,sklearn库的结构:
    这里写图片描述
    (1)结构:
    由图中,可以看到库的算法主要有四类:分类,回归,聚类,降维。其中:

    • 常用的回归:线性、决策树、SVM、KNN ;集成回归:随机森林、Adaboost、GradientBoosting、Bagging、ExtraTrees
    • 常用的分类:线性、决策树、SVM、KNN,朴素贝叶斯;集成分类:随机森林、Adaboost、GradientBoosting、Bagging、ExtraTrees
    • 常用聚类:k均值(K-means)、层次聚类(Hierarchical clustering)、DBSCAN
    • 常用降维:LinearDiscriminantAnalysis、PCA

    (2)图片中隐含的操作流程:
    这个流程图代表:蓝色圆圈内是判断条件,绿色方框内是可以选择的算法。你可以根据自己的数据特征和任务目标去找到一条自己的操作路线,一步步做就好了。

    二、机器学习主要步骤中sklearn应用
    1,数据集:面对自己的任务肯定有自己的数据集,但是对于学习来说,sklearn提供了一些数据,主要有两部分:现在网上一些常用的数据集,可以通过方法加载;另一种sklearn可以生成数据,可以生成你设定的数据。(设定规模,噪声等)
    这里写图片描述

    下面是一段python实例:

    from sklearn import datasets
    from sklearn.linear_model import LinearRegression
    import matplotlib.pyplot as plt
    
    #使用以后的数据集进行线性回归(这里是波士顿房价数据)
    loaded_data=datasets.load_boston()
    data_X=loaded_data.data
    data_y=loaded_data.target
    
    model=LinearRegression()
    model.fit(data_X,data_y)
    
    print(model.predict(data_X[:4,:]))
    print(data_y[:4])
    
    #使用生成线性回归的数据集,最后的数据集结果用散点图表示
    X,y=datasets.make_regression(n_samples=100,n_features=1,n_targets=1,noise=10)   #n_samples表示样本数目,n_features特征的数目  n_tragets  noise噪音
    plt.scatter(X,y)
    plt.show()

    2,数据预处理:数据预处理包括:降维、数据归一化、特征提取和特征转换(one-hot)等,这在sklearn里面有很多方法,具体查看api。这里用归一化(preprocessing.scale() )例子解释一下:

    from sklearn import preprocessing #进行标准化数据时,需要引入个包
    import numpy as np
    from sklearn.cross_validation 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)
    
    #X=preprocessing.minmax_scale(X,feature_range=(-1,1))
    X=preprocessing.scale(X)   #0.966666666667 没有 0.477777777778
    X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.3)
    clf=SVC()
    clf.fit(X_train,y_train)
    print(clf.score(X_test,y_test))
    
    
    plt.scatter(X[:,0],X[:,1],c=y)
    plt.show()
    
    a=np.array([[10,2.7,3.6],
                [-100,5,-2],
                [120,20,40]],dtype=np.float64)   #每一列代表一个属性
    print(a)       #标准化之前a     
    print(preprocessing.scale(a)) #标准化之后的a 

    3,选择模型并训练: sklearn里面有很多的机器学习方法,可以查看api找到你需要的方法,sklearn统一了所有模型调用的api,使用起来还是比较简单。

    from sklearn import datasets
    from sklearn.linear_model import LinearRegression
    import matplotlib.pyplot as plt
    
    #使用以后的数据集进行线性回归
    loaded_data=datasets.load_boston()
    data_X=loaded_data.data
    data_y=loaded_data.target
    
    model=LinearRegression()
    model.fit(data_X,data_y)
    
    print(model.predict(data_X[:4,:]))
    print(data_y[:4])
    
    #参数
    print(model.coef_)      #如果y=0.1x+0.3   则此行输出的结果为0.1
    print(model.intercept_)             #此行输出的结果为0.3
    print(model.get_params())       #模型定义时定义的参数,如果没有定义则返回默认值
    print(model.score(data_X,data_y))   #给训练模型打分,注意用在LinearR中使用R^2 conefficient of determination打分

    4,模型评分:
    (1)模型的score方法:最简单的模型评估方法是调用模型自己的方法:

        #预测
        y_predict = knnClf.predict(x_test)
        print("score on the testdata:",knnClf.score(x_test,y_test))

    (2)sklearn的指标函数:库提供的一些计算方法,常用的有classification_report方法
    这里写图片描述

    下面是一个svm分类器,是关于图片分类的,具体数据这里没有给出,大家只需要关注模型的评估就好。

    def svmClassify(x_train, x_test, y_train, y_test):
        id = range(1, x_test.shape[0]+1)
        print("start run svm!")
        #训练
        svc = svm.SVC(kernel='rbf', C=10,probability=True)
        svc.fit(x_train, y_train)
        #预测
        y_predict = svc.predict(x_test)
        print("svm mode's score on the test data:",svc.score(x_test,y_test))
        print("svm mode's evaluate:",classification_report(y_test,y_predict))
        # print(svc.coef_)  # 如果y=0.1x+0.3   则此行输出的结果为0.1
        # print(svc.intercept_)  # 此行输出的结果为0.3
        print(svc.get_params())  # 模型定义时定义的参数,如果没有定义则返回默认值
    
        #可能性计算
        probablity = svc.predict_proba(x_test)
        list_pro = []
        for i in range(probablity.shape[0]):
            pro = max(list(probablity[i]))
            list_pro.append(pro)
        #输出
        index = np.array(id).reshape(-1,1)
        result = pd.DataFrame(np.column_stack((np.array(id).reshape(-1, 1), np.array(y_test).reshape(-1, 1),np.array(y_predict).reshape(-1,1),np.array(list_pro).reshape(-1,1))),
                              columns=['ImageId','test_label','predict_lable','probablity'])
    
        result.to_csv("result/svm_result.csv", index=False, header=True, encoding='gbk')
    
        diff_index = []
        for i in range(result.shape[0]):
            # print(result['test_label'][i], result['predict_lable'][i],)
            diff_index.append(result['test_label'][i] != result['predict_lable'][i])
        print(diff_index)
        diff = result[diff_index]
        diff_x = x_test_original[diff_index]
    
        diff.to_csv('result/svm_result_diff.csv', index=False, header=True, encoding='gbk')
        # 查看每个错误
        for i in range(len(diff_index)):
            # print("label is:",diff['test_label'][i],"predict is:",diff['predict_lable'][i])
            print("test label is :", diff.iloc[i]['test_label'], 'predict label is :', diff.iloc[i]['predict_lable'])
            x = diff_x[i]
            img = x.reshape(28, 28)
            image_show(img)

    (3)sklearn也支持自己开发评价方法

    5,模型的保存于恢复:模型的保存与恢复可以采用python的pickle,也可以用joblib的方法。

    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)
    
    #method1:pickle
    import pickle
    #save
    with open('save/clf.pickle','wb')as f:
        pickle.dump(clf,f)
    
    #restore
    with open('save/clf.pickle','rb') as f:
        clf=pickle.load(f)
        print(clf.predict(X[0:1]))
    
    
    #method2:joblib
    from sklearn.externals import joblib
    #save
    joblib.dump(clf,'save/clf.pkl')
    clf3=joblib.load('save/clf.pkl')
    print(clf3.predict(X[0:1]))

    这是一篇入门的文章,希望入门的人有一个很好的引导,接下来我也会跟新一些重要的内容。下一篇,我打算讲解交叉验证这个很重要的模块。

    展开全文
  • sklearn

    千次阅读 2019-06-27 15:40:59
    文章目录数据预处理缺失值无量纲化标准化归一化正则化对比处理连续型变量:二值化与分段处理离散型变量:独热编码与哑变量生成多项式特征特征选择Filter过滤法方差选择法卡方检验/卡方过滤F检验互信息法总结Embedded...
  • sklearn入门经典案例

    2019-01-07 14:22:30
    自2007年发布以来,scikit-learn已经成为Python重要的机器学习库了。scikit-learn简称sklearn,支持包括分类、回归、降维和聚类四大机器学习算法。
  • sklearn 快速入门教程

    万次阅读 多人点赞 2018-05-21 23:48:07
    本教程使用于对理论知识具有一定的了解但编码能力稍弱且对sklearn不太了解的同学本文为转载文章,原文地址:https://www.cnblogs.com/lianyingteng/p/7811126.html 传统的机器学习任务从开始到建模的一般流程是:...
  • sklearn之三分类应用

    2019-03-21 14:43:05
    用到的代码目录: 1.入门demo:(先不关心具体数据是什么) python代码:lr_iris.py import numpy as np ...from sklearn import datasets from sklearn.model_...from sklearn.linear_model import Logisti...
  • sklearn简介

    万次阅读 2016-12-12 11:04:30
    sklearn是机器学习中一个常用的python第三方模块,网址:http://scikit-learn.org/stable/index.html ,里面对一些常用的机器学习方法进行了封装,在进行机器学习任务时,并不需要每个人都实现所有的算法,只需要...
  • Sklearn安装

    千次阅读 2017-11-22 08:42:12
    安装sklearn
  • python安装sklearn模块

    万次阅读 多人点赞 2018-03-16 16:56:06
    转载自:http://blog.csdn.net/qq_21904665/article/details/52681176 第一步:更新pip python -m pip install –upgrade pip 第二步:安装 scipy 在网址http://www.lfd.uci.edu/~gohlke/pythonlibs/ ... ...
  • sklearn中的交叉验证(Cross-Validation)

    万次阅读 多人点赞 2017-05-14 01:49:30
    这个repo 用来记录一些python技巧、书籍、学习链接等,...今天主要记录一下sklearn中关于交叉验证的各种用法,主要是对sklearn官方文档 Cross-validation: evaluating estimator performance进行讲解,英文水平好...
  • Sklearn-train_test_split随机划分训练集和测试集

    万次阅读 多人点赞 2017-02-05 15:06:15
    sklearn.model_selection.train_test_split随机划分训练集和测试集 官网文档:...
  • 之前提到过聚类之后,聚类质量的评价: 聚类︱python实现 六大 分群质量评估指标(兰德系数、互信息、轮廓系数) R语言相关分类效果评估: R语言︱分类器的性能表现评价(混淆矩阵,准确率,召回率,F1,mAP、...
  • python sklearn PCA 实例-主成分分析

    千次阅读 2019-08-21 11:17:22
    python sklearn decomposition PCA 主成分分析 主成分分析(PCA) 1、主成分分析(Principal Component Analysis,PCA)是最常用的一种降维方法, 通常用于高维数据集的探索与可视化,还可以用作数据压缩和预处理 2、...
  • sklearn分类

    千次阅读 2018-01-13 22:02:21
    sklearn分类
  • anaconda升级sklearn版本

    万次阅读 2017-09-05 21:18:15
    调用sklearn的model_selection时,发现sklearn中没有model_selection的模块。经过检查,发现anaconda中的sklearn版本太低,为0.17版本。于是,开始了sklearn的升级之旅。1.查看原有版本首先使用conda list命令,查看...
  • sklearn.svm.SVC 参数说明 经常用到sklearn中的SVC函数,这里把文档中的参数翻译了一些,以备不时之需。 本身这个函数也是基于libsvm实现的,所以在参数设置上有很多相似的地方。(PS: libsvm中的二次规划问题的...
  • Python Sklearn.metrics 简介及应用示例 利用Python进行各种机器学习算法的实现时,经常会用到sklearn(scikit-learn)这个模块/库。 无论利用机器学习算法进行回归、分类或者时聚类,评价指标,即检验机器学习...
1 2 3 4 5 ... 20
收藏数 117,228
精华内容 46,891
关键字:

sklearn