Lesson 6.1 Scikit-Learn快速入門

# 科學計算模塊 import numpy as np import pandas as pd# 繪圖模塊 import matplotlib as mpl import matplotlib.pyplot as plt# 自定義模塊 from ML_basic_function import *

在此前的算法學習過程中，我們都是先從機器學習的算法理論出發，然后通過手動編程的方式來進行算法的建模實踐。這其實是一種重內力大于重招式的學習方法，在理論+手動實現的學習過程中，我們不僅通過原理的手動實現深化了對基礎原理的理解，同時也一定程度鍛煉了代碼實現能力，而這些其實都是一名算法工程師的基本功。

不過，伴隨著算法難度逐漸加深，“原理+手動實現”的學習方式將逐漸變得不太適用，至少對初學者來說，面對復雜算法學習時，“原理+手動實現”的學習方式并不高效。對于定位在利用算法解決問題的算法工程崗位來說，整體的技能要求其實是內功和招式并重的。也就是說，我們不僅需要通曉算法原理以及具備一定的編程能力，同時也需要掌握一些能夠比手動編寫算法更高效的執行機器學習建模的工具，也就是掌握一些算法包或者算法庫工具。

所謂算法庫或者算法包，其實就是指封裝了一系列可以執行機器學習算法建模相關功能的函數和類的程序模塊，其功能調用方法和此前我們自定義的ML_basic_function.py文件類似。當然，對于不同的編程語言和運行環境，其實有對應不同的算法庫或算法包，例如在R語言中，就有數以萬計的針對不同算法的一個個獨立的算法包，比較有名的諸如提供分類模型建模功能支持的rpart包、提供聚類算法建模功能的cluster包等等。盡管這些分門別類的包在每一項（類）具體算法建模過程中都能提供非常專業的功能支持，但由于這些算法包是由不同的團隊/個人來進行的開發和維護，包的使用方法和維護相同都各不相同，這就使得一個使用R語言的算法工作者在日常工作中至少需要和幾十個算法包打交道，并且由于各個包相對獨立，使得算法工作者需要時刻關注各包的更新情況及兼容方法（如果需要的話），這些都在無形之中對使用R語言進行機器學習建模造成了一定的阻礙。

雖然Python也是開源語言，但或許是吸取了R語言的前車之鑒（Python比R誕生更晚），也或許是擁有了更完整的科學計算庫SciPy，Python數據科學的一些核心功能都由一些更加統一和規范的第三方庫來提供，例如科學計算庫NumPy、表格數據分析包Pandas，以及機器學習算法庫Scikit-Learn。

算法包、算法庫、算法框架概念辨析：
很多時候我們在使用這三個概念的時候并不會特別在意三者的區別，或者說大多數時候這三者概念的區別并不會影響我們實際對不同的程序模塊的稱呼，例如我們會稱呼sklearn為一個算法庫，要使用xgboost時候需要安裝一個對應的算法包，而類似PyTorch、TensorFlow這種能夠執行深度學習運算的模塊，我們則會稱其為算法框架。但其實三者其實還是略有區別，對于算法包來說，可能只是包含了支持單獨一個或一類算法使用的類或函數；而算法庫則指代封裝程度更高、對機器學習這一大類算法功能實現更加完整、甚至是定義了一類數據結構的代碼模塊；當然，如果是算法框架，則會在算法庫的基礎上，更進一步定義基本對象類型的運行方式。

一、Scikit-Learn的前世今生

• Scikit-Learn項目簡介

Scikit-Learn最早是由David Cournapeau等人在2007年谷歌編程之夏（Google Summer of Code）活動中發起的一個項目，并與2010年正式開源，目前歸屬INRIA（法國國家信息與自動化研究所）。而項目取名為Scikit-Learn，也是因為該算法庫是基于SciPy來進行的構建，而Scikit則是SciPy Kit（SciPy衍生的工具套件）的簡稱，而learn則不禁讓人聯系到機器學習Machine Learning。因此，盡管Scikit-Learn看起來不如NumPy、Pandas短小精悍，但其背后的實際含義也是一目了然。

經過數十年的發展，Scikit-Learn已經成為目前機器學習領域最完整、同時也是最具影響力的算法庫，更重要的是，該項目擁有較為充裕的資金支持和完整規范的運作流程，以及業內頂級的開發和維護團隊，目前以三個月一個小版本的速度在進行更新迭代。

• Scikit-Learn官網與中文社區

作為非營利性組織維護的開源項目，我們可以從https://scikit-learn.org/stable/ 網址登陸Scikit-Learn項目官網。

值得一提的是，對于大多數流行的開源項目，官網都是學習的絕佳資源。而對于Scikit-Learn來說尤其是如此。要知道，哪怕是頂級開源項目盛行的當下，Scikit-Learn官網在相關內容介紹的詳細和完整程度上，都是業內首屈一指的。無論是Scikit-Learn的安裝、更新，還是具體算法的使用方法，甚至包括算法核心原理的論文出處以及算法使用的案例，在Scikit-Learn官網上都有詳細的介紹。稍后我們將對其逐一進行詳細介紹。

正是因為Scikit-Learn官網內容的完整性，國內也有許多團隊試圖將Scikit-Learn項目進行翻譯、并建立相應的中文社區。但遺憾的是，由于國內的大多數團隊對于開源項目的維護、管理和資金運作都缺乏必要的經驗，導致諸多所謂的Scikit-Learn中文社區其實并不是真正意義上的開源社區，而是一堆過時的、不完整的、不準確的內容翻譯拼湊而成的內容網站，借著技術傳播之名、行商業產品引流之實。而這也最終導致國內的Scikit-Learn中文社區，充其量只能作為外文技術內容翻譯的一個參考，而無法作為技術解釋和技術學習的核心內容。因此，圍繞Scikit-Learn的內容查閱，我們更推薦直接訪問外文官網。

二、Scikit-Learn官網使用指南與核心功能介紹

接下來，我們圍繞Scikit-Learn官網的基本架構與核心功能進行介紹，并同時介紹關于Scikit-Learn的基本安裝與使用方法。進入Scikit-Learn官網，首先看到的是功能導航欄、sklearn基本情況介紹以及幾個核心功能跳轉鏈接。

關于核心信息部分，我們能夠看到Scikit-Learn作為開源項目的基本申明，以及該開源項目所遵循的BSD協議。當然比較重要的一點是，sklearn是構建在NumPy、SciPy和matplotlib上的相關申明，后面我們會看到，sklearn中核心能夠處理的對象類型就是NumPy當中的數組（array），同時sklearn中的諸多數學計算過程也都是基于SciPy中的相關功能來進行的實現。

值得注意的是，底層數據結構對算法庫的影響是至關重要的，在分布式計算框架Spark中，算法庫就有兩類，其一是圍繞Spark基本數據結構RDD構建的ML包，其二則是圍繞Spark高級數據結構DataSet和DataFrame構建的MLLib包。當然由于基于更高級的數據結構所構建的算法模型更易于使用，因此ML包已經不再更新了。

1.Scikit-Learn的安裝與更新

接下來核心介紹功能導航欄的相關功能。首先是關于Scikit-Learn的安裝方法，我們可以在Install內進行查看：
該頁面主要介紹了關于sklearn在不同平臺下、使用不同工具的安裝方法。如果是首次安裝sklearn，可參考上述代碼在命令行中進行安裝。并且官網還貼心的指出，可以通過后面的代碼查看sklearn的安裝情況，其中第一行是查看目前安裝的sklearn版本以及安裝位置，第二行代碼是查看安裝好的第三方庫（在當前虛擬環境下），第三行代碼則是查看當前已經安裝好的sklearn版本。

當然，該頁面還細心的給出了虛擬環境不同版本第三方包沖突后的解決方案，以及sklearn的包的依賴包的安裝方法，包括新版sklearn所需基礎依賴包的版本號等。另外，該頁面還給出了新版sklearn的Mac M1版本的包的安裝方法，由此可見sklearn官網內容的詳細程度。

當然，對于通過Anaconda安裝Python的小伙伴來說，sklearn包已經在安裝Anaconda的過程中安裝好了，并且不同平臺的Anaconda就已經自帶了能夠在對應平臺運行的sklearn包，我們可以直接通過下述語句進行sklearn版本的查看：

import sklearn sklearn.__version__ #'0.23.2'

本次課程將以sklearn 0.23+版本作為主要使用版本，相關方法兼容sklearn 0.22、0.24等版本，即0.22版本以上即可參與課程學習。如果版本低于0.22的，可通過如下方式進行版本更新：

pip install --upgrade sklearn

更多關于pip工具的講解和使用，以及更加詳細的Python第三方庫管理方法，參見Python編程基礎公開課的內容：https://www.bilibili.com/video/BV1U54y1W7jw?p=2

sklearn從0.21版本開始不再支持Python 2，課程建議在Python 3環境中安裝新版sklearn。

對于Mac M1的用戶，考慮到Mac的多版本Python管理問題以及新版sklearn適配問題，建議使用Anaconda進行sklearn的安裝，目前實測Mac版Anaconda已支持0.23.2版本，若后續Mac版Anaconda支持sklearn 0.24，則可隨Anaconda一起更新。

2.Scikit-Learn核心概念與快速使用方法

作為功能完整算法庫，sklearn不僅提供了完整的機器學習建模功能支持，同時也提供了包括數據預處理、模型評估、模型選擇等諸多功能，并且支持以Pipelines（管道）形式構建機器學習流，而基于Pipeline和模型選擇功能甚至能夠衍化出AutoML（自動機器學習）的相關功能，也就是現在所謂的Auto-sklearn。

不過在開始階段，我們還是需要從sklearn的基礎功能入手進行學習，然后循序漸進、逐步深化對工具的理解和掌握。

• sklearn核心對象類型：評估器（estimator）

很多功能完整的第三方庫其實都有各自定義的核心對象類型，如NumPy中的數組（Array）、Pandas中的DataFrame、以及PyTorch中的張量（tensor）等，當然這些由第三方庫定義的數據結構實際上都是定義在源碼中的某個類，在調用這些對象類型時實際上都是在實例化對應的類。而對于sklearn來說，定義的核心對象類型就是評估器。我們可以將評估器就理解成一個個機器學習模型，而sklearn的建模過程最核心的步驟就是圍繞著評估器進行模型的訓練。

同樣，圍繞評估器的使用也基本分為兩步，其一是實例化該對象，其二則是圍繞某數據進行模型訓練。接下來，我們就嘗試調用sklearn中的線性回歸評估器（模型）來進行線性回歸建模實驗。

首先是準備數據，我們還是以此前定義的、基本規律滿足$y=2x_1?x_2+1$分布回歸類數據集：

# 設置隨機數種子 np.random.seed(24) # 擾動項取值為0.01 features, labels = arrayGenReg(delta=0.01) # 查看數據 features #array([[ 1.32921217, -0.77003345, 1. ], # [-0.31628036, -0.99081039, 1. ], # [-1.07081626, -1.43871328, 1. ], # ..., # [ 1.5507578 , -0.35986144, 1. ], # [-1.36267161, -0.61353562, 1. ], # [-1.44029131, 0.50439425, 1. ]]) # 可視化數據分布 plt.subplot(121) plt.plot(features[:, 0], labels, 'o') plt.subplot(122) plt.plot(features[:, 1], labels, 'o')

然后，嘗試調用sklearn中的線性回歸評估器，這里需要知道的是，sklearn其實是分模塊存儲不同評估器的類或者常用函數的，比如sklearn中的線性回歸評估器LinearRegression實際上是在sklearn包中的linear_model模塊下，因此調用該評估器其實會有以下三種方法：

# 方法一：直接導入sklearn import sklearn # 然后在sklearn里面的linear_model模塊內查詢LinearRegression評估器 sklearn.linear_model.LinearRegression #sklearn.linear_model._base.LinearRegression# 方法二：直接導入sklearn內的linear_model模塊 from sklearn import linear_model # 然后在linear_model模塊內查詢LinearRegression評估器 linear_model.LinearRegression #sklearn.linear_model._base.LinearRegression# 方法三：直接導入LinearRegression評估器 from sklearn.linear_model import LinearRegression # 然后即可直接查詢LinearRegression評估器 LinearRegression #sklearn.linear_model._base.LinearRegression

默認情況下，我們采用第三種方法導入評估器。

需要知道的是，導入評估器實際上就相當于是導入了某個模塊（實際上是某個類），但要使用這個評估器類，還需要對其進行實例化操作才能進行后續的使用，類的實例化過程會有可選參數的輸入，當然也可以不輸入任何參數直接實例化該類的對象：

model = LinearRegression()

注意，此時model就是LinearRegression類的一個實例化對象，而這個model對象，其實就是一個線性回歸模型。當然，剛被實例化后的模型實際上還是一個未被訓練的模型，即此時的model其實是一個包含了若干個（暫時不確定）參數、并且參數取值待定的模型。接下來，我們需要輸入上述數據對該模型進行訓練。需要注意的是，此時我們無需在輸入的特征矩陣中加入一列全都是1的列：

X = features[:, :2] # 特征矩陣 y = labels # 標簽數組 # 調用評估器中的fit方法進行模型訓練 model.fit(X, y) #LinearRegression()

fit方法是LinearRegression類中的一個至關重要的方法，同時也是sklearn中代表模型的評估器都具有的方法，當fit方法執行完后，即完成了模型訓練，此時model就相當于一個參數個數、參數取值確定的線性方程。而這些包括參數取值在內的所有模型信息，我們都可以通過調用model對象當中的一些屬性來查看，例如：

# 查看自變量參數 model.coef_ #array([[ 1.99961892, -0.99985281]]) # 查看模型截距 model.intercept_ #array([0.99970541])

至此，我們就完成了模型訓練過程。這里需要特別強調的是，sklearn默認接收的對象類型是數組，即無論是特征矩陣還是標簽數組，最好都先轉化成array對象類型再進行輸入。此外，sklearn還能夠處理array-like的數據，例如和數組形式相同的列表，但并不建議這么做。同時，在sklearn中，我們往往以稱特征矩陣為Features Matrix，稱特征數組為Target Vector，并且以$n_{samples}$表示數據行數、$n_{features}$表示特征矩陣列數：

當然我們也可以對比最小二乘法的手動計算結果：

np.linalg.lstsq(features, labels, rcond=-1)[0] #array([[ 1.99961892], # [-0.99985281], # [ 0.99970541]])

接下來，我們還可以利用該模型進行數值預測，我們就將模型應用于訓練數據進行預測，可以使用model中的predict方法進行預測，同樣，該方法也是sklearn中所有評估器類的一個方法：

model.predict(X)[:10] #array([[ 4.42754333], # [ 1.35792976], # [ 0.29698247], # [ 1.83264567], # [-2.47201615], # [ 0.46806169], # [ 2.8184199 ], # [-0.81254525], # [ 2.84841913], # [ 0.81582296]]) y[:10] #array([[ 4.43811826], # [ 1.375912 ], # [ 0.30286597], # [ 1.81970897], # [-2.47783626], # [ 0.47374318], # [ 2.83085905], # [-0.83695165], # [ 2.84344069], # [ 0.8176895 ]])

通過對比，我們不難發現發現，模型整體預測效果較好。當然，在借助sklean進行建模的時候，我們也可以借助sklearn提供的模型評估函數來進行模型最終效果的評估，而這些實用函數，就是sklearn算法庫中第二類重要的對象類型。

• sklearn中的實用函數

接下來，我們嘗試調用sklearn中的MSE計算函數，對上述建模結果進行模型評估。值得注意的是，這些調用的對象不再是評估器（類），而是一個個單獨的函數。函數的調用過程不需要進行實例化，直接導入相關模塊即可：

# 在metrics模塊下導入MSE計算函數 from sklearn.metrics import mean_squared_error # 輸入數據，進行計算 mean_squared_error(model.predict(X), y) #9.300731379745624e-05 l = model.coef_.flatten().tolist() l.extend(model.intercept_.tolist()) l #[1.9996189241115245, -0.9998528065894624, 0.9997054101551712] w = np.array(l).reshape(-1, 1) w #array([[ 1.99961892], # [-0.99985281], # [ 0.99970541]]) # 對比手動計算的MSE計算結果 MSELoss(features, w, y) #array([[9.30073138e-05]])

至此，我們即完成了調用sklearn進行建模的簡單流程，當然，在更進一步加入數據預處理、數據集切分以及模型結果驗證等步驟之前，我們需要討論幾個至關重要的影響模型建模過程的核心問題：

• 模型實例化與超參數設置

上述調用sklearn進行的機器學習建模，不僅代碼簡單、而且過程也非常清晰，這些其實全都得益于Scikit-Learn對各評估器都設置了較為普適的初始默認參數所導致。我們知道，每個模型的構建過程其實都會涉及非常多的參數和超參數，參數的訓練過程稍后討論，此處先討論關于sklearn中模型超參數的設置方法。

所謂超參數，指的是無法通過數學過程進行最優值求解、但卻能夠很大程度上影響模型形式和建模結果的因素，例如線性回歸中，方程中自變量系數和截距項的取值是通過最小二乘法或者梯度下降算法求出的最優解，而例如是否帶入帶入截距項、是否對數據進行歸一化等，這些因素同樣會影響模型形態和建模結果，但卻是“人工判斷”然后做出決定的選項，而這些就是所謂的超參數。

而sklearn中，對每個評估器進行超參數設置的時機就在評估器類實例化的過程中。首先我們可以查看LinearRegression評估器的相關說明，其中Parameters部分就是當前模型超參數的相關說明：

LinearRegression?

我們可以簡單解釋上述評估器內的超參數選項：

不難發現，這些都是影響建模過程、并且需要人工決策的選項，而這些超參數可以在實例化過程中進行設置，例如我們創建一個不包含截距項的線性方程模型：

model1 = LinearRegression(fit_intercept=False) model1 #LinearRegression(fit_intercept=False) model1.get_params() model1.get_params() model1.get_params() #{'copy_X': True, 'fit_intercept': False, 'n_jobs': None, 'normalize': False}

通過輸入模型對象，我們就可以查看該評估器超參數取值情況（默認參數取值不顯示），或者可以直接使用get_params方法查看模型參數。而對于一個已經實例化好的評估器，我們都可以通過set_params來對其進行參數修改，如果是已經訓練好的模型，該方法不會抹去之前訓練結果，但會影響下次訓練流程。

model1.set_params(fit_intercept=True) #LinearRegression() model.set_params(fit_intercept=False) #LinearRegression(fit_intercept=False) model.coef_ #array([[ 1.99961892, -0.99985281]]) model.intercept_ #array([0.99970541]) model.fit(X,y) #LinearRegression(fit_intercept=False) model.coef_,model.intercept_ #(array([[ 1.93291366, -0.96799981]]), 0.0)

我們可以簡單評估器調用過程過程中各操作的代碼意義和建模意義對比如下：

值得注意，超參數的設置方法和參數不同，一個模型的參數形式基本根據模型的計算規則就能確定，而一個模型包含幾個超參數，其實是因模型而異、因工具而異的，例如，對于sklearn來說，我們可以通過n_jobs來設置參與計算的CPU核數，而在Spark中則是通過配置文件中的配置選項來分配每個任務的計算資源，不需要在算法執行過程中設置該超參數。但無論如何，sklearn中的超參數設計一定是一整套最符合sklearn設計理念以及模型運行方式的超參數，我們在實例化模型的過程中必須謹慎的選擇模型超參數，以達到最終模型訓練的預期。不過sklearn非常人性化的一點是，盡管大多數模型多有非常多的超參數（線性回歸除外），但sklearn都對其設置了一套非常普適的默認值，從而使得在很多場景下，在無需特別關注的一些超參數的取值上，我們都能夠直接使用默認值帶入進行建模。

其實，我們還可以給出超參數的一個更加“廣義”的定義：只要是影響模型建模過程的因素都是超參數，例如選取哪種優化方法、甚至是選取哪種算法進行建模，如果需要，我們都可以將其視作超參數，而不僅限于評估器中給出的這些。當然，如果要圍繞這些超參數進行探討，則需要更多的理論判別依據與實現工具。不過就模型選擇來說，其實已經有一些框架能夠實現模型的自動選擇（不僅是模型自動調參，而是自動對比模型性能進而進行模型選擇）。

不過盡管在定義上，參數與超參數是嚴格不同的，但很多場景下我們也不會對其進行嚴格區分，比如在實例化評估器的過程中，我們也更多的稱其為“進行參數設置”。

需要注意的是，此處線性方程中的normalize并不是此前介紹的歸一化方法，而是一種用每一行數據除以每一行數據的l1范數或者l2范數的方法，這種方法會在稍后進行介紹。

此外，我們還能夠在類的說明中查閱關于模型對象在訓練完后的相關屬性，注意，這些屬性只有當模型訓練完畢后才能調用查看，對于線性方程來說，模型訓練后可查看如下屬性：

# 訓練后模型屬性 model.rank_ #2 # 訓練前模型無該屬性 model1.rank_

• 訓練過程使用的參數求解方法

根據此前的討論，我們知道，實現線性回歸參數計算的方法有很多種，我們可以通過最小二乘法進行一步到位的參數求解，同時也能夠通過梯度下降進行迭代求解，而sklearn是采用哪種方式進行求解的呢？需要知道的是，這個問題其實至關重要，它不僅影響了sklearn中該算法的執行計算效率，同時也決定了該算法的很多建模特性，例如，如果是采用最小二乘法進行的參數求解，則面臨特征矩陣擁有多重共線性時，計算結果將變得不再可靠。而我們對任何一個算法工具的掌握，都不能僅僅停留在“能夠跑出結果”這個層面。

要詳細了解訓練過程的參數求解方法，就需要回到官網中查閱評估器的相關說明。而LinearRegression評估器的相關說明，在sklearn官網說明的六大板塊（稍后會進行詳細介紹）中的Regression板塊中。
在該模塊的1.1.1.Ordinary Least Squares中，就是關于LinearRegression評估器的相關說明。從標題就能看出，sklearn中是通過普通最小二乘法來執行的線性方程參數求解。接下來詳細介紹關于sklearn中算法解釋部分的內容排布。首先，對于任何一個評估器（算法模型），說明文檔會先介紹算法的基礎原理、算法公式（往往就是損失函數計算表達式）以及一個簡單的例子，必要時還會補充算法提出的相關論文鏈接，帶領用戶快速入門。
緊接著，說明文檔會對算法的某些特性進行探討（往往都是在使用過程中需要注意的問題），例如對于普通最小二乘法，最大的問題還是在于特征矩陣出現嚴重多重共線性時，預測結果會出現較大的誤差。然后，說明文檔會例舉一個該算法的完整使用過程，也就是穿插在說明文檔中的example。再然后，說明文檔會討論幾個在模型使用過程中經常會比較關注的點，對于線性回歸，此處列舉了兩個常見問題，其一是非負最小二乘如何實現，以及最小二乘法的計算復雜度。對于上述問題，有如下解釋。首先是關于非負最小二乘法，其實本質上就是約束線性方程建模結果中所有參數取值都為正數，以滿足某些需求場景；另外關于最小二乘法的復雜度，根據上述說明不難看出，最小二乘法計算復雜度為$O(n_{samples}{n}_{features}^2)$。

不難看出，sklearn官網說明文檔非常細致并且非常完整，如果稍加對比，相比目前流行的深度學習框架或者分布式計算框架，sklearn的說明文檔可以說是內容最詳細、布局最合理、對初學者用戶最友好的官網沒有之一，甚至在早些年，市面上大多數介紹sklearn的書，其實“靈感”來源都是sklearn官網。因此，如果要推薦關于sklearn的參考資料的話，首先也是力推sklearn官網。

不過，若要完全參照sklearn進行學習，還是會面臨一些“問題”。首先是API查詢與檢索的問題，盡管sklearn官網對所有的評估器進行了六大類的分類、并且將所有的API進行了整理并提供了索引的入口，但對于大多數初學者來說，如何快速的找到所需要的評估器和函數，仍然還是一個亟待解決的問題。對此，我們將在下一小節進行關于Scikit-Learn的內容分布于查找的相關介紹。此外，由于sklearn非常完整，包含了目前大多數機器學習算法和幾乎全部經典機器學習算法，這也導致sklearn中盡管看起來算法種類繁多，但并不是所有算法都有非常廣泛的用途，如果是圍繞sklearn進行算法學習，需要有選擇的進行針對性學習；其三，盡管sklearn包含了算法的損失函數和一些基本原理，但限于篇幅，其實sklearn的算法解釋文檔并未對算法的基本原理進行詳細介紹，若要深入原理層面進行學習，則還需要額外補充學習材料；其四，當然也是尤其需要注意的一點，sklearn為了內置接口的統一性和運算的高效性，很多算法其實都是在原機器學習算法上進行了微調，也就是sklearn的實現過程和原始算法的設計流程略微存在區別，這些區別會在后續算法內容學習中逐漸接觸到。

不過無論如何，作為一個算法工具迅速定位和查找我們所需的模型（評估器）和函數、以及其他相關內容，都是掌握這門工具之必須，接下來我們就圍繞sklearn官網的內容布局進行介紹。

3.Scikit-Learn內容分布與查找

• sklearn的六大功能模塊

首先，從建模功能上進行區分，sklearn將所有的評估器和函數功能分為六大類，分別是分類模型（Classification）、回歸模型（Regression）、聚類模型（Clustering）、降維方法（Dimensionality reduction）、模型選擇（Model selection）和數據預處理六大類。

其中分類模型、回歸模型和聚類模型是機器學習內主流的三大類模型，其功能實現主要依靠評估器類，并且前兩者是有監督學習、聚類模型屬于無監督學習范疇。當然，sklearn中并未包含關聯規則相關算法，如Apriori或者FP-Growth，這其實一定程度上和sklearn只能處理array-like類型對象有關。而后三者，降維方法、模型選擇方法和數據預處理方法，則多為輔助建模的相關方法，并且既有評估器也有實用函數。

值得一提的是，上述六個功能模塊的劃分其實是存在很多交叉的，對于很多模型來說，既能處理分類問題、同時也能處理回歸問題，而很多聚類算法同時也可以作為降維方法實用。不過這并不妨礙我們從這些功能入口出發，去尋找我們需要的評估器或實用函數。例如線性回歸對用評估器可從Regression進入進行查找，而對用模型評估指標，由于評估指標最終是指導進行模型選擇的，因此模型評估指標計算的實用函數的查找應該從Model selection入口進入，并且在3.3 Metrics and scoring: quantifying the quality of predictions內。

• User Guide：sklearn所有內容的合集文檔

此外，我們可以在最上方的User Guide一欄進入sklearn所有內容的合集頁面，其中包含了sklearn的所有內容按照使用順序進行的排序。如果點擊左上方的Other versions，則可以下載sklearn所有版本的User Guide的PDF版本。

• API：按照二級模塊首字母排序的接口查詢文檔

如果想根據評估器或實用函數的名字去查找相關API說明文檔，則可以點擊最上方的API一欄進入到根據二極模塊首字母排序的API查詢文檔中。其中二級模塊指的是類似包含線性回歸的linear_model模塊或者包含MSE的metrics模塊。

• 關于源碼的閱讀

閱讀開源算法框架的源碼，其實是很多高階算法工程師自我提升的必經之路。盡管sklearn中出于代碼運行速度考慮，有部分算法是用cython重寫了，但目前大多數代碼都在朝著代碼可讀性和易用性方向發展（降低協作門檻），因此大部分模塊的代碼還是相對不難讀懂的。

不過在初中級階段、尤其是以調用評估器建模為主的情況下，還是應以熟練掌握常用評估器和實用函數、以及其背后的實現原理為核心進行學習。因此對大多數小伙伴來說，并不推薦在當前階段并不推薦進行源碼閱讀。

以上就是關于sklearn官網的整體內容布局介紹，接下來，我們將繼續圍繞調庫建模這一目標，進一步探索與嘗試使用更多的sklearn中的相關功能。

Lesson 6.2 Scikit-Learn常用功能介紹

在對sklearn整體情況有了一定的了解之后，接下來我們來介紹sklearn中機器學習建模過程常用的一些功能。

# 科學計算模塊 import numpy as np import pandas as pd# 繪圖模塊 import matplotlib as mpl import matplotlib.pyplot as plt# 自定義模塊 from ML_basic_function import *

三、Scikit-Learn的常用功能介紹

接下來，我們進一步構建功能實現更加完整與復雜的建模過程，并練習使用更多的sklearn中的相關功能。

1.sklearn中的數據集讀取

sklearn提供了非常多的內置數據集，并且還提供了一些創建數據集的方法。

sklearn中的數據集相關功能都在datasets模塊下，我們可以通過API文檔中的datasets模塊所包含的內容對所有的數據集和創建數據集的方法進行概覽。不難發現，sklearn中提供了結構化數據集（如經典的鳶尾花數據集、波士頓房價數據集、乳腺癌數據集等），同時也提供了一些如圖片數據、文本數據等數據集，可以使用load函數來進行讀取；此外，sklearn中還提供了許多能夠創建不同數據分布的數據生成器（用make函數創建），和我們此前定義的數據生成器類似，都是可以用于創建測試評估器性能的數據生成器。

首先是鳶尾花數據的讀取，我們可借助load_iris來進行數據的讀取。簡單讀取方法如下：

from sklearn.datasets import load_iris iris_data = load_iris()# 查看讀取結果 iris_data

注意，在默認情況下，數據讀取結果的類型是Bunch類型，是一個類似字典類型的對象：

type(iris_data) #sklearn.utils.Bunch

而該對象（字典）有如下屬性（鍵值對）：

# 返回特征 iris_data.data[:10] #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], # [5.4, 3.9, 1.7, 0.4], # [4.6, 3.4, 1.4, 0.3], # [5. , 3.4, 1.5, 0.2], # [4.4, 2.9, 1.4, 0.2], # [4.9, 3.1, 1.5, 0.1]]) # 返回標簽 iris_data.target[:10] #array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) # 返回各列名稱 iris_data.feature_names #['sepal length (cm)', # 'sepal width (cm)', # 'petal length (cm)', # 'petal width (cm)'] # 返回標簽各類別名稱 iris_data.target_names[:10] #array(['setosa', 'versicolor', 'virginica'], dtype='<U10')

當然，如果希望只返回特征矩陣和標簽數組這兩個對象，則可以通過在讀取數據集時設置參數return_X_y為True來實現

X, y = load_iris(return_X_y=True) X[:10] #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], # [5.4, 3.9, 1.7, 0.4], # [4.6, 3.4, 1.4, 0.3], # [5. , 3.4, 1.5, 0.2], # [4.4, 2.9, 1.4, 0.2], # [4.9, 3.1, 1.5, 0.1]]) y[:10] #array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

而如果想創建DataFrame對象，則可以通過在讀取數據集時設置參數as_frame為True來實現

iris_dataFrame = load_iris(as_frame=True) iris_dataFrame.frame

更多信息，可以通過查閱API或者幫助文檔獲得。當然不僅鳶尾花數據的讀取過程如此，sklearn中其他數據的讀取過程也是類似。接下來，我們借助上述創建的X和y帶入進行后續建模。

2.sklearn中的數據集切分方法

在sklearn中，我們可以通過調用train_test_split函數來完成數據集切分，當然數據集切分的目的是為了更好的進行模型性能評估，而更好的進行模型性能評估則是為了更好的進行模型挑選，因此train_test_split函數實際上是在model_selection模塊下。

from sklearn.model_selection import train_test_split

該函數和此前我們定義的數據集切分函數在功能和使用上都基本一致，我們可以直接通過查閱該函數的幫助文檔來了解核心信息：

# 查閱該函數的幫助文檔 train_test_split?

此處有兩個地方需要注意，其一是隨機數種子的設置，和此前手動定義的數據集切分函數一樣，random_state取值不同，切分結果就會各有不同：

X = np.arange(12).reshape((6, 2)) X y = np.array([0, 0, 0, 1, 1, 1]) train_test_split(X, y, random_state=42) #[array([[10, 11], # [ 4, 5], # [ 8, 9], # [ 6, 7]]), # array([[0, 1], # [2, 3]]), # array([1, 0, 1, 1]), # array([0, 0])] train_test_split(X, y, random_state=24) #[array([[2, 3], # [0, 1], # [6, 7], # [4, 5]]), # array([[ 8, 9], # [10, 11]]), # array([0, 0, 1, 0]), # array([1, 1])]

而stratify參數則是控制訓練集和測試集不同類別樣本所占比例的參數，若希望切分后的訓練集和測試集中0、1兩類的比例和原始數據相同（1:1），則可另stratify=y，則有結果如下：

train_test_split(X, y, stratify=y, random_state=42) #[array([[ 2, 3], # [10, 11], # [ 0, 1], # [ 8, 9]]), # array([[6, 7], # [4, 5]]), # array([0, 1, 0, 1]), # array([1, 0])]

值得注意的是，此時盡管隨機數種子仍然會發揮作用，但由于計算流程發生了變化，最終切分出來的結果將和此前的切分結果不同（但都會保持（1:1）的分布比例）。

train_test_split(X, y, stratify=y, random_state=24) #[array([[ 0, 1], # [10, 11], # [ 8, 9], # [ 2, 3]]), # array([[6, 7], # [4, 5]]), # array([0, 1, 1, 0]), # array([1, 0])]

3.sklearn中的數據標準化與歸一化

正如此前介紹的，很多時候我們需要對數據進行歸一化處理。而在sklearn中，則包含了非常多關于數據歸一化的函數和評估器，接下來我們對其進行逐一介紹，然后從中挑選合適的函數或者評估器帶入進行建模。

從功能上劃分，sklearn中的歸一化其實是分為標準化（Standardization）和歸一化（Normalization）兩類。其中，此前所介紹的Z-Score標準化和0-1標準化，都屬于Standardization的范疇，而在sklearn中，Normalization則特指針對單個樣本（一行數據）利用其范數進行放縮的過程。不過二者都屬于數據預處理范疇，都在sklearn中的Preprocessing data模塊下。

from sklearn import preprocessing

需要注意的是，此前我們介紹數據歸一化時有討論過標準化和歸一化名稱上的區別，在大多數場景下其實我們并不會對其進行特意的區分，但sklearn中標準化和歸一化則各指代一類數據處理方法，此處需要注意。

3.1 標準化 Standardization

sklearn的標準化過程，即包括Z-Score標準化，也包括0-1標準化，并且即可以通過實用函數來進行標準化處理，同時也可以利用評估器來執行標準化過程。接下來我們分不同功能以的不同實現形式來進行討論：

• Z-Score標準化的函數實現方法

我們可以通過preprocessing模塊下的scale函數進行快速的Z-Score標準化處理。

preprocessing.scale?

上述函數說明文檔并不難懂，接下來我們簡單嘗試利用該函數進行數據歸一化處理。

X = np.arange(9).reshape(3, 3) X #array([[0, 1, 2], # [3, 4, 5], # [6, 7, 8]]) preprocessing.scale(X) #array([[-1.22474487, -1.22474487, -1.22474487], # [ 0. , 0. , 0. ], # [ 1.22474487, 1.22474487, 1.22474487]]) # 對比此前定義的函數處理結果 z_score(X) #array([[-1.22474487, -1.22474487, -1.22474487], # [ 0. , 0. , 0. ], # [ 1.22474487, 1.22474487, 1.22474487]])

• Z-Score標準化的評估器實現方法

實用函數進行標準化處理，盡管從代碼實現角度來看清晰易懂，但卻不適用于許多實際的機器學習建模場景。其一是因為在進行數據集的訓練集和測試集切分后，我們首先要在訓練集進行標準化、然后統計訓練集上統計均值和方差再對測試集進行標準化處理，因此其實還需要一個統計訓練集相關統計量的過程；其二則是因為相比實用函數，sklearn中的評估器其實會有一個非常便捷的串聯的功能，sklearn中提供了Pipeline工具能夠對多個評估器進行串聯進而組成一個機器學習流，從而簡化模型在重復調用時候所需代碼量，因此通過評估器的方法進行數據標準化，其實是一種更加通用的選擇。

既然是實用評估器進行數據標準化，那就需要遵照評估器的一般使用過程：

首先是評估器導入：

from sklearn.preprocessing import StandardScaler

然后是查閱評估器參數，然后進行評估器的實例化：

# 查閱參數 StandardScaler?scaler = StandardScaler()

然后導入數據，進行訓練，此處也是使用fit函數進行訓練：

X = np.arange(15).reshape(5, 3) X #array([[ 0, 1, 2], # [ 3, 4, 5], # [ 6, 7, 8], # [ 9, 10, 11], # [12, 13, 14]]) X_train, X_test = train_test_split(X) X_train, X_test #(array([[ 9, 10, 11], # [ 6, 7, 8], # [ 0, 1, 2]]), # array([[12, 13, 14], # [ 3, 4, 5]])) scaler.fit(X_train) #StandardScaler()

雖然同樣是輸入數據，但標準化的評估器和訓練模型的評估器實際上是不同的計算過程。此前我們介紹的線性方程的評估器，輸入數據進行訓練的過程（fit過程）實際上是計算線性方程的參數，而此處標準化的評估器的訓練結果實際上是對輸入數據的相關統計量進行了匯總計算，也就是計算了輸入數據的均值、標準差等統計量，后續將用這些統計量對各數據進行標準化計算。不過無論計算過程是否相同，評估器最終計算結果都可以通過相關屬性進行調用和查看：

# 查看訓練數據各列的標準差 scaler.scale_ #array([3.74165739, 3.74165739, 3.74165739]) # 查看訓練數據各列的均值 scaler.mean_ #array([5., 6., 7.]) # 查看訓練數據各列的方差 scaler.var_ #array([14., 14., 14.])# 總共有效的訓練數據條數 scaler.n_samples_seen_、 #3

當然，截止目前，我們只保留了訓練數據的統計量，但尚未對任何數據進行修改，輸入的訓練數據也是如此

X_train #array([[ 9, 10, 11], # [ 6, 7, 8], # [ 0, 1, 2]])

接下來，我們可以通過評估器中的transform方法來進行數據標準化處理。注意，算法模型的評估器是利用predict方法進行數值預測，而標準化評估器則是利用transform方法進行數據的數值轉化。

# 利用訓練集的均值和方差對訓練集進行標準化處理 scaler.transform(X_train) #array([[ 1.06904497, 1.06904497, 1.06904497], # [ 0.26726124, 0.26726124, 0.26726124], # [-1.33630621, -1.33630621, -1.33630621]]) # 利用訓練集的均值和方差對測試集進行標準化處理 scaler.transform(X_test) #array([[ 1.87082869, 1.87082869, 1.87082869], # [-0.53452248, -0.53452248, -0.53452248]]) z_score(X_train) #array([[ 1.06904497, 1.06904497, 1.06904497], # [ 0.26726124, 0.26726124, 0.26726124], # [-1.33630621, -1.33630621, -1.33630621]])

此外，我們還可以使用fit_transform對輸入數據進行直接轉化：

scaler = StandardScaler()# 一步執行在X_train上fit和transfrom兩個操作 scaler.fit_transform(X_train) #array([[ 1.06904497, 1.06904497, 1.06904497], # [ 0.26726124, 0.26726124, 0.26726124], # [-1.33630621, -1.33630621, -1.33630621]]) X_train #array([[ 9, 10, 11], # [ 6, 7, 8], # [ 0, 1, 2]]) scaler.transform(X_test) #array([[ 1.87082869, 1.87082869, 1.87082869], # [-0.53452248, -0.53452248, -0.53452248]])

接下來，我們就能直接帶入標準化后的數據進行建模了。

• 0-1標準化的函數實現方法

和Z-Score標準化類似，0-1標準化也有函數實現和評估器實現兩種，先看0-1標準化的函數實現過程：

# 查看函數說明文檔 preprocessing.minmax_scale?X #array([[ 0, 1, 2], # [ 3, 4, 5], # [ 6, 7, 8], # [ 9, 10, 11], # [12, 13, 14]]) preprocessing.minmax_scale(X) #array([[0. , 0. , 0. ], # [0.25, 0.25, 0.25], # [0.5 , 0.5 , 0.5 ], # [0.75, 0.75, 0.75], # [1. , 1. , 1. ]]) # 對比自定義函數計算結果 maxmin_norm(X) #array([[0. , 0. , 0. ], # [0.25, 0.25, 0.25], # [0.5 , 0.5 , 0.5 ], # [0.75, 0.75, 0.75], # [1. , 1. , 1. ]])

• 0-1標準化的評估器實現方法

類似的，我們可以調用評估器進行0-1標準化。

from sklearn.preprocessing import MinMaxScaler MinMaxScaler?scaler = MinMaxScaler() scaler.fit_transform(X) #array([[0. , 0. , 0. ], # [0.25, 0.25, 0.25], # [0.5 , 0.5 , 0.5 ], # [0.75, 0.75, 0.75], # [1. , 1. , 1. ]]) X #array([[ 0, 1, 2], # [ 3, 4, 5], # [ 6, 7, 8], # [ 9, 10, 11], # [12, 13, 14]]) scaler.data_min_ #array([0., 1., 2.]) scaler.data_max_ #array([12., 13., 14.])

此外，sklearn中還有針對稀疏矩陣的標準化（MaxAbsScaler）、針對存在異常值點特征矩陣的標準化（RobustScaler）、以及非線性變化的標準化（Non-linear transformation）等方法，相關內容待后續進行介紹。

3.2 歸一化 Normalization

和標準化不同，sklearn中的歸一化特指將單個樣本（一行數據）放縮為單位范數（1范數或者2范數為單位范數）的過程，該操作常見于核方法或者衡量樣本之間相似性的過程中。這些內容此前我們并未進行介紹，但出于為后續內容做鋪墊的考慮，此處先介紹關于歸一化的相關方法。同樣，歸一化也有函數實現和評估器實現兩種方法。

• 歸一化的函數實現方法

先查看函數相關說明文檔：

preprocessing.normalize?

在Lesson 3.3中曾解釋到關于范數的基本概念，假設向量$x=[x_1,x_2,...,x_n{]}^T$，則向量x的1-范數的基本計算公式為：
$$||x|{|}_1=|x_1|+|x_2|+...+|x_n|$$
即各分量的絕對值之和。而向量x的2-范數計算公式為：
$$||x|{|}_2=\sqrt{(|x_1{|}^2+|x_2{|}^2+...+|x_n{|}^2)}$$
即各分量的平方和再開平方。

而sklearn中的Normalization過程，實際上就是將每一行數據視作一個向量，然后用每一行數據去除以該行數據的1-范數或者2-范數。具體除以哪個范數，以preprocessing.normalize函數中輸入的norm參數為準。

X #array([[ 0, 1, 2], # [ 3, 4, 5], # [ 6, 7, 8], # [ 9, 10, 11], # [12, 13, 14]]) # 1-范數單位化過程 preprocessing.normalize(X, norm='l1') #array([[0. , 0.33333333, 0.66666667], # [0.25 , 0.33333333, 0.41666667], # [0.28571429, 0.33333333, 0.38095238], # [0.3 , 0.33333333, 0.36666667], # [0.30769231, 0.33333333, 0.35897436]]) np.linalg.norm(X, ord=1, axis=1) #array([ 3., 12., 21., 30., 39.]) np.sum(X, axis=1) #array([ 3, 12, 21, 30, 39]) X / np.linalg.norm(X, ord=1, axis=1).reshape(5, 1) #array([[0. , 0.33333333, 0.66666667], # [0.25 , 0.33333333, 0.41666667], # [0.28571429, 0.33333333, 0.38095238], # [0.3 , 0.33333333, 0.36666667], # [0.30769231, 0.33333333, 0.35897436]]) # 2-范數單位化過程 preprocessing.normalize(X, norm='l2') #array([[0. , 0.4472136 , 0.89442719], # [0.42426407, 0.56568542, 0.70710678], # [0.49153915, 0.57346234, 0.65538554], # [0.5178918 , 0.57543534, 0.63297887], # [0.53189065, 0.57621487, 0.62053909]]) np.linalg.norm(X, ord=2, axis=1) #array([ 2.23606798, 7.07106781, 12.20655562, 17.3781472 , 22.56102835]) np.sqrt(np.sum(np.power(X, 2), axis=1)) #array([ 2.23606798, 7.07106781, 12.20655562, 17.3781472 , 22.56102835]) X / np.linalg.norm(X, ord=2, axis=1).reshape(5, 1) #array([[0. , 0.4472136 , 0.89442719], # [0.42426407, 0.56568542, 0.70710678], # [0.49153915, 0.57346234, 0.65538554], # [0.5178918 , 0.57543534, 0.63297887], # [0.53189065, 0.57621487, 0.62053909]])# 范數單位化結果 np.linalg.norm(preprocessing.normalize(X, norm='l2'), ord=2, axis=1) #array([1., 1., 1., 1., 1.])

此外，我們也可以通過調用評估器來實現上述過程：

from sklearn.preprocessing import NormalizerNormalizer?normlize = Normalizer() normlize.fit_transform(X) #array([[0. , 0.4472136 , 0.89442719], # [0.42426407, 0.56568542, 0.70710678], # [0.49153915, 0.57346234, 0.65538554], # [0.5178918 , 0.57543534, 0.63297887], # [0.53189065, 0.57621487, 0.62053909]]) normlize = Normalizer(norm='l1') normlize.fit_transform(X) #array([[0. , 0.33333333, 0.66666667], # [0.25 , 0.33333333, 0.41666667], # [0.28571429, 0.33333333, 0.38095238], # [0.3 , 0.33333333, 0.36666667], # [0.30769231, 0.33333333, 0.35897436]])

4.嘗試使用邏輯回歸評估器

接下來，我們嘗試對上述鳶尾花數據進行邏輯回歸模型多分類預測，需要注意的是，sklearn中的邏輯回歸在默認參數下就支持進行多分類問題判別，并且支持此前介紹的MvM和OvR策略。首先我們先嘗試使用邏輯回歸評估器進行建模：

# 導入邏輯回歸評估器 from sklearn.linear_model import LogisticRegression # 數據準備 X, y = load_iris(return_X_y=True) LogisticRegression?# 實例化模型，使用默認參數 clf_test = LogisticRegression(max_iter=1000, multi_class='multinomial')

此處設置兩個參數，一個是最大迭代次數，另一個則是多分類問題時采用MvM策略。更多參數解釋將在Lesson 6.3中討論。

如不設置multi_class參數，其實默認情況下的auto在此時也會選擇multinomial策略。該策略也是在模型不受其他約束情況下（如優化方法）時auto會默認選擇的策略。

# 帶入全部數據進行訓練 clf_test.fit(X, y) #LogisticRegression(max_iter=1000, multi_class='multinomial') # 查看線性方程系數 clf_test.coef_ #array([[-0.42354204, 0.9673748 , -2.51718519, -1.07940405], # [ 0.5345048 , -0.32156595, -0.20635727, -0.94439435], # [-0.11096276, -0.64580885, 2.72354246, 2.02379841]]) # 在全部數據集上進行預測 clf_test.predict(X)[:10] #array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) # 查看概率預測結果 clf_test.predict_proba(X)[:10] #array([[9.81585264e-01, 1.84147216e-02, 1.44939596e-08], # [9.71339506e-01, 2.86604639e-02, 3.01840948e-08], # [9.85278813e-01, 1.47211746e-02, 1.23337373e-08], # [9.76069526e-01, 2.39304341e-02, 3.96921529e-08], # [9.85236392e-01, 1.47635957e-02, 1.19995412e-08], # [9.70226993e-01, 2.97729326e-02, 7.39546647e-08], # [9.86779074e-01, 1.32209059e-02, 1.99725384e-08], # [9.76150304e-01, 2.38496683e-02, 2.77243996e-08], # [9.79633463e-01, 2.03665062e-02, 3.05952963e-08], # [9.68764573e-01, 3.12353957e-02, 3.17246775e-08]])

上述過程在我們尚未了解邏輯回歸評估器細節時、僅僅將其視作一個評估器、并采用評估器通用方法就完成了建模的全過程，足以看出sklearn的易用性。不過需要知道是，sklearn中的邏輯回歸實際上是一個使用方法非常多樣的模型，我們將在下一小節介紹詳細解釋邏輯回歸模型參數，并借此詳細討論正則化和特征衍生等重要概念。

接下來，我們對模型預測結果進行準確率計算，首先我們可以直接調用評估器的score方法來進行準確率的查看：

clf_test.score(X, y) #0.9733333333333334

當然，我們也可以在metrics模塊中找到準確率計算函數進行準確率計算：

# 進行準確率計算 from sklearn.metrics import accuracy_score accuracy_score(y, clf_test.predict(X)) #0.9733333333333334

5.sklearn中的構建機器學習流

所謂機器學習流，其實就指的是將多個機器學習的步驟串聯在一起，形成一個完整的模型訓練流程。在sklearn中，我們可以借助其make_pipline類的相關功能來實現，當然需要注意的是，sklearn中只能將評估器類進行串聯形成機器學習流，而不能串聯實用函數，并且最終串聯的結果其實也等價于一個評估器。當然，這也從側面說明sklearn評估器內部接口的一致性。接下來，我們就利用sklearn中構建機器學習流的方法將上述數據歸一化、邏輯回歸進行多分類建模等過程串聯在一起，并提前進行數據切分，即執行一個更加完整的機器學習建模流程。

from sklearn.pipeline import make_pipeline make_pipeline?

接下來，可以通過如下方式將模型類進行機器學習流的集成。需要注意的是，只有模型類才能參與構建機器學習流，而實用函數不行。

# 在make_pipeline中輸入評估器的過程同時對評估器類進行參數設置 pipe = make_pipeline(StandardScaler(),LogisticRegression(max_iter=1000))

然后進行數據集切分

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

接下來，我們將pipe對象看成是一個完整的模型類（一個可以先執行Z-Score標準化再進行邏輯回歸建模的模型），直接使用fit對其進行訓練：

pipe.fit(X_train, y_train) #Pipeline(steps=[('standardscaler', StandardScaler()), # ('logisticregression', LogisticRegression(max_iter=1000))])

該過程就相當于兩個評估器都進行了訓練，然后我們即可使用predict方法，利用pipe對數據集進行預測，當然實際過程是先（借助訓練數據的統計量）進行歸一化，然后再進行邏輯回歸模型預測。

pipe.predict(X_test) #array([1, 0, 2, 1, 1, 0, 1, 2, 1, 1, 2, 0, 0, 0, 0, 1, 2, 1, 1, 2, 0, 2, # 0, 2, 2, 2, 2, 2, 0, 0, 0, 0, 1, 0, 0, 2, 1, 0]) pipe.score(X_test, y_test) #1.0 pipe.score(X_train, y_train) #0.9642857142857143

6.sklearn的模型保存

當模型構建完畢之后，我們即可借助joblib包來進行sklearn的模型存儲和讀取，相關功能非常簡單，我們可以使用dump函數進行模型保存，使用load函數進行模型讀取：

import joblib joblib.dump?joblib.dump(pipe,'pipe.model') #['pipe.model'] pipe1 = joblib.load('pipe.model') pipe1.score(X_train, y_train) #0.9642857142857143

以上就是關于sklearn建模的常用功能，基于這些功能，在下一小節開始，我們將從邏輯回歸出發，討論關于正則化、過擬合、特征衍生、特征篩選等非常重要的機器學習相關概念。

總結

以上是生活随笔為你收集整理的Lesson 6. Scikit-Learn使用与进阶的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。