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))