def maybe_rotate(image): if randint(0, 100) <= 4: r = randint(0, 100) if r <= 20: return RandomRotation(degrees=90)(image) elif r <= 50: return RandomRotation(degrees=45)(image) else: return RandomRotation(degrees=30)(image) return image
def __getitem__(self, index): input = load_img(self.image_filenames[index]) #input是预先合成的4通道RGDB图片 #数据增强 if self.crop: input = RandomCrop(64)(input) #取patch input = RandomHorizontalFlip()(input) #水平翻转 input = RandomVerticalFlip()(input) #竖直翻转 input = RandomRotation(180)(input) #随机旋转 input_tensor = ToTensor()(input) rgb_tensor = torch.zeros(3, input_tensor.shape[1], input_tensor.shape[2]) depth_tensor = torch.zeros(1, input_tensor.shape[1], input_tensor.shape[2]) rgb_tensor[0, :, :] = input_tensor[0, :, :] rgb_tensor[1, :, :] = input_tensor[1, :, :] rgb_tensor[2, :, :] = input_tensor[2, :, :] depth_tensor[0, :, :] = input_tensor[3, :, :] depth = ToPILImage()(depth_tensor) size = min(depth.size[0], depth.size[1]) guide = ToPILImage()(rgb_tensor) target = depth.copy() guide = guide.convert('L') #生成LR depth = downsampling(depth, self.upscale_factor) depth = Resize(size=size, interpolation=Image.BICUBIC)(depth) depth = ToTensor()(depth) guide = ToTensor()(guide) depth = torch.cat((depth, guide), 0) #concatenate 生成输入张量 target = ToTensor()(target) return depth, target
class Dataset(torch.utils.data.Dataset): transforms = Compose([ lambda img_tensor: img_tensor / 255, RandomHorizontalFlip(), RandomRotation(10, interpolation=InterpolationMode.BILINEAR) ]) def __init__(self): dataset_path = join(os.curdir, dirname(__file__), 'orl-database-of-faces') # Sort by length first, then lexicographically dirnames = sorted([e for e in os.scandir(dataset_path) if e.is_dir()], key=lambda e: (len(e.name), e.name)) self.filenames = [ (filename.path, label) for label, e in enumerate(dirnames) for filename in sorted(os.scandir(e), key=lambda e: (len(e.name), e.name)) if filename.name.endswith(f'{os.extsep}pgm') ] def __getitem__(self, index): # Specify path relative to this script entry, label = self.filenames[index] img: torch.Tensor = read_pgm(open(entry, 'rb')) return self.transforms(img), label def __len__(self): return len(self.filenames)
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 __getitem__(self, index): x = cv2.imread( os.path.join(self.root, self.image_set, self.ids[index]), cv2.IMREAD_GRAYSCALE) if x.shape != (256, 256): x = cv2.resize(x, (256, 256)) # data augmentation if self.transform: transformations = Compose([ ToPILImage(), RandomRotation(degrees=10, resample=PIL.Image.BICUBIC), #RandomAffine(degrees=10, translate=(-25, 25), scale=(0.90, 1.10), resample=PIL.Image.BILINEAR), RandomHorizontalFlip(), RandomResizedCrop(size=256, scale=(0.90, 1), ratio=(0.95, 1.05), interpolation=PIL.Image.BICUBIC), #ColorJitter(brightness=0.05), #CenterCrop(size=(256, 256)), ToTensor(), ]) x = x[..., np.newaxis] x = transformations(x).float().numpy() * 255 x = x[0] image, _, _ = Downsample(x, self.mask) x = x / 255. image = image / 255. target = torch.from_numpy(x).float().unsqueeze(0) image = torch.from_numpy(image).float().unsqueeze(0) mask = [0] # return something to be compatible with fastMRI dataset return target, image, mask
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 test_single_transform(self): from torchvision.transforms import Compose, RandomCrop, RandomRotation, ColorJitter, ToTensor, RandomResizedCrop transforms = SequentialWrapper(com_transform=Compose([ RandomRotation(45), RandomCrop(224), RandomResizedCrop(size=192, scale=(0.8, 1.2)) ]), image_transform=Compose([ ColorJitter(brightness=[0.8, 1.2], contrast=[0.8, 1.2], saturation=1), ToTensor() ]), target_transform=ToLabel()) dataset = ACDCDataset( root_dir=self._root, mode="train", transforms=transforms, ) (image, target), filename = dataset[4] from deepclustering3.viewer import multi_slice_viewer_debug import matplotlib.pyplot as plt multi_slice_viewer_debug(image, target, no_contour=True) plt.show()
def main(): torch.cuda.empty_cache() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") main_dir = "./tiny-imagenet-200" # mean = 112.4660 # std = 70.8325 train_transforms = Compose( [Normalize(112.4660, 70.8325), RandomRotation(30), ToTensor()]) test_transforms = ToTensor() train_loader = DataLoader(ImagenetDataset(main_dir, 'train', train_transforms), batch_size=64, shuffle=True) val_loader = DataLoader(ImagenetDataset(main_dir, 'val', test_transforms), batch_size=64, shuffle=False) test_loader = DataLoader(ImagenetDataset(main_dir, 'test', test_transforms), batch_size=64, shuffle=False)
def __init__(self, root_dir, csv_file, is_train=True): df = pd.read_csv(root_dir + csv_file) df = df[df['is_train'] == is_train].reset_index(drop=True) self.image_ids = df['image_id'].values self.y = df[[ 'grapheme_root', 'vowel_diacritic', 'consonant_diacritic' ]] #transforms if is_train == False: #validation set self.transform = transforms.Compose([ Resize((224, 224)), ToTensor(), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ]) else: #train set self.transform = transforms.Compose([ Resize((224, 224)), RandomRotation((0, 2)), ToTensor(), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ]) self.root_dir = root_dir
def test_twice_transform(self): from torchvision.transforms import Compose, RandomCrop, RandomRotation, ColorJitter, ToTensor transforms = SequentialWrapperTwice(com_transform=Compose( [RandomRotation(45), RandomCrop(224)], ), image_transform=Compose([ ColorJitter( brightness=[0.8, 1.2], contrast=[0.8, 1.2], saturation=1), ToTensor() ]), target_transform=ToLabel(), total_freedom=False) dataset = ACDCDataset( root_dir=self._root, mode="train", transforms=transforms, ) (image1, image2, target1, target2), filename = dataset[4] from deepclustering3.viewer import multi_slice_viewer_debug import matplotlib.pyplot as plt multi_slice_viewer_debug(torch.cat([image1, image2], dim=0), torch.cat([target1, target2], dim=0), no_contour=True) plt.show()
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 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 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 _get_erised_faceattr(opt, mean, std, attrs): root = os.path.join(opt.root_path, 'Erised') train_transform = Compose([ inference_transform, RandomHorizontalFlip(), RandomRotation(10, expand=True), Resize((opt.person_size, opt.person_size)), ToTensor(), Normalize(mean, std) ]) # [CenterCrop(178), Resize((256, 256)), RandomCrop(224), RandomHorizontalFlip(), ToTensor(), Normalize(mean, std)]) val_transform = Compose([ inference_transform, Resize((opt.face_size, opt.face_size)), ToTensor(), Normalize(mean, std) ]) target_transform = ToMaskedTargetTensor(attrs) train_data = ErisedAll(root, 'train', indicator='face', img_transform=train_transform, target_transform=target_transform, output_recognizable=opt.output_recognizable, specified_attrs=opt.specified_attrs) val_data = ErisedAll(root, 'val', indicator='face', img_transform=val_transform, target_transform=target_transform, output_recognizable=opt.output_recognizable, specified_attrs=opt.specified_attrs) return train_data, val_data
def _get_widerattr(opt, mean, std, attrs): root = os.path.join(opt.root_path, 'Wider_attributes') cropping_transform = get_inference_transform_person train_img_transform = Compose([ square_no_elastic, RandomHorizontalFlip(), RandomRotation(10, expand=True), # [RandomHorizontalFlip(), RandomRotation(10, expand=True), Resize((opt.person_size, opt.person_size)), ToTensor(), Normalize(mean, std) ]) # [CenterCrop(178), Resize((256, 256)), RandomCrop(224), RandomHorizontalFlip(), ToTensor(), Normalize(mean, std)]) val_img_transform = Compose([ square_no_elastic, Resize((opt.person_size, opt.person_size)), ToTensor(), Normalize(mean, std) ]) target_transform = ToMaskedTargetTensor(attrs) train_data = WiderAttr(root, 'train', cropping_transform, img_transform=train_img_transform, target_transform=target_transform, output_recognizable=opt.output_recognizable) val_data = WiderAttr(root, 'val', cropping_transform, img_transform=val_img_transform, target_transform=target_transform, output_recognizable=opt.output_recognizable) return train_data, val_data
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 cifar10(root: str, batch_size: int = 32, workers: int = 6, augment: bool = True, splits: Union[str, Tuple[str]] = ('train', 'val')) -> LoaderTypes: """Wrapper for loading the `CIFAR10` dataset. Args: root: The root directory where the dataset is stored. Usually ~/.torch/datasets. batch_size: The batch size. workers: The number of CPUs to use for when loading the data from disk. augment: Whether to use data augmentation when training. splits: Which splits of the data to return. Possible values are `train`, `val` and `test`. Returns: A list data loaders of the chosen splits. """ normalize = Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]) val_transform = Compose([ToTensor(), normalize]) if augment: transform = Compose( [RandomCrop(32, padding=4), RandomHorizontalFlip(), ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1), RandomRotation(degrees=5), ToTensor(), normalize]) else: transform = val_transform loader_list = list() if 'train' in splits: train_val_set = CIFAR10(root, train=True, transform=transform, download=True) train_loader = DataLoader(train_val_set, batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True) loader_list.append(train_loader) if 'test' in splits or 'val' in splits: val_test_set = CIFAR10(root, train=False, transform=val_transform, download=True) val_set, test_set = torch.utils.data.random_split(val_test_set, [5000, 5000]) if 'val' in splits: val_set = Memory(val_set, img_size=32, channels=3) for _ in val_set: pass val_set.set_use_cache(True) val_set.pin_memory() loader_list.append(val_set) if 'test' in splits: test_set = Memory(test_set, img_size=32, channels=3) for _ in test_set: pass test_set.set_use_cache(True) test_set.pin_memory() loader_list.append(test_set) if len(loader_list) == 1: return loader_list[0] return loader_list
def train_hr_transform(crop_size): return Compose([ RandomCrop(crop_size, pad_if_needed=True), RandomHorizontalFlip(p=0.5), RandomVerticalFlip(p=0.5), RandomRotation(360), # ToTensor(), ])
def get_image_transformer(self): transformations = [ ColorJitter(brightness=0.3, contrast=0.3, saturation=0.1, hue=0.1), RandomGrayscale(p=0.5), RandomRotation(degrees=[0., 45.]), RandomResizedCrop(size=[224, 224], scale=(0.3, 1.0)) ] return Compose([RandomApply(transformations, p=0.7), ToTensor()])
def _get_new1data(opt, mean, std, attrs): root = os.path.join(opt.root_path, 'new_data') # cropping_transform = get_inference_transform_person_lr if opt.logits_vac: cropping_transform = Compose( [get_inference_transform_person_lr, square_no_elastic]) train_img_transform = Compose([ # [RandomHorizontalFlip(), RandomRotation(10, expand=True), # Resize((opt.person_size, opt.person_size)), ToTensor(), Normalize(mean, std) ]) # [CenterCrop(178), Resize((256, 256)), RandomCrop(224), RandomHorizontalFlip(), ToTensor(), Normalize(mean, std)]) val_img_transform = Compose( [ # Resize((opt.person_size, opt.person_size)), ToTensor(), Normalize(mean, std) ]) else: cropping_transform = get_inference_transform_person_lr train_img_transform = Compose([ square_no_elastic, RandomHorizontalFlip(), RandomRotation(10, expand=True), Resize((opt.person_size, opt.person_size)), ToTensor(), Normalize(mean, std) ]) # [CenterCrop(178), Resize((256, 256)), RandomCrop(224), RandomHorizontalFlip(), ToTensor(), Normalize(mean, std)]) val_img_transform = Compose([ square_no_elastic, Resize((opt.person_size, opt.person_size)), ToTensor(), Normalize(mean, std) ]) target_transform = ToMaskedTargetTensor(attrs, opt.label_smooth, opt.at, opt.at_loss) train_data = NewdataAttr1(attrs, root, 'train', opt.mode, opt.state, cropping_transform, img_transform=train_img_transform, target_transform=target_transform, logits_vac=opt.logits_vac) val_data = NewdataAttr1(attrs, root, 'test', opt.mode, opt.state, cropping_transform, img_transform=val_img_transform, target_transform=target_transform, logits_vac=opt.logits_vac) return train_data, val_data
def __init__(self, scenario="ni", run_id=0): """Init. :param scenario: The desired CoRE50 scenario. Supports 'nc', 'ni', and 'joint', which is the scenario with a single experience. :param run_id: an integer in [0, 4]. Each run uses a different set of expert models and data splits. """ assert scenario in { "ni", "joint", "nc", }, "`scenario` argument must be one of {'ni', 'joint', 'nc'}." core50_normalization = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) core50_train_transforms = Compose([ RandomHorizontalFlip(p=0.5), RandomCrop(size=128, padding=1), RandomRotation(15), ToTensor(), core50_normalization, ]) core50_eval_transforms = Compose( [CenterCrop(size=128), ToTensor(), core50_normalization]) if scenario == "ni": benchmark = CORe50( scenario="ni", train_transform=core50_train_transforms, eval_transform=core50_eval_transforms, run=run_id, ) elif scenario == "nc": benchmark = CORe50( scenario="nc", train_transform=core50_train_transforms, eval_transform=core50_eval_transforms, run=run_id, ) elif scenario == "joint": core50nc = CORe50(scenario="nc") train_cat = AvalancheConcatDataset( [e.dataset for e in core50nc.train_stream]) test_cat = AvalancheConcatDataset( [e.dataset for e in core50nc.test_stream]) benchmark = nc_benchmark(train_cat, test_cat, n_experiences=1, task_labels=False) else: assert False, "Should never get here." ll = len(benchmark.train_stream) experts = _load_expert_models(f"{scenario}_core50", run_id, ll) super().__init__(benchmark, experts)
def input_transform(): return Compose([ Resize((224, 224)), RandomHorizontalFlip(), RandomRotation(degrees=15), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])
def rotate_aug(image_batch): angle = random.choice([90, 180, 270]) aug = torch.zeros_like(image_batch) for i in range(image_batch.shape[0]): aug[i] = ToTensor()(RandomRotation(degrees=angle)(ToPILImage(mode='RGB')(image_batch[i].cpu()))) if(FLAGS.cuda): aug = aug.cuda() return aug
def fetch_subset_dataloader(types, params): """ Use only a subset of dataset for KD training, depending on params.subset_percent """ mean = [0.5071, 0.4865, 0.4409] std_dev = [0.2673, 0.2564, 0.2762] # using random crops and horizontal flip for train set if params.augmentation == "yes": train_transformer = transforms.Compose([ RandomResizedCrop((64, 64), scale = (0.7, 1.0)), RandomRotation(30), RandomHorizontalFlip(), ColorJitter(0.2, 0.2, 0.2, 0.05), ToTensor(), Normalize(mean, std_dev) ]) # data augmentation can be turned off else: train_transformer = transforms.Compose([Resize((64, 64)), ToTensor(), Normalize(mean, std_dev)]) # transformer for dev set dev_transformer = transforms.Compose([Resize((64, 64)), ToTensor(), Normalize(mean, std_dev)]) trainset = torchvision.datasets.CIFAR100(root='./data-cifar10', train=True, download=True, transform=train_transformer) devset = torchvision.datasets.CIFAR100(root='./data-cifar10', train=False, download=True, transform=dev_transformer) trainset_size = len(trainset) indices = list(range(trainset_size)) split = int(np.floor(params.subset_percent * trainset_size)) np.random.seed(230) np.random.shuffle(indices) train_sampler = SubsetRandomSampler(indices[:split]) trainloader = torch.utils.data.DataLoader(trainset, batch_size=params.batch_size, sampler=train_sampler, num_workers=params.num_workers, pin_memory=params.cuda) devloader = torch.utils.data.DataLoader(devset, batch_size=params.batch_size, shuffle=False, num_workers=params.num_workers, pin_memory=params.cuda) if types == 'train': dl = trainloader else: dl = devloader return dl
def load_transforms(self): 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 __init__(self, domain_X, domain_Y, image_size, root="./data"): self.transform = Compose([ ColorJitter(brightness=0.05, contrast=0.05), RandomRotation(0.05), RandomCrop(image_size), RandomHorizontalFlip(p=0.5), ToTensor(), Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) self.files_X = sorted(glob(os.path.join(root, domain_X) + '/*.*')) self.files_Y = sorted(glob(os.path.join(root, domain_Y) + '/*.*'))
def get_transforms_camaro(img_size): return T_Compose([ CropBens(img_size), RandomHorizontalFlip(), RandomVerticalFlip(), RandomRotation((-120, 120)), T_ToTensor(), T_Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] ), ])
def __getitem__(self, index): if self.DAGAN: x = np.load( os.path.join(self.root, self.image_set, self.ids[index])) else: x = cv2.imread( os.path.join(self.root, self.image_set, self.ids[index]), cv2.IMREAD_GRAYSCALE) # data augmentation if self.transform: #x = x[..., np.newaxis] #x = flip_axis(x, axis=1, is_random=True) ##x = elastic_transform(x, alpha=255 * 3, sigma=255 * 0.10, is_random=True) TODO #x = rotation(x, rg=10, is_random=True, fill_mode='constant') #x = shift(x, wrg=0.10, hrg=0.10, is_random=True, fill_mode='constant') #x = zoom(x, zoom_range=[0.90, 1.10], is_random=True, fill_mode='constant') ##x = brightness(x, gamma=0.05, is_random=True) #x = x[..., 0] #ori = x.copy() transformations = Compose([ ToPILImage(), RandomRotation(degrees=10, resample=PIL.Image.BICUBIC), #RandomAffine(degrees=10, translate=(-25, 25), scale=(0.90, 1.10), resample=PIL.Image.BILINEAR), #RandomHorizontalFlip(), RandomResizedCrop(size=256, scale=(0.90, 1.0), ratio=(0.95, 1.05), interpolation=PIL.Image.BICUBIC), #CenterCrop(size=(256, 256)), ToTensor(), ]) x = x[..., np.newaxis] x = transformations(x).float().numpy() * 255 x = x[0] image, _, _ = Downsample(x, self.mask) #image = x #image = np.round(np.clip(image, 0, 255)) XXX this is not wrong (written before 2019.08.13), but DAGAN has some data problem #image = np.clip(image, 0, 255) #print(np.max(image), np.min(image)) #cv2.imwrite('aa.bmp', ori.astype(np.uint8)) #cv2.imwrite('a.bmp', image.astype(np.uint8)) #xxx #return x, image x = x / 255. image = image / 255. return torch.from_numpy(x).float().unsqueeze(0), torch.from_numpy( image).float().unsqueeze(0)
def q_eval(net, dataset, q_idx, flip=False, rotate=False, scale=1): # load query image q_im = dataset.get_image(q_idx) q_size = q_im.size # list of transformation lists trfs_chains = [[]] if rotate: eps = 1e-6 trfs_chains[0] += [RandomRotation((rotate - eps, rotate + eps))] if flip: trfs_chains[0] += [RandomHorizontalFlip(1)] if scale == 0: # AlexNet asks for resized images of 224x224 edge_list = [224] resize_list = [Resize((edge, edge)) for edge in edge_list] elif scale == 1: edge_list = [800] resize_list = [lambda im: imresize(im, edge) for edge in edge_list] elif scale == 1.5: edge_list = [1200] resize_list = [lambda im: imresize(im, edge) for edge in edge_list] elif scale == 2: # multiscale edge_list = [600, 800, 1000, 1200] resize_list = [lambda im: imresize(im, edge) for edge in edge_list] else: raise ValueError() if len(resize_list) == 1: trfs_chains[0] += resize_list else: add_trf(trfs_chains, resize_list) # default transformations mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] for chain in trfs_chains: chain += [ToTensor(), Normalize(mean, std)] net = net.eval() q_feat = torch.zeros((len(trfs_chains), net.out_features)) print( 'Computing the forward pass and extracting the image representation...' ) for i in range(len(trfs_chains)): q_tensor = Compose(trfs_chains[i])(q_im) import pdb pdb.set_trace() # XXX BREAKPOINT q_feat[i] = net.forward( q_tensor.view(1, q_tensor.shape[0], q_tensor.shape[1], q_tensor.shape[2])) return F.normalize(q_feat.mean(dim=0), dim=0).detach().numpy()
def test_filedataset_segmentation(self): target_trans = Compose([ default_image_load_fn, Resize(60), RandomRotation(90), ToTensor() ]) file_dataset = FileDataset(self.paths, self.paths, self.transform, target_trans, seed=1337) x, y = file_dataset[0] assert np.allclose(x.numpy(), y.numpy()) out1 = list( DataLoader(file_dataset, batch_size=1, num_workers=3, shuffle=False)) out2 = list( DataLoader(file_dataset, batch_size=1, num_workers=3, shuffle=False)) assert all([ np.allclose(x1.numpy(), x2.numpy()) for (x1, _), (x2, _) in zip(out1, out2) ]) file_dataset = FileDataset(self.paths, self.paths, self.transform, target_trans, seed=None) x, y = file_dataset[0] assert np.allclose(x.numpy(), y.numpy()) out1 = list( DataLoader(file_dataset, batch_size=1, num_workers=3, shuffle=False)) out2 = list( DataLoader(file_dataset, batch_size=1, num_workers=3, shuffle=False)) assert not all([ np.allclose(x1.numpy(), x2.numpy()) for (x1, _), (x2, _) in zip(out1, out2) ])