Árboles de decisión en Python con Scikit-Learn

Un árbol de decisión es uno de los algoritmos de aprendizaje automático supervisado más utilizados y que pueden realizar tareas de regresión y clasificación. Los...

Introducción

Un árbol de decisión es uno de los algoritmos de aprendizaje automático supervisado más utilizados y que pueden 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 árbol de decisión forma un nodo, donde el atributo más importante se ubica en el nodo raíz. Para la evaluación, comenzamos en el nodo raíz y avanzamos hacia abajo 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 sonar un poco complicado al principio, pero lo que probablemente no se dé cuenta es que ha estado usando árboles de decisión para tomar decisiones 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:

  1. ¿Es esta persona un amigo cercano o solo un conocido? Si la persona es solo un conocido, rechace la solicitud; si la persona es amiga, vaya al siguiente paso.
  2. ¿La persona que pide el auto es la primera vez? Si es así, présteles el automóvil, de lo contrario, continúe con el siguiente paso.
  3. ¿Se dañó el automóvil la última vez que lo devolvieron? En caso afirmativo, rechace la solicitud; si no, prestarles el coche.

El árbol de decisión para el escenario antes mencionado se ve así:

Árbol de decisiones{.img-responsive}

Ventajas de los árboles de decisión

Hay varias ventajas de usar árboles de decisión para el análisis predictivo:

  1. Los árboles de decisión se pueden usar para predecir valores continuos y discretos, es decir, funcionan bien tanto para tareas de regresión como de clasificación.
  2. Requieren relativamente menos esfuerzo para entrenar el algoritmo.
  3. Pueden usarse para clasificar datos separables no linealmente.
  4. They're very fast and efficient compared to KNN and other classification algorithms.

Implementación de árboles de decisión con Python Scikit Learn

En esta sección, implementaremos el algoritmo del árbol de decisión utilizando la biblioteca Scikit-Aprender de Python. En los siguientes ejemplos, resolveremos tanto problemas de clasificación como de regresión utilizando el árbol de decisión.

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 dependiendo de los cuatro atributos diferentes de la imagen del billete. Los atributos son la varianza de la imagen transformada en wavelet, la curtosis de la imagen, la entropía y la 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 Informe de aprendizaje automático 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 requeridas:

1
2
3
4
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
Importación del conjunto de datos

Dado que nuestro archivo está en formato CSV, utilizaremos el método read_csv de panda para leer nuestro archivo de datos CSV. Ejecute el siguiente script para hacerlo:

1
dataset = pd.read_csv("D:/Datasets/bill_authentication.csv")

En este caso, el archivo "bill_authentication.csv" se encuentra en la carpeta "Datasets" de la unidad "D". Debe cambiar esta ruta de acuerdo con la configuración de su propio sistema.

Análisis de datos {#análisis de datos}

Ejecute el siguiente comando para ver el número de filas y columnas en nuestro conjunto de datos:

1
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:

1
dataset.head()

La salida se verá así:

  Variance   Skewness   Curtosis   Entropy    Class

0 3,62160 8,6661 -2,8073 -0,44699 0 1 4,54590 8,1674 -2,4586 -1,46210 0 2 3,86600 -2,6383 1,9242 0,10645 0 3 3,45660 9,5228 -4,0112 -3,59440 0 4 0,32924 -4,4552 4,5718 -0,98880 0

Preparación de 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:

1
2
X = dataset.drop('Class', axis=1)
y = dataset['Class']

Aquí, la variable X contiene todas las columnas del conjunto de datos, excepto la columna "Clase", que es la etiqueta. La variable y contiene los valores de la columna "Clase". La variable X es nuestro conjunto de atributos y la variable y contiene las etiquetas correspondientes.

El último paso de preprocesamiento es dividir nuestros datos en conjuntos de entrenamiento y prueba. La biblioteca model_selection de Scikit-Learn contiene el método train_test_split, que usaremos para dividir aleatoriamente los datos en conjuntos de entrenamiento y prueba. Ejecute el siguiente código para hacerlo:

1
2
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 parámetro test_size 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.

Entrenamiento y elaboración de predicciones {#entrenamiento y elaboración de predicciones}

Una vez que los datos se han dividido en conjuntos de entrenamiento y prueba, el paso final es entrenar el algoritmo del árbol de decisiones con estos datos y hacer predicciones. Scikit-Learn contiene la biblioteca tree, que contiene clases/métodos integrados para varios algoritmos de árboles de decisión. Ya que vamos a realizar una tarea de clasificación aquí, usaremos la clase DecisionTreeClassifier para este ejemplo. Se llama al método fit de esta clase para entrenar el algoritmo en los datos de entrenamiento, que se pasan como parámetro al método fit. Ejecute el siguiente script para entrenar el algoritmo:

1
2
3
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 realizar predicciones se utiliza el método predict de la clase DecisionTreeClassifier. Eche un vistazo al siguiente código para su uso:

1
y_pred = classifier.predict(X_test)
Evaluación del algoritmo

En este punto, hemos entrenado nuestro algoritmo y hecho algunas predicciones. Ahora veremos qué tan preciso es nuestro algoritmo. Para las tareas de clasificación, algunas métricas de uso común son matriz de confusión, precisión, recuperación y [Puntuación F1](https://en.wikipedia.org/wiki /F1_puntuación). Por suerte para nosotros, la biblioteca metrics de Scikit=-Learn contiene los métodos classification_report y confusion_matrix que se pueden usar para calcular estas métricas para nosotros:

1
2
3
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:

1
2
3
4
5
6
7
8
[[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

A partir de la matriz de confusión, puede ver que de 275 instancias de prueba, nuestro algoritmo clasificó incorrectamente solo 4. Esta es una precisión del 98,5 %. ¡No está mal!

2. Árbol de decisiones para regresión

El proceso de resolución de problemas de regresión con árboles 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. También 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 {#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 gasolina (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 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 decisiones a estos datos para intentar predecir el consumo de gas a partir de estos datos.

Importación de bibliotecas
1
2
3
4
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
Importación del conjunto de datos
1
dataset = pd.read_csv('D:\Datasets\petrol_consumption.csv')
Análisis de datos {#análisis de datos}

Usaremos nuevamente la función head del marco de datos para ver cómo se ven realmente nuestros datos:

1
dataset.head()

La salida se ve así:

  Petrol_tax   Average_income   Paved_Highways   Population_Driver_license(%)   Petrol_Consumption

0 9.0 3571 1976 0.525 541 1 9.0 4092 1250 0.572 524 2 9,0 3865 1586 0,580 561 3 7.5 4870 2351 0.529 414 4 8,0 4399 431 0,544 410

Para ver los detalles estadísticos del conjunto de datos, ejecute el siguiente comando:

1
dataset.describe()
      Petrol_tax   Average_income   Paved_Highways   Population_Driver_license(%)   Petrol_Consumption

cuenta 48.000000 48.000000 48.000000 48.000000 48.000000 media 7,668333 4241,833333 5565,416667 0,570333 576,770833 estándar 0,950770 573,623768 3491,507166 0,055470 111,885816 min 5.000000 3063.000000 431.000000 0.451000 344.000000 25% 7.000000 3739.000000 3110.250000 0.529750 509.500000 50% 7,500000 4298,000000 4735,500000 0,564500 568,500000 75% 8.125000 4578.750000 7156.000000 0.595250 632.750000 máx. 10,00000 5342,000000 17782,000000 0,724000 986,000000

Preparación de 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:

1
2
X = dataset.drop('Petrol_Consumption', axis=1)
y = dataset['Petrol_Consumption']

Aquí, la variable X contiene todas las columnas del conjunto de datos, excepto la columna 'Petrol_Conquisition', que es la etiqueta. La variable y contiene valores de la columna 'Petrol_Consumption', lo que significa que la variable X contiene el conjunto de atributos y la variable y contiene las etiquetas correspondientes.

Ejecute el siguiente código para dividir nuestros datos en conjuntos de entrenamiento y prueba:

1
2
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)
Entrenamiento y elaboración de predicciones {#entrenamiento y elaboración de predicciones}

Como se mencionó anteriormente, para una tarea de regresión usaremos una clase de sklearn diferente a la que usamos para la tarea de clasificación. La clase que usaremos aquí es la clase DecisionTreeRegressor, a diferencia del DecisionTreeClassifier de antes.

Para entrenar el árbol, instanciaremos la clase DecisionTreeRegressor y llamaremos al método fit:

1
2
3
from sklearn.tree import DecisionTreeRegressor
regressor = DecisionTreeRegressor()
regressor.fit(X_train, y_train)

Para hacer predicciones en el conjunto de prueba, usa el método predict:

1
y_pred = regressor.predict(X_test)

Ahora comparemos algunos de nuestros valores pronosticados con los valores reales y veamos qué tan precisos fuimos:

1
2
df=pd.DataFrame({'Actual':y_test, 'Predicted':y_pred})
df

La salida se ve así:

   Actual   Predicted

41 699 631.0 2 561 524.0 12 525 510.0 36 640 704.0 38 648 524.0 9 498 510.0 24 460 510.0 13 508 603.0 35 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 método train_test_split divide aleatoriamente los datos, es probable que no tengamos los mismos conjuntos de entrenamiento y prueba.

Evaluación del algoritmo

Para evaluar el rendimiento del algoritmo de regresión, las métricas comúnmente utilizadas son [error absoluto medio] (https://en.wikipedia.org/wiki/Mean_absolute_error), [error cuadrático medio] (https://en.wikipedia.org /wiki/Mean_squared_error) y error cuadrático medio. La biblioteca Scikit-Learn contiene funciones que pueden ayudarlo a calcular estos valores por nosotros. Para ello, utilice el siguiente código del paquete metrics:

1
2
3
4
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 ser algo como esto:

1
2
3
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 'Consumo_de_gasolina'. Esto significa que nuestro algoritmo hizo un buen trabajo de predicción.

Yendo más lejos: proyecto de extremo a extremo portátil

¿Tu naturaleza inquisitiva te hace querer ir más allá? Recomendamos consultar nuestro Proyecto guiado: ["Predicción práctica del precio de la vivienda: aprendizaje automático en Python"](https://wikihtp.com/courses/hands-on-house- precio-predicción-aprendizaje-máquina-en-python/#cta){target="_blank"}.

[](https://wikihtp.com/ cursos/predicción-de-precio-de-la-casa-práctica-aprendizaje-de-máquina-en-python/#cta)

En este proyecto guiado, aprenderá a crear potentes modelos tradicionales de aprendizaje automático, así como modelos de aprendizaje profundo, utilizar Ensemble Learning y capacitar a los meta-aprendices para predecir los precios de la vivienda a partir de una bolsa de modelos Scikit-Learn y Keras.

Con Keras, la API de aprendizaje profundo creada sobre Tensorflow, experimentaremos con arquitecturas, crearemos un conjunto de modelos apilados y entrenaremos una red neuronal meta-aprendizaje (modelo de nivel 1) para averiguar el precio de un casa.

El aprendizaje profundo es sorprendente, pero antes de recurrir a él, se recomienda intentar resolver el problema con técnicas más simples, como los algoritmos de aprendizaje superficial. Nuestro rendimiento de referencia se basará en un algoritmo de Regresión de bosque aleatorio. Además, exploraremos la creación de conjuntos de modelos a través de Scikit-Learn a través de técnicas como embalaje y votación.

Este es un proyecto integral y, como todos los proyectos de aprendizaje automático, comenzaremos con Análisis exploratorio de datos, seguido de Preprocesamiento de datos y, finalmente, Creación de modelos de aprendizaje superficial y Profundo para ajustarse a los datos que hemos explorado y limpiado previamente.

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.