LIME: explicaciones locales interpretables e independientes del modelo

LIME: The Core Idea

The LIME Algorithm Step by Step

# Conceptual pseudocode for LIME
def lime_explain(instance, model, n_samples=5000):
    perturbed = perturb_around(instance, n=n_samples)
    predictions = model.predict_proba(perturbed)
    weights = kernel(distance(perturbed, instance))
    surrogate = LinearRegression()
    surrogate.fit(perturbed, predictions, sample_weight=weights)
    return surrogate.coef_  # these are the LIME explanations

Installing the lime Library

import lime
import lime.lime_tabular
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=42
)
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

LimeTabularExplainer for Tabular Data

explainer = lime.lime_tabular.LimeTabularExplainer(
    X_train,
    feature_names=list(data.feature_names),
    class_names=list(data.target_names),
    discretize_continuous=True,
    mode='classification'
)

# Explain a single test instance
instance = X_test[0]
explanation = explainer.explain_instance(
    instance,
    model.predict_proba,
    num_features=10,
    num_samples=5000
)

Reading the Tabular Explanation

# Print top features with their weights
for feature, weight in explanation.as_list():
    direction = 'supports' if weight > 0 else 'contradicts'
    print(f'{feature}: weight={weight:.3f} ({direction} predicted class)')

# Or display as a matplotlib bar chart
explanation.as_pyplot_figure(label=1)
import matplotlib.pyplot as plt
plt.tight_layout()
plt.savefig('lime_tabular.png', dpi=150)

LimeTextExplainer for Text Data

from lime.lime_text import LimeTextExplainer
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB

# Toy spam pipeline
text_pipeline = Pipeline([
    ('tfidf', TfidfVectorizer()),
    ('clf', MultinomialNB())
])
reviews = ['great product fast shipping', 'buy now click here free money']
labels = [0, 1]  # 0=ham, 1=spam
text_pipeline.fit(reviews, labels)

text_explainer = LimeTextExplainer(class_names=['ham', 'spam'])
exp = text_explainer.explain_instance(
    'free fast money click',
    text_pipeline.predict_proba,
    num_features=6
)
print(exp.as_list())

LimeImageExplainer for Images

from lime.lime_image import LimeImageExplainer
from skimage.segmentation import mark_boundaries
import numpy as np

image_explainer = LimeImageExplainer()

# Assume 'img' is a (224, 224, 3) numpy array and 'cnn_predict' wraps the model
# exp = image_explainer.explain_instance(
#     img, cnn_predict, top_labels=1, hide_color=0, num_samples=1000
# )
# image, mask = exp.get_image_and_mask(
#     exp.top_labels[0], positive_only=True, num_features=5
# )
# plt.imshow(mark_boundaries(image, mask))
print('Image explainer segments image into superpixels and identifies key regions.')

LIME vs SHAP: Key Differences

# Summary comparison
comparison = {
    'LIME': {
        'consistency': 'Random — varies between runs',
        'speed': 'Moderate (5k perturbations)',
        'modalities': 'Tabular, text, image',
        'axioms_satisfied': False
    },
    'SHAP': {
        'consistency': 'Exact for TreeExplainer',
        'speed': 'Fast (TreeSHAP), slow (KernelSHAP)',
        'modalities': 'Tabular, text, image (DeepSHAP)',
        'axioms_satisfied': True
    }
}
for method, props in comparison.items():
    print(method, props)

Stability: Increasing num_samples

import numpy as np

weights_runs = []
for seed in range(5):
    np.random.seed(seed)
    exp = explainer.explain_instance(
        instance, model.predict_proba,
        num_features=5, num_samples=5000
    )
    weights_runs.append(dict(exp.as_list()))

# Check variance across runs for top feature
top_feature = exp.as_list()[0][0]
vals = [run.get(top_feature, 0) for run in weights_runs]
print(f'Top feature weight std across 5 runs: {np.std(vals):.4f}')

Using Explanations to Detect Model Bugs

# Example: checking a suspicious prediction
suspect_text = 'I do not recommend this product at all'
exp = text_explainer.explain_instance(
    suspect_text,
    text_pipeline.predict_proba,
    num_features=5
)
for word, weight in exp.as_list():
    print(f'  word={word!r:15} weight={weight:+.3f}')
# If 'not' has positive weight for positive sentiment class,
# the model has learned a spurious pattern.

Integrating LIME into a Review Workflow

# Automated explanation logging for high-confidence errors
for i, (pred, true) in enumerate(zip(model.predict(X_test), y_test)):
    confidence = model.predict_proba(X_test[i:i+1]).max()
    if pred != true and confidence > 0.9:
        exp = explainer.explain_instance(
            X_test[i], model.predict_proba, num_features=5
        )
        print(f'Sample {i}: predicted={data.target_names[pred]}, '
              f'true={data.target_names[true]}, conf={confidence:.2f}')
        for feat, w in exp.as_list()[:3]:
            print(f'  {feat}: {w:+.3f}')

Quick Check

Lesson Recap