def main():
parser = argparse.ArgumentParser(description="Run Extended Q-Learning with given config")
parser.add_argument("-c",
"--config",
type=str,
metavar="",
required=True,
help="Config file name - file must be available as .json in ./configs")
args = parser.parse_args()
# load config files
with open(os.path.join(".", "configs", args.config), "r") as read_file:
config = json.load(read_file)
env = UnityEnvironment(file_name=os.path.join(*config["env_path"]))
normalizer = OnlineNormalizer(config["network"]["observation_size"])
if config["run_training"]:
elite_net = session.train(env, normalizer, config)
checkpoint_dir = os.path.join(".", *config["checkpoint_dir"], config["env_name"])
utils.save_state_dict(os.path.join(checkpoint_dir), elite_net.state_dict())
else:
trained_net = getattr(network, config["network"]["type"])(config["network"]).to(torch.device(config["device"]))
checkpoint_dir = os.path.join(".", *config["checkpoint_dir"], config["env_name"])
trained_net.load_state_dict(utils.load_latest_available_state_dict(os.path.join(checkpoint_dir, "*")))
session.evaluate(trained_net, env, normalizer, config, num_test_runs=50)
env.close()
def train(self):
"""Train the model for one epoch, evaluate on validation set and
save the best model
"""
start_time = datetime.now()
self._train(self.train_loader)
utils.save_state_dict(self.state_dict(), os.path.join(self.save_path, 'ckpt.pth'))
dev_class_loss, dev_domain_loss, dev_class_output, _,_, dev_domain_accuarcy = \
self._test(self.dev_loader)
dev_predict_prob = self.inference(dev_class_output)
dev_per_class_AP = utils.compute_weighted_AP(self.dev_target, dev_predict_prob,
self.dev_class_weight)
dev_mAP = utils.compute_mAP(dev_per_class_AP, self.subclass_idx)
self.log_result('Dev epoch',
{'class_loss': dev_class_loss/len(self.dev_loader),
'domain_loss': dev_domain_loss/len(self.dev_loader),
'mAP': dev_mAP,
'domain_accuracy': dev_domain_accuarcy},
self.epoch)
if (self.epoch) > 1 and (dev_mAP > self.best_dev_mAP):
self.best_dev_mAP = dev_mAP
utils.save_state_dict(self.state_dict(), os.path.join(self.save_path, 'best.pth'))
duration = datetime.now() - start_time
print('Finish training epoch {}, dev class loss: {}, dev doamin loss: {}, dev mAP: {},'\
'domain_accuracy: {}, time used: {}'
.format(self.epoch, dev_class_loss/len(self.dev_loader),
dev_domain_loss/len(self.dev_loader), dev_mAP, dev_domain_accuarcy,
duration))
def main():
parser = argparse.ArgumentParser(
description="Run Extended Q-Learning with given config")
parser.add_argument(
"-c",
"--config",
type=str,
metavar="",
required=True,
help="Config file name - file must be available as .json in ./configs")
args = parser.parse_args()
# load config files
with open(os.path.join(".", "configs", args.config), "r") as read_file:
config = json.load(read_file)
env = UnityEnvironment(file_name=os.path.join(*config["env_path"]))
noise = OrnsteinUhlenbeckNoise(config["n_actions"], config["mu"],
config["theta"], config["sigma"],
config["seed"])
replay_buffer = ReplayBuffer(config["buffer_size"], config["device"],
config["seed"])
agent = DDPGAgent(config, noise, replay_buffer)
if config["run_training"]:
session.train(agent, env, config)
checkpoint_dir = os.path.join(".", *config["checkpoint_dir"],
config["env_name"])
utils.save_state_dict(os.path.join(checkpoint_dir, "actor"),
agent.actor.state_dict())
utils.save_state_dict(os.path.join(checkpoint_dir, "critic"),
agent.critic.state_dict())
else:
checkpoint_dir = os.path.join(".", *config["checkpoint_dir"],
config["env_name"])
agent.actor.load_state_dict(
utils.load_latest_available_state_dict(
os.path.join(checkpoint_dir, "actor", "*")))
agent.critic.load_state_dict(
utils.load_latest_available_state_dict(
os.path.join(checkpoint_dir, "critic", "*")))
session.evaluate(agent, env, num_test_runs=1)
env.close()
def evolve(self, env):
self.population = self._create_init_population(env)
while True:
self.population = self._sort_population_by_fitness(self.population)
self._write_statistics()
if self.best_mean is None or np.mean(self.elite_scores) > self.best_mean:
self.best_mean = np.mean(self.elite_scores)
checkpoint_dir = os.path.join(".", *self.config["checkpoint_dir"], self.config["env_name"])
utils.save_state_dict(os.path.join(checkpoint_dir), self.population[0][0].state_dict())
if self._env_solved():
print("Environment solved in {}".format(self.gen_idx))
break
self._create_next_generation(env)
self.gen_idx += 1
return self.elite[0]
def main():
logger.info("Logger is set - training start")
# set default gpu device id
torch.cuda.set_device(config.gpus[0])
# set seed
np.random.seed(config.seed)
torch.manual_seed(config.seed)
torch.cuda.manual_seed_all(config.seed)
torch.backends.cudnn.benchmark = True
# get data with meta info
input_size, input_channels, n_classes, train_data = utils.get_data(
config.dataset, config.data_path, cutout_length=0, validation=False)
net_crit = nn.CrossEntropyLoss().to(device)
model = SearchCNNController(input_channels,
config.init_channels,
n_classes,
config.layers,
net_crit,
device_ids=config.gpus)
model = model.to(device)
# weights optimizer
w_optim = torch.optim.SGD(model.weights(),
config.w_lr,
momentum=config.w_momentum,
weight_decay=config.w_weight_decay)
# alphas optimizer
alpha_optim = torch.optim.Adam(model.alphas(),
config.alpha_lr,
betas=(0.5, 0.999),
weight_decay=config.alpha_weight_decay)
# split data to train/validation
n_train = len(train_data)
split = n_train // 2
indices = list(range(n_train))
train_sampler = torch.utils.data.sampler.SubsetRandomSampler(
indices[:split])
valid_sampler = torch.utils.data.sampler.SubsetRandomSampler(
indices[split:])
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=config.batch_size,
sampler=train_sampler,
num_workers=config.workers,
pin_memory=False)
valid_loader = torch.utils.data.DataLoader(train_data,
batch_size=config.batch_size,
sampler=valid_sampler,
num_workers=config.workers,
pin_memory=False)
lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
w_optim, config.epochs, eta_min=config.w_lr_min)
architect = Architect(model, config.w_momentum, config.w_weight_decay)
# training loop
best_top1 = -1.0
best_epoch = 0
################################ restore from last time #############################################
epoch_restore = config.epoch_restore
if config.restore:
utils.load_state_dict(model,
config.path,
extra='model',
parallel=(len(config.gpus) > 1))
if not config.model_only:
utils.load_state_dict(w_optim,
config.path,
extra='w_optim',
parallel=False)
utils.load_state_dict(alpha_optim,
config.path,
extra='alpha_optim',
parallel=False)
utils.load_state_dict(lr_scheduler,
config.path,
extra='lr_scheduler',
parallel=False)
utils.load_state_dict(epoch_restore,
config.path,
extra='epoch_restore',
parallel=False)
#####################################################################################################
for epoch in range(epoch_restore, config.epochs):
lr_scheduler.step()
lr = lr_scheduler.get_lr()[0]
model.print_alphas(logger)
# training
train(train_loader, valid_loader, model, architect, w_optim,
alpha_optim, lr, epoch)
# validation
cur_step = (epoch + 1) * len(train_loader)
top1 = validate(valid_loader, model, epoch, cur_step)
# top1 = 0.0
# log
# genotype
genotype = model.genotype()
logger.info("genotype = {}".format(genotype))
# genotype as a image
plot_path = os.path.join(config.plot_path,
"EP{:02d}".format(epoch + 1))
caption = "Epoch {}".format(epoch + 1)
plot(genotype.normal, plot_path + "-normal", caption)
plot(genotype.reduce, plot_path + "-reduce", caption)
# save
if best_top1 < top1:
best_top1 = top1
best_genotype = genotype
is_best = True
best_epoch = epoch + 1
else:
is_best = False
utils.save_checkpoint(model, config.path, is_best)
######################################## save all state ###################################################
utils.save_state_dict(model,
config.path,
extra='model',
is_best=is_best,
parallel=(len(config.gpus) > 1),
epoch=epoch + 1,
acc=top1,
last_state=((epoch + 1) >= config.epochs))
utils.save_state_dict(lr_scheduler,
config.path,
extra='lr_scheduler',
is_best=is_best,
parallel=False,
epoch=epoch + 1,
acc=top1,
last_state=((epoch + 1) >= config.epochs))
utils.save_state_dict(alpha_optim,
config.path,
extra='alpha_optim',
is_best=is_best,
parallel=False,
epoch=epoch + 1,
acc=top1,
last_state=((epoch + 1) >= config.epochs))
utils.save_state_dict(w_optim,
config.path,
extra='w_optim',
is_best=is_best,
parallel=False,
epoch=epoch + 1,
acc=top1,
last_state=((epoch + 1) >= config.epochs))
############################################################################################################
print("")
logger.info("Best Genotype at {} epch.".format(best_epoch))
logger.info("Final best Prec@1 = {:.4%}".format(best_top1))
logger.info("Best Genotype = {}".format(best_genotype))
def main(params):
train_batch_size = params['train_batch_size']
eval_batch_size = params['eval_batch_size']
model_output_path = params.get('output_path')
if model_output_path is None:
data_path = params['data_path'].split('/')[-2]
#model_output_path = f'experiments/{data_path}_{params["train_batch_size"]}_{params["eval_batch_size"]}_{params["is_biencoder"]}_{params["not_use_golden_tags"]}/'
model_used = 'long' if params['use_longformer'] else 'bert'
model_output_path = f'experiments/{data_path}/{train_batch_size}_{eval_batch_size}_{model_used}_{params["is_biencoder"]}_{params["not_use_golden_tags"]}_{params["classifier"]}/'
if not os.path.exists(model_output_path):
os.makedirs(model_output_path)
print('Model saved to: ', model_output_path)
# init model
ranker = BertEncoderRanker(params)
tokenizer = ranker.tokenizer
model = ranker.model
device = ranker.device
optim = torch.optim.Adam(model.parameters(), lr=params['learning_rate'])
model_path = params.get('model_path', None)
if model_path is not None:
checkpoint = torch.load(model_path + 'last_epoch')
optim.load_state_dict(checkpoint['optimizer_state_dict'])
epochs = params['epochs']
#b_tag = params['b_tag']
# prepare data
train_dataloader, valid_dataloader = utils.load_and_prepare_data(
tokenizer,
train_batch_size,
eval_batch_size,
max_len=params['max_context_length'])
utils.write_to_file(os.path.join(model_output_path, 'training_params.txt'),
str(params))
model.train()
for epoch in range(epochs):
total = 0
running_loss = 0.0
if params['silent']:
iter_ = train_dataloader
else:
iter_ = tqdm(train_dataloader)
for batch in iter_:
#model.zero_grad()
batch = tuple(t.to(device) for t in batch)
token_ids, attn_mask, tags = batch
loss, _, _ = ranker(token_ids, attn_mask, tags)
# Perform backpropagation
#(loss/token_ids.size(1)).backward()
loss.backward()
#optim.step()
total += 1
running_loss += loss.item()
torch.nn.utils.clip_grad_norm_(model.parameters(),
params['max_grad_norm'])
optim.step()
optim.zero_grad()
# optim.step()
# optim.zero_grad()
res = evaluate(ranker, valid_dataloader, params, device)
print(
f'Epoch: {epoch} Epoch Loss: {running_loss/total:.4f} Validation acc: {res["acc"]:.4f}'
)
metrics = res['start_tag']
print(
f'Start tag metrics: precision {metrics[0]:.4f}, recall {metrics[1]:.4f}, F1 {metrics[2]:.4f}'
)
print(
f'Pred start: {metrics[3]}, True start: {metrics[4]}, Total start: {metrics[5]}'
)
model.train()
epoch_output_folder_path = os.path.join(model_output_path,
'last_epoch')
utils.save_state_dict(model, optim, epoch_output_folder_path)
def main(params):
train_batch_size = params['train_batch_size']
eval_batch_size = params['eval_batch_size']
model_output_path = params.get('output_path')
if model_output_path is None:
data_path = params['data_path'].split('/')[-2]
#model_output_path = f'experiments/{data_path}_{params["train_batch_size"]}_{params["eval_batch_size"]}_{params["is_biencoder"]}_{params["not_use_golden_tags"]}/'
model_used = 'long' if params['use_longformer'] else 'bert'
model_output_path = f'experiments/{data_path}/{params["max_context_length"]}_{train_batch_size}_{eval_batch_size}_{model_used}_{params["is_biencoder"]}_{params["not_use_golden_tags"]}_{params["classifier"]}/'
if not os.path.exists(model_output_path):
os.makedirs(model_output_path)
print('Model saved to: ', model_output_path)
# init model
ranker = LongEncoderRanker(params)
tokenizer = ranker.tokenizer
device = ranker.device
start_epoch = 0
model_path = params.get('model_path', None)
if model_path is not None:
model_name = params.get('model_name')
checkpoint = torch.load(os.path.join(model_path, model_name),
map_location=device)
# load model state
ranker.model.load_state_dict(checkpoint['model_state_dict'])
model = ranker.model
# load optim state
optim = torch.optim.Adam(model.parameters(),
lr=params['learning_rate'])
optim.load_state_dict(checkpoint['optimizer_state_dict'])
# load last epoch
with open(os.path.join(model_path, 'training_params.json')) as f:
prev_params = json.load(f)
start_epoch = prev_params['epochs']
else:
model = ranker.model
optim = torch.optim.Adam(model.parameters(),
lr=params['learning_rate'])
epochs = params['epochs'] + start_epoch
params['epochs'] = epochs
b_tag = params['b_tag']
# prepare data
# load train and validate data
train_samples = read_dataset(params['data_path'], 'train')
valid_samples = read_dataset(params['data_path'], 'dev')
if params['debug'] is not None:
sample_size = params['debug']
train_samples = train_samples[:sample_size]
#valid_samples = valid_samples[:50]
if params['conll']:
train_tensor_data = process_conll_data(
train_samples,
tokenizer,
max_context_length=params['max_context_length'],
silent=params['silent'])
valid_tensor_data = process_conll_data(
valid_samples,
tokenizer,
max_context_length=params['max_context_length'],
silent=params['silent'])
else:
cand_enc_path = os.path.join(params['data_path'], 'train_enc.json')
train_tensor_data = process_mention_data(
train_samples,
tokenizer,
max_context_length=params['max_context_length'],
silent=params['silent'],
end_tag=params['end_tag'],
is_biencoder=params['is_biencoder'],
cand_enc_path=cand_enc_path,
use_longformer=params['use_longformer'])
cand_enc_path = os.path.join(params['data_path'], 'dev_enc.json')
valid_tensor_data = process_mention_data(
valid_samples,
tokenizer,
max_context_length=params['max_context_length'],
silent=params['silent'],
end_tag=params['end_tag'],
is_biencoder=params['is_biencoder'],
cand_enc_path=cand_enc_path,
use_longformer=params['use_longformer'])
train_tensor_data = TensorDataset(*train_tensor_data)
if params['shuffle']:
train_sampler = RandomSampler(train_tensor_data)
else:
train_sampler = SequentialSampler(train_tensor_data)
train_dataloader = DataLoader(train_tensor_data,
sampler=train_sampler,
batch_size=train_batch_size)
valid_tensor_data = TensorDataset(*valid_tensor_data)
valid_sampler = SequentialSampler(valid_tensor_data)
valid_dataloader = DataLoader(valid_tensor_data,
sampler=valid_sampler,
batch_size=eval_batch_size)
with open(os.path.join(model_output_path, 'training_params.json'),
'w') as outf:
json.dump(params, outf)
model.train()
for epoch in range(start_epoch, epochs):
total = 0
running_loss = 0.0
if params['silent']:
iter_ = train_dataloader
else:
iter_ = tqdm(train_dataloader)
for batch in iter_:
#model.zero_grad()
batch = tuple(t.to(device) for t in batch)
cand_enc = cand_enc_mask = label_ids = label_mask = None
if params['is_biencoder']:
token_ids, tags, cand_enc, cand_enc_mask, label_ids, label_mask, attn_mask, global_attn_mask = batch
else:
token_ids, tags, attn_mask, global_attn_mask = batch
# should not give out ner info
global_attn_mask = None
loss, _, _ = ranker(token_ids,
attn_mask,
global_attn_mask,
tags,
b_tag=b_tag,
golden_cand_enc=cand_enc,
golden_cand_mask=cand_enc_mask,
label_ids=label_ids,
label_mask=label_mask)
# Perform backpropagation
#(loss/token_ids.size(1)).backward()
loss.backward()
#optim.step()
total += 1
running_loss += loss.item()
torch.nn.utils.clip_grad_norm_(model.parameters(),
params['max_grad_norm'])
optim.step()
optim.zero_grad()
# optim.step()
# optim.zero_grad()
# evaluate on valid_dataloader
if params['silent']:
iter_ = valid_dataloader
else:
iter_ = tqdm(valid_dataloader)
print(f'Epoch: {epoch} Epoch Loss: {running_loss/total:.4f}')
ner_eval(ranker, iter_, params, device)
if params['is_biencoder']:
# in batch negative
#in_batch_el_eval(ranker, iter_, params, device)
# eval against all entities in train, dev, and test
cand_set_enc = torch.load(params['selected_set_path'],
map_location=device)
id2label = torch.load(params['id_to_label_path'],
map_location=device)
cand_set_eval(ranker, iter_, params, device, cand_set_enc,
id2label)
model.train()
epoch_output_folder_path = os.path.join(model_output_path,
'last_epoch')
utils.save_state_dict(model, optim, epoch_output_folder_path)
def train(self):
self._train(self.train_loader)
utils.save_state_dict(self.state_dict(),
os.path.join(self.save_path, 'ckpt.pth'))
filename = 'checkpoint_part4_resnet50.pth.tar'
state_dict_file_name = 'sd_part4_resnet50.pth'
log_filename = 'log_part_resnet50.log'
use_gpu = torch.cuda.is_available()
num_workers = 3
shuffle = True
device = torch.device("cuda" if use_gpu else "cpu")
dataset = PartLoader(data_file, num_parts)
train_loader = torch.utils.data.DataLoader(dataset,
shuffle=shuffle,
batch_size=batch_size,
num_workers=num_workers)
if model_path is not None:
checkpoint = torch.load(model_path)
start_epoch = checkpoint['epoch'] + 1
print('\nLoaded checkpoint from epoch %d.\n' % start_epoch)
net = checkpoint['model']
optimizer = checkpoint['optimizer']
else:
net = Network(num_outputs=num_parts)
optimizer = optim.SGD(net.parameters(), lr=lr, momentum=0.9)
start_epoch = 0
net = net.to(device)
criterion = nn.CrossEntropyLoss()
train_model(net, criterion, optimizer, start_epoch, epochs, dataset,
train_loader, device, filename, log_filename)
save_state_dict(filename, state_dict_file_name)
def train(self):
"""Train the model for one epoch, evaluate on validation set and
save the best model for each inference method
"""
start_time = datetime.now()
self._train(self.train_loader)
utils.save_state_dict(self.state_dict(),
os.path.join(self.save_path, 'ckpt.pth'))
dev_loss, dev_output, _ = self._test(self.dev_loader)
dev_predict_conditional = self.inference_conditional(
dev_output, self.dev_target)
dev_per_class_AP_conditional = utils.compute_weighted_AP(
self.dev_target, dev_predict_conditional, self.dev_class_weight)
dev_mAP_conditional = utils.compute_mAP(dev_per_class_AP_conditional,
self.subclass_idx)
if dev_mAP_conditional > self.best_dev_mAP_conditional:
self.best_dev_mAP_conditional = dev_mAP_conditional
utils.save_state_dict(
self.state_dict(),
os.path.join(self.save_path, 'best-conditional.pth'))
dev_predict_max = self.inference_max(dev_output)
dev_per_class_AP_max = utils.compute_weighted_AP(
self.dev_target, dev_predict_max, self.dev_class_weight)
dev_mAP_max = utils.compute_mAP(dev_per_class_AP_max,
self.subclass_idx)
if dev_mAP_max > self.best_dev_mAP_max:
self.best_dev_mAP_max = dev_mAP_max
utils.save_state_dict(self.state_dict(),
os.path.join(self.save_path, 'best-max.pth'))
dev_predict_sum_prob = self.inference_sum_prob(dev_output)
dev_per_class_AP_sum_prob = utils.compute_weighted_AP(
self.dev_target, dev_predict_sum_prob, self.dev_class_weight)
dev_mAP_sum_prob = utils.compute_mAP(dev_per_class_AP_sum_prob,
self.subclass_idx)
if dev_mAP_sum_prob > self.best_dev_mAP_sum_prob:
self.best_dev_mAP_sum_prob = dev_mAP_sum_prob
utils.save_state_dict(
self.state_dict(),
os.path.join(self.save_path, 'best-sum_prob.pth'))
dev_predict_sum_out = self.inference_sum_out(dev_output)
dev_per_class_AP_sum_out = utils.compute_weighted_AP(
self.dev_target, dev_predict_sum_out, self.dev_class_weight)
dev_mAP_sum_out = utils.compute_mAP(dev_per_class_AP_sum_out,
self.subclass_idx)
if dev_mAP_sum_out > self.best_dev_mAP_sum_out:
self.best_dev_mAP_sum_out = dev_mAP_sum_out
utils.save_state_dict(
self.state_dict(),
os.path.join(self.save_path, 'best-sum_out.pth'))
self.log_result(
'Dev epoch', {
'loss': dev_loss / len(self.dev_loader),
'mAP_conditional': dev_mAP_conditional,
'mAP_max': dev_mAP_max,
'mAP_sum_prob': dev_mAP_sum_prob,
'mAP_sum_out': dev_mAP_sum_out,
}, self.epoch)
duration = datetime.now() - start_time
print(('Finish training epoch {}, dev mAP conditional: {}'
'dev mAP max: {}, dev mAP sum prob: {}, '
'dev mAP sum out: {}, time used: {}').format(
self.epoch, dev_mAP_conditional, dev_mAP_max,
dev_mAP_sum_prob, dev_mAP_sum_out, duration))
