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)