main.py

# coding: utf-8

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import time
import numpy as np
import tensorflow as tf

from models import evalu
from models import evalu_enhanced
from models import sltunet
from models import initializer as tinit
from models.lr import get_lr
from models.data import Dataset
from models.search import beam_search
from utils import parallel, cycle, util, queuer, saver, dtype
from utils.loss_logger import LossLogger


def tower_train_graph(train_features, optimizer, graph, params):
    # define multi-gpu training graph
    def _tower_train_graph(features):
        train_output = graph.train_fn(
            features, params,
            initializer=tinit.get_initializer(params.initializer, params.initializer_gain))

        tower_gradients = optimizer.compute_gradients(
            train_output["loss"] * tf.cast(params.loss_scale, tf.float32), colocate_gradients_with_ops=True)
        tower_gradients = [(g/tf.cast(params.loss_scale, tf.float32), v) for g, v in tower_gradients]

        return {
            "loss": train_output["loss"],
            "gradient": tower_gradients
        }

    # feed model to multiple gpus
    tower_outputs = parallel.parallel_model(
        _tower_train_graph, train_features,
        params.gpus, use_cpu=(len(params.gpus) == 0))

    loss = tf.add_n(tower_outputs['loss']) / len(tower_outputs['loss'])
    gradients = parallel.average_gradients(tower_outputs['gradient'])

    return loss, gradients


def tower_infer_graph(eval_features, graph, params):
    # define multi-gpu inferring graph
    def _tower_infer_graph(features):
        encoding_fn, decoding_fn = graph.infer_fn(params)
        beam_output = beam_search(features, encoding_fn, decoding_fn, params)

        return beam_output

    # feed model to multiple gpus
    eval_outputs = parallel.parallel_model(
        _tower_infer_graph, eval_features,
        params.gpus, use_cpu=(len(params.gpus) == 0))
    eval_seqs, eval_scores = eval_outputs['seq'], eval_outputs['score']

    # Extract attention history if available (for detailed analysis)
    eval_attention = eval_outputs.get('attention_history', None)

    return eval_seqs, eval_scores, eval_attention


def train(params):
    # status measure
    if params.recorder.estop or \
            params.recorder.epoch > params.epoches or \
            params.recorder.step > params.max_training_steps:
        tf.logging.info("Stop condition reached, you have finished training your model.")
        return 0.

    # loading dataset
    tf.logging.info("Begin Loading Training and Dev Dataset")
    start_time = time.time()
    train_dataset = Dataset(params,
                            params.img_train_file,
                            params.src_train_file,
                            params.tgt_train_file,
                            params.max_len,
                            params.max_img_len,
                            batch_or_token=params.batch_or_token)
    dev_dataset = Dataset(params,
                          params.img_dev_file,
                          params.src_dev_file,
                          params.src_dev_file,
                          params.eval_max_len,
                          params.max_img_len,
                          batch_or_token='batch')
    tf.logging.info(
        f"End Loading dataset, within {time.time() - start_time} seconds")

    # Build Graph
    with tf.Graph().as_default():
        lr = tf.placeholder(tf.as_dtype(dtype.floatx()), [], "learn_rate")

        # shift automatically sliced multi-gpu process into `zero` manner :)
        features = []
        for fidx in range(max(len(params.gpus), 1)):
            feature = {
                "source": tf.placeholder(tf.int32, [None, None], "source"),
                "target": tf.placeholder(tf.int32, [None, None], "target"),
                "image": tf.placeholder(tf.float32, [None, None, params.img_feature_size], "image"),
                "mask": tf.placeholder(tf.float32, [None, None], "mask"),
                "is_img": tf.placeholder(tf.float32, [None], "is_img"),
                "label": tf.sparse_placeholder(tf.int32, name="label"),
            }
            features.append(feature)

        # session info
        sess = util.get_session(params.gpus)

        start_time = time.time()
        tf.logging.info("Begining Building Training Graph")

        # create global step
        global_step = tf.train.get_or_create_global_step()
        # set up optimizer
        optimizer = tf.train.AdamOptimizer(
            lr, beta1=params.beta1, beta2=params.beta2, epsilon=params.epsilon)

        # get graph
        graph = sltunet
        # set up training graph
        loss, gradients = tower_train_graph(features, optimizer, graph, params)

        # apply parallel operation, accounting gradient accumulation
        vle, ops = cycle.create_train_op(
            {"loss": loss}, gradients, optimizer, global_step, params)
        tf.logging.info(f"End Building Training Graph, within {time.time() - start_time} seconds")

        start_time = time.time()
        tf.logging.info("Begin Building Inferring Graph")

        # set up infer graph
        eval_seqs, eval_scores, eval_attention = tower_infer_graph(features, graph, params)

        tf.logging.info(f"End Building Inferring Graph, within {time.time() - start_time} seconds")

        # initialize the model
        sess.run(tf.global_variables_initializer())

        # log parameters
        util.variable_printer()

        # create saver
        train_saver = saver.Saver(
            checkpoints=params.checkpoints,
            output_dir=params.output_dir,
            best_checkpoints=params.best_checkpoints,
        )

        def run_evaluation(eval_step, save_checkpoint=False):
            """Run full evaluation cycle and optionally save checkpoint."""
            step_label = str(eval_step)
            tf.logging.info(f"Start Evaluating (trigger: {step_label})")
            eval_start_time = time.time()

            tranes, scores, indices, attentions = evalu.decoding(
                sess, features, eval_seqs, eval_scores, dev_dataset, params, eval_attention)

            bleu = evalu.eval_metric(
                tranes, params.tgt_dev_file, indices=indices, remove_bpe=params.remove_bpe)

            metrics_dict = evalu_enhanced.eval_metrics_multi(
                tranes, params.tgt_dev_file, indices=indices, remove_bpe=params.remove_bpe)

            eval_end_time = time.time()
            tf.logging.info("End Evaluating")
            tf.logging.info(
                "{} GStep {}, Scores {}, BLEU {}, Duration {:.3f} s".format(
                    util.time_str(eval_end_time), step_label, np.mean(scores),
                    bleu, eval_end_time - eval_start_time)
            )
            tf.logging.info(
                "Multiple Metrics: BLEU-1={:.4f}, BLEU-2={:.4f}, BLEU-3={:.4f}, BLEU-4={:.4f}, OTEM-2={:.4f}, UTEM-4={:.4f}".format(
                    metrics_dict['bleu1'], metrics_dict['bleu2'], metrics_dict['bleu3'],
                    metrics_dict['bleu4'], metrics_dict['otem2'], metrics_dict['utem4'])
            )

            output_file = os.path.join(params.output_dir, "eval-{}.trans.txt".format(step_label))
            evalu.dump_tanslation(tranes, output_file, indices=indices, attentions=attentions)

            coverage_metrics = evalu.dump_translation_with_reference(
                tranes, output_file, params.tgt_dev_file,
                indices=indices, remove_bpe=params.remove_bpe,
                attentions=attentions, dataset=dev_dataset
            )

            if coverage_metrics:
                tf.logging.info(
                    "Frame Alignment Metrics: CompleteCov={:.2%}, IoU={:.4f}".format(
                        coverage_metrics.get('complete_coverage', 0.0),
                        coverage_metrics.get('avg_iou', 0.0)
                    )
                )

            if save_checkpoint and isinstance(eval_step, (int, np.integer)):
                train_saver.save(sess, eval_step, bleu)

            return {
                "bleu": bleu,
                "metrics": metrics_dict,
                "scores": scores,
                "translations": tranes,
                "indices": indices,
                "attentions": attentions,
                "coverage": coverage_metrics
            }

        tf.logging.info("Training")
        cycle_counter = 0
        data_on_gpu = []
        cum_tokens = []

        # Initialize loss logger
        loss_logger = LossLogger(params.output_dir, plot_freq=10)
        loss_logger.load_history()  # Load any existing history

        # restore parameters
        tf.logging.info("Trying restore pretrained parameters")
        train_saver.restore(sess, path=params.pretrained_model)
        sess.run(tf.assign(global_step, 0))

        tf.logging.info("Trying restore existing parameters")
        train_saver.restore(sess)

        # Immediate evaluation before training starts to verify pipeline health
        try:
            run_evaluation("init", save_checkpoint=False)
        except Exception as e:
            tf.logging.error(f"Initial evaluation failed: {e}")

        # setup learning rate
        params.lrate = params.recorder.lrate
        adapt_lr = get_lr(params)

        start_time = time.time()
        start_epoch = params.recorder.epoch
        for epoch in range(start_epoch, params.epoches + 1):

            params.recorder.epoch = epoch

            tf.logging.info("Training the model for epoch {}".format(epoch))
            size = params.batch_size if params.batch_or_token == 'batch' \
                else params.token_size

            train_queue = queuer.EnQueuer(
                train_dataset.batcher(size,
                                      buffer_size=params.buffer_size,
                                      shuffle=params.shuffle_batch,
                                      train=True),
                lambda x: x,
                worker_processes_num=params.process_num,
                input_queue_size=params.input_queue_size,
                output_queue_size=params.output_queue_size,
            )

            adapt_lr.before_epoch(eidx=epoch)

            for lidx, data in enumerate(train_queue):

                if params.train_continue:
                    if lidx <= params.recorder.lidx:
                        segments = params.recorder.lidx // 5
                        if params.recorder.lidx < 5 or lidx % segments == 0:
                            tf.logging.info(
                                f"Passing {lidx}-th index according to record")

                        continue

                params.recorder.lidx = lidx

                data_on_gpu.append(data)
                # use multiple gpus, and data samples is not enough
                # make sure the data is fully added
                # The actual batch size: batch_size * num_gpus * update_cycle
                if len(params.gpus) > 0 and len(data_on_gpu) < len(params.gpus):
                    continue

                # increase the counter by 1
                cycle_counter += 1

                if cycle_counter == 1:
                    # calculate adaptive learning rate
                    adapt_lr.step(params.recorder.step)

                    # clear internal states
                    sess.run(ops["zero_op"])

                # data feeding to gpu placeholders
                feed_dicts = {}
                for fidx, shard_data in enumerate(data_on_gpu):
                    # define feed_dict
                    feed_dict = {
                        features[fidx]["source"]: shard_data["src"],
                        features[fidx]["target"]: shard_data["tgt"],
                        features[fidx]["image"]: shard_data["img"],
                        features[fidx]["mask"]: shard_data["mask"],
                        features[fidx]["is_img"]: shard_data["is_img"],
                        features[fidx]["label"]: shard_data["spar"],
                        lr: adapt_lr.get_lr(),
                    }
                    feed_dicts.update(feed_dict)

                    # collect target tokens
                    cum_tokens.append(np.sum(shard_data['tgt'] > 0))

                # reset data points on gpus
                data_on_gpu = []

                # internal accumulative gradient collection
                if cycle_counter < params.update_cycle:
                    sess.run(ops["collect_op"], feed_dict=feed_dicts)

                # at the final step, update model parameters
                if cycle_counter == params.update_cycle:
                    cycle_counter = 0

                    # directly update parameters, often this works well
                    if not params.safe_nan:
                        _, loss, gnorm, pnorm, gstep = sess.run(
                            [ops["train_op"], vle["loss"], vle["gradient_norm"], vle["parameter_norm"], global_step],
                            feed_dict=feed_dicts)

                        if np.isnan(loss) or np.isinf(loss) or np.isnan(gnorm) or np.isinf(gnorm):
                            tf.logging.error(f"Nan or Inf raised! Loss {loss} GNorm {gnorm}.")
                            params.recorder.estop = True
                            break
                    else:
                        # Note, applying safe nan can help train the big model, but sacrifice speed
                        loss, gnorm, pnorm, gstep = sess.run(
                            [vle["loss"], vle["gradient_norm"], vle["parameter_norm"], global_step],
                            feed_dict=feed_dicts)

                        if np.isnan(loss) or np.isinf(loss) or np.isnan(gnorm) or np.isinf(gnorm) \
                            or gnorm > params.gnorm_upper_bound:
                            tf.logging.error(
                                f"Nan or Inf raised, GStep {gstep} is passed! Loss {loss} GNorm {gnorm}.")
                            continue

                        sess.run(ops["train_op"], feed_dict=feed_dicts)

                    if gstep % params.disp_freq == 0:
                        end_time = time.time()
                        tf.logging.info(
                            "{} Epoch {}, GStep {}~{}, LStep {}~{}, "
                            "Loss {:.3f}, GNorm {:.3f}, PNorm {:.3f}, Lr {:.5f}, "
                            "Src {}, Tgt {}, Tokens {}, UD {:.3f} s".format(
                                util.time_str(end_time), epoch, gstep - params.disp_freq + 1, gstep,
                                lidx - params.disp_freq + 1, lidx, loss, gnorm, pnorm,
                                adapt_lr.get_lr(), data['src'].shape, data['tgt'].shape,
                                np.sum(cum_tokens), end_time - start_time)
                        )
                        # Log training step
                        loss_logger.log_train_step(
                            step=gstep, epoch=epoch, loss=loss,
                            gnorm=gnorm, pnorm=pnorm, lr=adapt_lr.get_lr()
                        )
                        start_time = time.time()
                        cum_tokens = []

                    # trigger model saver
                    if gstep > 0 and gstep % params.save_freq == 0:
                        train_saver.save(sess, gstep)
                        params.recorder.save_to_json(os.path.join(params.output_dir, "record.json"))

                    # trigger model evaluation
                    if gstep > 0 and gstep % params.eval_freq == 0:
                        eval_results = run_evaluation(gstep, save_checkpoint=True)
                        bleu = eval_results["bleu"]
                        metrics_dict = eval_results["metrics"]
                        scores = eval_results["scores"]
                        # check for early stopping
                        valid_scores = [v[1] for v in params.recorder.valid_script_scores]
                        if len(valid_scores) == 0 or bleu > np.max(valid_scores):
                            params.recorder.bad_counter = 0
                        else:
                            params.recorder.bad_counter += 1

                            if params.recorder.bad_counter > params.estop_patience:
                                params.recorder.estop = True
                                break

                        params.recorder.history_scores.append((int(gstep), float(np.mean(scores))))
                        params.recorder.valid_script_scores.append((int(gstep), float(bleu)))
                        params.recorder.save_to_json(os.path.join(params.output_dir, "record.json"))

                        # Log evaluation step with multiple metrics
                        loss_logger.log_eval_step(
                            step=gstep, eval_loss=float(np.mean(scores)),
                            bleu_score=float(bleu), metrics_dict=metrics_dict
                        )

                        # handle the learning rate decay in a typical manner
                        adapt_lr.after_eval(float(bleu))

                    # trigger temporary sampling
                    if gstep > 0 and gstep % params.sample_freq == 0:
                        tf.logging.info("Start Sampling")
                        decode_seqs, decode_scores = sess.run(
                            [eval_seqs[:1], eval_scores[:1]],
                            feed_dict={
                                features[0]["image"]: data["img"][:5],
                                features[0]["mask"]: data["mask"][:5],
                                features[0]["source"]: data["src"][:5]})
                        tranes, scores = evalu.decode_hypothesis(decode_seqs, decode_scores, params)

                        for sidx in range(min(5, len(scores))):
                            sample_target = evalu.decode_target_token(data['tgt'][sidx], params.tgt_vocab)
                            tf.logging.info("{}-th Target: {}".format(sidx, ' '.join(sample_target)))
                            sample_trans = tranes[sidx]
                            tf.logging.info("{}-th Translation: {}".format(sidx, ' '.join(sample_trans)))

                        tf.logging.info("End Sampling")

                    # trigger stopping
                    if gstep >= params.max_training_steps:
                        # stop running by setting EStop signal
                        params.recorder.estop = True
                        break

                    # should be equal to global_step
                    params.recorder.step = int(gstep)

            if params.recorder.estop:
                tf.logging.info("Early Stopped!")
                break

            # reset to 0
            params.recorder.lidx = -1

            adapt_lr.after_epoch(eidx=epoch)

    tf.logging.info("Your training is finished :)")

    return train_saver.best_score


def evaluate(params):
    # loading dataset
    tf.logging.info("Begin Loading Test Dataset")
    start_time = time.time()
    test_dataset = Dataset(params,
                           params.img_test_file,
                           params.src_test_file,
                           params.src_test_file,
                           params.eval_max_len,
                           params.max_img_len,
                           batch_or_token='batch')
    tf.logging.info(
        "End Loading dataset, within {} seconds".format(time.time() - start_time))

    # Build Graph
    with tf.Graph().as_default():
        features = []
        for fidx in range(max(len(params.gpus), 1)):
            feature = {
                "source": tf.placeholder(tf.int32, [None, None], "source"),
                "image": tf.placeholder(tf.float32, [None, None, params.img_feature_size], "image"),
                "mask": tf.placeholder(tf.float32, [None, None], "mask"),

            }
            features.append(feature)

        # session info
        sess = util.get_session(params.gpus)

        start_time = time.time()
        tf.logging.info("Begining Building Evaluation Graph")

        # get graph
        graph = sltunet

        # set up infer graph
        eval_seqs, eval_scores, eval_attention = tower_infer_graph(features, graph, params)

        tf.logging.info(f"End Building Inferring Graph, within {time.time() - start_time} seconds")

        # initialize the model
        sess.run(tf.global_variables_initializer())

        # log parameters
        util.variable_printer()

        # create saver
        eval_saver = saver.Saver(checkpoints=params.checkpoints, output_dir=params.output_dir)

        # restore parameters
        tf.logging.info("Trying restore existing parameters")
        eval_saver.restore(sess, params.output_dir)

        tf.logging.info("Starting Evaluating")
        eval_start_time = time.time()
        tranes, scores, indices, attentions = evalu.decoding(sess, features, eval_seqs, eval_scores, test_dataset, params, eval_attention)
        bleu = evalu.eval_metric(tranes, params.tgt_test_file, indices=indices, remove_bpe=params.remove_bpe)
        eval_end_time = time.time()

        tf.logging.info(
            "{} Scores {}, BLEU {}, Duration {}s".format(
                util.time_str(eval_end_time), np.mean(scores), bleu, eval_end_time - eval_start_time)
        )

        # save translation
        # Get video path from params if available (for test mode with inference video)
        video_path = getattr(params, 'inference_video_path', None)
        evalu.dump_tanslation(tranes, params.test_output, indices=indices, attentions=attentions, video_path=video_path)

    return bleu


def inference(params):
    # construction sign embeddings
    tf.logging.info("Begin Constructing Sign Embeddings")
    start_time = time.time()

    from smkd.sign_embedder import SignEmbedding
    sign_embedder = SignEmbedding(params.sign_cfg, 
            params.gloss_path, 
            params.img_test_file, 
            params.smkd_model_path, 
            str(params.gpus[0]),
            params.eval_batch_size)
    sign_embeddings = sign_embedder.embed()

    # construct temporay file
    tmp_file = "/tmp/tmpsignembed"
    with open(tmp_file, 'w') as writer:
        for key in sign_embeddings:
            writer.write(key + '\n')
        writer.close()

    tf.logging.info(
        "End Sign Embedding, within {} seconds".format(time.time() - start_time))

    # loading dataset
    tf.logging.info("Begin Loading Test Dataset")
    start_time = time.time()
    test_dataset = Dataset(params,
                           sign_embeddings,
                           tmp_file,
                           tmp_file,
                           params.eval_max_len,
                           params.max_img_len,
                           batch_or_token='batch')
    tf.logging.info(
        "End Loading dataset, within {} seconds".format(time.time() - start_time))

    # Build Graph
    with tf.Graph().as_default():
        features = []
        for fidx in range(max(len(params.gpus), 1)):
            feature = {
                "source": tf.placeholder(tf.int32, [None, None], "source"),
                "image": tf.placeholder(tf.float32, [None, None, params.img_feature_size], "image"),
                "mask": tf.placeholder(tf.float32, [None, None], "mask"),

            }
            features.append(feature)

        # session info
        sess = util.get_session(params.gpus)

        start_time = time.time()
        tf.logging.info("Begining Building Evaluation Graph")

        # get graph
        graph = sltunet

        # set up infer graph
        eval_seqs, eval_scores, eval_attention = tower_infer_graph(features, graph, params)

        tf.logging.info(f"End Building Inferring Graph, within {time.time() - start_time} seconds")

        # initialize the model
        sess.run(tf.global_variables_initializer())

        # log parameters
        util.variable_printer()

        # create saver
        eval_saver = saver.Saver(checkpoints=params.checkpoints, output_dir=params.output_dir)

        # restore parameters
        tf.logging.info("Trying restore existing parameters")
        eval_saver.restore(sess, params.output_dir)

        tf.logging.info("Starting Evaluating")
        eval_start_time = time.time()
        tranes, scores, indices, attentions = evalu.decoding(sess, features, eval_seqs, eval_scores, test_dataset, params, eval_attention)
        eval_end_time = time.time()

        tf.logging.info(
            "{} Scores {}, Duration {}s".format(
                util.time_str(eval_end_time), np.mean(scores), eval_end_time - eval_start_time)
        )

        # save translation
        # Get video path from params if available (for inference mode)
        video_path = getattr(params, 'inference_video_path', None)
        evalu.dump_tanslation(tranes, params.test_output, indices=indices, attentions=attentions, video_path=video_path)