How to Use LIME for Model Interpretation in Python

Key Insights

LIME explains individual predictions by approximating complex models locally with interpretable ones, making it model-agnostic and applicable to any black-box classifier
The technique works across data types—tabular, text, and images—by perturbing input data and observing how predictions change, then fitting a simple linear model to those perturbations
LIME explanations are local and instance-specific, meaning they explain why a model made a particular prediction for a specific input rather than how the model works globally

Understanding the Black Box Problem

Modern machine learning models like deep neural networks, gradient boosting machines, and ensemble methods achieve impressive accuracy but operate as black boxes. You can’t easily trace why they make specific predictions. This opacity creates serious problems in healthcare, finance, and legal applications where you need to justify decisions to regulators, customers, or patients.

LIME (Local Interpretable Model-agnostic Explanations) solves this by explaining individual predictions through a clever approach: it creates synthetic data points near your instance of interest, gets predictions from your black-box model, then fits a simple, interpretable model to approximate the complex model’s behavior in that local region. The result is an explanation you can understand and communicate.

Setting Up Your Environment

Install LIME and the supporting libraries you’ll need:

pip install lime scikit-learn numpy matplotlib pillow

Here are the essential imports for working with LIME across different data types:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_wine, fetch_20newsgroups
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from lime import lime_tabular, lime_text, lime_image
from lime.wrappers.scikit_image import SegmentationAlgorithm

Training a Base Model to Interpret

Let’s start with a tabular dataset. The Wine dataset works well because it has meaningful features we can interpret:

# Load and split data
wine = load_wine()
X_train, X_test, y_train, y_test = train_test_split(
    wine.data, wine.target, test_size=0.2, random_state=42
)

# Train a Random Forest classifier
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)

# Check accuracy
print(f"Model accuracy: {rf_model.score(X_test, y_test):.3f}")

# Make a prediction we'll explain
instance_idx = 0
instance = X_test[instance_idx]
prediction = rf_model.predict([instance])[0]
prediction_proba = rf_model.predict_proba([instance])[0]

print(f"Predicted class: {wine.target_names[prediction]}")
print(f"Prediction probabilities: {prediction_proba}")

Implementing LIME for Tabular Data

Now create a LIME explainer for tabular data. The explainer needs to know about your training data’s distribution and feature names:

# Initialize the LIME explainer
explainer = lime_tabular.LimeTabularExplainer(
    training_data=X_train,
    feature_names=wine.feature_names,
    class_names=wine.target_names,
    mode='classification'
)

# Generate explanation for the instance
explanation = explainer.explain_instance(
    data_row=instance,
    predict_fn=rf_model.predict_proba,
    num_features=10
)

# Display the explanation
explanation.show_in_notebook(show_table=True)

# Or get the feature importance as a list
print("\nTop features influencing this prediction:")
for feature, weight in explanation.as_list():
    print(f"{feature}: {weight:.3f}")

The explanation shows which features pushed the prediction toward or away from each class. Positive weights support the predicted class, while negative weights oppose it. You can also visualize this:

# Create a matplotlib figure
fig = explanation.as_pyplot_figure()
plt.tight_layout()
plt.savefig('lime_tabular_explanation.png', dpi=150, bbox_inches='tight')
plt.show()

Implementing LIME for Text Classification

Text classification presents different challenges. Let’s build a simple sentiment classifier and explain its predictions:

# Load a subset of 20 newsgroups for binary classification
categories = ['alt.atheism', 'soc.religion.christian']
newsgroups_train = fetch_20newsgroups(
    subset='train', categories=categories, random_state=42
)
newsgroups_test = fetch_20newsgroups(
    subset='test', categories=categories, random_state=42
)

# Create a pipeline with TF-IDF and Random Forest
text_pipeline = make_pipeline(
    TfidfVectorizer(max_features=1000),
    RandomForestClassifier(n_estimators=100, random_state=42)
)

# Train the model
text_pipeline.fit(newsgroups_train.data, newsgroups_train.target)

# Initialize LIME text explainer
text_explainer = lime_text.LimeTextExplainer(class_names=categories)

# Select a test instance
test_idx = 10
test_instance = newsgroups_test.data[test_idx]

# Generate explanation
text_explanation = text_explainer.explain_instance(
    test_instance,
    text_pipeline.predict_proba,
    num_features=10
)

# Display results
print(f"Predicted class: {categories[text_pipeline.predict([test_instance])[0]]}")
print("\nWords influencing the prediction:")
for word, weight in text_explanation.as_list():
    print(f"'{word}': {weight:.3f}")

# Visualize in HTML (useful for notebooks)
text_explanation.show_in_notebook(text=True)

The text explainer highlights which words or phrases most influenced the classification. Words with positive weights support the predicted class, while negative weights indicate words that argue against it.

Implementing LIME for Image Classification

Image explanations require a different approach. LIME segments images into “superpixels” and determines which regions influence predictions:

from skimage.segmentation import mark_boundaries
from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input, decode_predictions
from tensorflow.keras.preprocessing import image as keras_image

# Load pre-trained model
model = ResNet50(weights='imagenet')

# Load and preprocess an image
img_path = 'your_image.jpg'  # Replace with actual image path
img = keras_image.load_img(img_path, target_size=(224, 224))
img_array = keras_image.img_to_array(img)

# Create prediction function
def predict_fn(images):
    processed = preprocess_input(images.copy())
    return model.predict(processed)

# Initialize image explainer
image_explainer = lime_image.LimeImageExplainer()

# Generate explanation
image_explanation = image_explainer.explain_instance(
    img_array.astype('double'),
    predict_fn,
    top_labels=5,
    hide_color=0,
    num_samples=1000
)

# Get the top predicted class
top_class = image_explanation.top_labels[0]

# Visualize the explanation
temp, mask = image_explanation.get_image_and_mask(
    top_class,
    positive_only=True,
    num_features=5,
    hide_rest=False
)

plt.figure(figsize=(12, 4))
plt.subplot(1, 3, 1)
plt.imshow(img)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 3, 2)
plt.imshow(mark_boundaries(temp / 255.0, mask))
plt.title('LIME Explanation')
plt.axis('off')

plt.subplot(1, 3, 3)
plt.imshow(mask, cmap='gray')
plt.title('Influential Regions')
plt.axis('off')

plt.tight_layout()
plt.savefig('lime_image_explanation.png', dpi=150)
plt.show()

The visualization shows which image regions (superpixels) contributed most to the classification. This is invaluable for debugging models that might be focusing on spurious correlations.

Interpreting and Validating LIME Results

LIME explanations are approximations, not ground truth. Here’s how to validate and interpret them responsibly:

# Generate multiple explanations for the same instance
num_explanations = 5
feature_importance_matrix = []

for i in range(num_explanations):
    exp = explainer.explain_instance(
        instance,
        rf_model.predict_proba,
        num_features=10
    )
    # Extract feature weights as dictionary
    weights_dict = dict(exp.as_list())
    feature_importance_matrix.append(weights_dict)

# Check consistency across explanations
import pandas as pd
df_importance = pd.DataFrame(feature_importance_matrix)
print("Feature importance statistics across multiple runs:")
print(df_importance.describe())

# Calculate coefficient of variation for stability
cv = (df_importance.std() / df_importance.mean().abs()).sort_values(ascending=False)
print("\nFeature stability (lower is more stable):")
print(cv.head())

Key considerations when using LIME:

Locality matters: LIME explanations are only valid near the instance being explained. Don’t assume the same features matter for all predictions.

Sampling variability: LIME uses random sampling, so explanations can vary between runs. Run multiple explanations and check for consistency.

Feature interactions: LIME uses a linear model locally, so it may miss complex feature interactions that influence predictions.

Validation strategy: Compare LIME explanations against domain knowledge. If a model relies on features that make no sense, you’ve likely found a bug or data leakage.

Computational cost: Image explanations especially can be slow. The num_samples parameter controls the accuracy-speed tradeoff—more samples give better approximations but take longer.

LIME won’t tell you if your model is correct, but it will tell you why it made a specific prediction. Use this to build trust, debug failures, and communicate with stakeholders who need to understand your model’s reasoning. When explanations don’t match intuition, investigate—you might discover data quality issues, label errors, or fundamental model problems that accuracy metrics alone wouldn’t reveal.