def build_net(images, n_class=None, is_training=True, reuse=False, scope='mobilenet_half'): with tf.variable_scope(scope, reuse=reuse) as vscope: with slim.arg_scope([slim.batch_norm], is_training=is_training): net, endpoints = mobilenet_v1_base(images, depth_multiplier=0.5, conv_defs=_CONV_DEFS, scope=vscope) net = slim.flatten(net) net = slim.fully_connected( net, 512, weights_initializer=tf.truncated_normal_initializer( stddev=0.001), activation_fn=None, scope='fc5') if isinstance(n_class, int): net = slim.fully_connected(net, n_class, activation_fn=None, scope='logits') # add summarys slim.summarize_collection(tf.GraphKeys.MODEL_VARIABLES) return net
def build_model(self, input_imgs, is_training, targets, masks=None, privileged_input=None): '''Builds the model. Assumes that the input is from range [0, 1]. Args: input_imgs: list of input images (scaled between -1 and 1) with the dimensions specified in the cfg is_training: flag for whether the model is in training mode or not mask: mask used for computing sum of squares loss. If None, we assume it is np.ones. ''' print('building model') cfg = self.cfg self.is_training = is_training if self.decoder_only: encoder_output = input_imgs # Assume that the input is the representation else: encoder_output = self.build_encoder(input_imgs, is_training) # encoder_output = self.build_encoder(input_imgs, is_training) final_output = self.build_siamese_output_postprocess( encoder_output, is_training) losses = self.get_losses(final_output, targets, is_softmax='l2_loss' not in cfg) # use weight regularization if 'omit_weight_reg' in cfg and cfg['omit_weight_reg']: add_reg = False else: add_reg = True # get losses regularization_loss = tf.add_n(slim.losses.get_regularization_losses(), name='losses/regularization_loss') total_loss = slim.losses.get_total_loss( add_regularization_losses=add_reg, name='losses/total_loss') self.input_images = input_imgs self.targets = targets self.masks = masks self.encoder_output = encoder_output self.losses = losses self.task_loss = losses[0] self.total_loss = total_loss self.decoder_output = final_output # add summaries slim.summarize_variables() slim.summarize_weights() slim.summarize_biases() slim.summarize_activations() slim.summarize_collection(tf.GraphKeys.LOSSES) tf.summary.scalar('accuracy', self.accuracy) slim.summarize_tensor(regularization_loss) slim.summarize_tensor(total_loss) self.model_built = True
def build_model(self, input_imgs, is_training, targets=None, masks=None, privileged_input=None): '''Builds the model. Assumes that the input is from range [0, 1]. Args: input_imgs: list of input images (scaled between -1 and 1) with the dimensions specified in the cfg is_training: flag for whether the model is in training mode or not mask: mask used for computing sum of squares loss. If None, we assume it is np.ones. ''' print('building model') cfg = self.cfg self.is_training = is_training self.input_images = input_imgs self.target_images = targets self.masks = masks self.targets = targets if masks is None: masks = tf.constant( 1, dtype=tf.float32, shape=[], name='constant_mask' ) if self.decoder_only: self.encoder_output = input_imgs # Assume that the input is the representation else: self.encoder_output = self.build_encoder(input_imgs, is_training) self.decoder_output = self.build_decoder(self.encoder_output, is_training) resized_output = tf.reshape(self.decoder_output, [-1, self.cfg[ 'target_num_channels' ]]) resized_target = tf.reshape(targets, [-1]) masks = tf.reshape(masks, [-1]) losses = self.get_losses( resized_output, resized_target, masks) # use weight regularization if 'omit_weight_reg' in cfg and cfg['omit_weight_reg']: add_reg = False else: add_reg = True # get losses regularization_loss = tf.add_n( slim.losses.get_regularization_losses(), name='losses/regularization_loss' ) total_loss = slim.losses.get_total_loss( add_regularization_losses=add_reg, name='losses/total_loss') self.losses = losses self.total_loss = total_loss # add summaries if self.extended_summaries: slim.summarize_variables() slim.summarize_weights() slim.summarize_biases() slim.summarize_activations() slim.summarize_collection(tf.GraphKeys.LOSSES) slim.summarize_tensor( regularization_loss ) slim.summarize_tensor( total_loss ) self.model_built = True
def build_net(images, n_class=None, is_training=True, reuse=False, scope='resnet_50_half'): with tf.variable_scope(scope, reuse=reuse): with slim.arg_scope([slim.batch_norm], is_training=is_training): net_spec = [[[i, i, i * 4] for i in [32, 64, 128, 256]], [3, 4, 6, 3]] with slim.arg_scope([slim.conv2d], normalizer_fn=None, activation_fn=None): net = conv2d_same(images, 32, 5, stride=2, scope='conv1') for i, spec in enumerate(zip(*net_spec)): stride = 2 if i != 0 else 1 block_spec, n_block = spec for j in range(n_block): net = pre_bottleneck_block(net, block_spec, stride=stride, scope='res_%d_%d' % (i + 1, j + 1)) stride = 1 net = slim.batch_norm(net, activation_fn=tf.nn.relu, scope='postnorm') net = slim.conv2d(net, 256, 1, stride=1, scope='last_conv') net = slim.flatten(net) net = slim.fully_connected( net, 128, # weights_initializer=tf.truncated_normal_initializer(stddev=0.01), activation_fn=None, scope='fc5') if isinstance(n_class, int): net = slim.flatten(net) net = slim.fully_connected(net, n_class, activation_fn=None, scope='logits') # add summarys slim.summarize_collection(tf.GraphKeys.MODEL_VARIABLES) return net
def build_elbo(self, n_samples, training=False): cfg = self.config reuse = False if training: reuse = True z = self.variational.sample(self.data, n_samples=n_samples, reuse=reuse) log_q_z = self.variational.log_prob(z, reuse=reuse) self.log_q_z = log_q_z log_p_x_z = self.model.log_prob(self.data, z, reuse=reuse) if cfg['optim/deterministic_annealing'] and training: self.build_magnitude() tf.summary.scalar('c/magnitude', self.magnitude) magnitude = tf.maximum(1., self.magnitude) elbo = log_p_x_z - magnitude * log_q_z else: elbo = log_p_x_z - log_q_z if training: self.elbo_loss = elbo _, variance = tf.nn.moments(elbo, [0]) self.elbo_variance = tf.reduce_mean(variance) self.log_q_z_loss = log_q_z self.variational.build_entropy(z) self.q_z_sample = z slim.summarize_collection('variational') slim.summarize_collection('model') slim.summarize_activations('variational') slim.summarize_activations('model') else: self.elbo = elbo self.log_q_z = log_q_z self.log_p_x_hat = ( tf.reduce_logsumexp(elbo, [0], keep_dims=True) - tf.log(float(cfg['q/n_samples_stats']))) tf.summary.scalar('o/log_p_x_hat', tf.reduce_mean(self.log_p_x_hat)) def sum_mean(x): return tf.reduce_sum(tf.reduce_mean(x, 0)) self.elbo_sum = sum_mean(elbo) self.q_entropy = -sum_mean(log_q_z) self.E_log_lik = sum_mean(log_p_x_z) tf.summary.scalar('o/elbo_sum', sum_mean(elbo)) tf.summary.scalar('o/elbo_mean', sum_mean(elbo) / cfg['batch_size']) tf.summary.scalar('o/E_log_q_z', sum_mean(log_q_z)) tf.summary.scalar('o/E_log_p_x_z', self.E_log_lik)
def build_summary_ops(self, graph): """Build summary ops. Add summaries for variables, weights, biases, activations, and losses. Returns: summary_op: The (merged) summary op. summary_writer: A summary writer. """ # add summaries slim.summarize_variables() slim.summarize_weights() slim.summarize_biases() slim.summarize_activations() slim.summarize_collection(tf.GraphKeys.LOSSES) with tf.name_scope('summary_ops'): summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter(cfg.DIR.LOG_PATH, graph=graph) self.summary_op = summary_op self.summary_writer = summary_writer
def _build_summaries( self ): if not self.losses_built: raise RuntimeError( "Cannot _build_summaries until 'get_losses' ({0}) and _build_metrics ({1}) is run".format( self.losses_built, self.metrics_built ) ) # add check for losses, metrics built if self.extended_summaries: slim.summarize_variables() slim.summarize_weights() slim.summarize_biases() slim.summarize_activations() tf.summary.scalar( 'metrics/d_accuracy_on_real', self.real_accuracy ) tf.summary.scalar( 'metrics/d_accuracy_on_fake', self.fake_accuracy ) # losses slim.summarize_collection(tf.GraphKeys.LOSSES) slim.summarize_tensor( self.encoder_regularization_loss ) slim.summarize_tensor( self.decoder_regularization_loss ) slim.summarize_tensor( self.discriminator_regularization_loss ) slim.summarize_tensor( self.loss_g_total ) #, tag='losses/generator_total_loss' ) slim.summarize_tensor( self.loss_d_total ) #, tag='losses/discriminator_total_loss' ) self.summaries_built = True
def build_net(images, n_class=None, is_training=True, reuse=False, alpha=1.25, scope='mobile_id'): with tf.variable_scope(scope, reuse=reuse) as scope: with slim.arg_scope([slim.batch_norm], is_training=is_training): net = conv2d_same(images, int(32 * alpha), 3, stride=2, scope='conv1') net = mobile_block(net, int(16 * alpha), 3, stride=1, t=1, scope='mblock1_1') net = mobile_block(net, int(16 * alpha), 3, stride=1, scope='mblock1_2') net = mobile_block(net, int(24 * alpha), 3, stride=2, scope='mblock2_1') net = mobile_block(net, int(24 * alpha), 3, stride=1, scope='mblock2_2') net = mobile_block(net, int(24 * alpha), 3, stride=1, scope='mblock2_3') net = mobile_block(net, int(32 * alpha), 3, stride=2, scope='mblock3_1') net = mobile_block(net, int(32 * alpha), 3, stride=1, scope='mblock3_2') net = mobile_block(net, int(32 * alpha), 3, stride=1, scope='mblock3_3') net = mobile_block(net, int(32 * alpha), 3, stride=1, scope='mblock3_4') net = mobile_block(net, int(64 * alpha), 3, stride=2, scope='mblock4_1') for i in range(3): net = mobile_block(net, int(64 * alpha), 3, stride=1, scope='mblock4_%d' % (i + 2)) for i in range(4): net = mobile_block(net, int(96 * alpha), 3, stride=1, scope='mblock5_%d' % (i + 1)) net = mobile_block(net, int(160 * alpha), 3, stride=2, scope='mblock6_1') for i in range(3): net = mobile_block(net, int(160 * alpha), 3, stride=1, scope='mblock6_%d' % (i + 2)) net = mobile_block(net, int(320 * alpha), 3, stride=1, scope='mblock7_1') # net = mobile_block(net, int(320*alpha), 3, stride=1, scope='mblock7_2') net = slim.conv2d(net, 1280, 1, stride=1, scope='final_point_conv') net = slim.flatten(net) net = slim.fully_connected( net, 128, weights_initializer=tf.truncated_normal_initializer( stddev=0.001), normalizer_fn=slim.batch_norm, # normalizer_params={'param_initializers': {'gamma': tf.constant_initializer(0.0001)}}, activation_fn=None, scope='fc1') if isinstance(n_class, int): net = slim.flatten(net) net = slim.fully_connected(net, n_class, activation_fn=None, scope='logits') # add summarys slim.summarize_collection(tf.GraphKeys.MODEL_VARIABLES) return net
def build_model(self, input_imgs, is_training, targets=None, masks=None, privileged_input=None): '''Builds the model. Assumes that the input is from range [0, 1]. Args: input_imgs: list of input images (scaled between -1 and 1) with the dimensions specified in the cfg is_training: flag for whether the model is in training mode or not mask: mask used for computing sum of squares loss. If None, we assume it is np.ones. ''' print('building model') cfg = self.cfg self.is_training = is_training if masks is None: masks = tf.constant(1, dtype=tf.float32, shape=[], name='constant_mask') net = ResNet50UpProj({'data': input_imgs}, cfg['batch_size'], 1, False) decoder_output = net.get_output() decoder_output = decoder_output * 128. decoder_output = tf.log(decoder_output + 1.) / 11.090354888959125 # if self.decoder_only: # encoder_output = input_imgs Assume that the input is the representation # else: # encoder_output = self.build_encoder(input_imgs, is_training) # print("enc:", encoder_output.shape) # decoder_output = self.build_decoder(encoder_output, is_training) # print("tar:", targets.shape) # set up losses if targets is None: losses = self.get_losses(decoder_output, input_imgs, masks) else: losses = self.get_losses(decoder_output, targets, masks) # use weight regularization if 'omit_weight_reg' in cfg and cfg['omit_weight_reg']: add_reg = False else: add_reg = True # get losses #regularization_loss = tf.add_n( slim.losses.get_regularization_losses(), name='losses/regularization_loss' ) #total_loss = slim.losses.get_total_loss( add_regularization_losses=add_reg, # name='losses/total_loss') self.input_images = input_imgs self.target_images = targets self.targets = targets self.masks = masks self.decoder_output = decoder_output self.losses = losses self.total_loss = losses[0] # self.init_op = tf.global_variables_initializer() # add summaries if self.extended_summaries: slim.summarize_variables() slim.summarize_weights() slim.summarize_biases() slim.summarize_activations() slim.summarize_collection(tf.GraphKeys.LOSSES) #slim.summarize_tensor( regularization_loss ) #slim.summarize_tensor( total_loss ) self.model_built = True
def run_test_train_dataset(selected_model): #Create the sess, and use some options for better using gpu print("Create session") config = tf.ConfigProto() config.gpu_options.allow_growth = True # Do not assign whole gpu memory, just use it on the go config.allow_soft_placement = True # If a operation is not define it the default device, let it execute in another. sess = tf.Session(config=config) with tf.device('/cpu:0'): #input setup #train dataset setup train_dataset = train_dataset_prepare(FLAGS) train_iterator = train_dataset.make_one_shot_iterator() #test dataset setup test_dir = '/scratch_net/ofsoundof/yawli/BSD68/' test_iterator = test_dataset_prepare( test_path_prepare, test_dir, FLAGS.sigma).make_initializable_iterator() #create dataset handle and iterator handle = tf.placeholder(tf.string, shape=[]) iterator = tf.data.Iterator.from_string_handle( handle, train_dataset.output_types, train_dataset.output_shapes) image_gt, image_n = iterator.get_next() with tf.device('/device:GPU:' + FLAGS.sge_gpu): image_gt = image_gt / 255 * MAX_RGB image_n = image_n / 255 * MAX_RGB global_step = tf.Variable(1, name='global_step', trainable=False) image_dn = selected_model(image_n, FLAGS) MSE_dn, PSNR_dn = comp_mse_psnr(image_dn, image_gt, MAX_RGB) MSE_n, PSNR_n = comp_mse_psnr(image_n, image_gt, MAX_RGB) PSNR_gain = PSNR_dn - PSNR_n loss = tf.reduce_sum(tf.squared_difference( image_gt, image_dn)) + tf.reduce_sum( tf.losses.get_regularization_losses()) train_op, global_step = training(loss, FLAGS, global_step) #train summary tf.summary.scalar('MSE_dn', MSE_dn) tf.summary.scalar('PSNR_dn', PSNR_dn) tf.summary.scalar('MSE_n', MSE_n) tf.summary.scalar('PSNR_n', PSNR_n) tf.summary.scalar('PSNR_gain', PSNR_gain) slim.summarize_collection(collection=tf.GraphKeys.TRAINABLE_VARIABLES) #test summaries psnr_validate = tf.placeholder(tf.float32) tf.summary.scalar('psnr_validate', psnr_validate) merged = tf.summary.merge_all() #Get the dataset handle train_handle = sess.run(train_iterator.string_handle()) test_handle = sess.run(test_iterator.string_handle()) print("Create checkpoint directory") # if not FLAGS.restore: FLAGS.checkpoint = FLAGS.checkpoint + '_' + datetime.datetime.now( ).strftime("%Y-%m-%d-%H-%M-%S") with open('checkpoint.txt', 'w' ) as text_file: #save at the current directory, used for testing text_file.write(FLAGS.checkpoint) LOG_DIR = os.path.join('/scratch_net/ofsoundof/yawli/logs', FLAGS.checkpoint) # LOG_DIR = os.path.join('/home/yawli/Documents/hashnets/logs', FLAGS.checkpoint ) # assert (not os.path.exists(LOG_DIR)), 'LOG_DIR %s already exists'%LOG_DIR print("Create summary file writer") train_writer = tf.summary.FileWriter(os.path.join(LOG_DIR, 'train'), sess.graph) print("Create saver") saver = tf.train.Saver(max_to_keep=100) #Always init, then optionally restore print("Initialization") sess.run(tf.global_variables_initializer()) if FLAGS.restore: print('Restore model from checkpoint {}'.format( tf.train.latest_checkpoint(LOG_DIR))) saver.restore(sess, tf.train.latest_checkpoint(LOG_DIR)) checkpoint_filename = 'checkpoint' else: checkpoint_filename = 'checkpoint' # checkpoint_filename = 'checkpoint' score_all = [] model_index = [] image_path_dn, _ = test_path_prepare(test_dir, FLAGS.sigma) image_path_dn = [ os.path.join(LOG_DIR, os.path.basename(i)) for i in image_path_dn ] i = sess.run(global_step) + 1 print("Start iteration") while i <= FLAGS.max_iter: if i % FLAGS.summary_interval == 0: # test set5 sess.run(test_iterator.initializer) score_per = np.zeros((4, 69)) for j in range(68): img_dn, img_n, img_gt = sess.run( [image_dn, image_n, image_gt], feed_dict={handle: test_handle}) scipy.misc.toimage(np.squeeze(img_dn) * 255 / MAX_RGB, cmin=0, cmax=255).save(image_path_dn[j]) # The current scipy version started to normalize all images so that min(data) become black and max(data) # become white. This is unwanted if the data should be exact grey levels or exact RGB channels. # The solution: scipy.misc.toimage(image_array, cmin=0.0, cmax=255).save('...') or use imageio library # from IPython import embed; embed(); score = image_converter(np.squeeze(img_dn), np.squeeze(img_n), np.squeeze(img_gt), False, 0, MAX_RGB) score_per[:, j] = score score_per[:, -1] = np.mean(score_per[:, :-1], axis=1) print('PSNR results for Set5: SR {}, Bicubic {}'.format( score_per[1, -1], score_per[0, -1])) time_start = time.time() [_, i, l, mse_dn, mse_n, psnr_dn, psnr_n, psnr_gain, summary] =\ sess.run([train_op, global_step, loss, MSE_dn, MSE_n, PSNR_dn, PSNR_n, PSNR_gain, merged], feed_dict={handle: train_handle, psnr_validate: score_per[1, -1]})#, options=options, run_metadata=run_metadata) # from IPython import embed; embed(); exit() duration = time.time() - time_start train_writer.add_summary(summary, i) print( "Iter %d, total loss %.5f; denoise (mse %.5f, psnr %.5f); noise (mse %.5f, psnr %.5f); psnr_gain:%f" % (i - 1, l, mse_dn, psnr_dn, mse_n, psnr_n, psnr_gain)) print('Training time for one iteration: {}'.format(duration)) if (i - 1) % FLAGS.checkpoint_interval == 0: save_path = saver.save(sess, os.path.join(LOG_DIR, 'model'), global_step=i, latest_filename=checkpoint_filename, write_meta_graph=True) print("Saved checkpoint to {}".format(save_path)) print("Flushing train writer") train_writer.flush() model_index.append(i) score_all.append([ score_per[0, -1], score_per[1, -1], score_per[1, -1] - score_per[0, -1], score_per[2, -1], score_per[3, -1], score_per[3, -1] - score_per[2, -1] ]) else: [_, i, _] = sess.run([train_op, global_step, loss], feed_dict={handle: train_handle}) #write to csv files descriptor5 = 'Average PSNR (dB)/SSIM for Set5, Scale ' + str( FLAGS.upscale) + ', different model parameters during training' + '\n' descriptor = [descriptor5, '', '', '', '', '', ''] header_mul = ['Iteration'] + ['N', 'DN', 'Gain'] * 2 model_index_array = np.expand_dims(np.array(model_index), axis=0) score_all_array = np.transpose(np.array(score_all)) written_content = np.concatenate((model_index_array, score_all_array), axis=0) written_content_fmt = ['{:<8}'] + ['{:<8.4f}', '{:<8.4f}', '{:<8.4f}'] * 2 content = content_generator_mul_line(descriptor, written_content, written_content_fmt, header_mul) file_writer(os.path.join(LOG_DIR, 'psnr_ssim.csv'), 'a', content) #write to pickle files variables = { 'index': np.array(model_index), 'noise': score_all_array[0, :], 'denoise': score_all_array[1, :], 'gain': score_all_array[2, :] } pickle_out = open(os.path.join(LOG_DIR, 'psnr_bsd68.pkl'), 'wb') pickle.dump(variables, pickle_out) pickle_out.close()
def build_model(self, input_imgs, is_training, targets, masks=None, privileged_input=None): '''Builds the model. Assumes that the input is from range [0, 1]. Args: input_imgs: list of input images (scaled between -1 and 1) with the dimensions specified in the cfg is_training: flag for whether the model is in training mode or not mask: mask used for computing sum of squares loss. If None, we assume it is np.ones. ''' print('building model') cfg = self.cfg self.is_training = is_training if self.decoder_only: encoder_output = input_imgs # Assume that the input is the representation else: encoder_output = self.build_encoder(input_imgs, is_training) final_output_12 = self.build_siamese_output_postprocess( encoder_output, is_training, scope="three_layer_fc_network12") final_output_23 = self.build_siamese_output_postprocess( encoder_output, is_training, scope="three_layer_fc_network23") final_output_13 = self.calculate_combined_relative_camera_pose( self.denormalize_fixated_camera_pose(final_output_12), self.denormalize_fixated_camera_pose(final_output_23)) final_output_13 = self.normalize_fixated_camera_pose(final_output_13) #final_output = tf.concat(1, [final_output_12, final_output_13, final_output_23]) target12 = tf.slice(targets, [0, 0], [self.cfg['batch_size'], 6]) target13 = tf.slice(targets, [0, 6], [self.cfg['batch_size'], 6]) target23 = tf.slice(targets, [0, 12], [self.cfg['batch_size'], 6]) final_output = [final_output_12, final_output_13, final_output_23] target_total = [target12, target13, target23] losses = self.get_losses(final_output, target_total, is_softmax='l2_loss' not in cfg) # use weight regularization if 'omit_weight_reg' in cfg and cfg['omit_weight_reg']: add_reg = False else: add_reg = True # get losses regularization_loss = tf.add_n(slim.losses.get_regularization_losses(), name='losses/regularization_loss') total_loss = slim.losses.get_total_loss( add_regularization_losses=add_reg, name='losses/total_loss') self.input_images = input_imgs self.targets = targets self.encoder_output = encoder_output self.losses = losses self.total_loss = total_loss self.decoder_output = final_output # add summaries if self.extended_summaries: slim.summarize_variables() slim.summarize_weights() slim.summarize_biases() slim.summarize_activations() slim.summarize_collection(tf.GraphKeys.LOSSES) tf.summary.scalar('accuracy', self.accuracy) slim.summarize_tensor(regularization_loss) slim.summarize_tensor(total_loss) self.model_built = True
def build_net(images, n_class=None, is_training=True, reuse=False, alpha=1, scope='mobile_id'): with tf.variable_scope(scope, reuse=reuse) as scope: with slim.arg_scope([slim.batch_norm], is_training=is_training): net = conv2d_same(images, int(64 * alpha), 3, stride=2, scope='conv1') net = slim.separable_conv2d(net, None, 3, 1, stride=1, padding='SAME', scope='depth_conv1') net = mobile_block(net, int(64 * alpha), 3, stride=2, t=2, scope='mblock1_1') for i in range(4): net = mobile_block(net, int(64 * alpha), 3, stride=1, t=2, scope='mblock1_%d' % (i + 2)) net = mobile_block(net, int(128 * alpha), 3, stride=2, t=4, scope='mblock2_1') for i in range(6): net = mobile_block(net, int(128 * alpha), 3, stride=1, t=2, scope='mblock2_%d' % (i + 2)) net = mobile_block(net, int(128 * alpha), 3, stride=2, t=4, scope='mblock3_1') for i in range(2): net = mobile_block(net, int(128 * alpha), 3, stride=1, t=2, scope='mblock3_%d' % (i + 2)) net = slim.conv2d(net, 512, 1, stride=1, scope='final_point_conv') net = slim.separable_conv2d(net, None, [7, 6], 1, stride=1, padding='VALID', scope='GDConv') print(net.shape) net = slim.flatten(net) net = slim.fully_connected( net, 128, # weights_initializer=tf.truncated_normal_initializer(stddev=0.001), normalizer_fn=slim.batch_norm, weights_regularizer=slim.l2_regularizer(4e-4), # normalizer_params={'param_initializers': {'gamma': tf.constant_initializer(0.1)}}, activation_fn=None, scope='fc1') if isinstance(n_class, int): net = slim.flatten(net) net = slim.fully_connected(net, n_class, activation_fn=None, scope='logits') # add summarys slim.summarize_collection(tf.GraphKeys.MODEL_VARIABLES) return net