# Copyright 2016 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================

"""Tests for beam_reader_ops."""

import os.path
import time
import tensorflow as tf

from tensorflow.python.framework import test_util
from tensorflow.python.platform import googletest
from tensorflow.python.platform import tf_logging as logging

from syntaxnet import structured_graph_builder
from syntaxnet.ops import gen_parser_ops

FLAGS = tf.app.flags.FLAGS
if not hasattr(FLAGS, 'test_srcdir'):
    FLAGS.test_srcdir = ''
if not hasattr(FLAGS, 'test_tmpdir'):
    FLAGS.test_tmpdir = tf.test.get_temp_dir()


class ParsingReaderOpsTest(test_util.TensorFlowTestCase):

    def setUp(self):
        # Creates a task context with the correct testing paths.
        initial_task_context = os.path.join(FLAGS.test_srcdir,
                                            'syntaxnet/'
                                            'testdata/context.pbtxt')
        self._task_context = os.path.join(FLAGS.test_tmpdir, 'context.pbtxt')
        with open(initial_task_context, 'r') as fin:
            with open(self._task_context, 'w') as fout:
                fout.write(fin.read().replace('SRCDIR', FLAGS.test_srcdir)
                           .replace('OUTPATH', FLAGS.test_tmpdir))

        # Creates necessary term maps.
        with self.test_session() as sess:
            gen_parser_ops.lexicon_builder(task_context=self._task_context,
                                           corpus_name='training-corpus').run()
            self._num_features, self._num_feature_ids, _, self._num_actions = (
                sess.run(gen_parser_ops.feature_size(task_context=self._task_context,
                                                     arg_prefix='brain_parser')))

    def MakeGraph(self,
                  max_steps=10,
                  beam_size=2,
                  batch_size=1,
                  **kwargs):
        """Constructs a structured learning graph."""
        assert max_steps > 0, 'Empty network not supported.'

        logging.info('MakeGraph + %s', kwargs)

        with self.test_session(graph=tf.Graph()) as sess:
            feature_sizes, domain_sizes, embedding_dims, num_actions = sess.run(
                gen_parser_ops.feature_size(task_context=self._task_context))
        embedding_dims = [8, 8, 8]
        hidden_layer_sizes = []
        learning_rate = 0.01
        builder = structured_graph_builder.StructuredGraphBuilder(
            num_actions,
            feature_sizes,
            domain_sizes,
            embedding_dims,
            hidden_layer_sizes,
            seed=1,
            max_steps=max_steps,
            beam_size=beam_size,
            gate_gradients=True,
            use_locking=True,
            use_averaging=False,
            check_parameters=False,
            **kwargs)
        builder.AddTraining(self._task_context,
                            batch_size,
                            learning_rate=learning_rate,
                            decay_steps=1000,
                            momentum=0.9,
                            corpus_name='training-corpus')
        builder.AddEvaluation(self._task_context,
                              batch_size,
                              evaluation_max_steps=25,
                              corpus_name=None)
        builder.training['inits'] = tf.group(*builder.inits.values(), name='inits')
        return builder

    def Train(self, **kwargs):
        with self.test_session(graph=tf.Graph()) as sess:
            max_steps = 3
            batch_size = 3
            beam_size = 3
            builder = (
                self.MakeGraph(
                    max_steps=max_steps, beam_size=beam_size,
                    batch_size=batch_size, **kwargs))
            logging.info('params: %s', builder.params.keys())
            logging.info('variables: %s', builder.variables.keys())

            t = builder.training
            sess.run(t['inits'])
            costs = []
            gold_slots = []
            alive_steps_vector = []
            every_n = 5
            walltime = time.time()
            for step in range(10):
                if step > 0 and step % every_n == 0:
                    new_walltime = time.time()
                    logging.info(
                        'Step: %d <cost>: %f <gold_slot>: %f <alive_steps>: %f <iter '
                        'time>: %f ms',
                        step, sum(costs[-every_n:]) / float(every_n),
                              sum(gold_slots[-every_n:]) / float(every_n),
                              sum(alive_steps_vector[-every_n:]) / float(every_n),
                              1000 * (new_walltime - walltime) / float(every_n))
                    walltime = new_walltime

                cost, gold_slot, alive_steps, _ = sess.run(
                    [t['cost'], t['gold_slot'], t['alive_steps'], t['train_op']])
                costs.append(cost)
                gold_slots.append(gold_slot.mean())
                alive_steps_vector.append(alive_steps.mean())

            if builder._only_train:
                trainable_param_names = [
                    k for k in builder.params if k in builder._only_train]
            else:
                trainable_param_names = builder.params.keys()
            if builder._use_averaging:
                for v in trainable_param_names:
                    avg = builder.variables['%s_avg_var' % v].eval()
                    tf.assign(builder.params[v], avg).eval()

            # Reset for pseudo eval.
            costs = []
            gold_slots = []
            alive_stepss = []
            for step in range(10):
                cost, gold_slot, alive_steps = sess.run(
                    [t['cost'], t['gold_slot'], t['alive_steps']])
                costs.append(cost)
                gold_slots.append(gold_slot.mean())
                alive_stepss.append(alive_steps.mean())

            logging.info(
                'Pseudo eval: <cost>: %f <gold_slot>: %f <alive_steps>: %f',
                sum(costs[-every_n:]) / float(every_n),
                sum(gold_slots[-every_n:]) / float(every_n),
                sum(alive_stepss[-every_n:]) / float(every_n))

    def PathScores(self, iterations, beam_size, max_steps, batch_size):
        with self.test_session(graph=tf.Graph()) as sess:
            t = self.MakeGraph(beam_size=beam_size, max_steps=max_steps,
                               batch_size=batch_size).training
            sess.run(t['inits'])
            all_path_scores = []
            beam_path_scores = []
            for i in range(iterations):
                logging.info('run %d', i)
                tensors = (
                    sess.run(
                        [t['alive_steps'], t['concat_scores'],
                         t['all_path_scores'], t['beam_path_scores'],
                         t['indices'], t['path_ids']]))

                logging.info('alive for %s, all_path_scores and beam_path_scores, '
                             'indices and path_ids:'
                             '\n%s\n%s\n%s\n%s',
                             tensors[0], tensors[2], tensors[3], tensors[4], tensors[5])
                logging.info('diff:\n%s', tensors[2] - tensors[3])

                all_path_scores.append(tensors[2])
                beam_path_scores.append(tensors[3])
            return all_path_scores, beam_path_scores

    def testParseUntilNotAlive(self):
        """Ensures that the 'alive' condition works in the Cond ops."""
        with self.test_session(graph=tf.Graph()) as sess:
            t = self.MakeGraph(batch_size=3, beam_size=2, max_steps=5).training
            sess.run(t['inits'])
            for i in range(5):
                logging.info('run %d', i)
                tf_alive = t['alive'].eval()
                self.assertFalse(any(tf_alive))

    def testParseMomentum(self):
        """Ensures that Momentum training can be done using the gradients."""
        self.Train()
        self.Train(model_cost='perceptron_loss')
        self.Train(model_cost='perceptron_loss',
                   only_train='softmax_weight,softmax_bias', softmax_init=0)
        self.Train(only_train='softmax_weight,softmax_bias', softmax_init=0)

    def testPathScoresAgree(self):
        """Ensures that path scores computed in the beam are same in the net."""
        all_path_scores, beam_path_scores = self.PathScores(
            iterations=1, beam_size=130, max_steps=5, batch_size=1)
        self.assertArrayNear(all_path_scores[0], beam_path_scores[0], 1e-6)

    def testBatchPathScoresAgree(self):
        """Ensures that path scores computed in the beam are same in the net."""
        all_path_scores, beam_path_scores = self.PathScores(
            iterations=1, beam_size=130, max_steps=5, batch_size=22)
        self.assertArrayNear(all_path_scores[0], beam_path_scores[0], 1e-6)

    def testBatchOneStepPathScoresAgree(self):
        """Ensures that path scores computed in the beam are same in the net."""
        all_path_scores, beam_path_scores = self.PathScores(
            iterations=1, beam_size=130, max_steps=1, batch_size=22)
        self.assertArrayNear(all_path_scores[0], beam_path_scores[0], 1e-6)


if __name__ == '__main__':
    googletest.main()

# Copyright 2016 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================

"""Tests for beam_reader_ops."""

import os.path
import time
import tensorflow as tf

from tensorflow.python.framework import test_util
from tensorflow.python.platform import googletest
from tensorflow.python.platform import tf_logging as logging

from syntaxnet import structured_graph_builder
from syntaxnet.ops import gen_parser_ops

FLAGS = tf.app.flags.FLAGS
if not hasattr(FLAGS, 'test_srcdir'):
    FLAGS.test_srcdir = ''
if not hasattr(FLAGS, 'test_tmpdir'):
    FLAGS.test_tmpdir = tf.test.get_temp_dir()


class ParsingReaderOpsTest(test_util.TensorFlowTestCase):

    def setUp(self):
        # Creates a task context with the correct testing paths.
        initial_task_context = os.path.join(FLAGS.test_srcdir,
                                            'syntaxnet/'
                                            'testdata/context.pbtxt')
        self._task_context = os.path.join(FLAGS.test_tmpdir, 'context.pbtxt')
        with open(initial_task_context, 'r') as fin:
            with open(self._task_context, 'w') as fout:
                fout.write(fin.read().replace('SRCDIR', FLAGS.test_srcdir)
                           .replace('OUTPATH', FLAGS.test_tmpdir))

        # Creates necessary term maps.
        with self.test_session() as sess:
            gen_parser_ops.lexicon_builder(task_context=self._task_context,
                                           corpus_name='training-corpus').run()
            self._num_features, self._num_feature_ids, _, self._num_actions = (
                sess.run(gen_parser_ops.feature_size(task_context=self._task_context,
                                                     arg_prefix='brain_parser')))

    def MakeGraph(self,
                  max_steps=10,
                  beam_size=2,
                  batch_size=1,
                  **kwargs):
        """Constructs a structured learning graph."""
        assert max_steps > 0, 'Empty network not supported.'

        logging.info('MakeGraph + %s', kwargs)

        with self.test_session(graph=tf.Graph()) as sess:
            feature_sizes, domain_sizes, embedding_dims, num_actions = sess.run(
                gen_parser_ops.feature_size(task_context=self._task_context))
        embedding_dims = [8, 8, 8]
        hidden_layer_sizes = []
        learning_rate = 0.01
        builder = structured_graph_builder.StructuredGraphBuilder(
            num_actions,
            feature_sizes,
            domain_sizes,
            embedding_dims,
            hidden_layer_sizes,
            seed=1,
            max_steps=max_steps,
            beam_size=beam_size,
            gate_gradients=True,
            use_locking=True,
            use_averaging=False,
            check_parameters=False,
            **kwargs)
        builder.AddTraining(self._task_context,
                            batch_size,
                            learning_rate=learning_rate,
                            decay_steps=1000,
                            momentum=0.9,
                            corpus_name='training-corpus')
        builder.AddEvaluation(self._task_context,
                              batch_size,
                              evaluation_max_steps=25,
                              corpus_name=None)
        builder.training['inits'] = tf.group(*builder.inits.values(), name='inits')
        return builder

    def Train(self, **kwargs):
        with self.test_session(graph=tf.Graph()) as sess:
            max_steps = 3
            batch_size = 3
            beam_size = 3
            builder = (
                self.MakeGraph(
                    max_steps=max_steps, beam_size=beam_size,
                    batch_size=batch_size, **kwargs))
            logging.info('params: %s', builder.params.keys())
            logging.info('variables: %s', builder.variables.keys())

            t = builder.training
            sess.run(t['inits'])
            costs = []
            gold_slots = []
            alive_steps_vector = []
            every_n = 5
            walltime = time.time()
            for step in range(10):
                if step > 0 and step % every_n == 0:
                    new_walltime = time.time()
                    logging.info(
                        'Step: %d <cost>: %f <gold_slot>: %f <alive_steps>: %f <iter '
                        'time>: %f ms',
                        step, sum(costs[-every_n:]) / float(every_n),
                              sum(gold_slots[-every_n:]) / float(every_n),
                              sum(alive_steps_vector[-every_n:]) / float(every_n),
                              1000 * (new_walltime - walltime) / float(every_n))
                    walltime = new_walltime

                cost, gold_slot, alive_steps, _ = sess.run(
                    [t['cost'], t['gold_slot'], t['alive_steps'], t['train_op']])
                costs.append(cost)
                gold_slots.append(gold_slot.mean())
                alive_steps_vector.append(alive_steps.mean())

            if builder._only_train:
                trainable_param_names = [
                    k for k in builder.params if k in builder._only_train]
            else:
                trainable_param_names = builder.params.keys()
            if builder._use_averaging:
                for v in trainable_param_names:
                    avg = builder.variables['%s_avg_var' % v].eval()
                    tf.assign(builder.params[v], avg).eval()

            # Reset for pseudo eval.
            costs = []
            gold_slots = []
            alive_stepss = []
            for step in range(10):
                cost, gold_slot, alive_steps = sess.run(
                    [t['cost'], t['gold_slot'], t['alive_steps']])
                costs.append(cost)
                gold_slots.append(gold_slot.mean())
                alive_stepss.append(alive_steps.mean())

            logging.info(
                'Pseudo eval: <cost>: %f <gold_slot>: %f <alive_steps>: %f',
                sum(costs[-every_n:]) / float(every_n),
                sum(gold_slots[-every_n:]) / float(every_n),
                sum(alive_stepss[-every_n:]) / float(every_n))

    def PathScores(self, iterations, beam_size, max_steps, batch_size):
        with self.test_session(graph=tf.Graph()) as sess:
            t = self.MakeGraph(beam_size=beam_size, max_steps=max_steps,
                               batch_size=batch_size).training
            sess.run(t['inits'])
            all_path_scores = []
            beam_path_scores = []
            for i in range(iterations):
                logging.info('run %d', i)
                tensors = (
                    sess.run(
                        [t['alive_steps'], t['concat_scores'],
                         t['all_path_scores'], t['beam_path_scores'],
                         t['indices'], t['path_ids']]))

                logging.info('alive for %s, all_path_scores and beam_path_scores, '
                             'indices and path_ids:'
                             '\n%s\n%s\n%s\n%s',
                             tensors[0], tensors[2], tensors[3], tensors[4], tensors[5])
                logging.info('diff:\n%s', tensors[2] - tensors[3])

                all_path_scores.append(tensors[2])
                beam_path_scores.append(tensors[3])
            return all_path_scores, beam_path_scores

    def testParseUntilNotAlive(self):
        """Ensures that the 'alive' condition works in the Cond ops."""
        with self.test_session(graph=tf.Graph()) as sess:
            t = self.MakeGraph(batch_size=3, beam_size=2, max_steps=5).training
            sess.run(t['inits'])
            for i in range(5):
                logging.info('run %d', i)
                tf_alive = t['alive'].eval()
                self.assertFalse(any(tf_alive))

    def testParseMomentum(self):
        """Ensures that Momentum training can be done using the gradients."""
        self.Train()
        self.Train(model_cost='perceptron_loss')
        self.Train(model_cost='perceptron_loss',
                   only_train='softmax_weight,softmax_bias', softmax_init=0)
        self.Train(only_train='softmax_weight,softmax_bias', softmax_init=0)

    def testPathScoresAgree(self):
        """Ensures that path scores computed in the beam are same in the net."""
        all_path_scores, beam_path_scores = self.PathScores(
            iterations=1, beam_size=130, max_steps=5, batch_size=1)
        self.assertArrayNear(all_path_scores[0], beam_path_scores[0], 1e-6)

    def testBatchPathScoresAgree(self):
        """Ensures that path scores computed in the beam are same in the net."""
        all_path_scores, beam_path_scores = self.PathScores(
            iterations=1, beam_size=130, max_steps=5, batch_size=22)
        self.assertArrayNear(all_path_scores[0], beam_path_scores[0], 1e-6)

    def testBatchOneStepPathScoresAgree(self):
        """Ensures that path scores computed in the beam are same in the net."""
        all_path_scores, beam_path_scores = self.PathScores(
            iterations=1, beam_size=130, max_steps=1, batch_size=22)
        self.assertArrayNear(all_path_scores[0], beam_path_scores[0], 1e-6)


if __name__ == '__main__':
    googletest.main()

# Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # #     http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== Tests for beam_reader_ops. # Creates a task context with the correct testing paths. # Creates necessary term maps. Constructs a structured learning graph. # Reset for pseudo eval. Ensures that the 'alive' condition works in the Cond ops. Ensures that Momentum training can be done using the gradients. Ensures that path scores computed in the beam are same in the net. Ensures that path scores computed in the beam are same in the net. Ensures that path scores computed in the beam are same in the net.