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'
