机器学习 scikit-learn基本使用

超、凢脫俗 2022-06-07 04:53 147阅读 0赞

Python 的 scikit-learn 库实现了很多机器学习算法。我们来学习一下scikit-learn 的简单使用。

# 安装 #

这里使用的是 Python3.6 , 所以 pip安装命令使用 pip3 。

## 1. 安装numpy ##

pip3 install numpy

## 2. 安装scipy ##

pip3 install scipy

## 3. 安装 ##

pip3 install scikit-learn

# 使用 #

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

我们假设输入时一个特征矩阵或者csv文件。

首先，数据应该被载入内存中。

scikit-learn的实现使用了NumPy中的arrays，所以，我们要使用NumPy来载入csv文件。

以下是从UCI机器学习数据仓库中下载的数据。

import numpy as np
    import urllib.request
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]

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

注意事项：

1.  可以用浏览器打开那个url，把数据文件保存在本地，然后直接用 np.loadtxt(‘data.txt’, delemiter=”,”) 就可以加载数据了；
2.  X = dataset\[:, 0:7\]的意思是：把dataset中的所有行，所有0-7列的数据都保存在X中；

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

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

import numpy as np
    import urllib.request
    from sklearn import preprocessing
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]
    
    # 将特征数据缩放到 0-1 范围中
    scaled_X = preprocessing.scale(X)
    
    # 将特征数据 归一化
    normalized_X = preprocessing.normalize(X)
    
    print("normalized_X : ")
    print(normalized_X)
    
    # 将特征数据 标准化
    standardized_X = preprocessing.scale(X)
    
    print("standardized_X : ")
    print(standardized_X)

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

在解决一个实际问题的过程中，选择合适的特征或者构建特征的能力特别重要。这成为特征选择或者特征工程。

特征选择时一个很需要创造力的过程，更多的依赖于直觉和专业知识，并且有很多现成的算法来进行特征的选择。

下面的树算法(Tree algorithms)计算特征的信息量：

import numpy as np
    import urllib.request
    from sklearn.ensemble import ExtraTreesClassifier
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]
    
    # 选择合适的特征或者构建特征
    model = ExtraTreesClassifier()
    model.fit(X, y)
    
    # 显示每个特征值的相对重要性
    print(model.feature_importances_)

输出每个特征的重要程度：

[ 0.13779687  0.27460119  0.11799497  0.09243157  0.06930987  0.1612165  0.14664904]

## 4. 算法的使用 ##

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

### 4.1 逻辑回归 ###

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

[官方文档][Link 1]

import numpy as np
    import urllib.request
    from sklearn import metrics
    from sklearn.linear_model import LogisticRegression
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]
    
    model = LogisticRegression()
    model.fit(X, y)
    
    print('MODEL :')
    print(model)
    
    # 作出预测
    expected = y
    predicted = model.predict(X)
    
    # 总结模型数据的概率
    print('RESULT :')
    print(metrics.classification_report(expected, predicted))
    print('CONFUSION MATRIX :')
    print(metrics.confusion_matrix(expected, predicted))

结果

MODEL :
    LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
              intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
              penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
              verbose=0, warm_start=False)
    RESULT :
                 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
    
    CONFUSION MATRIX :
    [[447 53] [120 148]]

### 4.2 朴素贝叶斯 ###

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

[官方文档][Link 2]

import numpy as np
    import urllib.request
    from sklearn import metrics
    from sklearn.naive_bayes import GaussianNB
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]
    
    model = GaussianNB()
    model.fit(X, y)
    
    print('MODEL :')
    print(model)
    
    # 作出预测
    expected = y
    predicted = model.predict(X)
    
    # 总结模型数据的概率
    print('RESULT :')
    print(metrics.classification_report(expected, predicted))
    print('CONFUSION MATRIX :')
    print(metrics.confusion_matrix(expected, predicted))

结果

MODEL :
    GaussianNB(priors=None)
    RESULT :
                 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
    
    CONFUSION MATRIX :
    [[429 71] [108 160]]

### 4.3 k近邻 ###

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

[官方文档][Link 3]

import numpy as np
    import urllib.request
    from sklearn import metrics
    from sklearn.neighbors import KNeighborsClassifier
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]
    
    # k近邻算法
    model = KNeighborsClassifier()
    model.fit(X, y)
    print(model)
    
    # 作出预测
    expected = y
    predicted = model.predict(X)
    
    # 总结模型数据的概率
    print(metrics.classification_report(expected, predicted))
    print(metrics.confusion_matrix(expected, predicted))

结果

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
               metric_params=None, n_jobs=1, 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]]

### 4.4 决策树 ###

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

[官方文档][Link 4]

import numpy as np
    import urllib.request
    from sklearn import metrics
    from sklearn.tree import DecisionTreeClassifier
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]
    
    # 分类与回归树算法
    model = DecisionTreeClassifier()
    model.fit(X, y)
    print(model)
    
    # 作出预测
    expected = y
    predicted = model.predict(X)
    
    # 总结模型数据的概率
    print(metrics.classification_report(expected, predicted))
    print(metrics.confusion_matrix(expected, predicted))

结果

DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,
                max_features=None, max_leaf_nodes=None,
                min_impurity_decrease=0.0, min_impurity_split=None,
                min_samples_leaf=1, min_samples_split=2,
                min_weight_fraction_leaf=0.0, presort=False, 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]]

### 4.5 支持向量机 ###

SVM是非常流行的机器学习算法，主要用于分类问题，如同逻辑回归问题，它可以使用一对多的方法进行多类别的分类.

[官方文档][Link 5]

import numpy as np
    import urllib.request
    from sklearn import metrics
    from sklearn.svm import SVC
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]
    
    # 向量机算法：主要用于分类问题，如同逻辑回归问题，它可以使用一对多的方法进行多类别的分类。
    model = SVC()
    model.fit(X, y)
    print(model)
    
    # 作出预测
    expected = y
    predicted = model.predict(X)
    
    # 总结模型数据的概率
    print(metrics.classification_report(expected, predicted))
    print(metrics.confusion_matrix(expected, predicted))

结果

SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
      decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',
      max_iter=-1, probability=False, random_state=None, shrinking=True,
      tol=0.001, verbose=False)
                 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]]

# 5.如何优化算法参数 #

一项更加困难的任务是构建一个有效的方法用于选择正确的参数，我们需要用搜索的方法来确定参数。

scikit-learn提供了实现这一目标的函数。

下面的例子是一个进行正则参数选择的程序：

## 5.1 GridSearchCV ##

[官方文档][Link 6]

import numpy as np
    import urllib.request
    from sklearn.linear_model import Ridge
    from sklearn.model_selection import GridSearchCV
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]
    
    # 准备测试数据
    alphas = np.array([1, 0.1, 0.01, 0.001, 0.0001, 0])
    
    # 创建并匹配一个岭回归模型，测试随机的alpha值
    model = Ridge()
    grid = GridSearchCV(estimator=model, param_grid=dict(alpha=alphas))
    grid.fit(X, y)
    print(grid)
    
    # 总结 网格搜索的结果
    print(grid.best_score_)
    print(grid.best_estimator_.alpha)

结果

GridSearchCV(cv=None, error_score='raise',
           estimator=Ridge(alpha=1.0, copy_X=True, fit_intercept=True, max_iter=None,
       normalize=False, random_state=None, solver='auto', tol=0.001),
           fit_params=None, iid=True, 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, return_train_score=True,
           scoring=None, verbose=0)
    0.282118955686
    1.0

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

## 5.2 RandomizedSearchCV ##

[官方文档][Link 7]

import numpy as np
    import urllib.request
    from sklearn.linear_model import Ridge
    from scipy.stats import uniform as sp_rand
    from sklearn.model_selection import RandomizedSearchCV
    
    # 机器学习数据仓库的URL
    url = "http://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
    
    # 下载数据文件
    raw_data = urllib.request.urlopen(url)
    
    # 加载一个 CSV 文件作为 numpy matrix （数据模型）
    dataset = np.loadtxt(raw_data, delimiter=",")
    
    # 从目标数据集中分割数据
    X = dataset[:, 0:7]
    y = dataset[:, 8]
    
    # 为alpha参数准备一个均匀分布
    param_grid = {
       'alpha': sp_rand()}
    
    # 创建并匹配一个岭回归模型，测试随机的alpha值
    model = Ridge()
    rsearch = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=100)
    rsearch.fit(X, y)
    print(rsearch)
    
    # 总结 随机参数搜索的结果
    print(rsearch.best_score_)
    print(rsearch.best_estimator_.alpha)

结果

RandomizedSearchCV(cv=None, error_score='raise',
              estimator=Ridge(alpha=1.0, copy_X=True, fit_intercept=True, max_iter=None,
       normalize=False, random_state=None, solver='auto', tol=0.001),
              fit_params=None, iid=True, n_iter=100, n_jobs=1,
              param_distributions={
       'alpha': <scipy.stats._distn_infrastructure.rv_frozen object at 0x1063ffc88>},
              pre_dispatch='2*n_jobs', random_state=None, refit=True,
              return_train_score=True, scoring=None, verbose=0)
    0.282118951896
    0.999859282378

# 小结 #

总体了解了使用scikit-learn库的大致流程

[Link 1]: http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html
[Link 2]: http://scikit-learn.org/stable/modules/naive_bayes.html
[Link 3]: http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html
[Link 4]: http://scikit-learn.org/stable/modules/tree.html
[Link 5]: http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html
[Link 6]: http://scikit-learn.org/stable/modules/generated/sklearn.grid_search.GridSearchCV.html
[Link 7]: http://scikit-learn.org/stable/modules/generated/sklearn.grid_search.RandomizedSearchCV.html