def ShowModelActivationMaximization(model, layer_name): # Utility to search for layer index by name. # Alternatively we can specify this as -1 since it corresponds to the last layer. layer_idx = utils.find_layer_idx(model, layer_name) # Swap softmax with linear model.layers[layer_idx].activation = activations.linear model = utils.apply_modifications(model) # This is the output node we want to maximize. filter_idx = 0 img = visualize_activation(model, layer_idx, filter_indices=filter_idx, input_range=(0., 1.)) plt.imshow(img[..., 0]) file_name = "tmp/ActivationMax/" + layer_name + ".jpg" plt.imsave(file_name, img[..., 0]) # plt.show() classes_num = model.output_shape[1] for output_idx in np.arange(classes_num): # Lets turn off verbose output this time to avoid clutter and just see the output. img = visualize_activation(model, layer_idx, filter_indices=output_idx, input_range=(0., 1.)) img_name = "tmp/ActivationMax/%s_%s.jpg" % ( layer_name, TrainingDefines.ACTION_NAME[output_idx]) plt.imsave(img_name, img[..., 0]) return
def visualize(model): from vis.visualization import visualize_activation from vis.utils import utils from keras import activations visualization_path = Path("visualization/auto-tagger/") if not visualization_path.exists(): visualization_path.mkdir(parents=True) # visualize each class for t in range(len(tags)): save_path = visualization_path / "out_{}.png".format(tags[t]) if save_path.exists(): print("{} already visualized".format(tags[t])) continue layer_idx = utils.find_layer_idx(model, "dense_2") # Swap softmax with linear model.layers[layer_idx].activation = activations.linear model = utils.apply_modifications(model) img = visualize_activation(model, layer_idx, filter_indices=t, verbose=True) array_to_img(img).save(save_path) print("saved to {}".format(str(save_path))) # visualize each layer for layer_name in [layer.name for layer in model.layers]: save_path = visualization_path / "{}.png".format(layer_name) if save_path.exists(): print("{} already visualized".format(layer_name)) continue if any([x in layer_name for x in ["batch_normalization", "input"]]): print("skipping visualization of {}".format(layer_name)) continue # Utility to search for layer index by name. # Alternatively we can specify this as -1 since it corresponds to the last layer. layer_idx = utils.find_layer_idx(model, layer_name) # Swap softmax with linear model.layers[layer_idx].activation = activations.linear model = utils.apply_modifications(model) img = visualize_activation(model, layer_idx, verbose=True) array_to_img(img).save(save_path) print("saved to {}".format(str(save_path)))
def cnnfeature_vis(model): from vis.visualization import visualize_activation from vis.utils import utils from keras import activations from matplotlib import pyplot as plt # %matplotlib inline plt.rcParams['figure.figsize'] = (18, 6) # Utility to search for layer index by name. # Alternatively we can specify this as -1 since it corresponds to the last layer. layer_idx = utils.find_layer_idx(model, 'preds') # Swap softmax with linear model.layers[layer_idx].activation = activations.linear model = utils.apply_modifications(model) # This is the output node we want to maximize. filter_idx = 0 img = visualize_activation(model, layer_idx, filter_indices=filter_idx) plt.imshow(img[..., 0]) for output_idx in np.arange(10): # Lets turn off verbose output this time to avoid clutter and just see the output. img = visualize_activation(model, layer_idx, filter_indices=output_idx, input_range=(0., 1.)) plt.figure() plt.title('Networks perception of {}'.format(output_idx)) plt.imshow(img[..., 0]) # Visualizations without swapping softmax # Swap linear back with softmax model.layers[layer_idx].activation = activations.softmax model = utils.apply_modifications(model) for output_idx in np.arange(10): # Lets turn off verbose output this time to avoid clutter and just see the output. # Visualizations without swapping softmax img = visualize_activation(model, layer_idx, filter_indices=output_idx, input_range=(0., 1.)) plt.figure() plt.title('Networks perception of {}'.format(output_idx)) plt.imshow(img[..., 0]) plt.show()
def visualize_multiple_categories(show=True): """Example to show how to visualize images that activate multiple categories """ # Build the VGG16 network with ImageNet weights model = VGG16(weights='imagenet', include_top=True) print('Model loaded.') # The name of the layer we want to visualize # (see model definition in vggnet.py) layer_name = 'predictions' layer_idx = [idx for idx, layer in enumerate(model.layers) if layer.name == layer_name][0] # Visualize [20] (ouzel) and [20, 71] (An ouzel-scorpion :D) indices = [20, [20, 71]] images = [] for idx in indices: img = visualize_activation(model, layer_idx, filter_indices=idx, max_iter=500) img = utils.draw_text(img, utils.get_imagenet_label(idx)) images.append(img) # Easily stitch images via `utils.stitch_images` stitched = utils.stitch_images(images) if show: plt.axis('off') plt.imshow(stitched) plt.title('Multiple category visualization') plt.show()
def visualize_multiple_same_filter(num_runs=3, show=True): """Example to show how to visualize same filter multiple times via different runs. Args: num_runs: The number of times the same filter is visualized """ # Build the VGG16 network with ImageNet weights model = VGG16(weights='imagenet', include_top=True) print('Model loaded.') # The name of the layer we want to visualize # (see model definition in vggnet.py) layer_name = 'predictions' layer_idx = [idx for idx, layer in enumerate(model.layers) if layer.name == layer_name][0] # 20 is the imagenet category for 'ouzel' indices = [20] * num_runs images = [] for idx in indices: img = visualize_activation(model, layer_idx, filter_indices=idx, max_iter=500) img = utils.draw_text(img, utils.get_imagenet_label(idx)) images.append(img) # Easily stitch images via `utils.stitch_images` stitched = utils.stitch_images(images) if show: plt.axis('off') plt.imshow(stitched) plt.title('Multiple runs of ouzel') plt.show()
def layer_visualisation(model, layer, start, end): layer_idx = utils.find_layer_idx(model, layer) filters = np.random.permutation(get_num_filters( model.layers[layer_idx]))[:10] nbFilters = len(filters) # create a folder in static/img/ for every layers path = "static/img/" + layer + '/' if not os.path.isdir(path): os.makedirs(path) for index in range(start, end + 1): if index < nbFilters: namePath = img_name(layer, index) if not os.path.exists(namePath): layer_idx = utils.find_layer_idx(model, layer) #layer plt.rcParams['figure.figsize'] = (18, 6) img = visualize_activation(model, layer_idx, filter_indices=index) #filter_nb im = Image.fromarray(img) d = ImageDraw.Draw(im) d.text((10, 10), layer + " Filter: " + str(index), fill=(255, 255, 0)) print(layer + " Filter: " + str(index)) im.save(namePath) print('created ' + namePath) else: print(namePath + ' already exists' + str(os.path.exists(namePath)))
def save_img(path, savepath, origimg, typeimg, layeridx): img = load_img(path, target_size=(224,224)) x = img_to_array(img) #numpy array x = x.reshape(x.shape) #adds on dimension for keras model.layers[layeridx].activation = activations.linear if typeimg == 'activation': img = visualize_activation(model, layeridx, 20, x) if typeimg == 'saliency': img = visualize_saliency(model, layeridx, 1, x) if typeimg == 'cam': img = visualize_cam(model, layeridx, 1, x) if not os.path.exists('layer-' + savepath): os.makedirs('layer-' + savepath) if not os.path.exists('image-' + savepath): os.makedirs('image-' + savepath) combined = str(savepath) + '/' + str(origimg) plt.imshow(img) plt.savefig('layer-' + combined, dpi=600)
def plot_classes(model, number_sequence): """ Creates a keras model visualization of its learning state at a certain epoch depending on the model trained. Arguments: model (Keras Model Object): The neural network of the keras CNN. number_sequence (String): Number sequence primary name. """ # Numbers to visualize numbers_to_visualize = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] images_learned = [] # Visualize for number_to_visualize in numbers_to_visualize: visualization = visualize_activation( model, layer_index, filter_indices=number_to_visualize) plt.imshow(visualization[..., 0]) plt.title(f'MNIST target = {number_to_visualize}') plt.savefig(number_sequence + str(number_to_visualize) + ".png") images_learned.append(wandb.Image(plt)) wandb.log({"Learning Visualization for" + number_sequence: images_learned})
def visualize_random(num_categories=10, show=True): """Example to show how to visualize multiple filters via activation maximization. Args: num_categories: The number of random categories to visualize. (Default Value = 5) """ # Build the VGG16 network with ImageNet weights model = VGG16(weights='imagenet', include_top=True) print('Model loaded.') # The name of the layer we want to visualize # (see model definition in vggnet.py) layer_name = 'predictions' layer_idx = [idx for idx, layer in enumerate(model.layers) if layer.name == layer_name][0] # Visualize couple random categories from imagenet. indices = np.random.permutation(1000)[:num_categories] images = [] for idx in indices: img = visualize_activation(model, layer_idx, filter_indices=idx, max_iter=500) img = utils.draw_text(img, utils.get_imagenet_label(idx)) images.append(img) # Easily stitch images via `utils.stitch_images` stitched = utils.stitch_images(images) if show: plt.axis('off') plt.imshow(stitched) plt.title('Random imagenet categories') plt.show()
def main(): model = load_model('model2.h5py') model.summary() # swap softmax activation function to linear layer_idx = -1 model.layers[layer_idx].activation = activations.linear model = utils.apply_modifications(model) layer_names = ['leaky_re_lu_1', 'leaky_re_lu_2', 'leaky_re_lu_3', 'leaky_re_lu_4'] for lid in range(len(layer_names)): layer_name = layer_names[lid] layer_idx = utils.find_layer_idx(model, layer_name) filters = np.arange(get_num_filters(model.layers[layer_idx])) filters = _shuffle(filters) vis_images = [] for idx in range(16): indices = filters[idx] img = visualize_activation(model, layer_idx, filter_indices=indices, tv_weight=0., input_modifiers=[Jitter(0.5)]) vis_images.append(img) #img = img.reshape((48, 48)) #plt.imshow(img, cmap="Blues") #plt.show() stitched = utils.stitch_images(vis_images, cols=8) plt.figure() plt.axis('off') shape = stitched.shape stitched = stitched.reshape((shape[0], shape[1])) plt.imshow(stitched) plt.title(layer_name) plt.tight_layout() plt.savefig('Filter_{}.png'.format(lid))
def prediction_with_important(brain_net, graph_adjacency, n_nodes=84, kth=100): # make prediction for a single graph pred_bn, confidences = brain_net.predict(graph_adjacency) print('Computing partial derivatives for each samples') print('This operation requires time...') # graph_adjacency = np.expand_dims(graph_adjacency, axis=0) # compute for each edge the partial derivatives according to Simonyan et al (2013) heatmap = visualize_activation(brain_net.model, layer_idx=-1, filter_indices=0, seed_input=graph_adjacency) # compute the importance of each node by summing importance of edges important_nodes = np.sum(abs(heatmap), axis=0) # select the nodes belonging to the percentile-th percentile #most_important = np.argwhere(important_nodes >= np.percentile(important_nodes, percentile)) # sorting for getting the first k% most important vip = [(i, value) for i, value in enumerate(important_nodes)] k_vip = sorted(vip, reverse=True, key=lambda x: x[1])[n_nodes - int((kth/100) * n_nodes):] print(k_vip) #k_vip = list(map(lambda x: x[0]+1, k_vip)) print('done.') #return confidences, pred_bn, most_important return confidences, pred_bn, k_vip
def visualize_random(num_categories=10): """Example to show how to visualize multiple filters via activation maximization. Args: num_categories: The number of random categories to visualize. (Default Value = 5) """ # Build the VGG16 network with ImageNet weights model = VGG16(weights='imagenet', include_top=True) print('Model loaded.') # The name of the layer we want to visualize # (see model definition in vggnet.py) layer_name = 'predictions' layer_idx = [ idx for idx, layer in enumerate(model.layers) if layer.name == layer_name ][0] # Visualize couple random categories from imagenet. indices = np.random.permutation(1000)[:num_categories] images = [ visualize_activation(model, layer_idx, filter_indices=idx, text=utils.get_imagenet_label(idx), max_iter=500) for idx in indices ] # Easily stitch images via `utils.stitch_images` cv2.imshow('Random imagenet categories', utils.stitch_images(images)) cv2.waitKey(0)
def main(): # dataset_str = 'rgb' dataset_str = 'smooth' # load fine tuned model # model = train_and_test([dataset]) model = load_model('models/vgg16_hybrid_1365_softmax_mit67_' + dataset_str + '.h5') # use first dense layer # layer_idx = 19 # first conv layer # layer_idx = 0 # visualize all convolutional & fully connected layers layer_indices = [0,1,3,4,6,7,8,10,11,12,14,15,16,19,20,21] nb_filters = 32 # for each layer, iterate over nb_filters many filters for layer_idx in layer_indices: print('layer: ' + str(layer_idx)) for filter_idx in range(nb_filters): print('filter: ' + str(filter_idx)) act = visualize_activation(model, layer_idx, filter_idx).squeeze() # directory to save images to dir_name = 'mit67_' + dataset_str + '_activations/' imsave((dir_name + 'act_' + str(layer_idx) + '_' + str(filter_idx) + '.png'), act )
def find_mai(self, layer_id, filter_id): img = visualize_activation(model=self.model_, layer_idx=layer_id, filter_indices=[filter_id], max_iter=500, verbose=False) return img
def visualize_activation(self): from matplotlib import pyplot as plt from vis.utils import utils from vis.visualization import visualize_activation, get_num_filters vis_images = [] for i in range(self.config['output_shape'][0]): # The name of the layer we want to visualize layer_name = 'output_%d' % i layer_idx = [ idx for idx, layer in enumerate(self.net.layers) if layer.name == layer_name ][0] print('Working on %s' % layer_name) # Generate input image for each filter. Here `text` field is used to # overlay `filter_value` on top of the image. for idx in [1, 1, 1]: img = visualize_activation(self.net, layer_idx, filter_indices=idx, max_iter=500) # img = utils.draw_text(img, TAGS[i]) vis_images.append(img) # Generate stitched image palette with 8 cols. stitched = utils.stitch_images(vis_images, cols=3) plt.axis('off') plt.imshow(stitched) plt.title(self.checkpoint_name) plt.show()
def prediction_with_important_edges(brain_net, graph_adjacency, n_nodes=84, kth=100): # make prediction for a single graph pred_bn, confidences = brain_net.predict(graph_adjacency) print('Computing partial derivatives for each samples') print('This operation requires time...') # graph_adjacency = np.expand_dims(graph_adjacency, axis=0) # compute for each edge the partial derivatives according to Simonyan et al (2013) heatmap = visualize_activation(brain_net.model, layer_idx=-1, filter_indices=0, seed_input=graph_adjacency) edges = list() # getting the triu of the matrix triu = np.triu(heatmap) n,m = triu.shape for i in range(n): for j in range(i+1, m): edges.append((i+1,j+1,triu[i][j])) edges = sorted(edges, key=lambda x: x[2], reverse=True) print('done.') return confidences, pred_bn, edges
def maxout(model, layer, filters): # Changer l'activation softmax par linear model.layers[layer].activation = activations.linear model = apply_modifications(model) act = visualize_activation(model, layer, filter_indices=filters, tv_weight=1., lp_norm_weight=0., verbose=True, input_modifiers=[Jitter(16)]) return act
def visualize_multiple_same_filter(num_runs=3): """Example to show how to visualize same filter multiple times via different runs. Args: num_runs: The number of times the same filter is visualized """ # Build the VGG16 network with ImageNet weights model = VGG16(weights='imagenet', include_top=True) print('Model loaded.') # The name of the layer we want to visualize # (see model definition in vggnet.py) layer_name = 'predictions' layer_idx = [ idx for idx, layer in enumerate(model.layers) if layer.name == layer_name ][0] # 20 is the imagenet category for 'ouzel' indices = [20] * num_runs images = [ visualize_activation(model, layer_idx, filter_indices=idx, text=utils.get_imagenet_label(idx), max_iter=500) for idx in indices ] cv2.imshow('Multiple runs of ouzel', utils.stitch_images(images)) cv2.waitKey(0)
def visualize_dense_layer(self): self.logger.info('Visualizing dense layers') # create folder for saving visualization save_path = os.path.join(constants.MODEL_DIR, 'Visualization', self.model_name) if not os.path.exists(save_path): os.makedirs(save_path) # search the last dense layer with the name 'preds' layer_idx = utils.find_layer_idx(self.model, 'preds') # Swap softmax with linear self.model.layers[layer_idx].activation = activations.linear model = utils.apply_modifications(self.model) # output node we want to maximize for class_idx in np.arange(len(constants.CATEGORIES)): # Lets turn off verbose output this time to avoid clutter and just see the output. img = visualize_activation(model, layer_idx, filter_indices=class_idx, input_range=(0., 1.)) plt.figure() plt.title('Networks perception of {}'.format(class_idx)) plt.imshow(img[..., 0]) # save the plot plot_name = 'dense-layer-{}.png'.format( constants.CATEGORIES[class_idx]) plt.savefig(os.path.join(save_path, plot_name)) plt.show()
def visualize_multiple_categories(): """Example to show how to visualize images that activate multiple categories """ # Build the VGG16 network with ImageNet weights model = VGG16(weights='imagenet', include_top=True) print('Model loaded.') # The name of the layer we want to visualize # (see model definition in vggnet.py) layer_name = 'predictions' layer_idx = [ idx for idx, layer in enumerate(model.layers) if layer.name == layer_name ][0] # Visualize [20] (ouzel) and [20, 71] (An ouzel-scorpion :D) indices = [20, [20, 71]] images = [ visualize_activation(model, layer_idx, filter_indices=idx, text=utils.get_imagenet_label(idx), max_iter=500) for idx in indices ] cv2.imshow('Multiple category visualization', utils.stitch_images(images)) cv2.waitKey(0)
def vis_2(): # 20 is the imagenet category for 'ouzel' img = visualize_activation(model, layer_idx, filter_indices=6, max_iter=500, verbose=True) save_image(img, '2.png')
def plot_activation(self): layer_idx=-1 self.model.layers[layer_idx].activation = activations.linear model = utils.apply_modifications(self.model) for pred_class in range(25)[11:12]: print(self.inv_dico.get(pred_class)) actmap = visualize_activation(model,layer_idx,filter_indices=pred_class) plt.imsave('img.jpg',actmap)
def plt_activation(model_path, layer_idx=-1, max_iter=200, **kwargs): """ Plot activation of a given layer in a model by generating an image that maximizes the output of all `filter_indices` in the given `layer_idx`. Args: model_path: Path to the model file. layer_idx: Index of the layer to plot. max_iter: Maximum number of iterations to generate the input image. kwargs: Unused arguments. Returns: """ model = import_model(model_path) model = prediction_layer_linear_activation(model) if type(model.layers[layer_idx]) == keras.layers.Dense: img = vvis.visualize_activation(model, layer_idx, max_iter=max_iter, filter_indices=None) elif type(model.layers[layer_idx]) == keras.layers.Conv2D: filters = np.arange(vvis.get_num_filters(model.layers[layer_idx])) # Generate input image for each filter. vis_images = [] for idx in tqdm.tqdm(filters): act_img = vvis.visualize_activation(model, layer_idx, max_iter=max_iter, filter_indices=idx) vis_images.append(act_img) # Generate stitched image palette with 8 cols. img = vutils.stitch_images(vis_images, cols=8) else: raise TypeError("Invalid Layer type. model.layers[{}] is {}, " "only Dense and Conv2D layers can be used".format( str(layer_idx), str(type(model.layers[layer_idx])))) plt.axis("off") if len(img.shape) == 2 or img.shape[2] == 1: plt.imshow(img.reshape(img.shape[0:2]), cmap="gray") else: plt.imshow(img) plt.show()
def getModelActivation(model, classIdx): layer_idx = -1 act = visualize_activation(model, layer_idx, filter_indices=classIdx, seed_input=None, input_range=(0, 255), backprop_modifier='guided') return act
def vis_3(): # 20 is the imagenet category for 'ouzel' # Jitter 16 pixels along all dimensions to during the optimization process. img = visualize_activation(model, layer_idx, filter_indices=36, max_iter=2000, input_modifiers=[Jitter(16)]) save_image(img, 'filter_single_6_' + str(37) + '.png')
def show_layer_activation(self, layer_name, filter_indices): layer_idx = vis_utils.find_layer_idx(self.model, layer_name) self.model.layers[layer_idx].activation = activations.linear vis_model = vis_utils.apply_modifications(self.model) img = visualize_activation(vis_model, layer_idx, filter_indices=filter_indices) show_img_array(img)
def visualize_attention_on_image(raw_image, normalised_image, model, layer_index, filter_indices, type="saliency"): """ Shows the saliency map of an image, overlayed over the input image ATTENTION: seems so to be influenced by the learning phase, learning phase has to be 1(for learning) :param image: :param model: :param layer_index: :param filter_indices: :return: Image with overlayed saliency map """ titles = ['left steering', 'right steering'] modifiers = [None, 'negate'] for i, modifier in enumerate(modifiers): if type == "saliency": heatmap = visualize_saliency(model, layer_idx=layer_index, filter_indices=filter_indices, seed_input=normalised_image, grad_modifier=modifier, backprop_modifier='guided') elif type == "cam": heatmap = visualize_cam(model, layer_idx=layer_index, filter_indices=filter_indices, seed_input=normalised_image, grad_modifier=modifier) elif type == "activation": heatmap = visualize_activation(model, layer_idx=layer_index, filter_indices=filter_indices, seed_input=normalised_image, input_range=(0, 1), grad_modifier=modifier) else: print("Select 'saliency' or 'cam' as visualization type!") break #plt.figure() #plt.title(titles[i]) #plt.imshow(heatmap) overlay_colour_on_greyscale(heatmap, raw_image, titles[i])
def show_activation(model, layer_idx): from vis.visualization import visualize_activation from vis.input_modifiers import Jitter # 1 is the imagenet category for 'PNEUMONIA' im = visualize_activation(model, layer_idx, filter_indices=None, max_iter=500, input_modifiers=[Jitter(16)], verbose=False) plt.imshow(im) plt.show()
def vis_max(model, save_path): ''' Generate the input image that maximizes the response of each class in the final FC layer Please also see keras-vis for details. ''' layer_idx = vutils.find_layer_idx(model, 'predictions') model.layers[layer_idx].activation = activations.linear model = vutils.apply_modifications(model) for ind in range(len(config.classes)): print 'Generating for class {}'.format(ind) plt.rcParams['figure.figsize'] = (18, 6) img = visualize_activation(model, layer_idx, filter_indices=ind) mpimg.imsave(save_path + str(ind) + ".png", img) print('Done')
def visualize_grad(model_weights, data): #model: trained model. #data: preprocessed image by keras. #Note: Put "name = 'predictions'" on the last layer of every model (layer that include 'softmax'). This layer will #be the one we gonna visualize to standardize architectures. #layer_idx = [idx for idx,layer in enumerate(model.layers) if layer.name == layer_name][0] layer_idx = -1 #original = np.copy(recover(data)) #cv2.imwrite(path.replace('/scripts/python', '') + '/heatmaps/' + 'original.png', original) img = np.reshape(data, (1,) + data.shape) prediction = predictData(model_weights, img) pred_class = np.argmax(prediction) print('image shape: ', img.shape) print('prediction: ', prediction) print('class: ', pred_class) #model_weights.layers[layer_idx].activation = activations.linear #model_weights = utils.apply_modifications(model_weights) heatmap_activation = visualize_activation(model_weights, layer_idx, filter_indices=pred_class, seed_input=img) #plt.rcParams['figure.figsize'] = (18, 6) heatmap_activation = np.squeeze(heatmap_activation, axis=2) #plt.imshow(heatmap_activation, cmap='jet') plt.imsave(path.replace('/scripts/python', '') + '/heatmaps/' + 'activation.png', heatmap_activation, cmap='jet') #plt.show() #cv2.imwrite(path.replace('/scripts/python', '') + '/heatmaps/' + 'activation.png', heatmap_activation) heatmap_saliency = visualize_saliency(model_weights, layer_idx, filter_indices=pred_class, seed_input=img) #plt.rcParams['figure.figsize'] = (18, 6) #heatmap_saliency = np.squeeze(heatmap_saliency, axis=2) #plt.imshow(heatmap_saliency, cmap='jet') plt.imsave(path.replace('/scripts/python', '') + '/heatmaps/' + 'saliency.png', heatmap_saliency, cmap='jet') #plt.show() #cv2.imwrite(path.replace('/scripts/python', '') + '/heatmaps/' + 'saliency.png', heatmap_saliency) heatmap_saliency_g = visualize_saliency(model_weights, layer_idx, filter_indices=pred_class, seed_input=img, backprop_modifier='guided') plt.imsave(path.replace('/scripts/python', '') + '/heatmaps/' + 'saliency_guided.png', heatmap_saliency_g, cmap='jet') heatmap_saliency_r = visualize_saliency(model_weights, layer_idx, filter_indices=pred_class, seed_input=img, backprop_modifier='relu') plt.imsave(path.replace('/scripts/python', '') + '/heatmaps/' + 'saliency_relu.png', heatmap_saliency_r, cmap='jet') heatmap_cam = visualize_cam(model_weights, layer_idx, filter_indices=pred_class, seed_input=img) #plt.rcParams['figure.figsize'] = (18, 6) #heatmap_cam = np.squeeze(heatmap_cam, axis=2) #plt.imshow(heatmap_cam, cmap='jet') plt.imsave(path.replace('/scripts/python', '') + '/heatmaps/' + 'cam.png', heatmap_cam, cmap='jet')
#modelName = "/home/daiver/coding/jff/py/keras_shape_reg/checkpoints/2017-05-19 12:47:16.562989_ep_149_train_l_0.00872_test_l_0.02065.h5" modelName = "/home/daiver/coding/jff/py/keras_shape_reg/checkpoints/2017-05-18 16:43:27.041387_ep_9499_train_l_0.00009_test_l_0.00706.h5" model = keras.models.load_model(modelName) print model.layers[0].name#conv1 print model.layers[3].name#conv2 print model.layers[5].name#conv3 print model.layers[8].name#conv4 print model.layers[10].name#conv5 print model.layers[13].name#conv6 print model.layers[15].name#conv7 print model.layers[18].name#conv8 print model.layers[20].name#conv8 print model.layers[25].name#conv9 #exit() layer_idx = 25 num_filters = get_num_filters(model.layers[layer_idx]) print num_filters filters = np.arange(get_num_filters(model.layers[layer_idx]))[:32] vis_images = [] for idx in filters: img = visualize_activation(model, layer_idx, filter_indices=idx) img = utils.draw_text(img, str(idx)) vis_images.append(img) # Generate stitched image palette with 8 cols. stitched = utils.stitch_images(vis_images, cols=8) plt.axis('off') plt.imshow(stitched) plt.show()