30分钟学会用scikit-learn的基本回归方法（线性、决策树、SVM、KNN）和集成方法（随机森林，Adaboost和GBRT）

淩亂°似流年 2022-09-28 13:22 154阅读 0赞

[原文地址][Link 1]

注：本教程是本人尝试使用scikit-learn的一些经验，scikit-learn真的超级容易上手，简单实用。30分钟学会用调用基本的回归方法和集成方法应该是够了。   
本文主要参考了scikit-learn的[官方网站][Link 2]   
前言：本教程主要使用了numpy的最最基本的功能，用于生成数据，matplotlib用于绘图，scikit-learn用于调用[机器学习][Link 3]方法。如果你不熟悉他们（我也不熟悉）,没关系，看看numpy和matplotlib最简单的教程就够了。我们这个教程的程序不超过50行

## 1. 数据准备 ##

为了实验用，我自己写了一个二元函数，y=0.5*np.sin(x1)+ 0.5*np.cos(x2)+0.1*x1+3。其中x1的取值范围是0~50，x2的取值范围是-10~10，x1和x2的训练集一共有500个，测试集有100个。其中，在训练集的上加了一个-0.5~0.5的噪声。生成函数的代码如下：

def f(x1, x2):
        y = 0.5 * np.sin(x1) + 0.5 * np.cos(x2)  + 0.1 * x1 + 3 
        return y
    
    def load_data():
        x1_train = np.linspace(0,50,500)
        x2_train = np.linspace(-10,10,500)
        data_train = np.array([[x1,x2,f(x1,x2) + (np.random.random(1)-0.5)] for x1,x2 in zip(x1_train, x2_train)])
        x1_test = np.linspace(0,50,100)+ 0.5 * np.random.random(100)
        x2_test = np.linspace(-10,10,100) + 0.02 * np.random.random(100)
        data_test = np.array([[x1,x2,f(x1,x2)] for x1,x2 in zip(x1_test, x2_test)])
        return data_train, data_test
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12

其中训练集（y上加有-0.5~0.5的随机噪声）和[测试][Link 4]集（没有噪声）的图像如下：   
![训练集和测试集][20160926115213602]

## 2. scikit-learn最简单的介绍。 ##

scikit-learn非常简单，只需实例化一个[算法][Link 5]对象，然后调用fit()函数就可以了，fit之后，就可以使用predict()函数来预测了，然后可以使用score(）函数来评估预测值和真实值的差异，函数返回一个得分。例如调用决策树的方法如下

In [6]: from sklearn.tree import DecisionTreeRegressor
    
    In [7]: clf = DecisionTreeRegressor()
    
    In [8]: clf.fit(x_train,y_train)
    Out[11]:
    DecisionTreeRegressor(criterion='mse', max_depth=None, max_features=None,
               max_leaf_nodes=None, min_samples_leaf=1, min_samples_split=2,
               min_weight_fraction_leaf=0.0, presort=False, random_state=None,
               splitter='best')
    In [15]: result = clf.predict(x_test)
    
    In [16]: clf.score(x_test,y_test)
    Out[16]: 0.96352052312508396
    
    In [17]: result
    Out[17]:
    array([ 2.44996735,  2.79065744,  3.21866981,  3.20188779,  3.04219101,
            2.60239551,  3.35783805,  2.40556647,  3.12082094,  2.79870458,
            2.79049667,  3.62826131,  3.66788213,  4.07241195,  4.27444808,
            4.75036169,  4.3854911 ,  4.52663074,  4.19299748,  4.42235821,
            4.48263415,  4.16192621,  4.40477767,  3.76067775,  4.35353213,
            4.6554961 ,  4.99228199,  4.29504731,  4.55211437,  5.08229167,
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23

接下来，我们可以根据预测值和真值来画出一个图像。画图的代码如下：

plt.figure()
        plt.plot(np.arange(len(result)), y_test,'go-',label='true value')
        plt.plot(np.arange(len(result)),result,'ro-',label='predict value')
        plt.title('score: %f'%score)
        plt.legend()
        plt.show()
     
      
       1
       2
       3
       4
       5
       6
      
     
      
       1
       2
       3
       4
       5
       6

然后图像会显示如下：   
![决策树][20160926033445708]

## 3. 开始试验各种不同的回归方法 ##

为了加快测试, 这里写了一个函数,函数接收不同的回归类的对象,然后它就会画出图像,并且给出得分.   
函数基本如下:

def try_different_method(clf):
        clf.fit(x_train,y_train)
        score = clf.score(x_test, y_test)
        result = clf.predict(x_test)
        plt.figure()
        plt.plot(np.arange(len(result)), y_test,'go-',label='true value')
        plt.plot(np.arange(len(result)),result,'ro-',label='predict value')
        plt.title('score: %f'%score)
        plt.legend()
        plt.show()
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

train, test = load_data()
    x_train, y_train = train[:,:2], train[:,2] #数据前两列是x1,x2 第三列是y,这里的y有随机噪声
    x_test ,y_test = test[:,:2], test[:,2] # 同上,不过这里的y没有噪声
     
      
       1
       2
       3
      
     
      
       1
       2
       3

### 3.1 常规回归方法 ###

常规的回归方法有线性回归,决策树回归,SVM和k近邻(KNN)

#### 3.1.1 线性回归 ####

In [4]: from sklearn import linear_model
    
    In [5]: linear_reg = linear_model.LinearRegression()
    
    In [6]: try_different_method(linar_reg)
     
      
       1
       2
       3
       4
       5
      
     
      
       1
       2
       3
       4
       5

![线性回归][20160926112356854]

#### 3.1.2数回归 ####

from sklearn import tree
    tree_reg = tree.DecisionTreeRegressor()
    try_different_method(tree_reg)
    
     
      
       1
       2
       3
       4
      
     
      
       1
       2
       3
       4

然后决策树回归的图像就会显示出来:   
![树回归][20160926112012149]

#### 3.1.3 SVM回归 ####

In [7]: from sklearn import svm
    
    In [8]: svr = svm.SVR()
    
    In [9]: try_different_method(svr)
    
     
      
       1
       2
       3
       4
       5
       6
      
     
      
       1
       2
       3
       4
       5
       6

结果图像如下:   
![SVM][]

#### 3.1.4 KNN ####

In [11]: from sklearn import neighbors
    
    In [12]: knn = neighbors.KNeighborsRegressor()
    
    In [13]: try_different_method(knn)
    
     
      
       1
       2
       3
       4
       5
       6
      
     
      
       1
       2
       3
       4
       5
       6

竟然KNN这个计算效能最差的算法效果最好   
![knn][]

### 3.2 集成方法(随机森林,adaboost, GBRT) ###

#### 3.2.1随机森林 ####

In [14]: from sklearn import ensemble
    
    In [16]: rf =ensemble.RandomForestRegressor(n_estimators=20)#这里使用20个决策树
    
    In [17]: try_different_method(rf)
    
     
      
       1
       2
       3
       4
       5
       6
      
     
      
       1
       2
       3
       4
       5
       6

![随机森林][20160926113311031]

#### 3.2.2 Adaboost ####

In [18]: ada = ensemble.AdaBoostRegressor(n_estimators=50)
    
    In [19]: try_different_method(ada)
    
     
      
       1
       2
       3
       4
      
     
      
       1
       2
       3
       4

图像如下:   
![这里写图片描述][20160926113706738]

### 3.2.3 GBRT ###

In [20]: gbrt = ensemble.GradientBoostingRegressor(n_estimators=100)
    
    In [21]: try_different_method(gbrt)
    
     
      
       1
       2
       3
       4
      
     
      
       1
       2
       3
       4

图像如下   
![这里写图片描述][20160926113950851]

## 4. scikit-learn还有很多其他的方法,可以参考用户手册自行试验. ##

## 5.完整代码 ##

我这里在pycharm写的代码,但是在pycharm里面不显示图形,所以可以把代码复制到ipython中,使用`%paste`方法复制代码片.   
然后参照上面的各个方法导入算法,使用`try_different_mothod()`函数画图.   
完整代码如下:

import numpy as np
    import matplotlib.pyplot as plt
    
    def f(x1, x2):
        y = 0.5 * np.sin(x1) + 0.5 * np.cos(x2) + 3 + 0.1 * x1 
        return y
    
    def load_data():
        x1_train = np.linspace(0,50,500)
        x2_train = np.linspace(-10,10,500)
        data_train = np.array([[x1,x2,f(x1,x2) + (np.random.random(1)-0.5)] for x1,x2 in zip(x1_train, x2_train)])
        x1_test = np.linspace(0,50,100)+ 0.5 * np.random.random(100)
        x2_test = np.linspace(-10,10,100) + 0.02 * np.random.random(100)
        data_test = np.array([[x1,x2,f(x1,x2)] for x1,x2 in zip(x1_test, x2_test)])
        return data_train, data_test
    
    train, test = load_data()
    x_train, y_train = train[:,:2], train[:,2] #数据前两列是x1,x2 第三列是y,这里的y有随机噪声
    x_test ,y_test = test[:,:2], test[:,2] # 同上,不过这里的y没有噪声
    
    def try_different_method(clf):
        clf.fit(x_train,y_train)
        score = clf.score(x_test, y_test)
        result = clf.predict(x_test)
        plt.figure()
        plt.plot(np.arange(len(result)), y_test,'go-',label='true value')
        plt.plot(np.arange(len(result)),result,'ro-',label='predict value')
        plt.title('score: %f'%score)
        plt.legend()
        plt.show()

[Link 1]: http://blog.csdn.net/u010900574/article/details/52666291
[Link 2]: http://scikit-learn.org/stable/documentation.html
[Link 3]: http://lib.csdn.net/base/machinelearning
[Link 4]: http://lib.csdn.net/base/softwaretest
[20160926115213602]: /images/20220708/2405154f22314e33a51abf844eeb212a.png
[Link 5]: http://lib.csdn.net/base/datastructure
[20160926033445708]: /images/20220708/afc780e951694155ae6a2c7729b1759c.png
[20160926112356854]: /images/20220708/124710d3be114924a19f47e5fbb5359e.png
[20160926112012149]: /images/20220708/9a65d8f293134a69b367654e098d7a7a.png
[SVM]: /images/20220708/f0a42181109b47979a4a81b83e918b48.png
[knn]: /images/20220708/f21c0892b35e4969b0867021943597a6.png
[20160926113311031]: /images/20220708/bf136a4f3169493d87854eba29027f7a.png
[20160926113706738]: /images/20220708/bdb191189c074e60a0a9c92426852818.png
[20160926113950851]: /images/20220708/b289f0e8a4fd4d88bd07d9371dac8d7d.png