def write_add_format_advanced(moves, args, file=Params.STANDARD_GAME_FILE): """ Advanced format should contain informations like the board used, the model of the NN, the setup and time for the UTC... Current format : [player1],[player2],[winner]:[",".join([moves])] """ Params.prt("hex_game_manager.py", "Moves : " + str(moves)) Params.prt("hex_game_manager.py", "Args : " + str(args)) with open(file, "a") as mf: a = args["player1"] + "," + args["player2"] + "," + str( args["winner"]) + ":" ms = [] for m in moves: ms.append(positions_letter[m[1]] + positions_letter[m[2]]) a += ",".join(ms) + '\n' mf.write(a) if Params.GAME_SET_METHOD == "maximum": lines = [] with open(file, "r") as mf: lines = mf.readlines() if len(lines) > Params.MAXIMUM_GAMES_BATCH: lines.pop(0) with open(file, "w") as mf: for l in lines: mf.write(l)
def combo(self, num_agents_to_produce): agents = [] for _ in xrange(num_agents_to_produce): parents = self.get_parents(self.parents_to_combine) # create a new agent and its parameters new_aid = str(uuid.uuid4()) agents.append(new_aid) new_agent_params = Params(aid=new_aid, agent_dir=self.agent_dir) # randomly assign each parent weights parent_weights = [random.random() for _ in xrange(len(parents))] # iterate through all parent parameters, calculating a weighted average # as the new agent's parameter for param_index in xrange(len(parents[0].params)): new_param = np.zeros((parents[0].params[param_index].shape)) for i, p in enumerate(parents): new_param += parent_weights[i] * p.params[param_index] new_param /= sum(parent_weights) new_agent_params.params.append(new_param) new_agent_params.write_params() print "combo: %s, (%s) " % (new_aid, ','.join( [p.aid for p in parents])) return agents
def load_checkpoint(self, folder=Params.NN_CHECKPOINT_FOLDER, filename=Params.WORKING_CHECKPOINT_FILENAME): filepath = os.path.join(folder, filename) if not os.path.exists(filepath): Params.log("hex_ai.py", "No model in path {}".format(filepath)) else: self.nnet.model.load_weights(filepath)
def __init__(self, parent_agents=[], agent_dir="agent_params_nolimit"): self.agent_dir = agent_dir self.parent_agents = [] # insert in order of top-ranked parent agent to bottom agent for p in parent_agents: p_param = Params(aid=p, agent_dir=self.agent_dir) p_param.read_params() self.parent_agents.append(p_param) # calculate the parent probability of being chosen self.num_parents = len(parent_agents)
def play_move(self, move): if self.board_size > move[1] >= 0 and self.board_size > move[2] >= 0: if self.matrix[move[1]][move[2]] == 0: self.matrix[move[1]][move[2]] = move[0] self.moves_list.append(move) else: Params.log("hex_board.py", "Illegal move : " + str(move)) raise IllegalMove else: Params.log("hex_board.py", "Illegal move : " + str(move)) raise IllegalMove
def save_checkpoint(self, folder=Params.NN_CHECKPOINT_FOLDER, filename=Params.WORKING_CHECKPOINT_FILENAME): filepath = os.path.join(folder, filename) if not os.path.exists(folder): Params.log( "hex_ai.py", "Checkpoint Directory does not exist! Making directory {}". format(folder)) os.mkdir(folder) self.nnet.model.save_weights(filepath)
def load_config(self): logdir = self.exp_path + '/log/' cfg_filename = os.path.join(logdir, 'cfg-' + str(self.log_id - 1) + '-*.json') cfg_files = glob.glob(cfg_filename) cfg_files.sort(reverse=True) if len(cfg_files) == 0 or not os.path.isfile(cfg_files[0]): return None p = Params() if not p.load(cfg_files[0]): return None return p
def mutate(self, num_agents_to_produce): agents = [] for _ in xrange(num_agents_to_produce): parent = self.get_parents(1)[0] # create a new agent and its parameters new_aid = str(uuid.uuid4()) agents.append(new_aid) new_agent_params = Params(aid=new_aid, agent_dir=self.agent_dir) # randomly add noise to weights for param in parent.params: new_agent_params.params.append( param * (1 + 0.4 * np.random.normal(0, 1, 1))) new_agent_params.write_params() print "mutated: %s (%s)" % (new_aid, parent.aid) return agents
def init(train=1): #global settings if train==1: with open("configNetwork.json", 'r') as f: settings = json.load(f) #print(settings) if train==0: with open("configNetwork_eval.json", 'r') as f: settings = json.load(f) print(settings) return Params(**settings)
def crossover(self, num_agents_to_produce): agents = [] for _ in xrange(num_agents_to_produce): parents = self.get_parents(2) # create a new agent and its parameters new_aid = str(uuid.uuid4()) agents.append(new_aid) new_agent_params = Params(aid=new_aid, agent_dir=self.agent_dir) # randomize which parameters to take from which parents indices = range(len(parents[0].params)) for i, j in enumerate(indices): if i < len(parents[0].params) / 2: new_agent_params.params.append(parents[0].params[j]) else: new_agent_params.params.append(parents[1].params[j]) new_agent_params.write_params() print "crossover: %s (%s)" % (new_aid, ','.join( [p.aid for p in parents])) return agents
def init_agents(self): self.agents = [] noise = 0.001 for i in xrange(NUM_AGENTS): aid = str(uuid.uuid4()) initial_params = [] with np.load(os.path.join(AGENT_DIR, "initial-poker-params.npz")) as data: for i in range(len(data.keys())): initial_params.append(data["arr_%d" % i] + np.random.normal(0, noise, 1)[0]) agent_params = Params(aid=aid, agent_dir=AGENT_DIR, params_list=initial_params) self.agents.append(aid)
def main(): params = Params() config = params.opts dsr = LivedoorCorpusReader(config=config) # Loading Datasets train, dev, test = dsr._read('train'), dsr._read('dev'), dsr._read('test') train_and_dev = train + dev vocab = build_vocab(train_and_dev) num_label = len(dsr.class2id) train_loader, dev_loader, test_loader = build_data_loaders(config, train, dev, test) train_loader.index_with(vocab) dev_loader.index_with(vocab) _, __, embedder = emb_returner(config=config) mention_encoder = Pooler_for_mention(config, embedder) model = TitleAndCaptionClassifier(config, mention_encoder, num_label, vocab) trainer = build_trainer(config, model, train_loader, dev_loader) trainer.train() # Evaluation model.eval() test_loader.index_with(model.vocab) eval_result = evaluate(model=model, data_loader=test_loader, cuda_device=0, batch_weight_key="") print(eval_result) # Dump train and dev document to article embeddings embedding_encoder = EmbeddingEncoder(model, dsr) emb_dumper = ArticleKB(model=model, dsr=dsr, config=config) mention_idx2emb = emb_dumper.mention_idx2emb # load kb article_kb_class = ArticleTitleIndexerWithFaiss( config=config, mention_idx2emb=mention_idx2emb, dsr=dsr, kbemb_dim=768 ) top_titles = article_kb_class.search_with_emb( emb=emb_dumper.predictor.predict('iPhoneとパソコン')['encoded_embeddings']) print(top_titles) return article_kb_class, emb_dumper
class PmcAbc(object): def __init__(self, data, simulator, prior_dict = {}, N = 1000, eps0 = 0.01, T = 20, Nthreads = 10): """ Class taht describes PMC-ABC """ self.data = data self.N = N self.eps0 = eps0 self.T = T self.Nthreads = Nthreads # simulator function has to be a function of theta_star self.simz = simulator self.prior_param(param_dict = prior_dict) # first run prior parameters def prior_param(self, param_dict={}): """ Pass priors of parameters in theta """ self.param_obj = Params(param_dict) # parameter object self.param_names = param_dict.keys() self.n_params = len(param_dict.keys()) # number of parameters in theta def priors_sample(self): """ Sample from priors derived from parameter object """ theta_star = np.zeros(self.n_params) for i in xrange(self.n_params): np.random.seed() theta_star[i] = self.param_obj.prior()[i].rvs(size=1)[0] return theta_star def prior_of_priors(self, tt): """ Multiply priors of multile dimensions p(theta) = p(theta_0) * p(theta_1) * ... * p(theta_n_params) """ for i in xrange(self.n_params): try: p_theta *= self.param_obj.prior()[i].pdf(tt[i]) except UnboundLocalError: p_theta = self.param_obj.prior()[i].pdf(tt[i]) return p_theta def initial_sampling(self, params): """Wrapper for parallelized initial pool sampling """ i = params theta_star = self.priors_sample() model = self.simz( theta_star ) rho = test_dist(self.data, model) while rho > self.eps0: theta_star = self.priors_sample() model = self.simz( theta_star ) rho = test_dist(self.data, model) data_list = [np.int(i)] for i_param in xrange(self.n_params): data_list.append(theta_star[i_param]) data_list.append(1./np.float(self.N)) data_list.append(rho) return np.array(data_list) def initial_pool(self): """ Creating the initial pool """ self.t = 0 self.theta_t = np.zeros((self.n_params, self.N)) self.w_t = np.zeros((self.N)) self.rhos = np.zeros((self.N)) #pool = InterruptiblePool(self.Nthreads) #mapfn = pool.map args_list = [(i) for i in xrange(self.N)] results = [] for arg in args_list: print self.initial_sampling(arg) results.append(self.initial_sampling(arg)) #unwrap_self_initial_sampling(zip([self]*len(args_list), args_list)[0]) #results = mapfn(unwrap_self_initial_sampling, zip([self]*len(args_list), args_list)) #pool.close() #pool.terminate() #pool.join() print 'Initial Pool Complete' pars = np.array(results).T self.theta_t = pars[1:self.n_params+1,:] self.w_t = pars[self.n_params+1,:] self.rhos = pars[self.n_params+2,:] self.sig_t = 2.0 * np.cov( self.theta_t ) # covariance matrix self.writeout() self.plotout() return np.array(self.rhos) def importance_sampling(self, params): """ Wrapper for parallelized importance sampling """ i_part = params theta_star = weighted_sampling( self.theta_t_1, self.w_t_1 ) np.random.seed() theta_starstar = multivariate_normal( theta_star, self.sig_t_1 ).rvs(size=1) model_starstar = self.simz( theta_starstar ) rho = test_dist(self.data, model_starstar) while rho > self.eps_t: theta_star = weighted_sampling( self.theta_t_1, self.w_t_1 ) theta_starstar = multivariate_normal(theta_star, self.sig_t_1).rvs(size=1) model_starstar = self.simz( theta_starstar ) rho = test_dist(self.data, model_starstar) p_theta = self.prior_of_priors(theta_starstar) pos_t = np.dstack(self.theta_t_1) tmp_w_t = p_theta / np.sum(self.w_t_1 * multivariate_normal(self.theta_t[:,i_part], self.sig_t_1).pdf(pos_t)) data_list = [np.int(i_part)] for i_param in xrange(self.n_params): data_list.append(theta_starstar[i_param]) data_list.append(tmp_w_t) data_list.append(rho) return np.array(data_list) def pmc_abc(self): """ """ self.rhos = self.initial_pool() while self.t < self.T: self.eps_t = np.percentile(self.rhos, 75) print 'Epsilon t', self.eps_t self.theta_t_1 = self.theta_t.copy() self.w_t_1 = self.w_t.copy() self.sig_t_1 = self.sig_t.copy() pool = InterruptiblePool(self.Nthreads) mapfn = pool.map args_list = [ i for i in xrange(self.N) ] results = mapfn(unwrap_self_importance_sampling, zip([self]*len(args_list), args_list)) pool.close() pool.terminate() pool.join() pars = np.array(results).T self.theta_t = pars[1:self.n_params+1,:].copy() self.w_t = pars[self.n_params+1,:].copy() self.rhos = pars[self.n_params+2,:].copy() self.sig_t = 2.0 * np.cov(self.theta_t) self.t += 1 self.writeout() self.plotout() return None def writeout(self): """ Write out theta_t and w_t """ out_file = ''.join(['theta_w_t', str(self.t), '.dat']) data_list = [] for i in xrange(self.n_params): data_list.append( self.theta_t[i,:] ) data_list.append(self.w_t) np.savetxt( out_file, (np.vstack(np.array(data_list))).T, delimiter='\t' ) return None def plotout(self, plot_type = 'seabreeze'): """ Triangle plot the things """ if plot_type == 'seabreeze': figure = sns.jointplot(x = self.theta_t[0,:], y = self.theta_t[1,:], kind = 'kde', style = 'white', weights = self.w_t, xlim = [-1.0, 1], ylim = [0.0, 2.0] ) plt.savefig("seabreeze_theta_t"+str(self.t)+".png") plt.close() elif plot_type == 'triangle': # Clunky based on which version of corner.py you have # Clunky based on which version of corner.py you have # Clunky based on which version of corner.py you have # Clunky based on which version of corner.py you have figure = triangle.corner( (self.theta_t).T, labels = self.param_names, weights = self.w_t, show_titles=True, title_args={"fontsize": 12}, smooth=False ) figure.gca().annotate( str(self.t), xy=(0.5, 1.0), xycoords="figure fraction", xytext=(0, -5), textcoords="offset points", ha="center", va="top" ) figure.savefig("triangle_theta_t"+str(self.t)+".png") plt.close() elif plot_type == 'scatter': if len(self.theta_t[:,0]) != 2: warnings.warn("Can only plot two axes on scatter plot. No plot generated") return figure = plt.figure(1) sub = figure.add_subplot(111) sub.scatter(self.theta_t[0,:], self.theta_t[1,:]) sub.set_xlim([-1.0, 1.0]) sub.set_ylim([0.8, 1.5]) figure.savefig("scatter_theta_t"+str(self.t)+".png") plt.close()
return self.bert_tokenizer.tokenize(txt) def bert_model_and_vocab_downloader(self): if not os.path.exists('./japanese-bert/'): os.mkdir('./japanese-bert/') print('=== Downloading japanese-bert ===') # https://huggingface.co/cl-tohoku/bert-base-japanese urllib.request.urlretrieve( "https://huggingface.co/cl-tohoku/bert-base-japanese/raw/main/config.json", './japanese-bert/config.json') urllib.request.urlretrieve( "https://huggingface.co/cl-tohoku/bert-base-japanese/raw/main/pytorch_model.bin", './japanese-bert/pytorch_model.bin') urllib.request.urlretrieve( "https://huggingface.co/cl-tohoku/bert-base-japanese/raw/main/config.json", './japanese-bert/config.json') urllib.request.urlretrieve( "https://huggingface.co/cl-tohoku/bert-base-japanese/raw/main/tokenizer_config.json", './japanese-bert/tokenizer_config.json') if not os.path.exists('./vocab_file/'): os.mkdir('./vocab_file/') urllib.request.urlretrieve( "https://huggingface.co/cl-tohoku/bert-base-japanese/raw/main/vocab.txt", './vocab_file/vocab.txt') if __name__ == '__main__': config = Params() params = config.opts tokenizer = CustomTokenizer(config=params)
'r': r, 'label': label }}) if train_dev_test_flag == 'train': train_mention_ids.append(mention_id) elif train_dev_test_flag == 'dev': dev_mention_ids.append(mention_id) elif train_dev_test_flag == 'test': test_mention_ids.append(mention_id) except: print('Parse Error:', line.strip()) continue if self.config.debug: if idx == self.config.debug_sample_num: break # if self.config.debug: # # only for debugging model # dev_mention_ids = copy.copy(train_mention_ids) # test_mention_ids = copy.copy(train_mention_ids) return train_mention_ids, dev_mention_ids, test_mention_ids, mention_id2data if __name__ == '__main__': params = Params() config = params.opts dsr = NamedEntityResolutionReader(config=config) dsr._read('train')
def add_batch_file(self): player = Params.FIRST_PLAYER i = 0 error_count = 0 while i < Params.NUMBER_GAMES_BATCH: try: b = HexBoard() moves = [] w = 0 j = 0 expansions = [] rollouts = [] ended = [] start = time.time() while w == 0: m, infos = self.uct.next_turn(b, player) expansions.append(infos["expansions"]) rollouts.append(infos["rollouts"]) ended.append(infos["ended"]) player = Params.get_next_player(player) moves.append(m) b.play_move(m) b.find_if_winner(m) w = b.winner() j += 1 Params.ongoing() end = time.time() Params.end_ongoing() Params.log( "hex_coach.py", "Match : " + str(i + 1) + "/" + str(Params.NUMBER_GAMES_BATCH) + " - " + str(end - start) + " sec") Params.log("hex_coach.py", "Winner : " + str(w)) Params.log("hex_coach.py", "Moves (" + str(len(moves)) + ") : " + str(moves)) Params.log("hex_coach.py", "Expansions : " + str(expansions)) Params.log("hex_coach.py", "Rollouts : " + str(rollouts)) Params.log("hex_coach.py", "Ended : " + str(ended)) Params.log("hex_coach.py", "Matrix : \n" + str(b.get_copy_matrix())) args = {"player1": "cnn", "player2": "cnn", "winner": str(w)} HexGameManager.write_add_format_advanced( moves, args, Params.STANDARD_GAME_FILE) i += 1 HexCoach.rii = Params.RII_PARAMETER * HexCoach.rii + ( 1 - Params.RII_PARAMETER) * w except Exception: traceback.print_exc() time.sleep(0.1) Params.log("hex_coach.py", "Failure when creating game") error_count += 1 if error_count >= Params.SAVING_FROM_CONVERGENCE_TO_ERROR: raise ConvNetUnableToProduceGame
} def mention_preprocesseddir_for_each_world_makedir(self): for world in ALL_WORLDS: formention_preprocessing_each_world_dir = self.args.mentions_splitbyworld_dir + world + '/' if not os.path.exists(formention_preprocessing_each_world_dir): os.mkdir(formention_preprocessing_each_world_dir) def allworlds_loader(self): ''' :return: allworlds_dui2rawtext.json ''' world_2_dui2rawtext = {} for world in ALL_WORLDS: path_for_dui2rawtext = self.args.dir_for_each_world + world + '/' + 'dui2desc_raw.json' dui2raw = simplejopen(json_file_path=path_for_dui2rawtext) world_2_dui2rawtext.update({world: dui2raw}) return world_2_dui2rawtext if __name__ == '__main__': P = Params() opts = P.opts t = OneWorldParser(args=opts) for world in ALL_WORLDS: t.from_oneworld_dump_preprocessed_world(world_name=world) mp = MentionParser(args=opts) for flag in ["train", "dev", "test"]: mp.train_or_dev_or_test_2_eachworld_splitter(train_dev_testflag=flag)
def main(): print("===experiment starts===") exp_start_time = time.time() P = Params() opts = P.opts experiment_logdir = experiment_logger(args=opts) print("experiment_logdir:", experiment_logdir) P.dump_params(experiment_dir=experiment_logdir) cuda_devices = cuda_device_parser(str_ids=opts.cuda_devices) TRAIN_WORLDS, DEV_WORLDS, TEST_WORLDS = worlds_loader(args=opts) vocab = Vocabulary() iterator_for_training_and_evaluating_mentions = BucketIterator( batch_size=opts.batch_size_for_train, sorting_keys=[('context', 'num_tokens')]) iterator_for_training_and_evaluating_mentions.index_with(vocab) embloader = EmbLoader(args=opts) emb_mapper, emb_dim, textfieldEmbedder = embloader.emb_returner() tokenIndexing = TokenIndexerReturner(args=opts) global_tokenizer = tokenIndexing.berttokenizer_returner() global_tokenIndexer = tokenIndexing.token_indexer_returner() if opts.load_from_checkpoint: mention_encoder, entity_encoder, model = load_model_objects( model_path=opts.model_path, mention_encoder_filename=opts.mention_encoder_filename, entity_encoder_filename=opts.entity_encoder_filename, model_filename=opts.model_filename) else: mention_encoder = Pooler_for_mention(args=opts, word_embedder=textfieldEmbedder) entity_encoder = Pooler_for_title_and_desc( args=opts, word_embedder=textfieldEmbedder) model = Biencoder(args=opts, mention_encoder=mention_encoder, entity_encoder=entity_encoder, vocab=vocab) model = model.cuda() optimizer = optim.Adam(filter(lambda param: param.requires_grad, model.parameters()), lr=opts.lr, eps=opts.epsilon, weight_decay=opts.weight_decay, betas=(opts.beta1, opts.beta2), amsgrad=opts.amsgrad) devEvalEpochs = [j for j in range(1, 1000)] if opts.add_hard_negatives else \ [1, 3, 5] + [k * 10 for k in range(1, 100)] for epoch in range(opts.num_epochs): oneep_train_start = time.time() for world_name in TRAIN_WORLDS: reader = WorldsReader(args=opts, world_name=world_name, token_indexers=global_tokenIndexer, tokenizer=global_tokenizer) if opts.add_hard_negatives: with torch.no_grad(): mention_encoder.eval(), entity_encoder.eval() hardNegativeSearcher = HardNegativesSearcherForEachEpochStart( args=opts, world_name=world_name, reader=reader, embedder=textfieldEmbedder, mention_encoder=mention_encoder, entity_encoder=entity_encoder, vocab=vocab, berttokenizer=global_tokenizer, bertindexer=global_tokenIndexer) hardNegativeSearcher.hardNegativesSearcherandSetter() trains = reader.read('train') mention_encoder.train(), entity_encoder.train() trainer = Trainer( model=model, optimizer=optimizer, iterator=iterator_for_training_and_evaluating_mentions, train_dataset=trains, cuda_device=cuda_devices, num_epochs=1) trainer.train() if epoch + 1 in devEvalEpochs: print('\n===================\n', 'TEMP DEV EVALUATION@ Epoch', epoch + 1, '\n===================\n') t_entire_h1c, t_entire_h10c, t_entire_h50c, t_entire_h64c, t_entire_h100c, t_entire_h500c, t_entire_datapoints \ = oneLineLoaderForDevOrTestEvaluation( dev_or_test_flag='dev', opts=opts, global_tokenIndexer=global_tokenIndexer, global_tokenizer=global_tokenizer, textfieldEmbedder=textfieldEmbedder, mention_encoder=mention_encoder, entity_encoder=entity_encoder, vocab=vocab, experiment_logdir=experiment_logdir, finalEvalFlag=0, trainEpoch=epoch+1) result = oneLineLoaderForDevOrTestEvaluationRawData( dev_or_test_flag='dev', opts=opts, global_tokenIndexer=global_tokenIndexer, global_tokenizer=global_tokenizer, textfieldEmbedder=textfieldEmbedder, mention_encoder=mention_encoder, entity_encoder=entity_encoder, vocab=vocab, experiment_logdir=experiment_logdir, finalEvalFlag=0, trainEpoch=epoch + 1) devEvalExperimentEntireDevWorldLog(experiment_logdir, t_entire_h1c, t_entire_h10c, t_entire_h50c, t_entire_h64c, t_entire_h100c, t_entire_h500c, t_entire_datapoints, epoch=epoch) devEvalExperimentEntireDevWorldLogRawData(experiment_logdir, result, epoch=epoch) oneep_train_end = time.time() print('epoch {0} train time'.format(epoch + 1), oneep_train_end - oneep_train_start, 'sec') if opts.save_checkpoints: save_model_objects( model_object=model, mention_encoder_object=mention_encoder, entity_encoder_object=entity_encoder, model_path=experiment_logdir, mention_encoder_filename=opts.mention_encoder_filename, entity_encoder_filename=opts.entity_encoder_filename, model_filename=opts.model_filename, epoch=epoch) print('====training finished=======') with torch.no_grad(): model.eval() print('===FINAL Evaluation starts===') for dev_or_test_flag in ['dev', 'test']: print('\n===================\n', dev_or_test_flag, 'EVALUATION', '\n===================\n') entire_h1c, entire_h10c, entire_h50c, entire_h64c, entire_h100c, entire_h500c, entire_datapoints \ = oneLineLoaderForDevOrTestEvaluation(dev_or_test_flag=dev_or_test_flag, opts=opts, global_tokenIndexer=global_tokenIndexer, global_tokenizer=global_tokenizer, textfieldEmbedder=textfieldEmbedder, mention_encoder=mention_encoder, entity_encoder=entity_encoder, vocab=vocab, experiment_logdir=experiment_logdir, finalEvalFlag=1, trainEpoch=-1) result \ = oneLineLoaderForDevOrTestEvaluationRawData(dev_or_test_flag=dev_or_test_flag, opts=opts, global_tokenIndexer=global_tokenIndexer, global_tokenizer=global_tokenizer, textfieldEmbedder=textfieldEmbedder, mention_encoder=mention_encoder, entity_encoder=entity_encoder, vocab=vocab, experiment_logdir=experiment_logdir, finalEvalFlag=1, trainEpoch=-1) dev_or_test_finallog( entire_h1c, entire_h10c, entire_h50c, entire_h64c, entire_h100c, entire_h500c, entire_datapoints, dev_or_test_flag, experiment_logdir, ) dev_or_test_finallog_rawdata(result, experiment_logdir, dev_or_test_flag) exp_end_time = time.time() print('===experiment finised', exp_end_time - exp_start_time, 'sec') print(experiment_logdir)
def trainAI(self, checkpoint=Params.TAKE_FROM_CHECKPOINT): j = 0 if checkpoint: try: infos = self.get_last_valid_checkpoint_name() if infos is not None: self.ai.load_checkpoint(filename=infos["full"]) self.training_calls = infos["iters"] Params.prt("hex_coach.py", "Checkpoint Loaded : " + infos["full"]) except: Params.log("hex_coach.py", "Unable to open the checkpoint") while True: try: if Params.GAME_SET_METHOD is "reset": if j % Params.RESET_GAMES_AFTER_BATCH is 0: import os if os.path.isfile(Params.STANDARD_GAME_FILE): os.remove(Params.STANDARD_GAME_FILE) Params.prt("hex_coach.py", "Games removed") except Exception: traceback.print_exc() Params.log("hex_coach.py", "Impossible to remove previous games") try: self.add_batch_file() except Exception: traceback.print_exc() Params.log("hex_coach.py", "Impossible to add Files") try: self.launch_train() except Exception: traceback.print_exc() Params.log("hex_coach.py", "Impossible to train the neural network") try: self.check_infos_size_and_save() except Exception: traceback.print_exc() Params.log("hex_coach.py", "Impossible to check the infos") j += 1 try: Params.log( "hex_coach.py", "Round " + str(j + 1) + " (round " + str(j % Params.RESET_GAMES_AFTER_BATCH + 1) + "/" + str(Params.RESET_GAMES_AFTER_BATCH) + ", average winner : " + str(HexCoach.average_winner[-1]) + ", number of moves : " + str(HexCoach.average_number_moves[-1]) + ", number of learning iter : " + str(self.training_calls) + ", rii : " + str(HexCoach.rii) + ")") HexCoach.riis.append(HexCoach.rii) except: traceback.print_exc() Params.log("hex_coach.py", "Impossible to view round work")
def run(): nns = { "cnn525": { "nn": [ "check_b7x7v2_v1_v2_375.pth.tar", "check_b7x7v2_v1_v2_450.pth.tar", "check_b7x7v2_v1_v2_525.pth.tar", "check_b7x7v2_v1_v2_600.pth.tar", "check_b7x7v2_v1_v2_675.pth.tar" ], "id": 186 }, "cnn1050": { "nn": [ "check_b7x7v2_v1_v2_900.pth.tar", "check_b7x7v2_v1_v2_975.pth.tar", "check_b7x7v2_v1_v2_1050.pth.tar", "check_b7x7v2_v1_v2_1125.pth.tar", "check_b7x7v2_v1_v2_1200.pth.tar" ], "id": 180 }, "cnn1500": { "nn": [ "check_b7x7v2_v1_v2_1350.pth.tar", "check_b7x7v2_v1_v2_1425.pth.tar", "check_b7x7v2_v1_v2_1500.pth.tar", "check_b7x7v2_v1_v2_1575.pth.tar", "check_b7x7v2_v1_v2_1650.pth.tar" ], "id": 187 }, "cnn2025": { "nn": [ "check_b7x7v2_v1_v2_1875.pth.tar", "check_b7x7v2_v1_v2_1950.pth.tar", "check_b7x7v2_v1_v2_2025.pth.tar", "check_b7x7v2_v1_v2_2100.pth.tar", "check_b7x7v2_v1_v2_2175.pth.tar" ], "id": 181 }, "cnn2550": { "nn": [ "check_b7x7v2_v1_v2_2400.pth.tar", "check_b7x7v2_v1_v2_2475.pth.tar", "check_b7x7v2_v1_v2_2550.pth.tar", "check_b7x7v2_v1_v2_2625.pth.tar", "check_b7x7v2_v1_v2_2700.pth.tar" ], "id": 188 }, "cnn3000": { "nn": [ "check_b7x7v2_v1_v2_2850.pth.tar", "check_b7x7v2_v1_v2_2925.pth.tar", "check_b7x7v2_v1_v2_3000.pth.tar", "check_b7x7v2_v1_v2_3075.pth.tar", "check_b7x7v2_v1_v2_3150.pth.tar" ], "id": 182 }, "cnn3525": { "nn": [ "check_b7x7v2_v1_v2_3375.pth.tar", "check_b7x7v2_v1_v2_3450.pth.tar", "check_b7x7v2_v1_v2_3525.pth.tar", "check_b7x7v2_v1_v2_3600.pth.tar", "check_b7x7v2_v1_v2_3675.pth.tar" ], "id": 189 }, "cnn4050": { "nn": [ "check_b7x7v2_v1_v2_3900.pth.tar", "check_b7x7v2_v1_v2_3975.pth.tar", "check_b7x7v2_v1_v2_4050.pth.tar", "check_b7x7v2_v1_v2_4125.pth.tar", "check_b7x7v2_v1_v2_4200.pth.tar" ], "id": 183 }, "cnn4500": { "nn": [ "check_b7x7v2_v1_v2_4350.pth.tar", "check_b7x7v2_v1_v2_4425.pth.tar", "check_b7x7v2_v1_v2_4500.pth.tar", "check_b7x7v2_v1_v2_4575.pth.tar", "check_b7x7v2_v1_v2_4650.pth.tar" ], "id": 190 }, "cnn5025": { "nn": [ "check_b7x7v2_v1_v2_4875.pth.tar", "check_b7x7v2_v1_v2_4950.pth.tar", "check_b7x7v2_v1_v2_5025.pth.tar", "check_b7x7v2_v1_v2_5100.pth.tar", "check_b7x7v2_v1_v2_5175.pth.tar" ], "id": 184 }, "cnn5550": { "nn": [ "check_b7x7v2_v1_v2_5400.pth.tar", "check_b7x7v2_v1_v2_5475.pth.tar", "check_b7x7v2_v1_v2_5550.pth.tar", "check_b7x7v2_v1_v2_5625.pth.tar", "check_b7x7v2_v1_v2_5700.pth.tar" ], "id": 191 }, "cnn6000": { "nn": [ "check_b7x7v2_v1_v2_5850.pth.tar", "check_b7x7v2_v1_v2_5925.pth.tar", "check_b7x7v2_v1_v2_6000.pth.tar", "check_b7x7v2_v1_v2_6075.pth.tar", "check_b7x7v2_v1_v2_6150.pth.tar" ], "id": 185 } } for n in nns.keys(): if nns[n]["id"] < 0: r = requests.post("http://127.0.0.1:9080/player/") j = json.loads(r.text) print(j) nns[n]["id"] = j["id_player"] with open("checkpoint/api_id.txt", "a") as p: p.write(str(n) + ":" + str(nns[n]["id"]) + "\n") i = 0 while True: try: c = nns.copy() j1 = random.choice(list(c)) del c[j1] j2 = random.choice(list(c)) ai1 = HexIA() v1 = random.choice(nns[j1]["nn"]) ai1.load_checkpoint(filename=v1) print(str(ai1.nnet.summary())) ai2 = HexIA() v2 = random.choice(nns[j2]["nn"]) ai1.load_checkpoint(filename=v2) uct1 = UCT(ai1) uct2 = UCT(ai2) b = HexBoard() player = Params.FIRST_PLAYER w = 0 expansions = [] rollouts = [] while w == 0: if player == Params.FIRST_PLAYER: m, infos = uct1.next_turn(b, player) else: m, infos = uct2.next_turn(b, player) player = Params.get_next_player(player) b.play_move(m) b.find_if_winner(m) w = b.winner() Params.ongoing() expansions.append(infos["expansions"]) rollouts.append(infos["rollouts"]) js = { "id_player_1": int(nns[j1]["id"]), "id_player_2": int(nns[j2]["id"]), "moves": "none", "winner": w, } requests.post("http://127.0.0.1:9080/game", json=json.dumps(js)) print(requests.get("http://127.0.0.1:9080/players").text) print( str(i) + " : " + str(j1) + " vs " + str(j2) + " -> " + str(w)) print("Expansions - " + str(expansions)) print("Rollouts - " + str(rollouts)) i += 1 b = HexBoard() player = Params.FIRST_PLAYER w = 0 expansions = [] rollouts = [] while w == 0: if player == Params.FIRST_PLAYER: m, infos = uct2.next_turn(b, player) else: m, infos = uct1.next_turn(b, player) player = Params.get_next_player(player) b.play_move(m) b.find_if_winner(m) w = b.winner() Params.ongoing() expansions.append(infos["expansions"]) rollouts.append(infos["rollouts"]) js = { "id_player_1": int(nns[j2]["id"]), "id_player_2": int(nns[j1]["id"]), "moves": "none", "winner": w, } requests.post("http://127.0.0.1:9080/game", json=json.dumps(js)) print(requests.get("http://127.0.0.1:9080/players").text) print( str(i) + " : " + str(j2) + " vs " + str(j1) + " -> " + str(w)) print("Expansions - " + str(expansions)) print("Rollouts - " + str(rollouts)) i += 1 except: traceback.print_exc()
def prior_param(self, param_dict={}): """ Pass priors of parameters in theta """ self.param_obj = Params(param_dict) # parameter object self.param_names = param_dict.keys() self.n_params = len(param_dict.keys()) # number of parameters in theta
def S_DNN(self, patience=50, anneal=(0.5, 1.0), lambda_e0=(0.0, 5.0), lambda_s=(0.0, 10.0)): """ Only Shrodinger loss and only on training set. """ param = Params() param.data_params['data_path'] = self.data_path # set patience to 500 to give best potential to all models when doing hyper-parameter search param.train_params['early_stopping'] = { 'patience': patience, 'verbose': False, 'delta': 0 } param.train_params['cyclical'] = {} # cyclical learning rate # coefficient for energy loss and shrodinger loss param.loss_params['anneal_interval'] = 10 param.loss_params['anneal_factor'] = np.random.uniform(low=anneal[0], high=anneal[1]) param.loss_params['lambda_e0'] = np.random.uniform(low=lambda_e0[0], high=lambda_e0[1]) param.loss_params['lambda_s'] = np.random.uniform(low=lambda_s[0], high=lambda_s[1]) # for coefficient of the shrodinger loss param.loss_params['noise'] = {} # noisy coefficient param.loss_params['cyclical'] = {} # cyclical coefficient # loss function for NSE-DNNex-LB (label free) param.loss_params['norm_wf'] = False param.train_params['train_loss'] = [ 'mse_loss', 'phy_loss', ] param.train_params['test_loss'] = [] return param
import numpy as np import random import copy from collections import namedtuple, deque from model import Actor, Critic from parameters import Params import torch import torch.nn.functional as F import torch.optim as optim """ Set parameters, see parameters.py """ params = Params() # instantiate parameters BUFFER_SIZE = params.BUFFER_SIZE BATCH_SIZE = params.BATCH_SIZE GAMMA = params.GAMMA TAU = params.TAU LR_ACTOR = params.LR_ACTOR FC1_UNITS_ACTOR = params.FC1_UNITS_ACTOR FC2_UNITS_ACTOR = params.FC2_UNITS_ACTOR FC1_UNITS_CRITIC = params.FC1_UNITS_CRITIC FC2_UNITS_CRITIC = params.FC2_UNITS_CRITIC LR_CRITIC = params.LR_CRITIC WEIGHT_DECAY = params.WEIGHT_DECAY device = params.DEVICE print(device)
def pmc_abc(data, N = 1000, eps0 = 0.01, T = 20 ): start_time = time.time() toolz = Params({ 'mu': {'shape': 'gauss', 'mean': .0, 'stddev': 1.0}, 'sigma': { 'shape': 'uniform', 'min': 0.0, 'max': 2.0} }) t = 0 theta_t = np.zeros((2, N)) w_t = np.zeros((N)) for i in xrange(N): theta_star = np.zeros(2) theta_star[0] = toolz.prior()[0].rvs(size=1)[0] theta_star[1] = toolz.prior()[1].rvs(size=1)[0] #print theta_star model = toolz.simulator( theta_star ) rho = test_dist(data[1], model(data[0])) while rho > eps0: theta_star[0] = toolz.prior()[0].rvs(size=1)[0] theta_star[1] = toolz.prior()[1].rvs(size=1)[0] model = toolz.simulator( theta_star ) rho = test_dist(data[1], model(data[0])) theta_t[:,i] = theta_star w_t[i] = 1.0/np.float(N) sig_t = 2.0 * np.cov( theta_t ) # covariance matrix print sig_t # write out np.savetxt( ''.join(['theta_w_t', str(t), '.dat']), np.c_[theta_t[0,:], theta_t[1,:], w_t ] ) print 'Initial Pool ', time.time() - start_time fig = plt.figure(1) sub = fig.add_subplot(111) sub.scatter( theta_t[0,:], theta_t[1,:], alpha = 1. , color = 'b' ) #s = 10.**10.*w_t/w_t.sum() , sub.set_xlim([-2. , 2.]) sub.set_ylim([ 0. , 2.]) sub.set_xlabel(r'$\mu$') sub.set_ylabel(r'$\sigma$') plt.savefig("theta_scatter"+str(t)+".png") plt.close() start_time = time.time() while t < T: eps_t = np.percentile(rho, 75) print 'Epsilon t', eps_t theta_t_1 = theta_t.copy() w_t_1 = w_t.copy() sig_t_1 = sig_t.copy() for i in xrange(N): start_time = time.time() theta_star = weighted_sampling( theta_t_1, w_t_1 ) theta_starstar = multivariate_normal( theta_star, sig_t_1 ).rvs(size=1) while theta_starstar[1] < 0 : theta_star = weighted_sampling( theta_t_1, w_t_1 ) theta_starstar = multivariate_normal(theta_star, sig_t_1).rvs(size=1) #print theta_starstar model_starstar = toolz.simulator( theta_starstar ) rho = test_dist(data[1], model_starstar(data[0])) while rho > eps_t: theta_star = weighted_sampling( theta_t_1, w_t_1 ) theta_starstar = multivariate_normal(theta_star, sig_t_1).rvs(size=1) while theta_starstar[1] < 0 : theta_star = weighted_sampling( theta_t_1, w_t_1 ) theta_starstar = multivariate_normal(theta_star, sig_t_1).rvs(size=1) #print theta_starstar model_starstar = toolz.simulator( theta_starstar ) rho = test_dist(data[1], model_starstar(data[0])) #print theta_star, theta_starstar theta_t[:,i] = theta_starstar #print sig_t_1 p_theta = toolz.prior()[0].pdf(theta_t[0,i]) * toolz.prior()[1].pdf(theta_t[1,i]) #print p_theta pos_t = np.dstack((theta_t_1[0,:],theta_t_1[1,:])) #print multivariate_normal(theta_t[:,i], sig_t_1).pdf(pos_t).shape , w_t_1.shape w_t[i] = p_theta / np.sum(w_t_1 * multivariate_normal(theta_t[:,i], sig_t_1).pdf(pos_t)) #print test_dist(data[1], model_starstar(data[0])), w_t[i] #print 'For loop ', time.time() - start_time sig_t = 2.0 * np.cov(theta_t) t += 1 fig = plt.figure(1) sub = fig.add_subplot(111) sub.scatter( theta_t[0,:], theta_t[1,:], alpha = 0.5 ) # s = w_t/w_t.sum() , sub.set_xlim([-2. , 2.]) sub.set_ylim([ 0. , 2.]) sub.set_xlabel(r'$\mu$') sub.set_ylabel(r'$\sigma$') plt.savefig("theta_scatter"+str(t)+".png") plt.close() np.savetxt( ''.join(['theta_w_t', str(t), '.dat']), np.c_[theta_t[0,:], theta_t[1,:], w_t ] ) print t, ' ;D'