def activation_maximization(model, output_layer_name, losses, seed_input): """ Visualize internal representation using activation maximization """ activation_maximization = ActivationMaximization(eval_model, clone=False) activation = activation_maximization( losses, seed_input=seed_input, steps=300, input_modifiers=[], regularizers=[], input_range=(0.0, 1.0), callbacks=[Print(interval=50)], ) image = (activation[0, :, :, 0] * 255.0).astype(np.uint8) subplot_args = { "nrows": 1, "ncols": 1, "figsize": (5, 5), "subplot_kw": { "xticks": [], "yticks": [] }, } f, ax = plt.subplots(**subplot_args) ax.imshow(image, cmap="gray") plt.tight_layout() plt.show()
def test__call__with_mutiple_inputs_model(multiple_inputs_model): activation_maximization = ActivationMaximization(multiple_inputs_model) result = activation_maximization(SmoothedLoss(1), steps=1, input_modifiers=None) assert result[0].shape == (1, 8, 8, 3) assert result[1].shape == (1, 8, 8, 3)
def test__call__if_loss_is_None(cnn_model): activation_maximization = ActivationMaximization(cnn_model) try: activation_maximization(None, steps=1) assert False except ValueError: assert True
def test__call__with_mutiple_inputs_model(multiple_inputs_model): activation_maximization = ActivationMaximization(multiple_inputs_model) result = activation_maximization(CategoricalScore(1, 2), steps=1, input_modifiers=None) assert result[0].shape == (1, 8, 8, 3) assert result[1].shape == (1, 10, 10, 3)
def test__call__with_mutiple_outputs_model(multiple_outputs_model): activation_maximization = ActivationMaximization(multiple_outputs_model) result = activation_maximization(SmoothedLoss(1), steps=1, input_modifiers=None) assert result.shape == (1, 8, 8, 3) activation_maximization = ActivationMaximization(multiple_outputs_model) result = activation_maximization([SmoothedLoss(1), SmoothedLoss(1)], steps=1, input_modifiers=None) assert result.shape == (1, 8, 8, 3) activation_maximization = ActivationMaximization(multiple_outputs_model) result = activation_maximization([SmoothedLoss(1), SmoothedLoss(1)], steps=1, input_modifiers=None, regularizers=[TotalVariation(10.), L2Norm(10.)]) assert result.shape == (1, 8, 8, 3)
def test__call__with_callback(cnn_model): activation_maximization = ActivationMaximization(cnn_model) mock = MockCallback() result = activation_maximization(SmoothedLoss(1), steps=1, callbacks=mock) assert result.shape == (1, 8, 8, 3) assert mock.on_begin_was_called assert mock.on_call_was_called assert mock.on_end_was_called
def test__call__(self, model, layer, expected_error): assert model.outputs[0].shape.as_list() == [None, 2] with assert_raises(expected_error): instance = ActivationMaximization(model, model_modifier=ExtractIntermediateLayer(layer)) assert instance.model != model assert instance.model.outputs[0].shape.as_list() == [None, 6, 6, 6] instance([CategoricalScore(0)])
def test__call__with_mutiple_outputs_model_but_losses_is_too_many(multiple_outputs_model): activation_maximization = ActivationMaximization(multiple_outputs_model) try: activation_maximization( [SmoothedLoss(1), SmoothedLoss(1), SmoothedLoss(1)], steps=1, input_modifiers=None) assert False except ValueError: assert True
def test__call__with_callback(model): activation_maximization = ActivationMaximization(model) mock = MockCallback() result = activation_maximization(CategoricalScore(1, 2), steps=1, callbacks=mock) assert result.shape == (1, 8, 8, 3) assert mock.on_begin_was_called assert mock.on_call_was_called assert mock.on_end_was_called
def test__call__with_mutiple_outputs_model_but_losses_is_too_many( multiple_outputs_model): activation_maximization = ActivationMaximization(multiple_outputs_model) with pytest.raises(ValueError): activation_maximization([ CategoricalScore(1, 2), CategoricalScore(1, 2), CategoricalScore(1, 2) ], steps=1, input_modifiers=None)
def _make_actmax(self, img_array, model, layer_name, filter_idx, add_text=False): layer_idx = model.get_layer(name=layer_name) model_modifier = generate_model_modifier(layer_name) loss = generate_loss(filter_idx) activation_maximization = ActivationMaximization(model, model_modifier, clone=True) # Generate max activation activation = activation_maximization(loss, callbacks=[Print(interval=50)]) image = activation[0].astype(np.uint8) image = keras.preprocessing.image.array_to_img(image) return image
def test__call__with_mutiple_outputs_model(multiple_outputs_model): activation_maximization = ActivationMaximization(multiple_outputs_model) result = activation_maximization(CategoricalScore(1, 2), steps=1, input_modifiers=None) assert result.shape == (1, 8, 8, 3) activation_maximization = ActivationMaximization(multiple_outputs_model) result = activation_maximization( [CategoricalScore(1, 2), CategoricalScore(1, 2)], steps=1, input_modifiers=None) assert result.shape == (1, 8, 8, 3) activation_maximization = ActivationMaximization(multiple_outputs_model) result = activation_maximization( [CategoricalScore(1, 2), CategoricalScore(1, 2)], steps=1, input_modifiers=None, regularizers=[TotalVariation(10.), L2Norm(10.)]) assert result.shape == (1, 8, 8, 3)
def test__call__(self, model): assert model.get_layer(name='output_1').activation != tf.keras.activations.linear if len(model.outputs) > 1: assert model.get_layer(name='output_2').activation != tf.keras.activations.linear instance = ActivationMaximization(model, model_modifier=ReplaceToLinear()) assert instance.model != model assert instance.model.get_layer(name='output_1').activation == tf.keras.activations.linear if len(model.outputs) > 1: assert instance.model.get_layer( name='output_2').activation == tf.keras.activations.linear instance([CategoricalScore(0), CategoricalScore(0)]) else: instance([CategoricalScore(0)])
def visualize_dense_layer(model, layer_name, index_label_map, itr): def model_modifier(m): m.layers[-1].activation = tf.keras.activations.linear imgs = [] labels = [] for index, label in index_label_map.items(): activation_maximization = ActivationMaximization(model, model_modifier) loss = lambda x: K.mean(x[:, index - 1]) activation = activation_maximization(loss, steps=itr, callbacks=[Print(interval=100)]) img = activation[0].astype(np.uint8) img = np.squeeze(img, 2) cv2.imwrite(label + ".png", img) imgs.append(img) labels.append(label) plot_images(imgs, labels, 400, layer_name)
def visualize_conv_layer_filters(model, layer_name): def model_modifier(m): new_model = tf.keras.Model( inputs=m.inputs, outputs=[m.get_layer(name=layer_name).output]) new_model.layers[-1].activation = tf.keras.activations.linear return new_model activation_maximization = ActivationMaximization(model, model_modifier) num_of_filters = 16 filter_numbers = np.random.choice( model.get_layer(name=layer_name).output.shape[-1], num_of_filters) vis_images = [] for filter_number in enumerate(filter_numbers): # Define loss function that is sum of a filter output. loss = SmoothedLoss(filter_number) # Generate max activation activation = activation_maximization(loss) image = activation[0].astype(np.uint8) vis_images.append(image) plot_images(vis_images, None, 400, layer_name)
h5_fn = ('MODELS/CNN_4_classes_old.h5') model = keras.models.load_model(h5_fn) print(model.summary()) ######################################################################################################################## from tf_keras_vis.activation_maximization import ActivationMaximization import tensorflow as tf def model_modifier(m): m.layers[-1].activation = tf.keras.activations.linear activation_maximization = ActivationMaximization(model, model_modifier, clone=False) from tf_keras_vis.utils.callbacks import Print for filter_number in range(numClasses): def loss(output): return output[..., filter_number] activation = activation_maximization(loss, callbacks=[Print(interval=50)]) image = np.squeeze(activation[0].astype(np.uint8)) subplot_args = {'nrows': 1, 'ncols': 1, 'figsize': (5, 5)} f, ax = plt.subplots(**subplot_args) im = ax.imshow(image)
def test__call__with_gradient_modifier(cnn_model): activation_maximization = ActivationMaximization(cnn_model) result = activation_maximization(SmoothedLoss(1), steps=1, gradient_modifier=lambda x: x) assert result.shape == (1, 8, 8, 3)
def test__call__with_seed_input(cnn_model): activation_maximization = ActivationMaximization(cnn_model) result = activation_maximization(SmoothedLoss(1), seed_input=np.random.sample((8, 8, 3)), steps=1) assert result.shape == (1, 8, 8, 3)
def test__call__if_loss_is_list(cnn_model): activation_maximization = ActivationMaximization(cnn_model) result = activation_maximization([SmoothedLoss(1)], steps=1) assert result.shape == (1, 8, 8, 3)
def test__call__(cnn_model): activation_maximization = ActivationMaximization(cnn_model) result = activation_maximization(SmoothedLoss(1), steps=1) assert result.shape == (1, 8, 8, 3)
def test__call__with_gradient_modifier(model): activation_maximization = ActivationMaximization(model) result = activation_maximization(CategoricalScore(1, 2), steps=1, gradient_modifier=lambda x: x) assert result.shape == (1, 8, 8, 3)
from tf_keras_vis.activation_maximization import ActivationMaximization from tf_keras_vis.utils.callbacks import GifGenerator from tf_keras_vis.utils.callbacks import Print from tensorflow.keras.models import load_model MODEL_PATH = r"C:\NN\Experiments\DropletDetection\2020-01-29 07-55-29 - MediumNet_run2\checkpoint\best_epoch-00023_val-loss-0.01.hdf5" class_to_maximize = 0 model = load_model(MODEL_PATH) # Define modifier to replace a softmax function of the last layer to a linear function. def model_modifier(m): m.layers[-1].activation = tf.keras.activations.linear # Create Activation Maximization object activation_maximization = ActivationMaximization(model, model_modifier) loss = lambda x: K.mean(x[:, class_to_maximize]) activation = activation_maximization( loss, steps=512, callbacks=[Print(interval=100), GifGenerator('activation_maximization')]) image = activation[0].astype(np.uint8) plt.figure() plt.imshow(image)
def test__call__if_loss_is_None(model): activation_maximization = ActivationMaximization(model) with pytest.raises(ValueError): activation_maximization(None, steps=1)
def test__call__(model): activation_maximization = ActivationMaximization(model) result = activation_maximization(CategoricalScore(1, 2), steps=1) assert result.shape == (1, 8, 8, 3)
def test__call__with_seed_input(model): activation_maximization = ActivationMaximization(model) result = activation_maximization(CategoricalScore(1, 2), seed_input=np.random.sample((8, 8, 3)), steps=1) assert result.shape == (1, 8, 8, 3)
def test__call__if_loss_is_list(model): activation_maximization = ActivationMaximization(model) result = activation_maximization([CategoricalScore(1, 2)], steps=1) assert result.shape == (1, 8, 8, 3)