Hier is een geavanceerde implementatie voor uw pneumonie-detectiemodel: ```python import torch import torch.nn as nn import numpy as np import matplotlib.pyplot as plt import cv2 from PIL import Image from torchvision import transforms, models from captum.attr import Saliency, IntegratedGradients, LayerGradCam from captum.attr import visualization as viz class AdvancedExplanationPipeline: def __init__(self, model, device='cuda'): self.model = model.eval() self.device = device self.model.to(device) # Registreer hooks voor feature extraction self.features = {} self._register_hooks() def _register_hooks(self): """Registreer hooks om activaties van verschillende lagen vast te leggen""" def get_activation(name): def hook(model, input, output): self.features[name] = output.detach() return hook # Registreer hooks voor belangrijke ResNet50 lagen self.model.layer4[2].conv3.register_forward_hook(get_activation('layer4_conv3')) self.model.avgpool.register_forward_hook(get_activation('avgpool')) def generate_saliency_map(self, input_tensor, target_class=None): """Genereer saliency map met behulp van gradients""" saliency = Saliency(self.model) if target_class is None: # Gebruik predicted class als target with torch.no_grad(): output = self.model(input_tensor) target_class = output.argmax(dim=1).item() attributions = saliency.attribute(input_tensor, target=target_class) return attributions, target_class def generate_grad_cam(self, input_tensor, target_layer, target_class=None): """Genereer Grad-CAM voor specifieke laag""" if target_class is None: with torch.no_grad(): output = self.model(input_tensor) target_class = output.argmax(dim=1).item() grad_cam = LayerGradCam(self.model, target_layer) attributions = grad_cam.attribute(input_tensor, target=target_class) return attributions, target_class def generate_integrated_gradients(self, input_tensor, target_class=None, baselines=None): """Genereer integrated gradients""" ig = IntegratedGradients(self.model) if target_class is None: with torch.no_grad(): output = self.model(input_tensor) target_class = output.argmax(dim=1).item() attributions = ig.attribute(input_tensor, target=target_class, baselines=baselines) return attributions, target_class def overlay_heatmap(self, image, heatmap, alpha=0.5): """Overlay heatmap op originele afbeelding""" heatmap = heatmap.squeeze().cpu().numpy() heatmap = np.maximum(heatmap, 0) heatmap = heatmap / np.max(heatmap) heatmap = cv2.resize(heatmap, (image.width, image.height)) heatmap = np.uint8(255 * heatmap) heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET) # Converteer PIL image naar numpy array image_np = np.array(image.convert('RGB')) superimposed_img = cv2.addWeighted(image_np, alpha, heatmap, 1 - alpha, 0) return Image.fromarray(superimposed_img) def visualize_explanations(self, image_path, transform): """Complete visualisatie pipeline""" # Laad en transformeer afbeelding image = Image.open(image_path).convert('RGB') input_tensor = transform(image).unsqueeze(0).to(self.device) # Voorspelling with torch.no_grad(): output = self.model(input_tensor) probs = torch.softmax(output, dim=1) predicted_class = output.argmax(dim=1).item() confidence = probs[0, predicted_class].item() # Genereer verschillende verklaringen saliency_map, _ = self.generate_saliency_map(input_tensor, predicted_class) grad_cam, _ = self.generate_grad_cam(input_tensor, self.model.layer4[2].conv3, predicted_class) ig, _ = self.generate_integrated_gradients(input_tensor, predicted_class) # Visualisatie fig, axes = plt.subplots(2, 3, figsize=(15, 10)) # Originele afbeelding axes[0, 0].imshow(image) axes[0, 0].set_title(f'Origineel\nPredicted: {predicted_class} ({confidence:.3f})') axes[0, 0].axis('off') # Saliency Map viz.visualize_image_attr(saliency_map[0].cpu().permute(1, 2, 0).numpy(), original_image=np.array(image), method='blended_heat_map', plt_fig_axis=(fig, axes[0, 1]), sign='absolute_value', show_colorbar=True) axes[0, 1].set_title('Saliency Map') # Grad-CAM grad_cam_vis = self.overlay_heatmap(image, grad_cam) axes[0, 2].imshow(grad_cam_vis) axes[0, 2].set_title('Grad-CAM Overlay') axes[0, 2].axis('off') # Integrated Gradients viz.visualize_image_attr(ig[0].cpu().permute(1, 2, 0).numpy(), original_image=np.array(image), method='blended_heat_map', plt_fig_axis=(fig, axes[1, 0]), sign='absolute_value', show_colorbar=True) axes[1, 0].set_title('Integrated Gradients') # Feature Importance (laag activaties) if 'avgpool' in self.features: features = self.features['avgpool'].squeeze().cpu().numpy() axes[1, 1].barh(range(len(features[:20])), features[:20]) axes[1, 1].set_title('Top 20 Feature Activations') # Confidence scores classes = ['Geen Pneumonie', 'Pneumonie'] axes[1, 2].bar(classes, probs[0].cpu().numpy()) axes[1, 2].set_title('Class Confidence') axes[1, 2].set_ylim(0, 1) plt.tight_layout() return fig # Gebruiksvoorbeeld def main(): # Laad uw gefinetuned model model = models.resnet50(pretrained=False) num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, 2) # 2 classes voor pneumonie detectie # Laad uw getrainde weights model.load_state_dict(torch.load('path/to/your/model.pth')) # Transform voor inference transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # Initialiseer pipeline pipeline = AdvancedExplanationPipeline(model) # Genereer verklaringen voor een sample fig = pipeline.visualize_explanations('path/to/thorax_image.jpg', transform) plt.savefig('model_explanations.png', dpi=300, bbox_inches='tight') plt.show() if __name__ == '__main__': main() ``` **Installatievereisten:** ```bash pip install torch torchvision captum matplotlib opencv-python pillow ``` **Geavanceerde integratietechnieken:** 1. **Combinatie van methoden:** ```python def combined_analysis(self, input_tensor): # Combineer multiple explanation methods methods = { 'saliency': self.generate_saliency_map, 'grad_cam': lambda x: self.generate_grad_cam(x, self.model.layer4[2].conv3), 'integrated_grads': self.generate_integrated_gradients } results = {} for name, method in methods.items(): attr, target_class = method(input_tensor) results[name] = attr # Consensus analysis - gebieden waar alle methoden het eens zijn consensus_mask = self._compute_consensus(results) return results, consensus_mask ``` 2. **Quantitatieve evaluatie:** ```python def evaluate_explanations(self, dataloader): """Evalueer verklaringen op hele dataset""" metrics = {'consistency': [], 'stability': []} for images, labels in dataloader: explanations = self.generate_all_explanations(images) # Bereken consistentie tussen verschillende methoden consistency = self._calculate_consistency(explanations) metrics['consistency'].append(consistency) return metrics ``` **Best practices voor medische beeldanalyse:** 1. **Domeinspecifieke normalisatie:** ```python # Gebruik medisch-specifieke normalisatie medical_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.Grayscale(num_output_channels=3), # Converteer naar 3-kanaals transforms.ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) ]) ``` 2. **Uncertainty quantification:** ```python def uncertainty_estimation(self, input_tensor, n_samples=10): """Schat modelonzekerheid met Monte Carlo dropout""" self.model.train() # Zet dropout aan predictions = [] for _ in range(n_samples): with torch.no_grad(): output = self.model(input_tensor) predictions.append(torch.softmax(output, dim=1)) predictions = torch.stack(predictions) uncertainty = predictions.std(dim=0) return uncertainty ``` **Interpretatie van resultaten:** 1. **Saliency Maps**: Toon welke pixels het meest bijdragen aan de voorspelling 2. **Grad-CAM**: Identificeer anatomische regio's die het model gebruikt 3. **Integrated Gradients**: Meer robuuste attributie over meerdere baselines 4. **Feature Importance**: Begrijp welke hoog-niveau features doorslaggevend zijn Deze pipeline geeft u een compleet beeld van hoe uw model beslissingen neemt, essentieel voor medische toepassingen waar interpretatie even belangrijk is als accuratesse.