Function _evaluate

src_code/thumt1_code/thumt/utils/hooks.py:159–213

(eval_fn, input_fn, decode_fn, path, config, device_list)

def _evaluate(eval_fn, input_fn, decode_fn, path, config, device_list):
    graph = tf.Graph()
    with graph.as_default():
        features = input_fn()
        refs = features["references"]
        placeholders = []
        for i in range(len(device_list)):
            placeholders.append({
                "source": tf.placeholder(tf.int32, [None, None],
                                         "source_%d" % i),
                "source_length": tf.placeholder(tf.int32, [None],
                                                "source_length_%d" % i)
            })
        predictions = parallel.data_parallelism(
            device_list, eval_fn, placeholders)
        predictions = [pred[0][:, 0, :] for pred in predictions]

        all_refs = [[] for _ in range(len(refs))]
        all_outputs = []

        sess_creator = tf.train.ChiefSessionCreator(
            checkpoint_dir=path,
            config=config
        )

        with tf.train.MonitoredSession(session_creator=sess_creator) as sess:
            while not sess.should_stop():
                feats = sess.run(features)
                inp_feats = {
                    "source": feats["source"],
                    "source_length": feats["source_length"]
                }
                op, feed_dict = _shard_features(inp_feats, placeholders,
                                                predictions)
                # A list of numpy array with shape: [batch, len]
                outputs = sess.run(op, feed_dict=feed_dict)

                for shard in outputs:
                    all_outputs.extend(shard.tolist())

                # shape: ([batch, len], ..., [batch, len])
                references = [item.tolist() for item in feats["references"]]

                for i in range(len(refs)):
                    all_refs[i].extend(references[i])

        decoded_symbols = decode_fn(all_outputs)

        for i, l in enumerate(decoded_symbols):
            decoded_symbols[i] = " ".join(l).replace("@@ ", "").split()

        decoded_refs = [decode_fn(refs) for refs in all_refs]
        decoded_refs = [list(x) for x in zip(*decoded_refs)]

        return bleu.bleu(decoded_symbols, decoded_refs)


class EvaluationHook(tf.train.SessionRunHook):