def setup(self, stage=None): self.train_transform = A.Compose( [ A.Resize(width=416, height=416), A.ShiftScaleRotate(shift_limit=0.2, scale_limit=0.2, rotate_limit=0), ToTensor(), ], bbox_params=A.BboxParams(format="yolo", label_fields=["class_labels"]), ) self.test_transform = A.Compose( [A.Resize(width=416, height=416), ToTensor()], bbox_params=A.BboxParams(format="yolo", label_fields=["class_labels"]), ) if stage == "fit" or stage is None: train_files = [BASE_PATH / "train2017.txt"] val_files = [BASE_PATH / "val2017.txt"] # self.train_dataset = COCODataset(train_files, "train2017", transform=self.test_transform) self.train_dataset = COCODataset( val_files, "val2017", transform=self.test_transform ) self.val_dataset = COCODataset( val_files, "val2017", transform=self.test_transform ) if stage == "test": test_files = [BASE_PATH / "val2017.txt"] self.test_dataset = COCODataset( test_files, "val2017", transform=self.test_transform )
def get_augmentations(p=0.5, image_size=224): imagenet_stats = { "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225] } train_tfms = A.Compose([ # A.Resize(image_size, image_size), A.RandomResizedCrop(image_size, image_size), A.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.4, rotate_limit=45, p=p), A.Cutout(p=p), A.RandomRotate90(p=p), A.Flip(p=p), A.OneOf( [ A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, ), A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50), ], p=p, ), A.OneOf( [ A.IAAAdditiveGaussianNoise(), A.GaussNoise(), ], p=p, ), A.CoarseDropout(max_holes=10, p=p), A.OneOf( [ A.MotionBlur(p=0.2), A.MedianBlur(blur_limit=3, p=0.1), A.Blur(blur_limit=3, p=0.1), ], p=p, ), A.OneOf( [ A.OpticalDistortion(p=0.3), A.GridDistortion(p=0.1), A.IAAPiecewiseAffine(p=0.3), ], p=p, ), ToTensor(normalize=imagenet_stats), ]) valid_tfms = A.Compose([ A.CenterCrop(image_size, image_size), ToTensor(normalize=imagenet_stats) ]) return train_tfms, valid_tfms
def setup(self, stage=None): BASE_PATH = pathify(configs.BASE_DIR) self.train_transform = A.Compose( [ A.Resize(width=448, height=448), A.ShiftScaleRotate( shift_limit=0.2, scale_limit=0.2, rotate_limit=0), ToTensor(), ], bbox_params=A.BboxParams(format="yolo", label_fields=["class_labels"]), ) self.test_transform = A.Compose( [A.Resize(width=448, height=448), ToTensor()], bbox_params=A.BboxParams(format="yolo", label_fields=["class_labels"]), ) if stage == "fit" or stage is None: train_files = [ BASE_PATH / "2007_train.txt", BASE_PATH / "2012_train.txt" ] val_files = [ BASE_PATH / "2007_val.txt", BASE_PATH / "2012_val.txt" ] self.train_dataset = VOCDataset(train_files, transform=self.train_transform) self.val_dataset = VOCDataset(val_files, transform=self.test_transform) if stage == "test": test_files = [BASE_PATH / "2007_test.txt"] self.test_dataset = VOCDataset(test_files, transform=self.test_transform)
def __init__( self, in_channels=3, architecture=None, split_size=7, num_boxes=2, num_classes=20, ): super(YoloV1Model, self).__init__() self.in_channels = in_channels self.darknet = self._create_conv(architecture) self.fcs = self._create_fcs(split_size, num_boxes, num_classes) self.train_transform = A.Compose( [ A.Resize(width=448, height=448), A.ShiftScaleRotate( shift_limit=0.2, scale_limit=0.2, rotate_limit=0), ToTensor(), ], bbox_params=A.BboxParams(format="yolo", label_fields=["class_labels"]), ) self.test_transform = A.Compose( [A.Resize(width=448, height=448), ToTensor()], bbox_params=A.BboxParams(format="yolo", label_fields=["class_labels"]), )
def get_transform(mode='train', H=384, W=576): if mode == 'train': transform = A.Compose([ A.Flip(p=.5), A.OneOf([ A.CLAHE(clip_limit=2, p=.5), A.IAASharpen(p=.25), ], p=.35), A.OneOf( [A.RandomBrightness(), A.RandomContrast(), A.RandomGamma()], p=.3), A.OneOf([ A.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), A.GridDistortion(), A.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=.3), A.ShiftScaleRotate(scale_limit=0.2, rotate_limit=0, shift_limit=0, border_mode=0, p=.5), A.CropNonEmptyMaskIfExists(height=int(1400 * .9), width=int(2100 * .9), p=.5), A.Resize(H, W), ToTensor() ]) else: transform = A.Compose([A.Resize(352, 544), ToTensor()]) return transform
def get_transforms(phase, width=1600, height=256): list_transforms = [] if phase == "train": list_transforms.extend([ albu.HorizontalFlip(), albu.OneOf([ albu.RandomContrast(), albu.RandomGamma(), albu.RandomBrightness(), ], p=0.3), albu.OneOf([ albu.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), albu.GridDistortion(), albu.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), albu.ShiftScaleRotate(), ]) list_transforms.extend([ albu.Resize(width, height, always_apply=True), albu.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1), ToTensor(), ]) list_trfms = albu.Compose(list_transforms) return list_trfms
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}
def get_train_transform(img_size): train_transform = A.Compose([ A.Resize(img_size, img_size), A.Transpose(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5), A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255.0, p=1.0), A.CoarseDropout(p=0.5), A.Cutout(p=0.5), ToTensor() ]) return train_transform
def make_data(data_folder: str, mode: str, transform: dict, num_workers: int, batch_size: int, fold: str = None, folds_path: str = None, positive_ratio_range: Tuple[float, float] = (0.3, 0.8), epochs: int = 50): img_filenames, mask_filenames, non_emptiness = make_filenames( data_folder=data_folder, mode=mode, fold=fold, folds_path=folds_path) _transform = A.load(transform[mode], 'yaml') _transform.transforms = _transform.transforms + [ToTensor()] dataset = PneumothoraxDataset(img_filenames=img_filenames, mask_filenames=mask_filenames, transform=_transform, non_emptiness=non_emptiness) sampler = EmptySampler(data_source=dataset, positive_ratio_range=positive_ratio_range, epochs=epochs) loader = make_data_loader(dataset=dataset, sampler=sampler if mode == 'train' else None, batch_size=batch_size, num_workers=num_workers) return loader
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}
def __init__(self, detect_path='weights/best-checkpoint.bin', model_arc='weights/model_eff_arc.json', weights='weights/model_best_acc.h5'): #clf super().__init__() with open(model_arc, 'r') as f: self.model = tf.keras.models.model_from_json(f.read()) self.model.load_weights(weights) self.mapper = [ 'TH', 'ACB', 'Acecook', 'Addidas', 'Agribank', 'Bidv', 'Big C', 'Cai Lan', 'Chinsu', 'Colgate', 'FPT', 'Habeco', 'Hai Ha', 'Jollibee', 'KFC', 'Kinh Do', 'Lotte mart', 'Mbbank new', 'Mbbank old', 'Neptune', 'Nike', 'Pepsi', 'Petrolimex', 'Phuc Long', 'Samsung', 'SHB', 'Techcombank', 'The Coffe House', 'The gioi di dong', 'TPbank', 'Vietcombank', 'Vietinbank', 'Viettel', 'Vinamilk', 'Vinfast', 'Vinmart', 'Vifon', 'Vnpt', 'Vpbank' ] #detect self.transform = A.Compose([ A.Resize(height=512, width=512, p=1.0), ToTensor(), ]) self.load_detect(detect_path)
def get_train_transform(self): transforms = [] if self.transforms is None else self.transforms return A.Compose(transforms + [ToTensor()], bbox_params={ 'format': 'pascal_voc', 'label_fields': ['labels'] })
def __init__(self,phase='train',datalabel='', resize=(320,320),imgs_per_video=30,min_frames=0,\ normalize=dict(mean=[0.5,0.5,0.5],std=[0.5,0.5,0.5]),frame_interval=10,max_frames=300,augment='augment0'): assert phase in ['train', 'val', 'test'] self.datalabel = datalabel self.phase = phase self.imgs_per_video = imgs_per_video self.frame_interval = frame_interval self.num_classes = 2 self.epoch = 0 self.max_frames = max_frames if min_frames: self.min_frames = min_frames else: self.min_frames = max_frames * 0.3 self.dataset = [] self.aug = augmentations[augment] resize_ = (int(resize[0] / 0.8), int(resize[1] / 0.8)) self.resize = resize #Resize(*resize_,interpolation=cv2.INTER_CUBIC), self.trans = Compose( [CenterCrop(*resize), ToTensor(normalize=normalize)]) ############### # doing resize and center crop in trans if type(datalabel) != str: self.dataset = datalabel return if 'ff-5' in self.datalabel: for i, j in enumerate([ 'Origin', 'Deepfakes', 'NeuralTextures', 'FaceSwap', 'Face2Face' ]): temp = FF_dataset(j, self.datalabel.split('-')[2], phase) temp = [[k[0], i] for k in temp] self.dataset += temp elif 'ff-all' in self.datalabel: for i in [ 'Origin', 'Deepfakes', 'NeuralTextures', 'FaceSwap', 'Face2Face' ]: self.dataset += FF_dataset(i, self.datalabel.split('-')[2], phase) if phase != 'test': self.dataset = make_balance(self.dataset) elif 'ff' in self.datalabel: self.dataset += FF_dataset( self.datalabel.split('-')[1], self.datalabel.split('-')[2], phase) + FF_dataset( "Origin", self.datalabel.split('-')[2], phase) elif 'celeb' in self.datalabel: self.dataset = Celeb_test elif 'deeper' in self.datalabel: self.dataset = deeperforensics_dataset(phase) + FF_dataset( 'Origin', self.datalabel.split('-')[1], phase) elif 'dfdc' in self.datalabel: self.dataset = dfdc_dataset(phase) else: raise (Exception('no such datset'))
def get_transforms(img_size): train_transform = A.Compose([ A.Resize(img_size, img_size), A.HorizontalFlip(), A.VerticalFlip(), A.ShiftScaleRotate(), A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ToTensor() ]) test_transform = A.Compose([ A.Resize(img_size, img_size), A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ToTensor() ]) return train_transform, test_transform
def get_validation_tfms(dataset_normalize_stats): size = getModelInputSize() return A.Compose( [ A.Resize(size[0], size[1]), ToTensor(dataset_normalize_stats), ]) #--------------------------------------
def __init__(self, detect_path): super().__init__() #detect self.transform = A.Compose([ A.Resize(height=384, width=384, p=1.0), ToTensor(), ]) self.load_detect(detect_path)
def __init__(self, filelist, train_transforms=None, blur_mask=False): self.blur_mask = blur_mask self.filelist = filelist transform_list = [albu.Normalize(), ToTensor()] if train_transforms: #train_transforms = [albu.VerticalFlip(), albu.HorizontalFlip(), albu.ShiftScaleRotate()] transform_list = train_transforms + transform_list self.augs = albu.Compose(transform_list)
def __init__(self, folder, img_size=512): self.root = folder self.to_tensor = ToTensor() df = pd.read_csv('../dataset/train_folds_5.csv') self.image_name_list = df[df['exist_labels'] == 1]['fname'].to_list() self.img_size = img_size print("number of sample: ", self.__len__())
def get_transforms2(phase): list_transforms = [] list_transforms.extend([ HorizontalFlip(p=1), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1), ToTensor(), ]) list_trfms = Compose(list_transforms) return list_trfms
def get_valid_transform(img_size): # constants from imagenet data test_transform = A.Compose([ A.Resize(img_size, img_size), A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ToTensor() ]) return test_transform
def test_torch_to_tensor_raises_runtime_error(): with pytest.raises(RuntimeError) as exc_info: aug = ToTensor() # noqa F841 message = ( "`ToTensor` is obsolete and it was removed from Albumentations. Please use `ToTensorV2` instead - " "https://albumentations.ai/docs/api_reference/pytorch/transforms/" "#albumentations.pytorch.transforms.ToTensorV2. " "\n\nIf you need `ToTensor` downgrade Albumentations to version 0.5.2." ) assert str(exc_info.value) == message
def get_input_pair(self, data_info_row): if len(self.channels) == 0: raise Exception('You have to specify at least one channel.') instance_name = '_'.join( [data_info_row['name'], str(data_info_row['position'])]) image_path = get_filepath(self.dataset_path, data_info_row['name'], self.images_folder, instance_name, file_type=self.image_type) mask_path = get_filepath(self.dataset_path, data_info_row['name'], self.masks_folder, instance_name, file_type=self.mask_type) images_array = filter_by_channels(read_tensor(image_path), self.channels, self.neighbours) if images_array.ndim == 2: images_array = np.expand_dims(images_array, -1) masks_array = read_tensor(mask_path) aug = Compose([ RandomRotate90(), Flip(), OneOf( [ RandomSizedCrop(min_max_height=(int( self.image_size * 0.7), self.image_size), height=self.image_size, width=self.image_size), RandomBrightnessContrast(brightness_limit=0.15, contrast_limit=0.15), #MedianBlur(blur_limit=3, p=0.2), MaskDropout(p=0.6), ElasticTransform(alpha=15, sigma=5, alpha_affine=5), GridDistortion(p=0.6) ], p=0.8), ToTensor() ]) augmented = aug(image=images_array, mask=masks_array) augmented_images = augmented['image'] augmented_masks = augmented['mask'] if self.classification_head: masks_class = ((augmented_masks.sum() > 0) * 1).unsqueeze(-1).float() #.type(torch.FloatTensor) return augmented_images, [augmented_masks, masks_class] else: return {'features': augmented_images, 'targets': augmented_masks}
def get_input_pair(self, data_info_row): if len(self.channels) == 0: raise Exception('You have to specify at least one channel.') instance_name = '_'.join( [data_info_row['name'], data_info_row['position']]) image_path = get_filepath(self.dataset_path, data_info_row['dataset_folder'], self.images_folder, instance_name, file_type=self.image_type) mask_path = get_filepath(self.dataset_path, data_info_row['dataset_folder'], self.masks_folder, instance_name, file_type=self.mask_type) images_array = filter_by_channels(read_tensor(image_path), self.channels) if images_array.ndim == 2: images_array = np.expand_dims(images_array, -1) masks_array = read_tensor(mask_path) if self.channels[0] == 'rgb': rgb_tensor = images_array[:, :, :3].astype(np.uint8) rgb_aug = Compose( [OneOf([RGBShift(), CLAHE(clip_limit=2)], p=0.4)], p=0.9) augmented_rgb = rgb_aug(image=rgb_tensor, mask=masks_array) images_array = np.concatenate( [augmented_rgb['image'], images_array[:, :, 3:]], axis=2) masks_array = augmented_rgb['mask'] aug = Compose([ RandomRotate90(), Flip(), OneOf([ RandomSizedCrop(min_max_height=(int( self.image_size * 0.7), self.image_size), height=self.image_size, width=self.image_size) ], p=0.4), ToTensor() ]) augmented = aug(image=images_array, mask=masks_array) augmented_images = augmented['image'] augmented_masks = augmented['mask'] return {'features': augmented_images, 'targets': augmented_masks}
def complex_preprocess(normalize = normalize): return A.Compose([A.Cutout(num_holes=8, max_h_size=3, max_w_size=3, p=0.3), A.ShiftScaleRotate(shift_limit=(-0.05, 0.05), scale_limit=(0, .01), rotate_limit=45, border_mode=0), A.HorizontalFlip(), A.RandomGamma((40, 120)), A.GaussNoise(var_limit=0.01), A.RandomContrast((-0.2, 0.2)), ToTensor(normalize=normalize) ])
def get_augumentation(phase, width=512, height=512, min_area=0., min_visibility=0.): list_transforms = [] if phase == 'train': list_transforms.extend([ albu.augmentations.transforms.LongestMaxSize(max_size=width, always_apply=True), albu.PadIfNeeded(min_height=height, min_width=width, always_apply=True, border_mode=0, value=[0, 0, 0]), albu.augmentations.transforms.RandomResizedCrop(height=height, width=width, p=0.3), albu.augmentations.transforms.Flip(), albu.augmentations.transforms.Transpose(), albu.OneOf([ albu.RandomBrightnessContrast(brightness_limit=0.5, contrast_limit=0.4), albu.RandomGamma(gamma_limit=(50, 150)), albu.NoOp() ]), albu.OneOf([ albu.RGBShift(r_shift_limit=20, b_shift_limit=15, g_shift_limit=15), albu.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=5), albu.NoOp() ]), albu.CLAHE(p=0.8), albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), ]) if (phase == 'test' or phase == 'valid'): list_transforms.extend([albu.Resize(height=height, width=width)]) list_transforms.extend([ albu.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1), ToTensor() ]) if (phase == 'test'): return albu.Compose(list_transforms) return albu.Compose(list_transforms, bbox_params=albu.BboxParams( format='pascal_voc', min_area=min_area, min_visibility=min_visibility, label_fields=['category_id']))
def get_transforms(phase): list_transforms = [] if phase == "train": list_transforms.extend([ HorizontalFlip(p=0.5), # only horizontal flip as of now ]) list_transforms.extend([ Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1), ToTensor(), ]) list_trfms = Compose(list_transforms) return list_trfms
def __init__(self, data_folder, mode, transform=None, folder_index=None, folds_distr_path=None): self.transform = transform self.mode = mode self.train_image_path = os.path.join(data_folder, 'train') self.train_mask_path = os.path.join(data_folder, 'mask') self.test_image_path = os.path.join(data_folder, 'test') self.fold_index = None self.folds_distr_path = folds_distr_path self.set_mode(mode, folder_index) self.to_tensor = ToTensor()
def get_training_tfms(dataset_normalize_stats): size = getModelInputSize() return A.Compose([ A.Resize(size[0], size[1]), A.RandomRotate90(p=0.5), A.Flip(p=0.5), A.ColorJitter(p=0.5), A.RandomGamma(p=0.5), A.RandomContrast(p=0.3), A.RandomBrightness(p=0.5), ToTensor(dataset_normalize_stats), ])
def __init__(self): self.transforms = Compose([ PadIfNeeded(40, 40), RandomCrop(32, 32), HorizontalFlip(p=.5), Cutout(8, 8), Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010), max_pixel_value=255.0, always_apply=True, p=1.0), ToTensor() ])
def load_references(content, style, h, w): C_orig = plt.imread(content) S_orig = plt.imread(style) transform = albumentations.Compose([ albumentations.Resize(h, w, always_apply=True), albumentations.Normalize(always_apply=True), ToTensor(), ]) C = transform(image=C_orig)["image"].unsqueeze(0) S = transform(image=S_orig)["image"].unsqueeze(0) return C, S