當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

机器学习实战 | SKLearn最全应用指南

發(fā)布時間：2023/12/9 编程问答 31 豆豆

生活随笔收集整理的這篇文章主要介紹了机器学习实战 | SKLearn最全应用指南小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

Python微信訂餐小程序課程視頻

https://edu.csdn.net/course/detail/36074

Python實戰(zhàn)量化交易理財系統(tǒng)

https://edu.csdn.net/course/detail/35475

作者：韓信子@ShowMeAI
教程地址：http://www.showmeai.tech/tutorials/41
本文地址：http://www.showmeai.tech/article-detail/203
聲明：版權所有，轉載請聯(lián)系平臺與作者并注明出處
收藏ShowMeAI查看更多精彩內容

引言

我們在上一篇SKLearn入門與簡單應用案例里給大家講到了SKLearn工具的基本板塊與使用方法，在本篇內容中，我們展開講解SKLearn的進階與核心內容。SKLearn中有六大任務模塊，如下圖所示：分別是分類、回歸、聚類、降維、模型選擇和預處理。

SKLearn官網：https://scikit-learn.org/stable/
SKLearn的快速使用方法也推薦大家查看ShowMeAI的文章和速查手冊 AI建模工具速查|Scikit-learn使用指南

在SKLearn中，因為做了上層的封裝，分類模型、回歸模型、聚類與降維模型、預處理器等等都叫做估計器(estimator)，就像在Python里「萬物皆對象」，在SKLearn里「萬物皆估計器」。

在本篇內容中，我們將給大家進一步深入講解scikit-learn工具庫的使用方法，力求完整覆蓋sklearn工具庫應用的方方面面。本文的內容板塊包括：

① 機器學習基礎知識：機器學習定義與四要素：數(shù)據(jù)、任務、性能度量和模型。機器學習概念，以便和SKLearn對應匹配上。
② SKLearn講解：API設計原理，sklearn幾大特點：一致性、可檢驗、標準類、可組合和默認值，以及SKLearn自帶數(shù)據(jù)以及儲存格式。
③ SKLearn三大核心API講解：包括估計器、預測器和轉換器。這個板塊很重要，大家實際應用時主要是借助于核心API落地。
④ SKLearn高級API講解：包括簡化代碼量的流水線(Pipeline估計器)，集成模型(Ensemble估計器)、有多類別-多標簽-多輸出分類模型(Multiclass 和 Multioutput 估計器)和模型選擇工具(Model Selection估計器)。

1.機器學習簡介

關于本節(jié)內容，強烈推薦大家閱讀ShowMeAI文章 圖解機器學習 | 機器學習基礎知識 和 圖解機器學習 | 模型評估方法與準則 ，ShowMeAI對相關知識內容展開做了詳細講解。

1.1 定義和構成元素

何為機器學習？大師湯姆米切爾（Tom 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，翻譯成中文就是機器(計算機程序)和學習，整體翻譯下來就是說：如果計算機程序在T任務上的性能(由P衡量)隨著經驗E而提高，則稱計算機程序從經驗E中學習某類任務T。

由上述機器學習的定義可知機器學習包含四個元素：

數(shù)據(jù)(Data)
任務(Task)
性能度量(Quality Metric)
算法(Algorithm)

1.2 數(shù)據(jù)

數(shù)據(jù)(data)是信息的載體。數(shù)據(jù)可以有以下劃分方式：

從「數(shù)據(jù)具體類型」維度劃分：結構化數(shù)據(jù)和非結構化數(shù)據(jù)。
- 結構化數(shù)據(jù)(structured data)是由二維表結構來邏輯表達和實現(xiàn)的數(shù)據(jù)。
- 非結構化數(shù)據(jù)是沒有預定義的數(shù)據(jù)，不便用數(shù)據(jù)庫二維表來表現(xiàn)的數(shù)據(jù)。非結構化數(shù)據(jù)包括圖片，文字，語音和視頻等。
從「數(shù)據(jù)表達形式」維度劃分：原始數(shù)據(jù)和加工數(shù)據(jù)。
從「數(shù)據(jù)統(tǒng)計性質」維度劃分：樣本內數(shù)據(jù)和樣本外數(shù)據(jù)。

對于非結構數(shù)據(jù)，通常神經網絡有更好的效果，可以參考ShowMeAI的文章Python機器學習算法實踐中的圖像建模例子。

機器學習模型很多時候使用的是結構化數(shù)據(jù)，即二維的數(shù)據(jù)表。我們這里以iris花瓣數(shù)據(jù)集舉例，如下圖。

下面術語大家在深入了解機器學習前一定要弄清楚：

每行的記錄(這是一朵鳶尾花的數(shù)據(jù)統(tǒng)計)，稱為一個「樣本(sample)」。
反映樣本在某方面的性質，例如萼片長度(Sepal Length)、花瓣長度(Petal Length)，稱為「特征(feature)」。
特征上的取值，例如「樣本1」對應的5.1、3.5稱為「特征值(feature value)」。
關于樣本結果的信息，例如Setosa、Versicolor，稱為「類別標簽(class label)」。
包含標簽信息的示例，則稱為「樣例(instance)」，即樣例=(特征,標簽)。
從數(shù)據(jù)中學得模型的過程稱為「學習(learning)」或「訓練(training)」。
在訓練數(shù)據(jù)中，每個樣例稱為「訓練樣例(training instance)」，整個集合稱為「訓練集(training set)」。

1.3 任務

根據(jù)學習的任務模式(訓練數(shù)據(jù)是否有標簽)，機器學習可分為幾大類：

監(jiān)督學習(有標簽)
無監(jiān)督學習(無標簽)
半監(jiān)督學習(有部分標簽)
強化學習(有延遲的標簽)

下圖畫出機器學習各類之間的關系。

1.4 性能度量

回歸和分類任務中最常見的誤差函數(shù)以及一些有用的性能度量如下，詳細內容可以參考ShowMeAI文章 機器學習評估與度量準則。

2. SKLearn數(shù)據(jù)

SKLearn作為通用機器學習建模的工具包，包含六個任務模塊和一個數(shù)據(jù)導入模塊：

監(jiān)督學習：分類任務
監(jiān)督學習：回歸任務
無監(jiān)督學習：聚類任務
無監(jiān)督學習：降維任務
模型選擇任務
數(shù)據(jù)預處理任務
數(shù)據(jù)導入模塊

首先看看SKLearn默認數(shù)據(jù)格式和自帶數(shù)據(jù)集。

2.1 SKLearn默認數(shù)據(jù)格式

Sklean里模型能直接使用的數(shù)據(jù)有兩種形式：

Numpy二維數(shù)組(ndarray)的稠密數(shù)據(jù)(dense data)，通常都是這種格式。
SciPy矩陣(scipy.sparse.matrix)的稀疏數(shù)據(jù)(sparse data)，比如文本分析每個單詞(字典有100000個詞)做獨熱編碼得到矩陣有很多0，這時用ndarray就不合適了，太耗內存。

2.2 自帶數(shù)據(jù)集

SKLearn里面有很多自帶數(shù)據(jù)集供用戶使用。

比如在之前文章Python機器學習算法實踐中用到的鳶尾花數(shù)據(jù)集，包含四個特征(萼片長/寬和花瓣長/寬)和三個類別。

我們可以直接從SKLearn里面的datasets模塊中引入，代碼如下(代碼可以在線上Jupyter環(huán)境中運行)：

輸出如下：

| | dict\_keys(['data', 'target', 'target\_names', 'DESCR', 'feature\_names', 'filename']) |

讀取數(shù)據(jù)集的信息：

輸出如下：

| | (150, 4) | | | ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'] | | | (150,) | | | ['setosa' 'versicolor' 'virginica'] | | | 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]]) |

構建Dataframe格式的數(shù)據(jù)集：

輸出如下：

sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)species

0	5.1	3.5	1.4	0.2	setosa
1	4.9	3.0	1.4	0.2	setosa
2	4.7	3.2	1.3	0.2	setosa
147	6.5	3.0	5.2	2.0	virginica
148	6.2	3.4	5.4	2.3	virginica
149	5.9	3.0	5.1	1.8	virginica

我們使用seaborn來做一些數(shù)據(jù)分析，查看一下數(shù)據(jù)的分布特性。這里使用到的是成對維度的關聯(lián)分析，關于seaborn的使用方法可以參閱ShowMeAI的文章 seaborn工具與數(shù)據(jù)可視化教程。

| | # 使用Seaborn的pairplot查看兩兩特征之間的關系 | | | sns.pairplot( iris\_data, hue='species', palette='husl' ) |

2.3 數(shù)據(jù)集引入方式

前面提到的是鳶尾花iris數(shù)據(jù)集，我們通過load_iris加載進來，實際上SKLearn有三種引入數(shù)據(jù)形式。

打包好的數(shù)據(jù)：對于小數(shù)據(jù)集，用sklearn.datasets.load_*
分流下載數(shù)據(jù)：對于大數(shù)據(jù)集，用sklearn.datasets.fetch_*
隨機創(chuàng)建數(shù)據(jù)：為了快速展示，用sklearn.datasets.make_*

上面這個星號*指代具體文件名，如果大家在Jupyter這種IDE環(huán)境中，可以通過tab制表符自動補全和選擇。

datasets.load_
datasets.fetch_
datasets.make_

比如我們調用load_iris

輸出如下：

| | <function sklearn.datasets.base.load\_iris(return\_X\_y=False)> |

我們調用load_digits加載手寫數(shù)字圖像數(shù)據(jù)集

輸出：

| | dict\_keys(['data', 'target', 'target\_names', 'images', 'DESCR']) |

我們再來看看通過fetch拉取數(shù)據(jù)的示例：

輸出：

| | dict\_keys(['data', 'target', 'feature\_names', 'DESCR']) |

3.SKLearn核心API

我們前面提到SKLearn里萬物皆估計器。估計器是個非常抽象的叫法，不嚴謹?shù)囊粋€理解，我們可以視其為一個模型(用來回歸、分類、聚類、降維)，或一套流程(預處理、網格搜索交叉驗證)。

本節(jié)三大API其實都是估計器：

估計器(estimator)通常是用于擬合功能的估計器。
預測器(predictor)是具有預測功能的估計器。
轉換器(transformer)是具有轉換功能的估計器。

3.1 估計器

任何可以基于數(shù)據(jù)集對一些參數(shù)進行估計的對象都被稱為估計器，它有兩個核心點：

① 需要輸入數(shù)據(jù)。
② 可以估計參數(shù)。

估計器首先被創(chuàng)建，然后被擬合。

創(chuàng)建估計器：需要設置一組超參數(shù)，比如
- 線性回歸里超參數(shù)normalize=True
- K均值里超參數(shù)n_clusters=5
擬合估計器：需要訓練集
- 在監(jiān)督學習中的代碼范式為model.fit(X_train, y_train)
- 在無監(jiān)督學習中的代碼范式為model.fit(X_train)

擬合之后可以訪問model里學到的參數(shù)，比如線性回歸里的特征系數(shù)coef，或K均值里聚類標簽labels，如下(具體的可以在SKLearn文檔的每個模型頁查到)。

model.coef_
model.labels_

下面看看監(jiān)督學習的「線性回歸」和無監(jiān)督學習的「K均值聚類」的具體例子。

(1) 線性回歸

首先從SKLearn工具庫的linear_model中引入LinearRegression；創(chuàng)建模型對象命名為model，設置超參數(shù)normalize為True（在每個特征值上做標準化，這樣能保證擬合的穩(wěn)定性，加速模型擬合速度）。

輸出：

| | LinearRegression(copy\_X=True, fit\_intercept=True, n\_jobs=None, normalize=True) |

創(chuàng)建完后的估計器會顯示所有的超參數(shù)（比如剛才設置的normalize=True），未設置的超參數(shù)都使用默認值。

自己創(chuàng)建一個簡單數(shù)據(jù)集（一條直線上的數(shù)據(jù)點），簡單講解一下估計器里面的特征。

在我們生成的數(shù)據(jù)里，X是一維，我們做一點小小的調整，用np.newaxis加一個維度，把[1,2,3]轉成[[1],[2],[3]]，這樣的數(shù)據(jù)形態(tài)可以符合sklearn的要求。接著把X和y送入fit()函數(shù)來擬合線性模型的參數(shù)。

輸出為：

| | LinearRegression(copy\_X=True, fit\_intercept=True, n\_jobs=None, normalize=True) |

擬合完后的估計器和創(chuàng)建完似乎沒有差別，但我們已經可以用model.param_訪問到擬合完數(shù)據(jù)的參數(shù)了，如下代碼。

(2) K均值

我們來看看聚類的例子，先從SKLearn的cluster中導入KMeans，初始化模型對象命名為model，設置超參數(shù)n_cluster為3(為了展示方便而我們知道用的iris數(shù)據(jù)集有3類，實際上可以設置不同數(shù)量的n_cluster)。

雖然iris數(shù)據(jù)里包含標簽y，但在無監(jiān)督的聚類中我們不會使用到這個信息。

輸出為：

| | KMeans(algorithm='auto', copy\_x=True, init='k-means++', max\_iter=300, | | | n\_clusters=3, n\_init=10, n\_jobs=None, precompute\_distances='auto', | | | random\_state=None, tol=0.0001, verbose=0) |

iris數(shù)據(jù)集包含四維特征(萼片長、萼片寬、花瓣長、花瓣寬)，在下面的例子中我們希望可視化，這里我們簡單選取兩個特征(萼片長、萼片寬)來做聚類并且可視化結果。

注意下面代碼X = iris.data[:,0:2]其實就是提取特征維度。

輸出為：

擬合完后的估計器和創(chuàng)建完似乎沒有差別，但我們已經可以用model.param_訪問到擬合完數(shù)據(jù)的參數(shù)了，如下代碼。

| | print( model.cluster\_centers\_, '\n') | | | print( model.labels\_, '\n' ) | | | print( model.inertia\_, '\n') | | | print(iris.target) | | | [[5.77358491 2.69245283] | | | [6.81276596 3.07446809] | | | [5.006 3.428 ]] | | | | | | [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 1 1 1 0 1 0 1 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 | | | 1 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 1 1 1 1 | | | 1 1 0 0 1 1 1 1 0 1 0 1 0 1 1 0 0 1 1 1 1 1 0 0 1 1 1 0 1 1 1 0 1 1 1 0 1 | | | 1 0] | | | | | | 37.05070212765958 | | | | | | [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] |

這里解釋一下KMeans模型這幾個參數(shù)：

model.clustercenters：簇中心。三個簇意味著有三個坐標。
model.labels_：聚類后的標簽。
model.inertia_：所有點到對應的簇中心的距離平方和(越小越好)

小結

雖然上面以有監(jiān)督學習的Linear Regression和無監(jiān)督學習的KMeans舉例，但實際上你可以將它們替換成其他別的模型，比如監(jiān)督學習的Logistic Regression和無監(jiān)督學習的DBSCAN。它們都是「估計器」，因此都有fit()方法。

使用它們的通用偽代碼如下：

3.2 預測器

預測器是估計器做的一個延展，具備對數(shù)據(jù)進行預測的功能。

預測器最常見的是predict()函數(shù)：

model.predict(X_test)：評估模型在新數(shù)據(jù)上的表現(xiàn)。
model.predict(X_train)：確認模型在老數(shù)據(jù)上的表現(xiàn)。

為了進行新數(shù)據(jù)評估，我們先將數(shù)據(jù)分成80:20的訓練集(X_train, y_train)和測試集(X_test, y_test)，再用從訓練集上擬合fit()的模型在測試集上預測predict()。

predict & predict_proba

對于分類問題，我們不僅想知道預測的類別是什么，有時我們還希望獲取預測概率等信息。前者用 predict()，后者用predict_proba()。

score & decision_function

預測器里還有額外的兩個函數(shù)可以使用。在分類問題中：

score()返回的是分類準確率。
decision_function()返回的是每個樣例在每個類下的分數(shù)值。

小結

估計器都有fit()方法，預測器都有predict()和score()方法，言外之意不是每個預測器都有predict_proba()和decision_function()方法，這個在用的時候查查官方文檔就清楚了(比如RandomForestClassifier就沒有decision_function()方法)。

使用它們的通用偽代碼如下：

3.3 轉換器

轉換器是一種估計器，也有擬合功能，對比預測器做完擬合來預測，轉換器做完擬合來轉換。核心點如下：

估計器里fit + predict
轉換器里fit + transform

本節(jié)介紹兩大類轉換器：

將類別型變量(categorical)編碼成數(shù)值型變量(numerical)
規(guī)范化(normalize)或標準化(standardize)數(shù)值型變量

(1) 類別型變量編碼

① LabelEncoder&OrdinalEncoder

LabelEncoder和OrdinalEncoder都可以將字符轉成數(shù)字，但是：

LabelEncoder的輸入是一維，比如1d ndarray
OrdinalEncoder的輸入是二維，比如 DataFrame

除了LabelEncoder，OrdinalEncoder也可以完成編碼。如下代碼所示：

上面這種編碼的問題是，在編碼過后會帶來不同類別的大小關系，比如這里3種顏色其實本質上是平等的，沒有大小關系。

我們的另外一種類別型數(shù)據(jù)編碼方式，獨熱向量編碼(one-hot encoding)可以解決這個問題，大家繼續(xù)往下看。

② OneHotEncoder

獨熱向量編碼其實就是把一個整數(shù)用向量的形式表現(xiàn)。上圖右側就是對顏色做獨熱向量編碼。轉換器OneHotEncoder可以接受兩種類型的輸入：

① 用LabelEncoder編碼好的一維數(shù)組
② DataFrame

一、用LabelEncoder編碼好的一維數(shù)組(元素為整數(shù))，重塑(用reshape(-1,1))成二維數(shù)組作為OneHotEncoder輸入。

輸出為：

| | <4x3 sparse matrix of type 'numpy.float64'>' | | | with 4 stored elements in Compressed Sparse Row format> |

上面結果解釋如下：

第3行打印出編碼結果[2 0 1 2]。
第5行將其轉成獨熱形式，輸出是一個「稀疏矩陣」形式，因為實操中通常類別很多，因此就一步到位用稀疏矩陣來節(jié)省內存。

想看該矩陣里具體內容，用toarray()函數(shù)。

| | OHE\_y.toarray() |

輸出為：

| | array([[0., 0., 1.], | | | [1., 0., 0.], | | | [0., 1., 0.], | | | [0., 0., 1.]]) |

二、用DataFrame作為OneHotEncoder輸入。

輸出為：

| | array([[0., 0., 1.], | | | [1., 0., 0.], | | | [0., 1., 0.], | | | [0., 0., 1.]]) |

(2) 特征縮放

數(shù)據(jù)要做的最重要的轉換之一是特征縮放(feature scaling)。類似邏輯回歸，神經網絡這種計算型模型，對于不同特征的幅度大小差異是敏感的。

具體來說，對于某個特征，我們有兩種變換方法：

標準化(standardization)：每個維度的特征減去該特征均值，除以該維度的標準差。
規(guī)范化(normalization)：每個維度的特征減去該特征最小值，除以該特征的最大值與最小值之差。

① MinMaxScaler

如上圖所示，MinMaxScaler會根據(jù)特征的最大最小取值，對數(shù)據(jù)進行幅度縮放。

輸出為：

| | array([[0. ], | | | [0.005], | | | [0.01 ], | | | [0.015], | | | [0.02 ], | | | [1. ]]) |

② StandardScaler

StandardScaler做的事情是調整數(shù)據(jù)分布，盡量接近正態(tài)分布。

輸出為：

| | array([[-0.47424487], | | | [-0.46069502], | | | [-0.44714517], | | | [-0.43359531], | | | [-0.42004546], | | | [ 2.23572584]]) |

注意：fit()函數(shù)只能作用在訓練集上，如果希望對測試集變換，只要用訓練集上fit好的轉換器去transform即可。不能在測試集上fit再transform，否則訓練集和測試集的變換規(guī)則不一致，模型學習到的信息就無效了。

4.高級API

我們在這節(jié)中給大家介紹SKLearn的「高級API」，即五大元估計器（集成功能的Ensemble，多分類和多標簽的Multiclass，多輸出的Multioutput，選擇模型的Model Selection，流水線的Pipeline）。

ensemble.BaggingClassifier
ensemble.VotingClassifier
multiclass.OneVsOneClassifier
multiclass.OneVsRestClassifier
multioutput.MultiOutputClassifier
model_selection.GridSearchCV
model_selection.RandomizedSearchCV
pipeline.Pipeline

4.1 Ensemble 估計器

如上圖：分類器統(tǒng)計每個子分類器的預測類別數(shù)，再用「多數(shù)投票」原則得到最終預測?；貧w器計算每個子回歸器的預測平均值。

最常用的Ensemble估計器排列如下：

AdaBoostClassifier：逐步提升分類器
AdaBoostRegressor：逐步提升回歸器
BaggingClassifier：Bagging分類器
BaggingRegressor：Bagging回歸器
GradientBoostingClassifier：梯度提升分類器
GradientBoostingRegressor：梯度提升回歸器
RandomForestClassifier：隨機森林分類器
RandomForestRegressor：隨機森林回歸器
VotingClassifier：投票分類器
VotingRegressor：投票回歸器

我們用鳶尾花數(shù)據(jù)iris，拿以下estimator來舉例：

含同質估計器RandomForestClassifier
含異質估計器VotingClassifier

首先將數(shù)據(jù)分成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) |

(1) RandomForestClassifier

隨機森林RandomForestClassifier通過控制n_estimators超參數(shù)來決定基估計器的個數(shù)，在這里是4棵決策樹(森林由樹組成)；此外每棵樹的最大樹深為5(max_depth=5)。

| | from sklearn.ensemble import RandomForestClassifier | | | RF = RandomForestClassifier( n\_estimators=4, max\_depth=5 ) | | | RF.fit( X\_train, y\_train ) |

輸出為：

| | RandomForestClassifier(bootstrap=True, class\_weight=None, criterion='gini', | | | max\_depth=5, max\_features='auto', 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, n\_estimators=4, | | | n\_jobs=None, oob\_score=False, random\_state=None, | | | verbose=0, warm\_start=False) |

元估計器和預估器一樣也有fit()。下面看看隨機森林里包含的估計器個數(shù)和其本身。

輸出為：

| | 4 | | | | | | [DecisionTreeClassifier(class\_weight=None, criterion='gini', max\_depth=5, | | | max\_features='auto', 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=705712365, splitter='best'), | | | DecisionTreeClassifier(class\_weight=None, criterion='gini', max\_depth=5, | | | max\_features='auto', 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=1026568399, splitter='best'), | | | DecisionTreeClassifier(class\_weight=None, criterion='gini', max\_depth=5, | | | max\_features='auto', 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=1987322366, splitter='best'), | | | DecisionTreeClassifier(class\_weight=None, criterion='gini', max\_depth=5, | | | max\_features='auto', 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=1210538094, splitter='best')] |

擬合RF完再做預測，用metrics里面的accuracy_score來計算準確率。訓練準確率98.33%，測試準確率100%。

(2) VotingClassifier

和隨機森林由同質分類器「決策樹」不同，投票分類器由若干個異質分類器組成。下面我們用VotingClassifier建立個含有邏輯回歸(Logistic regression)、隨機森林(RandomForest)和高斯樸素貝葉斯(GNB)三個分類器的集成模型。

RandomForestClassifier的基分類器只能是決策樹，因此只用通過控制n_estimators超參數(shù)來決定樹的個數(shù)，而VotingClassifier的基分類器要輸入每個異質分類器。

| | from sklearn.linear\_model import LogisticRegression | | | from sklearn.naive\_bayes import GaussianNB | | | from sklearn.ensemble import RandomForestClassifier | | | from sklearn.ensemble import VotingClassifier | | | | | | LR = LogisticRegression( solver='lbfgs', multi\_class='multinomial' ) | | | RF = RandomForestClassifier( n\_estimators=5 ) | | | GNB = GaussianNB() | | | | | | Ensemble = VotingClassifier( estimators=[('lr', LR), (‘rf', RF), ('gnb', GNB)], voting='hard' ) | | | | | | Ensemble. fit( X\_train, y\_train ) | | | |

結果如下：

| | VotingClassifier(estimators=[('lr', LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True,intercept\_scaling=1, max\_iter=100, multi\_class='multinomial',n\_jobs=None, penalty='12', random\_state=None, solver='lbfgs',tol=0.0001, verbose=6, warm\_start=False)), ('rf', ...e, verbose=0,warm\_start=False)), ('gnb', GaussianNB(priors=None, var\_smoothing=1e-09))],flatten\_transform=None, n\_jobs=None, voting='hard', weights=None) |

看看Ensemble集成模型里包含的估計器個數(shù)和其本身。

結果如下：

| | 3 | | | | | | [LogisticRegression(C=1.0, class\_weight-None, dual-False, fit\_intercept=True,intercept\_scaling=1, max\_iter=100, multi\_class='multinomial',n\_jobs-None, penalty="12", random\_state-None, solver='1bfgs',t01=0.0001, verbose=0, warm\_start=False), | | | | | | RandomForestClassifier(bootstrap=True, class\_weight=None, criterion='gini',max\_depth=None, max\_features='auto', max\_leaf\_nodes=None,min\_impurity\_decrease-0.0, min\_impurity\_splitmin\_samples\_leaf=1, min\_samples\_split=2,min\_weight\_fraction\_leaf=0.0, n\_estimator:oob\_score=False, random\_state-None, verbose= | | | warm\_start=False), | | | | | | GaussianNB(priors-None, var\_smoothing=1e-9)] |

對比元估計器和它三個組成元素的表現(xiàn)，下過表現(xiàn)如下：

| | # 擬合 | | | LR.fit( X\_train, y\_train ) | | | RF.fit( X\_train, y\_train ) | | | GNB.fit( X\_train, y\_train ) | | | # 評估效果 | | | print ( "LR - Accuracy (Train): %.4g" % metrics.accuracy\_score(y\_train, LR.predict(X\_train)) ) | | | print ( "RF - Accuracy (Train): %.4g" % metrics.accuracy\_score(y\_train, RF.predict(X\_train)) ) | | | print ( "GNB - Accuracy (Train): %.4g" % metrics.accuracy\_score(y\_train, GNB.predict(X\_train)) ) | | | print ( "Ensemble - Accuracy (Train): %.4g" % metrics.accuracy\_score(y\_train, Ensemble.predict(X\_train)) ) | | | print ( "LR - Accuracy (Test): %.4g" % metrics.accuracy\_score(y\_test, LR.predict(X\_test)) ) | | | | | | print ( "RF - Accuracy (Test): %.4g" % metrics.accuracy\_score(y\_test, RF.predict(x\_test)) ) | | | print ( "GNB - Accuracy (Test): %.4g" % metrics.accuracy\_score(y\_test, RF.predict(X\_test)) ) | | | print ( "Ensemble - Accuracy (Test): %.4g" % metrics.accuracy\_score(y test, Ensemble.predict(X\_test)) ) | | | # 運行結果 | | | 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) 的分類問題。下面我們會使用數(shù)字數(shù)據(jù)集digits作為示例數(shù)據(jù)來講解。我們先將數(shù)據(jù)分成 80:20 的訓練集和測試集。

輸出如下：

下面我們切分數(shù)據(jù)集：

| | # 數(shù)據(jù)集切分 | | | 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 ) |

輸出如下

訓練集和測試集分別有1437和360張圖像。每張照片是包含8×8的像素，我們用flatten操作把2維的8×8展平為1維的64。

看看訓練集中前100張圖片和對應的標簽（如下圖）。像素很低，但基本上還是能看清。

(1) 多類別分類

手寫數(shù)字有0-9十類，但手頭上只有二分類估計器（比如像支撐向量機）怎么用呢？我們可以采取以下策略處理：

一對一(One vs One，OvO)：一個分類器用來處理數(shù)字0和數(shù)字1，一個用來處理數(shù)字0和數(shù)字2，一個用來處理數(shù)字1和2，以此類推。N個類需要N(N-1)/2個分類器。
一對其他(One vs All，OvA)：訓練10個二分類器，每一個對應一個數(shù)字，第一個分類「1」和「非1」，第二個分類「2」和「非2」，以此類推。N個類需要N個分類器。

① OneVsOneClassifier

考慮一個具體天氣多分類問題，天氣可以是晴天、陰天和雨天，在OvO中，三個分類器為f1、f2和f3。

f1負責區(qū)分橙色和綠色樣本
f2負責區(qū)分橙色和紫色樣本
f3負責區(qū)分綠色和紫色樣本

在下圖的例子中，f1和f2都預測為橙色，f3預測為紫色。根據(jù)多數(shù)原則得到的結合預測為橙色，如下圖所示。

回到數(shù)字分類問題上，代碼及結果如下：

| | from sklearn.multiclass import OneVsOneClassifier | | | from sklearn.linear\_model import LogisticRegression | | | ovo\_lr = OneVsOneClassifier( LogisticRegression(solver='lbfgs', max\_iter=200) ) | | | ovo\_lr.fit( X\_train, y\_train ) | | | OnevsOneClassifier(estimator=LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True,intercept\_scaling=1, max\_iter=200, multi\_class=‘warn’,n\_jobs=None, penalty='12', random\_state=None, solver='lbfgs’,tol=0.0001, verbose=6, warm\_start=False),n\_jobs=None) | | | |

10*9/2=45，10類總共45個OvO分類器。

結果如下：

| | 45 | | | | | | (LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True,intercept\_scaling=1, max\_iter=200, multi\_class='warn',n\_jobs=None, penalty='12', random\_state=None, solver='lbfgs',tol=60.0001, verbose=0, warm\_start=False), | | | | | | LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, intercept\_scaling=1, max\_iter=200, multi\_class='warn', n\_jobs=None, penalty='l2', random\_state=None, solver='lbfgs',tol=0.0001, verbose=0, warm\_start=False), | | | | | | LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, intercept\_scaling=1, max\_iter=200, multi\_class='warn', n\_jobs=None, penalty='12', random\_state=None, solver='lbfgs', tol=60.0001, verbose=0, warm\_start=False), | | | | | | LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, intercept\_scaling=1, max\_iter=200, multi\_class='warn', n\_jobs=None, penalty="12", random\_state=None, solver='lbfgs', tol=0.0001, verbose=0, warm\_start=False), | | | | | | LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, | | | ... |

訓練集分類全對，測試集準確率98%。

| | print ( “OvO LR - Accuracy (Train): %.4g" % metrics.accuracy\_score(y\_train, ovo\_Ir.predict(X\_train)) ) | | | print ( "OvO LR - Accuracy (Test): %.4g" % metrics.accuracy\_score(y\_test, ovo\_lr.predict(X\_test}) ) | | | | | | # 運行結果 | | | OvO LR - Accuracy (Train): 1 | | | OvO LR - Accuracy (Test): 0.9806 |

② OneVsRestClassifier

在OvA中，把數(shù)據(jù)分成“某個”和“其他”

圖一，某個=橙色，其他=綠色和紫色
圖二，某個=綠色，其他=橙色和紫色
圖三，某個=紫色，其他=橙色和綠色

三分類分解成三個二分類，對應的分類器為f1、f2和f3。

f1預測負類，即預測綠色和紫色
f2預測負類，即預測橙色和紫色
f3預測正類，即預測紫色

三個分類器都預測了紫色，根據(jù)多數(shù)原則得到的預測是紫色，即陰天。

回到數(shù)字分類問題上，代碼和結果如下：

| | from sklearn.multiclass import OneVsRestClassifier | | | ova\_lr = OneVsRestClassifier( LogisticRegression(solver='lbfgs', max\_iter=800) ) | | | ova\_lr.fit( X\_train, y\_train ) | | | OnevsRestClassifier(estimator=LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, intercept\_scaling=1, max\_iter=800, multi\_class=‘warn’, n\_jobs=None, penalty='12', random\_state=None, solver='lbfgs’, tol=0.0001, verbose=6, warm\_start=False), n\_jobs=None) | | | |

10類總共10個OvA分類器。

結果如下：

| | 10 | | | | | | [LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, intercept\_scaling=1, max\_iter=800, multi\_class='warn', n\_jobs=None, penalty='12', random\_state=None, solver='lbfgs',tol=0.0001, verbose=0, warm\_start=False), | | | | | | LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, intercept\_scaling=1, max\_iter=800, multi\_class='warn', n\_jobs=None, penalty='12', random\_state=None, solver='lbfgs', tol=0.0001, verbose=0, warm\_start=False), | | | | | | LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, | | | intercept\_scaling=1, max\_iter=800, multi\_class=‘warn', | | | n\_jobs=None, penalty='12', random\_state=None, solver="lbfgs', | | | tol=0.0001, verbose=0, warm\_start=False), | | | | | | LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, | | | intercept\_scaling=1, max\_iter=800, multi\_class='warn', n\_jobs=None, penalty='12', random\_state=None, solver='lbfgs', tol=0.0001, verbose=0, warm\_start=False), | | | | | | LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, | | | ... |

訓練集準確率幾乎100%，測試集準確率96%。代碼與結果如下：

| | print ( “OvA LR - Accuracy (Train): %.4g" % metrics.accuracy\_score(y\_train, ova\_Ir.predict(X\_train)) ) | | | print ( "OvA LR - Accuracy (Test): %.4g" % metrics.accuracy\_score(y\_test, ova\_lr.predict(X\_test}) ) | | | | | | OvA LR - Accuracy (Train): 6.9993 | | | OvA LR - Accuracy (Test}: 6.9639 |

(2) 多標簽分類

到目前為止，所有的樣例都總是被分配到僅一個類。有些情況下，你也許想讓分類器給一個樣例輸出多個類別。在無人駕駛的應用中，在下圖識別出有車和指示牌，沒有交通燈和人。

物體識別是一個復雜的深度學習問題，我們在這里暫且不深入探討。我們先看一個簡單點的例子，在手寫數(shù)字的例子上，我們特意為每個數(shù)字設計了兩個標簽：

標簽1：奇數(shù)、偶數(shù)
標簽2：小于等于4，大于4

我們構建多標簽y_train_multilabel，代碼如下（OneVsRestClassifier也可以用來做多標簽分類）：

看下圖訓練集第1和2個圖片是數(shù)字4和5，對應上面兩種標簽結果為：

[True True]：4是偶數(shù)，小于等于4
[False False]：5不是偶數(shù)，大于4

我們這次用y_train_multilabel來訓練模型。代碼如下

| | ova\_ml = OneVsRestClassifier( LogisticRegression(solver='lbfgs', max\_iter=800) ) | | | ova\_ml.fit( X\_train, y\_train\_multilabel ) | | | # 運行結果 | | | OnevsRestClassifier(estimator=LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, intercept\_scaling=1, max\_iter=800, multi\_class=‘warn’, n\_jobs=None, penalty='12', random\_state=None, solver='lbfgs', tol=0.0001, verbose=6, warm\_start=False), n\_jobs=None) |

有兩個估計器，每個對應一個標簽。

運行結果如下：

| | 2 | | | | | | [LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, intercept\_scaling=1, max\_iter=800, multi\_class=‘warn', n\_jobs=None, penalty='12°, random\_state=None, solver='lbfgs', tol=0.0001, verbose=0, warm\_start=False), | | | | | | LogisticRegression(C=1.0, class\_weight=None, dual=False, fit\_intercept=True, intercept\_scaling=1, max\_iter=800, multi\_class='warn', n\_jobs=None, penalty='l2', random\_state=None, solver='lbfgs', tol=0.0001, verbose=0, warm\_start=False) ] |

展示一下測試集上100張圖片。

| | fig, axes = plt.subplots( 10, 10, figsize=(8, 8) ) | | | fig.subplots\_adjust( hspace=0.1, wspace=0.1 ) | | | | | | for i, ax in enumerate( axes.flat ): | | | ax.imshow( X\_test[i,:].reshape(8,8), cmap='binary', interpolation='nearest') | | | ax.text( 6.05, 0.05, str(y\_test[i]), transform=ax.transAxes, color='blue') | | | ax.set\_xticks([]) | | | ax.set\_yticks([]) |

第一張圖片是數(shù)字2，它是偶數(shù)(標簽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個類別)。

Multioutput估計器有兩個：

MultiOutputRegressor：多輸出回歸
MultiOutputClassifier：多輸出分類

這里我們只關注多輸出分類。

(1) MultiOutputClassifier

首先引入MultiOutputClassifier和RandomForestClassifier。

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

在手寫數(shù)字的例子上，我們也為特意每個數(shù)字設計了多標簽而且每個標簽的類別都大于二。

標簽1：小于等于4，4和7之間，大于等于7(三類)
標簽2：數(shù)字本身(十類)

代碼如下：

| | y\_train\_1st = y\_train.copy() | | | y\_train\_1st[ y\_train<=4 ] = 0 | | | y\_train\_1st[ np.logical\_and{y\_train>4, y\_train<7) ] = 1 | | | y\_train\_ist[ y\_train>=7 ] = 2 | | | | | | y\_train\_multioutput = np.c\_[y\_train\_1st, y\_train] | | | y\_train\_multioutput | | | # 運行結果 | | | array( [[0, 4], | | | [1, 5], | | | [2, 7], | | | [1, 5], | | | [2, 9], | | | [2, 9]]) |

用含有100棵決策樹的隨機森林來解決這個多輸入分類問題。

| | MO = MultiOutputClassifier( RandomForestClassifier(n\_estimators=100) ) | | | MO.fit( X\_train, y\_train\_multioutput ) | | | # 結果 | | | MultiOutputClassifier(estimator=RandomForestClassifier(bootstrap=True, class\_weight=None, criterion='gini', max\_depth=None, max\_features='auto', 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, n\_estimators=100, n\_jobs=None, oob\_score=False, random\_state=None, verbose=0, warm\_start=False), n\_jobs=None) |

看看這個模型在測試集前五張照片上的預測。

這個ndarray第一列是標簽1的類別，第二列是標簽2的類別。預測結果是這五張照片分別顯示數(shù)字2、2、0、9、5(標簽2)，它們前三個數(shù)2、2、0都小于等于4(標簽1第一類)，第四個數(shù)9大于等于7(標簽1第二類)，而第五個數(shù)5在4和7之間(標簽1第三類)。

再看看真實標簽。

對比參考結果標簽，模型預測的結果還是很不錯的。

4.4 Model Selection 估計器

模型選擇(Model Selction)在機器學習非常重要，它主要用于評估模型表現(xiàn)，常見的Model Selection估計器有以下幾個：

cross_validate：評估交叉驗證的結果。
learning_curve：構建與繪制學習曲線。
GridSearchCV：用交叉驗證從超參數(shù)候選網格中搜索出最佳超參數(shù)。
RandomizedSearchCV：用交叉驗證從一組隨機超參數(shù)搜索出最佳超參數(shù)。

這里我們只關注調節(jié)超參數(shù)的兩個估計器，即GridSearchCV和RandomizedSearchCV。我們先回顧一下交叉驗證（更詳細的講解請查看ShowMeAI文章 圖解機器學習 | 模型評估方法與準則）。

(1) 交叉驗證

K-折交叉驗證(K-fold cross validation set)，指的是把整個數(shù)據(jù)集平均但隨機分成K份，每份大概包含m/K個數(shù)據(jù)(m 是總數(shù)據(jù)數(shù))。

在這K份，每次選K-1份作為訓練集擬合參數(shù)，在剩下1份驗證集上進行評估計算。由于遍歷了這K份數(shù)據(jù)，因此該操作稱為交叉驗證。操作如下圖所示

下圖展示了兩個調參的估計器：「網格搜索」和「隨機搜索」。

網格搜索調參：參數(shù)1在[1,10,100,1000]中取值，參數(shù)2在[0.01, 0.1, 1 10] 中取值，注意并不是等間距取值。模型在所有16組超參數(shù)上實驗，選取交叉驗證誤差最小的參數(shù)。

隨機搜索調參：根據(jù)指定分布隨機搜索，可以選擇獨立于參數(shù)個數(shù)，比如log(參數(shù)1)服從0到3的均勻分布，log(參數(shù)2)服從-2到1的均勻分布。

應用方式與參考代碼如下：

| | from time import time | | | from scipy.stats import randint | | | from sklearn.model\_selection import GridSearchCv | | | from sklearn.model\_selection import RandomizedSearchcCv | | | from sklearn.ensemble import RandomForestClassifier | | | | | | X, y = digits.data, digits.target | | | RFC = RandomForestClassifier(n\_estimators=20) | | | | | | # 隨機搜索/Randomized Search | | | param\_dist = { "max\_depth": [3, 5], | | | "max\_features": randint(1, 11), | | | "min\_samples\_split": randint(2, 11), | | | "criterion": ["gini", "entropy"]} | | | n\_iter\_search = 20 | | | random\_search = RandomizedSearchCv( RFC, param\_distributions=param\_dist, n\_iter=n\_iter\_search, cv=5 )} | | | start = time() | | | random\_search.fit(X, y) | | | print("RandomizedSearchCv took %.2f seconds for %d candidates，parameter settings." % ((time() - start), n\_iter\_search)) | | | print( random\_search.best\_params\_ ) | | | print( random\_search.best\_score\_ ) | | | | | | # 網格搜索/Grid Search | | | param\_grid = { "max\_depth": [3, 5], | | | "max\_features": [1, 3, 10], | | | "min\_samples\_ split": [2, 3, 10], | | | "criterion": ["gini", "entropy"]} | | | grid\_search = GridSearchCV( RF, param\_grid=param\_grid, cv=5 ) | | | start = time() | | | grid\_search.fit(X, y) | | | | | | print("\nGridSearchcv took %.2f seconds for %d candidate parameter settings." % (time() - start, len(grid\_search.cv\_results\_['params']))) | | | print( grid\_search.best\_params\_ ) | | | print( grid\_search.best\_score\_ ) |

輸出結果如下：

| | RandomizedSearchCv took 3.73 seconds for 20 candidates parameter settings. | | | {'criterion': 'entropy', '*max\_depth': 5, 'max\_features': 6, 'min\_samples\_split': 4} | | | 0.8898163606010017 | | | | | | GridSearchCV took 2.30 seconds for 36 candidate parameter settings. | | | {'criterion': 'entropy', 'max\_depth': 5, 'max\_features': 10, 'min\_samples\_ split': 10} | | | 0.841402337228714S5 |

這里我們對代碼做一個解釋：

前5行引入相應工具庫。
第7-8行準備好數(shù)據(jù)X和y，創(chuàng)建一個含20個決策樹的隨機森林模型。
第10-14和23-27行為對隨機森林的超參數(shù)「最大樹深、最多特征數(shù)、最小可分裂樣本數(shù)、分裂標準」構建候選參數(shù)分布與參數(shù)網格。
第15-18行是運行隨機搜索。
第18-30行是運行網格搜索。

運行結果里：

第一行輸出每種追蹤法運行的多少次和花的時間。
第二行輸出最佳超參數(shù)的組合。
第三行輸出最高得分。

在本例中，隨機搜索比網格搜索用更短時間內找到一組超參數(shù)，獲得了更高的得分。

4.5 Pipeline 估計器

Pipeline估計器又叫流水線，把各種估計器串聯(lián)(Pipeline)或并聯(lián)(FeatureUnion)的方式組成一條龍服務。用好了它真的能大大提高效率。

(1) Pipeline

Pipeline將若干個估計器按順序連在一起，比如：特征提取 → 降維 → 擬合 → 預測

Pipeline的屬性永遠和最后一個估計器屬性一樣：

如果最后一個估計器是預測器，那么Pipeline是預測器。
如果最后一個估計器是轉換器，那么Pipeline是轉換器。

下面是一個簡單示例，使用Pipeline來完成「填補缺失值-標準化」這兩步的。我們先構建含缺失值NaN的數(shù)據(jù)X。

我們用以下流程組件構建Pipeline：

處理缺失值的轉換器SimpleImputer。
做規(guī)劃化的轉換器MinMaxScaler。

第5-7行創(chuàng)建了流水線，使用方式非常簡單，在Pipeline()里輸入(名稱,估計器)這個元組構建的流水線列表。在本例中SimpleImputer起名叫impute，MinMaxScaler起名叫normalize。

因為最后一個估計器是轉換器，因此pipeline也是個轉換器。下面我們來運行一下，我們發(fā)現(xiàn)值都被填滿了，而且兩列也被標準化了。

| | X\_proc = pipe.fit\_transform( X ) |

來驗證上面流水線的參數(shù)，我們可以按順序來運行這兩個轉換器，結果是一樣的。

| | X\_impute = SimpleImputer(missing values=np.nan, strategy='mean').fit\_transform( X ) | | | X\_impute | | | # 運行結果 | | | array( [[50, 1.68], | | | [40, 1.83], | | | [30, 1.77], | | | [5, 1.78], | | | [7, 1.9 ], | | | [10, 1.65], | | | [9, 1.88], | | | [20.375, 1.78], | | | [12, 1.75 ]]) | | | X\_normalize = MinMaxScaler().fit\_transform( X\_impute ) | | | X\_normalize |

運行結果

| | array( [[1., 0.12 ], | | | [0.77777778, 0.72], | | | [0.55555556, 6.48], | | | [0.52, 1], | | | [0.04444444, 1.], | | | [0.11111111, 9.], | | | [0.08888889, 6.92], | | | [0.34166667, 6.52], | | | [0.15555556, 0.4 ]]) |

(2) FeatureUnion

如果我們想在一個節(jié)點同時運行幾個估計器，我們可用FeatureUnion。在下面的例子中，我們首先建立一個DataFrame數(shù)據(jù)，它有如下特點：

前兩列字段「智力IQ」和「脾氣temper」都是類別型變量。
后兩列字段「收入income」和「身高height」都是數(shù)值型變量。
每列中都有缺失值。

| | d= { 'IQ' : ['high','avg','avg','low', high', avg', 'high', 'high',None], | | | 'temper' : ['good', None,'good', 'bad', 'bad','bad', 'bad', None, 'bad'], | | | 'income' : [50,40,30,5,7,10,9,np.NaN,12], | | | 'height' : [1.68,1.83,1.77,np.NaN,1.9,1.65,1.88,np.NaN,1.75]} | | | | | | X = pd.DataFrame( d ) | | | X |

結果如下：

我們現(xiàn)在按下列步驟來清洗數(shù)據(jù)。

對類別型變量：獲取數(shù)據(jù) → 中位數(shù)填充 → 獨熱編碼
對數(shù)值型變量：獲取數(shù)據(jù) → 均值填充 → 標準化

上面兩步是并行進行的。

首先我們自己定義一個從DataFrame里面獲取數(shù)據(jù)列的類，起名叫DataFrameSelector。

上述代碼在transform函數(shù)中，我們將輸入的DataFrame X根據(jù)屬性名稱來獲取其值。

接下來建立流水線full_pipe，它并聯(lián)著兩個流水線

categorical_pipe處理分類型變量
- DataFrameSelector用來獲取
- SimpleImputer用出現(xiàn)最多的值來填充None
- OneHotEncoder來編碼返回非稀疏矩陣
numeric_pipe處理數(shù)值型變量
- DataFrameSelector用來獲取
- SimpleImputer用均值來填充NaN
- normalize來規(guī)范化數(shù)值

代碼如下：

| | from sklearn.pipeline import Pipeline | | | from sklearn.pipeline import FeatureUnion | | | from sklearn.impute import SimpleImputer | | | from sklearn.preprocessing import MinMaxScaler | | | from sklearn.preprocessing import OneHotEncoder | | | | | | categorical features = ['IQ', 'temper'] | | | numeric\_features = ['income', 'height'] | | | | | | categorical pipe = Pipeline([ | | | ('select', DataFrameSelector(categorical\_features)), | | | ('impute', SimpleImputer(missing values=None, strategy='most\_frequent')), | | | ('one\_hot\_encode', OneHotEncoder(sparse=False))]) | | | | | | numeric\_pipe = Pipeline([ | | | ('select', DataFrameSelector(numeric\_features)), | | | ('impute', SimpleImputer(missing values=np.nan, strategy='mean')), | | | ('normalize', MinMaxScaler())]) | | | | | | full\_pipe = FeatureUnion( transformer\_list=[ | | | ('numeric\_pipe', numeric\_pipe), | | | ('categorical\_pipe', categorical\_pipe)]) |

我們打印結果如下：

| | 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工具庫應用知識做一個總結。

5.1 SKLearn五大原則

SKLearn的設計下，它的主要API遵循五大原則

(1) 一致性

所有對象的接口一致且簡單，在「估計器」中

創(chuàng)建：model = Constructor(hyperparam)
擬參：
- 有監(jiān)督學習：model.fit(X_train, y_train)
- 無監(jiān)督學習：model.fit(X_train)

在「預測器」中

有監(jiān)督學習里預測標簽：y_pred = model.predict(X_test)
無監(jiān)督學習里識別模式：idx_pred = model.predict( Xtest)

在「轉換器」中

創(chuàng)建：trm = Constructor(hyperparam)
獲參：trm.fit(X_train)
轉換：X_trm = trm.transform(X_train)

(2) 可檢驗

所有估計器里設置的超參數(shù)和學到的參數(shù)都可以通過實例的變量直接訪問來檢驗其值，區(qū)別是超參數(shù)的名稱最后沒有下劃線_，而參數(shù)的名稱最后有下劃線_。舉例如下：

通例：model.hyperparameter
特例：SVC.kernel
通例：model.parameter_
特例：SVC.support_vectors_

(3) 標準類

SKLearn模型接受的數(shù)據(jù)集的格式只能是「Numpy數(shù)組」和「Scipy稀疏矩陣」。超參數(shù)的格式只能是「字符」和「數(shù)值」。
不接受其他的類！

(4) 可組成

模塊都能重復「連在一起」或「并在一起」使用，比如兩種形式流水線(pipeline)

任意轉換器序列
任意轉換器序列+估計器

(5) 有默認

SKLearn給大多超參數(shù)提供了合理的默認值，大大降低了建模的難度。

5.2 SKLearn框架流程

sklearn的建模應用流程框架大概如下：

(1) 確定任務

是「有監(jiān)督」的分類或回歸？還是「無監(jiān)督」的聚類或降維？確定好后基本就能知道用Sklearn里哪些模型了。

(2) 數(shù)據(jù)預處理

這步最繁瑣，要處理缺失值、異常值；要編碼類別型變量；要正規(guī)化或標準化數(shù)值型變量，等等。但是有了Pipeline神器一切變得簡單高效。

(3) 訓練和評估

這步最簡單，訓練用估計器fit()先擬合，評估用預測器predict()來評估。

(4) 選擇模型

啟動ModelSelection估計器里的GridSearchCV和RandomizedSearchCV，選擇得分最高的那組超參數(shù)(即模型)。

參考資料

圖解機器學習算法 | 從入門到精通系列
SKLearn官網：https://scikit-learn.org/stable/
AI建模工具速查|Scikit-learn使用指南

ShowMeAI系列教程推薦

圖解Python編程：從入門到精通系列教程
圖解數(shù)據(jù)分析：從入門到精通系列教程
圖解AI數(shù)學基礎：從入門到精通系列教程
圖解大數(shù)據(jù)技術：從入門到精通系列教程
圖解機器學習算法：從入門到精通系列教程
機器學習實戰(zhàn)：手把手教你玩轉機器學習系列

编程问答

机器学习实战 | SKLearn最全应用指南

Python微信訂餐小程序課程視頻

Python實戰(zhàn)量化交易理財系統(tǒng)

引言

1.機器學習簡介

1.1 定義和構成元素

1.2 數(shù)據(jù)

1.3 任務

1.4 性能度量

2. SKLearn數(shù)據(jù)

2.1 SKLearn默認數(shù)據(jù)格式

2.2 自帶數(shù)據(jù)集

2.3 數(shù)據(jù)集引入方式

3.SKLearn核心API

3.1 估計器

(1) 線性回歸

(2) K均值

小結

3.2 預測器

小結

3.3 轉換器

(1) 類別型變量編碼

① LabelEncoder&OrdinalEncoder

② OneHotEncoder

(2) 特征縮放

① MinMaxScaler

② StandardScaler

4.高級API

4.1 Ensemble 估計器

(1) RandomForestClassifier

(2) VotingClassifier

4.2 Multiclass 估計器

(1) 多類別分類

① OneVsOneClassifier

② OneVsRestClassifier

(2) 多標簽分類

4.3 Multioutput 估計器

(1) MultiOutputClassifier

4.4 Model Selection 估計器

(1) 交叉驗證

4.5 Pipeline 估計器

(1) Pipeline

(2) FeatureUnion

5.總結

5.1 SKLearn五大原則

(1) 一致性

(2) 可檢驗

(3) 標準類

(4) 可組成

(5) 有默認

5.2 SKLearn框架流程

(1) 確定任務

(2) 數(shù)據(jù)預處理

(3) 訓練和評估

(4) 選擇模型

參考資料

ShowMeAI系列教程推薦

相關文章推薦

總結