def guided_grad_cam(self,
numpy_img,
target_pspi,
file_name_to_export='test',
save=False):
# prep image for the network
prep_img = torch.from_numpy(
cv2.resize(numpy_img,
(200, 200))[None] / 255).float().unsqueeze_(0)
prep_img = prep_img.requires_grad_().cuda()
# Grad cam
# Generate cam mask
cam = generate_cam(self.pretrained_model, prep_img, target_pspi)
# Guided backprop
GBP = GuidedBackprop(self.pretrained_model)
# Get gradients
guided_grads = GBP.generate_gradients(prep_img, target_pspi)
# Guided Grad cam
cam_gb = guided_grad_cam(cam, guided_grads)
grayscale_cam_gb = convert_to_grayscale(cam_gb)
if save:
save_gradient_images(cam_gb, file_name_to_export + '_GGrad_Cam')
save_gradient_images(grayscale_cam_gb,
file_name_to_export + '_GGrad_Cam_gray')
return cam_gb, grayscale_cam_gb
def generate_one_image_smooth_gradient(model_name,
image_name,
target_class,
full_image_path,
pretrain=True):
if model_name == 'denseNet':
pretrained_model = models.densenet121(pretrained=pretrain)
elif model_name == "resNet": # res net
pretrained_model = models.resnet18(pretrained=pretrain)
original_image = Image.open(full_image_path).convert('RGB')
prep_img = customPreProcessing(original_image)
save_image_name = image_name + model_name + '_SM_pretrained'
# save_image_name = image_name + model_name + '_SM_randomWeights'
# Vanilla backprop
VBP = VanillaBackprop(pretrained_model, _type=model_name)
param_n = 50
param_sigma_multiplier = 4
smooth_grad = generate_smooth_grad(
VBP, # ^This parameter
prep_img,
target_class,
param_n,
param_sigma_multiplier)
# Save colored gradients
save_gradient_images(smooth_grad, save_image_name + '_colored')
# Convert to grayscale
grayscale_smooth_grad = convert_to_grayscale(smooth_grad)
# Save grayscale gradients
save_gradient_images(grayscale_smooth_grad, save_image_name)
print('Smooth grad completed')
def interpret_image(self, image, target_class, result_dir):
# Get gradients
guided_grads = self.algo.attribute(
image, target_class).detach().cpu().numpy()[0]
print(guided_grads.shape)
# Save colored gradients
save_gradient_images(guided_grads, result_dir + '_Guided_BP_color')
# Convert to grayscale
grayscale_guided_grads = convert_to_grayscale(
guided_grads * image.detach().numpy()[0])
# Save grayscale gradients
save_gradient_images(grayscale_guided_grads,
result_dir + '_Guided_BP_gray')
# Positive and negative saliency maps
pos_sal, neg_sal = get_positive_negative_saliency(guided_grads)
save_gradient_images(pos_sal, result_dir + '_pos_sal')
save_gradient_images(neg_sal, result_dir + '_neg_sal')
print('Guided backprop completed')
image_path = args.image_path
mask_path = args.mask_path
model_path = str(
Path(args.model_path).joinpath(
'model_{fold}.pt'.format(fold=args.fold)))
model_type = args.model_type
(original_image, prep_img, prep_mask, file_name_to_export,
pretrained_model, img_width,
img_height) = get_params(image_path, mask_path, model_path, model_type)
# Vanilla backprop
VBP = VanillaBackprop(pretrained_model)
# Generate gradients
vanilla_grads = VBP.generate_gradients(prep_img, prep_mask)
print(vanilla_grads.shape)
# Save colored gradients
# save_gradient_images(vanilla_grads, file_name_to_export + '_Vanilla_BP_color', img_width, img_height)
# Convert to grayscale
grayscale_vanilla_grads = convert_to_grayscale(vanilla_grads)
# Save grayscale gradients
save_gradient_images(grayscale_vanilla_grads,
file_name_to_export + '_Vanilla_BP_gray', img_width,
img_height)
print('Vanilla backprop completed')
save_gradient_images,
get_positive_negative_saliency)
from captum.attr import GuidedBackprop
from parkinsonsNet import Network
model = torch.load("/home/anasa2/pre_trained/parkinsonsNet-rest_mpower-rest.pth", map_location="cpu")
algo = GuidedBackprop(model)
# %%
import numpy as np
input = torch.randn(1, 3, 4000, requires_grad=True)
attribution = algo.attribute(input, target=0).detach().cpu().numpy()[0]
attribution = np.round(convert_to_grayscale(attribution* input.detach().numpy()[0]))
save_gradient_images(attribution, 'signal_color')
# %%
import pandas as pd
import numpy as np
import os
from torch.utils.data import Dataset, DataLoader
import math
import json
import time
from matplotlib.pylab import plt
%matplotlib inline
import itertools
class testMotionData(Dataset):
# Generate xbar images
xbar_list = self.generate_images_on_linear_path(input_image, steps)
# Initialize an iamge composed of zeros
integrated_grads = np.zeros(input_image.size())
for xbar_image in xbar_list:
# Generate gradients from xbar images
single_integrated_grad = self.generate_gradients(
xbar_image, target_class)
# Add rescaled grads from xbar images
integrated_grads = integrated_grads + single_integrated_grad / steps
# [0] to get rid of the first channel (1,3,224,224)
return integrated_grads[0]
if __name__ == '__main__':
# Get params
target_example = 0 # Snake
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_example_params(target_example)
# Vanilla backprop
IG = IntegratedGradients(pretrained_model)
# Generate gradients
integrated_grads = IG.generate_integrated_gradients(
prep_img, target_class, 100)
# Convert to grayscale
grayscale_integrated_grads = convert_to_grayscale(integrated_grads)
# Save grayscale gradients
save_gradient_images(grayscale_integrated_grads,
file_name_to_export + '_Integrated_G_gray')
print('Integrated gradients completed.')
if __name__ == '__main__':
# Get params
target_example = 0 # Snake
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_example_params(target_example)
VBP = VanillaBackprop(pretrained_model)
# GBP = GuidedBackprop(pretrained_model) # if you want to use GBP dont forget to
# change the parametre in generate_smooth_grad
param_n = 50
param_sigma_multiplier = 4
smooth_grad = generate_smooth_grad(
VBP, # ^This parameter
prep_img,
target_class,
param_n,
param_sigma_multiplier)
# Save colored gradients
save_gradient_images(smooth_grad,
file_name_to_export + '_SmoothGrad_color')
# Convert to grayscale
grayscale_smooth_grad = convert_to_grayscale(smooth_grad)
# Save grayscale gradients
save_gradient_images(grayscale_smooth_grad,
file_name_to_export + '_SmoothGrad_gray')
print('Smooth grad completed')
one_hot_output = torch.FloatTensor(1, model_output.size()[-1]).zero_()
one_hot_output[0][target_class] = 1
# Backward pass
model_output.backward(gradient=one_hot_output)
# Convert Pytorch variable to numpy array
# [0] to get rid of the first channel (1,3,224,224)
gradients_as_arr = self.gradients.data.numpy()[0]
return gradients_as_arr
if __name__ == '__main__':
target_example = 0 # Snake
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_params(target_example)
# Guided backprop
GBP = GuidedBackprop(pretrained_model)
# Get gradients
guided_grads = GBP.generate_gradients(prep_img, target_class)
# Save colored gradients
save_gradient_images(guided_grads, file_name_to_export + '_Guided_BP_color')
# Convert to grayscale
grayscale_guided_grads = convert_to_grayscale(guided_grads)
# Save grayscale gradients
save_gradient_images(grayscale_guided_grads, file_name_to_export + '_Guided_BP_gray')
# Positive and negative saliency maps
pos_sal, neg_sal = get_positive_negative_saliency(guided_grads)
save_gradient_images(pos_sal, file_name_to_export + '_pos_sal')
save_gradient_images(neg_sal, file_name_to_export + '_neg_sal')
print('Guided backprop completed')
guided_backprop_mask (np_arr):Guided backprop mask
"""
cam_gb = np.multiply(grad_cam_mask, guided_backprop_mask)
return cam_gb
if __name__ == '__main__':
# Get params
target_example = 0 # Snake
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_params(target_example)
# Grad cam
gcv2 = GradCam(pretrained_model, target_layer=11)
# Generate cam mask
cam = gcv2.generate_cam(prep_img, target_class)
print('Grad cam completed')
# Guided backprop
GBP = GuidedBackprop(pretrained_model)
# Get gradients
guided_grads = GBP.generate_gradients(prep_img, target_class)
print('Guided backpropagation completed')
# Guided Grad cam
cam_gb = guided_grad_cam(cam, guided_grads)
save_gradient_images(cam_gb, file_name_to_export + '_GGrad_Cam')
grayscale_cam_gb = convert_to_grayscale(cam_gb)
save_gradient_images(grayscale_cam_gb, file_name_to_export + '_GGrad_Cam_gray')
print('Guided grad cam completed')
model_output = self.model(self.input_image)
# Zero grads
self.model.zero_grad()
# Target for backprop
one_hot_output = torch.FloatTensor(1, model_output.size()[-1]).zero_()
one_hot_output[0][self.target_class] = 1
# Backward pass
model_output.backward(gradient=one_hot_output)
# Convert Pytorch variable to numpy array
# [0] to get rid of the first channel (1,3,224,224)
gradients_as_arr = self.gradients.data.numpy()[0]
return gradients_as_arr
if __name__ == '__main__':
# Get params
target_example = 0 # Snake
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_params(target_example)
# Vanilla backprop
VBP = VanillaBackprop(pretrained_model, prep_img, target_class)
# Generate gradients
vanilla_grads = VBP.generate_gradients()
# Save colored gradients
save_gradient_images(vanilla_grads, file_name_to_export + '_Vanilla_BP_color')
# Convert to grayscale
grayscale_vanilla_grads = convert_to_grayscale(vanilla_grads)
# Save grayscale gradients
save_gradient_images(grayscale_vanilla_grads, file_name_to_export + '_Vanilla_BP_gray')
print('Vanilla backprop completed')
"""
Created on Wed Jun 19 17:12:04 2019
@author: Utku Ozbulak - github.com/utkuozbulak
"""
from misc_functions import (get_example_params, convert_to_grayscale,
save_gradient_images)
from vanilla_backprop import VanillaBackprop
# from guided_backprop import GuidedBackprop # To use with guided backprop
# from integrated_gradients import IntegratedGradients # To use with integrated grads
if __name__ == '__main__':
# Get params
target_example = 0 # Snake
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_example_params(target_example)
# Vanilla backprop
VBP = VanillaBackprop(pretrained_model)
# Generate gradients
vanilla_grads = VBP.generate_gradients(prep_img, target_class)
# Make sure dimensions add up!
grad_times_image = vanilla_grads * prep_img.detach().numpy()[0]
# Convert to grayscale
grayscale_vanilla_grads = convert_to_grayscale(grad_times_image)
# Save grayscale gradients
save_gradient_images(
grayscale_vanilla_grads,
file_name_to_export + '_Vanilla_grad_times_image_gray')
print('Grad times image completed.')
for i, (input, target) in enumerate(val_loader):
image_index += 1
print("WORKING ON IMAGE {}".format(image_index))
input.requires_grad = True
prep_img = input
target_class = target.item()
# Generate gradients
# vanilla_grads = VBP.generate_gradients(prep_img, target_class)
guided_grads = GBP.generate_gradients(prep_img, target_class)
# Convert to grayscale
grayscale_guided_grads = convert_to_grayscale(guided_grads)
# Save grayscale gradients
save_gradient_images(grayscale_guided_grads,
"GRAD_{}".format(image_index))
# Unnormalize input image
input_copy = np.copy(input.detach().numpy())
input_copy = input_copy[0]
input_copy[0] = input_copy[0] * 0.229
input_copy[1] = input_copy[1] * 0.224
input_copy[2] = input_copy[2] * 0.225
input_copy[0] = input_copy[0] + 0.485
input_copy[1] = input_copy[1] + 0.456
input_copy[2] = input_copy[2] + 0.406
input_copy = np.rollaxis(input_copy, axis=2)
input_copy = np.rollaxis(input_copy, axis=2)
plt.imsave("./sample_images/IMAGE_{}.png".format(image_index),
input_copy)
# Average it out
smooth_grad = smooth_grad / param_n
return smooth_grad
if __name__ == '__main__':
# Get params
target_example = 0 # Snake
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_params(target_example)
VBP = VanillaBackprop(pretrained_model)
# GBP = GuidedBackprop(pretrained_model) # if you want to use GBP dont forget to
# change the parametre in generate_smooth_grad
param_n = 50
param_sigma_multiplier = 4
smooth_grad = generate_smooth_grad(VBP, # ^This parameter
prep_img,
target_class,
param_n,
param_sigma_multiplier)
# Save colored gradients
save_gradient_images(smooth_grad, file_name_to_export + '_SmoothGrad_color')
# Convert to grayscale
grayscale_smooth_grad = convert_to_grayscale(smooth_grad)
# Save grayscale gradients
save_gradient_images(grayscale_smooth_grad, file_name_to_export + '_SmoothGrad_gray')
print('Smooth grad completed')
cnn_layer = 14
filter_pos = 2
# for cnn_layer in range(10):
# for cnn_layer in range(10, 20):
if 0 == 0:
target_example = 2 # Spider
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_example_params(target_example)
# File export name
file_name_to_export = file_name_to_export + '_layer' + str(
cnn_layer) + '_filter' + str(filter_pos)
# Guided backprop
GBP = GuidedBackprop(pretrained_model)
# Get gradients
guided_grads = GBP.generate_gradients(prep_img, target_class,
cnn_layer, filter_pos)
# Save colored gradients
save_gradient_images(guided_grads,
file_name_to_export + '_Guided_BP_color')
# print(guided_grads.shape)
# Convert to grayscale
grayscale_guided_grads = convert_to_grayscale(guided_grads)
# Save grayscale gradients
# save_gradient_images(grayscale_guided_grads, file_name_to_export + '_Guided_BP_gray')
# Positive and negative saliency maps
# pos_sal, neg_sal = get_positive_negative_saliency(guided_grads)
# save_gradient_images(pos_sal, file_name_to_export + '_pos_sal')
# save_gradient_images(neg_sal, file_name_to_export + '_neg_sal')
# print('Layer Guided backprop completed')
image_index = 0
for i, (input, target) in enumerate(val_loader):
image_index += 1
print("WORKING ON IMAGE {}".format(image_index))
input.requires_grad = True
prep_img = input
target_class = target.item()
# Generate gradients
vanilla_grads = VBP.generate_gradients(prep_img, target_class)
# Convert to grayscale
grayscale_vanilla_grads = convert_to_grayscale(vanilla_grads)
# Save grayscale gradients
save_gradient_images(grayscale_vanilla_grads, "GRAD_{}".format(image_index))
# Unnormalize input image
input_copy = np.copy(input.detach().numpy())
input_copy = input_copy[0]
input_copy[0] = input_copy[0] * 0.229
input_copy[1] = input_copy[1] * 0.224
input_copy[2] = input_copy[2] * 0.225
input_copy[0] = input_copy[0] + 0.485
input_copy[1] = input_copy[1] + 0.456
input_copy[2] = input_copy[2] + 0.406
input_copy = np.rollaxis(input_copy, axis=2)
input_copy = np.rollaxis(input_copy, axis=2)
plt.imsave("./sample_images/IMAGE_{}.png".format(image_index), input_copy)
"""
cam_gb = np.multiply(grad_cam_mask, guided_backprop_mask)
return cam_gb
if __name__ == '__main__':
# Get params
target_example = 0 # Snake
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_example_params(target_example)
# Grad cam
# gcv2 = GradCam(pretrained_model, target_layer=11)
gcv2 = GradCam(pretrained_model, target_layer=7)
# Generate cam mask
cam = gcv2.generate_cam(prep_img, target_class)
print('Grad cam completed')
# Guided backprop
GBP = GuidedBackprop(pretrained_model)
# Get gradients
guided_grads = GBP.generate_gradients(prep_img, target_class)
print('Guided backpropagation completed')
# Guided Grad cam
cam_gb = guided_grad_cam(cam, guided_grads)
save_gradient_images(cam_gb, file_name_to_export + '_GGrad_Cam')
grayscale_cam_gb = convert_to_grayscale(cam_gb)
save_gradient_images(grayscale_cam_gb,
file_name_to_export + '_GGrad_Cam_gray')
print('Guided grad cam completed')
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_example_params(class_no,image_no,check_target_class)
# Grad cam
target_layer = 35
gcv2 = GradCam(pretrained_model, target_layer=target_layer)
# Generate cam mask
cam = gcv2.generate_cam(prep_img, target_class)
print('Grad cam completed')
# Guided backprop
GBP = GuidedBackprop(pretrained_model)
# Get gradients
guided_grads = GBP.generate_gradients(prep_img, target_class)
print('Guided backpropagation completed')
# Guided Grad cam
cam_gb = guided_grad_cam(cam, guided_grads)
save_gradient_images(
cam_gb, file_name_to_export + ",layer=" + str(target_layer) +
'_Guided_Grad_Cam')
grayscale_cam_gb = convert_to_grayscale(cam_gb)
save_gradient_images(
grayscale_cam_gb, file_name_to_export + ",layer=" + str(target_layer) +
'_Guided_Grad_Cam_gray')
save_gradient_images(
guided_grads, file_name_to_export + ",layer=" + str(target_layer) +
'_guided_grads ')
print('Guided grad cam completed')
one_hot_output[0][target_class] = 1
# Backward pass
model_output.backward(gradient=one_hot_output)
# Convert Pytorch variable to numpy array
# [0] to get rid of the first channel (1,3,224,224)
gradients_as_arr = self.gradients.data.numpy()[0]
return gradients_as_arr
if __name__ == '__main__':
target_example = 0 # Snake
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_example_params(target_example)
# Guided backprop
GBP = GuidedBackprop(pretrained_model)
# Get gradients
guided_grads = GBP.generate_gradients(prep_img, target_class)
# Save colored gradients
save_gradient_images(guided_grads, file_name_to_export + '_Guided_BP_color')
print("exported to: " + str(os.getcwd()))
# Convert to grayscale
grayscale_guided_grads = convert_to_grayscale(guided_grads)
# Save grayscale gradients
save_gradient_images(grayscale_guided_grads, file_name_to_export + '_Guided_BP_gray')
# Positive and negative saliency maps
pos_sal, neg_sal = get_positive_negative_saliency(guided_grads)
save_gradient_images(pos_sal, file_name_to_export + '_pos_sal')
save_gradient_images(neg_sal, file_name_to_export + '_neg_sal')
print('Guided backprop completed')
one_hot_output = torch.FloatTensor(1, model_output.size()[-1]).zero_()
one_hot_output[0][self.target_class] = 1
# Backward pass
model_output.backward(gradient=one_hot_output)
# Convert Pytorch variable to numpy array
# [0] to get rid of the first channel (1,3,224,224)
gradients_as_arr = self.gradients.data.numpy()[0]
return gradients_as_arr
if __name__ == '__main__':
# Get params
target_example = 0 # Snake
for target_example in range(1):
(original_image, prep_img, target_class, file_name_to_export, pretrained_model) =\
get_params(target_example)
# Vanilla backprop
VBP = VanillaBackprop(pretrained_model, prep_img, target_class)
# Generate gradients
vanilla_grads = VBP.generate_gradients()
# Save colored gradients
save_gradient_images(
vanilla_grads,
file_name_to_export + '_Vanilla_BP_color' + str(target_example))
# Convert to grayscale
grayscale_vanilla_grads = convert_to_grayscale(vanilla_grads)
# Save grayscale gradients
save_gradient_images(
grayscale_vanilla_grads,
file_name_to_export + '_Vanilla_BP_gray' + str(target_example))
print('Vanilla backprop completed')
