Esempio n. 1
0
def main():
    """Main pipleine for image similarity using deep ranking."""
    # Instantiate the parser
    parser = argparse.ArgumentParser()

    parser.add_argument(
        '--dataroot',
        type=str,
        default="/home/colin/Github/Computer-Vision/data/tiny-imagenet-200",
        help='train/val data root')
    parser.add_argument('--batch_size_train',
                        type=int,
                        default=30,
                        help='training set input batch size')
    parser.add_argument('--batch_size_test',
                        type=int,
                        default=1,
                        help='test set input batch size')

    parser.add_argument('--is_gpu',
                        type=bool,
                        default=True,
                        help='whether training using GPU')

    # parse the arguments
    args = parser.parse_args()

    # load triplet dataset
    trainloader, testloader = TinyImageNetLoader(args.dataroot,
                                                 args.batch_size_train,
                                                 args.batch_size_test)

    # calculate test accuracy
    calculate_accuracy(trainloader, testloader, args.is_gpu)
Esempio n. 2
0
def main():
    """Main pipleine for image similarity using deep ranking."""
    # Instantiate the parser
    parser = argparse.ArgumentParser()

    parser.add_argument('--dataroot',
                        type=str,
                        default="",
                        help='train/val data root')

    parser.add_argument('--batch_size_train',
                        type=int,
                        default=25,
                        help='training set input batch size')

    parser.add_argument('--batch_size_test',
                        type=int,
                        default=1,
                        help='test set input batch size')

    parser.add_argument('--is_gpu',
                        type=bool,
                        default=True,
                        help='whether training using GPU')

    parser.add_argument('--predict_similar_images',
                        type=str,
                        default="",
                        help='path to query image')

    parser.add_argument('--predict_top_N',
                        type=int,
                        default=5,
                        help='Search top N images')

    # parse the arguments
    args = parser.parse_args()

    # load triplet dataset
    trainloader, testloader = TinyImageNetLoader(args.dataroot,
                                                 args.batch_size_train,
                                                 args.batch_size_test)

    training_images = load_train_images()
    embedding_space = load_train_embedding()

    if args.predict_similar_images != "":
        predict_unseen(args.predict_similar_images, args.predict_top_N,
                       training_images, embedding_space, args.is_gpu)
    else:
        # calculate test accuracy
        calculate_accuracy(training_images, embedding_space, testloader,
                           args.is_gpu)
Esempio n. 3
0
def main():
    """Main pipeline of Image Similarity using Deep Ranking."""
    net = TripletNet(resnet101())

    # For training on GPU, we need to transfer net and data onto the GPU
    # http://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#training-on-gpu
    if args.is_gpu:
        print("==> Initialize CUDA support for TripletNet model ...")
        net = torch.nn.DataParallel(net).cuda()
        cudnn.benchmark = True

    # resume training from the last time
    if args.resume:
        # Load checkpoint
        print('==> Resuming training from checkpoint ...')
        checkpoint = torch.load(args.ckptroot)
        args.start_epoch = checkpoint['epoch']
        net.load_state_dict(checkpoint['state_dict'])
        print("==> Loaded checkpoint '{}' (epoch {})".format(
            args.ckptroot, checkpoint['epoch']))

    else:
        # start over
        print('==> Building new TripletNet model ...')
        net = TripletNet(resnet101())

    # Loss function, optimizer and scheduler
    criterion = nn.TripletMarginLoss(margin=args.g, p=args.p)
    optimizer = torch.optim.SGD(net.parameters(),
                                lr=args.lr,
                                momentum=args.momentum,
                                weight_decay=args.weight_decay,
                                nesterov=args.nesterov)
    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
                                                           mode='min',
                                                           factor=0.1,
                                                           patience=10,
                                                           verbose=True)

    # load triplet dataset
    trainloader, testloader = TinyImageNetLoader(args.dataroot,
                                                 args.batch_size_train,
                                                 args.batch_size_test)

    # train model
    train(net, criterion, optimizer, scheduler, trainloader, testloader,
          args.start_epoch, args.epochs, args.is_gpu)
Esempio n. 4
0
def main():
    """Main pipleine for image similarity using deep ranking."""
    # Instantiate the parser
    parser = argparse.ArgumentParser()

    parser.add_argument('--dataroot',
                        type=str,
                        default="",
                        help='train/val data root')

    parser.add_argument('--3',
                        type=int,
                        default=25,
                        help='training set input batch size')

    parser.add_argument('--3',
                        type=int,
                        default=3,
                        help='test set input batch size')

    parser.add_argument('--is_gpu',
                        type=bool,
                        default=True,
                        help='whether training using GPU')

    parser.add_argument(
        'D:/academic/homework&assignment/senior design/data/edgedetection/data2sampler22/l1/r.jpg',
        type=str,
        default="",
        help='path to query image')

    parser.add_argument('2', type=int, default=5, help='Search top N images')

    # parse the arguments
    args = parser.parse_args()

    # load triplet dataset
    trainloader, testloader = TinyImageNetLoader(args.dataroot,
                                                 args.batch_size_train,
                                                 args.batch_size_test)

    training_images = load_train_images()
    embedding_space = load_train_embedding()

    predict_unseen(args.predict_similar_images, args.predict_top_N,
                   training_images, embedding_space, args.is_gpu)