def visualize(sess, images_ph, im, y, prediction_class, neuron_selector,
base_name):
import saliency
graph = tf.get_default_graph()
# Construct the saliency object. This doesn't yet compute the saliency mask, it just sets up the necessary ops.
gradient_saliency = saliency.GradientSaliency(graph, sess, y, images_ph)
guided_backprop = saliency.GuidedBackprop(graph, sess, y, images_ph)
algo = guided_backprop
# Compute the vanilla mask and the smoothed mask.
for i, image in enumerate(im):
prediction_class = 1 #np.argmax(prediction_class[i])
vanilla_mask_3d = algo.GetMask(
image, feed_dict={neuron_selector: prediction_class})
#smoothgrad_mask_3d = algo.GetSmoothedMask(im, feed_dict = {neuron_selector: prediction_class})
# Call the visualization methods to convert the 3D tensors to 2D grayscale.
vanilla_mask_grayscale = saliency.VisualizeImageGrayscale(
vanilla_mask_3d)
#smoothgrad_mask_grayscale = saliency.VisualizeImageGrayscale(smoothgrad_mask_3d)
vanilla_mask_grayscale = ((vanilla_mask_grayscale + 1) * 127.5).astype(
np.uint8)
#smoothgrad_mask_grayscale = ((smoothgrad_mask_grayscale + 1) * 127.5).astype(np.uint8)
result = Image.fromarray(vanilla_mask_grayscale, mode='L')
#smoothed_result = Image.fromarray(smoothgrad_mask_grayscale, mode='L')
#print 'sal name', base_name[i]
print 'sal_image_dest_dir', sal_image_dest_dir
sal_name = sal_image_dest_dir + str(base_name[i]).replace(
'.jpg', '_sal.jpg')
print 'saving {} ...'.format(sal_name)
result.save(sal_name)
def get_saliency_image(graph, sess, y, image, saliency_method):
"""generates saliency image.
Args:
graph: tensor flow graph.
sess: the current session.
y: the pre-softmax activation we want to assess attribution with respect to.
image: float32 image tensor with size [1, None, None].
saliency_method: string indicating saliency map type to generate.
Returns:
a saliency map and a smoothed saliency map.
Raises:
ValueError: if the saliency_method string does not match any included method
"""
if saliency_method == 'integrated_gradients':
integrated_placeholder = saliency.IntegratedGradients(graph, sess, y, image)
return integrated_placeholder
elif saliency_method == 'gradient':
gradient_placeholder = saliency.GradientSaliency(graph, sess, y, image)
return gradient_placeholder
elif saliency_method == 'guided_backprop':
gb_placeholder = saliency.GuidedBackprop(graph, sess, y, image)
return gb_placeholder
else:
raise ValueError('No saliency method method matched. Verification of'
'input needed')
def get_saliency_constructors(model_graph,
model_session,
logit_tensor,
input_tensor,
gradcam=False,
conv_layer_gradcam=None):
"""Initialize mask functions in saliency package.
Args:
model_graph: tf graph of the model.
model_session: tf session with trained model loaded.
logit_tensor: tensor corresponding to the model logit output.
input_tensor: tensor coresponding to the input data.
gradcam: boolean to indicate whether to include gradcam.
conv_layer_gradcam: tensor corresponding to activations
from a conv layer, from the trained model.
Authors recommend last layer.
Returns:
saliency_constructor: dictionary (name of method, and value is
function to each saliency method.
neuron_selector: tensor of specific output to explain.
"""
assert (type(tf.Graph()) == type(model_graph)),\
("Model graph should be of type {}".format(type(tf.Graph())))
if gradcam and conv_layer_gradcam is None:
raise ValueError("If gradcam is True, then conv_layer_gradcam"
"is be provided.")
with model_graph.as_default():
with tf.name_scope("saliency"):
neuron_selector = tf.placeholder(tf.int32)
y_salient = logit_tensor[neuron_selector]
gradient_saliency = saliency.GradientSaliency(model_graph, model_session,
y_salient, input_tensor)
guided_backprop = saliency.GuidedBackprop(model_graph, model_session,
y_salient, input_tensor)
integrated_gradients = saliency.IntegratedGradients(
model_graph, model_session, y_salient, input_tensor)
saliency_constructor = {
'vng': gradient_saliency,
'gbp': guided_backprop,
'ig': integrated_gradients
}
if gradcam:
gradcam = saliency.GradCam(model_graph, model_session, y_salient,
input_tensor, conv_layer_gradcam)
saliency_constructor['gc'] = gradcam
return saliency_constructor, neuron_selector
def Guided_Backprop_SmoothGrad(graph, sess, y, images):
print('Guided_Backprop_SmoothGrad')
guided_backprop = saliency.GuidedBackprop(graph, sess, y, images)
# Compute the vanilla mask and the smoothed mask.
vanilla_guided_backprop_mask_3d = guided_backprop.GetMask(
im, feed_dict={neuron_selector: prediction_class})
smoothgrad_guided_backprop_mask_3d = guided_backprop.GetSmoothedMask(
im, feed_dict={neuron_selector: prediction_class})
# Call the visualization methods to convert the 3D tensors to 2D grayscale.
vanilla_mask_grayscale = saliency.VisualizeImageGrayscale(
vanilla_guided_backprop_mask_3d)
smoothgrad_mask_grayscale = saliency.VisualizeImageGrayscale(
smoothgrad_guided_backprop_mask_3d)
image_grad.append(vanilla_mask_grayscale)
image_grad.append(smoothgrad_mask_grayscale)
def build_i3d_model(video_tensor):
# model_name = "/home/ar/Experiment/ucf-101/rgb_backup01/models/rgb_scratch_10000_6_64_0.0001_decay/i3d_ucf_model-19999" # Note: I3D trained model
model_name = "./models/rgb_imagenet_10000_6_64_0.0001_decay/i3d_ucf_model-9999"
print("load model succeed")
graph = tf.Graph()
with graph.as_default():
images_placeholder = tf.placeholder(tf.float32, [FLAGS.batch_size, FLAGS.n_frames, FLAGS.crop_size, FLAGS.crop_size, FLAGS.rgb_channels])
#is_training = tf.placeholder(tf.bool)
with tf.variable_scope('RGB'):
logits, _ = InceptionI3d(
num_classes=FLAGS.classics,
spatial_squeeze=True,
final_endpoint='Logits',
name='inception_i3d'
)(images_placeholder, is_training=False)
# Create a saver for writing training checkpoints
saver = tf.train.Saver()
init = tf.global_variables_initializer()
# Create a session for running Ops on the Graph
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
sess.run(init)
# Restore trained model
saver.restore(sess, model_name)
neuron_selector = tf.placeholder(tf.int32)
y = logits[0][neuron_selector]
prediction = tf.argmax(logits, 1)
out_feature = sess.run(logits,
feed_dict={images_placeholder: video_tensor})
prediction_class = sess.run(prediction,
feed_dict={images_placeholder: video_tensor})[0]
#print(prediction_class)
###############################################################################################
#gradient_saliency = saliency.GradientSaliency(graph, sess, y, images_placeholder)
# Compute the vanilla mask and the smoothed mask.
#vanilla_mask_3d = gradient_saliency.GetMask(video_tensor[0], feed_dict = {neuron_selector: prediction_class})
#print(vanilla_mask_3d.shape)
#smoothgrad_mask_3d = gradient_saliency.GetSmoothedMask(video_tensor[0], feed_dict = {neuron_selector: prediction_class})
#vanilla_mask_grayscale = saliency.VisualizeImageGrayscale(vanilla_mask_3d)
#print(vanilla_mask_grayscale.shape)
#smoothgrad_mask_grayscale = saliency.VisualizeImageGrayscale(smoothgrad_mask_3d)
###############################################################################################
guided_backprop = saliency.GuidedBackprop(graph, sess, y, images_placeholder)
# Compute the vanilla mask and the smoothed mask.
vanilla_guided_backprop_mask_3d = guided_backprop.GetMask(video_tensor[0], feed_dict = {neuron_selector: prediction_class})
smoothgrad_guided_backprop_mask_3d = guided_backprop.GetSmoothedMask(video_tensor[0], feed_dict = {neuron_selector: prediction_class})
vanilla_mask_grayscale = saliency.VisualizeImageGrayscale(vanilla_guided_backprop_mask_3d)
smoothgrad_mask_grayscale = saliency.VisualizeImageGrayscale(smoothgrad_guided_backprop_mask_3d)
###############################################################################################
return vanilla_mask_grayscale, smoothgrad_mask_grayscale
num_classes=1001)
# Restore the checkpoint
sess = tf.Session(graph=graph)
saver = tf.train.Saver()
saver.restore(sess, ckpt_file)
# Construct the scalar neuron tensor.
logits = graph.get_tensor_by_name('InceptionV3/Logits/SpatialSqueeze:0')
neuron_selector = tf.placeholder(tf.int32)
y = logits[0][neuron_selector]
# Construct tensor for predictions.
prediction = tf.argmax(logits, 1)
guided_backprop = saliency.GuidedBackprop(graph, sess, y, images)
def guided_vanilla(image):
image = image / 127.5 - 1.0
prediction_class = sess.run(prediction, feed_dict={images: [image]})[0]
vanilla_guided_backprop_mask_3d = guided_backprop.GetMask(
image, feed_dict={neuron_selector: prediction_class})
vanilla_mask_grayscale = saliency.VisualizeImageGrayscale(
vanilla_guided_backprop_mask_3d)
return vanilla_mask_grayscale.tolist()
# Download human-readable labels for ImageNet.
inception_net = tf.keras.applications.InceptionV3() # load the model
ix = int(args.filename[-6])
else:
ix = 10 + int(args.filename[-6])
cnt = 0
for j, imgid in enumerate(x_test[int(args.start):int(args.end)]):
i = j + int(args.start)
if y_test[i] == 1:
img = LoadImage(root_dir + 'train/' + imgid + '.png')
bb_coords = LoadImage2(root_dir + 'mask/' + imgid + '.png')
l = sess.run(logits, feed_dict={inp: [img]})[0]
prediction_class = sess.run(prediction, feed_dict={inp: [img]})[0]
gbp = saliency.GuidedBackprop(sess.graph, sess, y, inp)
gbp_mask = gbp.GetMask(img,
feed_dict={neuron_selector: prediction_class})
gbp_mask = saliency.VisualizeImageGrayscale(gbp_mask)
scores['gbp'].append(
saliency_ttest(gbp_mask, bb_coords, prediction_class))
gradient_saliency = saliency.GradientSaliency(sess.graph, sess, y, inp)
vanilla_mask_3d = gradient_saliency.GetMask(
np.reshape(img, (320, 320, 3)),
feed_dict={neuron_selector: prediction_class})
smoothgrad_mask_3d = gradient_saliency.GetSmoothedMask(
np.reshape(img, (320, 320, 3)),
feed_dict={neuron_selector: prediction_class})
smoothgrad_mask_grayscale = saliency.VisualizeImageGrayscale(
smoothgrad_mask_3d)
def compute_and_save_attr(model, data, indices, num_threads):
"""Given the name of a model and a set of data, select a set of images based on provided indices, and compute and save their saliency maps and object attributions."""
base_dir = os.getcwd()
data_dir = os.path.join(base_dir, 'data', data, 'val')
model_dir = os.path.join(base_dir, 'models', model)
sal_output_dir = os.path.join(base_dir, SAL_DIR, model + '-' + data)
attr_output_dir = os.path.join(base_dir, ATTR_DIR, model + '-' + data)
if not tf.gfile.Exists(sal_output_dir):
tf.gfile.MakeDirs(sal_output_dir)
if not tf.gfile.Exists(attr_output_dir):
tf.gfile.MakeDirs(attr_output_dir)
img_names = [sorted(tf.gfile.ListDirectory(data_dir))[i] for i in indices]
img_paths = [os.path.join(data_dir, img_name) for img_name in img_names]
imgs = load_imgs(img_paths, num_threads)
input_name = 'input_tensor:0'
logit_name = 'resnet_model/final_dense:0'
conv_name = 'resnet_model/block_layer4:0'
with tf.Session(graph=tf.Graph()) as sess:
tf.saved_model.loader.load(sess, ['serve'], model_dir)
graph = tf.get_default_graph()
input_tensor = graph.get_tensor_by_name(input_name)
logit_tensor = graph.get_tensor_by_name(logit_name)
neuron_selector = tf.placeholder(tf.int32)
y = logit_tensor[:, neuron_selector]
pred_tensor = tf.argmax(logit_tensor, 1)
vg = saliency.GradientSaliency(graph, sess, y, input_tensor)
gb = saliency.GuidedBackprop(graph, sess, y, input_tensor)
ig = saliency.IntegratedGradients(graph, sess, y, input_tensor)
gc = saliency.GradCam(graph, sess, y, input_tensor,
graph.get_tensor_by_name(conv_name))
def single_map(img, img_name):
pred = sess.run(pred_tensor, feed_dict={input_tensor: [img]})[0]
vg_mask = vg.GetMask(img, feed_dict={neuron_selector: pred})
# *s is SmoothGrad
vgs_mask = vg.GetSmoothedMask(img,
feed_dict={neuron_selector: pred})
gb_mask = gb.GetMask(img, feed_dict={neuron_selector: pred})
gbs_mask = gb.GetSmoothedMask(img,
feed_dict={neuron_selector: pred})
baseline = np.zeros(img.shape) - np.expand_dims(
np.expand_dims(_CHANNEL_MEANS, 0), 0)
ig_mask = ig.GetMask(img,
feed_dict={neuron_selector: pred},
x_baseline=baseline)
igs_mask = ig.GetSmoothedMask(img,
feed_dict={neuron_selector: pred},
x_baseline=baseline)
gc_mask = gc.GetMask(img, feed_dict={neuron_selector: pred})
gcs_mask = gc.GetSmoothedMask(img,
feed_dict={neuron_selector: pred})
# gbgc is guided GradCam
gbgc_mask = gb_mask * gc_mask
gbgcs_mask = gbs_mask * gcs_mask
# Also include gradient x input
masks = np.array([
vg_mask, vgs_mask, gb_mask, gbs_mask, ig_mask, igs_mask,
gc_mask, gcs_mask, gbgc_mask, gbgcs_mask, vg_mask * img,
vgs_mask * img
])
return masks, pred
sal_maps = []
preds = []
for img, img_name in zip(imgs, img_names):
sal_path = tf.gfile.Glob(
os.path.join(sal_output_dir, img_name[:-4] + '*'))
if len(sal_path) > 0:
sal_maps.append(np.load(tf.gfile.GFile(sal_path[0], 'rb')))
preds.append(sal_path[0].split('_')[-1])
tf.logging.info(
'Loaded saliency maps for {}.'.format(img_name))
else:
masks, pred = single_map(img, img_name)
sal_maps.append(masks)
preds.append(pred)
out_path = os.path.join(sal_output_dir,
img_name[:-4] + '_' + str(pred))
np.save(tf.gfile.GFile(out_path, 'w'), masks)
tf.logging.info('Saved saliency maps for {}.'.format(img_name))
# Locate the objects, convert 3D saliency maps to 2D, and compute
# the attributions of the object segments by averaging over the
# per-pixel attributions of the objects.
loc_fpath = os.path.join(base_dir, 'data', data, 'val_loc.txt')
lines = [tf.gfile.Open(loc_fpath).readlines()[i] for i in indices]
locs = np.array([[
int(int(l) * float(RESNET_SHAPE[0]) / IMG_SHAPE[0])
for l in line.rstrip('\n').split(' ')[-1].split(',')
] for line in lines])
pool = multiprocessing.Pool(num_threads)
maps_3d = np.array(sal_maps).reshape(-1, RESNET_SHAPE[0], RESNET_SHAPE[1],
3)
maps_2d = np.array(pool.map(visualize_pos_attr, maps_3d))
maps_2d = maps_2d.reshape(len(indices),
int(maps_2d.shape[0] // len(indices)),
RESNET_SHAPE[0], RESNET_SHAPE[1])
mask_fpath = os.path.join(base_dir, 'data', data, 'val_mask')
if data in ['obj', 'scene', 'scene_only']:
# MCS and IDR are evaluated on 10000 images and masks are 10x100.
# Find the right mask.
obj_dict = {
'backpack': 0,
'bird': 1,
'dog': 2,
'elephant': 3,
'kite': 4,
'pizza': 5,
'stop_sign': 6,
'toilet': 7,
'truck': 8,
'zebra': 9,
}
# Loading val_mask from the data directory
masks_mat = np.load(tf.gfile.GFile(mask_fpath, 'rb'),
allow_pickle=True)
# Getting obj indices
obj_inds = [obj_dict[i.split('.')[0].split('-')[0]] for i in img_names]
# getting indices for a particular object class
temp_inds = [int(i.split('.')[0][-2:]) for i in img_names]
obj_masks = [
masks_mat[obj_inds[i] * 100 + temp_inds[i]]
for i, _ in enumerate(img_names)
]
else:
obj_masks = [
np.load(tf.gfile.GFile(mask_fpath, 'rb'), allow_pickle=True)[i]
for i in indices
]
attrs = []
for i in range(len(indices)):
attr = single_attr(maps_2d[i], locs[i], obj_masks[i])
attrs.append(attr)
out_path = os.path.join(attr_output_dir,
img_names[i][:-4] + '_' + str(preds[i]))
np.save(tf.gfile.GFile(out_path, 'w'), attr)
def simple_example():
#--------------------
mnist = input_data.read_data_sets('./MNIST_data', one_hot=True)
#--------------------
# Define a model.
num_classes = 10
input_shape = (None, 28, 28, 1) # 784 = 28 * 28.
output_shape = (None, num_classes)
input_ph = tf.placeholder(tf.float32, shape=input_shape, name='input_ph')
output_ph = tf.placeholder(tf.float32,
shape=output_shape,
name='output_ph')
with tf.variable_scope('conv1', reuse=tf.AUTO_REUSE):
conv1 = tf.layers.conv2d(input_ph,
32,
5,
activation=tf.nn.relu,
name='conv')
conv1 = tf.layers.max_pooling2d(conv1, 2, 2, name='maxpool')
with tf.variable_scope('conv2', reuse=tf.AUTO_REUSE):
conv2 = tf.layers.conv2d(conv1,
64,
3,
activation=tf.nn.relu,
name='conv')
conv2 = tf.layers.max_pooling2d(conv2, 2, 2, name='maxpool')
with tf.variable_scope('fc1', reuse=tf.AUTO_REUSE):
fc1 = tf.layers.flatten(conv2, name='flatten')
fc1 = tf.layers.dense(fc1, 1024, activation=tf.nn.relu, name='dense')
with tf.variable_scope('fc2', reuse=tf.AUTO_REUSE):
model_output = tf.layers.dense(fc1,
num_classes,
activation=tf.nn.softmax,
name='dense')
#--------------------
# Train.
loss = tf.reduce_mean(-tf.reduce_sum(output_ph * tf.log(model_output),
reduction_indices=[1]))
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
print('Start training...')
start_time = time.time()
for _ in range(2000):
batch_xs, batch_ys = mnist.train.next_batch(512)
batch_xs = np.reshape(batch_xs, (-1, ) + input_shape[1:])
sess.run(train_step,
feed_dict={
input_ph: batch_xs,
output_ph: batch_ys
})
if 0 == idx % 100: print('.', end='', flush=True)
print()
print('End training: {} secs.'.format(time.time() - start_time))
#--------------------
# Evaluate.
correct_prediction = tf.equal(tf.argmax(model_output, 1),
tf.argmax(output_ph, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print('Start testing...')
acc = sess.run(accuracy,
feed_dict={
input_ph:
np.reshape(mnist.test.images, (-1, ) + input_shape[1:]),
output_ph:
mnist.test.labels
})
print('Test accuracy = {}.'.format(acc))
print('End testing: {} secs.'.format(time.time() - start_time))
if acc < 0.95:
print('Failed to train...')
return
#--------------------
# Visualize.
images = np.reshape(mnist.test.images, (-1, ) + input_shape[1:])
img = images[0]
minval, maxval = np.min(img), np.max(img)
img_scaled = np.squeeze((img - minval) / (maxval - minval), axis=-1)
# Construct the scalar neuron tensor.
logits = model_output
neuron_selector = tf.placeholder(tf.int32)
y = logits[0][neuron_selector]
# Construct a tensor for predictions.
prediction = tf.argmax(logits, 1)
# Make a prediction.
prediction_class = sess.run(prediction, feed_dict={input_ph: [img]})[0]
#--------------------
start_time = time.time()
saliency_obj = saliency.Occlusion(sess.graph, sess, y, input_ph)
print('Occlusion: {} secs.'.format(time.time() - start_time))
# NOTE [info] >> An error exists in GetMask() of ${Saliency_HOME}/saliency/occlusion.py.
# <before>
# occlusion_window = np.array([size, size, x_value.shape[2]])
# occlusion_window.fill(value)
# <after>
# occlusion_window = np.full([size, size, x_value.shape[2]], value)
mask_3d = saliency_obj.GetMask(
img, feed_dict={neuron_selector: prediction_class})
# Compute a 2D tensor for visualization.
mask_gray = saliency.VisualizeImageGrayscale(mask_3d)
mask_div = saliency.VisualizeImageDiverging(mask_3d)
fig = plt.figure()
ax = plt.subplot(1, 3, 1)
ax.imshow(img_scaled, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Input')
ax = plt.subplot(1, 3, 2)
ax.imshow(mask_gray, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Grayscale')
ax = plt.subplot(1, 3, 3)
ax.imshow(mask_div, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Diverging')
fig.suptitle('Occlusion', fontsize=16)
fig.tight_layout()
#plt.savefig('./saliency_occlusion.png')
plt.show()
#--------------------
start_time = time.time()
conv_layer = sess.graph.get_tensor_by_name('conv2/conv/BiasAdd:0')
saliency_obj = saliency.GradCam(sess.graph, sess, y, input_ph, conv_layer)
print('GradCam: {} secs.'.format(time.time() - start_time))
mask_3d = saliency_obj.GetMask(
img, feed_dict={neuron_selector: prediction_class})
# Compute a 2D tensor for visualization.
mask_gray = saliency.VisualizeImageGrayscale(mask_3d)
mask_div = saliency.VisualizeImageDiverging(mask_3d)
fig = plt.figure()
ax = plt.subplot(1, 3, 1)
ax.imshow(img_scaled, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Input')
ax = plt.subplot(1, 3, 2)
ax.imshow(mask_gray, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Grayscale')
ax = plt.subplot(1, 3, 3)
ax.imshow(mask_div, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Diverging')
fig.suptitle('Grad-CAM', fontsize=16)
fig.tight_layout()
#plt.savefig('./saliency_gradcam.png')
plt.show()
#--------------------
start_time = time.time()
saliency_obj = saliency.GradientSaliency(sess.graph, sess, y, input_ph)
print('GradientSaliency: {} secs.'.format(time.time() - start_time))
vanilla_mask_3d = saliency_obj.GetMask(
img, feed_dict={neuron_selector: prediction_class})
smoothgrad_mask_3d = saliency_obj.GetSmoothedMask(
img, feed_dict={neuron_selector: prediction_class})
# Compute a 2D tensor for visualization.
vanilla_mask_gray = saliency.VisualizeImageGrayscale(vanilla_mask_3d)
smoothgrad_mask_gray = saliency.VisualizeImageGrayscale(smoothgrad_mask_3d)
vanilla_mask_div = saliency.VisualizeImageDiverging(vanilla_mask_3d)
smoothgrad_mask_div = saliency.VisualizeImageDiverging(smoothgrad_mask_3d)
fig = plt.figure()
ax = plt.subplot(2, 3, 1)
ax.imshow(img_scaled, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Input')
ax = plt.subplot(2, 3, 2)
ax.imshow(vanilla_mask_gray, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Vanilla Grayscale')
ax = plt.subplot(2, 3, 3)
ax.imshow(smoothgrad_mask_gray, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('SmoothGrad Grayscale')
ax = plt.subplot(2, 3, 5)
ax.imshow(vanilla_mask_div, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Vanilla Diverging')
ax = plt.subplot(2, 3, 6)
ax.imshow(smoothgrad_mask_div, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('SmoothGrad Diverging')
fig.suptitle('Gradient Saliency', fontsize=16)
fig.tight_layout()
#plt.savefig('./saliency_gradientsaliency.png')
plt.show()
#--------------------
start_time = time.time()
saliency_obj = saliency.GuidedBackprop(sess.graph, sess, y, input_ph)
print('GuidedBackprop: {} secs.'.format(time.time() - start_time))
vanilla_mask_3d = saliency_obj.GetMask(
img, feed_dict={neuron_selector: prediction_class})
smoothgrad_mask_3d = saliency_obj.GetSmoothedMask(
img, feed_dict={neuron_selector: prediction_class})
# Compute a 2D tensor for visualization.
vanilla_mask_gray = saliency.VisualizeImageGrayscale(vanilla_mask_3d)
smoothgrad_mask_gray = saliency.VisualizeImageGrayscale(smoothgrad_mask_3d)
vanilla_mask_div = saliency.VisualizeImageDiverging(vanilla_mask_3d)
smoothgrad_mask_div = saliency.VisualizeImageDiverging(smoothgrad_mask_3d)
fig = plt.figure()
ax = plt.subplot(2, 3, 1)
ax.imshow(img_scaled, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Input')
ax = plt.subplot(2, 3, 2)
ax.imshow(vanilla_mask_gray, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Vanilla Grayscale')
ax = plt.subplot(2, 3, 3)
ax.imshow(smoothgrad_mask_gray, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('SmoothGrad Grayscale')
ax = plt.subplot(2, 3, 4)
ax.imshow(vanilla_mask_div, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Vanilla Diverging')
ax = plt.subplot(2, 3, 5)
ax.imshow(smoothgrad_mask_div, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('SmoothGrad Diverging')
fig.suptitle('Guided Backprop', fontsize=16)
fig.tight_layout()
#plt.savefig('./saliency_guidedbackprop.png')
plt.show()
#--------------------
start_time = time.time()
saliency_obj = saliency.IntegratedGradients(sess.graph, sess, y, input_ph)
print('IntegratedGradients: {} secs.'.format(time.time() - start_time))
vanilla_mask_3d = saliency_obj.GetMask(
img, feed_dict={neuron_selector: prediction_class})
smoothgrad_mask_3d = saliency_obj.GetSmoothedMask(
img, feed_dict={neuron_selector: prediction_class})
# Compute a 2D tensor for visualization.
vanilla_mask_gray = saliency.VisualizeImageGrayscale(vanilla_mask_3d)
smoothgrad_mask_gray = saliency.VisualizeImageGrayscale(smoothgrad_mask_3d)
vanilla_mask_div = saliency.VisualizeImageDiverging(vanilla_mask_3d)
smoothgrad_mask_div = saliency.VisualizeImageDiverging(smoothgrad_mask_3d)
fig = plt.figure()
ax = plt.subplot(2, 3, 1)
ax.imshow(img_scaled, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Input')
ax = plt.subplot(2, 3, 2)
ax.imshow(vanilla_mask_gray, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Vanilla Grayscale')
ax = plt.subplot(2, 3, 3)
ax.imshow(smoothgrad_mask_gray, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('SmoothGrad Grayscale')
ax = plt.subplot(2, 3, 4)
ax.imshow(vanilla_mask_div, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Vanilla Diverging')
ax = plt.subplot(2, 3, 5)
ax.imshow(smoothgrad_mask_div, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('SmoothGrad Diverging')
fig.suptitle('Integrated Gradients', fontsize=16)
fig.tight_layout()
#plt.savefig('./saliency_integratedgradients.png')
plt.show()
#--------------------
start_time = time.time()
xrai_obj = saliency.XRAI(sess.graph, sess, y, input_ph)
print('XRAI: {} secs.'.format(time.time() - start_time))
if True:
xrai_attributions = xrai_obj.GetMask(
img, feed_dict={neuron_selector: prediction_class})
else:
# Create XRAIParameters and set the algorithm to fast mode which will produce an approximate result.
xrai_params = saliency.XRAIParameters()
xrai_params.algorithm = 'fast'
xrai_attributions_fast = xrai_obj.GetMask(
img,
feed_dict={neuron_selector: prediction_class},
extra_parameters=xrai_params)
# Show most salient 30% of the image.
mask = xrai_attributions > np.percentile(xrai_attributions, 70)
img_masked = img_scaled.copy()
img_masked[~mask] = 0
fig = plt.figure()
ax = plt.subplot(1, 3, 1)
ax.imshow(img_scaled, cmap=plt.cm.gray, vmin=0, vmax=1)
ax.axis('off')
ax.set_title('Input')
ax = plt.subplot(1, 3, 2)
ax.imshow(xrai_attributions, cmap=plt.cm.inferno)
ax.axis('off')
ax.set_title('XRAI Attributions')
ax = plt.subplot(1, 3, 3)
ax.imshow(img_masked, cmap=plt.cm.gray)
ax.axis('off')
ax.set_title('Masked Input')
fig.suptitle('XRAI', fontsize=16)
fig.tight_layout()
#plt.savefig('./saliency_xrai.png')
plt.show()
