File size: 4,021 Bytes
7812756 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 |
import torch
import numpy as np
from typing import Dict, Tuple
from src.model import KickstarterModel
class KickstarterExplainer:
"""Kickstarter prediction model explainer"""
def __init__(self, model: KickstarterModel, device: torch.device = None):
"""
Initialize the explainer.
Args:
model: Trained model.
device: Computation device.
"""
self.model = model
self.device = device if device is not None else torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.model.to(self.device)
self.model.eval()
# Numerical feature names
self.numerical_feature_names = [
'description_length',
'funding_goal',
'image_count',
'video_count',
'campaign_duration',
'previous_projects_count',
'previous_success_rate',
'previous_pledged',
'previous_funding_goal'
]
# Mapping from embedding feature names to internal names
self.embedding_map = {
'description_embedding': 'description_embedding',
'blurb_embedding': 'blurb_embedding',
'risk_embedding': 'risk_embedding',
'subcategory_embedding': 'subcategory_embedding',
'category_embedding': 'category_embedding',
'country_embedding': 'country_embedding'
}
def _compute_feature_contribution(self, baseline_probs, inputs, feature_name, is_numerical=False, index=None):
# Create input containing only the current feature
feature_input = {k: torch.zeros_like(v) for k, v in inputs.items()}
if is_numerical:
feature_input['numerical_features'] = torch.zeros_like(inputs['numerical_features'])
feature_input['numerical_features'][:, index] = inputs['numerical_features'][:, index]
else:
feature_input[feature_name] = inputs[feature_name]
# Prediction
with torch.no_grad():
feature_probs, _ = self.model(feature_input)
# SHAP value is the prediction difference
return (feature_probs - baseline_probs).cpu().item()
def explain_prediction(self, inputs: Dict[str, torch.Tensor]) -> Tuple[float, Dict[str, float]]:
"""
Explain a single prediction.
Args:
inputs: Input features.
Returns:
Predicted probability and SHAP contribution values.
"""
# Move inputs to device
inputs = {k: v.to(self.device) for k, v in inputs.items()}
# Prediction
with torch.no_grad():
probs, _ = self.model(inputs)
# Calculate SHAP values
shap_values = {}
baseline = {k: torch.zeros_like(v) for k, v in inputs.items()}
# Predict baseline
with torch.no_grad():
baseline_probs, _ = self.model(baseline)
# Calculate SHAP values for embedding features
for feature_name, embedding_name in self.embedding_map.items():
if embedding_name in inputs:
shap_values[feature_name] = self._compute_feature_contribution(
baseline_probs, inputs, embedding_name
)
# Calculate SHAP values for numerical features
if 'numerical_features' in inputs:
num_features = inputs['numerical_features'].size(1)
for i in range(num_features):
feature_name = self.numerical_feature_names[i]
shap_values[feature_name] = self._compute_feature_contribution(
baseline_probs, inputs, 'numerical_features',
is_numerical=True, index=i
)
# Return prediction probability and SHAP values
prediction = probs.cpu().item()
return prediction, shap_values |