def main(): # augmentation transform_aug = Compose([ aug.HueSaturationValue(), aug.RandomBrightnessContrast(), aug.CLAHE(), aug.JpegCompression(), aug.GaussNoise(), aug.MedianBlur(), aug.ElasticTransform(), aug.HorizontalFlip(), aug.Rotate(), aug.CoarseDropout(), aug.RandomSizedCrop() ], p=1) # transform for output transform = Compose([ Resize(cons.IMAGE_SIZE, cons.IMAGE_SIZE), Normalize( mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), max_pixel_value=255.0) ], p=1) # Dataset ''' dataset = UkiyoeTrainDataset( train_images_path='data', train_labels_path='data', valid=False, confidence_boader=0.87, result_path='result/model_effi_b3/efficientnet_b3_980/inference_with_c.csv', test_images_path='data', over_sampling=False, transform_aug=None, augmix=False, mixup=False, transform=transform) img, label = dataset[0] #print(img.shape) #plt.imshow(img) #plt.show() ''' # train data loader loader = load_train_data(train_images_path='data', train_labels_path='data', batch_size=2, valid=False, nfold=0, transform_aug=None, augmix=True, mixup=False, transform=transform, as_numpy=True) image_batch, label_batch = next(loader.__iter__()) print(image_batch[0].shape) print(label_batch[0].shape) '''
def val_transfrom(self, image, image_size): transform = Compose([ Resize(image_size, image_size, interpolation=cv2.INTER_AREA), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ToTensorV2() ]) image_transform = transform(image=image)['image'] return image_transform
def __init__(self, df=None, size=150, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], augment=True, frames=30, stochastic=True): """ Dataset initialization Parameters ---------- df : pd.DataFrame Dataframe with preprocessed data transform : torchvision.transforms Transformation operations for loaded images path : str Path to folder with the data frames : int Frames to load per video """ assert df is not None, 'Missing dataframe for data' self.frames = frames self.df = df[df['nframes'] >= frames] self.stochastic = stochastic addtl_img = {} for idx in range(frames): addtl_img['image{}'.format(idx)] = 'image' if augment: self.transform = albumentations.Compose( [ ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=15), HorizontalFlip(p=0.2), RandomBrightnessContrast( p=0.3, brightness_limit=0.25, contrast_limit=0.5), MotionBlur(p=.2), GaussNoise(p=.2), JpegCompression(p=.2, quality_lower=50), Normalize(mean, std) ], additional_targets=addtl_img) else: self.transform = albumentations.Compose([Normalize(mean, std)]) self.resize = transforms.Resize((size, size))
def __init__( self, system_config: configuration.SystemConfig = configuration.SystemConfig(), dataset_config: configuration.DatasetConfig = configuration.DatasetConfig(), # pylint: disable=redefined-outer-name dataloader_config: configuration.DataloaderConfig = configuration.DataloaderConfig(), # pylint: disable=redefined-outer-name optimizer_config: configuration.OptimizerConfig = configuration.OptimizerConfig(), # pylint: disable=redefined-outer-name ): self.system_config = system_config setup_system(system_config) self.dataset_train = ListDataset( root_dir=dataset_config.root_dir, list_file='../train_anno.txt', classes=["__background__", "person"], mode='train', transform=Compose(dataset_config.train_transforms), input_size=300 ) self.loader_train = DataLoader( dataset=self.dataset_train, batch_size=dataloader_config.batch_size, shuffle=True, collate_fn=self.dataset_train.collate_fn, num_workers=dataloader_config.num_workers, pin_memory=True ) self.dataset_test = ListDataset( root_dir=dataset_config.root_dir, list_file='../test_anno.txt', classes=["__background__", "person"], mode='val', transform=Compose([Normalize(), ToTensorV2()]), input_size=300 ) self.loader_test = DataLoader( dataset=self.dataset_test, batch_size=dataloader_config.batch_size, shuffle=False, collate_fn=self.dataset_test.collate_fn, num_workers=dataloader_config.num_workers, pin_memory=True ) self.model = Detector(len(self.dataset_train.classes)) self.loss_fn = DetectionLoss(len(self.dataset_train.classes)) self.metric_fn = APEstimator(classes=self.dataset_test.classes) self.optimizer = optim.SGD( self.model.parameters(), lr=optimizer_config.learning_rate, weight_decay=optimizer_config.weight_decay, momentum=optimizer_config.momentum ) self.lr_scheduler = MultiStepLR( self.optimizer, milestones=optimizer_config.lr_step_milestones, gamma=optimizer_config.lr_gamma ) self.visualizer = MatplotlibVisualizer()
def _define_augment(self, input_shape, do_augmentation): # mean, std, max_pixel_valueは適宜変更してください mean = (0.485 * 255, 0.456 * 255, 0.406 * 255) std = (0.229 * 255, 0.224 * 255, 0.225 * 255) normalize = Normalize(mean=mean, std=std, max_pixel_value=1) # データ拡張内容は適宜変更してください if do_augmentation: return Compose([normalize, HorizontalFlip(p=0.5)]) else: return Compose([normalize])
def test_transfrom( image, size=256 ): # note that test image size is same as crop_size in get_transfrom transform = Compose([ Resize(size, size, interpolation=cv2.INTER_AREA), Normalize(mean=[0.3835, 0.3737, 0.3698], std=[1.0265, 1.0440, 1.0499]), ToTensorV2() ]) image_transform = transform(image=image)['image'] return image_transform
def __init__(self): self.transforms = Compose([ HueSaturationValue(p=0.5), RandomBrightnessContrast(), GaussianBlur(), HorizontalFlip(p=.5), Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010), max_pixel_value=255.0, always_apply=True, p=1.0) ])
def _transform(self, img, mean, std): img = np.moveaxis(img, 0, 2) if self.mode == 'train': img = self.transform_train(image=img)['image'] elif self.mode == 'val': img = self.transform_val(image=img)['image'] normalize = Compose( [Normalize(mean=mean, std=std, max_pixel_value=255.0, p=1.0)], p=1.0) img = normalize(image=img)['image'] img = np.moveaxis(img, 2, 0) return img
def train_transfrom(image, size=256): transform = Compose([ Resize(size, size, interpolation=cv2.INTER_AREA), Flip(), RandomBrightnessContrast(), HueSaturationValue(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ToTensorV2() ]) image_transform = transform(image=image)['image'] return image_transform
def __init__(self): self.transforms = Compose([ PadIfNeeded(40, 40), RandomCrop(32, 32), HorizontalFlip(p=.5), Cutout(8, 8), Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010), max_pixel_value=255.0, always_apply=True, p=1.0), ToTensor() ])
def rand_aug(): return Compose([ RandomRotate90(p=0.2), GaussNoise(p=0.2), HorizontalFlip(p=0.2), RandomCrop(p=0.2), HueSaturationValue(p=0.2), RandomBrightness(p=0.2), RandomContrast(p=0.2), RandomGamma(p=0.2), GaussianBlur(p=0.2), ]), Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1.0)
def preprocess_image(img_path): # transformations for the input data transforms = Compose([ Resize(224, 224, interpolation=cv2.INTER_NEAREST), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ToTensor(), ]) # read input image input_img = cv2.imread(img_path) # do transformations input_data = transforms(image=input_img)["image"] batch_data = torch.unsqueeze(input_data, 0) return batch_data
def main(argv=None): loader = load_test_data( data_path=FLAGS.test_images_path, batch_size=1, transform=Compose([ Resize(cons.IMAGE_SIZE,cons.IMAGE_SIZE), Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5),max_pixel_value=255.0)])) data_len = UkiyoeTestDataset(data_path=FLAGS.test_images_path).__len__() confidence_sum = np.zeros((data_len,cons.NUM_CLASSES)) ratio_sum = 0 for e in range(len(PARAM_LIST)): ratio_sum = ratio_sum + PARAM_LIST[e]['ratio'] PARAM_PATH = FLAGS.params_path + PARAM_LIST[e]['model'] model = models.get_model(model_name=PARAM_LIST[e]['model'].split('/')[2],num_classes=cons.NUM_CLASSES) if PARAM_LIST[e]['fix']: model.load_state_dict(fix_model_state_dict(torch.load(PARAM_PATH))) else: model.load_state_dict(torch.load(PARAM_PATH)) confidence_sum = confidence_sum + inference_loop(model,loader,data_len)*PARAM_LIST[e]['ratio'] pred = np.argmax(confidence_sum, axis=1) confidence = confidence_sum/ratio_sum if FLAGS.adjust_inference: pred = adjust_inference(pred,confidence,data_len) result = pd.DataFrame(columns=['id','y']) if FLAGS.output_confidence: result_with_c = pd.DataFrame(columns=['id','y','confidence']) for idx,feed in enumerate(loader): id,_ = feed result = result.append( pd.Series( [id.data.numpy()[0], pred[idx]], index=result.columns), ignore_index=True) if FLAGS.output_confidence: result_with_c = result_with_c.append( pd.Series( [id.data.numpy()[0], pred[idx], confidence[idx,pred[idx]]], index=result_with_c.columns), ignore_index=True) RESULT_DIR = FLAGS.result_path +'/'+ FLAGS.case os.makedirs(RESULT_DIR,exist_ok=True) result.to_csv(RESULT_DIR +'/inference.csv', index=False) if FLAGS.output_confidence: result_with_c[['id','y']] = result_with_c[['id','y']].astype(int) result_with_c.to_csv(RESULT_DIR +'/inference_with_c.csv', index=False)
def ensemble_prediction(self): ds = self.train_loader.dataset transforms = Compose([Normalize(), ToTensorV2()]) for idx, images in tqdm(ds.images.items(), total=len(ds)): augmented = transforms(image=images['image']) img = augmented['image'].unsqueeze(0).to(self.config.device) with torch.no_grad(): pred = torch.nn.functional.softmax(self.model(img), dim=1) weight = torch.tensor(images['weight']) pred = pred.squeeze(0).cpu() x = pred[1] weight[..., 0] = self.config.alpha * x + ( 1 - self.config.alpha) * weight[..., 0] self.train_loader.dataset.images[idx]['weight'] = weight.numpy() self.n_ensemble += 1
def get_transfrom(image, size=512, crop_size=256): transform = Compose([ Resize(size, size, interpolation=cv2.INTER_AREA), RandomCrop(crop_size, crop_size), Cutout(num_holes=4), HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2), RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2), Flip(), Normalize(mean=[0.3835, 0.3737, 0.3698], std=[1.0265, 1.0440, 1.0499]), ToTensorV2() ]) image_transform = transform(image=image)['image'] return image_transform
def test_dataloader(self): augmentations = Compose([ Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ToTensorV2(), ]) test_ds = MelanomaDataset( df=self.test_df, images_path=self.test_images_path, augmentations=augmentations, # TODO: add TTA train_or_valid=False, ) return DataLoader( test_ds, batch_size=self.hparams.bs, shuffle=False, num_workers=os.cpu_count(), pin_memory=False, )
def main(argv=None): PARAM_PATH = FLAGS.params_path + '/' + FLAGS.case + '/' + FLAGS.model_name + '/fold' + str( FLAGS.nfold) RESULT_DIR = FLAGS.result_path + '/' + FLAGS.case + '/' + FLAGS.model_name if FLAGS.pseudo_labeling: PARAM_PATH = PARAM_PATH + '/with_pseudo_labeling' RESULT_DIR = RESULT_DIR + '/with_pseudo_labeling' PARAM_PATH = PARAM_PATH + '/' + FLAGS.case RESULT_DIR = RESULT_DIR + '/' + FLAGS.case if FLAGS.is_best_param: PARAM_PATH = PARAM_PATH + '_best' RESULT_DIR = RESULT_DIR + '_best' else: PARAM_PATH = PARAM_PATH + '_' + str(FLAGS.executed_epoch) RESULT_DIR = RESULT_DIR + '_' + str(FLAGS.executed_epoch) if FLAGS.is_final_epoch: PARAM_PATH = PARAM_PATH + '_final' RESULT_DIR = RESULT_DIR + '_final' PARAM_PATH = PARAM_PATH + '.pth' loader = load_test_data(data_path=FLAGS.test_images_path, batch_size=1, transform=Compose([ Resize(cons.IMAGE_SIZE, cons.IMAGE_SIZE), Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), max_pixel_value=255.0) ])) model = models.get_model(model_name=FLAGS.model_name, num_classes=cons.NUM_CLASSES) if FLAGS.fix_state_dict: model.load_state_dict(fix_model_state_dict(torch.load(PARAM_PATH))) else: model.load_state_dict(torch.load(PARAM_PATH)) result = inference_loop(model, loader, FLAGS.output_confidence) os.makedirs(RESULT_DIR, exist_ok=True) result.to_csv(RESULT_DIR + '/inference.csv', index=False) if FLAGS.output_confidence: result.to_csv(RESULT_DIR + '/inference_with_c.csv', index=False)
def transform(self, img: t.Any) -> t.Any: max_hw = max(img.shape[0:2]) img = PadIfNeeded(max_hw, max_hw, border_mode=cv2.BORDER_REPLICATE)(image=img)[ "image" ] img = Resize(self.resolution, self.resolution)(image=img)["image"] img = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225],)( image=img )["image"] if self.mode == "Train": img = RandomResizedCrop(self.resolution, self.resolution)(image=img)[ "image" ] img = Cutout(p=0.2)(image=img)["image"] img = HorizontalFlip(p=0.5)(image=img)["image"] img = ShiftScaleRotate( shift_limit=0.1, scale_limit=0.0, rotate_limit=10, p=0.3 )(image=img)["image"] img = ToTensorV2()(image=img)["image"] return img
def train_dataloader(self): augmentations = Compose([ RandomResizedCrop( height=self.hparams.sz, width=self.hparams.sz, scale=(0.7, 1.0), ), # ToGray(), GridDistortion(), RandomBrightnessContrast(), ShiftScaleRotate(), Flip(p=0.5), CoarseDropout( max_height=int(self.hparams.sz / 10), max_width=int(self.hparams.sz / 10), ), Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], max_pixel_value=255, ), ToTensorV2(), ]) train_ds = MelanomaDataset( df=self.train_df, images_path=self.train_images_path, augmentations=augmentations, train_or_valid=True, ) return DataLoader( train_ds, # sampler=sampler, batch_size=self.hparams.bs, shuffle=True, num_workers=os.cpu_count(), pin_memory=False, )
from albumentations import ( HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90, Transpose, Blur, OpticalDistortion, GridDistortion, HueSaturationValue, IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, IAASharpen, IAAEmboss, RandomContrast, RandomBrightness, Flip, OneOf, Compose, RandomGamma, ElasticTransform, ChannelShuffle,RGBShift, Rotate, Cutout ) # YOUR PATH path = f'/mnt/c/Users/bokhy/Desktop/Python/github/kaggle/bengaliai-cv19/input/' HEIGHT = 137 WIDTH = 236 # Augmentation train_augmentation = Compose([ Resize(HEIGHT,WIDTH, always_apply= True), Normalize(mean, std, always_apply = True), Rotate(), Flip(), OneOf([ IAAAdditiveGaussianNoise(), GaussNoise(), ], p=0.2), OneOf([ MotionBlur(p=0.2), MedianBlur(blur_limit=3, p=0.1), Blur(blur_limit=3, p=0.1), ], p=0.2), ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2), OneOf([ OpticalDistortion(p=0.3), GridDistortion(p=.1),
print('There are ' + str(y.count(1)) + ' fake train samples') print('There are ' + str(y.count(0)) + ' real train samples') print('There are ' + str(val_y.count(1)) + ' fake val samples') print('There are ' + str(val_y.count(0)) + ' real val samples') import albumentations from albumentations.augmentations.transforms import ShiftScaleRotate, HorizontalFlip, Normalize, RandomBrightnessContrast, MotionBlur, Blur, GaussNoise, JpegCompression train_transform = albumentations.Compose([ ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=25), HorizontalFlip(p=0.2), RandomBrightnessContrast(p=0.3, brightness_limit=0.25, contrast_limit=0.5), MotionBlur(p=.2), GaussNoise(p=.2), JpegCompression(p=.2, quality_lower=50), Normalize() ]) val_transform = albumentations.Compose([ Normalize() ]) train_dataset = ImageDataset(X, y, transform=train_transform) val_dataset = ImageDataset(val_X, val_y, transform=val_transform) ### Train import gc history = pd.DataFrame() history2 = pd.DataFrame()
import cv2 ##导入albumentations来做图像增强 input_size = 224 import albumentations from albumentations.augmentations.transforms import Resize, RandomSizedCrop, ShiftScaleRotate, HorizontalFlip, Normalize, RandomBrightnessContrast, MotionBlur, Blur, GaussNoise, JpegCompression train_transform = albumentations.Compose([ RandomSizedCrop(min_max_height=(input_size//3,input_size//3),height=input_size,width=input_size), ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=25), HorizontalFlip(p=0.2), RandomBrightnessContrast(p=0.3, brightness_limit=0.25, contrast_limit=0.5), MotionBlur(p=.2), GaussNoise(p=.2), JpegCompression(p=.2, quality_lower=50), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) val_transform = albumentations.Compose([ Resize(input_size,input_size), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) class MyDataset(data.Dataset): def __init__(self,root,transforms = None,is_train=True): """ 主要目标获取所有图片的地址 """ fake_path = os.path.join(root,"fake") real_path = os.path.join(root,"real")
def main(): global args, config, best_loss args = parser.parse_args() with open(args.config) as f: config = yaml.load(f) for k, v in config['common'].items(): setattr(args, k, v) config = EasyDict(config['common']) rank, world_size, device_id = dist_init( os.path.join(args.distributed_path, config.distributed_file)) args.save_path_dated = args.save_path + '/' + args.datetime if args.run_tag != '': args.save_path_dated += '-' + args.run_tag # create model model = model_entry(config.model) model.cuda() model = nn.parallel.DistributedDataParallel(model, device_ids=[device_id]) # create optimizer opt_config = config.optimizer opt_config.kwargs.lr = config.lr_scheduler.base_lr opt_config.kwargs.params = model.parameters() optimizer = optim_entry(opt_config) # optionally resume from a checkpoint last_iter = -1 best_loss = 1e9 if args.load_path: if args.recover: best_loss, last_iter = load_state(args.load_path, model, optimizer=optimizer) else: load_state(args.load_path, model) cudnn.benchmark = True # train augmentation if config.augmentation.get('imgnet_mean', False): model_mean = (0.485, 0.456, 0.406) model_std = (0.229, 0.224, 0.225) else: model_mean = (0.5, 0.5, 0.5) model_std = (0.5, 0.5, 0.5) trans = albumentations.Compose([ RandomResizedCrop(config.augmentation.input_size, config.augmentation.input_size, scale=(config.augmentation.min_scale**2., 1.), ratio=(1., 1.)), HorizontalFlip(p=0.5), RandomBrightnessContrast(brightness_limit=0.25, contrast_limit=0.1, p=0.5), JpegCompression(p=.2, quality_lower=50), MotionBlur(p=0.5), Normalize(mean=model_mean, std=model_std), ToTensorV2() ]) train_dataset = FaceDataset(config.train_root, config.train_source, transform=trans, resize=config.augmentation.input_size, image_format=config.get('image_format', None), random_frame=config.get( 'train_random_frame', False), bgr=config.augmentation.get('bgr', False)) train_sampler = DistributedGivenIterationSampler( train_dataset, config.lr_scheduler.max_iter, config.batch_size, last_iter=last_iter) train_loader = DataLoader(train_dataset, batch_size=config.batch_size, shuffle=False, num_workers=config.workers, pin_memory=True, sampler=train_sampler) # validation augmentation trans = albumentations.Compose([ Resize(config.augmentation.input_size, config.augmentation.input_size), Normalize(mean=model_mean, std=model_std), ToTensorV2() ]) val_multi_loader = [] if args.val_source != '': for dataset_idx in range(len(args.val_source)): val_dataset = FaceDataset( args.val_root[dataset_idx], args.val_source[dataset_idx], transform=trans, output_index=True, resize=config.augmentation.input_size, image_format=config.get('image_format', None), bgr=config.augmentation.get('bgr', False)) val_sampler = DistributedSampler(val_dataset, round_up=False) val_loader = DataLoader(val_dataset, batch_size=config.batch_size, shuffle=False, num_workers=config.workers, pin_memory=True, sampler=val_sampler) val_multi_loader.append(val_loader) config.lr_scheduler['optimizer'] = optimizer config.lr_scheduler['last_iter'] = last_iter lr_scheduler = get_scheduler(config.lr_scheduler) if rank == 0: mkdir(args.save_path) mkdir(args.save_path_dated) tb_logger = SummaryWriter(args.save_path_dated) logger = create_logger('global_logger', args.save_path_dated + '-log.txt') logger.info('{}'.format(args)) logger.info(model) logger.info(parameters_string(model)) logger.info('len(train dataset) = %d' % len(train_loader.dataset)) for dataset_idx in range(len(val_multi_loader)): logger.info( 'len(val%d dataset) = %d' % (dataset_idx, len(val_multi_loader[dataset_idx].dataset))) mkdir(args.save_path_dated + '/saves') else: tb_logger = None positive_weight = config.get('positive_weight', 0.5) weight = torch.tensor([1. - positive_weight, positive_weight]) * 2. if rank == 0: logger.info('using class weights: {}'.format(weight.tolist())) criterion = nn.CrossEntropyLoss(weight=weight).cuda() if args.evaluate: if args.evaluate_path: all_ckpt = get_all_checkpoint(args.evaluate_path, args.range_list, rank) for ckpt in all_ckpt: if rank == 0: logger.info('Testing ckpt: ' + ckpt) last_iter = -1 _, last_iter = load_state(ckpt, model, optimizer=optimizer) for dataset_idx in range(len(val_multi_loader)): validate(dataset_idx, val_multi_loader[dataset_idx], model, criterion, tb_logger, curr_step=last_iter, save_softmax=True) else: for dataset_idx in range(len(val_multi_loader)): validate(dataset_idx, val_multi_loader[dataset_idx], model, criterion, tb_logger, curr_step=last_iter, save_softmax=True) return train(train_loader, val_multi_loader, model, criterion, optimizer, lr_scheduler, last_iter + 1, tb_logger) return
print('There are ' + str(y.count(1)) + ' fake train samples') print('There are ' + str(y.count(0)) + ' real train samples') print('There are ' + str(val_y.count(1)) + ' fake val samples') print('There are ' + str(val_y.count(0)) + ' real val samples') import albumentations from albumentations.augmentations.transforms import ShiftScaleRotate, HorizontalFlip, Normalize, RandomBrightnessContrast, MotionBlur, Blur, GaussNoise, JpegCompression train_transform = albumentations.Compose([ ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=25), HorizontalFlip(p=0.2), RandomBrightnessContrast(p=0.3, brightness_limit=0.25, contrast_limit=0.5), MotionBlur(p=.2), GaussNoise(p=.2), JpegCompression(p=.2, quality_lower=50), Normalize() ]) val_transform = albumentations.Compose([Normalize()]) train_dataset = ImageDataset(X, y, transform=train_transform) val_dataset = ImageDataset(val_X, val_y, transform=val_transform) nrow, ncol = 5, 6 fig, axes = plt.subplots(nrow, ncol, figsize=(20, 8)) axes = axes.flatten() for i, ax in enumerate(axes): image, label = train_dataset[i] image = np.rollaxis(image, 0, 3) image = image * std + mean image = np.clip(image, 0., 1.) ax.imshow(image)
# Downloading dataset DataSetDownloader(root_dir='data', dataset_title='PennFudanPed', download=True) dataset_config = configuration.DatasetConfig( root_dir="data/PennFudanPed/", train_transforms=[ RandomBrightness(p=0.5), RandomContrast(p=0.5), OneOf([ RandomGamma(), HueSaturationValue(hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50), RGBShift() ], p=1), OneOf([Blur(always_apply=True), GaussNoise(always_apply=True)], p=1), CLAHE(), Normalize(), ToTensorV2() ] ) optimizer_config = configuration.OptimizerConfig( learning_rate=5e-3, lr_step_milestones=[50], lr_gamma=0.1, momentum=0.9, weight_decay=1e-5 ) experiment = Experiment( dataset_config=dataset_config, dataloader_config=dataloader_config,
def main(argv=None): transform = Compose([ Resize(cons.IMAGE_SIZE, cons.IMAGE_SIZE), Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), max_pixel_value=255.0) ]) valid_loader = load_train_data(train_images_path=FLAGS.train_images_path, train_labels_path=FLAGS.train_labels_path, batch_size=FLAGS.batch_size, num_worker=FLAGS.num_worker, valid=True, nfold=FLAGS.nfold, transform=transform) model = models.get_model(model_name=FLAGS.model_name, num_classes=cons.NUM_CLASSES) model.cuda() #model = torch.nn.DataParallel(model) DIR = '/' + FLAGS.case + '/' + FLAGS.model_name + '/fold' + str( FLAGS.nfold) RESULT_PATH = '' if FLAGS.confidence_border is not None: DIR = DIR + '/with_pseudo_labeling' RESULT_PATH = RESULT_PATH + FLAGS.result_path if FLAGS.result_case is not None: RESULT_PATH = RESULT_PATH + '/' + FLAGS.result_case RESULT_PATH = RESULT_PATH + '/inference_with_c.csv' PARAM_DIR = FLAGS.params_path + DIR os.makedirs(PARAM_DIR, exist_ok=True) PARAM_NAME = PARAM_DIR + '/' + FLAGS.case if FLAGS.executed_epoch > 0: TRAINED_PARAM_PATH = FLAGS.restart_param_path + '/' + FLAGS.case + str( FLAGS.executed_epoch) restart_epoch = FLAGS.executed_epoch + 1 if FLAGS.restart_from_final: TRAINED_PARAM_PATH = TRAINED_PARAM_PATH + '_final' TRAINED_PARAM_PATH = TRAINED_PARAM_PATH + '.pth' model.load_state_dict(torch.load(TRAINED_PARAM_PATH)) else: restart_epoch = 0 optimizer = optim.Adam(model.parameters(), lr=cons.start_lr) model, optimizer = amp.initialize(model, optimizer, opt_level=FLAGS.opt_level) if FLAGS.add_class_weight: loader = load_train_data(train_images_path=FLAGS.train_images_path, train_labels_path=FLAGS.train_labels_path, batch_size=FLAGS.batch_size, num_worker=FLAGS.num_worker, nfold=FLAGS.nfold) count_label = np.zeros(10, dtype=np.int64) for feed in loader: _, labels = feed count_label += np.sum(labels.numpy().astype(np.int64), axis=0) weight = torch.from_numpy(count_label).cuda() else: weight = None criterion = nn.BCEWithLogitsLoss(weight=weight) writer = SummaryWriter(log_dir=FLAGS.logs_path + DIR + '/tensorboardX/') best_acc = 0 if FLAGS.augmentation and FLAGS.aug_decrease: p = 0.5 for e in range(restart_epoch, FLAGS.final_epoch): p_partical = p * (FLAGS.final_epoch - e) / FLAGS.final_epoch lr = set_lr.cosine_annealing(optimizer, cons.start_lr, e, 100) writer.add_scalar('LearningRate', lr, e) train_loader = load_train_data( train_images_path=FLAGS.train_images_path, train_labels_path=FLAGS.train_labels_path, batch_size=FLAGS.batch_size, num_worker=FLAGS.num_worker, nfold=FLAGS.nfold, confidence_border=FLAGS.confidence_border, result_path=RESULT_PATH, test_images_path=FLAGS.test_images_path, over_sampling=FLAGS.over_sampling, transform_aug=Compose([ aug.HueSaturationValue(p=p_partical), aug.RandomBrightnessContrast(p=p_partical), aug.CLAHE(p=p_partical), aug.JpegCompression(p=p_partical), aug.GaussNoise(p=p), aug.MedianBlur(p=p), aug.ElasticTransform(p=p_partical), aug.HorizontalFlip(p=p), aug.Rotate(p=p), aug.CoarseDropout(p=p_partical), aug.RandomSizedCrop(p=p) ]), mixup=FLAGS.mixup, transform=transform) train_loss = train_loop(model, train_loader, criterion, optimizer) writer.add_scalar('train_loss', train_loss, e) valid_loss, valid_acc = valid_loop(model, valid_loader, criterion) writer.add_scalar('valid_loss', valid_loss, e) writer.add_scalar('valid_acc', valid_acc, e) print( 'Epoch: {}, Train Loss: {:.4f}, Valid Loss: {:.4f}, Valid Accuracy:{:.2f}' .format(e + 1, train_loss, valid_loss, valid_acc)) if e % 10 == 0: torch.save(model.state_dict(), PARAM_NAME + '_' + str(e) + '.pth') if valid_acc > best_acc: best_acc = valid_acc torch.save(model.state_dict(), PARAM_NAME + '_best.pth') else: if FLAGS.augmentation and not FLAGS.augmix: transform_aug = Compose([ aug.HueSaturationValue(), aug.RandomBrightnessContrast(), aug.CLAHE(), aug.JpegCompression(), aug.GaussNoise(), aug.MedianBlur(), aug.ElasticTransform(), aug.HorizontalFlip(), aug.Rotate(), aug.CoarseDropout(), aug.RandomSizedCrop() ]) else: transform_aug = None train_loader = load_train_data( train_images_path=FLAGS.train_images_path, train_labels_path=FLAGS.train_labels_path, batch_size=FLAGS.batch_size, num_worker=FLAGS.num_worker, valid=False, nfold=FLAGS.nfold, over_sampling=FLAGS.over_sampling, transform_aug=transform_aug, augmix=FLAGS.augmix, mixup=FLAGS.mixup, transform=transform) total_time = 0 for e in range(restart_epoch, FLAGS.final_epoch): start = time.time() lr = set_lr.cosine_annealing(optimizer, cons.start_lr, e, 100) writer.add_scalar('LearningRate', lr, e) train_loss = train_loop(model, train_loader, criterion, optimizer) writer.add_scalar('train_loss', train_loss, e) valid_loss, valid_acc = valid_loop(model, valid_loader, criterion) writer.add_scalar('valid_loss', valid_loss, e) writer.add_scalar('valid_acc', valid_acc, e) print( 'Epoch: {}, Train Loss: {:.4f}, Valid Loss: {:.4f}, Valid Accuracy:{:.2f}' .format(e + 1, train_loss, valid_loss, valid_acc)) if e % 10 == 0: torch.save(model.state_dict(), PARAM_NAME + '_' + str(e) + '.pth') if valid_acc > best_acc: best_acc = valid_acc torch.save(model.state_dict(), PARAM_NAME + '_best.pth') total_time = total_time + (time.time() - start) print('average time: {}[sec]'.format(total_time / (e + 1))) torch.save(model.state_dict(), PARAM_NAME + '_' + str(FLAGS.final_epoch - 1) + '_final.pth')
print('\n[Phase 1] : Data Preparation') transform_train = Compose([ Compose([ RandomRotate90(p=0.2), GaussNoise(p=0.2), HorizontalFlip(p=0.2), RandomCrop(p=0.2), HueSaturationValue(p=0.2), RandomBrightness(p=0.2), RandomContrast(p=0.2), RandomGamma(p=0.2), GaussianBlur(p=0.2) ], p=1.0), ToTensor(), Normalize(mean=mean[dataset], std=std[dataset], p=1.0) ], p=1.0) ]) transform_test = Compose([ ToTensor(), Normalize(mean=mean[dataset], std=std[dataset], p=1.0), ]) if(dataset == 'cifar10'): print("| Preparing CIFAR-10 dataset...") sys.stdout.write("| ") trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train) testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform_test) num_classes = 10 elif(dataset == 'cifar100'):