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)))
return tf.TensorShape(shape) def randomly_crop(image): num_images = image.shape[0] image_cropped = tf.image.random_crop(image, [num_images,224, 224, 3]) # image_cropped2 = tf.image.random_crop(image, [224, 224, 3]) # image = tf.concat([image_cropped1, image_cropped2],0) # label = tf.concat([label, label],0) # weight = tf.concat([weight, weight],0) return image_cropped tf.enable_eager_execution() data_dir='VOCdevkit/VOC2007/' print('start loading!') test_images, test_labels, test_weights = util.load_pascal(data_dir, class_names=CLASS_NAMES, split='test') # print(test_weights[0]) # embed() print('finish loading!') test_dataset = tf.data.Dataset.from_tensor_slices((test_images, test_labels, test_weights)) test_dataset = test_dataset.batch(100) model = Caffenet(num_classes=len(CLASS_NAMES)) f.close() size=test_images.shape[0]
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='Visualize 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() model = CaffeNet(num_classes=len(CLASS_NAMES)) checkpoint = tf.train.Checkpoint(model=model) status = checkpoint.restore(tf.train.latest_checkpoint('pascal_caffenet')) test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') ordering = np.random.permutation(1000) test_images = test_images[ordering] test_labels = test_labels[ordering] test_weights = test_weights[ordering] 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) sample_feats, sample_labels = test(model, test_dataset) sample_label_colors = compute_average_labels(sample_labels) feats_embedded = TSNE(n_components=2).fit_transform(sample_feats) cmap = matplotlib.cm.get_cmap('tab20') norm = matplotlib.colors.Normalize(vmin=0, vmax=19) plt.scatter(feats_embedded[:, 0], feats_embedded[:, 1], c=sample_label_colors, cmap=cmap) left, right = plt.xlim() plt.xlim(left, right + 5) recs = [] for i in range(len(CLASS_NAMES)): recs.append( matplotlib.patches.Rectangle((0, 0), 1, 1, fc=cmap(norm(i)))) plt.legend(recs, CLASS_NAMES, loc=4) plt.title('TSNE') plt.show() ######### PCA TSNE ####################### pca = PCA(n_components=50) principal_components = pca.fit_transform(sample_feats) feats_embedded = TSNE(n_components=2).fit_transform(principal_components) cmap = matplotlib.cm.get_cmap('tab20') norm = matplotlib.colors.Normalize(vmin=0, vmax=19) plt.scatter(feats_embedded[:, 0], feats_embedded[:, 1], c=sample_label_colors, cmap=cmap) left, right = plt.xlim() plt.xlim(left, right + 5) recs = [] for i in range(len(CLASS_NAMES)): recs.append( matplotlib.patches.Rectangle((0, 0), 1, 1, fc=cmap(norm(i)))) plt.legend(recs, CLASS_NAMES, loc=4) plt.title('TSNE with PCA (50-d)') plt.show()
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=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') model = SimpleCNN(num_classes=len(CLASS_NAMES)) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.batch(args.batch_size) ## 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) model.build((args.batch_size, 224, 224, 3)) ckpt_path = "./tb/2019-02-25_10-45-32/" status = checkpoint.restore(os.path.join(ckpt_path, "ckpt-60")) status.assert_consumed() # Test visualization # tmp = test_images[4,:,:,:] # plt.imshow(tmp) # plt.show() # return #0,1,2,3,6,7,10 20 22 25 #1 2 3 4 10 11 15 40 45 54 image name query_ind = [0, 1, 2, 3, 6, 7, 10, 20, 22, 25] # For testing only, need to generate them for each class image_num = test_images.shape[0] total_pool5_out = [] total_fc7_out = [] for batch, (images, labels, weights) in enumerate(test_dataset): pool5_out, fc7_out = model.call_fc7_pool5(images) pool5_out = pool5_out.numpy() pool5_out = pool5_out.reshape( (pool5_out.shape[0], pool5_out.shape[1] * pool5_out.shape[2] * pool5_out.shape[3])) #fc7_out = model.call_fc7(test_images) fc7_out = fc7_out.numpy() for i in range(pool5_out.shape[0]): total_pool5_out.append(pool5_out[i, :]) total_fc7_out.append(fc7_out[i, :]) total_pool5_out = np.array(total_pool5_out) total_fc7_out = np.array(total_fc7_out) # pool5_out = model.call_pool5(test_images) # pool5_out = pool5_out.numpy() # pool5_out = pool5_out.reshape((image_num, pool5_out.shape[1]*pool5_out.shape[2]*pool5_out.shape[3])) kdt = KDTree(total_pool5_out, metric='euclidean') pool5_inds = kdt.query(total_pool5_out[np.array(query_ind)], k=5, return_distance=False) # fc7_out = model.call_fc7(test_images) # fc7_out = fc7_out.numpy() print(pool5_inds) kdt = KDTree(total_fc7_out, metric='euclidean') fc7_inds = kdt.query(total_fc7_out[np.array(query_ind)], k=5, return_distance=False) print(fc7_inds) # For visualization for i in range(0, len(query_ind)): img_list_pool5 = pool5_inds[i, :] img_list_fc7 = fc7_inds[i, :] img_name_pool5 = "./hw1/figures/caffe_pool5_" + str(i) img_name_fc7 = "./hw1/figures/caffe_fc7_" + str(i) for j in range(1, 5): img_id = img_list_pool5[j] save_name = img_name_pool5 + "_" + str(j) + ".jpg" img = test_images[img_id, :, :, :] img = img.astype(np.uint8) plt.imshow(img) plt.savefig(save_name) for j in range(1, 5): img_id = img_list_fc7[j] save_name = img_name_fc7 + "_" + str(j) + ".jpg" img = test_images[img_id, :, :, :] img = img.astype(np.uint8) plt.imshow(img) plt.savefig(save_name)
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() # 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') random_ind = np.random.randint(test_images.shape[0], size=1000) test_images_sub = test_images[random_ind,:,:,:] test_labels_sub = test_labels[random_ind,:] test_weights_sub = test_weights[random_ind,:] model = SimpleCNN(num_classes=len(CLASS_NAMES)) test_dataset = tf.data.Dataset.from_tensor_slices((test_images_sub, test_labels_sub, test_weights_sub)) test_dataset = test_dataset.batch(args.batch_size) ## 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) model.build((args.batch_size,224,224,3)) ckpt_path = "./tb/2019-02-25_10-45-32/" status = checkpoint.restore(os.path.join(ckpt_path,"ckpt-60")) status.assert_consumed() total_fc7_out = [] for batch, (images, labels, weights) in enumerate(test_dataset): fc7_out = model.call_fc7(images) fc7_out = fc7_out.numpy() for i in range(fc7_out.shape[0]): total_fc7_out.append(fc7_out[i,:]) total_fc7_out = np.array(total_fc7_out) fc7_out_tsne = TSNE(n_components=2).fit_transform(total_fc7_out) print(fc7_out_tsne.shape) norm_labels = map_class(test_labels_sub) fig = plt.figure(figsize=(8, 8)) ax = plt.subplot(aspect='equal') draw = ax.scatter(fc7_out_tsne[:,0], fc7_out_tsne[:,1], c=norm_labels) fig.colorbar(draw, ax=ax) ax.axis('off') plt.show() plt.savefig("./hw1/figures/tsne.jpg")
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)))
def main(): parser = argparse.ArgumentParser(description='Visualize CaffeNet') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--ckpt', type=int, default=30, 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() model = CaffeNet(num_classes=len(CLASS_NAMES)) checkpoint = tf.train.Checkpoint(model=model) status = checkpoint.restore(tf.train.latest_checkpoint('pascal_caffenet')) 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) pool5_feats, fc7_feats, all_images, all_labels = test(model, test_dataset) pool5_feats = np.reshape(pool5_feats, (pool5_feats.shape[0], -1)) fc7_feats = np.reshape(fc7_feats, (fc7_feats.shape[0], -1)) picked_classes = np.zeros((len(CLASS_NAMES)), dtype=np.uint8) i = 0 num_images = 0 images = [] labels = [] pool5_nns = [] fc7_nns = [] mean_rgb = np.array([123.68, 116.78, 103.94]) all_images = np.add(all_images, mean_rgb) all_images = all_images.astype(np.uint8) while num_images < 10: label = np.argmax(all_labels[i], -1) if picked_classes[label]: i += 1 continue images.append(all_images[i]) labels.append(np.argmax(all_labels[i], -1)) pool5 = np.expand_dims(pool5_feats[i], 0) fc7 = np.expand_dims(fc7_feats[i], 0) pool_dists = np.squeeze(cdist(pool5, pool5_feats)) fc_dists = np.squeeze(cdist(fc7, fc7_feats)) pool_idxs = list(np.argsort(pool_dists)[0:5]) fc_idxs = list(np.argsort(fc_dists)[0:5]) pool5_nns.append(pool_idxs) fc7_nns.append(fc_idxs) i += 1 num_images += 1 f, axarr = plt.subplots(num_images, 6) axarr[0, 0].set_title('Chosen image') for i in range(num_images): axarr[i, 0].imshow(images[i]) axarr[i, 0].axis('off') for j in range(5): axarr[i, j+1].imshow(all_images[pool5_nns[i][j]]) axarr[i, j+1].axis('off') f.suptitle('Pool5 NNs') plt.show() f, axarr = plt.subplots(num_images, 6) axarr[0, 0].set_title('Chosen image') for i in range(num_images): axarr[i, 0].imshow(images[i]) axarr[i, 0].axis('off') for j in range(5): axarr[i, j+1].imshow(all_images[fc7_nns[i][j]]) axarr[i, j+1].axis('off') f.suptitle('FC7 NNs') plt.show()