Ejemplo n.º 1
0
def CreateDataset(opt):
    from data.aligned_dataset import AlignedDataset
    dataset = AlignedDataset()
    print("dataset [%s] was created" % (dataset.name()))
    dataset.initialize(opt)
    return dataset
def CreateDataset(opt):
    dataset = None
    if opt.dataset_mode == 'aligned':
        from data.aligned_dataset import AlignedDataset
        dataset = AlignedDataset()
    elif opt.dataset_mode == 'unaligned':
        from data.unaligned_dataset import UnalignedDataset
        dataset = UnalignedDataset()

    elif opt.dataset_mode == 'aligned_rand':
        from data.aligned_dataset_rand import AlignedDataset_Rand
        dataset = AlignedDataset_Rand()

    elif opt.dataset_mode == 'aligned_test':
        from data.aligned_dataset_test import AlignedDataset_Test
        dataset = AlignedDataset_Test()

    elif opt.dataset_mode == 'unaligned_seg':
        from data.unaligned_dataset_seg import UnalignedDataset_Seg
        dataset = UnalignedDataset_Seg()

    elif opt.dataset_mode == 'aligned_seg':
        from data.aligned_dataset_seg import AlignedDataset_Seg
        dataset = AlignedDataset_Seg()
    elif opt.dataset_mode == 'aligned_seg_rand':
        from data.aligned_dataset_seg_rand import AlignedDataset_Seg_Rand
        dataset = AlignedDataset_Seg_Rand()

    elif opt.dataset_mode == 'single':
        from data.single_dataset import SingleDataset
        dataset = SingleDataset()

    elif opt.dataset_mode == 'fivek':
        from data.fivek_dataset import FiveKDataset
        dataset = FiveKDataset()

    elif opt.dataset_mode == 'fivek2':
        from data.fivek_dataset2 import FiveKDataset2
        dataset = FiveKDataset2()

    elif opt.dataset_mode == 'fivek3':
        from data.fivek_dataset3 import FiveKDataset3
        dataset = FiveKDataset3()
    elif opt.dataset_mode == 'fivek4':
        from data.fivek_dataset4 import FiveKDataset4
        dataset = FiveKDataset4()
    elif opt.dataset_mode == 'fivek4_syn':
        from data.fivek_dataset4_syn import FiveKDataset4_syn
        dataset = FiveKDataset4_syn()
    elif opt.dataset_mode == 'fivek_single':
        from data.fivek_single import FiveKDataset_single
        dataset = FiveKDataset_single()

    elif opt.dataset_mode == 'ava':
        from data.ava_dataset import AVADataset
        dataset = AVADataset()

    elif opt.dataset_mode == 'aadb':
        from data.aadb_dataset import AADBDataset
        dataset = AADBDataset()
    else:
        raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)

    print("dataset [%s] was created" % (dataset.name()))
    dataset.initialize(opt)
    return dataset
    opt.display_freq = 1
    opt.print_freq = 1
    opt.niter = 1
    opt.niter_decay = 0
    opt.max_dataset_size = 10

n_gpu = int(os.environ['WORLD_SIZE']) if 'WORLD_SIZE' in os.environ else 1
opt.distributed = n_gpu > 1
local_rank = opt.local_rank

if opt.distributed:
    torch.cuda.set_device(opt.local_rank)
    torch.distributed.init_process_group(backend='nccl', init_method='env://')
    synchronize()

dataset = AlignedDataset()
dataset.initialize(opt)

data_loader = torch.utils.data.DataLoader(dataset,
                                          batch_size=opt.batchSize,
                                          shuffle=False,
                                          num_workers=int(opt.workers))
dataset_size = len(data_loader)
print('#training images = %d' % dataset_size)

total_steps = (start_epoch - 1) * dataset_size + epoch_iter

display_delta = total_steps % opt.display_freq
print_delta = total_steps % opt.print_freq
save_delta = total_steps % opt.save_latest_freq
Ejemplo n.º 4
0
def CreateDataset(opt):
    from data.aligned_dataset import AlignedDataset
    dataset = AlignedDataset()
    dataset.initialize(opt)
    return dataset
Ejemplo n.º 5
0
def CreateDataset_stage1(opt):
    dataset = None
    from data.aligned_dataset import AlignedDataset
    dataset = AlignedDataset()
    dataset.initialize(opt)
    return dataset
Ejemplo n.º 6
0
def CreateDataset(opt):
    dataset = None
    if opt.dataset_mode == 'aligned':
        from data.aligned_dataset import AlignedDataset
        dataset = AlignedDataset()
    elif opt.dataset_mode == 'unaligned':
        from data.unaligned_dataset import UnalignedDataset
        dataset = UnalignedDataset()
    elif opt.dataset_mode == 'single':
        from data.single_dataset import SingleDataset
        dataset = SingleDataset()
    elif opt.dataset_mode == 'unaligned_A_labeled':
        from data.unaligned_A_labeled_dataset import UnalignedALabeledDataset
        dataset = UnalignedALabeledDataset()
    elif opt.dataset_mode == 'mnist_svhn':
        from data.mnist_svhn_dataset import MnistSvhnDataset
        dataset = MnistSvhnDataset()
    elif opt.dataset_mode == 'mnist_mnistfg':
        from data.mnist_mnistfg_dataset import MnistMnistfgDataset
        dataset = MnistMnistfgDataset()
    elif opt.dataset_mode == 'mnistfg_test':
        from data.mnistfg_test_dataset import MnistfgTestDataset
        dataset = MnistfgTestDataset()
    elif opt.dataset_mode == 'cifar10_cifar10fg':
        from data.cifar10_cifar10fg_dataset import Cifar10Cifar10fgDataset
        dataset = Cifar10Cifar10fgDataset()
    elif opt.dataset_mode == 'cifar10fg_test':
        from data.cifar10fg_test_dataset import Cifar10fgTestDataset
        dataset = Cifar10fgTestDataset()
    elif opt.dataset_mode == 'cifar10_cifar10bim':
        from data.cifar10_cifar10bim_dataset import Cifar10Cifar10bimDataset
        dataset = Cifar10Cifar10bimDataset()
    elif opt.dataset_mode == 'cifar10bim_test':
        from data.cifar10bim_test_dataset import Cifar10bimTestDataset
        dataset = Cifar10bimTestDataset()
    elif opt.dataset_mode == 'cifar10_cifar10df':
        from data.cifar10_cifar10df_dataset import Cifar10Cifar10dfDataset
        dataset = Cifar10Cifar10dfDataset()
    elif opt.dataset_mode == 'cifar10df_test':
        from data.cifar10df_test_dataset import Cifar10dfTestDataset
        dataset = Cifar10dfTestDataset()
    elif opt.dataset_mode == 'mnist_mnistdf':
        from data.mnist_mnistdf_dataset import MnistMnistdfDataset
        dataset = MnistMnistdfDataset()
    elif opt.dataset_mode == 'mnistdf_test':
        from data.mnistdf_test_dataset import MnistdfTestDataset
        dataset = MnistdfTestDataset()
    elif opt.dataset_mode == 'mnist_mnistbim':
        from data.mnist_mnistbim_dataset import MnistMnistbimDataset
        dataset = MnistMnistbimDataset()
    elif opt.dataset_mode == 'mnistbim_test':
        from data.mnistbim_test_dataset import MnistbimTestDataset
        dataset = MnistbimTestDataset()
    elif opt.dataset_mode == 'svhn_mnist':
        from data.svhn_mnist_dataset import SvhnMnistDataset
        dataset = SvhnMnistDataset()

    else:
        raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)

    print("dataset [%s] was created" % (dataset.name()))
    dataset.initialize(opt)
    return dataset
    def test_dataloader(self):
        dataset = AlignedDataset(self.dataroot, 'test', self.load_size,
                                 self.crop_size, self.preprocess)

        return DataLoader(dataset, batch_size=1, num_workers=4)