def __init__(self): # Variables to hold the description of the experiment self.description = "" # System dependent variable self._workers = 10 self._multiprocessing = True # Variables for comet.ml self._project_name = "jpeg-deep" self._workspace = "classification_lcrfat" # Network variables self._weights = None self._network = late_concat_rfa_thinner() # Training variables self._epochs = 90 self._batch_size = 32 self._steps_per_epoch = 1281167 // self.batch_size self._validation_steps = 50000 // self._batch_size self.optimizer_parameters = { "lr": 0.0125, "momentum": 0.9} self._optimizer = SGD(**self.optimizer_parameters) self._loss = categorical_crossentropy self._metrics = ['accuracy', 'top_k_categorical_accuracy'] self.train_directory = join( environ["DATASET_PATH_TRAIN"], "train") self.validation_directory = join( environ["DATASET_PATH_VAL"], "validation") self.test_directory = join( environ["DATASET_PATH_TEST"], "validation") self.index_file = "data/imagenet_class_index.json" # Defining the transformations that will be applied to the inputs. self.train_transformations = [ SmallestMaxSize(256), RandomCrop(224, 224), HorizontalFlip() ] self.validation_transformations = [ SmallestMaxSize(256), CenterCrop(224, 224)] self.test_transformations = [SmallestMaxSize(256)] # Keras stuff self.reduce_lr_on_plateau = ReduceLROnPlateau(patience=5, verbose=1) self.terminate_on_nan = TerminateOnNaN() self.early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=11) self._callbacks = [self.reduce_lr_on_plateau, self.terminate_on_nan, self.early_stopping] self._train_generator = None self._validation_generator = None self._test_generator = None self._displayer = ImageNetDisplayer(self.index_file)
def train(model, cfg, model_cfg, start_epoch=0): cfg.batch_size = 32 if cfg.batch_size < 1 else cfg.batch_size cfg.val_batch_size = cfg.batch_size cfg.input_normalization = model_cfg.input_normalization crop_size = model_cfg.crop_size loss_cfg = edict() loss_cfg.instance_loss = NormalizedFocalLossSigmoid(alpha=0.5, gamma=2) loss_cfg.instance_loss_weight = 1.0 loss_cfg.instance_aux_loss = SigmoidBinaryCrossEntropyLoss() loss_cfg.instance_aux_loss_weight = 0.4 num_epochs = 120 num_masks = 1 train_augmentator = Compose([ Flip(), RandomRotate90(), ShiftScaleRotate(shift_limit=0.03, scale_limit=0, rotate_limit=(-3, 3), border_mode=0, p=0.75), PadIfNeeded( min_height=crop_size[0], min_width=crop_size[1], border_mode=0), RandomCrop(*crop_size), RandomBrightnessContrast(brightness_limit=(-0.25, 0.25), contrast_limit=(-0.15, 0.4), p=0.75), RGBShift(r_shift_limit=10, g_shift_limit=10, b_shift_limit=10, p=0.75) ], p=1.0) val_augmentator = Compose([ PadIfNeeded( min_height=crop_size[0], min_width=crop_size[1], border_mode=0), RandomCrop(*crop_size) ], p=1.0) def scale_func(image_shape): return random.uniform(0.75, 1.25) points_sampler = MultiPointSampler(model_cfg.num_max_points, prob_gamma=0.7, merge_objects_prob=0.15, max_num_merged_objects=2) trainset = SBDDataset( cfg.SBD_PATH, split='train', num_masks=num_masks, augmentator=train_augmentator, points_from_one_object=False, input_transform=model_cfg.input_transform, min_object_area=80, keep_background_prob=0.0, image_rescale=scale_func, points_sampler=points_sampler, samples_scores_path='./models/sbd/sbd_samples_weights.pkl', samples_scores_gamma=1.25) valset = SBDDataset(cfg.SBD_PATH, split='val', augmentator=val_augmentator, num_masks=num_masks, points_from_one_object=False, input_transform=model_cfg.input_transform, min_object_area=80, image_rescale=scale_func, points_sampler=points_sampler) optimizer_params = {'lr': 5e-4, 'betas': (0.9, 0.999), 'eps': 1e-8} lr_scheduler = partial(torch.optim.lr_scheduler.MultiStepLR, milestones=[100], gamma=0.1) trainer = ISTrainer(model, cfg, model_cfg, loss_cfg, trainset, valset, optimizer='adam', optimizer_params=optimizer_params, lr_scheduler=lr_scheduler, checkpoint_interval=5, image_dump_interval=100, metrics=[AdaptiveIoU()], max_interactive_points=model_cfg.num_max_points) logger.info(f'Starting Epoch: {start_epoch}') logger.info(f'Total Epochs: {num_epochs}') for epoch in range(start_epoch, num_epochs): trainer.training(epoch) trainer.validation(epoch)
def main(): with open('config.yaml', 'r') as f: config = yaml.load(f) set_global_seed(SEED) prepare_cudnn(deterministic=True, benchmark=True) model = EfficientNet.from_name('efficientnet-b7', override_params={'num_classes': 1}) state = torch.load(PRETRAINED_WEIGHTS_PATH, map_location=lambda storage, loc: storage) state.pop('_fc.weight') state.pop('_fc.bias') res = model.load_state_dict(state, strict=False) assert set(res.missing_keys) == set(['_fc.weight', '_fc.bias' ]), 'issue loading pretrained weights' for module in model.modules(): if isinstance(module, MBConvBlock): if module._block_args.expand_ratio != 1: expand_conv = module._expand_conv seq_expand_conv = SeqExpandConv(expand_conv.in_channels, expand_conv.out_channels, len(TRAIN_INDICES)) seq_expand_conv.conv.weight.data[:, :, 0, :, :].copy_( expand_conv.weight.data / 3) seq_expand_conv.conv.weight.data[:, :, 1, :, :].copy_( expand_conv.weight.data / 3) seq_expand_conv.conv.weight.data[:, :, 2, :, :].copy_( expand_conv.weight.data / 3) module._expand_conv = seq_expand_conv model = model.cuda() normalize = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) _, rand_augment, _ = transforms_imagenet_train( (CROP_HEIGHT, CROP_WIDTH), auto_augment='original-mstd0.5', separate=True) train_dataset = TrackPairDataset( os.path.join(config['ARTIFACTS_PATH'], TRACKS_ROOT), os.path.join(config['ARTIFACTS_PATH'], TRACK_PAIRS_FILE_NAME), TRAIN_INDICES, track_length=TRACK_LENGTH, track_transform=TrackTransform(FPS_RANGE, SCALE_RANGE, CRF_RANGE, TUNE_VALUES), image_transform=Compose([ SmallestMaxSize(MIN_SIZE), HorizontalFlip(), RandomCrop(CROP_HEIGHT, CROP_WIDTH), VisionTransform(rand_augment, p=0.5), normalize, ToTensor() ]), sequence_mode=True) print('Train dataset size: {}.'.format(len(train_dataset))) warmup_optimizer = torch.optim.SGD(model._fc.parameters(), INITIAL_LR, momentum=MOMENTUM, weight_decay=WEIGHT_DECAY, nesterov=True) full_optimizer = torch.optim.SGD(model.parameters(), INITIAL_LR, momentum=MOMENTUM, weight_decay=WEIGHT_DECAY, nesterov=True) full_lr_scheduler = torch.optim.lr_scheduler.LambdaLR( full_optimizer, lambda iteration: (MAX_ITERS - iteration) / MAX_ITERS) snapshots_root = os.path.join(config['ARTIFACTS_PATH'], SNAPSHOTS_ROOT, OUTPUT_FOLDER_NAME) os.makedirs(snapshots_root) log_root = os.path.join(config['ARTIFACTS_PATH'], LOGS_ROOT, OUTPUT_FOLDER_NAME) os.makedirs(log_root) writer = SummaryWriter(log_root) iteration = 0 if iteration < NUM_WARMUP_ITERATIONS: print('Start {} warmup iterations'.format(NUM_WARMUP_ITERATIONS)) model.eval() model._fc.train() for param in model.parameters(): param.requires_grad = False for param in model._fc.parameters(): param.requires_grad = True optimizer = warmup_optimizer else: print('Start without warmup iterations') model.train() optimizer = full_optimizer max_lr = max(param_group["lr"] for param_group in full_optimizer.param_groups) writer.add_scalar('train/max_lr', max_lr, iteration) epoch = 0 fake_prob_dist = distributions.beta.Beta(0.5, 0.5) while True: epoch += 1 print('Epoch {} is in progress'.format(epoch)) loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS, drop_last=True) for samples in tqdm.tqdm(loader): iteration += 1 fake_input_tensor = torch.stack(samples['fake']).transpose( 0, 1).cuda() real_input_tensor = torch.stack(samples['real']).transpose( 0, 1).cuda() target_fake_prob = fake_prob_dist.sample( (len(fake_input_tensor), )).float().cuda() fake_weight = target_fake_prob.view(-1, 1, 1, 1, 1) input_tensor = ( 1.0 - fake_weight ) * real_input_tensor + fake_weight * fake_input_tensor pred = model(input_tensor.flatten(0, 1)).flatten() loss = F.binary_cross_entropy_with_logits( pred, target_fake_prob.repeat_interleave(len(TRAIN_INDICES))) optimizer.zero_grad() loss.backward() optimizer.step() if iteration > NUM_WARMUP_ITERATIONS: full_lr_scheduler.step() max_lr = max(param_group["lr"] for param_group in full_optimizer.param_groups) writer.add_scalar('train/max_lr', max_lr, iteration) writer.add_scalar('train/loss', loss.item(), iteration) if iteration == NUM_WARMUP_ITERATIONS: print('Stop warmup iterations') model.train() for param in model.parameters(): param.requires_grad = True optimizer = full_optimizer if iteration % SNAPSHOT_FREQUENCY == 0: snapshot_name = SNAPSHOT_NAME_TEMPLATE.format(iteration) snapshot_path = os.path.join(snapshots_root, snapshot_name) print('Saving snapshot to {}'.format(snapshot_path)) torch.save(model.state_dict(), snapshot_path) if iteration >= MAX_ITERS: print('Stop training due to maximum iteration exceeded') return
from dataset import PoseNetDataset from models import GoogleNet from metrics import PosQtnMetricsProcessor, PoseNetLoss base_dir = '/mnt/tb_storage/uprojects/posenet/dataset' img_dir = os.path.join(base_dir, 'images') csv_data = os.path.join(base_dir, 'info.csv') BATCH_SIZE = 4 LEARN_LOSS = False POS_WT = 0.5 QTN_WT = 0.5 augmentations = Compose([ RandomCrop(299, 299), RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2), RGBShift(), RandomGamma(), OneOf([IAAAdditiveGaussianNoise(p=1.), GaussNoise(p=1.)], p=0.27), OneOf([ MotionBlur(p=1.), MedianBlur(blur_limit=3, p=1.), Blur(blur_limit=3, p=1.) ], p=0.27), OneOf([ OpticalDistortion(p=1.), GridDistortion(p=1.), IAAPiecewiseAffine(p=1.)
def augmentate_val(img: np.ndarray): res = RandomCrop(299, 299)(image=img) return torch.from_numpy( np.moveaxis(res['image'].astype(np.float32) / 255., -1, 0))
def build_test(self): return Compose([ RandomCrop(self.height, self.width), # not fully conv, so need to limit img size Normalize(mean=self.MEAN, std=self.STD), ToTensor(), ])
from albumentations import Compose, Resize, RandomCrop, Flip, HorizontalFlip, VerticalFlip, Transpose, RandomRotate90, \ ShiftScaleRotate, OneOf, Blur from albumentations.pytorch import ToTensor train_aug = Compose([ RandomCrop(height=96, width=96, p=0.2), OneOf([ VerticalFlip(p=0.2), HorizontalFlip(p=0.3), Transpose(p=0.2), RandomRotate90(p=0.2), ], p=0.3), ShiftScaleRotate(p=0.2), Blur(p=0.2), Resize(128, 128, always_apply=True), ToTensor() ]) valid_aug = Compose([Resize(128, 128, always_apply=True), ToTensor()])
class AlbuCompose: """ Converts to PyTorch compatible Transform """ def __init__(self,transforms): self.transforms = transforms def __call__(self, img): img = np.array(img) img = self.transforms(image=img)["image"] return img # Albumentations Transformations transform_train_albu = Compose([ PadIfNeeded(value=4), RandomCrop(height=32, width=32), #, always_apply=True HorizontalFlip(), # p=0.2 VerticalFlip(), # p=0.0 IAAFliplr(p=0.2), Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010), always_apply=True), Cutout(num_holes=1, max_h_size=8, max_w_size=8, fill_value=[0.4914, 0.4822, 0.4465], p=0.3), ToTensorV2(always_apply=True) ]) transform_test_albu = Compose([ #ToTensor(), Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)), ToTensorV2(always_apply=True) ])
def __crop(self): return Compose([RandomCrop(self.patch_size, self.patch_size)], p=1.0)
def _FastRandAugment2d(img_size, set='general'): _sets = { 'general': [ OneOf([ Blur(p=1), GaussNoise(p=1), MotionBlur(p=1), MedianBlur(p=1), ]), HorizontalFlip(p=1), Compose([ PadIfNeeded(min_height=img_size * 2, min_width=img_size * 2, border_mode=cv2.BORDER_WRAP, p=1), RandomCrop(img_size, img_size, p=1), ], p=1), RandomBrightnessContrast(p=1), InvertImg(p=1), ToGray(p=1), RGBShift(p=1), OneOf([ GridDropout(holes_number_x=4, holes_number_y=4, random_offset=True, ratio=r, fill_value=i, p=1) for i in _color_fill for r in np.linspace(0.3, 0.7, 4) ], p=1), NoOp(p=1), Equalize(p=1), Rotate(45, border_mode=cv2.BORDER_WRAP, p=1), ShiftScaleRotate(shift_limit=0.25, scale_limit=0.2, rotate_limit=45, border_mode=cv2.BORDER_WRAP, p=1), Solarize(p=1), Posterize(p=1), IAAPerspective(p=1), HueSaturationValue(hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50, p=1), RandomGamma(p=1), ChannelShuffle(p=1), OneOf([ CoarseDropout(max_holes=1, max_height=img_size // 2, max_width=img_size // 2, fill_value=i, p=1) for i in _color_fill ], p=1), OneOf([ CLAHE(clip_limit=2), IAASharpen(), IAAEmboss(), ], p=1), ], } return _sets[set]