XGBoost en R: un ejemplo paso a paso

Actualizado el 17 de julio de 2024, por Luis Benites.

El impulso es una técnica de aprendizaje automático que se ha demostrado que produce modelos con alta precisión predictiva.

Una de las formas más comunes de implementar el impulso en la práctica es usar XGBoost , abreviatura de «impulso de gradiente extremo».

Este tutorial proporciona un ejemplo paso a paso de cómo usar XGBoost para ajustar un modelo mejorado en R.

Paso 1: cargue los paquetes necesarios

Primero, cargaremos las bibliotecas necesarias.

library (xgboost) # para ajustar la 
biblioteca de modelos xgboost (caret)    # para la preparación de datos generales y el ajuste del modelo

Paso 2: cargue los datos

Para este ejemplo, ajustaremos un modelo de regresión mejorado al conjunto de datos de Boston del paquete MASS .

Este conjunto de datos contiene 13 variables predictoras que usaremos para predecir una variable de respuesta llamada mdev , que representa el valor mediano de las casas en diferentes distritos censales alrededor de Boston.

#cargar los datos
 data = MASS :: Boston

#ver la estructura de la
 cadena de datos (datos)

'data.frame': 506 obs. de 14 variables:
 $ crim: núm 0.00632 0.02731 0.02729 0.03237 0.06905 ...
 $ zn: num 18 0 0 0 0 0 12,5 12,5 12,5 12,5 ...
 $ indus: núm 2.31 7.07 7.07 2.18 2.18 2.18 7.87 7.87 7.87 7.87 ...
 $ chas: int 0 0 0 0 0 0 0 0 0 0 ...
 $ nox: num 0.538 0.469 0.469 0.458 0.458 0.458 0.524 0.524 0.524 0.524 ...
 $ rm: núm 6.58 6.42 7.18 7 7.15 ...
 $ edad: núm 65,2 78,9 61,1 45,8 54,2 58,7 66,6 96,1 100 85,9 ...
 $ dis: núm 4.09 4.97 4.97 6.06 6.06 ...
 $ rad: int 1 2 2 3 3 3 5 5 5 5 ...
 $ impuesto: num 2962422422222222222231131311311 ...
 $ ptratio: núm. 15,3 17,8 17,8 18,7 18,7 18,7 15,2 15,2 15,2 15,2 ...
 $ negro: núm 397397393395397 ...
 $ lstat: num 4.98 9.14 4.03 2.94 5.33 ...
 $ medv: num 24 21,6 34,7 33,4 36,2 28,7 22,9 27,1 16,5 18,9 ...

Podemos ver que el conjunto de datos contiene 506 observaciones y 14 variables en total.

Paso 3: preparar los datos

A continuación, usaremos la función createDataPartition () del paquete de intercalación para dividir el conjunto de datos original en un conjunto de entrenamiento y prueba.

Para este ejemplo, elegiremos usar el 80% del conjunto de datos original como parte del conjunto de entrenamiento.

Tenga en cuenta que el paquete xgboost también usa datos matriciales, por lo que usaremos la función data.matrix () para contener nuestras variables predictoras.

#Haga que este ejemplo sea reproducible
 set.seed (0)

# dividir en entrenamiento (80%) y conjunto de pruebas (20%)
 partes = createDataPartition (data $ medv, p = .8 , list = F )
tren = datos [partes,]
prueba = datos [-partes,]

#definir variables de predicción y respuesta en el conjunto de entrenamiento
 train_x = data. matriz (tren [, -13])
tren_y = tren [, 13]

#definir variables de predicción y respuesta en el conjunto de pruebas
 test_x = data. matriz (prueba [, -13])
test_y = test [, 13]

#define los conjuntos finales de entrenamiento y prueba
 xgb_train = xgb. DMatrix (datos = tren_x, etiqueta = tren_y)
prueba_xgb = xgb. DMatrix (datos = prueba_x, etiqueta = prueba_y)

Paso 4: ajuste el modelo

A continuación, ajustaremos el modelo XGBoost utilizando la función xgb.train () , que muestra el RMSE de entrenamiento y prueba (error cuadrático medio) para cada ronda de refuerzo.

Tenga en cuenta que elegimos usar 70 rondas para este ejemplo, pero para conjuntos de datos mucho más grandes no es raro usar cientos o incluso miles de rondas. Solo tenga en cuenta que cuantas más rondas, mayor será el tiempo de ejecución.

También tenga en cuenta que el argumento de profundidad máxima especifica la profundidad a la que deben crecer los árboles de decisión individuales. Por lo general, elegimos que este número sea bastante bajo, como 2 o 3, para que crezcan árboles más pequeños. Se ha demostrado que este enfoque tiende a producir modelos más precisos.

#definir lista de seguimiento lista de
 seguimiento = lista (tren = tren_xgb, prueba = prueba_xgb)

#fit XGBoost model y muestra los datos de entrenamiento y prueba en cada modelo de ronda
 = xgb.train (data = xgb_train, max.depth = 3 , watchlist = watchlist, nrounds = 70 )

[1] train-rmse: 10.167523 test-rmse: 10.839775 
[2] tren-rmse: 7.521903 prueba-rmse: 8.329679 
[3] tren-rmse: 5.702393 prueba-rmse: 6.691415 
[4] train-rmse: 4.463687 test-rmse: 5.631310 
[5] tren-rmse: 3.666278 prueba-rmse: 4.878750 
[6] train-rmse: 3.159799 test-rmse: 4.485698 
[7] train-rmse: 2.855133 test-rmse: 4.230533 
[8] train-rmse: 2.603367 test-rmse: 4.099881 
[9] train-rmse: 2.445718 test-rmse: 4.084360 
[10] train-rmse: 2.327318 test-rmse: 3.993562 
[11] tren-rmse: 2.267629 prueba-rmse: 3.944454 
[12] train-rmse: 2.189527 test-rmse: 3.930808 
[13] train-rmse: 2.119130 test-rmse: 3.865036 
[14] train-rmse: 2.086450 test-rmse: 3.875088 
[15] tren-rmse: 2.038356 prueba-rmse: 3.881442 
[16] tren-rmse: 2.010995 prueba-rmse: 3.883322 
[17] train-rmse: 1.949505 test-rmse: 3.844382 
[18] train-rmse: 1.911711 test-rmse: 3.809830 
[19] tren-rmse: 1.888488 prueba-rmse: 3.809830 
[20] train-rmse: 1.832443 test-rmse: 3.758502 
[21] tren-rmse: 1.816150 prueba-rmse: 3.770216 
[22] train-rmse: 1.801369 test-rmse: 3.770474 
[23] train-rmse: 1.788891 test-rmse: 3.766608 
[24] tren-rmse: 1.751795 prueba-rmse: 3.749583 
[25] train-rmse: 1.713306 test-rmse: 3.720173 
[26] train-rmse: 1.672227 test-rmse: 3.675086 
[27] train-rmse: 1.648323 test-rmse: 3.675977 
[28] train-rmse: 1.609927 test-rmse: 3.745338 
[29] tren-rmse: 1.594891 prueba-rmse: 3.756049 
[30] tren-rmse: 1.578573 prueba-rmse: 3.760104 
[31] train-rmse: 1.559810 test-rmse: 3.727940 
[32] tren-rmse: 1.547852 prueba-rmse: 3.731702 
[33] train-rmse: 1.534589 test-rmse: 3.729761 
[34] tren-rmse: 1.520566 prueba-rmse: 3.742681 
[35] tren-rmse: 1.495155 prueba-rmse: 3.732993 
[36] train-rmse: 1.467939 test-rmse: 3.738329 
[37] tren-rmse: 1.446343 prueba-rmse: 3.713748 
[38] tren-rmse: 1.435368 prueba-rmse: 3.709469 
[39] train-rmse: 1.401356 test-rmse: 3.710637 
[40] tren-rmse: 1.390318 prueba-rmse: 3.709461 
[41] train-rmse: 1.372635 test-rmse: 3.708049 
[42] train-rmse: 1.367977 test-rmse: 3.707429 
[43] tren-rmse: 1.359531 prueba-rmse: 3.711663 
[44] tren-rmse: 1.335347 prueba-rmse: 3.709101 
[45] train-rmse: 1.331750 test-rmse: 3.712490 
[46] train-rmse: 1.313087 test-rmse: 3.722981 
[47] tren-rmse: 1.284392 prueba-rmse: 3.712840 
[48] ​​tren-rmse: 1.257714 prueba-rmse: 3.697482 
[49] tren-rmse: 1.248218 prueba-rmse: 3.700167 
[50] train-rmse: 1.243377 test-rmse: 3.697914 
[51] tren-rmse: 1.231956 prueba-rmse: 3.695797 
[52] tren-rmse: 1.219341 prueba-rmse: 3.696277 
[53] tren-rmse: 1.207413 prueba-rmse: 3.691465 
[54] tren-rmse: 1.197197 prueba-rmse: 3.692108 
[55] train-rmse: 1.171748 test-rmse: 3.683577 
[56] train-rmse: 1.156332 test-rmse: 3.674458 
[57] tren-rmse: 1.147686 prueba-rmse: 3.686367 
[58] train-rmse: 1.143572 test-rmse: 3.686375 
[59] train-rmse: 1.129780 test-rmse: 3.679791 
[60] train-rmse: 1.111257 test-rmse: 3.679022 
[61] train-rmse: 1.093541 test-rmse: 3.699670 
[62] tren-rmse: 1.083934 prueba-rmse: 3.708187 
[63] train-rmse: 1.067109 test-rmse: 3.712538 
[64] train-rmse: 1.053887 test-rmse: 3.722480 
[65] train-rmse: 1.042127 test-rmse: 3.720720 
[66] tren-rmse: 1.031617 prueba-rmse: 3.721224 
[67] tren-rmse: 1.016274 prueba-rmse: 3.699549 
[68] train-rmse: 1.008184 test-rmse: 3.709522 
[69] tren-rmse: 0.999220 prueba-rmse: 3.708000 
[70] tren-rmse: 0.985907 prueba-rmse: 3.705192 

De la salida podemos ver que el RMSE de prueba mínimo se logra en 56 rondas. Más allá de este punto, el RMSE de prueba comienza a aumentar, lo que es una señal de que estamos sobreajustando los datos de entrenamiento .

Por lo tanto, definiremos nuestro modelo final de XGBoost para usar 56 rondas:

#define final model
 final = xgboost (data = xgb_train, max.depth = 3 , nrounds = 56 , verbose = 0 )

Nota: El argumento detallado = 0 le dice a R que no muestre el error de entrenamiento y prueba para cada ronda.

Paso 5: use el modelo para hacer predicciones

Por último, podemos utilizar el modelo potenciado final para hacer predicciones sobre el valor medio de la vivienda de las viviendas de Boston en el conjunto de pruebas.

Luego calcularemos las siguientes medidas de precisión para el modelo:

  • MSE: error cuadrático medio
  • MAE: Error absoluto medio
  • RMSE: error cuadrático medio de raíz
mean ((test_y - pred_y) ^ 2) #mse
 caret :: MAE (test_y, pred_y) #mae
 caret :: RMSE (test_y, pred_y) #rmse

[1] 13.50164
[1] 2.409426
[1] 3.674457 

El error cuadrático medio resulta ser 3.674457 . Esto representa la diferencia promedio entre la predicción hecha para la mediana de los valores de las casas y los valores reales de las casas observados en el conjunto de prueba.

Si queremos, podríamos comparar este RMSE con otros modelos como regresión lineal múltiple , regresión de crestas , regresión de componentes principales , etc. para ver qué modelo produce las predicciones más precisas.

Puede encontrar el código R completo utilizado en este ejemplo aquí .

  • https://r-project.org
  • https://www.python.org/
  • https://www.stata.com/

Redactor del artículo

  • Luis Benites
    Directo & CEO de Statologos LSI

    Tengo una Maestría en Ciencias en Estadística Aplicada y he trabajado en algoritmos de aprendizaje automático para empresas profesionales tanto en el sector de la salud como en el comercio minorista.

    Ver todas las entradas

Deja un comentario

El rango intercuartílico y la desviación estándar son dos formas de medir la dispersión de valores en un conjunto de…
statologos comunidad-2

Compartimos información EXCLUSIVA y GRATUITA solo para suscriptores (cursos privados, programas, consejos y mucho más)

You have Successfully Subscribed!