def tearDown(self):
image = load_image('test/data/cat_dog.png')
prob_op_name = darkon.Gradcam.candidate_predict_op_names(
self.sess, self.nbclasses, self.graph_origin)[-1]
insp = darkon.Gradcam(self.inputs,
self.nbclasses,
self.target_op_name,
prob_op_name,
graph=self.graph_origin)
ret_top1 = insp.gradcam(self.sess, image)
ret_243 = insp.gradcam(self.sess, image, 243)
# save_expected_data(self.model_name, 'top1', ret_top1)
# save_expected_data(self.model_name, '243', ret_243)
exp_top1 = load_expected_data(self.model_name, 'top1')
for key in ret_top1.keys():
atol = 5 if 'img' in key else 1e-6
print(key, atol)
self.assertTrue(
np.allclose(ret_top1[key], exp_top1[key], atol=atol))
exp_243 = load_expected_data(self.model_name, '243')
for key in ret_243.keys():
atol = 5 if 'img' in key else 1e-6
self.assertTrue(np.allclose(ret_243[key], exp_243[key], atol=atol))
# just check new output
# cv2.imwrite('test_{}.png', ret['gradcam_img'])
# cv2.imwrite('test_guided_{}.png', ret['guided_gradcam_img'])
# cv2.imwrite('test_guided_backprop_{}.png', ret['guided_backprop_img'])
# tf.summary.FileWriter("./tmp/log-{}/".format(self.model_name), sess.graph)
self.sess.close()
def tearDown(self):
x = nn_graph(activation=self.activation_fn)
image = np.random.uniform(size=(2, 2, 3))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
gradcam_ops = darkon.Gradcam.candidate_featuremap_op_names(sess)
if self.enable_guided_backprop:
_ = darkon.Gradcam(x, _classes, gradcam_ops[-1])
g = tf.get_default_graph()
from_ts = g.get_operation_by_name(gradcam_ops[-1]).outputs
to_ts = g.get_operation_by_name(gradcam_ops[-2]).outputs
max_output = tf.reduce_max(from_ts, axis=3)
y = tf.reduce_sum(-max_output * 1e2)
grad = tf.gradients(y, to_ts)[0]
grad_val = sess.run(grad, feed_dict={x: np.expand_dims(image, 0)})
if self.enable_guided_backprop:
self.assertTrue(not np.any(grad_val))
else:
self.assertTrue(np.any(grad_val))
def test_relu(self):
x, y, cross_entropy = nn_graph(activation=tf.nn.relu)
image = np.random.uniform(size=(2, 2, 3))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
gradcam_ops = darkon.Gradcam.candidate_featuremap_op_names(sess)
prob_ops = darkon.Gradcam.candidate_predict_op_names(sess, _classes)
insp = darkon.Gradcam(x, _classes, gradcam_ops[-1], prob_ops[-1])
ret = insp.gradcam(sess, image)
self.assertTrue(ret)
def setUp(self):
tf.reset_default_graph()
self.nbclasses = 1000
inputs = tf.placeholder(tf.float32, [1, 224, 224, 3])
with slim.arg_scope(resnet_v1.resnet_arg_scope()):
net, end_points = resnet_v1.resnet_v1_50(inputs, self.nbclasses, is_training=False)
saver = tf.train.Saver(tf.global_variables())
check_point = 'test/data/resnet_v1_50.ckpt'
sess = tf.InteractiveSession()
saver.restore(sess, check_point)
conv_name = 'resnet_v1_50/block4/unit_3/bottleneck_v1/Relu'
self.graph_origin = tf.get_default_graph().as_graph_def()
self.insp = darkon.Gradcam(inputs, self.nbclasses, conv_name)
self.sess = sess
def test_text(self):
sess = tf.InteractiveSession()
checkpoint_file = "test/data/sequence/model-15000"
saver = tf.train.import_meta_graph("{}.meta".format(checkpoint_file))
saver.restore(sess, checkpoint_file)
graph = tf.get_default_graph()
input_x = graph.get_operation_by_name("input_x").outputs[0]
dropout_keep_prob = graph.get_operation_by_name(
"dropout_keep_prob").outputs[0]
input_y = graph.get_operation_by_name("input_y").outputs[0]
conv_op_names = darkon.Gradcam.candidate_featuremap_op_names(
sess,
feed_options={
input_x: self.x_test_batch,
input_y: self.y_test_batch,
dropout_keep_prob: 1.0
})
prob_op_names = darkon.Gradcam.candidate_predict_op_names(
sess,
2,
feed_options={
input_x: self.x_test_batch,
input_y: self.y_test_batch,
dropout_keep_prob: 1.0
})
conv_name = conv_op_names[-7]
prob_name = prob_op_names[-1]
self.assertEqual(conv_name, "conv-maxpool-3/relu")
self.assertEqual(prob_name, "output/scores")
insp = darkon.Gradcam(input_x, 2, conv_name, prob_name, graph=graph)
ret = insp.gradcam(sess,
self.x_test_batch[0],
feed_options={dropout_keep_prob: 1})