Notas de estudio "Derivación de fórmulas de aprendizaje automático e implementación de código", registre su propio proceso de aprendizaje, compre el libro del autor para obtener contenido detallado.
Aprendizaje integrado: comparación y ajuste de parámetros
Aunque el aprendizaje profundo es popular ahora, los algoritmos representados por XGBoost, LightGBMy todavía se usan ampliamente. Independientemente de las aplicaciones de datos no estructurados, como texto, imágenes, voz y video, que son adecuadas para el aprendizaje profundo, los algoritmos siguen siendo la primera opción para los campos de datos estructurados con menos muestras de capacitación .CatBoostBoostingBoosting
1 Comparación de los tres principales algoritmos de Boosting
XGBoost, LightGBMy CatBoostson los algoritmos de impulso clásicos actuales SOTA( state of the art). Estos tres modelos son marcos de aprendizaje integrados compatibles con árboles de decisión. Entre ellos, XGBoost es una mejora de la versión original del algoritmo GBDT, y se han optimizado aún más LightGBMsobre la base CatBoost. XGBoostCada uno tiene sus puntos fuertes en precisión y velocidad.
Hay dos diferencias principales entre los tres algoritmos de Boosting:
Primero, el método de construcción del árbol modelo es diferente, usando la estrategia de construcción del árbol de decisiones de XGBoostcrecimiento por capas ( ), LightGBM usa la estrategia de construcción de crecimiento por hojas (hoja-sabia) y CatBoost usa la estructura de árbol simétrica (sin previo aviso). level-wisetree), cuyos árboles de decisión son todos árboles binarios completos.
En segundo lugar, hay una gran diferencia en el procesamiento de las características categóricas. No tiene la capacidad de procesar automáticamente las características categóricas. Para las características categóricas de los datos, debemos convertirlas manualmente en valores antes de ingresarlos XGBoosten el modelo; LightGBMName, el algoritmo se alineará automáticamente para el procesamiento; CatBoostes famoso por procesar características categóricas y también puede procesar características categóricas de manera eficiente a través de métodos de codificación de características, como estadísticas de variables objetivo.
1.1 Preprocesamiento de datos
Tomemos como ejemplo el conjunto de datos Kagglede 2015 y experimentemos con los modelos , y flightsrespectivamente : conjunto de datos de vuelosXGBoostLightGBMCatBoost
El conjunto de datos tiene más de 5 millones de registros de vuelo y 31 funciones. Tomamos muestras para extraer el 1 % de los datos del conjunto de datos original y analizamos 11 funciones para demostración. Después del preprocesamiento, reconstruimos el conjunto de entrenamiento. El objetivo era construir un modelo de clasificación binaria para determinar si el vuelo se retrasó.
import pandas as pd
from sklearn.model_selection import train_test_split
flights = pd.read_csv('flights.csv')
flights = flights.sample(frac=0.01, random_state=10) # 数据集抽样1%
flights
flights = flights[["MONTH","DAY","DAY_OF_WEEK","AIRLINE","FLIGHT_NUMBER","DESTINATION_AIRPORT",
"ORIGIN_AIRPORT","AIR_TIME", "DEPARTURE_TIME","DISTANCE","ARRIVAL_DELAY"]] # 选11个特征
flights= flights.reset_index(drop=True)
flights
flights["ARRIVAL_DELAY"] = (flights["ARRIVAL_DELAY"]>10)*1 # 延误超过10分钟看作是延误，bool类型转换为int类型
flights["ARRIVAL_DELAY"].unique()
array([0, 1], dtype=int32)
cols = ["AIRLINE","FLIGHT_NUMBER","DESTINATION_AIRPORT","ORIGIN_AIRPORT"] # 类别特征
for col in cols:
print(len(flights[col].unique()))
14
6163
633
644
for item in cols:
flights[item] = flights[item].astype("category").cat.codes
X_train, X_test, y_train, y_test = train_test_split(flights.drop(["ARRIVAL_DELAY"], axis=1), flights["ARRIVAL_DELAY"], random_state=10, test_size=0.3) # 划分数据集
1.2 Prueba de XGBoost en conjunto de datos de vuelos
from sklearn.metrics import roc_auc_score
import xgboost as xgb
import time
# 设置模型参数
params = {
'booster': 'gbtree', # 基于树
'objective': 'binary:logistic',
'gamma': 0.1, # 剪枝中用到的最小损失下降值
'max_depth': 8,
'lambda': 2,
'subsample': 0.7, # 表示用于训练的样本比例
'colsample_bytree': 0.7, # 表示用于训练的特征比例
'min_child_weight': 3, # 一个叶子节点的最小权重
'eta': 0.001,# 学习速率
'seed': 1000,
'nthread': 4, # 线程数量，用于并行计算
}
# 训练
t0 = time.time()
num_rounds = 500 # 表示训练轮数，即树的个数
dtrain = xgb.DMatrix(X_train, y_train)
model_xgb = xgb.train(params, dtrain, num_rounds)
print('training spend {} seconds'.format(time.time()-t0))
# 测试
t1 = time.time()
dtest = xgb.DMatrix(X_test)
y_pred = model_xgb.predict(dtest)
print('testing spend {} seconds'.format(time.time()-t1))
y_pred_train = model_xgb.predict(dtrain)
print(f"训练集auc：{
roc_auc_score(y_train, y_pred_train)}")
print(f"测试集auc：{
roc_auc_score(y_test, y_pred)}")
training spend 6.46193265914917 seconds
testing spend 0.057062625885009766 seconds
训练集auc：0.752049936354563
测试集auc：0.6965194979943091
1.3 Prueba de LightGBM en el conjunto de datos de vuelos
import lightgbm as lgb
d_train = lgb.Dataset(X_train, label=y_train)
# 设置模型参数
params = {
"max_depth": 5,
"learning_rate" : 0.05,
"num_leaves": 500,
"n_estimators": 300
}
cate_features_name = ["MONTH","DAY","DAY_OF_WEEK","AIRLINE","DESTINATION_AIRPORT", "ORIGIN_AIRPORT"] # 类别特征
t0 = time.time()
model_lgb = lgb.train(params, d_train, categorical_feature = cate_features_name)
print('training spend {} seconds'.format(time.time()-t0))
t1 = time.time()
y_pred = model_lgb.predict(X_test)
print('testing spend {} seconds'.format(time.time()-t1))
y_pred_train = model_lgb.predict(X_train)
print(f"训练集auc：{
roc_auc_score(y_train, y_pred_train)}")
print(f"测试集auc：{
roc_auc_score(y_test, y_pred)}")
training spend 0.43550848960876465 seconds
testing spend 0.0230252742767334 seconds
训练集auc：0.8867447004324996
测试集auc：0.7033506245405025
1.2 Prueba de CatBoost en el conjunto de datos de vuelos
import catboost as cb
cat_features_index = [0,1,2,3,4,5,6]
t0 = time.time()
model_cb = cb.CatBoostClassifier(eval_metric="AUC", one_hot_max_size=50, depth=6, iterations=300, l2_leaf_reg=1, learning_rate=0.1)
model_cb.fit(X_train,y_train, cat_features= cat_features_index)
print('training spend {} seconds'.format(time.time()-t0))
t1 = time.time()
y_pred = model_cb.predict(X_test)
print('testing spend {} seconds'.format(time.time()-t1))
y_pred_train = model_cb.predict(X_train)
print(f"训练集auc：{
roc_auc_score(y_train, y_pred_train)}")
print(f"测试集auc：{
roc_auc_score(y_test, y_pred)}")
training spend 20.633496284484863 seconds
testing spend 0.03611636161804199 seconds
训练集auc：0.5670692017560355
测试集auc：0.5473357824098838
A partir de los resultados experimentales anteriores, se puede ver que sin más ingeniería de características de datos y ajuste de hiperparámetros, en este conjunto de datos, tanto en términos de LightGBMprecisión como de velocidad, es mejor que XGBoosty CatBoost, y CatBoostel rendimiento es el peor.
2 métodos comunes de ajuste de hiperparámetros
Llamamos a los parámetros obtenidos sin entrenamiento del modelo 超参数( hyperparameter), y los métodos de ajuste de parámetros comúnmente utilizados en el aprendizaje automático incluyen 网格搜索法( grid search), 随机搜索法( random search) y 贝叶斯优化( bayesian optimization).
2.1 Método de búsqueda en cuadrícula
El método de búsqueda de cuadrícula es un método de ajuste de hiperparámetros de uso común, que a menudo se usa para optimizar tres o menos hiperparámetros, y es esencialmente un método exhaustivo. Para cada hiperparámetro, el usuario selecciona un conjunto finito más pequeño para buscar y luego realiza el producto cartesiano de estos hiperparámetros para obtener varios conjuntos de hiperparámetros. La búsqueda en cuadrícula utiliza cada conjunto de hiperparámetros para entrenar el modelo y selecciona el hiperparámetro con el error más pequeño en el conjunto de validación como el hiperparámetro óptimo.
sklearnEl ajuste de parámetros de búsqueda de cuadrícula se realiza a través model_selectiondel módulo , y el proceso de ajuste de parámetros se valida de forma cruzada. GridSearchCVA continuación se muestra un ejemplo de la búsqueda en cuadrícula de XGBoost:
# 基于XGBoost的GridSearch搜索范例
from sklearn.model_selection import GridSearchCV
model = xgb.XGBClassifier()
# 待搜索的参数列表实例
params_lst = {
'max_depth': [3,5,7],
'min_child_weight': [1,3,6],
'n_estimators': [100,200,300],
'learning_rate': [0.01, 0.05, 0.1]
}
# verbose：表示日志输出的详细程度
# n_jobs：表示并行计算的数量，即同时运行的任务数，-1 表示使用所有可用的 CPU 进行并行计算
t0 = time.time()
grid_search = GridSearchCV(model, param_grid=params_lst, cv=3, verbose=10, n_jobs=-1)
grid_search.fit(X_train, y_train)
print('gridsearch for xgb spend', time.time()-t0, 'seconds.')
print(grid_search.best_params_)
gridsearch for xgb spend 67.24716424942017 seconds.
{
'learning_rate': 0.1, 'max_depth': 5, 'min_child_weight': 6, 'n_estimators': 300}
2.2 Búsqueda aleatoria
La búsqueda aleatoria consiste en buscar hiperparámetros óptimos aleatoriamente dentro del rango o distribución de hiperparámetros especificados. En comparación con el método de búsqueda en cuadrícula, dada una distribución de hiperparámetros, no se prueban todos los hiperparámetros, sino que se muestrean un número fijo de parámetros de la distribución dada, y solo estos hiperparámetros muestreados se prueban realmente.
sklearnLa búsqueda aleatoria se realiza a través de los métodos del módulo model_selection RandomizedSearchCV.
# 基于XGBoost的RandomizedSearch搜索范例
from sklearn.model_selection import RandomizedSearchCV # 通过 n_iter 进行手动设置或是自动根据参数空间大小确定采样次数
model = xgb.XGBClassifier()
# 待搜索的参数列表实例
params_lst = {
'max_depth': [3,5,7],
'min_child_weight': [1,3,6],
'n_estimators': [100,200,300],
'learning_rate': [0.01, 0.05, 0.1]
}
t0 = time.time()
random_search = RandomizedSearchCV(model, params_lst, random_state=0)
random_search.fit(X_train, y_train)
print(random_search.best_params_)
print('randomsearch for xgb spend', time.time()-t0, 'seconds.')
{
'n_estimators': 300, 'min_child_weight': 6, 'max_depth': 5, 'learning_rate': 0.1}
randomsearch for xgb spend 60.41917014122009 seconds.
2.3 Ajuste de parámetros bayesianos
La optimización bayesiana es un método de optimización de hiperparámetros basado en el teorema bayesiano, que se utiliza principalmente para optimizar funciones de caja negra. En comparación con la búsqueda en cuadrícula tradicional o la búsqueda aleatoria, el ajuste de parámetros bayesiano crea un modelo basado en la incertidumbre de las observaciones de la muestra, calcula la distribución posterior a través de la fórmula bayesiana y selecciona hiperparámetros con expectativas de optimización relativamente altas.
La idea clave del ajuste de parámetros bayesianos es usar observaciones de muestra para actualizar continuamente las previas (suposiciones de premisas) del modelo y predecir los resultados del próximo experimento en función de las premisas conocidas. A través de los resultados predichos, se actualiza la distribución posterior del modelo, es decir, la función de densidad de probabilidad de la distribución de hiperparámetros después de conocer las muestras. En función de las métricas estadísticas de la función de densidad de probabilidad de hiperparámetros, como la expectativa y la varianza, se genera el siguiente conjunto de valores de hiperparámetros hasta que se alcanza un resultado óptimo. En todo el proceso, el siguiente conjunto de hiperparámetros a probar se basa en los datos existentes actuales, calcula inversamente la distribución de probabilidad de hiperparámetros de las muestras existentes y busca de acuerdo con el valor esperado (o modo) de los hiperparámetros, a un cierto medida, hace que la búsqueda sea más "inteligente" y eficiente.
Antes de realizar la optimización bayesiana, debemos definir una función objetivo que se optimizará en función de la validación cruzada xgb.cv de XGBoost, obtener los resultados de verificación de validación cruzada de xgb.cv y usar el conjunto de prueba AUC como medida de precisión para la optimización. Finalmente, la función de optimización objetivo definida y el rango de búsqueda de hiperparámetros se pasan a la función de optimización bayesiana, y la optimización bayesiana se puede realizar dado el punto de inicialización y el número de iteraciones.
# 定义相关参数
num_rounds = 3000
params = {
'eta': 0.1,
'silent': 1,
'eval_metric': 'auc',
'verbose_eval': True,
'seed': 2023
}
# 定义目标优化函数
def xgb_evaluate(min_child_weight, colsample_bytree, max_depth, subsample, gamma,alpha):
params['min_child_weight'] = int(min_child_weight)
params['cosample_bytree'] = max(min(colsample_bytree, 1), 0)
params['max_depth'] = int(max_depth)
params['subsample'] = max(min(subsample, 1), 0)
params['gamma'] = max(gamma, 0)
params['alpha'] = max(alpha, 0)
cv_result = xgb.cv(params, dtrain, num_boost_round=num_rounds, nfold=5, seed=2023, callbacks=[xgb.callback.EarlyStopping(rounds=50)])
return cv_result['test-auc-mean'].values[-1]
# pip install bayesian-optimization
from bayes_opt import BayesianOptimization
#-*-coding:utf-8-*-
num_iter = 25
init_points = 5
t0 = time.time()
xgbBO = BayesianOptimization(xgb_evaluate, {
'min_child_weight': (1, 20),
'colsample_bytree': (0.1, 1),
'max_depth': (5, 15),
'subsample': (0.5, 1),
'gamma': (0, 10),
'alpha': (0, 10),
})
xgbBO.maximize(init_points=init_points, n_iter=num_iter)
print('bayesianSearch for xgb spend', time.time()-t0, 'seconds.')
| iter | target | alpha | colsam... | gamma | max_depth | min_ch... | subsample |
| 1 | 0.7193 | 7.155 | 0.5762 | 0.9578 | 9.488 | 13.18 | 0.9343 |
bayesianSearch for xgb spend 765.5525000095367 seconds.
Se puede observar que los parámetros obtenidos tras la sintonización bayesiana hacen que el valor auc de xgboost en el conjunto de pruebas de vuelos alcance 0,72.