Python下的機器學習工具scikit-learn（-資料預處理）

（1）資料標準化（Standardization or Mean Removal and Variance Scaling）

進行標準化縮放的資料均值為0，具有單位方差。

#scale函式提供一種便捷的標準化轉換操作，如下：
from sklearn import preprocessing #匯入資料預處理包
X=[[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)#preprocessing.scale()方法預設是按0軸（x座標）縮放的

array([ 0.,  0.,  0.])

X_scaled.std(axis=0)

array([ 1.,  1.,  1.])

同樣我們也可以通過preprocessing模組提供的Scaler（StandardScaler 0.15以後版本）工具類來實現這個功能：

scaler=preprocessing.StandardScaler().fit(X)
scaler

StandardScaler(copy=True, with_mean=True, with_std=True)
 

scaler.mean_

array([ 1.        ,  0.        ,  0.33333333])

scaler.scale_#scaler.std_ will be removed in 0.19. Use ``scale_`` instead

array([ 0.81649658,  0.81649658,  1.24721913])

scaler.transform(X)

array([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])
 

（2）資料規範化（Normalization）

將矩陣縮放至[0,1]區間

import numpy as np
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.        ]])

#上面的min_max_scaler可以用來適配新的資料
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]])

min_max_scaler.scale_

array([ 0.5       ,  0.5       ,  0.33333333])

min_max_scaler.min_

array([ 0.        ,  0.5       ,  0.33333333])

如果MinMaxScaler被賦予了一個顯式的feature_range =（min，max），則完整的公式是：

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std / (max - min) + min

MaxAbsScaler以非常相似的方式工作，但通過劃分每個特徵中最大的最大值，訓練資料位於[-1,1]範圍內。它是針對已經以零或稀疏資料為中心的資料。

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]])

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

array([[-1.5, -1. ,  2. ]])

max_abs_scaler.scale_

array([ 2.,  1.,  2.])

如果資料包含許多異常值，則使用資料的均值和方差進行縮放可能無法正常工作。在這些情況下，可以使用robust_scale和RobustScaler。他們對資料的中心和範圍使用更強大的估計

把資料集中的每個樣本所有數值縮放到(-1,1)之間。

X=[[1.,-1.,2.],
   [2.,0.,0.],
   [0.,1.,-1.]]
X_normalized=preprocessing.normalize(X,norm='l2')#norm l1 l2 預設axis=1,按行
#norm=l2 相當於每個元素除以根號下整行元素的平方和
#norm=l1  X np.abs(X).sum(axis=1)每個元素除以整行元素絕對值的和
#norm=max 每個元素除以整行元素的最大值
X_normalized

array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])

normalizer=preprocessing.Normalizer().fit(X)#fit does nothing
normalizer

Normalizer(copy=True, norm='l2')

normalizer.transform(X)

array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])

normalizer.transform([[-1.,1.,0.]])

array([[-0.70710678,  0.70710678,  0.        ]])

（3）二進位制化（Binarization）

將數值型資料轉化為布林型的二值資料，可以設定一個閾值（threshold）

X=[[1.,-1.,2.],
   [2.,0.,0.],
   [0.,1.,-1.]]
binarizer=preprocessing.Binarizer().fit(X)#fit does nothing
binarizer #預設閾值為0.0

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)#設定閾值為1.1
binarizer.transform(X)

array([[ 0.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  0.,  0.]])

（4）標籤預處理（Label preprocessing）

4.1）標籤二值化（Label binarization）

LabelBinarizer通常用於通過一個多類標籤（label）列表，建立一個label指示器矩陣

lb=preprocessing.LabelBinarizer()
lb.fit([1,2,6,4,2])

LabelBinarizer(neg_label=0, pos_label=1, sparse_output=False)

lb.classes_

array([1, 2, 4, 6])

lb.transform([1,6])

array([[1, 0, 0, 0],
       [0, 0, 0, 1]])

4.2）標籤編碼（Label encoding）

le=preprocessing.LabelEncoder()
le.fit([1,2,2,6])

LabelEncoder()

le.classes_

array([1, 2, 6])

le.transform([1,1,2,6])#編碼

array([0, 0, 1, 2], dtype=int64)

le.inverse_transform([0,0,1,2])#解碼

array([1, 1, 2, 6])

也可以用於非數值型別的標籤到數值型別標籤的轉化：

le=preprocessing.LabelEncoder()
le.fit(["paris","paris","tokyo","amsterdam"])

LabelEncoder()

list(le.classes_)

['amsterdam', 'paris', 'tokyo']

le.transform(["tokyo","tokyo","paris"])

array([2, 2, 1], dtype=int64)

le.inverse_transform([0,2,1])

array(['amsterdam', 'tokyo', 'paris'],
      dtype='<U9')

（5）編碼分類特徵 OneHotEncoder

通常特徵不是連續值，而是類似於性別：[“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]

但是這樣的特徵不能直接放入機器學習演算法中

對於上述的問題，性別的屬性是二維的，同理，地區是三維的，瀏覽器則是思維的，這樣，我們可以採用One-Hot編碼的方式對上述的樣本“[“male”，”US”，”Internet Explorer”]”編碼，“male”則對應著[1，0]，同理“US”對應著[0，1，0]，“Internet Explorer”對應著[0,0,0,1]。則完整的特徵數字化的結果為：[1,0,0,1,0,0,0,0,1]。這樣導致的一個結果就是資料會變得非常的稀疏。

enc=preprocessing.OneHotEncoder()
enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])

OneHotEncoder(categorical_features='all', dtype=<class 'numpy.float64'>,
       handle_unknown='error', n_values='auto', sparse=True)

上面的程式碼我這樣理解的，將矩陣的每一列視為一個特徵進行編碼，比如第一列是[0 1 0 1]，其中有兩個不同的元素0和1，所以需要兩個維度進行編碼，分別編碼為[0 1]和[1 0].

類似，第二列元素是[0 1 2 0],共有3個不同的元素，分別是0 1 2，所以需要三個維度進行編碼，依次編碼為[1 0 0][0 1 0][0 0 1]

第三列元素是[3 0 1 2]，共有四個不同的元素，分別是 0 1 2 3，所以需要四個維度進行編碼，依次編碼為[1 0 0 0][0 1 0 0][0 0 1 0][0 0 0 1]

enc.transform([[1,2,0]]).toarray()

array([[ 0.,  1.,  0.,  0.,  1.,  1.,  0.,  0.,  0.]])

enc = preprocessing.OneHotEncoder(n_values=[2, 3, 4])
# Note that there are missing categorical values for the 2nd and 3rd
# features
enc.fit([[1, 2, 3], [0, 2, 0]])

array([[ 0.,  1.,  1.,  0.,  0.,  1.,  0.,  0.,  0.]])

enc.transform([[1, 0, 0]]).toarray()

array([[ 0.,  1.,  1.,  0.,  0.,  1.,  0.,  0.,  0.]])

(6)估算缺失值

以下程式碼段演示瞭如何使用包含缺失值的列（軸0）的平均值來替換編碼為np.nan的缺失值：

imp=preprocessing.Imputer(missing_values='NaN',strategy='mean',axis=0)
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=preprocessing.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.        ]])

（7）生成多項式特徵

X=np.arange(6).reshape(3,2)
X

array([[0, 1],
       [2, 3],
       [4, 5]])

poly=preprocessing.PolynomialFeatures(degree=2)
poly.fit_transform(X)
#X的特徵從 (X_1, X_2) 轉換為了(1, X_1, X_2, X_1^2, X_1X_2, X_2^2).

array([[  1.,   0.,   1.,   0.,   0.,   1.],
       [  1.,   2.,   3.,   4.,   6.,   9.],
       [  1.,   4.,   5.,  16.,  20.,  25.]])

使用interaction_only=True，會保留元素之間的交叉項，去掉平方立方項

X = np.arange(9).reshape(3, 3)
X

array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

poly=preprocessing.PolynomialFeatures(degree=3,interaction_only=True)
poly.fit_transform(X)
#(X_1, X_2, X_3) to (1, X_1, X_2, X_3, X_1X_2, X_1X_3, X_2X_3, X_1X_2X_3).

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.]])

(8)自定義轉換

import numpy as np
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]])