分類演算法

# knn演算法
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier()
'''
__init__函式
    def __init__(self, n_neighbors=5,
                 weights='uniform', algorithm='auto', leaf_size=30,
                 p=2, metric='minkowski', metric_params=None, n_jobs=1,
                 **kwargs):
                  
n_neighbors=5,指定以幾個最鄰近的樣本具有投票權
weight="uniform",每個擁有投票權的樣本是按照什麼比重投票，"uniform"表示按照等比重投票，"distance"表示按距離反比投票,
                 [callable]表示自己定義的一個函式，這個函式接收一個距離陣列返回一個全職陣列
algorithm="auto",內部採用什麼樣的演算法實現，有以下幾種方法，"ball_tree":球樹，"kd_tree":kd樹，"brute":暴力搜尋。
                 "auto"表示自動根據資料型別和結構選擇合適的演算法。一般來說，低維資料用kd_tree,高維資料用ball_tree
leaf_size=30:ball_tree或者kd_tree的葉子節點規模
matric="minkowski",怎樣度量距離，預設是閔式距離
p=2,閔式距離各種不同的距離引數
metric_params=None,距離度量函式的額外關鍵字引數，一般預設為None，不用管
n_jobs=1,並行的任務數
 
用法：
    knn.fit(X_train, y_train)
    y_pred = knn.predict(X_test)
    knn.score(y_pred, y_test)
'''
 
# 樸素貝葉斯演算法
from sklearn.naive_bayes import GaussianNB
gsn = GaussianNB()
'''
__init__函式
        def __init__(self, priors=None):
            self.priors = priors
             
priors=None,先驗概率
用法：
    gsn.fit(X_train, y_train)
    y_pred = gsn.predict(X_test)
'''
 
# 線性判別分析
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
lda = LinearDiscriminantAnalysis()
'''
__init__函式
    def __init__(self, solver='svd', shrinkage=None, priors=None,
                 n_components=None, store_covariance=False, tol=1e-4):
        self.solver = solver
        self.shrinkage = shrinkage
        self.priors = priors
        self.n_components = n_components
        self.store_covariance = store_covariance  # used only in svd solver
        self.tol = tol  # used only in svd solver
         
solver="svd",求解演算法，svd表示使用奇異值分解求解，不用計算協方差矩陣。
             lsqr表示最小平方qr分解
             eigen表示特徵值分解
shrinkage=None,是否使用引數收縮
priors=None,用於LDA中貝葉斯規則的先驗概率
components,需要保留的特徵個數，小於等於n-1
store_covariance，是否計算每個類的協方差矩陣，0.19版本刪除
用法：
    lda.fit(X_train, y_train)
屬性：
    covariances_：每個類的協方差矩陣， shape = [n_features, n_features]
    means_：類均值，shape = [n_classes, n_features]
    priors_：歸一化的先驗概率
    rotations_：LDA分析得到的主軸，shape [n_features, n_component]
    scalings_：陣列列表，每個高斯分佈的方差σ
'''
 
# 二次判別分析
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
qda = QuadraticDiscriminantAnalysis()
'''
__init__函式
    def __init__(self, priors=None, reg_param=0., store_covariance=False,
                 tol=1.0e-4, store_covariances=None):
        self.priors = np.asarray(priors) if priors is not None else None
        self.reg_param = reg_param
        self.store_covariances = store_covariances
        self.store_covariance = store_covariance
        self.tol = tol
         
reg_param=None,正則化引數，規範化協方差
'''
 
# 支援向量機
from sklearn.svm import SVC
svc = SVC()
'''
__init__函式
def __init__(self, C=1.0, kernel='rbf', degree=3, gamma='auto',
                 coef0=0.0, shrinking=True, probability=False,
                 tol=1e-3, cache_size=200, class_weight=None,
                 verbose=False, max_iter=-1, decision_function_shape='ovr',
                 random_state=None):
 
C,錯誤項的懲罰係數，即對分錯樣本的懲罰程度越大，因此在訓練樣本中準確率越高，但是泛化能力降低，也就是對測試資料的分類準確率降低。
kernel，演算法中採用的核函式型別
degree，這個引數只對多項式核函式有用，是指多項式核函式的階數n
gamma，核函式係數，預設為auto
coef0，核函式中的獨立項
probability，是否啟用概率估計
shrinking，是否採用啟發式收縮方式
tol，svm停止訓練的誤差精度
cache_size，指定訓練所需要的記憶體，以MB為單位，預設為200MB。
class_weight，給每個類別分別設定不同的懲罰引數C，如果沒有給，則會給所有類別都給C=1，即前面引數指出的引數C.
verbose，是否啟用詳細輸出。此設定利用libsvm中的每個程序執行時設定，如果啟用，可能無法在多執行緒上下文中正常工作。一般情況都設為False，不用管它。
max_iter，最大迭代次數，如果為-1，表示不限制
random_state，偽隨機數發生器的種子,在混洗資料時用於概率估計。
屬性：
    svc.n_support_：各類各有多少個支援向量
    svc.support_：各類的支援向量在訓練樣本中的索引
    svc.support_vectors_：各類所有的支援向量
'''
 
# 神經網路
from sklearn.neural_network import MLPClassifier
mlp = MLPClassifier()
'''
__init__函式
def __init__(self, hidden_layer_sizes=(100,), activation="relu",
                 solver='adam', alpha=0.0001,
                 batch_size='auto', learning_rate="constant",
                 learning_rate_init=0.001, power_t=0.5, max_iter=200,
                 shuffle=True, random_state=None, tol=1e-4,
                 verbose=False, warm_start=False, momentum=0.9,
                 nesterovs_momentum=True, early_stopping=False,
                 validation_fraction=0.1, beta_1=0.9, beta_2=0.999,
                 epsilon=1e-8):
 
hidden_layer_sizes，長度=n_layers-2, 預設(100，），第i個元素表示第i個隱藏層的神經元的個數。
activation，啟用函式，預設為relu
solver，預設 ‘adam’，用來優化權重
alpha，可選的，預設0.0001,正則化項引數
batch_size，預設‘auto’,隨機優化的minibatches的大小
learning_rate，預設‘constant’，用於權重更新
max_iter，預設200，最大迭代次數。
random_state，可選，預設None，隨機數生成器的狀態或種子
shuffle，可選，預設True,只有當solver=’sgd’或者‘adam’時使用，判斷是否在每次迭代時對樣本進行清洗。
tol，可選，預設1e-4，優化的容忍度
learning_rate_int，預設0.001，初始學習率，控制更新權重的補償，只有當solver=’sgd’ 或’adam’時使用。
power_t，只有solver=’sgd’時使用，是逆擴充套件學習率的指數.當learning_rate=’invscaling’，用來更新有效學習率。
verbose，是否將過程列印到stdout
warm_start，當設定成True，使用之前的解決方法作為初始擬合，否則釋放之前的解決方法。
 
屬性：
    - classes_:每個輸出的類標籤
    - loss_:損失函式計算出來的當前損失值
    - coefs_:列表中的第i個元素表示i層的權重矩陣
    - intercepts_:列表中第i個元素代表i+1層的偏差向量
    - n_iter_ ：迭代次數
    - n_layers_:層數
    - n_outputs_:輸出的個數
    - out_activation_:輸出啟用函式的名稱。
用法：
    - fit(X,y):擬合
    - get_params([deep]):獲取引數
    - predict(X):使用MLP進行預測
    - predic_log_proba(X):返回對數概率估計
    - predic_proba(X)：概率估計
    - score(X,y[,sample_weight]):返回給定測試資料和標籤上的平均準確度
    -set_params(**params):設定引數。
'''
 
# 決策樹演算法
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier()
'''
__init__函式
def __init__(self,
                 criterion="gini",
                 splitter="best",
                 max_depth=None,
                 min_samples_split=2,
                 min_samples_leaf=1,
                 min_weight_fraction_leaf=0.,
                 max_features=None,
                 random_state=None,
                 max_leaf_nodes=None,
                 min_impurity_decrease=0.,
                 min_impurity_split=None,
                 class_weight=None,
                 presort=False):
                  
criterion，劃分標準；可選項，預設值為”gini”，即基尼指數，”entropy”資訊增益
max_depth，最大深度；可選項，預設值為”None”，即不限深度，直到達到某種閾值
min_samples_split，閾值；可選項，預設值為2，當某個結點的樣本數小於該值時，停止劃分；
min_samples_leaf，葉結點中，樣本點的最小值；預設值為1
 
屬性：
    n_classes_  列出類數目
    classes_    列出類標籤
    feature_importances_    列出每一維特徵的重要性
    n_features_ 特徵數目
 
用法：
    fix(X,y)    擬合
    get_params()    獲取引數表中的引數
    predict(X)  返回預測出的結果
    score(X,y)  返回準確率
'''
 
# 整合演算法-Bagging
from sklearn.ensemble import BaggingClassifier
bgc = BaggingClassifier()
'''
__init__函式
def __init__(self,
             base_estimator=None,
             n_estimators=10,
             max_samples=1.0,
             max_features=1.0,
             bootstrap=True,
             bootstrap_features=False,
             oob_score=False,
             warm_start=False,
             n_jobs=1,
             random_state=None,
             verbose=0):
 
base_estimator，基本的估計器，就是你要用到的演算法，如果該引數沒有賦值，預設為決策樹。
                這個資訊告訴我們bagging，不僅可以用在決策樹上，還可以用於其他的演算法模型上
n_estimators，基本估計器的個數，就是你要產生多少個子模型，用在決策樹時，即表示產生多少條決策樹用來融合。
max_samples，節點分裂參與判斷的最大樣本數
max_features，節點分裂參與判斷的最大特徵數
bootstrap，是否有放回對樣本抽樣
bootstrap_features，是否有放回對特徵抽樣
'''
 
# 整合演算法-隨機森林
from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier()
'''
__init__函式
def __init__(self,
                 n_estimators=10,
                 criterion="gini",
                 max_depth=None,
                 min_samples_split=2,
                 min_samples_leaf=1,
                 min_weight_fraction_leaf=0.,
                 max_features="auto",
                 max_leaf_nodes=None,
                 min_impurity_decrease=0.,
                 min_impurity_split=None,
                 bootstrap=True,
                 oob_score=False,
                 n_jobs=1,
                 random_state=None,
                 verbose=0,
                 warm_start=False,
                 class_weight=None):
 
min_samples_split，分裂所需要的最小樣本數
min_samples_leaf，葉節點最小樣本數
min_weight_fraction_leaf，葉子節點所需要的最小權值
bootstrap，是否有放回的取樣。
oob_score，在某次決策樹訓練中沒有被bootstrap選中的資料
warm_start，熱啟動，決定是否使用上次呼叫該類的結果然後增加新的。 
class_weight，各個label的權重。 
 
用法：
predict_proba(x)：給出帶有概率值的結果。每個點在所有label的概率和為1. 
predict(x)：直接給出預測結果。內部還是呼叫的predict_proba()，根據概率的結果看哪個型別的預測值最高就是哪個型別。 
predict_log_proba(x)：和predict_proba基本上一樣，只是把結果給做了log()處理。
'''
 
# 整合演算法-AdaBoost
from sklearn.ensemble import AdaBoostClassifier
abc = AdaBoostClassifier()
'''
__init__函式
    def __init__(self,
                 base_estimator=None,
                 n_estimators=50,
                 learning_rate=1.,
                 algorithm='SAMME.R',
                 random_state=None):
 
learning_rate，學習效率
'''
 
# 整合演算法-GBDT（Gradient Tree Boosting）
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier()
'''
__init__函式
    def __init__(self, loss='deviance', learning_rate=0.1, n_estimators=100,
                 subsample=1.0, criterion='friedman_mse', min_samples_split=2,
                 min_samples_leaf=1, min_weight_fraction_leaf=0.,
                 max_depth=3, min_impurity_decrease=0.,
                 min_impurity_split=None, init=None,
                 random_state=None, max_features=None, verbose=0,
                 max_leaf_nodes=None, warm_start=False,
                 presort='auto'):
 
subsample，訓練每個決策樹所用到的子樣本佔總樣本的比例，而對於子樣本的選擇是隨機的。
max_ leaf_ nodes，定義了樹裡最多能有多少個終點節點。
'''
 

迴歸演算法

# 最小二乘迴歸
from sklearn.linear_model import LinearRegression
lg = LinearRegression()
'''
__init__引數
    def __init__(self, fit_intercept=True, normalize=False, copy_X=True,
                 n_jobs=1):
 
fit_intercept，是否存在截距，預設存在
normalize，標準化開關，預設關閉
 
用法：
    lg.fit(X_train, y_train)
    y_pred = lg.predict(X_test)
    lg.score(y_pred, y_test)
'''
 
# 嶺迴歸
from sklearn.linear_model import Ridge
clf = Ridge()
'''
__init__函式
    def __init__(self, alpha=1.0, fit_intercept=True, normalize=False,
                 copy_X=True, max_iter=None, tol=1e-3, solver="auto",
                 random_state=None):
 
alpha，兩項之間的權重；
fit_intercept，預設為true，資料可以攔截，沒有中心化
normalize，輸入的樣本特徵歸一化，預設false
copy_X，複製或者重寫
max_iter，最大迭代次數
tol，控制求解的精度
solver，求解器
 
用法：
    clf.fit(X, y),輸入訓練樣本資料X，和對應的標記y
    clf.predict(X),利用學習好的線性分類器，預測標記，一般在fit之後呼叫；
    clf.corf_,迴歸係數
    clf.intercept_，截距
'''
 
# 核嶺迴歸
from sklearn.kernel_ridge import KernelRidge
clf = KernelRidge()
'''
__init__函式
    def __init__(self, alpha=1, kernel="linear", gamma=None, degree=3, coef0=1,
                 kernel_params=None):
 
kernel，核的型別
gamma，rbf，laplacian，poly，chi2，sigmoid核中的引數，使用其他核時無效。
degree，poly核中的引數d，使用其他核時無效
coef0，poly和sigmoid核中的0引數的替代值，使用其他核時無效。
 
屬性：
    dual_coef_，核空間對應的模型引數
    X_fit_，訓練資料，預測時也需要該值
'''
 
# 支援向量機迴歸
from sklearn.svm import SVR
svr = SVR()
'''
__init__函式
    def __init__(self, kernel='rbf', degree=3, gamma='auto', coef0=0.0,
                 tol=1e-3, C=1.0, epsilon=0.1, shrinking=True,
                 cache_size=200, verbose=False, max_iter=-1):
 
C，懲罰係數
'''
 
# 套索迴歸
from sklearn.linear_model import Lasso
lasso = Lasso()
'''
__init__函式
    def __init__(self, alpha=1.0, fit_intercept=True, normalize=False,
                 precompute=False, copy_X=True, max_iter=1000,
                 tol=1e-4, warm_start=False, positive=False,
                 random_state=None, selection='cyclic'):
 
alpha,可選，預設 1.0。當 alpha 為 0 時演算法等同於普通最小二乘法，可通過 Linear Regression 實現，因此不建議將 alpha 設為 0.
fit_intercept,是否進行攔截計算
max_iter，最大迴圈次數。
tol，優化容忍度 The tolerance for the optimization
warm_start，為 True 時, 重複使用上一次學習作為初始化，否則直接清除上次方案
positive，設為 True 時，強制使係數為正。
selection，若設為 ‘random’, 每次迴圈會隨機更新引數，而按照預設設定則會依次更新
'''
 
# 彈性網路迴歸
from sklearn.linear_model import ElasticNet
etn = ElasticNet()
'''
__init__函式
    def __init__(self, alpha=1.0, l1_ratio=0.5, fit_intercept=True,
                 normalize=False, precompute=False, max_iter=1000,
                 copy_X=True, tol=1e-4, warm_start=False, positive=False,
                 random_state=None, selection='cyclic'):
'''
 
# 貝葉斯迴歸
from sklearn.linear_model import BayesianRidge
bys = BayesianRidge()
'''
__init__函式
    def __init__(self, n_iter=300, tol=1.e-3, alpha_1=1.e-6, alpha_2=1.e-6,
                 lambda_1=1.e-6, lambda_2=1.e-6, compute_score=False,
                 fit_intercept=True, normalize=False, copy_X=True,
                 verbose=False):
 
'''
 
# 邏輯迴歸
from sklearn.linear_model import LogisticRegression
clf = LogisticRegression()
'''
__init__函式
    def __init__(self, penalty='l2', 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):
 
penalty，懲罰項，str型別，可選引數為l1和l2，預設為l2。
dual，對偶或原始方法，bool型別，預設為False。
tol，停止求解的標準，float型別，預設為1e-4。就是求解到多少的時候，停止，認為已經求出最優解
c，正則化係數λ的倒數，float型別，預設為1.0
fit_intercept，是否存在截距或偏差，bool型別，預設為True。
intercept_scaling，僅在正則化項為”liblinear”，且fit_intercept設定為True時有用。float型別，預設為1。
class_weight，用於標示分類模型中各種型別的權重，可以是一個字典或者’balanced’字串，預設為不輸入，也就是不考慮權重，即為None。
solver，優化演算法選擇引數
'''
 
# 穩健迴歸
from sklearn.linear_model import RANSACRegressor
rsg = RANSACRegressor()
'''
__init__函式
    def __init__(self, base_estimator=None, min_samples=None,
                 residual_threshold=None, is_data_valid=None,
                 is_model_valid=None, max_trials=100, max_skips=np.inf,
                 stop_n_inliers=np.inf, stop_score=np.inf,
                 stop_probability=0.99, residual_metric=None,
                 loss='absolute_loss', random_state=None):
'''
 
# 多項式迴歸
from sklearn.preprocessing import PolynomialFeatures
pnf = PolynomialFeatures()
'''
__init__函式
    def __init__(self, degree=2, interaction_only=False, include_bias=True):
 
degree,控制多項式的度
interaction_only,預設為False，如果指定為True，那麼就不會有特徵自己和自己結合的項
include_bias,是否包含截距，預設為True。
'''
 
# 偏最小二乘迴歸
from sklearn.cross_decomposition import PLSRegression
plsr = PLSRegression()
'''
__init__函式
    def __init__(self, n_components=2, scale=True,
                 max_iter=500, tol=1e-06, copy=True):
                  
n_components，要保留的主成分數量,預設為2
scale，是否歸一化資料，預設為是
max_iter，使用NIPALS時的最大迭代次數
tol，迭代截止條件
'''
 
# 典型相關分析
from sklearn.cross_decomposition import CCA
cca = CCA()
'''
__init__函式
    def __init__(self, n_components=2, scale=True,
                 max_iter=500, tol=1e-06, copy=True):
'''
 

聚類演算法

# knn演算法
from sklearn.neighbors import NearestNeighbors
nbrs = NearestNeighbors()
'''
__init__函式
    def __init__(self, n_neighbors=5, radius=1.0,
                 algorithm='auto', leaf_size=30, metric='minkowski',
                 p=2, metric_params=None, n_jobs=1, **kwargs):
 
n_neighbors，整數，可選（預設值為5）,用k_neighbors查詢的近鄰數
radius，引數空間的範圍
'''
 
# Kmeans演算法
from sklearn.cluster import KMeans
k = KMeans()
'''
__init__函式
    def __init__(self, n_clusters=8, init='k-means++', n_init=10,
                 max_iter=300, tol=1e-4, precompute_distances='auto',
                 verbose=0, random_state=None, copy_x=True,
                 n_jobs=1, algorithm='auto'):
                  
n_clusters，生成的聚類數，即產生的質心（centroids）數
max_iter，執行一次k-means演算法所進行的最大迭代數。
n_init，用不同的質心初始化值執行演算法的次數，最終解是在inertia意義下選出的最優結果。
init：有三個可選值：’k-means++’， ‘random’，或者傳遞一個ndarray向量。
                  此引數指定初始化方法，預設值為 ‘k-means++’。
                  （１）‘k-means++’ 用一種特殊的方法選定初始質心從而能加速迭代過程的收斂（即上文中的k-means++介紹）
                  （２）‘random’ 隨機從訓練資料中選取初始質心。
                  （３）如果傳遞的是一個ndarray，則應該形如 (n_clusters, n_features) 並給出初始質心。
precompute_distances，三個可選值，‘auto’，True 或者 False。預計算距離，計算速度更快但佔用更多記憶體。
tol，預設值= 1e-4　與inertia結合來確定收斂條件。
random_state，用於初始化質心的生成器（generator）。如果值為一個整數，則確定一個seed。此引數預設值為numpy的隨機數生成器。
copy_x，當我們precomputing distances時，將資料中心化會得到更準確的結果。如果把此引數值設為True，則原始資料不會被改變。
        如果是False，則會直接在原始資料上做修改並在函式返回值時將其還原。
        但是在計算過程中由於有對資料均值的加減運算，所以資料返回後，原始資料和計算前可能會有細小差別。
 
用法：
    fit(X[,y]):
    　計算k-means聚類。
    fit_predictt(X[,y]):
    　計算簇質心並給每個樣本預測類別。
    fit_transform(X[,y])：
    計算簇並 transform X to cluster-distance space。
    get_params([deep])：
    　取得估計器的引數。
    predict(X):predict(X)
    　給每個樣本估計最接近的簇。
    score(X[,y]):
    　計算聚類誤差
    set_params(**params):
    　為這個估計器手動設定引數。
    transform(X[,y]): 將X轉換為群集距離空間。
    　在新空間中，每個維度都是到叢集中心的距離。 請注意，即使X是稀疏的，轉換返回的陣列通常也是密集的。
'''
 
# 層次聚類
from sklearn.cluster import AgglomerativeClustering
agg = AgglomerativeClustering()
'''
__init__函式
    def __init__(self, n_clusters=2, affinity="euclidean",
                 memory=None,
                 connectivity=None, compute_full_tree='auto',
                 linkage='ward', pooling_func=np.mean):
 
n_clusters，一個整數，指定分類簇的數量
connectivity，一個數組或者可呼叫物件或者None，用於指定連線矩陣
affinity，一個字串或者可呼叫物件，用於計算距離。
memory，用於快取輸出的結果，預設為不快取
compute_full_tree，通常當訓練了n_clusters後，訓練過程就會停止，但是如果compute_full_tree=True，則會繼續訓練從而生成一顆完整的樹
linkage，一個字串，用於指定連結演算法
 
屬性：
    labels：每個樣本的簇標記
    n_leaves_：分層樹的葉節點數量
    n_components：連線圖中連通分量的估計值
    children：一個數組，給出了每個非節點數量
 
方法：
    fit(X[,y])：訓練樣本
    fit_predict(X[,y])：訓練模型並預測每個樣本的簇標記
'''
 
# DBSCAN
from sklearn.cluster import DBSCAN
dbs = DBSCAN()
'''
__init__函式
    def __init__(self, eps=0.5, min_samples=5, metric='euclidean',
                 metric_params=None, algorithm='auto', leaf_size=30, p=None,
                 n_jobs=1):
 
eps，DBSCAN演算法引數，即我們的ϵ-鄰域的距離閾值，和樣本距離超過ϵ的樣本點不在ϵ-鄰域內。預設值是0.5。一般需要通過在多組值裡面選擇一個合適的閾值。
     eps過大，則更多的點會落在核心物件的ϵ-鄰域，此時我們的類別數可能會減少， 本來不應該是一類的樣本也會被劃為一類。
     反之則類別數可能會增大，本來是一類的樣本卻被劃分開。
min_samples，DBSCAN演算法引數，即樣本點要成為核心物件所需要的ϵ-鄰域的樣本數閾值。預設值是5. 一般需要通過在多組值裡面選擇一個合適的閾值。
            通常和eps一起調參。在eps一定的情況下，min_samples過大，則核心物件會過少，此時簇內部分本來是一類的樣本可能會被標為噪音點，類別數也會變多。
            反之min_samples過小的話，則會產生大量的核心物件，可能會導致類別數過少。
metric，最近鄰距離度量引數
algorithm，最近鄰搜尋演算法引數
'''
 

降維演算法

# 主成分分析法
from sklearn.decomposition import PCA
pca = PCA()
'''
__init__函式
    def __init__(self, n_components=None, copy=True, whiten=False,
                 svd_solver='auto', tol=0.0, iterated_power='auto',
                 random_state=None):
 
n_components，PCA演算法中所要保留的主成分個數n，即保留下來的特徵個數n
copy，表示是否在執行演算法時，將原始訓練資料複製一份。
whiten，白化，使得每個特徵具有相同的方差
'''
 
# 核函主成分
from sklearn.decomposition import KernelPCA
kpca = KernelPCA()
'''
__init__函式
    def __init__(self, n_components=None, kernel="linear",
                 gamma=None, degree=3, coef0=1, kernel_params=None,
                 alpha=1.0, fit_inverse_transform=False, eigen_solver='auto',
                 tol=0, max_iter=None, remove_zero_eig=False,
                 random_state=None, copy_X=True, n_jobs=1):
'''
 
 
# 因子分析
from sklearn.decomposition import FactorAnalysis
fac = FactorAnalysis()
'''
__init__函式
    def __init__(self, n_components=None, tol=1e-2, copy=True, max_iter=1000,
                 noise_variance_init=None, svd_method='randomized',
                 iterated_power=3, random_state=0):
'''

資料預處理

from sklearn.preprocessing import scale
import numpy as np
x = np.array([[1., -1., 2.],
              [2., 0., 0.],
              [0., 1., -1.]])
 
# 將每一列特徵標準化為標準正太分佈，注意，標準化是針對每一列而言的
x_scale = scale(x)
x_scale.mean(axis=0)
x_scale.mean(axis=1)
x_scale.std(axis=0)
 
'''
preprocessing這個模組還提供了一個實用類StandarScaler，
它可以在訓練資料集上做了標準轉換操作之後，把相同的轉換應用到測試訓練集中。
'''
from sklearn.preprocessing import StandardScaler
# 呼叫fit方法，根據已有的訓練資料建立一個標準化的轉換器
scaler = StandardScaler().fit(x)
# 使用上面這個轉換器去轉換訓練資料x,呼叫transform方法
scaler.transform(x)
 
 
# 規模化特徵到一定的範圍內
from sklearn.preprocessing import MinMaxScaler
min_max_scaler = MinMaxScaler()
x_minmax = min_max_scaler.fit_transform(x)
 
 
# MaxAbsScaler
'''
原理與上面的很像，只是資料會被規模化到[-1,1]之間。
也就是特徵中，所有資料都會除以最大值。這個方法對那些已經中心化均值維0或者稀疏的資料有意義。
'''
from sklearn.preprocessing import MaxAbsScaler
max_abs_scaler = MaxAbsScaler()
x_train_maxsbs = max_abs_scaler.fit_transform(x)
 
# 正則化Normalization
'''
正則化是將樣本在向量空間模型上的一個轉換，經常被使用在分類與聚類中。
函式normalize 提供了一個快速有簡單的方式在一個單向量上來實現這正則化的功能
'''
from sklearn.preprocessing import normalize
x_normalized = normalize(x, norm='l2')
 
from sklearn.preprocessing import Normalizer
# 根據訓練資料建立一個正則器
normalizer = Normalizer().fit(x)
# 對訓練資料進行正則
normalizer.transform(x)
 
#  二值化–特徵的二值化
from sklearn.preprocessing import Binarizer
binarizer = Binarizer().fit(x)
binarizer.transform(x)