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 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_class_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 visualize_conv_filters(output_dir, model, layer_name):
layer_idx = utilsvis.find_layer_idx(model, layer_name)
filters = np.arange(get_num_filters(model.layers[layer_idx]))
vis_images = []
for idx in tqdm(filters):
img = visualize_activation(model, layer_idx, filter_indices=idx)
img = utilsvis.draw_text(img, 'Filter {}'.format(idx))
vis_images.append(img)
stitched = utilsvis.stitch_images(vis_images, cols=32)
path = os.path.join(output_dir, '{}.png')
imsave(path, stitched)
def visualiseDenseLayer(model,
layer_name,
output_classes,
verbose,
save=False):
'''
Makes a plot for visualising the activations of a dense layer.
:param model: The model to visualise.
:param layer_name: The name of the dense layer to visualise.
:param output_classes: The number of activations in the layer.
:param verbose: Print statements of progress.
:return: N/A
'''
layer_index = utils.find_layer_idx(model, layer_name)
model.layers[layer_index].activation = activations.linear
model = utils.apply_modifications(model)
vis_images = []
for filter_index in range(0, output_classes):
if (verbose):
print("Preparing Visualisation for class {} in layer {}".format(
filter_index, layer_name))
visualisation = visualize_activation(model,
layer_index,
filter_index,
max_iter=500,
input_modifiers=[Jitter(16)])
img = utils.draw_text(visualisation, 'Class {}'.format(filter_index))
vis_images.append(img)
stitched = utils.stitch_images(vis_images, cols=4)
if (save):
matplotlib.image.imsave("../SavedData/" + save, stitched)
else:
plt.imshow(stitched)
plt.figure()
plt.axis('off')
plt.show()
def plot_conv_weights(self):
PATH = os.path.dirname(__file__)
cls = _get_conv_layers(self.model)
i=0
for layer in cls :
layer_name = layer.name
print("{}/{} : {}".format(i,len(cls),layer_name))
layer_idx = utils.find_layer_idx(self.model,layer_name)
filters = np.arange(get_num_filters(self.model.layers[layer_idx]))
vis_images = []
for idx in filters[:64]:
img = visualize_activation(self.model, layer_idx, filter_indices=idx)
# Utility to overlay text on image.
img = utils.draw_text(img, 'Filter {}'.format(idx))
vis_images.append(img)
# Generate stitched image palette with 8 cols.
stitched = utils.stitch_images(vis_images, cols=8)
plt.axis('off')
plt.imsave(join(PATH,'heatmaps/'+layer_name+'.jpg'),stitched)
i+=1
def visualiseCovolutionLayer(model,
selected_layer,
selected_indices,
verbose,
save=False):
'''
Makes a plot for visualising the activations of a convolutional layer.
:param model: The model to visualise.
:param selected_layer: The name of the dense layer to visualise.
:param selected_indices: The indices of the filters to visualise.
:param verbose: Print statements of progress.
:return: N/A.
'''
layer_index = utils.find_layer_idx(model, selected_layer)
vis_images = []
for filter_index in selected_indices:
if (verbose):
print("Preparing Visualisation for filter {} in layer {}".format(
filter_index, selected_layer))
img = visualize_activation(model, layer_index, filter_index)
# Utility to overlay text on image.
visualisation = utils.draw_text(
img, 'Filter {} on layer {}'.format(filter_index, selected_layer))
vis_images.append(visualisation)
# Generate stitched image palette with 5 cols so we get 2 rows.
stitched = utils.stitch_images(vis_images, cols=5)
plt.figure()
plt.axis('off')
plt.imshow(stitched)
if (save):
plt.savefig("../SavedData/" + save)
else:
plt.show()
from vis.visualization import visualize_activation
from keras.models import load_model
from keras.layers import Activation
from scipy.misc import imsave
# Load the fine-tuned plankton model
model = load_model('plankton_model.h5')
# Change output activation from softmax to linear
model.layers[-1].activation = Activation('linear')
print('Model loaded.')
# The name of the layer we want to visualize
layer_name = 'dense_1'
layer_idx = [idx for idx, layer in enumerate(model.layers) if layer.name == layer_name][0]
# Get dense layer visualizations for all 12 plankton categories
vis_images = []
for idx in range(12):
img = visualize_activation(model, layer_idx, filter_indices=idx, max_iter=1000 )
img = utils.draw_text(img, str(idx))
vis_images.append(img)
stitched = utils.stitch_images(vis_images)
imsave('class_%d.png' % (idx), stitched)
plt.axis('off')
plt.imshow(stitched)
plt.title(layer_name)
plt.show()
img = visualize_activation(model, layer_idx, filter_indices=3)
plt.imshow(img)
idx = 59
# Generate input image for each filter.
new_vis_images = []
for i, idx in enumerate(filters):
# We will seed with optimized image this time.
img = visualize_activation(model,
layer_idx,
filter_indices=idx,
seed_input=vis_images[i],
input_modifiers=[Jitter(0.05)])
# Utility to overlay text on image.
img = utils.draw_text(img, 'Filter {}'.format(idx))
new_vis_images.append(img)
# Generate stitched image palette with 5 cols so we get 2 rows.
stitched = utils.stitch_images(new_vis_images, cols=5)
plt.figure()
plt.axis('off')
plt.imshow(stitched)
plt.show()
from vis.visualization import get_num_filters
selected_indices = []
for layer_name in ['block_6_conv_3']:
layer_idx = utils.find_layer_idx(model, layer_name)
from vis.utils import utils
from keras import activations
from vis.visualization import visualize_activation
from matplotlib import pyplot as plt
from vis.input_modifiers import Jitter
import numpy as np
import os
import cv2
categorias = np.random.permutation(1000)[:15]
model = VGG16(weights='imagenet', include_top=True)
layer_idx = utils.find_layer_idx(
model, 'predictions') # -1 tambien vale (es la ultima)
#Softmax a linear
model.layers[layer_idx].activation = activations.linear
model = utils.apply_modifications(model)
if not os.path.isdir("fc"):
os.mkdir("fc")
for categoria in categorias:
img = visualize_activation(model,
layer_idx,
filter_indices=categoria,
max_iter=500,
input_modifiers=[Jitter(16)])
img = utils.draw_text(img, utils.get_imagenet_label(categoria))
cv2.imwrite("fc/" + utils.get_imagenet_label(categoria) + ".png", img)
def visualize_activation(model,
layer_idx,
filter_indices=None,
seed_img=None,
text=None,
act_max_weight=1,
lp_norm_weight=10,
tv_weight=10,
**optimizer_params):
"""Generates stitched input image(s) over all `filter_indices` in the given `layer` that maximize
the filter output activation.
Args:
model: The `keras.models.Model` instance. Model input is expected to be a 4D image input of shape:
`(samples, channels, rows, cols)` if data_format='channels_first' or `(samples, rows, cols, channels)` if data_format='channels_last'.
layer_idx: The layer index within `model.layers` whose filters needs to be visualized.
filter_indices: filter indices within the layer to be maximized.
For `keras.layers.Dense` layer, `filter_idx` is interpreted as the output index.
If you are visualizing final `keras.layers.Dense` layer, you tend to get
better results with 'linear' activation as opposed to 'softmax'. This is because 'softmax'
output can be maximized by minimizing scores for other classes.
filter indices within the layer to be maximized.
If None, all filters are visualized. (Default value = None)
An input image is generated for each entry in `filter_indices`. The entry can also be an array.
For example, `filter_indices = [[1, 2], 3, [4, 5, 6]]` would generate three input images. The first one
would maximize output of filters 1, 2, 3 jointly. A fun use of this might be to generate a dog-fish
image by maximizing 'dog' and 'fish' output in final `Dense` layer.
For `keras.layers.Dense` layers, `filter_idx` is interpreted as the output index.
If you are visualizing final `keras.layers.Dense` layer, you tend to get
better results with 'linear' activation as opposed to 'softmax'. This is because 'softmax'
output can be maximized by minimizing scores for other classes.
seed_img: Seeds the optimization with a starting image. Initialized with a random value when set to None.
(Default value = None)
text: The text to overlay on top of the generated image. (Default Value = None)
act_max_weight: The weight param for `ActivationMaximization` loss. Not used if 0 or None. (Default value = 1)
lp_norm_weight: The weight param for `LPNorm` regularization loss. Not used if 0 or None. (Default value = 10)
tv_weight: The weight param for `TotalVariation` regularization loss. Not used if 0 or None. (Default value = 10)
optimizer_params: The **kwargs for optimizer [params](vis.optimizer.md##optimizerminimize). Will default to
reasonable values when required keys are not found.
Example:
If you wanted to visualize the input image that would maximize the output index 22, say on
final `keras.layers.Dense` layer, then, `filter_indices = [22]`, `layer = dense_layer`.
If `filter_indices = [22, 23]`, then it should generate an input image that shows features of both classes.
Returns:
Stitched image output visualizing input images that maximize the filter output(s). (Default value = 10)
"""
filter_indices = utils.listify(filter_indices)
print("Working on filters: {}".format(pprint.pformat(filter_indices)))
# Default optimizer kwargs.
optimizer_params_default = {
'seed_img': seed_img,
'max_iter': 200,
'verbose': False,
'image_modifiers': _DEFAULT_IMG_MODIFIERS
}
optimizer_params_default.update(optimizer_params)
optimizer_params = optimizer_params_default
losses = [(ActivationMaximization(model.layers[layer_idx],
filter_indices), act_max_weight),
(LPNorm(model.input), lp_norm_weight),
(TotalVariation(model.input), tv_weight)]
opt = Optimizer(model.input, losses, norm_grads=False)
img = opt.minimize(**optimizer_params)[0]
if text:
img = utils.draw_text(img, text)
return img
#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()
tv_weight=0.,
max_iter=300,
input_modifiers=[Jitter(16)])
initial.append(img)
tuples.append((name, idx))
i = 0
for name, idx in tuples:
img = visualize_activation(model,
layer_idx,
filter_indices=idx,
seed_input=initial[i],
max_iter=300,
input_modifiers=[Jitter(16)])
img = utils.draw_text(img, name)
i += 1
images.append(img)
stitched = utils.stitch_images(images, cols=4)
plt.figure(figsize=(20, 20))
plt.axis('off')
plt.imshow(stitched)
plt.show()
# # Visualizing Convnet Filters
# In[39]:
max_filters = 40
selected_indices = []
model.save('lenet_'+args.network+'.h5')
layer_dict = dict([(layer.name, layer) for layer in model.layers])
print(layer_dict)
layer_name = 'conv2d_1'
layer_idx = utils.find_layer_idx(model, layer_name=layer_name)
plt.rcParams['figure.figsize'] = (18, 6)
img = visualize_activation(model, layer_idx, filter_indices=1)
plt.savefig('fil_in_vis.png')
filters = np.arange(get_num_filters(model.layers[layer_idx]))
# Generate input image for each filter.
vis_images = []
for idx in filters:
img = visualize_activation(model, layer_idx, filter_indices=idx)
# Utility to overlay text on image.
img = utils.draw_text(img, ' {}'.format(idx))
vis_images.append(img)
stitched = utils.stitch_images(vis_images, cols=8)
plt.axis('off')
plt.imshow(stitched)
plt.title(layer_name)
# plt.show()
plt.savefig("filter_vis_"+args.network+".png")
