def arch_multi_alexnet_v2(self, X1, X2, X3, num_classes, dropout_keep_prob=0.8, is_train=False): arg_scope = alexnet_v2_arg_scope() with slim.arg_scope(arg_scope): with tf.variable_scope('arch_alexnet_v2_1'): net_vis1, end_points1 = alexnet_v2(X1, is_training=is_train) with tf.variable_scope('arch_alexnet_v2_2'): net_vis2, end_points2 = alexnet_v2(X2, is_training=is_train) with tf.variable_scope('arch_alexnet_v2_3'): net_vis3, end_points3 = alexnet_v2(X2, is_training=is_train) # net_vis3, end_points3 = alexnet_v2(X3, is_training=is_train) with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d], stride=1, padding='SAME'): with tf.variable_scope('Logits_out'): net_vis = tf.concat([net_vis1, net_vis2, net_vis3], 3) net = slim.conv2d(net_vis, num_classes, [1, 1], activation_fn=None, normalizer_fn=None, scope='fc8') net = tf.squeeze(net, [1, 2], name='fc8/squeezed') return net, net_vis
def arch_alexnet_v2(self, X, num_classes, dropout_keep_prob=0.8, is_train=False): arg_scope = alexnet_v2_arg_scope() with slim.arg_scope(arg_scope): net_vis, end_points = alexnet_v2(X, is_training=is_train) with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d], stride=1, padding='SAME'): with tf.variable_scope('Logits_out'): net = slim.conv2d(net_vis, num_classes, [1, 1],activation_fn=None,normalizer_fn=None,scope='fc8') net = tf.squeeze(net,[1,2], name='fc8/squeezed') return net, net_vis
def main(_): """ Configuration Part. """ assert FLAGS.image_folder, "--picture_folder necessary" assert FLAGS.logs_dir, "--logs_dir necessary" assert FLAGS.label_list_path, "--label_list_path necessary" logs_path = os.path.join('logs', FLAGS.logs_dir) pattern_extension = range(2) num_classes = 2 label_list = [] with open(FLAGS.label_list_path) as f: for line in f: label_list.append(line.strip().split()) image_size = [256, 256] image1_placeholder = tf.placeholder(tf.uint8, [None, image_size[0], image_size[1]], name='image1_input') image2_placeholder = tf.placeholder(tf.uint8, [None, image_size[0], image_size[1]], name='image2_input') merged_image = tf.stack((image1_placeholder, image2_placeholder), -1) float_input_tensor = tf.to_float(merged_image) # Define the network # with slim.arg_scope(mobilenet_v2.training_scope(is_training=False)): # logits, _ = mobilenet_v2.mobilenet(tf.to_float(image_tensor), num_classes=num_classes) with slim.arg_scope(alexnet.alexnet_v2_arg_scope()): logits, end_points = alexnet.alexnet_v2(float_input_tensor, num_classes=num_classes, is_training=False) predictions = tf.argmax(logits, 1, name='output_argmax') # Setup the global step. tf.train.get_or_create_global_step() session_config = tf.ConfigProto() session_config.gpu_options.allow_growth = True tf.logging.set_verbosity(tf.logging.INFO) saver = tf.train.Saver() # Launch the graph with tf.Session(config=session_config) as sess: start_time = time.time() prev_model = tf.train.get_checkpoint_state(logs_path) if prev_model: saver.restore(sess, prev_model.model_checkpoint_path) elapsed_time = time.time() - start_time print('Checkpoint found, {}'.format(prev_model)) print('restore elapsed time: {}'.format(elapsed_time)) for image_pair in label_list: image_array = read_image_array(image_pair, FLAGS.image_folder) start_time = time.time() predict_array = sess.run(predictions, feed_dict={image1_placeholder: [image_array[0]], image2_placeholder: [image_array[1]]}) elapsed_time = time.time() - start_time print("Prediction: {}, shape: {}".format(predict_array, predict_array.shape)) print('inference elapsed time: {}'.format(elapsed_time)) else: print('No checkpoint found')
def predict(self,preprocessed_inputs): """Predict prediction tensors from inputs tensor. Outputs of this function can be passed to loss or postprocess functions. Args: preprocessed_inputs: A float32 tensor with shape [batch_size, height, width, num_channels] representing a batch of images. Returns: prediction_dict: A dictionary holding prediction tensors to be passed to the Loss or Postprocess functions. """ with slim.arg_scope(alexnet.alexnet_v2_arg_scope()): net, endpoints = alexnet.alexnet_v2(inputs=preprocessed_inputs,num_classes=None, is_training=self._is_training,global_pool=True) net = tf.squeeze(net,axis=[1,2]) logits = slim.fully_connected(net, num_outputs=self.num_classes, activation_fn=None, scope='Predict') prediction_dict = {'logits': logits} return prediction_dict
def main(_): """ Configuration Part. """ assert FLAGS.logs_dir, '`logs_dir` is missing.' logs_path = os.path.join('logs', FLAGS.logs_dir) data_dir = 'data' tfrecord_train = ['2_image_compare_train.tfrecords'] load_checkpoint = True train_tf_path = [] for record in tfrecord_train: train_tf_path.append(os.path.join(data_dir, record)) crop_size = [256, 256] # Learning params learning_rate = 0.01 num_epochs = 500 batch_size = 128 num_examples = get_record_number(train_tf_path) num_batches = math.ceil(num_examples / float(batch_size)) total_steps = num_batches * num_epochs print('batch number: {}, total steps: {}'.format(num_batches, total_steps)) pattern_extension = range(2) num_classes = 2 num_ng_sample = 3760 num_ok_sample = 4929 class_ratio = num_ng_sample / (num_ng_sample + num_ok_sample) # Launch the graph with tf.Graph().as_default(): tf.logging.set_verbosity(tf.logging.INFO) tf.summary.scalar('batch_size', batch_size) # Load the data train_image_batch, train_label_batch = get_data_batch( train_tf_path, pattern_extension, crop_size, batch_size, is_training=True, one_hot=False) # convert to float batch float_image_batch = tf.to_float(train_image_batch) # with slim.arg_scope(mobilenet_v2.training_scope(is_training=True)): # logits, end_points = mobilenet_v2.mobilenet(float_image_batch, num_classes=num_classes) with slim.arg_scope(alexnet.alexnet_v2_arg_scope()): logits, end_points = alexnet.alexnet_v2(float_image_batch, num_classes=num_classes, is_training=True) # make summaries of every operation in the node for layer_name, layer_op in end_points.items(): tf.summary.histogram(layer_name, layer_op) class_weight = tf.constant([[class_ratio, 1 - class_ratio]]) # weighted_logits = tf.multiply(logits, class_weight) # Specify the loss function (outside the model!) one_hot_label = tf.one_hot(indices=train_label_batch, depth=num_classes) weight_per_label = tf.transpose(tf.matmul(one_hot_label, tf.transpose(class_weight))) loss = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=one_hot_label, name='softmax') weight_loss = tf.multiply(weight_per_label, loss) total_loss = tf.reduce_mean(weight_loss) # slim.losses.softmax_cross_entropy(logits, one_hot_label) # total_loss = slim.losses.get_total_loss() # Create some summaries to visualize the training process: tf.summary.scalar('losses/Total Loss', total_loss) # Specify the optimizer and create the train op: optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate) # optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) train_op = slim.learning.create_train_op(total_loss, optimizer) # Track accuracy and recall predictions = tf.argmax(logits, 1) # Define the metrics: # Recall@5 would make no sense, because we have only 5 classes here names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({ 'eval/Accuracy': slim.metrics.streaming_accuracy(predictions, train_label_batch), 'eval/Recall': slim.metrics.streaming_recall(predictions, train_label_batch), 'eval/Precision': slim.metrics.streaming_precision(predictions, train_label_batch) }) for name, tensor in names_to_updates.items(): tf.summary.scalar(name, tensor) saver = tf.train.Saver() session_config = tf.ConfigProto() session_config.gpu_options.allow_growth = True session_config.log_device_placement = True session = tf.Session(config=session_config) prev_model = tf.train.get_checkpoint_state(logs_path) if load_checkpoint: if prev_model: saver.restore(session, prev_model.model_checkpoint_path) print('Checkpoint found, {}'.format(prev_model)) else: print('No checkpoint found') # Run the training: final_loss = slim.learning.train( train_op, logdir=logs_path, number_of_steps=num_epochs * num_batches, session_config=session_config, save_summaries_secs=20, save_interval_secs=300 ) print('Finished training. Final batch loss %d' % final_loss)
X_test = mnist.test.images X_test=np.reshape(X_test,[-1,28,28,1]) X_images=[] for image in X_test: X_images.append(pad_image(image,img_h,img_w)) X_test=np.asarray(X_images) y_test=mnist.test.labels # -------------------------------# X = tf.placeholder('float', [None, img_h,img_w,1]) Y = tf.placeholder('float') is_training=tf.placeholder(tf.bool) with slim.arg_scope(alexnet_v2_arg_scope()): predict, _ = alexnet_v2(X, n_output_layer, is_training, 0.8) cost_func = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=predict, labels=Y)) optimizer = tf.train.AdamOptimizer().minimize(cost_func) # learning rate 默认 0.001 correct = tf.equal(tf.argmax(predict, 1), tf.argmax(Y, 1)) accuracy = tf.reduce_mean(tf.cast(correct, 'float')) epochs = 1 with tf.Session() as session: session.run(tf.global_variables_initializer()) epoch_loss = 0 for epoch in range(epochs): for step in range(mnist.train.num_examples // batch_size): x, y = mnist.train.next_batch(batch_size)
def main(_): """ Configuration Part. """ assert FLAGS.logs_dir, '`logs_dir` is missing.' logs_path = os.path.join('logs', FLAGS.logs_dir) data_dir = 'data' tfrecord_test = ['2_image_compare_test.tfrecords'] test_tf_path = [] for record in tfrecord_test: test_tf_path.append(os.path.join(data_dir, record)) crop_size = [256, 256] num_classes = 2 pattern_extension = range(2) num_examples = get_record_number(test_tf_path) batch_size = 64 num_batches = math.ceil(num_examples / float(batch_size)) # Load the data test_image_batch, test_label_batch = get_data_batch(test_tf_path, pattern_extension, crop_size, batch_size, is_training=False, one_hot=False) # convert to float batch float_image_batch = tf.to_float(test_image_batch) # Define the network # with slim.arg_scope(mobilenet_v2.training_scope(is_training=False)): # logits, _ = mobilenet_v2.mobilenet(float_image_batch, num_classes=num_classes) with slim.arg_scope(alexnet.alexnet_v2_arg_scope()): logits, end_points = alexnet.alexnet_v2(float_image_batch, num_classes=num_classes, is_training=False) predictions = tf.argmax(logits, 1) # Choose the metrics to compute: # names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({ # 'accuracy': slim.metrics.accuracy(predictions, test_label_batch), # }) names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({ 'test/Accuracy': slim.metrics.streaming_accuracy(predictions, test_label_batch), 'test/mse': slim.metrics.streaming_mean_squared_error(predictions, test_label_batch), 'test/Recall': slim.metrics.streaming_recall(predictions, test_label_batch), 'test/Precision': slim.metrics.streaming_precision(predictions, test_label_batch) # 'test/Recall@5': slim.metrics.streaming_recall_at_k(logits, test_label, 5), }) for name, tensor in names_to_updates.items(): tf.summary.scalar(name, tensor) # Create the summary ops such that they also print out to std output: summary_ops = [] for metric_name, metric_value in names_to_values.items(): op = tf.summary.scalar(metric_name, metric_value) op = tf.Print(op, [metric_value], metric_name) summary_ops.append(op) # Setup the global step. slim.get_or_create_global_step() session_config = tf.ConfigProto() session_config.gpu_options.allow_growth = True session = tf.Session(config=session_config) tf.logging.set_verbosity(tf.logging.INFO) eval_interval_secs = 10 # How often to run the evaluation. slim.evaluation.evaluation_loop('', logs_path, logs_path, num_evals=num_batches, eval_op=list(names_to_updates.values()), summary_op=tf.summary.merge(summary_ops), eval_interval_secs=eval_interval_secs)
def FullyConvolutional_net(X, num_classes, dropout_keep_prob=0.25): with alexnet.slim.arg_scope(alexnet.alexnet_v2_arg_scope( )): # Dimension of inputs : [batch_size, height, width, 3] logits, _ = alexnet.alexnet_v2( X, num_classes) # Dimension of Logits : [batch_size, num_classes] return logits
def train(): input_model = Inputs(FLAGS.data_dir, FLAGS.batch_size, one_hot=FLAGS.one_hot) with tf.name_scope('input'): x = tf.placeholder(tf.float32, [None, 28 * 28 * 1], 'x') y_ = tf.placeholder(tf.float32, [None, 10], 'y_') keep = tf.placeholder(tf.float32) is_training = tf.placeholder(tf.bool, name='MODE') image_shaped_input = tf.reshape(x, [-1, 28, 28, 1]) # shape [n,28,28,1] # alexnet要求的数据shape是 224x224 image_shaped_input = tf.image.resize_image_with_crop_or_pad( image_shaped_input, 224, 224) # shape[n,224,224,1] # with slim.arg_scope(cifarnet_arg_scope()): # with slim.arg_scope(inception_resnet_v2_arg_scope()): # y, _ = cifarnet(images=image_shaped_input,num_classes=10,is_training=is_training,dropout_keep_prob=keep) # 上面的修改成 with slim.arg_scope(alexnet.alexnet_v2_arg_scope()): y, _ = alexnet.alexnet_v2(inputs=image_shaped_input, num_classes=10, is_training=is_training, dropout_keep_prob=keep) model = Conv_model(y_, FLAGS.learning_rate) cross_entropy = model.loss(y, MSE_error=False, one_hot=FLAGS.one_hot) train_op = model.train(cross_entropy) accuracy = model.evaluate(y, one_hot=FLAGS.one_hot) init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) with tf.Session() as sess: sess.run(init) for step in range(FLAGS.num_steps): batch_xs, batch_ys = input_model.inputs() train_op.run({ x: batch_xs, y_: batch_ys, keep: 0.7, is_training: True }) if step % FLAGS.disp_step == 0: acc = accuracy.eval({ x: batch_xs, y_: batch_ys, keep: 1., is_training: False }) print( "step", step, 'acc', acc, 'loss', cross_entropy.eval({ x: batch_xs, y_: batch_ys, keep: 1., is_training: False })) # test acc test_x, test_y = input_model.test_inputs() acc = accuracy.eval({ x: test_x, y_: test_y, keep: 1., is_training: False }) print('test acc', acc)