def __init__(self, num_classes, train_layers=None, weights_path='DEFAULT'): """Create the graph of the densenet_161 model. """ # Parse input arguments into class variables if weights_path == 'DEFAULT': self.WEIGHTS_PATH = "./pre_trained_models/densenet_161.ckpt" else: self.WEIGHTS_PATH = weights_path self.train_layers = train_layers with tf.variable_scope("input"): self.image_size = densenet.densenet161.default_image_size self.x_input = tf.placeholder(tf.float32, [None, self.image_size, self.image_size, 3], name="x_input") self.y_input = tf.placeholder(tf.float32, [None, num_classes], name="y_input") self.learning_rate = tf.placeholder(tf.float32, name="learning_rate") # train with arg_scope(densenet.densenet_arg_scope()): self.logits, _ = densenet.densenet161(self.x_input, num_classes=num_classes, is_training=True, reuse=tf.AUTO_REUSE ) # validation with arg_scope(densenet.densenet_arg_scope()): self.logits_val, _ = densenet.densenet161(self.x_input, num_classes=num_classes, is_training=False, reuse=tf.AUTO_REUSE, ) with tf.name_scope("loss"): self.loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=self.logits, labels=self.y_input)) self.loss_val = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=self.logits_val, labels=self.y_input)) with tf.name_scope("train"): self.global_step = tf.Variable(0, name="global_step", trainable=False) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) var_list = [v for v in tf.trainable_variables() if v.name.split('/')[-2] in train_layers or v.name.split('/')[-3] in train_layers ] gradients = tf.gradients(self.loss, var_list) self.grads_and_vars = list(zip(gradients, var_list)) optimizer = tf.train.GradientDescentOptimizer(self.learning_rate) with tf.control_dependencies(update_ops): self.train_op = optimizer.apply_gradients(grads_and_vars=self.grads_and_vars, global_step=self.global_step) with tf.name_scope("probability"): self.probability = tf.nn.softmax(self.logits_val, name="probability") with tf.name_scope("prediction"): self.prediction = tf.argmax(self.logits_val, 1, name="prediction") with tf.name_scope("accuracy"): correct_prediction = tf.equal(self.prediction, tf.argmax(self.y_input, 1)) self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"), name="accuracy")
def apply_network_img(data_dense, batch_size, is_training_net, is_training_drop, net): if net == 'D': #DenseNet-161 with slim.arg_scope(densenet.densenet_arg_scope()): logits, _ = densenet.densenet161(data_dense, num_classes=None, is_training_batch=is_training_net, is_training_drop=is_training_drop) elif net == 'V': #VGG-16 with slim.arg_scope(vgg.vgg_arg_scope()): logits, _ = vgg.vgg_16(data_dense, num_classes=None, is_training=is_training_drop, spatial_squeeze=False, classification=False, max_pool=False) return logits
def load_model_tf(parameters): # Setup model params if (parameters["device_type"] == "gpu") and tf.test.is_gpu_available(): device_str = "/device:GPU:{}".format(parameters["gpu_number"]) else: device_str = "/cpu:0" # Setup Graph graph = tf.Graph() with graph.as_default(): with tf.device(device_str): x = tf.placeholder(tf.float32, [None, 256, 256, 3]) with slim.arg_scope( densenet_arg_scope(weight_decay=0.0, data_format='NHWC')): densenet121_net, end_points = densenet121( x, num_classes=parameters["number_of_classes"], data_format='NHWC', is_training=False, ) y_logits = densenet121_net[:, 0, 0, :] y = tf.nn.softmax(y_logits) # Load weights sess = tf.Session(graph=graph, config=tf.ConfigProto(gpu_options=tf.GPUOptions( per_process_gpu_memory_fraction=0.333))) with open(parameters["tf_torch_weights_map_path"]) as f: tf_torch_weights_map = json.loads(f.read()) with sess.as_default(): torch_weights = torch.load(parameters["initial_parameters"]) match_dict = construct_densenet_match_dict( tf_variables=tf_utils.get_tf_variables(graph, batch_norm_key="BatchNorm"), torch_weights=torch_weights, tf_torch_weights_map=tf_torch_weights_map) sess.run(tf_utils.construct_weight_assign_ops(match_dict)) return sess, x, y
def testAllEndPointsShapes(self): batch_size = 5 height, width = 224, 224 num_classes = 1000 inputs = tf.random_uniform((batch_size, height, width, 3)) with slim.arg_scope(densenet.densenet_arg_scope()): logits, end_points = densenet.densenet(inputs, num_classes) endpoints_shapes = {'input_layer': [batch_size, 56, 56, 48], 'dense_block1': [batch_size, 56, 56, 192], 'transition_layer1': [batch_size, 28, 28, 96], 'dense_block2': [batch_size, 28, 28, 384], 'transition_layer2': [batch_size, 14, 14, 192], 'dense_block3': [batch_size, 14, 14, 768], 'transition_layer3': [batch_size, 7, 7, 384], 'dense_block4': [batch_size, 7, 7, 768], 'classify_layer': [batch_size, num_classes]} self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys()) for endpoint_name in endpoints_shapes: expected_shape = endpoints_shapes[endpoint_name] self.assertTrue(endpoint_name in end_points) self.assertListEqual(end_points[endpoint_name].get_shape().as_list(), expected_shape)
def _extract_proposal_features(self, preprocessed_inputs, scope): """Extracts first stage RPN features. Extracts features using the first half of the Inception Resnet v2 network. We construct the network in `align_feature_maps=True` mode, which means that all VALID paddings in the network are changed to SAME padding so that the feature maps are aligned. Args: preprocessed_inputs: A [batch, height, width, channels] float32 tensor representing a batch of images. scope: A scope name. Returns: rpn_feature_map: A tensor with shape [batch, height, width, depth] Raises: InvalidArgumentError: If the spatial size of `preprocessed_inputs` (height or width) is less than 33. ValueError: If the created network is missing the required activation. """ if len(preprocessed_inputs.get_shape().as_list()) != 4: raise ValueError( '`preprocessed_inputs` must be 4 dimensional, got a ' 'tensor of shape %s' % preprocessed_inputs.get_shape()) with slim.arg_scope( densenet.densenet_arg_scope(weight_decay=self._weight_decay)): # Forces is_training to False to disable batch norm update. with slim.arg_scope([slim.batch_norm], is_training=False): with tf.variable_scope('DenseNet', reuse=self._reuse_weights) as scope: rpn_feature_map = densenet.Dense_net(preprocessed_inputs, nb_blocks=2, filters=24, is_training=True, dropout_ratio=0.2) return rpn_feature_map
def main(_): if not FLAGS.dataset_dir: raise ValueError( 'You must supply the dataset directory with --dataset_dir') tf.logging.set_verbosity(tf.logging.INFO) with tf.Graph().as_default(): ###################### # Select the dataset # ###################### dataset = dataset_factory.get_dataset(FLAGS.dataset_name, FLAGS.dataset_split_name, FLAGS.dataset_dir) #################### # Select the model # #################### network_fn = nets_factory.get_network_fn( FLAGS.model_name, num_classes=(dataset.num_classes - FLAGS.labels_offset), is_training=False) ############################################################## # Create a dataset provider that loads data from the dataset # ############################################################## provider = slim.dataset_data_provider.DatasetDataProvider( dataset, shuffle=False, common_queue_capacity=2 * FLAGS.batch_size, common_queue_min=FLAGS.batch_size) [image, file_name] = provider.get(['image', 'file_name']) ##################################### # Select the preprocessing function # ##################################### preprocessing_name = FLAGS.preprocessing_name or FLAGS.model_name image_preprocessing_fn = preprocessing_factory.get_preprocessing( preprocessing_name, is_training=False) eval_image_size = FLAGS.eval_image_size or network_fn.default_image_size image = image_preprocessing_fn(image, eval_image_size, eval_image_size) images, file_names = tf.train.batch( [image, file_name], batch_size=FLAGS.batch_size, num_threads=FLAGS.num_preprocessing_threads, capacity=5 * FLAGS.batch_size) #################### # Define the model # #################### # logits, end_points = network_fn(images) # predictions = tf.argmax(logits, 1) # TODO(sguada) use num_epochs=1 num_batches_per_epoch = math.ceil(dataset.num_samples / float(FLAGS.batch_size)) num_steps_per_epoch = num_batches_per_epoch with slim.arg_scope(densenet_arg_scope()): logits, end_points = network_fn(images) print(FLAGS.checkpoint_path) if tf.gfile.IsDirectory(FLAGS.checkpoint_path): checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path) else: checkpoint_path = FLAGS.checkpoint_path tf.logging.info('Evaluating %s' % checkpoint_path) # #get all the variables to restore from the checkpoint file and create the saver function to restore variables_to_restore = slim.get_variables_to_restore() saver = tf.train.Saver(variables_to_restore) def restore_fn(sess): return saver.restore(sess, checkpoint_path) #Just define the metrics to track without the loss or whatsoever # predictions = tf.argmax(logits, 1) # predictions = end_points[] top_k_pred = tf.nn.top_k(end_points['predictions'], k=5) # top_k_pred = tf.nn.top_k(logits, k=5) #Create the global step and an increment op for monitoring global_step = get_or_create_global_step() global_step_op = tf.assign( global_step, global_step + 1 ) #no apply_gradient method so manually increasing the global_step file_names_all = [] predictions_all = [] all_key = {} c_key = {} #Create a evaluation step function def eval_step(sess, top_k_pred, file_names, global_step): ''' Simply takes in a session, runs the metrics op and some logging information. ''' start_time = time.time() # global_step_count, predictions_ = sess.run([global_step_op, predictions]) p_file_name = sess.run(file_names) global_step_count = sess.run(global_step_op) time_elapsed = time.time() - start_time #Log some information logging.info('Global Step %s: Streaming Accuracy: (%.2f sec/step)', global_step_count, time_elapsed) return p_file_name #Get your supervisor sv = tf.train.Supervisor(logdir=FLAGS.test_dir, summary_op=None, saver=None, init_fn=restore_fn) #Now we are ready to run in one session #config = tf.ConfigProto(device_count={'GPU':0}) # mask GPUs visible to the session so it falls back on CPU with sv.managed_session() as sess: for step in range(num_steps_per_epoch * num_epochs): sess.run(sv.global_step) #print vital information every start of the epoch as always file_names_ = eval_step(sess, top_k_pred, file_names, global_step=sv.global_step) my_file_name = str(file_names_[0], 'utf-8') logging.info('my_file_name=' + my_file_name) if my_file_name not in all_key: all_key[my_file_name] = my_file_name else: c_key[my_file_name] = my_file_name #At the end of all the evaluation, show the final accuracy logging.info('总处理不重复的文件数:' + str(len(all_key))) logging.info('总处理重复的文件数:' + str(len(c_key)))
def _extract_box_classifier_features(self, proposal_feature_maps, scope): """Extracts second stage box classifier features. This function reconstructs the "second half" of the Densenet network after the part defined in `_extract_proposal_features`. Args: proposal_feature_maps: A 4-D float tensor with shape [batch_size * self.max_num_proposals, crop_height, crop_width, depth] representing the feature map cropped to each proposal. scope: A scope name. Returns: proposal_classifier_features: A 4-D float tensor with shape [batch_size * self.max_num_proposals, height, width, depth] representing box classifier features for each proposal. """ with tf.variable_scope('DenseNet', reuse=self._reuse_weights): with slim.arg_scope( densenet.densenet_arg_scope( weight_decay=self._weight_decay)): # Forces is_training to False to disable batch norm update. with slim.arg_scope([slim.batch_norm], is_training=False): with slim.arg_scope( [slim.conv2d, slim.max_pool2d, slim.avg_pool2d], stride=1, padding='SAME'): with tf.variable_scope('Mixed_7a'): with tf.variable_scope('Branch_0'): tower_conv = slim.conv2d(proposal_feature_maps, 256, 1, scope='Conv2d_0a_1x1') tower_conv_1 = slim.conv2d( tower_conv, 384, 3, stride=2, padding='VALID', scope='Conv2d_1a_3x3') with tf.variable_scope('Branch_1'): tower_conv1 = slim.conv2d( proposal_feature_maps, 256, 1, scope='Conv2d_0a_1x1') tower_conv1_1 = slim.conv2d( tower_conv1, 288, 3, stride=2, padding='VALID', scope='Conv2d_1a_3x3') with tf.variable_scope('Branch_2'): tower_conv2 = slim.conv2d( proposal_feature_maps, 256, 1, scope='Conv2d_0a_1x1') tower_conv2_1 = slim.conv2d( tower_conv2, 288, 3, scope='Conv2d_0b_3x3') tower_conv2_2 = slim.conv2d( tower_conv2_1, 320, 3, stride=2, padding='VALID', scope='Conv2d_1a_3x3') with tf.variable_scope('Branch_3'): tower_pool = slim.max_pool2d( proposal_feature_maps, 3, stride=2, padding='VALID', scope='MaxPool_1a_3x3') net = tf.concat([ tower_conv_1, tower_conv1_1, tower_conv2_2, tower_pool ], 3) net = slim.repeat(net, 9, inception_resnet_v2.block8, scale=0.20) net = inception_resnet_v2.block8(net, activation_fn=None) proposal_classifier_features = slim.conv2d( net, 1536, 1, scope='Conv2d_7b_1x1') return proposal_classifier_features
if not data: break image_files.append(data[:-1]) # image_files = random.sample(image_names, sample_num) for i in image_files: # GT_dict[i] = i.split('/')[3] GT_num[i] = i.split('\\')[3] image_input = tf.read_file(i) image = tf.image.decode_jpeg(image_input, channels=3) user_images.append(image) processed_image = densenet_preprocessing.preprocess_image(image, image_size, image_size, is_training=False) user_processed_images.append(processed_image) processed_images = tf.expand_dims(processed_image, 0) with slim.arg_scope(densenet.densenet_arg_scope()): logits, _ = densenet.densenet121(user_processed_images, num_classes=5, is_training=False) probabilities = tf.nn.softmax(logits) init_fn = slim.assign_from_checkpoint_fn( os.path.join(checkpoints_dir, 'model.ckpt-21031'), slim.get_model_variables('densenet121')) with tf.Session() as sess: init_fn(sess) probabilities = sess.run(probabilities) # names = os.listdir("tmp/captcha/test_photos2") names = ['bus', 'car', 'cat', 'dog', 'ship'] names.sort() #names=['normal', 'adenoma', 'adenocarcinoma']
def __init__(self, options): num_classes = options.NUM_CLASSES with tf.variable_scope("input"): self.image_size = options.IMAGE_SIZE self.x_input = tf.placeholder( tf.float32, [None, self.image_size, self.image_size, 3], name="x_input") self.y_input = tf.placeholder(tf.float32, [None, num_classes], name="y_input") self.learning_rate = tf.placeholder(tf.float32, name="learning_rate") self.keep_prob = None if options.PHASE == 'train': if train_layers == 'default': self.train_layers = self.DEFAULT_TRAIN_LAYERS else: self.train_layers = train_layers # train with arg_scope(densenet.densenet_arg_scope()): self.logits, _ = densenet.densenet121(self.x_input, num_classes=num_classes, is_training=True, reuse=tf.AUTO_REUSE) self.logits = tf.squeeze(self.logits, [1, 2]) # validation with arg_scope(densenet.densenet_arg_scope()): self.logits_val, _ = densenet.densenet121( self.x_input, num_classes=num_classes, is_training=False, reuse=tf.AUTO_REUSE) self.logits_val = tf.squeeze(self.logits_val, [1, 2]) with tf.name_scope("loss"): self.loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2( logits=self.logits, labels=self.y_input)) self.loss_val = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2( logits=self.logits_val, labels=self.y_input)) with tf.name_scope("train"): self.global_step = tf.Variable(0, name="global_step", trainable=False) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) var_list = [ v for v in tf.trainable_variables() if v.name.split('/')[-2] in self.train_layers or v.name.split('/')[-3] in self.train_layers ] gradients = tf.gradients(self.loss, var_list) self.grads_and_vars = list(zip(gradients, var_list)) # optimizer = tf.train.GradientDescentOptimizer(self.learning_rate) opt_name = options.OPTIMIZER if opt_name == 'sgd': optimizer = tf.train.GradientDescentOptimizer( self.learning_rate) elif opt_name == 'adam': optimizer = tf.train.AdamOptimizer(self.learning_rate) else: raise ValueError('Optimizer not supported') with tf.control_dependencies(update_ops): self.train_op = optimizer.apply_gradients( grads_and_vars=self.grads_and_vars, global_step=self.global_step) else: with arg_scope(densenet.densenet_arg_scope()): self.logits_val, _ = densenet.densenet121( self.x_input, num_classes=num_classes, is_training=False, reuse=tf.AUTO_REUSE) self.logits_val = tf.squeeze(self.logits_val, [1, 2]) with tf.name_scope("probability"): self.probability = tf.nn.softmax(self.logits_val, name="probability") with tf.name_scope("prediction"): self.prediction = tf.argmax(self.logits_val, 1, name="prediction") with tf.name_scope("accuracy"): correct_prediction = tf.equal(self.prediction, tf.argmax(self.y_input, 1)) self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"), name="accuracy") print(self.logits.shape.as_list()) print(self.logits_val.shape.as_list())