def main(): parser = argparse.ArgumentParser(description='Evaluate CaffeNet') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--data-dir', type=str, default='./data/VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() test_images, test_labels, test_weights = util.load_pascal(args.data_dir, class_names=CLASS_NAMES, split='test') test_dataset = tf.data.Dataset.from_tensor_slices((test_images, test_labels, test_weights)) test_dataset = test_dataset.map(center_crop_test_data) test_dataset = test_dataset.batch(args.batch_size) model = CaffeNet(num_classes=len(CLASS_NAMES)) checkpoint = tf.train.Checkpoint(model=model) status = checkpoint.restore(tf.train.latest_checkpoint('pascal_caffenet')) AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap( test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def test(model, dataset): test_loss = tfe.metrics.Mean() accuracy = [] for batch, (images, labels, weights) in enumerate(dataset): images, labels, weights = center_crop(images, labels, weights) logits = model(images) loss_value = tf.losses.sigmoid_cross_entropy(labels, logits, weights) prediction = tf.math.sigmoid(logits) # embed() if np.sum(prediction.numpy()) == 0: pass else: accuracy.append( util.compute_ap(labels.numpy(), prediction.numpy(), weights.numpy(), average=None)) test_loss(loss_value) # print(batch) # print(np.sum(prediction.numpy())) accuracy_mean = np.nanmean(accuracy) return test_loss.result(), accuracy_mean
def main(): parser = argparse.ArgumentParser(description='VGG Fine Tune') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=10, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.0001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=60, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=60, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./data/VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset = train_dataset.map(augment_train_data) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.map(center_crop_test_data) test_dataset = test_dataset.batch(args.batch_size) model = VGG(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() tf.contrib.summary.initialize() global_step = tf.train.get_or_create_global_step() train_log = {'iter': [], 'loss': [], 'accuracy': []} test_log = {'iter': [], 'loss': [], 'accuracy': []} ckpt_dir = 'pascal_vgg_ft' ckpt_prefix = os.path.join(ckpt_dir, 'ckpt') if not os.path.exists(ckpt_dir): os.makedirs(ckpt_dir) # Build model first to load weights input_shape = tf.TensorShape([None, 224, 224, 3]) model.build(input_shape) model.load_weights('vgg16_weights_tf_dim_ordering_tf_kernels.h5', by_name=True) # Print layer names in saved weights # f = h5py.File('vgg16_weights_tf_dim_ordering_tf_kernels.h5', 'r') # # Get the data # for i in list(f.keys()): # print(i) decayed_lr = tf.train.exponential_decay(args.lr, global_step, 1000, 0.5, staircase=True) optimizer = tf.train.MomentumOptimizer(learning_rate=decayed_lr(), momentum=0.9) root = tf.train.Checkpoint(optimizer=optimizer, model=model) for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() for batch, (images, labels, weights) in enumerate(train_dataset): loss_value, grads = util.cal_grad( model, loss_func=tf.losses.sigmoid_cross_entropy, inputs=images, targets=labels, weights=weights) grads_and_vars = zip(grads, model.trainable_variables) optimizer.apply_gradients(grads_and_vars, global_step) epoch_loss_avg(loss_value) if global_step.numpy() % args.log_interval == 0: print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f}' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Training Loss', loss_value) tf.contrib.summary.image('RGB', images) tf.contrib.summary.scalar('LR', decayed_lr()) for i, variable in enumerate(model.trainable_variables): tf.contrib.summary.histogram("grad_" + variable.name, grads[i]) if global_step.numpy() % args.eval_interval == 0: test_AP, test_mAP = util.eval_dataset_map(model, test_dataset) test_loss = test(model, test_dataset) print("mAP: ", test_mAP) print("Test Loss: ", test_loss) # print("Loss: %.4f, Acc: %.4f, mAP: %.4f", test_lotest_mAP) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Test mAP', test_mAP) tf.contrib.summary.scalar('Test Loss', test_loss) if ep % 2 == 0: root.save(ckpt_prefix) root.save(ckpt_prefix) model.summary() AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=5, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=20, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() img_save_interval = 200 train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') ## TODO modify the following code to apply data augmentation here ori_h = train_images.shape[1] ori_w = train_images.shape[2] crop_h = 224 crop_w = 224 central_fraction = 0.7 train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) train_dataset_aug_flip = train_dataset.map( lambda img, l, w: (tf.image.random_flip_left_right(img), l, w)) train_dataset_aug_crop = train_dataset_aug_flip.map( lambda img, l, w: (tf.random_crop(img, [crop_h, crop_w, 3]), l, w)) train_dataset.concatenate(train_dataset_aug_flip) test_dataset_aug = test_dataset.map( lambda img, l, w: (tf.image.central_crop(img, central_fraction), l, w)) test_dataset_aug = test_dataset_aug.map( lambda img, l, w: (tf.image.resize_images(img, (ori_h, ori_w)), l, w)) test_dataset.concatenate(test_dataset_aug) train_dataset = train_dataset.map(lambda img, l, w: (img_mean_substract(img), l, w)) test_dataset = test_dataset.map(lambda img, l, w: (img_mean_substract(img), l, w)) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = test_dataset.batch(args.batch_size) model = SimpleCNN(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) checkpoint_dir = os.path.join(logdir, "ckpt") if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() ## TODO write the training and testing code for multi-label classification global_step = tf.train.get_or_create_global_step() learning_rate = tf.train.exponential_decay(args.lr, global_step, 5000, 0.5, staircase=True) optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9) checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model) train_log = {'iter': [], 'loss': [], 'accuracy': []} test_log = {'iter': [], 'loss': [], 'accuracy': []} for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() for batch, (images, labels, weights) in enumerate(train_dataset): loss_value, grads = util.cal_grad( model, loss_func=tf.losses.sigmoid_cross_entropy, inputs=images, weights=weights, targets=labels) optimizer.apply_gradients(zip(grads, model.trainable_variables), global_step) epoch_loss_avg(loss_value) if global_step.numpy() % args.log_interval == 0: print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f} ' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) # Tensorboard Visualization with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('training_loss', epoch_loss_avg.result()) #tf.contrib.summary.scalar('learning_rate', learning_rate()) # for grad,var in zip(grads,model.trainable_variables): # tf.contrib.summary.histogram("gradients_{0}".format(var.name), grad) if global_step.numpy() % args.eval_interval == 0: with tf.contrib.summary.always_record_summaries(): test_AP, test_mAP = util.eval_dataset_map( model, test_dataset) tf.contrib.summary.scalar('test_map', test_mAP) #test_loss = test(test_dataset,model) #tf.contrib.summary.scalar('testing_loss', test_loss) # if global_step.numpy() % img_save_interval == 0: # with tf.contrib.summary.always_record_summaries(): # tf.contrib.summary.image('training_img', images) # Save checkpoints checkpoint.save(file_prefix=checkpoint_dir) AP, mAP = util.eval_dataset_map(model, test_dataset) # For visualization rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def test_all(model, valid_path, epoch, batch_size, num_classes=11, n_cpu=8, iou_thres=0.5, img_size=512, cuda=True): # Get dataloader # when training the data without multi-scale dataset = ListDatasetraw(valid_path, img_size) dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=False, num_workers=n_cpu) # when training the data with multi-scale # transform_test = my_transform(image_size=(1200, 1920)) # dataset = ListDataset(valid_path, img_size, transform=transform_test.image_transforms_original_image(), # target_transform=transform_test.target_transform_org) # dataloader = torch.utils.data.DataLoader(dataset, # batch_size=batch_size, shuffle=False, num_workers=n_cpu) # get hyper-params conf_thresh = 0.9 NMS_thresh = 0.1 Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor file_name = './test_log.txt' f = open(file_name, 'a') f.write('Epoch%d Compute mAP...\n' % (epoch)) f.write('IoU threshold: %.4f\n' % (iou_thres)) print('Compute mAP...') targets = None APs = [] for batch_i, (_, imgs, targets) in enumerate(dataloader): targets = targets.type(Tensor) imgs = imgs.type(Tensor) with torch.no_grad(): output = model(imgs, None) output = non_max_suppression(output, num_classes, conf_thres=conf_thresh, nms_thres=NMS_thresh, cls_dependent=False) # Compute average precision for each sample for sample_i in range(targets.size(0)): correct = [] # Get labels for sample where width is not zero (dummies) annotations = targets[sample_i, targets[sample_i, :, 3] != 0] # Extract detections detections = output[sample_i] if detections is None: if annotations.size(0) == 0: continue APs.append(1) print("+ Sample [%d/%d] AP: %.4f (%.4f)" % (len(APs), len(dataset), 1, np.mean(APs))) # If there are no detections but there are annotations mask as zero AP if annotations.size(0) != 0: APs.append(0) print("+ Sample [%d/%d] AP: %.4f (%.4f)" % (len(APs), len(dataset), 0, np.mean(APs))) continue if detections.size(0) == 0: if annotations.size(0) == 0: APs.append(1) print("+ Sample [%d/%d] AP: %.4f (%.4f)" % (len(APs), len(dataset), 1, np.mean(APs))) # If there are no detections but there are annotations mask as zero AP if annotations.size(0) != 0: APs.append(0) print("+ Sample [%d/%d] AP: %.4f (%.4f)" % (len(APs), len(dataset), 0, np.mean(APs))) continue # Get detections sorted by decreasing confidence scores detections = detections[np.argsort(-detections[:, 4])] # If no annotations add number of detections as incorrect if annotations.size(0) == 0: correct.extend([0 for _ in range(len(detections))]) else: # Extract target boxes as (x1, y1, x2, y2) target_boxes = torch.FloatTensor(annotations[:, 1:].shape) target_boxes[:, 0] = (annotations[:, 1] - annotations[:, 3] / 2) target_boxes[:, 1] = (annotations[:, 2] - annotations[:, 4] / 2) target_boxes[:, 2] = (annotations[:, 1] + annotations[:, 3] / 2) target_boxes[:, 3] = (annotations[:, 2] + annotations[:, 4] / 2) target_boxes *= img_size detected = [] for *pred_bbox, conf, obj_conf, obj_pred in detections: pred_bbox = torch.FloatTensor(pred_bbox).view(1, -1) # Compute iou with target boxes iou = bbox_ious(pred_bbox, target_boxes) # Extract index of largest overlap best_i = np.argmax(iou) # If overlap exceeds threshold and classification is correct mark as correct if iou[best_i] > iou_thres and obj_pred == annotations[ best_i, 0] and best_i not in detected: correct.append(1) detected.append(best_i) else: correct.append(0) # Extract true and false positives true_positives = np.array(correct) false_positives = 1 - true_positives # Compute cumulative false positives and true positives false_positives = np.cumsum(false_positives) true_positives = np.cumsum(true_positives) # Compute recall and precision at all ranks recall = true_positives / annotations.size(0) if annotations.size( 0) else true_positives precision = true_positives / np.maximum( true_positives + false_positives, np.finfo(np.float64).eps) # Compute average precision AP = compute_ap(recall, precision) APs.append(AP) # f.write("+ Sample [%d/%d] AP: %.4f (%.4f)" % (len(APs), len(dataset), AP, np.mean(APs))) # f.write('\n') print("+ Sample [%d/%d] AP: %.4f (%.4f)" % (len(APs), len(dataset), AP, np.mean(APs))) f.write("Mean Average Precision: %.4f" % np.mean(APs)) f.write('\n') f.close() print("Mean Average Precision: %.4f" % np.mean(APs))
def evaluate(self, test_imgs, iou_threshold=0.3, obj_threshold=0.2, nms_threshold=0.3): print( 'evaulating the model with iou_threshold={}, obj_threshold={}, nms_threshold={}' .format(iou_threshold, obj_threshold, nms_threshold)) self.Yolo.train(False) generator_config = { 'IMAGE_H': self.input_size, 'IMAGE_W': self.input_size, 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': 1, 'TRUE_BOX_BUFFER': self.max_box_per_image, } # evaluation has to be in the eval stage generator = data_generator(test_imgs, generator_config, norm=self.Yolo.normalize, jitter=False) # gather all detections and annotations all_detections = [[None for i in range(generator.num_classes())] for j in range(len(generator))] all_annotations = [[None for i in range(generator.num_classes())] for j in range(len(generator))] for i in tqdm(range(len(generator))): raw_image = generator.load_image(i) raw_height, raw_width, raw_channels = raw_image.shape # make the boxes and the labels pred_boxes = self.predict(raw_image, obj_threshold, nms_threshold) if i < 40: image_bbox = draw_boxes_object(raw_image, pred_boxes, self.labels) cv2.imwrite( './sample/image_pred_box/test_pred_{}.png'.format(i), image_bbox) score = np.array([box.score for box in pred_boxes]) pred_labels = np.array([box.label for box in pred_boxes]) if len(pred_boxes) > 0: pred_boxes = np.array([[ box.xmin * raw_width, box.ymin * raw_height, box.xmax * raw_width, box.ymax * raw_height, box.score ] for box in pred_boxes]) else: pred_boxes = np.array([[]]) # sort the boxes and the labels according to scores score_sort = np.argsort(-score) pred_labels = pred_labels[score_sort] pred_boxes = pred_boxes[score_sort] # copy detections to all_detections for label in range(generator.num_classes()): all_detections[i][label] = pred_boxes[pred_labels == label, :] annotations = generator.load_annotation(i) # copy detections to all_annotations for label in range(generator.num_classes()): all_annotations[i][label] = annotations[annotations[:, 4] == label, :4].copy() # compute mAP by comparing all detections and all annotations average_precisions = {} for label in range(generator.num_classes()): false_positives = np.zeros((0, )) true_positives = np.zeros((0, )) scores = np.zeros((0, )) num_annotations = 0.0 for i in range(len(generator)): detections = all_detections[i][label] annotations = all_annotations[i][label] num_annotations += annotations.shape[0] detected_annotations = [] for d in detections: scores = np.append(scores, d[4]) if annotations.shape[0] == 0: false_positives = np.append(false_positives, 1) true_positives = np.append(true_positives, 0) continue overlaps = compute_overlap(np.expand_dims(d, axis=0), annotations) assigned_annotation = np.argmax(overlaps, axis=1) max_overlap = overlaps[0, assigned_annotation] if max_overlap >= iou_threshold and assigned_annotation not in detected_annotations: false_positives = np.append(false_positives, 0) true_positives = np.append(true_positives, 1) detected_annotations.append(assigned_annotation) else: false_positives = np.append(false_positives, 1) true_positives = np.append(true_positives, 0) # no annotations -> AP for this class is 0 (is this correct?) if num_annotations == 0: average_precisions[label] = 0 continue # sort by score indices = np.argsort(-scores) false_positives = false_positives[indices] true_positives = true_positives[indices] # compute false positives and true positives false_positives = np.cumsum(false_positives) true_positives = np.cumsum(true_positives) # compute recall and precision recall = true_positives / num_annotations precision = true_positives / np.maximum( true_positives + false_positives, np.finfo(np.float64).eps) # compute average precision average_precision = compute_ap(recall, precision) average_precisions[label] = average_precision # for label, average_precision in average_precisions.items(): # print(self.labels[label], '{:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions))) return average_precisions
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=10, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.0001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=60, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb/05', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./VOCdevkit/VOC2007', help='Path to PASCAL data storage') parser.add_argument('--checkpoint-dir', type=str, default='./checkpoints/06', help='Path to checkpoints storage') parser.add_argument( '--save-interval', type=int, default=2, help='How many batch to wait before storing checkpoints') parser.add_argument( '--pretrain-dir', type=str, default= './pre_trained_model/vgg16_weights_tf_dim_ordering_tf_kernels.h5', help='path the pretrained model') parser.add_argument('--scratch-dir', type=str, default='./checkpoints/04/ckpt.h5', help='path the scratched model') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() model = SimpleCNN(pretrain_dir=args.pretrain_dir, scratch_dir=args.scratch_dir, num_classes=len(CLASS_NAMES)) train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') # np.random.seed(1) # images_mix = train_images # np.random.shuffle(images_mix) # np.random.seed(1) # labels_mix = train_labels # np.random.shuffle(labels_mix) # np.random.seed(1) # weights_mix = train_weights # np.random.shuffle(weights_mix) # lamb = np.random.beta(2., 2.) # train_images=train_images * lamb + images_mix * (1-lamb) # train_labels=train_labels * lamb + labels_mix * (1-lamb) # train_weights=train_weights * lamb + weights_mix * (1-lamb) ## TODO modify the following code to apply data augmentation here print('start_loading!') train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.batch(50) train_dataset_mix = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset_mix = train_dataset_mix.shuffle(10000).batch(args.batch_size) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() ## TODO write the training and testing code for multi-label classification global_step = tf.train.get_or_create_global_step() learning_rate_decay = tf.train.exponential_decay(args.lr, global_step, 1000, 0.5) optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate_decay, momentum=0.9) train_log = {'iter': [], 'loss': []} test_log = {'iter': [], 'loss': [], 'accuracy': []} print('start training!') for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() # epoch_accuracy = tfe.metrics.Accuracy() for batch, ((images, labels, weights), (images_mix, labels_mix, weights_mix)) in enumerate( zip(train_dataset, train_dataset_mix)): # print(labels - labels_mix) labels = tf.cast(labels, tf.float32) labels_mix = tf.cast(labels_mix, tf.float32) weights = tf.cast(weights, tf.float32) weights_mix = tf.cast(weights_mix, tf.float32) lamb_size = images.shape[0] lamb = np.random.beta(0.2, 0.2, lamb_size) # print(lamb) images = images * lamb[:, np.newaxis, np.newaxis, np.newaxis] + images_mix * ( 1 - lamb)[:, np.newaxis, np.newaxis, np.newaxis] # print(images.shape) weights = weights * lamb[:, np.newaxis] + weights_mix * ( 1. - lamb)[:, np.newaxis] labels = labels * lamb[:, np.newaxis] + labels_mix * ( 1. - lamb)[:, np.newaxis] # print(labels * lamb[:, np.newaxis]) # print(labels.dtype) images, labels, weights = mean_normalization( images, labels, weights) images, labels, weights = randomly_crop(images, labels, weights) images, labels, weights = randomly_flip(images, labels, weights) # print(images[0]) # print(labels) # print(weights.shape) with tf.contrib.summary.record_summaries_every_n_global_steps(100): tf.contrib.summary.image("sample_image", images, max_images=3) loss_value, grads = util.cal_grad( model, loss_func=tf.losses.sigmoid_cross_entropy, inputs=images, targets=labels, weights=weights) optimizer.apply_gradients(zip(grads, model.trainable_variables), global_step) learning_rate_decay = tf.train.exponential_decay( args.lr, global_step, 1000, 0.5) with tf.contrib.summary.record_summaries_every_n_global_steps(1): tf.contrib.summary.scalar('learning_rate', learning_rate_decay()) with tf.contrib.summary.record_summaries_every_n_global_steps(10): for grad, var in zip(grads, model.trainable_variables): tf.contrib.summary.histogram( "{}/grad_histogram".format(var.name), grad) with tf.contrib.summary.record_summaries_every_n_global_steps(1): tf.contrib.summary.scalar('training_loss', loss_value) epoch_loss_avg(loss_value) if global_step.numpy() % args.log_interval == 0: print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f}' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) # tf.contrib.summary.scalar('training_loss', epoch_loss_avg.result()) # train_log['accuracy'].append(epoch_accuracy.result()) if global_step.numpy() % args.eval_interval == 0: test_loss, test_acc = test(model, test_dataset) with tf.contrib.summary.record_summaries_every_n_global_steps( args.eval_interval): tf.contrib.summary.scalar('testing_acc', test_acc) test_log['iter'].append(global_step.numpy()) test_log['loss'].append(test_loss) test_log['accuracy'].append(test_acc) # tf.contrib.summary.scalar('testing_loss', test_loss) # tf.contrib.summary.scalar('testing_loss', test_acc) print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Testing Loss:{3:.4f} Testing Accuracy:{4:.4f}' .format(ep, args.epochs, global_step.numpy(), test_loss, test_acc)) # if global_step.numpy() % args.save_epoch == 0: # checkpoint = tfe.Checkpoint(optimizer=optimizer, # model=model, # optimizer_step=tf.train.get_or_create_global_step()) # checkpoint_prefix = os.path.join(args.checkpoint_dir, "ckpt") # checkpoint.save(file_prefix=checkpoint_prefix) AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) # checkpoint = tfe.Checkpoint(optimizer=optimizer, # model=model, # optimizer_step=tf.train.get_or_create_global_step()) # checkpoint_prefix = os.path.join(args.checkpoint_dir, "ckpt") # checkpoint.save(file_prefix=checkpoint_prefix) checkpoint_prefix = os.path.join(args.checkpoint_dir, "ckpt.h5") model.save_weights(checkpoint_prefix) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid))) writer.close()
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=30, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=250, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='pascal_caffenet_tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() splt = "trainval" trainval_npz = splt + '.npz' test_npz = 'test.npz' if (os.path.isfile(trainval_npz)): print("\nFound trainval npz file\n") with np.load(trainval_npz) as tr_npzfile: train_images = tr_npzfile['imgs'] train_labels = tr_npzfile['labels'] train_weights = tr_npzfile['weights'] else: train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split=splt) np.savez(trainval_npz, imgs=train_images, labels=train_labels, weights=train_weights) ##TEST## if (os.path.isfile(test_npz)): print("\nFound test npz file\n") # npzfile = np.load(test_npz) with np.load(test_npz) as test_npzfile: test_images = test_npzfile['imgs'] test_labels = test_npzfile['labels'] test_weights = test_npzfile['weights'] else: test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') np.savez(test_npz, imgs=test_images, labels=test_labels, weights=test_weights) ## TODO modify the following code to apply data augmentation here rgb_mean = np.array([123.68, 116.78, 103.94], dtype=np.float32) / 256.0 train_images = (train_images - rgb_mean).astype(np.float32) test_images = (test_images - rgb_mean).astype(np.float32) flip_fn = lambda img, lbl, wts: flip(img, lbl, wts) crop_fn = lambda img, lbl, wts: crop(img, lbl, wts) ccrop_fn = lambda img, lbl, wts: center_crop(img, lbl, wts) train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) flipped_train = train_dataset.map(flip_fn, num_parallel_calls=4) train_dataset = train_dataset.concatenate(flipped_train) train_dataset = train_dataset.map(crop_fn, num_parallel_calls=4) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.map(ccrop_fn, num_parallel_calls=4) test_dataset = test_dataset.batch(args.batch_size) model = SimpleCNN(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() tf.contrib.summary.initialize() global_step = tf.train.get_or_create_global_step() # optimizer = tf.train.AdamOptimizer(learning_rate=args.lr) ##decay lr using callback learning_rate = tf.Variable(args.lr) decay_interval = 5000 # decay_op = tf.train.exponential_decay(args.lr,global_step,decay_interval,0.5) ##optimizer : sgd , momentum, 0.9 optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9) train_log = {'iter': [], 'loss': []} test_log = {'iter': [], 'mAP': []} checkpoint_directory = "./03_pascal_caffenet/" if not os.path.exists(checkpoint_directory): os.makedirs(checkpoint_directory) checkpoint_prefix = os.path.join(checkpoint_directory, "ckpt") checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model) # pdb.set_trace() latest = tf.train.latest_checkpoint(checkpoint_directory) load_flag = 0 if (latest is not None): print("Loading checkpoint ", latest) status = checkpoint.restore( tf.train.latest_checkpoint(checkpoint_directory)) load_flag = 1 print("\nUsing eval interval: ", args.eval_interval) print("\nUsing batch size: ", args.batch_size) for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() # for batch, (images, labels,weights) in enumerate(train_dataset): for (images, labels, weights) in tfe.Iterator(train_dataset): # pdb.set_trace() # loss_value, grads = util.cal_grad(model, # loss_func=tf.losses.sigmoid_cross_entropy, # inputs=images, # targets=labels, # weights=weights) with tf.GradientTape() as tape: logits = model(images, training=True) loss_value = tf.losses.sigmoid_cross_entropy( labels, logits, weights) grads = tape.gradient(loss_value, model.trainable_variables) # print("Loss and gradient calculation, done \n") # pdb.set_trace() optimizer.apply_gradients(zip(grads, model.trainable_variables), global_step) epoch_loss_avg(loss_value) if global_step.numpy() % args.log_interval == 0: # pdb.set_trace() print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f} ' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Training loss', loss_value) tf.contrib.summary.scalar('Learning rate', learning_rate) for i, variable in enumerate(model.trainable_variables): tf.contrib.summary.histogram("grad_" + variable.name, grads[i]) if global_step.numpy() % args.eval_interval == 0: print("\n **** Running Eval *****\n") test_AP, test_mAP = util.eval_dataset_map(model, test_dataset) print("Eval finsished with test mAP : ", test_mAP) test_log['iter'].append(global_step.numpy()) test_log['mAP'].append(test_mAP) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Testing mAP', test_mAP) learning_rate.assign( tf.train.exponential_decay(args.lr, global_step, decay_interval, 0.5)()) print("Learning rate:", learning_rate) checkpoint.save(checkpoint_prefix) ## TODO write the training and testing code for multi-label classification AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=20, help='input batch size for training') parser.add_argument('--epochs', type=int, default=5, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=50, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./data/VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset = train_dataset.map(augment_train_data) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.map(center_crop_test_data) test_dataset = test_dataset.batch(args.batch_size) model = SimpleCNN(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() tf.contrib.summary.initialize() global_step = tf.train.get_or_create_global_step() optimizer = tf.train.AdamOptimizer(learning_rate=args.lr) train_log = {'iter': [], 'loss': [], 'accuracy': []} test_log = {'iter': [], 'loss': [], 'accuracy': []} for ep in range(args.epochs): epoch_loss_avg = tfe.metrics.Mean() for batch, (images, labels, weights) in enumerate(train_dataset): loss_value, grads = util.cal_grad( model, loss_func=tf.losses.sigmoid_cross_entropy, inputs=images, targets=labels, weights=weights) optimizer.apply_gradients(zip(grads, model.trainable_variables), global_step) epoch_loss_avg(loss_value) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Training Loss', loss_value) if global_step.numpy() % args.log_interval == 0: print( 'Epoch: {0:d}/{1:d} Iteration:{2:d} Training Loss:{3:.4f}' .format(ep, args.epochs, global_step.numpy(), epoch_loss_avg.result())) train_log['iter'].append(global_step.numpy()) train_log['loss'].append(epoch_loss_avg.result()) if global_step.numpy() % args.eval_interval == 0: test_AP, test_mAP = util.eval_dataset_map(model, test_dataset) print("mAP: ", test_mAP) with tf.contrib.summary.always_record_summaries(): tf.contrib.summary.scalar('Test mAP', test_mAP) model.summary() # fig = plt.figure() # plt.plot(train_log['iter'], train_log['loss'], 'r', label='Training') # plt.plot(test_log['iter'], test_log['loss'], 'b', label='Testing') # plt.title('Loss') # plt.legend() # fig = plt.figure() # plt.plot(train_log['iter'], train_log['accuracy'], 'r', label='Training') # plt.plot(test_log['iter'], test_log['accuracy'], 'b', label='Testing') # plt.title('Accuracy') # plt.legend() # plt.show() AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))
def main(): parser = argparse.ArgumentParser(description='TensorFlow Pascal Example') parser.add_argument('--batch-size', type=int, default=10, help='input batch size for training') parser.add_argument('--epochs', type=int, default=5, help='number of epochs to train') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') parser.add_argument('--seed', type=int, default=1, help='random seed') parser.add_argument('--log-interval', type=int, default=10, help='how many batches to wait before' ' logging training status') parser.add_argument('--eval-interval', type=int, default=20, help='how many batches to wait before' ' evaluate the model') parser.add_argument('--log-dir', type=str, default='tb', help='path for logging directory') parser.add_argument('--data-dir', type=str, default='./VOCdevkit/VOC2007', help='Path to PASCAL data storage') args = parser.parse_args() util.set_random_seed(args.seed) sess = util.set_session() train_images, train_labels, train_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='trainval') test_images, test_labels, test_weights = util.load_pascal( args.data_dir, class_names=CLASS_NAMES, split='test') ## TODO modify the following code to apply data augmentation here train_dataset = tf.data.Dataset.from_tensor_slices( (train_images, train_labels, train_weights)) train_dataset = train_dataset.shuffle(10000).batch(args.batch_size) test_dataset = tf.data.Dataset.from_tensor_slices( (test_images, test_labels, test_weights)) test_dataset = test_dataset.batch(args.batch_size) model = SimpleCNN(num_classes=len(CLASS_NAMES)) logdir = os.path.join(args.log_dir, datetime.now().strftime('%Y-%m-%d_%H-%M-%S')) if os.path.exists(logdir): shutil.rmtree(logdir) os.makedirs(logdir) writer = tf.contrib.summary.create_file_writer(logdir) writer.set_as_default() ## TODO write the training and testing code for multi-label classification AP, mAP = util.eval_dataset_map(model, test_dataset) rand_AP = util.compute_ap(test_labels, np.random.random(test_labels.shape), test_weights, average=None) print('Random AP: {} mAP'.format(np.mean(rand_AP))) gt_AP = util.compute_ap(test_labels, test_labels, test_weights, average=None) print('GT AP: {} mAP'.format(np.mean(gt_AP))) print('Obtained {} mAP'.format(mAP)) print('Per class:') for cid, cname in enumerate(CLASS_NAMES): print('{}: {}'.format(cname, util.get_el(AP, cid)))