機器學習總結-sklearn參數解釋

本文轉自：lytforgood

機器學習總結-sklearn參數解釋

實驗數據集選取：

1分類數據選取 load_iris 鳶尾花數據集

from sklearn.datasets import load_iris
data = load_iris()
data.data[[10, 25, 50]]
data.target[[10, 25, 50]]
list(data.target_names)
list(data.feature_names)

2回歸數據選取

from sklearn.datasets import load_boston
boston = load_boston()
print(boston.data.shape)
boston.feature_names

數據集-切分為 訓練集-驗證集

GBDT

系數說明參考
GradientBoostingClassifier支持二進制和多類分類

from  sklearn.datasets  import  make_hastie_10_2
from  sklearn.ensemble  import  GradientBoostingClassifier
X, y = make_hastie_10_2(random_state=0)
X_train, X_test = X[:2000], X[2000:]
y_train, y_test = y[:2000], y[2000:]

clf = GradientBoostingClassifier(
loss='deviance',  ##損失函數默認deviance  deviance具有概率輸出的分類的偏差
n_estimators=100, ##默認100 回歸樹個數 弱學習器個數
learning_rate=0.1,  ##默認0.1學習速率/步長0.0-1.0的超參數  每個樹學習前一個樹的殘差的步長
max_depth=3,   ## 默認值為3每個回歸樹的深度  控制樹的大小 也可用葉節點的數量max leaf nodes控制
subsample=1,  ##樹生成時對樣本采樣 選擇子樣本<1.0導致方差的減少和偏差的增加
min_samples_split=2, ##生成子節點所需的最小樣本數 如果是浮點數代表是百分比
min_samples_leaf=1, ##葉節點所需的最小樣本數  如果是浮點數代表是百分比
max_features=None, ##在尋找最佳分割點要考慮的特征數量auto全選/sqrt開方/log2對數/None全選/int自定義幾個/float百分比
max_leaf_nodes=None, ##葉節點的數量 None不限數量
min_impurity_split=1e-7, ##停止分裂葉子節點的閾值
verbose=0,  ##打印輸出 大於1打印每棵樹的進度和性能
warm_start=False, ##True在前面基礎上增量訓練(重設參數減少訓練次數) False默認擦除重新訓練
random_state=0  ##隨機種子-方便重現
).fit(X_train, y_train)  ##多類別回歸建議使用隨機森林
print clf.score(X_test, y_test)  ##tp / (tp + fp)正實例占所有正實例的比例
test_y= clf.predict(X_test)
test_y= clf.predict_proba(X_test)[:,1] ##預測概率
print clf.feature_importances_  ##輸出特征重要性
print clf.train_score_  ##每次迭代后分數
##test_y= clf.predict(X_test)
##from sklearn.metrics import precision_score
##precision_score(test_y, y_test,average='micro')  ##tp / (tp + fp)
##from sklearn import metrics
##fpr, tpr, thresholds = metrics.roc_curve(y_test, test_y)
##print("auc : %.4g" % metrics.auc(fpr, tpr)
y_pre= clf.predict(X_test)
y_pro= clf.predict_proba(X_test)[:,1] ##預測概率
from sklearn import metrics
fpr, tpr, thresholds = metrics.roc_curve(y_test, y_pro)
print("auc : %.4g" % metrics.auc(fpr, tpr),x%10000/100,x%100) #auc表示一
print "AUC Score (Train): %f" % metrics.roc_auc_score(y_test, y_pro) #auc表示二 兩種方式等價
print"Accuracy : %.4g" % metrics.accuracy_score(y_test, y_pre) ##等價於clf.score(X_test, y_test)

sklearn.ensemble.GradientBoostingRegressor

import numpy as np
from sklearn.metrics import mean_squared_error
from sklearn.datasets import make_friedman1
from sklearn.ensemble import GradientBoostingRegressor

X, y = make_friedman1(n_samples=1200, random_state=0, noise=1.0)
X_train, X_test = X[:200], X[200:]
y_train, y_test = y[:200], y[200:]
est = GradientBoostingRegressor(
loss='ls',      ##默認ls損失函數'ls'是指最小二乘回歸lad'（最小絕對偏差）'huber'是兩者的組合
n_estimators=100, ##默認100 回歸樹個數 弱學習器個數
learning_rate=0.1,  ##默認0.1學習速率/步長0.0-1.0的超參數  每個樹學習前一個樹的殘差的步長
max_depth=3,   ## 默認值為3每個回歸樹的深度  控制樹的大小 也可用葉節點的數量max leaf nodes控制
subsample=1,  ##用於擬合個別基礎學習器的樣本分數 選擇子樣本<1.0導致方差的減少和偏差的增加
min_samples_split=2, ##生成子節點所需的最小樣本數 如果是浮點數代表是百分比
min_samples_leaf=1, ##葉節點所需的最小樣本數  如果是浮點數代表是百分比
max_features=None, ##在尋找最佳分割點要考慮的特征數量auto全選/sqrt開方/log2對數/None全選/int自定義幾個/float百分比
max_leaf_nodes=None, ##葉節點的數量 None不限數量
min_impurity_split=1e-7, ##停止分裂葉子節點的閾值
verbose=0,  ##打印輸出 大於1打印每棵樹的進度和性能
warm_start=False, ##True在前面基礎上增量訓練 False默認擦除重新訓練 增加樹
random_state=0  ##隨機種子-方便重現
).fit(X_train, y_train)
mean_squared_error(y_test, est.predict(X_test))

import numpy as np
from sklearn import ensemble
from sklearn import datasets
from sklearn.utils import shuffle
from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score

boston = datasets.load_boston()
X, y = shuffle(boston.data, boston.target, random_state=13) #抽取
X = X.astype(np.float32)
offset = int(X.shape[0] * 0.9) #設置取0.9做樣本
X_train, y_train = X[:offset], y[:offset]
X_test, y_test = X[offset:], y[offset:]
##參數可以放入一個字典當中
params = {'n_estimators': 500, 'max_depth': 4, 'min_samples_split': 2,
          'learning_rate': 0.01, 'loss': 'ls'}
clf = ensemble.GradientBoostingRegressor(**params)
clf.fit(X_train, y_train)
mse = mean_squared_error(y_test, clf.predict(X_test))
r2 = r2_score(y_test, clf.predict(X_test))
print("MSE: %.4f" % mse) ##輸出均方誤差
print("r^2 on test data : %f" % r2) ##R^2 擬合優度=(預測值-均值)^2之和/(真實值-均值)^2之和

##繪圖查看
import matplotlib.pyplot as plt
test_score = np.zeros((params['n_estimators'],), dtype=np.float64)
##計算每次迭代分數變化
for i, y_pred in enumerate(clf.staged_predict(X_test)):
    test_score[i] = clf.loss_(y_test, y_pred)

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.title('Deviance')
plt.plot(np.arange(params['n_estimators']) + 1, clf.train_score_, 'b-',
         label='Training Set Deviance')
plt.plot(np.arange(params['n_estimators']) + 1, test_score, 'r-',
         label='Test Set Deviance')
plt.legend(loc='upper right')
plt.xlabel('Boosting Iterations')
plt.ylabel('Deviance')
##輸出特征重要性
feature_importance = clf.feature_importances_
# make importances relative to max importance
feature_importance = 100.0 * (feature_importance / feature_importance.max())
sorted_idx = np.argsort(feature_importance)  ##返回的是數組值從小到大的索引值
pos = np.arange(sorted_idx.shape[0]) + .5
plt.subplot(1, 2, 2)
plt.barh(pos, feature_importance[sorted_idx], align='center')
plt.yticks(pos, boston.feature_names[sorted_idx])
plt.xlabel('Relative Importance')
plt.title('Variable Importance')
plt.show()

網格搜索調整超參數

from sklearn.model_selection import GridSearchCV
clf=GridSearchCV(
estimator, ##模型
param_grid, ##參數字典或者字典列表
scoring=None,  ##評價分數的方法
fit_params=None, ##fit的參數 字典
n_jobs=1, ##並行數  -1全部啟動
iid=True,  ##每個cv集上等價
refit=True,  ##使用整個數據集重新編制最佳估計量
cv=None,   ##幾折交叉驗證None默認3
verbose=0, ##控制詳細程度：越高，消息越多
pre_dispatch='2*n_jobs',  ##總作業的確切數量
error_score='raise',  ##錯誤時選擇的分數
return_train_score=True   ##如果'False'，該cv_results_屬性將不包括訓練得分
)

clf.cv_results_  ##結果表 常看mean_test_score std_test_score
clf.cv_results_.keys()  ##clf.cv_results_['mean_test_score']
clf.best_estimator_  ##最優模型
clf.best_score_  ##最優分數
clf.best_params_  ##最優參數

from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import classification_report
from sklearn import metrics
from  sklearn.datasets  import  make_hastie_10_2
from  sklearn.ensemble  import  GradientBoostingClassifier
X, y = make_hastie_10_2(random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)##test_size測試集合所占比例
##設置參數
tuned_parameters= [{'n_estimators':range(20,81,10),
                  'max_depth':range(3,14,2),
                  'learning_rate':[0.1, 0.5, 1.0],
                  'subsample':[0.6,0.7,0.75,0.8,0.85,0.9]
                  }]
##設置分數計算方法精度/召回
scores = ['precision', 'recall']  ## roc_auc
for score in scores:
    print("評測選擇 %s" % score)
    clf = GridSearchCV(GradientBoostingClassifier(), tuned_parameters, cv=5,
                       scoring='%s_macro' % score)
    clf.fit(X_train, y_train)
    print(clf.best_params_)
    means = clf.cv_results_['mean_test_score']  ##tp / (tp + fp)
    stds = clf.cv_results_['std_test_score']
    for mean, std, params in zip(means, stds, clf.cv_results_['params']):
        print("%0.3f (+/-%0.03f) for %r" % (mean, std * 2, params))
    ##預測
    y_true, y_pred = y_test, clf.predict(X_test)
    ##y_true, y_pred = y_test, clf.predict_proba(X_test)
    print(classification_report(y_true, y_pred))
    ##print"Accuracy : %.4g" % metrics.accuracy_score(y_true, y_pred)

XGBoost

xgb原始

from sklearn.model_selection import train_test_split
from sklearn import metrics
from  sklearn.datasets  import  make_hastie_10_2
import xgboost as xgb
#記錄程序運行時間
import time 
start_time = time.time()
X, y = make_hastie_10_2(random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)##test_size測試集合所占比例
#xgb矩陣賦值
xgb_train = xgb.DMatrix(X_train, label=y_train)
xgb_test = xgb.DMatrix(X_test,label=y_test)
##參數
params={
'booster':'gbtree',
'silent':1 ,#設置成1則沒有運行信息輸出，最好是設置為0.
#'nthread':7,# cpu 線程數 默認最大
'eta': 0.007, # 如同學習率
'min_child_weight':3, 
# 這個參數默認是 1，是每個葉子里面 h 的和至少是多少，對正負樣本不均衡時的 0-1 分類而言
#，假設 h 在 0.01 附近，min_child_weight 為 1 意味着葉子節點中最少需要包含 100 個樣本。
#這個參數非常影響結果，控制葉子節點中二階導的和的最小值，該參數值越小，越容易 overfitting。
'max_depth':6, # 構建樹的深度，越大越容易過擬合
'gamma':0.1,  # 樹的葉子節點上作進一步分區所需的最小損失減少,越大越保守，一般0.1、0.2這樣子。
'subsample':0.7, # 隨機采樣訓練樣本
'colsample_bytree':0.7, # 生成樹時進行的列采樣 
'lambda':2,  # 控制模型復雜度的權重值的L2正則化項參數，參數越大，模型越不容易過擬合。
#'alpha':0, # L1 正則項參數
#'scale_pos_weight':1, #如果取值大於0的話，在類別樣本不平衡的情況下有助於快速收斂。
#'objective': 'multi:softmax', #多分類的問題
#'num_class':10, # 類別數，多分類與 multisoftmax 並用
'seed':1000, #隨機種子
#'eval_metric': 'auc'
}
plst = list(params.items())
num_rounds = 100 # 迭代次數
watchlist = [(xgb_train, 'train'),(xgb_test, 'val')]

#訓練模型並保存
# early_stopping_rounds 當設置的迭代次數較大時，early_stopping_rounds 可在一定的迭代次數內准確率沒有提升就停止訓練
model = xgb.train(plst, xgb_train, num_rounds, watchlist,early_stopping_rounds=100,pred_margin=1)
#model.save_model('./model/xgb.model') # 用於存儲訓練出的模型
print "best best_ntree_limit",model.best_ntree_limit 
y_pred = model.predict(xgb_test,ntree_limit=model.best_ntree_limit)
print ('error=%f' % (  sum(1 for i in range(len(y_pred)) if int(y_pred[i]>0.5)!=y_test[i]) /float(len(y_pred))))  
#輸出運行時長
cost_time = time.time()-start_time
print "xgboost success!",'\n',"cost time:",cost_time,"(s)......"

xgb使用sklearn接口(推薦)
官方
會改變的函數名是：
eta -> learning_rate
lambda -> reg_lambda
alpha -> reg_alpha

from sklearn.model_selection import train_test_split
from sklearn import metrics
from  sklearn.datasets  import  make_hastie_10_2
from xgboost.sklearn import XGBClassifier
X, y = make_hastie_10_2(random_state=0)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)##test_size測試集合所占比例
clf = XGBClassifier(
silent=0 ,#設置成1則沒有運行信息輸出，最好是設置為0.是否在運行升級時打印消息。
#nthread=4,# cpu 線程數 默認最大
learning_rate= 0.3, # 如同學習率
min_child_weight=1, 
# 這個參數默認是 1，是每個葉子里面 h 的和至少是多少，對正負樣本不均衡時的 0-1 分類而言
#，假設 h 在 0.01 附近，min_child_weight 為 1 意味着葉子節點中最少需要包含 100 個樣本。
#這個參數非常影響結果，控制葉子節點中二階導的和的最小值，該參數值越小，越容易 overfitting。
max_depth=6, # 構建樹的深度，越大越容易過擬合
gamma=0,  # 樹的葉子節點上作進一步分區所需的最小損失減少,越大越保守，一般0.1、0.2這樣子。
subsample=1, # 隨機采樣訓練樣本 訓練實例的子采樣比
max_delta_step=0,#最大增量步長，我們允許每個樹的權重估計。
colsample_bytree=1, # 生成樹時進行的列采樣 
reg_lambda=1,  # 控制模型復雜度的權重值的L2正則化項參數，參數越大，模型越不容易過擬合。
#reg_alpha=0, # L1 正則項參數
#scale_pos_weight=1, #如果取值大於0的話，在類別樣本不平衡的情況下有助於快速收斂。平衡正負權重
#objective= 'multi:softmax', #多分類的問題 指定學習任務和相應的學習目標
#num_class=10, # 類別數，多分類與 multisoftmax 並用
n_estimators=100, #樹的個數
seed=1000 #隨機種子
#eval_metric= 'auc'
)
clf.fit(X_train,y_train,eval_metric='auc')
y_true, y_pred = y_test, clf.predict(X_test)
print"Accuracy : %.4g" % metrics.accuracy_score(y_true, y_pred)
#回歸
#m_regress = xgb.XGBRegressor(n_estimators=1000,seed=0)

網格搜索

可以先固定一個參數 最優化后繼續調整
第一步：確定學習速率和tree_based 給個常見初始值 根據是否類別不平衡調節
max_depth,min_child_weight,gamma,subsample,scale_pos_weight
max_depth=3 起始值在4-6之間都是不錯的選擇。
min_child_weight比較小的值解決極不平衡的分類問題eg:1
subsample, colsample_bytree = 0.8: 這個是最常見的初始值了
scale_pos_weight = 1: 這個值是因為類別十分不平衡。
第二步： max_depth 和 min_weight 對最終結果有很大的影響
'max_depth':range(3,10,2),
'min_child_weight':range(1,6,2)
先大范圍地粗調參數，然后再小范圍地微調。
第三步：gamma參數調優
'gamma':[i/10.0 for i in range(0,5)]
第四步：調整subsample 和 colsample_bytree 參數
'subsample':[i/100.0 for i in range(75,90,5)],
'colsample_bytree':[i/100.0 for i in range(75,90,5)]
第五步：正則化參數調優
'reg_alpha':[1e-5, 1e-2, 0.1, 1, 100]
'reg_lambda'
第六步：降低學習速率
learning_rate =0.01,

from sklearn.model_selection import GridSearchCV
tuned_parameters= [{'n_estimators':[100,200,500],
                  'max_depth':[3,5,7], ##range(3,10,2)
                  'learning_rate':[0.5, 1.0],
                  'subsample':[0.75,0.8,0.85,0.9]
                  }]
tuned_parameters= [{'n_estimators':[100,200,500,1000]
                  }]
clf = GridSearchCV(XGBClassifier(silent=0,nthread=4,learning_rate= 0.5,min_child_weight=1, max_depth=3,gamma=0,subsample=1,colsample_bytree=1,reg_lambda=1,seed=1000), param_grid=tuned_parameters,scoring='roc_auc',n_jobs=4,iid=False,cv=5)  
clf.fit(X_train, y_train)
##clf.grid_scores_, clf.best_params_, clf.best_score_
print(clf.best_params_)
y_true, y_pred = y_test, clf.predict(X_test)
print"Accuracy : %.4g" % metrics.accuracy_score(y_true, y_pred) 
y_proba=clf.predict_proba(X_test)[:,1]
print "AUC Score (Train): %f" % metrics.roc_auc_score(y_true, y_proba)               

from sklearn.model_selection import GridSearchCV
parameters= [{'learning_rate':[0.01,0.1,0.3],'n_estimators':[1000,1200,1500,2000,2500]}]
clf = GridSearchCV(XGBClassifier(
             max_depth=3,
             min_child_weight=1,
             gamma=0.5,
             subsample=0.6,
             colsample_bytree=0.6,
             objective= 'binary:logistic', #邏輯回歸損失函數
             scale_pos_weight=1,
             reg_alpha=0,
             reg_lambda=1,
             seed=27
            ), 
            param_grid=parameters,scoring='roc_auc')  
clf.fit(X_train, y_train)
print(clf.best_params_)  
y_pre= clf.predict(X_test)
y_pro= clf.predict_proba(X_test)[:,1] 
print "AUC Score : %f" % metrics.roc_auc_score(y_test, y_pro) 
print"Accuracy : %.4g" % metrics.accuracy_score(y_test, y_pre)              

輸出特征重要性

import pandas as pd
import matplotlib.pylab as plt
feat_imp = pd.Series(clf.booster().get_fscore()).sort_values(ascending=False)
feat_imp.plot(kind='bar', title='Feature Importances')
plt.ylabel('Feature Importance Score')
plt.show()

GBDT輸出新特征+blending/stacking/聯級森林

R生成新特征

library(xgboost)  
training <-iris  
x1=rep(0,50)  
x2=rep(1,50)  
x3=rep(2,50)  
x=c(x1,x2,x3)  
d=training[,c(1:4)]  
training=data.frame(d,x)   
ind<-sample(2,nrow(training),replace=TRUE,prob=c(0.7,0.3)) #對數據分成兩部分，70%訓練數據，30%檢測數據  traindata<- training [ind==1,]  #訓練集  
testdata<- training [ind==2,]  #測試集  
traindatax=as.matrix(traindata[,c(1:4)])  
traindatay=as.matrix(traindata[,5])  
testdatax=as.matrix(testdata[,c(1:4)])  
testdatay=as.matrix(testdata[,5])  
##多分類 默認從0開始
bst <- xgboost(data = traindatax, label = traindatay, max.depth = 3, eta = 0.1,nround = 1000 ,objective = "multi:softmax",num_class=3) 
pred <- predict(bst, testdatax) 
new_feature_train <- predict(bst, traindatax,predleaf = T)
new_feature_test <- predict(bst, testdatax,predleaf = T)
t_train=cbind(traindatax,new_feature_train,traindatay)
t_test=cbind(testdatax,new_feature_test,testdatay)

python生成GBDT特征

clf.apply(X_train)