def CreateDataset(opt):
dataset = None
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.model == 'pix2pixHD':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.model == 'pix2pixHDts':
if opt.face:
from .aligned_paired_dataset import AlignedPairedFaceDataset
dataset = AlignedPairedFaceDataset()
else:
from .aligned_paired_dataset import AlignedPairedDataset
dataset = AlignedPairedDataset()
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 == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
#print("================="+str(opt.dataset_mode))
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
## add 3D videodataset loader
elif opt.dataset_mode == 'v':
from data.video_data import VideoDataset
dataset = VideoDataset()
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()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
def CreateDataset(opt):
dataset = None
# Data stored as one image concatenated along horizontal axis
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
# Data stored in different directories
elif opt.dataset_mode == 'unaligned':
from data.unaligned_dataset import UnalignedDataset
dataset = UnalignedDataset()
elif opt.dataset_mode == 'geo':
from data.geo_dataset import GeoDataset
dataset = GeoDataset()
elif opt.dataset_mode == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
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 == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
class TwoAlignedDataset:
def initialize(self, opt):
assert opt.isTrain == True
# set different phases (folders of image)
opt1 = opt
opt1.phase = opt.phase1
opt1.dataset_model = 'aligned'
self.dataset1 = AlignedDataset()
self.dataset1.initialize(opt1)
opt2 = opt
opt2.phase = opt.phase2
opt2.dataset_model = 'aligned'
self.dataset2 = AlignedDataset()
self.dataset2.initialize(opt2)
def __getitem__(self, index):
# make crop and flip same in two datasets
w = self.dataset1.opt.loadSize
h = self.dataset1.opt.loadSize
w_offset = random.randint(0, max(0,
w - self.dataset1.opt.fineSize - 1))
h_offset = random.randint(0, max(0,
h - self.dataset1.opt.fineSize - 1))
is_flip = random.random() < 0.5
item1 = self.dataset1.get_item(index, w_offset, h_offset, is_flip)
item2 = self.dataset2.get_item(index, w_offset, h_offset, is_flip)
#item1 = self.dataset1[index]
#item2 = self.dataset2[index]
return {'dataset1_input': item1, 'dataset2_input': item2}
def __len__(self):
assert (len(self.dataset1) == len(self.dataset2))
return len(self.dataset1)
def name(self):
return 'TwoAlignedDataset'
def CreateDataset(opt):
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
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
def CreateDataset(opt):
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
dataset.initialize(opt)
return dataset
def modify_commandline_options(parser, is_train=True):
AlignedDataset.modify_commandline_options(parser=parser,
is_train=is_train)
parser.add_argument('--unaligned_dir', help='Unaligned dir')
return parser
def CreateDataset_stage1(opt):
dataset = None
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
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 == '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 CreateDataset(opt):
dataset = None
if opt.dataset_mode == 'aligned':
from data.aligned_dataset import AlignedDataset
dataset = AlignedDataset()
elif opt.dataset_mode == 'aligned_with_C':
from data.aligned_dataset_with_C import AlignedDatasetWithC
dataset = AlignedDatasetWithC()
elif opt.dataset_mode == 'aligned_multi_view':
from data.aligned_dataset_multi_view import AlignedDatasetMultiView
dataset = AlignedDatasetMultiView()
elif opt.dataset_mode == 'aligned_multi_view_random':
from data.aligned_dataset_multi_view_random import AlignedDatasetMultiView
dataset = AlignedDatasetMultiView()
elif opt.dataset_mode == 'aligned_depth':
from data.aligned_dataset_depth import AlignedDatasetDepth
dataset = AlignedDatasetDepth()
elif opt.dataset_mode == 'appearance_flow':
from data.appearance_flow_dataloader import AppearanceFlowDataloader
dataset = AppearanceFlowDataloader()
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_with_guidance':
from data.unaligned_dataset_with_guidance import UnalignedDatasetWithGuidance
dataset = UnalignedDatasetWithGuidance()
elif opt.dataset_mode == 'unaligned_with_label':
from data.unaligned_dataset_with_label import UnalignedDatasetWithLabel
dataset = UnalignedDatasetWithLabel()
elif opt.dataset_mode == 'unaligned_tensor_with_label':
from data.unaligned_tensor_dataset_with_label import UnalignedTensorDatasetWithLabel
dataset = UnalignedTensorDatasetWithLabel()
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)
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_landmark':
from data.unaligned_landmark_dataset import UnalignedLandmarkDataset
dataset = UnalignedLandmarkDataset()
elif opt.dataset_mode == 'aligned_heatmap2face':
from data.aligned_dataset import AlignedDatasetHeatmap2Face
dataset = AlignedDatasetHeatmap2Face()
elif opt.dataset_mode == 'aligned_boundary_detection':
from data.aligned_dataset import AlignedBoundaryDetection
dataset = AlignedBoundaryDetection()
elif opt.dataset_mode == 'aligned_boundary_detection_landmarks':
from data.aligned_dataset import AlignedBoundaryDetectionLandmark
dataset = AlignedBoundaryDetectionLandmark()
elif opt.dataset_mode == 'aligned_face2boundary2face':
from data.aligned_dataset import AlignedFace2Boudnary2Face
dataset = AlignedFace2Boudnary2Face()
elif opt.dataset_mode == 'aligned_face2face':
from data.aligned_dataset import AlignedFace2Face
dataset = AlignedFace2Face()
elif opt.dataset_mode == 'aligned_faceDataset':
from data.aligned_dataset import AlignedFaceDataset
dataset = AlignedFaceDataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
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
def CreateDataset(opt):
from data.aligned_dataset import AlignedDataset
train_dataset = AlignedDataset()
train_dataset.initialize(opt)
print("dataset [%s] was created" % (train_dataset.name()))
test_dataset = AlignedDataset()
opt_test = copy.deepcopy(opt)
opt_test.shuffle = False
opt_test.phase = "test"
opt_test.no_flip = True
opt_test.num_input_views = 9
test_dataset.initialize(opt_test)
print("dataset [%s] was created" % (test_dataset.name()))
validation_dataset = AlignedDataset()
opt_val = copy.deepcopy(opt)
opt_val.phase = "validation"
opt_val.no_flip = True
opt_val.shuffle = False
opt_val.num_input_views = 9
validation_dataset.initialize(opt_val)
print("dataset [%s] was created" % (validation_dataset.name()))
return train_dataset, test_dataset, validation_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 == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'tif':
from data.tif_dataset import TifDataset
dataset = TifDataset(opt)
elif opt.dataset_mode == 'mb':
from data.mb_dataset import MBDataset
dataset = MBDataset(opt)
elif opt.dataset_mode == 'png_withlist':
from data.png_dataset_withlist import PngDataset
dataset = PngDataset(opt)
elif opt.dataset_mode == 'png':
from data.png_dataset import PngDataset
dataset = PngDataset(opt)
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
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 == 'single':
from data.single_dataset import SingleDataset
dataset = SingleDataset()
elif opt.dataset_mode == 'imagelist':
from data.imagelist_dataset import ImageList
if opt.isTrain:
dataset = ImageList(root=opt.image_root, fileList=opt.train_list)
else:
dataset = ImageList(root=opt.image_root,
fileList=opt.train_list,
testPahse=True)
elif opt.dataset_mode == 'imagelist_cross_view':
from data.imagelist_dataset import ImageList_cross_view
dataset = ImageList_cross_view()
elif opt.dataset_mode == 'imglist_pts':
from data.imagelist_pts_dataset import Imglist_Pts_Dataset
dataset = Imglist_Pts_Dataset()
else:
raise ValueError("Dataset [%s] not recognized." % opt.dataset_mode)
print("dataset [%s] was created" % (dataset.name()))
dataset.initialize(opt)
return dataset
