Tutorial ScikitLearn: Clasificación con árboles DecisionTreeClassifier

Introducción teórica a los árboles de decisión para clasificación

Los árboles de decisión son modelos de aprendizaje automático utilizados para tareas de clasificación y regresión. En clasificación, un árbol de decisión divide de manera recursiva el espacio de características en regiones homogéneas respecto a la etiqueta de clase. Este proceso se basa en seleccionar los atributos que mejor separan las clases en cada nodo del árbol.

La construcción del árbol comienza con el nodo raíz, que contiene todas las muestras del conjunto de entrenamiento. Se evalúan todos los atributos disponibles para determinar cuál proporciona la mejor partición de los datos según un criterio de impureza. Los criterios más comunes son la impureza de Gini y la entropía:

Impureza de Gini:
$$
Gini = 1 - \sum_{i=1}^{C} p_i^2
$$
donde ( p_i ) es la proporción de muestras de la clase ( i ) en el nodo y ( C ) es el número total de clases.

Entropía:
$$
Entropía = -\sum_{i=1}^{C} p_i \log_2 p_i
$$

Un valor más bajo en estos criterios indica una mayor homogeneidad en las clases. El objetivo es minimizar la impureza para lograr nodos lo más puros posible.

El proceso de partición continúa de forma recursiva en los nodos hijos. En cada paso, se selecciona el atributo que maximiza la ganancia de información, que representa la reducción en la impureza al dividir el nodo. Este proceso continúa hasta que se cumple un criterio de parada, como alcanzar una profundidad máxima, que todos los nodos estén puros o que no haya suficientes muestras para dividir.

Sin embargo, un árbol demasiado profundo puede llevar al sobreajuste del modelo, capturando ruido en los datos de entrenamiento y perdiendo capacidad de generalización. Para evitarlo, se utilizan técnicas como:

• Poda pre-pruning: Limitar la profundidad máxima del árbol, el número mínimo de muestras por hoja o el número mínimo de muestras para realizar una partición.
• Poda post-pruning: Construir el árbol completo y luego podar los nodos que no aportan mejora significativa, reduciendo así la complejidad del modelo.

La interpretabilidad es una de las principales ventajas de los árboles de decisión. Es posible visualizar el modelo completo, lo que facilita la comprensión de las reglas de decisión que utiliza. Esta característica es especialmente útil en sectores donde la transparencia y la explicabilidad son esenciales.

A continuación, se presenta un ejemplo práctico utilizando Scikit-Learn:

from sklearn.datasets import load_wine
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

# Cargar el conjunto de datos
datos = load_wine()
X = datos.data
y = datos.target

# Dividir los datos en conjuntos de entrenamiento y prueba
X_entreno, X_prueba, y_entreno, y_prueba = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Crear el modelo de árbol de decisión con criterio de impureza de Gini
arbol = DecisionTreeClassifier(criterion='gini', max_depth=5, random_state=42, ccp_alpha=0.01)

# Entrenar el modelo
arbol.fit(X_entreno, y_entreno)

# Realizar predicciones
predicciones = arbol.predict(X_prueba)

# Evaluar la exactitud del modelo
exactitud = arbol.score(X_prueba, y_prueba)
print(f"Exactitud del modelo: {exactitud:.2f}")

En este código, se ha utilizado el conjunto de datos Wine para clasificar diferentes tipos de vino. Se ha establecido una profundidad máxima de 5 para prevenir el sobreajuste. El método score calcula la exactitud del modelo en el conjunto de prueba.

Es importante destacar que los árboles de decisión pueden manejar tanto características categóricas como numéricas y no requieren escalado de datos. Además, son resistentes a valores atípicos y pueden capturar relaciones no lineales entre las características y la variable objetivo.

Sin embargo, también presentan ciertas limitaciones, como la tendencia a crear árboles sesgados si las clases están desbalanceadas. En tales casos, es recomendable equilibrar el conjunto de datos o ajustar los parámetros del modelo para compensar este efecto.

DecisionTreeClassifier

El DecisionTreeClassifier de Scikit-Learn es una clase que implementa un árbol de decisión para tareas de clasificación. Este modelo crea un árbol donde cada nodo interno representa una prueba en una característica, cada rama representa el resultado de la prueba y cada hoja representa una clase.

Para utilizar DecisionTreeClassifier, es necesario importar la clase y crear una instancia del modelo. Luego, se entrena el modelo con los datos de entrenamiento y se realizan predicciones sobre nuevos datos. El flujo básico es el siguiente:

from sklearn.tree import DecisionTreeClassifier

# Crear una instancia del modelo
arbol = DecisionTreeClassifier(random_state=42, ccp_alpha=0.01)

# Entrenar el modelo con los datos de entrenamiento
arbol.fit(X_entrenamiento, y_entrenamiento)

# Realizar predicciones sobre datos de prueba
predicciones = arbol.predict(X_prueba)

En este ejemplo, el parámetro random_state se establece para asegurar la reproducibilidad de los resultados. El método fit entrena el modelo utilizando las características X_entrenamiento y las etiquetas y_entrenamiento. El método predict genera las predicciones para las nuevas entradas X_prueba.

Es posible evaluar el rendimiento del modelo utilizando métricas como la exactitud. A continuación, se muestra cómo calcular la precisión del modelo:

from sklearn.metrics import accuracy_score

# Calcular la precisión del modelo
precision = accuracy_score(y_prueba, predicciones)
print(f"Precisión del modelo: {precision:.2f}")

Además de predicciones puntuales, el DecisionTreeClassifier permite obtener las probabilidades asociadas a cada clase mediante el método predict_proba:

# Obtener las probabilidades de predicción
probabilidades = arbol.predict_proba(X_prueba)

# Mostrar las probabilidades de la primera muestra
print("Probabilidades de la primera predicción:")
for clase, probabilidad in zip(arbol.classes_, probabilidades[0]):
    print(f"{clase}: {probabilidad:.2f}")

Este enfoque es útil cuando se requiere conocer el grado de confianza en cada predicción, lo que es especialmente importante en aplicaciones donde las consecuencias de una clasificación errónea son significativas.

Un ejemplo completo utilizando el conjunto de datos Iris ilustra el uso práctico del DecisionTreeClassifier:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# Cargar el conjunto de datos Iris
datos = load_iris()
X = datos.data
y = datos.target

# Dividir los datos en conjuntos de entrenamiento y prueba
X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Crear una instancia del modelo
arbol = DecisionTreeClassifier(random_state=42, ccp_alpha=0.01)

# Entrenar el modelo
arbol.fit(X_entrenamiento, y_entrenamiento)

# Realizar predicciones
predicciones = arbol.predict(X_prueba)

# Evaluar el modelo
precision = accuracy_score(y_prueba, predicciones)
print(f"Precisión del modelo: {precision:.2f}")

En este código, se carga el conjunto de datos Iris, que contiene características de flores y sus respectivas especies. Después de dividir el conjunto en entrenamiento y prueba, se entrena el modelo y se evalúa su rendimiento. La precisión obtenida proporciona una medida de qué tan bien el modelo clasifica muestras no vistas.

El DecisionTreeClassifier es capaz de manejar tanto características numéricas como categóricas. No obstante, Scikit-Learn requiere que las variables categóricas se codifiquen numéricamente antes del entrenamiento. Esto se puede lograr utilizando transformaciones como One-Hot Encoding.

También es posible visualizar el árbol de decisión generado, lo que ayuda a entender las reglas de clasificación aprendidas por el modelo. Aunque la visualización y la interpretación detallada se abordan en secciones posteriores, es importante saber que Scikit-Learn ofrece herramientas como export_text y plot_tree para este fin.

Finalmente, el DecisionTreeClassifier se integra fácilmente con otras herramientas de Scikit-Learn, lo que permite incorporarlo en pipelines y combinarlo con técnicas de preprocesamiento y validación cruzada. Esta flexibilidad facilita la construcción de modelos complejos y el desarrollo de soluciones más robustas.

Parámetros de DecisionTreeClassifier

El DecisionTreeClassifier de Scikit-Learn proporciona múltiples parámetros que permiten personalizar la construcción del árbol de decisión para tareas de clasificación. Estos parámetros controlan aspectos como la profundidad del árbol, los criterios de división y la poda, influyendo directamente en el rendimiento y la generalización del modelo.

• criterion: Este parámetro establece la función para medir la impureza de una división. Las opciones disponibles son 'gini' para la impureza de Gini y 'entropy' para la entropía. La elección del criterio puede afectar la forma en que el árbol divide los datos.

arbol = DecisionTreeClassifier(criterion='entropy', random_state=42, ccp_alpha=0.01)

• splitter: Determina la estrategia utilizada para elegir la división en cada nodo. Puede ser 'best', que selecciona la mejor división, o 'random', que elige la mejor división entre un subconjunto aleatorio de características. El uso de 'random' puede introducir aleatoriedad que ayude a mitigar el sobreajuste.

arbol = DecisionTreeClassifier(splitter='random', random_state=42, ccp_alpha=0.01)

• max_depth: Especifica la profundidad máxima del árbol. Limitar la profundidad puede prevenir el sobreajuste al restringir el crecimiento del árbol. Si se establece en None, el árbol crecerá hasta que todas las hojas sean puras o hasta que cada hoja contenga menos muestras que min_samples_split.

arbol = DecisionTreeClassifier(max_depth=5, random_state=42, ccp_alpha=0.01)

• min_samples_split: Indica el número mínimo de muestras necesarias para dividir un nodo interno. Puede ser un entero o un valor decimal entre 0.0 y 1.0, representando una fracción del número total de muestras. Aumentar este valor puede conducir a árboles más generales.

arbol = DecisionTreeClassifier(min_samples_split=10, random_state=42, ccp_alpha=0.01)

• min_samples_leaf: Define el número mínimo de muestras que debe tener una hoja. Al igual que min_samples_split, puede ser un entero o una fracción. Valores más altos evitarán que el árbol cree ramas con pocas muestras, lo que puede mejorar la generalización.

arbol = DecisionTreeClassifier(min_samples_leaf=5, random_state=42, ccp_alpha=0.01)

• min_weight_fraction_leaf: Es la fracción mínima del peso total que debe tener una hoja. Este parámetro es útil cuando se trabaja con muestras con pesos. Por defecto es 0.0, lo que significa que no se aplicará ningún umbral adicional aparte de min_samples_leaf.
• max_features: Controla el número de características a considerar cuando se busca la mejor división. Puede tomar valores como un entero, un flotante, 'auto', 'sqrt', 'log2' o None. Por ejemplo, 'sqrt' utilizará la raíz cuadrada del número total de características.

arbol = DecisionTreeClassifier(max_features='sqrt', random_state=42, ccp_alpha=0.01)

• random_state: Establece la semilla del generador de números aleatorios, permitiendo la reproducibilidad de los resultados. Es especialmente importante cuando se utiliza un splitter aleatorio o cuando se trabaja con parámetros como max_features.

arbol = DecisionTreeClassifier(random_state=42, ccp_alpha=0.01)

• max_leaf_nodes: Limita el número máximo de nodos hoja en el árbol. Restringir el número de hojas puede reducir la complejidad del modelo y ayudar a prevenir el sobreajuste.

arbol = DecisionTreeClassifier(max_leaf_nodes=20, random_state=42, ccp_alpha=0.01)

• min_impurity_decrease: Un nodo se dividirá solo si al hacerlo se logra una reducción mínima en la impureza. Es un valor flotante que actúa como un umbral, ayudando a controlar el crecimiento del árbol.

arbol = DecisionTreeClassifier(min_impurity_decrease=0.01, random_state=42, ccp_alpha=0.01)

• class_weight: Permite asignar pesos a las clases, útil cuando hay un desbalance en las clases. Puede ser un diccionario, 'balanced' o None. Usar 'balanced' ajusta automáticamente los pesos inversamente proporcionales a las frecuencias de las clases en los datos.

arbol = DecisionTreeClassifier(class_weight='balanced', random_state=42, ccp_alpha=0.01)

• ccp_alpha: Representa el parámetro de complejidad para la poda mediante coste-complejidad mínima. Un valor positivo de ccp_alpha reduce la complejidad del árbol al podar ramas cuyo coste-complejidad es menor que el umbral especificado.

arbol = DecisionTreeClassifier(ccp_alpha=0.01, random_state=42, ccp_alpha=0.01)

• Presort: Este parámetro fue eliminado en versiones anteriores y ya no está disponible en Scikit-Learn. No es necesario configurarlo, ya que el algoritmo de construcción del árbol ahora maneja automáticamente las mejores prácticas para el ordenamiento.

A continuación, se muestra un ejemplo completo que incorpora varios de estos parámetros:

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

# Cargar el conjunto de datos
datos = load_wine()
X = datos.data
y = datos.target

# Dividir en conjuntos de entrenamiento y prueba
X_entreno, X_prueba, y_entreno, y_prueba = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Crear y configurar el modelo
arbol = DecisionTreeClassifier(
    criterion='entropy',
    splitter='best',
    max_depth=5,
    min_samples_split=4,
    min_samples_leaf=2,
    max_features='log2',
    class_weight=None,
    random_state=42,
    ccp_alpha=0.01
)

# Entrenar el modelo
arbol.fit(X_entreno, y_entreno)

# Evaluar el modelo
exactitud = arbol.score(X_prueba, y_prueba)
print(f"Exactitud del modelo: {exactitud:.2f}")

En este código, se utilizan varios parámetros para ajustar el comportamiento del árbol. Por ejemplo, max_depth=5 limita la profundidad máxima, y min_samples_leaf=2 asegura que cada hoja tenga al menos dos muestras.

Es importante experimentar con estos parámetros para encontrar la configuración que proporcione el mejor rendimiento en el conjunto de datos específico. El ajuste de hiperparámetros puede realizarse mediante técnicas como la búsqueda en cuadrícula (GridSearchCV) o la búsqueda aleatoria (RandomizedSearchCV).

GridSearchCV permite explorar exhaustivamente una cuadrícula de parámetros especificados:

from sklearn.model_selection import GridSearchCV

# Definir la cuadrícula de hiperparámetros
param_grid = {
    'max_depth': [3, 5, 7, None],
    'min_samples_split': [2, 5, 10],
    'criterion': ['gini', 'entropy']
}

# Crear el objeto GridSearchCV
grid_search = GridSearchCV(
    estimator=DecisionTreeClassifier(random_state=42),
    param_grid=param_grid,
    cv=5,
    scoring='accuracy'
)

# Realizar la búsqueda
grid_search.fit(X_entreno, y_entreno)

# Mejor combinación de parámetros
print("Mejores parámetros:", grid_search.best_params_)

Utilizando GridSearchCV, se pueden identificar los hiperparámetros que optimizan el rendimiento del modelo. Este enfoque sistemático es esencial para construir modelos robustos y eficaces.

Además, el parámetro max_features desempeña un papel crucial en cómo el árbol considera las características al dividir los nodos. Por ejemplo, establecer max_features='sqrt' puede ser beneficioso en conjuntos de datos con un gran número de características, ya que reduce la variabilidad del modelo.

El parámetro ccp_alpha es relevante para la poda del árbol utilizando la complejidad del coste minimal (Minimal Cost-Complexity Pruning). Al ajustar ccp_alpha, se controla el equilibrio entre el ajuste al conjunto de entrenamiento y la complejidad del árbol.

Para obtener información detallada sobre los valores de impureza y los nodos del árbol, se puede acceder a los atributos del modelo entrenado. Por ejemplo, arbol.tree_ proporciona acceso a la estructura interna del árbol, permitiendo una comprensión más profunda del modelo.

En resumen, el ajuste adecuado de los parámetros de DecisionTreeClassifier es esencial para aprovechar al máximo el potencial de los árboles de decisión en tareas de clasificación. Comprender el impacto de cada parámetro facilita la creación de modelos más precisos y generalizables.

Interpretabilidad de los árboles de decisión para clasificación en Scikit Learn

La interpretabilidad es una de las características más interesantes de los árboles de decisión en clasificación. Estos modelos permiten comprender fácilmente cómo se toman las decisiones, ya que representan explícitamente las reglas utilizadas para clasificar las muestras. En Scikit-Learn, existen diversas herramientas para explorar y visualizar el árbol generado, facilitando así su análisis y explicación.

Un primer paso para interpretar el modelo es visualizar su estructura. La función plot_tree del módulo sklearn.tree permite generar una representación gráfica del árbol. En este ejemplo, utilizaremos el conjunto de datos wine de Scikit-Learn, que clasifica vinos en tres categorías basándose en características químicas como la acidez, el alcohol, y los niveles de magnesio:

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

# Cargar el conjunto de datos
datos = load_wine()
X = datos.data
y = datos.target

# Dividir los datos en entrenamiento y prueba
X_entreno, X_prueba, y_entreno, y_prueba = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Crear y entrenar el modelo
arbol = DecisionTreeClassifier(max_depth=3, random_state=42, ccp_alpha=0.01)
arbol.fit(X_entreno, y_entreno)

# Visualizar el árbol
plt.figure(figsize=(12, 8))
plot_tree(
    arbol,
    feature_names=datos.feature_names,
    class_names=datos.target_names,
    filled=True,
    rounded=True,
    fontsize=10
)
plt.show()

Explicación del árbol generado

El conjunto de datos wine contiene tres categorías de vino (class_0, class_1, class_2) basadas en características químicas. Al entrenar el modelo y visualizar el árbol, podemos observar cómo se toman las decisiones en cada nodo:

• Raíz del árbol:
  • El nodo raíz evalúa la característica color_intensity, que representa la intensidad del color del vino.
  • Condición: color_intensity <= 3.82. Si esta condición es verdadera, el modelo pasa al nodo izquierdo; si es falsa, al derecho.
  • Esta división inicial separa los vinos class_1 de las demás clases, mostrando que la intensidad del color es clave para diferenciar entre estas clases.
• Nodo izquierdo del árbol (rama izquierda):
  • La siguiente división utiliza la característica proline, que es un compuesto químico relacionado con la calidad del vino.
  • Condición: proline <= 1010.0. Si esta condición es verdadera, el modelo pasa al nodo izquierdo; si es falsa, al derecho.
  • Esto ayuda a distinguir entre vinos class_1 y class_0.
• Nodo derecho del árbol (rama derecha):
  • El modelo evalúa la característica flavanoids, un compuesto químico relacionado con los flavonoides del vino.
  • Condición: flavanoids <= 1.4. Si es verdadera, el modelo clasifica hacia class_2. Si es falsa, evalúa la característica proline para separar vinos class_0 de class_1.
• Hojas del árbol:
  • Cada nodo hoja representa una clase final (class_0, class_1, class_2).
  • Por ejemplo, si color_intensity > 3.82 y flavanoids <= 1.4, el vino es clasificado como class_2.

Además de la representación gráfica, es posible extraer una descripción textual del árbol utilizando la función export_text:

from sklearn.tree import export_text

# Extraer reglas del árbol
reglas = export_text(arbol, feature_names=datos.feature_names)
print(reglas)

Salida:

El resultado es una serie de reglas if-else que describen el camino desde el nodo raíz hasta cada nodo hoja. Esto permite entender exactamente qué condiciones deben cumplirse para que una muestra sea clasificada en una determinada categoría.

Otra forma de interpretar el modelo es analizando la importancia de las características. El atributo feature_importances_ del objeto DecisionTreeClassifier proporciona una medida cuantitativa de la relevancia de cada característica en el árbol:

import pandas as pd
import numpy as np

# Crear un dataframe con las importancias
importancias = pd.DataFrame({
    'Característica': datos.feature_names,
    'Importancia': arbol.feature_importances_
})

# Ordenar las características por importancia
importancias = importancias.sort_values('Importancia', ascending=False)

print(importancias)

Salida:

Este análisis indica qué características contribuyen más a la predicción, lo que puede ser crucial para entender el comportamiento del modelo y para la selección de características en futuros análisis.

En contextos donde la transparencia es esencial, como en sectores regulados o sensibles, poder explicar cómo el modelo llega a una decisión es fundamental. Por ejemplo, en aplicaciones médicas, es importante saber qué factores influyen en el diagnóstico para garantizar confianza y cumplimiento ético.

También es posible examinar las decisiones individuales del modelo para muestras específicas. Mediante el método decision_path, se puede obtener el recorrido de un ejemplo a través del árbol:

# Seleccionar una muestra de prueba
indice_muestra = 0
X_muestra = X_prueba[indice_muestra]

# Obtener el camino de decisión
ruta, _ = arbol.decision_path([X_muestra])

# Identificar los nodos recorridos
nodos_recorridos = ruta.indices

print(f"SAMPLE {indice_muestra}:")
for nodo in nodos_recorridos:
    if arbol.tree_.children_left[nodo] != -1:
        nombre_caracteristica = datos.feature_names[arbol.tree_.feature[nodo]]
        umbral = arbol.tree_.threshold[nodo]
        valor_muestra = X_muestra[arbol.tree_.feature[nodo]]
        if valor_muestra <= umbral:
            decision = "izquierda"
        else:
            decision = "derecha"
        print(f"En el nodo {nodo}, la característica '{nombre_caracteristica}' con valor {valor_muestra:.2f} va a la rama {decision}.")

Este fragmento de código detalla paso a paso cómo una muestra es clasificada, mostrando las decisiones tomadas en cada nodo. De esta manera, se puede explicar de forma intuitiva el razonamiento del modelo para casos individuales.

Para abordar problemas de sobreajuste y mejorar la interpretabilidad, es recomendable limitar la profundidad del árbol o podar ramas irrelevantes. Esto simplifica el modelo y facilita su comprensión. Por ejemplo, al establecer max_depth=3, se reduce la complejidad y se obtiene un árbol más manejable.

Además, herramientas externas como Lime o SHAP pueden complementar el análisis al proporcionar explicaciones más detalladas y locales de las predicciones. Sin embargo, los árboles de decisión ya ofrecen una interpretabilidad inherente que a menudo es suficiente para muchos propósitos.

Es importante destacar que la capacidad de interpretar el modelo no solo ayuda en la explicación de resultados, sino que también permite detectar sesgos o errores en los datos. Al examinar las reglas y la importancia de las características, es posible identificar variables que puedan estar influyendo de manera inapropiada en el modelo.

Por último, la exportación del modelo a formatos como Graphviz permite integrarlo en documentos o presentaciones:

from sklearn.tree import export_graphviz

# Exportar el árbol a un archivo DOT
export_graphviz(
    arbol,
    out_file='arbol.dot',
    feature_names=datos.feature_names,
    class_names=datos.target_names,
    filled=True,
    rounded=True
)

# Convertir el archivo DOT a una imagen PNG (requiere instalar Graphviz)
import os
os.system('dot -Tpng arbol.dot -o arbol.png')

Esta funcionalidad facilita compartir y documentar el modelo, manteniendo la integridad de la información y la visualización.

En resumen, Scikit-Learn proporciona múltiples herramientas para explorar y comprender los árboles de decisión en clasificación. La combinación de visualizaciones, extracciones de reglas y análisis de importancias permite una interpretación completa y detallada del modelo, lo que es esencial para asegurar su eficacia y confiabilidad en aplicaciones prácticas.