資料集轉換之預處理資料：
      將輸入的資料轉化成機器學習演算法可以使用的資料。包含特徵提取和標準化。
      原因：資料集的標準化（服從均值為0方差為1的標準正態分佈（高斯分佈））是大多數機器學習演算法的常見要求。

      如果原始資料不服從高斯分佈，在預測時表現可能不好。在實踐中，我們經常進行標準化（z-score 特徵減去均值/標準差）。

1.1 標準正態分佈(均值為0，方差為1) Scale函式的使用 對列進行z-score 

from sklearn import preprocessing
import numpy as np
#1、資料標準化  

X = np.array([[ 1., -1.,  2.],
             [ 2.,  0.,  0.],
             [ 0.,  1., -1.]])
X_scaled = preprocessing.scale(X)
X_scaled
"""
輸出標準化的結果：
array([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])
"""
X_scaled.mean(axis=0) #用於計算均值和標準偏差的軸。如果為0，獨立規範每個特徵，否則（如果為1）標準化每個樣品。
"""
輸出歸一化後的均值：
array([ 0.,  0.,  0.])
"""
X_scaled.std(axis=0)
"""
輸出標準化後的標準差：
array([ 1.,  1.,  1.])
"""
 

1.2 預處理模組StandardScaler

其實現Transformer API以計算訓練集上的平均值和標準偏差，以便以後能夠在測試集上重新應用相同的變換。

#StandardScaler()的引數
"""
StandardScaler() 的引數with_mean 預設為True 表示使用密集矩陣，使用稀疏矩陣則會報錯 ，with_mean= False 適用於稀疏矩陣
with_std 預設為True 如果為True，則將資料縮放為單位方差（單位標準偏差）
copy 預設為True 如果為False，避免產生一個副本，並執行inplace縮放。 如果資料不是NumPy陣列或scipy.sparse CSR矩陣，則仍可能返回副本
"""
scaler = preprocessing.StandardScaler().fit(X) 
scaler
"""
輸出：
StandardScaler(copy=True, with_mean=True, with_std=True)
"""
#StandardScaler()的屬性
scaler.mean_ 
"""
輸出X（原資料）每列的均值：
array([ 1.        ,  0.        ,  0.33333333])
"""
scaler.scale_
"""
輸出X（原資料）每列的標準差（標準偏差）：
array([ 0.81649658,  0.81649658,  1.24721913])
"""
scaler.var_
"""
輸出X（原資料）每列的方差：
array([ 0.66666667,  0.66666667,  1.55555556])
"""
#StandardScaler()的方法
scaler.transform(X) 
"""
輸出X（原資料）標準化（z-score）：
rray([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])
"""
#  StandardScaler().fit(X) 輸入資料用於計算以後縮放的平均值和標準差
#  StandardScaler().fit_transform(X)輸入資料，然後轉換它
scaler.get_params() #獲取此估計量的引數
"""
輸出:
{'copy': True, 'with_mean': True, 'with_std': True}
"""
scaler.inverse_transform(scaler.transform(X))#將標準化後的資料轉換成原來的資料
"""
輸出:
array([[ 1., -1.,  2.],
       [ 2.,  0.,  0.],
       [ 0.,  1., -1.]])
"""
#scaler.partial_fit(X) 在X縮放以後 線上計算平均值和std
#scaler.set_params(with_mean=False)設定此估計量的引數
 

2、歸一化 將特徵縮放到一個範圍內（0，1）
縮放特徵到給定的最小值到最大值之間，通常在0到1之間。或則使得每個特徵的最大絕對值被縮放到單位大小。這可以分別使用MinMaxScaler或MaxAbsScaler函式實現。

"""
#訓練集資料 例如縮放到[0-1]
"""
MinMaxScaler 引數feature_range=(0, 1)資料集的分佈範圍, copy=True 副本
計算公式如下：
X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std * (max - min) + min
"""

X_train = np.array([[ 1., -1.,  2.],
                   [ 2.,  0.,  0.],
                   [ 0.,  1., -1.]])
min_max_scaler = preprocessing.MinMaxScaler()
X_train_minmax = min_max_scaler.fit_transform(X_train)
X_train_minmax
"""
輸出訓練集：
array([[ 0.5       ,  0.        ,  1.        ],
       [ 1.        ,  0.5       ,  0.33333333],
       [ 0.        ,  1.        ,  0.        ]])
"""
#測試集資料
X_test = np.array([[ -3., -1.,  4.]])
X_test_minmax = min_max_scaler.transform(X_test)
X_test_minmax
"""
輸出測試集：
array([[-1.5       ,  0.        ,  1.66666667]])
"""
"""
MaxAbsScaler 通過其最大絕對值來縮放每個特徵,範圍在[-1,1]。它用於已經以零或稀疏資料為中心的資料，應用於稀疏CSR或CSC矩陣。
X_std = X/每列的最大絕對值
"""
X_train = np.array([[ 1., -1.,  2.],
                   [ 2.,  0.,  0.],
                   [ 0.,  1., -1.]])
max_abs_scaler = preprocessing.MaxAbsScaler()
X_train_maxabs = max_abs_scaler.fit_transform(X_train)
X_train_maxabs
"""
輸出訓練集：
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
"""
max_abs_scaler.scale_  
"""
輸出訓練集的縮放資料：
array([ 2.,  1.,  2.])
"""

X_test = np.array([[ -3., -1.,  4.]])
X_test_maxabs = max_abs_scaler.transform(X_test)
X_test_maxabs 
"""
輸出測試集：
array([[-1.5, -1. ,  2. ]])
"""
 

3、關於稀疏矩陣
MaxAbsScaler和maxabs_scale是專門為縮放稀疏資料而設計的。scale和StandardScaler可以接受scipy.sparse矩陣作為輸入，只要將with_mean = False顯式傳遞給建構函式即可。否則，將丟擲ValueError，因為靜默中心將打破稀疏性，並且通常會由於無意分配過多的記憶體而導致執行崩潰。RobustScaler不能適用於稀疏輸入，但是您可以對稀疏輸入使用變換方法。
請注意，縮放器接受壓縮的稀疏行和壓縮的稀疏列的格式（請參閱scipy.sparse.csr_matrix和scipy.sparse.csc_matrix）。任何其他稀疏輸入將被轉換為壓縮稀疏行表示。為了避免不必要的記憶體複製，建議選擇CSR或CSC表示。最後，如果中心資料預期足夠小，使用稀疏矩陣的toarray方法將輸入顯式轉換為陣列是另一個好的選擇。

4 縮放具有異常值的資料
如果您的資料包含許多異常值，使用資料的均值和方差的縮放可能無法很好地工作。在這些情況下，您可以使用robust_scale和RobustScaler作為替代替換。 它們對資料的中心和範圍使用更穩健的估計。可以使用sklearn.decomposition.PCA或sklearn.decomposition.RandomizedPCA與whiten = True進一步刪除特徵之間的線性相關。

5 、歸一化
歸一化是縮放單個樣本以具有單位範數的過程。 如果您計劃使用二次形式（如點積或任何其他核心）來量化任何樣本對的相似性，則此過程可能很有用。這個假設基於經常被用於文字分類和聚類上下文的空間向量模型上。函式normalize提供了一個快速和簡單的方法來在單個數組類資料集上執行此操作，使用l1或l2範數。

X = [[ 1., -1.,  2.],
    [ 2.,  0.,  0.],
     [ 0.,  1., -1.]]
X_normalized = preprocessing.normalize(X, norm='l2')
X_normalized
"""
輸出l2歸一化：
array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])
"""

 預處理模組還提供了一個實用類Normalizer，它使用Transformer API實現相同的操作（其中fit方法無用，因為該操作獨立處理樣本）。transform(X[, y, copy])將X的每個非零行縮放為單位範數。單獨歸一化樣本為單位標準，具有至少一個非零分量的每個樣本（即資料矩陣的每一行）獨立於其他樣本被重新縮放，使得其範數（l1或l2）等於1。
能夠使用密集numpy陣列和scipy.sparse矩陣（如果避免複製/轉換，使用CSR格式）。 例如文字分類或聚類的常見操作。 例如，兩個l2歸一化的TF-IDF向量的點積是向量的餘弦相似性，並且是資訊檢索團體通常使用的向量空間模型的基本相似性度量。

normalizer = preprocessing.Normalizer(norm='l1').fit(X)  # fit 無用
normalizer.transform(X) 
"""
輸出：
array([[ 0.25, -0.25,  0.5 ],
       [ 1.  ,  0.  ,  0.  ],
       [ 0.  ,  0.5 , -0.5 ]])
"""

6 、二值化
6.1 特徵二值化
特徵二值化是將數值特徵閾值化以獲得布林值的過程。 這對於假設輸入資料根據多變數伯努利分佈而分佈的下游概率估計器可能是有用的。例如，這是sklearn.neural_network.BernoulliRBM 的情況。在文字處理中經常使用二值特徵（可能簡化概率推理），即使歸一化計數（也稱為詞項頻率）或TF-IDF值特徵在實踐中經常表現得更好。二元化和二元化接受來自scipy.sparse的密集陣列樣和稀疏矩陣作為輸入。對於稀疏輸入，資料將轉換為壓縮稀疏行表示形式（請參閱scipy.sparse.csr_matrix）。為了避免不必要的記憶體複製，建議選擇CSR。

X = [[ 1., -1.,  2.],
      [ 2.,  0.,  0.],
     [ 0.,  1., -1.]]

binarizer = preprocessing.Binarizer().fit(X)  # fit does nothing
binarizer
"""
輸出：
Binarizer(copy=True, threshold=0.0)
"""
binarizer.transform(X)
"""
輸出：
array([[ 1.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  1.,  0.]])
"""
#可以調整二值化器的閾值
binarizer = preprocessing.Binarizer(threshold=1.1)
binarizer.transform(X)
"""
輸出：
array([[ 0.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  0.,  0.]])
"""

7、分類特徵編碼

     通常來說，特徵不都是連續的值而是由分類給出的。例如，一個人可以具有如下特徵：
       ["male", "female"]
       ["from Europe", "from US", "from Asia"]
       ["uses Firefox", "uses Chrome", "uses Safari", "uses Internet Explorer"]
      這樣的特徵可以被有效地整合在一起然後進行編碼，比如：
       ["male", "from US", "uses Internet Explorer"] 可以用[0, 1, 3]表示
       ["female", "from Asia", "uses Chrome"] 可以用[1, 2, 1]表示
 但是，這樣的表示不能用於Sklearn進行估計，因為離散（分類）特徵，將特徵值轉化成數字時往往是不連續的。OneHotEncoder函式通過one-of-K （k之一）和 one-hot(獨熱)編碼來解決這個問題。

enc = preprocessing.OneHotEncoder()
enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]]) 
"""
輸出：
OneHotEncoder(categorical_features='all', dtype=<class 'float'>,
       handle_unknown='error', n_values='auto', sparse=True)
"""
enc.transform([[0, 1, 3]]).toarray()
"""
輸出：
array([[ 1.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  1.]])
"""

"""
    預設情況下，每個要素可以自動從資料集中推斷出多少值。可以使用引數n_values顯式地指定它。
    在我們的資料集中有兩個性別，三個可能的大陸和四個網路瀏覽器。然後我們擬合估計器，並變換資料點。
結果:前兩個數字編碼性別，三個數字的大陸和四個數字的為網路瀏覽器。
"""
#注意，如果存在訓練資料可能缺少分類特徵的可能性，則必須顯式地設定n_value。例如，
enc = preprocessing.OneHotEncoder(n_values=[2, 3, 4])
#請注意，第2個和第3個特徵缺少分類值 第一個特徵不缺少（有0，1）
enc.fit([[1, 2, 3], [0, 2, 0]])
"""
輸出：
OneHotEncoder(categorical_features='all', dtype=<class 'float'>,
       handle_unknown='error', n_values=[2, 3, 4], sparse=True)
"""
enc.transform([[1, 0, 0]]).toarray()
"""
輸出：
array([[ 0.,  1.,  1.,  0.,  0.,  1.,  0.,  0.,  0.]])
"""

8 缺失值的插補
由於各種原因，許多現實世界資料集包含缺失值，通常編碼為空白，NaN或其他佔位符。然而，這樣的資料集與scikit-learn估計器不相容，scikit-learn估計器假定陣列中的所有值都是數字的，並且都具有和保持意義。使用不完整資料集的基本策略是丟棄包含缺少值的整個行和/或列。然而，這是以丟失可能有價值的資料（即使不完全）為代價。一個更好的策略是插補缺失值，即從資料的已知部分推斷它們。 Imputer類提供了輸入缺失值的基本策略，使用缺失值所在的行或列的平均值，中值或最常見的值。這個類還允許不同的缺失值編碼。

#以下程式碼段演示瞭如何使用包含缺少值的列（軸0）的平均值替換編碼為np.nan的缺失值：
import numpy as np
from sklearn.preprocessing import Imputer
imp = Imputer(missing_values='NaN', strategy='mean', axis=0) # missing_values：integer/“NaN”, strategy：mean/median/most_frequent
imp.fit([[1, 2], [np.nan, 3], [7, 6]])
"""
輸出：
Imputer(axis=0, copy=True, missing_values='NaN', strategy='mean', verbose=0)
"""
X = [[np.nan, 2], [6, np.nan], [7, 6]]
imp.transform(X)
"""
輸出：
array([[ 4.        ,  2.        ],
       [ 6.        ,  3.66666667],
       [ 7.        ,  6.        ]])
"""
#Imputer類還支援稀疏矩陣：
import scipy.sparse as sp
X = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
imp = Imputer(missing_values=0, strategy='mean', axis=0)
imp.fit(X)
"""
Imputer(axis=0, copy=True, missing_values=0, strategy='mean', verbose=0)
"""
X_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
imp.transform(X_test)
"""
輸出：
array([[ 4.        ,  2.        ],
       [ 6.        ,  3.66666667],
       [ 7.        ,  6.        ]])
"""

9 生成多項式特徵
 通常，通過考慮輸入資料的非線性特徵來增加模型的複雜性是有用的。使用的一種簡單和常見的方法是多項式特徵，其可以獲得特徵的高階和互動項。它在PolynomialFeatures中實現。注意，當使用多項式核函式時，多項式特徵在核心方法（例如，sklearn.svm.SVC，sklearn.decomposition.KernelPCA）中被隱含地使用。

from sklearn.preprocessing import PolynomialFeatures
X = np.arange(6).reshape(3, 2)
X
"""
輸出：
array([[0, 1],
       [2, 3],
       [4, 5]])
"""
poly = PolynomialFeatures(2)
poly.fit_transform(X)        
"""
輸出：
array([[  1.,   0.,   1.,   0.,   0.,   1.],
       [  1.,   2.,   3.,   4.,   6.,   9.],
       [  1.,   4.,   5.,  16.,  20.,  25.]])
       
從X(X_1, X_2) 到X(1, X_1, X_2, X_1^2, X_1X_2, X_2^2).
"""

#在某些情況下，只需要特徵之間的互動項，並且可以通過設定獲得
X = np.arange(9).reshape(3, 3)
X   
"""
輸出：
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
"""
poly = PolynomialFeatures(degree=3, interaction_only=True)
poly.fit_transform(X) 
"""
輸出：
array([[   1.,    0.,    1.,    2.,    0.,    0.,    2.,    0.],
       [   1.,    3.,    4.,    5.,   12.,   15.,   20.,   60.],
       [   1.,    6.,    7.,    8.,   42.,   48.,   56.,  336.]])
       
從(X_1, X_2, X_3) 到 (1, X_1, X_2, X_3, X_1X_2, X_1X_3, X_2X_3, X_1X_2X_3).
"""

10 自定義轉化器

from sklearn.preprocessing import FunctionTransformer
transformer = FunctionTransformer(np.log1p)
X = np.array([[0, 1], [2, 3]])
transformer.transform(X)
"""
輸出：
array([[ 0.        ,  0.69314718],
       [ 1.09861229,  1.38629436]])
"""