class OracleWrapper(object):
def __init__(self, oracle, tokenizer):
self.oracle = oracle
self.evaluator = None
self.tokenizer = tokenizer
def initialize(self, sess):
self.evaluator = Evaluator(self.oracle.get_sources(sess),
self.oracle.scope_name)
def answer_question(self, sess, question, seq_length, game_data):
game_data["question"] = question
game_data["seq_length"] = seq_length
# convert dico name to fit oracle constraint
game_data["category"] = game_data.get("targets_category", None)
game_data["spatial"] = game_data.get("targets_spatial", None)
# sample
answers_indices = self.evaluator.execute(sess,
output=self.oracle.best_pred,
batch=game_data)
# Decode the answers token ['<yes>', '<no>', '<n/a>'] WARNING magic order... TODO move this order into tokenizer
answer_dico = [
self.tokenizer.yes_token, self.tokenizer.no_token,
self.tokenizer.non_applicable_token
]
answers = [answer_dico[a]
for a in answers_indices] # turn indices into tokenizer_id
return answers
class QGenSamplingWrapper(object):
def __init__(self, qgen, tokenizer, max_length):
self.qgen = qgen
self.tokenizer = tokenizer
self.max_length = max_length
self.evaluator = None
# Track the hidden state of LSTM
self.state_c = None
self.state_h = None
self.state_size = int(qgen.decoder_zero_state_c.get_shape()[1])
def initialize(self, sess):
self.evaluator = Evaluator(self.qgen.get_sources(sess),
self.qgen.scope_name)
def reset(self, batch_size):
# reset state
self.state_c = np.zeros((batch_size, self.state_size))
self.state_h = np.zeros((batch_size, self.state_size))
def sample_next_question(self, sess, prev_answers, game_data, greedy):
game_data["dialogues"] = prev_answers
game_data["seq_length"] = [1] * len(prev_answers)
game_data["state_c"] = self.state_c
game_data["state_h"] = self.state_h
game_data["greedy"] = greedy
# sample
res = self.evaluator.execute(sess, self.qgen.samples, game_data)
self.state_c = res[0]
self.state_h = res[1]
transpose_questions = res[2]
seq_length = res[3]
# Get questions
padded_questions = transpose_questions.transpose([1, 0])
padded_questions = padded_questions[:, 1:] # ignore first token
for i, l in enumerate(seq_length):
padded_questions[i, l:] = self.tokenizer.padding_token
questions = [q[:l] for q, l in zip(padded_questions, seq_length)]
return padded_questions, questions, seq_length
class OracleWrapper(object):
def __init__(self, oracle, batchifier, tokenizer):
self.oracle = oracle
self.evaluator = None
self.tokenizer = tokenizer
self.batchifier = batchifier
def initialize(self, sess):
self.evaluator = Evaluator(self.oracle.get_sources(sess),
self.oracle.scope_name)
def answer_question(self, sess, games):
# create the training batch #TODO: hack -> to remove
oracle_games = []
if self.batchifier.split_mode == 1:
for game in games:
g = copy.copy(game)
g.questions = [game.questions[-1]]
g.question_ids = [game.question_ids[-1]]
oracle_games.append(g)
else:
oracle_games = games
batch = self.batchifier.apply(oracle_games, skip_targets=True)
batch["is_training"] = False
# Sample
answers_index = self.evaluator.execute(sess,
output=self.oracle.prediction,
batch=batch)
# Update game
new_games = []
for game, answer in zip(games, answers_index):
if not game.user_data[
"has_stop_token"]: # stop adding answer if dialogue is over
game.answers.append(
self.tokenizer.decode_oracle_answer(answer, sparse=True))
new_games.append(game)
return new_games
class GuesserWrapper(object):
def __init__(self, guesser):
self.guesser = guesser
self.evaluator = None
def initialize(self, sess):
self.evaluator = Evaluator(self.guesser.get_sources(sess), self.guesser.scope_name)
def find_object(self, sess, dialogues, seq_length, game_data):
game_data["dialogues"] = dialogues
game_data["seq_length"] = seq_length
# sample
selected_object, softmax = self.evaluator.execute(sess, output=[self.guesser.selected_object, self.guesser.softmax], batch=game_data)
found = (selected_object == game_data["targets_index"])
return found, softmax, selected_object
class QGenWrapper(object):
def __init__(self, qgen, batchifier, tokenizer, max_length, k_best):
self.qgen = qgen
self.batchifier = batchifier
self.tokenizer = tokenizer
self.ops = dict()
self.ops["sampling"] = qgen.create_sampling_graph(
start_token=tokenizer.start_token,
stop_token=tokenizer.stop_token,
max_tokens=max_length)
self.ops["greedy"] = qgen.create_greedy_graph(
start_token=tokenizer.start_token,
stop_token=tokenizer.stop_token,
max_tokens=max_length)
beam_predicted_ids, seq_length, att = qgen.create_beam_graph(
start_token=tokenizer.start_token,
stop_token=tokenizer.stop_token,
max_tokens=max_length,
k_best=k_best)
# print('b',beam_predicted_ids)
# print('s',seq_length)
# Only keep best beam
self.ops[
"beam"] = beam_predicted_ids[:,
0, :], seq_length[:,
0], beam_predicted_ids[:,
0, :] * 0, att
self.evaluator = None
def initialize(self, sess):
self.evaluator = Evaluator(self.qgen.get_sources(sess),
self.qgen.scope_name,
network=self.qgen,
tokenizer=self.tokenizer)
def policy_update(self, sess, games, optimizer):
# ugly hack... to allow training on RL
batchifier = copy.copy(self.batchifier)
batchifier.generate = False
batchifier.supervised = False
iterator = BasicIterator(games,
batch_size=len(games),
batchifier=batchifier)
# Check whether the gradient is accumulated
if isinstance(optimizer, AccOptimizer):
sess.run(optimizer.zero) # reset gradient
local_optimizer = optimizer.accumulate
else:
local_optimizer = optimizer
# Compute the gradient
self.evaluator.process(sess,
iterator,
outputs=[local_optimizer],
show_progress=False)
if isinstance(optimizer, AccOptimizer):
sess.run(optimizer.update) # Apply accumulated gradient
def sample_next_question(self, sess, games, att_dict, beta_dict, mode):
# ugly hack... to allow training on RL
batchifier = copy.copy(self.batchifier)
batchifier.generate = True
batchifier.supervised = False
# create the training batch
batch = batchifier.apply(games, skip_targets=True)
batch["is_training"] = False
batch["is_dynamic"] = True
# Sample
tokens, seq_length, state_values, atts = self.evaluator.execute(
sess, output=self.ops[mode], batch=batch)
# tokens, seq_length, state_values, atts, betas = self.evaluator.execute(sess, output=self.ops[mode], batch=batch)
# Update game
new_games = []
for game, question_tokens, l, state_value, att in zip(
games, tokens, seq_length, state_values, atts):
# for game, question_tokens, l, state_value, att, beta in zip(games, tokens, seq_length, state_values, atts, betas):
if not game.user_data[
"has_stop_token"]: # stop adding question if dialogue is over
# clean tokens after stop_dialogue_tokens
if self.tokenizer.stop_dialogue in question_tokens:
game.user_data["has_stop_token"] = True
l = np.nonzero(
question_tokens == self.tokenizer.stop_dialogue
)[0][0] + 1 # find the first stop_dialogue occurrence
# Append the newly generated question
game.questions.append(
self.tokenizer.decode(question_tokens[:l]))
game.question_ids.append(len(game.question_ids))
game.user_data["state_values"] = game.user_data.get(
"state_values", [])
game.user_data["state_values"].append(state_value[:l].tolist())
att = att.tolist()
att_i = np.argsort(att).tolist()
att_3 = np.sort(att).tolist()
if game.dialogue_id not in att_dict:
att_dict[game.dialogue_id] = []
att_dict[game.dialogue_id].append((att_i, att_3))
else:
att_dict[game.dialogue_id].append((att_i, att_3))
# beta = beta.tolist()
# if game.dialogue_id not in beta_dict:
# beta_dict[game.dialogue_id] = []
# beta_dict[game.dialogue_id].append(beta)
# else:
# beta_dict[game.dialogue_id].append(beta)
new_games.append(game)
return new_games, att_dict #, beta_dict
