Ejemplo n.º 1
0
def augmentation(p: float = 0.5) -> Callable:
    """Data augmentation pipeline.
    
    Fairly basic, can be improved. It would also be nice to define add this to hparams so we can include them in hyperparameter searches"""

    return Compose([
        RandomRotate90(),
        Flip(),
        OneOf([
            IAAAdditiveGaussianNoise(),
            GaussNoise(),
        ], p=0.2),
        OneOf([
            MotionBlur(p=0.2),
            MedianBlur(blur_limit=3, p=0.1),
            Blur(blur_limit=3, p=0.1),
        ],
              p=0.2),
        ShiftScaleRotate(
            shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
        OneOf([
            IAASharpen(),
            RandomBrightnessContrast(),
        ], p=0.3),
    ],
                   p=p)
def strong_aug(p=1.0):
    return Compose([
        Flip(p=0.75),
        ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=30, border_mode=cv2.BORDER_CONSTANT, p=0.3),
        RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.3),
        # RandomSizedCrop(min_max_height=(0,0), height=0, width=0, w2h_ratio=0, p=0.3)
        # OneOf([
        #     Blur(blur_limit=5, p=1.0),
        #     MedianBlur(blur_limit=5, p=1.0),
        #     MotionBlur(p=1.0),
        # ], p=0.2),
        # OneOf([
        #     HueSaturationValue(hue_shift_limit=10, sat_shift_limit=30, val_shift_limit=20, p=1.0),
        #     RGBShift(p=1.0)
        # ], p=0.1),
        # GaussNoise(p=0.1),

        # OneOf([
        #     GridDistortion(p=1.0),
        #     ElasticTransform(p=1.0)
        # ], p=0.2),
        # OneOf([
        #     CLAHE(p=1.0),
        #     IAASharpen(p=1.0),
        # ], p=0.2)
    ], p=p)
Ejemplo n.º 3
0
 def get_aug(p=.9):
     return Compose(
         [
             OneOf(
                 [
                     RandomRotate90(),
                     Flip(),
                     # ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=10)
                 ],
                 p=p),
             # OneOf([
             #     IAAAdditiveGaussianNoise(),
             #     GaussNoise(),
             # ], p = 0.0),
             # OneOf([
             #     MotionBlur(p = .2),
             #     MedianBlur(blur_limit = 3, p = 0.1),
             #     Blur(blur_limit = 3, p = 0.0),
             # ], p = 0.1),
             # OneOf([
             #     OpticalDistortion(p = 0.1),
             #     GridDistortion(p = .1),
             #     IAAPiecewiseAffine(p = 0.3),
             # ], p = 0.0),
             # OneOf([
             #     CLAHE(clip_limit = 2),
             #     IAASharpen(),
             #     IAAEmboss(),
             #     RandomBrightnessContrast(),
             # ], p = 0.0),
             Normalize(mean=(0.485, 0.456, 0.406),
                       std=(0.229, 0.224, 0.225))
         ],
         p=1.0)
Ejemplo n.º 4
0
 def aug(self, image):
     '''
     center crop, resize, affine, hue, saturation,
     '''
     if self.phase == 'train':
         imgaug = Compose([
             transforms.Resize(height=self.input_shape[0], width=self.input_shape[1]),
             RandomRotate90(),
             Flip(),
             Transpose(),
             OneOf([
                 IAAAdditiveGaussianNoise(),
                 GaussNoise(),
             ], p=0.2),
             OneOf([
                 MotionBlur(p=.2),
                 MedianBlur(blur_limit=3, p=.1),
                 Blur(blur_limit=3, p=.1),
             ], p=0.2),
             ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2),
             ToTensorV2(),
         ], p=1)
     else:
         imgaug = Compose([transforms.Resize(height=self.input_shape[0], width=self.input_shape[1]),
                           ToTensorV2()])
     image = imgaug(image=image)['image']
     return image
Ejemplo n.º 5
0
def aug2(p=1.0):
    return Compose([
        Flip(p=0.75),
        ShiftScaleRotate(
            rotate_limit=0, border_mode=cv2.BORDER_CONSTANT, p=0.5),
    ],
                   p=p)
Ejemplo n.º 6
0
def aug_daniel(prob=0.8):
    return Compose(
        [
            RandomRotate90(p=0.5),
            Transpose(p=0.5),
            Flip(p=0.5),
            OneOf(
                [
                    IAAAdditiveGaussianNoise(),
                    GaussNoise(),
                    #Blur(),
                ],
                p=0.3),
            OneOf(
                [
                    CLAHE(clip_limit=2),
                    IAASharpen(),
                    IAAEmboss(),
                    OneOf([
                        RandomContrast(),
                        RandomBrightness(),
                    ]),
                    #Blur(),
                    #GaussNoise()
                ],
                p=0.5),
            HueSaturationValue(p=0.5)
        ],
        p=prob)
def strong_aug(p=0.5):
    return Compose([
        RandomRotate90(),
        Flip(),
        Transpose(),
        OneOf([
            IAAAdditiveGaussianNoise(),
            GaussNoise(),
        ], p=0.2),
        OneOf([
            MotionBlur(p=0.2),
            MedianBlur(blur_limit=3, p=0.1),
            Blur(blur_limit=3, p=0.1),
        ], p=0.2),
        ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
        OneOf([
            OpticalDistortion(p=0.3),
            GridDistortion(p=0.1),
            IAAPiecewiseAffine(p=0.3),
        ], p=0.2),
        OneOf([
            CLAHE(clip_limit=2),
            IAASharpen(),
            IAAEmboss(),
            RandomBrightnessContrast(),
        ], p=0.3),
        HueSaturationValue(p=0.3),
    ], p=p)
Ejemplo n.º 8
0
    def train_aug(self, image, label):
        aug = Compose(
            [
                OneOf(
                    [CLAHE(), IAASharpen(), IAAEmboss()], p=0.5),
                # OneOf([IAAAdditiveGaussianNoise(), GaussNoise()], p=0.2),
                # OneOf([MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1)], p=0.2),
                RandomContrast(),
                RandomBrightness(),
                # ChannelShuffle(),
                RandomRotate90(),
                Flip(),
                # RandomScale(scale_limit=(0.0, 0.1)),
                OneOf([
                    ElasticTransform(),
                    OpticalDistortion(),
                    GridDistortion(),
                    IAAPiecewiseAffine()
                ],
                      p=0.5),
                # HueSaturationValue(p=0.3),
            ],
            p=0.9)
        augmented = aug(image=image, mask=label)
        augmented = ToGray(p=1)(image=augmented['image'],
                                mask=augmented['mask'])
        augmented = RandomCrop(256, 256)(image=augmented['image'],
                                         mask=augmented['mask'])
        image, label = augmented['image'], augmented['mask']

        return image, label
    def get_input_pair(self, image_info):
        dataset_path = self.dataset_path
        img_path = os.path.join(dataset_path, image_info["dataset_folder"], self.images_folder,
                                image_info["name"] + '_' + image_info["position"] + '.' + self.image_type)
        mask_path = os.path.join(dataset_path, image_info["dataset_folder"], self.masks_folder,
                                 image_info["name"] + '_' + image_info["position"] + '.' + self.mask_type)

        img = Image.open(img_path)
        mask = Image.open(mask_path)

        img_array = np.array(img)
        mask_array = np.array(mask).astype(np.float32)

        aug = Compose([
            RandomCrop(224, 224),
            RandomRotate90(),
            Flip(),
            OneOf([
                RGBShift(),
                CLAHE(clip_limit=2)
            ], p=0.4),
            ToTensor()
        ], p=1)

        augmented = aug(image=img_array, mask=mask_array)

        augmented_img = augmented['image']
        augmented_mask = augmented['mask']

        augmented_mask = augmented_mask.squeeze().long()

        return {"features": augmented_img, "targets": augmented_mask}
Ejemplo n.º 10
0
    def get_input_pair(self, image_info):
        dataset_path = self.dataset_path
        img_path = os.path.join(
            dataset_path, image_info["dataset_folder"], self.images_folder,
            image_info["name"] + '_' + image_info["position"] + '.' +
            self.image_type)

        img = Image.open(img_path)

        img_array = np.array(img)

        augm = Compose([
            RandomCrop(224, 224),
            RandomRotate90(),
            Flip(),
            OneOf([RGBShift(), CLAHE(clip_limit=2)], p=0.4),
            ToTensor()
        ],
                       p=1)

        augmented = augm(image=img_array)

        augmented_img = augmented['image']

        return {"features": augmented_img, "targets": augmented_img}
Ejemplo n.º 11
0
def strong_aug(p=1):
    return Compose([
        ToFloat(),
        RandomRotate90(),
        Flip(),
        Transpose(),
        OneOf([
            IAAAdditiveGaussianNoise(),
            GaussNoise(),
        ], p=0.2),
        OneOf([
            MotionBlur(p=0.2),
            MedianBlur(blur_limit=3, p=0.1),
            Blur(blur_limit=3, p=0.1),
        ],
              p=0.2),
        ShiftScaleRotate(
            shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
        OneOf([
            OpticalDistortion(p=0.3),
            GridDistortion(p=0.1),
            IAAPiecewiseAffine(p=0.3),
        ],
              p=0.2),
        FromFloat(dtype='uint16', max_value=65535.0)
    ],
                   p=p)
Ejemplo n.º 12
0
def get_train_transforms():
    augmentations = Compose([
        Resize(236,236),
        Flip(),
        OneOf([
            IAAAdditiveGaussianNoise(p=.5),
            GaussNoise(p=.4),
        ], p=0.4),
        OneOf([
            MotionBlur(p=0.6),
            Blur(blur_limit=3, p=0.2),
        ], p=0.4),
        ShiftScaleRotate(shift_limit=0.0725, scale_limit=0.2, rotate_limit=45, p=0.6),
        OneOf([
            OpticalDistortion(p=0.3),
            GridDistortion(p=0.4),
            IAAPiecewiseAffine(p=0.2),
        ], p=0.3),
        OneOf([
            CLAHE(clip_limit=2),
            IAASharpen(),
            IAAEmboss(),
            RandomBrightnessContrast(),
        ], p=0.25),
        HueSaturationValue(p=0.3),
        CenterCrop(224,224),
        Normalize(
            mean=[0.485, 0.456, 0.406],
            std=[0.229, 0.224, 0.225]
        ),
        ToTensor()
    ])

    return lambda img:augmentations(image=np.array(img))
Ejemplo n.º 13
0
def Rotate_Crop(img, v):  # [-90, 90]
    assert -90 <= v <= 90
    if random.random() < 0.5:
        v = -v
    transform = Compose([Flip(), Rotate(limit=v, interpolation=2), CenterCrop(img.shape[1], img.shape[1])])
    Aug_img = transform(image=img)
    return Aug_img
Ejemplo n.º 14
0
def strong_aug(p=1.0):
    return Compose(
        [
            Flip(p=0.75),  # ok
            # RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.5),
            # RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=1.0, brightness_by_max=False),
            # # RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.5),
            # ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=45, border_mode=cv2.BORDER_CONSTANT, p=0.2),
            # OneOf([
            #     Blur(blur_limit=5, p=1.0),
            #     MedianBlur(blur_limit=5, p=1.0),
            #     MotionBlur(p=1.0),
            # ], p=0.2),
            # OneOf([
            #     HueSaturationValue(hue_shift_limit=10, sat_shift_limit=30, val_shift_limit=20, p=1.0),
            #     RGBShift(p=1.0)
            # ], p=0.1),
            # GaussNoise(p=0.1),

            # OneOf([
            #     GridDistortion(p=1.0),
            #     ElasticTransform(p=1.0)
            # ], p=0.2),
            # OneOf([
            #     CLAHE(p=1.0),
            #     IAASharpen(p=1.0),
            # ], p=0.2)
        ],
        p=p)
Ejemplo n.º 15
0
def get_transforms():
    return Compose([
        RandomRotate90(p=0.5),
        Flip(p=0.5),
        Transpose(p=0.5),
        # OneOf([
        #     IAAAdditiveGaussianNoise(),
        #     GaussNoise(),
        # ], p=0.2),
        # OneOf([
        #     MotionBlur(p=.2),
        #     MedianBlur(blur_limit=3, p=0.1),
        #     Blur(blur_limit=3, p=0.1),
        # ], p=0.2),
        ShiftScaleRotate(shift_limit=0.0625,
                         scale_limit=0.2,
                         rotate_limit=45,
                         p=0.2),
        # OneOf([
        #     CLAHE(clip_limit=2),
        #     IAASharpen(),
        #     IAAEmboss(),
        #     RandomBrightnessContrast(),
        # ], p=0.3),
        HueSaturationValue(p=0.3),
    ])
Ejemplo n.º 16
0
 def build_train(self):
     return Compose([
         RandomCrop(self.H, 416),
         Flip(p=0.5),
         Normalize(mean=self.MEAN, std=self.STD),
         ToTensor(),
     ])
def alb_transform_train(imsize = 256, p=1):
    albumentations_transform = Compose([
    # RandomCrop(imsize),
    # RandomRotate90(),
    Flip(),
    # Transpose(),
    OneOf([
            IAAAdditiveGaussianNoise(),
            GaussNoise(),
        ], p=0.2),
    OneOf([
            MotionBlur(p=.2),
            MedianBlur(blur_limit=3, p=.1),
            Blur(blur_limit=3, p=.1),
        ], p=0.2),
    ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2),
    OneOf([
        OpticalDistortion(p=0.3),
        GridDistortion(p=.1),
        IAAPiecewiseAffine(p=0.3),
        ], p=0.2),
    OneOf([
        # CLAHE(clip_limit=2),
        IAASharpen(),
        IAAEmboss(),
        RandomContrast(),
        RandomBrightness(),
        ], p=0.3),
    Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
        )
    ], p=p)
    return albumentations_transform
Ejemplo n.º 18
0
def transform(config, image, mask):

    try:
        p = config["train"]["dap"]["p"]
    except:
        p = 1

    assert 0 <= p <= 1

    # Inspire by: https://albumentations.readthedocs.io/en/latest/examples.html
    return Compose([
        Flip(),
        Transpose(),
        OneOf([IAAAdditiveGaussianNoise(),
               GaussNoise()], p=0.2),
        OneOf([
            MotionBlur(p=0.2),
            MedianBlur(blur_limit=3, p=0.1),
            Blur(blur_limit=3, p=0.1)
        ],
              p=0.2),
        ShiftScaleRotate(shift_limit=0.0625,
                         scale_limit=0.2,
                         rotate_limit=45,
                         p=0.2),
        OneOf([IAASharpen(),
               IAAEmboss(),
               RandomBrightnessContrast()], p=0.3),
        HueSaturationValue(p=0.3),
    ])(image=image, mask=mask, p=p)
def strong_aug(p=1):
    return Compose([
        RandomRotate90(),
        Flip(),
        Transpose(),
        OneOf([
            IAAAdditiveGaussianNoise(),
            GaussNoise(),
        ], p=0.2),
        OneOf([
            MotionBlur(p=0.2),
            MedianBlur(blur_limit=3, p=0.1),
            Blur(blur_limit=3, p=0.1),
        ],
              p=0.2),
        OneOf([
            CLAHE(clip_limit=2),
            IAASharpen(),
            IAAEmboss(),
            RandomBrightnessContrast(),
        ],
              p=0.3),
        HueSaturationValue(p=0.3),
    ],
                   p=p)
    def gettraintransforms(self, mean, std, p=1):
        # Train Phase transformations

        albumentations_transform = Compose([
            # RandomRotate90(),
            PadIfNeeded(72, 72, border_mode=cv2.BORDER_REFLECT, always_apply=True),
            RandomCrop(64, 64, True),
            Flip(),
            GaussNoise(p=0.8, mean=mean),
            OneOf([
                MotionBlur(p=0.4),
                MedianBlur(blur_limit=3, p=0.2),
                Blur(blur_limit=3, p=0.2),
            ], p=0.4),
            ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.6),
            OneOf([
                OpticalDistortion(p=0.8),
                GridDistortion(p=0.4),
            ], p=0.6),
            HueSaturationValue(hue_shift_limit=20, sat_shift_limit=0.1, val_shift_limit=0.1, p=0.6),
            CoarseDropout(always_apply=True, max_holes=1, min_holes=1, max_height=16, max_width=16,
                          fill_value=(255 * .6), min_height=16, min_width=16),
            Normalize(mean=mean, std=std, always_apply=True),
            pytorch.ToTensorV2(always_apply=True),

        ], p=p)

        return albumentations_transform;
Ejemplo n.º 21
0
def strong_aug(p=1):
    return Compose([
        OneOf([
            RandomRotate90(p=1),
            Flip(p=1),
        ], p=1),
        ShiftScaleRotate(shift_limit=0.1,
                         scale_limit=0.1,
                         rotate_limit=45,
                         p=1,
                         value=0,
                         border_mode=2),
        OneOf([
            IAAAdditiveGaussianNoise(p=0.7),
            GaussNoise(p=0.7),
        ], p=1),
        OneOf([
            MotionBlur(p=0.7),
            MedianBlur(blur_limit=3, p=0.7),
            Blur(blur_limit=3, p=0.7),
        ],
              p=1),
        RandomBrightnessContrast(p=0.5),
        OneOf([
            CLAHE(clip_limit=2),
            IAASharpen(),
            IAAEmboss(),
            RandomBrightnessContrast(p=0.7),
        ],
              p=1)
    ],
                   p=p)
Ejemplo n.º 22
0
    def gettraintransforms(self, mean, std, p=1):
        # Train Phase transformations

        albumentations_transform = Compose([
            RandomRotate90(),
            Flip(),
            GaussNoise(p=0.6, mean=mean),
            OneOf([
                MotionBlur(p=0.2),
                MedianBlur(blur_limit=3, p=0.1),
                Blur(blur_limit=3, p=0.1),
            ],
                  p=0.2),
            ShiftScaleRotate(
                shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.3),
            OneOf([
                OpticalDistortion(p=0.4),
                GridDistortion(p=0.2),
            ], p=0.3),
            HueSaturationValue(hue_shift_limit=20,
                               sat_shift_limit=0.1,
                               val_shift_limit=0.1,
                               p=0.3),
            Cutout(always_apply=True,
                   num_holes=2,
                   max_h_size=10,
                   max_w_size=10,
                   fill_value=(255 * .6)),
            Normalize(mean=mean, std=std, always_apply=True),
            pytorch.ToTensorV2(always_apply=True),
        ],
                                           p=p)

        return albumentations_transform
Ejemplo n.º 23
0
def aug_daniel_prepadded(prob=1.0, image_size=448):
	return Compose([
		RandomRotate90(p=0.5),
		Transpose(p=0.5),
		Flip(p=0.5),
		OneOf([
			RandomCrop(height=image_size, width=image_size, p=0.3),
			Compose([
				#3.94 determined by largest angle possible rotatable without introducing nodata pixels into center crop area
				ShiftScaleRotate(shift_limit=0.0, scale_limit=0.0, rotate_limit=6, border_mode=cv2.BORDER_CONSTANT, p=1.0),
				CenterCrop(height=int(round(236/224*image_size)), width=int(round(236/224*image_size)), p=1.0),
				RandomCrop(height=image_size, width=image_size, p=1.0)
			], p=0.4),
			Compose([
				#3.94 determined by largest angle possible rotatable without introducing nodata pixels into center crop area
				ShiftScaleRotate(shift_limit=0.0, scale_limit=0.0, rotate_limit=12, border_mode=cv2.BORDER_CONSTANT, p=1.0),
				CenterCrop(height=image_size, width=image_size, p=1.0)
			], p=0.3)
		], p=1.0),
		#OneOf([
			#IAASharpen(),
			#IAAEmboss(),
#			RandomBrightnessContrast(brightness_limit=0.01, contrast_limit=0.01) # This causes a blackout for some reason
			#Blur(),
			#GaussNoise()
		#], p=0.5),
		IAASharpen(p=0.2),
		IAAAdditiveGaussianNoise(p=0.2),
#		HueSaturationValue(p=0.3)
		#ShiftScaleRotate(shift_limit=0.0, scale_limit=0.0, rotate_limit=2, border_mode=cv2.BORDER_CONSTANT, p=.75),
		#ChannelShuffle(p=0.33)
	], p=prob)
Ejemplo n.º 24
0
def strong_aug2(p=1.0):
    return Compose(
        [
            Flip(p=0.75),  # ok
            # RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.5),
            RandomBrightnessContrast(brightness_limit=(-0.2, 0.2),
                                     contrast_limit=0.2,
                                     p=1.0,
                                     brightness_by_max=False),
            ShiftScaleRotate(shift_limit=0.1,
                             scale_limit=0.2,
                             rotate_limit=45,
                             border_mode=cv2.BORDER_CONSTANT,
                             p=0.2),
            OneOf([
                IAASharpen(p=1),
                Blur(blur_limit=5, p=1.0),
                MedianBlur(blur_limit=5, p=1.0),
                MotionBlur(p=1.0),
            ],
                  p=0.6),
            OneOf([
                HueSaturationValue(hue_shift_limit=10,
                                   sat_shift_limit=30,
                                   val_shift_limit=20,
                                   p=1.0),
                RGBShift(p=1.0),
                RandomGamma(p=1),
            ],
                  p=0.3),
            IAAAdditiveGaussianNoise(p=.2),
        ],
        p=p)
Ejemplo n.º 25
0
def train_aggressive_transform(from_dicom: bool, longest_max_size: int) -> Compose:
    additional_transforms = [
        Flip(),
        RandomRotate90(),
        RandomBrightnessContrast(),
        GaussNoise(),
    ]
    return train_transform(from_dicom, longest_max_size, additional_transforms)
 def _albumentations_strong_aug() -> Compose:
     return Compose([
         ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1,
                          rotate_limit=20),
         Flip(),
         # ElasticTransform(alpha=720, sigma=24, approximate=False),
         # RandomBrightnessContrast(),
     ])
Ejemplo n.º 27
0
 def build_train(self):
     return Compose([
         CropNonEmptyMaskIfExists(self.H, self.H),
         Flip(p=0.5),
         RandomRotate90(p=0.5),
         Normalize(mean=self.MEAN, std=self.STD),
         ToTensor(),
     ])
Ejemplo n.º 28
0
def aug4(p=1.0):
    return Compose([
        Flip(p=0.75),
        ShiftScaleRotate(
            rotate_limit=0, border_mode=cv2.BORDER_CONSTANT, p=0.3),
        GaussianBlur(blur_limit=3, p=0.3),
    ],
                   p=p)
Ejemplo n.º 29
0
def strong_aug(p=0.5, crop_size=(512, 512)):
    return Compose([
        RandomResizedCrop(crop_size[0],
                          crop_size[1],
                          scale=(0.3, 1.0),
                          ratio=(0.75, 1.3),
                          interpolation=4,
                          p=1.0),
        RandomRotate90(),
        Flip(),
        Transpose(),
        OneOf([
            IAAAdditiveGaussianNoise(),
            GaussNoise(),
        ], p=0.8),
        OneOf([
            MotionBlur(p=0.5),
            MedianBlur(blur_limit=3, p=0.5),
            Blur(blur_limit=3, p=0.5),
        ],
              p=0.3),
        ShiftScaleRotate(
            shift_limit=0.2, scale_limit=0.5, rotate_limit=180, p=0.8),
        OneOf([
            OpticalDistortion(p=0.5),
            GridDistortion(p=0.5),
            IAAPiecewiseAffine(p=0.5),
            ElasticTransform(p=0.5),
        ],
              p=0.3),
        OneOf([
            CLAHE(clip_limit=2),
            IAASharpen(),
            IAAEmboss(),
            RandomBrightnessContrast(),
        ],
              p=0.3),
        OneOf([
            GaussNoise(),
            RandomRain(
                p=0.2, brightness_coefficient=0.9, drop_width=1, blur_value=5),
            RandomSnow(p=0.4,
                       brightness_coeff=0.5,
                       snow_point_lower=0.1,
                       snow_point_upper=0.3),
            RandomShadow(p=0.2,
                         num_shadows_lower=1,
                         num_shadows_upper=1,
                         shadow_dimension=5,
                         shadow_roi=(0, 0.5, 1, 1)),
            RandomFog(
                p=0.5, fog_coef_lower=0.3, fog_coef_upper=0.5, alpha_coef=0.1)
        ],
              p=0.3),
        RGBShift(),
        HueSaturationValue(p=0.9),
    ],
                   p=p)
Ejemplo n.º 30
0
 def __init__(self, size, root, phase):
     if phase == 'train':
         self.data_list = open(os.path.join(root, 'train.txt'), 'r').readlines()
         self.transform = Compose([Flip(),
                                   RandomResizedCrop(width=size, height=size, scale=(0.8, 1.2)),
                                   ])
     else:
         self.data_list = open(os.path.join(root, 'valid.txt'), 'r').readlines()
         self.transform = Compose([Resize(width=size, height=size)])