Introducción
Contenido
Un árbol de decisiones es uno de los algoritmos de aprendizaje automático supervisados más utilizados y que puede realizar tareas de regresión y clasificación. La intuición detrás del algoritmo del árbol de decisiones es simple, pero también muy poderosa.
Para cada atributo del conjunto de datos, el algoritmo del árbol de decisión forma un nodo, donde el atributo más importante se coloca en el nodo raíz. Para la evaluación, comenzamos en el nodo raíz y avanzamos en el árbol siguiendo el nodo correspondiente que cumple con nuestra condición o «decisión». Este proceso continúa hasta que se alcanza un nodo hoja, que contiene la predicción o el resultado del árbol de decisión.
Esto puede parecer un poco complicado al principio, pero lo que probablemente no se dé cuenta es que ha estado utilizando árboles de decisiones para tomar decisiones durante toda su vida sin siquiera saberlo. Considere un escenario en el que una persona le pide que le preste su automóvil por un día, y usted tiene que tomar la decisión de prestarle o no el automóvil. Hay varios factores que ayudan a determinar su decisión, algunos de los cuales se enumeran a continuación:
- ¿Es esta persona un amigo cercano o simplemente un conocido? Si la persona es solo un conocido, rechace la solicitud; si la persona es un amigo, pase al siguiente paso.
- ¿La persona que pide el coche es la primera vez? Si es así, présteles el automóvil; de lo contrario, continúe con el siguiente paso.
- ¿Se dañó el coche la última vez que lo devolvieron? Si es así, rechace la solicitud; si no, prestales el coche.
El árbol de decisiones para el escenario mencionado anteriormente se ve así:
Ventajas de los árboles de decisión
Existen varias ventajas de utilizar árboles de decisión para el análisis predictivo:
- Los árboles de decisión se pueden utilizar para predecir valores tanto continuos como discretos, es decir, funcionan bien para tareas de regresión y clasificación.
- Requieren relativamente menos esfuerzo para entrenar el algoritmo.
- Se pueden utilizar para clasificar datos separables de forma no lineal.
- Son muy rápidos y eficientes en comparación con KNN y otros algoritmos de clasificación.
Implementación de árboles de decisión con Python Scikit Learn
En esta sección, implementaremos el algoritmo del árbol de decisiones utilizando la biblioteca Scikit-Learn de Python . En los siguientes ejemplos resolveremos problemas de clasificación y regresión utilizando el árbol de decisiones.
Nota : Tanto las tareas de clasificación como las de regresión se ejecutaron en un Jupyter iPython Notebook.
1. Árbol de decisiones para la clasificación
En esta sección predeciremos si un billete de banco es auténtico o falso en función de los cuatro atributos diferentes de la imagen del billete. Los atributos son varianza de la imagen transformada en ondículas, curtosis de la imagen, entropía y asimetría de la imagen.
Conjunto de datos
El conjunto de datos para esta tarea se puede descargar desde este enlace:
https://drive.google.com/open?id=13nw-uRXPY8XIZQxKRNZ3yYlho-CYm_Qt
Para obtener información más detallada sobre este conjunto de datos, consulte el repositorio de ML de UCI para este conjunto de datos.
El resto de los pasos para implementar este algoritmo en Scikit-Learn son idénticos a cualquier problema típico de aprendizaje automático, importaremos bibliotecas y conjuntos de datos, realizaremos algunos análisis de datos, dividiremos los datos en conjuntos de entrenamiento y prueba, entrenaremos el algoritmo, haremos predicciones, y finalmente evaluaremos el rendimiento del algoritmo en nuestro conjunto de datos.
Importación de bibliotecas
El siguiente script importa las bibliotecas necesarias:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
Importar el conjunto de datos
Dado que nuestro archivo está en formato CSV, usaremos el read_csvmétodo de panda para leer nuestro archivo de datos CSV. Ejecute el siguiente script para hacerlo:
dataset = pd.read_csv("D:/Datasets/bill_authentication.csv")
En este caso, el archivo «bill_authentication.csv» se encuentra en la carpeta «Conjuntos de datos» de la unidad «D». Debe cambiar esta ruta de acuerdo con la configuración de su propio sistema.
Análisis de los datos
Ejecute el siguiente comando para ver la cantidad de filas y columnas en nuestro conjunto de datos:
dataset.shape
La salida mostrará «(1372,5)», lo que significa que nuestro conjunto de datos tiene 1372 registros y 5 atributos.
Ejecute el siguiente comando para inspeccionar los primeros cinco registros del conjunto de datos:
dataset.head()
La salida se verá así:
Varianza
Asimetría
curtosis
Entropía
Clase
01234
| 3.62160 | 8.6661 | -2.8073 | -0.44699 | 0 |
| 4.54590 | 8.1674 | -2.4586 | -1.46210 | 0 |
| 3.86600 | -2.6383 | 1.9242 | 0.10645 | 0 |
| 3.45660 | 9.5228 | -4.0112 | -3.59440 | 0 |
| 0.32924 | -4.4552 | 4.5718 | -0.98880 | 0 |
Preparando los datos
En esta sección, dividiremos nuestros datos en atributos y etiquetas y luego dividiremos los datos resultantes en conjuntos de entrenamiento y de prueba. Al hacer esto, podemos entrenar nuestro algoritmo en un conjunto de datos y luego probarlo en un conjunto de datos completamente diferente que el algoritmo aún no ha visto. Esto le proporciona una visión más precisa de cómo funcionará realmente su algoritmo entrenado.
Para dividir los datos en atributos y etiquetas, ejecute el siguiente código:
X = dataset.drop('Class', axis=1)
y = dataset['Class']
Aquí la Xvariable contiene todas las columnas del conjunto de datos, excepto la columna «Clase», que es la etiqueta. La yvariable contiene los valores de la columna «Clase». La Xvariable es nuestro conjunto de atributos y la yvariable contiene las etiquetas correspondientes.
El último paso previo al procesamiento es dividir nuestros datos en conjuntos de prueba y entrenamiento. La model_selectionbiblioteca de Scikit-Learn contiene el train_test_splitmétodo, que usaremos para dividir aleatoriamente los datos en conjuntos de entrenamiento y prueba. Ejecute el siguiente código para hacerlo:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
En el código anterior, el test_sizeparámetro especifica la proporción del conjunto de prueba, que usamos para dividir el 20% de los datos en el conjunto de prueba y el 80% para el entrenamiento.
Entrenando y haciendo predicciones
Una vez que los datos se han dividido en los conjuntos de entrenamiento y prueba, el paso final es entrenar el algoritmo del árbol de decisión sobre estos datos y hacer predicciones. Scikit-Learn contiene la treebiblioteca, que contiene clases / métodos integrados para varios algoritmos de árboles de decisión. Como vamos a realizar una tarea de clasificación aquí, usaremos la DecisionTreeClassifierclase para este ejemplo. Se fitllama al método de esta clase para entrenar el algoritmo en los datos de entrenamiento, que se pasan como parámetro al fitmétodo. Ejecute el siguiente script para entrenar el algoritmo:
from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier()
classifier.fit(X_train, y_train)
Ahora que nuestro clasificador ha sido entrenado, hagamos predicciones sobre los datos de prueba. Para hacer predicciones se utiliza el predictmétodo de la DecisionTreeClassifierclase. Eche un vistazo al siguiente código de uso:
y_pred = classifier.predict(X_test)
Evaluar el algoritmo
En este punto, hemos entrenado nuestro algoritmo y realizado algunas predicciones. Ahora veremos qué tan preciso es nuestro algoritmo. Para las tareas de clasificación, algunas métricas de uso común son la matriz de confusión , la precisión, la recuperación y la puntuación F1 . Por suerte para nosotros, la metricsbiblioteca de Scikit = -Learn contiene los métodos classification_reporty confusion_matrixque se pueden usar para calcular estas métricas para nosotros:
from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))
Esto producirá la siguiente evaluación:
[[142 2]
2 129]]
precision recall f1-score support
0 0.99 0.99 0.99 144
1 0.98 0.98 0.98 131
avg / total 0.99 0.99 0.99 275
En la matriz de confusión, puede ver que de 275 instancias de prueba, nuestro algoritmo clasificó erróneamente solo 4. Esto es un 98,5% de precisión. ¡No está mal!
2. Árbol de decisión para la regresión
El proceso de resolución de problemas de regresión con árbol de decisión utilizando Scikit Learn es muy similar al de clasificación. Sin embargo, para la regresión usamos la clase DecisionTreeRegressor de la biblioteca de árboles. Además, las matrices de evaluación para la regresión difieren de las de clasificación. El resto del proceso es casi el mismo.
Conjunto de datos
El conjunto de datos que usaremos para esta sección es el mismo que usamos en el artículo Regresión lineal. Usaremos este conjunto de datos para intentar predecir el consumo de gas (en millones de galones) en 48 estados de EE. UU. En función del impuesto a la gasolina (en centavos), el ingreso per cápita (dólares), las carreteras pavimentadas (en millas) y la proporción de la población con un Licencia de conducir.
El conjunto de datos está disponible en este enlace:
https://drive.google.com/open?id=1mVmGNx6cbfvRHC_DvF12ZL3wGLSHD9f_
Los detalles del conjunto de datos se pueden encontrar en la fuente original .
Las dos primeras columnas del conjunto de datos anterior no proporcionan ninguna información útil, por lo que se han eliminado del archivo del conjunto de datos.
Ahora apliquemos nuestro algoritmo de árbol de decisión en estos datos para intentar predecir el consumo de gas a partir de estos datos.
Importación de bibliotecas
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
Importar el conjunto de datos
dataset = pd.read_csv('D:Datasetspetrol_consumption.csv')
Análisis de los datos
Usaremos nuevamente la headfunción del marco de datos para ver cómo se ven realmente nuestros datos:
dataset.head()
La salida se ve así:
Impuesto a la
gasolina Ingresos medios
Carreteras pavimentadas Licencia de conductor de
población (%)
Consumo de
gasolina 01234
| 9.0 | 3571 | 1976 | 0.525 | 541 |
| 9.0 | 4092 | 1250 | 0.572 | 524 |
| 9.0 | 3865 | 1586 | 0.580 | 561 |
| 7.5 | 4870 | 2351 | 0.529 | 414 |
| 8.0 | 4399 | 431 | 0.544 | 410 |
Para ver detalles estadísticos del conjunto de datos, ejecute el siguiente comando:
dataset.describe()
Gasolina_impuesto_ingreso_promedio
Carreteras_
pavimentadas
Población_Licencia_conductores (%)
Recuento de
consumo_de gasolinameanstdmin25% 50% 75% máx.
| 48.000000 | 48.000000 | 48.000000 | 48.000000 | 48.000000 |
| 7.668333 | 4241.833333 | 5565.416667 | 0.570333 | 576.770833 |
| 0.950770 | 573.623768 | 3491.507166 | 0.055470 | 111.885816 |
| 5.000000 | 3063.000000 | 431.000000 | 0.451000 | 344.000000 |
| 7.000000 | 3739.000000 | 3110.250000 | 0.529750 | 509.500000 |
| 7.500000 | 4298.000000 | 4735.500000 | 0.564500 | 568.500000 |
| 8.125000 | 4578.750000 | 7156.000000 | 0.595250 | 632.750000 |
| 10.00000 | 5342.000000 | 17782.000000 | 0.724000 | 986.000000 |
Preparando los datos
Al igual que con la tarea de clasificación, en esta sección dividiremos nuestros datos en atributos y etiquetas y, en consecuencia, en conjuntos de entrenamiento y prueba.
Ejecute los siguientes comandos para dividir los datos en etiquetas y atributos:
X = dataset.drop('Petrol_Consumption', axis=1)
y = dataset['Petrol_Consumption']
Aquí la Xvariable contiene todas las columnas del conjunto de datos, excepto la columna ‘Petrol_Consumption’, que es la etiqueta. La yvariable contiene valores de la columna ‘Gasolina_Consumo’, lo que significa que la Xvariable contiene el conjunto de atributos y la yvariable contiene las etiquetas correspondientes.
Ejecute el siguiente código para dividir nuestros datos en conjuntos de prueba y entrenamiento:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
Entrenando y haciendo predicciones
Como se mencionó anteriormente, para una tarea de regresión usaremos una clase sklearn diferente a la que usamos para la tarea de clasificación. La clase que usaremos aquí es la DecisionTreeRegressorclase, a diferencia de la DecisionTreeClassifieranterior.
Para entrenar el árbol, crearemos una instancia de la DecisionTreeRegressorclase y llamaremos al fitmétodo:
from sklearn.tree import DecisionTreeRegressor
regressor = DecisionTreeRegressor()
regressor.fit(X_train, y_train)
Para hacer predicciones en el conjunto de prueba, utilice el predictmétodo:
y_pred = regressor.predict(X_test)
Ahora comparemos algunos de nuestros valores predichos con los valores reales y veamos qué tan precisos éramos:
df=pd.DataFrame({'Actual':y_test, 'Predicted':y_pred})
df
La salida se ve así:
Real
Previsto
4121236389241335
| 699 | 631.0 |
| 561 | 524.0 |
| 525 | 510.0 |
| 640 | 704.0 |
| 648 | 524.0 |
| 498 | 510.0 |
| 460 | 510.0 |
| 508 | 603.0 |
| 644 | 631.0 |
Recuerde que en su caso, los registros comparados pueden ser diferentes, dependiendo de la división de entrenamiento y prueba. Dado que el train_test_splitmétodo divide aleatoriamente los datos, probablemente no tengamos los mismos conjuntos de entrenamiento y prueba.
Evaluar el algoritmo
Para evaluar el rendimiento del algoritmo de regresión, las métricas comúnmente utilizados son el error medio absoluto , error cuadrático medio , y la raíz del error cuadrático medio . La biblioteca Scikit-Learn contiene funciones que pueden ayudarnos a calcular estos valores. Para hacerlo, use este código del metricspaquete:
from sklearn import metrics
print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))
print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred))
print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
La salida debería verse así:
Mean Absolute Error: 54.7
Mean Squared Error: 4228.9
Root Mean Squared Error: 65.0299930801
El error absoluto medio de nuestro algoritmo es 54,7, que es menos del 10 por ciento de la media de todos los valores de la columna ‘Gasolina_Consumo’. Esto significa que nuestro algoritmo hizo un buen trabajo de predicción.
Conclusión
En este artículo, mostramos cómo puede usar la popular biblioteca Scikit-Learn de Python para usar árboles de decisión para tareas de clasificación y regresión. Si bien es un algoritmo bastante simple en sí mismo, implementar árboles de decisión con Scikit-Learn es aún más fácil.
