def main(): parser = argparse.ArgumentParser(description='Evaluate CaffeNet') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--data-dir', type=str, default='./data/VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() test_images, test_labels, test_weights = util.load_pascal(args.data_dir, class_names=CLASS_NAMES, split='test') test_dataset = tf.data.Dataset.from_tensor_slices((test_images, test_labels, test_weights)) test_dataset = test_dataset.map(center_crop_test_data) test_dataset = test_dataset.batch(args.batch_size) model = CaffeNet(num_classes=len(CLASS_NAMES)) checkpoint = tf.train.Checkpoint(model=model) status = checkpoint.restore(tf.train.latest_checkpoint('pascal_caffenet')) AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap( test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def main(): parser = argparse.ArgumentParser(description='VGG Fine Tune') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=10, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.0001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=60, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=60, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./data/VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset = train_dataset.map(augment_train_data) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.map(center_crop_test_data) test_dataset = test_dataset.batch(args.batch_size) model = VGG(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() tf.contrib.summary.initialize() global_step = tf.train.get_or_create_global_step() train_log = {'iter': [], 'loss': [], 'accuracy': []} test_log = {'iter': [], 'loss': [], 'accuracy': []} ckpt_dir = 'pascal_vgg_ft' ckpt_prefix = os.path.join(ckpt_dir, 'ckpt') if not os.path.exists(ckpt_dir): os.makedirs(ckpt_dir) # Build model first to load weights input_shape = tf.TensorShape([None, 224, 224, 3]) model.build(input_shape) model.load_weights('vgg16_weights_tf_dim_ordering_tf_kernels.h5', by_name=True) # Print layer names in saved weights # f = h5py.File('vgg16_weights_tf_dim_ordering_tf_kernels.h5', 'r') # # Get the data # for i in list(f.keys()): # print(i) decayed_lr = tf.train.exponential_decay(args.lr, global_step, 1000, 0.5, staircase=True) optimizer = tf.train.MomentumOptimizer(learning_rate=decayed_lr(), momentum=0.9) root = tf.train.Checkpoint(optimizer=optimizer, model=model) for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() for batch, (images, labels, weights) in enumerate(train_dataset): loss_value, grads = util.cal_grad( model, loss_func=tf.losses.sigmoid_cross_entropy, inputs=images, targets=labels, weights=weights) grads_and_vars = zip(grads, model.trainable_variables) optimizer.apply_gradients(grads_and_vars, global_step) epoch_loss_avg(loss_value) if global_step.numpy() % args.log_interval == 0: print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f}' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Training Loss', loss_value) tf.contrib.summary.image('RGB', images) tf.contrib.summary.scalar('LR', decayed_lr()) for i, variable in enumerate(model.trainable_variables): tf.contrib.summary.histogram("grad_" + variable.name, grads[i]) if global_step.numpy() % args.eval_interval == 0: test_AP, test_mAP = util.eval_dataset_map(model, test_dataset) test_loss = test(model, test_dataset) print("mAP: ", test_mAP) print("Test Loss: ", test_loss) # print("Loss: %.4f, Acc: %.4f, mAP: %.4f", test_lotest_mAP) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Test mAP', test_mAP) tf.contrib.summary.scalar('Test Loss', test_loss) if ep % 2 == 0: root.save(ckpt_prefix) root.save(ckpt_prefix) model.summary() AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=5, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=20, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() img_save_interval = 200 train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') ## TODO modify the following code to apply data augmentation here ori_h = train_images.shape[1] ori_w = train_images.shape[2] crop_h = 224 crop_w = 224 central_fraction = 0.7 train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) train_dataset_aug_flip = train_dataset.map( lambda img, l, w: (tf.image.random_flip_left_right(img), l, w)) train_dataset_aug_crop = train_dataset_aug_flip.map( lambda img, l, w: (tf.random_crop(img, [crop_h, crop_w, 3]), l, w)) train_dataset.concatenate(train_dataset_aug_flip) test_dataset_aug = test_dataset.map( lambda img, l, w: (tf.image.central_crop(img, central_fraction), l, w)) test_dataset_aug = test_dataset_aug.map( lambda img, l, w: (tf.image.resize_images(img, (ori_h, ori_w)), l, w)) test_dataset.concatenate(test_dataset_aug) train_dataset = train_dataset.map(lambda img, l, w: (img_mean_substract(img), l, w)) test_dataset = test_dataset.map(lambda img, l, w: (img_mean_substract(img), l, w)) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = test_dataset.batch(args.batch_size) model = SimpleCNN(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) checkpoint_dir = os.path.join(logdir, "ckpt") if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() ## TODO write the training and testing code for multi-label classification global_step = tf.train.get_or_create_global_step() learning_rate = tf.train.exponential_decay(args.lr, global_step, 5000, 0.5, staircase=True) optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9) checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model) train_log = {'iter': [], 'loss': [], 'accuracy': []} test_log = {'iter': [], 'loss': [], 'accuracy': []} for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() for batch, (images, labels, weights) in enumerate(train_dataset): loss_value, grads = util.cal_grad( model, loss_func=tf.losses.sigmoid_cross_entropy, inputs=images, weights=weights, targets=labels) optimizer.apply_gradients(zip(grads, model.trainable_variables), global_step) epoch_loss_avg(loss_value) if global_step.numpy() % args.log_interval == 0: print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f} ' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) # Tensorboard Visualization with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('training_loss', epoch_loss_avg.result()) #tf.contrib.summary.scalar('learning_rate', learning_rate()) # for grad,var in zip(grads,model.trainable_variables): # tf.contrib.summary.histogram("gradients_{0}".format(var.name), grad) if global_step.numpy() % args.eval_interval == 0: with tf.contrib.summary.always_record_summaries(): test_AP, test_mAP = util.eval_dataset_map( model, test_dataset) tf.contrib.summary.scalar('test_map', test_mAP) #test_loss = test(test_dataset,model) #tf.contrib.summary.scalar('testing_loss', test_loss) # if global_step.numpy() % img_save_interval == 0: # with tf.contrib.summary.always_record_summaries(): # tf.contrib.summary.image('training_img', images) # Save checkpoints checkpoint.save(file_prefix=checkpoint_dir) AP, mAP = util.eval_dataset_map(model, test_dataset) # For visualization rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=10, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.0001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=60, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb/05', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./VOCdevkit/VOC2007', help='Path to PASCAL data storage') parser.add_argument('--checkpoint-dir', type=str, default='./checkpoints/06', help='Path to checkpoints storage') parser.add_argument( '--save-interval', type=int, default=2, help='How many batch to wait before storing checkpoints') parser.add_argument( '--pretrain-dir', type=str, default= './pre_trained_model/vgg16_weights_tf_dim_ordering_tf_kernels.h5', help='path the pretrained model') parser.add_argument('--scratch-dir', type=str, default='./checkpoints/04/ckpt.h5', help='path the scratched model') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() model = SimpleCNN(pretrain_dir=args.pretrain_dir, scratch_dir=args.scratch_dir, num_classes=len(CLASS_NAMES)) train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') # np.random.seed(1) # images_mix = train_images # np.random.shuffle(images_mix) # np.random.seed(1) # labels_mix = train_labels # np.random.shuffle(labels_mix) # np.random.seed(1) # weights_mix = train_weights # np.random.shuffle(weights_mix) # lamb = np.random.beta(2., 2.) # train_images=train_images * lamb + images_mix * (1-lamb) # train_labels=train_labels * lamb + labels_mix * (1-lamb) # train_weights=train_weights * lamb + weights_mix * (1-lamb) ## TODO modify the following code to apply data augmentation here print('start_loading!') train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.batch(50) train_dataset_mix = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset_mix = train_dataset_mix.shuffle(10000).batch(args.batch_size) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() ## TODO write the training and testing code for multi-label classification global_step = tf.train.get_or_create_global_step() learning_rate_decay = tf.train.exponential_decay(args.lr, global_step, 1000, 0.5) optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate_decay, momentum=0.9) train_log = {'iter': [], 'loss': []} test_log = {'iter': [], 'loss': [], 'accuracy': []} print('start training!') for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() # epoch_accuracy = tfe.metrics.Accuracy() for batch, ((images, labels, weights), (images_mix, labels_mix, weights_mix)) in enumerate( zip(train_dataset, train_dataset_mix)): # print(labels - labels_mix) labels = tf.cast(labels, tf.float32) labels_mix = tf.cast(labels_mix, tf.float32) weights = tf.cast(weights, tf.float32) weights_mix = tf.cast(weights_mix, tf.float32) lamb_size = images.shape[0] lamb = np.random.beta(0.2, 0.2, lamb_size) # print(lamb) images = images * lamb[:, np.newaxis, np.newaxis, np.newaxis] + images_mix * ( 1 - lamb)[:, np.newaxis, np.newaxis, np.newaxis] # print(images.shape) weights = weights * lamb[:, np.newaxis] + weights_mix * ( 1. - lamb)[:, np.newaxis] labels = labels * lamb[:, np.newaxis] + labels_mix * ( 1. - lamb)[:, np.newaxis] # print(labels * lamb[:, np.newaxis]) # print(labels.dtype) images, labels, weights = mean_normalization( images, labels, weights) images, labels, weights = randomly_crop(images, labels, weights) images, labels, weights = randomly_flip(images, labels, weights) # print(images[0]) # print(labels) # print(weights.shape) with tf.contrib.summary.record_summaries_every_n_global_steps(100): tf.contrib.summary.image("sample_image", images, max_images=3) loss_value, grads = util.cal_grad( model, loss_func=tf.losses.sigmoid_cross_entropy, inputs=images, targets=labels, weights=weights) optimizer.apply_gradients(zip(grads, model.trainable_variables), global_step) learning_rate_decay = tf.train.exponential_decay( args.lr, global_step, 1000, 0.5) with tf.contrib.summary.record_summaries_every_n_global_steps(1): tf.contrib.summary.scalar('learning_rate', learning_rate_decay()) with tf.contrib.summary.record_summaries_every_n_global_steps(10): for grad, var in zip(grads, model.trainable_variables): tf.contrib.summary.histogram( "{}/grad_histogram".format(var.name), grad) with tf.contrib.summary.record_summaries_every_n_global_steps(1): tf.contrib.summary.scalar('training_loss', loss_value) epoch_loss_avg(loss_value) if global_step.numpy() % args.log_interval == 0: print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f}' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) # tf.contrib.summary.scalar('training_loss', epoch_loss_avg.result()) # train_log['accuracy'].append(epoch_accuracy.result()) if global_step.numpy() % args.eval_interval == 0: test_loss, test_acc = test(model, test_dataset) with tf.contrib.summary.record_summaries_every_n_global_steps( args.eval_interval): tf.contrib.summary.scalar('testing_acc', test_acc) test_log['iter'].append(global_step.numpy()) test_log['loss'].append(test_loss) test_log['accuracy'].append(test_acc) # tf.contrib.summary.scalar('testing_loss', test_loss) # tf.contrib.summary.scalar('testing_loss', test_acc) print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Testing Loss:{3:.4f} Testing Accuracy:{4:.4f}' .format(ep, args.epochs, global_step.numpy(), test_loss, test_acc)) # if global_step.numpy() % args.save_epoch == 0: # checkpoint = tfe.Checkpoint(optimizer=optimizer, # model=model, # optimizer_step=tf.train.get_or_create_global_step()) # checkpoint_prefix = os.path.join(args.checkpoint_dir, "ckpt") # checkpoint.save(file_prefix=checkpoint_prefix) AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) # checkpoint = tfe.Checkpoint(optimizer=optimizer, # model=model, # optimizer_step=tf.train.get_or_create_global_step()) # checkpoint_prefix = os.path.join(args.checkpoint_dir, "ckpt") # checkpoint.save(file_prefix=checkpoint_prefix) checkpoint_prefix = os.path.join(args.checkpoint_dir, "ckpt.h5") model.save_weights(checkpoint_prefix) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid))) writer.close()
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=30, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=250, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='pascal_caffenet_tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() splt = "trainval" trainval_npz = splt + '.npz' test_npz = 'test.npz' if (os.path.isfile(trainval_npz)): print("\nFound trainval npz file\n") with np.load(trainval_npz) as tr_npzfile: train_images = tr_npzfile['imgs'] train_labels = tr_npzfile['labels'] train_weights = tr_npzfile['weights'] else: train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split=splt) np.savez(trainval_npz, imgs=train_images, labels=train_labels, weights=train_weights) ##TEST## if (os.path.isfile(test_npz)): print("\nFound test npz file\n") # npzfile = np.load(test_npz) with np.load(test_npz) as test_npzfile: test_images = test_npzfile['imgs'] test_labels = test_npzfile['labels'] test_weights = test_npzfile['weights'] else: test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') np.savez(test_npz, imgs=test_images, labels=test_labels, weights=test_weights) ## TODO modify the following code to apply data augmentation here rgb_mean = np.array([123.68, 116.78, 103.94], dtype=np.float32) / 256.0 train_images = (train_images - rgb_mean).astype(np.float32) test_images = (test_images - rgb_mean).astype(np.float32) flip_fn = lambda img, lbl, wts: flip(img, lbl, wts) crop_fn = lambda img, lbl, wts: crop(img, lbl, wts) ccrop_fn = lambda img, lbl, wts: center_crop(img, lbl, wts) train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) flipped_train = train_dataset.map(flip_fn, num_parallel_calls=4) train_dataset = train_dataset.concatenate(flipped_train) train_dataset = train_dataset.map(crop_fn, num_parallel_calls=4) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.map(ccrop_fn, num_parallel_calls=4) test_dataset = test_dataset.batch(args.batch_size) model = SimpleCNN(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() tf.contrib.summary.initialize() global_step = tf.train.get_or_create_global_step() # optimizer = tf.train.AdamOptimizer(learning_rate=args.lr) ##decay lr using callback learning_rate = tf.Variable(args.lr) decay_interval = 5000 # decay_op = tf.train.exponential_decay(args.lr,global_step,decay_interval,0.5) ##optimizer : sgd , momentum, 0.9 optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9) train_log = {'iter': [], 'loss': []} test_log = {'iter': [], 'mAP': []} checkpoint_directory = "./03_pascal_caffenet/" if not os.path.exists(checkpoint_directory): os.makedirs(checkpoint_directory) checkpoint_prefix = os.path.join(checkpoint_directory, "ckpt") checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model) # pdb.set_trace() latest = tf.train.latest_checkpoint(checkpoint_directory) load_flag = 0 if (latest is not None): print("Loading checkpoint ", latest) status = checkpoint.restore( tf.train.latest_checkpoint(checkpoint_directory)) load_flag = 1 print("\nUsing eval interval: ", args.eval_interval) print("\nUsing batch size: ", args.batch_size) for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() # for batch, (images, labels,weights) in enumerate(train_dataset): for (images, labels, weights) in tfe.Iterator(train_dataset): # pdb.set_trace() # loss_value, grads = util.cal_grad(model, # loss_func=tf.losses.sigmoid_cross_entropy, # inputs=images, # targets=labels, # weights=weights) with tf.GradientTape() as tape: logits = model(images, training=True) loss_value = tf.losses.sigmoid_cross_entropy( labels, logits, weights) grads = tape.gradient(loss_value, model.trainable_variables) # print("Loss and gradient calculation, done \n") # pdb.set_trace() optimizer.apply_gradients(zip(grads, model.trainable_variables), global_step) epoch_loss_avg(loss_value) if global_step.numpy() % args.log_interval == 0: # pdb.set_trace() print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f} ' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Training loss', loss_value) tf.contrib.summary.scalar('Learning rate', learning_rate) for i, variable in enumerate(model.trainable_variables): tf.contrib.summary.histogram("grad_" + variable.name, grads[i]) if global_step.numpy() % args.eval_interval == 0: print("\n **** Running Eval *****\n") test_AP, test_mAP = util.eval_dataset_map(model, test_dataset) print("Eval finsished with test mAP : ", test_mAP) test_log['iter'].append(global_step.numpy()) test_log['mAP'].append(test_mAP) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Testing mAP', test_mAP) learning_rate.assign( tf.train.exponential_decay(args.lr, global_step, decay_interval, 0.5)()) print("Learning rate:", learning_rate) checkpoint.save(checkpoint_prefix) ## TODO write the training and testing code for multi-label classification AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=5, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=50, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./data/VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset = train_dataset.map(augment_train_data) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.map(center_crop_test_data) test_dataset = test_dataset.batch(args.batch_size) model = SimpleCNN(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() tf.contrib.summary.initialize() global_step = tf.train.get_or_create_global_step() optimizer = tf.train.AdamOptimizer(learning_rate=args.lr) train_log = {'iter': [], 'loss': [], 'accuracy': []} test_log = {'iter': [], 'loss': [], 'accuracy': []} for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() for batch, (images, labels, weights) in enumerate(train_dataset): loss_value, grads = util.cal_grad( model, loss_func=tf.losses.sigmoid_cross_entropy, inputs=images, targets=labels, weights=weights) optimizer.apply_gradients(zip(grads, model.trainable_variables), global_step) epoch_loss_avg(loss_value) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Training Loss', loss_value) if global_step.numpy() % args.log_interval == 0: print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f}' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) if global_step.numpy() % args.eval_interval == 0: test_AP, test_mAP = util.eval_dataset_map(model, test_dataset) print("mAP: ", test_mAP) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Test mAP', test_mAP) model.summary() # fig = plt.figure() # plt.plot(train_log['iter'], train_log['loss'], 'r', label='Training') # plt.plot(test_log['iter'], test_log['loss'], 'b', label='Testing') # plt.title('Loss') # plt.legend() # fig = plt.figure() # plt.plot(train_log['iter'], train_log['accuracy'], 'r', label='Training') # plt.plot(test_log['iter'], test_log['accuracy'], 'b', label='Testing') # plt.title('Accuracy') # plt.legend() # plt.show() AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=10, help='input batch size for training') parser.add_argument('--epochs', type=int, default=5, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=20, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') ## TODO modify the following code to apply data augmentation here train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.batch(args.batch_size) model = SimpleCNN(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() ## TODO write the training and testing code for multi-label classification AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))