#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
