def rivalProposal(): print("rivalProposal") processes = ['alpha', 'beta', 'gamma'] um = UniversalMessenger() m1 = MockMessenger('alpha', processes, um) m2 = MockMessenger('beta', processes, um) m3 = MockMessenger('gamma', processes, um) p1 = Proposer('alpha', processes, m1) p2 = Proposer('beta', processes, m2) p3 = Proposer('gamma', processes, m3) a1 = Acceptor(processes, m1) a2 = Acceptor(processes, m2) a3 = Acceptor(processes, m3) l1 = Learner(processes, m1) l2 = Learner(processes, m2) l3 = Learner(processes, m3) p1.prepare('ABC', 0) a1.promise(um.lastMessageToSite('alpha', 'prepare')) p1.receivePromise(um.lastMessageToSite('alpha', 'promise')) a2.promise(um.lastMessageToSite('beta', 'prepare')) p1.receivePromise(um.lastMessageToSite('alpha', 'promise')) #a3.promise(um.lastMessageToSite('gamma', 'prepare')) #p1.receivePromise(um.lastMessageToSite('alpha', 'promise')) #a1.accept(um.lastMessageToSite('alpha', 'accept')) #a2.accept(um.lastMessageToSite('beta', 'accept')) #a3.accept(um.lastMessageToSite('gamma', 'accept')) p2.prepare( 'XYZ', 0) # A majority of these need to be uncommented for XYZ to be accepted #a1.promise(um.lastMessageToSite('alpha', 'prepare')) #p2.receivePromise(um.lastMessageToSite('beta', 'promise')) a2.promise(um.lastMessageToSite('beta', 'prepare')) p2.receivePromise(um.lastMessageToSite('beta', 'promise')) a3.promise(um.lastMessageToSite('gamma', 'prepare')) p2.receivePromise(um.lastMessageToSite('beta', 'promise')) a1.accept(um.lastMessageToSite('alpha', 'accept')) l1.receiveAccepted(um.lastMessageToSite('alpha', 'accepted')) l2.receiveAccepted(um.lastMessageToSite('beta', 'accepted')) l3.receiveAccepted(um.lastMessageToSite('gamma', 'accepted')) a2.accept(um.lastMessageToSite('beta', 'accept')) l1.receiveAccepted(um.lastMessageToSite('alpha', 'accepted')) l2.receiveAccepted(um.lastMessageToSite('beta', 'accepted')) l3.receiveAccepted(um.lastMessageToSite('gamma', 'accepted')) a3.accept(um.lastMessageToSite('gamma', 'accept')) l1.receiveAccepted(um.lastMessageToSite('alpha', 'accepted')) l2.receiveAccepted(um.lastMessageToSite('beta', 'accepted')) l3.receiveAccepted(um.lastMessageToSite('gamma', 'accepted')) um.printMessages()
def __init__(self, args, config): """ :param args: """ super(Meta, self).__init__() self.meta_lr = args.meta_lr self.n_way = args.n_way self.k_spt = args.k_spt self.k_qry = args.k_qry self.task_num = args.task_num self.update_step = args.update_step self.update_step_test = args.update_step_test self.net = Learner(config, args.imgc, args.imgsz) # Create learnable per parameter learning rate self.type = args.lr_type if self.type == "vector": self.update_lr = nn.ParameterList() for p in self.net.parameters(): p_lr = args.update_lr * torch.ones_like(p) self.update_lr.append(nn.Parameter(p_lr)) params = list(self.net.parameters()) + list(self.update_lr) elif self.type == "scalar": self.update_lr = nn.Parameter(torch.tensor(args.update_lr)) params = list(self.net.parameters()) params += [self.update_lr] # Define outer optimizer (also optimize lr) self.meta_optim = optim.Adam(params, lr=self.meta_lr)
def evaluate(f, optimizer, best_sum_loss, best_final_loss, best_flag, lr): print('\n --> evalute the model') STEPS = 100 LSTM_learner = Learner(f, optimizer, STEPS, eval_flag=True, reset_theta=True, retain_graph_flag=True) lstm_losses, sum_loss = LSTM_learner() try: best = torch.load('best_loss.txt') except IOError: print('can not find best_loss.txt') pass else: best_sum_loss = best[0] best_final_loss = best[1] print("load_best_final_loss and sum_loss") if lstm_losses[-1] < best_final_loss and sum_loss < best_sum_loss: best_final_loss = lstm_losses[-1] best_sum_loss = sum_loss print( '\n\n===> best of final LOSS[{}]: = {}, best_sum_loss ={}'.format( STEPS, best_final_loss, best_sum_loss)) torch.save(optimizer.state_dict(), 'best_LSTM_optimizer.pth') torch.save([best_sum_loss, best_final_loss, lr], 'best_loss.txt') best_flag = True return best_sum_loss, best_final_loss, best_flag
def setUp(self): """Learner Testing Configuration. Sets up the necessary information to begin testing. """ self.data_shape = 100, 20 self.label = '`learner.Learner`' self.learner = Learner() self.n_tests = 50 self.name = __name__ self.shapes = {} p_to_shape = lambda p: p.shape """callable: Maps parameters to their matrix dimensions.""" for name, ModelWrapper in self.learner: ModelWrapper.model = dict(X=_random_matrix(self.data_shape)) self.shapes[name] = _compose(tuple, map)(p_to_shape, ModelWrapper._model.params) # Model string should indicate that all parameters are set at this # point. self.assertIsNotNone(ModelWrapper._model.params) del ModelWrapper._model.params # Model string should indicate unset parameters at this point. self.assertIsNone(ModelWrapper._model.params)
def zero_shot_NOmeta(args): res_filename = '{}/res-0shot-NOmeta-{}.json'.format(args.model_dir, '_'.join(args.test_langs)) if os.path.exists(res_filename): assert False, 'Already evaluated.' logger.info("********** Scheme: 0-shot NO meta learning **********") # build the model learner = Learner(args.bert_model, LABEL_LIST, args.freeze_layer, logger, lr_meta=0, lr_inner=0, warmup_prop_meta=-1, warmup_prop_inner=-1, max_meta_steps=-1, model_dir=args.model_dir, gpu_no=args.gpu_device, py_alias=args.py_alias).to(device) languages = args.test_langs F1s = {lang: [] for lang in languages} for lang in languages: corpus_test = Corpus('bert-base-multilingual-cased', args.max_seq_len, logger, language=lang, mode='test', load_data=False, support_size=-1, base_features=None, mask_rate=-1.0, compute_repr=False, shuffle=False) logger.info("********** Scheme: evaluate [{}] - [test] **********".format(lang)) F1_test = learner.evaluate_NOmeta(corpus_test, args.result_dir, logger, lang=lang, mode='test') F1s[lang].append(F1_test) logger.info("===> Test F1: {}".format(F1_test)) for lang in languages: logger.info('{} Test F1: {}'.format(lang, ', '.join([str(i) for i in F1s[lang]]))) with Path(res_filename).open('w', encoding='utf-8') as fw: json.dump(F1s, fw, indent=4, sort_keys=True)
def __init__(self, model, device): super(RobustVis, self).__init__() #self.normalize = helpers.InputNormalize(dataset.mean, dataset.std) configtest = [ ('conv2d', [32, 3, 3, 3, 1, 0]), ('relu', [True]), ('bn', [32]), ('max_pool2d', [2, 2, 0]), ('conv2d', [32, 32, 3, 3, 1, 0]), ('relu', [True]), ('bn', [32]), ('max_pool2d', [2, 2, 0]), ('conv2d', [32, 32, 3, 3, 1, 0]), ('relu', [True]), ('bn', [32]), ('max_pool2d', [2, 2, 0]), ('conv2d', [32, 32, 3, 3, 1, 0]), ('relu', [True]), ('bn', [32]), ('max_pool2d', [2, 1, 0]), ('flatten', []) ] copymod = Learner(configtest, 3, 84)#.to('cuda:3') for i in range(0,16): copymod.parameters()[i] = model.parameters()[i] self.model = copymod.to(device) self.model.eval() self.device = device
def __init__(self, args, config): """ :param args: """ super(Meta, self).__init__() self.update_lr = args.update_lr self.meta_lr = args.meta_lr self.n_way = args.n_way self.k_spt = args.k_spt self.k_qry = args.k_qry self.task_num = args.task_num self.update_step = args.update_step self.update_step_test = args.update_step_test self.meta_states = dict() self.iteration = 1 self.net = Learner(config, args.imgc, args.imgsz) # self.meta_optim = optim.Adam(self.net.parameters(), lr=self.meta_lr) self.optimizer = optim.EntropySGD(self.net.parameters(), config=dict(lr=1.2, momentum=0, nesterov=True, weight_decay=0, L=10, eps=1e-4, g0=1e-2, g1=1e-1))
def main(): from learner import Learner from res_unet_dropout import ResUnet # lr=3e-5 dprob=0.2 epochs = 8 trainset = Prostate_data(img_size=256, num_classes=3) validset = Prostate_data(dataset_type='valid', img_size=256, num_classes=3) datasets = {'train': trainset, 'valid': validset} for lr in [1e-4,5e-4,1e-3,5e-3,1e-2]: for gamma in [0] : # fig,axes = plt.subplots(nrows=1,ncols=6,figsize=(24,4)) # imgs = [] # for i in tqdm(range(6)): # imgs.append(get_rgb(trainset[i][1])) # for j in range(6): # axes[j].imshow(imgs[j]) # plt.show() model = ResUnet(num_classes=5,dprob=dprob) criterion = Focalloss(gamma=gamma) optimizer = torch.optim.SGD(model.parameters(),lr=lr,momentum=0.9) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,patience=10) dtime = '0057_1806' tb_logs = {'path':'logdirs/onevall_trials_aug/respre_SGD_plateau','comment':f'lr={lr}_gamma={gamma}_dprob={dprob}_{dtime}'} trainer = Learner(datasets,model,criterion,optimizer,scheduler,bs=8,num_workers=4) try : trainer.fit(tb_logs=tb_logs,epochs=epochs) # torch.save(trainer.model,f'logdirs/onevall_trials_aug/respre_SGD_plateau/lr={lr}_gamma={gamma}_dprob={dprob}_{dtime}/{dtime}') except KeyboardInterrupt: pass
def setup_master(self): policy1 = None policy2 = None team1 = [ ] ## List of Neo objects, one Neo object per agent, teams_list = [team1, teams2] team2 = [] num_adversary = 0 num_friendly = 0 for i, agent in enumerate(self.world.policy_agents): if agent.attacker: num_adversary += 1 else: num_friendly += 1 action_space = self.action_spaces[ i] ##* why on earth would you put i??? pol_obs_dim = self.observation_spaces[0].shape[ 0] ##* ensure 27 is correct # index at which agent's position is present in its observation pos_index = 2 ##* don't know why it's a const and +2 for i, agent in enumerate(self.world.policy_agents): obs_dim = self.observation_spaces[i].shape[0] if not agent.attacker: # first we have the guards and then the attackers if policy1 is None: policy1 = MPNN(input_size=pol_obs_dim, num_agents=num_friendly, num_opp_agents=num_adversary, num_entities=0, action_space=self.action_spaces[i], pos_index=pos_index, mask_dist=1.0, entity_mp=False, policy_layers=1).to(self.device) team1.append( Neo(self.namespace_args, policy1, (obs_dim, ), action_space) ) ## Neo adds additional features to policy such as loading model, update_rollout. Neo.actor_critic is the policy and is the same object instance within a team else: if policy2 is None: policy2 = MPNN(input_size=pol_obs_dim, num_agents=num_adversary, num_opp_agents=num_friendly, num_entities=0, action_space=self.action_spaces[i], pos_index=pos_index, mask_dist=1.0, entity_mp=False).to(self.device) team2.append( Neo(self.namespace_args, policy2, (obs_dim, ), action_space)) master = Learner(self.namespace_args, [team1, team2], [policy1, policy2], world=self.world) return master
def __init__(self, args, config): """ :param args: """ super(Meta, self).__init__() # self.update_lr = args.update_lr self.meta_lr = args.meta_lr self.n_way = args.n_way self.k_spt = args.k_spt self.k_qry = args.k_qry self.task_num = args.task_num self.update_step = args.update_step self.update_step_test = args.update_step_test self.reg_lambda = args.reg_lambda self.regularization = nn.MSELoss() self.net = Learner(config, args.imgc, args.imgsz) self.update_lrs = nn.Parameter( args.update_lr * torch.ones(self.update_step, len(self.net.vars)), requires_grad=True) self.meta_optim = optim.Adam(self.parameters(), lr=self.meta_lr) #self.CG_optim = HessianFree(self.parameters(), lr=self.meta_lr, cg_max_iter=5) self.lr_scheduler = optim.lr_scheduler.ExponentialLR( self.meta_optim, 0.9) self.MAX_CG = args.MAX_CG
def main(): dbinfo = recover() conn = MySQLdb.connect(**dbinfo) cur = conn.cursor() #Learn sql = "SELECT id,article_text,trainpos,trainneg,trainneutral FROM articles WHERE trainset=1 AND (trainpos>0 OR trainneg>0 OR trainneutral>0)" cur.execute(sql) a = Learner() for aid,article_text,trainpos,trainneg,trainneutral in cur.fetchall(): aid = int(aid) items = [ (1, int(trainpos)),(0, int(trainneutral)),(-1, int(trainneg)) ] classification = max(items, key=lambda x : x[1])[0] a.add_string(article_text, classification) a.train() #Predict sql = "SELECT id,article_text FROM articles" cur.execute(sql) b = Classifier(a) for aid,article_text in cur.fetchall(): aid = int(aid) classification = b.classify(article_text) sql = "UPDATE articles SET score=%s WHERE id=%s" args = [classification,aid] cur.execute(sql,args) print aid,classification conn.commit()
def __init__(self): self.learn = learn self.load = load self.learner = Learner() if self.load and os.path.isfile(learnerFile): self.learner.loadData(learnerFile) self.learner.newGame()
def main(args_list: list = []): parser = argparse.ArgumentParser() # parser.add_argument('--env-type', default='gridworld') parser.add_argument('--env-type', default='point_robot_sparse') # parser.add_argument('--env-type', default='cheetah_vel') # parser.add_argument('--env-type', default='ant_semicircle_sparse') args, rest_args = parser.parse_known_args(args_list) env = args.env_type # --- GridWorld --- if env == 'gridworld': args = args_gridworld.get_args(rest_args) # --- PointRobot --- elif env == 'point_robot_sparse': args = args_point_robot_sparse.get_args(rest_args) # --- Mujoco --- elif env == 'cheetah_vel': args = args_cheetah_vel.get_args(rest_args) elif env == 'ant_semicircle_sparse': args = args_ant_semicircle_sparse.get_args(rest_args) set_gpu_mode(torch.cuda.is_available()) if hasattr(args, 'save_buffer') and args.save_buffer: os.makedirs(args.main_save_dir, exist_ok=True) learner = Learner(args) learner.train()
def main(): # Setup logger logging.basicConfig(filename='log.txt', level=logging.INFO, format='%(asctime)s %(levelname)s : %(message)s', datefmt='%m/%d/%Y %H:%M:%S') logging.info('Running file : {}'.format(__file__)) # parse command line arguments parser = argparse.ArgumentParser() parser.add_argument('--seed', type=int, default=None, help='random seed') parser.add_argument('--save-to', type=str, C > default=None, help='name of a file to save') args = parser.parse_args() # get dataset dataset, test_dataset, emb_weights = get_dataset(min_freq=5, test_set=True) dataset.fields['review'].include_lengths = True # the above line adds a tensor with lengths of reviews in a batch, # so that we can pass batches to embeddingbag ds_train, ds_val = dataset.split(split_ratio=[0.9, 0.1]) if args.seed is not None: random.seed(args.randomseed) bs = 64 logging.info('Initialising the model with the embedding layer frozen.') model = Baseline_model(emb_weights.clone()).to(device) loss_fn = nn.CrossEntropyLoss().to(device) optimiser = AdamW(model.parameters(), weight_decay=1e-2) steps_per_cycle = (len(ds_train) // bs + 1) scheduler = CyclicLRDecay(optimiser, 1e-4, 1e-2, steps_per_cycle, 0.25, gamma_factor=0.80) learner = Learner(model, loss_fn, optimiser, scheduler, ds_train, ds_val, device) logging.info('Training') learner.train(epochs=6, bs=bs, grad_clip=(0.2, 0.4)) logging.info('Unfreezing the embedding layer') model.embedding.weight.requires_grad_(True) learner.train(epochs=5, bs=bs, grad_clip=(0.2, 0.4)) logging.info('--- Final statistics ---') logging.info('Training loss : {:.4f}, accuracy {:.4f}'.format( *validate(ds_train, loss_fn, model, bs))) logging.info('Test loss : {:.4f}, accuracy {:.4f}'.format( *validate(test_dataset, loss_fn, model, bs))) if args.save_to is not None: if not os.path.exists('models'): os.makedirs('models') logging.info('Model saved to: models/{}'.format(args['--save-to'])) torch.save(model.state_dict(), 'models/{}'.format(args['--save-to']))
def main(): #Initialize Game manipulator gm = GameManipulator() gm.findGamePosition() # Check for found game if (not gm.offset): print 'FAILED TO FIND GAME!' return gm.focusGame() # Initialize UI global_stop_event = threading.Event() # Init Learner learner = Learner(gm, 12, 4, 0.2) try: # Initialize UI and start the game UI(gm, learner, global_stop_event).run() except KeyboardInterrupt: global_stop_event.set() learner.interuptted = True # clear log file with open('/tmp/ui.log', 'w'): pass raise SystemExit
def __init__(self, args, config): """ :param args: """ super(Meta, self).__init__() # self.update_lr = args.update_lr self.meta_lr = args.meta_lr self.n_way = args.n_way self.k_spt = args.k_spt self.k_qry = args.k_qry self.task_num = args.task_num self.update_step = args.update_step self.update_step_test = args.update_step_test self.net = Learner(config, args.imgc, args.imgsz) self.update_lrs = nn.ParameterList([ nn.Parameter(args.update_lr * torch.ones(self.update_step, var.size(0)), requires_grad=True) for var in self.net.vars ]) self.meta_optim = optim.Adam(self.parameters(), lr=self.meta_lr) self.lr_scheduler = optim.lr_scheduler.ExponentialLR( self.meta_optim, 0.9)
def solve_task(task, max_steps=10, workspace=Path('/tmp'), verbose=1): model = Learner(model_config) # model = load_model(model, verbose) model = model.to(device) criterion = nn.CrossEntropyLoss() losses = np.zeros(fintune_epoch) optimizer = torch.optim.Adam(model.parameters(), lr=fintune_lr, weight_decay=weight_decay) best_loss = 1000 # task = data_augmentation(task) data_x = [torch.Tensor(inp2img(sample['input'])).unsqueeze(0).float().to(device) for sample in task] data_y = [torch.Tensor(np.array(sample['output'])).long().unsqueeze(0).to(device) for sample in task] for cur_epoch in range(fintune_epoch): loss = 0.0 for x, y in zip(data_x, data_y): # predict output from input y_pred = model(x) loss += criterion(y_pred, y) optimizer.zero_grad() loss.backward() optimizer.step() losses[cur_epoch] = loss.item() if best_loss > loss.item(): best_loss = loss.item() torch.save({'model': model.state_dict()}, workspace / 'best_model.pth') model.load_state_dict(torch.load(workspace / 'best_model.pth')['model']) return model, losses
def secondProposal(): print("secondProposal") processes = ['alpha', 'beta', 'gamma'] um = UniversalMessenger() m1 = MockMessenger('alpha', processes, um) m2 = MockMessenger('beta', processes, um) m3 = MockMessenger('gamma', processes, um) p1 = Proposer('alpha', processes, m1) p2 = Proposer('beta', processes, m2) p3 = Proposer('gamma', processes, m3) a1 = Acceptor(processes, m1) a2 = Acceptor(processes, m2) a3 = Acceptor(processes, m3) l1 = Learner(processes, m1) l2 = Learner(processes, m2) l3 = Learner(processes, m3) p1.prepare('ABC', 0) a1.promise(um.lastMessageToSite('alpha', 'prepare')) p1.receivePromise(um.lastMessageToSite('alpha', 'promise')) a2.promise(um.lastMessageToSite('beta', 'prepare')) p1.receivePromise(um.lastMessageToSite('alpha', 'promise')) a3.promise(um.lastMessageToSite('gamma', 'prepare')) p1.receivePromise(um.lastMessageToSite('alpha', 'promise')) a1.accept(um.lastMessageToSite('alpha', 'accept')) l1.receiveAccepted(um.lastMessageToSite('alpha', 'accepted')) l2.receiveAccepted(um.lastMessageToSite('beta', 'accepted')) l3.receiveAccepted(um.lastMessageToSite('gamma', 'accepted')) a2.accept(um.lastMessageToSite('beta', 'accept')) l1.receiveAccepted(um.lastMessageToSite('alpha', 'accepted')) l2.receiveAccepted(um.lastMessageToSite('beta', 'accepted')) l3.receiveAccepted(um.lastMessageToSite('gamma', 'accepted')) a3.accept(um.lastMessageToSite('gamma', 'accept')) l1.receiveAccepted(um.lastMessageToSite('alpha', 'accepted')) l2.receiveAccepted(um.lastMessageToSite('beta', 'accepted')) l3.receiveAccepted(um.lastMessageToSite('gamma', 'accepted')) p2.prepare('XYZ', 0) a1.promise(um.lastMessageToSite('alpha', 'prepare')) p2.receivePromise(um.lastMessageToSite('beta', 'promise')) a2.promise(um.lastMessageToSite('beta', 'prepare')) p2.receivePromise(um.lastMessageToSite('beta', 'promise')) a3.promise(um.lastMessageToSite('gamma', 'prepare')) p2.receivePromise(um.lastMessageToSite('beta', 'promise')) um.printMessages()
def main(): printer = Printer('log.txt') utils = Utils(printer) utils.setup_and_verify() utils.evaluate_baseline() learner = Learner(utils.learner_utils) learner.train_and_evaluate() utils.printer.print('finished!')
def main(argv): domain_path = argv[1] problem_path = argv[2] if argv[0] == "-L": agent = Learner() else: agent = MyExecutor() print LocalSimulator().run(domain_path, problem_path, agent)
def job(args, train_csv, test_csv, embeddings, cache): """ Reads data, makes preprocessing, trains model and records results. Gets args as argument and passes values of it's fields to functions.""" data = Data(train_csv, test_csv, cache) # read and preprocess data to_cache = not args.no_cache data.read_embedding(embeddings, args.unk_std, args.max_vectors, to_cache) data.preprocess(args.tokenizer, args.var_length) data.embedding_lookup() # split train dataset data_iter = data.split(args.kfold, args.split_ratio, args.stratified, args.test, args.seed) # iterate through folds loss_function = nn.BCEWithLogitsLoss() for fold, d in enumerate(data_iter): print(f'\n__________ fold {fold} __________') # get dataloaders if len(d) == 2: train, val = d test = data.test else: train, val, test = d dataloaders = iterate(train, val, test, args.batch_size) # train, val and test dataloader # choose model, optimizer, lr scheduler model = choose_model(args.model, data.text, args.n_layers, args.hidden_dim, args.dropout) optimizer = choose_optimizer(filter(lambda p: p.requires_grad, model.parameters()), args) scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lrstep, gamma=0.1) learn = Learner(model, dataloaders, loss_function, optimizer, scheduler, args) learn.fit(args.epoch, args.n_eval, args.f1_tresh, args.early_stop, args.warmup_epoch, args.clip) # load best model learn.model, info = learn.recorder.load() # save val predictions y_pred, y_true, ids = learn.predict_probs() val_ids = [data.qid.vocab.itos[i] for i in ids] pred_to_csv(val_ids, y_pred, y_true) # choose best threshold for val predictions best_th, max_f1 = choose_thresh(y_pred, y_true, [0.1, 0.5, 0.01], message=True) learn.recorder.append_info({'best_th': best_th, 'max_f1': max_f1}) # predict test labels test_label, test_prob,_, test_ids, tresh = learn.predict_labels(is_test=True, thresh=args.f1_tresh) if args.test: test_loss, test_f1, _, _, _ = learn.evaluate(learn.test_dl, args.f1_tresh) learn.recorder.append_info({'test_loss': test_loss, 'test_f1': test_f1}, message='Test set results: ') # save test predictions to submission.csv test_ids = [data.qid.vocab.itos[i] for i in test_ids] submit(test_ids, test_label, test_prob) record_path = learn.recorder.record(fold) # directory path with all records print('\n') return record_path
def _initActors(self): self.proposer = Proposer(self.servers, self.id) self.acceptor = Acceptor(self.servers, self.id) self.learner = Learner(self.servers, self.id) # load saved if os.path.isfile(self.stateFileName): print('Loading from:', self.stateFileName) self._loadState()
def train(conf): gan = KernelGAN(conf) learner = Learner() data = DataGenerator(conf, gan) for iteration in tqdm.tqdm(range(conf.max_iters), ncols=60): [g_in, d_in] = data.__getitem__(iteration) gan.train(g_in, d_in) learner.update(iteration, gan) gan.finish()
def evaluate(self, args): self.load(args) test_set = HBertMseEuopDataset(os.path.join(args.data_path, 'test.h5'), self.model.tokenizer) result, generated_text = Learner().run_eval(args, self.model, test_set) eval_output_dir = f"./output/{args.model}/{args.experiment_name}/" if args.local_rank in [-1, 0]: os.makedirs(eval_output_dir, exist_ok=True) with open(os.path.join(eval_output_dir, f"eval_results.txt"), 'w') as f_eval: f_eval.write(generated_text+'\n') return result
def createLearner(self): learner = Learner(self.port + 2, self.ips, self.ip, self.num) if not self.logging_switch: learner.logging(False) learner.log('starting') learner.listen() learner.log('exiting')
def estimate_kernel(img_file): conf = config_kernelGAN(img_file) kgan = KernelGAN(conf) learner = Learner() data = DataGenerator(conf, kgan) for iteration in tqdm.tqdm(range(conf.max_iters), ncols=70): [g_in, d_in, _] = data.__getitem__(iteration) kgan.train(g_in, d_in) learner.update(iteration, kgan) kgan.finish()
def __init__(self): super().__init__() # self.gv = gv self.learner = Learner() self.pg_layout = self.create_tab() self.tool_dock = self.create_settings_dock() self.create_open_settings_button() result_dock, self.training_plot = self.create_result_dock() self.create_test_unseen_data_dock(result_dock) self.lr = 0
def get_learner(self): return Learner( self.actor, self.critic, self.replay_buffer, num_learning_iterations=self.args.num_learning_iterations, episode_batch_size=self.args.episode_batch_size, use_gpu=self.use_gpu, continuous=True, writer=self.writer)
def train(conf): sr_net = DBPISR(conf) learner = Learner() data = DataGenerator(conf, sr_net) for iteration in tqdm.tqdm(range(conf.max_iters), ncols=60): g_in = data.__getitem__(iteration) sr_net.train(g_in) learner.update(iteration, sr_net) sr_net.finish(data.input_image)
def Learning_to_learn_global_training(f, optimizer, global_taining_steps, optimizer_Train_Steps, UnRoll_STEPS, Evaluate_period, optimizer_lr): """ Training the LSTM optimizer . Learning to learn Args: `optimizer` : DeepLSTMCoordinateWise optimizer model `global_taining_steps` : how many steps for optimizer training optimizer `optimizer_Train_Steps` : how many step for optimizer opimitzing each function sampled from IID. `UnRoll_STEPS` :: how many steps for LSTM optimizer being unrolled to construct a computing graph to BPTT. """ global_loss_list = [] Total_Num_Unroll = optimizer_Train_Steps // UnRoll_STEPS adam_global_optimizer = torch.optim.Adam(optimizer.parameters(), lr=optimizer_lr) LSTM_Learner = Learner(f, optimizer, UnRoll_STEPS, retain_graph_flag=True, reset_theta=True, reset_function_from_IID_distirbution=False) #这里考虑Batchsize代表IID的化,那么就可以不需要每次都重新IID采样 best_sum_loss = 999999 best_final_loss = 999999 best_flag = False for i in range(global_taining_steps): print('\n=============> global training steps: {}'.format(i)) for num in range(Total_Num_Unroll): start = timer() _, global_loss = LSTM_Learner(num) adam_global_optimizer.zero_grad() global_loss.backward() adam_global_optimizer.step() global_loss_list.append(global_loss.detach_()) time = timer() - start print( '--> time consuming [{:.4f}s] optimizer train steps : [{}] | Global_Loss = [{:.1f}]' .format(time, (num + 1) * UnRoll_STEPS, global_loss)) if (i + 1) % Evaluate_period == 0: best_sum_loss, best_final_loss, best_flag = evaluate( f, optimizer, best_sum_loss, best_final_loss, best_flag, optimizer_lr) return global_loss_list, best_flag