python大戰機器學習——數據預處理

　　數據預處理的常用流程：

　　　　1）去除唯一屬性

　　　　2）處理缺失值

　　　　3）屬性編碼

　　　　4）數據標准化、正則化

　　　　5）特征選擇

　　　　6）主成分分析

1、去除唯一屬性

　　如id屬性，是唯一屬性，直接去除就好

2、處理缺失值

(1)直接使用含有缺失值的特征

　　如決策樹算法就可以直接使用含有缺失值的特征

(2)刪除含有缺失值的特征

(3)缺失值補全

1)均值插補

　　若樣本屬性的距離是可度量的，則該屬性的缺失值就以該屬性有效值的平均值來插補缺失的值。如果樣本的屬性的距離是不可度量的，則該屬性的缺失值就以該屬性有效值的眾數來插補缺失的值。

2)用同類均值插補

　　首先將樣本進行分類，然后以該類樣本中的均值來插補缺失值。

3)建模預測

　　將缺失的屬性作為預測目標來預測。這種方法效果較好，但是該方法有個根本的缺陷：如果其他屬性和缺失屬性無關，則預測的結果毫無意義。但是如果預測結果相當准確，則說明這個缺失屬性是沒必要考慮納入數據集中的。一般的情況介於兩者之間。

4)高維映射

　　將屬性高映射到高維空間。這種做法是最精確的做法，它完全保留了所有的信息，也未增加任何額外的信息。這樣做的好處是完整保留了原始數據的全部信息、不用考慮缺失值。但它的缺點也很明顯，就是計算量大大提升。而且只有在樣本量非常大的時候效果才好，否則會因為過於稀疏，效果很差。

5)多重插補

　　多重插補認為待插補的值是隨機的，它的值來自於已觀測到的值。具體實踐上通常是估計出待插補的值，然后再加上不同的噪聲，形成多組可選插補值。根據某種選擇依據，選取最合適的插補值。

6)極大似然估計

7)壓縮感知及矩陣補全

　　壓縮感知通過利用信號本身所具有的稀疏性，從部分觀測樣本中回復原信號。壓縮感知分為感知測量和重構恢復兩個階段。

　　　　感知測量：此階段對原始信號進行處理以獲得稀疏樣本表示。常用的手段是傅里葉變換、小波變換、字典學習、稀疏編碼等

　　　　重構恢復：此階段基於稀疏性從少量觀測中恢復原信號。這是壓縮感知的核心

　　矩陣補全

3、特征編碼

(1)特征二元化：將數值型的屬性轉換成布爾型的屬性

(2)獨熱編碼：構建一個映射，將這些非數值屬性映射到整數。其采用N位狀態寄存器來對N個可能的取值進行編碼，每個狀態都由獨立的寄存器位表示，並且在任意時刻只有其中的一位有效。

4、數據標准化、正則化

(1)數據標准化：將樣本的屬性縮放到某個指定范圍

　　進行數據標准化的原因：一是因為某些算法要求樣本數據具有零均值和單位方差。二是樣本不同屬性具有不同量級時，消除數量級的影響。

　　min-max標准化：標准化之后，樣本x的所有屬性值都在[0,1]之間

　　z-score標准化：標准化之后，樣本集的所有屬性的均值都是0，標准差均為1

(2)數據正則化：將樣本的某個范數（如L1范數）縮放到單位1。正則化的過程是針對單個樣本的，對於每個樣本將樣本縮放到單位范數。通常如果使用二次型（如點積）或者其他核方法計算兩個樣本之間的相似性，該方法會很有用。

5、特征選擇

(1)過濾式選擇：先對數據集進行特征選擇，然后再訓練學習器。特征選擇過程與后續學習器無關。常用方法有Relief（二分類）、Relief-F（多分類）

(2)包裹式選擇：直接把最終將要使用的學習器的性能作為特征子集的評價准則。常用方法LVW

(3)嵌入式選擇和L1正則化

　　嵌入式特征選擇是在學習器訓練過程中自動進行了特征選擇

6、稀疏表示和字典學習

代碼實現：

from sklearn.preprocessing import Binarizer,OneHotEncoder,MinMaxScaler,MaxAbsScaler,StandardScaler,Normalizer
from sklearn.feature_selection import VarianceThreshold,SelectKBest,f_classif,RFE,RFECV,SelectFromModel
from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris
import numpy as np
from sklearn.decomposition import DictionaryLearning

#Binary
X=[   [1,2,3,4,5],
      [5,4,3,2,1],
      [3,3,3,3,3],
      [1,1,1,1,1]]

print("before transform:",X)
binarizer=Binarizer(threshold=2.5)
print("after transform:",binarizer.transform(X))

#OneHotEncoder
X=[   [1,2,3,4,5],
      [5,4,3,2,1],
      [3,3,3,3,3],
      [1,1,1,1,1]]
print("before transform:",X)
encoder=OneHotEncoder(sparse=False)
encoder.fit(X)
print("active_feature_:",encoder.active_features_)
print("feature_indices_:",encoder.feature_indices_)
print("n_values:",encoder.n_values_)
print("after transform:",encoder.transform([[1,2,3,4,5]]))

#standardization

#MinMaxScaler
X=[ [1,5,1,2,10],
    [2,6,3,2,7],
    [3,7,5,6,4],
    [4,8,7,8,1]
]

print("before transform:",X)
scaler=MinMaxScaler(feature_range=(0,2))
scaler.fit(X)
print("min_is:",scaler.min_)
print("scale_is:",scaler.scale_)
print("data_max_ is:",scaler.data_max_)
print("data_min_ is:",scaler.data_min_)
print("data_range_ is:",scaler.data_range_)
print("after transform:",scaler.transform(X))

#MaxAbsScaler
X=[
      [1,5,1,2,10],
      [2,6,3,2,7],
      [3,7,5,6,4],
      [4,8,7,8,1]
]

print("before transform:",X)
scaler=MaxAbsScaler()
scaler.fit(X)
print("scale_is:",scaler.scale_)
print("max_abs_ is:",scaler.max_abs_)
print("after transform:",scaler.transform(X))

#StandardScaler:z-score
X=[
      [1,5,1,2,10],
      [2,6,3,2,7],
      [3,7,5,6,4],
      [4,8,7,8,1]
]
print("before transfrom:",X)
scaler=StandardScaler()
scaler.fit(X)
print("scale_ is:",scaler.scale_)
print("mean_ is:",scaler.mean_)
print("var_ is:",scaler.var_)
print("after transfrom:",scaler.transform(X))

#Normalizer
X=[
      [1,2,3,4,5],
      [5,4,3,2,1],
      [1,3,5,2,4],
      [2,4,1,3,5]
]
print("before transform:",X)
normalizer=Normalizer(norm='l2')
print("after transform:",normalizer.transform(X))

#VarianceThreshold
X=[
      [100,1,2,3],
      [100,4,5,6],
      [100,7,8,9],
      [101,11,12,13]
]
selector=VarianceThreshold(1)
selector.fit(X)
print("Variances is %s"%selector.variances_)
print("After transform is %s"%selector.transform(X))
print("The surport is %s"%selector.get_support(True))
print("After reverse transform is %s"%selector.inverse_transform(selector.transform(X)))

#SelectKBest
X=[   [1,2,3,4,5],
      [5,4,3,2,1],
      [3,3,3,3,3],
      [1,1,1,1,1]]
Y=[0,1,0,1]
print("before transform:",X)
selector=SelectKBest(score_func=f_classif,k=3)
selector.fit(X,Y)
print("scores_:",selector.scores_)
print("pvalues_:",selector.pvalues_)
print("selected index:",selector.get_support(True))
print("after transform:",selector.transform(X))

#RFE
iris=load_iris()
X=iris.data
Y=iris.target
estimator=LinearSVC()
selector=RFE(estimator=estimator,n_features_to_select=2)
print("Before transform,X=",X)
selector.fit(X,Y)
selector.transform(X)
print("After transform,X=",X)
print("Ranking %s"%selector.ranking_)

#RFECV
iris=load_iris()
X=iris.data
Y=iris.target
estimator=LinearSVC()
selector=RFECV(estimator=estimator,cv=3)
selector.fit(X,Y)
print("Grid Scores %s"%selector.grid_scores_)

#SelectFromModel
iris=load_iris()
X=iris.data
Y=iris.target
estimator=LinearSVC(penalty='l1',dual=False)
selector=SelectFromModel(estimator=estimator,threshold='mean')
selector.fit(X,Y)
selector.transform(X)
print("Threshold %s"%selector.threshold_)
print("Support is %s"%selector.get_support(indices=True))

#DictionaryLearning
X=[
      [1,2,3,4,5],
      [6,7,8,9,10],
      [10,9,8,7,6],
      [5,4,3,2,1]
]
print("before transform:",X)
dct=DictionaryLearning(n_components=3)
dct.fit(X)
print("components is :",dct.components_)
print("after transform:",dct.transform(X))