def main():
parser = argparse.ArgumentParser(
description='TensorFlow Fashion MNIST Example')
parser.add_argument('--batch-size',
type=int,
default=100,
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.001,
help='learning rate')
parser.add_argument('--seed', type=int, default=1, help='random seed')
parser.add_argument('--log-interval',
type=int,
default=5,
help='how many batches to wait before'
' logging training status')
parser.add_argument('--eval-interval',
type=int,
default=100,
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('--ckpt-dir',
type=str,
default='ckpt',
help='path for saving model')
args = parser.parse_args()
start_time = time.time()
util.set_random_seed(args.seed)
sess = util.set_session()
fashion_mnist = keras.datasets.fashion_mnist
class_names = [
'T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal',
'Shirt', 'Sneaker', 'Bag', 'Ankle boot'
]
(train_images, train_labels), (test_images,
test_labels) = fashion_mnist.load_data()
train_images, train_labels = preprocess_data(train_images, train_labels)
test_images, test_labels = preprocess_data(test_images, test_labels)
train_dataset = tf.data.Dataset.from_tensor_slices(
(train_images, train_labels))
train_dataset = train_dataset.shuffle(10000).batch(args.batch_size)
test_dataset = tf.data.Dataset.from_tensor_slices(
(test_images, test_labels))
test_dataset = test_dataset.shuffle(10000).batch(args.batch_size)
train_dataset_mix = tf.data.Dataset.from_tensor_slices(
(train_images, train_labels))
train_dataset_mix = train_dataset.shuffle(10000).batch(args.batch_size)
model = SimpleCNN(num_classes=len(class_names))
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()
epoch_accuracy = tfe.metrics.Accuracy()
for batch, ((images, labels), (images_mix, labels_mix)) in enumerate(
zip(train_dataset, train_dataset_mix)):
lamb = np.random.beta(2., 2., args.batch_size)
images = images * lamb[:, np.newaxis, np.newaxis,
np.newaxis] + images_mix * (
1 - lamb)[:, np.newaxis, np.newaxis,
np.newaxis]
labels = labels * lamb + labels_mix * (1. - lamb)
loss_value, grads = util.cal_grad(
model,
loss_func=tf.losses.sparse_softmax_cross_entropy,
inputs=images,
targets=labels)
optimizer.apply_gradients(zip(grads, model.trainable_variables),
global_step)
epoch_loss_avg(loss_value)
epoch_accuracy(
tf.argmax(model(images), axis=1, output_type=tf.int32), labels)
if global_step.numpy() % args.log_interval == 0:
print(
'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f} '
'Training Accuracy:{4:.4f}'.format(
ep, args.epochs, global_step.numpy(),
epoch_loss_avg.result(), epoch_accuracy.result()))
train_log['iter'].append(global_step.numpy())
train_log['loss'].append(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)
test_log['iter'].append(global_step.numpy())
test_log['loss'].append(test_loss)
test_log['accuracy'].append(test_acc)
model.summary()
end_time = time.time()
print('Elapsed time: {0:.3f}s'.format(end_time - start_time))
predict(model, test_images[:5], class_names)
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()
plt.savefig('dynamic_loss_10.png')
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.savefig('dynamic_accuracy_10.png')
plt.show()
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=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=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 Fashion MNIST Example')
parser.add_argument('--batch-size',
type=int,
default=100,
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.001,
help='learning rate')
parser.add_argument('--seed', type=int, default=1, help='random seed')
parser.add_argument('--log-interval',
type=int,
default=5,
help='how many batches to wait before'
' logging training status')
parser.add_argument('--eval-interval',
type=int,
default=100,
help='how many batches to wait before'
' evaluate the model')
args = parser.parse_args()
start_time = time.time()
util.set_random_seed(args.seed)
sess = util.set_session()
fashion_mnist = keras.datasets.fashion_mnist
class_names = [
'T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal',
'Shirt', 'Sneaker', 'Bag', 'Ankle boot'
]
(train_images, train_labels), (test_images,
test_labels) = fashion_mnist.load_data()
train_images, train_labels = preprocess_data(train_images,
train_labels,
num_classes=len(class_names))
test_images, test_labels = preprocess_data(test_images,
test_labels,
num_classes=len(class_names))
# print(train_images.shape)
# embed()
features_placeholder = tf.placeholder(train_images.dtype,
train_images.shape)
labels_placeholder = tf.placeholder(train_labels.dtype, train_labels.shape)
train_dataset = tf.data.Dataset.from_tensor_slices(
(features_placeholder, labels_placeholder))
train_dataset = train_dataset.shuffle(10000).batch(args.batch_size)
iterator = train_dataset.make_initializable_iterator()
next_element = iterator.get_next()
model = SimpleCNN(num_classes=len(class_names))
model.compile(optimizer=keras.optimizers.Adam(lr=args.lr),
loss='categorical_crossentropy',
metrics=['accuracy'])
iter = 0
train_log = {'iter': [], 'loss': [], 'accuracy': []}
test_log = {'iter': [], 'loss': [], 'accuracy': []}
for ep in range(args.epochs):
sess.run(iterator.initializer,
feed_dict={
features_placeholder: train_images,
labels_placeholder: train_labels
})
try:
while True:
iter += 1
images, labels = sess.run(next_element)
train_loss, train_acc = model.train_on_batch(images, labels)
if iter % args.log_interval == 0:
print(
'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f} '
'Training Accuracy:{4:.4f}'.format(
ep, args.epochs, iter, train_loss, train_acc))
train_log['iter'].append(iter)
train_log['loss'].append(train_loss)
train_log['accuracy'].append(train_acc)
if iter % args.eval_interval == 0:
test_loss, test_acc = model.evaluate(
test_images, test_labels)
test_log['iter'].append(iter)
test_log['loss'].append(test_loss)
test_log['accuracy'].append(test_acc)
except tf.errors.OutOfRangeError:
pass
model.summary()
end_time = time.time()
print('Elapsed time: {0:.3f}s'.format(end_time - start_time))
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()
plt.savefig('static_loss_10.png')
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.savefig('static_accuracy_10.png')
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='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()
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)
## 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/"
for cp_ind in range(1, 61, 5):
status = checkpoint.restore(
os.path.join(ckpt_path, "ckpt-" + str(cp_ind)))
weights = model.get_weights()
status.assert_consumed()
conv_weights = model.get_conv_weights()
kernel_weights = conv_weights[0].numpy() # 11 11 3 96
visualize_idx = [0, 10, 20]
for i in visualize_idx:
kernel_weight = kernel_weights[:, :, :, i]
norm = colors.Normalize(0, 1)
norm_weight = kernel_normalize(kernel_weight)
plt.imshow(norm_weight, cmap='gray')
img_name = "./hw1/figures/ckpt-" + str(cp_ind) + "_conv1_f" + str(
i) + ".jpg"
# plt.show()
plt.savefig(img_name)
