def guided_backprop(model, image, results_dir, file_name):
gbp = GuidedBackprop(model)
attributions = gbp.attribute(image)
attributions = attributions.squeeze()
attributions = attributions.numpy()
attributions = nib.Nifti1Image(attributions, affine=np.eye(4))
nib.save(attributions, results_dir + file_name + "-HM.nii")
class Explainer():
def __init__(self,model):
self.model=model
self.explain=GuidedBackprop(model)
def get_attribution_map(self,img,target=None):
if target is None:
target=torch.argmax(self.model(img),1)
attributions = self.explain.attribute(img, target=target)
return attributions
def compute_GBP(model,
dataloader,
num_state_inputs=54,
model_type="S",
no_pbar=False):
'''
Computes the Guided Backpropogation values - only used for models with state information.
right now only works for force only predictions - can be adapted for torques as well
'''
tqdm.write('Computing guided backprop...')
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
if torch.cuda.is_available():
tqdm.write("using GPU acceleration")
model = model.to(device, dtype=torch.float)
model.eval()
gbp_array = [np.empty((0, num_state_inputs)) for i in range(3)]
gbp_norm = [[] for i in range(3)]
gbp = GuidedBackprop(model)
for n in range(3):
with tqdm(total=len(dataloader), disable=no_pbar) as pbar:
for img, state, labels in dataloader:
state = state.to(device, dtype=torch.float)
if model_type != "S":
img = img.to(device, dtype=torch.float)
attributions = gbp.attribute((img, state), target=n)
gbp_array[n] = np.vstack(
(gbp_array[n], attributions[1].cpu().numpy()))
else:
attributions = gbp.attribute(state, target=n)
gbp_array[n] = np.vstack(
(gbp_array[n], attributions.cpu().numpy()))
pbar.update(1)
gbp_norm[n] = gbp_array[n] - np.min(gbp_array[n], axis=0)
gbp_norm[n] = gbp_norm[n] / np.reshape(np.sum(gbp_norm[n], axis=1),
(-1, 1))
return gbp_norm
class ImageInterpreter(object):
def __init__(self, model, dataset=None, gpu=-1):
self.model = model
# Put model in evaluation mode
self.model.eval()
# data_loader = DataLoader(dataset,batch_size=len(dataset))
# itr = iter(data_loader)
# X,y = next(itr)
# if len(X.shape) != 4:
# raise IllegalDataDeminsionException("Expected data to have deminsions 4 but got deminsion ",len(X.shape))
if gpu == -1:
device = torch.device('cpu')
else:
device = torch.device('cuda:' + str(gpu))
self.algo = GuidedBackprop(model)
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')
class SignalInterpreter(object):
"""Summary of class here.
Longer class information....
Longer class information....
Attributes:
likes_spam: A boolean indicating if we like SPAM or not.
eggs: An integer count of the eggs we have laid.
"""
def __init__(self, model, X, y, gpu, channel_labels):
"""
Args:
model:
dataset:
gpu:
channel_labels:
"""
# data_loader = DataLoader(dataset, batch_size=len(dataset))
# itr = iter(data_loader)
self.X, self.y = X, y
self.algo = GuidedBackprop(model)
self.model = model.eval()
if len(self.X.shape) != 3:
raise IllegalDataDimensionException("Expected data to have dimensions 3 but got dimension ",
str(len(self.X.shape)))
if len(self.X.shape) != len(channel_labels):
raise IllegalDataDimensionException("Expected channel_labels to contain ", str(len(self.X.shape)),
" labels but got ", str(len(channel_labels)), " labels instead.")
self.channel_labels = channel_labels
if gpu == -1:
self.device = torch.device('cpu')
else:
self.device = torch.device('cuda:' + str(gpu))
model.to(self.device)
counter = 0
self.modules = {}
for top, module in model.named_children():
if type(module) == torch.nn.Sequential:
self.modules.update({"" + top: module})
counter += 1
print(f"Total Interpretable layers: {counter}")
self.X.to(self.device)
layer_map = {0: self.X.flatten(start_dim=1)}
index = 1
output = self.X
for i in self.modules:
layer = self.modules[i]
layer.eval().to(self.device)
output = layer(output)
layer_map.update({index: output.flatten(start_dim=1)})
index += 1
assert counter == len(layer_map) - 1
print("Intermediate Forward Pass Through " + str(len(layer_map) - 1) + " Layers")
print("Generating PCA...")
self.pca_layer_result = []
self.pca = PCA(n_components=3)
self.pca_result = self.pca.fit_transform(layer_map[len(layer_map) - 1].detach().numpy())
for i in range(len(channel_labels)):
self.pca_layer_result.append(self.pca_result[:,i])
print("Generation Complete")
def interpret_signal(self, signal):
"""
Args:
signal:
Returns:
"""
output = signal.unsqueeze(0).to(self.device)
for i in self.modules:
layer = self.modules[i]
layer.eval().to(self.device)
output = layer(output)
output = torch.flatten(output,start_dim=1)
reduced_signal = self.pca.transform(output.detach())
example_index = self.__closest_point(reduced_signal)
example_signal = self.X[example_index]
signal_attribution = self.algo.attribute(signal.unsqueeze(0), target=0).detach().cpu().numpy()[0]
example_signal_attribution = self.algo.attribute(example_signal.unsqueeze(0), target=0).detach().cpu().numpy()[0]
signal_attribution = convert_to_grayscale(signal_attribution* signal.detach().numpy())
example_signal_attribution = convert_to_grayscale(example_signal_attribution* example_signal.detach().numpy())
# save_gradient_images(grayscale_guided_grads, result_dir + '_Guided_BP_gray')
return self.__plot_signals([signal, example_signal], [signal_attribution, example_signal_attribution]
, int(torch.round(torch.sigmoid(self.model(signal.unsqueeze(0).to(self.device)))).item())
, self.y[example_index].item(), self.channel_labels)
def __closest_point(self, point):
"""
Args:
point:
points:
Returns:
"""
points = np.asarray(self.pca_result)
deltas = points - point
dist_2 = np.einsum('ij,ij->i', deltas, deltas)
return np.argmin(dist_2)
def __plot_signals(self, signals, attribution, output_test, output_training, channel_labels):
"""
Args:
signals:
channel_labels:
Returns:
object:
"""
colors = list(CSS4_COLORS.keys())
i = 0
fig = plt.figure(figsize=(40, 40))
ax = fig.add_subplot(4, 4, i + 1)
i += 1
color_index = 0
ax.set_title("Interpreted Signal with Output Class "+str(output_test))
# for channel, label in zip(signals[0], channel_labels):
ax.plot(sum(signals[0]).detach().cpu())
ax.plot(sum(attribution[0]), color="r")
# color_index += 1
# plt.legend()
ax = fig.add_subplot(4, 4, i + 1)
i += 1
color_index = 0
ax.set_title("Example Signal with Output Class "+str(output_training))
# for channel, label in zip(signals[1], channel_labels):
# ax.plot(channel, color=colors[color_index + 20], label=label)
# color_index += 1
ax.plot(sum(signals[1]))
ax.plot(sum(attribution[1]), color="r")
# plt.legend()
plt.show()
return plt
from misc_functions import (get_example_params,
convert_to_grayscale,
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
num_workers=num_workers,
chunkload=chunkload,
include=(0, 1, 0),
ages=ages,
)
model_filepath = save_path + f"{net_name}.pt"
logging.info(net.name)
_, net_state, _ = load_checkpoint(model_filepath)
net.load_state_dict(net_state)
gbp = GuidedBackprop(net)
gbps = []
targets = []
for i, batch in enumerate(validloader):
X, y = batch
X = X.view(-1, *net.input_size).to(device)
y = y.to(torch.int64).to(device)
for trial, target in zip(X, y):
gbps.append(
gbp.attribute(torch.unsqueeze(trial.float(), 0),
target).cpu())
targets.append(target.cpu().numpy())
gbps = torch.cat(gbps).numpy()
savemat(save_path + f"gbp_{net_name}.mat", {
"gbp": gbps,
"targets": targets
})
def get_attribution(real_img,
fake_img,
real_class,
fake_class,
net_module,
checkpoint_path,
input_shape,
channels,
methods=["ig", "grads", "gc", "ggc", "dl", "ingrad", "random", "residual"],
output_classes=6,
downsample_factors=[(2,2), (2,2), (2,2), (2,2)]):
imgs = [image_to_tensor(normalize_image(real_img).astype(np.float32)),
image_to_tensor(normalize_image(fake_img).astype(np.float32))]
classes = [real_class, fake_class]
net = init_network(checkpoint_path, input_shape, net_module, channels, output_classes=output_classes,eval_net=True, require_grad=False,
downsample_factors=downsample_factors)
attrs = []
attrs_names = []
if "residual" in methods:
res = np.abs(real_img - fake_img)
res = res - np.min(res)
attrs.append(torch.tensor(res/np.max(res)))
attrs_names.append("residual")
if "random" in methods:
rand = np.abs(np.random.randn(*np.shape(real_img)))
rand = np.abs(scipy.ndimage.filters.gaussian_filter(rand, 4))
rand = rand - np.min(rand)
rand = rand/np.max(np.abs(rand))
attrs.append(torch.tensor(rand))
attrs_names.append("random")
if "gc" in methods:
net.zero_grad()
last_conv_layer = [(name,module) for name, module in net.named_modules() if type(module) == torch.nn.Conv2d][-1]
layer_name = last_conv_layer[0]
layer = last_conv_layer[1]
layer_gc = LayerGradCam(net, layer)
gc_real = layer_gc.attribute(imgs[0], target=classes[0])
gc_fake = layer_gc.attribute(imgs[1], target=classes[1])
gc_real = project_layer_activations_to_input_rescale(gc_real.cpu().detach().numpy(), (input_shape[0], input_shape[1]))
gc_fake = project_layer_activations_to_input_rescale(gc_fake.cpu().detach().numpy(), (input_shape[0], input_shape[1]))
attrs.append(torch.tensor(gc_real[0,0,:,:]))
attrs_names.append("gc_real")
attrs.append(torch.tensor(gc_fake[0,0,:,:]))
attrs_names.append("gc_fake")
# SCAM
gc_diff_0, gc_diff_1 = get_sgc(real_img, fake_img, real_class,
fake_class, net_module, checkpoint_path,
input_shape, channels, None, output_classes=output_classes,
downsample_factors=downsample_factors)
attrs.append(gc_diff_0)
attrs_names.append("gc_diff_0")
attrs.append(gc_diff_1)
attrs_names.append("gc_diff_1")
if "ggc" in methods:
net.zero_grad()
last_conv = [module for module in net.modules() if type(module) == torch.nn.Conv2d][-1]
guided_gc = GuidedGradCam(net, last_conv)
ggc_real = guided_gc.attribute(imgs[0], target=classes[0])
ggc_fake = guided_gc.attribute(imgs[1], target=classes[1])
attrs.append(ggc_real[0,0,:,:])
attrs_names.append("ggc_real")
attrs.append(ggc_fake[0,0,:,:])
attrs_names.append("ggc_fake")
net.zero_grad()
gbp = GuidedBackprop(net)
gbp_real = gbp.attribute(imgs[0], target=classes[0])
gbp_fake = gbp.attribute(imgs[1], target=classes[1])
attrs.append(gbp_real[0,0,:,:])
attrs_names.append("gbp_real")
attrs.append(gbp_fake[0,0,:,:])
attrs_names.append("gbp_fake")
ggc_diff_0 = gbp_real[0,0,:,:] * gc_diff_0
ggc_diff_1 = gbp_fake[0,0,:,:] * gc_diff_1
attrs.append(ggc_diff_0)
attrs_names.append("ggc_diff_0")
attrs.append(ggc_diff_1)
attrs_names.append("ggc_diff_1")
# IG
if "ig" in methods:
baseline = image_to_tensor(np.zeros(input_shape, dtype=np.float32))
net.zero_grad()
ig = IntegratedGradients(net)
ig_real, delta_real = ig.attribute(imgs[0], baseline, target=classes[0], return_convergence_delta=True)
ig_fake, delta_fake = ig.attribute(imgs[1], baseline, target=classes[1], return_convergence_delta=True)
ig_diff_0, delta_diff = ig.attribute(imgs[0], imgs[1], target=classes[0], return_convergence_delta=True)
ig_diff_1, delta_diff = ig.attribute(imgs[1], imgs[0], target=classes[1], return_convergence_delta=True)
attrs.append(ig_real[0,0,:,:])
attrs_names.append("ig_real")
attrs.append(ig_fake[0,0,:,:])
attrs_names.append("ig_fake")
attrs.append(ig_diff_0[0,0,:,:])
attrs_names.append("ig_diff_0")
attrs.append(ig_diff_1[0,0,:,:])
attrs_names.append("ig_diff_1")
# DL
if "dl" in methods:
net.zero_grad()
dl = DeepLift(net)
dl_real = dl.attribute(imgs[0], target=classes[0])
dl_fake = dl.attribute(imgs[1], target=classes[1])
dl_diff_0 = dl.attribute(imgs[0], baselines=imgs[1], target=classes[0])
dl_diff_1 = dl.attribute(imgs[1], baselines=imgs[0], target=classes[1])
attrs.append(dl_real[0,0,:,:])
attrs_names.append("dl_real")
attrs.append(dl_fake[0,0,:,:])
attrs_names.append("dl_fake")
attrs.append(dl_diff_0[0,0,:,:])
attrs_names.append("dl_diff_0")
attrs.append(dl_diff_1[0,0,:,:])
attrs_names.append("dl_diff_1")
# INGRAD
if "ingrad" in methods:
net.zero_grad()
saliency = Saliency(net)
grads_real = saliency.attribute(imgs[0],
target=classes[0])
grads_fake = saliency.attribute(imgs[1],
target=classes[1])
attrs.append(grads_real[0,0,:,:])
attrs_names.append("grads_real")
attrs.append(grads_fake[0,0,:,:])
attrs_names.append("grads_fake")
net.zero_grad()
input_x_gradient = InputXGradient(net)
ingrad_real = input_x_gradient.attribute(imgs[0], target=classes[0])
ingrad_fake = input_x_gradient.attribute(imgs[1], target=classes[1])
ingrad_diff_0 = grads_fake * (imgs[0] - imgs[1])
ingrad_diff_1 = grads_real * (imgs[1] - imgs[0])
attrs.append(torch.abs(ingrad_real[0,0,:,:]))
attrs_names.append("ingrad_real")
attrs.append(torch.abs(ingrad_fake[0,0,:,:]))
attrs_names.append("ingrad_fake")
attrs.append(torch.abs(ingrad_diff_0[0,0,:,:]))
attrs_names.append("ingrad_diff_0")
attrs.append(torch.abs(ingrad_diff_1[0,0,:,:]))
attrs_names.append("ingrad_diff_1")
attrs = [a.detach().cpu().numpy() for a in attrs]
attrs_norm = [a/np.max(np.abs(a)) for a in attrs]
return attrs_norm, attrs_names