code: def main():
      """Entrypoint."""
      training_data = tx.data.PairedTextData(hparams=config_data.train)
      val_data = tx.data.PairedTextData(hparams=config_data.val)
      test_data = tx.data.PairedTextData(hparams=config_data.test)
      data_iterator = tx.data.TrainTestDataIterator(
          train=training_data, val=val_data, test=test_data
      )
  
      batch = data_iterator.get_next()
      lambdas_ts = tf.placeholder(shape=[3], dtype=tf.float32)
  
      train_op, infer_outputs = build_model(
          batch, training_data, lambdas_ts
      )
  
      def _train_epoch(sess, epoch, lambdas):
          data_iterator.switch_to_train_data(sess)
          log_file = open(
              log_dir + "training_log" + str(epoch) + ".txt",
              "w",
              encoding="utf-8",
          )
  
          step = 0
          while True:
              try:
                  loss = sess.run(
                      train_op,
                      feed_dict={lambdas_ts: np.array(lambdas)},
                  )
                  print(
                      "step={}, loss={:.4f}, lambdas={}".format(
                          step, loss, lambdas
                      ),
                      file=log_file,
                  )
                  if step % config_data.observe_steps == 0:
                      print(
                          "step={}, loss={:.4f}, lambdas={}".format(
                              step, loss, lambdas
                          )
                      )
                  log_file.flush()
                  step += 1
  
              except tf.errors.OutOfRangeError:
                  break
  
      def _eval_epoch(sess, mode, epoch_no):
          """
          This function is the same as _eval_epoch() in
          baseline_seq2seq_attn_main.py.
          """
          if mode == "val":
              data_iterator.switch_to_val_data(sess)
          else:
              data_iterator.switch_to_test_data(sess)
  
          refs, hypos = [], []
          while True:
              try:
                  fetches = [
                      batch["target_text"][:, 1:],
                      infer_outputs.predicted_ids[:, :, 0],
                  ]
                  feed_dict = {
                      tx.global_mode(): tf.estimator.ModeKeys.EVAL
                  }
                  target_texts_ori, output_ids = sess.run(
                      fetches, feed_dict=feed_dict
                  )
  
                  target_texts = tx.utils.strip_special_tokens(
                      target_texts_ori.tolist(), is_token_list=True
                  )
                  target_texts = tx.utils.str_join(target_texts)
                  output_texts = tx.utils.map_ids_to_strs(
                      ids=output_ids, vocab=val_data.target_vocab
                  )
  
                  tx.utils.write_paired_text(
                      target_texts,
                      output_texts,
                      log_dir
                      + mode
                      + "_results"
                      + str(epoch_no)
                      + ".txt",
                      append=True,
                      mode="h",
                      sep=" ||| ",
                  )
  
                  for hypo, ref in zip(output_texts, target_texts):
                      if config_data.eval_metric == "bleu":
                          hypos.append(hypo)
                          refs.append([ref])
                      elif config_data.eval_metric == "rouge":
                          hypos.append(tx.utils.compat_as_text(hypo))
                          refs.append(tx.utils.compat_as_text(ref))
              except tf.errors.OutOfRangeError:
                  break
  
          if config_data.eval_metric == "bleu":
              return tx.evals.corpus_bleu_moses(
                  list_of_references=refs, hypotheses=hypos
              )
          elif config_data.eval_metric == "rouge":
              rouge = Rouge()
              return rouge.get_scores(hyps=hypos, refs=refs, avg=True)
  
      def _calc_reward(score):
          """
          Return the bleu score or the sum of (Rouge-1, Rouge-2, Rouge-L).
          """
          if config_data.eval_metric == "bleu":
              return score
          elif config_data.eval_metric == "rouge":
              return sum([value["f"] for key, value in score.items()])
  
      def _anneal():
          """
          Operate lambdas when the reward of val set decrease.
          """
  
          def _update_self():
              """
              Decrease lambda_truth and increase lambda_self.
              """
              lambdas[1] -= FLAGS.delta_lambda_self
              lambdas[0] += FLAGS.delta_lambda_self
              updates.append("self")
  
          def _update_rew():
              """
              Decrease lambda_truth and increase lambda_reward.
              """
              lambdas[1] -= FLAGS.delta_lambda_reward
              lambdas[2] += FLAGS.delta_lambda_reward
              updates.append("rew")
  
          if (
              updates[-FLAGS.lambda_reward_steps :]
              == ["rew"] * FLAGS.lambda_reward_steps
          ):
              _update_self()
          else:
              _update_rew()
  
      saver = tf.train.Saver(max_to_keep=2)
      with tf.Session() as sess:
          sess.run(tf.global_variables_initializer())
          sess.run(tf.local_variables_initializer())
          sess.run(tf.tables_initializer())
  
          lambdas = FLAGS.lambdas_init
          updates = ["rew"] * FLAGS.lambda_reward_steps
  
          best_val_score, best_val_score_current_lambdas = -1.0, -1.0
          scores_file = open(
              log_dir + "scores.txt", "w", encoding="utf-8"
          )
  
          for i in range(config_data.num_epochs):
              print_stdout_and_file(
                  "training epoch={}, lambdas={}".format(i, lambdas),
                  file=scores_file,
              )
              _train_epoch(sess, i, lambdas)
              saver.save(
                  sess, log_dir + "models/model{}.ckpt".format(i)
              )
  
              val_score = _eval_epoch(sess, "val", i)
              test_score = _eval_epoch(sess, "test", i)
  
              if (
                  _calc_reward(val_score)
                  < best_val_score_current_lambdas
              ):
                  _anneal()
                  best_val_score_current_lambdas = -1.0
                  saver.restore(
                      sess,
                      log_dir + "models/model{}.ckpt".format(i - 1),
                  )
              else:
                  best_val_score_current_lambdas = _calc_reward(
                      val_score
                  )
  
              best_val_score = max(
                  best_val_score, _calc_reward(val_score)
              )
  
              if config_data.eval_metric == "bleu":
                  print_stdout_and_file(
                      "val epoch={}, BLEU={:.4f}; best-ever={:.4f}".format(
                          i, val_score, best_val_score
                      ),
                      file=scores_file,
                  )
  
                  print_stdout_and_file(
                      "test epoch={}, BLEU={:.4f}".format(
                          i, test_score
                      ),
                      file=scores_file,
                  )
                  print_stdout_and_file("=" * 50, file=scores_file)
  
              elif config_data.eval_metric == "rouge":
                  print_stdout_and_file(
                      "valid epoch {}:".format(i), file=scores_file
                  )
                  for key, value in val_score.items():
                      print_stdout_and_file(
                          "{}: {}".format(key, value), file=scores_file
                      )
                  print_stdout_and_file(
                      "fsum: {}; best_val_fsum: {}".format(
                          _calc_reward(val_score), best_val_score
                      ),
                      file=scores_file,
                  )
  
                  print_stdout_and_file(
                      "test epoch {}:".format(i), file=scores_file
                  )
                  for key, value in test_score.items():
                      print_stdout_and_file(
                          "{}: {}".format(key, value), file=scores_file
                      )
                  print_stdout_and_file("=" * 110, file=scores_file)
  
              scores_file.flush()
  
file_path: texar/examples/seq2seq_exposure_bias/interpolation_main.py
imports: import importlib
  from io import open
  import tensorflow
  import texar.tf
  import numpy
  from interpolation_decoder import InterpolationDecoder
  from interpolation_helper import InterpolationHelper
  from rouge import Rouge
label_desc: Use image node_id 3 for calling a global function with example usage: main() and returns: tx, score, rouge, sum