def get_transforms(auto_augment, input_sizes, m, mean, n, std): if auto_augment: # AutoAugment + Cutout train_transforms = Compose([ RandomCrop(size=input_sizes, padding=4, fill=128), RandomHorizontalFlip(p=0.5), CIFAR10Policy(), ToTensor(), Normalize(mean=mean, std=std), Cutout(n_holes=1, length=16) ]) else: # RandAugment + Cutout train_transforms = Compose([ RandomCrop(size=input_sizes, padding=4, fill=128), RandomHorizontalFlip(p=0.5), RandomRandAugment(n=n, m_max=m), # This version includes cutout ToTensor(), Normalize(mean=mean, std=std) ]) test_transforms = Compose([ ToTensor(), Normalize(mean=mean, std=std) ]) return test_transforms, train_transforms
def prepare_data(self): "Prepare supervised and unsupervised datasets from cifar" dataset_path = self.hparams.dataset_path n_labeled = self.hparams.n_labeled n_overlap = self.hparams.n_overlap seed = self.hparams.seed if self.hparams.dataset == "cifar": n = self.hparams.randaug_n m = self.hparams.randaug_m uda_tfm = Compose([RandAugment(n, m), ToTensor(), Normalize(*CIFAR_STATS)]) sup_tfm = Compose([RandomCrop(32, 4, padding_mode="reflect"), RandomHorizontalFlip(), ToTensor(), Normalize(*CIFAR_STATS)]) val_tfm = Compose([ToTensor(), Normalize(*CIFAR_STATS)]) sup_ds, unsup_ds = Cifar.uda_ds(dataset_path, n_labeled, n_overlap, sup_tfm, uda_tfm, seed=seed) val_ds = Cifar.val_ds(dataset_path, val_tfm) if self.hparams.dataset == "quickdraw": uda_tfm = Compose([ExpandChannels, SketchDeformation, RandomHorizontalFlip(), RandomRotation(30), RandomCrop(128, 18), ToTensor()]) sup_tfm = Compose([ExpandChannels, RandomCrop(128, 9), RandomHorizontalFlip(), ToTensor()]) val_tfm = Compose([ExpandChannels, ToTensor()]) sup_ds, unsup_ds = QuickDraw.uda_ds(dataset_path, n_labeled, n_overlap, sup_tfm, uda_tfm, seed=seed) val_ds = QuickDraw.val_ds(dataset_path, val_tfm) self.train_ds_sup = sup_ds self.train_ds_unsup = unsup_ds self.valid_ds = val_ds
def get_transforms(augment): valid_t = Compose([Resize(256), CenterCrop(224), ToTensor(), Normalize(**_ImageNet['Normalize'])]) if augment == False: train_t = valid_t elif augment == True: train_t = Compose([RandomResizedCrop(224), RandomHorizontalFlip(), ToTensor(), ColorJitter(), Lighting(_ImageNet['PCA']), Normalize(**_ImageNet['Normalize'])]) elif augment == "torchvision": train_t = Compose([RandomResizedCrop(224), RandomHorizontalFlip(), ToTensor(), Normalize(**_ImageNet['Normalize'])]) elif augment == "torchvision2": train_t = Compose([Resize(256), RandomCrop(224), RandomHorizontalFlip(), ToTensor(), Normalize(**_ImageNet['Normalize'])]) else: assert(False) transforms = { 'training': train_t, 'validation': valid_t } return transforms
def train_hr_transform(crop_size): return Compose([ RandomCrop(crop_size), RandomHorizontalFlip(), RandomHorizontalFlip(), ColorJitter(0.2, 0.2, 0.1, 0.1), ToTensor(), ])
def init_datasets(x, y, cfg): # We assume IMDB, FairFace print("Loading Datasets...") transforms_train = transforms.Compose([ Resize(224), RandomHorizontalFlip(0.5), RandomCrop(224), RandomGrayscale(0.5), ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) transforms_val = transforms.Compose([ Resize(224), RandomHorizontalFlip(0.5), CenterCrop(224), RandomGrayscale(0.5), ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) datasets = {k: [] for k in ['train', 'val', 'test']} for i, (x_val, y_val) in enumerate(zip(x, y)): #print(x_val,y_val) X_train, X_test, y_train, y_test = train_test_split( x_val, y_val, test_size=(1 - cfg.TRAIN.TRAIN_RATIO), random_state=42) X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.15, random_state=42) datasets['train'].append( IMDBDataset(X_train, y_train, root_dir=cfg.DATASET.DATA_FOLDER[i], transform=transforms_train)) datasets['val'].append( IMDBDataset(X_val, y_val, root_dir=cfg.DATASET.DATA_FOLDER[i], transform=transforms_val)) datasets['test'].append( IMDBDataset(X_test, y_test, root_dir=cfg.DATASET.DATA_FOLDER[i], transform=transforms_val)) for k in ['train', 'val', 'test']: datasets[k] = ConcatDataset(datasets[k]) return datasets
def get_transform(new_size=None, flip_horizontal=False): """ obtain the image transforms required for the input data :param new_size: size of the resized images :param flip_horizontal: Whether to randomly mirror input images during training :return: image_transform => transform object from TorchVision """ from torchvision.transforms import ToTensor, Normalize, Compose, Resize, \ RandomHorizontalFlip if not flip_horizontal: if new_size is not None: image_transform = Compose([ Resize(new_size), ToTensor(), #TODO: Make this respect 1 or 3 channels #Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) Normalize(mean=[0.5], std=[0.5]) ]) else: image_transform = Compose([ ToTensor(), #TODO: Make this respect 1 or 3 channels #Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) Normalize(mean=[0.5], std=[0.5]) ]) else: if new_size is not None: image_transform = Compose([ RandomHorizontalFlip(p=0.5), Resize(new_size), ToTensor(), #TODO: Make this respect 1 or 3 channels #Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) Normalize(mean=[0.5], std=[0.5]) ]) else: image_transform = Compose([ RandomHorizontalFlip(p=0.5), ToTensor(), #TODO: Make this respect 1 or 3 channels #Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) Normalize(mean=[0.5], std=[0.5]) ]) return image_transform
def __init__(self, *args, num_classes=100, keep_index=True, img_size=224, train=True, load_features_path=None, save_features_path=None, extract_at_layer=None, feature_extractor=None, **kwargs): super(ExtendedDataset, self).__init__(*args, train=train, **kwargs) self.train = train self.num_classes = num_classes self.data_index = None self.keep_index = keep_index if keep_index: self.data_index = np.arange(len(self)) self.mean_image = None self.resize = Resize(img_size) self.augment = Compose( [RandomCrop(img_size, padding=8), RandomHorizontalFlip()]) self._set_mean_image() self._set_data() self.layer = extract_at_layer self.use_feature_data = False self.feature_data_set = False if extract_at_layer: self.use_feature_data = True self._set_feature_data(feature_extractor, extract_at_layer, load_features_path=load_features_path, save_features_path=save_features_path)
def get_basic_train_test_loaders(path, batch_size, num_workers, device): train_set_raw = CIFAR10(root=path, train=True, download=False) test_set_raw = CIFAR10(root=path, train=False, download=False) train_transforms = Compose([ RandomHorizontalFlip(), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) test_transforms = Compose([ ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) train_set = TransformedDataset(train_set_raw, train_transforms) test_set = TransformedDataset(test_set_raw, test_transforms) train_loader = DataLoader(train_set, batch_size=batch_size, num_workers=num_workers, pin_memory="cuda" in device, drop_last=True) test_loader = DataLoader(test_set, batch_size=batch_size * 4, num_workers=num_workers, pin_memory="cuda" in device, drop_last=False) return train_loader, test_loader
def get_cifar10_loaders(data_root: str, batch_size: int, num_workers: int, augment=True) -> (DataLoader, DataLoader): """ Function for retrieving CIFAR10 data as data loaders. Training set is augmented. Note that ToTensor() automatically divides by 255. Args: data_root: Path to CIFAR10 data. batch_size: Batch size of data. num_workers: Number of workers to pre-process data. augment: Whether to use data augmentation on the training data. Returns: Training and evaluation data loaders for the CIFAR10 dataset. """ # Normalize(mean=[0.491, 0.482, 0.447], std=[0.247, 0.243, 0.262]) if augment: train_transform = Compose([RandomHorizontalFlip(), RandomCrop(size=32, padding=4), ToTensor()]) else: train_transform = ToTensor() eval_transform = ToTensor() train_set = CIFAR10(root=data_root, train=True, transform=train_transform, download=True) eval_set = CIFAR10(root=data_root, train=False, transform=eval_transform, download=True) train_loader = DataLoader(train_set, batch_size, shuffle=True, num_workers=num_workers, pin_memory=True) eval_loader = DataLoader(eval_set, batch_size, shuffle=False, num_workers=num_workers, pin_memory=True) return train_loader, eval_loader
def get_train_test_loaders(dataset_name, path, batch_size, num_workers): assert dataset_name in datasets.__dict__, "Unknown dataset name {}".format(dataset_name) fn = datasets.__dict__[dataset_name] train_transform = Compose([ Pad(2), RandomCrop(32), RandomHorizontalFlip(), ToTensor(), Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25)), ]) test_transform = Compose([ ToTensor(), Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25)), ]) train_ds = fn(root=path, train=True, transform=train_transform, download=True) test_ds = fn(root=path, train=False, transform=test_transform, download=False) train_loader = DataLoader(train_ds, batch_size=batch_size, num_workers=num_workers, pin_memory=True) test_loader = DataLoader(test_ds, batch_size=batch_size * 2, num_workers=num_workers, pin_memory=True) return train_loader, test_loader
def __init__(self,SourceDatasetPath="../data/dataset/kaggledataset",pathTestDataSource="../test/dataset/kaggledataset"): self.SourceDatasetPath=SourceDatasetPath self.pathTestDataSource=pathTestDataSource self.pathTestDataTarget="../test/testdata/test_tmp/" self.trainValidDatasetLength=0 self.directory_common = "../data/tmp_kaggle/" self.directory_original = '../data/' self.train_prefix = 'train/' self.val_prefix = 'valid/' self.datasplit=0.2 # reatio of dataset between test and train+valid self.load_second_dataset() # preparing dataset-train dataset/ validation datadset self.train_transform = Compose([Resize([128,128]),RandomHorizontalFlip(0.5),RandomRotation(0.2),ToTensor(),Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5))]) self.simple_transform = Compose([Resize([128,128]),ToTensor(),Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5))]) self.train_dataset = ImageFolder(os.path.join(self.directory_original,'train'),transform=self.train_transform) self.valid_dataset = ImageFolder(os.path.join(self.directory_original,'valid'),transform=self.simple_transform) self.test_dataset=ImageFolder(self.pathTestDataTarget,transform=self.simple_transform) # preparing dataloader - train dataloader /validation dataloader self.train_dataloader = DataLoader(self.train_dataset,batch_size=30) self.valid_dataloader = DataLoader(self.valid_dataset,batch_size=30) self.test_dataloader = DataLoader(self.test_dataset,batch_size=30) ################ Removing temporary paths ####################### sh.rmtree(self.directory_common)
def get_frame_and_landmarks_from_folder(path, num_frames, generate_landmark=False): augumentation = Compose([RandomHorizontalFlip(0.5)]) transform = Compose( [ToTensor(), Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])]) length = len(path) if len(path) > num_frames: random_frames = [ random.choice(range(0, length - 1)) for _ in range(num_frames + 1) ] else: random_frames = random.sample(range(0, length - 1), num_frames + 1) res = [] for index in random_frames: frame = cv2.imread(path[index]) frame = cv2.resize(frame, (256, 256), interpolation=cv2.INTER_LINEAR) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame = augumentation(Image.fromarray(frame, mode='RGB')) # frame = Image.fromarray(frame, mode='RGB') if generate_landmark: landmark = get_landmark(np.array(frame)) res.append([transform(frame), landmark]) else: res.append(transform(frame)) return res
def default_transforms(self) -> Dict[str, Callable]: if self.training: post_tensor_transform = [ RandomShortSideScale(min_size=256, max_size=320), RandomCrop(244), RandomHorizontalFlip(p=0.5), ] else: post_tensor_transform = [ ShortSideScale(256), ] return { "post_tensor_transform": Compose([ ApplyTransformToKey( key="video", transform=Compose([UniformTemporalSubsample(8)] + post_tensor_transform), ), ]), "per_batch_transform_on_device": Compose([ ApplyTransformToKey( key="video", transform=K.VideoSequential( K.Normalize(torch.tensor([0.45, 0.45, 0.45]), torch.tensor([0.225, 0.225, 0.225])), data_format="BCTHW", same_on_frame=False ) ), ]), }
def CropResize(options): return Compose([ RandomResizedCrop(size=options.image_size), RandomHorizontalFlip(0.5), ToTensor(), Normalize(options.image_mean, options.image_std), ])
def get_data_loaders(train_files, val_files, img_size=224): train_transform = Compose([ ColorJitter(0.3, 0.3, 0.3, 0.3), RandomResizedCrop(img_size, scale=(0.8, 1.2)), RandomAffine(10.), RandomRotation(13.), RandomHorizontalFlip(), ToTensor(), ]) #train_mask_transform = Compose([ # RandomResizedCrop(img_size, scale=(0.8, 1.2)), # RandomAffine(10.), # RandomRotation(13.), # RandomHorizontalFlip(), # ToTensor(), #]) val_transform = Compose([ Resize((img_size, img_size)), ToTensor(), ]) train_loader = DataLoader(MaskDataset(train_files, train_transform), batch_size=BATCH_SIZE, shuffle=True, pin_memory=True, num_workers=4) val_loader = DataLoader(MaskDataset(val_files, val_transform), batch_size=BATCH_SIZE, shuffle=False, pin_memory=True, num_workers=4) return train_loader, val_loader
def __getitem__(self, index): transforms = list() if self.dataset_name == 'facades': transforms += [Resize((self.load_size, self.load_size), Image.BILINEAR)] transforms += [RandomHorizontalFlip()] if random.random() > 0.5 else [] transforms += [ToTensor(), Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])] image_input = Image.open(join(self.dir_input, self.list_paths_input[index])).convert('RGB') if self.mode == 'train' or self.mode == 'val': index_random = random.randint(0, len(self.list_paths_real) - 1) image_real = Image.open(join(self.dir_real, self.list_paths_real[index_random])).convert('RGB') else: transforms += [Resize((self.load_size, self.load_size), Image.BILINEAR)] transforms += [ToTensor(), Normalize(mean=[0.5], std=[0.5])] image_input = Image.open(join(self.dir_input, self.list_paths_input[index])).convert('L') if self.mode == 'train' or self.mode == 'val': index_random = random.randint(0, len(self.list_paths_real) - 1) image_real = Image.open(join(self.dir_real, self.list_paths_real[index_random])).convert('L') transforms = Compose(transforms) input = transforms(image_input) real = transforms(image_real) if self.mode == 'train' or self.mode == 'val' else 0 return input, real
def get_data_loaders(train_files, val_files, img_size=224): train_transform = Compose([ #ColorJitter(0.3, 0.3, 0.3, 0.3), RandomResizedCrop(img_size, scale=(0.8, 1.2)), RandomAffine(10.), RandomRotation(13.), RandomHorizontalFlip(), ToTensor(), Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) val_transform = Compose([ Resize((img_size, img_size)), ToTensor(), Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ]) train_loader = DataLoader(HairStyleDataset(train_files, train_transform), batch_size=BATCH_SIZE, shuffle=True, pin_memory=True, num_workers=4) val_loader = DataLoader(HairStyleDataset(val_files, val_transform), batch_size=BATCH_SIZE, shuffle=True, pin_memory=True, num_workers=4) return train_loader, val_loader
def __init__(self, opt, val=False): super(CustomCIFAR100, self).__init__() dir_dataset = opt.dir_dataset if val: self.dataset = CIFAR100(root=dir_dataset, train=False, download=True) self.transform = Compose([ ToTensor(), Normalize(mean=[0.507, 0.487, 0.441], std=[0.267, 0.256, 0.276]) ]) else: self.dataset = CIFAR100(root=dir_dataset, train=True, download=True) self.transform = Compose([ RandomCrop((32, 32), padding=4, fill=0, padding_mode='constant'), RandomHorizontalFlip(), ToTensor(), Normalize(mean=[0.507, 0.487, 0.441], std=[0.267, 0.256, 0.276]) ])
def __init__(self, filepath, split='train', data_augmentation=False, img_size=None): self.filepath = filepath self.split = split # open the dataset file self.file = h5py.File(self.filepath , "r") self.data_group = self.file[self.split] self.n_images = self.data_group['observations'].shape[0] self.has_labels = 'labels' in self.data_group if img_size is not None: self.img_size = img_size else: self.img_size = self.data_group['observations'][0].shape self.data_augmentation = data_augmentation if self.data_augmentation: radius = max(self.img_size[0], self.img_size[1]) / 2 padding_size = int(np.sqrt(2 * np.power(radius, 2)) - 128) self.spheric_pad = SphericPad(padding_size=padding_size) # max rotation needs padding of [sqrt(2*128^2)-128 = 53.01] self.random_horizontal_flip = RandomHorizontalFlip(0.2) self.random_vertical_flip = RandomVerticalFlip(0.2) self.random_resized_crop = RandomResizedCrop(size=self.img_size) self.random_rotation = RandomRotation(40) self.center_crop = CenterCrop(self.img_size) self.roll_y = Roll(shift=0, dim=1) self.roll_x = Roll(shift=0, dim=2)
def ImageTransform(loadSize, cropSize): return Compose([ Resize(size=loadSize, interpolation=Image.BICUBIC), RandomCrop(size=cropSize), RandomHorizontalFlip(p=0.5), ToTensor(), ])
def get_frames_and_landmarks_non_random(video_path, num_frames, generate_landmark=False): augumentation = Compose([RandomHorizontalFlip(0.5)]) transform = Compose( [ToTensor(), Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])]) res = [] cap = cv2.VideoCapture(video_path) length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) # for if length < num_frames: num_frames = length for frame_number in range(0, num_frames): cap.set(1, frame_number) _, frame = cap.read() frame = cv2.resize(frame, (256, 256), interpolation=cv2.INTER_LINEAR) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # frame = augumentation(Image.fromarray(frame, mode='RGB')) frame = Image.fromarray(frame, mode='RGB') if generate_landmark: landmark = get_landmark_save_frames(frame, frame_number=frame_number) res.append([transform(frame), landmark]) else: res.append(transform(frame)) cap.release() return res
def __init__(self, opts): self.dataroot = opts.dataroot self.num_domains = opts.num_domains self.input_dim = opts.input_dim self.nz = opts.input_nz domains = [chr(i) for i in range(ord('A'),ord('Z')+1)] self.images = [None]*self.num_domains stats = '' for i in range(self.num_domains): img_dir = os.path.join(self.dataroot, opts.phase + domains[i]) ilist = os.listdir(img_dir) self.images[i] = [os.path.join(img_dir, x) for x in ilist] stats += '{}: {}'.format(domains[i], len(self.images[i])) stats += ' images' self.dataset_size = max([len(self.images[i]) for i in range(self.num_domains)]) # setup image transformation transforms = [Resize((opts.resize_size, opts.resize_size), Image.BICUBIC)] if opts.phase == 'train': transforms.append(RandomCrop(opts.img_size)) else: transforms.append(CenterCrop(opts.img_size)) if not opts.no_flip: transforms.append(RandomHorizontalFlip()) transforms.append(ToTensor()) transforms.append(Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])) self.transforms = Compose(transforms) return
def load_dataset(batch_size=64): data_path = 'autism_faces/train/' valid_path = 'autism_faces/valid/' test_path = 'autism_faces/test/' transformed = transforms.Compose([ RandomResizedCrop(224), RandomHorizontalFlip(), RandomRotation(10), ToTensor() ]) train_dataset = torchvision.datasets.ImageFolder(root=data_path, transform=transformed) validation_dataset = torchvision.datasets.ImageFolder( root=valid_path, transform=transformed) test_dataset = torchvision.datasets.ImageFolder(root=test_path, transform=transformed) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, num_workers=0, shuffle=True) validation_loader = torch.utils.data.DataLoader(validation_dataset, batch_size=100, num_workers=0, shuffle=True) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, num_workers=0, shuffle=True) return train_loader, validation_loader, test_loader
def __init__(self, seq_name, vis_threshold, P, K, max_per_person, crop_H, crop_W, transform, normalize_mean=None, normalize_std=None): self.data_dir = osp.join(cfg.DATA_DIR, 'Market-1501-v15.09.15') self.seq_name = seq_name self.P = P self.K = K self.max_per_person = max_per_person self.crop_H = crop_H self.crop_W = crop_W if transform == "random": self.transform = Compose([RandomCrop((crop_H, crop_W)), RandomHorizontalFlip(), ToTensor(), Normalize(normalize_mean, normalize_std)]) elif transform == "center": self.transform = Compose([CenterCrop((crop_H, crop_W)), ToTensor(), Normalize(normalize_mean, normalize_std)]) else: raise NotImplementedError("Tranformation not understood: {}".format(transform)) if seq_name: assert seq_name in ['bounding_box_test', 'bounding_box_train', 'gt_bbox'], \ 'Image set does not exist: {}'.format(seq_name) self.data = self.load_images() else: self.data = [] self.build_samples()
def __init__(self, opts): self.dataroot = opts.dataroot # A images_A = os.listdir(os.path.join(self.dataroot, opts.phase + 'A')) self.A = [os.path.join(self.dataroot, opts.phase + 'A', x) for x in images_A] # B images_B = os.listdir(os.path.join(self.dataroot, opts.phase + 'B')) self.B = [os.path.join(self.dataroot, opts.phase + 'B', x) for x in images_B] self.A_size = len(self.A) self.B_size = len(self.B) self.dataset_size = max(self.A_size, self.B_size) self.input_dim_A = opts.input_dim_a self.input_dim_B = opts.input_dim_b # setup image transformation transforms = [Resize((opts.resize_size, opts.resize_size), Image.BICUBIC)] if opts.phase == 'train': transforms.append(RandomCrop(opts.crop_size)) else: transforms.append(CenterCrop(opts.crop_size)) if not opts.no_flip: transforms.append(RandomHorizontalFlip()) transforms.append(ToTensor()) transforms.append(Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])) self.transforms = Compose(transforms) print('A: %d, B: %d images'%(self.A_size, self.B_size)) return
def get_train_transform(cfg): trfm = Compose([ RandomHorizontalFlip(), ToTensor(), Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ]) return trfm
def MedT_preprocess_image_v3(img, train, mean=None, std=None) -> torch.Tensor: if std is None: std = [0.5, 0.5, 0.5] if mean is None: mean = [0.5, 0.5, 0.5] if train == True: augment = Compose([ Image.fromarray, RandomResizedCrop(224, scale=(0.88, 1.0), ratio=(0.999, 1.001)), RandomHorizontalFlip(), RandomVerticalFlip(), RandomRot90() ]) normilize = Compose([ToTensor(), Normalize(mean=mean, std=std)]) augmented = augment(img) preprocced = normilize(augmented).unsqueeze(0) return preprocced, augmented preprocessing = Compose([ Image.fromarray, Resize(size=224), ToTensor(), Normalize(mean=mean, std=std) ]) return preprocessing(img).unsqueeze(0), None
def build_dataset(source_domain_name, target_domain_name): """ Build torch DataSet Args: source_domain_name (string): name of source domain dataset. target_domain_name (string): name of target domain dataset. Returns: datasets (dict): dictionary mapping domain_name (string) to torch Dataset. """ # Define transforms for training and evaluation transform_train = Compose([Resize([256, 256]), RandomCrop([224, 224]), RandomHorizontalFlip(), RandomRotation(degrees=30, fill=128), ToTensor(), Normalize(IMAGENET_MEAN, IMAGENET_STD)]) transform_eval = Compose([Resize([256, 256]), CenterCrop([224, 224]), ToTensor(), Normalize(IMAGENET_MEAN, IMAGENET_STD)]) datasets = {} datasets['train_source'] = ImageFolder(root=root_dir[source_domain_name], transform=transform_train) datasets['train_target'] = ImageFolder(root=root_dir[target_domain_name], transform=transform_train) datasets['test'] = ImageFolder(root=root_dir[target_domain_name], transform=transform_eval) return datasets
def transform_train(self, data, targets=None, batch_size=None): """ Transform the training data, perform random cropping data augmentation and basic random flip augmentation. Args: data: Numpy array. The data to be transformed. batch_size: int batch_size. targets: the target of training set. Returns: A DataLoader class instance. """ short_edge_length = min(data.shape[1], data.shape[2]) common_list = [Normalize(torch.Tensor(self.mean), torch.Tensor(self.std))] if self.augment: compose_list = [ToPILImage(), RandomCrop(data.shape[1:3], padding=4), RandomHorizontalFlip(), ToTensor() ] + common_list + [Cutout(n_holes=Constant.CUTOUT_HOLES, length=int(short_edge_length * Constant.CUTOUT_RATIO))] else: compose_list = common_list if len(data.shape) != 4: compose_list = [] dataset = self._transform(compose_list, data, targets) if batch_size is None: batch_size = Constant.MAX_BATCH_SIZE batch_size = min(len(data), batch_size) return DataLoader(dataset, batch_size=batch_size, shuffle=True)
def transform_target(crop_size): """Ground truth image """ return Compose([ RandomCrop(crop_size), RandomHorizontalFlip(), ])