Profundización en la Interpretabilidad de Modelos con PFI

Interpretability of Models with PFI

Otra herramienta de interpretabilidad para tu caja de herramientas

Saber cómo evaluar tu modelo es esencial para tu trabajo como científico de datos. Nadie aprobará tu solución si no eres capaz de comprenderla y comunicarla completamente a tus interesados. Es por eso que conocer los métodos de interpretabilidad es tan importante.

La falta de interpretabilidad puede acabar con un modelo muy bueno. No he desarrollado un modelo en el que mis interesados no estuvieran interesados en entender cómo se realizaron las predicciones. Por lo tanto, saber cómo interpretar un modelo y comunicarlo al negocio es una habilidad esencial para un científico de datos.

En esta publicación, vamos a explorar la Importancia de Características por Permutación (PFI), una metodología agnóstica de modelo que nos puede ayudar a identificar cuáles son las características más importantes de nuestro modelo y, por lo tanto, comunicar mejor lo que el modelo está considerando al hacer sus predicciones.

¿Qué es la Importancia de Características por Permutación?

El método PFI intenta estimar qué tan importante es una característica para los resultados del modelo basándose en lo que sucede en el modelo cuando cambiamos la característica conectada a la variable objetivo.

• Comprendiendo los fundamentos de las redes neuronales y el aprendizaje profundo
• Explorando el poder y las limitaciones de GPT-4
• Girando hacia el futuro La nueva guía de ondas está cambiando la forma en que se transfiere y se manipula los datos.

Para hacer eso, para cada característica que queremos analizar la importancia, la mezclamos al azar manteniendo todas las demás características y la variable objetivo de la misma manera.

Esto hace que la característica sea inútil para predecir la variable objetivo, ya que rompimos la relación entre ellas al cambiar su distribución conjunta.

Luego, podemos usar nuestro modelo para predecir nuestro conjunto de datos mezclado. La cantidad de reducción de rendimiento en nuestro modelo indicará qué tan importante es esa característica.

El algoritmo se vería algo así:

• Entrenamos un modelo en un conjunto de datos de entrenamiento y luego evaluamos su rendimiento tanto en el conjunto de entrenamiento como en el conjunto de pruebas
• Para cada característica, creamos un nuevo conjunto de datos donde la característica está mezclada
• Luego usamos el modelo entrenado para predecir la salida del nuevo conjunto de datos
• El cociente de la nueva métrica de rendimiento entre la antigua nos da la importancia de la característica

Observa que si una característica no es importante, el rendimiento del modelo no debería variar mucho. Si lo es, entonces el rendimiento debe sufrir mucho.

Interpretando el PFI

Ahora que sabemos cómo calcular el PFI, ¿cómo lo interpretamos?

Depende de a qué conjunto de datos estemos aplicando el PFI. Por lo general, tenemos dos opciones: aplicarlo al conjunto de entrenamiento o al conjunto de pruebas.

Interpretación en el entrenamiento

Durante el entrenamiento, nuestro modelo aprende los patrones de los datos y trata de representarlos. Por supuesto, durante el entrenamiento, no tenemos idea de qué tan bien nuestro modelo generaliza a datos no vistos.

Por lo tanto, al aplicar el PFI al conjunto de entrenamiento, veremos qué características fueron las más relevantes para el aprendizaje de la representación de los datos por parte del modelo.

En términos empresariales, esto indica qué características fueron las más importantes para la construcción del modelo.

Interpretación en las pruebas

Ahora, si aplicamos el método al conjunto de pruebas, veremos el impacto de las características en la generalización del modelo.

Pensemos en ello. Si vemos que el rendimiento del modelo disminuye en el conjunto de pruebas después de mezclar una característica, significa que esa característica fue importante para el rendimiento en ese conjunto. Dado que el conjunto de pruebas es lo que usamos para probar la generalización (si estás haciendo todo correctamente), entonces podemos decir que es importante para la generalización.

Los problemas con el PFI

El PFI analiza el efecto de una característica en el rendimiento de tu modelo, por lo tanto, no establece nada sobre los datos sin procesar. Si el rendimiento de tu modelo es pobre, entonces cualquier relación que encuentres con el PFI carecerá de sentido.

Esto es válido para ambos conjuntos, si tu modelo está subajustado (baja capacidad de predicción en el conjunto de entrenamiento) o sobreajustado (baja capacidad de predicción en el conjunto de pruebas), entonces no puedes obtener información útil de este método.

Además, cuando dos características están altamente correlacionadas, el PFI puede llevar a una interpretación errónea. Si mezclas una característica pero la información necesaria está codificada en otra, es posible que el rendimiento no se vea afectado en absoluto, lo que te haría pensar que la característica es inútil, lo cual puede no ser el caso.

Implementando el PFI en Python

Para implementar el PFI en Python primero debemos importar nuestras librerías requeridas. Para esto, vamos a utilizar principalmente las librerías numpy, pandas, tqdm y sklearn:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_diabetes, load_iris
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from sklearn.metrics import accuracy_score, r2_score

Ahora, debemos cargar nuestro dataset, que va a ser el dataset Iris. Luego, vamos a ajustar un Random Forest a los datos.

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=12, shuffle=True)
rf = RandomForestClassifier(n_estimators=3, random_state=32).fit(X_train, y_train)

Con nuestro modelo ajustado, analicemos su rendimiento para ver si podemos aplicar de manera segura el PFI para ver cómo afectan las características a nuestro modelo:

print(accuracy_score(rf.predict(X_train), y_train))
print(accuracy_score(rf.predict(X_test), y_test))

Podemos ver que obtuvimos un 99% de precisión en el conjunto de entrenamiento y un 95.5% de precisión en el conjunto de prueba. Parece bien hasta ahora. Obtengamos los errores originales para una comparación posterior:

original_error_train = 1 - accuracy_score(rf.predict(X_train), y_train)
original_error_test = 1 - accuracy_score(rf.predict(X_test), y_test)

Ahora calculemos los puntajes de permutación. Para eso, es usual ejecutar la permutación para cada característica varias veces para obtener una estadística de los puntajes de las características y evitar cualquier coincidencia. En nuestro caso, vamos a hacer 10 repeticiones para cada característica:

n_steps = 10
feature_values = {}
for feature in range(X.shape[1]):  # Vamos a guardar cada nuevo punto de rendimiento para cada característica
    errors_permuted_train = []
    errors_permuted_test = []
    for step in range(n_steps):
        # Tomamos los datos nuevamente porque la función np.random.shuffle mezcla en su lugar
        X, y = load_iris(return_X_y=True)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=12, shuffle=True)
        np.random.shuffle(X_train[:, feature])
        np.random.shuffle(X_test[:, feature])
        # Aplicamos nuestro modelo previamente ajustado en los nuevos datos para obtener el rendimiento
        errors_permuted_train.append(1 - accuracy_score(rf.predict(X_train), y_train))
        errors_permuted_test.append(1 - accuracy_score(rf.predict(X_test), y_test))
    feature_values[f'{feature}_train'] = errors_permuted_train
    feature_values[f'{feature}_test'] = errors_permuted_test

Ahora tenemos un diccionario con el rendimiento para cada permutación que hicimos. Ahora generemos una tabla que tenga, para cada característica en cada repetición, el promedio y la desviación estándar del rendimiento en comparación con el rendimiento original de nuestro modelo:

PFI = pd.DataFrame()
for feature in feature_values:
    if 'train' in feature:
        aux = feature_values[feature] / original_error_train
        fold = 'train'
    elif 'test' in feature:
        aux = feature_values[feature] / original_error_test
        fold = 'test'
    PFI = PFI.append({
        'feature': feature.replace(f'_{fold}', ''),
        'pfold': fold,
        'mean': np.mean(aux),
        'std': np.std(aux),
    }, ignore_index=True)
PFI = PFI.pivot(index='feature', columns='fold', values=['mean', 'std']).reset_index().sort_values(('mean', 'test'), ascending=False)

Vamos a obtener algo como esto:

Podemos ver que la característica 2 parece ser la característica más importante en nuestro dataset para ambos conjuntos, seguida de la característica 3. Dado que no estamos fijando la semilla aleatoria para la función de mezcla de numpy, podemos esperar que este número varíe.

Luego, podemos graficar la importancia en un gráfico para tener una mejor visualización de la importancia:

Conclusión

El PFI es una metodología simple que puede ayudarte a identificar rápidamente las características más importantes. Adelante, intenta aplicarlo a algún modelo que estés desarrollando para ver cómo se comporta.

Pero también ten en cuenta las limitaciones del método. No saber dónde falla un método terminará haciendo que hagas una interpretación incorrecta.

Además, ten en cuenta que el PFI muestra la importancia de la característica pero no indica en qué dirección está influenciando la salida del modelo.

Entonces, dime, ¿cómo vas a utilizar esto en tus próximos modelos?

Mantente atento a más publicaciones sobre métodos de interpretabilidad que puedan mejorar tu comprensión general de un modelo.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!