Exemple #1
0
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
Exemple #2
0
    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)
Exemple #4
0
    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)
Exemple #5
0
    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
Exemple #6
0
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
Exemple #7
0
    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()
Exemple #8
0
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
Exemple #10
0
    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()
Exemple #11
0
    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)
Exemple #12
0
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
Exemple #13
0
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
Exemple #14
0
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
Exemple #15
0
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
Exemple #16
0
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
Exemple #17
0
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(),
    ])
Exemple #19
0
 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()])
Exemple #20
0
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
Exemple #21
0
    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])
    ])
Exemple #23
0
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
Exemple #24
0
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
Exemple #25
0
 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)
Exemple #26
0
    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]
        ),
    ])  
Exemple #28
0
    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)
Exemple #29
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()
Exemple #30
0
    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)
        ])