def BetaAlpha(self, b, depth, alpha, beta):
self.noeuds += 1
""" MaxMin avec Alpha beta pruning"""
if b.is_game_over():
resultat = b.result()
if resultat == "1-0":
r = -((-1)**self.maCouleur) * self.scoremax
elif resultat == "0-1":
r = ((-1)**self.maCouleur) * self.scoremax
else:
r = 0
return r
if depth == 0:
self.evaluation = eval.Eval(self.maCouleur)
e = self.evaluation.evaluate(b)
return e
v = None
for m in b.generate_legal_moves():
b.push(m)
ret = self.AlphaBeta(b, depth - 1, alpha, beta)
b.pop()
if v is None or ret > v:
v = ret
if alpha < v:
alpha = v
if alpha >= beta:
return beta
return alpha
def eval(self, **kwargs):
logging.info('evaluating')
if torch.cuda.is_available():
self.inference.cpu()
try:
e = _eval.Eval(self.args, self.config)
cls_ap = e()
self.backup_best(cls_ap, e.path)
except:
traceback.print_exc()
if torch.cuda.is_available():
self.inference.cuda()
def eval(self, **kwargs):
step, inference = (kwargs[key] for key in 'step, inference'.split(', '))
logging.info('evaluating')
if torch.cuda.is_available():
inference.cpu()
try:
e = _eval.Eval(self.args, self.config)
cls_ap = e()
self.backup_best(cls_ap, e.path)
except:
traceback.print_exc()
if torch.cuda.is_available():
inference.cuda()
def eval(self, **kwargs):
step, inference = (kwargs[key] for key in 'step, inference'.split(', '))
logging.info('evaluating')
if torch.cuda.is_available():
inference.cpu()
try:
e = _eval.Eval(self.args, self.config)
cls_ap = e()
for c in cls_ap:
self.summary_worker.writer.add_scalar('ap/' + self.category[c], cls_ap[c], step)
self.summary_worker.writer.add_scalar('mean_ap', np.mean(list(cls_ap.values())), step)
except Exception as e:
logging.warning(e)
if torch.cuda.is_available():
inference.cuda()
def __init__(self, color):
self.maCouleur = color
self.noeuds = 0
self.scoremax = 100000
self.evaluation = eval.Eval(color)
with open(args.parampath) as f:
params = yaml.load(f)
if params is None:
logger.error('no params found from %s' % args.parampath)
sys.exit(1)
files = os.listdir(args.imagepath)
images = []
for _ in files:
images.append(os.path.join(args.imagepath, _))
evaer = eval.Eval(modelprefix=args.modelprefix,
imagepath=images,
inputshape=params['inputshape'],
labelpath=params['eval']['label'],
epoch=args.epoch,
format=args.format)
names, prob_predicts, label_predicts = evaer.predict()
reports = []
for i in range(len(names)):
print('name: %s, predict: %s, acc: %f' %
(names[i], label_predicts[i], prob_predicts[i]))
reports.append(names[i] + ' : ' + label_predicts[i] + ' : ' +
str(prob_predicts[i]) + '\n')
with open('reports.txt', 'a') as f:
for report in reports:
f.write(report)
def __init__(self, vocab_file_path=None, model_file_path=None):
"""
:param vocab_file_path: tuple of code vocab, ast vocab, nl vocab, if given, build vocab by given path
:param model_file_path:
"""
# dataset
self.train_dataset = data.CodePtrDataset(
code_path=config.train_code_path,
ast_path=config.train_sbt_path,
nl_path=config.train_nl_path)
self.train_dataset_size = len(self.train_dataset)
self.train_dataloader = DataLoader(
dataset=self.train_dataset,
batch_size=config.batch_size,
shuffle=True,
collate_fn=lambda *args: utils.unsort_collate_fn(
args,
code_vocab=self.code_vocab,
ast_vocab=self.ast_vocab,
nl_vocab=self.nl_vocab))
# vocab
self.code_vocab: utils.Vocab
self.ast_vocab: utils.Vocab
self.nl_vocab: utils.Vocab
# load vocab from given path
if vocab_file_path:
code_vocab_path, ast_vocab_path, nl_vocab_path = vocab_file_path
self.code_vocab = utils.load_vocab_pk(code_vocab_path)
self.ast_vocab = utils.load_vocab_pk(ast_vocab_path)
self.nl_vocab = utils.load_vocab_pk(nl_vocab_path)
# new vocab
else:
self.code_vocab = utils.Vocab('code_vocab')
self.ast_vocab = utils.Vocab('ast_vocab')
self.nl_vocab = utils.Vocab('nl_vocab')
codes, asts, nls = self.train_dataset.get_dataset()
for code, ast, nl in zip(codes, asts, nls):
self.code_vocab.add_sentence(code)
self.ast_vocab.add_sentence(ast)
self.nl_vocab.add_sentence(nl)
self.origin_code_vocab_size = len(self.code_vocab)
self.origin_nl_vocab_size = len(self.nl_vocab)
# trim vocabulary
self.code_vocab.trim(config.code_vocab_size)
self.nl_vocab.trim(config.nl_vocab_size)
# save vocabulary
self.code_vocab.save(config.code_vocab_path)
self.ast_vocab.save(config.ast_vocab_path)
self.nl_vocab.save(config.nl_vocab_path)
self.code_vocab.save_txt(config.code_vocab_txt_path)
self.ast_vocab.save_txt(config.ast_vocab_txt_path)
self.nl_vocab.save_txt(config.nl_vocab_txt_path)
self.code_vocab_size = len(self.code_vocab)
self.ast_vocab_size = len(self.ast_vocab)
self.nl_vocab_size = len(self.nl_vocab)
# model
self.model = models.Model(code_vocab_size=self.code_vocab_size,
ast_vocab_size=self.ast_vocab_size,
nl_vocab_size=self.nl_vocab_size,
model_file_path=model_file_path)
self.params = list(self.model.code_encoder.parameters()) + \
list(self.model.ast_encoder.parameters()) + \
list(self.model.reduce_hidden.parameters()) + \
list(self.model.decoder.parameters())
# optimizer
self.optimizer = Adam([
{
'params': self.model.code_encoder.parameters(),
'lr': config.code_encoder_lr
},
{
'params': self.model.ast_encoder.parameters(),
'lr': config.ast_encoder_lr
},
{
'params': self.model.reduce_hidden.parameters(),
'lr': config.reduce_hidden_lr
},
{
'params': self.model.decoder.parameters(),
'lr': config.decoder_lr
},
],
betas=(0.9, 0.999),
eps=1e-08,
weight_decay=0,
amsgrad=False)
if config.use_lr_decay:
self.lr_scheduler = lr_scheduler.StepLR(
self.optimizer,
step_size=config.lr_decay_every,
gamma=config.lr_decay_rate)
# best score and model(state dict)
self.min_loss: float = 1000
self.best_model: dict = {}
self.best_epoch_batch: (int, int) = (None, None)
# eval instance
self.eval_instance = eval.Eval(self.get_cur_state_dict())
# early stopping
self.early_stopping = None
if config.use_early_stopping:
self.early_stopping = utils.EarlyStopping()
config.model_dir = os.path.join(config.model_dir,
utils.get_timestamp())
if not os.path.exists(config.model_dir):
os.makedirs(config.model_dir)
