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'
