Zeker, ik help je graag met het implementeren van feature attributie technieken voor je PyTorch CNN-model. Hier zijn concrete implementaties en uitleg: ## 1. Integrated Gradients Implementatie ```python import torch import torch.nn as nn import numpy as np import matplotlib.pyplot as plt from captum.attr import IntegratedGradients # Stel dat je model is gedefinieerd als: class AnimalCNN(nn.Module): def __init__(self, num_classes=10): super(AnimalCNN, self).__init__() self.features = nn.Sequential( nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2), nn.Conv2d(32, 64, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2) ) self.classifier = nn.Sequential( nn.Linear(64 * 56 * 56, 128), # Aanpassen op basis van input size nn.ReLU(), nn.Linear(128, num_classes) ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x # Initialiseer model en Integrated Gradients model = AnimalCNN() ig = IntegratedGradients(model) # Functie voor attributie berekening def calculate_integrated_gradients(input_tensor, target_class): # Creëer baseline (zwarte afbeelding) baseline = torch.zeros_like(input_tensor) # Bereken attributies attributions = ig.attribute(input_tensor, baseline, target=target_class, n_steps=50) return attributions # Voorbeeld gebruik input_image = ... # Je input tensor [1, 3, H, W] target_class = 3 # Gewenste klasse voor attributie attributions = calculate_integrated_gradients(input_image, target_class) ``` ## 2. SHAP Implementatie met DeepExplainer ```python import shap import torch from torchvision import transforms # Voorbereiding voor SHAP def model_forward(x): # Transformeer SHAP input naar model input formaat x = torch.tensor(x, dtype=torch.float32) if len(x.shape) == 4: x = x.permute(0, 3, 1, 2) # Van [batch, H, W, C] naar [batch, C, H, W] return model(x).detach().numpy() # Kies achtergrond samples voor SHAP background = ... # Selecteer 50-100 willekeurige afbeeldingen [50, 3, H, W] # Initialiseer SHAP explainer explainer = shap.DeepExplainer(model, background) # Bereken SHAP waarden test_image = ... # Je test afbeelding [1, 3, H, W] shap_values = explainer.shap_values(test_image) # Visualiseer resultaten shap.image_plot(shap_values, -test_image.permute(0, 2, 3, 1).numpy()) ``` ## 3. Captum Library voor Meerdere Methoden ```python from captum.attr import Saliency, GuidedBackprop, DeepLift # Saliency Maps saliency = Saliency(model) saliency_attr = saliency.attribute(input_image, target=target_class) # Guided Backpropagation guided_bp = GuidedBackprop(model) guided_attr = guided_bp.attribute(input_image, target=target_class) # DeepLIFT deeplift = DeepLift(model) deeplift_attr = deeplift.attribute(input_image, target=target_class) ``` ## 4. Visualisatie en Interpretatie ```python def visualize_attributions(original_img, attributions, method_name): # Normaliseer attributies attributions = attributions.detach().cpu().numpy() attributions = np.transpose(attributions[0], (1, 2, 0)) # Bereken absolute waarden voor visualisatie attr_abs = np.abs(attributions).sum(axis=2) attr_abs = (attr_abs - attr_abs.min()) / (attr_abs.max() - attr_abs.min()) # Plot resultaten fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5)) # Originele afbeelding ax1.imshow(np.transpose(original_img[0].cpu().numpy(), (1, 2, 0))) ax1.set_title('Originele Afbeelding') ax1.axis('off') # Attributie heatmap im = ax2.imshow(attr_abs, cmap='hot') ax2.set_title(f'Feature Attributie - {method_name}') ax2.axis('off') plt.colorbar(im, ax=ax2) plt.show() # Gebruik de visualisatie visualize_attributions(input_image, attributions, "Integrated Gradients") ``` ## 5. Interpretatie van Resultaten **Hoe te interpreteren:** - **Rode gebieden**: Sterk positieve bijdrage aan de voorspelling - **Blauwe gebieden**: Sterk negatieve bijdrage (tegen de voorspelling) - **Neutrale gebieden**: Weinig invloed op de voorspelling **Praktische tips:** 1. **Vergelijk meerdere methoden** voor consistente resultaten 2. **Controleer of de model focust op relevante features** (bijv. ogen, poten bij dieren) 3. **Let op bias**: Als het model op achtergrond focust i.p.v. het dier 4. **Gebruik meerdere samples** per klasse voor betrouwbare conclusies ## 6. Installatie Vereisten ```bash pip install captum shap torch torchvision matplotlib ``` ## 7. Complete Workflow Voorbeeld ```python def analyze_model_decisions(model, test_loader, class_names): model.eval() for images, labels in test_loader: # Kies een paar voorbeelden for i in range(min(3, len(images))): image = images[i:i+1] true_label = labels[i].item() # Voorspelling with torch.no_grad(): output = model(image) pred_label = output.argmax().item() print(f"Waar: {class_names[true_label]}, Voorspeld: {class_names[pred_label]}") # Bereken attributies attributions = calculate_integrated_gradients(image, pred_label) # Visualiseer visualize_attributions(image, attributions, f"Klasse: {class_names[pred_label]}") if i >= 2: # Beperk aantal voorbeelden break break ``` Deze techniek helpt je begrijpen **welke pixels** het meest bijdragen aan de voorspelling van je model, wat cruciaal is voor model debugging en betrouwbaarheid.