這次我們專門挑了一份爛大街的數據集Titanic，寫了一點關于數據預處理部分，但是代碼風格卻是大(zhuang)佬(bi)級別。很明顯，我不是大佬，不過是有幸被培訓過。

說到預處理，一般就是需要：

• 數字型缺失值處理
• 類別型缺失值處理
• 數字型標準化
• 類別型特征變成dummy變量
• Pipeline 思想

在做數據處理以及機器學習的過程中，最后你會發現每個項目似乎都存在“套路”。所有的項目處理過程都會存在一個“套路”：

• 預處理
• 建模
• 訓練
• 預測

對于預處理，其實也是一個套路，不過我們不用pipeline 函數，而是另一個FeatureUnion函數。

當然一個函數也不能解決所有問題，我們通過實戰來看看哪些函數以及編碼風格能讓我們的代碼看起來很有條理并且“大(zhuang)佬(bi)”風格十足。

導入數據開啟實戰

今天我們分析的titanic 數據，數據我已經下載，并且放在項目路徑下的data 文件中。

import pandas as pd 
file = 'data/titanic_train.csv' 
raw_df = pd.read_csv(file) 

接下來就是標準套路：預覽info以及預覽head。

print(raw_df.info()) 
print(raw_df.head()) 

我們對數據集的名稱進行簡單的回顧：

• RangeIndex: 891 entries, 0 to 890：表示891 個樣本
• columns ：共12 列

按數據類型來劃分：

int64 ：

• PassengerId ：乘客ID
• Survived：是否生存，1 為生存
• Pclass ：乘客級別
• SibSp ：sibling and spouse (兄弟姐妹以及配偶個數)Parch ：parents and children(父母以及子女個數)

object:

• Name: 名字
• Sex：性別
• Ticket ：船票編號
• Cabin：船艙號
• Embarked：登船地點

float64：

• Age：年齡
• Fare 票價

RangeIndex: 891 entries, 0 to 890 
Data columns (total 12 columns): 
 #   Column       Non-Null Count  Dtype   
---  ------       --------------  -----   
 0   PassengerId  891 non-null    int64   
 1   Survived     891 non-null    int64   
 2   Pclass       891 non-null    int64   
 3   Name         891 non-null    object  
 4   Sex          891 non-null    object  
 5   Age          714 non-null    float64 
 6   SibSp        891 non-null    int64   
 7   Parch        891 non-null    int64   
 8   Ticket       891 non-null    object  
 9   Fare         891 non-null    float64 
 10  Cabin        204 non-null    object  
 11  Embarked     889 non-null    object  
dtypes: float64(2), int64(5), object(5) 
memory usage: 83.7+ KB 

一般的機器學習都不會預處理缺失值以及類別型數據，因此我們至少要對這兩種情形做預處理。

首先我們查看缺失值，其實上文中的info已經有這樣的信息。這里我們更顯式的展示缺失信息。

# get null count for each columns 
nulls_per_column = raw_df.isnull().sum() 
print(nulls_per_column) 

結果如下：

PassengerId       0 
Survived             0 
Pclass                 0 
Name                 0 
Sex                     0 
Age                177 
SibSp                  0 
Parch                  0 
Ticket                 0 
Fare                    0 
Cabin             687 
Embarked          2 
dtype: int64 

可以看到Age 有缺失，Age是float64 類型數據，Cabin 有缺失，Cabin 為object 類型，Embarked 有缺失，Embarked 也是object 類型。

主角登場(策略與函數)

上述我們可以看到缺失的列有哪些，對于有些情況，比如快速清理數據，我們僅僅會制定如下策略：

對于float類型，我們一般就是用均值或者中位數來代替 對于object 類型，如果ordinal 類型，也就是嚴格類別之分，比如(男，女)，比如(高，中，低)等，一般就用眾數來替代 對于object 類型，如果nominal類型，也就是沒有等級/嚴格類別關系，比如ID，我們就用常值來替代。本文中用到的是sklearn的preprocessing 模塊，pipeline模塊，以及一個第三方“新秀”sklearn_pandas 庫。

這里我們簡單的介紹這個函數的用途。

StandardScaler： 用于對數字類型做標準化處理 
LabelBinarizer： 顧名思義，將類型類型，先label 化（變成數字），再Binarize （變成二進制）。相當于onehot 編碼，不過LabelBinarizer只是針對一列進行處理 
FeatureUnion：用于將不同特征預處理過程（函數）重新合并，但是需要注意的是它的輸入不是數據而是transformer，也就是預處理的方法。 
SimpleImputer：sklearn 自帶了類似于fillna的預處理函數 
CategoricalImputer： 來自于sklearn_pandas 的補充，因為sklearn 中并沒有針對類別類型數據的預處理。 
DataFrameMapper： 相當于構建針對dataframe的不同的列構建不同的transformer。 
from sklearn.preprocessing import StandardScaler 
from sklearn.preprocessing import LabelBinarizer 
from sklearn.pipeline import FeatureUnion 
from sklearn_pandas import CategoricalImputer 
from sklearn_pandas import DataFrameMapper 
from sklearn.impute import SimpleImputer 

按照我們策略，我們需要將列分為數字型和類別型。思路就是看一列數據是否為object類型。

# split categorical columns and numerical columns 
categorical_mask = (raw_df.dtypes == object) 
categorical_cols = raw_df.columns[categorical_mask].tolist() 
numeric_cols = raw_df.columns[~categorical_mask].tolist() 
numeric_cols.remove('Survived') 
print(f'categorical_cols are {categorical_cols}' ) 
print(f'numeric_cols are {numeric_cols}' ) 

print:

categorical_cols are ['Name', 'Sex', 'Ticket', 'Cabin', 'Embarked'] 
numeric_cols are ['PassengerId', 'Pclass', 'Age', 'SibSp', 'Parch', 'Fare'] 

數值型數據預處理

對數值型數據進行預處理，這里我們采用DataFrameMapper來創建這個transformer 對象，對所有的numeric_cols 進行填寫中值。

numeric_fillna_mapper=DataFrameMapper([([col], SimpleImputer(strategy="median")) for col in numeric_cols], 
                                            input_df=True, 
                                            df_out=True 
                                           ) 

我們可以測試代碼，看一下變換后的數據是什么樣。這里需要調用fit_transform 方法。

transformed = numeric_fillna_mapper.fit_transform(raw_df) 
print(transformed.info()) 

結果如下，可以看到變換后的數據只包含我們處理的列，并且可以看到non-null 個數已經為891，表明沒有缺失。

#   Column       Non-Null Count  Dtype   
--  ------       --------------  -----   
0   PassengerId  891 non-null    float64 
1   Pclass       891 non-null    float64 
2   Age          891 non-null    float64 
3   SibSp        891 non-null    float64 
4   Parch        891 non-null    float64 
5   Fare         891 non-null    float64 

如果我們需要對數值型特征，先進行缺失值填充，然后再進行標準化。這樣我們只需要將上面的函數重新修改，增加一個transformer list。這個transformer list包含SimpleImputer 和StandardScaler 兩步。

# fill nan with mean 
# and then standardize cols 
numeric_fillna_standardize_mapper=DataFrameMapper([([col], [SimpleImputer(strategy="median"), 
                                                StandardScaler()]) for col in numeric_cols], 
                                            input_df=True, 
                                            df_out=True 
                                           ) 
fillna_standardized = numeric_fillna_standardize_mapper.fit_transform(raw_df) 
 
print(fillna_standardized.head()) 

預覽變換后的結果：

   PassengerId       Pclass          Age        SibSp        Parch          Fare 
0    -1.730108  0.827377 -0.565736  0.432793 -0.473674 -0.502445 
1    -1.726220 -1.566107  0.663861  0.432793 -0.473674  0.786845 
2    -1.722332  0.827377 -0.258337 -0.474545 -0.473674 -0.488854 
3    -1.718444 -1.566107  0.433312  0.432793 -0.473674  0.420730 
4    -1.714556  0.827377  0.433312 -0.474545 -0.473674 -0.486337 

這樣我們就完成了數值型數據的預處理。類似的我們可以針對類別型數據進行預處理。

類別型數據預處理

本例中，Cabin 有缺失，Embarked 有缺失，因為這兩者都是有有限類別個數的，我們可以用出現最高頻次的數據進行填充，假如是Name 缺失呢?一般Name都沒有重名的，而且即便有個別重名，用最高頻次的數據進行填充也沒有意義。所以我們會選擇用常數值填充，比如“unknown”等。

作為一個模板，這里我們的處理方法要涵蓋兩種情況。

['Name','Cabin','Ticket'] 其實都類似于ID，幾乎沒有重復的，我們用常值替代，然后用LabelBinarizer變成dummy 變量 其他列，我們用最高頻次的類別填充，然后用LabelBinarizer變成dummy 變量。

# Apply categorical imputer 
 
constant_cols = ['Name','Cabin','Ticket'] 
frequency_cols = [_ for _  in categorical_cols if _ not in constant_cols] 
 
categorical_fillna_freq_mapper = DataFrameMapper( 
                                                [(col, [CategoricalImputer(),LabelBinarizer()]) for col in frequency_cols], 
                                                input_df=True, 
                                                df_out=True 
                                               ) 
 
categorical_fillna_constant_mapper = DataFrameMapper( 
                                                [(col, [CategoricalImputer(strategy='constant',fill_value='unknown'),LabelBinarizer()]) for col in constant_cols], 
                                                input_df=True, 
                                                df_out=True 
                                               ) 

我們同樣進行測試代碼：

transformed = categorical_fillna_freq_mapper.fit_transform(raw_df) 
print(transformed.info()) 
transformed = categorical_fillna_constant_mapper.fit_transform(raw_df) 
print(transformed.shape) 

結果如下：

Data columns (total 4 columns): 
 #   Column      Non-Null Count  Dtype 
---  ------      --------------  ----- 
 0   Sex         891 non-null    int32 
 1   Embarked_C  891 non-null    int32 
 2   Embarked_Q  891 non-null    int32 
 3   Embarked_S  891 non-null    int32 
dtypes: int32(4) 

以及：

(891, 1720) 

featureunion 所有的預處理過程

前面我們已經測試了每一種的預處理的方式(transfomer 或者稱為mapper)，可以看到結果中只包含處理的部分列對應的結果。

實際中，我們可以用FeatureUnion，直接將所有需要處理的方式(transfomer 或者稱為mapper)變成一個pipeline，一目了然。

然后調用fit_transform 對原始數據進行變換，這樣我們的預處理看起來更有條理。

feature_union_1 = FeatureUnion([("numeric_fillna_standerdize", numeric_fillna_standardize_mapper), 
                              ("cat_freq", categorical_fillna_freq_mapper), 
                                ("cat_constant", categorical_fillna_constant_mapper)]) 
 
df_1 = feature_union_1.fit_transform(raw_df) 
 
print(df_1.shape) 
print(raw_df.shape) 

總結

本文介紹了“大佬”級別的數據預處理方式，并且是在實戰中進行演示。

通過本文可以學到：

• 數值型預處理，通過DataFrameMapper 直接對數值類型的列進行多次變換
• 類別型預處理，通過DataFrameMapper 直接對類別型的列進行多次變換
• 類別型變換方法可以至少采用兩種方式
• LabelBinarizer，SimpleImputer，CategoricalImputer，LabelBinarizer等函數對數據 進行變換
• FeatureUnion 來將預處理過程管道化(pipeline) 通過這樣的方式處理數據，會一目了然。