def testForward(self): batch_size = 1 height, width = 224, 224 with self.test_session() as sess: inputs = tf.random_uniform((batch_size, height, width, 3)) logits, _ = alexnet.alexnet_v2(inputs) sess.run(tf.global_variables_initializer()) output = sess.run(logits) self.assertTrue(output.any())
def test_image(): '''Test images against the saved models and parameters ''' train, image_ids = get_files() with tf.Graph().as_default(): train_batch, imageid_batch = get_batch(train, image_ids, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) logit, _ = alexnet.alexnet_v2(train_batch, N_CLASSES) prediction = tf.argmax(logit, 1) # you need to change the directories to yours. logs_train_dir = './logs/train/' saver = tf.train.Saver() with tf.Session() as sess: print("Reading checkpoints...") ckpt = tf.train.get_checkpoint_state(logs_train_dir) if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split( '-')[-1] saver.restore(sess, ckpt.model_checkpoint_path) print('Loading success, global_step is %s' % global_step) else: print('No checkpoint file found') coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) all_predictions = [] try: for step in np.arange(MAX_STEP): if coord.should_stop(): break batch_predictions = sess.run([prediction]) print(batch_predictions) all_predictions = np.concatenate( [all_predictions, batch_predictions[0]]) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) # pdb.set_trace() all_predictions.astype(np.int64) all_predictions = input_helper.get_real_label(all_predictions) predictions_human_readable = np.column_stack( (all_predictions, np.array(image_ids))) out_path = os.path.join(".", "prediction.csv") print("Saving evaluation to {0}".format(out_path)) with open(out_path, 'w') as f: for line in predictions_human_readable: f.write(str(line[0]) + '\t' + str(line[1]) + '\n')
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 testBuild(self): batch_size = 5 height, width = 224, 224 num_classes = 1000 with self.test_session(): inputs = tf.random_uniform((batch_size, height, width, 3)) logits, _ = alexnet.alexnet_v2(inputs, num_classes) self.assertEquals(logits.op.name, 'alexnet_v2/fc8/squeezed') self.assertListEqual(logits.get_shape().as_list(), [batch_size, num_classes])
def testFullyConvolutional(self): batch_size = 1 height, width = 300, 400 num_classes = 1000 with self.test_session(): inputs = tf.random_uniform((batch_size, height, width, 3)) logits, _ = alexnet.alexnet_v2(inputs, num_classes, spatial_squeeze=False) self.assertEquals(logits.op.name, 'alexnet_v2/fc8/BiasAdd') self.assertListEqual(logits.get_shape().as_list(), [batch_size, 4, 7, num_classes])
def testEvaluation(self): batch_size = 2 height, width = 224, 224 num_classes = 1000 with self.test_session(): eval_inputs = tf.random_uniform((batch_size, height, width, 3)) logits, _ = alexnet.alexnet_v2(eval_inputs, is_training=False) self.assertListEqual(logits.get_shape().as_list(), [batch_size, num_classes]) predictions = tf.argmax(logits, 1) self.assertListEqual(predictions.get_shape().as_list(), [batch_size])
def main(): args = parse_args() # Load the train data (train_images, train_labels, train_weights) = load_pascal(args.data_directory, split='train') # Avoid loading other data for now # (test_images, test_labels, test_weights) = load_pascal(args.data_directory, split='test') # (val_images, val_labels, val_weights) = load_pascal(args.data_directory, split='val') num_train_images = train_images.shape[0] batch_size = 10 num_epochs = 5 inputs = tf.placeholder(tf.float32, shape=(batch_size, 224, 224, 3)) outputs, end_points = alexnet.alexnet_v2(inputs) # Log some dummy data to tensorboard summary_writer = tf.summary.FileWriter('tmp/tensorboard_example', graph=tf.get_default_graph()) loss = 0.2 tf.summary.scalar('Loss', loss) tf.summary.image('Batch Images', inputs) merged_summary = tf.summary.merge_all() # Setup a TensorFlow session with tf.Session() as sess: # Initialize global variables sess.run(tf.global_variables_initializer()) # Epoch = a full cycle through all of the training images for epoch in range(num_epochs): # Randomly order the training images training_order = range(num_train_images) shuffle(training_order) # Split the training images into batches for batch_num in range(int(floor(num_train_images / batch_size))): # Extract the data for this batch batch_indices = training_order[batch_num * batch_size:(batch_num + 1) * batch_size] batch_images = np.take(train_images, batch_indices, axis=0) batch_labels = np.take(train_labels, batch_indices, axis=0) batch_weights = np.take(train_weights, batch_indices, axis=0) [output_logits, summary] = sess.run([outputs, merged_summary], feed_dict={inputs: batch_images}) summary_writer.add_summary(summary)
def testEndPoints(self): batch_size = 5 height, width = 224, 224 num_classes = 1000 with self.test_session(): inputs = tf.random_uniform((batch_size, height, width, 3)) _, end_points = alexnet.alexnet_v2(inputs, num_classes) expected_names = [ 'alexnet_v2/conv1', 'alexnet_v2/pool1', 'alexnet_v2/conv2', 'alexnet_v2/pool2', 'alexnet_v2/conv3', 'alexnet_v2/conv4', 'alexnet_v2/conv5', 'alexnet_v2/pool5', 'alexnet_v2/fc6', 'alexnet_v2/fc7', 'alexnet_v2/fc8' ] self.assertSetEqual(set(end_points.keys()), set(expected_names))
def testTrainEvalWithReuse(self): train_batch_size = 2 eval_batch_size = 1 train_height, train_width = 224, 224 eval_height, eval_width = 300, 400 num_classes = 1000 with self.test_session(): train_inputs = tf.random_uniform( (train_batch_size, train_height, train_width, 3)) logits, _ = alexnet.alexnet_v2(train_inputs) self.assertListEqual(logits.get_shape().as_list(), [train_batch_size, num_classes]) tf.get_variable_scope().reuse_variables() eval_inputs = tf.random_uniform( (eval_batch_size, eval_height, eval_width, 3)) logits, _ = alexnet.alexnet_v2(eval_inputs, is_training=False, spatial_squeeze=False) self.assertListEqual(logits.get_shape().as_list(), [eval_batch_size, 4, 7, num_classes]) logits = tf.reduce_mean(logits, [1, 2]) predictions = tf.argmax(logits, 1) self.assertEquals(predictions.get_shape().as_list(), [eval_batch_size])
def run_training(): # you need to change the directories to yours. file = 'train_data.txt' logs_train_dir = './logs/train/' train, train_label = input_helper.get_files(file) train_batch, train_label_batch = input_helper.get_batch( train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) train_logits, _ = alexnet.alexnet_v2(train_batch, N_CLASSES) train_loss = alexnet.losses(train_logits, train_label_batch) train_op = alexnet.trainning(train_loss, learning_rate) train__acc = alexnet.evaluation(train_logits, train_label_batch) summary_op = tf.summary.merge_all() sess = tf.Session() train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) try: for step in np.arange(MAX_STEP): if coord.should_stop(): break _, tra_loss, tra_acc = sess.run([train_op, train_loss, train__acc]) if step % 50 == 0: print('Step %d, train loss = %.2f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc * 100.0)) summary_str = sess.run(summary_op) train_writer.add_summary(summary_str, step) if step % 200 == 0 or (step + 1) == MAX_STEP: checkpoint_path = os.path.join(logs_train_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads) sess.close()
def evalalexnet(): # Create model and obtain the predictions: imgs, labels = load_data.read_tfrecord(data_dir=DATA_DIR, image_size=IMAGE_SIZE, spilt='val', batch_size=BATCH_SIZE, num_classes=NUM_CLASS) X = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3]) Y = tf.placeholder(dtype=tf.int64, shape=[BATCH_SIZE, NUM_CLASS]) logits, _ = alexnet.alexnet_v2(inputs=X, num_classes=5) predictions = tf.nn.softmax(logits) predictions = tf.cast(predictions, tf.int32) accuracy = slim.metrics.streaming_accuracy(predictions, Y), precision = slim.metrics.streaming_precision(predictions, Y), # recall = slim.metrics.streaming_recall_at_k(predictions, labels, 5), tf.summary.scalar('accuracy', accuracy) tf.summary.scalar('precision', precision) num_examples = 100 num_batches = math.ceil(num_examples / float(BATCH_SIZE)) summary_op = tf.summary.merge_all() ckptfile = '../train_log/alexnet/model.ckpt-4900' with tf.Session() as sess: summary_writer = tf.summary.FileWriter(os.path.join(LOG_DIR, 'eval'), sess.graph) tf.train.Saver().restore(sess, ckptfile) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for batch_id in range(10): reaccuracy, reprecision = sess.run([accuracy, precision], feed_dict={ X: imgs, Y: labels }) # summary_writer.add_event(summary_str) coord.request_stop() coord.join(threads)
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 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 inference(img): ref_dict = {} for img_file in glob("Dataset/Test/*.*"): img_name = img_file.split('/')[-1] img = cv2.imread(img_file) img = cv2.resize(img, (224, 224)) ref_dict[img_name] = img images = np.asarray(list(ref_dict.values())) output = alexnet.alexnet_v2(X) saver = tf.train.Saver() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) ckpt = tf.train.get_checkpoint_state("model") saver.restore(sess, "model/model-epoch500.ckpt") result = sess.run(output, feed_dict={X: images}) result = tf.nn.softmax(result) inf_result = tf.argmax(result, 1) class_result = sess.run(result) out = sess.run(inf_result) for res in range(len(out)): if (out[res] == 0): print('It is NSFW!', list(ref_dict.keys())[res]) else: print('It is SFW!', list(ref_dict.keys())[res])
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=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) x = np.reshape(x, [-1, 28, 28, 1])
shape=(1, SIZE, SIZE, 3), name='real_images') labels = tf.placeholder(tf.float32, shape=(1, 5), name='attributes') # clip logits between [0, 1] because that's the range of the labels if NETWORK == 'inception': print 'Using inception' with slim.arg_scope( inception_resnet_v2.inception_resnet_v2_arg_scope()): logits, _ = inception_resnet_v2.inception_resnet_v2( images, num_classes=5, is_training=False) if NETWORK == 'alexnet': print 'Using alexnet' with slim.arg_scope(alexnet.alexnet_v2_arg_scope()): logits, _ = alexnet.alexnet_v2(images, num_classes=5, is_training=False) print 'Done.' saver = tf.train.Saver() init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess = tf.Session() sess.run(init) # restore previous model if there is one ckpt = tf.train.get_checkpoint_state(CHECKPOINT_DIR) if ckpt and ckpt.model_checkpoint_path: print 'Restoring previous model...' try: saver.restore(sess, ckpt.model_checkpoint_path) print 'Model restored'
def train(data_dir, train_dir, max_steps, log_frequency): train_batch, train_label_batch = load_data.read_tfrecord( data_dir, image_size=IMAGE_SIZE, spilt='train', batch_size=BATCH_SIZE, num_classes=NUM_CLASS) val_batch, val_label_batch = load_data.read_tfrecord(data_dir, image_size=IMAGE_SIZE, spilt='val', batch_size=BATCH_SIZE, num_classes=NUM_CLASS) X = tf.placeholder(dtype=tf.float32, shape=[BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3]) Y = tf.placeholder(dtype=tf.int64, shape=[BATCH_SIZE, NUM_CLASS]) # 训练集 logits, _ = alexnet.alexnet_v2(inputs=X, num_classes=NUM_CLASS, is_training=True) loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=logits)) train_op = tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss) correct_prediction = tf.equal(tf.argmax(Y, 1), tf.argmax(logits, 1)) acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) tf.summary.scalar('train_loss', loss) tf.summary.scalar('train_acc', acc) summary_op = tf.summary.merge_all() saver = tf.train.Saver() start_time = now_time = time.time() with tf.Session() as sess: summary_train_writer = tf.summary.FileWriter( os.path.join(train_dir, 'trainsum'), sess.graph) summary_val_writer = tf.summary.FileWriter( os.path.join(train_dir, 'valsum'), sess.graph) sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for step in range(max_steps): if coord.should_stop(): break train_images, train_labels = sess.run( [train_batch, train_label_batch]) train_loss, _, train_acc, summary_str = sess.run( [loss, train_op, acc, summary_op], feed_dict={ X: train_images, Y: train_labels }) if step % log_frequency == 0: # 添加训练数据到tensorboard summary_train_writer.add_summary(summary_str, step) valdat_images, valdat_labels = sess.run( [val_batch, val_label_batch]) valdat_loss, valdat_acc, summary_str = sess.run( [loss, acc, summary_op], feed_dict={ X: valdat_images, Y: valdat_labels }) # 添加验证集数据到tensorboard summary_val_writer.add_summary(summary_str, step) print( 'Step %d using %ds, loss %f, acc %.2f%% --- * val_loss %f, val_acc %.2f%%' % (step, time.time() - now_time, train_loss, train_acc * 100.0, valdat_loss, valdat_acc * 100.0)) if step % (max_steps / 5) == 0 or (step + 1) == max_steps: checkpoint_path = os.path.join(train_dir, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) coord.request_stop() coord.join(threads) print('all using %d time:' % (time.time() - start_time))
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 train(): ps_hosts = FLAGS.ps_hosts.split(',') worker_hosts = FLAGS.worker_hosts.split(',') print('PS hosts are: %s' % ps_hosts) print('Worker hosts are: %s' % worker_hosts) server = tf.train.Server({ 'ps': ps_hosts, 'worker': worker_hosts }, job_name=FLAGS.job_name, task_index=FLAGS.task_id) if FLAGS.job_name == 'ps': server.join() is_chief = (FLAGS.task_id == 0) if is_chief: if tf.gfile.Exists(FLAGS.train_dir): tf.gfile.DeleteRecursively(FLAGS.train_dir) tf.gfile.MakeDirs(FLAGS.train_dir) device_setter = tf.train.replica_device_setter(ps_tasks=len(ps_hosts)) with tf.device('/job:worker/task:%d' % FLAGS.task_id): partitioner = tf.fixed_size_partitioner(len(ps_hosts), axis=0) with tf.variable_scope('partitioned_space', partitioner=partitioner): with tf.device(device_setter): global_step = tf.Variable(0, trainable=False) decay_steps = 50000 * 350.0 / FLAGS.batch_size batch_size = tf.placeholder(dtype=tf.int32, shape=(), name='batch_size') images, labels = cifar10.distorted_inputs(batch_size) inputs = tf.reshape(images, [-1, _HEIGHT, _WIDTH, _DEPTH]) labels = tf.one_hot(labels, 10, 1, 0) # network_fn = nets_factory.get_network_fn('alexnet_v2',num_classes=10) # (logits,_) = network_fn(inputs) # with slim.arg_scope(alexnet.alexnet_v2_arg_scope(weight_decay=0.0)): (logits, _) = alexnet.alexnet_v2(inputs, num_classes=10, is_training=True) cross_entropy = tf.losses.softmax_cross_entropy( logits=logits, onehot_labels=labels) loss = cross_entropy + _WEIGHT_DECAY * tf.add_n( [tf.nn.l2_loss(v) for v in tf.trainable_variables()]) # Decay the learning rate exponentially based on the number of steps. lr = tf.train.exponential_decay(INITIAL_LEARNING_RATE * len(worker_hosts), global_step, decay_steps, LEARNING_RATE_DECAY_FACTOR, staircase=True) opt = tf.train.GradientDescentOptimizer(lr) # Track the moving averages of all trainable variables. exp_moving_averager = tf.train.ExponentialMovingAverage( MOVING_AVERAGE_DECAY, global_step) variables_to_average = (tf.trainable_variables() + tf.moving_average_variables()) opt = tf.train.SyncReplicasOptimizer( opt, replicas_to_aggregate=len(worker_hosts), total_num_replicas=len(worker_hosts), variable_averages=exp_moving_averager, variables_to_average=variables_to_average) naive_grads = opt.compute_gradients(loss) grads = [(tf.scalar_mul( tf.cast(batch_size / FLAGS.batch_size, tf.float32), grad), var) for grad, var in naive_grads] apply_gradients_op = opt.apply_gradients( grads, global_step=global_step) with tf.control_dependencies([apply_gradients_op]): train_op = tf.identity(loss, name='train_op') chief_queue_runners = [opt.get_chief_queue_runner()] init_tokens_op = opt.get_init_tokens_op() saver = tf.train.Saver() sv = tf.train.Supervisor(is_chief=is_chief, logdir=FLAGS.train_dir, init_op=tf.group( tf.global_variables_initializer(), tf.local_variables_initializer()), summary_op=None, global_step=global_step, saver=saver, recovery_wait_secs=1, save_model_secs=60) tf.logging.info('%s Supervisor' % datetime.now()) sess_config = tf.ConfigProto( allow_soft_placement=True, log_device_placement=FLAGS.log_device_placement) sess_config.gpu_options.allow_growth = True sess = sv.prepare_or_wait_for_session(server.target, config=sess_config) queue_runners = tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS) sv.start_queue_runners(sess, queue_runners) sv.start_queue_runners(sess, chief_queue_runners) sess.run(init_tokens_op) """Train CIFAR-10 for a number of steps.""" time0 = time.time() batch_size_num = FLAGS.batch_size for step in range(FLAGS.max_steps): start_time = time.time() run_options = tf.RunOptions( trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() num_batches_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN / batch_size_num decay_steps_num = int(num_batches_per_epoch * NUM_EPOCHS_PER_DECAY) _, loss_value, gs = sess.run( [train_op, loss, global_step], feed_dict={batch_size: batch_size_num}, options=run_options, run_metadata=run_metadata) b = time.time() if step % 1 == 0: duration = time.time() - start_time num_examples_per_step = batch_size_num examples_per_sec = num_examples_per_step / duration sec_per_batch = float(duration) format_str = ( "time: " + str(time.time()) + '; %s: step %d (global_step %d), loss = %.2f (%.1f examples/sec; %.3f sec/batch)' ) tf.logging.info(format_str % (datetime.now(), step, gs, loss_value, examples_per_sec, sec_per_batch))
LR = tf.placeholder(tf.float32, name='learning_rate') # clip logits between [0, 1] because that's the range of the labels if NETWORK == 'inception': print 'Using inception' with slim.arg_scope( inception_resnet_v2.inception_resnet_v2_arg_scope()): logits, _ = inception_resnet_v2.inception_resnet_v2( images, num_classes=37, is_training=True) logits = tf.minimum(tf.maximum(0.0, logits), 1.0) if NETWORK == 'alexnet': print 'Using alexnet' with slim.arg_scope(alexnet.alexnet_v2_arg_scope()): logits, _ = alexnet.alexnet_v2(images, num_classes=37, is_training=True) logits = tf.minimum(tf.maximum(0.0, logits), 1.0) print 'Done.' loss = tf.reduce_mean(tf.nn.l2_loss(logits - labels)) tf.summary.scalar('loss', loss) summary_writer = tf.summary.FileWriter(CHECKPOINT_DIR + '/' + 'logs/', graph=tf.get_default_graph()) merged_summary_op = tf.summary.merge_all() train_op = tf.train.AdamOptimizer(learning_rate=LR).minimize( loss, global_step=global_step) saver = tf.train.Saver(max_to_keep=1)
datagen = Data() batch_generate = datagen.get_batch(imagefilepath) batch_xs, batch_ys = next(batch_generate) imshow(batch_xs[0]) print(batch_ys) xs = tf.placeholder(tf.float32, [None, 512, 512, 3]) ys = tf.placeholder(tf.float32, [None, 6]) keep_prob_tensor = tf.placeholder(tf.float32) learning_rate_tensor = tf.placeholder(tf.float32) global_step = tf.Variable(0, name='global_step', trainable=False) define_model = False log_path = '/data3/Avery_Jupyter/log' logit, _ = alexnet.alexnet_v2(xs, num_classes=6, spatial_squeeze=False) #define loss loss = slim.losses.softmax_cross_entropy(logit, ys) #define optimizer for training optimizer = tf.train.GradientDescentOptimizer( learning_rate=learning_rate_tensor) #define train operator train_op = slim.learning.create_train_op(loss, optimizer, global_step) prediction = tf.arg_max(logit, 1) accuracy = slim.metrics.accuracy(tf.arg_max(logit, 1), tf.arg_max(ys, 1)) #define summary for tensorboard tf.summary.scalar('Loss', loss) tf.summary.scalar('accuracy', accuracy) summary_op = tf.summary.merge_all()
def alexnet(self, images, is_training): return alexnet_v2(images, is_training=is_training)
tf.FixedLenFeature([], tf.string) }) img = tf.decode_raw(features["image"], tf.uint8) img = tf.reshape(img, [image_pixels, image_pixels, 3]) img = tf.cast(img, tf.float32) label = tf.cast(features["label"], tf.int32) return img, label images = tf.placeholder(tf.float32, [None, image_pixels, image_pixels, 3], name="input/x_input") labels = tf.placeholder(tf.int64, [None], name="input/y_input") with slim.arg_scope(alexnet_v2_arg_scope()): logits, end_points = alexnet_v2(images, num_classes=classes, is_training=True) exclude = ["alexnet_v2/fc8"] variables_to_restore = slim.get_variables_to_restore(exclude=exclude) one_hot_labels = slim.one_hot_encoding(labels, classes) loss = tf.losses.softmax_cross_entropy(onehot_labels=one_hot_labels, logits=logits) total_loss = tf.losses.get_total_loss() learning_rate = tf.Variable(initial_value=0.0001, trainable=False, name="learning_rate", dtype=tf.float32) update_learning_rate = tf.assign(learning_rate, learning_rate * 0.8) train_step = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(
def alexnet(self, images, is_training): return alexnet_v2(images, num_classes=self.params.number_of_classes, is_training=is_training)
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)
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 evaluate_image(): '''Test one image against the saved models and parameters ''' # you need to change the directories to yours. file = 'validation_data.txt' train, train_label = input_helper.get_files(file) with tf.Graph().as_default() as g: train_batch, train_label_batch = input_helper.get_batch(train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) logit, _ = alexnet.alexnet_v2(train_batch, N_CLASSES) top_k_op = tf.nn.in_top_k(logit, train_label_batch, 1) # Build the summary operation based on the TF collection of Summaries. summary_op = tf.summary.merge_all() summary_writer = tf.summary.FileWriter('./logs/eval', g) # you need to change the directories to yours. logs_train_dir = './logs/train/' saver = tf.train.Saver() with tf.Session() as sess: print("Reading checkpoints...") ckpt = tf.train.get_checkpoint_state(logs_train_dir) if ckpt and ckpt.model_checkpoint_path: global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1] saver.restore(sess, ckpt.model_checkpoint_path) print('Loading success, global_step is %s' % global_step) else: print('No checkpoint file found') coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) total_sample_count = MAX_STEP * BATCH_SIZE true_count = 0 # Counts the number of correct predictions. try: for step in np.arange(MAX_STEP): if coord.should_stop(): break predictions = sess.run([top_k_op]) true_count += np.sum(predictions) # Compute precision @ 1. precision = true_count / total_sample_count print('%s: precision @ 1 = %.3f' % (datetime.now(), precision)) summary = tf.Summary() summary.ParseFromString(sess.run(summary_op)) summary.value.add(tag='Precision @ 1', simple_value=precision) summary_writer.add_summary(summary, global_step) except tf.errors.OutOfRangeError: print('Done training -- epoch limit reached') finally: coord.request_stop() coord.join(threads)