Scikit-Learn各算法詳細參數速查手冊(中文)

Scikit-Learn各算法詳細參數速查手冊(中文)

martin

• Scikit-Learn各算法詳細參數速查手冊中文
  • 線性模型
    • 1 線性迴歸
    • 2 線性迴歸的正則化
      • 21 Lasso迴歸L1正則
      • 22 嶺迴歸L2正則
      • 23 ElasticNet彈性網絡正則
    • 3 邏輯迴歸
    • 4 線性判別分析
  • 決策樹
    • 1 迴歸決策樹
    • 2分類決策樹
  • 貝葉斯分類器
    • 1 高斯貝葉斯分類器
    • 2 多項貝葉斯分類器
    • 3 伯努利貝葉斯分類器
  • K近鄰
    • 1 KNN分類器
    • 2 KNN迴歸器
  • 數據降維
    • 1 PCA
    • 2 超大規模數據降維IncrementalPCA
  • 聚類
    • 1 K均值KMeans聚類
    • 2 密度DBSCAN聚類
    • 3 層次AgglomerativeClustering聚類
  • 支持向量機
    • 1 線性分類SVM
    • 2 非線性分類SVM
    • 3 線性迴歸SVR
    • 4 非線性迴歸SVR
  • 集成學習
    • 概念
    • Bagging
    • Boosting
    • 1 AdaBoost
      • 算法過程
      • 基分類器權值a與訓練數據集權值w的分析
      • AdaBoost推導
      • 11 AdaBoostClassifier
      • 12 AdaBoostRegressor
    • 2 Gradient Tree Boosting
      • 21 GradientBoostingClassifier
      • 22 GradientBoostingRegressor
    • 3 Random Forest
      • 31 RandomForestClassifier
      • 32 RandomForestRegressor
  • 參考書籍

---

1. 線性模型

1.1 線性迴歸

LinearRegression是scikit-learn提供的線性迴歸模型，其原型爲：
class sklearn.linear_model.LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=1)

• [x] 導包
  
  • from sklearn.linear_model import LinearRegression
• [x] 參數
  
  • fit_intercept : 一個布爾值，指定是否需要計算b值。如果爲False，那麼不計算b值。
  • normalize : 一個布爾值。如果爲True，那麼訓練樣本會在迴歸之前被歸一化。
  • copy_X : 一個布爾值。如果爲True，則會被複制。
  • n_jobs : 一個正數。任務並行時指定的CPU數量。如果爲-1則使用所有可用的CPU。
• [x] 屬性
  
  • coef_ : 權重向量。
  • intercept_ : 截距b值。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型預測，返回預測值。
  • score(X,y) : 返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y^i ，則：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

1.2 線性迴歸的正則化

1.2.1 Lasso迴歸（L1正則）

原型爲：
class sklearn.linear_model.Lasso(alpha=1.0,fit_intercept=True,normalize=False,precompute=False,
copy_X=True,max_iter=1000,tol=0.0001,warm_start=False,positive=False,random_state=None,
selection=’cyclic’)

• [x] 導包
  
  • from sklearn.linear_model import Lasso
• [x] 參數
  
  • alpha : α 值，其值越大則正則化項的佔比越大。
  • fit_intercept ：一個布爾值，指定是否需要計算b值。如果爲False，那麼不計算b值。
  • max_iter : 一個整數，指定最大迭代次數。
  • normalize :一個布爾值。如果爲True，那麼訓練樣本會在迴歸之前被歸一化。
  • copy_X : 一個布爾值。如果爲True，則會被複制。
  • precompute : 一個布爾值或者一個序列。決定是否提前計算Gram矩陣來加速計算。
  • tol : 一個浮點數，指定判斷迭代收斂與否的閾值
  • warm_start : 一個布爾值。如果爲True，那麼使用前一次訓練結果繼續訓練。否則從頭開始訓練
  • positive : 一個布爾值。如果爲True，那麼要求權重向量的分量都爲正數。
  • selection : 一個字符串，可以爲‘cyclic’或者‘random’。它指定了當每輪迭代的時候，選擇權重向量的那個分量來更新。
    
    • cyclic：更新的時候，從前向後依次選擇權重向量的一個分量來更新。
    • random：更新的時候，隨機選擇權重向量的一個分量來更新。
  • random_state : 一個整數或者一個RandomState實例，或者None。
    
    • 整數，則指定了隨機數生成器的種子。
    • RandomState，則指定了隨機數生成器。
    • None，則默認使用隨機數生成器。
• [x] 屬性
  
  • coef_ : 權重向量。
  • intercept_ : 截距b值。
  • n_iter_ : 實際迭代次數。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型預測，返回預測值。
  • score(X,y) : 返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y^i ，則：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

1.2.2 嶺迴歸（L2正則）

原型爲：
class sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, solver=’auto’, random_state=None)

• [x] 導包
  
  • from sklearn.linear_model import Ridge
• [x] 參數
  
  • alpha : α 值，其值越大則正則化項的佔比越大。
  • fit_intercept ：一個布爾值，指定是否需要計算b值。如果爲False，那麼不計算b值。
  • max_iter : 一個整數，指定最大迭代次數。
  • normalize :一個布爾值。如果爲True，那麼訓練樣本會在迴歸之前被歸一化。
  • copy_X : 一個布爾值。如果爲True，則會被複制。
  • solver : 一個字符串，指定求解最優化問題的算法。可以爲：
    
    • auto : 根據數據集自動選擇算法。
    • svd :使用奇異值分解計算迴歸係數。
    • cholesky :使用scipy.linalg.solve函數來求解。
    • sparse_cg :使用scipy.sparse.linalg.cg函數來求解。
    • lsqr :使用scipy.sparse.linalg.lsqr函數來求解。
    • sag :使用隨機梯度下降來求解
  • tol : 一個浮點數，指定判斷迭代收斂與否的閾值
  • random_state : 一個整數或者一個RandomState實例，或者None。
    
    • 整數，則指定了隨機數生成器的種子。
    • RandomState，則指定了隨機數生成器。
    • None，則默認使用隨機數生成器。
• [x] 屬性
  
  • coef_ : 權重向量。
  • intercept_ : 截距b值。
  • n_iter_ : 實際迭代次數。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型預測，返回預測值。
  • score(X,y) : 返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y^i ，則：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

1.2.3 ElasticNet（彈性網絡正則）

原型爲：
class sklearn.linear_model.ElasticNet(alpha=1.0, l1_ratio=0.5, fit_intercept=True, normalize=False, precompute=False, max_iter=1000, copy_X=True, tol=0.0001, warm_start=False, positive=False, random_state=None, selection=’cyclic’)

• [x] 導包
  
  • from sklearn.linear_model import ElasticNet
• [x] 參數
  
  • alpha : α 值，其值越大則正則化項的佔比越大。
  • l1_ratio : ρ 值。公式爲：
    
    αρ||ω||1+α(1−ρ)2||ω||22，α≥0，0≤ρ≤1
  • fit_intercept ：一個布爾值，指定是否需要計算b值。如果爲False，那麼不計算b值。
  • max_iter : 一個整數，指定最大迭代次數。
  • normalize :一個布爾值。如果爲True，那麼訓練樣本會在迴歸之前被歸一化。
  • copy_X : 一個布爾值。如果爲True，則會被複制。
  • precompute : 一個布爾值或者一個序列。決定是否提前計算Gram矩陣來加速計算。
  • tol : 一個浮點數，指定判斷迭代收斂與否的閾值
  • warm_start : 一個布爾值。如果爲True，那麼使用前一次訓練結果繼續訓練。否則從頭開始訓練
  • positive : 一個布爾值。如果爲True，那麼要求權重向量的分量都爲正數。
  • selection : 一個字符串，可以爲‘cyclic’或者‘random’。它指定了當每輪迭代的時候，選擇權重向量的那個分量來更新。
    
    • cyclic：更新的時候，從前向後依次選擇權重向量的一個分量來更新。
    • random：更新的時候，隨機選擇權重向量的一個分量來更新。
  • random_state : 一個整數或者一個RandomState實例，或者None。
    
    • 整數，則指定了隨機數生成器的種子。
    • RandomState，則指定了隨機數生成器。
    • None，則默認使用隨機數生成器。
• [x] 屬性
  
  • coef_ : 權重向量。
  • intercept_ : 截距b值。
  • n_iter_ : 實際迭代次數。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型預測，返回預測值。
  • score(X,y) : 返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y^i ，則：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

1.3 邏輯迴歸

Logistic Regression是scikit-learn提供的邏輯迴歸模型，其原型爲：
class sklearn.linear_model.LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, 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)

• [x] 導包
  
  • from sklearn.linear_model import LogisticRegression
• [x] 參數
  
  • penalty : 一個字符串，指定了正則化策略。
    
    • l2 : 優化目標爲 12||ω⃗ ||22+CL(ω⃗ ) 。
    • l1 : 優化目標爲 12||ω⃗ ||1+CL(ω⃗ ) 。
  • dual : 一個布爾值。如果爲True，則求解對偶形式(只在penalty=‘l2’且solver=‘liblinear’有對偶形式)，如果爲False，則求解原始形式。
  • C : 一個浮點數。它指定了罰項係數的倒數。如果它的值越小，則正則化項越大。
  • fit_intercept : 一個布爾值，指定是否需要計算b值。如果爲False，那麼不計算b值。
  • intercept_scaling : 一個浮點數。只有當solver=‘liblinear’纔有意義。當採用fit_intercept時，相當於人造了一個特徵，該特徵恆爲1，其權重爲b。在計算正則化項的時候，該人造特徵也被考慮了。因此爲了降低這個人造特徵的影響，需要提供intercept_scaling。
  • class_weight : 一個字典或者字符串‘balanced’。
    
    • 字典 : 字典給出每個分類的權重。
    • balanced : 每個分類的權重與該分類在樣本集中出現的頻率成反比。
    • 未指定 : 每個分類權重都爲1。
  • max_iter : 一個整數，制定最大迭代數。
  • random_state :一個整數或者一個RandomState實例，或者None。
    
    • 整數，則指定了隨機數生成器的種子。
    • RandomState，則指定了隨機數生成器。
    • None，則默認使用隨機數生成器。
  • solver : 一個字符串，指定了求解最優化的算法，可以爲：
    
    • newton-cg : 使用牛頓法。只適用於penalty=‘l2’。
    • lbfgs : 使用L-BFGS擬牛頓法。只適用於penalty=‘l2’。
    • liblinear : 使用liblinear，適用於小數據集。
    • sag : 使用Stochastic Average Gradient Descent算法，適用於大數據集。只適用於penalty=‘l2’。
  • tol : 一個浮點數，指定判斷迭代收斂與否的閾值
  • multi_class : 一個字符串，指定對於多分類問題的策略，可以爲：
    
    • ovr : 採用one-vs-rest策略。
    • multinomial : 直接採用多分類邏輯迴歸策略，不能與liblinear共存。
  • verbose : 一個正數。用於開啓關閉迭代中輸出日誌。
  • warm_start: 一個布爾值。如果爲True，那麼使用前一次訓練結果繼續訓練。否則從頭開始訓練
  • n_jobs : 一個正數。任務並行時指定的CPU數量。如果爲-1則使用所有可用的CPU。
• [x] 屬性
  
  • coef_ : 權重向量。
  • intercept_ :b值。
  • n_iter :實際迭代次數。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型預測，返回預測值。
  • predict_log_proba(X) : 返回一個數組，數組的元素依次是X預測爲各個類別的概率的對數值。
  • predict_proba(X) : 返回一個數組，數組的元素依次是X預測爲各個類別的概率值。
  • score(X,y) : 返回在(X,y)上預測的準確率(accuracy)。

1.4 線性判別分析

LinearDiscriminationAnalysis是scikit-learn提供的線性判別分析模型，其原型爲：
class sklearn.discriminant_analysis.LinearDiscriminantAnalysis(solver=’svd’, shrinkage=None, priors=None, n_components=None, store_covariance=False, tol=0.0001)[source]

• [x] 導包
  
  • from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
• [x] 參數
  
  • solver : 一個字符串，指定求解最優化問題的算法，可以爲：
    
    • svd：奇異值分解，對於有大規模特徵的數據推薦用此種算法。
    • lsqr：最小平方QR分解法，可以結合shrinkage，適合大且稀疏的矩陣。
    • eigen：特徵值分解法，可以結合shrinkage。
  • shrinkage : 字符串‘auto’或者浮點數或者None。該參數通常在訓練樣本數量小於特徵數量的場合下使用。該參數只有在solver=lsqr或者eigen下才有意義。
  • priors : 一個數組，數組中的元素依次指定了每個類別的先驗概率。如果爲None，則認爲每個類別的先驗概率是均等的。
  • n_components :
  • store_covariance :
  • tol :
• [x] 屬性
  
  • coef_ : 權重向量。
  • intercept_ : b值。
  • covariance :一個數組，依次給出每個類別的協方差矩陣。
  • means_ : 一個數組，依次給出每個類別的均值向量。
  • xbar_ : 給出了整體樣本的均值向量。
  • n_iter : 實際迭代次數。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型預測，返回預測值。
  • predict_log_proba(X) : 返回一個數組，數組的元素依次是X預測爲各個類別的概率的對數值。
  • predict_proba(X) : 返回一個數組，數組的元素依次是X預測爲各個類別的概率值。
  • score(X,y) : 返回在(X,y)上預測的準確率(accuracy)。

---

2. 決策樹

2.1 迴歸決策樹

DescisionTreeRegressor實現了迴歸決策樹，用於迴歸問題，其原型爲：
class sklearn.tree.DecisionTreeRegressor(criterion=’mse’, splitter=’best’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_split=1e-07, presort=False)[source]

• [x] 導包
  
  • from sklearn.tree import DecisionTreeRegressor
• [x] 參數
  
  • criterion : 一個字符串，指定切分質量的評價標準。默認爲‘mse’，且只支持該字符串，表示均方誤差。
  • splitter : 一個字符串，指定切分原則，可以爲：
    
    • best : 表示選擇最優的切分。
    • random ： 表示隨機切分。
  • max_features : 可以爲整數、浮點、字符或者None，指定尋找best split時考慮的特徵數量。
    
    • 如果是整數，則每次切分只考慮max_features個特徵。
    • 如果是浮點數，則每次切分只考慮max_features*n_features個特徵(max_features指定了百分比)。
    • 如果是字符串‘auto’，則max_features等於n_features。
    • 如果是字符串‘sqrt’，則max_features等於sqrt(n_features)。
    • 如果是字符串‘log2’，則max_features等於log2(n_features)。
    • 如果是字符串None，則max_features等於n_features。
  • max_depth : 可以爲整數或者None，指定樹的最大深度。
    
    • 如果爲None，表示樹的深度不限(知道每個葉子都是純的，即葉子結點中的所有樣本點都屬於一個類，或者葉子中包含小於min_sanples_split個樣本點)。
    • 如果max_leaf_nodes參數非None，則忽略此項。
  • min_samples_split : 爲整數，指定每個內部節點(非葉子節點)包含的最少的樣本數。
  • min_samples_leaf : 爲整數，指定每個葉子結點包含的最少的樣本數。
  • min_weight_fraction_leaf : 爲浮點數，葉子節點中樣本的最小權重係數。
  • max_leaf_nodes : 爲整數或None，指定葉子結點的最大數量。
    
    • 如果爲None，此時葉子節點數不限。
    • 如果非None，則max_depth被忽略。
  • class_weight : 一個字典、字典的列表、字符串‘balanced’或者None，他指定了分類的權重。權重形式爲：{class_label:weight}
    
    • 如果爲None，則每個分類權重都爲1.
    • 字符串‘balanced’表示每個分類的權重是各分類在樣本出現的頻率的反比。
  • random_state : 一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數，則它指定了隨機數生成器的種子。
    • 如果爲RandomState實例，則指定了隨機數生成器。
    • 如果爲None，則使用默認的隨機數生成器。
  • presort : 一個布爾值，指定了是否要提前排序數據從而加速尋找最優切分的過程。設置爲True時，對於大數據集會減慢總體訓練過程，但對於小數據集或者設定了最大深度的情況下，則會加速訓練過程。
• [x] 屬性
  
  • feature_importances_ : 給出了特徵的重要程度。該值越高，則特徵越重要(也稱爲Gini importance)。
  • max_features_ : max_feature的推斷值。
  • n_features_ : 當執行fit後，特徵的數量。
  • n_outputs_ : 當執行fit後，輸出的數量。
  • tree_ : 一個Tree對象，即底層的決策樹。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型預測，返回預測值。
  • score(X,y) : 返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y^i ，則：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

2.2分類決策樹

DescisionTreeClassifier實現了分類決策樹，用於分類問題，其原型爲：
class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, splitter=’best’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_split=1e-07, class_weight=None, presort=False)

• [x] 導包
  
  • from sklearn.tree import DecisionTreeClassifier

• [x] 參數

  • criterion : 一個字符串，指定切分質量的評價標準。可以爲：

    • ‘gini’ ：表示切分標準是Gini係數。切分時選取基尼係數小的屬性切分。
      數據集基尼指數：Gini(D)=1−∑k=1K(|Ck||D|)2
      給定特徵A，根據其是否取某一個可能值a，樣本集D被分爲D1和D2
      Gini(D,A)=|D1||D|Gini(D1)+|D2||D|Gini(D2)
    • ‘entropy’ ： 表示切分標準是熵。切分時選取熵大的屬性切分。數據集總量爲 |D| ，共有 K 個類，每個類數量爲 |Ck| ，根據特徵A可以將數據集切分，每個數據集數量爲 |Di|:
      數據集D的經驗熵：H(D)=−∑k=1K|Ck||D|log2|Ck||D|
      特徵A對數據集D的經驗條件熵：H(D|A)=∑i=1n|Di||D|H(Di)=−∑i=1n|Di||D|∑k=1K|Dik||Di|log2|Dik||Di|
      計算信息增益：g(D,A)=H(D)−H(D|A)

  • splitter : 一個字符串，指定切分原則，可以爲：

    • best : 表示選擇最優的切分。
    • random ： 表示隨機切分。
  • max_features : 可以爲整數、浮點、字符或者None，指定尋找best split時考慮的特徵數量。
    
    • 如果是整數，則每次切分只考慮max_features個特徵。
    • 如果是浮點數，則每次切分只考慮max_features*n_features個特徵(max_features指定了百分比)。
    • 如果是字符串‘auto’，則max_features等於n_features。
    • 如果是字符串‘sqrt’，則max_features等於sqrt(n_features)。
    • 如果是字符串‘log2’，則max_features等於log2(n_features)。
    • 如果是字符串None，則max_features等於n_features。
  • max_depth : 可以爲整數或者None，指定樹的最大深度。
    
    • 如果爲None，表示樹的深度不限(知道每個葉子都是純的，即葉子結點中的所有樣本點都屬於一個類，或者葉子中包含小於min_sanples_split個樣本點)。
    • 如果max_leaf_nodes參數非None，則忽略此項。
  • min_samples_split : 爲整數，指定每個內部節點(非葉子節點)包含的最少的樣本數。
  • min_samples_leaf : 爲整數，指定每個葉子結點包含的最少的樣本數。
  • min_weight_fraction_leaf : 爲浮點數，葉子節點中樣本的最小權重係數。
  • max_leaf_nodes : 爲整數或None，指定葉子結點的最大數量。
    
    • 如果爲None，此時葉子節點數不限。
    • 如果非None，則max_depth被忽略。
  • class_weight : 一個字典、字典的列表、字符串‘balanced’或者None，他指定了分類的權重。權重形式爲：{class_label:weight}
    
    • 如果爲None，則每個分類權重都爲1.
    • 字符串‘balanced’表示每個分類的權重是各分類在樣本出現的頻率的反比。
  • random_state : 一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數，則它指定了隨機數生成器的種子。
    • 如果爲RandomState實例，則指定了隨機數生成器。
    • 如果爲None，則使用默認的隨機數生成器。
  • presort : 一個布爾值，指定了是否要提前排序數據從而加速尋找最優切分的過程。設置爲True時，對於大數據集會減慢總體訓練過程，但對於小數據集或者設定了最大深度的情況下，則會加速訓練過程。
• [x] 屬性
  
  • classes_ : 分類的標籤值。
  • feature_importances_ : 給出了特徵的重要程度。該值越高，則特徵越重要(也稱爲Gini importance)。
  • max_features_ : max_feature的推斷值。
  • n_classes_ : 給出了分類的數量。
  • n_features_ : 當執行fit後，特徵的數量。
  • n_outputs_ : 當執行fit後，輸出的數量。
  • tree_ : 一個Tree對象，即底層的決策樹。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型預測，返回預測值。
  • predict_log_proba(X) : 返回一個數組，數組元素依次爲X預測爲各個類別的概率值的對數值。
  • predict_proba(X) : 返回一個數組，數組元素依次爲X預測爲各個類別的概率值。
  • score(X,y) : 返回在(X,y)上預測的準確率(accuracy)。

---

3. 貝葉斯分類器

樸素貝葉斯算法

• 輸入
  
  • 訓練集 T=(x1,y1),(x2,y2),...,(xN,yN) , xi=(x(1)i,x(2)i,...,x(n)i)T , x(j)i 爲第i個樣本的第j個特徵，其中 x(j)i∈{aj1,aj2,...,ajsj} , ajl爲第j個特徵可能渠道的第l個值，j=1,2,...,n,l=1,2,...,sj,y∈{c1,c2,...,cK} 。
• 算法步驟
  
  • 計算先驗概率的估計值以及條件概率的估計值。
    
    • P(Y=ck)=∑Ni=1I(yi=ck)N;k=1,2,...,K
    • P(X(j)=ajl|y=ck)=∑Ni=1I(x(j)i=ajl,yi=ck)∑Ni=1I(yi=ck)
      
      
      j=1,2,...,n;l=1,2,...,sj;k=1,2,...,K
  • 對於給定的實例 x ，計算： P(Y=ck)∏P(X(j)|Y=ck),k=1,2,...,K
  • 計算並返回實例 x 的分類 :y=argmaxP(Y=ck)∏nj=1P(X(j)=x(j)|Y=ck)

三大算法均是樸素貝葉斯算法，區別在於假設了不同的 P(X(j)|Y=ck) 分佈。
GaussianNB假設:

P(X(j)|Y=ck)=12πσ2k−−−−√exp(−(X(j)−μk)22σ2k)

MultinomialNB假設:

P(X(j)=ajl|Y=ck)=∑Ni=1I(x(j)i=ajl,yi=ck)+a∑Ni=1I(yi=ck)+sja

BernoulliNB假設：

P(X(j)|Y=ck)=pX(j)+(1−p)(1−X(j))

3.1 高斯貝葉斯分類器

GaussianNB是高斯貝葉斯分類器，它假設特徵的條件概率分佈滿足高斯分佈：

P(X(j)|y=ck)=12πσ2k−−−−√exp(−(X(j)−μk)22σ2k)

其原型爲：
class sklearn.naive_bayes.GaussianNB(priors=None)

• [x] 導包
  
  • from sklearn.naive_bayes import GaussianNB
• [x] 參數
  
  • priors : 類的先驗概率。如果指定的先驗概率並不適合數據。
• [x] 屬性
  
  • class_prior_ : 一個數組，形狀爲(n_classes)，是每個類別的概率 P(y=ck) 。
  • class_count_ : 一個數組，形狀爲(n_classes)，是每個類別包含的樣本數量。
  • theta_ : 一個數組，形狀爲(n_classes，n_features)，是每個類別上每個特徵的均值 μk 。
  • sigma_ : 一個數組，形狀爲(n_classes，n_features)，是每個類別上每個特徵的標準差 σk
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • partial_fit(X,y) : 追加訓練模型，該方法主要用於大規模數據集的訓練，此時大規模數據集被分成多個小數據集然後分別訓練。
  • predict(X) : 用模型預測，返回預測值。
  • predict_log_proba(X) : 返回一個數組，數組元素依次爲X預測爲各個類別的概率值的對數值。
  • predict_proba(X) : 返回一個數組，數組元素依次爲X預測爲各個類別的概率值。
  • score(X,y) : 返回在(X,y)上預測的準確率(accuracy)。

3.2 多項貝葉斯分類器

MultinomialNB是多項貝葉斯分類器，它假設特徵的條件概率分佈滿足多項分佈。

貝葉斯估計：

設第 j 個特徵 x(j) 可能取值爲 aj1,aj2,...,ajsj ，則條件概率 P(X(j)=ajl|Y=ck) 的極大似然估計爲：

極大似然估計：P(X(j)=ajl|y=ck)=∑Ni=1I(x(j)i=ajl,yi=ck)∑Ni=1I(yi=ck)

j=1,2,...,n

l=1,2,...,sj

k=1,2,...,K

用極大似然估計可能會出現分母 ∑Ni=1I(yi=ck)=0 的情況，此時可以採用貝葉斯估計(最大後驗估計)：

貝葉斯估計：P(X(j)=ajl|y=ck)=∑Ni=1I(x(j)i=ajl,yi=ck)+a∑Ni=1I(yi=ck)+sja

其等價於在 X(j) 的各個取值的頻數上賦予了一個正數 a(也叫λ) 。

• 當 a=0 時，爲極大似然估計。

• 當 a=1 時，爲拉普拉斯平滑。
  其原型爲：
  class sklearn.naive_bayes.MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)

• [x] 導包

  • from sklearn.naive_bayes import MultinomialNB
• [x] 參數
  
  • alpha : 一個浮點數，指定 α 值。
  • fit_prior : 布爾值。如果爲True，則不去學習 P(y=ck) ，替代以均勻分佈；如果爲False，則去學習 P(y=ck) 。
  • class_prior : 一個數組它指定了每個類別的先驗概率 P(y=c1) ， P(y=c2) ，…, P(y=cK) ，如果指定了該參數，則每個分類的先驗概率不再從數據集中學習。
• [x] 屬性
  
  • class_log_prob_ : 一個數組對象，形狀爲(n_classes)，給出了每個類別調整後的經驗概率分佈的對數值。
  • feature_log_prob_ : 一個數組對象，形狀爲(n_classes,n_features)。給出了 P(X(j)|y=ck) 的經驗概率分佈的對數。
  • class_count_ : 一個數組，形狀爲(N_classes)，是每個類別包含的訓練樣本數。
  • feature_count_ : 一個數組，形狀爲(n_classes,n_features)。訓練過程中，每個類別每個特徵遇到的樣本數。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • partial_fit(X,y) : 追加訓練模型，該方法主要用於大規模數據集的訓練，此時大規模數據集被分成多個小數據集然後分別訓練。
  • predict(X) : 用模型預測，返回預測值。
  • predict_log_prob(X) : 返回一個數組，數組元素依次爲X預測爲各個類別的概率值的對數值。
  • predict_prob(X) : 返回一個數組，數組元素依次爲X預測爲各個類別的概率值。
  • score(X,y) : 返回在(X,y)上預測的準確率(accuracy)。

3.3 伯努利貝葉斯分類器

BernoulliNB是伯努利貝葉斯分類器。它假設特徵的條件概率分佈滿足二項分佈：

P(X(j)|Y=ck)=pX(j)+(1−p)(1−X(j))

其中，要求特徵的取值爲 X(j)∈{0,1} ，且 P(X(j)=1|y=ck)=p 。其原型爲：
class sklearn.naive_bayes.BernoulliNB(alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None)

• [x] 導包
  
  • from sklearn.naive_bayes import BernoulliNB
• [x] 參數
  
  • alpha : 一個浮點數，指定 α 值。
  • binarize : 一個浮點數或者None。
    
    • None：假定數據已經是二元化了。
    • 浮點數，那麼會以該值作爲閾值，特徵值大於它的作爲1，小於它的作爲0。
  • fit_prior : 布爾值。如果爲True，則不去學習 P(y=ck) ，替代以均勻分佈；如果爲False，則去學習 P(y=ck) 。
  • class_prior : 一個數組它指定了每個類別的先驗概率 P(y=c1) ， P(y=c2) ，…, P(y=cK) ，如果指定了該參數，則每個分類的先驗概率不再從數據集中學習。
• [x] 屬性
  
  • class_log_prob_ : 一個數組對象，形狀爲(n_classes)，給出了每個類別調整後的經驗概率分佈的對數值。
  • feature_log_prob_ : 一個數組對象，形狀爲(n_classes,n_features)。給出了 P(X(j)|y=ck) 的經驗概率分佈的對數。
  • class_count_ : 一個數組，形狀爲(N_classes)，是每個類別包含的訓練樣本數。
  • feature_count_ : 一個數組，形狀爲(n_classes,n_features)。訓練過程中，每個類別每個特徵遇到的樣本數。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • partial_fit(X,y) : 追加訓練模型，該方法主要用於大規模數據集的訓練，此時大規模數據集被分成多個小數據集然後分別訓練。
  • predict(X) : 用模型預測，返回預測值。
  • predict_log_prob(X) : 返回一個數組，數組元素依次爲X預測爲各個類別的概率值的對數值。
  • predict_prob(X) : 返回一個數組，數組元素依次爲X預測爲各個類別的概率值。
  • score(X,y) : 返回在(X,y)上預測的準確率(accuracy)。

---

4. K近鄰

• KNeighborsClassifier將待預測樣本點最近鄰的k個訓練樣本點中出現次數最多的分類作爲待預測樣本點的分類。
• KNeighborsRegressor將待預測樣本點最近鄰的k個訓練樣本點的平均值作爲待預測樣本點的分類。

4.1 KNN分類器

KNeighborsClassifier是scikit-learn提供的K近鄰算法分類模型，其原型爲：
class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30, p=2, metric=’minkowski’, metric_params=None, n_jobs=1, **kwargs)

• [x] 導包
  
  • from sklearn.neighbors import KNeighborsClassifier
• [x] 參數
  
  • n_neighbors : 一個整數，指定k值。
  • weights : 一字符串或者可調用對象，指定投票權重類型。即這些鄰居投票權可以爲相同或者不同。
    
    • uniform : 本節點的所有鄰居節點的投票權重都相等。
    • distance : 本節點的所有鄰居節點的投票權重與距離成反比，即越近節點，其投票權重越大。
    • [callable] : 一個可調用對象，它傳入距離的數組，返回同樣形狀的權重數組。
  • algorithm : 一個字符串，指定最近鄰的算法，可以爲下：
    
    • ball_tree : 使用BallTree算法。
    • kd_tree : 使用KDTree算法。
    • brute : 使用暴力搜索算法。
    • auto : 自動決定最合適算法。
  • leaf_size : 一個整數，指定BallTree或者KDTree葉節點的規模。它影響樹的構建和查詢速度。
  • metric : 一個字符串，指定距離度量。默認爲‘minkowski’(閔可夫斯基)距離。
  • P : 整數值。
    
    • p=1： 對應曼哈頓距離。
    • p=2 : 對應歐氏距離。
  • n_jobs : 並行性。默認爲-1表示派發任務到所有計算機的CPU上。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 預測模型。
  • score(X,y) : 返回在(X,y)上預測的準確率(accuracy)。
  • predict_proba(X) : 返回樣本爲每種標記的概率。
  • kneighbors([X,n_neighbors,return_distace]) : 返回樣本點的k鄰近點。如果return_distance=True，同時還返回到這些近鄰點的距離。
  • kneighbors_graph([X,n_neighbors,mode]) : 返回樣本點的連接圖。

4.2 KNN迴歸器

KNeighborsRegressor是scikit-learn提供的K近鄰算法迴歸模型，其原型爲：
class sklearn.neighbors.KNeighborsRegressor(n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30, p=2, metric=’minkowski’, metric_params=None, n_jobs=1, **kwargs)

• [x] 導包
  
  • from sklearn.neighbors import KNeighborsRegressor
• [x] 參數
  
  • n_neighbors : 一個整數，指定k值。
  • weights : 一字符串或者可調用對象，指定投票權重類型。即這些鄰居投票權可以爲相同或者不同。
    
    • uniform : 本節點的所有鄰居節點的投票權重都相等。
    • distance : 本節點的所有鄰居節點的投票權重與距離成反比，即越近節點，其投票權重越大。
    • [callable] : 一個可調用對象，它傳入距離的數組，返回同樣形狀的權重數組。
  • algorithm : 一個字符串，指定最近鄰的算法，可以爲下：
    
    • ball_tree : 使用BallTree算法。
    • kd_tree : 使用KDTree算法。
    • brute : 使用暴力搜索算法。
    • auto : 自動決定最合適算法。
  • leaf_size : 一個整數，指定BallTree或者KDTree葉節點的規模。它影響樹的構建和查詢速度。
  • metric : 一個字符串，指定距離度量。默認爲‘minkowski’(閔可夫斯基)距離。
  • P : 整數值。
    
    • p=1： 對應曼哈頓距離。
    • p=2 : 對應歐氏距離。
  • n_jobs : 並行性。默認爲-1表示派發任務到所有計算機的CPU上。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 預測模型。
  • score(X,y) : 返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y^i ，則：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2
  • predict_proba(X) : 返回樣本爲每種標記的概率。
  • kneighbors([X,n_neighbors,return_distace]) : 返回樣本點的k鄰近點。如果return_distance=True，同時還返回到這些近鄰點的距離。
  • kneighbors_graph([X,n_neighbors,mode]) : 返回樣本點的連接圖。

---

5. 數據降維

5.1 PCA

PCA是scikit-learn中提供的PCA模型，其原型爲：
class sklearn.decomposition.PCA(n_components=None, copy=True, whiten=False, svd_solver=’auto’, tol=0.0, iterated_power=’auto’, random_state=None)

• [x] 導包
  
  • from sklearn.decomposition import PCA
• [x] 參數
  
  • n_components : 一個整數，指定降維後的維數。
    
    • None : 則選擇它的值爲min(n_samples,n_features)。
    • 字符mle：則使用MLE算法來猜測降維後的維度。
    • 如爲大於0小於1的浮點數：指定降維後的維數佔原來的維數百分比。
  • copy ： 一個布爾值。如果爲False，則直接用原始數據來訓練，結果會覆蓋原始數據所在的數組。
  • whiten ：一個布爾值。如果爲True，則將特徵向量除以n_samples倍的特徵值，從而保證非相關輸出的方差爲1。
  • tol : 一個浮點數，指定arpack他特徵值求解器的收斂閾值（如果爲0，則自動選擇）。
  • svd_solver :字符串。
    
    • auto :默認根據X的形狀和n_component選擇。如果輸入數據大於500x500，提取的組件數低於數據最小尺寸的80%，則啓用更有效的「隨機」方法。否則，完整的SVD將被計算並可選擇性地截斷。
    • full ：調用scipy.linalg.svd包進行分解選擇。
    • arpack：通過調用scipy.sparse.linalg.svds來進行截斷，但必須滿足0 < n_components < X.shape1。
    • randomized：用Halko等方法隨機運行SVD。
  • random_state : 整數或者一個RandomState實例或者None。
    
    • 整數：控制僞隨機數種子。
    • None ：使用Numpy進行隨機。
  • iterated_power : 整數或者‘auto’。指定使用svd_solver = ‘randomized’方法進行高效迭代。
• [x] 屬性
  
  • components_ : 主成分數組。
  • explained_variance_ : 每個成分對應的explained variance。
  • explained_variance_ratio_ : 一個數組，元素是每個主分成的explained variance的比例。
  • mean_ : 一個數組，元素是每個特徵的統計平均值。
  • n_components_ : 一個整數，指示主成分有多少各元素。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • transform(X) : 執行降維。
  • fit_transform(X,y) : 訓練模型並降維。
  • inverse_transform(X) : 執行升維(逆向操作)，將數據從低維空間逆向轉換到原始空間。

5.2 超大規模數據降維IncrementalPCA

IncrementalPCA適用於超大規模數據，它可以將數據分批加載進內存。其原型爲：
class sklearn.decomposition.IncrementalPCA(n_components=None, whiten=False, copy=True, batch_size=None)

• [x] 導包
  
  • from sklearn.decomposition import IncrementalPCA
• [x] 參數
  
  • n_components : 一個整數，指定降維後的維數。
    
    • None : 則選擇它的值爲min(n_samples,n_features)。
    • 字符mle：則使用MLE算法來猜測降維後的維度。
    • 如爲大於0小於1的浮點數：指定降維後的維數佔原來的維數百分比。
  • bath_size : 一個整數或者None，指定每個批次訓練時，使用的樣本數量。只有當調用fit()/partial_fit()方法時纔會用到該參數。
    
    • 爲None ： 則有算法自動推斷。
  • copy ： 一個布爾值。如果爲False，則直接用原始數據來訓練，結果會覆蓋原始數據所在的數組。
  • whiten ：一個布爾值。如果爲True，則將特徵向量除以n_samples倍的特徵值，從而保證非相關輸出的方差爲1。
• [x] 屬性
  
  • components_ : 主成分數組。
  • explained_varicance_ : 每個成分對應的explained variance。
  • explained_variance_ratio_ : 一個數組，元素是每個主分成的explained variance的比例。
  • mean_ : 一個數組，元素是每個特徵的統計平均值。
  • var_ : 一個數組，元素是每個特徵的經驗方差。每調用一次partial_fit()方法，就會更新一次該屬性。
  • n_components_ : 一個整數，指示主成分有多少各元素。
  • n_samples_seen_ : 一個整數，只是目前已經處理了多少個樣本。每調用一次partial_fit()方法，就會更新一次該屬性。每調用一個fit()方法就會清零該屬性。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • partial_fit(X,y) : 繼續訓練模型，使用bath_size個樣本。
  • transform(X) : 執行降維。
  • fit_transform(X,y) : 訓練模型並降維。
  • inverse_transform(X) : 執行升維(逆向操作)，將數據從低維空間逆向轉換到原始空間。

---

6. 聚類

6.1 K均值（KMeans）聚類

KMeans是scikitlearn提供的k均值聚類算法模型，其原型爲：
class sklearn.cluster.KMeans(n_clusters=8, init=’k-means++’, n_init=10, max_iter=300, tol=0.0001, precompute_distances=’auto’, verbose=0, random_state=None, copy_x=True, n_jobs=1, algorithm=’auto’)

• [x] 導包
  
  • from sklearn.cluster import KMeans
• [x] 參數
  
  • n_clusters : 一個整數，指定分類數量。
  • init : 一個字符串，指定初始均值向量的策略，可以爲以下值：
    
    • k-means++ : 該初始化策略選擇的初始均值向量相互之間都距離較遠，它的效果較好。
    • random ： 從數據集中隨機選擇K個樣本作初始均值向量。
    • 提供一個數組，數組形狀爲(n_clusters,n_features)，該數組作爲初始均值向量。
  • n_init : 一個整數，指定了k均值算法的運行次數，每一次都會選擇一組不同的初始化均值向量，最終算法會選擇最佳的分類簇作爲最終結果。
  • algorithm : 一個字符串。
    
    • ‘full’ ：使用EM算法。
    • ‘elkan’ ：使用三角變化使得該算法更具效率，但不支持稀疏數據。
    • ‘auto’ ： 使用‘full’處理稀疏數據，使用‘elkan’處理稠密數據。
  • max_iter : 一個整數，指定了單輪kmeans算法中最大的迭代次數。算法總的迭代次數爲：max_iter*n_init。
  • precompute_distances : 可以爲布爾值或者字符串‘auto’。該參數指定是否提前計算好樣本之間的距離（如果提前計算需要更多內存，但是算法會運行更快）。
    
    • ‘auto’ ：如果n_samples*n_clusters > 12 million，則不提前計算。
    • ‘True’ ：提前計算。
    • ‘False’ ：不提前計算。
  • tol : 一個浮點數，指定了算法收斂的閾值。
  • n_jobs : 一個整數，指定任務並行時指定CPU數量，如果爲-1使用全部CPU。
  • verbose : 一個整數。如果爲0，則不輸出日誌，如果爲1，則每隔一段時間打印一次日誌，如果大於1則打印日誌更頻繁。
  • random_state : 一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數：指定了隨機數生成器種子。
    • 如果爲RandomState實例，則指定了隨機數生成器。
    • 如果爲None，則使用默認的隨機數生成器。
  • copy_x : 布爾值，用於precompute_distances=True的情況。
    
    • 如果爲True，則預計算距離的時候，並不會修改原數據。
    • 如果爲False，則預計算距離的時候，會修改原數據用於節省內存，然後當算法結束時，會將原數據返還，但可能會因爲浮點數的表示會產生一些誤差。
• [x] 屬性
  
  • cluster_centers_ : 給出分類簇的均值向量。
  • labels_ : 給出每個樣本所屬的簇的標記。
  • inertia_ : 給出了每個樣本距離他們各自最近的簇中心的距離之和。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • fit_predict(X,y) : 訓練模型並預測每個樣本所屬的簇。它等價於先調用fit()方法，後調用predict()方法。
  • predict(X) : 預測樣本所屬的簇。
  • score(X,y) : 給出了樣本距離簇中心的偏移量的相反數。

6.2 密度（DBSCAN）聚類

DBSCAN是scikit-learn提供的密度聚類算法模型，其原型爲：
class sklearn.cluster.DBSCAN(eps=0.5, min_samples=5, metric=’euclidean’, algorithm=’auto’, leaf_size=30, p=None, n_jobs=1)

• [x] 導包
  
  • from sklearn.cluster import DBSCAN
• [x] 參數
  
  • eps : ϵ 參數，用於確定鄰域的大小。
  • min_samples : MinPts參數，用於判斷核心對象。
  • metric : 一個字符串或者可調用對象，用於計算距離。如果是字符串，則必須是在metrics.pairwise.calculate_distance中指定它。
  • algorithm : 一個字符串，用於計算兩點距離並找出最近鄰點，可以爲如下：
    
    • ‘auto’：由算法自動選取合適的算法。
    • ‘ball_tree’ : 用ball樹來搜索。
    • ‘kd_tree’ : 用kd樹來搜索。
    • ‘brute’ ：暴力搜索。
  • leaf_size : 一個整數，用於指定當algorithm=ball_tree或者kd_tree時，樹的葉節點大小。該參數會影響構建樹、搜索最近鄰速度，同時影響存儲樹的內存。
  • p : 閔可夫斯基距離p參數。
• [x] 屬性
  
  • core_sample_indices_ : 核心樣本在原始訓練集中的位置。
  • components_ ： 核心樣本的一份副本。
  • labels_ : 每個樣本所屬的簇的標記。對於噪聲樣本，其簇標記爲-1樣本
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • fit_predict(X,y) ： 訓練模型並預測每個樣本的所屬簇的標記。

6.3 層次（AgglomerativeClustering）聚類

AgglomerativeClustering是scikitlearn提供的層次聚類算法模型。其原型爲：
class sklearn.cluster.AgglomerativeClustering(n_clusters=2, affinity=’euclidean’, memory=Memory(cachedir=None), connectivity=None, compute_full_tree=’auto’, linkage=’ward’, pooling_func=)

• [x] 導包
  
  • from sklearn.cluster import AgglomerativeClustering
• [x] 參數
  
  • n_clusters : 一個整數，指定分類簇的數量。
  • connectivity : 一個數組或者可調用對象或者爲None，用於指定連接矩陣，它指出了每個樣本可連接的樣本。
  • affinity : 一個字符串或者可調用對象，用於計算距離，可以爲：’euclidean’,’l1’,’l2’,’manhattan’,’cosine’,’precomputed’,如果linkage=’ward’，則’affinity’必須是’euclidean’。
  • memory : 用於緩存輸出結果，默認不緩存。
  • compute_full_tree : 通常當訓練了n_clusters之後，訓練過程就停止，但是如果爲True則會繼續訓練從而生成一棵完整的樹。
  • linkage : 一個字符串，用於指定鏈接算法。
    
    • ‘ward’ ：單鏈接single-linkage算法，採用 dmin 。
    • ‘complete’ ：全連接complete-linkage算法，採用 dmax 。
    • ‘average’ ：均連接average-linkage算法，採用 davg 。
  • pooling_func : 一個可調用對象，它的輸入是一組特徵值，輸出是一個數值。
• [x] 屬性
  
  • labels_ : 每個樣本的簇標記。
  • n_leaves_ : 分層樹的葉節點數量。
  • n_components : 連接圖中聯通分量的估計值。
  • children : 一個數組，給出了每個非葉節點中的子節點數量。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • fit_predict(X,y) : 訓練模型並預測每個樣本所屬的標記。

---

7. 支持向量機

• 優點
  支持向量機SVM本質上是非線性方法，在樣本量比較少的時候，容易抓住數據和特徵之間的非線性關係(相比線性分類方法如Logistic regression)，因此尅解決非線性問題、可以避免神經網絡結構選擇和局部極小點的問題，可以提高泛化性，可以解決高維問題。
• 缺點
  SVM對缺失數據敏感，對非線性問題沒有解決的通用方案，必須謹慎選擇核函數來處理，計算複雜度高。主流算法是 O(n2) ，這樣對大規模數據就顯得無力了。不僅如此，由於其存在兩個對結果影響相當大的超參數(如果是RBF核，是核函數的參數gamma以及懲罰項C)，這兩個超參數無法通過概率方法進行計算，只能通過窮舉試驗求出，計算時間要遠高於不少類似的非線性分類器。

7.1 線性分類SVM

LinearSVC實現了線性分類支持向量機，它是根據liblinear實現的，可以用於二分類、也可以用於多分類，其原型爲：
class sklearn.svm.LinearSVC(penalty=’l2’, loss=’squared_hinge’, dual=True, tol=0.0001, C=1.0, multi_class=’ovr’, fit_intercept=True, intercept_scaling=1, class_weight=None, verbose=0, random_state=None, max_iter=1000)

• [x] 導包
  
  • from sklearn.svm import LinearSVC
• [x] 參數
  
  • C : 一個浮點數，罰項係數。C值越大對誤分類的懲罰越大。
  • loss : 字符串，表示損失函數，可以爲如下值：
    
    • ‘hinge’：此時爲合頁損失(他是標準的SVM損失函數)。
    • ‘squared_hinge’：合頁損失函數的平方。
  • penalty :字符串，指定‘l1’或者‘l2’，罰項範數。默認爲‘l2’(他是標準的SVM範數)。
  • dual :布爾值，如果爲True，則解決對偶問題，如果是False，則解決原始問題。當n_samples>n_features是，傾向於採用False。
  • tol :浮點數，指定終止迭代的閾值。
  • multi_class :字符串，指定多分類的分類策略。
    
    • ‘ovr’ ：採用one-vs-rest策略。
    • ‘crammer_singer’:多類聯合分類，很少用，因爲他計算量大，而且精度不會更佳，此時忽略loss,penalty,dual等參數。
  • fit_intecept :布爾值，如果爲True，則計算截距，即決策樹中的常數項，否則忽略截距。
  • intercept_scaling :浮點值，若提供了，則實例X變成向量[X,intercept_scaling]。此時相當於添加一個人工特徵，該特徵對所有實例都是常數值。
  • class_weight : 可以是個字典或者字符串‘balanced’。指定個各類的權重，若未提供，則認爲類的權重爲1。
    
    • 如果是字典，則指定每個類標籤的權重。
    • 如果是‘balanced’，則每個累的權重是它出現頻數的倒數。
  • verbose :一個整數，表示是否開啓verbose輸出。
  • random_state :一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數，指定隨機數生成器的種子。
    • 如果爲RandomState，指定隨機數生成器。
    • 如果爲None，指定使用默認的隨機數生成器。
  • max_iter :一個整數，指定最大迭代數。
• [x] 屬性
  
  • coef_ : 一個數組，它給出了各個特徵的權重。
  • intercept_ : 一個數組，它給出了截距。
• [x] 方法
  
  • fit(X,y) :訓練模型。
  • predict(X) : 用模型進行預測，返回預測值。
  • score(X,y) : 返回在(X,y)上的預測準確率。

7.2 非線性分類SVM

SVC實現了非線性分類支持向量機，它是根據libsvm實現的，可以用於二分類，也可以用於多分類，其原型爲：
class sklearn.svm.SVC(C=1.0, kernel=’rbf’, degree=3, gamma=’auto’, coef0=0.0, shrinking=True, probability=False, tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1, decision_function_shape=None, random_state=None)

• [x] 導包
  
  • from sklearn.svm import SVC
• [x] 參數
  
  • C : 一個浮點數，罰項係數，C越大懲罰越大。
  • kernel : 一個字符串，指定核函數。
    
    • ’linear’ :線性核 K(x⃗ ,z⃗ )=x⃗ ∗z⃗  。
    • ‘poly’:多項式核 K(x⃗ ,z⃗ )=(γ(x⃗ ∗z⃗ +1)+r)p ，其中 p 由 degree 參數決定， γ 由 gamma 參數決定， r 由 coef0 參數決定。
    • ‘rbf’:默認值，高斯核函數 K(x⃗ ,z⃗ )=exp(−γ||x⃗ −z⃗ ||2) ，其中 γ 由 gamma 參數決定。
    • ‘sigmoid’: K(x⃗ ,z⃗ )=tanh(γ(x⃗ ,z⃗ )+r) ，其中 γ 由 gamma 參數決定， r 由 coef0 參數指定。
    • ‘precomputed’:表示提供了kernel matrix，或者提供一個可調用對象，該對象用於計算kernel matrix。
  • degree : 一個整數，指定當核函數是多項式核函數時，多項式的係數。對於其它核函數該參數無效。
  • gamma :一個浮點數。當核函數是’rbf’,’poly’,’sigmoid’時，核函數的係數。如果爲‘auto’，則表示係數爲 1n_features 。
  • coef0 :浮點數，用於指定核函數中的自由項。只有當核函數是‘poly’和‘sigmoid’時有效。
  • probability :布爾值。如果爲True，則會進行概率估計。它必須在訓練之前設定好，且會拖慢訓練速度。
  • shrinking : 布爾值。如果爲True，則使用啓發式收縮。
  • tol :浮點數，指定終止迭代的閾值。
  • cache_size :浮點值，指定了kernel cache的大小，單位爲MB。
  • class_weight : 可以是個字典，或者字符串‘balanced’。指定各個類的權重，若爲提供，則權重均爲1。
  • verbose :是否開啓verbose輸出。
  • max_iter :一個整數，指定最大迭代次數。
  • decision_function_shape :爲字符串或者None，指定決策函數的形狀。
    
    • ‘ovr’ ：採用one-vs-rest策略，那麼決策函數形狀是(n_samples,n_classes)。
    • ‘ovo’ ：使用‘one-vs-one’準則，那麼決策函數形狀是(n_samples,n_classes*(n_classes-1)/2)。
  • random_state :一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數，指定隨機數生成器的種子。
    • 如果爲RandomState，指定隨機數生成器。
    • 如果爲None，指定使用默認的隨機數生成器。
• [x] 屬性
  
  • support_ :一個數組，形狀爲[n_SV]，支持向量的下標。
  • support_vectors_ :一個數組，形狀爲[n_SV,n_features]，支持向量。
  • n_support_ :一個數組，形狀爲[n_class]，每一個分類的支持向量個數。
  • dual_coef_ : 一個數組，形狀爲[n_class-1,n_SV]。對偶問題中，在分類決策函數中每一個支持向量的係數。
  • coef_ :一個數組，形狀爲[n_class-1,n_features]。原始問題中，每個特徵的係數。只有在linear kernel中有效。
  • intercept_:一個數組，形狀爲[n_class*(n_class-1)/2]。決策函數中的常數項。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型進行預測，返回預測值。
  • score(X,y) : 返回在（X，y）上預測的準確度。
  • predict_log_proba(X) : 返回一個數組，數組的元素依次是X預測爲各個類別的概率的對數值。
  • predict_proba(X) :返回一個數組，數組的元素依次是X預測爲各個類別的概率。

7.3 線性迴歸SVR

LinearSVR實現了線性迴歸支持向量機，它基於liblinear實現，其原型爲：
class sklearn.svm.LinearSVR(epsilon=0.0, tol=0.0001, C=1.0, loss=’epsilon_insensitive’, fit_intercept=True, intercept_scaling=1.0, dual=True, verbose=0, random_state=None, max_iter=1000)

• [x] 導包
  
  • from sklearn.svm import LinearSVR
• [x] 參數
  
  • C: 一個浮點值，罰項係數。
  • loss:字符串，表示損失函數，可以爲：
    
    • ‘epsilon_insensitive’:此時損失函數爲 Lϵ (標準的SVR)
    • ‘squared_epsilon_insensitive’:此時損失函數爲 Lϵ
  • epsilon:浮點數，用於lose中的 ϵ 參數。
  • dual:布爾值。如果爲True，則解決對偶問題，如果是False則解決原始問題。
  • tol:浮點數，指定終止迭代的閾值。
  • fit_intercept:布爾值。如果爲True，則計算截距，否則忽略截距。
  • intercept_scaling:浮點值。如果提供了，則實例X變成向量[X,intercept_scaling]。此時相當於添加了一個人工特徵，該特徵對所有實例都是常數值。
  • verbose:是否開啓verbose輸出。
  • random_state:一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數，指定隨機數生成器的種子。
    • 如果爲RandomState，指定隨機數生成器。
    • 如果爲None，指定使用默認的隨機數生成器。
  • max_iter:一個整數，指定最大迭代次數。
• [x] 屬性
  
  • coef_:一個數組，他給出了各個特徵的權重。
  • intercept_:一個數組，他給出了截距，及決策函數中的常數項。
• [x] 方法
  
  • fit(X,y):訓練模型。
  • predict(X):用模型進行預測，返回預測值。
  • score(X,y):返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y^i ，則：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

7.4 非線性迴歸SVR

SVR實現了非線性迴歸支持向量機，它是基於libsvm實現的，其原型爲：
class sklearn.svm.SVR(kernel=’rbf’, degree=3, gamma=’auto’, coef0=0.0, tol=0.001, C=1.0, epsilon=0.1, shrinking=True, cache_size=200, verbose=False, max_iter=-1)

• [x] 導包
  
  • from sklearn.svm import SVR
• [x] 參數
  
  • C:一個浮點值，罰項係數。
  • epsilon:浮點數，用於lose中的 ϵ 參數。
  • kernel: 一個字符串，指定核函數。
    
    • ’linear’ :線性核 K(x⃗ ,z⃗ )=x⃗ ∗z⃗  。
    • ‘poly’:多項式核 K(x⃗ ,z⃗ )=(γ(x⃗ ∗z⃗ +1)+r)p ，其中 p 由 degree 參數決定， γ 由 gamma 參數決定， r 由 coef0 參數決定。
    • ‘rbf’:默認值，高斯核函數 K(x⃗ ,z⃗ )=exp(−γ||x⃗ −z⃗ ||2) ，其中 γ 由 gamma 參數決定。
    • ‘sigmoid’: K(x⃗ ,z⃗ )=tanh(γ(x⃗ ,z⃗ )+r) ，其中 γ 由 gamma 參數決定， r 由 coef0 參數指定。
    • ‘precomputed’:表示提供了kernel matrix，或者提供一個可調用對象，該對象用於計算kernel matrix。
  • degree:一個整數，指定當核函數是多項式核函數時，多項式的係數。對於其它核函數該參數無效。
  • gamma:一個浮點數。當核函數是’rbf’,’poly’,’sigmoid’時，核函數的係數。如果爲‘auto’，則表示係數爲 1n_features 。
  • coef0:浮點數，用於指定核函數中的自由項。只有當核函數是‘poly’和‘sigmoid’時有效。
  • shrinking:布爾值。如果爲True，則使用啓發式收縮。
  • tol:浮點數，指定終止迭代的閾值。
  • cache_size:浮點值，指定了kernel cache的大小，單位爲MB。
  • verbose:指定是否開啓verbose輸出。
  • max_iter:一個整數，指定最大迭代步數。
• [x] 屬性
  
  • support_ :一個數組，形狀爲[n_SV]，支持向量的下標。
  • support_vectors_ :一個數組，形狀爲[n_SV,n_features]，支持向量。
  • n_support_ :一個數組，形狀爲[n_class]，每一個分類的支持向量個數。
  • dual_coef_ : 一個數組，形狀爲[n_class-1,n_SV]。對偶問題中，在分類決策函數中每一個支持向量的係數。
  • coef_ :一個數組，形狀爲[n_class-1,n_features]。原始問題中，每個特徵的係數。只有在linear kernel中有效。
  • intercept_:一個數組，形狀爲[n_class*(n_class-1)/2]。決策函數中的常數項。
• [x] 方法
  
  • fit(X,y) : 訓練模型。
  • predict(X) : 用模型進行預測，返回預測值。
  • score(X,y):返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y^i ，則：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2

---

8. 集成學習

概念

• 每個基分類器的精度必須要> 12 。
• 基分類器之間要有差異性。

Bagging

Bagging這個詞是根據BootstrapAggregation這個詞組創造的一個新詞。Bootstrap，是指拔靴帶，是幫助穿靴子時的一個紐帶。統計學上的Bootstrap一般稱爲自助法，是指從m個訓練樣本中隨機有放回的抽樣m次，重複此過程T次。然後對每個樣本集進行訓練，最後結果由T個訓練器投票表決最終答案。

Bagging典型的代表就是Random Forest，不過隨機森林與Bagging有點不同：

• 基分類器只能是決策樹。
• 隨機森林不光是樣本隨機，也有特徵隨機。

由於以上兩點，在樣本充足的條件下，隨機森林一般的結果都比任何一個單分類器效果要好。

Boosting

Boosting就不同了，他是一種串行模型，取的是全部樣本來學習，但是它會進行多次重複學習，並且每次學習都會在之前一步的學習結果上在進行學習和改進，改進的是對上一次分錯的節點的權重，爲的是在本次學習中上次分錯的節點在本次會得到更多關注，進而分類正確。Adaboost是Boosting的一種。

下面給出一個例題，可以對Boosting有一個直觀的認識：

x	0	1	2	3	4	5	6	7	8	9
y	1	1	1	-1	-1	-1	1	1	1	-1

• 閾值v取2.5時誤差率爲0.3（x < 2.5時取1，x > 2.5時取-1，則6 7 8分錯，誤差率爲0.3）
• 閾值v取8.5時誤差率爲0.3（x < 8.5時取1，x > 8.5時取-1，則3 4 5分錯，誤差率爲0.3）
• 所以無論閾值v取2.5，還是8.5，總得分錯3個樣本，故可任取其中任意一個如2.5。
  

對於m=2步：

• 閾值v取2.5時誤差率爲0.1666*3（x < 2.5時取1，x > 2.5時取-1，則6 7 8分錯，誤差率爲0.1666*3）。
• 閾值v取5.5時誤差率最低爲0.0715*4（x > 5.5時取1，x < 5.5時取-1，則0 1 2 9分錯，誤差率爲0.0715*3 + 0.0715）。
• 閾值v取8.5時誤差率爲0.0715*3（x < 8.5時取1，x > 8.5時取-1，則3 4 5分錯，誤差率爲0.0715*3）。

爲何採用加法模型

• 問：如果不採用加法模型，只是把上一次分類錯的點的權重調高不行嗎？
• 答：這樣做不可行，因爲在每次權值更改後，錯分類樣本的權重被增大，那麼就會出現當錯分樣本權值很大時相當於把正確分類樣本的權重變小了，會導致正確樣本錯分。

8.1 AdaBoost

算法過程

下面介紹AdaBoost算法的過程：
1. 初始化訓練數據的權值分佈：

D1=(w11,w12,w13,...,w1N),w1i=1N,i=1,2,...,N

2. 對 m=1,2,...,M
(a) 使用具有權值分佈 Dm 的訓練集學習，得到基本分類器：

Gm(x):X−>{−1,+1}

(b) 計算 Gm(x) 在訓練數據集上的分類誤差：

em=P(Gm(xi)≠yi)=∑Ni=1wmiI(Gm(xi)≠yi)∑Ni=1wmi=∑i=1NwmiI(Gm(xi)≠yi)

上式中，∑i=1Nwmi=1

(c) 計算 Gm(x) 的係數：

αm=12log1−emem

(d) 更新數據集的權值分佈：

Dm+1=(wm+1,1,wm+1,2,...,wm+1,N)

wm+1,i=wmiZme−αmyiGm(xi)

其中，Zm=∑i=1Nwmie−αmyiGm(xi)，是規範化因子

(e) 重複 (a)−(d) 步 m 次得到 m 個權值 a 和 m 個基分類器 G(x)

3. 構建基本分類器的線性組合：

f(x)=∑m=1MamGm(x)

4. 最終得到分類器：

G(x)=sign(f(x))=sign(∑m=1MamGm(x))

基分類器權值 a 與訓練數據集權值 w 的分析

1. 先來看基分類器的權值 α ，公式如下:

α=12log1−emem

我們知道AdaBoost是將多個弱分類器組合起來形成一個很強的分類器，但這裏有個隱含條件：弱分類器。什麼叫弱分類器？意思就是在效果上比隨機猜想要好的分類器。比如二分類問題，隨機猜想的正確率是0.5，所以說弱分類器的正確率一定要比0.5高，於是它的錯誤率 em<0.5 ，所以 α會隨着em的減小而增大 ，這是什麼意思？意思是，如果我的基分類器的錯誤率很小，也就是正確率很大，那麼在衆多基分類器中我給予它很大的權值 α ，讓它能發揮更大的作用。

2. 再來看訓練數據集分佈的權值分配，公式如下：

wm+1,i=wm,iZme−amyiG(xi)=⎧⎩⎨wm,iZme−am，Gm(xi)=yiwm,iZmeam，Gm(xi)≠yi

由公式可知，對訓練集的樣例正確分類與錯誤分類之間，錯誤分類樣本的權值被放大： e2αm=1−emem 倍，所以，在下一輪學習中將會被更大關注。

AdaBoost推導

AdaBoost模型是由基本分類器組成的 加法模型 ，損失函數是 指數函數 。

1. 加法模型： f(x)=∑Mm=1αmGm(x)

2. 損失函數： L(y,f(x))=e−yf(x)

3. 每次訓練後的基分類器都是乘以 α 再與前一個模型線性相加，所以對於第 m−1 次訓練後模型爲：

fm−1(x)=fm−2(x)+αm−1Gm−1(x)=α1G1(x)+...+αm−1Gm−1(x)

4. 於是，在第 m 次訓練後有： fm(x)=fm−1(x)+αmGm(x)

5. 目標是每一次的損失在訓練集上最小，所以最小化目標函數爲：

(αm,Gm(x))=min∑i=1Ne−yifm(xi)=min∑i=1Ne−yi[fm−1(xi)+αmGm(x)]=min∑i=1Ne−yifm−1(xi)−yiαmGm(x)=min∑i=1Nwmie−yiαmGm(x)

上式中，將 e−yifm−1(xi)=wmi ，因爲 wmi 既不依賴 α 也不依賴與 G ，所以與最小無關。

6. 於是，有：

min∑i=1Nwmie−yiαmGm(x)=min∑yi=Gm(xi)wmie−a+∑yi≠Gm(xi)wmiea=min(e−a∑i=1NwmiI(yi=Gm(xi))+eα∑i=1NwmiI(yi≠Gm(xi)))=min(e−a∑i=1Nwmi[1−I(yi≠Gm(xi))]+eα∑i=1NwmiI(yi≠Gm(xi)))=min((eα−e−α)∑i=1NwmiI(yi≠Gm(xi))+e−a∑i=1Nwmi)

所以，我們得到了優化的目標函數：

L(α)=(eα−e−α)∑i=1NwmiI(yi≠Gm(xi))+e−a∑i=1Nwmi

7. 對6中的目標函數關於 α 求導，令 ∂L(α)∂α=0 ，求的最小值：

∂L(α)∂α=−e−a∑i=1Nwmi+(eα+e−α)∑i=1NwmiI(yi≠Gm(xi))=0

等價於：

(eα+e−α)∑i=1NwmiI(yi≠Gm(xi))=e−a∑i=1Nwmi

因爲： em=∑Ni=1wmiI(yi≠Gm(xi)) ， ∑Ni=1wmi=1

所以有：

(eα+e−α)em=e−a

等價於：

e2a=1−emem

解得：

α=12ln1−emem

8. 由於之前有個假設： wmi=e−yifm−1(xi) ，而這個式子又可以化爲：

wm+1,i=e−yifm(xi)=e−yi[fm−1(xi)+αmGm(xi)]=wmie−yiαmGm(xi)

於是，就有了更新公式：

wm+1,i=wmie−yiαmGm(xi)

，與AdaBoost算法中的更新公式只差了個規範化因子而已。

8.1.1 AdaBoostClassifier

AdaBoostClassifier是scikit-learn提供的AdaBoost分類器，其原型爲：
class sklearn.ensemble.AdaBoostClassifier(base_estimator=None, n_estimators=50, learning_rate=1.0, algorithm=’SAMME.R’, random_state=None)

• [x] 導包
  
  • from sklearn.ensemble import AdaBoostClassifier
• [x] 參數
  
  • base_estimator:是一個基礎分類器對象。默認爲DecisionTreeClassifier。該基礎分類器必須支持帶權重的學習。
  • n_estimator:一個整數，指定基礎分類器的數量（默認50）。當然如果訓練集已經完美地訓練好了，可能算法會提前停止。此時基礎分類器的數量少於該值。
  • learning_rate:爲浮點數。默認爲1.它用於每一步的步長，防止步長太大而跨過了極值點。通常learning_rate越小，則需要的基礎分類器數量就會越多，因此在learning_rate和n_estimators之間會有所折中。learning_rate爲下式中的v。
    
    Hm(x⃗ )=Hm−1(x⃗ )+vαmhm(x⃗ )
  • algorithm:一個字符串，指定算法，該算法用於多分類問題，默認爲’SAMME.R’。
    
    • ‘SAMME.R’:使用SAMME.R算法，基礎分類器必須支持計算類別的概率。
    • ‘SAMME’：使用SAMME算法。
  • random_state:一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數，指定隨機數生成器的種子。
    • 如果爲RandomState，指定隨機數生成器。
    • 如果爲None，指定使用默認的隨機數生成器。
• [x] 屬性
  
  • estimators_:所有訓練過的基礎分類器。
  • classes_:所有類別標籤。
  • n_classes_:類別數量。
  • estimator_weights_:每個基礎分類器的權重。
  • estimator_errors_:每個基礎分類器的分類誤差。
  • feature_importances_:每個特徵的重要性。
• [x] 方法
  
  • fit(X,y):訓練模型。
  • predict(X):用模型進行預測，返回預測值。
  • predict_log_proba(X):返回一個數組，數組的元素依次是X預測爲各個類別的概率的對數值。
  • predict_proba(X):返回一個數組，數組的元素依次是X預測爲各個類別的概率值。
  • score(X,y):返回在（X,y）上預測的準確率。
  • staged_predict(X):返回一個數組，數組元素依次是每一輪迭代結束時尚未完成的集成分類器的預測值。
  • staged_predict_proba(X):返回一個二維數組，數組元素依次是每一輪迭代結束時尚未完成的集成分類器預測X爲各個類別的概率值。
  • staged_score(X,y):返回一個數組，數組元素依次是每一輪迭代結束時尚未完成的集成分類器的預測準確率。

---

8.1.2 AdaBoostRegressor

AdaBoostRegressor是scikit-learn提供的AdaBoost迴歸器，其原型爲：
class sklearn.ensemble.AdaBoostRegressor(base_estimator=None, n_estimators=50, learning_rate=1.0, loss=’linear’, random_state=None)

• [x] 導包
  
  • from sklearn.ensemble import AdaBoostRegressor
• [x] 參數
• base_estimator:是一個基礎迴歸器對象。默認爲DecisionTreeRegressor。該基礎迴歸器必須支持帶權重的學習。
  
  • n_estimator:一個整數，指定基礎迴歸器的數量（默認50）。當然如果訓練集已經完美地訓練好了，可能算法會提前停止。此時基礎迴歸器的數量少於該值。
  • learning_rate:爲浮點數。默認爲1.它用於每一步的步長，防止步長太大而跨過了極值點。通常learning_rate越小，則需要的基礎迴歸器數量就會越多，因此在learning_rate和n_estimators之間會有所折中。learning_rate爲下式中的v。
    
    Hm(x⃗ )=Hm−1(x⃗ )+vαmhm(x⃗ )
  • loss:一個字符串，指定了損失函數，可以爲：
    
    • ‘linear’：線性損失函數（默認）。
    • ‘square’：平方損失函數。
    • ‘exponential’：指數損失函數。
  • random_state:一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數，指定隨機數生成器的種子。
    • 如果爲RandomState，指定隨機數生成器。
    • 如果爲None，指定使用默認的隨機數生成器。
• [x] 屬性
  
  • estimators_:所有訓練過的基礎迴歸器。
  • estimator_weights_:每個基礎迴歸器的權重。
  • estimator_errors_:每個基礎迴歸器的誤差。
  • feature_importances_:每個特徵的重要性。
• [x] 方法
  
  • fit(X,y):訓練模型。
  • predict(X):用模型進行預測，返回預測值。
  • score(X,y):返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y^i ，則：
    
    score=1−∑Ttest(yi−y^i)2(yi−y¯)2
  • staged_predict(X):返回一個數組，數組元素依次是每一輪迭代結束時尚未完成的集成迴歸器的預測值。
  • staged_score(X,y):返回一個數組，數組元素依次是每一輪迭代結束時尚未完成的集成迴歸器的預測準確率。

---

8.2 Gradient Tree Boosting

8.2.1 GradientBoostingClassifier

GradientBoostingClassifier是scikit-learn提供的梯度提升決策樹，其原型爲：
class sklearn.ensemble.GradientBoostingClassifier(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.0, max_depth=3, min_impurity_split=1e-07, init=None, random_state=None, max_features=None, verbose=0, max_leaf_nodes=None, warm_start=False, presort=’auto’)

• [x] 導包
  
  • from sklearn.ensemble import GradientBoostingClassifier
• [x] 參數
  
  • loss:一個字符串，指定損失函數，可以爲：
    
    • ‘deviance’：此時損失函數爲對數損失函數： L(Y,P(Y|X))=−logP(Y|X) 。
    • ‘exponential’：此時使用指數損失函數，注意該損失只能用於二分類。
  • n_estimators :一個整數，指定基礎決策樹的數量（默認爲100）。GBDT對過擬合有很好的魯棒性，因此該值越大越好。
  • learning_rate:爲浮點數。默認爲1.它用於每一步的步長，防止步長太大而跨過了極值點。通常learning_rate越小，則需要的基礎分類器數量就會越多，因此在learning_rate和n_estimators之間會有所折中。learning_rate爲下式中的v。
    
    Hm(x⃗ )=Hm−1(x⃗ )+vαmhm(x⃗ )
    。
  • max_depth:一個整數或者None，指定每一個基礎決策樹模型的最大深度。如果max_leaf_noeds不是None，則忽略此參數。
  • criterion:字符串。用來衡量切分的質量。默認爲‘friedman_mse’。可以爲：
    
    • ‘friedman_mse’ 改進型的均方誤差。
    • ‘mse’：標準的均方誤差。
    • ‘mae’：平均絕對誤差。
  • min_samples_split:一個整數，指定了每個基礎決策樹模型分裂所需最小樣本數。
  • min_samples_leaf:一個整數，指定了每個基礎決策樹模型葉節點所包含的最小樣本數。
  • min_weight_fraction_leaf:一個浮點數。葉節點的最小加權權重。當不提供sample_weight時，樣本的權重是相等的。
  • subsample:一個浮點數，指定了提取原始訓練集中的一個子集用於訓練基礎決策樹，該參數就是子集佔原始訓練集的大小， 0<subsample<1 。
  • max_features:一個整數，浮點數或者None。代表節點分裂是參與判斷的最大特徵數。整數爲個數，浮點數爲所佔比重。
  • max_leaf_nodes:爲整數或者None，指定了每個基礎決策樹模型的最大葉節點數量。
  • min_impurity_split:一個浮點數，指定在樹生長的過程中，節點分裂的閾值，默認爲1e-7。
  • init:一個基礎分類器對象或者None，該分類器對象用於執行初始的預測。如果爲None，則使用loss.init_estimator。
  • verbose:一個整數，如果爲0則不輸出日誌，如果爲1，則每隔一段時間輸出日誌，大於1輸出日誌會更頻繁。
  • warm_start:布爾值。當爲True是，則繼續使用上一次訓練結果。否則重新開始訓練。
  • random_state:一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數，指定隨機數生成器的種子。
    • 如果爲RandomState，指定隨機數生成器。
    • 如果爲None，指定使用默認的隨機數生成器。
  • presort:一個布爾值或者‘auto’，是否對數據進行顯示以加速最佳分割的發現。默認情況下，自動模式將在密集的數據上使用presorting，默認爲稀疏數據的正常排序。在稀疏的數據上設置顯示值將會導致錯誤。
• [x] 屬性
  
  • feature_importance_:一個數組，給出了每個特徵的重要性（值越高重要性越大）。
  • oob_improvement_:一個數組，給出了每增加一棵基礎決策樹，在包外估計（即測試集）的損失函數的改善情況。（及損失函數減少值）。
  • train_score_:一個數組，給出每增加一棵基礎決策樹，在訓練集上的損失函數的值。
  • loss:具體損失函數對象。
  • init:初始預測使用的分類器。
  • estimators_:一個數組，給出了每個基礎決策樹。
• [x] 方法
  
  • fit(X,y):訓練模型。
  • predict(X):用模型進行預測，返回預測值。
  • predict_log_proba(X):返回一個數組，數組的元素依次是X預測爲各個類別的概率的對數值。
  • predict_proba(X):返回一個數組，數組的元素依次是X預測爲各個類別的概率值。
  • score(X,y):返回在（X,y）上預測的準確率。
  • staged_predict(X):返回一個數組，數組元素依次是每一輪迭代結束時尚未完成的集成分類器的預測值。
  • staged_predict_proba(X):返回一個二維數組，數組元素依次是每一輪迭代結束時尚未完成的集成分類器預測X爲各個類別的概率值。

---

8.2.2 GradientBoostingRegressor

GradientBoostingRegressor是scikit-learn提供的提升樹迴歸模型，其原型爲：
class sklearn.ensemble.GradientBoostingRegressor(loss=’ls’, 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.0, max_depth=3, min_impurity_split=1e-07, init=None, random_state=None, max_features=None, alpha=0.9, verbose=0, max_leaf_nodes=None, warm_start=False, presort=’auto’)

• [x] 導包
  
  • from sklearn.ensemble import GradientBoostingRegressor
• [x] 參數
• loss:一個字符串，指定損失函數，可以爲：
  - ‘ls’：此時損失函數爲平方損失函數。
  - ‘lad’：此時使用指數絕對值損失函數。
  - ‘quantile’：分位數迴歸（分位數指的是百分之幾），採用絕對值損失。
  - ‘huber’：此時損失函數爲上述兩者的綜合，即誤差較小時，採用平方損失，在誤差較大時，採用絕對值損失。通過 α 參數的指定比例，該損失函數的定義爲：
  LHuber=⎧⎩⎨12(y−f(x))2，if|y−f(x)|≤aa|y−f(x)|−12a2，else
  
  
  • alpha:一個浮點數，只有當loss=‘huber’或者loss=‘quantile’時纔有效。
  • n_estimators :一個整數，指定基礎決策樹的數量（默認爲100）。GBRT對過擬合有很好的魯棒性，因此該值越大越好。
  • learning_rate:爲浮點數。默認爲1.它用於每一步的步長，防止步長太大而跨過了極值點。通常learning_rate越小，則需要的基礎迴歸器數量就會越多，因此在learning_rate和n_estimators之間會有所折中。learning_rate爲下式中的v。
    
    Hm(x⃗ )=Hm−1(x⃗ )+vαmhm(x⃗ )
    。
  • max_depth:一個整數或者None，指定每一個基礎決策樹模型的最大深度。如果max_leaf_noeds不是None，則忽略此參數。
  • criterion:字符串。用來衡量切分的質量。默認爲‘friedman_mse’。可以爲：
    
    • ‘friedman_mse’ 改進型的均方誤差。
    • ‘mse’：標準的均方誤差。
    • ‘mae’：平均絕對誤差。
  • min_samples_split:一個整數，指定了每個基礎決策樹模型分裂所需最小樣本數。
  • min_samples_leaf:一個整數，指定了每個基礎決策樹模型葉節點所包含的最小樣本數。
  • min_weight_fraction_leaf:一個浮點數。葉節點的最小加權權重。當不提供sample_weight時，樣本的權重是相等的。
  • subsample:一個浮點數，指定了提取原始訓練集中的一個子集用於訓練基礎決策樹，該參數就是子集佔原始訓練集的大小， 0<subsample<1 。
  • max_features:一個整數，浮點數或者None。代表節點分裂是參與判斷的最大特徵數。整數爲個數，浮點數爲所佔比重。
  • max_leaf_nodes:爲整數或者None，指定了每個基礎決策樹模型的最大葉節點數量。
  • min_impurity_split:一個浮點數，指定在樹生長的過程中，節點分裂的閾值，默認爲1e-7。
  • init:一個基礎迴歸器對象或者None，該回歸器對象用於執行初始的預測。如果爲None，則使用loss.init_estimator。
  • verbose:一個整數，如果爲0則不輸出日誌，如果爲1，則每隔一段時間輸出日誌，大於1輸出日誌會更頻繁。
  • warm_start:布爾值。當爲True是，則繼續使用上一次訓練結果。否則重新開始訓練。
  • random_state:一個整數或者一個RandomState實例，或者None。
    
    • 如果爲整數，指定隨機數生成器的種子。
    • 如果爲RandomState，指定隨機數生成器。
    • 如果爲None，指定使用默認的隨機數生成器。
  • presort:一個布爾值或者‘auto’，是否對數據進行顯示以加速最佳分割的發現。默認情況下，自動模式將在密集的數據上使用presorting，默認爲稀疏數據的正常排序。在稀疏的數據上設置顯示值將會導致錯誤。
• [x] 屬性
  
  • feature_importance_:一個數組，給出了每個特徵的重要性（值越高重要性越大）。
  • oob_improvement_:一個數組，給出了每增加一棵基礎決策樹，在包外估計（即測試集）的損失函數的改善情況。（及損失函數減少值）。
  • train_score_:一個數組，給出每增加一棵基礎決策樹，在訓練集上的損失函數的值。
  • loss:具體損失函數對象。
  • init:初始預測使用的分類器。
  • estimators_:一個數組，給出了每個基礎決策樹。
• [x] 方法
  
  • fit(X,y):訓練模型。
  • predict(X):用模型進行預測，返回預測值。
  • predict_log_proba(X):返回一個數組，數組的元素依次是X預測爲各個類別的概率的對數值。
  • predict_proba(X):返回一個數組，數組的元素依次是X預測爲各個類別的概率值。
  • score(X,y):返回性能得分。設預測集爲 Ttest ，真實值爲 yi ，真實值的均值爲 y¯ ，預測值爲 y