En este tutorial, vamos a descubrir distintas visualizaciones con SHAP-IQ que nos ayudan a entender cómo un modelo de aprendizaje automático llega a sus predicciones. Estas visualizaciones descomponen el comportamiento complejo del modelo en partes interpretables, mostrando tanto las contribuciones individuales de cada característica como las interacciones entre ellas en una predicción específica.
Para comenzar, instalamos las librerías necesarias:
```python !pip install shapiq overrides scikit-learn pandas numpy seaborn ```
Luego, importamos las dependencias y verificamos la versión de shapiq:
```python from sklearn.ensemble import RandomForestRegressor from sklearn.metrics import mean_squared_error, r2_score from sklearn.model_selection import train_test_split from tqdm.asyncio import tqdm import shapiq
print(f"shapiq version: {shapiq.__version__}") ```
Usaremos el conjunto de datos MPG (millas por galón) que trae la librería Seaborn. Este dataset incluye información de distintos modelos de autos, con atributos como caballos de fuerza, peso y origen.
```python import seaborn as sns df = sns.load_dataset("mpg") df ```
Para preparar el conjunto de datos, eliminamos filas con datos faltantes y convertimos la columna categórica "origin" en valores numéricos mediante label encoding, para poder entrenar el modelo.
```python import pandas as pd from sklearn.preprocessing import LabelEncoder
df = df.dropna() le = LabelEncoder() df["origin"] = le.fit_transform(df["origin"])
for i, label in enumerate(le.classes_): print(f"{label} → {i}") ```
A continuación, dividimos los datos en conjuntos de entrenamiento y prueba, separando las características del objetivo (millas por galón).
```python X = df.drop(columns=["mpg", "name"]) y = df["mpg"]
feature_names = X.columns.tolist() x_data, y_data = X.values, y.values
x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.2, random_state=42) ```
Entrenamos un modelo Random Forest con 10 árboles y profundidad máxima 10, asegurando la reproducibilidad con un estado aleatorio fijo.
```python model = RandomForestRegressor(random_state=42, max_depth=10, n_estimators=10) model.fit(x_train, y_train) ```
Evaluamos el rendimiento del modelo con error cuadrático medio y coeficiente de determinación:
```python mse = mean_squared_error(y_test, model.predict(x_test)) r2 = r2_score(y_test, model.predict(x_test)) print(f"Mean Squared Error: {mse:.2f}") print(f"R2 Score: {r2:.2f}") ```
Ahora, escogemos una instancia específica de prueba (por ejemplo la número 7) para examinar cómo el modelo realiza su predicción. Mostramos el valor real, el valor predicho y los valores de las características para esa instancia.
```python instance_id = 7 x_explain = x_test[instance_id] y_true = y_test[instance_id] y_pred = model.predict(x_explain.reshape(1, -1))[0]
print(f"Instancia {instance_id}, Valor real: {y_true}, Valor predicho: {y_pred}") for i, feature in enumerate(feature_names): print(f"{feature}: {x_explain[i]}") ```
Generamos explicaciones basadas en valores de Shapley considerando distintos órdenes de interacción entre características: orden 1 (valores Shapley estándar), orden 2 (interacciones pares) y hasta orden N (todas las interacciones posibles).
```python n_features = len(feature_names) si_order = {}
for order in tqdm([1, 2, n_features]): index = "k-SII" if order > 1 else "SV" explainer = shapiq.TreeExplainer(model=model, max_order=order, index=index) si_order[order] = explainer.explain(x=x_explain) ```
Pasemos a las visualizaciones para interpretar estas explicaciones:
1. **Gráfico de Fuerza (Force Chart)** Este gráfico muestra cómo cada característica hace que la predicción se desplace desde un valor base. Las barras en rojo indican que la característica aumenta la predicción, mientras que las azules la disminuyen. La longitud de cada barra refleja la magnitud de este efecto. Utilizando valores de interacción de Shapley, podemos ver no solo las contribuciones individuales sino también cómo interactúan entre sí.
```python sv = si_order[1] # valores Shapley simples si = si_order[2] # interacciones de segundo orden mi = si_order[n_features] # todas las interacciones
sv.plot_force(feature_names=feature_names, show=True) si.plot_force(feature_names=feature_names, show=True) mi.plot_force(feature_names=feature_names, show=True) ```
Por ejemplo, el valor base es 23.5. Características como Peso, Cilindros y Caballos de fuerza elevan la predicción, mientras que el Año del modelo y la aceleración la bajan.
2. **Gráfico Cascada (Waterfall Chart)** Similar al gráfico de fuerza, muestra cómo las características afectan la predicción en comparación con la base. Su ventaja es que agrupa automáticamente en un bloque “otros” las características con impacto muy pequeño, haciendo la visualización más clara.
```python sv.plot_waterfall(feature_names=feature_names, show=True) si.plot_waterfall(feature_names=feature_names, show=True) mi.plot_waterfall(feature_names=feature_names, show=True) ```
3. **Gráfico de Red (Network Plot)** Este gráfico ilustra las interacciones entre características usando las interacciones de primer y segundo orden de Shapley. El tamaño de cada nodo indica la importancia individual, y el grosor y color de las aristas muestran la fuerza y dirección de las interacciones, revelando relaciones complejas que otros gráficos no capturan tan bien.
```python si.plot_network(feature_names=feature_names, show=True) mi.plot_network(feature_names=feature_names, show=True) ```
4. **Gráfico SI (SI Graph Plot)** Extiende el gráfico de red para incluir interacciones de orden superior mediante hiper-aristas que conectan múltiples características. Aquí, el tamaño de los nodos refleja el impacto individual, y el ancho, color y transparencia de las aristas muestran la intensidad y dirección de las interacciones, ofreciendo una vista completa de cómo las características influyen conjuntamente en la predicción.
```python abbrev_feature_names = shapiq.plot.utils.abbreviate_feature_names(feature_names)
sv.plot_si_graph( feature_names=abbrev_feature_names, show=True, size_factor=2.5, node_size_scaling=1.5, plot_original_nodes=True, ) si.plot_si_graph( feature_names=abbrev_feature_names, show=True, size_factor=2.5, node_size_scaling=1.5, plot_original_nodes=True, ) mi.plot_si_graph( feature_names=abbrev_feature_names, show=True, size_factor=2.5, node_size_scaling=1.5, plot_original_nodes=True, ) ```
5. **Gráfico de Barras (Bar Plot)** Diseñado para explicaciones globales, este gráfico muestra la importancia promedio absoluta de las características o sus interacciones en todo el conjunto de datos, destacando cuáles tienen mayor impacto general en las predicciones del modelo.
```python explanations = [] explainer = shapiq.TreeExplainer(model=model, max_order=2, index="k-SII")
for instance_id in tqdm(range(20)): x_explain = x_test[instance_id] si = explainer.explain(x=x_explain) explanations.append(si)
shapiq.plot.bar_plot(explanations, feature_names=feature_names, show=True) ```
En este gráfico, “Distance” y “Horsepower” son las características más influyentes en promedio. Además, las interacciones “Horsepower × Weight” y “Distance × Horsepower” también tienen un impacto significativo, demostrando que el modelo capta relaciones no lineales entre características.
Estas visualizaciones nos permiten descomponer y entender cómo distintas características y sus combinaciones afectan las predicciones, facilitando la interpretación de modelos complejos.
Este tutorial concluye con una mirada práctica sobre cómo usar SHAP-IQ para interpretar modelos de aprendizaje automático de forma efectiva y visualmente clara.
