def test_transform_pipeline_serialization(seed, image, mask):
aug = A.Compose(
[
A.OneOrOther(
A.Compose(
[
A.Resize(1024, 1024),
A.RandomSizedCrop(min_max_height=(256, 1024), height=512, width=512, p=1),
A.OneOf(
[
A.RandomSizedCrop(min_max_height=(256, 512), height=384, width=384, p=0.5),
A.RandomSizedCrop(min_max_height=(256, 512), height=512, width=512, p=0.5),
]
),
]
),
A.Compose(
[
A.Resize(1024, 1024),
A.RandomSizedCrop(min_max_height=(256, 1025), height=256, width=256, p=1),
A.OneOf([A.HueSaturationValue(p=0.5), A.RGBShift(p=0.7)], p=1),
]
),
),
A.HorizontalFlip(p=1),
A.RandomBrightnessContrast(p=0.5),
]
)
serialized_aug = A.to_dict(aug)
deserialized_aug = A.from_dict(serialized_aug)
set_seed(seed)
aug_data = aug(image=image, mask=mask)
set_seed(seed)
deserialized_aug_data = deserialized_aug(image=image, mask=mask)
assert np.array_equal(aug_data["image"], deserialized_aug_data["image"])
assert np.array_equal(aug_data["mask"], deserialized_aug_data["mask"])
def __init__(self, csv_path, data_path, train=True):
if train:
self.data = pd.read_csv(csv_path)
else:
self.data = pd.read_csv(csv_path)
self.transforms = transforms.ToTensor()
self.data_path = data_path
self.flip = albu.HorizontalFlip()
self.train = train
rotate_crop = albu.Compose([
albu.Rotate(limit=10, p=1.),
albu.RandomSizedCrop((185, 202), height=224, width=224, p=1.)
],
p=0.95)
self.aug = albu.Compose([
rotate_crop,
albu.RandomBrightnessContrast(),
albu.Blur(),
albu.GaussNoise()
],
p=1.)
def test_transform_pipeline_serialization_with_keypoints(
seed, image, keypoints, keypoint_format, labels):
aug = A.Compose(
[
A.OneOrOther(
A.Compose([
A.RandomRotate90(),
A.OneOf([A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5)])
]),
A.Compose([
A.Rotate(p=0.5),
A.OneOf([A.HueSaturationValue(p=0.5),
A.RGBShift(p=0.7)],
p=1)
]),
),
A.HorizontalFlip(p=1),
A.RandomBrightnessContrast(p=0.5),
],
keypoint_params={
"format": keypoint_format,
"label_fields": ["labels"]
},
)
serialized_aug = A.to_dict(aug)
deserialized_aug = A.from_dict(serialized_aug)
set_seed(seed)
aug_data = aug(image=image, keypoints=keypoints, labels=labels)
set_seed(seed)
deserialized_aug_data = deserialized_aug(image=image,
keypoints=keypoints,
labels=labels)
assert np.array_equal(aug_data["image"], deserialized_aug_data["image"])
assert np.array_equal(aug_data["keypoints"],
deserialized_aug_data["keypoints"])
def __init__(self, outputs=6):
super().__init__()
self.net = models.resnet101(True)
self.linear = Sequential(ReLU(), Dropout(), Linear(1000, outputs))
df = pd.read_csv("/home/dipet/kaggle/prostate/input/prostate-cancer-grade-assessment/train.csv")
self.train_df, self.valid_df = train_test_split(df, test_size=0.2)
self.data_dir = "/datasets/panda/train_64_100"
self.train_transforms = A.Compose(
[
A.InvertImg(p=1),
A.RandomGridShuffle(grid=(10, 10)),
A.RandomScale(0.1),
A.PadIfNeeded(640, 640),
A.RandomSizedCrop([512, 640], 640, 640),
A.Flip(),
A.Rotate(90),
A.RandomBrightnessContrast(0.02, 0.02),
A.HueSaturationValue(0, 10, 10),
A.Normalize(mean, std, 1),
]
)
self.valid_transforms = A.Compose([A.InvertImg(p=1), A.Normalize(mean, std, 1),])
def get_aug(cfg):
print('getting aug', cfg['aug']['name'])
print('aug size', cfg['aug']['size'])
size = cfg['aug']['size']
name = cfg['aug']['name']
if name == 'v0':
return alb.Compose([
alb.RandomResizedCrop(size, size, p=1.0),
alb.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0),
ToTensorV2(p=1.0),
])
elif name == 'v1':
return alb.Compose([
alb.RandomResizedCrop(size, size, p=1.0),
alb.RandomBrightnessContrast(brightness_limit=(-0.4, 0.4),
contrast_limit=(-0.4, 0.4),
p=0.3),
alb.HueSaturationValue(hue_shift_limit=0.4,
sat_shift_limit=0.4,
val_shift_limit=0.5,
p=0.3),
alb.ShiftScaleRotate(p=0.3),
alb.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0),
ToTensorV2(p=1.0),
])
else:
raise Exception('{} not supported'.format(name))
return aug
def __init__(self, data_root, effect):
self.data_root = os.path.join(data_root, effect)
self.effect = effect
self.data_list = sorted(os.listdir(self.data_root), key=lambda x: int(x.replace('.png', '')))
self.train_shape = cv2.imread(os.path.join(self.data_root, self.data_list[0])).shape[:2]
self.scaled_shape = (int(self.train_shape[0] * 0.5), int(self.train_shape[1] * 0.8))
self.target_transforms = albu.Compose([
albu.RandomSizedCrop(self.scaled_shape, height=self.train_shape[1], width=self.train_shape[0]),
albu.ElasticTransform(),
albu.Blur(blur_limit=11, p=0.5),
albu.RandomBrightnessContrast(p=0.5),
albu.HorizontalFlip(p=0.5),
])
self.final_transforms = transforms.Compose([
transforms.ToPILImage(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
self.source_transforms = transforms.Compose([
transforms.ToPILImage(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
}
augmentations = {
"strong": albu.Compose(
[
albu.HorizontalFlip(),
albu.ShiftScaleRotate(
shift_limit=0.0, scale_limit=0.2, rotate_limit=30, p=0.4
),
albu.ElasticTransform(),
albu.GaussNoise(),
albu.OneOf(
[
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.RandomBrightnessContrast(),
albu.RandomGamma(),
albu.MedianBlur(),
],
p=0.5,
),
albu.OneOf([albu.RGBShift(), albu.HueSaturationValue()], p=0.5),
]
),
"weak": albu.Compose([albu.HorizontalFlip()]),
"pneumothorax": albu.Compose(
[
albu.HorizontalFlip(p=0.5),
albu.OneOf([albu.RandomBrightnessContrast(), albu.RandomGamma(),], p=0.3),
albu.OneOf(
[
def get_hard_augmentations_v2(image_size):
return A.Compose([
A.OneOf([
A.ShiftScaleRotate(shift_limit=0.05,
scale_limit=0.1,
rotate_limit=45,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.ElasticTransform(alpha_affine=0,
alpha=35,
sigma=5,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.OpticalDistortion(distort_limit=0.11,
shift_limit=0.15,
border_mode=cv2.BORDER_CONSTANT,
value=0),
A.GridDistortion(border_mode=cv2.BORDER_CONSTANT, value=0),
A.NoOp()
]),
A.OneOf([
A.RandomSizedCrop(min_max_height=(int(image_size[0] * 0.75),
image_size[0]),
height=image_size[0],
width=image_size[1],
p=0.3),
A.NoOp()
]),
A.ISONoise(p=0.5),
A.JpegCompression(p=0.3, quality_lower=75),
# Brightness/contrast augmentations
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.5,
contrast_limit=0.4),
IndependentRandomBrightnessContrast(brightness_limit=0.25,
contrast_limit=0.24),
A.RandomGamma(gamma_limit=(50, 150)),
A.NoOp()
]),
A.OneOf([
A.RGBShift(r_shift_limit=40, b_shift_limit=30, g_shift_limit=30),
A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=10),
A.ToGray(p=0.2),
A.NoOp()
]),
A.OneOf([
A.ChannelDropout(p=0.2),
A.CoarseDropout(p=0.1,
max_holes=2,
max_width=256,
max_height=256,
min_height=16,
min_width=16),
A.NoOp()
]),
A.RandomGridShuffle(p=0.3),
DiagnosisNoise(p=0.2),
# D4
A.Compose([A.RandomRotate90(), A.Transpose()])
])
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']))
])
transform_test = albu.Compose([
# transforms.CenterCrop(opt.MODEL.INPUT_SIZE),
albu.RandomCrop(height=opt.MODEL.INPUT_SIZE,
width=opt.MODEL.INPUT_SIZE),
albu.HorizontalFlip(),
])
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',
# image_size=opt.MODEL.INPUT_SIZE,
num_classes=opt.MODEL.NUM_CLASSES,
resize=False,
num_tta=1, # opt.TEST.NUM_TTAS,
augmentor=transform_test)
test_dataset = Dataset(
test_df,
path=opt.TEST.PATH,
mode='test',
# image_size=opt.MODEL.INPUT_SIZE,
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
# TODO Learning detail params
lr_scheduler = CosineDecayScheduler(max_lr=lr,
max_epochs=epoch,
warmup_epochs=0)
ignore_indices = [
255,
]
# TODO Data augmentation
train_transforms = AlbumentationsSegmentationWrapperTransform(
A.Compose([
A.HorizontalFlip(),
A.RandomResizedCrop(width=width, height=height, scale=(0.5, 2.0)),
A.CoarseDropout(max_height=int(height / 5), max_width=int(width / 5)),
A.RandomBrightnessContrast(),
ToTensorV2(),
]),
class_num=n_classes,
ignore_indices=ignore_indices)
test_transforms = AlbumentationsSegmentationWrapperTransform(
A.Compose([
A.Resize(width=width, height=height),
ToTensorV2(),
]),
class_num=n_classes,
ignore_indices=ignore_indices)
# dataset/dataloader
if test_images_dir == "":
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
mean = std = [0.5] * 3
aug_seq1 = A.OneOf([
A.HorizontalFlip(p=1.0),
A.VerticalFlip(p=1.0),
A.Transpose(p=1.0),
],
p=1.0)
aug_seq2 = A.OneOf(
[
# A.RandomGamma(always_apply=False, p=1.0, gamma_limit=(80, 120), eps=1e-07),
A.RandomBrightnessContrast(always_apply=False,
p=1.0,
brightness_limit=(-0.2, 0.2),
contrast_limit=(-0.2, 0.2),
brightness_by_max=True),
],
p=1.0)
aug_seq3 = A.OneOf([
A.RGBShift(always_apply=False,
p=1.0,
r_shift_limit=(-10, 10),
g_shift_limit=(-10, 10),
b_shift_limit=(-10, 10)),
A.HueSaturationValue(always_apply=False,
p=1.0,
hue_shift_limit=(-4, 4),
sat_shift_limit=(-30, 30),
val_shift_limit=(-20, 20)),
def __init__(self,
mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5),
pad_dim=(0, 0),
random_crop_dim=(0, 0),
resize=(0, 0),
horizontal_flip=0,
vertical_flip=0,
rotate_degree=0,
rotation=0,
cutout=0,
cutout_dim=(1, 1),
hsv=0,
iso_noise=0,
bright_contrast=0,
gaussian_blur=0,
train=False,
modest_input=True):
"""Transformations to be applied on the data
Arguments:
mean : Tuple of mean values for each channel
(default: (0.5,0.5,0.5))
std : Tuple of standard deviation values for each channel
(default: (0.5,0.5,0.5))
pad_dim (tuple, optional): Pad side of the image
pad_dim[0]: minimal result image height (int)
pad_dim[1]: minimal result image width (int)
(default: (0,0))
random_crop_dim (tuple, optional): Crop a random part of the input
random_crop_dim[0]: height of the crop (int)
random_crop_dim[1]: width of the crop (int)
(default: (0,0))
resize (tuple, optional): Resize input
resize[0]: new height of the input (int)
resize[1]: new width of the input (int)
(default: (0,0))
horizontal_flip (float, optional): Probability of image being flipped horizontaly
(default: 0)
vertical_flip (int, optional): Probability of image being flipped vertically
(default: 0)
rotation (int, optional): Probability of image being rotated
(default: 0)
cutout (int, optional): Probability of image being cutout
(default: 0)
cutout_dim (list, optional): Cutout a random part of the image
cutout_dimtransformations.append(ToTensor())[0]: height of the cutout (int)
cutout_dim[1]: width of the cutout (int)
(default: (1,1))
transform_train : If True, transformations for training data else for testing data
(default : False)
Returns:
Transformations that is to applied on the data
"""
transformations = []
if train:
if sum(pad_dim) > 0:
transformations.append(
A.PadIfNeeded(min_height=pad_dim[0],
min_width=pad_dim[1],
p=1.0))
if sum(random_crop_dim) > 0:
transformations.append(
A.RandomCrop(height=random_crop_dim[0],
width=random_crop_dim[1],
p=1.0))
if horizontal_flip:
transformations.append(A.HorizontalFlip(p=horizontal_flip))
if vertical_flip:
transformations.append(A.VerticalFlip(p=vertical_flip))
if gaussian_blur:
transformations.append(A.GaussianBlur(p=gaussian_blur))
if rotation:
transformations.append(
A.Rotate(limit=rotate_degree, p=rotation))
if cutout:
transformations.append(
A.CoarseDropout(max_holes=1,
fill_value=tuple(x * 255 for x in mean),
max_height=cutout_dim[0],
max_width=cutout_dim[1],
min_height=1,
min_width=1,
p=cutout))
if hsv:
transformations.append(
A.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
always_apply=False,
p=hsv))
if iso_noise:
transformations.append(
A.ISONoise(color_shift=(0.01, 0.05),
intensity=(0.1, 0.5),
always_apply=False,
p=iso_noise))
if bright_contrast:
transformations.append(
A.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2,
brightness_by_max=True,
always_apply=False,
p=bright_contrast))
if modest_input:
transformations.append(
A.Normalize(mean=mean, std=std, always_apply=True))
if sum(resize) > 0:
transformations.append(
A.Resize(height=resize[0],
width=resize[1],
interpolation=1,
always_apply=False,
p=1))
transformations.append(ToTensor())
self.transform = A.Compose(transformations)
def load_data(fold: int) -> Any:
torch.multiprocessing.set_sharing_strategy('file_system') # type: ignore
cudnn.benchmark = True # type: ignore
logger.info('config:')
logger.info(pprint.pformat(config))
full_df = pd.read_csv(find_input_file(INPUT_PATH + config.train.csv))
print('full_df', full_df.shape)
train_df, _ = train_val_split(full_df, fold)
print('train_df', train_df.shape)
# use original train.csv for validation
full_df2 = pd.read_csv(INPUT_PATH + 'train.csv')
assert full_df2.shape == full_df.shape
_, val_df = train_val_split(full_df2, fold)
print('val_df', val_df.shape)
test_df = pd.read_csv(find_input_file(INPUT_PATH + 'sample_submission.csv'))
augs: List[Union[albu.BasicTransform, albu.OneOf]] = []
if config.augmentations.hflip:
augs.append(albu.HorizontalFlip(.5))
if config.augmentations.vflip:
augs.append(albu.VerticalFlip(.5))
if config.augmentations.rotate90:
augs.append(albu.RandomRotate90())
if config.augmentations.affine == 'soft':
augs.append(albu.ShiftScaleRotate(shift_limit=0.075, scale_limit=0.15, rotate_limit=10, p=.75))
elif config.augmentations.affine == 'medium':
augs.append(albu.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2))
elif config.augmentations.affine == 'hard':
augs.append(albu.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.50, rotate_limit=45, p=.75))
if config.augmentations.rect_crop.enable:
augs.append(RandomRectCrop(rect_min_area=config.augmentations.rect_crop.rect_min_area,
rect_min_ratio=config.augmentations.rect_crop.rect_min_ratio,
image_size=config.model.image_size,
input_size=config.model.input_size))
if config.augmentations.noise != 0:
augs.append(albu.OneOf([
albu.IAAAdditiveGaussianNoise(),
albu.GaussNoise(),
], p=config.augmentations.noise))
if config.augmentations.blur != 0:
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=config.augmentations.blur))
if config.augmentations.distortion != 0:
augs.append(albu.OneOf([
albu.OpticalDistortion(p=0.3),
albu.GridDistortion(p=.1),
albu.IAAPiecewiseAffine(p=0.3),
], p=config.augmentations.distortion))
if config.augmentations.color != 0:
augs.append(albu.OneOf([
albu.CLAHE(clip_limit=2),
albu.IAASharpen(),
albu.IAAEmboss(),
albu.RandomBrightnessContrast(),
], p=config.augmentations.color))
if config.augmentations.erase.prob != 0:
augs.append(RandomErase(min_area=config.augmentations.erase.min_area,
max_area=config.augmentations.erase.max_area,
min_ratio=config.augmentations.erase.min_ratio,
max_ratio=config.augmentations.erase.max_ratio,
input_size=config.model.input_size,
p=config.augmentations.erase.prob))
transform_train = albu.Compose([
albu.PadIfNeeded(config.model.input_size, config.model.input_size),
albu.RandomCrop(height=config.model.input_size, width=config.model.input_size),
albu.Compose(augs, p=config.augmentations.global_prob),
])
if config.test.num_ttas > 1:
transform_test = albu.Compose([
albu.PadIfNeeded(config.model.input_size, config.model.input_size),
albu.RandomCrop(height=config.model.input_size, width=config.model.input_size),
# horizontal flip is done by the data loader
])
else:
transform_test = albu.Compose([
albu.PadIfNeeded(config.model.input_size, config.model.input_size),
# albu.CenterCrop(height=config.model.input_size, width=config.model.input_size),
albu.RandomCrop(height=config.model.input_size, width=config.model.input_size),
albu.HorizontalFlip(.5)
])
train_dataset = ImageDataset(train_df, mode='train', config=config,
augmentor=transform_train)
num_ttas_for_val = config.test.num_ttas if args.predict_oof else 1
val_dataset = ImageDataset(val_df, mode='val', config=config,
num_ttas=num_ttas_for_val, augmentor=transform_test)
test_dataset = ImageDataset(test_df, mode='test', config=config,
num_ttas=config.test.num_ttas,
augmentor=transform_test)
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=config.train.batch_size, shuffle=True,
num_workers=config.num_workers, drop_last=True)
val_loader = torch.utils.data.DataLoader(
val_dataset, batch_size=config.train.batch_size, shuffle=False,
num_workers=config.num_workers)
test_loader = torch.utils.data.DataLoader(
test_dataset, batch_size=config.test.batch_size, shuffle=False,
num_workers=config.num_workers)
return train_loader, val_loader, test_loader
AUGMENTATIONS = albumentations.Compose([
# albumentations.Transpose(p=0.5),
albumentations.RandomSunFlare(flare_roi=(0, 0, 1, 1),
angle_lower=0.5,
p=0.5),
albumentations.HorizontalFlip(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.GaussNoise(mean=100, p=0.5),
albumentations.Normalize(std=(0.9, 0.9, 0.9), p=0.2),
albumentations.RGBShift(r_shift_limit=20,
g_shift_limit=20,
b_shift_limit=20,
p=0.5),
albumentations.OneOf([
albumentations.RandomBrightnessContrast(brightness_limit=0.3,
contrast_limit=0.3),
albumentations.RandomBrightnessContrast(brightness_limit=0.1,
contrast_limit=0.1)
],
p=1),
])
# ToDo: 後で関数にする
train_datagen = ImageDataAugmentor(
rescale=1. / 255,
augment=AUGMENTATIONS,
augment_seed=seed_value
# preprocess_input=None
# rotation_range=15,
# shear_range=0.2,
# horizontal_flip=True,
def val_albu_augment(record):
"""
"""
verbose = record.get('verbose', False)
image = record['image']
mask = record['mask']
if verbose:
pipeline = albu.ReplayCompose
else:
pipeline = albu.Compose
aug = pipeline([
albu.OneOf([
albu.RandomBrightnessContrast(brightness_limit=0.2,
contrast_limit=0.2,
brightness_by_max=True,
always_apply=False,
p=1),
albu.RandomBrightnessContrast(brightness_limit=(-0.2, 0.6),
contrast_limit=.2,
brightness_by_max=True,
always_apply=False,
p=1),
albu.augmentations.transforms.ColorJitter(brightness=0.2,
contrast=0.2,
saturation=0.1,
hue=0.1,
always_apply=False,
p=1),
albu.RandomGamma(p=1)
],
p=1),
albu.OneOf([
albu.GaussNoise(0.02, p=.5),
albu.IAAAffine(p=.5),
],
p=.25),
albu.OneOf([
albu.augmentations.transforms.Blur(
blur_limit=15, always_apply=False, p=0.25),
albu.augmentations.transforms.Blur(
blur_limit=3, always_apply=False, p=0.5)
],
p=0.5),
])
data = aug(image=image, mask=mask)
record['image'] = data['image']
record['mask'] = data['mask']
if verbose:
for transformation in data['replay']['transforms']:
if not isinstance(transformation, dict):
print('not a dict')
pass
elif transformation.get('applied', False):
print(30 * '-')
if 'OneOf' in transformation['__class_fullname__']:
print(30 * '=')
for _trans in transformation['transforms']:
if not _trans.get('applied', False): continue
_name = _trans['__class_fullname__']
if 'Flip' in _name: continue
print(_trans['__class_fullname__'])
for k, v in _trans.items():
if k in [
'__class_fullname__', 'applied',
'always_apply'
]:
continue
print(f"{k}: {v}")
else:
_name = transformation['__class_fullname__']
if 'Flip' in _name: continue
print(_name)
for k, v in transformation.items():
if k in [
'__class_fullname__', 'applied', 'always_apply'
]:
continue
print(f"{k}: {v}")
return record
albu.RandomSizedCrop(
min_max_height=(
int(0.5 * (train_parameters["height_crop_size"])),
int(2 * (train_parameters["height_crop_size"])),
),
height=train_parameters["height_crop_size"],
width=train_parameters["width_crop_size"],
w2h_ratio=1.0,
p=1,
),
albu.ShiftScaleRotate(border_mode=cv2.BORDER_CONSTANT,
rotate_limit=10,
scale_limit=0,
p=0.5,
mask_value=ignore_index),
albu.RandomBrightnessContrast(p=0.5),
albu.RandomGamma(p=0.5),
albu.ImageCompression(quality_lower=20, quality_upper=100, p=0.5),
albu.GaussNoise(p=0.5),
albu.Blur(p=0.5),
albu.CoarseDropout(p=0.5, max_height=26, max_width=16),
albu.OneOf([albu.HueSaturationValue(p=0.5),
albu.RGBShift(p=0.5)],
p=0.5),
normalization,
],
p=1,
)
val_augmentations = albu.Compose(
[
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)
PAD_VALUE = (0, 0, 0)
IGNORE_INDEX = 255
transforms = [
abm.RandomResizedCrop(
scale=(0.7, 1),
ratio=(1.5, 2),
height=config.img_height,
width=config.img_width,
interpolation=cv2.INTER_NEAREST,
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.5,
),
abm.OneOf([
abm.ShiftScaleRotate(
rotate_limit=7,
interpolation=cv2.INTER_NEAREST,
border_mode=cv2.BORDER_CONSTANT,
value=PAD_VALUE,
mask_value=IGNORE_INDEX,
p=1.0,
),
abm.ElasticTransform(
interpolation=cv2.INTER_NEAREST,
border_mode=cv2.BORDER_CONSTANT,
alpha_affine=30,
value=PAD_VALUE,
mask_value=IGNORE_INDEX,
p=1.0,
),
abm.Perspective(
scale=(0.05),
interpolation=cv2.INTER_NEAREST,
pad_mode=cv2.BORDER_CONSTANT,
pad_val=PAD_VALUE,
mask_pad_val=IGNORE_INDEX,
keep_size=True,
fit_output=True,
p=1.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.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()
def __init__(self, dataframe, image_dir, transforms=None):
super().__init__()
self.df = dataframe
self.image_ids = dataframe['image_id'].unique()
self.image_ids = shuffle(self.image_ids)
self.labels = [np.zeros(
(0, 5), dtype=np.float32)] * len(self.image_ids)
self.img_size = 1024
im_w = 1024
im_h = 1024
for i, img_id in enumerate(self.image_ids):
records = self.df[self.df['image_id'] == img_id]
boxes = records[['x', 'y', 'w', 'h']].values
boxes[:, 2] = boxes[:, 0] + boxes[:, 2]
boxes[:, 3] = boxes[:, 1] + boxes[:, 3]
boxesyolo = []
for box in boxes:
x1, y1, x2, y2 = box
xc, yc, w, h = 0.5 * x1 / im_w + 0.5 * x2 / im_w, 0.5 * y1 / im_h + 0.5 * y2 / im_h, abs(
x2 / im_w - x1 / im_w), abs(y2 / im_h - y1 / im_h)
boxesyolo.append([1, xc, yc, w, h])
self.labels[i] = np.array(boxesyolo)
self.image_dir = image_dir
self.transforms = transforms
self.mosaic = False
self.augment = True
self.aug = A.Compose(
[
A.Resize(config.CROP_SIZE, config.CROP_SIZE,
always_apply=True),
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.4,
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.OneOf([A.ChannelShuffle(),
A.CLAHE(clip_limit=4),
A.NoOp()]),
A.OneOf([A.JpegCompression(),
A.Blur(blur_limit=4),
A.NoOp()]),
A.OneOf([A.ToGray(), A.ToSepia(),
A.NoOp()], p=0.2),
A.GaussNoise(),
A.Cutout(num_holes=8,
max_h_size=64,
max_w_size=64,
fill_value=0,
p=0.5),
A.Normalize(
config.MODEL_MEAN, config.MODEL_STD, always_apply=True),
ToTensorV2(p=1.0)
],
bbox_params={
'format': config.DATA_FMT,
'min_area': 1,
'min_visibility': 0.5,
'label_fields': ['labels']
},
p=1.0)
normalization = albu.Normalize(mean=mean, std=std, p=1)
train_augmentations = albu.Compose(
[
albu.RandomSizedCrop(
min_max_height=(
int(0.5 * (train_parameters["height_crop_size"])),
int(2 * (train_parameters["height_crop_size"])),
),
height=train_parameters["height_crop_size"],
width=train_parameters["width_crop_size"],
w2h_ratio=1.0,
p=1,
),
albu.RandomBrightnessContrast(
brightness_limit=0.1, contrast_limit=0, p=0.5),
albu.HorizontalFlip(p=0.5),
normalization,
],
p=1,
)
val_augmentations = albu.Compose([
albu.PadIfNeeded(
min_height=1024, min_width=2048, mask_value=ignore_index, p=1),
normalization
],
p=1)
test_augmentations = albu.Compose([normalization], p=1)
def __init__(self, folds):
df = pd.read_csv(config.TRAIN_FOLDS)
df = df[['image_id', 'x', 'y', 'w', 'h', 'kfold']]
self.df = df[df.kfold.isin(folds)].reset_index(drop=True)
self.image_ids = self.df.image_id.unique()
if len(folds) == 1:
self.aug = A.Compose(
[
A.Resize(
config.CROP_SIZE, config.CROP_SIZE, always_apply=True),
A.Normalize(
config.MODEL_MEAN, config.MODEL_STD, always_apply=True)
],
bbox_params={
'format': config.DATA_FMT,
'min_area': 1,
'min_visibility': 0.5,
'label_fields': ['labels']
})
else:
self.aug = A.Compose(
[
A.Resize(
config.CROP_SIZE, config.CROP_SIZE, always_apply=True),
A.OneOf([
A.RandomBrightnessContrast(brightness_limit=0.4,
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.OneOf(
[A.ChannelShuffle(),
A.CLAHE(clip_limit=4),
A.NoOp()]),
A.OneOf(
[A.JpegCompression(),
A.Blur(blur_limit=4),
A.NoOp()]),
A.Cutout(num_holes=8,
max_h_size=64,
max_w_size=64,
fill_value=0,
p=0.5),
A.Normalize(
config.MODEL_MEAN, config.MODEL_STD, always_apply=True)
],
bbox_params={
'format': config.DATA_FMT,
'min_area': 1,
'min_visibility': 0.5,
'label_fields': ['labels']
},
p=1.0)
except:
target["image_id"] = torch.tensor([idx])
target["area"] = torch.as_tensor([], dtype=torch.float32)
target["masks"] = torch.as_tensor([], dtype=torch.uint8)
print(target)
return torch.as_tensor(np.transpose(transformed["image"], (2, 0, 1)),
dtype=torch.float32), target
dataset_path = "/home/techgarage/Projects/Max Planck/AIModelTrainer/datasets/default.json"
model_type = ""
model_name = ""
transformations = A.Compose([
A.RandomCrop(width=1024, height=1024),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(p=0.2),
])
test_dataset = UniversalDataset(dataset_path,
model_type,
transformations=transformations)
def get_model_instance_segmentation(num_classes):
# load an instance segmentation model pre-trained pre-trained on COCO
model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)
# get number of input features for the classifier
in_features = model.roi_heads.box_predictor.cls_score.in_features
# replace the pre-trained head with a new one
model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)
def safe_color_augmentations():
return A.Compose([
A.RandomBrightnessContrast(brightness_limit=0.1,
contrast_limit=0.1,
brightness_by_max=True)
])
def __init__(self):
super(TaskConfig, self).__init__()
# self.data_root = "/data/yyh/2020/Simple-Centernet-with-Visualization-Pytorch/dataset/wuzhifenli"
self.data_root = "/data/yyh/2020/Simple-Centernet-with-Visualization-Pytorch_/dataset/code_testing_coco"
# self.data_root = "/data/yyh/2020/CenterNet/data/coco/"
self.training_name = "train_test"
self.log_and_model_root = os.path.join("./train_out",
self.training_name,
self.traing_time)
self.log_file_path = os.path.join(self.log_and_model_root, "log.txt")
check_path_without_delete(self.log_and_model_root)
check_file_without_delete(self.log_file_path)
self.transform = A.Compose(
[
# A.RandomCropNearBBox(p=1),
# Dropout
A.Cutout(p=0.3),
# Color
A.RandomBrightnessContrast(p=0.5),
A.CLAHE(p=0.1),
A.RGBShift(p=0.1),
# Blur
A.MotionBlur(p=0.2),
# Noise
A.GaussNoise(p=0.2),
# Spatial
# either horizontally, vertically or both horizontally and vertically
A.Flip(p=0.5),
A.ShiftScaleRotate(scale_limit=(-0.3, 0.3),
shift_limit=(-0.3, 0.3),
rotate_limit=(0, 0),
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=0.2),
A.RandomCrop(
height=self.train_height, width=self.train_width, p=0.2),
A.Resize(height=self.train_height, width=self.train_width)
],
bbox_params=A.BboxParams(
# format='pascal_voc', min_visibility=0.3, label_fields=['category_ids']), # pascal_voc: [[x_min, y_min, x_max, y_max],[]]
format='coco',
min_visibility=0.3,
label_fields=['category_ids'
]), # coco: [[x_min, y_min, width, height],[]]
)
self.if_debug = False
self.vis = init_visdom_(window_name=self.training_name)
if self.if_debug:
self.num_workers = 0
self.batch_size = 1
self.label_list = [
'bolibang', 'bolibangduandian', 'jiaotoudiguan',
'jiaotoudiguantou', 'jiaotoudiguanwei', 'liangtong', 'loudou',
'loudoujianzui', 'lvzhi', 'lvzhiloudou', 'shaobei', 'shiguan',
'shiguankou', 'shiguanwei', 'shou', 'tiejiaquan', 'tiejiatai',
'xiping'
]
self.class_num = len(self.label_list)
self.label_map = self.gen_label_map()
transform = {}
transform['train'] = A.Compose([
A.Resize(224, 224),
A.OneOf([
GridMask(num_grid=3, mode=0, rotate=15),
GridMask(num_grid=3, mode=2, rotate=15),
], p=0.7),
A.Resize(224, 224),
A.RandomBrightness(),
A.OneOf([
A.ShiftScaleRotate(rotate_limit=15, scale_limit=0.10),
A.OpticalDistortion(distort_limit=0.11, shift_limit=0.15),
A.NoOp()
]),
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.OneOf([
A.CLAHE(),
A.NoOp()
]),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.JpegCompression(80),
transform = A.Compose([
A.OneOf([
A.ISONoise(p=0.4),
A.JpegCompression(
quality_lower=50, quality_upper=70, always_apply=False, p=0.8),
],
p=0.6),
A.OneOf([
A.MotionBlur(blur_limit=10, p=.8),
A.MedianBlur(blur_limit=3, p=0.75),
A.GaussianBlur(blur_limit=7, p=0.75),
],
p=0.8),
A.OneOf([
A.RandomBrightnessContrast(
brightness_limit=0.3, contrast_limit=0.3, p=0.75),
A.RandomShadow(num_shadows_lower=1,
num_shadows_upper=18,
shadow_dimension=6,
p=0.85),
],
p=0.8),
])
def GenerateTrainingBlocks(data_folder,
gt_folder,
dataset_path='./dataset',
M=256,
N=256):
print(data_folder)
return normed
def get_trainsform_init_args_names(self):
return 'max_pixel_value'
alb_trn_trnsfms = A.Compose(
[
A.Resize(*config.IMG_SIZE),
# A.CLAHE(p=1),
A.Rotate(limit=10, p=1),
# A.RandomSizedCrop((IMG_SIZE[0]-32, IMG_SIZE[0]-10), *INPUT_SIZE),
A.RandomCrop(*config.INPUT_SIZE),
# A.HueSaturationValue(val_shift_limit=20, p=0.5),
A.HorizontalFlip(p=0.5),
A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2),
A.GaussianBlur(blur_limit=7, p=0.5),
NormalizePerImage(),
# A.Normalize(
# mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225],
# ),
ATorch.transforms.ToTensor()
],
p=1)
alb_val_trnsfms = A.Compose(
[
A.Resize(*config.IMG_SIZE),
# A.CLAHE(p=1),
A.CenterCrop(*config.INPUT_SIZE),
import cv2
from transformers import PreTrainedTokenizerFast
from tqdm.auto import tqdm
train_transform = alb.Compose(
[
alb.Compose(
[alb.ShiftScaleRotate(shift_limit=0, scale_limit=(-.15, 0), rotate_limit=1, border_mode=0, interpolation=3,
value=[255, 255, 255], p=1),
alb.GridDistortion(distort_limit=0.1, border_mode=0, interpolation=3, value=[255, 255, 255], p=.5)], p=.15),
# alb.InvertImg(p=.15),
alb.RGBShift(r_shift_limit=15, g_shift_limit=15,
b_shift_limit=15, p=0.3),
alb.GaussNoise(10, p=.2),
alb.RandomBrightnessContrast(.05, (-.2, 0), True, p=0.2),
alb.ImageCompression(95, p=.3),
alb.ToGray(always_apply=True),
alb.Normalize((0.7931, 0.7931, 0.7931), (0.1738, 0.1738, 0.1738)),
# alb.Sharpen()
ToTensorV2(),
]
)
test_transform = alb.Compose(
[
alb.ToGray(always_apply=True),
alb.Normalize((0.7931, 0.7931, 0.7931), (0.1738, 0.1738, 0.1738)),
# alb.Sharpen()
ToTensorV2(),
]
)
def train_function(gpu, world_size, node_rank, gpus):
import torch.multiprocessing
torch.multiprocessing.set_sharing_strategy('file_system')
torch.manual_seed(25)
np.random.seed(25)
rank = node_rank * gpus + gpu
dist.init_process_group(
backend='nccl',
init_method='env://',
world_size=world_size,
rank=rank
)
width_size = 512
batch_size = 32
accumulation_step = 5
device = torch.device("cuda:{}".format(gpu) if torch.cuda.is_available() else "cpu")
if rank == 0:
wandb.init(project='inception_v3', group=wandb.util.generate_id())
wandb.config.width_size = width_size
wandb.config.aspect_rate = 1
wandb.config.batch_size = batch_size
wandb.config.accumulation_step = accumulation_step
shutil.rmtree('tensorboard_runs', ignore_errors=True)
writer = SummaryWriter(log_dir='tensorboard_runs', filename_suffix=str(time.time()))
ranzcr_df = pd.read_csv('train_folds.csv')
ranzcr_train_df = ranzcr_df[ranzcr_df['fold'] != 1]
chestx_df = pd.read_csv('chestx_pseudolabeled_data_lazy_balancing.csv')
train_image_transforms = alb.Compose([
alb.ImageCompression(quality_lower=65, p=0.5),
alb.HorizontalFlip(p=0.5),
alb.CLAHE(p=0.5),
alb.OneOf([
alb.GridDistortion(
num_steps=8,
distort_limit=0.5,
p=1.0
),
alb.OpticalDistortion(
distort_limit=0.5,
shift_limit=0.5,
p=1.0,
),
alb.ElasticTransform(alpha=3, p=1.0)],
p=0.7
),
alb.RandomResizedCrop(
height=width_size,
width=width_size,
scale=(0.8, 1.2),
p=0.7
),
alb.RGBShift(p=0.5),
alb.RandomSunFlare(p=0.5),
alb.RandomFog(p=0.5),
alb.RandomBrightnessContrast(p=0.5),
alb.HueSaturationValue(
hue_shift_limit=20,
sat_shift_limit=20,
val_shift_limit=20,
p=0.5
),
alb.ShiftScaleRotate(shift_limit=0.025, scale_limit=0.1, rotate_limit=20, p=0.5),
alb.CoarseDropout(
max_holes=12,
min_holes=6,
max_height=int(width_size / 6),
max_width=int(width_size / 6),
min_height=int(width_size / 6),
min_width=int(width_size / 20),
p=0.5
),
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_sampler = DistributedSampler(train_set, num_replicas=world_size, rank=rank, shuffle=True)
train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=False, num_workers=4, sampler=train_sampler)
ranzcr_valid_df = ranzcr_df[ranzcr_df['fold'] == 1]
valid_image_transforms = alb.Compose([
alb.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
ToTensorV2()
])
valid_set = ImageDataset(ranzcr_valid_df, valid_image_transforms, '../ranzcr/train', width_size=width_size)
valid_loader = DataLoader(valid_set, batch_size=batch_size, num_workers=4, pin_memory=False, drop_last=False)
# ranzcr_valid_df = ranzcr_df[ranzcr_df['fold'] == 1]
# valid_image_transforms = alb.Compose([
# alb.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
# ToTensorV2()
# ])
# valid_set = ImageDataset(ranzcr_valid_df, valid_image_transforms, '../ranzcr/train', width_size=width_size)
# valid_sampler = DistributedSampler(valid_set, num_replicas=world_size, rank=rank)
# valid_loader = DataLoader(valid_set, batch_size=batch_size, num_workers=4, sampler=valid_sampler)
checkpoints_dir_name = 'inception_v3_noisy_student_{}'.format(width_size)
os.makedirs(checkpoints_dir_name, exist_ok=True)
# model = EfficientNetNoisyStudent(11, pretrained_backbone=True,
# mixed_precision=True, model_name='tf_efficientnet_b7_ns')
model = Inception(11, pretrained_backbone=True, mixed_precision=False, model_name='inception_v3')
model = SyncBatchNorm.convert_sync_batchnorm(model)
model.to(device)
model = DistributedDataParallel(model, device_ids=[gpu])
# class_weights = [354.625, 23.73913043478261, 2.777105767812362, 110.32608695652173,
# 52.679245283018865, 9.152656621728786, 4.7851333032083145,
# 8.437891632878731, 2.4620064899945917, 0.4034751151063363, 31.534942820838626]
class_names = ['ETT - Abnormal', 'ETT - Borderline', 'ETT - Normal',
'NGT - Abnormal', 'NGT - Borderline', 'NGT - Incompletely Imaged', 'NGT - Normal',
'CVC - Abnormal', 'CVC - Borderline', 'CVC - Normal', 'Swan Ganz Catheter Present']
scaler = GradScaler()
criterion = torch.nn.BCEWithLogitsLoss()
lr_start = 1e-4
lr_end = 1e-6
weight_decay = 0
epoch_num = 20
if rank == 0:
wandb.config.model_name = checkpoints_dir_name
wandb.config.lr_start = lr_start
wandb.config.lr_end = lr_end
wandb.config.weight_decay = weight_decay
wandb.config.epoch_num = epoch_num
wandb.config.optimizer = 'adam'
wandb.config.scheduler = 'CosineAnnealingLR'
wandb.config.is_loss_weights = 'no'
optimizer = Adam(model.parameters(), lr=lr_start, weight_decay=weight_decay)
scheduler = CosineAnnealingLR(optimizer, T_max=epoch_num, eta_min=lr_end, last_epoch=-1)
max_val_auc = 0
for epoch in range(epoch_num):
train_loss, train_avg_auc, train_auc, train_rocs, train_data_pr, train_duration = one_epoch_train(
model, train_loader, optimizer, criterion, device, scaler,
iters_to_accumulate=accumulation_step, clip_grads=False)
scheduler.step()
if rank == 0:
val_loss, val_avg_auc, val_auc, val_rocs, val_data_pr, val_duration = eval_model(
model, valid_loader, device, criterion, scaler)
wandb.log({'train_loss': train_loss, 'val_loss': val_loss,
'train_auc': train_avg_auc, 'val_auc': val_avg_auc, 'epoch': epoch})
for class_name, auc1, auc2 in zip(class_names, train_auc, val_auc):
wandb.log({'{} train auc'.format(class_name): auc1,
'{} val auc'.format(class_name): auc2, 'epoch': epoch})
if val_avg_auc > max_val_auc:
max_val_auc = val_avg_auc
wandb.run.summary["best_accuracy"] = val_avg_auc
print('EPOCH %d:\tTRAIN [duration %.3f sec, loss: %.3f, avg auc: %.3f]\t\t'
'VAL [duration %.3f sec, loss: %.3f, avg auc: %.3f]\tCurrent time %s' %
(epoch + 1, train_duration, train_loss, train_avg_auc,
val_duration, val_loss, val_avg_auc, str(datetime.now(timezone('Europe/Moscow')))))
torch.save(model.module.state_dict(),
os.path.join(checkpoints_dir_name, '{}_epoch{}_val_auc{}_loss{}_train_auc{}_loss{}.pth'.format(
checkpoints_dir_name, epoch + 1, round(val_avg_auc, 3), round(val_loss, 3),
round(train_avg_auc, 3), round(train_loss, 3))))
if rank == 0:
wandb.finish()
images = images.astype(np.float32)
images /= 255
images = images.transpose(2, 0, 1)
# label = np.zeros(5).astype(np.float32)
# label[:row.isup_grade] = 1.
return torch.tensor(
images
), row.isup_grade, 1 if row.data_provider == "karolinska" else weight
transforms_train = albumentations.Compose([
albumentations.Transpose(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.HorizontalFlip(p=0.5),
albumentations.RandomBrightnessContrast(p=0.5),
albumentations.Rotate(20, border_mode=cv2.BORDER_CONSTANT, value=0)
])
transforms_val = albumentations.Compose([])
def train_epoch(loader, optimizer):
model.train()
train_loss = []
# bar = tqdm(loader, mininterval = 60)
for (data, target, data_provider) in loader:
data, target, data_provider = data.to(device), target.to(
device), data_provider.to(device)
loss_func = criterion
optimizer.zero_grad()
logits = model(data)
def __getitem__(self, idx):
path = self.data.loc[idx, 'path']
study_id = path.split('/')[2]
slice_num = os.path.basename(path).split('.')[0]
path = os.path.normpath(os.path.join(self.config.data_root, '..', path))
# todo it would be better to have generic paths in csv and parameter specifying which data version to use
path = path.replace('npy/', self.config.data_version + '/')
middle_img_path = Path(path)
middle_img_num = int(middle_img_path.stem)
slices_indices = list(range(middle_img_num - self.config.num_slices // 2,
middle_img_num + self.config.num_slices // 2 + 1))
slices_image = load_scan_2dc(middle_img_path, slices_indices, self.config.pre_crop_size,
self.config.padded_size)
if self.config.use_cdf:
slices_image = self.hu_converter.convert(slices_image)
else:
slices_image = normalize_train(slices_image,
self.config.min_hu_value,
self.config.max_hu_value)
slices_image = (slices_image.transpose((1, 2, 0)) + 1) / 2
# Load and append segmentation masks
if hasattr(self.config, 'append_masks') and self.config.append_masks:
seg_masks = load_seg_masks_2dc(middle_img_path, slices_indices, self.config.pre_crop_size)
seg_masks = seg_masks.transpose((1, 2, 0))
slices_image = np.concatenate((slices_image, seg_masks), axis=2)
transforms = []
if self.additional_transforms is not None:
transforms.extend(self.additional_transforms)
if self.augment:
if self.config.vertical_flip:
transforms.append(albumentations.VerticalFlip(p=0.5))
if self.config.pixel_augment:
transforms.append(albumentations.RandomBrightnessContrast(0.2, 0.2, False, 0.8))
if self.config.elastic_transform:
transforms.append(albumentations.ElasticTransform(
alpha=20,
sigma=6,
alpha_affine=10,
interpolation=cv2.INTER_LINEAR,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=0.5
))
transforms.extend([
albumentations.HorizontalFlip(p=0.5),
albumentations.ShiftScaleRotate(
shift_limit=self.config.shift_limit, scale_limit=0.15, rotate_limit=30,
interpolation=cv2.INTER_LINEAR,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=0.9),
])
if self.augment and self.config.random_crop:
transforms.append(albumentations.RandomCrop(self.config.crop_size, self.config.crop_size))
else:
transforms.append(albumentations.CenterCrop(self.config.crop_size, self.config.crop_size))
transforms.append(albumentations.pytorch.ToTensorV2())
processed = albumentations.Compose(transforms)(image=slices_image)
img = (processed['image'] * 2) - 1
# img = torch.tensor(slices_image, dtype=torch.float32)
out = {
'image': img,
'path': path,
'study_id': study_id,
'slice_num': slice_num
}
if not self.mode == 'test':
out['labels'] = torch.tensor(self.data.loc[idx, ['epidural',
'intraparenchymal',
'intraventricular',
'subarachnoid',
'subdural',
'any']], dtype=torch.float32)
return out
