Convolutional Neural Network Visualizations

This repository contains a number of convolutional neural network visualization techniques implemented in PyTorch.

Note: I removed cv2 dependencies and moved the repository towards PIL. A few things might be broken (although I tested all methods), I would appreciate if you could create an issue if something does not work.

Note: The code in this repository was tested with torch version 0.4.1 and some of the functions may not work as intended in later versions. Although it shouldn't be too much of an effort to make it work, I have no plans at the moment to make the code in this repository compatible with the latest version because I'm still using 0.4.1.

Implemented Techniques

• Gradient visualization with vanilla backpropagation
• Gradient visualization with guided backpropagation [1]
• Gradient visualization with saliency maps [4]
• Gradient-weighted class activation mapping [3] (Generalization of [2])
• Guided, gradient-weighted class activation mapping [3]
• Score-weighted class activation mapping [15] (Gradient-free generalization of [2])
• Element-wise gradient-weighted class activation mapping [16]
• Smooth grad [8]
• CNN filter visualization [9]
• Inverted image representations [5]
• Deep dream [10]
• Class specific image generation [4] [14]
• Grad times image [12]
• Integrated gradients [13]
• Layerwise relevance propagation [17]

General Information

Depending on the technique, the code uses pretrained AlexNet or VGG from the model zoo. Some of the code also assumes that the layers in the model are separated into two sections; features, which contains the convolutional layers and classifier, that contains the fully connected layer (after flatting out convolutions). If you want to port this code to use it on your model that does not have such separation, you just need to do some editing on parts where it calls model.features and model.classifier.

Every technique has its own python file (e.g. gradcam.py) which I hope will make things easier to understand. misc_functions.py contains functions like image processing and image recreation which is shared by the implemented techniques.

All images are pre-processed with mean and std of the ImageNet dataset before being fed to the model. None of the code uses GPU as these operations are quite fast for a single image (except for deep dream because of the example image that is used for it is huge). You can make use of gpu with very little effort. The example pictures below include numbers in the brackets after the description, like Mastiff (243), this number represents the class id in the ImageNet dataset.

I tried to comment on the code as much as possible, if you have any issues understanding it or porting it, don't hesitate to send an email or create an issue.

Below, are some sample results for each operation.

Gradient Visualization

	Target class: King Snake (56)	Target class: Mastiff (243)	Target class: Spider (72)
Original Image
Colored Vanilla Backpropagation
Vanilla Backpropagation Saliency
Colored Guided Backpropagation (GB)
Guided Backpropagation Saliency (GB)
Guided Backpropagation Negative Saliency (GB)
Guided Backpropagation Positive Saliency (GB)
Gradient-weighted Class Activation Map (Grad-CAM)
Gradient-weighted Class Activation Heatmap (Grad-CAM)
Gradient-weighted Class Activation Heatmap on Image (Grad-CAM)
Score-weighted Class Activation Map (Score-CAM)
Score-weighted Class Activation Heatmap (Score-CAM)
Score-weighted Class Activation Heatmap on Image (Score-CAM)
Colored Guided Gradient-weighted Class Activation Map (Guided-Grad-CAM)
Guided Gradient-weighted Class Activation Map Saliency (Guided-Grad-CAM)
Integrated Gradients (without image multiplication)
Layerwise Relevance (LRP) - Layer 7