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)