def main(argv=None): print("This script is used to compute accuracy!") if len(argv) < 2: print("No argv! You need to assign train/test/adv data as below:") print("Try: python compute_acc.py train, python compute_acc.py test\n") return batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3] nb_classes = FLAGS.num_classes tf.logging.set_verbosity(tf.logging.INFO) config = tf.ConfigProto() # allocate 50% of GPU memory config.gpu_options.allow_growth = True config.gpu_options.per_process_gpu_memory_fraction = 0.5 with tf.Graph().as_default(): print("Prepare graph...") x_input = tf.placeholder(tf.float32, shape=batch_shape) noise_input = gaussian_noise_layer(x_input, .0) with slim.arg_scope(inception.inception_v1_arg_scope()): _, end_points = inception.inception_v1(noise_input, num_classes=nb_classes, is_training=False) predicted_labels = tf.argmax(end_points['Predictions'], 1) print("Restore Model...") saver = tf.train.Saver(slim.get_model_variables()) session_creator = tf.train.ChiefSessionCreator( config=config, scaffold=tf.train.Scaffold(saver=saver), checkpoint_filename_with_path=FLAGS.checkpoint_path) print("Run computation...") with tf.train.MonitoredSession( session_creator=session_creator) as sess: if argv[1] == 'test': INPUT_DIR = FLAGS.test_data_dir FLAGS.output_file = './result/test_accuracy.txt' elif argv[1] == 'train': INPUT_DIR = FLAGS.train_data_dir FLAGS.output_file = './result/train_accuracy.txt' elif argv[1] == 'adv': INPUT_DIR = FLAGS.adv_data_dir FLAGS.output_file = './result/adversarial_accuracy.txt' data_generator = load_path_label(INPUT_DIR, batch_shape, shuffle=False) acc_dict = {} for i in range(FLAGS.num_classes): acc_dict[i] = [0, 0] for images, true_labels, _ in tqdm(data_generator): labels = sess.run(predicted_labels, feed_dict={x_input: images}) for i in range(len(true_labels)): acc_dict[true_labels[i]][1] += 1 if labels[i] == true_labels[i]: acc_dict[true_labels[i]][0] += 1 print("Compute accuracy...") with open(FLAGS.output_file, 'w') as f: total_true = 0 total_count = 0 for i in range(FLAGS.num_classes): total_true += acc_dict[i][0] total_count += acc_dict[i][1] if acc_dict[i][1] == 0: f.writelines("class: %d, accuracy: %d/%d = %.3f \n" % (i, acc_dict[i][0], acc_dict[i][1], 0)) else: f.writelines("class: %d, accuracy: %d/%d = %.3f \n" % (i, acc_dict[i][0], acc_dict[i][1], acc_dict[i][0] / acc_dict[i][1])) print("Total accuracy: %.3f \n" % (total_true / total_count)) f.writelines("Total accuracy: %.3f \n" % (total_true / total_count)) print('Save accuracy result to %s' % FLAGS.output_file)
def main(_): if not tf.gfile.Exists(FLAGS.checkpoint_path): tf.gfile.MkDir(FLAGS.checkpoint_path) else: if not FLAGS.restore: tf.gfile.DeleteRecursively(FLAGS.checkpoint_path) tf.gfile.MkDir(FLAGS.checkpoint_path) batch_shape = [FLAGS.batch_size, FLAGS.image_height, FLAGS.image_width, 3] nb_classes = FLAGS.num_classes input_images = tf.placeholder( tf.float32, [None, FLAGS.image_height, FLAGS.image_width, 3]) input_labels = tf.placeholder(tf.float32, [None, nb_classes]) learning_rate = FLAGS.learning_rate # add summary tf.summary.scalar('learning_rate', learning_rate) with slim.arg_scope(inception.inception_v1_arg_scope()): logits, end_points = inception.inception_v1(input_images, num_classes=110, is_training=True) variables_to_restore = slim.get_variables_to_restore() loss_op = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=input_labels) total_loss_op = tf.reduce_mean(loss_op) train_op = tf.train.AdamOptimizer(learning_rate).minimize(loss_op) tf.summary.scalar('total loss', total_loss_op) summary_op = tf.summary.merge_all() saver = tf.train.Saver(variables_to_restore) summary_writer = tf.summary.FileWriter(FLAGS.checkpoint_path, tf.get_default_graph()) init = tf.global_variables_initializer() if FLAGS.pretrained_model_path is not None: variable_restore_op = slim.assign_from_checkpoint_fn( FLAGS.pretrained_model_path, slim.get_trainable_variables(), ignore_missing_vars=True) with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess: if FLAGS.restore: sess.run(init) print('continue training from previous checkpoint') ckpt = tf.train.latest_checkpoint(FLAGS.checkpoint_path) saver.restore(sess, ckpt) else: sess.run(init) if FLAGS.pretrained_model_path is not None: variable_restore_op(sess) for epoch in range(FLAGS.max_epochs): start = time.time() data_generator = load_path_label('./datasets/train_labels.txt', batch_shape, onehot=True) for step in range(FLAGS.max_steps): data = next(data_generator) _, total_loss, res = sess.run( [train_op, total_loss_op, summary_op], feed_dict={ input_images: data[0], input_labels: data[1] }) if step % 50 == 0: summary_writer.add_summary(res, step) if np.isnan(total_loss): print('Loss diverged, stop training') break if step % 10 == 0: avg_time_per_step = (time.time() - start) / 10 avg_examples_per_second = (10 * FLAGS.batch_size) / ( time.time() - start) start = time.time() print( 'Step {:06d}, total loss {:.4f}, {:.2f} seconds/step, {:.2f} examples/second' .format(step, total_loss, avg_time_per_step, avg_examples_per_second)) saver.save(sess, FLAGS.checkpoint_path + 'robust_model', global_step=epoch)
tf.GraphKeys.GLOBAL_VARIABLES, scope='Critic') ac_saver = tf.train.Saver(ac_var_list, max_to_keep=3) if not tf.gfile.Exists(FLAGS.ddpg_checkpoint_path): tf.gfile.MkDir(FLAGS.ddpg_checkpoint_path) else: if tf.train.latest_checkpoint(FLAGS.ddpg_checkpoint_path): ac_saver.restore( sess, tf.train.latest_checkpoint(FLAGS.ddpg_checkpoint_path)) # initialization classifier classifier = Classifier([None, 224, 224, 3], FLAGS.num_classes) M = Memory(FLAGS.MEMORY_CAPACITY) var = 0.001 # control exploration start = time.time() data_generator = load_path_label( FLAGS.input_dir, [1, FLAGS.image_height, FLAGS.image_width, 3]) for episode in range(FLAGS.max_ep_steps): # ep_reward = 0.0 step = 0 done = False (images, _, filepaths) = next(data_generator) features, labels = classifier.extract_feature(images) noise_images = images while not done: actions = actor.choose_action(features) actions = np.clip( np.random.normal(actions, var), -FLAGS.EPSILON, FLAGS.EPSILON ) # add randomness to action selection for exploration noise_images = np.clip(noise_images + actions, -1, 1) r, l2_dist, pre_labels = classifier.get_reward( images, noise_images, labels)