貝葉斯全域性優化（LightGBM調參）

　　這裡結合Kaggle比賽的一個資料集，記錄一下使用貝葉斯全域性優化和高斯過程來尋找最佳引數的方法步驟。

　　1.安裝貝葉斯全域性優化庫

　　從pip安裝最新版本

　　pip install bayesian-optimization

　　2.載入資料集

　　import pandas as pd

　　import numpy as np

　　from sklearn.model_selection import StratifiedKFold

　　from scipy.stats import rankdata

　　from sklearn import metrics

　　import lightgbm as lgb

　　import warnings

　　import gc

　　pd.set_option('display.max_columns', 200)

　　train_df = pd.read_csv('../input/train.csv')

　　test_df = pd.read_csv('../input/test.csv')

　　目標變數的分佈

　　target = 'target'

　　predictors = train_df.columns.values.tolist()[2:]

　　train_df.target.value_counts()

　　

　　問題是不平衡。這裡使用50%分層行作為保持行，以便驗證集獲得最佳引數。 稍後將在最終模型擬閤中使用5折交叉驗證。

　　bayesian_tr_index, bayesian_val_index = list(StratifiedKFold(n_splits=2,

　　shuffle=True, random_state=1).split(train_df, train_df.target.values))[0]

　　這些bayesian_tr_index和bayesian_val_index索引將用於貝葉斯優化，作為訓練和驗證資料集的索引。

　　3.黑盒函式優化(LightGBM)

　　在載入資料時，為LightGBM建立黑盒函式以查詢引數。

　　def LGB_bayesian(

　　num_leaves, # int

　　min_data_in_leaf, # int

　　learning_rate,

　　min_sum_hessian_in_leaf, # int

　　feature_fraction,

　　lambda_l1,

　　lambda_l2,

　　min_gain_to_split,

　　max_depth):

　　# LightGBM expects next three parameters need to be integer. So we make them integer

　　num_leaves = int(num_leaves)

　　min_data_in_leaf = int(min_data_in_leaf)

　　max_depth = int(max_depth)

　　assert type(num_leaves) == int

　　assert type(min_data_in_leaf) == int

　　assert type(max_depth) == int

　　param = {

　　'num_leaves': num_leaves,

　　'max_bin': 63,

　　'min_data_in_leaf': min_data_in_leaf,

　　'learning_rate': learning_rate,

　　'min_sum_hessian_in_leaf': min_sum_hessian_in_leaf,

　　'bagging_fraction': 1.0,

　　'bagging_freq': 5,

　　'feature_fraction': feature_fraction,

　　'lambda_l1': lambda_l1,

　　'lambda_l2': lambda_l2,

　　'min_gain_to_split': min_gain_to_split,

　　'max_depth': max_depth,

　　'save_binary': True,

　　'seed': 1337,

　　'feature_fraction_seed': 1337,

　　'bagging_seed': 1337,

　　'drop_seed': 1337,

　　'data_random_seed': 1337,

　　'objective': 'binary',

　　'boosting_type': 'gbdt',

　　'verbose': 1,

　　'metric': 'auc',

　　'is_unbalance': True,

　　'boost_from_average': False,

　　}

　　xg_train = lgb.Dataset(train_df.iloc[bayesian_tr_index][predictors].values,

　　label=train_df.iloc[bayesian_tr_index][target].values,

　　feature_name=predictors,

　　free_raw_data = False

　　)

　　xg_valid = lgb.Dataset(train_df.iloc[bayesian_val_index][predictors].values,

　　label=train_df.iloc[bayesian_val_index][target].values,

　　feature_name=predictors,

　　free_raw_data = False

　　)

　　num_round = 5000

　　clf = lgb.train(param, xg_train, num_round, valid_sets = [xg_valid], verbose_eval=250, early_stopping_rounds = 50)

　　predictions = clf.predict(train_df.iloc[bayesian_val_index][predictors].values, num_iteration=clf.best_iteration)

　　score = metrics.roc_auc_score(train_df.iloc[bayesian_val_index][target].values, predictions)

　　return score

　　上面的LGB_bayesian函式將作為貝葉斯優化的黑盒函式。 我已經在LGB_bayesian函式中為LightGBM定義了trainng和validation資料集。

　　LGB_bayesian函式從貝葉斯優化框架獲取num_leaves，min_data_in_leaf，learning_rate，min_sum_hessian_in_leaf，feature_fraction，lambda_l1，lambda_l2，min_gain_to_split，max_depth的值。 請記住，對於LightGBM，num_leaves，min_data_in_leaf和max_depth應該是整數。 但貝葉斯優化會傳送連續的函式。 所以我強制它們是整數。 我只會找到它們的最佳引數值。 讀者可以增加或減少要優化的引數數量。

　　現在需要為這些引數提供邊界，以便貝葉斯優化僅在邊界內搜尋。

　　bounds_LGB = {

　　'num_leaves': (5, 20),

　　'min_data_in_leaf': (5, 20),

　　'learning_rate': (0.01, 0.3),

　　'min_sum_hessian_in_leaf': (0.00001, 0.01),

　　'feature_fraction': (0.05, 0.5),

　　'lambda_l1': (0, 5.0),

　　'lambda_l2': (0, 5.0),

　　'min_gain_to_split': (0, 1.0),

　　'max_depth':(3,15),

　　}

　　讓我們將它們全部放在BayesianOptimization物件中

　　from bayes_opt import BayesianOptimization

　　LGB_BO = BayesianOptimization(LGB_bayesian, bounds_LGB, random_state=13)

　　現在，讓我們來優化key space (parameters)：

　　print(LGB_BO.space.keys)

　　

　　我建立了BayesianOptimization物件(LGB_BO)，在呼叫maxime之前它不會工作。在呼叫之前，解釋一下貝葉斯優化物件(LGB_BO)的兩個引數，我們可以傳遞給它們進行最大化：

　　init_points：我們想要執行的隨機探索的初始隨機執行次數。 在我們的例子中，LGB_bayesian將被執行n_iter次。

　　n_iter：執行init_points數後，我們要執行多少次貝葉斯優化執行。

　　現在，是時候從貝葉斯優化框架呼叫函式來最大化。 我允許LGB_BO物件執行5個init_points和5個n_iter。

　　init_points = 5

　　n_iter = 5

　　print('-' * 130)

　　with warnings.catch_warnings():

　　warnings.filterwarnings('ignore')

　　LGB_BO.maximize(init_points=init_points, n_iter=n_iter, acq='ucb', xi=0.0, alpha=1e-6)

　　優化完成後，讓我們看看我們得到的最大值是多少。

　　LGB_BO.max['target']

　　

　　引數的驗證AUC是0.89， 讓我們看看引數:

　　LGB_BO.max['params']

　　現在我們可以將這些引數用於我們的最終模型!

　　BayesianOptimization庫中還有一個很酷的選項。 你可以探測LGB_bayesian函式，如果你對最佳引數有所瞭解，或者您從其他kernel獲取引數。 我將在此複製並貼上其他核心中的引數。 你可以按照以下方式進行探測：

　　LGB_BO.probe(

　　params={'feature_fraction': 0.1403,

　　'lambda_l1': 4.218,

　　'lambda_l2': 1.734,

　　'learning_rate': 0.07,

　　'max_depth': 14,

　　'min_data_in_leaf': 17,

　　'min_gain_to_split': 0.1501,

　　'min_sum_hessian_in_leaf': 0.000446,

　　'num_leaves': 6},

　　lazy=True, #

　　)

　　好的，預設情況下這些將被懶惰地探索(lazy = True)，這意味著只有在你下次呼叫maxime時才會評估這些點。 讓我們對LGB_BO物件進行最大化呼叫。

　　LGB_BO.maximize(init_points=0, n_iter=0) # remember no init_points or n_iter

　　最後，通過屬性LGB_BO.res可以獲得探測的所有引數列表及其相應的目標值。

　　for i, res in enumerate(LGB_BO.res):

　　print("Iteration {}: \n\t{}".format(i, res))

　　我們在調查中獲得了更好的驗證分數!和以前一樣，我只執行LGB_BO 10次。在實踐中，我將它增加到100。

　　LGB_BO.max['target']

　　LGB_BO.max['params']

　　讓我們一起構建一個模型使用這些引數。

　　4.訓練LightGBM模型

　　param_lgb = {

　　'num_leaves': int(LGB_BO.max['params']['num_leaves']), # remember to int here

　　'max_bin': 63,

　　'min_data_in_leaf': int(LGB_BO.max['params']['min_data_in_leaf']), # remember to int here

　　'learning_rate': LGB_BO.max['params']['learning_rate'],

　　'min_sum_hessian_in_leaf': LGB_BO.max['params']['min_sum_hessian_in_leaf'],

　　'bagging_fraction': 1.0,

　　'bagging_freq': 5,

　　'feature_fraction': LGB_BO.max['params']['feature_fraction'],

　　'lambda_l1': LGB_BO.max['params']['lambda_l1'],

　　'lambda_l2': LGB_BO.max['params']['lambda_l2'],

　　'min_gain_to_split': LGB_BO.max['params']['min_gain_to_split'],

　　'max_depth': int(LGB_BO.max['params']['max_depth']), # remember to int here

　　'save_binary': True,

　　'seed': 1337,

　　'feature_fraction_seed': 1337,

　　'bagging_seed': 1337,

　　'drop_seed': 1337,

　　'data_random_seed': 1337,

　　'objective': 'binary',

　　'boosting_type': 'gbdt',

　　'verbose': 1,

　　'metric': 'auc',

　　'is_unbalance': True,

　　'boost_from_average': False,

　　}

　　如您所見，我將LGB_BO的最佳引數儲存到param_lgb字典中，它們將用於訓練5折的模型。

　　Kfolds數量： 無錫婦科檢查醫院 http://www.87554006.com/

　　nfold = 5

　　gc.collect()

　　skf = StratifiedKFold(n_splits=nfold, shuffle=True, random_state=2019)

　　oof = np.zeros(len(train_df))

　　predictions = np.zeros((len(test_df),nfold))

　　i = 1

　　for train_index, valid_index in skf.split(train_df, train_df.target.values):

　　print("\nfold {}".format(i))

　　xg_train = lgb.Dataset(train_df.iloc[train_index][predictors].values,

　　label=train_df.iloc[train_index][target].values,

　　feature_name=predictors,

　　free_raw_data = False

　　)

　　xg_valid = lgb.Dataset(train_df.iloc[valid_index][predictors].values,

　　label=train_df.iloc[valid_index][target].values,

　　feature_name=predictors,

　　free_raw_data = False

　　)

　　clf = lgb.train(param_lgb, xg_train, 5000, valid_sets = [xg_valid], verbose_eval=250, early_stopping_rounds = 50)

　　oof[valid_index] = clf.predict(train_df.iloc[valid_index][predictors].values, num_iteration=clf.best_iteration)

　　predictions[:,i-1] += clf.predict(test_df[predictors], num_iteration=clf.best_iteration)

　　i = i + 1

　　print("\n\nCV AUC: {:<0.2f}".format(metrics.roc_auc_score(train_df.target.values, oof)))

　　所以我們在5折交叉驗證中獲得了0.90 AUC。

　　讓我們對5折預測進行排名平均。

　　5.排名平均值

　　print("Rank averaging on", nfold, "fold predictions")

　　rank_predictions = np.zeros((predictions.shape[0],1))

　　for i in range(nfold):

　　rank_predictions[:, 0] = np.add(rank_predictions[:, 0], rankdata(predictions[:, i].reshape(-1,1))/rank_predictions.shape[0])

　　rank_predictions /= nfold

　　6.提交

　　sub_df = pd.DataFrame({"ID_code": test_df.ID_code.values})

　　sub_df["target"] = rank_predictions

　　sub_df.to_csv("Customer_Transaction_rank_predictions.csv", index=False)

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/69945560/viewspace-2654236/，如需轉載，請註明出處，否則將追究法律責任。