Python create_data_loaders Examples

Example #1

def main():
    # Seed all sources of randomness to 0 for reproducibility
    np.random.seed(0)
    torch.manual_seed(0)
    torch.cuda.manual_seed(0)
    random.seed(0)

    opt = Opts().parse()

    # Create data loaders
    train_loader, test_loader = create_data_loaders(opt)

    # Create nn
    model, criterion_hm, criterion_paf, latest_inx = create_model(opt)
    model = model.cuda()
    criterion_hm = criterion_hm.cuda()
    criterion_paf = criterion_paf.cuda()

    # Create optimizer
    optimizer = create_optimizer(opt, model)

    # Other params
    n_epochs = opt.nEpoch
    to_train = opt.train
    drop_lr = opt.dropLR
    val_interval = opt.valInterval
    learn_rate = opt.LR
    visualize_out = opt.vizOut

    # train/ test
    train_net(train_loader, test_loader, model, criterion_hm, criterion_paf,
              optimizer, n_epochs, val_interval, learn_rate, drop_lr,
              opt.saveDir, visualize_out, latest_inx)

Example #2

def main():
    # Seed all sources of randomness to 0 for reproducibility
    np.random.seed(0)
    torch.manual_seed(0)
    torch.cuda.manual_seed(0)
    random.seed(0)

    opt = Opts().parse()

    # Create data loaders
    train_loader, test_loader = create_data_loaders(opt)

    # Create nn
    model, criterion_hm, criterion_paf, latest_inx = create_model(opt)
    # model = model.cuda()
    # criterion_hm = criterion_hm.cuda()
    # criterion_paf = criterion_paf.cuda()

    # Create optimizer
    optimizer = create_optimizer(opt, model)

    # Other params
    n_epochs = opt.nEpoch
    to_train = opt.train
    drop_lr = opt.dropLR
    val_interval = opt.valInterval
    learn_rate = opt.LR
    visualize_out = opt.vizOut

    # train/ test
    img, heat_map, paf, ignore_mask, keypoints = test_loader.dataset.get_item_raw(0, False)

Example #3

File: eval.py Project: Akimoto-Cris/pytorch-CPR

def main():
    # Seed all sources of randomness to 0 for reproducibility
    np.random.seed(0)
    torch.manual_seed(0)
    torch.cuda.manual_seed(0)
    random.seed(0)

    opt = Opts().parse()
    os.environ["CUDA_VISIBLE_DEVICES"] = opt["env"]["device"]
    print("Using GPU: {}".format(opt["env"]["device"]))
    # Create data loaders
    if opt["to_test"]:
        _, _, test_loader = create_data_loaders(opt)
    else:
        _, test_loader = create_data_loaders(opt)

    # Create nn
    model, _, _ = create_model(opt)
    model = model.cuda()
    # Get nn outputs
    outputs, indices = eval_net(test_loader, model, opt)

    if opt["val"]["dataset"] == 'coco':
        eval_COCO(outputs, opt["env"]["data"], indices, opt)

Example #4

File: eval.py Project: zuoym15/part-affinity

def main():
    # Seed all sources of randomness to 0 for reproducibility
    np.random.seed(0)
    torch.manual_seed(0)
    torch.cuda.manual_seed(0)
    random.seed(0)

    opt = Opts().parse()

    # Create data loaders
    _, test_loader = create_data_loaders(opt)

    # Create nn
    model, _, _ = create_model(opt)
    model = model.cuda()

    # Get nn outputs
    outputs, indices = eval_net(test_loader, model, opt)

    if opt.dataset == 'coco':
        eval_COCO(outputs, opt.data, indices)

Example #5

File: test.py Project: 0shimax/part-affinity

def main():
    # Seed all sources of randomness to 0 for reproducibility
    np.random.seed(0)
    torch.manual_seed(0)
    torch.cuda.manual_seed(0)
    random.seed(0)

    opt = Opts().parse()
    opt.dataset = 'mine'
    opt.batchSize = 1
    opt.data = './data'
    opt.nThreads = 0
    opt.device = device
    fnames = ['test.jpg']

    # Create data loaders
    _, test_loader = create_data_loaders(opt, fnames)

    # Create nn
    model, _, _ = create_model(opt).to(opt.device)

    # output result images
    test_net(test_loader, model, opt)

Example #6

def main():
    # Seed all sources of randomness to 0 for reproducibility
    np.random.seed(0)
    torch.manual_seed(0)
    torch.cuda.manual_seed(0)
    random.seed(0)

    opt = Opts().parse()
    os.environ["CUDA_VISIBLE_DEVICES"] = opt["env"]["device"]
    print("Using GPU: {}".format(opt["env"]["device"]))

    # Create data loaders
    # Create data loaders
    train_loader, test_loader, _ = create_data_loaders(opt)
    # Create nn
    model, criterion_hm, criterion_paf = create_model(opt)
    model = torch.nn.DataParallel(model, device_ids=[int(index) for index in opt["env"]["device"].split(",")]).cuda() \
        if "," in opt["env"]["device"] else model.cuda()
    if opt["env"]["loadModel"] is not None and opt["typ"] == 'cpr':
        model.load_state_dict(torch.load(opt["env"]["loadModel"]))
        print('Loaded model from ' + opt["env"]["loadModel"])
    criterion_hm = criterion_hm.cuda()
    criterion_paf = criterion_paf.cuda()

    # Create optimizer
    optimizer = create_optimizer(opt, model)

    # Other params
    to_train = opt["to_train"]
    visualize_out = opt["viz"]["vizOut"]

    # train/ test
    Processer = process(model)
    if to_train:
        Processer.train_net(train_loader, test_loader, criterion_hm, criterion_paf, optimizer, opt, viz_output=visualize_out)
    else:
        Processer.validate_net(test_loader, criterion_hm, criterion_paf, save_dir=opt["env"]["saveDir"], viz_output=visualize_out)