from sklearn.datasets import load_iris
 
#導入IRIS數據集
iris = load_iris()
 
#特征矩陣
iris.data
 
#目標向量
iris.target

from sklearn.preprocessing import StandardScaler
 
#標準化，返回值為標準化后的數據
StandardScaler().fit_transform(iris.data)

from sklearn.preprocessing import MinMaxScaler

from sklearn.preprocessing import Normalizer
 
#歸一化，返回值為歸一化后的數據
Normalizer().fit_transform(iris.data)

from sklearn.preprocessing import Binarizer
 
#二值化，閾值設置為3，返回值為二值化后的數據
Binarizer(threshold=3).fit_transform(iris.data)

from sklearn.preprocessing import OneHotEncoder
 
#啞編碼，對IRIS數據集的目標值，返回值為啞編碼后的數據
OneHotEncoder().fit_transform(iris.target.reshape((-1,1)))

from numpy import vstack, array, nan
from sklearn.preprocessing import Imputer
 
#缺失值計算，返回值為計算缺失值后的數據
#參數missing_value為缺失值的表示形式，默認為NaN
#參數strategy為缺失值填充方式，默認為mean（均值）
Imputer().fit_transform(vstack((array([nan, nan, nan, nan]), iris.data)))

from sklearn.preprocessing import PolynomialFeatures
 
#多項式轉換
#參數degree為度，默認值為2
PolynomialFeatures().fit_transform(iris.data)

from numpy import log1p
from sklearn.preprocessing import FunctionTransformer
 
#自定義轉換函數為對數函數的數據變換
#第一個參數是單變元函數
FunctionTransformer(log1p).fit_transform(iris.data)

from sklearn.feature_selection import VarianceThreshold
 
#方差選擇法，返回值為特征選擇后的數據
#參數threshold為方差的閾值
VarianceThreshold(threshold=3).fit_transform(iris.data)

from sklearn.feature_selection import SelectKBest
from scipy.stats import pearsonr
 
#選擇K個最好的特征，返回選擇特征后的數據
#第一個參數為計算評估特征是否好的函數，該函數輸入特征矩陣和目標向量，輸出二元組（評分，P值）的數組，數組第i項為第i個特征的評分和P值。在此定義為計算相關系數
#參數k為選擇的特征個數
SelectKBest(lambda X, Y: array(map(lambda x:pearsonr(x, Y), X.T)).T, k=2).fit_transform(iris.data, iris.target)

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
 
#選擇K個最好的特征，返回選擇特征后的數據
SelectKBest(chi2, k=2).fit_transform(iris.data, iris.target)

 from sklearn.feature_selection import SelectKBest
 from minepy import MINE
 
 #由于MINE的設計不是函數式的，定義mic方法將其為函數式的，返回一個二元組，二元組的第2項設置成固定的P值0.5
 def mic(x, y):
     m = MINE()
     m.compute_score(x, y)
     return (m.mic(), 0.5)
 
#選擇K個最好的特征，返回特征選擇后的數據
SelectKBest(lambda X, Y: array(map(lambda x:mic(x, Y), X.T)).T, k=2).fit_transform(iris.data, iris.target)

from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
 
#遞歸特征消除法，返回特征選擇后的數據
#參數estimator為基模型
#參數n_features_to_select為選擇的特征個數
RFE(estimator=LogisticRegression(), n_features_to_select=2).fit_transform(iris.data, iris.target)

from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import LogisticRegression
 
#帶L1懲罰項的邏輯回歸作為基模型的特征選擇
SelectFromModel(LogisticRegression(penalty="l1", C=0.1)).fit_transform(iris.data, iris.target)

from sklearn.linear_model import LogisticRegression
 
class LR(LogisticRegression):
    def __init__(self, threshold=0.01, dual=False, tol=1e-4, C=1.0,
                 fit_intercept=True, intercept_scaling=1, class_weight=None,
                 random_state=None, solver='liblinear', max_iter=100,
                 multi_class='ovr', verbose=0, warm_start=False, n_jobs=1):
 
        #權值相近的閾值
        self.threshold = threshold
        LogisticRegression.__init__(self, penalty='l1', dual=dual, tol=tol, C=C,
                 fit_intercept=fit_intercept, intercept_scaling=intercept_scaling, class_weight=class_weight,
                 random_state=random_state, solver=solver, max_iter=max_iter,
                 multi_class=multi_class, verbose=verbose, warm_start=warm_start, n_jobs=n_jobs)
        #使用同樣的參數創建L2邏輯回歸
        self.l2 = LogisticRegression(penalty='l2', dual=dual, tol=tol, C=C, fit_intercept=fit_intercept, intercept_scaling=intercept_scaling, class_weight = class_weight, random_state=random_state, solver=solver, max_iter=max_iter, multi_class=multi_class, verbose=verbose, warm_start=warm_start, n_jobs=n_jobs)
 
    def fit(self, X, y, sample_weight=None):
        #訓練L1邏輯回歸
        super(LR, self).fit(X, y, sample_weight=sample_weight)
        self.coef_old_ = self.coef_.copy()
        #訓練L2邏輯回歸
        self.l2.fit(X, y, sample_weight=sample_weight)
 
        cntOfRow, cntOfCol = self.coef_.shape
        #權值系數矩陣的行數對應目標值的種類數目
        for i in range(cntOfRow):
            for j in range(cntOfCol):
                coef = self.coef_[i][j]
                #L1邏輯回歸的權值系數不為0
                if coef != 0:
                    idx = [j]
                    #對應在L2邏輯回歸中的權值系數
                    coef1 = self.l2.coef_[i][j]
                    for k in range(cntOfCol):
                        coef2 = self.l2.coef_[i][k]
                        #在L2邏輯回歸中，權值系數之差小于設定的閾值，且在L1中對應的權值為0
                        if abs(coef1-coef2) < self.threshold and j != k and self.coef_[i][k] == 0:
                            idx.append(k)
                    #計算這一類特征的權值系數均值
                    mean = coef / len(idx)
                    self.coef_[i][idx] = mean
        return self

from sklearn.feature_selection import SelectFromModel
 
#帶L1和L2懲罰項的邏輯回歸作為基模型的特征選擇
#參數threshold為權值系數之差的閾值
SelectFromModel(LR(threshold=0.5, C=0.1)).fit_transform(iris.data, iris.target)

from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import GradientBoostingClassifier
 
#GBDT作為基模型的特征選擇
SelectFromModel(GradientBoostingClassifier()).fit_transform(iris.data, iris.target)

from sklearn.decomposition import PCA
 
#主成分分析法，返回降維后的數據
#參數n_components為主成分數目
PCA(n_components=2).fit_transform(iris.data)

from sklearn.lda import LDA
 
#線性判別分析法，返回降維后的數據
#參數n_components為降維后的維數
LDA(n_components=2).fit_transform(iris.data, iris.target)