def run_iris():
"""Run IRIS data, a small classification task of different flower species."""
samples = load_data(IRIS_DATA)
train, validation, test = divide_dataset(samples)
# Train the network with the given hyperparameters and evaluate
nn = FeedForwardNeuralNetwork(samples[0].num_features, 3, [6])
epochs = nn.train(train, validation, learning_rate=0.01, threshold=1e-5)
eval_tr = nn.eval_classification(train)
eval_v = nn.eval_classification(validation)
eval_t = nn.eval_classification(test)
print('Epochs: {}\tTrain: {:.3f}\tValidation: {:.3f}\tTest: {:.3f}'
.format(epochs, eval_tr, eval_v, eval_t))
def main():
"""Runs the Perceptron on a simple data set."""
# Load the energy data and split into datasets for training, validation, and testing.
samples = load_data('energy-data.txt')
train, validation, test = divide_dataset(samples)
# Create an Unthresholded Perceptron and evaluate it with varying convergence thresholds
up = UnthresholdedPerceptron(samples[0].num_features)
for thresh in [1e-4]: # [1e-1, 1e-2, 1e-3, 1e-4, 1e-5]:
up.train(train, validation, threshold=thresh)
eval_tr = up.evaluate(train)
eval_v = up.evaluate(validation)
eval_t = up.evaluate(test)
print('Train: {:.3f}\tValidation: {:.3f}\tTest: {:.3f}'.format(
eval_tr, eval_v, eval_t))
def main(rank, option, resume, save_folder):
# Basic Options
resume_path = os.path.join(save_folder, 'last_dict.pt')
num_gpu = len(option.result['train']['gpu'].split(','))
total_epoch = option.result['train']['total_epoch']
multi_gpu = len(option.result['train']['gpu'].split(',')) > 1
if multi_gpu:
ddp = option.result['train']['ddp']
else:
ddp = False
scheduler = option.result['train']['scheduler']
batch_size, pin_memory = option.result['train'][
'batch_size'], option.result['train']['pin_memory']
# Logger
if (rank == 0) or (rank == 'cuda'):
neptune.init(
'sunghoshin/imp',
api_token=
'eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI5MTQ3MjY2Yy03YmM4LTRkOGYtOWYxYy0zOTk3MWI0ZDY3M2MifQ=='
)
exp_name, exp_num = save_folder.split('/')[-2], save_folder.split(
'/')[-1]
neptune.create_experiment(params={
'exp_name': exp_name,
'exp_num': exp_num
},
tags=['inference:False'])
# Load Model
model = load_model(option)
patch_criterion, detection_criterion = load_loss(option, rank)
save_module = train_module(total_epoch, model, patch_criterion,
detection_criterion, multi_gpu)
if resume:
save_module.import_module(resume_path)
model.load_state_dict(save_module.save_dict['model'][0])
# Multi-Processing GPUs
if ddp:
setup(rank, num_gpu)
torch.manual_seed(0)
torch.cuda.set_device(rank)
model.to(rank)
model = DDP(model, device_ids=[rank])
model = apply_gradient_allreduce(model)
patch_criterion.to(rank)
detection_criterion.to(rank)
else:
if multi_gpu:
model = nn.DataParallel(model).to(rank)
else:
model = model.to(rank)
# Optimizer and Scheduler
if resume:
# Load Optimizer
optimizer = load_optimizer(option, model.parameters())
optimizer.load_state_dict(save_module.save_dict['optimizer'][0])
# Load Scheduler
if scheduler is not None:
scheduler = load_scheduler(option, optimizer)
scheduler.load_state_dict(save_module.save_dict['scheduler'][0])
else:
optimizer = load_optimizer(option, model.parameters())
if scheduler is not None:
scheduler = load_scheduler(option, optimizer)
# Early Stopping
early_stop = option.result['train']['early']
if early_stop:
early = EarlyStopping(patience=option.result['train']['patience'])
else:
early = None
# Dataset and DataLoader
tr_robust_dataset, tr_coco_dataset, tr_ex_dataset = load_data(option,
type='train')
val_robust_dataset, val_coco_dataset, val_ex_dataset = load_data(
option, type='val')
if ddp:
# Robust Dataset Loader
if tr_robust_dataset is not None:
tr_robust_sampler = torch.utils.data.distributed.DistributedSampler(
dataset=tr_robust_dataset, num_replicas=num_gpu, rank=rank)
val_robust_sampler = torch.utils.data.distributed.DistributedSampler(
dataset=val_robust_dataset, num_replicas=num_gpu, rank=rank)
tr_robust_loader = torch.utils.data.DataLoader(
dataset=tr_robust_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=4 * num_gpu,
pin_memory=pin_memory,
sampler=tr_robust_sampler)
val_robust_loader = torch.utils.data.DataLoader(
dataset=val_robust_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=4 * num_gpu,
pin_memory=pin_memory,
sampler=val_robust_sampler)
else:
tr_robust_loader = None
val_robust_loader = None
# Detection-COCO-Dark-Dataset Loader
if tr_coco_dataset is not None:
tr_coco_sampler = torch.utils.data.distributed.DistributedSampler(
dataset=tr_coco_dataset, num_replicas=num_gpu, rank=rank)
val_coco_sampler = torch.utils.data.distributed.DistributedSampler(
dataset=val_coco_dataset, num_replicas=num_gpu, rank=rank)
tr_coco_loader = torch.utils.data.DataLoader(
dataset=tr_coco_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=4 * num_gpu,
pin_memory=pin_memory,
sampler=tr_coco_sampler,
collate_fn=detection_collate)
val_coco_loader = torch.utils.data.DataLoader(
dataset=val_coco_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=4 * num_gpu,
pin_memory=pin_memory,
sampler=val_coco_sampler,
collate_fn=detection_collate)
else:
tr_coco_loader = None
val_coco_loader = None
# Detection-EX-Dark-Dataset Loader
if tr_ex_dataset is not None:
tr_ex_sampler = torch.utils.data.distributed.DistributedSampler(
dataset=tr_ex_dataset, num_replicas=num_gpu, rank=rank)
val_ex_sampler = torch.utils.data.distributed.DistributedSampler(
dataset=val_ex_dataset, num_replicas=num_gpu, rank=rank)
tr_ex_loader = torch.utils.data.DataLoader(
dataset=tr_ex_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=4 * num_gpu,
pin_memory=pin_memory,
sampler=tr_ex_sampler,
collate_fn=detection_collate)
val_ex_loader = torch.utils.data.DataLoader(
dataset=val_ex_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=4 * num_gpu,
pin_memory=pin_memory,
sampler=val_ex_sampler,
collate_fn=detection_collate)
else:
tr_ex_loader = None
val_ex_loader = None
else:
# Robust Dataset Loader
if tr_robust_dataset is not None:
tr_robust_loader = DataLoader(tr_robust_dataset,
batch_size=batch_size,
shuffle=True,
pin_memory=pin_memory,
num_workers=4 * num_gpu)
val_robust_loader = DataLoader(val_robust_dataset,
batch_size=batch_size,
shuffle=False,
pin_memory=pin_memory,
num_workers=4 * num_gpu)
else:
tr_robust_loader = None
val_robust_loader = None
# Detection-COCO-Dark-Dataset Loader
if tr_coco_dataset is not None:
tr_coco_loader = DataLoader(tr_coco_dataset,
batch_size=batch_size,
shuffle=True,
pin_memory=pin_memory,
num_workers=4 * num_gpu,
collate_fn=detection_collate)
val_coco_loader = DataLoader(val_coco_dataset,
batch_size=batch_size,
shuffle=False,
pin_memory=pin_memory,
num_workers=4 * num_gpu,
collate_fn=detection_collate)
else:
tr_coco_loader = None
val_coco_loader = None
# Detection-EX-Dark-Dataset Loader
if tr_ex_dataset is not None:
tr_ex_loader = DataLoader(tr_ex_dataset,
batch_size=batch_size,
shuffle=True,
pin_memory=pin_memory,
num_workers=4 * num_gpu,
collate_fn=detection_collate)
val_ex_loader = DataLoader(val_ex_dataset,
batch_size=batch_size,
shuffle=False,
pin_memory=pin_memory,
num_workers=4 * num_gpu,
collate_fn=detection_collate)
else:
tr_ex_loader = None
val_ex_loader = None
# Mixed Precision
mixed_precision = option.result['train']['mixed_precision']
if mixed_precision:
scaler = torch.cuda.amp.GradScaler()
else:
scaler = None
# Training
from module.trainer import robust_trainer
early, save_module, option = robust_trainer.run(option, model, tr_robust_loader, tr_coco_loader, tr_ex_loader, \
val_robust_loader, val_coco_loader, val_ex_loader, optimizer, \
patch_criterion, detection_criterion, scaler, scheduler, early, \
save_folder, save_module, multi_gpu, rank, neptune)
if ddp:
cleanup()
def main(rank, option, resume, save_folder, log, master_port):
# Basic Options
train_type = option.result['train']['train_type']
resume_path = os.path.join(save_folder, 'last_dict.pt')
total_epoch = option.result['train']['total_epoch']
# GPU Configuration
num_gpu = len(option.result['train']['gpu'].split(','))
multi_gpu = len(option.result['train']['gpu'].split(',')) > 1
if multi_gpu:
ddp = option.result['train']['ddp']
else:
ddp = False
scheduler_list = option.result['train']['scheduler']
batch_size, pin_memory = option.result['train'][
'batch_size'], option.result['train']['pin_memory']
# Logger
if (rank == 0) or (rank == 'cuda'):
token = 'eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI5MTQ3MjY2Yy03YmM4LTRkOGYtOWYxYy0zOTk3MWI0ZDY3M2MifQ=='
if log:
mode = 'async'
else:
mode = 'debug'
monitoring_hardware = True
if resume and option.result['meta']['neptune_id'] is not None:
run = neptune.init('sunghoshin/%s' %
option.result['meta']['project_folder'],
api_token=token,
capture_stdout=monitoring_hardware,
capture_stderr=monitoring_hardware,
capture_hardware_metrics=monitoring_hardware,
run=option.result['meta']['neptune_id'],
mode=mode)
else:
run = neptune.init('sunghoshin/%s' %
option.result['meta']['project_folder'],
api_token=token,
capture_stdout=monitoring_hardware,
capture_stderr=monitoring_hardware,
capture_hardware_metrics=monitoring_hardware,
mode=mode)
neptune_id = str(run.__dict__['_short_id'])
option.result['meta']['neptune_id'] = neptune_id
exp_name, exp_num = save_folder.split('/')[-2], save_folder.split(
'/')[-1]
run['exp_name'] = exp_name
run['exp_num'] = exp_num
cfg = option.result
for key in cfg.keys():
for key_ in cfg[key].keys():
cfg_name = 'config/%s/%s' % (key, key_)
run[cfg_name] = cfg[key][key_]
else:
run = None
# Load Model
model_list, addon_list = load_model(option)
criterion_list = load_loss(option)
save_module = train_module(total_epoch, criterion_list, multi_gpu)
if resume:
save_module.import_module(resume_path)
# Load Model
for ix, model in enumerate(model_list):
model.load_state_dict(save_module.save_dict['model'][ix])
# Load Add-on
for ix, addon in enumerate(addon_list):
if ix == 1:
for id, (_, _, _, attn) in enumerate(addon):
attn.load_state_dict(
save_module.save_dict['addon'][ix][id])
# Load Epoch
if save_module.save_dict['save_epoch'] == (
int(option.result['train']['total_epoch']) - 1):
return None
# Multi-Processing GPUs
if ddp:
setup(rank, num_gpu, master_port)
torch.manual_seed(0)
torch.cuda.set_device(rank)
for ix in range(len(model_list)):
model_list[ix].to(rank)
model_list[ix] = DDP(model_list[ix], device_ids=[rank])
model_list[ix] = apply_gradient_allreduce(model_list[ix])
for ix in range(len(addon_list)):
addon_list[ix] = addon_list[ix].to(rank)
for ix in range(len(criterion_list)):
criterion_list[ix].to(rank)
else:
for ix in range(len(model_list)):
if multi_gpu:
model_list[ix] = nn.DataParallel(model_list[ix]).to(rank)
else:
model_list[ix] = model_list[ix].to(rank)
for ix in range(len(addon_list)):
if multi_gpu:
addon_list[ix] = nn.DataParallel(addon_list[ix]).to(rank)
else:
addon_list[ix] = addon_list[ix].to(rank)
# Optimizer and Scheduler
optimizer_list = load_optimizer(option, model_list, addon_list)
if resume:
# Load Optimizer
for ix, optimizer in enumerate(optimizer_list):
optimizer.load_state_dict(save_module.save_dict['optimizer'][ix])
if scheduler_list is not None:
scheduler_list = load_scheduler(option, optimizer_list)
if resume:
for ix, scheduler in enumerate(scheduler_list):
scheduler.load_state_dict(
save_module.save_dict['scheduler'][ix])
# Early Stopping
early = EarlyStopping(patience=option.result['train']['patience'])
# Dataset and DataLoader
tr_dataset = load_data(option, data_type='train')
val_dataset = load_data(option, data_type='val')
# Data Loader
if ddp:
tr_sampler = torch.utils.data.distributed.DistributedSampler(
dataset=tr_dataset, num_replicas=num_gpu, rank=rank)
val_sampler = torch.utils.data.distributed.DistributedSampler(
dataset=val_dataset, num_replicas=num_gpu, rank=rank)
tr_loader = torch.utils.data.DataLoader(
dataset=tr_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=option.result['train']['num_workers'],
pin_memory=pin_memory,
sampler=tr_sampler)
val_loader = torch.utils.data.DataLoader(
dataset=val_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=option.result['train']['num_workers'],
pin_memory=pin_memory,
sampler=val_sampler)
else:
tr_loader = DataLoader(
tr_dataset,
batch_size=batch_size,
shuffle=True,
pin_memory=pin_memory,
num_workers=option.result['train']['num_workers'])
val_loader = DataLoader(
val_dataset,
batch_size=batch_size,
shuffle=False,
pin_memory=pin_memory,
num_workers=option.result['train']['num_workers'])
# Mixed Precision
mixed_precision = option.result['train']['mixed_precision']
if mixed_precision:
scaler = torch.cuda.amp.GradScaler()
else:
scaler = None
# Run
for epoch in range(save_module.init_epoch, save_module.total_epoch):
# Scheduler with Warm-up
save_module.save_dict['scheduler'] = []
if scheduler_list is not None:
for scheduler in scheduler_list:
if option.result['train']['scheduler'] == 'anealing':
scheduler.step(epoch)
else:
scheduler.step()
save_module.save_dict['scheduler'].append(
scheduler.state_dict())
# Train
save_module = naive_trainer.train(option, rank, epoch, model_list, addon_list, criterion_list, optimizer_list, multi_gpu, \
tr_loader, scaler, save_module, run, save_folder)
# Evaluation
result = naive_trainer.validation(option, rank, epoch, model_list,
addon_list, criterion_list,
multi_gpu, val_loader, scaler, run)
# Log Learning Rate
if run is not None:
for param_group in optimizer_list[0].param_groups:
run['debug/current_lr'].log(param_group['lr'])
# Save the last-epoch module
if (rank == 0) or (rank == 'cuda'):
save_module_path = os.path.join(save_folder, 'last_dict.pt')
save_module.export_module(save_module_path)
save_config_path = os.path.join(save_folder, 'last_config.json')
option.export_config(save_config_path)
# Early Stopping
param_list = []
if multi_gpu:
for model in model_list:
param_list.append(deepcopy(model.module.state_dict()))
else:
for model in model_list:
param_list.append(deepcopy(model.state_dict()))
if option.result['train']['early_loss']:
early(result['val_loss'], param_list, result)
else:
early(-result['acc1'], param_list, result)
if early.early_stop == True:
break
if (rank == 0) or (rank == 'cuda'):
# Save the best_model
torch.save(early.model, os.path.join(save_folder, 'best_model.pt'))
if ddp:
cleanup()
return None
def main(args, logger):
writer = SummaryWriter(
log_dir=os.path.join('logs', args.dataset, args.model_name, args.loss))
train_loader, test_loader = load_data(args)
if args.dataset == 'CIFAR10':
num_classes = 10
elif args.dataset == 'CIFAR100':
num_classes = 100
elif args.dataset == 'TINY_IMAGENET':
num_classes = 200
elif args.dataset == 'IMAGENET':
num_classes = 1000
print('Model name :: {}, Dataset :: {}, Num classes :: {}'.format(
args.model_name, args.dataset, num_classes))
if args.model_name == 'mixnet_s':
model = mixnet_s(num_classes=num_classes, dataset=args.dataset)
# model = mixnet_s(num_classes=num_classes)
elif args.model_name == 'mixnet_m':
model = mixnet_m(num_classes=num_classes, dataset=args.dataset)
elif args.model_name == 'mixnet_l':
model = mixnet_l(num_classes=num_classes, dataset=args.dataset)
elif args.model_name == 'ghostnet':
model = ghostnet(num_classes=num_classes)
elif args.model_name == 'ghostmishnet':
model = ghostmishnet(num_classes=num_classes)
elif args.model_name == 'ghosthmishnet':
model = ghosthmishnet(num_classes=num_classes)
elif args.model_name == 'ghostsharkfinnet':
model = ghostsharkfinnet(num_classes=num_classes)
elif args.model_name == 'mobilenetv2':
model = models.mobilenet_v2(num_classes=num_classes)
elif args.model_name == 'mobilenetv3_s':
model = mobilenetv3_small(num_classes=num_classes)
elif args.model_name == 'mobilenetv3_l':
model = mobilenetv3_large(num_classes=num_classes)
else:
raise NotImplementedError
if args.pretrained_model:
filename = 'best_model_' + str(args.dataset) + '_' + str(
args.model_name) + '_ckpt.tar'
print('filename :: ', filename)
file_path = os.path.join('./checkpoint', filename)
checkpoint = torch.load(file_path)
model.load_state_dict(checkpoint['state_dict'])
start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
best_acc5 = checkpoint['best_acc5']
model_parameters = checkpoint['parameters']
print(
'Load model, Parameters: {0}, Start_epoch: {1}, Acc1: {2}, Acc5: {3}'
.format(model_parameters, start_epoch, best_acc1, best_acc5))
logger.info(
'Load model, Parameters: {0}, Start_epoch: {1}, Acc1: {2}, Acc5: {3}'
.format(model_parameters, start_epoch, best_acc1, best_acc5))
else:
start_epoch = 1
best_acc1 = 0.0
best_acc5 = 0.0
if args.cuda:
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
model = model.cuda()
print("Number of model parameters: ", get_model_parameters(model))
logger.info("Number of model parameters: {0}".format(
get_model_parameters(model)))
if args.loss == 'ce':
criterion = nn.CrossEntropyLoss()
elif args.loss == 'focal':
criterion = FocalLoss()
else:
raise NotImplementedError
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# lr_scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=10, T_mult=2, eta_min=0.001)
lr_scheduler = optim.lr_scheduler.MultiStepLR(
optimizer, milestones=[30, 60], gamma=0.1) #learning rate decay
for epoch in range(start_epoch, args.epochs + 1):
# adjust_learning_rate(optimizer, epoch, args)
train(model, train_loader, optimizer, criterion, epoch, args, logger,
writer)
acc1, acc5 = eval(model, test_loader, criterion, args)
lr_scheduler.step()
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
if is_best:
best_acc5 = acc5
if not os.path.isdir('checkpoint'):
os.mkdir('checkpoint')
filename = 'model_' + str(args.dataset) + '_' + str(
args.model_name) + '_ckpt.tar'
print('filename :: ', filename)
parameters = get_model_parameters(model)
if torch.cuda.device_count() > 1:
save_checkpoint(
{
'epoch': epoch,
'arch': args.model_name,
'state_dict': model.module.state_dict(),
'best_acc1': best_acc1,
'best_acc5': best_acc5,
'optimizer': optimizer.state_dict(),
'parameters': parameters,
}, is_best, filename)
else:
save_checkpoint(
{
'epoch': epoch,
'arch': args.model_name,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'best_acc5': best_acc5,
'optimizer': optimizer.state_dict(),
'parameters': parameters,
}, is_best, filename)
writer.add_scalar('Test/Acc1', acc1, epoch)
writer.add_scalar('Test/Acc5', acc5, epoch)
print(" Test best acc1:", best_acc1, " acc1: ", acc1, " acc5: ", acc5)
writer.close()
def main():
inputs, targets = load_data()
#TODO: improve get_unique_configs
UNIQUE_CONFIGS = get_unique_configs(DET_LAYER_1, DET_HIDDEN_SIZE_1)
for i, config in enumerate(UNIQUE_CONFIGS):
print('Evaluating configuration %i / %i' %(i, len(UNIQUE_CONFIGS)))
for hour in range(24):
# TODO: make it more elegant
fold_train_mse = []
fold_train_mae = []
fold_train_mape = []
fold_vali_mse = []
fold_vali_mae = []
fold_vali_mape = []
for fold_n in FOLDS_VALI:
#TODO: if IS_MODEL_RECURRENT == True, input data is a 3D array not shaped as a Dataframe. Better save
# feature names in a separate .pkl and load it
# features_names = inputs['train']['H_'+ str(hour)][str(fold_n)].columns.tolist()
features_names = []
# TODO: if IS_MODEL_RECURRENT == True, input data is a 3D array, so the .values attribute is not required. Make it more elegant
if IS_MODEL_RECURRENT:
X_train = inputs['train']['H_' + str(hour)][str(fold_n)]
y_train = targets['train']['H_' + str(hour)][str(fold_n)].values
X_vali = inputs['vali']['H_' + str(hour)][str(fold_n)]
y_vali = targets['vali']['H_' + str(hour)][str(fold_n)].values
else:
X_train = inputs['train']['H_'+ str(hour)][str(fold_n)].values
y_train = targets['train']['H_'+ str(hour)][str(fold_n)].values
X_vali = inputs['vali']['H_'+ str(hour)][str(fold_n)].values
y_vali = targets['vali']['H_'+ str(hour)][str(fold_n)].values
# TODO better implementation of how model read configuration (dictionary?)
epf_model = mdn4epf(det_layers=config[0], det_hidden_sizes=config[1],
features_names=features_names, device = 'GPU:0',
train_data=(X_train,y_train), vali_data=(X_vali,y_vali))
epf_model.setup_folders(det_layers=config[0], det_hidden_sizes=config[1], hour=hour,fold_n=fold_n)
print('Training...')
epf_model.fit(x=X_train, y=y_train,
batch_size=BATCH_SIZE,
epochs=MAX_EPOCHS,
callbacks=epf_model.call_list,
validation_data=(X_vali,y_vali))
epf_model.summary()
epf_model.evaluate_fold_vali_metrics(fold_n=fold_n)
fold_train_mse.append(epf_model.mse_train)
fold_train_mae.append(epf_model.mae_train)
fold_train_mape.append(epf_model.mape_train)
fold_vali_mse.append(epf_model.mse_vali)
fold_vali_mae.append(epf_model.mae_vali)
fold_vali_mape.append(epf_model.mape_vali)
print('Validating current hour...')
epf_model.evaluate_avg_vali_metrics(fold_train_mse,
fold_train_mae,
fold_train_mape,
fold_vali_mse,
fold_vali_mae,
fold_vali_mape)
epf_model.evaluate_test_set(inputs,targets)
print('Done.')
#TODO: plot results
print('Validating current configuration...')
evaluate_config_metrics(epf_model.path_run)
print('Done.')
# Load and check config from args
config = config_from_args()
if os.path.exists(config.run_dir + f"{config.criterion}_test_scores.json"):
assert False, "Run already launched"
# Set logger
print("Logging in {}".format(os.path.join(config.run_dir, "train.log")))
set_logger(os.path.join(config.run_dir, "train.log"))
# Set random seed
set_random_seed(config.seed)
# Load data
assert os.path.exists(DATA_DIR + f"{config.dataset}.json")
data, vocab = load_data(DATA_DIR + f"{config.dataset}.json", verbose=False)
# Standard mode = training on train set and validation on dev set
train_key, dev_key, test_key = "train", "dev", "test"
# Training on train + dev => no validation
if config.train_mode == "train+dev":
train_key, dev_key, test_key = "train+dev", None, "test"
# If a standard training was done with same config get best number of epochs on dev
best_checkpoint_path = os.path.join(
dirname(dirname(config.run_dir)),
f"{config.criterion}_best.pth.tar")
if os.path.exists(best_checkpoint_path):
best_checkpoint = load_checkpoint(best_checkpoint_path)
config.epochs = best_checkpoint["epoch"]