Crear y evaluar un modelo de arboles aleatotios (random forest) para predecir las ventas con datos simulados de una empresa dependiendo de las inversiones realizadas en publicidad.
Se utiliza programación Python
Cargar librerías y datos
Limpiar datos si es necesario
Explorar datos
Partir los datos en datos de entrenamiento y datos de validación 70% y 30%
Crear modelo de regresión con los datos de entrenamiento
Predicciones
Evaluar predicciones con respecto a datos reales
Determinar el estadístico rmse para evaluar con respecto a otros modelos
Interpretar el caso
Extraído de : [@amatrodrigo2017]
Un modelo Random Forest está formado por un conjunto (ensemble) de árboles de decisión individuales, cada uno entrenado con una muestra aleatoria extraída de los datos de entrenamiento originales mediante bootstrapping. Esto implica que cada árbol se entrena con unos datos ligeramente distintos.
En cada árbol individual, las observaciones se van distribuyendo por bifurcaciones (nodos) generando la estructura del árbol hasta alcanzar un nodo terminal. La predicción de una nueva observación se obtiene agregando las predicciones de todos los árboles individuales que forman el modelo.
Para entender cómo funcionan los modelos Random Forest es necesario conocer primero los conceptos de ensemble y bagging.
Métodos de ensemble
Todos los modelos de aprendizaje estadístico y machine learning sufren el problema de equilibrio entre bias y varianza.
El término bias (sesgo) hace referencia a cuánto se alejan en promedio las predicciones de un modelo respecto a los valores reales. Refleja cómo de capaz es el modelo de aprender la relación real que existe entre los predictores y la variable respuesta. Por ejemplo, si la relación sigue un patrón no lineal, por muchos datos de los que se disponga, un modelo de regresión lineal no podrá modelar correctamente la relación, por lo que tendrá un bias alto.
El término varianza hace referencia a cuánto cambia el modelo dependiendo de los datos utilizados en su entrenamiento. Idealmente, un modelo no debería modificarse demasiado por pequeñas variaciones en los datos de entrenamiento, si esto ocurre, es porque el modelo está memorizando los datos en lugar de aprender la verdadera relación entre los predictores y la variable respuesta. Por ejemplo, un modelo de árbol con muchos nodos, suele variar su estructura con que apenas cambien unos pocos datos de entrenamiento, tiene mucha varianza.
A medida que aumenta la complejidad de un modelo, este dispone de mayor flexibilidad para adaptarse a las observaciones, reduciendo así el bias y mejorando su capacidad predictiva. Sin embargo, alcanzado un determinado grado de flexibilidad, aparece el problema de overfitting, el modelo se ajusta tanto a los datos de entrenamiento que es incapaz de predecir correctamente nuevas observaciones. El mejor modelo es aquel que consigue un equilibrio óptimo entre bias y varianza.
¿Cómo se controlan el bias y varianza en los modelos basados en árboles? Por lo general, los árboles pequeños (pocas ramificaciones) tienen poca varianza pero no consiguen representar bien la relación entre las variables, es decir, tienen bias alto. En contraposición, los árboles grandes se ajustan mucho a los datos de entrenamiento, por lo que tienen muy poco bias pero mucha varianza. Una forma de solucionar este problema son los métodos de ensemble.
Los métodos de ensemble combinan múltiples modelos en uno nuevo con el objetivo de lograr un equilibro entre bias y varianza, consiguiendo así mejores predicciones que cualquiera de los modelos individuales originales. Dos de los tipos de ensemble más utilizados son:
Bagging: Se ajustan múltiples modelos, cada uno con un subconjunto distinto de los datos de entrenamiento. Para predecir, todos los modelos que forman el agregado participan aportando su predicción. Como valor final, se toma la media de todas las predicciones (variables continuas) o la clase más frecuente (variables categóricas). Los modelos Random Forest están dentro de esta categoría.
Boosting: Se ajustan secuencialmente múltiples modelos sencillos, llamados weak learners, de forma que cada modelo aprende de los errores del anterior. Como valor final, al igual que en bagging, se toma la media de todas las predicciones (variables continuas) o la clase más frecuente (variables cualitativas). Tres de los métodos de boosting más empleados son AdaBoost, Gradient Boosting y Stochastic Gradient Boosting.
Aunque el objetivo final es el mismo, lograr un balance óptimo entre bias y varianza, existen dos diferencias importantes:
Forma en que consiguen reducir el error total. El error total de un modelo puede descomponerse como \(bias+varianza+ϵ\).
En bagging, se emplean modelos con muy poco bias pero mucha varianza, agregándolos se consigue reducir la varianza sin apenas inflar el bias. En boosting, se emplean modelos con muy poca varianza pero mucho bias, ajustando secuencialmente los modelos se reduce el bias. Por lo tanto, cada una de las estrategias reduce una parte del error total.
Forma en que se introducen variaciones en los modelos que forman el ensemble. En bagging, cada modelo es distinto del resto porque cada uno se entrena con una muestra distinta obtenida mediante bootstrapping. En boosting, los modelos se ajustan secuencialmente y la importancia (peso) de las observaciones va cambiando en cada iteración, dando lugar a diferentes ajustes.
La clave para que los métodos de ensemble consigan mejores resultados que cualquiera de sus modelos individuales es que, los modelos que los forman, sean lo más diversos posibles (sus errores no estén correlacionados). Una analogía que refleja este concepto es la siguiente: supóngase un juego como el trivial en el que los equipos tienen que acertar preguntas sobre temáticas diversas. Un equipo formado por muchos jugadores, cada uno experto en un tema distinto, tendrá más posibilidades de ganar que un equipo formado por jugadores expertos en un único tema o por un único jugador que sepa un poco de todos los temas.
A continuación, se describe con más detalle la estrategia de bagging, sobre la que se fundamenta el modelo Random Forest.
Bagging
El término bagging es el diminutivo de bootstrap aggregation, y hace referencia al empleo del muestreo repetido con reposición bootstrapping con el fin de reducir la varianza de algunos modelos de aprendizaje estadístico, entre ellos los basados en árboles.
Dadas \(n\) muestras de observaciones independientes \(Z_1, ... Z_n\), cada una con varianza \(\sigma^2\), la varianza de la media de las observaciones \(\bar{Z}\) es \(\sigma^2 / n\).
En otras palabras, promediando un conjunto de observaciones se reduce la varianza.
Basándose en esta idea, una forma de reducir la varianza y aumentar la precisión de un método predictivo es obtener múltiples muestras de la población, ajustar un modelo distinto con cada una de ellas, y hacer la media (la moda en el caso de variables cualitativas) de las predicciones resultantes.
Como en la práctica no se suele tener acceso a múltiples muestras, se puede simular el proceso recurriendo a bootstrapping, generando así pseudo-muestras con los que ajustar diferentes modelos y después agregarlos. A este proceso se le conoce como bagging y es aplicable a una gran variedad de métodos de regresión.
En el caso particular de los árboles de decisión, dada su naturaleza de bajo bias y alta varianza, bagging ha demostrado tener muy buenos resultados. La forma de aplicarlo es:
Generar BB pseudo-training sets mediante bootstrapping a partir de la muestra de entrenamiento original.
Entrenar un árbol con cada una de las BB muestras del paso
Cada árbol se crea sin apenas restricciones y no se somete a pruning, por lo que tiene varianza alta pero poco bias. En la mayoría de casos, la única regla de parada es el número mínimo de observaciones que deben tener los nodos terminales. El valor óptimo de este hiperparámetro puede obtenerse comparando el out of bag error o por validación cruzada.
Para cada nueva observación, obtener la predicción de cada uno de los BB árboles. El valor final de la predicción se obtiene como la media de las BB predicciones en el caso de variables cuantitativas y como la clase predicha más frecuente (moda) para variables cualitativas.
En el proceso de bagging, el número de árboles creados no es un hiperparámetro crítico en cuanto a que, por mucho que se incremente el número, no se aumenta el riesgo de overfitting. Alcanzado un determinado número de árboles, la reducción de test error se estabiliza. A pesar de ello, cada árbol ocupa memoria, por lo que no conviene almacenar más de los necesarios.
Entrenamiento de Random Forest
El algoritmo de Random Forest es una modificación del proceso de bagging que consigue mejorar los resultados gracias a que decorrelaciona aún más los árboles generados en el proceso.
Recordando el apartado anterior, los beneficios del bagging se basan en el hecho de que, promediando un conjunto de modelos, se consigue reducir la varianza. Esto es cierto siempre y cuando los modelos agregados no estén correlacionados. Si la correlación es alta, la reducción de varianza que se puede lograr es pequeña.
Suponendo un set de datos en el que hay un predictor muy influyente, junto con otros moderadamente influyentes. En este escenario, todos o casi todos los árboles creados en el proceso de bagging estarán dominados por el mismo predictor y serán muy parecidos entre ellos. Como consecuencia de la alta correlación entre los árboles, el proceso de bagging apenas conseguirá disminuir la varianza y, por lo tanto, tampoco mejorar el modelo.
Random forest evita este problema haciendo una selección aleatoria de mm predictores antes de evaluar cada división. De esta forma, un promedio de \((p−m)/p\) divisiones no contemplarán el predictor influyente, permitiendo que otros predictores puedan ser seleccionados. Añadiendo este paso extra se consigue decorrelacionar los árboles todavía más, con lo que su agregación consigue una mayor reducción de la varianza.
Los métodos de random forest y bagging siguen el mismo algoritmo con la única diferencia de que, en random forest, antes de cada división, se seleccionan aleatoriamente m predictores. La diferencia en el resultado dependerá del valor m escogido. Si \(m=p\) los resultados de random forest y bagging son equivalentes. Algunas recomendaciones son:
La raíz cuadrada del número total de predictores para problemas de clasificación. \(m \approx \sqrt{p}\)
Un tercio del número de predictores para problemas de regresión \(m \approx \frac{p}{3}\).
Si los predictores están muy correlacionados, valores pequeños de \(m\) consiguen mejores resultados.
Sin embargo, la mejor forma para encontrar el valor óptimo de mm es evaluar el out-of-bag-error o recurrir a validación cruzada.
Al igual que ocurre con bagging, random forest no sufre problemas de overfit por aumentar el número de árboles creados en el proceso. Alcanzado un determinado número, la reducción del error de test se estabiliza.
Por otra parte como lo menciona mejor formar de evaluar los datos podría ser utilizar diversos arboles de decisión, así hacer una mejor predicción calculando el promedio de sus predicciones, este enfoque se denomina como algoritmos de ensamble o ensemble learning.
De este algoritmo se pudiera decir, que une multiples arboles de decision, así crea un bosque de predicción, las evalúa y entrega el resultado promedio. [@veloso2019]
Para trabajar con código Python, se deben cargan las librerías de Python previamente instaladas con la función py_install() de la librería reticulate de R.
La función repl_python() se utilizar para ejecutar ventana de comando o shell de Python.
Se recomienda instalar estos paquetes de Python
py_install(packages = “pandas”)
py_install(packages = “matplotlib”)
py_install(packages = “numpy”)
py_install(packages = “sklearn”) en R cloud
py_install(“scikit-learn”) R Studio local
py_install(packages = “statsmodels.api”)
py_install(packages = “seaborn”)
En terminal de Python se puede actualizar con conda create -n py3.8 python=3.8 scikit-learn pandas numpy matplotlib
library(reticulate)# Tratamiento de datos
import numpy as np
import pandas as pd
# Gráficos
import matplotlib.pyplot as plt
# Preprocesado y moYdelado
from sklearn.model_selection import train_test_split
# from sklearn.tree import DecisionTreeRegressor
# from sklearn.tree import plot_tree
# from sklearn.tree import export_graphviz
# from sklearn.tree import export_text
# from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestRegressor
from sklearn import metrics
from sklearn.metrics import mean_squared_error, r2_scoredatos = pd.read_csv("https://raw.githubusercontent.com/rpizarrog/Analisis-Inteligente-de-datos/main/datos/Advertising_Web.csv")
datos## Unnamed: 0 X TV Radio Newspaper Web Sales
## 0 1 1 230.1 37.8 69.2 306.634752 22.1
## 1 2 2 44.5 39.3 45.1 302.653070 10.4
## 2 3 3 17.2 45.9 69.3 49.498908 9.3
## 3 4 4 151.5 41.3 58.5 257.816893 18.5
## 4 5 5 180.8 10.8 58.4 195.660076 12.9
## .. ... ... ... ... ... ... ...
## 195 196 196 38.2 3.7 13.8 248.841073 7.6
## 196 197 197 94.2 4.9 8.1 118.041856 9.7
## 197 198 198 177.0 9.3 6.4 213.274671 12.8
## 198 199 199 283.6 42.0 66.2 237.498063 25.5
## 199 200 200 232.1 8.6 8.7 151.990733 13.4
##
## [200 rows x 7 columns]print("Observaciones y variables: ", datos.shape)## Observaciones y variables: (200, 7)print("Columnas y tipo de dato")
# datos.columns## Columnas y tipo de datodatos.dtypes## Unnamed: 0 int64
## X int64
## TV float64
## Radio float64
## Newspaper float64
## Web float64
## Sales float64
## dtype: objectdatos.info()## <class 'pandas.core.frame.DataFrame'>
## RangeIndex: 200 entries, 0 to 199
## Data columns (total 7 columns):
## # Column Non-Null Count Dtype
## --- ------ -------------- -----
## 0 Unnamed: 0 200 non-null int64
## 1 X 200 non-null int64
## 2 TV 200 non-null float64
## 3 Radio 200 non-null float64
## 4 Newspaper 200 non-null float64
## 5 Web 200 non-null float64
## 6 Sales 200 non-null float64
## dtypes: float64(5), int64(2)
## memory usage: 11.1 KBSe describen las variables independientes: TV, Radio Newpaper y la variable dependiente Sales.
Valor de etiqueta o variable objetivo deendiente(ventas): que significa el volumen de ventas del producto correspondiente
Las variables independientes: (TV, Radio, Periódico, WEB):
TV: son los costos de la publicidad en TV (en miles)
Radio: costos de publicidad invertidos en medios de difusión radio;
Newspaper Periódico: costos publicitarios para medios impresos.
Web: Costos de publicidad invertidos en herramientas digitales.
Quitar las primeras columnas y dejar TV Radio NewsPaper Web y Sales
datos = datos[['TV','Radio', 'Newspaper', 'Web', 'Sales']]
datos.describe()## TV Radio Newspaper Web Sales
## count 200.000000 200.000000 200.000000 200.000000 200.000000
## mean 147.042500 23.264000 30.554000 159.587355 14.022500
## std 85.854236 14.846809 21.778621 76.815266 5.217457
## min 0.700000 0.000000 0.300000 4.308085 1.600000
## 25% 74.375000 9.975000 12.750000 99.048767 10.375000
## 50% 149.750000 22.900000 25.750000 156.862154 12.900000
## 75% 218.825000 36.525000 45.100000 212.311848 17.400000
## max 296.400000 49.600000 114.000000 358.247042 27.000000datos## TV Radio Newspaper Web Sales
## 0 230.1 37.8 69.2 306.634752 22.1
## 1 44.5 39.3 45.1 302.653070 10.4
## 2 17.2 45.9 69.3 49.498908 9.3
## 3 151.5 41.3 58.5 257.816893 18.5
## 4 180.8 10.8 58.4 195.660076 12.9
## .. ... ... ... ... ...
## 195 38.2 3.7 13.8 248.841073 7.6
## 196 94.2 4.9 8.1 118.041856 9.7
## 197 177.0 9.3 6.4 213.274671 12.8
## 198 283.6 42.0 66.2 237.498063 25.5
## 199 232.1 8.6 8.7 151.990733 13.4
##
## [200 rows x 5 columns]Se utiliza semilla 1349 (random_state=1349)
La función train_test_split() parte los datos originales el 70% y 30% para datos de entrenamiento y validación y con el argumento datos.drop(columns = “Sales”), datos[‘Sales’] solo incluye las variables independientes; la semilla de aleatoriedad es 1349
X_entrena, X_valida, Y_entrena, Y_valida = train_test_split(datos.drop(columns = "Sales"), datos['Sales'],train_size=.70, random_state=1349)print("Estructura de datos de entrenamiento... ", X_entrena.shape)## Estructura de datos de entrenamiento... (140, 4)print(X_entrena)## TV Radio Newspaper Web
## 143 104.6 5.7 34.4 336.571095
## 124 229.5 32.3 74.2 88.080721
## 45 175.1 22.5 31.5 62.809264
## 181 218.5 5.4 27.4 162.387486
## 151 121.0 8.4 48.7 103.255212
## .. ... ... ... ...
## 194 149.7 35.6 6.0 99.579981
## 164 117.2 14.7 5.4 109.008763
## 17 281.4 39.6 55.8 41.755313
## 126 7.8 38.9 50.6 209.471977
## 18 69.2 20.5 18.3 210.489910
##
## [140 rows x 4 columns]print(X_entrena[['TV']], X_entrena[['Radio']], X_entrena[['Newspaper']], X_entrena[['Web']])## TV
## 143 104.6
## 124 229.5
## 45 175.1
## 181 218.5
## 151 121.0
## .. ...
## 194 149.7
## 164 117.2
## 17 281.4
## 126 7.8
## 18 69.2
##
## [140 rows x 1 columns] Radio
## 143 5.7
## 124 32.3
## 45 22.5
## 181 5.4
## 151 8.4
## .. ...
## 194 35.6
## 164 14.7
## 17 39.6
## 126 38.9
## 18 20.5
##
## [140 rows x 1 columns] Newspaper
## 143 34.4
## 124 74.2
## 45 31.5
## 181 27.4
## 151 48.7
## .. ...
## 194 6.0
## 164 5.4
## 17 55.8
## 126 50.6
## 18 18.3
##
## [140 rows x 1 columns] Web
## 143 336.571095
## 124 88.080721
## 45 62.809264
## 181 162.387486
## 151 103.255212
## .. ...
## 194 99.579981
## 164 109.008763
## 17 41.755313
## 126 209.471977
## 18 210.489910
##
## [140 rows x 1 columns]Se crea el modelo con la función RandomForestRegressor().fit() con los datos de entrenamiento que contiene la variables independientes en relación a la variable dependiente ‘Sales’.
El argumento n_estimators define el número de árboles en el bosque aleatorio. Puede usar cualquier valor numérico para el parámetro n_estimator.
El valor argumento de random_state es la semilla para la aleatoriedad del modelo
model_rf = RandomForestRegressor(n_estimators = 50, random_state = 1349)
model_rf.fit(X_entrena, Y_entrena)RandomForestRegressor(n_estimators=50, random_state=1349)In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
RandomForestRegressor(n_estimators=50, random_state=1349)
Se generan predicciones con los datos de validación
predicciones = model_rf.predict(X_valida)Construir una conjunto de datos con los valores reales de los datos de validación y las predicciones generadas del modelo.
comparaciones = pd.DataFrame(Y_valida)
# comparaciones = comparaciones.assign(Sales_Real = Y_valida)
comparaciones = comparaciones.assign(Predicho = predicciones.flatten().tolist())
print(comparaciones)## Sales Predicho
## 179 12.6 13.024
## 7 13.2 13.132
## 153 19.0 18.088
## 140 10.9 11.224
## 144 11.4 11.204
## 52 22.6 21.884
## 54 20.2 19.492
## 188 15.9 15.444
## 185 22.6 21.832
## 133 19.6 19.758
## 101 23.8 23.232
## 125 10.6 10.006
## 120 15.5 14.716
## 190 10.8 10.594
## 66 9.5 8.180
## 196 9.7 9.756
## 165 11.9 11.968
## 122 11.6 11.138
## 111 21.8 22.498
## 172 7.6 6.972
## 127 8.8 9.240
## 180 10.5 10.900
## 2 9.3 7.092
## 57 13.2 13.630
## 48 14.8 15.742
## 21 12.5 12.340
## 73 11.0 11.152
## 156 15.3 14.048
## 75 8.7 7.080
## 10 8.6 9.518
## 40 16.6 16.452
## 137 20.8 20.770
## 149 10.1 9.726
## 187 17.3 18.154
## 103 14.7 15.066
## 27 15.9 15.792
## 154 15.6 15.318
## 42 20.7 20.686
## 118 15.9 15.734
## 61 24.2 24.334
## 158 7.3 6.166
## 82 11.3 11.592
## 31 11.9 13.080
## 119 6.6 6.810
## 100 11.7 12.006
## 80 11.8 11.836
## 102 14.8 14.080
## 167 12.2 11.828
## 56 5.5 5.926
## 65 9.3 9.978
## 47 23.2 23.280
## 110 13.4 12.532
## 104 20.7 20.072
## 193 19.6 18.194
## 105 19.2 17.260
## 116 12.2 13.040
## 163 18.0 17.498
## 12 9.2 8.526
## 117 9.4 9.298
## 55 23.7 23.240Este valor normalmente se compara contra otro modelo y el que esté mas cerca de cero es mejor.
La raiz del Error Cuadrático Medio (rmse) es una métrica que dice qué tan lejos están los valores predichos de los valores observados o reales en un análisis de regresión, en promedio. Se calcula como:
\[ rmse = \sqrt{\frac{\sum(predicho_i - real_i)^{2}}{n}} \]
RMSE es una forma útil de ver qué tan bien un modelo de regresión puede ajustarse a un conjunto de datos.
Cuanto mayor sea el rmse, mayor será la diferencia entre los valores predichos y reales, lo que significa que peor se ajusta un modelo de regresión a los datos. Por el contrario, cuanto más pequeño sea el rmse, mejor podrá un modelo ajustar los datos.
Se compara este valor de rmse con respecto al modelo de regresión múltiple
rmse = mean_squared_error(
y_true = Y_valida,
y_pred = predicciones,
squared = False
)
print(f"El error (rmse) de test es: {rmse}")## El error (rmse) de test es: 0.7354177497631301print('Mean Squared Error: MSE', metrics.mean_squared_error(Y_valida, predicciones))## Mean Squared Error: MSE 0.5408392666666658print('Root Mean Squared Error RMSE:', np.sqrt(metrics.mean_squared_error(Y_valida, predicciones)))## Root Mean Squared Error RMSE: 0.7354177497631301Para estos datos para estos valores de entrenamiento y validación, con un valor de 50 árboles en el modelo, el valor de RMSE es aproximadamente 0.7660, menor que el valor de árbol de regresión en Python del Caso 4.
El RMSE obtenido se puede comparar contra los estadísticos RMSE de los modelos regresión múltiple y árbol de regresión tanto de Python y de R , se puede interpretar cuál modelo es más eficiente en términos de este estadístico con estos datos.
Para la realización de este caso en particular haciendo uso de la 1349, la predicción precisa ya queel valor de rmse es de 0.735417749763130.
Además nos da un resultado del MSE de 0.5408392666666658