Redes neuronales como árboles de decisión

Respuesta corta: qué muestra "Neural Networks are Decision Trees"

Aytekin (2022) muestra que una red neuronal con activaciones lineales por tramos, como ReLU, equivale exactamente a un árbol de decisión: cada nodo revisa el signo de un filtro efectivo y cada hoja aplica una función lineal. En su red para y = x², el árbol limpio tiene 5 regiones en vez de 16.

Motivación: por qué convertir una red neuronal en un árbol de decisión

Las redes neuronales predicen bien, pero cuesta explicar por qué. Caglar Aytekin, líder de IA en AAC Technologies, abre su preprint de arXiv de 2022 con ese problema: la naturaleza de caja negra (black box) de las redes frena su adopción en industrias como salud y seguridad. Si no sabes por qué un modelo decidió algo, es difícil confiarle decisiones caras.

El paper repasa tres familias de soluciones. La primera son los mapas de saliencia (saliency maps), que marcan qué zonas de la entrada pesaron más en la predicción a partir de gradientes o activaciones. Sirven para revisar si el modelo mira el lugar correcto. Según el autor, no dan un razonamiento lógico de por qué se tomó la decisión.

La segunda familia aproxima la red con un modelo interpretable. El ejemplo que cita es la destilación de Frosst y Hinton, que entrena un árbol de decisión suave para imitar a la red. Es una aproximación, y el autor señala que rinde peor en la tarea original. La tercera familia mezcla red y árbol en un solo modelo, pero obliga a cambiar la arquitectura.

La propuesta de Aytekin es distinta: no aproximar ni modificar nada. Toma una red ya entrenada y la escribe, sin pérdida, como un árbol de decisión (decision tree). Si la equivalencia es exacta, el árbol da la misma salida que la red para cualquier entrada. Sus reglas son una lectura literal de lo que la red calcula.

El autor reconoce que hay trabajos previos con resultados parecidos para redes ReLU, como el análisis con splines afines de Balestriero y Baraniuk o la geometría tropical de Zhang, Naitzat y Lim. Su aporte, según el propio paper, es extender la idea a cualquier activación, a convoluciones, conexiones residuales, normalización y redes recurrentes.

Cómo funciona: la red neuronal como árbol de decisión, paso a paso

Empieza con una red totalmente conectada (fully connected). En cada capa $i$ se multiplica por una matriz de pesos $\mathbf{W}_i$ y se aplica una activación $\sigma$ elemento por elemento. El paper omite el sesgo (bias) porque se puede meter como una entrada constante extra. La observación clave: una activación lineal por tramos, como ReLU o Leaky ReLU, solo multiplica cada neurona por una pendiente.

Con ReLU esa pendiente vale cero o uno, según si la neurona quedó del lado negativo o del positivo. Si guardas las pendientes en un vector $\mathbf{a}_{i-1}$, la activación desaparece de la fórmula y queda una multiplicación de matrices. Es la ecuación (3) del paper:

$$\mathbf{W}_i^T\sigma(\mathbf{W}_{i-1}^T\mathbf{x}_{i-1}) = (\mathbf{W}_i \odot \mathbf{a}_{i-1})^T\mathbf{W}_{i-1}^T\mathbf{x}_{i-1}$$

• $\mathbf{x}_{i-1}$: la entrada de la capa $i-1$; en la primera capa es el dato original $\mathbf{x}_0$.
• $\mathbf{W}_{i-1}^T\mathbf{x}_{i-1}$: la respuesta lineal de los filtros de esa capa, antes de la activación.
• $\mathbf{a}_{i-1}$: la pendiente de la activación en el tramo donde cayó cada respuesta. El paper lo interpreta como un resultado de categorización: dice de qué lado del umbral quedó cada neurona.
• $\odot$: multiplicación elemento por elemento aplicada por columnas. Con ReLU apaga las columnas de $\mathbf{W}_i$ que corresponden a neuronas apagadas.

La intuición: en cuanto sabes qué neuronas se encendieron, la red completa es lineal en esa zona del espacio. Si una pendiente cambia, cambia la matriz que se aplica después.

Repitiendo el truco capa por capa, el paper define una matriz efectiva que actúa directo sobre la entrada. Es la ecuación (5):

$${}_{\mathbf{c}_{i-1}}\hat{\mathbf{W}}_i^T = (\mathbf{W}_i \odot \mathbf{a}_{i-1})^T \cdots (\mathbf{W}_1 \odot \mathbf{a}_0)^T\mathbf{W}_0^T$$

• $\mathbf{c}_{i-1} = \mathbf{a}_0 \Vert \mathbf{a}_1 \Vert \cdots \Vert \mathbf{a}_{i-1}$: el vector de categorización, la concatenación de todas las decisiones tomadas antes de la capa $i$.
• $\hat{\mathbf{W}}_i$: la matriz efectiva de la capa $i$. Cumple ${}_{\mathbf{c}_{i-1}}\hat{\mathbf{W}}_i^T\mathbf{x}_0 = \mathbf{W}_i^T\mathbf{x}_i$: da la misma respuesta que la capa original, pero calculada desde la entrada.
• $\mathbf{W}_0$: los pesos de la primera capa, que no dependen de ninguna decisión previa.

La intuición: la matriz efectiva de cada capa depende solo de las decisiones anteriores. Eso es justo un árbol de decisión. La raíz evalúa el primer filtro efectivo y pregunta si $\hat{\mathbf{w}}^T\mathbf{x}_0 > 0$. Cada respuesta abre una rama y se evalúa el siguiente filtro, hasta cubrir la capa. Con esas decisiones se calcula la matriz efectiva de la capa siguiente y se repite. En cada hoja queda la función lineal que la red aplica a las entradas que llegan ahí. El paper lo resume en los algoritmos 1 y 2.

Con ReLU cada nodo tiene dos hijos. Una capa con $m_i$ filtros produce $k^{m_i}$ categorías, donde $k$ es el número de tramos lineales de la activación. La profundidad del árbol es $d = \sum_{i=0}^{n-2} m_i$ y el número de hojas llega a $2^d$. El autor lo dice sin rodeos: si la primera capa tiene 64 filtros, hay al menos $2^{64}$ ramas, algo ya intratable. Su respuesta es que muchas reglas son redundantes o contradictorias y se pueden podar sin perder exactitud. Además, muchas categorías nunca reciben datos de entrenamiento.

Más allá de las redes densas

El paper extiende el argumento a otros bloques. Las conexiones residuales (skip connections) dan otra matriz efectiva que también depende solo de decisiones previas. Las capas de normalización son lineales después de entrenar, así que se absorben en los pesos. En las convoluciones hay un vector de pendientes por cada región espacial, y muchas decisiones miran solo un pedazo de la entrada. Las redes recurrentes se desenrollan en el tiempo y quedan como una red hacia adelante.

Con activaciones continuas, como tanh o la sigmoide, la historia cambia. El autor las trata como lineales por tramos con infinitos tramos, así que el árbol tiene ancho infinito incluso con un solo filtro. Él mismo escribe que quizá no sea un resultado útil. Sugiere cuantizar la activación para tener pocos tramos, pero entonces el árbol equivale a la red cuantizada, no a la original.

Ejemplo visual: la red de y = x² convertida en cinco reglas lineales

El primer experimento del paper es una regresión de juguete. Una red de 3 capas densas, con 2 filtros por capa y 1 en la última, aprende $y = x^2$. Usa Leaky ReLU con pendiente negativa de 0.3 y se entrenó con 5000 pares $(x, y)$, con $x$ muestreado de forma regular entre -2.5 y 2.5.

Las capas ocultas suman cuatro filtros, así que el árbol completo tiene 16 hojas. Muchas reglas sobran: revisar $x < 0.32$ después de saber que $x < -1.16$ no aporta nada. Al limpiarlo, el árbol de la red de y = x² queda con 5 categorías. Cada una es un intervalo de $x$ con su propia recta (asignamos los intervalos con la convención de ramas del paper):

• $x < -1.16$: $y = -3.67x - 3.22$
• $-1.16 \le x < 0.11$: $y = -1.00x - 0.12$
• $0.11 \le x < 0.32$: $y = 2.37x - 0.50$
• $0.32 \le x \le 1$: $y = 0.55x + 0.09$
• $x > 1$: $y = 3.47x - 2.83$

La gráfica traza esas cinco rectas junto a la parábola real. Así se ve la red de y = x² como lo que es: una función lineal por tramos con cinco segmentos que se tocan en los umbrales.

Del árbol salen lecturas que la red sola no da. El autor nota que los umbrales no son simétricos, así que la red no captó la simetría de la parábola. También señala que las regiones por debajo de -1.16 y por encima de 1 no tienen límite, y ahí la red pierde precisión conforme $x$ se aleja.

Resultados de Neural Networks are Decision Trees en sus problemas de juguete

El paper no reporta benchmarks con datos reales. Sus resultados son dos experimentos de juguete y una tabla de costo computacional. Lo que muestra es que la conversión funciona y que el árbol se puede leer. No mide exactitud en datos nuevos ni tiempos reales de ejecución.

Clasificación de medias lunas

El segundo problema clasifica el conjunto de medias lunas (half-moons), con dos variables de entrada. La red tiene 3 capas con Leaky ReLU, 2 filtros por capa, 1 en la última y una sigmoide a la salida. El árbol limpio asigna una clase a cada categoría. Cada regla es una combinación lineal de las dos entradas; en la raíz, por ejemplo, la regla es $-0.98x - 0.49y + 0.95$.

Al colorear las regiones, el autor distingue tres tipos. Hay regiones acotadas que coinciden con los datos de entrenamiento y que considera confiables. Hay regiones sin límite que ayudan a separar las clases pero que podrían ser extrapolaciones imprecisas. Y hay categorías donde no cae ningún dato de entrenamiento. Esa lectura es la interpretación del autor sobre una figura, no una métrica.

Parámetros y operaciones del árbol frente a la red

La Tabla 1 compara el árbol inducido con la red original en los dos problemas. Cuenta parámetros, comparaciones de punto flotante y multiplicaciones o sumas. Las cifras del árbol son valores esperados, porque cada hoja está a distinta profundidad.

En la regresión de y = x², el árbol tiene 14 parámetros frente a 13 de la red. Hace 2.6 comparaciones frente a 4, y 2 multiplicaciones o sumas frente a 16.

En medias lunas, el árbol usa 39 parámetros frente a 15 de la red, con 4.1 comparaciones frente a 5 y 8.2 multiplicaciones o sumas frente a 25.

El patrón se repite en los dos casos: el árbol ocupa más memoria y hace menos cuentas por predicción. El autor lo explica así: en el árbol, cada capa aplica sus filtros efectivos directo sobre la entrada, que suele ser más chica que las capas ocultas. Por eso concluye que, en cómputo, el árbol tiene ventaja. Esa conclusión sale de redes con 2 filtros por capa; en redes reales, los parámetros del árbol crecen con el número de hojas.

Limitaciones de Neural Networks are Decision Trees: qué no prueba el paper

• Solo experimentos de juguete. Hay una regresión de una variable y una clasificación de dos variables, con redes de 2 filtros por capa. No hay datos reales, redes grandes ni tiempos medidos; la Tabla 1 cuenta operaciones.
• El tamaño del árbol explota. El propio paper calcula al menos $2^{64}$ ramas para una primera capa de 64 filtros. La poda se ilustra a mano en el caso de una sola variable; no hay un algoritmo de poda evaluado ni una medición de cuántas hojas sobreviven en una red mediana.
• La equivalencia finita solo vale para activaciones lineales por tramos. Con tanh o sigmoide el árbol es infinito, y cuantizar la activación cambia la red.
• Reglas exactas, no siempre legibles. Cada nodo es un umbral sobre una combinación lineal de todas las entradas, no una pregunta sobre una sola variable como en un árbol de scikit-learn. Además, el autor reconoce traslapes con trabajos previos sobre redes ReLU, y el paper es un preprint de un solo autor, sin versión publicada en una revista o conferencia registrada en arXiv.

Qué significa para ti: cómo usar la idea de Neural Networks are Decision Trees

Si trabajas con redes pequeñas sobre datos tabulares, la idea te sirve hoy. Una red ReLU divide el espacio en regiones y en cada una aplica un modelo lineal. Puedes calcular la región de cualquier ejemplo y la función lineal que la red usa ahí. Eso ayuda a auditar predicciones puntuales y a detectar zonas donde la red extrapola sin datos.

No necesitas una librería especial. Con un MLPRegressor de scikit-learn y unas líneas de NumPy reconstruyes el camino en el árbol y la recta de la hoja, siguiendo la ecuación (3):

import numpy as np
from sklearn.neural_network import MLPRegressor

# Red de juguete: dos capas ocultas de 2 filtros, como en el paper
x = np.linspace(-2.5, 2.5, 5000).reshape(-1, 1)
y = x.ravel() ** 2
red = MLPRegressor(hidden_layer_sizes=(2, 2), activation="relu",
                   max_iter=5000, random_state=0).fit(x, y)

def hoja(red, x0):
    """Camino en el árbol (decisiones por capa) y recta de la hoja."""
    W_ef = np.eye(x0.shape[0])   # mapa efectivo desde la entrada
    b_ef = np.zeros(x0.shape[0])
    camino = []
    for W, b in zip(red.coefs_[:-1], red.intercepts_[:-1]):
        z = x0 @ (W_ef @ W) + (b_ef @ W + b)   # filtros efectivos sobre x0
        a = (z > 0).astype(float)              # decisión sí/no por filtro
        camino.append(tuple(int(v) for v in a))
        W_ef = (W_ef @ W) * a                  # (W ⊙ a) de la ecuación (3)
        b_ef = (b_ef @ W + b) * a
    W_out, b_out = red.coefs_[-1], red.intercepts_[-1]
    return tuple(camino), (W_ef @ W_out).ravel(), (b_ef @ W_out + b_out).ravel()

hojas = {}
for x0 in x[::50]:
    camino, w, b = hoja(red, x0)
    assert np.allclose(x0 @ w + b, red.predict(x0.reshape(1, -1)))
    hojas[camino] = (round(float(w[0]), 2), round(float(b[0]), 2))

print(f"Hojas visitadas: {len(hojas)} de {2 ** 4} posibles")
for camino, (w, b) in hojas.items():
    print(camino, f"y = {w}x + {b}")

El código evalúa los filtros efectivos sobre la entrada, guarda las decisiones de cada capa y comprueba que la recta de la hoja da la misma predicción que la red. Al recorrer muchos puntos verás que solo se visitan unas pocas hojas de las posibles, igual que en el paper.

Lo que no cambia: en una red de producción con miles de neuronas, el árbol completo no cabe en memoria y tampoco es más legible que la red. Ahí conviene usar la idea de forma local, para explicar la región de un ejemplo, y no como reemplazo del modelo. Si necesitas un modelo que se explique solo, un árbol de decisión o un modelo lineal entrenados directamente siguen siendo la opción más simple.

Otras referencias

• Balestriero, R. y Baraniuk, R. (2018). Mad max: Affine spline insights into deep learning. arXiv:1805.06576.
• Zhang, L., Naitzat, G. y Lim, L.-H. (2018). Tropical geometry of deep neural networks. ICML 2018, PMLR, pp. 5824 a 5832.
• Frosst, N. y Hinton, G. (2017). Distilling a neural network into a soft decision tree. arXiv:1711.09784.
• Nguyen, D. T., Kasmarik, K. E. y Abbass, H. A. (2020). Towards interpretable ANNs: An exact transformation to multi-class multivariate decision trees. arXiv:2003.04675.
• Sudjianto, A., Knauth, W., Singh, R., Yang, Z. y Zhang, A. (2020). Unwrapping the black box of deep ReLU networks: interpretability, diagnostics, and simplification. arXiv:2011.04041.