def decode_sequence(features, areas, hparams, decode_length,
post_processing=True):
"""Decodes the entire sequence in an auto-regressive way."""
decode_utils.decode_n_step(seq2act_model.compute_logits,
features, areas,
hparams, n=decode_length, beam_size=1)
if post_processing:
features["input_refs"] = decode_utils.unify_input_ref(
features["verbs"], features["input_refs"])
pred_lengths = decode_utils.verb_refs_to_lengths(features["task"],
features["verb_refs"],
include_eos=False)
predicted_actions = tf.concat([
features["verb_refs"],
features["obj_refs"],
features["input_refs"],
tf.to_int32(tf.expand_dims(features["verbs"], 2)),
tf.to_int32(tf.expand_dims(features["objects"], 2))], axis=-1)
if post_processing:
predicted_actions = tf.where(
tf.tile(tf.expand_dims(
tf.sequence_mask(pred_lengths,
maxlen=tf.shape(predicted_actions)[1]),
2), [1, 1, tf.shape(predicted_actions)[-1]]), predicted_actions,
tf.zeros_like(predicted_actions))
return predicted_actions
def decode_fn(hparams):
"""The main function."""
decode_dict, decode_mask, label_dict = _decode_common(hparams)
if FLAGS.problem != "android_howto":
decode_dict["input_refs"] = decode_utils.unify_input_ref(
decode_dict["verbs"], decode_dict["input_refs"])
print_ops = []
for key in [
"raw_task", "verbs", "objects", "verb_refs", "obj_refs",
"input_refs"
]:
print_ops.append(
tf.print(key,
tf.shape(decode_dict[key]),
decode_dict[key],
label_dict[key],
"decode_mask",
decode_mask,
summarize=100))
acc_metrics = decode_utils.compute_seq_metrics(label_dict,
decode_dict,
mask=None)
saver = tf.train.Saver()
with tf.Session() as session:
session.run(tf.global_variables_initializer())
latest_checkpoint = tf.train.latest_checkpoint(FLAGS.checkpoint_path)
tf.logging.info("Restoring from the latest checkpoint: %s" %
(latest_checkpoint))
saver.restore(session, latest_checkpoint)
task_seqs = []
ref_seqs = []
act_seqs = []
mask_seqs = []
try:
i = 0
while True:
tf.logging.info("Example %d" % i)
task, acc, mask, label, decode = session.run([
decode_dict["raw_task"], acc_metrics, decode_mask,
label_dict, decode_dict
])
ref_seq = {}
ref_seq["gt_seq"] = np.concatenate([
label["verb_refs"], label["obj_refs"], label["input_refs"]
],
axis=-1)
ref_seq["pred_seq"] = np.concatenate([
decode["verb_refs"], decode["obj_refs"],
decode["input_refs"]
],
axis=-1)
ref_seq["complete_seq_acc"] = acc["complete_refs_acc"]
ref_seq["partial_seq_acc"] = acc["partial_refs_acc"]
act_seq = {}
act_seq["gt_seq"] = np.concatenate([
np.expand_dims(label["verbs"], 2),
np.expand_dims(label["objects"], 2), label["input_refs"]
],
axis=-1)
act_seq["pred_seq"] = np.concatenate([
np.expand_dims(decode["verbs"], 2),
np.expand_dims(decode["objects"], 2), decode["input_refs"]
],
axis=-1)
act_seq["complete_seq_acc"] = acc["complete_acts_acc"]
act_seq["partial_seq_acc"] = acc["partial_acts_acc"]
print("task", task)
print("ref_seq", ref_seq)
print("act_seq", act_seq)
print("mask", mask)
task_seqs.append(task)
ref_seqs.append(ref_seq)
act_seqs.append(act_seq)
mask_seqs.append(mask)
i += 1
except tf.errors.OutOfRangeError:
pass
save(task_seqs, ref_seqs, mask_seqs, "joint_refs")
save(task_seqs, act_seqs, mask_seqs, "joint_act")
def _eval(metrics, pred_dict, loss_dict, features, areas, compute_seq_accuracy,
hparams, metric_types, decode_length=20):
"""Internal eval function."""
# Assume data sources are not mixed within each batch
if compute_seq_accuracy:
decode_features = {}
for key in features:
if not key.endswith("_refs"):
decode_features[key] = features[key]
decode_utils.decode_n_step(seq2act_model.compute_logits,
decode_features, areas,
hparams, n=decode_length, beam_size=1)
decode_features["input_refs"] = decode_utils.unify_input_ref(
decode_features["verbs"], decode_features["input_refs"])
acc_metrics = decode_utils.compute_seq_metrics(
features, decode_features)
metrics["seq_full_acc"] = tf.metrics.mean(acc_metrics["complete_refs_acc"])
metrics["seq_partial_acc"] = tf.metrics.mean(
acc_metrics["partial_refs_acc"])
if "final_accuracy" in metric_types:
metrics["complet_act_accuracy"] = tf.metrics.mean(
acc_metrics["complete_acts_acc"])
metrics["partial_seq_acc"] = tf.metrics.mean(
acc_metrics["partial_acts_acc"])
print0 = tf.print("*** lang", features["raw_task"], summarize=100)
with tf.control_dependencies([print0]):
loss_dict["total_loss"] = tf.identity(loss_dict["total_loss"])
else:
decode_features = None
if "ref_accuracy" in metric_types:
with tf.control_dependencies([
tf.assert_equal(tf.rank(features["verb_refs"]), 3),
tf.assert_equal(tf.shape(features["verb_refs"])[-1], 2)]):
_ref_accuracy(features, pred_dict,
tf.less(features["verb_refs"][:, :, 0],
features["verb_refs"][:, :, 1]),
"verb_refs", metrics, decode_features,
measure_beginning_eos=True)
_ref_accuracy(features, pred_dict,
tf.less(features["obj_refs"][:, :, 0],
features["obj_refs"][:, :, 1]),
"obj_refs", metrics, decode_features,
measure_beginning_eos=True)
_ref_accuracy(features, pred_dict,
tf.less(features["input_refs"][:, :, 0],
features["input_refs"][:, :, 1]),
"input_refs", metrics, decode_features,
measure_beginning_eos=True)
if "basic_accuracy" in metric_types:
target_verbs = tf.reshape(features["verbs"], [-1])
verb_nonpadding = tf.greater(target_verbs, 1)
target_verbs = tf.boolean_mask(target_verbs, verb_nonpadding)
predict_verbs = tf.boolean_mask(tf.reshape(pred_dict["verbs"], [-1]),
verb_nonpadding)
metrics["verb"] = tf.metrics.accuracy(
labels=target_verbs,
predictions=predict_verbs,
name="verb_accuracy")
input_mask = tf.reshape(
tf.less(features["verb_refs"][:, :, 0],
features["verb_refs"][:, :, 1]), [-1])
metrics["input"] = tf.metrics.accuracy(
labels=tf.boolean_mask(
tf.reshape(tf.to_int32(
tf.less(features["input_refs"][:, :, 0],
features["input_refs"][:, :, 1])), [-1]), input_mask),
predictions=tf.boolean_mask(
tf.reshape(pred_dict["input"], [-1]), input_mask),
name="input_accuracy")
metrics["object"] = tf.metrics.accuracy(
labels=tf.boolean_mask(tf.reshape(features["objects"], [-1]),
verb_nonpadding),
predictions=tf.boolean_mask(tf.reshape(pred_dict["objects"], [-1]),
verb_nonpadding),
name="object_accuracy")
metrics["eval_object_loss"] = tf.metrics.mean(
tf.reduce_mean(
tf.boolean_mask(tf.reshape(loss_dict["object_losses"], [-1]),
verb_nonpadding)))
metrics["eval_verb_loss"] = tf.metrics.mean(
tf.reduce_mean(
tf.boolean_mask(tf.reshape(loss_dict["verbs_losses"], [-1]),
verb_nonpadding)))