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()
