Pipeline, ColumnTransformer和FeatureUnion

時間 2020-10-22

標籤 html python git github sql app dom 機器學習工具學習欄目設計模式简体版

原文原文鏈接

做者|Zolzaya Luvsandorj
編譯|VK
來源|Towards Datas Sciencehtml

掌握sklearn必須知道這三個強大的工具。所以，在創建機器學習模型時，學習如何有效地使用這些方法是相當重要的。python

在深刻討論以前，咱們先從兩個方面着手：git

Transformer：Transformer是指具備fit()和transform()方法的對象，用於清理、減小、擴展或生成特徵。簡單地說，transformers幫助你將數據轉換爲機器學習模型所需的格式。OneHotEncoder和MinMaxScaler就是Transformer的例子。github
Estimator：Estimator是指機器學習模型。它是一個具備fit()和predict()方法的對象。咱們將交替使用模型和Estimator這2個術語。該連接是一些Estimator的例子：https://scikit-learn.org/stable/tutorial/machine_learning_map/index.html。sql

安裝

若是你想在你電腦上運行代碼，確保你已經安裝了pandas，seaborn和sklearn。我在Jupyter notebook中在python3.7.1中編寫腳本。app

讓咱們導入所需的庫和數據集。關於這個數據集(包括數據字典)的詳細信息能夠在這裏找到(這個源其實是針對R的，可是它彷佛引用了相同的底層數據集)：https://vincentarelbundock.github.io/Rdatasets/doc/reshape2/tips.html。dom

# 設置種子
seed = 123

# 爲數據導入包/模塊
import pandas as pd
from seaborn import load_dataset

# 爲特徵工程和建模導入模塊
from sklearn.model_selection import train_test_split
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.preprocessing import OneHotEncoder, MinMaxScaler
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline, FeatureUnion
from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LinearRegression

# 加載數據集
df = load_dataset('tips').drop(columns=['tip', 'sex']).sample(n=5, random_state=seed)

# 添加缺失的值
df.iloc[[1, 2, 4], [2, 4]] = np.nan
df

使用少許的記錄能夠很容易地監控每一個步驟的輸入和輸出。所以，咱們將只使用數據集中5條記錄的樣本。機器學習

管道

假設咱們想用smoker、day和time列來預測總的帳單。咱們將先刪除size列並對數據進行劃分：工具

# 劃分數據
X_train, X_test, y_train, y_test = train_test_split(df.drop(columns=['total_bill', 'size']), 
                                                    df['total_bill'], 
                                                    test_size=.2, 
                                                    random_state=seed)

一般狀況下，原始數據不是咱們能夠直接將其輸入機器學習模型的狀態。所以，將數據轉換爲可接受且對模型有用的狀態成爲建模的必要先決條件。讓咱們作如下轉換做爲準備：學習

用「missing」填充缺失值
one-hot編碼

如下完成這兩個步驟：

# 輸入訓練數據
imputer = SimpleImputer(strategy='constant', fill_value='missing')
X_train_imputed = imputer.fit_transform(X_train)

# 編碼訓練數據
encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
X_train_encoded = encoder.fit_transform(X_train_imputed)

# 檢查訓練先後的數據
print("******************** Training data ********************")
display(X_train)
display(pd.DataFrame(X_train_imputed, columns=X_train.columns))
display(pd.DataFrame(X_train_encoded, columns=encoder.get_feature_names(X_train.columns)))

# 轉換測試數據
X_test_imputed = imputer.transform(X_test)
X_test_encoded = encoder.transform(X_test_imputed)

# 檢查測試先後的數據
print("******************** Test data ********************")
display(X_test)
display(pd.DataFrame(X_test_imputed, columns=X_train.columns))
display(pd.DataFrame(X_test_encoded, columns=encoder.get_feature_names(X_train.columns)))

你可能已經注意到，當映射回測試數據集的列名時，咱們使用了來自訓練數據集的列名。這是由於我更喜歡使用來自於訓練Transformer的數據的列名。可是，若是咱們使用測試數據集，它將給出相同的結果。

對於每一個數據集，咱們首先看到原始數據，而後是插補後的輸出，最後是編碼後的輸出。

這種方法能夠完成任務。可是，咱們將上一步的輸出做爲輸入手動輸入到下一步，而且有多個臨時輸出。咱們還必須在測試數據上重複每一步。隨着步驟數的增長，維護將變得更加繁瑣，更容易出錯。

咱們可使用管道編寫更精簡和簡潔的代碼：

# 將管道與訓練數據匹配
pipe = Pipeline([('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
                 ('encoder', OneHotEncoder(handle_unknown='ignore', sparse=False))])
pipe.fit(X_train)

# 檢查訓練先後的數據
print("******************** Training data ********************")
display(X_train)
display(pd.DataFrame(pipe.transform(X_train), columns=pipe['encoder'].get_feature_names(X_train.columns)))

# 檢查測試先後的數據
print("******************** Test data ********************")
display(X_test)
display(pd.DataFrame(pipe.transform(X_test), columns=pipe['encoder'].get_feature_names(X_train.columns)))

使用管道時，每一個步驟都將其輸出做爲輸入傳遞到下一個步驟。所以，咱們沒必要手動跟蹤數據的不一樣版本。這種方法爲咱們提供了徹底相同的最終輸出，可是使用了更優雅的代碼。

在查看了轉換後的數據以後，如今是在咱們的示例中添加模型的時候了。讓咱們從爲第一種方法添加一個簡單模型：

# 輸入訓練數據
imputer = SimpleImputer(strategy='constant', fill_value='missing')
X_train_imputed = imputer.fit_transform(X_train)

# 編碼訓練數據
encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
X_train_encoded = encoder.fit_transform(X_train_imputed)

# 使模型擬合訓練數據
model = LinearRegression()
model.fit(X_train_encoded, y_train)

# 預測訓練數據
y_train_pred = model.predict(X_train_encoded)
print(f"Predictions on training data: {y_train_pred}")

# 轉換測試數據
X_test_imputed = imputer.transform(X_test)
X_test_encoded = encoder.transform(X_test_imputed)

# 預測測試數據
y_test_pred = model.predict(X_test_encoded)
print(f"Predictions on test data: {y_test_pred}")

咱們將對管道方法進行一樣的處理：

# 將管道與訓練數據匹配
pipe = Pipeline([('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
                 ('encoder', OneHotEncoder(handle_unknown='ignore', sparse=False)), 
                 ('model', LinearRegression())])
pipe.fit(X_train, y_train)

# 預測訓練數據
y_train_pred = pipe.predict(X_train)
print(f"Predictions on training data: {y_train_pred}")

# 預測測試數據
y_test_pred = pipe.predict(X_test)
print(f"Predictions on test data: {y_test_pred}")

你可能已經注意到，一旦咱們訓練了一條管道，進行預測是多麼簡單。pipe.predict(X)對原始數據進行轉換，而後返回預測。也很容易看到步驟的順序。讓咱們直觀地總結一下這兩種方法：

使用管道不只能夠組織和簡化代碼，並且還有許多其餘好處，下面是其中一些好處：

微調管道的能力：當構建一個模型時，你可能須要嘗試不一樣的方法來預處理數據並再次運行模型，看看預處理步驟中的調整是否能提升模型的泛化能力。在優化模型時，微調不只存在於模型的超參數中，並且存在於預處理步驟的實現中。考慮到這一點，當咱們有一個統一了Transformer和Estimator的管道對象時，咱們能夠微調整個管道的超參數，包括使用GridSearchCV或RandomizedSearchCV的Estimator和兩個Transformer。
更容易部署：在訓練模型時用於準備數據的全部轉換步驟在進行預測時也能夠應用於生產環境中的數據。當咱們訓練管道時，咱們訓練一個包含數據轉換器和模型的對象。一旦通過訓練，這個管道對象就能夠用於更平滑的部署。

ColumnTransformer

在前面的例子中，咱們以相同的方式對全部列進行插補和編碼。可是，咱們常常須要對不一樣的列組應用不一樣的transformer。例如，咱們但願將OneHotEncoder僅應用於分類列，而不該用於數值列。這就是ColumnTransformer的用武之地。

這一次，咱們將對保留全部列的數據集進行分區，以便同時具備數值和類別特徵。

# 劃分數據
X_train, X_test, y_train, y_test = train_test_split(df.drop(columns=['total_bill']), 
                                                    df['total_bill'], 
                                                    test_size=.2, 
                                                    random_state=seed)

# 定義分類列
categorical = list(X_train.select_dtypes('category').columns)
print(f"Categorical columns are: {categorical}")

# 定義數字列
numerical = list(X_train.select_dtypes('number').columns)
print(f"Numerical columns are: {numerical}")

咱們根據數據類型將特徵分爲兩組。列分組能夠根據數據的適當狀況進行。例如，若是不一樣的預處理管道更適合分類列，則能夠將它們進一步拆分爲多個組。

上一節的代碼如今將再也不工做，由於咱們有多個數據類型。讓咱們看一個例子，其中咱們使用ColumnTransformer和Pipeline在存在多個數據類型的狀況下執行與以前相同的轉換。

# 定義分類管道
cat_pipe = Pipeline([('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
                     ('encoder', OneHotEncoder(handle_unknown='ignore', sparse=False))])

# 使ColumnTransformer擬合訓練數據
preprocessor = ColumnTransformer(transformers=[('cat', cat_pipe, categorical)], 
                                 remainder='passthrough')
preprocessor.fit(X_train)

# 準備列名
cat_columns = preprocessor.named_transformers_['cat']['encoder'].get_feature_names(categorical)
columns = np.append(cat_columns, numerical)

# 檢查訓練先後的數據
print("******************** Training data ********************")
display(X_train)
display(pd.DataFrame(preprocessor.transform(X_train), columns=columns))

# 檢查測試先後的數據
print("******************** Test data ********************")
display(X_test)
display(pd.DataFrame(preprocessor.transform(X_test), columns=columns))

分類列的輸出與上一節的輸出相同。惟一的區別是這個版本有一個額外的列：size。咱們已經將cat_pipe(在上一節中稱爲pipe)傳遞給ColumnTransformer來轉換分類列，並指定remainment='passthrough'以保持其他列不變。

讓咱們用中值填充缺失值，並將其縮放到0和1之間：

# 定義分類管道
cat_pipe = Pipeline([('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
                     ('encoder', OneHotEncoder(handle_unknown='ignore', sparse=False))])

# 定義數值管道
num_pipe = Pipeline([('imputer', SimpleImputer(strategy='median')),
                     ('scaler', MinMaxScaler())])

# 使ColumnTransformer擬合訓練數據
preprocessor = ColumnTransformer(transformers=[('cat', cat_pipe, categorical),
                                               ('num', num_pipe, numerical)])
preprocessor.fit(X_train)

# 準備列名
cat_columns = preprocessor.named_transformers_['cat']['encoder'].get_feature_names(categorical)
columns = np.append(cat_columns, numerical)

# 檢查訓練先後的數據
print("******************** Training data ********************")
display(X_train)
display(pd.DataFrame(preprocessor.transform(X_train), columns=columns))

# 檢查測試先後的數據
print("******************** Test data ********************")
display(X_test)
display(pd.DataFrame(preprocessor.transform(X_test), columns=columns))

如今全部列都被插補，範圍在0到1之間。使用ColumnTransformer和Pipeline，咱們將數據分紅兩組，將不一樣的管道和不一樣的Transformer應用到每組，而後將結果粘貼在一塊兒：

儘管在咱們的示例中，數值管道和分類管道中的步驟數相同，但管道中能夠有任意數量的步驟，而且不一樣列子集的步驟數沒必要相同。如今咱們將一個模型添加到咱們的示例中：

# 定義分類管道
cat_pipe = Pipeline([('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
                     ('encoder', OneHotEncoder(handle_unknown='ignore', sparse=False))])

# 定義數值管道
num_pipe = Pipeline([('imputer', SimpleImputer(strategy='median')),
                     ('scaler', MinMaxScaler())])

# 組合分類管道和數值管道
preprocessor = ColumnTransformer(transformers=[('cat', cat_pipe, categorical),
                                               ('num', num_pipe, numerical)])

# 在管道上安裝transformer和訓練數據的estimator
pipe = Pipeline(steps=[('preprocessor', preprocessor),
                       ('model', LinearRegression())])
pipe.fit(X_train, y_train)

# 預測訓練數據
y_train_pred = pipe.predict(X_train)
print(f"Predictions on training data: {y_train_pred}")

# 預測測試數據
y_test_pred = pipe.predict(X_test)
print(f"Predictions on test data: {y_test_pred}")

爲了將ColumnTransformer中指定的預處理步驟與模型結合起來，咱們在外部使用了一個管道。如下是它的視覺表現：

當咱們須要對不一樣的列子集執行不一樣的操做時，ColumnTransformer很好地補充了管道。

FeatureUnion

如下代碼的輸出在本節中被省略，由於它們與ColumnTransformer章節的輸出相同。

FeatureUnion是另外一個有用的工具。它能夠作ColumnTransformer剛剛作過的事情，但要作得更遠：

# 自定義管道
class ColumnSelector(BaseEstimator, TransformerMixin):
    """Select only specified columns."""
    def __init__(self, columns):
        self.columns = columns
        
    def fit(self, X, y=None):
        return self
    
    def transform(self, X):
        return X[self.columns]

# 定義分類管道
cat_pipe = Pipeline([('selector', ColumnSelector(categorical)),
                     ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
                     ('encoder', OneHotEncoder(handle_unknown='ignore', sparse=False))])

# 定義數值管道
num_pipe = Pipeline([('selector', ColumnSelector(numerical)),
                     ('imputer', SimpleImputer(strategy='median')),
                     ('scaler', MinMaxScaler())])

# FeatureUnion擬合訓練數據
preprocessor = FeatureUnion(transformer_list=[('cat', cat_pipe),
                                              ('num', num_pipe)])
preprocessor.fit(X_train)

# 準備列名
cat_columns = preprocessor.transformer_list[0][1][2].get_feature_names(categorical)
columns = np.append(cat_columns, numerical)

# 檢查訓練先後的數據
print("******************** Training data ********************")
display(X_train)
display(pd.DataFrame(preprocessor.transform(X_train), columns=columns))

# 檢查測試先後的數據
print("******************** Test data ********************")
display(X_test)
display(pd.DataFrame(preprocessor.transform(X_test), columns=columns))

咱們能夠將FeatureUnion視爲建立數據的副本，並行地轉換這些副本，而後將結果粘貼在一塊兒。這裏的術語副本更像是一種輔助概念化的類比，而不是實際採用的技術。

在每一個管道的開始，咱們添加了一個額外的步驟，在這裏咱們使用一個定製的轉換器來選擇相關的列：第14行和第19行的ColumnSelector。下面是咱們可視化上面的腳本的圖：

如今，是時候向腳本添加模型了：

# 定義分類管道
cat_pipe = Pipeline([('selector', ColumnSelector(categorical)),
                     ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
                     ('encoder', OneHotEncoder(handle_unknown='ignore', sparse=False))])

# 定義數值管道
num_pipe = Pipeline([('selector', ColumnSelector(numerical)),
                     ('imputer', SimpleImputer(strategy='median')),
                     ('scaler', MinMaxScaler())])

# 組合分類管道和數值管道
preprocessor = FeatureUnion(transformer_list=[('cat', cat_pipe),
                                              ('num', num_pipe)])

# 組合分類管道和數值管道
pipe = Pipeline(steps=[('preprocessor', preprocessor),
                       ('model', LinearRegression())])
pipe.fit(X_train, y_train)

# 預測訓練數據
y_train_pred = pipe.predict(X_train)
print(f"Predictions on training data: {y_train_pred}")

# 預測測試數據
y_test_pred = pipe.predict(X_test)
print(f"Predictions on test data: {y_test_pred}")

它看起來很像咱們用ColumnTransformer作的。

如本例所示，使用FeatureUnion比使用ColumnTransformer要複雜得多。所以，在我看來，在相似的狀況下最好使用ColumnTransformer。

然而，FeatureUnion確定有它的位置。若是你須要以不一樣的方式轉換相同的輸入數據並將它們用做特徵，FeatureUnion就是其中之一。例如，若是你正在處理一個文本數據，而且但願對數據進行tf-idf矢量化以及提取文本長度，FeatureUnion是一個完美的工具。