數據預處理是在各類算法的使用前對數據進行一定的操作糠悯，讓數據能在訓練中得到更好的使用效果，而數據有很多種，如連續(xù)型特征數據较木，分類型的特征數據（也稱離散型）等等，因此預處理有很多種方法青柄，依次可分為以下幾種：

Standardization伐债，or mean removal and variance scaling（標準化、去均值和方差按比例縮放）
Non-linear transformation（非線性轉換）
Normalization（歸一化）
Feature binarization（特征二值化）
Encoding categorical features（分類特征編碼）
Imputation of missing values（缺失值插補）
Generating polynomial features（生成多項式特征）
Custom transformers（自定義轉換器）

在介紹這些方法的開頭致开，為了方便峰锁，先將某大佬的經驗總結貼在這里：

首先要明確有多少特征，哪些是連續(xù)的喇喉，哪些是類別的祖今。
檢查有沒有缺失值，對確實的特征選擇恰當方式進行彌補拣技，使數據完整千诬。
對連續(xù)的數值型特征進行標準化，使得均值為0膏斤，方差為1徐绑。
對類別型的特征進行one-hot編碼。
將需要轉換成類別型數據的連續(xù)型數據進行二值化莫辨。
為防止過擬合或者其他原因傲茄，選擇是否要將數據進行正則化。
在對數據進行初探之后發(fā)現效果不佳沮榜，可以嘗試使用多項式方法盘榨，尋找非線性的關系。
根據實際問題分析是否需要對特征進行相應的函數轉換蟆融。

Standardization草巡，or mean removal and variance scaling（標準化、去均值和方差按比例縮放）

目的：讓特征擁有零均值和單位方差型酥，以在未來的訓練中達到更好的效果

實現方式：

放縮scale

1 >>> from sklearn import preprocessing
2 >>> import numpy as np
3 >>> X_train = np.array([[ 1., -1.,  2.],
4 ...                     [ 2.,  0.,  0.],
5 ...                     [ 0.,  1., -1.]])
6 >>> X_scaled = preprocessing.scale(X_train)
7 
8 >>> X_scaled                                          
9 array([[ 0\.  ..., -1.22... ,  1.33...],
10       [ 1.22... ,  0\.  ..., -0.26...],
11       [-1.22... ,  1.22... , -1.06...]])

經過縮放后的數據具有零均值以及標準方差

1 >>> X_scaled.mean(axis=0)
2 array([ 0.,  0.,  0.])
3 
4 >>> X_scaled.std(axis=0)
5 array([ 1.,  1.,  1.])

另一種實現方式：
- StandardScaler模塊
  - 它實現了轉化器的API來計算訓練集上的平均值和標準偏差山憨，以便以后能夠在測試集上重新應用相同的變換
  - 這是相當好的一個功能∶趾恚可以對訓練數據郁竟，測試數據應用相同的轉換，以后有新的數據進來也可以直接調用由境，不用再重新把數據放在一起再計算一次了
- 使用方法
  - 調用fit方法棚亩，根據已有的訓練數據創(chuàng)建一個標準化的轉換器
```
1 >>> scaler = preprocessing.StandardScaler().fit(X_train)
2 >>> scaler
3 StandardScaler(copy=True, with_mean=True, with_std=True)
```
  - 使用上面這個轉換器去轉換訓練數據x,調用transform方法
```
1 >>> scaler.transform(X_train)                           
2 array([[ 0\...., -1.22...,  1.33...],
3       [ 1.22...,  0\. ..., -0.26...],
4       [-1.22...,  1.22..., -1.06...]])
```
  - 比如現在又來了一組新的樣本，也想得到相同的轉換
```
1 >>> X_test = [[-1., 1., 0.]]
2 >>> scaler.transform(X_test)                
3 array([[-2.44...,  1.22..., -0.26...]])
```
- 注意：StandardScaler()中可以傳入兩個參數：with_mean,with_std.這兩個都是布爾型的參數虏杰，默認情況下都是true,但也可以自定義成false.即不要均值中心化或者不要方差規(guī)募ン。化為1.

實踐操作

驗證縮放情況

1 >>>from sklearn import preprocessing
2 >>>import numpy as np
3 >>>y = np.array([[ 1., 0.,  0.],
4                  [ 2., 0.,  0.],
5                  [ 0., 0.,  0.]])
6 >>>y_scaled = preprocessing.scale(y)
7 >>>y_scaled
8 array([[ 0.        ,  0.        ,  0.        ],
9        [ 1.22474487,  0.        ,  0.        ],
10       [-1.22474487,  0.        ,  0.        ]]

再看一個例子

1 >>>z = np.array([[ 1., 0.,  1.],
2                  [ 0., 1.,  2.],
3                  [ 0., 0.,  0.]])
4 >>>z_scaled = preprocessing.scale(z)
5 >>>z_scaled
6 array([[ 1.41421356, -0.70710678,  0.        ],
7        [-0.70710678,  1.41421356,  1.22474487],
8        [-0.70710678, -0.70710678, -1.22474487]])

可以明顯發(fā)現，放縮scale是按照列為單位進行放縮嘹屯，中心點始終為0攻询，而大小規(guī)模是根據數值進而讓方差為1才算出來的

驗證均值和方差是否為0和1

1 >>>y_scaled.mean(axis=0)
2 array([0., 0., 0.])
3 >>>y_scaled.std(axis=0)
4 array([1., 0., 0.])
5 >>>z_scaled.mean(axis=0)
6 array([7.40148683e-17, 7.40148683e-17, 0.00000000e+00])
7 >>>z_scaled.std(axis=0)
8 array([1., 1., 1.])

注：上面的7.40148683e-17十分接近于0，所以可以視為其均值為0

驗證StandarScaler

第一個例子

1 >>>scaler = preprocessing.StandardScaler().fit(y)
2 >>>scaler
3 StandardScaler(copy=True, with_mean=True, with_std=True)
4 >>>scaler.transform(y)
5 array([[ 0.        ,  0.        ,  0.        ],
6        [ 1.22474487,  0.        ,  0.        ],
7        [-1.22474487,  0.        ,  0.        ]])
8 >>>scaler.transform(z)
9 array([[ 0.        ,  0.        ,  1.        ],
10       [-1.22474487,  1.        ,  2.        ],
11       [-1.22474487,  0.        ,  0.        ]])

第二個例子

1 >>>new_scaler = preprocessing.StandardScaler().fit(z)
2 >>>new_scaler
3 StandardScaler(copy=True, with_mean=True, with_std=True)
4 >>>new_scaler.transform(y)
5 array([[ 1.41421356, -0.70710678, -1.22474487],
6        [ 3.53553391, -0.70710678, -1.22474487],
7        [-0.70710678, -0.70710678, -1.22474487]])
8 >>>new_scaler.transform(z)
9 array([[ 1.41421356, -0.70710678,  0.        ],
10       [-0.70710678,  1.41421356,  1.22474487],
11       [-0.70710678, -0.70710678, -1.22474487]])

由此可以發(fā)現州弟，調用fit方法創(chuàng)建的標準的轉換器钧栖，其傳入的數據作為標準，然后transform的數據都會根據原先的數據標準計算標準化后的值婆翔，即如果訓練的是z拯杠，transform的數據是y，則y的第一列會按照z的第一列的均值和方差計算啃奴，第二列會按照z的第二列潭陪，以此類推，另外，如果transform的列數大于訓練的列數依溯，則會報錯

將特征縮放到指定范圍

將特征放縮到最大值和最小值之間老厌，通常是0和1之間

MinMaxScaler
公式
- 縮放后數據： $x _ { s t d } = \frac { x - x _ { \min } } { x _ { \max } - x _ { \min } }$

代碼實例：

  1 >>> X_train = np.array([[ 1., -1.,  2.],
  2 ...                     [ 2.,  0.,  0.],
  3 ...                     [ 0.,  1., -1.]])
  4 ...
  5 >>> min_max_scaler = preprocessing.MinMaxScaler()
  6 >>> X_train_minmax = min_max_scaler.fit_transform(X_train)
  7 >>> X_train_minmax
  8 array([[ 0.5        ,  0\.        ,  1\.        ],
  9        [ 1\.        ,  0.5        ,  0.33333333 ],
 10        [ 0\.        ,  1\.        ,  0\.        ]])

當有新的測試數據進來，也可以進行相同的數據轉換

  1 >>> X_test = np.array([[ -3., -1.,  4.]])
  2 >>> X_test_minmax = min_max_scaler.transform(X_test)
  3 >>> X_test_minmax
  4 array([[-1.5       ,  0\.        ,  1.66666667]])

可以檢查縮放器（scaler）屬性黎炉，來觀察在訓練集中學習到的轉換操作的基本性質

  1 >>> min_max_scaler.scale_                             
  2 array([ 0.5       ,  0.5       ,  0.33...])
  3 
  4 >>> min_max_scaler.min_                               
  5 array([ 0\.        ,  0.5       ,  0.33...])

將每個特征的最大絕對值轉換至單位大小

MaxAbsScaler
工作原理和MinMaxScaler非常相似枝秤，但是它只通過除以每個特征的最大值將訓練數據特征縮放至【-1,1】區(qū)間內，這就意味著慷嗜，訓練數據應該是已經零中心化或者是稀疏數據淀弹，即這個方法對中心化均值為0的數據或者稀疏的數據有意義
公式
- $x _ { n e w } = \frac { x } { x _ { \max } }$

代碼實例

  1 >>> X_train = np.array([[ 1., -1.,  2.],
  2 ...                     [ 2.,  0.,  0.],
  3 ...                     [ 0.,  1., -1.]])
  4 ...
  5 >>> max_abs_scaler = preprocessing.MaxAbsScaler()
  6 >>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
  7 >>> X_train_maxabs           # doctest +NORMALIZE_WHITESPACE^
  8 array([[ 0.5 , -1\. ,  1\. ],
  9        [ 1\. ,  0\. ,  0\. ],
 10        [ 0\. ,  1\. , -0.5]])

當有新的測試數據進來

  1 >>> X_test = np.array([[ -3., -1.,  4.]])
  2 >>> X_test_maxabs = max_abs_scaler.transform(X_test)
  3 >>> X_test_maxabs                 
  4 array([[-1.5, -1\. ,  2\. ]])

檢查放縮器的屬性

  1 >>> max_abs_scaler.scale_         
  2 array([ 2.,  1.,  2.])

注意：在 scale 模塊中進一步提供了方便的功能。當你不想創(chuàng)建對象時庆械，可以使用如 minmax_scale 以及 maxabs_scale

縮放稀疏矩陣
- 中心化稀疏(矩陣)數據會破壞數據的稀疏結構薇溃，但是縮放稀疏輸入還是有意義的，尤其是當幾個特征在不同的量級范圍時缭乘，而MaxAbsScaler 以及 maxabs_scale 是專為縮放數據而設計的沐序，并且是縮放數據的推薦方法；但是忿峻， scale 和 StandardScaler 也能夠接受 scipy.sparse 作為輸入薄啥，只要參數 with_mean=False 被準確傳入它的構造器。否則會出現 ValueError 的錯誤逛尚，因為默認的中心化會破壞稀疏性垄惧，并且經常會因為分配過多的內存而使執(zhí)行崩潰。
縮放有離群值的數據
- 如果你的數據包含許多異常值绰寞，使用均值和方差縮放可能并不是一個很好的選擇到逊，這種情況下，你可以使用 robust_scale 以及 RobustScaler 作為替代品滤钱。它們對你的數據的中心和范圍使用更有魯棒性的估計觉壶。

Non-linear transformation（非線性轉換）

類似于縮放， QuantileTransformer 類是將每個特征都縮放在同樣的范圍或分布情況下件缸，不再是單個特征的縮放了
- 好處：通過執(zhí)行一個秩轉換能夠使異常的分布平滑化铜靶，并且能夠比縮放更少地受到離群值的影響
- 壞處：使特征間及特征內的關聯和距離失真
QuantileTransformer類與quantile_transform函數提供了一個基于分位數函數的無參數轉換
- 將數據映射到了0到1的均勻分布上
  - 我們以iris數據集為例
    - 將數據集導入，并且進行劃分
```
 1 >>> from sklearn.datasets import load_iris
 2 >>> from sklearn.model_selection import train_test_split
 3 >>> iris = load_iris()
 4 >>> X, y = iris.data, iris.target
 5 >>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
```
    - 對訓練集部分進行非線性轉換
```
 1 quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
 2 >>> X_train_trans = quantile_transformer.fit_transform(X_train)
 3 >>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
 4 array([ 4.3,  5.1,  5.8,  6.5,  7.9])
```
      - 注：np.percentile()是對數據進行分位數處理他炊，即X_train[:, 0]先選擇了X_train的第一列所有數據争剿，然后np.percentile()選擇了排序后的0%、25%痊末、50%蚕苇、75%和100%的數據元素，總的來說凿叠，這就是一種抽查數據的手段
      - 注：X_train[:, 0]選擇的第一列數據是指的萼片的厘米單位的長度涩笤，上面的輸出結果array([ 4.3, 5.1, 5.8, 6.5, 7.9])是未經過轉換的原數據
        1 >>> np.percentile(X_train_trans[:, 0], [0, 25, 50, 75, 100]) 2 array([ 0.00... , 0.24..., 0.49..., 0.73..., 0.99... ])
      - 可以發(fā)現嚼吞，經過分位數轉換后，所有的數據都被映射到了【0,1】的范圍內
    - 對訓練集部分進行非線性轉換
```
 1 quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
 2 >>> X_train_trans = quantile_transformer.fit_transform(X_train)
 3 >>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
 4 array([ 4.3,  5.1,  5.8,  6.5,  7.9])
```
      - 注：np.percentile()是對數據進行分位數處理蹬碧，即X_train[:, 0]先選擇了X_train的第一列所有數據舱禽，然后np.percentile()選擇了排序后的0%、25%锰茉、50%呢蔫、75%和100%的數據元素，總的來說，這就是一種抽查數據的手段
      - 注：X_train[:, 0]選擇的第一列數據是指的萼片的厘米單位的長度距辆，上面的輸出結果array([ 4.3, 5.1, 5.8, 6.5, 7.9])是未經過轉換的原數據
```
 1 >>> np.percentile(X_train_trans[:, 0], [0, 25, 50, 75, 100])
 2 array([ 0.00... ,  0.24...,  0.49...,  0.73...,  0.99... ])
```
      - 可以發(fā)現城榛，經過分位數轉換后，所有的數據都被映射到了【0,1】的范圍內
    - 對測試集部分進行同樣的轉換
```
1 >>> np.percentile(X_test[:, 0], [0, 25, 50, 75, 100])
2 array([ 4.4  ,  5.125,  5.75 ,  6.175,  7.3  ])
3 >>> np.percentile(X_test_trans[:, 0], [0, 25, 50, 75, 100])
4 array([ 0.01...,  0.25...,  0.46...,  0.60... ,  0.94...])
```
- 將轉換后的數據映射到正態(tài)分布
  - 方法：通過設置 output_distribution='normal'
  - 代碼：
```
  1 >>> quantile_transformer = preprocessing.QuantileTransformer(
  2 ...     output_distribution='normal', random_state=0)
 3 >>> X_trans = quantile_transformer.fit_transform(X)
 4 >>> quantile_transformer.quantiles_ 
 5 array([[ 4.3 ...,  2   ...,  1   ...,  0.1...],
 6        [ 4.31...,  2.02...,  1.01...,  0.1...],
 7        [ 4.32...,  2.05...,  1.02...,  0.1...],
 8          ...
 9        [ 7.84...,  4.34...,  6.84...,  2.5...],
10        [ 7.87...,  4.37...,  6.87...,  2.5...],
11        [ 7.9 ...,  4.4 ...,  6.9 ...,  2.5...]])
```
- 注意：輸入的中值稱為輸出的平均值喻频，并且以0為中心。正常輸出被剪切，使得輸入的最小和最大值分別對應于1e-7和1-1e-7分位數——在變換下不會變得無限大

Normalization（歸一化肤晓，也稱正則化）

歸一化是縮放單個樣本以讓其具有單位范數的過程，它是將樣本在向量空間模型上的一個轉換认然，經常被使用在分類與聚類中

實現方式：normalize函數

函數 normalize 提供了一個快速簡單的方法在類似數組的數據集上執(zhí)行操作补憾，使用 l1 或 l2 范式

代碼實現：

  1 >>> X = [[ 1., -1.,  2.],
  2 ...      [ 2.,  0.,  0.],
  3 ...      [ 0.,  1., -1.]]
  4 >>> X_normalized = preprocessing.normalize(X, norm='l2')
  5 
  6 >>> X_normalized                                      
  7 array([[ 0.40 ..., -0.40...,  0.81...],
  8        [ 1\.  ...,  0\. ...,  0\. ...],
  9        [ 0\.  ...,  0.70..., -0.70...]])

注意：代碼中使用的是L2范式，其公式為 $x _ { i j } ^ { \prime } = \frac { x _ { i j } } { \sqrt { \sum _ { i } \left( x _ { i j } \right) ^ { 2 } } }$

另一種實現方式：
- preprocessing這個模塊還提供了一個實用類Normalizer,實用transform方法同樣也可以對新的數據進行同樣的轉換
- 代碼實現：
  - 根據訓練數據創(chuàng)建一個歸一化的轉換器
```
 1 >>> normalizer = preprocessing.Normalizer().fit(X)  # fit does nothing
 2 >>> normalizer
 3 Normalizer(copy=True, norm='l2') 
```
  - 對訓練數據進行歸一化
```
1 >>> normalizer.transform(X)                            
2 array([[ 0.40...,  -0.40...,   0.81...],
3        [ 1\. ...,   0\. ...,   0\. ...],
4        [ 0\. ...,   0.70...,  -0.70...]]) 
```
  - 對新的測試數據進行歸一化
```
1 >>> normalizer.transform([[-1.,  1., 0.]])             
2 array([[-0.70...,  0.70...,  0\.  ...]])
```
- 注意：函數 normalize 和類 Normalizer 接收來自scipy.sparse的密集類數組數據和稀疏矩陣作為輸入卷员，但對于稀疏的輸入數據盈匾，在被提交給高效Cython例程前，數據被轉化為壓縮的稀疏行形式

Feature binarization（特征二值化）

特征二值化是將數值特征用閾值過濾得到布爾值的過程

實現方法：Binarizer

代碼實現：

1 >>> X = [[ 1., -1.,  2.],
2 ...      [ 2.,  0.,  0.],
3 ...      [ 0.,  1., -1.]]
4 
5 >>> binarizer = preprocessing.Binarizer().fit(X)  # fit does nothing
6 >>> binarizer
7 Binarizer(copy=True, threshold=0.0)
8 
9 >>> binarizer.transform(X)
10 array([[ 1.,  0.,  1.],
11        [ 1.,  0.,  0.],
12        [ 0.,  1.,  0.]])

注：可以發(fā)現毕骡，Binarizer函數默認的閾值是0削饵，所以樣本x所有小于等于0的值全部為0，大于0的值全部為1未巫，變成了一個布爾型的數據集

也可以為二值化器賦一個閾值

1 >>> binarizer = preprocessing.Binarizer(threshold=1.1)
2 >>> binarizer.transform(X)
3 array([[ 0.,  0.,  1.],
4        [ 1.,  0.,  0.],
5        [ 0.,  0.,  0.]])

注意：
- 相比于前面的放縮 StandardScaler 和歸一化 Normalizer 類的情況窿撬，預處理模塊還提供了一個相似的函數 binarize ，以便不需要轉換接口時可以使用
- binarize 和 Binarizer 可以接收來自scipy.sparse的密集類數組數據和稀疏矩陣作為輸入叙凡。其中對于稀疏輸入劈伴，數據被轉化為壓縮的稀疏行形式

Encoding categorical features（分類特征編碼）

我們知道特征可能是連續(xù)型的也可能是類別型的變量，比如說
- 對于一個人握爷，他可能的特征有以下
  - 性別：["male", "female"]
  - 洲：["from Europe", "from US", "from Asia"]
  - 瀏覽器使用：["uses Firefox", "uses Chrome", "uses Safari", "uses Internet Explorer"]
- 如果跛璧，我們簡單的對這些分類型的特征進行編碼，比如將洲特征中的"from Europe"編碼為0饼拍，"from US"編碼為1, "from Asia"編碼為2赡模，然后我們綜合起來，對某單個樣本的數據["male", "from US", "uses Internet Explorer"]可以編碼為[0,1,3]师抄，["female", "from Asia", "uses Chrome"] 可以編碼為[1, 2, 1]漓柑，雖然這樣實現了編碼，但這樣的整數特征并不能在scikit-learn的估計器中直接使用，因為這樣的連續(xù)輸入辆布，估計器會認為類別之間是有序的瞬矩，但實際卻是無序的，比如洲之間的類別數據可能是隨意排序的

實現方法：

一種將分類特征轉換為能夠被scikit-learn中模型使用的編碼是one-of-K或one-hot編碼锋玲，在 OneHotEncoder 中實現景用，它可以將有n種值的一個特征變成n個二元的特征
例如下表：

特征洲經過one-hot編碼的模樣
- 因此，如果經過了one-hot編碼惭蹂，那么一個人的洲特征是from US伞插，那么它對應的編碼就是010，其他以此類推

代碼實現：

1 >>> enc = preprocessing.OneHotEncoder()
2 >>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])  
3 OneHotEncoder(categorical_features='all', dtype=<... 'numpy.float64'>,
4  handle_unknown='error', n_values='auto', sparse=True)

5 >>> enc.transform([[0, 1, 3]]).toarray()
6 array([[ 1.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  1.]])

注：上面的數據結果中盾碗，前兩位數值表明性別編碼媚污，緊接著中間的三位數值表明洲編碼，最后的四位數值表示瀏覽器編碼（如果看不明白廷雅，可以把代碼中fit的數字想象成漢字或英文即可耗美，或者看下面的一個例子）

再舉個簡單的實現例子：

創(chuàng)建數據

  1 >>>enc = preprocessing.OneHotEncoder()
  2 >>>import pandas as pd
  3 >>>data = [['male'  ,'us' ],
  4            ['female','eur'],
  5            ['female','asi']] 
  6 >>>x = pd.DataFrame(data)
  7 >>>x
  8         0      1
  9   0    male    us
 10   1   female  eur
 11   2   female  asi

進行one-hot編碼

  1 >>>enc.fit(x)
  2 OneHotEncoder(categorical_features=None, categories=None,
  3        dtype=<class 'numpy.float64'>, handle_unknown='error',
  4        n_values=None, sparse=True)

選取樣本數據進行測試

  1 >>>y = x.iloc[:1,:]
  2 >>>y
  3         0      1
  4   0   male    us

  5 >>>enc.transform(y).toarray()
  6 array([[0., 1., 0., 0., 1.]])

注意：默認情況下，每個特征使用幾維的數值由數據集自動推斷航缀，當然商架，你也可以通過使用參數n_values來精確指明每個特征中值的總個數，另外芥玉，如果訓練集中有丟失的分類特征值蛇摸，必須顯式地設置 n_values

舉例如下

1 >>> enc = preprocessing.OneHotEncoder(n_values=[2, 3, 4])
2 >>> # 注意下面fit的數據，其中第二飞傀、三個特征是不全的 
3 >>> # features 

4 >>> enc.fit([[1, 2, 3], [0, 2, 0]])  
5 OneHotEncoder(categorical_features='all', dtype=<... 'numpy.float64'>,
6  handle_unknown='error', n_values=[2, 3, 4], sparse=True)

7 >>> enc.transform([[1, 0, 0]]).toarray()
8 array([[ 0.,  1.,  1.,  0.,  0.,  1.,  0.,  0.,  0.]])

Imputation of missing values（缺失值插補）

許多數據集都包含缺失數據皇型，這類數據經常被編碼成空格、NaNs砸烦，或者是其他的占位符弃鸦，但是這樣的數據集并不能scikit-learn學習算法兼容，因為大多的學習算法都默認假設數組中的元素都是數值幢痘。所以唬格，使用不完整的數據集的一個基本策略就是舍棄掉整行或整列包含缺失值的數據。但是這樣就付出了舍棄可能有價值數據（即使是不完整的）的代價颜说。因此购岗，處理缺失數值的一個更好的策略就是從已有的數據推斷出缺失的數值。
目的：減少數據價值的損失

實現方法：Imputer

Imputer類提供了估算缺失值的基本策略门粪，它可以使用缺失值所在的行or列中的平均值喊积、中位數或者眾數來填充。

代碼實現：

訓練一個數據

1 >>> import numpy as np
2 >>> from sklearn.preprocessing import Imputer
3 >>> imp = Imputer(missing_values='NaN', strategy='mean', axis=0)
4 >>> imp.fit([[1, 2], [np.nan, 3], [7, 6]])
5 Imputer(axis=0, copy=True, missing_values='NaN', strategy='mean', verbose=0)

以fit的填補策略填補新的數據集中的缺失值

1 >>> X = [[np.nan, 2], [6, np.nan], [7, 6]]
2 >>> print(imp.transform(X))                           
3 [[ 4\.          2\.        ]
4  [ 6\.          3.666…     ]
5  [ 7\.          6\.        ]]

注意玄妈，該代碼演示的是如何使用包含缺失值的列(軸0)的平均值來替換編碼為 np.nan 的缺失值乾吻，其中新的數據集填充的平均值是fit方法里的列平均值

Imputer 類也支持稀疏矩陣

舉例

  1 >>> import scipy.sparse as sp
  2 >>> X = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
  3 >>> imp = Imputer(missing_values=0, strategy='mean', axis=0)
  4 >>> imp.fit(X)
  5 Imputer(axis=0, copy=True, missing_values=0, strategy='mean', verbose=0)

  6 >>> X_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
  7 >>> print(imp.transform(X_test))                      
  8 [[ 4\.          2\.        ]
  9  [ 6\.          3.666...   ]
 10  [ 7\.          6\.        ]]

注意髓梅，矩陣中的缺失值被編碼為0，隱式地存儲在了矩陣中绎签，而填補的時候還是用的fit的數據

Generating polynomial features（生成多項式特征）

在機器學習中枯饿，通過增加一些輸入數據的非線性特征來增加模型的復雜度通常是有用的，一個簡單通用的辦法是使用多項式特征诡必，這可以獲得特征的更高維度和互相間關系的項

實現方法：PolynomialFeatures

比如：將

X

的特征從

(x_1,x_2)

轉換為

（1,x_1,x_2,x_1^2,x_1 x_2,x_2^2）

1 >>> import numpy as np
2 >>> from sklearn.preprocessing import PolynomialFeatures
3 >>> X = np.arange(6).reshape(3, 2)
4 >>> X                                                 
5 array([[0, 1],
6        [2, 3],
7        [4, 5]])
8 >>> poly = PolynomialFeatures(2)
9 >>> poly.fit_transform(X)                             
10 array([[  1.,   0.,   1.,   0.,   0.,   1.],
11        [  1.,   2.,   3.,   4.,   6.,   9.],
12        [  1.,   4.,   5.,  16.,  20.,  25.]])

在一些情況下奢方，如果只需要特征間的交互項，這可以通過設置 interaction_only=True 來得到

 1 >>> X = np.arange(9).reshape(3, 3)
 2 >>> X                                                 
 3 array([[0, 1, 2],
 4  [3, 4, 5],
 5  [6, 7, 8]])
 6 >>> poly = PolynomialFeatures(degree=3, interaction_only=True)
 7 >>> poly.fit_transform(X)                             
 8 array([[   1.,    0.,    1.,    2.,    0.,    0.,    2.,    0.],
 9        [   1.,    3.,    4.,    5.,   12.,   15.,   20.,   60.],
10        [   1.,    6.,    7.,    8.,   42.,   48.,   56.,  336.]])

此時爸舒， $X$ 的特征從 $(x_1,x_2,x_3)$ 轉換為 $（1,x_1,x_2,x_3,x_1 x_2,x_1 x_3,x_2 x_3,x_1 x_2 x_3）$

Custom transformers（自定義轉換器）

在機器學習中蟋字，可以將一個已有的 Python 函數轉化為一個轉換器來協助數據清理或處理，通俗的講碳抄，就是把原始的特征放進一個函數中做轉換愉老，這個函數出來的值作為新的特征

使用方法：FunctionTransformer

功能：從任意函數中實現一個轉換器

舉例：在一個管道中構建一個實現日志轉換的轉化器

  1 >>> import numpy as np
  2 >>> from sklearn.preprocessing import FunctionTransformer
  3 >>> transformer = FunctionTransformer(np.log1p)
  4 >>> X = np.array([[0, 1], [2, 3]])
  5 >>> transformer.transform(X)
  6 array([[ 0\.        ,  0.69314718],
  7        [ 1.09861229 ,  1.38629436]])

參考資料：
【1】Preprocessing data（sklearn官方文檔）
【2】預處理數據（sklearn中文文檔）
【3】預處理數據的方法總結（使用sklearn-preprocessing）