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