import albumentations as A
from albumentations.pytorch import ToTensorV2
import timm
import warnings
warnings.filterwarnings('ignore')
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
#Transform for efficientnet
transforms_valid = albumentations.Compose([
albumentations.CenterCrop(image_size, image_size, p=1),
albumentations.Resize(image_size, image_size),
albumentations.Normalize()
])
# ====================================================
# Directory settings for Resnext
# ====================================================
import os
OUTPUT_DIR = '.\\'
MODEL_DIR = '.\\cassava-models-res\\'
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
TRAIN_PATH = '.\\train_images'
TEST_PATH = '.\\test_images'
train_transforms = A.Compose([
A.RandomResizedCrop(train_img_size,
train_img_size,
scale=(0.7, 1.0),
ratio=(0.9, 1.1)),
A.OneOf([
A.RandomRotate90(),
A.Flip(),
A.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.0,
rotate_limit=45,
interpolation=1)
]),
A.CoarseDropout(max_holes=4, max_height=64, max_width=64),
A.Normalize(mean=mean, std=std, max_pixel_value=max_value),
ToTensorV2()
])
val_transforms = A.Compose(
[A.Normalize(mean=mean, std=std, max_pixel_value=max_value),
ToTensorV2()])
train_loader, val_loader, train_eval_loader = get_train_val_loaders(
train_ds,
val_ds,
train_transforms=train_transforms,
val_transforms=val_transforms,
batch_size=batch_size,
num_workers=num_workers,
val_batch_size=val_batch_size,
def get_transforms(self):
return A.Normalize()
exp_suffix = '_1in20_0005b'
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.Normalize(mean=(0.08069, 0.05258, 0.05487),
std=(0.1300, 0.0879, 0.1386),
max_pixel_value=255.)
])
val_aug = A.Compose([
A.HorizontalFlip(p=0.5),
A.Normalize(mean=(0.08069, 0.05258, 0.05487),
std=(0.1300, 0.0879, 0.1386),
max_pixel_value=255.)
])
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),
def __init__(self, config, split):
"""
:param opt:
:param split: train/val
"""
super(DATASET_CUSTOM, self).__init__()
self.data_dir = config['dataset']['data_dir']
self.img_dir = os.path.join(self.data_dir, 'images')
self.input_h = config['model']['input_h']
self.input_w = config['model']['input_h']
self.pad = config['model']['pad']
self.down_ratio = config['model']['down_ratio']
self.mean = config['dataset']['mean']
self.std = config['dataset']['std']
self.max_objs = config['dataset']['max_object']
self.num_classes = config['dataset']['num_classes']
self.radius = config['dataset']['radius']
self.annot_path = os.path.join(
self.data_dir, 'annotations',
'{}.json').format(split)
# print(self.data_dir)
self.class_name = ['__background__'] + config['dataset']['label_name']
self._valid_ids = [_id for _id in range(1, self.num_classes+1)] # [1,2,..self.num_classes]
self.cat_ids = {v: i for i, v in enumerate(self._valid_ids)} # {1:0,
self.split = split
print('==> initializing {} data.'.format(split))
self.coco = coco.COCO(self.annot_path)
self.images = self.coco.getImgIds()
self.num_samples = len(self.images)
print('Loaded {} {} samples'.format(split, self.num_samples))
self.output_h = self.input_h // self.down_ratio # 512/4 = 128
self.output_w = self.input_w // self.down_ratio
self.transform_train = A.Compose(
[
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.5,
contrast_limit=0.4),
A.RandomGamma(gamma_limit=(50, 150)),
A.NoOp()
]),
A.OneOf([
A.RGBShift(r_shift_limit=20, b_shift_limit=15,
g_shift_limit=15),
A.HueSaturationValue(hue_shift_limit=5,
sat_shift_limit=5),
A.NoOp()
]),
A.HorizontalFlip(p=0.5), #OK
A.ShiftScaleRotate(shift_limit=[0.1, 0.1], scale_limit=[0,0], rotate_limit=[-45, 45], p=0.5, border_mode=cv2.BORDER_CONSTANT, value=(255,255,255)), #OK
A.Downscale(scale_min=0.1, scale_max=0.2, p=0.3), # OK
# A.CoarseDropout(max_holes=5, max_height=100, max_width=100, min_holes=3, min_height=64, min_width=64, p=0.5), # error
A.CLAHE(p=0.5),
A.Resize(height=self.input_h, width=self.input_w, interpolation=cv2.INTER_LINEAR, always_apply=True),
A.Normalize(mean=self.mean, std=self.std, always_apply=True)
],
keypoint_params=A.KeypointParams(format='xy', label_fields=['class_labels'])
)
self.transform_heatmap = A.Compose(
[
A.Resize(height=self.output_h, width=self.output_w, interpolation=cv2.INTER_LINEAR, always_apply=True)
]
, keypoint_params=A.KeypointParams(format='xy')
)
self.transform_test = A.Compose(
[
A.Resize(height=self.input_h, width=self.input_w, interpolation=cv2.INTER_LINEAR, always_apply=True),
A.Normalize(mean=self.mean, std=self.std, always_apply=True)
],
keypoint_params=A.KeypointParams(format='xy')
)
def get_transforms(*, data):
if data == 'train':
import albumentations
return Compose([
albumentations.RandomResizedCrop(CFG.size,
CFG.size,
scale=(0.9, 1),
p=1),
albumentations.HorizontalFlip(p=0.5),
albumentations.ShiftScaleRotate(p=0.5),
albumentations.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=10,
val_shift_limit=10,
p=0.7),
albumentations.RandomBrightnessContrast(brightness_limit=(-0.2,
0.2),
contrast_limit=(-0.2, 0.2),
p=0.7),
albumentations.CLAHE(clip_limit=(1, 4), p=0.5),
albumentations.OneOf([
albumentations.OpticalDistortion(distort_limit=1.0),
albumentations.GridDistortion(num_steps=5, distort_limit=1.),
albumentations.ElasticTransform(alpha=3),
],
p=0.2),
albumentations.OneOf([
albumentations.GaussNoise(var_limit=[10, 50]),
albumentations.GaussianBlur(),
albumentations.MotionBlur(),
albumentations.MedianBlur(),
],
p=0.2),
albumentations.Resize(CFG.size, CFG.size),
albumentations.OneOf([
albumentations.JpegCompression(),
albumentations.Downscale(scale_min=0.1, scale_max=0.15),
],
p=0.2),
albumentations.IAAPiecewiseAffine(p=0.2),
albumentations.IAASharpen(p=0.2),
albumentations.Cutout(max_h_size=int(CFG.size * 0.1),
max_w_size=int(CFG.size * 0.1),
num_holes=5,
p=0.5),
albumentations.Normalize(),
ToTensorV2()
])
# if data == 'train':
# return Compose([
# # Resize(int(CFG.size * 1.25), int(CFG.size * 1.25)),
# #Resize(CFG.size, CFG.size),
# RandomResizedCrop(CFG.size, CFG.size, scale=(0.85, 1.0)),
# # HorizontalFlip(p=0.5),
# # RandomBrightnessContrast(p=0.2, brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2)),
# # HueSaturationValue(p=0.2),
# ShiftScaleRotate(p=0.2, shift_limit=0.0625, scale_limit=0.2, rotate_limit=20),
# # # CoarseDropout(p=0.2), # max_holes=8, max_height=8, max_width=8
# # Cutout(p=0.2, max_h_size=16, max_w_size=16, fill_value=(0., 0., 0.), num_holes=16),
# Normalize(
# mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225],
# ),
# ToTensorV2(),
# ])
elif data == 'valid':
return Compose([
Resize(CFG.size, CFG.size),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
def make_transform(args):
base_transform = [
A.Resize(args.img_size, args.img_size),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2()
]
train_transform = []
if args.Blur:
train_transform.append(A.Blur(p=args.Blur))
if args.Blur:
train_transform.append(A.ElasticTransform(p=args.Blur))
if args.CLAHE:
train_transform.append(
A.CLAHE(clip_limit=(1, 4), tile_grid_size=(8, 8), p=args.CLAHE))
if args.RandomBrightnessContrast:
train_transform.append(
A.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2,
brightness_by_max=True,
p=args.RandomBrightnessContrast))
if args.HueSaturationValue:
train_transform.append(
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=args.HueSaturationValue))
if args.RGBShift:
train_transform.append(
A.RGBShift(r_shift_limit=20,
g_shift_limit=20,
b_shift_limit=20,
p=args.RGBShift))
if args.RandomGamma:
train_transform.append(
A.RandomGamma(gamma_limit=(80, 120), p=args.RandomGamma))
if args.HorizontalFlip:
train_transform.append(A.HorizontalFlip(p=args.HorizontalFlip))
if args.VerticalFlip:
train_transform.append(A.VerticalFlip(p=args.VerticalFlip))
if args.ShiftScaleRotate:
train_transform.append(
A.ShiftScaleRotate(shift_limit=0.2,
scale_limit=0.2,
rotate_limit=10,
border_mode=args.ShiftScaleRotateMode,
p=args.ShiftScaleRotate))
if args.GridDistortion:
train_transform.append(
A.GridDistortion(num_steps=5,
distort_limit=(-0.3, 0.3),
p=args.GridDistortion))
if args.MotionBlur:
train_transform.append(
A.MotionBlur(blur_limit=(3, 7), p=args.MotionBlur))
if args.RandomResizedCrop:
train_transform.append(
A.RandomResizedCrop(height=args.img_size,
width=args.img_size,
scale=(-0.4, 1.0),
ratio=(0.75, 1.3333333333333333),
p=args.RandomResizedCrop))
if args.ImageCompression:
train_transform.append(
A.ImageCompression(quality_lower=99,
quality_upper=100,
p=args.ImageCompression))
train_transform.extend(base_transform)
train_transform = A.Compose(train_transform)
test_transform = A.Compose(base_transform)
return train_transform, test_transform
Image.open(
os.path.join(CONFIG.INPUT_PATH, 'masks',
self.image_name[idx] + extention)))
image = self.image_transforms(image=image)['image']
mask = self.mask_transforms(image=mask)['image']
mask = mask.unsqueeze(0)
return {'original_image': image, 'mask': mask}
if __name__ == "__main__":
path = CONFIG.INPUT_PATH
x_ray_image_names = os.listdir(path + '/CXR_png/')
images_name = []
for name in x_ray_image_names:
images_name.append(name.split('.')[0])
image_transforms = alb.Compose([
alb.Normalize(CONFIG.mean, CONFIG.std, always_apply=True),
alb.Resize(572, 572, always_apply=True),
alb.pytorch.ToTensor()
])
segmented_transforms = alb.Compose(
[alb.Resize(388, 388, always_apply=True),
ToTensor()])
dataloder = DataLoader(images_name, image_transforms, segmented_transforms)
for data in dataloder:
a = data['original_image']
b = data['mask']
print(a.shape, b.shape)
break
if __name__ == '__main__':
import pandas as pd
import os
import torch
from torch.utils.data import DataLoader
from constants import SHUFFLE_DATASET, VALIDATION_SPLIT, IDX2LABELS, IMAGE_SIZE_SMALL
import albumentations
df_train = pd.read_csv(os.path.join('data', 'train.csv'))
print(df_train.head())
transforms = albumentations.Compose([
albumentations.Normalize(mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5)),
albumentations.GridDistortion(p=0.2),
albumentations.HorizontalFlip(p=0.2),
albumentations.ShiftScaleRotate(p=0.2),
])
cloud_dataset = CloudDataset(df_train, transforms, output_img_shape=IMAGE_SIZE_SMALL)
# Creating indices for train and test set
dataset_size = len(cloud_dataset)
indices = list(range(dataset_size))
split = int(np.floor(VALIDATION_SPLIT * dataset_size))
if SHUFFLE_DATASET:
# np.random.seed(42)
np.random.shuffle(indices)
train_indices, val_indices = indices[split:], indices[:split]
train_sampler = torch.utils.data.sampler.SubsetRandomSampler(train_indices)
seed_everything(21)
# train.json / validation.json / test.json 디렉토리 설정
# dataset_path = "./input/data"
dataset_path = "/opt/ml/input/data"
train_path = dataset_path + "/train.json"
val_path = dataset_path + "/val.json"
all_path = dataset_path + "/train_all.json"
test_path = dataset_path + "/test.json"
kfold_train_path = [f"{dataset_path}/train_data{i}.json" for i in range(5)]
kfold_val_path = [f"{dataset_path}/valid_data{i}.json" for i in range(5)]
# augmentations
_train_transform = [
A.Resize(256, 256),
A.Normalize(mean=(0.4611, 0.4403, 0.4193), std=(0.2107, 0.2074, 0.2157)),
ToTensorV2(),
]
_valid_transform = [
A.Resize(256, 256),
A.Normalize(mean=(0.4611, 0.4403, 0.4193), std=(0.2107, 0.2074, 0.2157)),
ToTensorV2(),
]
_test_transform = [
A.Resize(256, 256),
A.Normalize(mean=(0.4611, 0.4403, 0.4193), std=(0.2107, 0.2074, 0.2157)),
ToTensorV2(),
]
A.ImageCompression(quality_lower=99, quality_upper=100),
A.ShiftScaleRotate(shift_limit=0.2,
scale_limit=0.2,
rotate_limit=10,
border_mode=0,
p=0.5),
A.ColorJitter(0.2, 0.2, 0.2, 0.2),
A.Resize(args.max_size, args.max_size),
A.OneOf([
A.RandomResizedCrop(args.max_size, args.max_size),
A.Cutout(max_h_size=int(args.max_size * 0.4),
max_w_size=int(args.max_size * 0.4),
num_holes=1,
p=0.3),
]),
A.Normalize(mean=(0.4452, 0.4457, 0.4464), std=(0.2592, 0.2596, 0.2600)),
ToTensorV2(),
])
print('Loading dataset...')
train_dataset = LandmarkDataset(transforms_train)
train_loader = DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers)
print('Loading model...')
# model = EfficientNetLandmark(1, args.num_classes)
model = ResNext101Landmark(args.num_classes)
model.cuda()
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
#A.Transpose(p=0.5),
#A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=30,
# border_mode=cv2.BORDER_CONSTANT, value=[255,255,255], p=0.8),
#A.GridDistortion(p=0.5),
#A.RandomBrightnessContrast(p=0.5),
#A.RandomCrop(int(options.tilesize*1.5),
# int(options.tilesize*1.5),
# always_apply=True, p=1.0),
])
mean_img = [0.485, 0.456, 0.406]
std_img = [0.229, 0.224, 0.225]
transform_norm = A.Compose([
A.Normalize(mean=mean_img, std=std_img, max_pixel_value=255.0, p=1.0),
ToTensor()
])
Image.fromarray(trn_transforms(image=img)['image'])
# Lets load a model
model = timm.create_model('mixnet_l', pretrained=True)
# Downloads to /Users/dhanley/.cache/torch/checkpoints/mixnet_xl_ra-aac3c00c.pth
# Normalise the image
x = transform_norm(image=img)['image']
x.shape
type(x)
x[:10, :10, 0]
pd.Series(x.flatten()).hist(bins=100)
def albu(use_pretrained):
if use_pretrained == True:
transform = {
"train":
A.Compose([
# A.OneOf([
# A.ShiftScaleRotate(always_apply=False, p=0.3, shift_limit=(0.0, 0.0), scale_limit=(0.0, 0.0), rotate_limit=(-10, 10), interpolation=0, border_mode=0, value=(0, 0, 0), mask_value=None),
# A.ShiftScaleRotate(always_apply=False, p=0.3, shift_limit=(-0.1, 0.1), scale_limit=(0.0, 0.0), rotate_limit=(0, 0), interpolation=0, border_mode=0, value=(0, 0, 0), mask_value=None),
# A.ShiftScaleRotate(always_apply=False, p=0.3, shift_limit=(0.0, 0.0), scale_limit=(-0.1, 0.1), rotate_limit=(0, 0), interpolation=0, border_mode=0, value=(0, 0, 0), mask_value=None),
# A.ShiftScaleRotate(always_apply=False, p=0.1, shift_limit=(-0.1, 0.1), scale_limit=(-0.1, 0.1), rotate_limit=(-10, 10), interpolation=0, border_mode=0, value=(0, 0, 0), mask_value=None),
# ],p=1.0),
# A.InvertImg(always_apply=False, p=0.5),
A.Resize(width=224, height=224),
A.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
ToTensorV2(),
]),
"val":
A.Compose([
# A.InvertImg(always_apply=False, p=0.5),
A.Resize(width=224, height=224),
A.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
ToTensorV2(),
])
}
return transform
transform = {
"train":
A.Compose([
A.OneOf([
A.ShiftScaleRotate(always_apply=False,
p=0.3,
shift_limit=(0.0, 0.0),
scale_limit=(0.0, 0.0),
rotate_limit=(-10, 10),
interpolation=0,
border_mode=0,
value=(0, 0, 0),
mask_value=None),
A.ShiftScaleRotate(always_apply=False,
p=0.3,
shift_limit=(-0.1, 0.1),
scale_limit=(0.0, 0.0),
rotate_limit=(0, 0),
interpolation=0,
border_mode=0,
value=(0, 0, 0),
mask_value=None),
A.ShiftScaleRotate(always_apply=False,
p=0.3,
shift_limit=(0.0, 0.0),
scale_limit=(-0.1, 0.1),
rotate_limit=(0, 0),
interpolation=0,
border_mode=0,
value=(0, 0, 0),
mask_value=None),
A.ShiftScaleRotate(always_apply=False,
p=0.1,
shift_limit=(-0.1, 0.1),
scale_limit=(-0.1, 0.1),
rotate_limit=(-10, 10),
interpolation=0,
border_mode=0,
value=(0, 0, 0),
mask_value=None),
],
p=1.0),
# A.InvertImg(always_apply=False, p=0.5),
A.Resize(width=32, height=32),
ToTensorV2(),
]),
"val":
A.Compose([
# A.InvertImg(always_apply=False, p=0.5),
A.Resize(width=32, height=32),
ToTensorV2()
])
}
return transform
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),
A.Normalize(mean=(0.08069, 0.05258, 0.05487),
std=(0.13704, 0.10145, 0.15313),
max_pixel_value=255.)
])
val_aug = A.Compose([
A.HorizontalFlip(p=0.5),
A.Normalize(mean=(0.08069, 0.05258, 0.05487),
std=(0.13704, 0.10145, 0.15313),
max_pixel_value=255.)
])
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),
train_targets = train_csv.target.values
# test data
test_csv = pd.read_csv(root_dir + 'test.csv')
images_id_test = test_csv.image_name.values.tolist()
test_images = [
os.path.join(root_dir + 'test/', i + '.jpg') for i in images_id_test
]
test_targets = test_csv.target.values
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
# adding a simple augmentation
aug = albumentations.Compose([
albumentations.Normalize(mean,
std,
max_pixel_value=255.0,
always_apply=True)
])
# Loading customDataset and
train_dataset = ClassificationDataset(image_paths=train_images,
targets=train_targets,
resize=(224, 224),
augmentations=aug)
test_dataset = ClassificationDataset(image_paths=test_images,
targets=test_targets,
resize=(224, 224),
augmentations=aug)
train_loader = DataLoader(train_dataset,
batch_size=16,
def train(config, device='cuda:0', save_chkpt=True):
''' procedure launching all main functions of training,
validation and testing pipelines'''
# for pipeline testing purposes
save_chkpt = False if config.test_steps else True
# preprocessing data
normalize = A.Normalize(**config.img_norm_cfg)
train_transform_real = A.Compose([
A.Resize(**config.resize, interpolation=cv.INTER_CUBIC),
A.HorizontalFlip(p=0.5),
A.augmentations.transforms.ISONoise(color_shift=(0.15, 0.35),
intensity=(0.2, 0.5),
p=0.2),
A.augmentations.transforms.RandomBrightnessContrast(
brightness_limit=0.2,
contrast_limit=0.2,
brightness_by_max=True,
always_apply=False,
p=0.3),
A.augmentations.transforms.MotionBlur(blur_limit=5, p=0.2), normalize
])
train_transform_spoof = A.Compose([
A.Resize(**config.resize, interpolation=cv.INTER_CUBIC),
A.HorizontalFlip(p=0.5),
A.augmentations.transforms.ISONoise(color_shift=(0.15, 0.35),
intensity=(0.2, 0.5),
p=0.2),
A.augmentations.transforms.RandomBrightnessContrast(
brightness_limit=0.2,
contrast_limit=0.2,
brightness_by_max=True,
always_apply=False,
p=0.3),
A.augmentations.transforms.MotionBlur(blur_limit=5, p=0.2), normalize
])
val_transform = A.Compose(
[A.Resize(**config.resize, interpolation=cv.INTER_CUBIC), normalize])
# load data
sampler = config.data.sampler
if sampler:
num_instances, weights = make_weights(config)
sampler = torch.utils.data.WeightedRandomSampler(weights,
num_instances,
replacement=True)
train_transform = Transform(train_spoof=train_transform_spoof,
train_real=train_transform_real,
val=None)
val_transform = Transform(train_spoof=None,
train_real=None,
val=val_transform)
train_dataset, val_dataset, test_dataset = make_dataset(
config, train_transform, val_transform)
train_loader, val_loader, test_loader = make_loader(train_dataset,
val_dataset,
test_dataset,
config,
sampler=sampler)
# build model and put it to cuda and if it needed then wrap model to data parallel
model = build_model(config, device=device, strict=False, mode='train')
model.to(device)
if config.data_parallel.use_parallel:
model = torch.nn.DataParallel(model,
**config.data_parallel.parallel_params)
# build a criterion
softmax = build_criterion(config, device, task='main').to(device)
cross_entropy = build_criterion(config, device, task='rest').to(device)
bce = nn.BCELoss().to(device)
criterion = (softmax, cross_entropy,
bce) if config.multi_task_learning else softmax
# build optimizer and scheduler for it
optimizer = torch.optim.SGD(model.parameters(), **config.optimizer)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
**config.scheduler)
# create Trainer object and get experiment information
trainer = Trainer(model, criterion, optimizer, device, config,
train_loader, val_loader, test_loader)
trainer.get_exp_info()
# learning epochs
for epoch in range(config.epochs.start_epoch, config.epochs.max_epoch):
if epoch != config.epochs.start_epoch:
scheduler.step()
# train model for one epoch
train_loss, train_accuracy = trainer.train(epoch)
print(
f'epoch: {epoch} train loss: {train_loss} train accuracy: {train_accuracy}'
)
# validate your model
accuracy = trainer.validate()
# eval metrics such as AUC, APCER, BPCER, ACER on val and test dataset according to rule
trainer.eval(epoch, accuracy, save_chkpt=save_chkpt)
# for testing purposes
if config.test_steps:
exit()
# evaluate in the end of training
if config.evaluation:
file_name = 'tests.txt'
trainer.test(file_name=file_name)
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))
A.Normalize(mean=(0.1174382, 0.06798691, 0.06592218),
std=(0.16392466, 0.10036821, 0.16703453),
max_pixel_value=255.)
])
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
)
def evaluate_model(dataset_path, model_path):
checkpoint_path = load_best_model(model_path)
config_path = os.path.join(os.path.dirname(checkpoint_path), "..",
"config.yaml")
net_config = NetConfig(config_path)
test_data, test_images = load_dataset(dataset_path, "Test", "test.json")
test_dict = {"labels": test_data, "images": test_images}
eval_transforms = A.Compose([
A.LongestMaxSize(net_config.base_size, always_apply=True),
A.PadIfNeeded(net_config.base_size,
net_config.base_size,
always_apply=True,
border_mode=cv2.BORDER_CONSTANT),
A.Normalize(),
ToTensorV2()
])
model = VisualControl.load_from_checkpoint(
checkpoint_path=checkpoint_path,
dataset_path=dataset_path,
lr=5e-2,
base_size=net_config.base_size,
batch_size=net_config.batch_size,
net_config=net_config)
# prints the learning_rate you used in this checkpoint
device = "cuda:0"
model.to(device)
model.eval()
model.freeze()
results = {}
visualize = False
save = False
output_dir = "visual_results"
if save:
if os.path.exists(output_dir):
raise Exception("output dir already exists")
os.mkdir(output_dir)
for batch_idx in tqdm(
range(0, len(test_dict["labels"]), net_config.batch_size)):
images_batch = []
labels = []
raw_images = []
for idx in range(
batch_idx,
min(batch_idx + net_config.batch_size,
len(test_dict["labels"]))):
image_path = os.path.join(dataset_path, "Test", "Images",
test_dict["images"][idx])
image = cv2.imread(image_path)
raw_images.append(image)
x = eval_transforms(image=image)
y = net_config.encode(test_dict["labels"][idx])
images_batch.append(x["image"])
labels.append(y)
predictions = model(default_collate(images_batch).to(device))
for idx in range(0, len(predictions)):
# d = encoder.get_smooth_estimation(predictions[idx].cpu().numpy())
if net_config.head_type == NetConfig.CLASSIFICATION_TYPE:
y_hat = from_logit_to_estimation(predictions[idx], net_config)
else:
y_hat = predictions[idx].cpu().numpy()
y = labels[idx]
results[idx + batch_idx] = {"label": y, "prediction": y_hat}
if visualize or save:
if visualize:
print("-----------------")
print(y)
print(y_hat)
image_labels = add_labels_to_image(raw_images[idx], y, y_hat)
if net_config.head_type == NetConfig.CLASSIFICATION_TYPE:
class_idx = from_one_hot_to_class(y_hat, net_config)
motors_info = net_config.get_real_values_from_estimation(
class_idx)
else:
motors_info = {"w": y_hat[0], "v": y_hat[1]}
image_labels = add_arrow_prediction(image_labels, motors_info)
if visualize:
cv2.imshow("Test", image_labels)
cv2.waitKey(0)
if save:
output_file = os.path.join(
output_dir, "{}.jpg".format(idx + batch_idx))
cv2.imwrite(output_file, image_labels)
if net_config.head_type == NetConfig.CLASSIFICATION_TYPE:
final_stats = {}
gt = [results[x]["label"] for x in results]
pred = [results[x]["prediction"] for x in results]
acc = accuracy_score(gt, pred)
acc2 = accuracy_score(gt, pred, normalize=False)
print(acc)
print("Global accuracy: {}/{}".format(acc2, len(gt)))
final_stats["acc"] = acc
final_stats["hits"] = int(acc2)
final_stats["dataset_size"] = len(gt)
for controller in net_config.classification_data:
base_idx = 0
if controller == "v" and "w" in net_config.classification_data:
base_idx = len(net_config.classification_data['w']['classes'])
indexes = net_config.softmax_config[controller]
controller_labels = []
for current_label in gt:
controller_label = [current_label[i]
for i in indexes].index(1.0)
controller_labels.append(controller_label)
controller_preds = []
for controller_pred in pred:
controller_preds.append([controller_pred[i]
for i in indexes].index(1.0))
acc1 = np.count_nonzero(
np.abs(
np.array(controller_preds) -
np.array(controller_labels)) == 0)
acc2 = np.count_nonzero(
np.abs(
np.array(controller_preds) -
np.array(controller_labels)) <= 1)
current_stats = {
"acc1": acc1 / len(controller_preds),
"acc2": acc2 / len(controller_preds)
}
final_stats[controller] = current_stats
out_json_stats = os.path.join(os.path.dirname(checkpoint_path), "..",
"stats.json")
json.dump(final_stats, open(out_json_stats, "w"), indent=4)
# confusion matrices
try:
final_data = {}
for current_data in results:
gt = results[current_data]["label"]
pred = results[current_data]["prediction"]
class_data_gt = from_one_hot_to_class(gt, net_config)
class_data_pred = from_one_hot_to_class(pred, net_config)
for output_key in class_data_gt:
if output_key not in final_data:
final_data[output_key] = {
"label": [],
"prediction": []
}
final_data[output_key]["label"].append(
class_data_gt[output_key])
final_data[output_key]["prediction"].append(
class_data_pred[output_key])
fig, axs = plt.subplots(1, 2)
fig.set_size_inches(15, 7, forward=True)
for idx, output_key in enumerate(final_data):
ax = axs[idx]
a = confusion_matrix(
final_data[output_key]["label"],
final_data[output_key]["prediction"],
normalize="true",
labels=net_config.get_str_labels()[output_key])
plot_confusion_matrix(
a,
classes=net_config.get_str_labels()[output_key],
title=output_key,
ax=ax)
plt.tight_layout()
output_image_path = os.path.join(os.path.dirname(checkpoint_path),
"..", "confusion_matrix.png")
plt.savefig(output_image_path)
except Exception as exc:
print(Exception)
else:
stats = {}
for result in results:
current_result = results[result]
for idx_controller, controller in enumerate(
net_config.regression_data["controllers"]):
current_diff = np.square(
current_result["label"][idx_controller] -
current_result["prediction"][idx_controller])
if controller not in stats:
stats[controller] = []
stats[controller].append(current_diff)
final_stats = {}
for controller in net_config.regression_data["controllers"]:
final_stats[controller] = {
"rmse": float(np.square(np.mean(stats[controller])))
}
out_json_stats = os.path.join(os.path.dirname(checkpoint_path), "..",
"stats.json")
json.dump(final_stats, open(out_json_stats, "w"), indent=4)
def main(args):
writer = SummaryWriter(comment=args.exp_name)
os.makedirs(args.weights, exist_ok=True)
norm_mean, norm_std = normalization_isic_seg
train_transform = A.Compose([
A.Resize(args.size, args.size, cv2.INTER_CUBIC),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Rotate(limit=(-180, 180),
interpolation=cv2.INTER_CUBIC,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0,
p=1),
A.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0,
rotate_limit=0,
interpolation=cv2.INTER_CUBIC,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0),
A.ShiftScaleRotate(shift_limit=0,
scale_limit=(0.95, 1.25),
rotate_limit=0,
interpolation=cv2.INTER_CUBIC,
border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0),
A.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1),
A.GaussianBlur(blur_limit=(3, 5)),
A.GaussNoise(var_limit=(10, 40)),
A.ElasticTransform(border_mode=cv2.BORDER_CONSTANT,
value=0,
mask_value=0),
A.CoarseDropout(),
A.Normalize(norm_mean, norm_std),
ToTensorV2(),
])
valid_test_transform = A.Compose([
A.Resize(args.size, args.size, cv2.INTER_CUBIC),
A.Normalize(norm_mean, norm_std),
ToTensorV2(),
])
train_dataset = YAMLSegmentationDataset(dataset=args.in_ds,
transform=train_transform,
split=['training'])
valid_dataset = YAMLSegmentationDataset(dataset=args.in_ds,
transform=valid_test_transform,
split=['validation'])
test_dataset = YAMLSegmentationDataset(
dataset=args.in_ds,
transform=valid_test_transform,
split=['test'],
)
train_dataloader = DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
drop_last=True,
pin_memory=True)
valid_dataloader = DataLoader(valid_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
drop_last=False,
pin_memory=True)
test_dataloader = DataLoader(test_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
drop_last=False,
pin_memory=True)
dataloaders = {
'train': train_dataloader,
'valid': valid_dataloader,
'test': test_dataloader
}
device = torch.device('cpu' if not args.gpu else 'cuda')
# Model, loss, optimizer
print('Loading model...')
model = SkinLesionModel(args.model)
if args.onnx_export:
# export onnx
dummy_input = torch.ones(4, 3, args.size, args.size, device='cpu')
model.train()
torch.onnx.export(
model,
dummy_input,
f'{args.model}.onnx',
verbose=True,
export_params=True,
training=torch.onnx.TrainingMode.TRAINING,
opset_version=12,
do_constant_folding=False,
input_names=['input'],
output_names=['output'],
dynamic_axes={
'input': {
0: 'batch_size'
}, # variable length axes
'output': {
0: 'batch_size'
}
})
if torch.cuda.device_count() > 1 and args.gpu:
model = torch.nn.DataParallel(
model, device_ids=np.where(np.array(args.gpu) == 1)[0])
print(f'Move model to {device}')
model = model.to(device)
# loss_fn = nn.modules.loss.BCEWithLogitsLoss()
loss_fn = smp.losses.DiceLoss('binary')
# optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, momentum=0.9, nesterov=True)
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate)
# optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, eps=1e-5)
metric_fn = smp.utils.metrics.IoU(threshold=0.5)
if args.ckpts is None:
best_valid_iou = 0.
load_epoch = 0
else:
checkpoint = torch.load(args.ckpts)
model.load_state_dict(checkpoint['state_dict'])
load_epoch = checkpoint['epoch']
optimizer.load_state_dict(checkpoint['optimizer'])
best_valid_iou = checkpoint['best_metric']
print('Loaded checkpoint epoch ', load_epoch, ' with best metric ',
best_valid_iou)
if args.train:
valid_iou = 0
print('Starting training')
for epoch in range(load_epoch, args.epochs):
loss_train = []
loss_valid = []
for phase in ['train', 'valid']:
if phase == 'train':
model.train()
else:
model.eval()
iou_scores = np.array([])
with tqdm(desc=f'{phase} {epoch}/{args.epochs - 1}',
unit='batch',
total=len(dataloaders[phase]),
file=sys.stdout) as pbar:
for i, (x, gt,
original_shape) in enumerate(dataloaders[phase]):
# torchvision.utils.save_image(x, f'batch_{i}.jpg')
x, gt = x.to(device), gt.to(device,
dtype=torch.float32)
with torch.set_grad_enabled(phase == 'train'):
pred = model(x)
loss = loss_fn(pred, gt)
loss_item = loss.item()
pred, gt = torch.sigmoid(
pred.detach()), gt.detach()
if phase == 'train':
optimizer.zero_grad()
loss.backward()
optimizer.step()
loss_train.append(loss_item)
elif phase == 'valid':
loss_valid.append(loss_item)
# Upsampling(pred, gt, original_shape)
iou = metric_fn(pred, gt).item()
iou_scores = np.append(iou_scores, iou)
pbar.set_postfix(loss=loss_item,
IoU=iou_scores.mean())
pbar.update()
pbar.refresh()
iou = iou_scores.mean()
if phase == 'train':
train_iou = iou
writer.add_scalar(f'{phase}/loss', np.mean(loss_train),
epoch)
writer.add_scalar(f'{phase}/iou', train_iou, epoch)
writer.add_images(f'{phase}/images',
Denormalize(x, norm_mean, norm_std),
epoch)
writer.add_images(f'{phase}/prediction', pred, epoch)
else:
valid_iou = iou
writer.add_scalar(f'{phase}/loss', np.mean(loss_valid),
epoch)
writer.add_scalar(f'{phase}/iou', valid_iou, epoch)
grid = torchvision.utils.make_grid(
Denormalize(x, norm_mean, norm_std))
writer.add_image(f'{phase}/images', grid, epoch)
grid = torchvision.utils.make_grid(pred)
writer.add_image(f'{phase}/prediction', grid, epoch)
if valid_iou > best_valid_iou:
best_valid_iou = valid_iou
state = {
'epoch': epoch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'best_metric': best_valid_iou
}
torch.save(state,
os.path.join(args.weights, f'{args.model}.pth'))
elif args.test:
model.eval()
iou_scores = np.array([])
for i, (x, gt, original_shape) in enumerate(dataloaders['test']):
x, gt = x.to(device), gt.to(device, dtype=torch.float32)
pred = model(x)
pred, gt = torch.sigmoid(pred.detach()), gt.detach()
iou = metric_fn(pred, gt).item()
iou_scores = np.append(iou_scores, iou)
iou = iou_scores.mean()
print(f'Test IoU: {iou:.3f}')
def experiment(device, args=None):
"""Train model.
Args:
device (str): device to use for training.
args (dict): experiment arguments.
"""
if args is None:
args = dict
train_config = args["train"]
train_augmentations = albu.Compose(
[
albu.OneOf([
albu.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=35,
val_shift_limit=25),
albu.RandomGamma(),
albu.CLAHE(),
]),
albu.RandomBrightnessContrast(brightness_limit=[-0.3, 0.3],
contrast_limit=[-0.3, 0.3],
p=0.5),
albu.OneOf([
albu.Blur(),
albu.MotionBlur(),
albu.GaussNoise(),
albu.ImageCompression(quality_lower=75)
]),
albu.ShiftScaleRotate(shift_limit=0.0625,
scale_limit=0.15,
rotate_limit=10,
border_mode=0,
p=0.5),
albu.Resize(300, 300),
albu.Normalize(),
ToTensorV2(),
],
bbox_params=albu.BboxParams(
"albumentations"
), # 'albumentations' because x1, y1, x2, y2 in range [0, 1]
)
train_dataset = COCOFileDataset(train_config["annotations"],
train_config["images_dir"],
transforms=train_augmentations)
train_loader = DataLoader(
train_dataset,
batch_size=train_config["batch_size"],
num_workers=train_config["num_workers"],
shuffle=True,
drop_last=True,
)
logger.info("Train dataset information:")
logger.info("\n" + train_dataset.info())
valid_config = args["validation"]
valid_augmentations = albu.Compose(
[
albu.Resize(300, 300),
albu.Normalize(),
ToTensorV2(),
],
bbox_params=albu.BboxParams(
format="albumentations"
), # 'albumentations' because x1, y1, x2, y2 in range [0, 1]
)
valid_dataset = COCOFileDataset(valid_config["annotations"],
valid_config["images_dir"],
transforms=valid_augmentations)
valid_loader = DataLoader(
valid_dataset,
batch_size=valid_config["batch_size"],
num_workers=valid_config["num_workers"],
shuffle=False,
drop_last=False,
)
logger.info("Validation dataset information:")
logger.info("\n" + valid_dataset.info())
model_config = args["model"]
num_classes = model_config["num_classes"] + 1 # +1 for background class
seed_all(42)
model = SSD300(model_config["backbone"], num_classes)
model = model.to(device)
optimizer = optim.AdamW(model.parameters(), lr=1e-3 / 2)
# optimizer = optim.SGD(model.parameters(), lr=2.6e-3, momentum=0.9, weight_decay=0.0005)
epoch_scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(
optimizer, args["experiment"]["num_epochs"])
batch_scheduler = None
criterion = Loss(num_classes)
experiment_config = args["experiment"]
num_epochs = experiment_config["num_epochs"]
for epoch_idx in range(1, num_epochs + 1):
logger.info(f"Epoch: {epoch_idx}/{num_epochs}")
train_metrics = train_fn(train_loader,
model,
device,
criterion,
optimizer,
batch_scheduler,
verbose=False)
logger.info(f" Train: {train_metrics}")
# TODO: checkpoints
valid_metrics = valid_fn(valid_loader,
model,
device,
criterion,
verbose=False)
logger.info(f"Validation: {valid_metrics}")
epoch_scheduler.step()
export_to_onnx(model, torch.randn(1, 3, 300, 300),
experiment_config["onnx"])
logger.info("Exported ONNX model to '{}'".format(
experiment_config["onnx"]))
alb.IAAAdditiveGaussianNoise(loc=0,
scale=(2.5500000000000003, 12.75),
per_channel=False,
p=0.5),
alb.IAAAffine(scale=1.0,
translate_percent=None,
translate_px=None,
rotate=0.0,
shear=0.0,
order=1,
cval=0,
mode='reflect',
p=0.5),
alb.IAAAffine(rotate=90., p=0.5),
alb.IAAAffine(rotate=180., p=0.5),
alb.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
ToTensorV2()
])
train_set = NoisyStudentDataset(ranzcr_train_df,
chestx_df,
train_image_transforms,
'../ranzcr/train',
'../data',
width_size=width_size)
train_loader = DataLoader(train_set,
batch_size=batch_size,
shuffle=True,
num_workers=12,
drop_last=True)
ranzcr_valid_df = ranzcr_df[ranzcr_df['fold'] == 1]
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--local_rank",
type=int,
default=-1,
help="local_rank for distributed training on gpus")
args = parser.parse_args()
torch.cuda.set_device(args.local_rank)
device = torch.device("cuda", args.local_rank)
torch.distributed.init_process_group(backend="nccl")
args.device = device
seed = 2001
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
# prepare input
import pickle
with open('../process_input/split2/image_list_train.pickle', 'rb') as f:
image_list_train = pickle.load(f)
with open('../process_input/split2/image_dict.pickle', 'rb') as f:
image_dict = pickle.load(f)
with open('../lung_localization/split2/bbox_dict_train.pickle', 'rb') as f:
bbox_dict_train = pickle.load(f)
print(len(image_list_train), len(image_dict), len(bbox_dict_train))
# hyperparameters
learning_rate = 0.0004
batch_size = 32
image_size = 576
num_epoch = 1
# build model
if args.local_rank != 0:
torch.distributed.barrier()
model = seresnext50()
if args.local_rank == 0:
torch.distributed.barrier()
model.to(args.device)
num_train_steps = int(
len(image_list_train) / (batch_size * 4) * num_epoch) # 4 GPUs
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
scheduler = get_linear_schedule_with_warmup(
optimizer, num_warmup_steps=0, num_training_steps=num_train_steps)
model, optimizer = amp.initialize(model,
optimizer,
opt_level="O1",
verbosity=0)
model = torch.nn.parallel.DistributedDataParallel(
model,
device_ids=[args.local_rank],
output_device=args.local_rank,
find_unused_parameters=True)
criterion = nn.BCEWithLogitsLoss().to(args.device)
# training
train_transform = albumentations.Compose([
albumentations.RandomContrast(limit=0.2, p=1.0),
albumentations.ShiftScaleRotate(shift_limit=0.2,
scale_limit=0.2,
rotate_limit=20,
border_mode=cv2.BORDER_CONSTANT,
p=1.0),
albumentations.Cutout(num_holes=2,
max_h_size=int(0.4 * image_size),
max_w_size=int(0.4 * image_size),
fill_value=0,
always_apply=True,
p=1.0),
albumentations.Normalize(mean=(0.456, 0.456, 0.456),
std=(0.224, 0.224, 0.224),
max_pixel_value=255.0,
p=1.0)
])
# iterator for training
datagen = PEDataset(image_dict=image_dict,
bbox_dict=bbox_dict_train,
image_list=image_list_train,
target_size=image_size,
transform=train_transform)
sampler = DistributedSampler(datagen)
generator = DataLoader(dataset=datagen,
sampler=sampler,
batch_size=batch_size,
num_workers=5,
pin_memory=True)
for ep in range(num_epoch):
losses = AverageMeter()
model.train()
for j, (images, labels) in enumerate(generator):
images = images.to(args.device)
labels = labels.float().to(args.device)
logits = model(images)
loss = criterion(logits.view(-1), labels)
losses.update(loss.item(), images.size(0))
optimizer.zero_grad()
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
optimizer.step()
scheduler.step()
if args.local_rank == 0:
print('epoch: {}, train_loss: {}'.format(ep, losses.avg),
flush=True)
if args.local_rank == 0:
out_dir = 'weights/'
if not os.path.exists(out_dir):
os.makedirs(out_dir)
torch.save(model.module.state_dict(),
out_dir + 'epoch{}'.format(ep))
albtransforms.PadIfNeeded(min_height=40,
min_width=40,
border_mode=4,
value=[0, 0, 0],
always_apply=False,
p=1.),
#albtransforms.RandomCrop(32,32,always_apply=False, p=1.0),
albtransforms.RandomCrop(32, 32, always_apply=False, p=1.),
#albtransforms.HorizontalFlip(1.0),
albtransforms.HorizontalFlip(0.5),
albtransforms.Cutout(num_holes=8,
max_h_size=8,
max_w_size=8,
always_apply=False,
p=0.1),
A.Normalize(*stats),
ToTensor()
])
test_transform = A.Compose([A.Normalize(*stats), ToTensor()])
# loaded only when loaddata() invoked
trainset = None
trainloader = None
testset = None
testloader = None
def __custom_getitem__(self, index):
image, label = self.data[index], self.targets[index]
if self.transform is not None:
# ##############################
# Setup Dataflow
# ##############################
assert "DATASET_PATH" in os.environ
data_path = os.environ["DATASET_PATH"]
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
train_transforms = A.Compose([
A.RandomResizedCrop(train_crop_size, train_crop_size, scale=(0.08, 1.0)),
A.HorizontalFlip(),
A.CoarseDropout(max_height=32, max_width=32),
A.HueSaturationValue(),
A.Normalize(mean=mean, std=std),
ToTensor(),
])
val_transforms = A.Compose([
# https://github.com/facebookresearch/FixRes/blob/b27575208a7c48a3a6e0fa9efb57baa4021d1305/imnet_resnet50_scratch/transforms.py#L76
A.Resize(int((256 / 224) * val_crop_size), int(
(256 / 224) * val_crop_size)),
A.CenterCrop(val_crop_size, val_crop_size),
A.Normalize(mean=mean, std=std),
ToTensor(),
])
train_loader, val_loader, train_eval_loader = get_train_val_loaders(
data_path,
train_transforms=train_transforms,
def get_aug(aug_type: str = "val",
task: str = "denoise",
dataset: str = "cifar100",
size: int = 64):
"""
Args:
aug_type: {`val`, `test`, `light`, `medium`}
task: {"denoise", "deblur", "sr"}
dataset: Name of dataset to get MEAN and STD
size: final size of the crop
"""
assert aug_type in ["val", "test", "light", "medium"]
# Add the same noise for all channels for single-channel images
mean, std, max_value = MEAN_STD_BY_NAME[dataset]
if dataset == "medicaldecathlon":
singlechannel = True
normalization = albu.NoOp()
noise = GaussNoiseNoClipping(
singlechannel,
var_limit=0.1,
)
else:
singlechannel = False
normalization = albu.Normalize(mean=mean,
std=std,
max_pixel_value=max_value)
noise = albu.MultiplicativeNoise(multiplier=(0.75, 1.25),
per_channel=True,
elementwise=True)
NORM_TO_TENSOR = albu.Compose(
[normalization, albu_pt.ToTensorV2()],
additional_targets={"mask": "image"})
CROP_AUG = albu.Compose([
albu.PadIfNeeded(size, size),
albu.RandomResizedCrop(size, size, scale=(0.5, 1.)),
])
if task == "deblur":
TASK_AUG = albu.OneOf(
[
albu.Blur(blur_limit=(3, 5)),
albu.GaussianBlur(blur_limit=(3, 5)),
# albu.MotionBlur(),
# albu.MedianBlur(),
# albu.GlassBlur(),
],
p=1.0)
elif task == "denoise":
# TASK_AUG = noise
TASK_AUG = albu.OneOf(
[
noise,
# albu.GaussNoise(),
# GaussNoiseNoClipping(singlechannel, var_limit=0.1 if singlechannel else (20., 50.)),
# albu.GlassBlur(),
# albu.ISONoise(),
# albu.MultiplicativeNoise(),
],
p=1.0)
elif task == "sr":
TASK_AUG = albu.Downscale(scale_min=0.5,
scale_max=0.5,
interpolation=cv2.INTER_CUBIC,
always_apply=True)
else:
raise ValueError("Name of task must be in {'deblur', 'denosie', 'sr'}")
VAL_AUG = albu.Compose([
albu.PadIfNeeded(size, size),
albu.CenterCrop(size, size),
TASK_AUG,
NORM_TO_TENSOR,
])
LIGHT_AUG = albu.Compose([
CROP_AUG,
TASK_AUG,
NORM_TO_TENSOR,
])
MEDIUM_AUG = albu.Compose([
albu.Flip(),
albu.RandomRotate90(), CROP_AUG, TASK_AUG, NORM_TO_TENSOR
])
types = {
"val": VAL_AUG,
"light": LIGHT_AUG,
"medium": MEDIUM_AUG,
}
return types[aug_type]
def best_cifar10_test_transforms(stats):
return alb.Compose([
alb.Normalize(*stats),
alb_torch.transforms.ToTensor()
], p=1.0)
input_target_key="targets")
mean = (0.485, 0.456, 0.406) # RGB
std = (0.229, 0.224, 0.225) # RGB
albu_transforms = {
'train':
A.Compose([
A.OneOf([
A.Cutout(max_h_size=5, max_w_size=16),
A.CoarseDropout(max_holes=4),
A.RandomBrightness(p=0.25),
],
p=0.5),
A.Normalize(mean, std),
]),
'valid':
A.Compose([
A.Normalize(mean, std),
]),
}
audio_augmenter = Compose([
OneOf([GaussianNoiseSNR(min_snr=10),
PinkNoiseSNR(min_snr=10)]),
TimeShift(sr=32000),
VolumeControl(p=0.5),
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)
# Load dataset info
tile = 'ur'
exp_suffix = f'_{tile}'
path_to_train = f'Christof/assets/train_rgb_1024_9crop/{tile}/'
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.08165012, 0.0530909, 0.05298166),
std=(0.12806622, 0.08622692, 0.13038702),
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))
A.Normalize(mean=(0.11843426, 0.06886751, 0.06541236),
std=(0.16149608, 0.0987589, 0.16087747),
max_pixel_value=255.)
])
