使用這些基本 REST API 最佳實踐構建出色的 API
在SKLearn中，因為做了上層的封裝，分類模型、回歸模型、聚類與降維模型、預處理器等等都叫做估計器(estimator)，就像在Python里『萬物皆對象』，在SKLearn里『萬物皆估計器』。在本篇內容中，我們將給大家進一步深入講解scikit-learn工具庫的使用方法，力求完整覆蓋SKLearn工具庫應用的方方面面。本文的內容板塊包括：
關于本節內容，強烈推薦大家閱讀ShowMeAI文章 圖解機器學習 | 機器學習基礎知識[4] 和 圖解機器學習 | 模型評估方法與準則[5] ，ShowMeAI對相關知識內容展開做了詳細講解。
何為機器學習？大師湯姆米切爾（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。
由上述機器學習的定義可知機器學習包含四個元素：
數據(data)是信息的載體。數據可以有以下劃分方式：
對于非結構數據，通常神經網絡有更好的效果，可以參考 ShowMeAI 的文章Python機器學習算法實踐[6]中的圖像建模例子。機器學習模型很多時候使用的是結構化數據，即二維的數據表。我們這里以 iris 花瓣數據集舉例，如下圖。
下面術語大家在深入了解機器學習前一定要弄清楚：
樣例=(特征,標簽)。
根據學習的任務模式(訓練數據是否有標簽)，機器學習可分為幾大類。上圖畫出機器學習各類之間的關系。
回歸和分類任務中最常見的誤差函數以及一些有用的性能度量如下，詳細內容可以參考ShowMeAI文章 機器學習評估與度量準則[7]。
SKLearn作為通用機器學習建模的工具包，包含六個任務模塊和一個數據導入模塊：
首先看看 SKLearn 默認數據格式和自帶數據集。
Sklearn 里模型能直接使用的數據有兩種形式：
SKLearn 里面有很多自帶數據集供用戶使用。比如在之前文章Python機器學習算法實踐中用到的鳶尾花數據集，包含四個特征(萼片長/寬和花瓣長/寬)和三個類別。
我們可以直接從SKLearn里面的datasets模塊中引入，代碼如下(代碼可以在?線上Jupyter環境[15]?中運行)：
# 導入工具庫
from sklearn.datasets import load_iris
iris = load_iris()
#數據是以『字典』格式存儲的，看看 iris 的鍵有哪些。
iris.keys()
輸出如下：
dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names', 'filename'])
讀取數據集的信息：
#輸出iris 數據中特征的大小、名稱等信息和前五個樣本。
n_samples,?n_features?=?iris.data.shape????
print((n_samples,?n_features))????
print(iris.feature_names)????
print(iris.target.shape)????
print(iris.target_names)
iris.data[0:5]
輸出如下：
(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格式的數據集：
#?將X和y合并為Dataframe格式數據?
import?pandas?as?pd
import?seaborn?as?sns
iris_data?=?pd.DataFrame(?iris.data,?????
??????????????????????????columns=iris.feature_names?)????
iris_data['species']?=?iris.target_names[iris.target]????
iris_data.head(3).append(iris_data.tail(3))
輸出如下：
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 來做一些數據分析，查看一下數據的分布特性。這里使用到的是成對維度的關聯分析，關于seaborn的使用方法可以參閱ShowMeAI的文章?seaborn工具與數據可視化教程[16]。
#?使用Seaborn的pairplot查看兩兩特征之間的關系
sns.pairplot(?iris_data,?hue='species',?palette='husl'?)
前面提到的是鳶尾花iris數據集，我們通過load_iris加載進來，實際上SKLearn有三種引入數據形式。
sklearn.datasets.load_*sklearn.datasets.fetch_*sklearn.datasets.make_*上面這個星號*指代具體文件名，如果大家在Jupyter這種IDE環境中，可以通過tab制表符自動補全和選擇。
比如我們調用load_iris
from sklearn import datasets
datasets.load_iris輸出如下：
<function?sklearn.datasets.base.load_iris(return_X_y=False)>
我們調用load_digits加載手寫數字圖像數據集
digits?=?datasets.load_digits()
digits.keys()
輸出：
dict_keys(['data',?'target',?'target_names',?'images',?'DESCR'])
我們再來看看通過fetch拉取數據的示例：
#加州房屋數據集
california_housing?=?datasets.fetch_california_housing()????
california_housing.keys()
輸出：
dict_keys(['data',?'target',?'feature_names',?'DESCR'])我們前面提到SKLearn里萬物皆估計器。估計器是個非常抽象的叫法，不嚴謹的一個理解，我們可以視其為一個模型(用來回歸、分類、聚類、降維)，或一套流程(預處理、網格搜索交叉驗證)。
本節三大API其實都是估計器：
任何可以基于數據集對一些參數進行估計的對象都被稱為估計器，它有兩個核心點：
估計器首先被創建，然后被擬合。
normalize=Truen_clusters=5model.fit(X_train, y_train)model.fit(X_train)擬合之后可以訪問model里學到的參數，比如線性回歸里的特征系數coef，或K均值里聚類標簽labels，如下(具體的可以在SKLearn文檔的每個模型頁查到)。
model.coef_model.labels_下面看看監督學習的『線性回歸』和無監督學習的『K均值聚類』的具體例子。
首先從SKLearn工具庫的linear_model中引入LinearRegression；創建模型對象命名為model，設置超參數normalize為True（在每個特征值上做標準化，這樣能保證擬合的穩定性，加速模型擬合速度）。
from?sklearn.linear_model?import?LinearRegression
model?=?LinearRegression(normalize=True)
model
輸出：
LinearRegression(copy_X=True,?fit_intercept=True,?n_jobs=None,?normalize=True)
創建完后的估計器會顯示所有的超參數（比如剛才設置的normalize=True），未設置的超參數都使用默認值。自己創建一個簡單數據集（一條直線上的數據點），簡單講解一下估計器里面的特征。
import?numpy?as?np
import?matplotlib.pyplot?as?plt
x?=?np.arange(10)????
y?=?2?*?x?+?1????
plt.plot(?x,?y,?'o'?)
在我們生成的數據里，X是一維，我們做一點小小的調整，用np.newaxis加一個維度，把[1,2,3]轉成[[1],[2],[3]]，這樣的數據形態可以符合sklearn的要求。接著把X和y送入fit()函數來擬合線性模型的參數。
X?=?x[:,?np.newaxis]????
model.fit(?X,?y?)
輸出為：
LinearRegression(copy_X=True,?fit_intercept=True,?n_jobs=None,?normalize=True)
擬合完后的估計器和創建完似乎沒有差別，但我們已經可以用model.param_訪問到擬合完數據的參數了，如下代碼
。print(?model.coef_?)????
print(?model.intercept_?)
#?輸出結果
#?[2.]
#?0.9999999999999982
我們來看看聚類[17]的例子，先從SKLearn的cluster中導入KMeans，初始化模型對象命名為model，設置超參數n_cluster為3(為了展示方便而我們知道用的iris數據集有3類，實際上可以設置不同數量的n_cluster)。
雖然iris數據里包含標簽y，但在無監督的聚類中我們不會使用到這個信息。
from?sklearn.cluster?import?KMeans????
model?=?KMeans(?n_clusters=3?)????
model
輸出為：
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數據集包含四維特征(萼片長、萼片寬、花瓣長、花瓣寬)，在下面的例子中我們希望可視化，這里我們簡單選取兩個特征(萼片長、萼片寬)來做聚類并且可視化結果。
注意下面代碼
X = iris.data[:,0:2]其實就是提取特征維度。
from?sklearn.datasets?import?load_iris????
iris?=?load_iris()
X?=?iris.data[:,0:2]????
model.fit(X)
輸出為：
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)
擬合完后的估計器和創建完似乎沒有差別，但我們已經可以用model.param_訪問到擬合完數據的參數了，如下代碼。
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模型這幾個參數：
model.clustercenters：簇中心。三個簇意味著有三個坐標。model.labels_：聚類后的標簽。model.inertia_：所有點到對應的簇中心的距離平方和(越小越好)雖然上面以有監督學習的Linear Regression和無監督學習的KMeans舉例，但實際上你可以將它們替換成其他別的模型，比如監督學習的Logistic Regression和無監督學習的DBSCAN。它們都是『估計器』，因此都有fit()方法。使用它們的通用偽代碼如下：
# 有監督學習
from sklearn.xxx import SomeModel
# xxx 可以是 linear_model 或 ensemble 等
model = SomeModel( hyperparameter )
model.fit( X, y )
# 無監督學習
from sklearn.xxx import SomeModel
# xxx 可以是 cluster 或 decomposition 等
model = SomeModel( hyperparameter )
model.fit( X )預測器是估計器做的一個延展，具備對數據進行預測的功能。
預測器最常見的是predict()函數：
model.predict(X_test)：評估模型在新數據上的表現。model.predict(X_train)：確認模型在老數據上的表現。為了進行新數據評估，我們先將數據分成80:20的訓練集(X_train, y_train)和測試集(X_test, y_test)，再用從訓練集上擬合fit()的模型在測試集上預測predict()。
from?sklearn.datasets?import?load_iris????
iris?=?load_iris()
from?sklearn.model_selection?import?train_test_split????
X_train,?X_test,?y_train,?y_test?=?train_test_split(?iris['data'],?????
????????????????????iris['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?)
The?size?of?X_train?is??(120,?4)
The?size?of?y_train?is??(120,)
The?size?of?X_test?is??(30,?4)
The?size?of?y_test?is??(30,)對于分類問題，我們不僅想知道預測的類別是什么，有時我們還希望獲取預測概率等信息。前者用?predict()，后者用predict_proba()。
y_pred?=?model.predict(?X_test?)
p_pred?=?model.predict_proba(?X_test?)
print(?y_test,?'\n'?)
print(?y_pred,?'\n'?)
print(?p_pred?)預測器里還有額外的兩個函數可以使用。在分類問題中：
score()返回的是分類準確率。decision_function()返回的是每個樣例在每個類下的分數值。print( model.score( X_test, y_test ) )
print( np.sum(y_pred==y_test)/len(y_test) )
decision_score = model.decision_function( X_test )
print( decision_score )估計器都有fit()方法，預測器都有predict()和score()方法，言外之意不是每個預測器都有predict_proba()和decision_function()方法，這個在用的時候查查官方文檔就清楚了(比如RandomForestClassifier就沒有decision_function()方法)。使用它們的通用偽代碼如下：
# 有監督學習
from sklearn.xxx import SomeModel
# xxx 可以是 linear_model 或 ensemble 等
model = SomeModel( hyperparameter )
model.fit( X, y )
y_pred = model.predict( X_new )
s = model.score( X_new )
# 無監督學習
from sklearn.xxx import SomeModel
# xxx 可以是 cluster 或 decomposition 等
model = SomeModel( hyperparameter )
model.fit( X )
idx_pred = model.predict( X_new )
s = model.score( X_new )轉換器是一種估計器，也有擬合功能，對比預測器做完擬合來預測，轉換器做完擬合來轉換。核心點如下：
fit + predictfit + transform
本節介紹兩大類轉換器：
① LabelEncoder&OrdinalEncoderLabelEncoder和OrdinalEncoder都可以將字符轉成數字，但是：
# 首先給出要編碼的列表 enc 和要解碼的列表 dec。
enc = ['red','blue','yellow','red']
dec = ['blue','blue','red']
# 從sklearn下的preprocessing中引入LabelEncoder，再創建轉換器起名LE，不需要設置任何超參數。
from sklearn.preprocessing import LabelEncoder
LE = LabelEncoder()
print(LE.fit(enc))
print( LE.classes_ )
print( LE.transform(dec) )
LabelEncoder()
['blue' 'yellow' 'red']
[0 1 2]
除了LabelEncoder，OrdinalEncoder也可以完成編碼。如下代碼所示：
from?sklearn.preprocessing?import?OrdinalEncoder????
OE?=?OrdinalEncoder()????
enc_DF?=?pd.DataFrame(enc)????
dec_DF?=?pd.DataFrame(dec)????
print(?OE.fit(enc_DF)?)????
print(?OE.categories_?)????
print(?OE.transform(dec_DF)?)
OrdinalEncoder(categories='auto',?dtype=<class?'numpy.float64'>)
[array(['blue',?'yellow',?'red'],?dtype=object)]
[[0.]
?[1.]
?[2.]]
上面這種編碼的問題是，在編碼過后會帶來不同類別的大小關系，比如這里3種顏色其實本質上是平等的，沒有大小關系。
我們的另外一種類別型數據編碼方式，獨熱向量編碼(one-hot encoding)可以解決這個問題，大家繼續往下看。
② OneHotEncoder
獨熱向量編碼其實就是把一個整數用向量的形式表現。上圖右側就是對顏色做獨熱向量編碼。轉換器OneHotEncoder可以接受兩種類型的輸入：
一、用LabelEncoder編碼好的一維數組(元素為整數)，重塑(用reshape(-1,1))成二維數組作為OneHotEncoder輸入。
from?sklearn.preprocessing?import?OneHotEncoder????
OHE?=?OneHotEncoder()????
num?=?LE.fit_transform(?enc?)????
print(?num?)????
OHE_y?=?OHE.fit_transform(?num.reshape(-1,1)?)????
OHE_y
[2?0?1?2]
輸出為：
<4x3?sparse?matrix?of?type?'<class?'numpy.float64'>'
????with?4?stored?elements?in?Compressed?Sparse?Row?format>
上面結果解釋如下：
想看該矩陣里具體內容，用toarray()函數。
OHE_y.toarray()
輸出為：array([[0.,?0.,?1.],
???????[1.,?0.,?0.],
???????[0.,?1.,?0.],
???????[0.,?0.,?1.]])
二、用DataFrame作為OneHotEncoder輸入。
OHE?=?OneHotEncoder()????
OHE.fit_transform(?enc_DF?).toarray()
輸出為：array([[0.,?0.,?1.],
???????[1.,?0.,?0.],
???????[0.,?1.,?0.],
???????[0.,?0.,?1.]])數據要做的最重要的轉換之一是特征縮放(feature scaling)。類似邏輯回歸，神經網絡這種計算型模型，對于不同特征的幅度大小差異是敏感的。具體來說，對于某個特征，我們有兩種變換方法：
① MinMaxScaler
如上圖所示，MinMaxScaler會根據特征的最大最小取值，對數據進行幅度縮放。
from?sklearn.preprocessing?import?MinMaxScaler????
X?=?np.array(?[0,?0.5,?1,?1.5,?2,?100]?)????
X_scale?=?MinMaxScaler().fit_transform(?X.reshape(-1,1)?)????
X_scale
輸出為：
array([[0.???],
???????[0.005],
???????[0.01?],
???????[0.015],
???????[0.02?],
???????[1.???]])
② StandardScaler
StandardScaler做的事情是調整數據分布，盡量接近正態分布。
from?sklearn.preprocessing?import?StandardScaler????
X_scale?=?StandardScaler().fit_transform(?X.reshape(-1,1)?)????
X_scale
輸出為：
array([[-0.47424487],
???????[-0.46069502],
???????[-0.44714517],
???????[-0.43359531],
???????[-0.42004546],
???????[?2.23572584]])注意：
fit()函數只能作用在訓練集上，如果希望對測試集變換，只要用訓練集上fit好的轉換器去transform即可。不能在測試集上fit再transform，否則訓練集和測試集的變換規則不一致，模型學習到的信息就無效了。
我們在這節中給大家介紹SKLearn的『高級API』，即五大元估計器（集成功能的Ensemble，多分類和多標簽的Multiclass，多輸出的Multioutput，選擇模型的Model Selection，流水線的Pipeline）。
ensemble.BaggingClassifierensemble.VotingClassifiermulticlass.OneVsOneClassifiermulticlass.OneVsRestClassifiermultioutput.MultiOutputClassifiermodel_selection.GridSearchCVmodel_selection.RandomizedSearchCVpipeline.Pipeline
如上圖：分類器統計每個子分類器的預測類別數，再用『多數投票』原則得到最終預測。回歸器計算每個子回歸器的預測平均值。最常用的Ensemble估計器排列如下：
AdaBoostClassifier：逐步提升分類器AdaBoostRegressor：逐步提升回歸器BaggingClassifier：Bagging分類器BaggingRegressor：Bagging回歸器GradientBoostingClassifier：梯度提升分類器GradientBoostingRegressor：梯度提升回歸器RandomForestClassifier：隨機森林分類器RandomForestRegressor：隨機森林回歸器VotingClassifier：投票分類器VotingRegressor：投票回歸器我們用鳶尾花數據iris，拿以下estimator來舉例：
RandomForestClassifierVotingClassifier首先將數據分成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)
隨機森林RandomForestClassifier通過控制n_estimators超參數來決定基估計器的個數，在這里是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()。下面看看隨機森林里包含的估計器個數和其本身。
print(?RF.n_estimators?)????
RF.estimators_
輸出為：
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%。
print ( "RF - Accuracy (Train): %.4g" %
metrics.accuracy_score(y_train, RF.predict(X_train)) )
print ( "RF - Accuracy (Test): %.4g" %
metrics.accuracy_score(y_test, RF.predict(X_test)) )RF - Accuracy (Train): 1
RF - Accuracy (Test): 0.9667三個分類器的集成模型。
和隨機森林由同質分類器『決策樹』不同，投票分類器由若干個異質分類器組成。下面我們用VotingClassifier建立個含有邏輯回歸(Logistic regression)、隨機森林(RandomForest)和高斯樸素貝葉斯(GNB)三個分類器的集成模型。
RandomForestClassifier的基分類器只能是決策樹，因此只用通過控制n_estimators超參數來決定樹的個數，而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集成模型里包含的估計器個數和其本身。
print(?len(Ensemble.estimators_)?)????????
Ensemble.estimators_
結果如下：
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)]
對比元估計器和它三個組成元素的表現，下過表現如下：
#?擬合
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
sklearn.multiclass可以處理多類別(multi-class) 的多標簽(multi-label) 的分類問題。下面我們會使用數字數據集digits作為示例數據來講解。我們先將數據分成 80:20 的訓練集和測試集。
#?導入數據
from?sklearn.datasets?import?load_digits?????????????????
digits?=?load_digits()????????
digits.keys()
輸出如下：
#?輸出結果
dict_keys(['data',?'target',?'target_names','images',?'DESCR'])下面我們切分數據集：
#?數據集切分
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?)
輸出如下
The?size?of?X_train?is?(1437,?64)
The?size?of?y_train?is?(1437,)
The?size?of?X_test?is?(360,?64)
The?size?of?y_test?is?(360,)
訓練集和測試集分別有1437和360張圖像。每張照片是包含8×8的像素，我們用flatten操作把2維的8×8展平為1維的64。
看看訓練集中前100張圖片和對應的標簽（如下圖）。像素很低，但基本上還是能看清。
fig,?axes?=?plt.subplots(?10,?16,?figsize=(8,?8)?)
fig.subplots_adjust(?hspace=0.1,?wspace=0.1?)
for?i,?ax?in?enumerate(?axes.flat?):
????ax.imshow(?X_train[i,:].reshape(8,8),?cmap='binary’,?interpolation='nearest’)
????ax.text(?0.05,?0.05,?str(y_train[i]),
????transform=ax.transAxes,?color='blue')
????ax.set_xticks([])
????ax.set_yticks([])
手寫數字有0-9十類，但手頭上只有二分類估計器（比如像支撐向量機）怎么用呢？我們可以采取以下策略處理：
① OneVsOneClassifier
考慮一個具體天氣多分類問題，天氣可以是晴天、陰天和雨天，在OvO中，三個分類器為f1、f2和f3。
在下圖的例子中，f1和f2都預測為橙色，f3預測為紫色。根據多數原則得到的結合預測為橙色，如下圖所示。
回到數字分類問題上，代碼及結果如下：
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分類器。
print(?len(ovo_lr.estimators_)?)????????
ovo_lr.estimators_
結果如下：
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中，把數據分成“某個”和“其他”
三分類分解成三個二分類，對應的分類器為f1、f2和f3。
三個分類器都預測了紫色，根據多數原則得到的預測是紫色，即陰天。
回到數字分類問題上，代碼和結果如下：
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分類器。
print( len(ova_lr.estimators_) )
ova_lr.estimators_結果如下：
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到目前為止，所有的樣例都總是被分配到僅一個類。有些情況下，你也許想讓分類器給一個樣例輸出多個類別。在無人駕駛的應用中，在下圖識別出有車和指示牌，沒有交通燈和人。
物體識別是一個復雜的深度學習問題，我們在這里暫且不深入探討。我們先看一個簡單點的例子，在手寫數字的例子上，我們特意為每個數字設計了兩個標簽：
我們構建多標簽y_train_multilabel，代碼如下（OneVsRestClassifier也可以用來做多標簽分類）：
from sklearn.multiclass import OneVsRestClassifier
y_train_multilabel = np.c_[y_train%2==0, y_train<=4 ]
print(y_train_multilabel)
[[ True True] [False False] [False False]
...
[False False] [False False] [False False]]看下圖訓練集第1和2個圖片是數字4和5，對應上面兩種標簽結果為：
我們這次用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)有兩個估計器，每個對應一個標簽。
print( len(ova_ml.estimators_) )
ova_ml.estimators_運行結果如下：
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([])
第一張圖片是數字2，它是偶數(標簽1為true)，小于等于4(標簽2為true)。
print( y_test[:1] )
print( ova_ml.predict(X_test[:1,:]) )
[2]
[[1 1]]sklearn.multioutput可以處理多輸出(multi-output)的分類問題。
多輸出分類是多標簽分類的泛化，在這里每一個標簽可以是多類別(大于兩個類別)的。一個例子就是預測圖片每一個像素(標簽)的像素值是多少(從0到255的256個類別)。
Multioutput估計器有兩個：
**MultiOutputRegressor**：多輸出回歸**MultiOutputClassifier**：多輸出分類這里我們只關注多輸出分類。
首先引入MultiOutputClassifier和RandomForestClassifier。
from sklearn.multioutput import MultiOutputClassifier
from sklearn.ensemble import RandomForestClassifier在手寫數字的例子上，我們也為特意每個數字設計了多標簽而且每個標簽的類別都大于二。
代碼如下：
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)看看這個模型在測試集前五張照片上的預測。
MO.predict( X_test[:5,:] )
array([[0, 2],[0, 2],[0, 0],[2, 9],[1, 5]])這個ndarray第一列是標簽1的類別，第二列是標簽2的類別。預測結果是這五張照片分別顯示數字2、2、0、9、5(標簽2)，它們前三個數2、2、0都小于等于4(標簽1第一類)，第四個數9大于等于7(標簽1第二類)，而第五個數5在4和7之間(標簽1第三類)。
再看看真實標簽。
y_test_1st = y_test.copy()
y_test_1st[ y_test<=4 ] = 0
y_test_1st[ np.logical_and(y_test>4, y_test<7) ] = 1
y_test_1st[ y_test>=7 ] = 2
y_test_multioutput = np.c_[ y_test_1st, y_test ]
y_test_multioutput[:5]
array([[0, 2],[0, 2],[0, 0],[2, 9],[1, 5]])對比參考結果標簽，模型預測的結果還是很不錯的。
模型選擇(Model Selction)在機器學習非常重要，它主要用于評估模型表現，常見的Model Selection估計器有以下幾個：
**cross_validate**：評估交叉驗證的結果。**learning_curve**：構建與繪制學習曲線。**GridSearchCV**：用交叉驗證從超參數候選網格中搜索出最佳超參數。**RandomizedSearchCV**：用交叉驗證從一組隨機超參數搜索出最佳超參數。這里我們只關注調節超參數的兩個估計器，即GridSearchCV和RandomizedSearchCV。我們先回顧一下交叉驗證（更詳細的講解請查看ShowMeAI文章 圖解機器學習 | 模型評估方法與準則）。
K-折交叉驗證(K-fold cross validation set)，指的是把整個數據集平均但隨機分成K份，每份大概包含m/K個數據(m 是總數據數)。
在這K份，每次選K-1份作為訓練集擬合參數，在剩下1份驗證集上進行評估計算。由于遍歷了這K份數據，因此該操作稱為交叉驗證。操作如下圖所示
下圖展示了兩個調參的估計器：『網格搜索』和『隨機搜索』。
網格搜索調參：參數1在[1,10,100,1000]中取值，參數2在[0.01, 0.1, 1 10] 中取值，注意并不是等間距取值。模型在所有16組超參數上實驗，選取交叉驗證誤差最小的參數。
隨機搜索調參：根據指定分布隨機搜索，可以選擇獨立于參數個數，比如log(參數1)服從0到3的均勻分布，log(參數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這里我們對代碼做一個解釋：
運行結果里：
在本例中，隨機搜索比網格搜索用更短時間內找到一組超參數，獲得了更高的得分。
Pipeline估計器又叫流水線，把各種估計器串聯(Pipeline)或并聯(FeatureUnion)的方式組成一條龍服務。用好了它真的能大大提高效率。
Pipeline將若干個估計器按順序連在一起，比如：特征提取 → 降維 → 擬合 → 預測
Pipeline的屬性永遠和最后一個估計器屬性一樣：
下面是一個簡單示例，使用Pipeline來完成『填補缺失值-標準化』這兩步的。我們先構建含缺失值NaN的數據X。
X = np.array([[56,40,30,5,7,10,9,np.NaN,12],
[1.68,1.83,1.77,np.NaN,1.9,1.65,1.88,np.NaN,1.75]])
X = np.transpose(X)我們用以下流程組件構建Pipeline：
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import MinMaxScaler
pipe = Pipeline([
('impute', SimpleImputer(missing_values=np.nan, strategy='mean')),
('normalize', MinMaxScaler())])第5-7行創建了流水線，使用方式非常簡單，在Pipeline()里輸入(名稱,估計器)這個元組構建的流水線列表。在本例中SimpleImputer起名叫impute，MinMaxScaler起名叫normalize。
因為最后一個估計器是轉換器，因此pipeline也是個轉換器。下面我們來運行一下，我們發現值都被填滿了，而且兩列也被標準化了。
X_proc = pipe.fit_transform( X )來驗證上面流水線的參數，我們可以按順序來運行這兩個轉換器，結果是一樣的。
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 ]])如果我們想在一個節點同時運行幾個估計器，我們可用FeatureUnion。在下面的例子中，我們首先建立一個DataFrame數據，它有如下特點：
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結果如下：
我們現在按下列步驟來清洗數據。
上面兩步是并行進行的。
首先我們自己定義一個從DataFrame里面獲取數據列的類，起名叫DataFrameSelector。
from sklearn.base import BaseEstimator, TransformerMixin
class DataFrameSelector( BaseEstimator, TransformerMixin ):
def _init_( self, attribute_names ):
self.attribute_names = attribute_names
def fit( self, X, y=None ):
return self
def transform( self, X ):
return X[self.attribute_names].values上述代碼在transform函數中，我們將輸入的DataFrame X根據屬性名稱來獲取其值。
接下來建立流水線full_pipe，它并聯著兩個流水線
代碼如下：
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. ]]下面我們對上面講解到的sklearn工具庫應用知識做一個總結。
SKLearn的設計下，它的主要API遵循五大原則
所有對象的接口一致且簡單，在『估計器』中
**model = Constructor(hyperparam)****model.fit(X_train, y_train)****model.fit(X_train)**在『預測器』中
**y_pred = model.predict(X_test)****idx_pred = model.predict( Xtest)**在『轉換器』中
**trm = Constructor(hyperparam)****trm.fit(X_train)****X_trm = trm.transform(X_train)**所有估計器里設置的超參數和學到的參數都可以通過實例的變量直接訪問來檢驗其值，區別是超參數的名稱最后沒有下劃線，而參數的名稱最后有下劃線。舉例如下：
**model.hyperparameter****SVC.kernel****model.parameter_****SVC.support_vectors_**SKLearn模型接受的數據集的格式只能是『Numpy數組』和『Scipy稀疏矩陣』。超參數的格式只能是『字符』和『數值』。不接受其他的類！
模塊都能重復『連在一起』或『并在一起』使用，比如兩種形式流水線(pipeline)
SKLearn給大多超參數提供了合理的默認值，大大降低了建模的難度。
sklearn的建模應用流程框架大概如下：
是『有監督』的分類或回歸？還是『無監督』的聚類或降維？確定好后基本就能知道用Sklearn里哪些模型了。
這步最繁瑣，要處理缺失值、異常值；要編碼類別型變量；要正規化或標準化數值型變量，等等。但是有了Pipeline神器一切變得簡單高效。
這步最簡單，訓練用估計器fit()先擬合，評估用預測器predict()來評估。
啟動ModelSelection估計器里的GridSearchCV和RandomizedSearchCV，選擇得分最高的那組超參數(即模型)。
[1] SKLearn入門與簡單應用案例: https://www.showmeai.tech/article-detail/202
[2] SKLearn官網: https://scikit-learn.org/stable/
[3] AI建模工具速查|Scikit-learn使用指南: https://www.showmeai.tech/article-detail/108
[4] 圖解機器學習 | 機器學習基礎知識: https://www.showmeai.tech/article-detail/185
[5] 圖解機器學習 | 模型評估方法與準則: https://www.showmeai.tech/article-detail/186
[6] Python機器學習算法實踐: https://www.showmeai.tech/article-detail/201
[7] 機器學習評估與度量準則: https://www.showmeai.tech/article-detail/186
[8] 監督學習：分類任務: https://scikit-learn.org/stable/supervised_learning.html#supervised-learning
[9] 監督學習：回歸任務: https://scikit-learn.org/stable/supervised_learning.html#supervised-learning
[10] 無監督學習：聚類任務: https://scikit-learn.org/stable/modules/clustering.html#clustering
[11] 無監督學習：降維任務: https://scikit-learn.org/stable/modules/decomposition.html#decompositions
[12] 模型選擇任務: https://scikit-learn.org/stable/model_selection.html#model-selection
[13] 數據預處理任務: https://scikit-learn.org/stable/modules/preprocessing.html#preprocessing
[14] 數據導入模塊: https://scikit-learn.org/stable/datasets.html
[15] 線上Jupyter環境: https://jupyter.org/try
[16] seaborn工具與數據可視化教程: https://www.showmeai.tech/article-detail/151
[17] 聚類: https://www.showmeai.tech/article-detail/197
文章轉自微信公眾號@算法進階