Unlocking Transparency in AI: A Comprehensive Guide to Explainable AI (XAI)

# Install required libraries
pip install shap==0.44.1 lime==0.2.0.1 captum==0.7.0
pip install scikit-learn==1.3.2 torch==2.1.2 torchvision==0.16.2
pip install xgboost==2.0.3 matplotlib==3.8.2 pillow==10.1.0

import shap
import xgboost as xgb
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

class LoanApprovalExplainer:
    """Explainable loan approval model using SHAP."""

    def __init__(self):
        self.model = None
        self.explainer = None
        self.feature_names = [
            'credit_score',
            'annual_income',
            'debt_to_income_ratio',
            'employment_years',
            'loan_amount',
            'num_credit_lines',
            'late_payments_3yr',
            'inquiries_6mo'
        ]

    def create_synthetic_data(self, n_samples=1000):
        """Create synthetic loan data for demonstration."""
        np.random.seed(42)

        # Generate features with realistic distributions
        data = pd.DataFrame({
            'credit_score': np.random.normal(700, 80, n_samples).clip(300, 850),
            'annual_income': np.random.lognormal(11, 0.5, n_samples),  # ~$60k median
            'debt_to_income_ratio': np.random.beta(2, 5, n_samples) * 0.6,  # 0-60%
            'employment_years': np.random.exponential(5, n_samples).clip(0, 40),
            'loan_amount': np.random.lognormal(10.5, 0.7, n_samples),  # ~$40k median
            'num_credit_lines': np.random.poisson(8, n_samples).clip(0, 30),
            'late_payments_3yr': np.random.poisson(0.5, n_samples).clip(0, 20),
            'inquiries_6mo': np.random.poisson(1, n_samples).clip(0, 10)
        })

        # Create approval target based on realistic criteria
        approval_score = (
            (data['credit_score'] - 300) / 550 * 40 +  # 40 points max
            np.log(data['annual_income']) / np.log(200000) * 25 +  # 25 points max
            (1 - data['debt_to_income_ratio']) * 20 +  # 20 points max
            np.minimum(data['employment_years'] / 10, 1) * 10 +  # 10 points max
            (1 - data['late_payments_3yr'] / 20) * 5  # 5 points max
        )

        # Add noise and threshold
        approval_score += np.random.normal(0, 5, n_samples)
        data['approved'] = (approval_score > 60).astype(int)

        return data

    def train_model(self, X_train, y_train):
        """Train XGBoost model for loan approval."""
        self.model = xgb.XGBClassifier(
            n_estimators=100,
            max_depth=5,
            learning_rate=0.1,
            random_state=42,
            eval_metric='logloss'
        )

        self.model.fit(X_train, y_train)

        # Create SHAP explainer (TreeExplainer for XGBoost is fast)
        self.explainer = shap.TreeExplainer(self.model)

        print(f"✓ Model trained. Accuracy: {self.model.score(X_train, y_train):.3f}")

    def explain_prediction(self, X_sample):
        """
        Explain a single prediction using SHAP.

        Returns SHAP values showing each feature's contribution.
        """
        # Calculate SHAP values for this instance
        shap_values = self.explainer.shap_values(X_sample)

        # Get prediction probability
        prediction_proba = self.model.predict_proba(X_sample)[0, 1]

        # SHAP base value (expected value with no features)
        base_value = self.explainer.expected_value

        print(f"\n{'='*60}")
        print(f"Loan Approval Prediction: {prediction_proba:.1%}")
        print(f"Base approval rate: {base_value:.1%}")
        print(f"{'='*60}\n")

        # Create explanation DataFrame
        explanation = pd.DataFrame({
            'feature': self.feature_names,
            'value': X_sample.iloc[0].values,
            'shap_value': shap_values[0]
        })

        # Sort by absolute SHAP value
        explanation['abs_shap'] = explanation['shap_value'].abs()
        explanation = explanation.sort_values('abs_shap', ascending=False)

        print("Feature Contributions (most impactful first):\n")
        for idx, row in explanation.iterrows():
            impact = "INCREASES" if row['shap_value'] > 0 else "DECREASES"
            print(f"{row['feature']:25} = {row['value']:8.2f}  "
                  f"{impact:9} approval by {abs(row['shap_value']):.3f}")

        return shap_values, base_value

    def visualize_explanation(self, X_sample):
        """Create waterfall plot showing feature contributions."""
        shap_values = self.explainer.shap_values(X_sample)

        # Waterfall plot for single prediction
        shap.waterfall_plot(
            shap.Explanation(
                values=shap_values[0],
                base_values=self.explainer.expected_value,
                data=X_sample.iloc[0].values,
                feature_names=self.feature_names
            )
        )

    def global_importance(self, X_test):
        """Calculate global feature importance across all predictions."""
        shap_values = self.explainer.shap_values(X_test)

        # Summary plot (beeswarm plot)
        plt.figure(figsize=(10, 6))
        shap.summary_plot(shap_values, X_test, feature_names=self.feature_names)

        # Bar plot of mean absolute SHAP values
        plt.figure(figsize=(10, 6))
        shap.summary_plot(shap_values, X_test, feature_names=self.feature_names, plot_type='bar')


# Example usage: Explain loan approval decision
if __name__ == "__main__":
    explainer = LoanApprovalExplainer()

    # Create and split data
    data = explainer.create_synthetic_data(n_samples=1000)
    X = data[explainer.feature_names]
    y = data['approved']

    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )

    # Train model
    explainer.train_model(X_train, y_train)

    # Explain specific application
    applicant = X_test.iloc[[0]]  # First test sample

    print("\nApplicant Details:")
    print(applicant.T)

    shap_values, base_value = explainer.explain_prediction(applicant)

    # Visualize explanation
    explainer.visualize_explanation(applicant)

    # Show global feature importance
    explainer.global_importance(X_test)

import torch
import torch.nn as nn
import shap
import numpy as np

class DeepLoanModel(nn.Module):
    """Neural network for loan approval."""

    def __init__(self, input_dim=8):
        super(DeepLoanModel, self).__init__()
        self.network = nn.Sequential(
            nn.Linear(input_dim, 64),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(32, 16),
            nn.ReLU(),
            nn.Linear(16, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.network(x)


def explain_deep_model(model, X_train, X_test):
    """
    Explain PyTorch model using SHAP DeepExplainer.

    DeepExplainer uses DeepLIFT algorithm adapted for deep networks.
    """
    # Convert to PyTorch tensors
    X_train_tensor = torch.FloatTensor(X_train.values)
    X_test_tensor = torch.FloatTensor(X_test.values)

    # Create SHAP explainer (use subset of training data as background)
    background = X_train_tensor[:100]  # Background distribution
    explainer = shap.DeepExplainer(model, background)

    # Calculate SHAP values for test set
    shap_values = explainer.shap_values(X_test_tensor[:10])  # Explain first 10 samples

    # Visualize
    shap.summary_plot(
        shap_values,
        X_test.iloc[:10],
        feature_names=X_test.columns.tolist()
    )

    return shap_values


# Example: Train and explain deep model
model = DeepLoanModel(input_dim=8)
# ... (training code omitted for brevity)
shap_values = explain_deep_model(model, X_train, X_test)

from lime import lime_tabular
import numpy as np
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt

class LIMELoanExplainer:
    """Explain loan decisions using LIME."""

    def __init__(self, model, X_train, feature_names):
        self.model = model
        self.feature_names = feature_names

        # Create LIME explainer
        self.explainer = lime_tabular.LimeTabularExplainer(
            training_data=X_train.values,
            feature_names=feature_names,
            class_names=['Denied', 'Approved'],
            mode='classification',
            random_state=42
        )

    def explain_instance(self, instance, num_features=8):
        """
        Explain a single prediction using LIME.

        Returns: LimeExplanation object with feature contributions.
        """
        # Generate explanation
        explanation = self.explainer.explain_instance(
            data_row=instance.values[0],
            predict_fn=self.model.predict_proba,
            num_features=num_features
        )

        # Print explanation
        print("\n" + "="*60)
        print("LIME Explanation (Approximate Local Model)")
        print("="*60 + "\n")

        for feature, weight in explanation.as_list():
            impact = "INCREASES" if weight > 0 else "DECREASES"
            print(f"{feature:40} {impact:9} approval (weight: {weight:+.3f})")

        # Visualize
        fig = explanation.as_pyplot_figure()
        plt.tight_layout()

        return explanation

    def compare_predictions(self, instance):
        """Compare actual model prediction with LIME's local approximation."""
        explanation = self.explainer.explain_instance(
            data_row=instance.values[0],
            predict_fn=self.model.predict_proba,
            num_features=len(self.feature_names)
        )

        # Actual prediction
        actual_proba = self.model.predict_proba(instance)[0, 1]

        # LIME's local prediction (based on interpretable model)
        local_pred = explanation.local_pred[1]  # Probability for class 1

        print(f"\nActual model prediction: {actual_proba:.3f}")
        print(f"LIME local model prediction: {local_pred:.3f}")
        print(f"Difference: {abs(actual_proba - local_pred):.3f}")

        return explanation


# Example usage
if __name__ == "__main__":
    # Train RandomForest on loan data
    rf = RandomForestClassifier(n_estimators=100, random_state=42)
    rf.fit(X_train, y_train)

    # Create LIME explainer
    lime_explainer = LIMELoanExplainer(
        model=rf,
        X_train=X_train,
        feature_names=explainer.feature_names
    )

    # Explain specific instance
    test_instance = X_test.iloc[[5]]
    explanation = lime_explainer.explain_instance(test_instance)

    # Compare predictions
    lime_explainer.compare_predictions(test_instance)

from lime import lime_image
from skimage.segmentation import mark_boundaries
import torch
import torchvision.models as models
import torchvision.transforms as transforms
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt

class ImageExplainer:
    """Explain image classification using LIME."""

    def __init__(self, model, device='cpu'):
        self.model = model
        self.model.eval()
        self.device = device

        # ImageNet normalization
        self.transform = transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406],
                               std=[0.229, 0.224, 0.225])
        ])

        # Create LIME explainer for images
        self.explainer = lime_image.LimeImageExplainer()

    def predict_fn(self, images):
        """
        Prediction function for LIME.

        Args:
            images: Batch of images (numpy arrays)

        Returns: Probabilities for all classes
        """
        self.model.eval()
        batch = []

        for img in images:
            # Convert numpy array to PIL
            pil_img = Image.fromarray(img.astype('uint8'))
            # Apply transforms
            tensor = self.transform(pil_img)
            batch.append(tensor)

        batch_tensor = torch.stack(batch).to(self.device)

        with torch.no_grad():
            outputs = self.model(batch_tensor)
            probas = torch.nn.functional.softmax(outputs, dim=1)

        return probas.cpu().numpy()

    def explain_prediction(self, image_path, top_labels=3, num_samples=1000):
        """
        Explain which image regions contribute to the predicted class.

        Args:
            image_path: Path to input image
            top_labels: Number of top predicted classes to explain
            num_samples: Number of perturbed samples for LIME

        Returns: Explanation with highlighted regions
        """
        # Load and preprocess image
        image = Image.open(image_path).convert('RGB')
        image = image.resize((224, 224))
        image_np = np.array(image)

        # Get top predictions
        predictions = self.predict_fn([image_np])[0]
        top_indices = np.argsort(predictions)[-top_labels:][::-1]

        print("\nTop Predictions:")
        for idx in top_indices:
            print(f"  Class {idx}: {predictions[idx]:.3f}")

        # Generate explanation
        explanation = self.explainer.explain_instance(
            image_np,
            self.predict_fn,
            top_labels=top_labels,
            hide_color=0,
            num_samples=num_samples,
            random_seed=42
        )

        # Visualize explanations for top class
        temp, mask = explanation.get_image_and_mask(
            label=top_indices[0],
            positive_only=True,
            num_features=10,
            hide_rest=False
        )

        # Plot original and explanation
        fig, axes = plt.subplots(1, 3, figsize=(15, 5))

        axes[0].imshow(image_np)
        axes[0].set_title('Original Image')
        axes[0].axis('off')

        axes[1].imshow(mark_boundaries(temp, mask))
        axes[1].set_title(f'Positive Regions (Class {top_indices[0]})')
        axes[1].axis('off')

        # Show negative regions
        temp_neg, mask_neg = explanation.get_image_and_mask(
            label=top_indices[0],
            positive_only=False,
            num_features=10,
            hide_rest=False
        )

        axes[2].imshow(mark_boundaries(temp_neg, mask_neg))
        axes[2].set_title('Positive (green) & Negative (red) Regions')
        axes[2].axis('off')

        plt.tight_layout()
        plt.show()

        return explanation


# Example usage: Explain ResNet prediction
if __name__ == "__main__":
    # Load pre-trained ResNet
    model = models.resnet50(pretrained=True)
    model.eval()

    # Create explainer
    explainer = ImageExplainer(model)

    # Explain prediction for a specific image
    explanation = explainer.explain_prediction(
        image_path='cat.jpg',
        top_labels=3,
        num_samples=1000
    )

import torch
import torch.nn as nn
from captum.attr import IntegratedGradients, Saliency, GuidedBackprop, LayerGradCam
import torchvision.models as models
import torchvision.transforms as transforms
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt

class CaptumImageExplainer:
    """Explain CNN predictions using Captum attribution methods."""

    def __init__(self, model, device='cpu'):
        self.model = model
        self.model.eval()
        self.device = device

        self.transform = transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406],
                               std=[0.229, 0.224, 0.225])
        ])

        # Denormalize for visualization
        self.inv_normalize = transforms.Normalize(
            mean=[-0.485/0.229, -0.456/0.224, -0.406/0.225],
            std=[1/0.229, 1/0.224, 1/0.225]
        )

    def load_image(self, image_path):
        """Load and preprocess image."""
        image = Image.open(image_path).convert('RGB')
        input_tensor = self.transform(image).unsqueeze(0).to(self.device)
        input_tensor.requires_grad = True
        return input_tensor, image

    def integrated_gradients_attribution(self, input_tensor, target_class):
        """
        Compute Integrated Gradients attributions.

        Args:
            input_tensor: Preprocessed input image
            target_class: Target class index

        Returns: Attribution map
        """
        ig = IntegratedGradients(self.model)

        # Create baseline (all zeros = black image after normalization)
        baseline = torch.zeros_like(input_tensor)

        # Compute attributions
        attributions = ig.attribute(
            input_tensor,
            baselines=baseline,
            target=target_class,
            n_steps=50  # Number of interpolation steps
        )

        return attributions

    def saliency_map(self, input_tensor, target_class):
        """Compute vanilla gradient saliency map."""
        saliency = Saliency(self.model)

        attributions = saliency.attribute(
            input_tensor,
            target=target_class
        )

        return attributions

    def guided_backprop(self, input_tensor, target_class):
        """Compute Guided Backpropagation attributions."""
        gbp = GuidedBackprop(self.model)

        attributions = gbp.attribute(
            input_tensor,
            target=target_class
        )

        return attributions

    def grad_cam(self, input_tensor, target_class, layer_name='layer4'):
        """
        Compute Grad-CAM for convolutional layer.

        Grad-CAM shows which spatial regions activated for the prediction.
        """
        # Get the target layer (e.g., last conv layer of ResNet)
        if layer_name == 'layer4':
            target_layer = self.model.layer4[-1]
        else:
            target_layer = self.model.layer4  # Default

        layer_gc = LayerGradCam(self.model, target_layer)

        attributions = layer_gc.attribute(
            input_tensor,
            target=target_class
        )

        # Upsample to input size
        attributions = LayerGradCam.interpolate(
            attributions,
            (224, 224)
        )

        return attributions

    def visualize_all_attributions(self, image_path, target_class=None):
        """
        Visualize multiple attribution methods side-by-side.

        Args:
            image_path: Path to input image
            target_class: Target class (if None, uses top prediction)
        """
        # Load image
        input_tensor, original_image = self.load_image(image_path)

        # Get prediction
        with torch.no_grad():
            output = self.model(input_tensor)
            probabilities = torch.nn.functional.softmax(output, dim=1)[0]

        if target_class is None:
            target_class = output.argmax(dim=1).item()

        print(f"\nPredicted Class: {target_class}")
        print(f"Confidence: {probabilities[target_class]:.3f}")

        # Compute attributions using different methods
        ig_attr = self.integrated_gradients_attribution(input_tensor, target_class)
        saliency_attr = self.saliency_map(input_tensor, target_class)
        gbp_attr = self.guided_backprop(input_tensor, target_class)
        gradcam_attr = self.grad_cam(input_tensor, target_class)

        # Convert to numpy for visualization
        def to_numpy(tensor):
            return tensor.squeeze().cpu().detach().numpy()

        # Denormalize original image
        orig_img_denorm = self.inv_normalize(input_tensor.squeeze().cpu())
        orig_img_np = np.transpose(orig_img_denorm.detach().numpy(), (1, 2, 0))
        orig_img_np = np.clip(orig_img_np, 0, 1)

        # Aggregate attributions across color channels
        ig_attr_agg = to_numpy(ig_attr).transpose(1, 2, 0).mean(axis=2)
        saliency_attr_agg = to_numpy(saliency_attr).transpose(1, 2, 0).mean(axis=2)
        gbp_attr_agg = to_numpy(gbp_attr).transpose(1, 2, 0).mean(axis=2)
        gradcam_attr_agg = to_numpy(gradcam_attr)

        # Plot
        fig, axes = plt.subplots(2, 3, figsize=(15, 10))

        axes[0, 0].imshow(orig_img_np)
        axes[0, 0].set_title('Original Image')
        axes[0, 0].axis('off')

        axes[0, 1].imshow(ig_attr_agg, cmap='RdBu_r')
        axes[0, 1].set_title('Integrated Gradients')
        axes[0, 1].axis('off')

        axes[0, 2].imshow(np.abs(saliency_attr_agg), cmap='hot')
        axes[0, 2].set_title('Saliency Map')
        axes[0, 2].axis('off')

        axes[1, 0].imshow(np.abs(gbp_attr_agg), cmap='hot')
        axes[1, 0].set_title('Guided Backpropagation')
        axes[1, 0].axis('off')

        axes[1, 1].imshow(orig_img_np)
        axes[1, 1].imshow(gradcam_attr_agg, cmap='jet', alpha=0.5)
        axes[1, 1].set_title('Grad-CAM Overlay')
        axes[1, 1].axis('off')

        # Combine Guided Backprop with Grad-CAM
        guided_gradcam = gbp_attr_agg * gradcam_attr_agg
        axes[1, 2].imshow(np.abs(guided_gradcam), cmap='hot')
        axes[1, 2].set_title('Guided Grad-CAM')
        axes[1, 2].axis('off')

        plt.tight_layout()
        plt.show()


# Example usage
if __name__ == "__main__":
    # Load pre-trained ResNet50
    model = models.resnet50(pretrained=True)
    model.eval()

    # Create explainer
    explainer = CaptumImageExplainer(model)

    # Visualize all attribution methods
    explainer.visualize_all_attributions(
        image_path='dog.jpg',
        target_class=None  # Explain top prediction
    )

def check_explanation_faithfulness(model, X, explainer_func, feature_idx, num_samples=100):
    """
    Test if removing top features identified by explainer degrades predictions.

    High-importance features should cause larger prediction changes when removed.
    """
    results = []

    for i in range(num_samples):
        instance = X.iloc[[i]]

        # Get original prediction
        orig_pred = model.predict_proba(instance)[0, 1]

        # Get SHAP/LIME explanation
        shap_values = explainer_func(instance)

        # Find top feature
        top_feature_idx = np.abs(shap_values).argmax()

        # Remove top feature (set to median/mean)
        perturbed = instance.copy()
        perturbed.iloc[0, top_feature_idx] = X.iloc[:, top_feature_idx].median()

        # Get perturbed prediction
        perturbed_pred = model.predict_proba(perturbed)[0, 1]

        # Measure change
        change = abs(orig_pred - perturbed_pred)

        results.append({
            'sample_idx': i,
            'top_feature': X.columns[top_feature_idx],
            'shap_value': shap_values[top_feature_idx],
            'prediction_change': change
        })

    results_df = pd.DataFrame(results)

    print(f"\nFaithfulness Check:")
    print(f"Mean prediction change when removing top feature: {results_df['prediction_change'].mean():.3f}")
    print(f"Correlation between |SHAP| and prediction change: {results_df[['shap_value', 'prediction_change']].corr().iloc[0, 1]:.3f}")

    return results_df

import hashlib
import pickle
from pathlib import Path

class ExplanationCache:
    """Cache SHAP/LIME explanations to avoid recomputation."""

    def __init__(self, cache_dir='./explanation_cache'):
        self.cache_dir = Path(cache_dir)
        self.cache_dir.mkdir(exist_ok=True)

    def get_cache_key(self, instance):
        """Generate unique key for instance."""
        instance_str = str(instance.values)
        return hashlib.md5(instance_str.encode()).hexdigest()

    def get(self, instance):
        """Retrieve cached explanation."""
        key = self.get_cache_key(instance)
        cache_file = self.cache_dir / f"{key}.pkl"

        if cache_file.exists():
            with open(cache_file, 'rb') as f:
                return pickle.load(f)

        return None

    def set(self, instance, explanation):
        """Store explanation in cache."""
        key = self.get_cache_key(instance)
        cache_file = self.cache_dir / f"{key}.pkl"

        with open(cache_file, 'wb') as f:
            pickle.dump(explanation, f)


# Usage
cache = ExplanationCache()

def explain_with_cache(model, explainer, instance):
    """Check cache before computing explanation."""
    cached = cache.get(instance)

    if cached is not None:
        print("✓ Using cached explanation")
        return cached

    print("Computing new explanation...")
    explanation = explainer.explain_instance(instance)
    cache.set(instance, explanation)

    return explanation

def monitor_explanation_drift(explainer, X_baseline, X_current, threshold=0.3):
    """
    Detect if feature importances have drifted over time.

    Large shifts may indicate model decay or data distribution changes.
    """
    # Compute global feature importance on baseline data
    shap_baseline = explainer.shap_values(X_baseline)
    importance_baseline = np.abs(shap_baseline).mean(axis=0)

    # Compute on current data
    shap_current = explainer.shap_values(X_current)
    importance_current = np.abs(shap_current).mean(axis=0)

    # Normalize
    importance_baseline /= importance_baseline.sum()
    importance_current /= importance_current.sum()

    # Compute drift (Jensen-Shannon divergence)
    from scipy.spatial.distance import jensenshannon
    drift_score = jensenshannon(importance_baseline, importance_current)

    if drift_score > threshold:
        print(f"⚠ Explanation drift detected: {drift_score:.3f} (threshold: {threshold})")
        print("Feature importance changes:")

        for i, feature_name in enumerate(X_baseline.columns):
            change = importance_current[i] - importance_baseline[i]
            if abs(change) > 0.05:
                print(f"  {feature_name}: {change:+.3f}")

    else:
        print(f"✓ No significant drift ({drift_score:.3f})")

    return drift_score

from flask import Flask, request, jsonify

app = Flask(__name__)

# Load model and explainer (global)
model = xgb.XGBClassifier()
model.load_model('loan_model.json')
explainer = shap.TreeExplainer(model)

@app.route('/predict_and_explain', methods=['POST'])
def predict_and_explain():
    """
    API endpoint: Predict and explain loan approval.

    Request:
        {
            "credit_score": 720,
            "annual_income": 65000,
            "debt_to_income_ratio": 0.28,
            ...
        }

    Response:
        {
            "prediction": "approved",
            "confidence": 0.87,
            "explanation": [
                {"feature": "credit_score", "value": 720, "impact": +0.15},
                ...
            ]
        }
    """
    try:
        # Parse input
        data = request.json
        features = pd.DataFrame([data])

        # Predict
        prediction_proba = model.predict_proba(features)[0, 1]
        prediction_label = "approved" if prediction_proba >= 0.5 else "denied"

        # Explain
        shap_values = explainer.shap_values(features)[0]

        # Format explanation
        explanation = [
            {
                "feature": feature_name,
                "value": float(features.iloc[0][feature_name]),
                "impact": float(shap_values[i]),
                "impact_direction": "increases" if shap_values[i] > 0 else "decreases"
            }
            for i, feature_name in enumerate(features.columns)
        ]

        # Sort by absolute impact
        explanation.sort(key=lambda x: abs(x['impact']), reverse=True)

        return jsonify({
            "prediction": prediction_label,
            "confidence": float(prediction_proba),
            "explanation": explanation[:5]  # Top 5 features
        })

    except Exception as e:
        return jsonify({"error": str(e)}), 400


if __name__ == '__main__':
    app.run(port=5000)

def verify_shap_additivity(explainer, instance):
    """Check if SHAP values satisfy local accuracy."""
    shap_values = explainer.shap_values(instance)
    base_value = explainer.expected_value

    # Sum SHAP values
    shap_sum = base_value + shap_values.sum()

    # Actual prediction
    actual_pred = explainer.model.predict_proba(instance)[0, 1]

    print(f"Base value: {base_value:.4f}")
    print(f"Sum of SHAP values: {shap_values.sum():.4f}")
    print(f"SHAP prediction (base + sum): {shap_sum:.4f}")
    print(f"Actual model prediction: {actual_pred:.4f}")
    print(f"Difference: {abs(shap_sum - actual_pred):.6f}")

    if abs(shap_sum - actual_pred) > 0.01:
        print("⚠ SHAP values do NOT sum correctly!")
        print("Possible causes: wrong explainer type, model preprocessing not captured")

def measure_lime_stability(lime_explainer, instance, num_runs=10):
    """Measure explanation variance across multiple LIME runs."""
    explanations = []

    for _ in range(num_runs):
        exp = lime_explainer.explain_instance(instance, num_features=5)
        feature_weights = dict(exp.as_list())
        explanations.append(feature_weights)

    # Check variance
    for feature in explanations[0].keys():
        weights = [exp.get(feature, 0) for exp in explanations]
        print(f"{feature}: mean={np.mean(weights):.3f}, std={np.std(weights):.3f}")