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.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, )
albumentations.Transpose(p=0.5), albumentations.Flip(p=0.5), albumentations.OneOf([ albumentations.CLAHE(clip_limit=2), albumentations.IAASharpen(), albumentations.IAAEmboss(), albumentations.RandomBrightness(), albumentations.RandomContrast(), albumentations.JpegCompression(), albumentations.Blur(), albumentations.GaussNoise() ], p=0.5), # albumentations.HueSaturationValue(p=0.5), albumentations.ShiftScaleRotate(shift_limit=0.15, scale_limit=0.15, rotate_limit=45, p=0.5), albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), # albumentations.ToFloat() ]) data_transforms_test = albumentations.Compose([ albumentations.Resize(args.image_height, args.image_width), albumentations.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), # albumentations.ToFloat() ]) data_transforms_tta0 = albumentations.Compose([ albumentations.Resize(args.image_height, args.image_width),
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
g_truth = g_truth.reset_index() g_truth = g_truth.sort_values(by='id') return g_prob.drop('id', 1).values, g_truth['id'].values, g_truth.drop('id', 1).values if __name__ == '__main__': with open('SETTINGS.json', 'r') as f: path_dict = json.load(f) # TTA valid_transform_aug = albumentations.Compose([ albumentations.Flip(p=0.75), albumentations.ShiftScaleRotate(shift_limit=0.1, scale_limit=0.1, rotate_limit=90, interpolation=cv2.INTER_LINEAR,border_mode=cv2.BORDER_REFLECT_101, p=1), albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, p=1.0) ]) csv_path = path_dict['KAGGLE_LABEL_TRAIN_DATA_CLEAN_PATH'] df_all = pd.read_csv(csv_path) # load test images' name test_csv_path = path_dict['SUBMIT_CSV_PATH'] df_test = pd.read_csv(test_csv_path) c_test = list(set(df_test['Id'].values.tolist())) is_aug = True num_aug = 5 batch_size = 8
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.ShiftScaleRotate(rotate_limit=20, scale_limit=0, p=0.5), albu.RandomBrightnessContrast(p=0.5), albu.RandomGamma(p=0.5), albu.HueSaturationValue(p=0.5), albu.HorizontalFlip(p=0.5), normalization, ], p=1, ) val_augmentations = albu.Compose( [ albu.PadIfNeeded( min_height=1024, min_width=2048, border_mode=cv2.BORDER_CONSTANT, mask_value=ignore_index, p=1 ), normalization,
RandomHorizontalFlip(0.5), ]) tensor_transform = Compose([ ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) albu_transform = A.Compose([ A.LongestMaxSize(SIZE, interpolation=cv2.INTER_AREA), A.PadIfNeeded(SIZE, SIZE, border_mode=cv2.BORDER_CONSTANT), A.OneOf([ A.ShiftScaleRotate(scale_limit=0.2, shift_limit=0, rotate_limit=10, border_mode=cv2.BORDER_CONSTANT), A.ElasticTransform(sigma=10, alpha_affine=10, border_mode=cv2.BORDER_CONSTANT), ]), A.Cutout(), A.HorizontalFlip(), A.Normalize() ]) valid_transform = A.Compose([ A.LongestMaxSize(SIZE, interpolation=cv2.INTER_AREA), A.PadIfNeeded(SIZE, SIZE, border_mode=cv2.BORDER_CONSTANT), A.Normalize() ])
args['neck'] = 'option-D' args['head'] = 'arc_margin' args['pretrained_weights'] = None args['optim'] = 'sgd' args['batch_size'] = 32 args['n_splits'] = 5 args['fold'] = 0 args['seed'] = 9999 args['device'] = 'cuda:0' args['out_dim'] = 1049 args['n_classes'] = 1000 args['class_weights'] = 'log' args['class_weights_norm'] = 'batch' args['normalization'] = 'imagenet' args['crop_size'] = 448 args['tr_aug'] = A.Compose([ A.HorizontalFlip(p=0.5), 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.7), A.Cutout(max_h_size=int(256 * 0.4), max_w_size=int(256 * 0.4), num_holes=1, p=0.5), ]) args['val_aug'] = A.Compose([ A.ImageCompression(quality_lower=99, quality_upper=100), ])
def __init__(self, hparams: Dict): super(AircraftClassifier, self).__init__() self.journal = logging.getLogger(__name__) self.hparams = hparams self.config = from_dict(AircraftClassifierConfig, hparams) self.random_state = RandomState(self.config.random_state_seed) # # Statistics # self.epoch_fit_metrics = None self.epoch_samples: Dict[str, ReservoirSamplingMeter] = {} self.epoch_predictions: Dict[str, PredictionMeter] = {} self.training_outputs = [] # # Model # self.target_classes = load_classes(self.config.classes_path) self.num_classes = len(self.target_classes) self.model = torch.hub.load(self.config.repo, self.config.network, pretrained=True, verbose=False) self.model.fc = nn.Linear(in_features=self.model.fc.in_features, out_features=self.num_classes) self.group_names, self.optimizer_params = self.adjust_model_params() self.train_accuracy = DiceAccuracy() self.train_loss = SoftLabelCrossEntropyLoss( smooth_factor=self.config.kv['x_lbs'], smooth_dist=torch.full([self.num_classes], fill_value=1.0 / self.num_classes)) self.eval_accuracy = ExactMatchAccuracy() self.eval_loss = CrossEntropyLoss() # # Transforms # normalize_mean = [0.485, 0.456, 0.406] normalize_std = [0.229, 0.224, 0.225] mean_color = tuple([int(round(c * 255)) for c in normalize_mean]) self.initial_transform = AlbumentationsTransform( albu.Compose([ albu_ext.Rescale(scale=0.5, interpolation=cv2.INTER_AREA), albu_ext.PadToSquare(fill=mean_color) ])) self.train_transform_mix = albu.Compose([ albu.ShiftScaleRotate(shift_limit=0.1, scale_limit=(-0.15, 0.15), rotate_limit=20, border_mode=cv2.BORDER_CONSTANT, value=mean_color, interpolation=cv2.INTER_AREA, p=1.0), albu.Resize(height=224, width=224, interpolation=cv2.INTER_AREA), albu.HorizontalFlip(p=0.5), albu.HueSaturationValue(hue_shift_limit=30, sat_shift_limit=30, val_shift_limit=30, p=1.0) ]) self.train_transform_final = albu.Compose([ albu.MultiplicativeNoise(multiplier=(0.9, 1.1), p=1.0), albu.CoarseDropout(max_holes=12, max_height=12, max_width=12, min_holes=6, min_height=6, min_width=6, fill_value=mean_color, p=1.0) ]) self.eval_transform = albu.Compose( [albu.Resize(height=224, width=224, interpolation=cv2.INTER_AREA)]) self.model_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=normalize_mean, std=normalize_std) ]) self.sample_transform = torchviz_ext.InvNormalize(mean=normalize_mean, std=normalize_std) # # DataLoaders # self.train_root_dataset = None self.train_orig_loader = None self.val_loader = None
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/splitall/image_list_train.pickle', 'rb') as f: image_list_train = pickle.load(f) with open('../process_input/splitall/image_dict.pickle', 'rb') as f: image_dict = pickle.load(f) with open('../lung_localization/splitall/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))
def create_dataloader_train_valid_test(train_batch_size=32, valid_batch_size=16, test_batch_size=16): common_transform_tensor = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), #transforms.Normalize(mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225]) ]) normalize_mask_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), #transforms.Normalize(mean=[0.5], # std=[0.5]) ]) train_transform = albu.Compose([ albu.RandomBrightnessContrast(p=0.5), albu.Blur(p=0.5), albu.HueSaturationValue(p=0.5), albu.ShiftScaleRotate(scale_limit=(-0.1, 0), rotate_limit=20, border_mode=0), albu.RGBShift(p=0.5), albu.CLAHE(p=0.5), albu.RandomGamma(p=0.5) ]) train_dataset, train_sampler = load_dataset( root_dir= '/media/huxi/DATA/inf_master/Semester-5/Thesis/code/dataset/train/', class_name_to_id=class_name_to_id_, aug_transform_list=[ common_transform_tensor, train_transform, normalize_mask_transform ]) valid_dataset, valid_sampler = load_dataset( root_dir= '/media/huxi/DATA/inf_master/Semester-5/Thesis/code/dataset/valid/', class_name_to_id=class_name_to_id_, aug_transform_list=[ common_transform_tensor, None, normalize_mask_transform ]) test_dataset, test_sampler = load_dataset( root_dir= '/media/huxi/DATA/inf_master/Semester-5/Thesis/code/dataset/test/', class_name_to_id=class_name_to_id_, aug_transform_list=[ common_transform_tensor, None, normalize_mask_transform ]) train_data_loader = DataLoader(train_dataset, batch_size=train_batch_size, sampler=train_sampler, num_workers=8, pin_memory=True) valid_data_loader = DataLoader(valid_dataset, batch_size=valid_batch_size, sampler=valid_sampler, num_workers=8, pin_memory=True) test_data_loader = DataLoader(test_dataset, batch_size=test_batch_size, sampler=test_sampler, num_workers=8, pin_memory=True) dataloaders = { 'train': train_data_loader, 'valid': valid_data_loader, 'test': test_data_loader, } return dataloaders
def main(): parser = ArgumentParser( description="Script to do data augmentation tests with albumentations." ) parser.add_argument("data_path", type=Path, help="Path to the dataset.") args = parser.parse_args() data_path: Path = args.data_path sizes = (512, 512) p_value = 1 # Data augmentation done on cpu. pipeline = albumentations.Compose([ albumentations.HorizontalFlip(p=0.5), albumentations.VerticalFlip(p=0.5), # albumentations.RandomRotate90(p=0.2), # albumentations.CLAHE(), albumentations.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=p_value), albumentations.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=15, val_shift_limit=10, p=p_value), albumentations.ShiftScaleRotate(scale_limit=0.05, rotate_limit=10, shift_limit=0.06, p=p_value, border_mode=cv2.BORDER_CONSTANT, value=0), # albumentations.GridDistortion(p=0.5), albumentations.Normalize(mean=(0.041, 0.129, 0.03), std=(0.054, 0.104, 0.046), max_pixel_value=255.0, p=1.0), albumentations.Resize(*sizes, interpolation=cv2.INTER_LINEAR) ]) # This assumes that the masks' paths contain either "mask" or "seg" (and that the main image does not). exts = [".jpg", ".png", ".tiff"] img_path_list = list([ p for p in data_path.rglob('*') if p.suffix in exts and "seg" not in str(p) and "mask" not in str(p) ]) nb_imgs = len(img_path_list) for i, img_path in enumerate(img_path_list, start=1): msg = f"Processing image {img_path.name} ({i}/{nb_imgs})" print( msg + ' ' * (shutil.get_terminal_size(fallback=(156, 38)).columns - len(msg)), end='\r') img = cv2.imread(str(img_path)) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) transformed = pipeline(image=img) aug_img = transformed["image"] show_img(img, "Original image") show_img(aug_img, "Augmented normalized image") denormalized_img = denormalize(aug_img, mean=(0.041, 0.129, 0.03), std=(0.054, 0.104, 0.046)) show_img(denormalized_img, "Augmented denormalized image")
self.augmentations = A.Compose(augmentations) def __call__(self, image): image = self.augmentations(image=image)['image'] return image preprocess = [ A.CenterCrop(height=137, width=IMG_WIDTH), A.Resize(height=IMG_HEIGHT, width=IMG_WIDTH, always_apply=True), ] augmentations = [ A.PadIfNeeded(min_height=256, min_width=256, border_mode=cv2.BORDER_CONSTANT, value=[255, 255, 255], always_apply=True), A.imgaug.transforms.IAAAffine(shear=5, mode='constant', cval=255, always_apply=True), A.ShiftScaleRotate(rotate_limit=5, border_mode=cv2.BORDER_CONSTANT, value=[255, 255, 255], mask_value=[255, 255, 255], always_apply=True), A.RandomCrop(height=IMG_HEIGHT, width=IMG_WIDTH, always_apply=True), ] train_transform = transforms.Compose([ np.uint8, transforms.Lambda(lambda x: np.array([x, x, x]).transpose((1, 2, 0)) ), np.uint8, Albumentations(preprocess + augmentations), transforms.ToTensor(), transforms.Normalize(mean=MEAN, std=STD), # transforms.ToPILImage(), ]) valid_transform = transforms.Compose([ np.uint8,
def get_aug(aug, min_area=0.0, min_visibility=0.0): return albumentations.Compose( aug, bbox_params={ "format": "pascal_voc", "min_area": min_area, "min_visibility": min_visibility, "label_fields": ["category_id"], }, ) train_augs = [ albumentations.RandomBrightnessContrast(always_apply=True), albumentations.ShiftScaleRotate(rotate_limit=10, always_apply=True), albumentations.augmentations.transforms.HorizontalFlip(), # albumentations.augmentations.transforms.RandomCrop(448, 448, p=1.0), ] class BBoxDataset(Dataset): def __init__(self, csv_file, size=500, type="train", aug=None, fastai_out=True): super(BBoxDataset).__init__() if csv_file is None: csv_file = get_one_sample_csv() self.df = pd.read_csv(csv_file, converters={"bbox": literal_eval}) print("Dataset has {} samples.".format((self.df.shape[0]))) if type == "train": self.aug = get_aug(train_augs) if aug is None else get_aug(aug) else:
for ch in range(img.shape[2]): alpha = 1.0 + random.uniform(self.contrast_limit[0], self.contrast_limit[1]) beta = 0.0 + random.uniform(self.brightness_limit[0], self.brightness_limit[1]) img[..., ch] = brightness_contrast_adjust(img[..., ch], alpha, beta) return img albu_tfms = A.Compose([ A.OneOf([ A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.1, rotate_limit=15, 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.NoOp() ]), 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() ]),
aug_types = albu.Compose([ albu.HorizontalFlip(p=0.5), albu.OneOf([ albu.RandomBrightnessContrast(), albu.RandomGamma(), ], p=0.3), albu.OneOf([ albu.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), albu.GridDistortion(), albu.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), albu.ShiftScaleRotate(scale_limit=0.1, rotate_limit=10, shift_limit=0.1, p=0.5, border_mode=0), ]) #Péparation de la base de données listmimg = os.listdir(brain_path) listmMask = os.listdir(mask_path) database = {'img': listmimg, 'mask': listmMask} print("test", database) df = pd.DataFrame(database) df_train, df_val = train_test_split(df, train_size=0.75, random_state=107) df_train.to_csv('df_train.csv.gz', compression='gzip', index=False)
# A.ImageCompression(quality_lower=0.7, p=1), A.GaussianBlur(p=1), ], p=0.2, ), post_transform, ]) valid_transform_3 = valid_transform_1 test_transform_3 = test_transform_1 # crop 768 and very hard augs train_transform_4 = A.Compose([ A.ShiftScaleRotate(scale_limit=0.2, rotate_limit=45, border_mode=0, value=0, p=0.7), A.PadIfNeeded(768, 768, border_mode=0, value=0, p=1.), A.RandomCrop(768, 768, p=1.), A.Flip(p=0.75), A.Downscale(scale_min=0.5, scale_max=0.75, p=0.05), A.MaskDropout(max_objects=3, image_fill_value=0, mask_fill_value=0, p=0.1), # color transforms A.OneOf( [ A.RandomBrightnessContrast( brightness_limit=0.3, contrast_limit=0.3, p=1), A.RandomGamma(gamma_limit=(70, 130), p=1), A.ChannelShuffle(p=0.2),
from tqdm import tqdm from vision.utils.split_data import split_data n_images = 500 bg_dir = '/home/mathias/Downloads/Linemod_preprocessed/data/01/rgb' bgs = [os.path.join(bg_dir, f) for f in os.listdir(bg_dir)] mask_path = 'vision/create_fence/data/fence_mask.png' img_dir = 'vision/create_fence/data/mask_fence/images' mask_dir = 'vision/create_fence/data/mask_fence/labels' transforms = A.Compose([ A.ShiftScaleRotate(p=1.0), A.HorizontalFlip(), A.VerticalFlip(), A.Transpose(), A.RandomRotate90(), A.OpticalDistortion(), A.GridDistortion(), A.Blur(), A.CLAHE(), A.RandomGamma(p=1.0), A.GaussNoise(p=1.0) ]) def rand_color(): color = list(np.random.choice(range(10, 30), size=3))
tfms = A.Compose([ A.HorizontalFlip(), A.OneOf([ A.RandomContrast(), A.RandomGamma(), A.RandomBrightness(), ], p=0.3), A.OneOf([ A.ElasticTransform( alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03), A.GridDistortion(), A.OpticalDistortion(distort_limit=2, shift_limit=0.5), ], p=0.3), A.ShiftScaleRotate(), A.Normalize(max_pixel_value=1.0, mean=(0.521, 0.521, 0.521), std=(0.304, 0.304, 0.304)), ToTensor(), ]) params = { "batch_size": 32, "stages": [{ "epochs": 8, "lr": 0.001, "freeze_to": -1 }, { "epochs": 8,
def get_augmentations(resize: int = 224, augmentation_intensity: Optional[str] = None) -> A.Compose: fix_seeds(24) crop_limits = (int(resize * 0.85), resize) if augmentation_intensity == "slight": p_augment = 0.15 p_scale = 0.15 p_blur = 0.05 p_dropout = 0.05 p_flip = 0.15 p_noise = 0.15 gauss_limit = 0.005 elif augmentation_intensity == "light": p_augment = 0.25 p_scale = 0.2 p_blur = 0.1 p_dropout = 0.05 p_flip = 0.2 p_noise = 0.2 gauss_limit = 0.01 elif augmentation_intensity == "medium": p_augment = 0.5 p_scale = 0.2 p_blur = 0.2 p_dropout = 0.1 p_flip = 0.2 p_noise = 0.2 gauss_limit = 0.015 elif augmentation_intensity == "heavy": p_augment = 0.5 p_scale = 0.35 p_blur = 0.35 p_dropout = 0.15 p_flip = 0.35 p_noise = 0.35 gauss_limit = 0.02 elif augmentation_intensity is None: return None else: raise ValueError("Improper augmentation flag: should be equal to None, light, medium, or heavraisey") augmentation = A.Compose( [ A.OneOf( [A.HorizontalFlip(), A.VerticalFlip()], p=p_flip, ), A.OneOf( [A.Rotate(p=1.0, limit=30), A.RandomRotate90(p=1.0)], p=p_scale, ), A.OneOf( [ A.ShiftScaleRotate(p=1.0, rotate_limit=30), A.RandomSizedCrop( min_max_height=crop_limits, height=resize, width=resize, w2h_ratio=1.0, interpolation=cv2.INTER_CUBIC, ), ], p=p_scale, ), A.Blur(blur_limit=3, p=p_blur), A.CoarseDropout(max_height=7, max_width=7, p=p_dropout), A.GaussNoise(var_limit=(0.0, gauss_limit), p=p_noise), ], p=p_augment, ) return augmentation
test_df = pd.read_csv("sample_submission.csv") bbox_df = pd.read_csv("bounding_boxes.csv") RESIZE_H = 224 RESIZE_W = 224 data_transforms = albumentations.Compose([ albumentations.Resize(RESIZE_H, RESIZE_W), albumentations.HorizontalFlip(), albumentations.OneOf([ albumentations.RandomContrast(), albumentations.RandomBrightness(), albumentations.Blur() ]), albumentations.ShiftScaleRotate(rotate_limit=10, scale_limit=0.15), albumentations.JpegCompression(80), albumentations.HueSaturationValue(), albumentations.Normalize(), AT.ToTensor() ]) data_transforms_test = albumentations.Compose([ albumentations.Resize(RESIZE_H, RESIZE_W), albumentations.Normalize(), AT.ToTensor() ]) # ## Set up
torch.backends.cudnn.deterministic = True # the following line gives ~10% speedup # but may lead to some stochasticity in the results torch.backends.cudnn.benchmark = True seed_everything(cfg.SEED) tfms = alb.Compose([ alb.HorizontalFlip(), alb.VerticalFlip(), alb.RandomRotate90(), alb.RandomBrightness(), alb.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=15, p=0.9, border_mode=cv2.BORDER_REFLECT), alb.OneOf([ alb.HueSaturationValue(10, 15, 10), alb.CLAHE(clip_limit=2), alb.RandomBrightnessContrast(), ], p=0.3), ], p=0.8) df_train = pd.read_csv(cfg.csv_path) df_train['id'] = [x[:9] for x in df_train['id'].values] if cfg.use_test: pass
import albumentations as A image_size = 512 train_transforms = A.Compose( [ #flip horizontal, randomcrop, scaling, clahe, randombrightnesscontrast, shiftscalerotate, blur A.ShiftScaleRotate(p=0.1), A.HorizontalFlip(p=0.5), #A.RandomCrop(512, 512, p=0.05), A.CLAHE(p=0.5), A.OneOf([ A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5), A.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, p=0.5), ], p=0.5), A.OneOf( [A.MedianBlur(p=0.5), A.GaussianBlur(p=0.5)], p=0.5), A.Normalize(p=1.0), A.Resize(height=image_size, width=image_size, p=1) ], bbox_params=A.BboxParams(format='pascal_voc', min_visibility=0.9)) train_transforms_only_image = A.Compose( [ #flip horizontal, randomcrop, scaling, clahe, randombrightnesscontrast, shiftscalerotate, blur A.ShiftScaleRotate(p=0.1), A.HorizontalFlip(p=0.5), #A.RandomCrop(512, 512, p=0.05), A.CLAHE(p=0.5),
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.ShiftScaleRotate( rotate_limit=20, scale_limit=0, p=0.5, mask_value=ignore_index), albu.RandomBrightnessContrast(p=0.5), albu.RandomGamma(p=0.5), albu.HueSaturationValue(p=0.5), albu.HorizontalFlip(p=0.5), normalization, ], p=1, ) val_augmentations = albu.Compose( [ albu.PadIfNeeded(min_height=1024, min_width=2048, border_mode=cv2.BORDER_CONSTANT, mask_value=ignore_index,
return LOGGER EXP_ID = "exp48_densenet121_backborn_75epoch_1e-4" LOGGER_PATH = f"logs/log_{EXP_ID}.txt" setup_logger(out_file=LOGGER_PATH) LOGGER.info("seed={}".format(SEED)) SIZE = 128 HEIGHT = 137 WIDTH = 236 OUT_DIR = 'models' data_transforms_96 = albumentations.Compose([ albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=(5, 15), p=0.5), albumentations.CenterCrop(96, 96, p=1), albumentations.Resize(256, 256, p=1), albumentations.Cutout(num_holes=1, max_h_size=40, max_w_size=15, p=0.1), albumentations.OneOf([ GridMask(num_grid=1, rotate=(5, 15), p=0.15), GridMask(num_grid=2, rotate=(5, 15), p=0.15), ], p=0.1) ]) data_transforms_104 = albumentations.Compose([ albumentations.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=(5, 15),
def prepare_net(config, model, GCNModel, _use='train'): # img_size = (config['img_size'], config['img_size']) def worker_init_fn(worker_id): random.seed(config['seed'] + worker_id) if _use == 'train': if config['optim'] == 'Adam': optimizer = torch.optim.Adam(model.parameters(), config['lr'], weight_decay=config['weight_decay']) gcn_optimizer = torch.optim.Adam( GCNModel.parameters(), config['lr'], weight_decay=config['weight_decay']) if config['optim'] == 'RMSprop': optimizer = torch.optim.RMSprop( model.parameters(), config['lr'], weight_decay=config['weight_decay']) gcn_optimizer = torch.optim.RMSprop( GCNModel.parameters(), config['lr'], weight_decay=config['weight_decay']) elif config['optim'] == 'SGD': optimizer = torch.optim.SGD(model.parameters(), config['lr'], momentum=config['momentum'], weight_decay=config['weight_decay'], nesterov=config['nesterov']) gcn_optimizer = torch.optim.SGD( GCNModel.parameters(), config['lr'], momentum=config['momentum'], weight_decay=config['weight_decay'], nesterov=config['nesterov']) folds = [fold for fold in range(config['n_fold'])] train_dataset = CustomDataset( 'train', config['DataRoot'], config['TrainFold'], None, transform=albumentations.Compose([ albumentations.Resize(config['img_size'], config['img_size']), albumentations.OneOf( [ # albumentations.RandomGamma(gamma_limit=(60, 120), p=0.9), albumentations.RandomBrightnessContrast( brightness_limit=0.05, contrast_limit=0.05, p=0.9), ], p=0.5), albumentations.OneOf( [ albumentations.Blur(blur_limit=4, p=1), # albumentations.MotionBlur(blur_limit=4, p=1), # albumentations.MedianBlur( # blur_limit=4, p=1) ], p=0.5), albumentations.HorizontalFlip(p=0.5), albumentations.ShiftScaleRotate( shift_limit=0.01, scale_limit=0.01, rotate_limit=3, interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_CONSTANT, p=0.5), # albumentations.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), max_pixel_value=255.0, always_apply=False, p=1.0) ]), ) labeled_df = pd.read_csv(config['TrainFold']) labeled_fold = [i for i in config['label_fold']] labeled_df = labeled_df[labeled_df.fold_label.isin(labeled_fold)] labeled_fold_name = labeled_df.image.tolist() labeled_idxs, unlabeled_idxs = relabel_dataset(train_dataset, labeled_fold_name) batch_sampler = TwoStreamBatchSampler(unlabeled_idxs, labeled_idxs, config['batchsize'], config['label_bs']) train_loader = torch.utils.data.DataLoader( train_dataset, num_workers=config['num_workers'], batch_sampler=batch_sampler, pin_memory=True, worker_init_fn=worker_init_fn) # Count different classes num in train dataset # all_label = np.array([label for _, _, label, _, _ in train_dataset]) # class_sample_count = np.array([len(np.where(all_label == t)[0]) for t in np.unique(all_label)]) # for index in range(len(config['Data_CLASSES'])): # print("Train class {}: Num {}".format(index, class_sample_count[index])) valid_dataset = CustomDataset('valid', config['DataRoot'], config['ValidFold'], None, transform=albumentations.Compose([ albumentations.Resize( config['img_size'], config['img_size']), ])) valid_loader = torch.utils.data.DataLoader( valid_dataset, batch_size=10, shuffle=False, num_workers=config['num_workers'], drop_last=False, pin_memory=True, worker_init_fn=worker_init_fn) # Count different classes num in valid dataset # all_label = np.array([label for _, _, label, _, _ in valid_dataset]) # class_sample_count = np.array([len(np.where(all_label == t)[0]) for t in np.unique(all_label)]) # for index in range(len(config['Data_CLASSES'])): # print("Valid class {}: Num {}".format(index, class_sample_count[index])) return optimizer, gcn_optimizer, train_loader, valid_loader elif _use == 'infer': infer_dataset = CustomDataset('infer', config['DataRoot'], config['TestFold'], None, transform=albumentations.Compose([ albumentations.Resize( config['img_size'], config['img_size']), ])) infer_loader = torch.utils.data.DataLoader( infer_dataset, batch_size=10, shuffle=False, num_workers=config['num_workers'], drop_last=False, pin_memory=True, worker_init_fn=worker_init_fn) return infer_loader
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.5), alb.RandomResizedCrop(height=int(0.8192 * width_size), width=width_size, scale=(0.5, 1.5), 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(0.8192 * width_size / 6), max_width=int(width_size / 6), min_height=int(0.8192 * width_size / 20), min_width=int(width_size / 20), p=0.5), alb.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2() ]) train_set = ImagesWithAnnotationsDataset(train_df, annot_df, train_image_transforms, '../ranzcr/train',
def __init__(self, image_paths, labels=None, train=True, test=False, aug=None, use_onehot=False): self.paths = image_paths self.test = test self.use_onehot = use_onehot if self.test == False: self.labels = labels self.train = train # self.transform = albu.Compose([albu.HorizontalFlip(p=0.5), # albu.VerticalFlip(p=0.5), # albu.ShiftScaleRotate(rotate_limit=25.0, p=0.7), # albu.OneOf([albu.IAAEmboss(p=1), # albu.IAASharpen(p=1), # albu.Blur(p=1)], p=0.5), # albu.IAAPiecewiseAffine(p=0.5), # albu.Resize(545, 545, always_apply=True), # albu.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), # albu.pytorch.ToTensor(), # ]) self.transform = [] self.transform.append(albu.HorizontalFlip(p=0.5)) self.transform.append(albu.VerticalFlip(p=0.5)) if aug is not None and 'rt90' in aug: print('=> using rotate 90.') self.transform.append(albu.RandomRotate90(p=0.5)) self.transform.append(albu.ShiftScaleRotate(rotate_limit=25.0, p=0.7)) self.transform.append( albu.OneOf( [albu.IAAEmboss(p=1), albu.IAASharpen(p=1), albu.Blur(p=1)], p=0.5)) self.transform.append(albu.IAAPiecewiseAffine(p=0.5)) if aug is not None and 'cj' in aug: print('=> using color jittering.') self.transform.append(albu.RandomBrightness(p=0.5)) self.transform.append(albu.HueSaturationValue(p=0.5)) self.transform.append(albu.Resize(545, 545, always_apply=True)) if aug is not None and 'autoaug' in aug: print('=> using autoaug.') self.transform.append(albuImageNetPolicy()) self.transform.append( albu.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))) self.transform.append(albu.pytorch.ToTensor()) self.transform = albu.Compose(self.transform) self.usere = False if aug is not None and 're' in aug: self.usere = True print('=> using random erasing.') self.re = RandomErasing() self.default_transform = albu.Compose([ albu.Resize(545, 545, always_apply=True), albu.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225), always_apply=True), albu.pytorch.ToTensor() ]) # normalized for pretrained network
"pretrained": True, "fp16": True, "grayscale": False, "DEBUG": True } args['tr_aug'] = A.Compose( [ # A.Resize(512, 512), # A.RandomCrop(448, 448, p=0.5), # A.RandomResizedCrop(512, 512), A.Resize(512, 512), A.Transpose(p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.ShiftScaleRotate(p=0.5), # A.OneOf([ # A.MotionBlur(blur_limit=5), # A.MedianBlur(blur_limit=5), # #A.GaussianBlur(blur_limit=5), # A.GaussNoise(var_limit=(5.0, 30.0))], p=0.5), # A.Normalize(), ], p=1.) args['val_aug'] = A.Compose( [ # A.Resize(512, 512), # A.RandomCrop(448, 448, p=0.5), # A.RandomResizedCrop(512, 512), A.Resize(512, 512),
[A.RandomBrightness(limit=0.1, p=1), A.RandomContrast(limit=0.1, p=1)]), A.OneOf( [ A.MotionBlur(blur_limit=3), A.MedianBlur(blur_limit=3), A.GaussianBlur(blur_limit=3), ], p=0.5, ), A.VerticalFlip(p=0.5), A.HorizontalFlip(p=0.5), A.ShiftScaleRotate( shift_limit=0.2, scale_limit=0.2, rotate_limit=20, interpolation=cv2.INTER_LINEAR, border_mode=cv2.BORDER_REFLECT_101, p=1, ), A.Cutout(num_holes=6, max_h_size=64, max_w_size=64, fill_value=0, p=0.5), A.Normalize(mean=[0.4309, 0.4968, 0.3135], std=[0.2131, 0.2179, 0.1940]), ToTensorV2(p=1.0), ]) valid_transforms = A.Compose([ A.Resize(img_size[0], img_size[1], p=1.0), A.Normalize(mean=[0.4309, 0.4968, 0.3135], std=[0.2131, 0.2179, 0.1940]), ToTensorV2(p=1.0), ], p=1.0)
args.sep_conv = bool(args.sep_conv) # for reproduciblity if args.resume_dir is None: make_reproducible() # define device device = 'cuda' if torch.cuda.is_available() else 'cpu' # create logdir save_path = f'logs/{args.logdir}' mkdir(save_path) # define augmentation train_transform = albu.Compose([ albu.ShiftScaleRotate(shift_limit=0.125, border_mode=0, value=0, p=1), albu.HorizontalFlip(p=0.5), albu.CoarseDropout(max_holes=3, max_height=8, max_width=8), albu.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261)) ]) val_transform = albu.Compose([ albu.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261)) ]) # load data x_train = joblib.load('data/x_data.jl') y_train = joblib.load('data/y_data.jl') x_val = joblib.load('data/x_test.jl') y_val = joblib.load('data/y_test.jl') train_loader = get_loader(x_train, y_train, batch_size=args.batch_size, num_workers=args.num_workers, transforms=train_transform, shuffle=True)