# Install the LIME library if you haven't already
!pip install lime

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.datasets import make_classification

import lime
import lime.lime_tabular

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

print("Generating synthetic dataset...")
# Generate a synthetic dataset for binary classification
X, y = make_classification(
    n_samples=1000, n_features=10, n_informative=5, n_redundant=2, n_repeated=0,
    n_classes=2, n_clusters_per_class=1, weights=[0.5, 0.5], flip_y=0.01,
    random_state=42
)

feature_names = [f'feature_{i}' for i in range(X.shape[1])]
class_names = ['Class 0', 'Class 1']

df = pd.DataFrame(X, columns=feature_names)
df['target'] = y

print("Dataset head:")
display(df.head())

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
print(f"\nTraining data shape: {X_train.shape}")
print(f"Testing data shape: {X_test.shape}")

print("Training a RandomForestClassifier (our black-box model)...")
# Train a RandomForestClassifier
model = RandomForestClassifier(n_estimators=100, random_state=42, class_weight='balanced')
model.fit(X_train, y_train)

# Evaluate the model
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Model accuracy on test set: {accuracy:.4f}")

# We need a predict_proba function for LIME
predict_fn = lambda x: model.predict_proba(x)

print("\nModel trained successfully. This will be our black-box model for LIME explanations.")

print("Initializing LIME Explainer...")
# Initialize the LIME Tabular Explainer
# Parameters:
#   training_data: The data LIME uses to understand the distribution of features.
#   feature_names: List of strings with feature names.
#   class_names: List of strings with class names (e.g., 'Not Spam', 'Spam').
#   mode: 'classification' or 'regression' based on the task.
explainer = lime.lime_tabular.LimeTabularExplainer(
    training_data=X_train,  # LIME uses this to sample perturbations
    feature_names=feature_names,
    class_names=class_names,
    mode='classification',
    random_state=42  # Added for reproducibility
)
print("LIME Explainer initialized.")

print("Selecting an instance to explain and generating explanation...")
# Select an instance from the test set to explain
instance_idx = 0
data_row_to_explain = X_test[instance_idx]

# Get the black-box model's prediction for this instance
prediction_proba = predict_fn(data_row_to_explain.reshape(1, -1))[0]
predicted_class = np.argmax(prediction_proba)

print(f"Instance to explain (first 5 features): {data_row_to_explain[:5]}")
print(f"True label: {y_test[instance_idx]}")
print(f"Black-box model prediction probabilities: {prediction_proba}")
print(f"Black-box model predicted class: {class_names[predicted_class]}\n")

# Generate the explanation for the instance
# Parameters:
#   data_row: The instance to explain.
#   predict_fn: The black-box model's prediction function (must return probabilities).
#   num_features: The maximum number of features to include in the explanation.
#   num_samples: The number of perturbed samples to generate around the instance.
exp = explainer.explain_instance(
    data_row=data_row_to_explain,
    predict_fn=predict_fn,
    num_features=5,  # Show top 5 contributing features
    num_samples=5000  # More samples generally lead to more stable explanations
)

print("Explanation generated successfully.")

print("Displaying LIME explanation in notebook...")

# Force white background for better readability in dark mode
from IPython.display import HTML, display

# Add custom CSS to force white background for the LIME output
display(HTML("""
<style>
.lime-prediction-container,
.lime-explanation-container,
.lime .panel,
.lime .well,
.lime .bar-chart,
.lime .explanation,
.widget-output {
    background-color: white !important;
    color: black !important;
}
.lime-text {
    color: black !important;
}
.lime-bar {
    background-color: #4CAF50 !important;
}
.lime-bar-negative {
    background-color: #F44336 !important;
}
</style>
"""))

# Visualize the explanation directly in the notebook
# This visualization shows the contribution of each feature to the predicted class.
# Green bars indicate features supporting the predicted class, red bars indicate features contradicting it.
exp.show_in_notebook(show_all=False)

print("\nInterpretation for the above visualization:")
print("The bar chart above shows the features that are most influential for the specific prediction of the black-box model for the selected instance. The length and color of the bars indicate the magnitude and direction of their contribution.")
print("  - **Green bars**: Features that push the prediction towards 'Class 1' (the predicted class in this case).")
print("  - **Red bars**: Features that push the prediction towards 'Class 0'.")
print("The values next to the feature names are the actual values of those features for the explained instance.")
print("The intercept is the prediction of the local surrogate model when all features are at their baseline (average) values.")

print("Creating a custom bar plot of feature contributions...")
# Get the explanation as a list of (feature, weight) tuples
explanation_list = exp.as_list()

# Sort features by absolute weight for better visualization
explanation_list.sort(key=lambda x: abs(x[1]), reverse=True)

features = [item[0] for item in explanation_list]
weights = [item[1] for item in explanation_list]
colors = ['green' if w > 0 else 'red' for w in weights]

plt.figure(figsize=(10, 6))
# Note: Using barplot with manual colors
for i, (feature, weight, color) in enumerate(zip(features, weights, colors)):
    plt.barh(feature, weight, color=color, alpha=0.7)

plt.xlabel('Contribution to Prediction (Weight)')
plt.ylabel('Feature')
plt.title(f'LIME Explanation for Instance {instance_idx} (Predicted Class: {class_names[predicted_class]})')
plt.axvline(0, color='grey', linestyle='--', linewidth=0.8)  # Add a vertical line at 0 for reference
plt.grid(axis='x', linestyle='--', alpha=0.7)
plt.tight_layout()
plt.show()

print("\nInterpretation for the custom bar plot:")
print("This bar plot provides the same information as the LIME built-in visualization but in a standard matplotlib format. Each bar represents a feature's local contribution to the model's prediction for the specific instance. Positive weights (green) contribute towards the predicted class, while negative weights (red) contribute against it.")
print("This custom plot allows for easier integration into reports or dashboards and offers flexibility in styling.")