def main(config):
os.chdir(hydra.utils.get_original_cwd())
config.parameters.model = config.opt.usemodel
config.parameters.wrdim = config.opt.worddim
config.parameters.ptrnd = config.opt.pretrnd
use_dataset = config.opt.dataset
dataset_path = os.path.join('datasets', use_dataset)
tz = datetime.timezone(datetime.timedelta(hours=3))
dt = datetime.datetime.now(tz=tz)
date_path = f'{dt.date()}'
time_path = f'{dt.time()}'.replace(':', '-').split('.')[0]
result_path = os.path.join(config.opt.result_path, use_dataset, date_path,
time_path)
# model_name = config.opt.usemodel
# model_load = config.opt.reload
loader = Loader()
log.info(f'Model: {config.opt.usemodel}')
log.info(f'Dataset: {use_dataset}')
if not os.path.exists(result_path):
os.makedirs(result_path)
if not os.path.exists(os.path.join(result_path, config.opt.usemodel)):
os.makedirs(os.path.join(result_path, config.opt.usemodel))
with open(os.path.join(result_path, config.opt.usemodel, 'params'),
'wt') as fobj:
for param in config.parameters:
fobj.write(f'{param}:\t{config.parameters[param]}\n')
if use_dataset == 'conll':
train_data, dev_data, test_data, test_train_data, mappings = loader.load_conll(
dataset_path, config.parameters)
elif use_dataset == 'ontonotes':
train_data, dev_data, test_data, mappings = loader.load_ontonotes(
dataset_path, config.parameters)
test_train_data = train_data[-10000:]
else:
raise KeyError('unknown dataset name')
log.info('Load Complete')
model = make_model(config, mappings, result_path)
model.cuda()
learning_rate = config.parameters['lrate']
log.info(f'Initial learning rate is: {learning_rate:.6f}')
optimizer = torch.optim.SGD(model.parameters(),
lr=learning_rate,
momentum=0.9)
trainer = Trainer(model,
optimizer,
result_path,
config.opt.usemodel,
usedataset=config.opt.dataset,
mappings=mappings)
losses, all_F = trainer.train_model(
config.opt.num_epochs,
train_data,
dev_data,
test_train_data,
test_data,
learning_rate=learning_rate,
batch_size=config.parameters['batch_size'],
lr_decay=config.opt.lr_decay)
plt.plot(losses)
plt.savefig(os.path.join(result_path, config.opt.usemodel, 'lossplot.png'))
if model_load:
print ('Loading Saved Data points....................................................................')
acquisition_path = os.path.join(result_path, model_name, 'active_checkpoint', acquire_method,
checkpoint, 'acquisition2.p')
acquisition_function = pkl.load(open(acquisition_path,'rb'))
else:
acquisition_function = Acquisition(train_data, init_percent=init_percent, seed=0,
acq_mode = parameters['acqmd'])
model.cuda()
learning_rate = parameters['lrate']
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9)
trainer = Trainer(model, optimizer, result_path, model_name, usedataset=opt.dataset, mappings= mappings)
active_train_data = [train_data[i] for i in acquisition_function.train_index]
tokens_acquired = sum([len(x['words']) for x in active_train_data])
num_acquisitions_required = 25
acquisition_strat_all = [2]*24 + [5]*10 + [0]
acquisition_strat = acquisition_strat_all[:num_acquisitions_required]
for acquire_percent in acquisition_strat:
checkpoint_folder = os.path.join('active_checkpoint',acquire_method, str(tokens_acquired).zfill(8))
checkpoint_path = os.path.join(result_path, model_name, checkpoint_folder)
if not os.path.exists(checkpoint_path):
os.makedirs(checkpoint_path)
char_vocab_size,
char_embedding_dim,
char_out_channels,
decoder_hidden_units,
tag_to_id,
sigma_prior=sigma_prior,
pretrained=word_embeds)
model.cuda()
learning_rate = parameters['lrate']
print('Initial learning rate is: %s' % (learning_rate))
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9)
trainer = Trainer(model,
optimizer,
result_path,
model_name,
usedataset=opt.dataset,
mappings=mappings)
losses, all_F = trainer.train_model(opt.num_epochs,
train_data,
dev_data,
test_train_data,
test_data,
learning_rate=learning_rate,
batch_size=parameters['batch_size'],
lr_decay=0.05)
plt.plot(losses)
plt.savefig(os.path.join(result_path, model_name, 'lossplot.png'))