這里結合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)
開始玩起來)