Scikit-learn：主要模块和基本使用方法

深碍√TFBOYSˉ_ 2022-09-25 02:24 171阅读 0赞

http://[blog.csdn.net/pipisorry/article/details/52128222][blog.csdn.net_pipisorry_article_details_52128222]

scikit-learn: Machine Learning in Python.scikit-learn库实现了很多机器学习算法。

scikit-learn是一个基于NumPy, SciPy, Matplotlib的开源机器学习工具包，主要涵盖分类，回归和聚类算法，例如SVM， 逻辑回归，朴素贝叶斯，随机森林，k-means等算法，代码和文档都非常不错，在许多Python项目中都有应用。例如在我们熟悉的NLTK中，分类器方面就有专门针对scikit-learn的接口，可以调用scikit-learn的分类算法以及训练数据来训练分类器模型。

scikit-learn的基本功能主要被分为六个部分，分类，回归，聚类，数据降维，模型选择，数据预处理，具体可以参考官方网站上的文档。

## 安装 ##

Note: 要先安装Numpy, Scipy。\[[linux和windows下安装python拓展包及requirement.txt安装类库 ][linux_windows_python_requirement.txt_] \]

### linux下安装scikit-learn ###

Building scikit-learn with pip

This is usually the fastest way to install or upgrade to the latest stablerelease:

pip install -U scikit-learn

pip install --user --install-option="--prefix=" -U scikit-learn

Note:1. The --user flag ask pip to install scikit-learn in the $HOME/.local folder therefore not requiring root permission. This flag should make pip ignore any old version of scikit-learn previously installed on the system while benefitting from system packages for numpy and scipy. Those dependencies can be long and complex to build correctly from source.

2. The --install-option="--prefix=" flag is only required if Python has adistutils.cfg configuration with a predefinedprefix= entry.

\[[Installing scikit-learn][]\]

## scikit-learn机器学习问题解决思路 ##

对于具体的机器学习问题，通常可以分为三个步骤，数据准备与预处理，模型选择与训练，模型验证与参数调优。

### 逻辑回归模型示例 ###

scikit-learn支持多种格式的数据，包括经典的iris数据，LibSVM格式数据等等。为了方便起见，推荐使用LibSVM格式的数据，详细见LibSVM的官网。

from sklearn.datasets importload\_svmlight\_file，导入这个模块就可以加载LibSVM模块的数据，

t\_X,t\_y=load\_svmlight\_file("filename")

机器学习模型也要导入相应的模块，逻辑回归模型在下面的模块中。

from sklearn.linear\_modelimport LogisticRegression

regressionFunc =LogisticRegression(C=10, penalty='l2', tol=0.0001)

train\_sco=regressionFunc.fit(train\_X,train\_y).score(train\_X,train\_y)

test\_sco=regressionFunc.score(test\_X,test\_y)

就可以完成模型的训练和测试了。

为了选择更好地模型可以进行交叉实验，或者使用贪心算法进行参数调优。

导入如下模块就可以，

CV：

from sklearn importcross\_validation

X\_train\_m, X\_test\_m,y\_train\_m, y\_test\_m = cross\_validation.train\_test\_split(t\_X,t\_y, test\_size=0.5,random\_state=seed\_i)

regressionFunc\_2.fit(X\_train\_m,y\_train\_m)

sco=regressionFunc\_2.score(X\_test\_m,y\_test\_m, sample\_weight=None)

GridSearch：

from sklearn.grid\_searchimport GridSearchCV

tuned\_parameters =\[\{'penalty': \['l1'\], 'tol': \[1e-3, 1e-4\],

'C': \[1, 10, 100, 1000\]\},

\{'penalty': \['l2'\], 'tol':\[1e-3, 1e-4\],

'C': \[1, 10, 100, 1000\]\}\]

clf =GridSearchCV(LogisticRegression(), tuned\_parameters, cv=5, scoring=\['precision','recall'\])

print(clf.best\_estimator\_)

当然可以利用matplotlib绘制学习曲线，需要导入相应模块如下：

from sklearn.learning\_curveimport learning\_curve,validation\_curve

核心代码如下，具体参见Scikit-Learn的官方文档：

rain\_sizes, train\_scores,test\_scores = learning\_curve(

estimator, X, y, cv=cv, n\_jobs=n\_jobs,train\_sizes=train\_sizes)

train\_scores, test\_scores =validation\_curve(

estimator, X, y, param\_name,param\_range,

cv, scoring, n\_jobs)

[皮皮blog][blog]

# 预处理 #

## 加载数据(Data Loading) ##

我们假设输入时一个特征矩阵或者csv文件。  
首先，数据应该被载入内存中。  
scikit-learn的实现使用了NumPy中的arrays，所以，我们要使用NumPy来载入csv文件。  
以下是从UCI机器学习数据仓库中下载的数据。

import numpy as np
    import urllib
    # url with dataset
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    # download the file
    raw_data = urllib.urlopen(url)
    # load the CSV file as a numpy matrix
    dataset = np.loadtxt(raw_data, delimiter=",")
    # separate the data from the target attributes
    X = dataset[:,0:7]
    y = dataset[:,8]

我们要使用该数据集作为例子，将特征矩阵作为X，目标变量作为y。

## 数据归一化(Data Normalization) ##

大多数机器学习算法中的梯度方法对于数据的缩放和尺度都是很敏感的，在开始跑算法之前，我们应该进行归一化或者标准化的过程，这使得特征数据缩放到0-1范围中。scikit-learn提供了归一化的方法：

from sklearn import preprocessing
    # normalize the data attributes
    normalized_X = preprocessing.normalize(X)
    # standardize the data attributes
    standardized_X = preprocessing.scale(X)

\[[Scikit-learn：数据预处理Preprocessing data][Scikit-learn_Preprocessing data]\]

## 特征选择(Feature Selection) ##

在解决一个实际问题的过程中，选择合适的特征或者构建特征的能力特别重要。这成为特征选择或者特征工程。  
特征选择时一个很需要创造力的过程，更多的依赖于直觉和专业知识，并且有很多现成的算法来进行特征的选择。  
下面的树算法(Tree algorithms)计算特征的信息量：

from sklearn import metrics
    from sklearn.ensemble import ExtraTreesClassifier
    model = ExtraTreesClassifier()
    model.fit(X, y)
    # display the relative importance of each attribute
    print(model.feature_importances_)

## 评估器 ##

fit，fit\_transform,transform的区别与联系？

fit方法是用于从一个训练集中学习模型参数，其中就包括了归一化时用到的均值，标准偏差；

transform方法就是用于将模型用于位置数据；

fit\_transform就很高效的将模型训练和转化合并到一起，训练样本先做fit，得到mean，standard deviation，然后将这些参数用于transform（归一化训练数据），使得到的训练数据是归一化的。

测试数据只需要在原先得到的mean，std上来做归一化就行了，所以用transform就行了。

[皮皮blog][blog]

# scikit-learn算法的使用 #

scikit-learn实现了机器学习的大部分基础算法，让我们快速了解一下。

### 逻辑回归 ###

大多数问题都可以归结为二元分类问题。这个算法的优点是可以给出数据所在类别的概率。

这里我们使用Pima Indians Diabetes dataset，其中包含健康数据和糖尿病状态数据，一共有768个病人的数据。

import pandas as pd
    url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data'
    col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
    pima = pd.read_csv(url, header=None, names=col_names)
    pima.head()

<table> 
 <thead> 
  <tr> 
   <th>&nbsp;</th> 
   <th>pregnant</th> 
   <th>glucose</th> 
   <th>bp</th> 
   <th>skin</th> 
   <th>insulin</th> 
   <th>bmi</th> 
   <th>pedigree</th> 
   <th>age</th> 
   <th>label</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th>0</th> 
   <td>6</td> 
   <td>148</td> 
   <td>72</td> 
   <td>35</td> 
   <td>0</td> 
   <td>33.6</td> 
   <td>0.627</td> 
   <td>50</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <th>1</th> 
   <td>1</td> 
   <td>85</td> 
   <td>66</td> 
   <td>29</td> 
   <td>0</td> 
   <td>26.6</td> 
   <td>0.351</td> 
   <td>31</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <th>2</th> 
   <td>8</td> 
   <td>183</td> 
   <td>64</td> 
   <td>0</td> 
   <td>0</td> 
   <td>23.3</td> 
   <td>0.672</td> 
   <td>32</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <th>3</th> 
   <td>1</td> 
   <td>89</td> 
   <td>66</td> 
   <td>23</td> 
   <td>94</td> 
   <td>28.1</td> 
   <td>0.167</td> 
   <td>21</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <th>4</th> 
   <td>0</td> 
   <td>137</td> 
   <td>40</td> 
   <td>35</td> 
   <td>168</td> 
   <td>43.1</td> 
   <td>2.288</td> 
   <td>33</td> 
   <td>1</td> 
  </tr> 
 </tbody> 
</table>

上面表格中的label一列，1表示该病人有糖尿病，0表示该病人没有糖尿病

# define X and y
    feature_cols = ['pregnant', 'insulin', 'bmi', 'age']
    X = pima[feature_cols]
    y = pima.label

# split X and y into training and testing sets
    from sklearn.cross_validation import train_test_split
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

# train a logistic regression model on the training set
    from sklearn.linear_model import LogisticRegression
    logreg = LogisticRegression()
    logreg.fit(X_train, y_train)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True, intercept_scaling=1, 
                       max_iter=100, multi_class='ovr', penalty='l2', random_state=None, solver='liblinear', tol=0.0001,verbose=0)

# make class predictions for the testing set
    y_pred_class = logreg.predict(X_test)

from sklearn import metrics
    from sklearn.linear_model import LogisticRegression
    model = LogisticRegression()
    model.fit(X, y)
    print(model)
    # make predictions
    expected = y
    predicted = model.predict(X)
    # summarize the fit of the model
    print(metrics.classification_report(expected, predicted))
    print(metrics.confusion_matrix(expected, predicted))

结果：

> LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True,  
> intercept\_scaling=1, penalty=l2, random\_state=None, tol=0.0001)  
> precision recall f1-score support
> 
>     0.0       0.79      0.89      0.84       500
>        1.0       0.74      0.55      0.63       268
> 
> avg / total 0.77 0.77 0.77 768
> 
> \[\[447 53\]  
> \[120 148\]\]

### 朴素贝叶斯 ###

这也是著名的机器学习算法，该方法的任务是还原训练样本数据的分布密度，其在多类别分类中有很好的效果。

from sklearn import metrics
    from sklearn.naive_bayes import GaussianNB
    model = GaussianNB()
    model.fit(X, y)
    print(model)
    # make predictions
    expected = y
    predicted = model.predict(X)
    # summarize the fit of the model
    print(metrics.classification_report(expected, predicted))
    print(metrics.confusion_matrix(expected, predicted))

结果：

> GaussianNB()  
> precision recall f1-score support
> 
>     0.0       0.80      0.86      0.83       500
>         1.0       0.69      0.60      0.64       268
> 
> avg / total 0.76 0.77 0.76 768
> 
> \[\[429 71\]  
> \[108 160\]\]

### k近邻 ###

k近邻算法常常被用作是分类算法一部分，比如可以用它来评估特征，在特征选择上我们可以用到它。

from sklearn import metrics
    from sklearn.neighbors import KNeighborsClassifier
    # fit a k-nearest neighbor model to the data
    model = KNeighborsClassifier()
    model.fit(X, y)
    print(model)
    # make predictions
    expected = y
    predicted = model.predict(X)
    # summarize the fit of the model
    print(metrics.classification_report(expected, predicted))
    print(metrics.confusion_matrix(expected, predicted))

结果：

> KNeighborsClassifier(algorithm=auto, leaf\_size=30, metric=minkowski,  
> n\_neighbors=5, p=2, weights=uniform)  
> precision recall f1-score support
> 
>     0.0       0.82      0.90      0.86       500
>         1.0       0.77      0.63      0.69       268
> 
> avg / total 0.80 0.80 0.80 768
> 
> \[\[448 52\]  
> \[ 98 170\]\]

### 决策树 ###

分类与回归树(Classification and Regression Trees ,CART)算法常用于特征含有类别信息的分类或者回归问题，这种方法非常适用于多分类情况。

from sklearn import metrics
    from sklearn.tree import DecisionTreeClassifier
    # fit a CART model to the data
    model = DecisionTreeClassifier()
    model.fit(X, y)
    print(model)
    # make predictions
    expected = y
    predicted = model.predict(X)
    # summarize the fit of the model
    print(metrics.classification_report(expected, predicted))
    print(metrics.confusion_matrix(expected, predicted))

结果：

> DecisionTreeClassifier(compute\_importances=None, criterion=gini,  
> max\_depth=None, max\_features=None, min\_density=None,  
> min\_samples\_leaf=1, min\_samples\_split=2, random\_state=None,  
> splitter=best)  
> precision recall f1-score support
> 
>     0.0       1.00      1.00      1.00       500
>         1.0       1.00      1.00      1.00       268
> 
> avg / total 1.00 1.00 1.00 768
> 
> \[\[500 0\]  
> \[ 0 268\]\]

### 支持向量机 ###

\[[Scikit-learn：分类classification ][Scikit-learn_classification] ：svm\]

除了分类和回归算法外，scikit-learn提供了更加复杂的算法，比如聚类算法，还实现了算法组合的技术，如Bagging和Boosting算法。

[皮皮blog][blog]

# 如何优化算法参数 #

一项更加困难的任务是构建一个有效的方法用于选择正确的参数，我们需要用搜索的方法来确定参数。scikit-learn提供了实现这一目标的函数。  
下面的例子是一个进行正则参数选择的程序：

import numpy as np
    from sklearn.linear_model import Ridge
    from sklearn.grid_search import GridSearchCV
    # prepare a range of alpha values to test
    alphas = np.array([1,0.1,0.01,0.001,0.0001,0])
    # create and fit a ridge regression model, testing each alpha
    model = Ridge()
    grid = GridSearchCV(estimator=model, param_grid=dict(alpha=alphas))
    grid.fit(X, y)
    print(grid)
    # summarize the results of the grid search
    print(grid.best_score_)
    print(grid.best_estimator_.alpha)

结果：

> GridSearchCV(cv=None,  
> estimator=Ridge(alpha=1.0, copy\_X=True, fit\_intercept=True, max\_iter=None,  
> normalize=False, solver=auto, tol=0.001),  
> estimator\_\_alpha=1.0, estimator\_\_copy\_X=True,  
> estimator\_\_fit\_intercept=True, estimator\_\_max\_iter=None,  
> estimator\_\_normalize=False, estimator\_\_solver=auto,  
> estimator\_\_tol=0.001, fit\_params=\{\}, iid=True, loss\_func=None,  
> n\_jobs=1,  
> param\_grid=\{'alpha': array(\[ 1.00000e+00, 1.00000e-01, 1.00000e-02, 1.00000e-03,  
> 1.00000e-04, 0.00000e+00\])\},  
> pre\_dispatch=2\*n\_jobs, refit=True, score\_func=None, scoring=None,  
> verbose=0)  
> 0.282118955686  
> 1.0

有时随机从给定区间中选择参数是很有效的方法，然后根据这些参数来评估算法的效果进而选择最佳的那个。

import numpy as np
    from scipy.stats import uniform as sp_rand
    from sklearn.linear_model import Ridge
    from sklearn.grid_search import RandomizedSearchCV
    # prepare a uniform distribution to sample for the alpha parameter
    param_grid = {'alpha': sp_rand()}
    # create and fit a ridge regression model, testing random alpha values
    model = Ridge()
    rsearch = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=100)
    rsearch.fit(X, y)
    print(rsearch)
    # summarize the results of the random parameter search
    print(rsearch.best_score_)
    print(rsearch.best_estimator_.alpha)

结果：

> RandomizedSearchCV(cv=None,  
> estimator=Ridge(alpha=1.0, copy\_X=True, fit\_intercept=True, max\_iter=None,  
> normalize=False, solver=auto, tol=0.001),  
> estimator\_\_alpha=1.0, estimator\_\_copy\_X=True,  
> estimator\_\_fit\_intercept=True, estimator\_\_max\_iter=None,  
> estimator\_\_normalize=False, estimator\_\_solver=auto,  
> estimator\_\_tol=0.001, fit\_params=\{\}, iid=True, n\_iter=100,  
> n\_jobs=1,  
> param\_distributions=\{'alpha': <scipy.stats.distributions.rv\_frozen object at 0x04B86DD0>\},  
> pre\_dispatch=2\*n\_jobs, random\_state=None, refit=True,  
> scoring=None, verbose=0)  
> 0.282118643885  
> 0.988443794636

\[简书：【机器学习实验】scikit-learn的主要模块和基本使用\]

from: [http://blog.csdn.net/pipisorry/article/details/52128222][blog.csdn.net_pipisorry_article_details_52128222]

ref: \[Homepage: [scikit-learn Machine Learning in Python][]\]

\[莫烦: 用 Scikit-learn 和 Python 优雅地学会机器学习 machine learning sklearn 教学 [优酷教程][Link 1][视频列表][Link 1]\]

\[[scikit-learn User Guide][]\]

\[[scikit-learn Tutorials][]\]

\[[Scikit-learn 使用手册中文版][Scikit-learn]\]

\[Fabian Pedregosa, Gael Varoquaux: Scipy Lecture Notes: [2.11. scikit-learn: machine learning in Python][2.11. scikit-learn_ machine learning in Python]\]

\[翻译：[Scikit Learn: 在Python中机器学习][Scikit Learn_ _Python]  [Scikit Learn: 在python中机器学习][Scikit Learn_ _python]\]

[blog.csdn.net_pipisorry_article_details_52128222]: http://blog.csdn.net/pipisorry/article/details/52128222
[linux_windows_python_requirement.txt_]: http://blog.csdn.net/pipisorry/article/details/39902327
[Installing scikit-learn]: http://scikit-learn.org/stable/install.html#install-official-release
[blog]: http://blog.csdn.net/pipisorry
[Scikit-learn_Preprocessing data]: http://blog.csdn.net/pipisorry/article/details/52247679
[Scikit-learn_classification]: http://blog.csdn.net/pipisorry/article/details/53034340
[scikit-learn Machine Learning in Python]: http://scikit-learn.org/stable/index.html
[Link 1]: http://list.youku.com/albumlist/show?id=27469882&ascending=1&page=1
[scikit-learn User Guide]: http://scikit-learn.org/stable/user_guide.html#
[scikit-learn Tutorials]: http://scikit-learn.org/stable/tutorial/index.html
[Scikit-learn]: https://xacecask2.gitbooks.io/scikit-learn-user-guide-chinese-version/content/
[2.11. scikit-learn_ machine learning in Python]: http://www.scipy-lectures.org/advanced/scikit-learn/index.html
[Scikit Learn_ _Python]: http://reverland.org/python/2012/10/14/scikit-learn-machine-learning-in-python/#section-6
[Scikit Learn_ _python]: http://my.oschina.net/u/175377/blog/84420