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 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 get_img(idx, name): #img = visualize_activation_tf(vis_img_input,end_points,name, filter_indices=idx, max_iter=600, act_max_weight=1.,tv_weight=0.01,lp_norm_weight=10, input_modifiers=[Jitter(16)], verbose=True) #img = visualize_activation_tf(vis_img_input,end_points,name, filter_indices=idx, max_iter=600, act_max_weight=1.,tv_weight=0.01,lp_norm_weight=10, input_modifiers=[Jitter(16)], verbose=True) seed = visualize_activation_tf(vis_img_input, end_points, name, filter_indices=idx, act_max_weight=8., tv_weight=0., input_modifiers=[Jitter(0.05)], verbose=True) img = visualize_activation_tf(vis_img_input, end_points, name, filter_indices=idx, seed_input=seed, input_modifiers=[Jitter(0.05)], verbose=True) return img
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 get_img(idx, name): img = visualize_activation_tf(inputs, end_points, name, filter_indices=idx, max_iter=600, act_max_weight=1., tv_weight=0.01, lp_norm_weight=10, input_modifiers=[Jitter(16)], verbose=True) return img
def vis_4(): import numpy as np # categories = np.random.permutation(1000)[:15] vis_images = [] image_modifiers = [Jitter(16)] for idx in range(10): print('filter_indices_: ' + str(idx + 1)) img = visualize_activation(model, layer_idx, filter_indices=idx, max_iter=4000, input_modifiers=image_modifiers) save_image(img, '[4000]filter_' + str(idx + 1) + '.png')
def generate_max_activation(model, gradmod, backprop): activations = visualize_activation(model, -1, filter_indices=[0], verbose=True, input_modifiers=[Jitter(16)], backprop_modifier=backprop, grad_modifier=gradmod, act_max_weight=1, lp_norm_weight=10, tv_weight=10) plt.imsave('activations_inferno.eps', activations[:, :, 0], cmap='inferno') plt.imsave('activations_plasma.eps', activations[:, :, 0], cmap='plasma') plt.imsave('activations_magma.eps', activations[:, :, 0], cmap='magma') plt.imsave('activations_gray.eps', activations[:, :, 0], cmap='gray') plt.imsave('activations_viridis.eps', activations[:, :, 0], cmap='viridis')
def layered_actmax(sample_count): for layer_nm in layerlist_for_layered_actmax: layer_idx = utils.find_layer_idx(model, layer_nm) num_filters = get_num_filters(model.layers[layer_idx]) drawn_filters = random.choices(np.arange(num_filters), k=sample_count) for filter_id in drawn_filters: img = visualize_activation(model, layer_idx, filter_indices=filter_id, input_modifiers=[Jitter(16)]) img = img.reshape(IMG_SIZE, IMG_SIZE, IMG_DEPTH) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) plt.imshow(img, cmap='gray') img_path = os.path.join(IMG_DIR, layer_nm + '_' + str(filter_id) + '.jpg') plt.imsave(img_path, img) print(f'Saved layer {layer_nm}/{filter_id} to file!') print('done!')
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 apply(self, model, layer, filter, nb_iter): # Changer l'activation softmax par linear model.layers[layer].activation = activations.linear model = utils.apply_modifications(model) img = visualize_activation(model, layer, filter_indices=filter, max_iter=nb_iter, tv_weight=1., lp_norm_weight=0., verbose=True, input_modifiers=[Jitter(16)]) if img.shape[2] == 1: image = np.zeros(shape=(int(img.shape[0]), int(img.shape[1]), 3)) for i in range(len(image)): for j in range(len(image[i])): image[i][j][0] = img[i][j][0] image[i][j][1] = img[i][j][0] image[i][j][2] = img[i][j][0] img = image return img
def main(): for domain in domains: for model_name in model_names: for init_opt in init_opts: for preprocess_opt in preprocess_opts: for stage in stages: log_path = os.path.join(log_path_main, domain, model_name, init_opt, stage) if not os.path.exists(log_path): os.makedirs(log_path) fold = '0' K.clear_session() if init_opt == 'random': model = model_loader.load_full_model( model_name, random_weights=True, no_cats=2) elif init_opt == 'ImageNet': model = model_loader.load_full_model( model_name, random_weights=False, no_cats=2) elif init_opt == 'fine-tuned': # fine-tuned from ImageNet model_path = os.path.join('log', domain, model_name, 'ImageNet', preprocess_opt, fold, 'stage_5.h5') model = model_loader.load_full_model(model_name, no_cats=2) model.load_weights(model_path) # keras.utils.plot_model(model, to_file=os.path.join(log_path_main, model_name + '.png')) if model_name == 'ResNet50': end_layer = ResNet50_layer_names[stage] elif model_name == 'VGG19': end_layer = VGG19_layer_names[stage] ind_layer = utils.find_layer_idx(model, end_layer) model.layers[-1].activation = keras.activations.linear model = utils.apply_modifications(model) #for ind_filter in range(model.layers[ind_layer].output_shape[-1]): for ind_filter in range( min(200, model.layers[ind_layer].output_shape[-1])): if stage == 'stage_1': img = visualize_activation( model, ind_layer, filter_indices=ind_filter, input_modifiers=[Jitter()], tv_weight=0, max_iter=200) elif stage == 'stage_2': img = visualize_activation( model, ind_layer, filter_indices=ind_filter, input_modifiers=[Jitter()], tv_weight=1, max_iter=200) elif stage == 'stage_3': img = visualize_activation( model, ind_layer, filter_indices=ind_filter, input_modifiers=[Jitter()], tv_weight=2, max_iter=200) elif stage == 'stage_4': img = visualize_activation( model, ind_layer, filter_indices=ind_filter, input_modifiers=[Jitter()], tv_weight=1, max_iter=200) elif stage == 'stage_5': img = visualize_activation( model, ind_layer, filter_indices=ind_filter, input_modifiers=[Jitter()], tv_weight=0, max_iter=200) elif stage == 'stage_final': img = visualize_activation( model, ind_layer, filter_indices=ind_filter, input_modifiers=[Jitter()], tv_weight=2, max_iter=400) img = Image.fromarray(img, 'RGB') img.save( os.path.join(log_path, str(ind_filter) + '.png'), 'PNG')
steps=10) print('Test loss: {:.4f}. Test Accuracy: {:.4f}'.format( test_loss, test_accuracy)) if args.layer_to_visualize: print('Visualizing model activation') filters_to_visualize = [0, 1, 2, 3, 4, 5, 6, 7] for filter_to_visualize in filters_to_visualize: print('Visualizing layer {} filter {}'.format( model.layers[args.layer_to_visualize].name, filter_to_visualize)) visualization = visualize_activation( model, args.layer_to_visualize, filter_indices=filter_to_visualize, input_modifiers=[Jitter(0)]) plt.imshow(visualization) plt.title(f'Filter = {filter_to_visualize}') plt.axis('off') plt.show() def display(display_list): plt.figure(figsize=(15, 15)) title = ['Input Image', 'True Mask', 'Predicted Mask'] for i in range(len(display_list)): plt.subplot(1, len(display_list), i + 1) plt.title(title[i]) plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))
from vis.losses import ActivationMaximization from vis.regularizers import TotalVariation, LPNorm from vis.input_modifiers import Jitter from vis.optimizer import Optimizer from vis.callbacks import GifGenerator if __name__ == "__main__": lucky_num = 50756711264384381850616619995309447969109689825336919605444730053665222018857 % (2 ** 32) np.random.seed(lucky_num) set_random_seed(lucky_num) os.environ["CUDA_VISIBLE_DEVICES"] = "2" modelH5 = sys.argv[1] # outputDir = sys.argv[2] model = load_model(modelH5) layerDict = dict([(layer.name, layer) for layer in model.layers[1:]]) layerName = "dense_5" for idx in range(7): outputClass = [0] losses = [(ActivationMaximization(layerDict[layerName], outputClass), 2), (LPNorm(model.input), 10), (TotalVariation(model.input), 10)] opt = Optimizer(model.input, losses) opt.minimize(max_iter=500, verbose=True, input_modifiers=[Jitter()], callbacks=[GifGenerator('OptProgress_%d' % (idx))])
plt.rcParams['figure.figsize'] = (18, 6) # 20 is the imagenet category for 'ouzel' 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 = []
# # layer_idx_conv = utils.find_layer_idx(model, 'predictions') model.layers[layer_idx_conv].activation = activations.linear model = utils.apply_modifications(model) filter_indices = 392 # 卷積層的卷積核的最大激活input=========================================================================== # 觀察第一個卷積層的第2個卷積核(filter_indices=1)的最大激活input,這個最大激活input即可表示這個卷積核所關注並提取的特征(人為可理解的) # data_input_c[:,:,:,0]=max_activition_norm # max_activition_norm = visualize_activation(model, layer_idx_conv, filter_indices=filter_indices, max_iter=1000, input_modifiers=[Jitter(9)], verbose=True,seed_input=data_input_c) max_activition_norm = visualize_activation(model, layer_idx_conv, filter_indices=filter_indices, max_iter=5000, input_modifiers=[Jitter(16)], verbose=True) # max_activition_norm = np.squeeze(max_activition_norm, axis=-1) for ii in range(1): plt.figure() # max_activition_piece = max_activition_norm[:, :, ii] plt.imshow(max_activition_norm) # plt.imshow((data_input_c[:,:,ii,0]), cmap=plt.cm.jet) plt.title(str(filter_indices)) plt.show() # plt.figure() # plt.imshow(max_activition_norm) # # plt.imshow((data_input_c[:,:,ii,0]), cmap=plt.cm.jet) # plt.title(str(filter_indices)) # plt.show()
layer_idx = utils.find_layer_idx(model, 'batch_normalization_xx') print(model.layers[layer_idx].get_weights()) ''' for layer_name in layer_names: layer_idx = utils.find_layer_idx(model, layer_name) # Visualize all filters in this layer. filters = np.arange(get_num_filters(model.layers[layer_idx])) vis_images = [] for idx in filters: #if idx % 2 == 0: # Generate input image for each filter. img = visualize_activation( model, layer_idx, filter_indices=idx, act_max_weight=10, lp_norm_weight=0.01, tv_weight=0.05 #, lp_norm_weight=0, tv_weight=0 , max_iter=200, input_modifiers=[Jitter()]) #, verbose=True vis_images.append(img) print(idx) stitched = utils.stitch_images(vis_images, cols=24) scipy.misc.imsave(layer_name + '.png', stitched)
from vis.losses import ActivationMaximization from vis.regularizers import TotalVariation, LPNorm from vis.input_modifiers import Jitter from vis.optimizer import Optimizer from vis.callbacks import GifGenerator from vis.utils.vggnet import VGG16 # 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_dict = dict([(layer.name, layer) for layer in model.layers[1:]]) output_class = [20] losses = [(ActivationMaximization(layer_dict[layer_name], output_class), 2), (LPNorm(model.input), 10), (TotalVariation(model.input), 10)] opt = Optimizer(model.input, losses) opt.minimize(max_iter=500, verbose=True, image_modifiers=[Jitter()], callbacks=[GifGenerator('opt_progress')])
# plt.imshow(img[...,0]) #plt.show() #img = visualize_activation(model,layer_idx,filter_indices =7,max_iter=500,input_range=(0., 1.),input_modifiers=[Jitter(16)]) #plt.figure() #plt.imshow(img) #plt.show() vis_images = [] for idx in filters: img = visualize_activation(model, layer_idx, filter_indices=idx, tv_weight=0, lp_norm_weight=0.1, input_modifiers=[Jitter(0.05)]) vis_images.append(img) new_vis_image = [] for i, idx in enumerate(filters): img = visualize_activation(model, layer_idx, filter_indices=idx, max_iter=1000, tv_weight=0.3, lp_norm_weight=0.4, seed_input=vis_images[i], input_modifiers=[Jitter(0.05)]) new_vis_image.append(img)
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