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 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 __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 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 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 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 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
def NS_DNNex(self, patience=50, anneal=(0.5, 1.0), lambda_e0=(0.0, 5.0), lambda_s=(0.0, 10.0)): """ See what will happen without energy loss. """ 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'] = True param.train_params['train_loss'] = [ 'mse_loss', 'phy_loss', ] param.train_params['test_loss'] = [ 'phy_loss', ] return param
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
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 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
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 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 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'