import marimo __generated_with = "0.14.10" app = marimo.App(width="medium") @app.cell def _(): import pandas as pd import numpy as np import plotly.express as px import plotly.graph_objects as go import altair as alt from sklearn.datasets import fetch_california_housing from sklearn.model_selection import train_test_split from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score from sklearn.preprocessing import StandardScaler import joblib import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset import warnings return ( DataLoader, LinearRegression, StandardScaler, TensorDataset, alt, fetch_california_housing, joblib, mean_absolute_error, mean_squared_error, nn, np, optim, pd, px, r2_score, torch, train_test_split, ) @app.cell def _(): import marimo as mo return (mo,) @app.cell def _(mo): mo.md(r"""# eXplainable AI (XAI)""") return @app.cell def _(mo): mo.md( """ ## What is XAI? XAI refers to a set of techniques and methods that make the decision-making process of AI models transparent, understandable, and interpretable to humans. """ ) return @app.cell def _(mo): mo.md(r"""When the complexity of a model increases, you get better accuracy, but then explaining how your model makes its decisions becomes harder. The feild of XAI tries to find the best trade-off between explainability and accuracy.""") return @app.cell def _(mo): mo.image("/Users/negarvahid/Desktop/intorduction_to_xai/increasing_complexity.png") return @app.cell def _(mo): mo.md(r"""## What is Interpretibility?""") return @app.cell def _(mo): mo.md(r"""You call a model *interpretable* when you can understand the internal mechanisms of a model.""") return @app.cell def _(mo): mo.md(r"""Let’s say you’re predicting someone’s risk of heart disease. If you use a linear regression model, you’ll get a clean equation like:""") return @app.cell def _(mo): mo.md( r""" $$ \text{Risk} = 0.3 \cdot \text{Age} + 0.5 \cdot \text{Cholesterol} + 0.7 \cdot \text{SmokingStatus} $$ """ ) return @app.cell def _(mo): mo.md(r"""This model is interpretable. You can look at the numbers and instantly understand how each feature contributes to the prediction. You don’t need any extra tools, as **it’s transparent by design**.""") return @app.cell def _(mo): mo.md(r"""## What is Explainbility?""") return @app.cell def _(mo): mo.md(r"""Now imagine you use a deep neural network for the same task. The network might give highly accurate predictions, but its internal workings are opaque due to multiple hidden layers and non-linear transformations. You can't just "look" at the model and understand how it made a decision.""") return @app.cell def _(mo): mo.image("/Users/negarvahid/Desktop/intorduction_to_xai/Screenshot 2025-07-12 at 16.05.55.png") return @app.cell def _(mo): mo.md( r""" To make sense of this black-box model, you might use a tool like SHAP (SHapley Additive exPlanations) to show that for a particular patient, high cholesterol and smoking status increased their predicted risk by specific amounts. This is **explainability** You're using a tool to externally explain the behavior of a complex, non-interpretable model. """ ) return @app.cell def _(mo): mo.md(r"""#The California Housing Prices Dataset""") return @app.cell def _(mo): mo.md( r""" The California Housing Prices Dataset a tabular dataset that contains information collected from the 1990 California census, aimed at predicting the median house value (in USD) for various districts across California, based on features like: - Median income of residents - Average number of rooms per household - Average number of bedrooms - Population and household size - Latitude and longitude - Housing median age - Total instances: 20,640 rows (each one represents a housing block group) Number of features: 8 input features + 1 target value (median house price) """ ) return @app.cell def _(mo): mo.md( r""" ### Load the dataset Run the following cell to load the dataset: """ ) return @app.cell def _(): return @app.cell def _(fetch_california_housing, pd): def load_data(): california = fetch_california_housing() data = pd.DataFrame(california.data, columns=california.feature_names) data['target'] = california.target return data data = load_data() return data, load_data @app.cell def _(data): data return @app.cell def _(mo): mo.md( r""" ### Visualize the Dataset: It would be great to visualize the dataset! Run the cell below to get an interactive plot of the dataset: """ ) return @app.cell(hide_code=True) def _(alt, data, mo): selection = alt.selection_point(fields=['index'], name='select') data_sample = data.sample(n=200, random_state=42) location_chart = mo.ui.altair_chart( alt.Chart(data_sample.reset_index()).mark_circle(size=60).encode( x=alt.X('Longitude:Q', title='Longitude', scale=alt.Scale(domain=[-124.5, -114.0])), y=alt.Y('Latitude:Q', title='Latitude', scale=alt.Scale(domain=[32.0, 42.5])), color=alt.Color('target:Q', scale=alt.Scale(scheme='viridis', domain=[0, 5]), title='Price ($100k)', legend=alt.Legend(orient='top', titleFontSize=14, labelFontSize=12)), size=alt.Size('AveBedrms:Q', scale=alt.Scale(range=[100, 400], domain=[0, 2]), title='Avg Bedrooms', legend=alt.Legend(orient='top', titleFontSize=14, labelFontSize=12)), tooltip=[ alt.Tooltip('Longitude:Q', title='Longitude', format='.3f'), alt.Tooltip('Latitude:Q', title='Latitude', format='.3f'), alt.Tooltip('target:Q', title='Price ($100k)', format='.2f'), alt.Tooltip('AveBedrms:Q', title='Avg Bedrooms', format='.2f'), alt.Tooltip('MedInc:Q', title='Median Income', format='.2f'), alt.Tooltip('HouseAge:Q', title='House Age', format='.0f'), alt.Tooltip('AveRooms:Q', title='Avg Rooms', format='.2f'), alt.Tooltip('Population:Q', title='Population', format='.0f'), alt.Tooltip('AveOccup:Q', title='Avg Occupancy', format='.2f') ], opacity=alt.condition(selection, alt.value(1), alt.value(0.7)) ).add_params(selection).properties( title='California Housing: 500 Sample Points - Location, Price & Bedrooms (Click to Select)', width=900, height=700 ).interactive() ) price_bedrooms_chart = mo.ui.altair_chart( alt.Chart(data_sample.reset_index()).mark_circle(size=60).encode( x=alt.X('AveBedrms:Q', title='Average Bedrooms', scale=alt.Scale(domain=[0, 2])), y=alt.Y('target:Q', title='Price ($100k)', scale=alt.Scale(domain=[0, 5])), color=alt.Color('MedInc:Q', scale=alt.Scale(scheme='plasma', domain=[0, 15]), title='Median Income', legend=alt.Legend(orient='top', titleFontSize=14, labelFontSize=12)), size=alt.Size('Population:Q', scale=alt.Scale(range=[100, 400], domain=[0, 3000]), title='Population', legend=alt.Legend(orient='top', titleFontSize=14, labelFontSize=12)), tooltip=[ alt.Tooltip('AveBedrms:Q', title='Avg Bedrooms', format='.2f'), alt.Tooltip('target:Q', title='Price ($100k)', format='.2f'), alt.Tooltip('MedInc:Q', title='Median Income', format='.2f'), alt.Tooltip('Population:Q', title='Population', format='.0f'), alt.Tooltip('Longitude:Q', title='Longitude', format='.3f'), alt.Tooltip('Latitude:Q', title='Latitude', format='.3f'), alt.Tooltip('HouseAge:Q', title='House Age', format='.0f'), alt.Tooltip('AveRooms:Q', title='Avg Rooms', format='.2f'), alt.Tooltip('AveOccup:Q', title='Avg Occupancy', format='.2f') ], opacity=alt.condition(selection, alt.value(1), alt.value(0.7)) ).add_params(selection).properties( title='Price vs Bedrooms: 500 Sample Points - Income & Population (Click to Select)', width=900, height=600 ).interactive() ) mo.md(f""" # California Housing Dataset - 500 Sample Points Analysis **Dataset Shape:** {data.shape[0]} total rows × {data.shape[1]} columns **Sample Size:** 500 random points (for better visualization) **Key Features:** - **Location**: Longitude & Latitude - **Price**: Median house value (target) - $0-500k - **Bedrooms**: Average number of bedrooms (AveBedrms) - 0-2 - **Income**: Median income (MedInc) - $0-15k - **Population**: Block group population - 0-3000 - **Age**: Median house age (HouseAge) - **Rooms**: Average rooms per household (AveRooms) - **Occupancy**: Average household members (AveOccup) **How to Use:** Click on any point to select it and see its data highlighted. Selected points will appear more opaque. --- """) mo.md("## 1. Interactive Map: Location, Price & Bedrooms") mo.md("**500 sample points** across California. **Color = Price** (viridis scale), **Size = Number of Bedrooms**. **Click on any point to select it** - selected points become more opaque. Hover for detailed information.") location_chart mo.md("## 2. Price vs Bedrooms Analysis") mo.md("**500 sample points** showing price vs bedrooms relationship. **Color = Income** (plasma scale), **Size = Population**. **Click on any point to select it** - the same selection works across both charts.") price_bedrooms_chart return @app.cell(hide_code=True) def _(data, mo, px): def create_map_plot(): fig = px.scatter( data, x='Longitude', y='Latitude', color='target', color_continuous_scale='viridis', title='California Housing Prices by Location', labels={'target': 'Price ($100k)', 'Longitude': 'Longitude', 'Latitude': 'Latitude'}, hover_data=['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup'] ) fig.update_layout( width=800, height=600, title_x=0.5 ) return fig map_plot = create_map_plot() interactive_map = mo.ui.plotly(map_plot) return (interactive_map,) @app.cell def _(interactive_map): interactive_map return @app.cell(hide_code=True) def _( DataLoader, LinearRegression, StandardScaler, TensorDataset, fetch_california_housing, joblib, mean_absolute_error, mean_squared_error, nn, np, optim, pd, r2_score, torch, train_test_split, ): class NeuralNetwork(nn.Module): def __init__(self, input_size=8, hidden_size=64, output_size=1): super(NeuralNetwork, self).__init__() self.layer1 = nn.Linear(input_size, hidden_size) self.layer2 = nn.Linear(hidden_size, hidden_size // 2) self.layer3 = nn.Linear(hidden_size // 2, hidden_size // 4) self.layer4 = nn.Linear(hidden_size // 4, output_size) self.relu = nn.ReLU() self.dropout = nn.Dropout(0.2) def forward(self, x): x = self.relu(self.layer1(x)) x = self.dropout(x) x = self.relu(self.layer2(x)) x = self.dropout(x) x = self.relu(self.layer3(x)) x = self.layer4(x) return x class PyTorchModel: def __init__(self, input_size=8, hidden_size=64, epochs=100, lr=0.001): self.model = NeuralNetwork(input_size, hidden_size) self.epochs = epochs self.lr = lr self.criterion = nn.MSELoss() self.optimizer = optim.Adam(self.model.parameters(), lr=lr) self.is_trained = False def fit(self, X, y): # Convert to PyTorch tensors X_tensor = torch.FloatTensor(X) y_tensor = torch.FloatTensor(y.values if hasattr(y, 'values') else y).reshape(-1, 1) # Create data loader dataset = TensorDataset(X_tensor, y_tensor) dataloader = DataLoader(dataset, batch_size=32, shuffle=True) # Training loop self.model.train() for epoch in range(self.epochs): total_loss = 0 for batch_X, batch_y in dataloader: self.optimizer.zero_grad() outputs = self.model(batch_X) loss = self.criterion(outputs, batch_y) loss.backward() self.optimizer.step() total_loss += loss.item() if (epoch + 1) % 20 == 0: print(f" Epoch [{epoch+1}/{self.epochs}], Loss: {total_loss/len(dataloader):.4f}") self.is_trained = True def predict(self, X): if not self.is_trained: raise ValueError("Model not trained yet!") self.model.eval() with torch.no_grad(): X_tensor = torch.FloatTensor(X) predictions = self.model(X_tensor) return predictions.numpy().flatten() class CaliforniaHousingKaggleStyle: def __init__(self): self.scaler = StandardScaler() self.feature_names = None self.X_train = None self.X_test = None self.y_train = None self.y_test = None def load_data(self): """Load California Housing dataset""" print("Loading California Housing dataset...") california = fetch_california_housing() # Create DataFrame self.data = pd.DataFrame(california.data, columns=california.feature_names) self.data['target'] = california.target # Store feature names self.feature_names = california.feature_names print(f"Dataset shape: {self.data.shape}") print(f"Features: {list(self.feature_names)}") print(f"Target: Median house value (in $100,000s)") return self.data def prepare_data(self, test_size=0.2, random_state=42): """Prepare data for training""" print("\n=== Data Preparation ===") # Separate features and target X = self.data.drop('target', axis=1) y = self.data['target'] # Split the data self.X_train, self.X_test, self.y_train, self.y_test = train_test_split( X, y, test_size=test_size, random_state=random_state ) # Scale the features self.X_train_scaled = self.scaler.fit_transform(self.X_train) self.X_test_scaled = self.scaler.transform(self.X_test) print(f"Training set shape: {self.X_train.shape}") print(f"Test set shape: {self.X_test.shape}") return self.X_train_scaled, self.X_test_scaled, self.y_train, self.y_test def train_models(self): """Train Linear Regression and Neural Network""" print("\n=== Training Models ===") # Train Linear Regression print("Training Linear Regression...") self.linear_model = LinearRegression() self.linear_model.fit(self.X_train_scaled, self.y_train) print(" ✓ Linear Regression trained successfully") # Train Neural Network print("Training Neural Network...") self.nn_model = PyTorchModel(epochs=100, lr=0.001) self.nn_model.fit(self.X_train_scaled, self.y_train) print(" ✓ Neural Network trained successfully") def evaluate_models(self): """Evaluate both models""" print("\n=== Model Evaluation ===") # Linear Regression evaluation y_train_pred_lr = self.linear_model.predict(self.X_train_scaled) y_test_pred_lr = self.linear_model.predict(self.X_test_scaled) lr_train_rmse = np.sqrt(mean_squared_error(self.y_train, y_train_pred_lr)) lr_test_rmse = np.sqrt(mean_squared_error(self.y_test, y_test_pred_lr)) lr_train_mae = mean_absolute_error(self.y_train, y_train_pred_lr) lr_test_mae = mean_absolute_error(self.y_test, y_test_pred_lr) lr_train_r2 = r2_score(self.y_train, y_train_pred_lr) lr_test_r2 = r2_score(self.y_test, y_test_pred_lr) print("Linear Regression:") print(f" Test RMSE: {lr_test_rmse:.4f}") print(f" Test MAE: {lr_test_mae:.4f}") print(f" Test R²: {lr_test_r2:.4f}") # Neural Network evaluation y_train_pred_nn = self.nn_model.predict(self.X_train_scaled) y_test_pred_nn = self.nn_model.predict(self.X_test_scaled) nn_train_rmse = np.sqrt(mean_squared_error(self.y_train, y_train_pred_nn)) nn_test_rmse = np.sqrt(mean_squared_error(self.y_test, y_test_pred_nn)) nn_train_mae = mean_absolute_error(self.y_train, y_train_pred_nn) nn_test_mae = mean_absolute_error(self.y_test, y_test_pred_nn) nn_train_r2 = r2_score(self.y_train, y_train_pred_nn) nn_test_r2 = r2_score(self.y_test, y_test_pred_nn) print("\nNeural Network:") print(f" Test RMSE: {nn_test_rmse:.4f}") print(f" Test MAE: {nn_test_mae:.4f}") print(f" Test R²: {nn_test_r2:.4f}") return { 'linear_regression': { 'train_rmse': lr_train_rmse, 'test_rmse': lr_test_rmse, 'train_mae': lr_train_mae, 'test_mae': lr_test_mae, 'train_r2': lr_train_r2, 'test_r2': lr_test_r2 }, 'neural_network': { 'train_rmse': nn_train_rmse, 'test_rmse': nn_test_rmse, 'train_mae': nn_train_mae, 'test_mae': nn_test_mae, 'train_r2': nn_train_r2, 'test_r2': nn_test_r2 } } def save_models(self): """Save both models and their parameters""" print("\n=== Saving Models ===") # Save Linear Regression linear_model_data = { 'model': self.linear_model, 'scaler': self.scaler, 'feature_names': self.feature_names, 'parameters': { 'coef_': self.linear_model.coef_.tolist(), 'intercept_': float(self.linear_model.intercept_) } } joblib.dump(linear_model_data, 'linear_regression_model.pkl') print("Linear Regression model saved to 'linear_regression_model.pkl'") # Save Neural Network nn_model_data = { 'model': self.nn_model, 'scaler': self.scaler, 'feature_names': self.feature_names, 'parameters': { 'state_dict': self.nn_model.model.state_dict(), 'input_size': 8, 'hidden_size': 64, 'epochs': 100, 'lr': 0.001 } } joblib.dump(nn_model_data, 'neural_network_model.pkl') print("Neural Network model saved to 'neural_network_model.pkl'") def predict_with_linear_regression(self, sample_data): """Make prediction with Linear Regression""" if isinstance(sample_data, dict): sample_df = pd.DataFrame([sample_data]) else: sample_df = sample_data # Ensure all features are present for feature in self.feature_names: if feature not in sample_df.columns: raise ValueError(f"Missing feature: {feature}") # Reorder columns to match training data sample_df = sample_df[self.feature_names] # Scale the data sample_scaled = self.scaler.transform(sample_df) # Make prediction prediction = self.linear_model.predict(sample_scaled)[0] return prediction def predict_with_neural_network(self, sample_data): """Make prediction with Neural Network""" if isinstance(sample_data, dict): sample_df = pd.DataFrame([sample_data]) else: sample_df = sample_data # Ensure all features are present for feature in self.feature_names: if feature not in sample_df.columns: raise ValueError(f"Missing feature: {feature}") # Reorder columns to match training data sample_df = sample_df[self.feature_names] # Scale the data sample_scaled = self.scaler.transform(sample_df) # Make prediction prediction = self.nn_model.predict(sample_scaled)[0] return prediction def main(): """Main function""" print("California Housing Price Prediction - Linear Regression & Neural Network") print("=" * 70) # Initialize predictor = CaliforniaHousingKaggleStyle() # Load data data = predictor.load_data() # Prepare data predictor.prepare_data() # Train models predictor.train_models() # Evaluate models results = predictor.evaluate_models() # Save models predictor.save_models() # Example predictions print("\n=== Example Predictions ===") sample_data = { 'MedInc': 8.3252, 'HouseAge': 41.0, 'AveRooms': 6.984127, 'AveBedrms': 1.023810, 'Population': 322.0, 'AveOccup': 2.555556, 'Latitude': 37.88, 'Longitude': -122.23 } lr_prediction = predictor.predict_with_linear_regression(sample_data) nn_prediction = predictor.predict_with_neural_network(sample_data) print(f"Sample data: {sample_data}") print(f"Linear Regression prediction: ${lr_prediction * 100000:.2f}") print(f"Neural Network prediction: ${nn_prediction * 100000:.2f}") main() return @app.cell def _(mo): mo.md(r"""You already have two models prepared for you. One is a linear regression, the other is a neural network. Run the followung cell to load them and make a sample prediction:""") return @app.cell(hide_code=True) def _(joblib, pd): def load_models(): linear_model_data = joblib.load('linear_regression_model.pkl') nn_model_data = joblib.load('neural_network_model.pkl') return linear_model_data, nn_model_data def make_prediction(linear_model_data, nn_model_data, sample_data): if isinstance(sample_data, dict): sample_df = pd.DataFrame([sample_data]) else: sample_df = sample_data feature_names = linear_model_data['feature_names'] for feature in feature_names: if feature not in sample_df.columns: raise ValueError(f"Missing feature: {feature}") sample_df = sample_df[feature_names] scaler = linear_model_data['scaler'] sample_scaled = scaler.transform(sample_df) linear_prediction = linear_model_data['model'].predict(sample_scaled)[0] nn_model = nn_model_data['model'] nn_prediction = nn_model.predict(sample_scaled)[0] return linear_prediction, nn_prediction def predict_with_models(): print("Loading saved models...") linear_model_data, nn_model_data = load_models() print("Models loaded successfully!") sample_data = { 'MedInc': 8.3252, 'HouseAge': 41.0, 'AveRooms': 6.984127, 'AveBedrms': 1.023810, 'Population': 322.0, 'AveOccup': 2.555556, 'Latitude': 37.88, 'Longitude': -122.23 } print(f"\nSample data: {sample_data}") linear_pred, nn_pred = make_prediction(linear_model_data, nn_model_data, sample_data) print(f"Linear Regression prediction: ${linear_pred * 100000:.2f}") print(f"Neural Network prediction: ${nn_pred * 100000:.2f}") predict_with_models() return @app.cell def _(mo): mo.md(r"""# Interpret a Linear Regressor""") return @app.cell def _(mo): mo.md(r"""## Load Model's Coefficients and Intercept""") return @app.cell def _(mo): mo.md(r"""As you saw earlier, linear regression models are naturally interpretable. You can directly inspect the coefficients and intercept to understand how the model makes predictions. Go ahead and load the trained model so you can extract and examine those values:""") return @app.cell def _(joblib): model_data = joblib.load('linear_regression_model.pkl') model = model_data['model'] feature_names = model_data['feature_names'] # Get coefficients and intercept coefficients = model.coef_ intercept = model.intercept_ print("Linear Regression Model Interpretation") print("=" * 50) print(f"Intercept: {intercept:.4f}") print("\nFeature Coefficients:") print("-" * 30) print(coefficients) return coefficients, feature_names @app.cell def _(mo): mo.md(rf"""#### Question: In a linear regression model, what does the intercept represent?""") return @app.cell def _(mo): mo.md( r""" The intercept in a linear regression model represents the predicted output when all input features are zero. $$ y = w_1 x_1 + w_2 x_2 + \cdots + w_n x_n + b $$ where: $$ w_1, w_2, \dots, w_n \text{ are the coefficients} $$ $$ x_1, x_2, \dots, x_n \text{ are the features} $$ $$ b \text{ is the intercept} $$ So: $$ \text{Intercept } b = y \quad \text{when all } x_i = 0 $$ Think of the intercept as the model’s baseline prediction — the value of \( y \) when there’s no influence from any feature. It anchors the regression line or hyperplane in the output space. """ ) return @app.cell def _(mo): mo.md( r""" ## Examine the most Influential Features To get a better sense of what the coefficients represent and which features they belong to, you can create a DataFrame that pairs each coefficient with its corresponding feature name. This helps you see which inputs have the strongest impact on the model’s predictions. """ ) return @app.cell def _(coefficients, feature_names, np, pd): def interpret_model(): coef_df = pd.DataFrame({ 'Feature': feature_names, 'Coefficient': coefficients, 'Abs_Coefficient': np.abs(coefficients) }).sort_values('Abs_Coefficient', ascending=False) return coef_df return (interpret_model,) @app.cell def _(interpret_model): coef_df = interpret_model() coef_df return (coef_df,) @app.cell def _(mo): mo.md(r"""According to your model's coefs and intercept, the three most important features are:""") return @app.cell def _(coef_df): top_features = coef_df.head(3) print("\nTop 3 Most Important Features:") for _, row in top_features.iterrows(): effect = "increases" if row['Coefficient'] > 0 else "decreases" print(f"• {row['Feature']}: {effect} price by {abs(row['Coefficient']):.4f} units") return @app.cell def _(mo): mo.md( r""" The coefficients and their signs tell you a lot about the model. **Latitude has the strongest negative effect**: moving north (higher latitude) decreases price. **Longitude is next**: moving east (higher longitude) also decreases price. **MedInc (median income) strongly increases housing price**: richer areas tend to have more expensive homes. """ ) return @app.cell def _(mo): mo.md(r"""🤔 Question: What effect does `AveRooms` have on your model?""") return @app.cell def _(mo): mo.md(r"""# Explain a Neural Network""") return @app.cell def _(mo): mo.md(r"""## Understand SHAP""") return @app.cell def _(mo): mo.md( r""" SHAP stands for SHapley Additive exPlanations. Shapley values come from coalitional game theory. They were introduced by Lloyd Shapley in 1953 as a principled way to distribute total gains fairly among players who form coalitions. The core idea is this: > Each player’s payout should reflect their average contribution across all possible orders in which players could join the team. In the context of machine learning: - Each feature is treated as a player. - The model's output is the total “reward” to be distributed. - SHAP assigns each feature a value that reflects how much it contributed to the prediction, across all possible subsets of features. It’s a way to explain a model’s output that’s consistent, additive, and fair. """ ) return @app.cell def _(mo): mo.md(r"""## Use SHAP""") return @app.cell def _(joblib, load_data, np, pd): import shap def load_nn_model(): model_data = joblib.load('neural_network_model.pkl') return model_data['model'], model_data['scaler'], model_data['feature_names'] def perform_nn_shap_analysis(): model, scaler, feature_names = load_nn_model() data = load_data() # Use only the features that were used during training (exclude target) X = data[feature_names] X_scaled = scaler.transform(X) # Use a subset for SHAP analysis X_sample = X_scaled[:1000] # Create a wrapper function for the neural network def nn_predict(X): return model.predict(X) # Use KernelExplainer for neural networks explainer = shap.KernelExplainer(nn_predict, X_sample[:100]) shap_values = explainer.shap_values(X_sample[:100]) print("Neural Network SHAP Analysis Results:") print("=" * 50) # Calculate feature importance feature_importance = np.abs(shap_values).mean(0) importance_df = pd.DataFrame({ 'Feature': feature_names, 'SHAP_Importance': feature_importance }).sort_values('SHAP_Importance', ascending=False) print("\nFeature Importance (SHAP):") print(importance_df) return shap_values, importance_df perform_nn_shap_analysis() return if __name__ == "__main__": app.run()