#pip install git+https://github.com/albumentations-team/albumentations import albumentations as A from albumentations.pytorch import ToTensorV2 import cv2 as cv train_transforms = A.Compose([ A.HorizontalFlip(p=0.3), A.RandomBrightnessContrast(p=0.1), A.OneOf( [ A.ShiftScaleRotate( rotate_limit=18, p=1, border_mode=cv.BORDER_CONSTANT), A.IAAAffine(shear=10, p=1, mode="constant"), #A.Perspective(scale=(0.05, 0.15), keep_size=True, pad_mode=0, pad_val=0, # mask_pad_val=0, fit_output=False, interpolation=1, always_apply=False, p=1), ], p=1.0, ), A.OneOf( [ A.FancyPCA(alpha=0.1, always_apply=False, p=1), A.Blur(p=1), A.ToGray(p=0.8), A.ColorJitter( brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1, p=1), A.ChannelDropout((1, 1), fill_value=0, always_apply=False, p=1), ], p=0.3, ), A.OneOf( [ #A.GaussNoise (var_limit=(10.0, 50.0), mean=0, per_channel=True, always_apply=False, p=0.5),
def augmentation_train(): train_transform = [ albu.HorizontalFlip(p=0.5), albu.VerticalFlip(p=0.5), albu.OneOf([ albu.InvertImg(p=0.5), albu.RandomBrightnessContrast(brightness_limit=(-0.5, 0.3), contrast_limit=(-0.5, 0.3), brightness_by_max=False, p=0.5), albu.RandomGamma(gamma_limit=(50, 120), p=.5), albu.RandomToneCurve(scale=0.4, p=.5), albu.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=20, val_shift_limit=20, p=.5), albu.ChannelShuffle(p=.5), albu.RGBShift( r_shift_limit=20, g_shift_limit=20, b_shift_limit=20, p=.5), ], p=0.5), albu.OneOf([ albu.RandomFog( fog_coef_lower=0.1, fog_coef_upper=.4, alpha_coef=0.06, p=0.5), albu.MotionBlur(blur_limit=7, p=0.5), albu.MedianBlur(blur_limit=7, p=0.5), albu.GlassBlur(sigma=0.5, max_delta=2, p=0.5), albu.Sharpen(alpha=(0.1, 0.3), lightness=(0.7, 1.1), p=0.5) ], p=0.5), albu.OneOf([ albu.GaussNoise(var_limit=0.03, mean=0, p=0.5), albu.MultiplicativeNoise(multiplier=(0.98, 1.02), p=0.5), albu.ISONoise( color_shift=(0.01, 0.02), intensity=(0.1, 0.3), p=0.5), ], p=0.3), albu.OneOf([ albu.ElasticTransform(border_mode=cv2.BORDER_CONSTANT, interpolation=cv2.INTER_CUBIC, alpha=1, sigma=50, alpha_affine=50, p=0.5), albu.GridDistortion(border_mode=cv2.BORDER_CONSTANT, interpolation=cv2.INTER_CUBIC, distort_limit=(-0.3, 0.3), num_steps=5, p=0.5), albu.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT, interpolation=cv2.INTER_CUBIC, distort_limit=(-.05, .05), shift_limit=(-0.05, 0.05), p=0.5), albu.ShiftScaleRotate(border_mode=cv2.BORDER_CONSTANT, interpolation=cv2.INTER_CUBIC, shift_limit=(0.05, 0.02), scale_limit=(-.1, 0), rotate_limit=2, p=0.5), ], p=0.5), ] return albu.Compose(train_transform)
import warnings warnings.filterwarnings("ignore") from classification_models.resnet.models import ResNet18 import albumentations as A MODEL_PATH = 'Christof/models/GAPNet/11_ext_h/' exp_suffix = '_0' SIZE = 512 # Load dataset info path_to_train = 'Christof/assets/train_rgb_512/' data = pd.read_csv('Christof/assets/train.csv') normal_aug = A.Compose([A.Rotate((0,30),p=0.75), A.RandomRotate90(p=1), A.HorizontalFlip(p=0.5), #A.RandomBrightness(0.05), #A.RandomContrast(0.05), A.IAAAffine(translate_percent=10,rotate=45,shear=10, scale=(0.9,1.1)), #A.RandomAffine(degrees=45, translate=(0.1,0.1), shear=10, scale=(0.9,1.1)) A.Normalize(mean=(0.08069, 0.05258, 0.05487), std=(0.1300, 0.0879, 0.1386), max_pixel_value=255.) ]) normal_aug_ext = A.Compose([A.Rotate((0,30),p=0.75), A.RandomRotate90(p=1), A.HorizontalFlip(p=0.5), #A.RandomBrightness(0.05), #A.RandomContrast(0.05), A.IAAAffine(translate_percent=10,rotate=45,shear=10, scale=(0.9,1.1)), #A.RandomAffine(degrees=45, translate=(0.1,0.1), shear=10, scale=(0.9,1.1))
class Args: ############################## ###### Hyperparameters ####### ############################## epochs = 30 # DEFAULT 30 (int 1-99) batch_size = 16 # DEFAULT 16 (int) weight_decay = 1e-4 # DEFAULT 0 (float) arch = "inceptionv4" # DEFAULT resnet152 (resnet50 | resnet152 | senet154 | inceptionv4) initial_lr = 1e-5 # DEFAULT 1e-5 (float) lr_schedule = None # DEFAULT None (None | poly | exp | step | multistep | cosine) lr_schedule_params = { # DEFAULT {} (dict) } img_size = None # DEFAULT None (None | int 224-1024) full_size = False # DEFAULT False (bool) use_external = False # DEFAULT False (bool) img_channels = "rgby" # DEFAULT g (str {r, g, b, y}) loss = "softmargin" # DEFAULT softmargin (softmargin | focal | fbeta) focal_gamma = 2 # DEFAULT 2 (float) fbeta = 1 # DEFAULT 1 (float) weight_mode = "inverse" # DEFAULT inverse ({inverse, sqrt} | None) weight_method = "loss" # DEFAULT loss (loss | sampling | None) device_ids = [0, 1] # DEFAULT [0,] (list int 0-8) workers = 8 # DEFAULT 8 (int 0-16) log_freq = 5 # DEFAULT 10 (int) trainval_ratio = 0.90 # DEFAULT 0.9 n_val_samples = None # DEFAULT None (int | None) n_train_eval_samples = 1024 # DEFAULT 1024 (int | None) train_split = "train" # DEFAULT train (train | val | trainval) val_split = "val" # DEFAULT val (train | val | trainval) train_augmentation = tfms.Compose([ tfms.HorizontalFlip(p=0.5), tfms.VerticalFlip(p=0.5), tfms.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.2, rotate_limit=20), tfms.RandomBrightnessContrast(), tfms.GaussNoise(var_limit=(2, 8)) ]) ############################## ########### Test ############# ############################## test_augmentation = [ # DEFAULT [] (list) tfms.HorizontalFlip(p=1.0), tfms.VerticalFlip(p=1.0), ] postprocessing = [ # DEFAULT [] (list {max3, max4, min1, 9+10, crf, uniform_thresh, perclass_thresh}) "max3", "9+10", "min1", "uniform_thresh" ] ############################## ########## Paths ############# ############################## primary_datapath = "" fullsize_datapath = ""
def get_filenames_of_path(path: pathlib.Path, ext: str = '*'): """Returns a list of files in a directory/path. Uses pathlib.""" filenames = [file for file in path.glob(ext) if file.is_file()] return filenames # input and target files images_train = get_filenames_of_path(root / 'train_frames') masks_train = get_filenames_of_path(root / 'train_masks') images_valid = get_filenames_of_path(root / 'val_frames') masks_valid = get_filenames_of_path(root / 'val_masks') # training transformations and augmentations transforms = Compose([ Resize(input_size=(480, 720), target_size=(240, 360)), AlbuSeg2d(albu=albumentations.HorizontalFlip(p=0.5)), AlbuSeg2d(albu=albumentations.Rotate(limit=20,p=0.2)), DenseTarget(), Normalize_to_01(), FixGreyScale() ]) # dataset training dataset_train = dataset.EyeDataset(inputs=images_train, targets=masks_train, transform=transforms) # dataset validation dataset_valid = dataset.EyeDataset(inputs=images_valid, targets=masks_valid, transform=transforms)
def __init__(self, data_dir, data_type, dataset, img_size=224, augment=False, age_stddev=1.0, label=False, gender=False, expand=0.0): assert(data_type in ("train", "valid", "test")) csv_path = Path(data_dir).joinpath(f"{dataset}_{data_type}_align.csv") img_dir = Path(data_dir) self.img_size = img_size self.label = label self.gen = gender self.race_dic = {"A":0, "B": 1, "H": 2, "O": 4, "W": 4} self.augment = augment self.expand = expand self.age_stddev = age_stddev self.transform = transforms.Compose([ transforms.Resize((img_size, img_size)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[ 0.229, 0.224, 0.225]) ]) # self.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], # ), # ToTensorV2() # ]) self.transform_aug = A.Compose([ A.HorizontalFlip(p=0.3), A.HueSaturationValue(p=0.3), A.RandomGamma(p=0.3), A.RandomBrightnessContrast(p=0.3), A.Resize(img_size, img_size, always_apply=True), A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], always_apply=True ), ToTensorV2() ]) self.x = [] self.y = [] # self.std = [] self.rotate = [] self.boxes = [] self.race = [] df = pd.read_csv(str(csv_path)) if self.gen: self.gender = [] for _, row in df.iterrows(): img_name = row["photo"] img_path = img_dir.joinpath(img_name) assert(img_path.is_file()) self.x.append(str(img_path)) self.y.append(row["age"]) self.rotate.append(row["deg"]) if self.gen: if row["gender"] == "M" or row["gender"] == "male": self.gender.append(0) if row["gender"] == "F" or row["gender"] == "female": self.gender.append(1) if row["race"] is not None: self.race.append(self.race_dic[row["race"]]) self.boxes.append( [row["box1"], row["box2"], row["box3"], row["box4"]])
plt.plot(list_of_history.history['accuracy']) plt.plot(list_of_history.history['val_accuracy']) plt.xlabel('Number of epoch') plt.ylabel('Accuracy obtained') plt.show() plt.plot(list_of_history.history['loss']) plt.plot(list_of_history.history['val_loss']) plt.xlabel('Number of epoch') plt.ylabel('Loss obtained') plt.show() SIZE_OF_IMAGE = 224 augmentation_transformation = augment.Compose([ augment.Resize(SIZE_OF_IMAGE, SIZE_OF_IMAGE), augment.HorizontalFlip(0.5), augment.VerticalFlip(), augment.RandomRotate90(), augment.Normalize(), ToTensorV2(), ]) class ReadingData(Dataset): def __init__(self, data, transformation = None): self.data = data self.transformation = transformation def __getitem__(self, i): image = self.data[i][0] label = self.data[i][1] if self.transformation:
def get_datasets(model_dir=None, new_ds_split=True, train_list="train.txt", val_list="val.txt", test_list="test.txt"): ''' Builds the necessary datasets model_dir is where model parameters will be stored new_ds_split creates a new train/val/test split if True, and loads the relevant folders if false dslist_in_pt_dir uses the pt dir as a reference for where the patient lists are located ''' # Manage patient splits if new_ds_split: dsm = DatasetManager.generate_train_val_test(dataset_dir, val_frac, test_frac) if model_dir is not None: dsm.save_lists(model_dir) else: dsm = DatasetManager.load_train_val_test(dataset_dir, train_list, val_list, test_list) #preprocess_fn = get_preprocessing_fn(backbone, pretrained=encoder_weights) prep = transforms.Compose( [Window(WL, WW), Imagify(WL, WW), Normalize(mean, std)]) resize_tsfm = A.Compose([A.Resize(img_size, img_size)], additional_targets={ "image1": 'image', "mask1": 'mask' }) img_mask_tsfm = A.Compose([ A.ShiftScaleRotate( shift_limit=translate, scale_limit=scale, rotate_limit=rotate), A.HorizontalFlip() ], additional_targets={ "image1": 'image', "mask1": 'mask' }) # create ds train_dicoms, val_dicoms, test_dicoms = dsm.get_dicoms( train_frac=train_frac) datasets = {} datasets['train'] = CTDicomSlices(train_dicoms, preprocessing=prep, resize_transform=resize_tsfm, img_and_mask_transform=img_mask_tsfm, n_surrounding=in_channels // 2) datasets['val'] = CTDicomSlices(val_dicoms, preprocessing=prep, resize_transform=resize_tsfm, n_surrounding=in_channels // 2) datasets['test'] = CTDicomSlices(test_dicoms, preprocessing=prep, resize_transform=resize_tsfm, n_surrounding=in_channels // 2) return datasets
def train_process(data_path, config): def _worker_init_fn_(): import random import numpy as np import torch random_seed = config.random_seed torch.manual_seed(random_seed) np.random.seed(random_seed) random.seed(random_seed) if torch.cuda.is_available(): torch.cuda.manual_seed(random_seed) input_size = (config.img_height, config.img_width) transforms = [ abm.RandomResizedCrop( scale=(0.7, 1), height=config.img_height, width=config.img_width, ratio=(1.5, 2), always_apply=True, ), abm.OneOf([abm.IAAAdditiveGaussianNoise(), abm.GaussNoise()], p=0.5), abm.OneOf( [ abm.MedianBlur(blur_limit=3), abm.GaussianBlur(blur_limit=3), abm.MotionBlur(blur_limit=3), ], p=0.1, ), abm.ShiftScaleRotate(rotate_limit=10, p=0.5, border_mode=0), abm.RandomGamma(gamma_limit=(80, 120), p=0.5), abm.RandomBrightnessContrast(brightness_limit=(-0.5, 0.5), contrast_limit=(-0.5, 0.5), p=0.5), abm.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=0.5), abm.RandomShadow(p=0.5), abm.RandomSunFlare(p=0.5), abm.ChannelShuffle(p=0.5), abm.ChannelDropout(p=0.5), abm.HorizontalFlip(p=0.5), abm.ImageCompression(quality_lower=50, p=0.5), abm.Cutout(num_holes=100, max_w_size=8, max_h_size=8, p=0.5), ] data_transform = DataTransformBase(transforms=transforms, input_size=input_size, normalize=True) train_dataset = EgoRailDataset(data_path=data_path, phase="train", transform=data_transform) val_dataset = EgoRailDataset(data_path=data_path, phase="val", transform=data_transform) # train_dataset.weighted_class() weighted_values = [8.90560578, 1.53155476] train_data_loader = DataLoader( train_dataset, batch_size=config.batch_size, shuffle=True, num_workers=config.num_workers, drop_last=True, worker_init_fn=_worker_init_fn_(), ) val_data_loader = DataLoader( val_dataset, batch_size=config.batch_size, shuffle=False, num_workers=config.num_workers, drop_last=True, ) data_loaders_dict = {"train": train_data_loader, "val": val_data_loader} model = BiSeNetV2(n_classes=config.num_classes) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") criterion = OHEMCELoss(thresh=config.ohem_ce_loss_thresh, weighted_values=weighted_values) base_lr_rate = config.lr_rate / (config.batch_size * config.batch_multiplier) base_weight_decay = config.weight_decay * (config.batch_size * config.batch_multiplier) def _lambda_epoch(epoch): import math max_epoch = config.num_epochs return math.pow((1 - epoch * 1.0 / max_epoch), 0.9) optimizer = torch.optim.SGD( model.parameters(), lr=base_lr_rate, momentum=config.momentum, weight_decay=base_weight_decay, ) scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=_lambda_epoch) trainer = BiSeNetV2Trainer( model=model, criterion=criterion, metric_func=None, optimizer=optimizer, data_loaders_dict=data_loaders_dict, config=config, scheduler=scheduler, device=device, ) if config.snapshot and os.path.isfile(config.snapshot): trainer.resume_checkpoint(config.snapshot) with torch.autograd.set_detect_anomaly(True): trainer.train()
unique_labels = df["cultivar"].unique() label_mapping = {label: i for i, label in enumerate(unique_labels)} rev_label_mapping = {i: label for label, i in label_mapping.items()} df.loc[:, "cultivar"] = df["cultivar"].map(label_mapping) test_df.loc[:, "cultivar"] = test_df["cultivar"].map(label_mapping) train_aug = albumentations.Compose( [ albumentations.RandomResizedCrop( height=args.image_size, width=args.image_size, p=1, ), albumentations.HorizontalFlip(p=0.5), albumentations.VerticalFlip(p=0.5), albumentations.HueSaturationValue(p=0.5), albumentations.OneOf( [ albumentations.RandomBrightnessContrast(p=0.5), albumentations.RandomGamma(p=0.5), ], p=0.5, ), albumentations.OneOf( [ albumentations.Blur(p=0.1), albumentations.GaussianBlur(p=0.1), albumentations.MotionBlur(p=0.1), ],
Attention! Images and corresponding masks must have the same names, e. g. 123.png and 123.npy ''' if __name__ == '__main__': IMG_PATH = sys.argv[1] MASK_PATH = sys.argv[2] N_CLASSES = int(sys.argv[3]) BATCH_SZ = int(sys.argv[4]) LR = float(sys.argv[5]) N_EPOCHS = int(sys.argv[6]) DICT_PATH = sys.argv[7] df = get_names(IMG_PATH) model = UNet(num_class=N_CLASSES) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') train,test = train_test_split(df['id'].values,test_size = 0.2, random_state = 1337) train_transform = A.Compose([A.OneOf([A.HorizontalFlip(),A.VerticalFlip(),A.RandomRotate90()],p=0.8), A.Perspective(p=0.7,scale=(0.07,0.12)),A.Blur(p=0.5,blur_limit=6), A.RandomBrightnessContrast((0,0.5),(0,0.5)),A.GaussNoise()]) test_transform = A.Compose([A.OneOf([A.HorizontalFlip(),A.VerticalFlip(),A.RandomRotate90()],p=0.8), A.GaussNoise()]) train_set = PipeDataset(IMG_PATH,MASK_PATH,train,train_transform) test_set = PipeDataset(IMG_PATH,MASK_PATH,test,test_transform) train_loader = DataLoader(train_set, batch_size = BATCH_SZ, shuffle = True) test_loader = DataLoader(test_set, batch_size = BATCH_SZ, shuffle = True) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr = LR) history,best_model_dict = fit(N_EPOCHS, model, N_CLASSES, train_loader, test_loader, criterion, optimizer, device) torch.save(best_model_dict,DICT_PATH)
def get_transforms(self): normalise = A.Normalize() d4_tansforms = A.Compose([ A.SmallestMaxSize(self.img_size, interpolation=0, p=1.), # D4 Group augmentations A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Transpose(p=0.5), A.Normalize(), ]) tensor_transform = Compose([ ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) d4_geometric = A.Compose([ A.SmallestMaxSize(self.img_size, interpolation=0, p=1.), A.ShiftScaleRotate(shift_limit=self.shift_limit, self.scale_limit, rotate_limit=self.rotate_limit, interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=0.5), # D4 Group augmentations A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Transpose(p=0.2), # crop and resize A.RandomSizedCrop((self.crop_size[0], min(self.crop_size[1], self.img_size[0], self.img_size[1])), self.img_size[0], self.img_size[1], w2h_ratio=1.0, interpolation=cv2.INTER_LINEAR, always_apply=False, p=0.2), A.Normalize(), ]) resize_norm = A.Compose([ A.SmallestMaxSize(IMG_SIZE, interpolation=0, p=1.), A.RandomCrop(self.img_size[0], self.img_size[1], p=1.), A.Normalize(), ]) geometric_transforms = A.Compose([ A.SmallestMaxSize(self.img_size, interpolation=0, p=1.), A.ShiftScaleRotate(shift_limit=self.shift_limit, self.scale_limit, rotate_limit=self.rotate_limit, interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=0.5), A.RandomSizedCrop((self.crop_size[0], min(self.crop_size[1], self.img_size[0], self.img_size[1])), self.img_size[0], self.img_size[1]), # D4 Group augmentations A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.Transpose(p=0.2), A.Normalize(), ]) train_light = A.Compose([ A.SmallestMaxSize(self.img_size, interpolation=0, p=1.), A.RandomCrop(self.img_size[0], self.img_size[1], p=1.), A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(p=0.5), A.Normalize(), ]) train_light_show = A.Compose([ A.SmallestMaxSize(self.img_size, interpolation=0, p=1.), A.RandomCrop(self.img_size[0], self.img_size[1], p=1.), A.HorizontalFlip(p=0.5), A.RandomBrightnessContrast(p=0.5), ]) train_medium = A.Compose([ A.SmallestMaxSize(self.img_size, interpolation=0, p=1.), A.RandomCrop(self.img_size[0], self.img_size[1], p=1.), A.HorizontalFlip(p=0.5), A.ShiftScaleRotate(shift_limit=self.shift_limit, self.scale_limit, rotate_limit=self.rotate_limit, p=0.5), A.OneOf( [ A.RandomBrightnessContrast(p=0.7), A.Equalize(p=0.3), A.HueSaturationValue(p=0.5), A.RGBShift(p=0.5), A.RandomGamma(p=0.4), A.ChannelShuffle(p=0.05), ], p=0.9), A.OneOf([ A.GaussNoise(p=0.5), A.ISONoise(p=0.5), A.MultiplicativeNoise(0.5), ], p=0.2), A.Normalize(), ]) valid_ade = A.Compose([ A.SmallestMaxSize(self.img_size, p=1.), A.Lambda(name="Pad32", image=pad_x32, mask=pad_x32), A.Normalize(), ]) # from bloodaxe # https://github.com/BloodAxe/Catalyst-Inria-Segmentation-Example/blob/master/inria/augmentations.py crop_transform = A.Compose([ #(image_size: Tuple[int, int], min_scale=0.75, max_scale=1.25, input_size=5000): A.OneOrOther( A.RandomSizedCrop((self.crop_size[0], min(self.crop_size[1], self.img_size[0], self.img_size[1])), self.img_size[0], self.img_size[1]), A.CropNonEmptyMaskIfExists(self.img_size[0], self.img_size[1]), ) ]) safe_augmentations = A.Compose([A.HorizontalFlip(), A.RandomBrightnessContrast(), A.Normalize()]) light_augmentations = A.Compose([ A.HorizontalFlip(), A.RandomBrightnessContrast(), A.OneOf([ A.ShiftScaleRotate(scale_limit=self.scale_limit, rotate_limit=self.rotate_limit, border_mode=cv2.BORDER_CONSTANT), A.IAAAffine(), A.IAAPerspective(), A.NoOp() ]), A.HueSaturationValue(), A.Normalize() ]) medium_augmentations = A.Compose([ A.HorizontalFlip(), A.ShiftScaleRotate(scale_limit=self.scale_limit, rotate_limit=self.rotate_limit, border_mode=cv2.BORDER_CONSTANT), # Add occasion blur/sharpening A.OneOf([A.GaussianBlur(), A.IAASharpen(), A.NoOp()]), # Spatial-preserving augmentations: A.OneOf([A.CoarseDropout(), A.MaskDropout(max_objects=5), A.NoOp()]), A.GaussNoise(), A.OneOf([A.RandomBrightnessContrast(), A.CLAHE(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma()]), # Weather effects A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1), A.Normalize(), ]) hard_augmentations = A.Compose([ A.RandomRotate90(), A.Transpose(), A.RandomGridShuffle(), A.ShiftScaleRotate( scale_limit=self.scale_limit, rotate_limit=self.rotate_limit, border_mode=cv2.BORDER_CONSTANT, mask_value=0, value=0 ), A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT, alpha_affine=5, mask_value=0, value=0), # Add occasion blur A.OneOf([A.GaussianBlur(), A.GaussNoise(), A.IAAAdditiveGaussianNoise(), A.NoOp()]), # D4 Augmentations A.OneOf([A.CoarseDropout(), A.MaskDropout(max_objects=10), A.NoOp()]), # Spatial-preserving augmentations: A.OneOf( [ A.RandomBrightnessContrast(brightness_by_max=True), A.CLAHE(), A.HueSaturationValue(), A.RGBShift(), A.RandomGamma(), A.NoOp(), ] ), # Weather effects A.OneOf([A.RandomFog(fog_coef_lower=0.01, fog_coef_upper=0.3, p=0.1), A.NoOp()]), A.Normalize(), ]) TRANSFORMS = { "d4": d4_tansforms, "normalise": normalise, "resize_norm": resize_norm, "geometric": geometric_transforms, "d4_geometric": d4_geometric, "ade_light": train_light, "ade_medium": train_medium, "ade_valid": valid_ade, "ade_show": train_light_show, "resize_norm": resize_norm, "flip_bright": safe_augmentations, "inria_light": light_augmentations, "inria_medium": medium_augmentations, "inria_hard": hard_augmentations, "inria_valid": safe_augmentations, } return TRANSFORMS[self.augs_name]
def get_training_augmentation(): train_transform = [albu.HorizontalFlip(p=1)] return albu.Compose(train_transform)
from os import path import albumentations as alb from albumentations.pytorch import ToTensorV2 from skimage.color import gray2rgb import skimage import cv2 import torch import numpy as np from torch.utils.data import Dataset import pickle from conet.config import get_cfg train_size_aug = alb.Compose([ # alb.RandomSizedCrop(min_max_height=(300, 500)), alb.HorizontalFlip(), alb.VerticalFlip(), # alb.RandomBrightness(limit=0.01), alb.RandomScale(), alb.ElasticTransform(), alb.Rotate(limit=50), alb.PadIfNeeded(530, border_mode=cv2.BORDER_REFLECT101), alb.RandomCrop(512, 512), # alb.Normalize(), # alb.pytorch.ToTensor(), # ToTensorV2() ]) train_content_aug = alb.Compose([ alb.MedianBlur(), alb.RGBShift(r_shift_limit=10, g_shift_limit=10, b_shift_limit=10), alb.RandomBrightnessContrast(brightness_limit=0.1),
for c in self.void_classes: lbl[lbl == c] = self.ignore_index for c in self.valid_classes: lbl[lbl == c] = self.class_map[c] return lbl if __name__ == '__main__': import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt from utils.custum_aug import Rotate affine_augmenter = albu.Compose([ albu.HorizontalFlip(p=.5), # Rotate(5, p=.5) ]) # image_augmenter = albu.Compose([albu.GaussNoise(p=.5), # albu.RandomBrightnessContrast(p=.5)]) image_augmenter = None dataset = CityscapesDataset(split='train', net_type='deeplab', ignore_index=19, debug=True, affine_augmenter=affine_augmenter, image_augmenter=image_augmenter) dataloader = DataLoader(dataset, batch_size=8, shuffle=True) print(len(dataset)) for i, batched in enumerate(dataloader):
from classification_models.resnet.models import ResNet152 import albumentations as A MODEL_PATH = 'Christof/models/ResNet101/2/' exp_suffix = '_base' SIZE = 256 # Load dataset info path_to_train = 'Christof/assets/train_rgb_256/' data = pd.read_csv('Christof/assets/train.csv') normal_aug = A.Compose([ A.Rotate((0, 30), p=0.75), A.RandomRotate90(p=1), A.HorizontalFlip(p=0.5), A.RandomBrightness(0.05), A.RandomContrast(0.05), ]) val_aug = A.HorizontalFlip(p=0.5) train_dataset_info = [] for name, labels in zip(data['Id'], data['Target'].str.split(' ')): train_dataset_info.append({ 'path': os.path.join(path_to_train, name), 'labels': np.array([int(label) for label in labels]) }) train_dataset_info = np.array(train_dataset_info)
def main(): train_transform = A.Compose([ A.Resize(height=IMAGE_HEIGHT, width=IMAGE_WIDTH), A.Rotate(limit=35, p=1.0), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.1), A.Normalize( mean=[0.0, 0.0, 0.0], std=[1.0, 1.0, 1.0], max_pixel_value=255.0, ), ToTensorV2(), ], ) val_transforms = A.Compose([ A.Resize(height=IMAGE_HEIGHT, width=IMAGE_WIDTH), A.Normalize( mean=[0.0, 0.0, 0.0], std=[1.0, 1.0, 1.0], max_pixel_value=255.0, ), ToTensorV2(), ], ) model = UNET(in_channels=3, out_channels=1).to(DEVICE) loss_fn = nn.BCEWithLogitsLoss() optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE) train_loader, val_loader = get_loaders( TRAIN_IMG_DIR, TRAIN_MASK_DIR, VAL_IMG_DIR, VAL_MASK_DIR, BATCH_SIZE, train_transform, val_transforms, NUM_WORKERS, PIN_MEMORY, ) #if LOAD_MODEL: #load_checkpoint(torch.load("my_checkpoint.pth.tar"), model) check_accuracy(val_loader, model, device=DEVICE) scaler = torch.cuda.amp.GradScaler() for epoch in range(NUM_EPOCHS): train_fn(train_loader, model, optimizer, loss_fn, scaler) # save model checkpoint = { "state_dict": model.state_dict(), "optimizer": optimizer.state_dict(), } save_checkpoint(checkpoint) # check accuracy check_accuracy(val_loader, model, device=DEVICE) # print some examples to a folder save_predictions_as_imgs(val_loader, model, folder="saved_images/", device=DEVICE)
# thresholds = [0.2, 0.25, 0.3, 0.35, 0.4] sublist = [] for index, row in tqdm.tqdm(sample_df.iterrows(), total=len(sample_df)): image_id = row['ImageId'] if image_id in masks_: tta_img = [] tta_preds = [] img_path = os.path.join('input/test_png', image_id + '.png') img = imread(img_path) # print ("data1: ",img.shape) width, height = img.shape[0], img.shape[1] img = imresize(img, (IMG_SIZE, IMG_SIZE), interp='bilinear') aug_HFlip = albumentations.HorizontalFlip(p=1) # aug_transp = albumentations.Transpose(p=1) augmented1 = aug_HFlip(image=img) # augmented2 = aug_transp(image=img) img1 = augmented1['image'] # img2 = augmented2['image'] # img3 = np.rot90(img, k=1).copy() # img4 = np.rot90(img, k=2).copy() # img5 = np.rot90(img, k=3).copy() tta_img.append(img) tta_img.append(img1) # tta_img.append(img2) # tta_img.append(img3)
def get_train_transforms(height: int = 437, width: int = 582, level: str = 'hard'): if level == 'light': return A.Compose([ A.HorizontalFlip(p=0.5), A.IAAAdditiveGaussianNoise(p=0.2), A.OneOf( [A.CLAHE(p=1.0), A.RandomBrightness(p=1.0), A.RandomGamma(p=1.0), ],p=0.5), A.OneOf( [A.IAASharpen(p=1.0), A.Blur(blur_limit=3, p=1.0), A.MotionBlur(blur_limit=3, p=1.0), ],p=0.5), A.OneOf( [A.RandomContrast(p=1.0), A.HueSaturationValue(p=1.0), ],p=0.5), A.Resize(height=height, width=width, p=1.0), A.PadIfNeeded(pad_to_multiple(height), pad_to_multiple(width), border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0) ], p=1.0) elif level == 'hard': return A.Compose([ A.HorizontalFlip(p=0.5), A.IAAAdditiveGaussianNoise(p=0.2), A.OneOf( [A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.ElasticTransform(alpha_affine=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), A.ShiftScaleRotate( shift_limit=0, scale_limit=0, rotate_limit=10, border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0 ), A.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0, p=1.0), ],p=0.5), A.OneOf( [A.CLAHE(p=1.0), A.RandomBrightness(p=1.0), A.RandomGamma(p=1.0), A.ISONoise(p=1.0) ],p=0.5), A.OneOf( [A.IAASharpen(p=1.0), A.Blur(blur_limit=3, p=1.0), A.MotionBlur(blur_limit=3, p=1.0), ],p=0.5), A.OneOf( [A.RandomContrast(p=1.0), A.HueSaturationValue(p=1.0), ],p=0.5), A.Resize(height=height, width=width, p=1.0), A.Cutout(p=0.3), A.PadIfNeeded(pad_to_multiple(height), pad_to_multiple(width), border_mode=cv2.BORDER_CONSTANT, value=0, mask_value=0) ], p=1.0) elif level == 'hard_weather': raise NotImplementedError("WIP")
def load_data(fold: int, params: Dict[str, Any]) -> Any: torch.multiprocessing.set_sharing_strategy('file_system') cudnn.benchmark = True logger.info('Options:') logger.info(pprint.pformat(opt)) full_df = pd.read_csv(opt.TRAIN.CSV) print('full_df', full_df.shape) train_df, val_df = train_val_split(full_df, fold) print('train_df', train_df.shape, 'val_df', val_df.shape) test_df = pd.read_csv(opt.TEST.CSV) # transform_train = transforms.Compose([ # # transforms.Resize((opt.MODEL.IMAGE_SIZE)), # smaller edge # transforms.RandomCrop(opt.MODEL.INPUT_SIZE), # transforms.RandomHorizontalFlip(), # # transforms.ColorJitter(brightness=0.2, contrast=0.2), # # transforms.RandomAffine(degrees=20, scale=(0.8, 1.2), shear=10, resample=PIL.Image.BILINEAR), # # transforms.RandomCrop(opt.MODEL.INPUT_SIZE), # ]) augs = [] augs.append(albu.HorizontalFlip(.5)) if int(params['vflip']): augs.append(albu.VerticalFlip(.5)) if int(params['rotate90']): augs.append(albu.RandomRotate90()) if params['affine'] == 'soft': augs.append( albu.ShiftScaleRotate(shift_limit=0.075, scale_limit=0.15, rotate_limit=10, p=.75)) elif params['affine'] == 'medium': augs.append( albu.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2)) elif params['affine'] == 'hard': augs.append( albu.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.50, rotate_limit=45, p=.75)) if float(params['noise']) > 0.1: augs.append( albu.OneOf([ albu.IAAAdditiveGaussianNoise(), albu.GaussNoise(), ], p=float(params['noise']))) if float(params['blur']) > 0.1: augs.append( albu.OneOf([ albu.MotionBlur(p=.2), albu.MedianBlur(blur_limit=3, p=0.1), albu.Blur(blur_limit=3, p=0.1), ], p=float(params['blur']))) if float(params['distortion']) > 0.1: augs.append( albu.OneOf([ albu.OpticalDistortion(p=0.3), albu.GridDistortion(p=.1), albu.IAAPiecewiseAffine(p=0.3), ], p=float(params['distortion']))) if float(params['color']) > 0.1: augs.append( albu.OneOf([ albu.CLAHE(clip_limit=2), albu.IAASharpen(), albu.IAAEmboss(), albu.RandomBrightnessContrast(), ], p=float(params['color']))) transform_train = albu.Compose([ albu.RandomCrop(height=opt.MODEL.INPUT_SIZE, width=opt.MODEL.INPUT_SIZE), albu.Compose(augs, p=float(params['aug_global_prob'])) ]) if opt.TEST.NUM_TTAS > 1: transform_test = albu.Compose([ albu.RandomCrop(height=opt.MODEL.INPUT_SIZE, width=opt.MODEL.INPUT_SIZE), albu.HorizontalFlip(), ]) else: transform_test = albu.Compose([ albu.CenterCrop(height=opt.MODEL.INPUT_SIZE, width=opt.MODEL.INPUT_SIZE), ]) train_dataset = Dataset(train_df, path=opt.TRAIN.PATH, mode='train', num_classes=opt.MODEL.NUM_CLASSES, resize=False, augmentor=transform_train) val_dataset = Dataset(val_df, path=opt.TRAIN.PATH, mode='val', num_classes=opt.MODEL.NUM_CLASSES, resize=False, num_tta=opt.TEST.NUM_TTAS, augmentor=transform_test) test_dataset = Dataset(test_df, path=opt.TEST.PATH, mode='test', num_classes=opt.MODEL.NUM_CLASSES, resize=False, num_tta=opt.TEST.NUM_TTAS, augmentor=transform_test) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=opt.TRAIN.BATCH_SIZE, shuffle=True, num_workers=opt.TRAIN.WORKERS) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=opt.TRAIN.BATCH_SIZE, shuffle=False, num_workers=opt.TRAIN.WORKERS) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=opt.TRAIN.BATCH_SIZE, shuffle=False, num_workers=opt.TRAIN.WORKERS) return train_loader, val_loader, test_loader
def __init__(self): self.Compose = albu.Compose([ albu.HorizontalFlip(p=0), albu.ToFloat(max_value=None, always_apply=True), ToTensor(normalize={'mean': [0.5071, 0.4867, 0.4408], 'std': [0.2675, 0.2565, 0.2761]}) ])
label = self.labels[idx] image = self.imgs[idx] # By default OpenCV uses BGR color space for color images, # so we need to convert the image to RGB color space. # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) if self.transform: augmented = self.transform(image=image) image = augmented['image'] return image, label albumentations_transform = A.Compose([ A.RandomCrop(48, 48), A.OneOf([ A.HorizontalFlip(p=1), A.RandomRotate90(p=1), A.VerticalFlip(p=1) ], p=1), A.OneOf([ A.MotionBlur(p=1), A.OpticalDistortion(p=1), A.GaussNoise(p=1) ], p=1), ToTensorV2() ]) albumentations_transform_test = A.Compose([ # A.CenterCrop(224, 224), ToTensorV2() ])
def __len__(self): return len(self.img_paths) # meta 데이터와 이미지 경로를 불러옵니다. submission = pd.read_csv(os.path.join(test_dir, 'info.csv')) image_dir = os.path.join(test_dir, 'images') # Test Dataset 클래스 객체를 생성하고 DataLoader를 만듭니다. image_paths = [ os.path.join(image_dir, img_id) for img_id in submission.ImageID ] augs = [ albumentations.HorizontalFlip(), # albumentations.CenterCrop(224, 224), # albumentations.ColorJitter(p=0.5) ] transform = albumentations.Compose([ albumentations.Resize(384, 512), albumentations.Normalize(mean=(0.560, 0.524, 0.501), std=(0.233, 0.243, 0.245)), albumentations.pytorch.transforms.ToTensorV2() ]) dataset = TestDataset(image_paths, augs, transform) loader = DataLoader(dataset, shuffle=False)
def get_dataset_loaders(config, workers, idDir=None): # idDir is the place to save train/test IDS as txt files. p = pprint.PrettyPrinter() fs = s3fs.S3FileSystem(session=boto3.Session( profile_name=config['dataset']['aws_profile'])) imagery_searchpath = config['dataset']['image_bucket'] + '/' + config[ 'dataset']['imagery_directory_regex'] print("Searching for imagery...({})".format(imagery_searchpath)) imagery_candidates = fs.ls(config['dataset']['image_bucket']) print("candidates:") p.pprint(imagery_candidates) imagery_locs = [ c for c in imagery_candidates if match(imagery_searchpath, c) ] print("result:") p.pprint(imagery_locs) mask_searchpath = config['dataset']['mask_bucket'] + '/' + config[ 'dataset']['mask_directory_regex'] print("Searching for mask...({})".format(mask_searchpath)) mask_candidates = fs.ls(config['dataset']['mask_bucket']) print("candidates:") p.pprint(mask_candidates) mask_locs = [c for c in mask_candidates if match(mask_searchpath, c)] print("result:") p.pprint(mask_locs) assert (len(mask_locs) > 0 and len(imagery_locs) > 0) print("Merging tilesets...") allTiles = MultiSlippyMapTilesConcatenation( imagery_locs, mask_locs, aws_profile=config['dataset']['aws_profile']) print(len(allTiles)) train_ids, test_ids = train_test_split( allTiles.image_ids, train_size=config['dataset']['train_percent']) transform = A.Compose([ #A.ToFloat(p = 1), # A.RandomRotate90(p = 0.5), #A.RandomRotate90(p = 0.5), #A.RandomRotate90(p = 0.5), #these do something bad to the bands # A.Normalize(mean = mean, std = std, max_pixel_value = 1), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), # A.ToFloat(p = 1, max_value = np.finfo(np.float64).max) ]) train_tileset = MultiSlippyMapTilesConcatenation( imagery_locs, mask_locs, aws_profile=config['dataset']['aws_profile'], image_ids=train_ids, joint_transform=transform) test_tileset = MultiSlippyMapTilesConcatenation( imagery_locs, mask_locs, aws_profile=config['dataset']['aws_profile'], image_ids=test_ids, joint_transform=transform) train_ids = train_tileset.getIds() test_ids = test_tileset.getIds() if idDir: print("Writing train/test ids to {}.".format(idDir)) with open(os.path.join(idDir, 'train_ids.txt'), 'w') as f: for item in train_ids: f.write("%s\n" % item) with open(os.path.join(idDir, 'test_ids.txt'), 'w') as f: for item in test_ids: f.write("%s\n" % item) train_loader = DataLoader(train_tileset, batch_size=config['model']['batch_size'], shuffle=True, drop_last=True, num_workers=workers) test_loader = DataLoader(test_tileset, batch_size=config['model']['batch_size'], shuffle=True, drop_last=True, num_workers=workers) return (train_loader, test_loader)
import albumentations from albumentations import torch as AT train_transforms = albumentations.Compose([ albumentations.Resize(256, 256), albumentations.HorizontalFlip(), albumentations.Rotate(limit=10), albumentations.JpegCompression(80), albumentations.HueSaturationValue(), albumentations.Normalize(), AT.ToTensor() ]) val_transforms = albumentations.Compose([ albumentations.Resize(256, 256), albumentations.Normalize(), AT.ToTensor() ]) test_norm_transforms = albumentations.Compose([ albumentations.Resize(256, 256), albumentations.Normalize(), AT.ToTensor() ]) test_flip_transforms = albumentations.Compose([ albumentations.Resize(256, 256), albumentations.HorizontalFlip(p=1.1), albumentations.Normalize(), AT.ToTensor()
from albumentations.pytorch.transforms import ToTensorV2 if __name__ == '__main__': train_path = 'Kvasir-SEG/train' val_path = 'Kvasir-SEG/val' batch_size = 8 start_epoch = 0 epochs = 130 device = torch.device( 'cuda') if torch.cuda.is_available() else torch.device['cpu'] print(device) t_transforms = A.Compose([ # A.RandomBrightnessContrast(p=0.5), A.OneOf([A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5)], p=0.5), A.RandomRotate90(p=0.5), A.ShiftScaleRotate(p=0.5), A.Resize(256, 256), A.Normalize(), ToTensorV2() ]) v_transforms = A.Compose([ # A.RandomBrightnessContrast(p=0.5), # A.OneOf([A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5)], p=0.5), # A.RandomRotate90(p=0.5), # A.ShiftScaleRotate(p=0.5), A.Resize(256, 256), A.Normalize(),
def __init__(self, resize=(0, 0), padding=(0, 0), crop=(0, 0), horizontal_flip_prob=0.0, vertical_flip_prob=0.0, gaussian_blur_prob=0.0, rotate_degree=0.0, cutout_prob=0.0, cutout_dim=(8, 8), hue_saturation_prob=0.0, contrast_prob=0.0, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), normalize=True, train=True): """Create data transformation pipeline. Args: resize (tuple, optional): Resize the input to the given height and width. (default: (0, 0)) padding (tuple, optional): Pad the image if the image size is less than the specified dimensions (height, width). (default= (0, 0)) crop (tuple, optional): Randomly crop the image with the specified dimensions (height, width). (default: (0, 0)) horizontal_flip_prob (float, optional): Probability of an image being horizontally flipped. (default: 0) vertical_flip_prob (float, optional): Probability of an image being vertically flipped. (default: 0) rotate_prob (float, optional): Probability of an image being rotated. (default: 0) rotate_degree (float, optional): Angle of rotation for image augmentation. (default: 0) cutout_prob (float, optional): Probability that cutout will be performed. (default: 0) cutout_dim (tuple, optional): Dimensions of the cutout box (height, width). (default: (8, 8)) hue_saturation_prob (float, optional): Probability of randomly changing hue, saturation and value of the input image. (default: 0) contrast_prob (float, optional): Randomly changing contrast of the input image. (default: 0) mean (float or tuple, optional): Dataset mean. (default: 0.5 for each channel) std (float or tuple, optional): Dataset standard deviation. (default: 0.5 for each channel) """ transforms_list = [] if sum(resize) > 0: transforms_list += [ A.Resize(height=resize[0], width=resize[1], always_apply=True) ] if train: if sum(padding) > 0: transforms_list += [ A.PadIfNeeded(min_height=padding[0], min_width=padding[1], always_apply=True) ] if sum(crop) > 0: transforms_list += [ A.RandomCrop(crop[0], crop[1], always_apply=True) ] if horizontal_flip_prob > 0: # Horizontal Flip transforms_list += [A.HorizontalFlip(p=horizontal_flip_prob)] if vertical_flip_prob > 0: # Vertical Flip transforms_list += [A.VerticalFlip(p=vertical_flip_prob)] if gaussian_blur_prob > 0: # Patch Gaussian Augmentation transforms_list += [A.GaussianBlur(p=gaussian_blur_prob)] if rotate_degree > 0: # Rotate image transforms_list += [A.Rotate(limit=rotate_degree)] if cutout_prob > 0: # CutOut if isinstance(mean, float): fill_value = mean * 255.0 else: fill_value = tuple([x * 255.0 for x in mean]) transforms_list += [ A.CoarseDropout(p=cutout_prob, max_holes=1, fill_value=fill_value, max_height=cutout_dim[0], max_width=cutout_dim[1]) ] if hue_saturation_prob > 0: # Hue Saturation transforms_list += [ A.HueSaturationValue(p=hue_saturation_prob) ] if contrast_prob > 0: # Random Contrast transforms_list += [A.RandomContrast(p=contrast_prob)] if normalize: # normalize the data with mean and standard deviation to keep values in range [-1, 1] # since there are 3 channels for each image, # we have to specify mean and std for each channel transforms_list += [ A.Normalize(mean=mean, std=std, always_apply=True), ] # convert the data to torch.FloatTensor transforms_list += [ToTensor()] self.transform = A.Compose(transforms_list)
test_ids = sub['Image_Label'].apply( lambda x: x.split('_')[0]).drop_duplicates().values # In[84]: image_name = '8242ba0.jpg' image = get_img(image_name) mask = make_mask(train, image_name) # In[85]: visualize(image, mask) # In[86]: plot_with_augmentation(image, mask, albu.HorizontalFlip(p=1)) # In[87]: plot_with_augmentation(image, mask, albu.VerticalFlip(p=1)) # In[88]: plot_with_augmentation(image, mask, albu.RandomRotate90(p=1)) # In[89]: plot_with_augmentation( image, mask, albu.ElasticTransform(p=1, alpha=120,
device = torch.device(cuda_str if config['cuda']['using_cuda'] else "cpu") # tensorboard summary_writer = SummaryWriter(os.path.join(config['model']['exp_path'], 'log')) # Data print('==> Preparing data..') target_classes = utils.read_txt(config['params']['classes']) num_classes = len(target_classes) img_size = config['params']['image_size'].split('x') img_size = (int(img_size[0]), int(img_size[1])) bbox_params = A.BboxParams(format='pascal_voc', min_visibility=0.3) train_transforms = A.Compose([ A.Resize(height=img_size[0], width=img_size[1], p=1.0), A.HorizontalFlip(p=0.5), # A.OneOf([ # A.Sequential([ # A.Resize(height=img_size[0], width=img_size[1], p=1.0), # ], p=1.0), # A.Sequential([ # A.RandomSizedBBoxSafeCrop(height=img_size[0], width=img_size[1], p=1.0), # ], p=1.0) # ], p=1.0), A.OneOf([ A.Sequential([ A.GaussNoise(var_limit=(100, 150), p=0.5), A.MotionBlur(blur_limit=17, p=0.5) ], p=1.0), A.Sequential([
def __init__(self, image_paths, labels=None, train=True, test=False, aug=None, use_onehot=False): self.paths = image_paths self.test = test self.use_onehot = use_onehot if self.test == False: self.labels = labels self.train = train # self.transform = albu.Compose([albu.HorizontalFlip(p=0.5), # albu.VerticalFlip(p=0.5), # albu.ShiftScaleRotate(rotate_limit=25.0, p=0.7), # albu.OneOf([albu.IAAEmboss(p=1), # albu.IAASharpen(p=1), # albu.Blur(p=1)], p=0.5), # albu.IAAPiecewiseAffine(p=0.5), # albu.Resize(545, 545, always_apply=True), # albu.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), # albu.pytorch.ToTensor(), # ]) self.transform = [] self.transform.append(albu.HorizontalFlip(p=0.5)) self.transform.append(albu.VerticalFlip(p=0.5)) if aug is not None and 'rt90' in aug: print('=> using rotate 90.') self.transform.append(albu.RandomRotate90(p=0.5)) self.transform.append(albu.ShiftScaleRotate(rotate_limit=25.0, p=0.7)) self.transform.append( albu.OneOf( [albu.IAAEmboss(p=1), albu.IAASharpen(p=1), albu.Blur(p=1)], p=0.5)) self.transform.append(albu.IAAPiecewiseAffine(p=0.5)) if aug is not None and 'cj' in aug: print('=> using color jittering.') self.transform.append(albu.RandomBrightness(p=0.5)) self.transform.append(albu.HueSaturationValue(p=0.5)) self.transform.append(albu.Resize(545, 545, always_apply=True)) # self.transform.append(albu.Resize(224, 224, always_apply=True)) if aug is not None and 'autoaug' in aug: print('=> using autoaug.') self.transform.append(albuImageNetPolicy()) self.transform.append( albu.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))) self.transform.append(albu.pytorch.ToTensor()) self.transform = albu.Compose(self.transform) self.usere = False if aug is not None and 're' in aug: self.usere = True print('=> using random erasing.') self.re = RandomErasing() self.default_transform = albu.Compose([ albu.Resize(545, 545, always_apply=True), # self.default_transform = albu.Compose([albu.Resize(224, 224, always_apply=True), albu.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225), always_apply=True), albu.pytorch.ToTensor() ]) # normalized for pretrained network