import os import time import tensorflow as tf from copy import deepcopy from collections import defaultdict from tensorboard.plugins.hparams import api as hp from tensorflow.python.eager import context from tensorflow.keras import backend as K from tensorflow.python.ops import summary_ops_v2 from tensorflow.python.summary import summary as tf_summary from tensorflow.python.training.summary_io import SummaryWriterCache from tensorflow.compat.v1.keras.callbacks import TensorBoard, Callback from tensorflow.python.training.session_run_hook import SessionRunHook, SessionRunArgs def _remove_prefix(s, prefix): if s.startswith(prefix): s = s[len(prefix):] return s def _parse_precision(hparams: dict): # Check if 'hparams' contain data type. if 'dtype' in hparams or 'data_type' in hparams: param_name = 'dtype' if 'dtype' in hparams else 'data_type' return hparams[param_name] # Check if bf16 conversion flags are set. flag = os.environ.get('TF_BF16_CONVERSION', '0') flag = flag.lower() try: value = int(flag) except: value = -1 if flag == 'false' or value == 0: return 'fp32' elif flag == 'true' or value == 1: return 'bf16' return flag def _set_precision_if_missing(hparams: dict): if 'precision' not in hparams: hparams['precision'] = _parse_precision(hparams) return hparams def _copy_and_clean_hparams(hparams: dict): hparams_ = dict() for name, value in hparams.items(): if isinstance(value, (str, bool, int, float)): hparams_[name] = value continue try: hparams_[name] = str(value) except: tf.compat.v1.logging.info( f'Conversion of parameter "{name}" to string failed. ' 'Parameter will not be saved.') return hparams_ def write_hparams_v1(writer, hparams: dict): hparams = _copy_and_clean_hparams(hparams) hparams = _set_precision_if_missing(hparams) with tf.compat.v1.Graph().as_default(): if isinstance(writer, str): writer = SummaryWriterCache.get(writer) summary = hp.hparams_pb(hparams).SerializeToString() writer.add_summary(summary) def write_hparams_v2(writer, hparams: dict): hparams = _copy_and_clean_hparams(hparams) hparams = _set_precision_if_missing(hparams) with writer.as_default(): hp.hparams(hparams) class ExamplesPerSecondEstimatorHook(tf.compat.v1.train.StepCounterHook): """Calculate and report global_step/sec and examples/sec during runtime.""" # Copy-pasted from tensorflow_estimator/python/estimator/tpu/tpu_estimator.py def __init__(self, batch_size=None, every_n_steps=1, every_n_secs=None, output_dir=None, summary_writer=None, extra_metrics=None, log_global_step=False, verbose=False, tags_to_print=None): super().__init__( every_n_steps=every_n_steps, every_n_secs=every_n_secs, output_dir=output_dir, summary_writer=summary_writer) self._metrics = extra_metrics or {} self._verbose = verbose self._tags_to_print = tags_to_print if log_global_step: # Because estimator will log global_step/sec by default # when log_step_count_steps is not None saving it here # would duplicate events in TensorBoard. # Use log_global_step=True when RunConfig.log_step_count_step=None self._metrics['global_step/sec'] = 1 if batch_size is not None: self._metrics['examples/sec'] = batch_size def _add_summary(self, tag, value, step): Summary = tf.compat.v1.Summary global_step_summary = Summary(value=[ Summary.Value(tag=tag, simple_value=value) ]) self._summary_writer.add_summary(global_step_summary, step) if (self._verbose or (self._tags_to_print is not None and tag in self._tags_to_print)): tf.compat.v1.logging.info(f'{tag}: {value}') def _log_and_record(self, elapsed_steps, elapsed_time, global_step): global_step_per_sec = elapsed_steps / elapsed_time if self._summary_writer is not None: for name, factor in self._metrics.items(): value = factor * global_step_per_sec self._add_summary(name, value, global_step) def after_create_session(self, session, coord): self._timer.reset() class ExamplesPerSecondKerasHookV1(Callback): def __init__(self, every_n_steps=1, every_n_secs=None, output_dir=None, summary_writer=None, batch_size=None): self.writer = summary_writer or SummaryWriterCache.get(output_dir) self._timer = tf.compat.v1.train.SecondOrStepTimer( every_n_secs, every_n_steps) self._global_step = 0 self._total_examples = 0 self._should_trigger = True self._batch_size = batch_size def on_train_begin(self, logs=None): self._timer.reset() def on_train_batch_begin(self, batch, logs=None): # batch is index within current epoch, if we want to dump data through all epochs then we need to use global_step self._should_trigger = self._timer.should_trigger_for_step(self._global_step) def on_predict_batch_end(self, batch, logs=None): self._global_step += 1 def on_train_batch_end(self, batch, logs=None): step = self._global_step self._total_examples += logs.get('size', 0) if self._should_trigger: elapsed_time, elapsed_steps = self._timer.update_last_triggered_step( step) if elapsed_time is not None: total_examples = self._total_examples if self._batch_size is not None: total_examples = self._batch_size * elapsed_steps self._log_and_record( elapsed_steps, elapsed_time, step, total_examples) self._total_examples = 0 self._global_step += 1 def _log_and_record(self, elapsed_steps, elapsed_time, global_step, total_examples=None): Summary = tf.compat.v1.Summary global_step_per_sec = elapsed_steps / elapsed_time if self.writer is not None: global_step_summary = Summary(value=[ Summary.Value( tag='global_step/sec', simple_value=global_step_per_sec) ]) self.writer.add_summary(global_step_summary, global_step) if total_examples is not None: examples_per_sec = total_examples / elapsed_time example_summary = Summary(value=[ Summary.Value(tag='examples/sec', simple_value=examples_per_sec) ]) self.writer.add_summary(example_summary, global_step) class ExamplesPerSecondKerasHookV2(ExamplesPerSecondKerasHookV1): def __init__(self, every_n_steps=1, every_n_secs=None, output_dir=None, summary_writer=None, batch_size=None): writer = summary_writer or summary_ops_v2.create_file_writer_v2(output_dir) super().__init__(every_n_steps, every_n_secs, output_dir, writer, batch_size) def _log_and_record(self, elapsed_steps, elapsed_time, global_step, total_examples=None): global_step_per_sec = elapsed_steps / elapsed_time if self.writer is not None: with self.writer.as_default(), summary_ops_v2.always_record_summaries(): summary_ops_v2.scalar('global_step/sec', global_step_per_sec, step=global_step) if total_examples is not None: examples_per_sec = total_examples / elapsed_time summary_ops_v2.scalar('examples/sec', examples_per_sec, step=global_step) ExamplesPerSecondKerasHook = ExamplesPerSecondKerasHookV1 class TBSummary(object): """ Creates a proxy for FileWriter for TensorBoard. :param log_dir: - path where experiment is running (usually the same as model_dir in Estimator) """ def __init__(self, log_dir: str): super().__init__() self._log_dir = log_dir def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): pass def add_scalar(self, tag, value, global_step=None): with tf.compat.v1.Graph().as_default(): writer = SummaryWriterCache.get(self._log_dir) summary = tf.compat.v1.Summary( value=[tf.compat.v1.Summary.Value(tag=tag, simple_value=value)]) event = tf.compat.v1.Event(summary=summary) event.wall_time = time.time() event.step = global_step writer.add_event(event) class TensorBoardWithHParamsV1(TensorBoard): """ Adds TensorBoard visualization to training process. Writes training tfevent file into default log directory, but stores evaluation in log_dir/eval subdirectory. """ def __init__(self, hparams, *args, **kwargs): super().__init__(*args, **kwargs) self.hparams = hparams self._train_summary = None self._eval_summary = None def _switch_writer(self, mode): self.writer = self._train_summary if mode == 'train' else self._eval_summary def _init_writer(self, model): """Sets file writer.""" if context.executing_eagerly(): raise NotImplementedError('hook does not support eager execution') self._train_summary = SummaryWriterCache.get(self.log_dir) self._eval_summary = SummaryWriterCache.get( os.path.join(self.log_dir, 'eval')) self._switch_writer('train') write_hparams_v1(self.writer, self.hparams) def _write_custom_summaries(self, step, logs=None): """ This methods works on the assumption that metrics containing `val` in name are related to validation (that's the default in Keras). """ logs = logs or {} train_logs = {} eval_logs = {} for name, value in logs.items(): if 'val' in name: if name.startswith('batch_val_'): name = 'batch_' + _remove_prefix(name, 'batch_val_') elif name.startswith('epoch_val_'): name = _remove_prefix(name, 'epoch_val_') eval_logs[name] = value else: if name.startswith('batch_'): name = _remove_prefix(name, 'batch_') train_logs[name] = value self._switch_writer('eval') super()._write_custom_summaries(step, eval_logs) self._switch_writer('train') super()._write_custom_summaries(step, train_logs) class TensorBoardWithHParamsV2(TensorBoard): """ Adds TensorBoard visualization to training process. Writes training tfevent file into default log directory, but stores evaluation in log_dir/eval subdirectory. """ def __init__(self, hparams, *args, **kwargs): super().__init__(*args, **kwargs) self.hparams = hparams def set_model(self, model): """Sets Keras model and writes graph if specified.""" self.model = model self._log_write_dir = self._get_log_write_dir() self._train_dir = self._log_write_dir self._train_step = self.model._train_counter # pylint: disable=protected-access self._val_dir = os.path.join(self._log_write_dir, 'eval') self._val_step = self.model._test_counter # pylint: disable=protected-access self._writers = {} # Resets writers. self._should_write_train_graph = False if self.write_graph: self._write_keras_model_summary() self._should_write_train_graph = True if self.embeddings_freq: self._configure_embeddings() write_hparams_v2(self._train_writer, self.hparams) def _log_epoch_metrics(self, epoch, logs): """Writes epoch metrics out as scalar summaries. Arguments: epoch: Int. The global step to use for TensorBoard. logs: Dict. Keys are scalar summary names, values are scalars. """ if not logs: return train_logs = {k: v for k, v in logs.items() if not k.startswith('val_')} val_logs = {k: v for k, v in logs.items() if k.startswith('val_')} train_logs = self._collect_learning_rate(train_logs) with summary_ops_v2.always_record_summaries(): if train_logs: with self._train_writer.as_default(): for name, value in train_logs.items(): summary_ops_v2.scalar(name, value, step=epoch) if val_logs: with self._val_writer.as_default(): for name, value in val_logs.items(): name = name[4:] # Remove 'val_' prefix. summary_ops_v2.scalar(name, value, step=epoch) class TensorBoardHook(SessionRunHook): def __init__(self, output_dir="", profile_steps="" ): self.output_dir = output_dir profile_steps_error_message = ( 'profile_steps must be a comma separated pair of positive integers, ' 'specifying the first and last steps to be profiled.' ) try: profile_steps = [int(i) for i in profile_steps.split(',')] except ValueError: raise ValueError(profile_steps_error_message) if len(profile_steps) != 2: raise ValueError(profile_steps_error_message) self.start_step, self.stop_step = profile_steps if self.start_step < 0 or self.start_step > self.stop_step: raise ValueError(profile_steps_error_message) self._step = 0 def before_run(self, run_context): self._step += 1 if self._step == self.start_step: tf.profiler.experimental.start(self.output_dir) elif self._step == self.stop_step + 1: tf.profiler.experimental.stop() return SessionRunArgs({}) class TimeToTrainKerasHook(Callback): def __init__(self, output_dir=None, summary_writer=None): self.writer = summary_writer or summary_ops_v2.create_file_writer_v2(output_dir) self.counters = defaultdict(int) def _add_event(self, tag, step): if self.writer is not None: with self.writer.as_default(), summary_ops_v2.always_record_summaries(): summary_ops_v2.scalar(tag, 0, step=step) def on_epoch_begin(self, epoch, logs=None): self._add_event("ttt/train/epoch/begin", epoch) def on_epoch_end(self, epoch, logs=None): self._add_event("ttt/train/epoch/end", epoch) def on_train_begin(self, logs=None): self._add_event("ttt/train/begin", self.counters["train"]) def on_train_end(self, logs=None): self._add_event("ttt/train/end", self.counters["train"]) self.counters["train"] += 1 def on_test_begin(self, logs=None): self._add_event("ttt/eval/begin", self.counters["eval"]) def on_test_end(self, logs=None): self._add_event("ttt/eval/end", self.counters["eval"]) self.counters["eval"] += 1 def on_predict_begin(self, logs=None): self._add_event("ttt/predict/begin", self.counters["predict"]) def on_predict_end(self, logs=None): self._add_event("ttt/predict/end", self.counters["predict"]) self.counters["predict"] += 1 class TimeToTrainEstimatorHook(tf.estimator.SessionRunHook): def __init__(self, train_or_eval, output_dir): assert train_or_eval in ("eval", "train") self._summary_writer = None self._output_dir = output_dir self._tag = train_or_eval self._counter = 0 def _add_event(self, tag, value): summary = tf.compat.v1.Summary( value=[ tf.compat.v1.Summary.Value( tag=tag, simple_value=0) ] ) event = tf.compat.v1.Event(summary=summary) event.wall_time = time.time() event.step = self._counter self._summary_writer.add_event(event) def begin(self): if self._summary_writer is None and self._output_dir: self._summary_writer = SummaryWriterCache.get(self._output_dir) self._add_event(f"ttt/{self._tag}/begin", self._counter) def after_create_session(self, session, coord): pass def before_run(self, run_context): pass def after_run(self, run_context, run_values): pass def end(self, session): self._add_event(f"ttt/{self._tag}/end", self._counter) self._counter += 1