def run(cfg: dict, use_wandb: bool): # Set logger exp_name = get_exp_name(cfg.model.params) if use_wandb: wandb_logger = WandbLogger( name=exp_name, project="hephaestusproject-pytorch-AE", log_model=True, ) else: wandb_logger = None # Create dataloader train_dataloader, val_dataloader = get_dataloader(cfg) # Create model Model = getattr(__import__("src"), cfg.model.name) runner = Model(cfg.model.params) # Set trainer (pytorch lightening) os.makedirs(cfg.model.ckpt.path, exist_ok=True) trainer = pl.Trainer( logger=wandb_logger, gpus=-1 if torch.cuda.is_available() else 0, max_epochs=cfg.model.params.max_epochs, deterministic=True, checkpoint_callback=ModelCheckpoint(cfg.model.ckpt.path), ) # Train trainer.fit( runner, train_dataloader=train_dataloader, val_dataloaders=val_dataloader )
def setup_train_configuration(self, config: Dict[str, Any]) -> None: """Setup train configuration.""" self.config = config self.total_epochs = self.config["EPOCHS"] # get datasets trainset, testset = utils.get_dataset( config["DATASET"], config["AUG_TRAIN"], config["AUG_TEST"], config["AUG_TRAIN_PARAMS"], config["AUG_TEST_PARAMS"], ) self.input_size = trainset[0][0].size() logger.info("Datasets prepared") # transform the training dataset for CutMix augmentation if "CUTMIX" in config: trainset = CutMix( trainset, config["MODEL_PARAMS"]["num_classes"], **config["CUTMIX"], ) # get dataloaders self.trainloader, self.testloader = utils.get_dataloader( trainset, testset, config["BATCH_SIZE"], config["N_WORKERS"], ) logger.info("Dataloader prepared") # define criterion and optimizer self.criterion = get_criterion( criterion_name=config["CRITERION"], criterion_params=config["CRITERION_PARAMS"], device=self.device, ) self.regularizer = None if "REGULARIZER" in config: self.regularizer = get_regularizer(config["REGULARIZER"], config["REGULARIZER_PARAMS"]) self.optimizer = optim.SGD( self.model.parameters(), lr=config["LR"], momentum=config["MOMENTUM"], weight_decay=config["WEIGHT_DECAY"], nesterov=config["NESTEROV"], ) # learning rate scheduler self.lr_scheduler = get_lr_scheduler( config["LR_SCHEDULER"], config["LR_SCHEDULER_PARAMS"], )
def run(cfg: dict): # Load checkpoint checkpoint_path = os.path.join(cfg.model.ckpt.path, cfg.model.ckpt.filename) Model = getattr(__import__("src"), cfg.model.name) model = Model(cfg.model.params) model = model.load_from_checkpoint(checkpoint_path=checkpoint_path, ) # Select test image _, val_dataloader = get_dataloader(cfg) test_image = None for data in val_dataloader: images, _ = data test_image = images[0, :, :, :].unsqueeze(0) break # Inference x = torch.Tensor(test_image) y = model(x) output = np.transpose(y[0].cpu().detach().numpy(), [1, 2, 0]) test_image = np.transpose(test_image[0, :, :, :].cpu().numpy(), [1, 2, 0]) show_result(test_image, output)
def main(cfg): SEED = cfg.values.seed BATCH_SIZE = cfg.values.train_args.batch_size IMAGE_SIZE = cfg.values.image_size USE_KFOLD = cfg.values.use_kfold NUM_FOLD = cfg.values.train_args.num_fold if USE_KFOLD else 0 seed_everything(SEED) print(f'Cuda is Available ? : {torch.cuda.is_available()}\n') data_df = pd.read_csv('E:/seti-breakthrough-listen/train_labels.csv') data_df['file_path'] = data_df['id'].apply(get_train_file_path) train_transform = albumentations.Compose([ albumentations.Resize(IMAGE_SIZE, IMAGE_SIZE), albumentations.HorizontalFlip(), albumentations.VerticalFlip(), # albumentations.Normalize(mean=(0.5, 0.5, 0.5), std=(0.25, 0.25, 0.25)), albumentations.pytorch.transforms.ToTensorV2() ]) val_transform = albumentations.Compose([ albumentations.Resize(IMAGE_SIZE, IMAGE_SIZE), # albumentations.Normalize(mean=(0.5, 0.5, 0.5), std=(0.25, 0.25, 0.25)), albumentations.pytorch.transforms.ToTensorV2() ]) if USE_KFOLD: kfold = StratifiedKFold(n_splits=NUM_FOLD, shuffle=True, random_state=SEED) for k, (train_index, val_index) in enumerate(kfold.split(data_df, data_df['target'])): print('\n') cpprint('=' * 15 + f'{k + 1}-Fold Cross Validation' + '=' * 15) train_df = data_df.iloc[train_index].reset_index(drop=True) val_df = data_df.iloc[val_index].reset_index(drop=True) train_loader = get_dataloader(df=train_df, transform=train_transform, batch_size=BATCH_SIZE, shuffle=True) val_loader = get_dataloader(df=val_df, transform=val_transform, batch_size=BATCH_SIZE, shuffle=False) val_labels = val_df['target'].values.tolist() train(cfg, train_loader, val_loader, val_labels, k + 1) else: print('\n') cpprint('=' * 15 + f'Start Training' + '=' * 15) train_df, val_df = train_test_split(data_df, test_size=0.2, shuffle=True, stratify=data_df['target'], random_state=SEED) train_loader = get_dataloader(df=train_df, transform=train_transform, batch_size=BATCH_SIZE, shuffle=True) val_loader = get_dataloader(df=val_df, transform=val_transform, batch_size=BATCH_SIZE, shuffle=False) val_labels = val_df['target'].values.tolist() train(cfg, train_loader, val_loader, val_labels, 0)
batch_size = args.batch_size do_predict = args.do_predict thresh_range = args.thresh_range config = AutoConfig.from_pretrained(model_name, output_hidden_states=True) tokenizer = AutoTokenizer.from_pretrained(model_name, config=config) model = AutoModelForSequenceClassification.from_pretrained(model_name, config=config) model = model.cuda() for k, v in model.named_parameters(): x = k.split('.') if x[0] == 'classifier': v.requires_grad = False if adaptive: train_adap(model, tokenizer, train_path, threshold, extra_aug, max_epoch, thresh_range) else: train_dataloader = get_dataloader(model, tokenizer, train_path, threshold, extra_aug, batch_size) min_steps = max_epoch * len(train_dataloader) train_normal(model, train_dataloader, min_steps) model.save_pretrained(model_save_dir) tokenizer.save_pretrained(model_save_dir) if do_predict: predict(model, tokenizer, test_path, res_pred) # # "drive/My Drive/Team6/sfda/negation/practice_text/dev_labels.txt" score_negation(ref_pred, res_pred)