ML Model Explainability

As machine learning models become more complex and are deployed in critical applications, the need for explainability has never been greater. This comprehensive guide explores the techniques, tools, and best practices for making AI systems more transparent, interpretable, and trustworthy.

The Importance of Model Explainability

Model explainability refers to the ability to explain and present machine learning model behavior in understandable terms to humans. It's crucial for building trust, ensuring fairness, meeting regulatory requirements, and debugging models.

Key Benefits of Explainable AI

Types of Explainability Methods

Explainability methods can be categorized based on their scope and approach. Understanding these categories helps in selecting the right technique for your specific use case.

1. Global vs. Local Explanations

2. Model-Specific vs. Model-Agnostic Methods

Key Explainability Techniques

Let's dive deeper into the most widely used explainability techniques, their implementations, and when to use them.

1. SHAP (SHapley Additive exPlanations)

SHAP values provide a unified measure of feature importance by calculating the contribution of each feature to the prediction for a specific instance, based on concepts from cooperative game theory.

Implementing SHAP in Python

# Install required packages
# pip install shap pandas scikit-learn

import numpy as np
import pandas as pd
import shap
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

# Load and prepare data
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train a model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Initialize SHAP explainer
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)

# Visualize the first prediction's explanation
shap.initjs()
shap.force_plot(
    explainer.expected_value[1], 
    shap_values[1][0,:], 
    X_test.iloc[0,:],
    feature_names=data.feature_names,
    matplotlib=True,
    show=False
)
plt.tight_layout()
plt.savefig('shap_force_plot.png', dpi=300, bbox_inches='tight')
plt.close()

# Summary plot (feature importance)
shap.summary_plot(shap_values[1], X_test, feature_names=data.feature_names, show=False)
plt.tight_layout()
plt.savefig('shap_summary_plot.png', dpi=300, bbox_inches='tight')
plt.close()

# Dependence plot for a specific feature
shap.dependence_plot(
    "worst radius", 
    shap_values[1], 
    X_test, 
    feature_names=data.feature_names,
    interaction_index=None
)
plt.tight_layout()
plt.savefig('shap_dependence_plot.png', dpi=300, bbox_inches='tight')
plt.close()

2. LIME (Local Interpretable Model-agnostic Explanations)

LIME explains individual predictions by approximating the model locally with an interpretable model, such as a linear model, in the neighborhood of the instance being explained.

Implementing LIME in Python

# Install required packages
# pip install lime

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from lime import lime_tabular
import matplotlib.pyplot as plt
from matplotlib import pyplot as plt
from lime import submodular_pick

# Load and prepare data
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train a model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Initialize LIME explainer
explainer = lime_tabular.LimeTabularExplainer(
    training_data=X_train.values,
    feature_names=data.feature_names,
    class_names=['malignant', 'benign'],
    mode='classification',
    verbose=True,
    random_state=42
)

# Explain a prediction
i = 0  # index of the instance to explain
exp = explainer.explain_instance(
    data_row=X_test.iloc[i],
    predict_fn=model.predict_proba,
    num_features=10,
    top_labels=1
)

# Save explanation to HTML
html = exp.as_html()
with open('lime_explanation.html', 'w') as f:
    f.write(html)

# Get the explanation as a matplotlib figure
fig = exp.as_pyplot_figure(label=1)
plt.tight_layout()
plt.savefig('lime_explanation.png', dpi=300, bbox_inches='tight')
plt.close()

# Submodular pick to get global insights
sp_obj = submodular_pick.SubmodularPick(
    explainer,
    X_test.values,
    model.predict_proba,
    num_features=10,
    num_exps_desired=10
)

# Save submodular pick explanations
for i, exp in enumerate(sp_obj.explanations):
    fig = exp.as_pyplot_figure(label=1)
    plt.tight_layout()
    plt.savefig(f'lime_submodular_pick_{i}.png', dpi=300, bbox_inches='tight')
    plt.close()

3. Counterfactual Explanations

Counterfactual explanations describe the smallest change to the feature values that would change the model's prediction to a predefined output. They answer the question: "What would need to change to get a different outcome?"

Implementing Counterfactual Explanations

# Install required packages
# pip install alibi

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import tensorflow as tf
from alibi.explainers import Counterfactual

# Set random seed for reproducibility
np.random.seed(42)
tf.random.set_seed(42)

# Load and prepare data
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Define a simple neural network model
def create_model(input_shape):
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(64, activation='relu', input_shape=input_shape),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(32, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(1, activation='sigmoid')
    ])
    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    return model

# Create and train the model
input_shape = (X_train.shape[1],)
model = create_model(input_shape)
model.fit(
    X_train.values, 
    y_train,
    epochs=50,
    batch_size=32,
    validation_split=0.1,
    verbose=0
)

# Select an instance to explain
instance = X_test.iloc[0:1].values
prediction = model.predict(instance)
print(f"Original prediction: {prediction[0][0]:.4f} (class: {int(prediction[0][0] > 0.5)})")

# Define predict function for the explainer
predict_fn = lambda x: model.predict(x)

# Initialize counterfactual explainer
cf = Counterfactual(
    predict_fn=predict_fn,
    shape=(1, X_train.shape[1]),
    target_proba=0.5,  # Target probability for the counterfactual
    target_class='other',  # We want to flip the prediction
    max_iter=1000,
    feature_range=(X_train.values.min(axis=0), X_train.values.max(axis=0)),
    lam_init=1e-1,
    max_lam_steps=10,
    learning_rate_init=0.1,
    feature_names=data.feature_names
)

# Generate counterfactual explanation
cf.fit(X_train.values)
explanation = cf.explain(instance)

# Get the counterfactual
if explanation.cf is not None:
    print("
Counterfactual found!")
    print(f"Original instance prediction: {model.predict(instance)[0][0]:.4f}")
    print(f"Counterfactual prediction: {model.predict(explanation.cf['X'])[0][0]:.4f}")
    
    # Calculate and display the changes
    changes = explanation.cf['X'] - instance
    changes_df = pd.DataFrame({
        'Feature': data.feature_names,
        'Original': instance.flatten(),
        'Counterfactual': explanation.cf['X'].flatten(),
        'Change': changes.flatten()
    })
    
    # Only show features that changed
    changed_features = changes_df[changes_df['Change'] != 0].sort_values('Change', key=abs, ascending=False)
    print("
Feature changes needed:")
    print(changed_features[['Feature', 'Original', 'Counterfactual', 'Change']].to_string(index=False))
    
    # Visualize the most important changes
    plt.figure(figsize=(10, 6))
    top_changes = changed_features.nlargest(5, 'Change', key=abs)
    plt.barh(
        top_changes['Feature'], 
        top_changes['Change'],
        color=['green' if x > 0 else 'red' for x in top_changes['Change']]
    )
    plt.title('Top Feature Changes for Counterfactual')
    plt.xlabel('Change in Feature Value')
    plt.tight_layout()
    plt.savefig('counterfactual_changes.png', dpi=300, bbox_inches='tight')
    plt.close()
else:
    print("No counterfactual found within the given constraints.")

Explainability for Different Data Types

Different data types require different explainability approaches. Let's explore techniques for various data modalities.

1. Tabular Data

For tabular data, we've already covered SHAP, LIME, and counterfactual explanations. Additional techniques include:

• Partial Dependence Plots (PDP): Show the relationship between a feature and the predicted outcome after accounting for the average effect of all other features.
• Individual Conditional Expectation (ICE): Similar to PDP but shows the relationship for individual instances.
• Anchors: High-precision rules that "anchor" the prediction, providing conditions that are sufficient to guarantee the same prediction.

2. Text Data

For text classification and generation models, explainability focuses on identifying which words or phrases influence the model's predictions.

Example: Text Classification with LIME

# Install required packages
# pip install lime nltk scikit-learn

import numpy as np
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import fetch_20newsgroups
from lime import lime_text
from lime.lime_text import LimeTextExplainer

# Load a text dataset
categories = ['alt.atheism', 'soc.religion.christian']
newsgroups_train = fetch_20newsgroups(subset='train', categories=categories)
newsgroups_test = fetch_20newsgroups(subset='test', categories=categories)

# Create a simple text classification pipeline
pipeline = Pipeline([
    ('tfidf', TfidfVectorizer(stop_words='english')),
    ('clf', LogisticRegression(random_state=42))
])

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

# Define class names for better interpretation
class_names = ['atheism', 'christian']

# Initialize LIME explainer
explainer = LimeTextExplainer(class_names=class_names)

# Select a random instance to explain
idx = 10
text_instance = newsgroups_test.data[idx]
true_label = newsgroups_test.target[idx]
pred_label = pipeline.predict([text_instance])[0]
pred_proba = pipeline.predict_proba([text_instance])[0]

print(f"True label: {class_names[true_label]}")
print(f"Predicted label: {class_names[pred_label]} (confidence: {pred_proba.max():.2f})")

# Generate explanation
explanation = explainer.explain_instance(
    text_instance, 
    pipeline.predict_proba, 
    num_features=10,
    top_labels=1
)

# Save explanation to HTML
html = explanation.as_html()
with open('lime_text_explanation.html', 'w') as f:
    f.write(html)

# Show the explanation in notebook (if running in notebook)
# explanation.show_in_notebook(text=True)

3. Image Data

For image classification and object detection models, explainability focuses on identifying which regions of the image influenced the model's predictions.

Example: Image Classification with Grad-CAM

# Install required packages
# pip install tensorflow matplotlib opencv-python numpy

import numpy as np
import tensorflow as tf
from tensorflow.keras.applications import VGG16
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions
import matplotlib.pyplot as plt
import cv2

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

# Load and preprocess an image
img_path = 'example_image.jpg'  # Replace with your image path
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)

# Make prediction
preds = model.predict(x)
print('Predicted:', decode_predictions(preds, top=3)[0])

# Get the predicted class index
pred_class = np.argmax(preds[0])

# Grad-CAM implementation
def grad_cam(model, img_array, layer_name, pred_index=None):
    # Create a model that maps the input image to the activations
    # of the last conv layer and the output predictions
    grad_model = tf.keras.models.Model(
        [model.inputs],
        [model.get_layer(layer_name).output, model.output]
    )
    
    # Compute the gradient of the top predicted class for the input image
    # with respect to the activations of the last conv layer
    with tf.GradientTape() as tape:
        conv_outputs, predictions = grad_model(img_array)
        if pred_index is None:
            pred_index = tf.argmax(predictions[0])
        loss = predictions[:, pred_index]
    
    # Get the gradients of the loss with respect to the output feature map
    grads = tape.gradient(loss, conv_outputs)
    
    # Pool the gradients over all the axes leaving out the channel dimension
    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
    
    # Multiply each channel in the feature map array by its importance
    conv_outputs = conv_outputs[0]
    for i in range(pooled_grads.shape[0]):
        conv_outputs[:, :, i] *= pooled_grads[i]
    
    # Average over all the channels to get the heatmap
    heatmap = tf.reduce_mean(conv_outputs, axis=-1)
    
    # ReLU on the heatmap (equivalent to passing the feature maps through a ReLU)
    heatmap = np.maximum(heatmap, 0)
    
    # Normalize the heatmap
    heatmap /= np.max(heatmap)
    
    return heatmap

# Generate class activation heatmap
layer_name = 'block5_conv3'  # Last conv layer in VGG16
heatmap = grad_cam(model, x, layer_name)

# Rescale heatmap to a range 0-255
heatmap = np.uint8(255 * heatmap)

# Use jet colormap to colorize heatmap
heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)

# Superimpose the heatmap on the original image
img = cv2.imread(img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (224, 224))

# Resize heatmap to match the original image size
heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0]))

# Combine the heatmap with the original image
superimposed_img = heatmap * 0.4 + img
superimposed_img = np.uint8(superimposed_img)
superimposed_img = cv2.cvtColor(superimposed_img, cv2.COLOR_BGR2RGB)

# Display the original image and the heatmap
plt.figure(figsize=(20, 10))

plt.subplot(1, 2, 1)
plt.imshow(img)
plt.title('Original Image')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(superimposed_img)
plt.title('Grad-CAM Heatmap')
plt.axis('off')

plt.tight_layout()
plt.savefig('grad_cam_visualization.png', dpi=300, bbox_inches='tight')
plt.close()

Explainability in Production

Deploying explainability in production requires careful consideration of performance, scalability, and integration with existing systems.

1. Performance Considerations

Optimizing SHAP for Production

# Install required packages
# pip install shap numba joblib

import numpy as np
import pandas as pd
import shap
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
import time
import joblib
from pathlib import Path

# Load and prepare data
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target

# Train a model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X, y)

# 1. Use TreeExplainer for tree-based models (much faster than KernelExplainer)
# This is optimized for tree-based models like Random Forest and XGBoost
explainer = shap.TreeExplainer(model)

# 2. Pre-compute expected values for faster predictions
# This avoids recomputing the expected value for each explanation
expected_value = explainer.expected_value

# 3. Use a subset of the data for background distribution
# Instead of using all training data, use a representative sample
background = shap.sample(X, 100)  # Use 100 samples instead of the full dataset

def explain_instance(instance, explainer, expected_value):
    """Explain a single instance using the pre-computed explainer."""
    # Convert to numpy array if needed
    if hasattr(instance, 'values'):
        instance = instance.values.reshape(1, -1)
    
    # Get SHAP values
    shap_values = explainer.shap_values(instance, check_additivity=False)
    
    # For binary classification, use the SHAP values for the positive class
    if isinstance(shap_values, list):
        shap_values = shap_values[1]  # Positive class
    
    return {
        'shap_values': shap_values,
        'expected_value': expected_value,
        'prediction': model.predict_proba(instance)[0][1]  # Probability of positive class
    }

# 4. Cache explanations for similar inputs
# This is a simple in-memory cache, but you could use Redis or similar in production
explanation_cache = {}

def get_explanation_cached(instance, cache_key=None):
    """Get explanation from cache or compute it if not found."""
    if cache_key is None:
        # Create a simple hash of the instance for caching
        cache_key = hash(tuple(instance.flatten().astype(float)))
    
    if cache_key in explanation_cache:
        return explanation_cache[cache_key]
    
    # Compute explanation if not in cache
    explanation = explain_instance(instance, explainer, expected_value)
    explanation_cache[cache_key] = explanation
    return explanation

# 5. Parallelize explanations for multiple instances
def explain_batch(instances, n_jobs=-1):
    """Explain multiple instances in parallel."""
    return joblib.Parallel(n_jobs=n_jobs)(
        joblib.delayed(explain_instance)(instance.reshape(1, -1), explainer, expected_value)
        for instance in instances
    )

# Example usage
instance = X.iloc[0:1]  # Get first instance

# Time the first explanation (will be slower due to compilation)
start_time = time.time()
explanation = get_explanation_cached(instance.values)
first_time = time.time() - start_time
print(f"First explanation took {first_time:.4f} seconds")

# Time subsequent explanations (should be faster, especially with caching)
start_time = time.time()
for _ in range(10):
    explanation = get_explanation_cached(instance.values)
subsequent_time = (time.time() - start_time) / 10
print(f"Subsequent explanations took {subsequent_time:.4f} seconds on average")

# 6. Save and load the explainer for production use
explainer_save_path = 'shap_explainer.joblib'
joblib.dump(explainer, explainer_save_path)

# In production, you would load it like this:
# explainer = joblib.load(explainer_save_path)

# 7. Batch processing for better performance
batch_size = 32
batch_explanations = explain_batch(X.iloc[:batch_size].values)
print(f"Generated {len(batch_explanations)} explanations in a batch")

2. API Design for Explainability

When exposing explainability features through an API, consider the following design patterns:

• Synchronous vs. Asynchronous: For complex explanations, consider an asynchronous API that returns a job ID and allows clients to poll for results.
• Granularity: Allow clients to specify the level of detail they need (e.g., just feature importance scores vs. full explanations).
• Caching: Implement caching to avoid recomputing explanations for the same or similar inputs.
• Rate Limiting: Protect your API from abuse with appropriate rate limiting.

Example: FastAPI Service for Model Explainability

# Install required packages
# pip install fastapi uvicorn python-multipart joblib scikit-learn pandas numpy

from fastapi import FastAPI, HTTPException, Depends, status
from fastapi.security import APIKeyHeader
from pydantic import BaseModel
from typing import List, Dict, Any, Optional
import joblib
import numpy as np
import pandas as pd
import hashlib
import time
from datetime import datetime
import os
from pathlib import Path

# Initialize FastAPI app
app = FastAPI(
    title="ML Model Explainability API",
    description="API for explaining machine learning model predictions",
    version="1.0.0"
)

# Security
API_KEY = os.getenv("API_KEY", "your-secret-key")
api_key_header = APIKeyHeader(name="X-API-Key")

def get_api_key(api_key: str = Depends(api_key_header)):
    if api_key != API_KEY:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid API Key"
        )
    return api_key

# Models
class ExplanationRequest(BaseModel):
    features: Dict[str, Any]
    explanation_type: str = "shap"  # or "lime", "counterfactual"
    num_features: Optional[int] = 5
    return_visualization: bool = True

class ExplanationResponse(BaseModel):
    explanation_id: str
    status: str
    explanation: Optional[Dict[str, Any]] = None
    visualization_url: Optional[str] = None
    timestamp: str

# Global variables for caching
EXPLANATION_CACHE = {}
MODEL = None
EXPLAINER = None

# Load model and explainer on startup
@app.on_event("startup")
async def load_model():
    global MODEL, EXPLAINER
    try:
        # In a real application, you would load your trained model here
        # For this example, we'll use a dummy model
        from sklearn.ensemble import RandomForestClassifier
        from sklearn.datasets import load_breast_cancer
        import shap
        
        # Load example data and train a simple model
        data = load_breast_cancer()
        X, y = data.data, data.target
        
        MODEL = RandomForestClassifier(n_estimators=100, random_state=42)
        MODEL.fit(X, y)
        
        # Initialize explainer
        EXPLAINER = shap.TreeExplainer(MODEL)
        
        print("Model and explainer loaded successfully")
    except Exception as e:
        print(f"Error loading model: {str(e)}")
        raise e

def generate_explanation_id(features: dict, explanation_type: str) -> str:
    """Generate a unique ID for the explanation request."""
    feature_str = "".join(f"{k}:{v}" for k, v in sorted(features.items()))
    return hashlib.md5(f"{feature_str}:{explanation_type}".encode()).hexdigest()

@app.post("/explain", response_model=ExplanationResponse)
async def explain(
    request: ExplanationRequest,
    api_key: str = Depends(get_api_key)
):
    """Generate an explanation for a model prediction."""
    try:
        # Generate a unique ID for this explanation
        explanation_id = generate_explanation_id(request.features, request.explanation_type)
        
        # Check if explanation is already in cache
        if explanation_id in EXPLANATION_CACHE:
            return EXPLANATION_CACHE[explanation_id]
        
        # Convert features to the format expected by the model
        # In a real application, you would need to handle feature encoding properly
        feature_names = ["mean radius", "mean texture", "mean perimeter", "mean area", 
                        "mean smoothness", "mean compactness", "mean concavity", 
                        "mean concave points", "mean symmetry", "mean fractal dimension",
                        "radius error", "texture error", "perimeter error", "area error", 
                        "smoothness error", "compactness error", "concavity error",
                        "concave points error", "symmetry error", "fractal dimension error", 
                        "worst radius", "worst texture", "worst perimeter", "worst area", 
                        "worst smoothness", "worst compactness", "worst concavity",
                        "worst concave points", "worst symmetry", "worst fractal dimension"]
        
        # Create a feature vector with the same order as the model expects
        feature_vector = np.array([request.features.get(feature, 0) for feature in feature_names]).reshape(1, -1)
        
        # Get model prediction
        prediction = MODEL.predict_proba(feature_vector)[0]
        predicted_class = int(prediction[1] > 0.5)
        
        # Generate explanation based on the requested type
        explanation = {}
        visualization_path = None
        
        if request.explanation_type == "shap":
            # Generate SHAP values
            shap_values = EXPLAINER.shap_values(feature_vector, check_additivity=False)
            
            # For binary classification, use the SHAP values for the positive class
            if isinstance(shap_values, list):
                shap_values = shap_values[1]  # Positive class
            
            # Get top features
            top_indices = np.argsort(-np.abs(shap_values[0]))[:request.num_features]
            
            explanation = {
                "type": "shap",
                "predicted_class": predicted_class,
                "prediction_confidence": float(prediction[predicted_class]),
                "feature_importance": [
                    {
                        "feature": feature_names[i],
                        "value": float(feature_vector[0, i]),
                        "shap_value": float(shap_values[0, i]),
                        "impact": float(shap_values[0, i] * 100)  # As percentage
                    }
                    for i in top_indices
                ],
                "base_value": float(EXPLAINER.expected_value[1] if isinstance(EXPLAINER.expected_value, list) else EXPLAINER.expected_value)
            }
            
            # In a real application, you would generate and save a visualization
            # For this example, we'll just return a placeholder
            if request.return_visualization:
                visualization_path = f"/visualizations/{explanation_id}.png"
                # Save a dummy visualization in a real app, this would be a SHAP plot
                # import matplotlib.pyplot as plt
                # shap.plots.waterfall(shap_values[0], show=False)
                # plt.savefig(f"static{visualization_path}")
                # plt.close()
        
        elif request.explanation_type == "lime":
            # LIME explanation would go here
            explanation = {
                "type": "lime",
                "predicted_class": predicted_class,
                "explanation": "LIME explanation would be generated here in a real implementation"
            }
            
            if request.return_visualization:
                visualization_path = f"/visualizations/{explanation_id}.png"
        
        elif request.explanation_type == "counterfactual":
            # Counterfactual explanation would go here
            explanation = {
                "type": "counterfactual",
                "predicted_class": predicted_class,
                "explanation": "Counterfactual explanation would be generated here in a real implementation"
            }
            
            if request.return_visualization:
                visualization_path = f"/visualizations/{explanation_id}.png"
        
        else:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail=f"Unsupported explanation type: {request.explanation_type}"
            )
        
        # Prepare response
        response = ExplanationResponse(
            explanation_id=explanation_id,
            status="success",
            explanation=explanation,
            visualization_url=f"https://api.yourservice.com{visualization_path}" if visualization_path else None,
            timestamp=datetime.utcnow().isoformat()
        )
        
        # Cache the explanation
        EXPLANATION_CACHE[explanation_id] = response
        
        return response
    
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error generating explanation: {str(e)}"
        )

@app.get("/explanations/{explanation_id}", response_model=ExplanationResponse)
async def get_explanation(
    explanation_id: str,
    api_key: str = Depends(get_api_key)
):
    """Retrieve a previously generated explanation by ID."""
    if explanation_id not in EXPLANATION_CACHE:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="Explanation not found"
        )
    
    return EXPLANATION_CACHE[explanation_id]

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Best Practices for Implementing Explainability

Future Trends in Explainable AI