def embed_data(x, dset): ''' Convenience function: embeds x into the code space using the corresponding autoencoder (specified by dset). ''' if not len(x): return np.zeros(shape=(0, 10)) if dset == 'reuters': dset = 'reuters10k' json_path = '../pretrain_weights/ae_{}.json'.format(dset) weights_path = '../pretrain_weights/ae_{}_weights.h5'.format(dset) with open(json_path) as f: pt_ae = model_from_json(f.read()) pt_ae.load_weights(weights_path) x = x.reshape(-1, np.prod(x.shape[1:])) get_embeddings = K.function([pt_ae.input], [pt_ae.layers[3].output]) get_reconstruction = K.function([pt_ae.layers[4].input], [pt_ae.output]) x_embedded = predict_with_K_fn(get_embeddings, x)[0] x_recon = predict_with_K_fn(get_reconstruction, x_embedded)[0] reconstruction_mse = np.mean(np.square(x - x_recon)) print( "using pretrained embeddings; sanity check, total reconstruction error:", np.mean(reconstruction_mse)) del pt_ae return x_embedded
def do_activation(input_values, function_name, alpha=0.2): """Runs input array through activation function. :param input_values: numpy array (any shape). :param function_name: Name of activation function (must be accepted by ``). :param alpha: Slope parameter (alpha) for activation function. This applies only for eLU and ReLU. :return: output_values: Same as `input_values` but post-activation. """ architecture_utils.check_activation_function( activation_function_string=function_name, alpha_for_elu=alpha, alpha_for_relu=alpha ) input_object = K.placeholder() if function_name == architecture_utils.ELU_FUNCTION_STRING: function_object = K.function( [input_object], [layers.ELU(alpha=alpha)(input_object)] ) elif function_name == architecture_utils.RELU_FUNCTION_STRING: function_object = K.function( [input_object], [layers.LeakyReLU(alpha=alpha)(input_object)] ) else: function_object = K.function( [input_object], [layers.Activation(function_name)(input_object)] ) return function_object([input_values])[0]
def create_mtcnn(self, sess, model_path): tf.disable_eager_execution() if not model_path: model_path, _ = os.path.split(os.path.realpath(__file__)) with tf.variable_scope('pnet'): data = tf.placeholder(tf.float32, (None, None, None, 3), 'input') pnet = mtcnn_detect_face.PNet({'data': data}) pnet.load(os.path.join(model_path, 'det1.npy'), sess) with tf.variable_scope('rnet'): data = tf.placeholder(tf.float32, (None, 24, 24, 3), 'input') rnet = mtcnn_detect_face.RNet({'data': data}) rnet.load(os.path.join(model_path, 'det2.npy'), sess) with tf.variable_scope('onet'): data = tf.placeholder(tf.float32, (None, 48, 48, 3), 'input') onet = mtcnn_detect_face.ONet({'data': data}) onet.load(os.path.join(model_path, 'det3.npy'), sess) self.pnet = K.function([pnet.layers['data']], [pnet.layers['conv4-2'], pnet.layers['prob1']]) self.rnet = K.function([rnet.layers['data']], [rnet.layers['conv5-2'], rnet.layers['prob1']]) self.onet = K.function([onet.layers['data']], [ onet.layers['conv6-2'], onet.layers['conv6-3'], onet.layers['prob1'] ])
def compute_activation(self, lidx, test): if lidx < 0: return test inp = self.model.input functor = K.function([inp, K.learning_phase()], [self.model.layers[lidx].output]) return functor([test])[0]
def main(): model = load_model('/home/dzd/dzd/labwork/face/CNN/model/CNN_model.h5') image = cv2.imread(os.path.join('/home/dzd/dzd/labwork/face/yaleBExtData/yaleB01', 'yaleB01_P00A-005E-10.pgm'), cv2.IMREAD_GRAYSCALE) # images=cv2.imread("/home/dzd/dzd/labwork/face/yaleBExtData/yaleB01/yaleB01_P00A-005E-10.pgm") # cv2.imshow("Image", images) # cv2.waitKey(0) # Turn the image into an array. # 根据载入的训练好的模型的配置,将图像统一尺寸 # image_arr = cv2.resize(image, (192, 168)) image.resize(192, 168) image_arr = np.array(image).reshape(1,192,168,1) # image_arr = np.expand_dims(image_arr, axis=0) # 第一个 model.layers[0],不修改,表示输入数据; # 第二个model.layers[ ],修改为需要输出的层数的编号[] layer_1 = K.function([model.layers[0].input], [model.layers[6].output]) # visualization_model = K.function([model.layers[0].input], [model.layers[1].output]) # 只修改inpu_image # f1 = visualization_model.predict(images/255.0) f1 = layer_1([image_arr/255.0])[0] # 第一层卷积后的特征图展示,输出是(1,66,66,32),(样本个数,特征图尺寸长,特征图尺寸宽,特征图个数) for _ in range(32): show_img = f1[:, :, :, _] show_img = show_img.reshape(len(show_img[0]),len(show_img[0][0])) # show_img.shape = [66, 66] plt.subplot(4, 8, _ + 1) # plt.imshow(show_img, cmap='black') plt.imshow(show_img, cmap='gray') plt.axis('off') plt.show()
def __init__(self, restore=None, session=None, use_log=False): self.num_channels = 1 self.image_size = 28 self.num_labels = 10 model = Sequential() model.add(Flatten(input_shape=(28, 28, 1))) model.add(Dense(1024)) model.add(Lambda(lambda x: x * 10)) model.add(Activation('softplus')) model.add(Lambda(lambda x: x * 0.1)) model.add(Dense(10)) # output log probability, used for black-box attack if use_log: model.add(Activation('softmax')) if restore: model.load_weights(restore) layer_outputs = [] for layer in model.layers: if isinstance(layer, Conv2D) or isinstance(layer, Dense): layer_outputs.append( K.function([model.layers[0].input], [layer.output])) self.layer_outputs = layer_outputs self.model = model
def __init__(self, restore=None, session=None, use_log=False, use_brelu=False): def bounded_relu(x): return K.relu(x, max_value=1) if use_brelu: activation = bounded_relu else: activation = 'relu' self.num_channels = 1 self.image_size = 28 self.num_labels = 10 model = Sequential() model.add(Conv2D(32, (3, 3), input_shape=(28, 28, 1))) model.add(Activation(activation)) model.add(Conv2D(32, (3, 3))) model.add(Activation(activation)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3))) model.add(Activation(activation)) model.add(Conv2D(64, (3, 3))) model.add(Activation(activation)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(200)) model.add(Activation(activation)) model.add(Dense(200)) model.add(Activation(activation)) model.add(Dense(10)) # output log probability, used for black-box attack if use_log: model.add(Activation('softmax')) if restore: model.load_weights(restore) layer_outputs = [] for layer in model.layers: if isinstance(layer, Conv2D) or isinstance(layer, Dense): layer_outputs.append( K.function([model.layers[0].input], [layer.output])) self.model = model self.layer_outputs = layer_outputs
def embed_data(x, dset, path): """embeds x into the code space using the autoencoder.""" if x: return np.zeros(shape=(0, 10)) # load model and weights json_path = os.path.join(path, 'ae_{}.json'.format(dset)) print('load model from json file:', json_path) with gfile.Open(json_path) as f: pt_ae = model_from_json(f.read()) weights_path = os.path.join(path, 'ae_{}_weights.h5'.format(dset)) print('load code spase from:', weights_path) local_filename = weights_path.split('/')[-1] tmp_filename = os.path.join(tempfile.gettempdir(), str(int(time.time())) + '_' + local_filename) gfile.Copy(weights_path, tmp_filename) pt_ae.load_weights(tmp_filename) gfile.Remove(tmp_filename) print('***********************', x.shape) x = x.reshape(-1, np.prod(x.shape[1:])) print('***********************', x.shape) get_embeddings = K.function([pt_ae.input], [pt_ae.layers[3].output]) get_reconstruction = K.function([pt_ae.layers[4].input], [pt_ae.output]) x_embedded = predict_with_k_fn(get_embeddings, x)[0] x_recon = predict_with_k_fn(get_reconstruction, x_embedded)[0] reconstruction_mse = np.mean(np.square(x - x_recon)) print( 'using pretrained embeddings; sanity check, total reconstruction error:', np.mean(reconstruction_mse)) del pt_ae return x_embedded
def predict_stochastic(neural_net): """ Have the neural network make predictions with the Dropout layers on, resulting in stochastic behavior from the neural net itself. Args: neural_net: data: Returns: """ input = neural_net.input output = neural_net.output pred_func = K.function(input + [K.learning_phase()], [output]) return pred_func
def inject(self, model): """Inject the Lookahead algorithm for the given model. The following code is modified from keras's _make_train_function method. See: https://github.com/keras-team/keras/blob/master/keras/engine/training.py#L497 """ if not hasattr(model, 'train_function'): raise RuntimeError('You must compile your model before using it.') model._check_trainable_weights_consistency() if model.train_function is None: inputs = (model._feed_inputs + model._feed_targets + model._feed_sample_weights) if model._uses_dynamic_learning_phase(): inputs += [K.learning_phase()] fast_params = model._collected_trainable_weights with K.name_scope('training'): with K.name_scope(model.optimizer.__class__.__name__): training_updates = model.optimizer.get_updates( params=fast_params, loss=model.total_loss) slow_params = [K.variable(p) for p in fast_params] fast_updates = (model.updates + training_updates + model.metrics_updates) slow_updates, copy_updates = [], [] for p, q in zip(fast_params, slow_params): slow_updates.append(K.update(q, q + self.alpha * (p - q))) copy_updates.append(K.update(p, q)) # Gets loss and metrics. Updates weights at each call. fast_train_function = K.function(inputs, [model.total_loss] + model.metrics_tensors, updates=fast_updates, name='fast_train_function', **model._function_kwargs) def F(inputs): self.count += 1 R = fast_train_function(inputs) if self.count % self.k == 0: K.batch_get_value(slow_updates) K.batch_get_value(copy_updates) return R model.train_function = F
def grad_cam(input_model, image, cls, layer_name, H=320, W=320): """GradCAM method for visualizing input saliency.""" y_c = input_model.output[0, cls] conv_output = input_model.get_layer(layer_name).output grads = K.gradients(y_c, conv_output)[0] gradient_function = K.function([input_model.input], [conv_output, grads]) output, grads_val = gradient_function([image]) output, grads_val = output[0, :], grads_val[0, :, :, :] weights = np.mean(grads_val, axis=(0, 1)) cam = np.dot(output, weights) # Process CAM cam = cv2.resize(cam, (W, H), cv2.INTER_LINEAR) cam = np.maximum(cam, 0) cam = cam / cam.max() return cam
def __init__(self, model_path=None): self.model_path = model_path self.model_path_start = "/".join(model_path.split("/")[:-1]) self.model_config = model_path.split("/")[-1].split("_")[2] self.model = load_model(self.model_path, custom_objects={ "Interpolate1D": Interpolate1D, "ConcreteDropout": ConcreteDropout, "Split1D": Split1D, "Scale": Scale, "AutoScale": AutoScale }) self.pred_func = K.function(self.model.input + [K.learning_phase()], [self.model.output]) self.x_scaling_file = join( self.model_path_start, "gan_X_scaling_values_{0}.csv".format(self.model_config)) self.y_scaling_file = join( self.model_path_start, "gan_Y_scaling_values_{0}.csv".format(self.model_config)) self.y_scaling_values = pd.read_csv(self.y_scaling_file, index_col="Channel") self.x_scaling_values = pd.read_csv(self.x_scaling_file, index_col="Channel")
def on_train_begin(self, logs={}): if not os.path.exists(self.cfg['SAVE_DIR']): print("Making directory", self.cfg['SAVE_DIR']) os.makedirs(self.cfg['SAVE_DIR']) # Indexes of the layers which we keep track of. Basically, this will be any layer # which has a 'kernel' attribute, which is essentially the "Dense" or "Dense"-like layers self.layerixs = [] # Functions return activity of each layer self.layerfuncs = [] # Functions return weights of each layer self.layerweights = [] for lndx, l in enumerate(self.model.layers): if hasattr(l, 'kernel'): self.layerixs.append(lndx) self.layerfuncs.append( K.function(self.model.inputs, [ l.output, ])) self.layerweights.append(l.kernel) # print(self.model._feed_inputs) # print(self.model._feed_sample_weights) # print(self.model._feed_targets) inputs = [ self.model._feed_inputs, self.model._feed_targets, self.model._feed_sample_weights, K.learning_phase() ] # inputs = [self.model.input, # self.model._feed_targets, # self.model._feed_sample_weights, # backend.symbollearning_phase() # ] # inputs =(3277,12) # print(inputs) # grads_fn = K.function(inputs=[model.inputs[0], # model._feed_targets[0], # backend.symbolic_learning_phase()], # outputs=grads) # g_learning = grads_fn([x, x, True]) # g_not_learning = grads_fn([x, x, False]) # [model.inputs[0], model._feed_targets[0], model.sample_weights[0]] # Get gradients of all the relevant layers at once grads = self.model.optimizer.get_gradients(self.model.total_loss, self.layerweights) self.get_gradients = K.function(inputs=inputs, outputs=grads) # Get cross-entropy loss self.get_loss = K.function(inputs=inputs, outputs=[ self.model.total_loss, ])
def activations_norm(images, labels, batch_size, model, layer_regex, daug_params, norms=['fro']): """ Computes the norm of the activation of all feature maps Parameters ---------- images : h5py Dataset The set of images labels : h5py Dataset The ground truth labels batch_size : int Batch size model : Keras Model The model daug_params : dict Dictionary of data augmentation parameters Returns ------- results_dict : dict Dictionary containing some performance metrics """ def _update_stats(mean_norm, std_norm, norm): mean_norm_batch = np.mean(norm, axis=0) std_norm_batch = np.std(norm, axis=0) mean_norm = init / float(end) * mean_norm + \ batch_size / float(end) * mean_norm_batch std_norm = init / float(end) * std_norm ** 2 + \ batch_size / float(end) * std_norm_batch ** 2 + \ (init * batch_size) / float(end ** 2) * \ (mean_norm - mean_norm_batch) ** 2 std_norm = np.sqrt(std_norm) return mean_norm, std_norm def _frobenius_norm(activations): norm = np.linalg.norm( activations, ord='fro', axis=tuple(range(1, len(activations.shape) - 1))) return norm def _inf_norm(activations): norm = np.max(np.abs(activations), axis=tuple(range(1, len(activations.shape) - 1))) return norm n_images = images.shape[0] n_batches_per_epoch = int(np.ceil(float(n_images) / batch_size)) # Create batch generator image_gen = get_generator(images, **daug_params) batch_gen = batch_generator(image_gen, images, labels, batch_size, aug_per_im=1, shuffle=False) # Initialize list to store the mean norm of the activations results_dict = {'activations_norm': {}, 'summary': {}} # Iterate over the layers model = del_extra_nodes(model) for layer in model.layers: if re.match(layer_regex, layer.name): layer_name = layer.name.encode('utf-8') print('\nLayer {}'.format(layer_name)) output = model.get_layer(layer_name)\ .outbound_nodes[0].input_tensors[0] get_output = K.function([model.input, K.learning_phase()], [output]) n_channels = K.int_shape(output)[-1] results_dict['activations_norm'].update({layer_name: {n: {'mean': np.zeros(n_channels), 'std': np.zeros(n_channels)} for n in norms}}) layer_dict = results_dict['activations_norm'][layer_name] init = 0 batch_gen.image_gen.reset() for _ in tqdm(range(n_batches_per_epoch)): batch_images, _ = next(batch_gen()) batch_size = batch_images.shape[0] end = init + batch_size activations = get_output([batch_images, 0])[0] for norm_key in norms: mean_norm = layer_dict[norm_key]['mean'] std_norm = layer_dict[norm_key]['std'] if norm_key == 'fro': norm = _frobenius_norm(activations) elif norm_key == 'inf': norm = _inf_norm(activations) else: raise NotImplementedError('Implemented norms are fro ' 'and inf') mean_norm, std_norm = _update_stats(mean_norm, std_norm, norm) layer_dict[norm_key]['mean'] = mean_norm layer_dict[norm_key]['std'] = std_norm init = end # Compute summary statistics across the channels for layer, layer_dict in results_dict['activations_norm'].items(): results_dict['summary'].update({layer: {}}) for norm_key, norm_dict in layer_dict.items(): results_dict['summary'][layer].update({norm_key: { 'mean': np.mean(norm_dict['mean']), 'std': np.mean(norm_dict['std'])}}) return results_dict
def activations(images, labels, batch_size, model, layer_regex, nodaug_params, daug_params, include_input=False, class_invariance=False, n_daug_rep=0, norms=['fro']): """ Computes metrics from the activations, such as the norm of the feature maps, data augmentation invariance, class invariance, etc. Parameters ---------- images : h5py Dataset The set of images labels : h5py Dataset The ground truth labels batch_size : int Batch size model : Keras Model The model nodaug_params : dict Dictionary of data augmentation parameters for the baseline daug_params : dict Dictionary of data augmentation parameters include_input : bool If True, the input layer is considered for the analysis class_invariance : bool If True, the class invariance score is computed n_daug_rep : int If larger than 0, the data augentation invariance score is computed, performing n_daug_rep repetitions of random augmentations norms : list List of keywords to specify the types of norms to compute on the activations Returns ------- results_dict : dict Dictionary containing some performance metrics """ def _update_stats(mean_norm, std_norm, norm): mean_norm_batch = np.mean(norm, axis=0) std_norm_batch = np.std(norm, axis=0) mean_norm = init / float(end) * mean_norm + \ batch_size / float(end) * mean_norm_batch std_norm = init / float(end) * std_norm ** 2 + \ batch_size / float(end) * std_norm_batch ** 2 + \ (init * batch_size) / float(end ** 2) * \ (mean_norm - mean_norm_batch) ** 2 std_norm = np.sqrt(std_norm) return mean_norm, std_norm def _frobenius_norm(activations): norm = np.linalg.norm( activations, ord='fro', axis=tuple(range(1, len(activations.shape) - 1))) return norm def _inf_norm(activations): norm = np.max(np.abs(activations), axis=tuple(range(1, len(activations.shape) - 1))) return norm model = del_extra_nodes(model) n_images = images.shape[0] n_batches_per_epoch = int(np.ceil(float(n_images) / batch_size)) # Get relevant layers if include_input: layer_regex = '({}|.*input.*)'.format(layer_regex) else: layer_regex = layer_regex layers = [layer.name for layer in model.layers if re.compile(layer_regex).match(layer.name)] # Initialize HDF5 to store the activations # filename = 'hdf5_aux_{}'.format(time.time()) # activations_hdf5_aux = h5py.File(filename, 'w') # hdf5_aux = [filename] # # grp_activations = activations_hdf5_aux.create_group('activations') if class_invariance: # grp_labels = activations_hdf5_aux.create_group('labels') labels_true_da = [] labels_pred_da = [] predictions_da = [] # labels_true = grp_labels.create_dataset( # 'labels_true', shape=(n_images, ), dtype=np.uint8) # labels_pred = grp_labels.create_dataset( # 'labels_pred', shape=(n_images, ), dtype=np.uint8) # predictions = grp_labels.create_dataset( # 'predictions', shape=labels.shape, dtype=K.floatx()) idx_softmax = model.output_names.index('softmax') store_labels = True else: store_labels = False # Initialize results dictionary results_dict = {'activations_norm': {}, 'summary': {}, 'class_invariance': {}, 'daug_invariance': {}} # Iterate over the layers for layer_name in layers: # Create batch generator image_gen = get_generator(images, **nodaug_params) batch_gen = generate_batches(image_gen, images, labels, batch_size, aug_per_im=1, shuffle=False) layer = model.get_layer(layer_name) layer_shape = layer.output_shape[1:] n_channels = layer_shape[-1] if re.compile('.*input.*').match(layer_name): layer_name = 'input' print('\nLayer {}\n'.format(layer_name)) # Create a Dataset for the activations of the layer # activations_layer = grp_activations.create_dataset( # layer_name, shape=(n_images, ) + layer_shape, # dtype=K.floatx()) # Create dask array for the activations of the layer activations_layer_da = [] # Initialize placeholders in the results dict for the layer results_dict['activations_norm'].update({layer_name: {n: {'mean': np.zeros(n_channels), 'std': np.zeros(n_channels)} for n in norms}}) layer_dict = results_dict['activations_norm'][layer_name] activation_function = K.function([model.input, K.learning_phase()], [layer.output]) # Iterate over the data set in batches init = 0 for batch_images, batch_labels in tqdm( batch_gen, total=n_batches_per_epoch): batch_size = batch_images.shape[0] end = init + batch_size # Store labels if store_labels: preds = model.predict_on_batch(batch_images) if isinstance(preds, list): preds = preds[idx_softmax] labels_pred_da.append(da.from_array( np.argmax(preds, axis=1))) labels_true_da.append(da.from_array( np.argmax(batch_labels, axis=1))) predictions_da.append(da.from_array(preds)) # labels_pred[init:end] = np.argmax(preds, axis=1) # labels_true[init:end] = np.argmax(batch_labels, axis=1) # predictions[init:end, :] = preds # Get and store activations activations = activation_function([batch_images, 0])[0] activations_layer_da.append(da.from_array( activations, chunks=activations.shape)) # activations_layer[init:end] = activations # Compute norms for norm_key in norms: mean_norm = layer_dict[norm_key]['mean'] std_norm = layer_dict[norm_key]['std'] if norm_key == 'fro': norm = _frobenius_norm(activations) elif norm_key == 'inf': norm = _inf_norm(activations) else: raise NotImplementedError('Implemented norms are fro ' 'and inf') mean_norm, std_norm = _update_stats(mean_norm, std_norm, norm) layer_dict[norm_key]['mean'] = mean_norm layer_dict[norm_key]['std'] = std_norm init = end if init == n_images: store_labels = False break # Concatenate dask arrays activations_layer_da = da.concatenate(activations_layer_da, axis=0) activations_layer_da = activations_layer_da.reshape((n_images, -1)) d_activations = activations_layer_da.shape[-1] if class_invariance: print('\nComputing class invariance\n') labels_pred_da = da.concatenate(labels_pred_da) labels_true_da = da.concatenate(labels_true_da) predictions_da = da.concatenate(predictions_da) n_classes = len(np.unique(labels_true_da)) # Compute MSE matrix of the activations r = da.reshape(da.sum(da.square(activations_layer_da), axis=1), (-1, 1)) mse_matrix_da = (r - 2 * da.dot(activations_layer_da, da.transpose(activations_layer_da)) \ + da.transpose(r)) / d_activations mse_matrix_da = mse_matrix_da.rechunk((mse_matrix_da.chunksize[0], mse_matrix_da.shape[-1])) # Compute class invariance time0 = time() results_dict['class_invariance'].update({layer_name: {}}) class_invariance_scores_da = [] if class_invariance: # mse_matrix_mean = da.mean(mse_matrix_da).compute() for cl in tqdm(range(n_classes)): labels_cl = labels_pred_da == cl labels_cl = labels_cl.compute() mse_class = mse_matrix_da[labels_cl, :][:, labels_cl] mse_class = mse_class.rechunk((-1, -1)) # mse_class_mean = da.mean(mse_class).compute() # class_invariance_score = 1. - np.divide( # mse_class_mean, mse_matrix_mean) # results_dict['class_invariance'][layer_name].update( # {cl: class_invariance_score}) class_invariance_scores_da.append( 1. - da.divide(da.mean(mse_class), da.mean(mse_matrix_da))) # Compute data augmentation invariance print('\nComputing data augmentation invariance\n') mse_daug_da = [] results_dict['daug_invariance'].update({layer_name: {}}) for r in range(n_daug_rep): print('Repetition {}'.format(r)) image_gen_daug = get_generator(images, **daug_params) batch_gen_daug = generate_batches(image_gen_daug, images, labels, batch_size, aug_per_im=1, shuffle=False) activations_layer_daug_da = [] # Iterate over the data set in batches to compute activations init = 0 for batch_images, batch_labels in tqdm( batch_gen, total=n_batches_per_epoch): batch_size = batch_images.shape[0] end = init + batch_size # Get and store activations activations = activation_function([batch_images, 0])[0] activations_layer_daug_da.append(da.from_array( activations, chunks=activations.shape)) init = end if init == n_images: break activations_layer_daug_da = da.concatenate( activations_layer_daug_da, axis=0) activations_layer_daug_da = activations_layer_daug_da.reshape( (n_images, -1)) activations_layer_daug_da = activations_layer_daug_da.rechunk( (activations_layer_daug_da.chunksize[0], activations_layer_daug_da.shape[-1])) # Compute MSE daug mse_daug_da.append(da.mean(da.square(activations_layer_da - \ activations_layer_daug_da), axis=1)) mse_daug_da = da.stack(mse_daug_da, axis=1) mse_sum = da.repeat(da.reshape(da.sum(mse_matrix_da, axis=1), (n_images, 1)), n_daug_rep, axis=1) daug_invariance_score_da = 1 - n_images * da.divide(mse_daug_da, mse_sum) time1 = time() # Compute dask results and update results dict results_dask = da.compute(class_invariance_scores_da, daug_invariance_score_da) time2 = time() results_dict['class_invariance'][layer_name].update( {cl: cl_inv_score for cl, cl_inv_score in enumerate(results_dask[0])}) results_dict['daug_invariance'].update({layer_name: {r: daug_inv_score for r, daug_inv_score in enumerate(results_dask[1].T)}}) # Compute summary statistics of the norms across the channels for layer, layer_dict in results_dict['activations_norm'].items(): results_dict['summary'].update({layer: {}}) for norm_key, norm_dict in layer_dict.items(): results_dict['summary'][layer].update({norm_key: { 'mean': np.mean(norm_dict['mean']), 'std': np.mean(norm_dict['std'])}}) return results_dict
def __init__(self, mean_inputs=1, hidden_layers=2, hidden_neurons=8, activation="selu", l2_weight=0.01, learning_rate=0.001, mean_loss="mse", res_loss="kullback_leibler_divergence", noise_sd=1, beta_1=0.9, model_path=None, dropout_alpha=0.5, num_epochs=10, batch_size=1024, val_split=0.5, verbose=0, model_config=0): self.config = dict(mean_inputs=mean_inputs, hidden_layers=hidden_layers, hidden_neurons=hidden_neurons, activation=activation, l2_weight=l2_weight, learning_rate=learning_rate, mean_loss=mean_loss, res_loss=res_loss, noise_sd=noise_sd, beta_1=beta_1, dropout_alpha=dropout_alpha, model_path=model_path, num_epochs=num_epochs, batch_size=batch_size, verbose=verbose, model_config=model_config, val_split=val_split) mean_model_file = join( model_path, "annres_config_{0:04d}_mean.nc".format( self.config["model_config"])) res_model_file = join( model_path, "annres_config_{0:04d}_res.nc".format(self.config["model_config"])) self.x_scaling_file = join( model_path, "annres_scaling_values_{0:04d}.csv".format(model_config)) if model_path is None or not exists(mean_model_file): nn_input = Input((mean_inputs, )) nn_model = nn_input for h in range(hidden_layers): nn_model = Dense(hidden_neurons, kernel_regularizer=l2(l2_weight))(nn_model) if activation == "leaky": nn_model = LeakyReLU(0.1)(nn_model) else: nn_model = Activation(activation)(nn_model) nn_model = Dense(1)(nn_model) nn_res_input_x = Input((mean_inputs, )) nn_res_input_res = Input((1, )) nn_res = concatenate([nn_res_input_x, nn_res_input_res]) for h in range(hidden_layers): nn_res = Dense(hidden_neurons, kernel_regularizer=l2(l2_weight))(nn_res) if activation == "leaky": nn_res = LeakyReLU(0.1)(nn_res) else: nn_res = Activation(activation)(nn_res) nn_res = Dropout(dropout_alpha)(nn_res) nn_res = GaussianNoise(noise_sd)(nn_res) nn_res = Dense(1)(nn_res) self.mean_model = Model(nn_input, nn_model) self.mean_model.compile(Adam(lr=learning_rate, beta_1=beta_1), loss=mean_loss) self.res_model = Model([nn_res_input_x, nn_res_input_res], nn_res) self.res_model.compile(Adam(lr=learning_rate, beta_1=beta_1), loss=res_loss) self.x_scaling_values = None elif type(model_path) == str: self.mean_model = load_model(mean_model_file) self.res_model = load_model(res_model_file) self.x_scaling_values = pd.read_csv(self.x_scaling_file, index_col="Channel") self.res_predict = K.function( self.res_model.input + [K.learning_phase()], [self.res_model.output])
def __init__(self, inputs=1, hidden_layers=2, hidden_neurons=8, activation="selu", l2_weight=0.01, learning_rate=0.001, loss="mse", noise_sd=1, beta_1=0.9, model_path=None, dropout_alpha=0.5, num_epochs=10, batch_size=1024, verbose=0, model_config=0, **kwargs): self.config = dict(inputs=inputs, hidden_layers=hidden_layers, hidden_neurons=hidden_neurons, activation=activation, l2_weight=l2_weight, learning_rate=learning_rate, loss=loss, noise_sd=noise_sd, beta_1=beta_1, dropout_alpha=dropout_alpha, model_path=model_path, num_epochs=num_epochs, batch_size=batch_size, verbose=verbose, model_config=model_config, corr=1, res_sd=0) if model_path is None: nn_input = Input((inputs, )) nn_model = nn_input for h in range(hidden_layers): nn_model = Dense(hidden_neurons, kernel_regularizer=l2(l2_weight))(nn_model) if activation == "leaky": nn_model = LeakyReLU(0.1)(nn_model) else: nn_model = Activation(activation)(nn_model) if dropout_alpha > 0: nn_model = Dropout(dropout_alpha)(nn_model) if noise_sd > 0: nn_model = GaussianNoise(noise_sd)(nn_model) nn_model = Dense(1)(nn_model) self.model = Model(nn_input, nn_model) self.model.compile(Adam(lr=learning_rate, beta_1=beta_1), loss=loss) self.x_scaling_file = None self.x_scaling_values = None self.sample_predict = K.function( [self.model.input, K.learning_phase()], [self.model.output]) elif type(model_path) == str: model_path_start = join(*model_path.split("/")[:-1]) self.model = load_model(model_path) self.sample_predict = K.function( [self.model.input, K.learning_phase()], [self.model.output]) self.x_scaling_file = join( model_path_start, "ann_config_{0:04d}_scale.csv".format( self.config["model_config"])) self.x_scaling_values = pd.read_csv(self.x_scaling_file, index_col="Channel")