Add logging of units to dllogger metrics

DGLPyTorch/DrugDiscovery/SE3Transformer/se3_transformer/runtime/callbacks.py

@@ -64,6 +64,8 @@ class LRSchedulerCallback(BaseCallback):
         self.logger = logger
         self.scheduler = None
 
+        self.logger.log_metadata('learning rate', {'unit': None})
+
     @abstractmethod
     def get_scheduler(self, optimizer, args):
         pass
@@ -93,6 +95,9 @@ class QM9MetricCallback(BaseCallback):
         self.prefix = prefix
         self.best_mae = float('inf')
 
+        self.logger.log_metadata(f'{self.prefix} MAE', {'unit': None})
+        self.logger.log_metadata(f'{self.prefix} best MAE', {'unit': None})
+
     def on_validation_step(self, input, target, pred):
         self.mae(pred.detach(), target.detach())
 
@@ -126,6 +131,12 @@ class PerformanceCallback(BaseCallback):
         self.mode = mode
         self.logger = logger
 
+        logger.log_metadata(f"throughput_{self.mode}", {'unit': 'molecules/s'})
+        logger.log_metadata(f"total_time_{self.mode}", {'unit': 's'})
+        logger.log_metadata(f"latency_{self.mode}_mean", {'unit': 's'})
+        for level in [90, 95, 99]:
+            logger.log_metadata(f"latency_{self.mode}_{level}", {'unit': 's'})
+
     def on_batch_start(self):
         if self.epoch >= self.warmup_epochs:
             self.timestamps.append(time.time() * 1000.0)

DGLPyTorch/DrugDiscovery/SE3Transformer/se3_transformer/runtime/loggers.py

@@ -40,6 +40,11 @@ class Logger(ABC):
     def log_hyperparams(self, params):
         pass
 
+    @rank_zero_only
+    @abstractmethod
+    def log_metadata(self, metric, metadata):
+        pass
+
     @rank_zero_only
     @abstractmethod
     def log_metrics(self, metrics, step=None):
@@ -81,6 +86,11 @@ class LoggerCollection(Logger):
         for logger in self.loggers:
             logger.log_hyperparams(params)
 
+    @rank_zero_only
+    def log_metadata(self, metric, metadata):
+        for logger in self.loggers:
+            logger.log_metadata(metric, metadata)
+
 
 class DLLogger(Logger):
     def __init__(self, save_dir: pathlib.Path, filename: str):
@@ -95,6 +105,10 @@ class DLLogger(Logger):
         params = self._sanitize_params(params)
         dllogger.log(step="PARAMETER", data=params)
 
+    @rank_zero_only
+    def log_metadata(self, metric, metadata):
+        dllogger.metadata(metric, metadata)
+
     @rank_zero_only
     def log_metrics(self, metrics, step=None):
         if step is None:
@@ -126,6 +140,10 @@ class WandbLogger(Logger):
         params = self._sanitize_params(params)
         self.experiment.config.update(params, allow_val_change=True)
 
+    @rank_zero_only
+    def log_metadata(self, metric, metadata):
+        pass
+
     @rank_zero_only
     def log_metrics(self, metrics: Dict[str, float], step: Optional[int] = None) -> None:
         if step is not None:

MxNet/Classification/RN50v1.5/log_utils.py

@@ -31,3 +31,11 @@ def setup_logging(args):
         ])
     else:
         dllogger.init([])
+
+    dllogger.metadata("val.accuracy", {"unit": None})
+    dllogger.metadata("val.top_k_accuracy_5", {"unit": None})
+    dllogger.metadata("train.ips", {"unit": "images/s"})
+    dllogger.metadata("val.ips", {"unit": "images/s"})
+    dllogger.metadata("val.latency_50", {"unit": "s"})
+    dllogger.metadata("val.latency_90", {"unit": "s"})
+    dllogger.metadata("val.latency_avg", {"unit": "s"})

PyTorch/Classification/ConvNets/image_classification/logger.py

@@ -338,10 +338,10 @@ class Logger(object):
 
 class Metrics:
     ACC_METADATA = {"unit": "%", "format": ":.2f"}
-    IPS_METADATA = {"unit": "img/s", "format": ":.2f"}
+    IPS_METADATA = {"unit": "images/s", "format": ":.2f"}
     TIME_METADATA = {"unit": "s", "format": ":.5f"}
-    LOSS_METADATA = {"format": ":.5f"}
-    LR_METADATA = {"format": ":.5f"}
+    LOSS_METADATA = {"unit": None, "format": ":.5f"}
+    LR_METADATA = {"unit": None, "format": ":.5f"}
 
     def __init__(self, logger):
         self.logger = logger

PyTorch/Classification/GPUNet/train.py

@@ -1100,6 +1100,11 @@ def main():
         )
     else:
         dllogger.init(backends=[])
+
+    dllogger.metadata("top1", {"unit": None})
+    dllogger.metadata("top5", {"unit": None})
+    dllogger.metadata("average_ips", {"unit": "images/s"})
+
     data_config = resolve_data_config(
         vars(args), model=model, verbose=args.local_rank == 0
     )

PyTorch/Detection/Efficientdet/train.py

@@ -275,6 +275,13 @@ def main():
     assert args.rank >= 0
 
     setup_dllogger(args.rank, filename=args.dllogger_file)
+    dllogger.metadata('eval_batch_time', {'unit': 's'})
+    dllogger.metadata('train_batch_time', {'unit': 's'})
+    dllogger.metadata('eval_throughput', {'unit': 'images/s'})
+    dllogger.metadata('train_throughout', {'unit': 'images/s'})
+    dllogger.metadata('eval_loss', {'unit': None})
+    dllogger.metadata('train_loss', {'unit': None})
+    dllogger.metadata('map', {'unit': None})
 
     if args.distributed:
         logging.info('Training in distributed mode with multiple processes, 1 GPU per process. Process %d, total %d.'

PyTorch/Detection/Efficientdet/validate.py

@@ -114,6 +114,11 @@ parser.add_argument('--waymo-val-annotation', default=None, type=str,
 
 def validate(args):
     setup_dllogger(0, filename=args.dllogger_file)
+    dllogger.metadata('total_inference_time', {'unit': 's'})
+    dllogger.metadata('inference_throughput', {'unit': 'images/s'})
+    dllogger.metadata('inference_time', {'unit': 's'})
+    dllogger.metadata('map', {'unit': None})
+    dllogger.metadata('total_eval_time', {'unit': 's'})
 
     if args.checkpoint != '':
         args.pretrained = True

PyTorch/Detection/SSD/ssd/logger.py

@@ -66,6 +66,7 @@ class Logger:
             backends.append(DLLogger.JSONStreamBackend(DLLogger.Verbosity.VERBOSE, json_output))
 
         DLLogger.init(backends)
+        DLLogger.metadata("mAP", {"unit": None})
 
         self.epoch = 0
         self.train_iter = 0
@@ -137,6 +138,11 @@ class BenchLogger(Logger):
         super().__init__(*args, **kwargs)
         self.images_per_ses = BenchmarkMeter(self.name)
 
+        DLLogger.metadata("avg_img/sec", {"unit": "images/s"})
+        DLLogger.metadata("med_img/sec", {"unit": "images/s"})
+        DLLogger.metadata("min_img/sec", {"unit": "images/s"})
+        DLLogger.metadata("max_img/sec", {"unit": "images/s"})
+
     def update(self, bs, time):
         self.images_per_ses.update(bs, time)
 

PyTorch/Forecasting/TFT/log_helper.py

@@ -101,23 +101,26 @@ def setup_logger(args):
     container_setup_info = {**get_framework_env_vars(), **get_system_info()}
     dllogger.log(step='ENVIRONMENT', data=container_setup_info, verbosity=0)
 
-    dllogger.metadata('loss', {'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN', 'format': ':5f'})
-    dllogger.metadata('P10', {'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN', 'format': ':5f'})
-    dllogger.metadata('P50', {'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN', 'format': ':5f'})
-    dllogger.metadata('P90', {'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN', 'format': ':5f'})
-    dllogger.metadata('items/s', {'GOAL': 'MAXIMIZE', 'STAGE': 'TRAIN', 'format': ':1f'})
-    dllogger.metadata('val_loss', {'GOAL': 'MINIMIZE', 'STAGE': 'VAL', 'format':':5f'})
-    dllogger.metadata('val_P10', {'GOAL': 'MINIMIZE', 'STAGE': 'VAL', 'format': ':5f'})
-    dllogger.metadata('val_P50', {'GOAL': 'MINIMIZE', 'STAGE': 'VAL', 'format': ':5f'})
-    dllogger.metadata('val_P90', {'GOAL': 'MINIMIZE', 'STAGE': 'VAL', 'format': ':5f'})
-    dllogger.metadata('val_items/s', {'GOAL': 'MAXIMIZE', 'STAGE': 'VAL', 'format': ':1f'})
-    dllogger.metadata('test_P10', {'GOAL': 'MINIMIZE', 'STAGE': 'TEST', 'format': ':5f'})
-    dllogger.metadata('test_P50', {'GOAL': 'MINIMIZE', 'STAGE': 'TEST', 'format': ':5f'})
-    dllogger.metadata('test_P90', {'GOAL': 'MINIMIZE', 'STAGE': 'TEST', 'format': ':5f'})
-    dllogger.metadata('throughput', {'GOAL': 'MAXIMIZE', 'STAGE': 'TEST', 'format': ':1f'})
-    dllogger.metadata('latency_p90', {'GOAL': 'MIMIMIZE', 'STAGE': 'TEST', 'format': ':5f'})
-    dllogger.metadata('latency_p95', {'GOAL': 'MIMIMIZE', 'STAGE': 'TEST', 'format': ':5f'})
-    dllogger.metadata('latency_p99', {'GOAL': 'MIMIMIZE', 'STAGE': 'TEST', 'format': ':5f'})
+    dllogger.metadata('loss', {'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN', 'format': ':5f', 'unit': None})
+    dllogger.metadata('P10', {'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN', 'format': ':5f', 'unit': None})
+    dllogger.metadata('P50', {'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN', 'format': ':5f', 'unit': None})
+    dllogger.metadata('P90', {'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN', 'format': ':5f', 'unit': None})
+    dllogger.metadata('items/s', {'GOAL': 'MAXIMIZE', 'STAGE': 'TRAIN', 'format': ':1f', 'unit': 'items/s'})
+    dllogger.metadata('val_loss', {'GOAL': 'MINIMIZE', 'STAGE': 'VAL', 'format':':5f', 'unit': None})
+    dllogger.metadata('val_P10', {'GOAL': 'MINIMIZE', 'STAGE': 'VAL', 'format': ':5f', 'unit': None})
+    dllogger.metadata('val_P50', {'GOAL': 'MINIMIZE', 'STAGE': 'VAL', 'format': ':5f', 'unit': None})
+    dllogger.metadata('val_P90', {'GOAL': 'MINIMIZE', 'STAGE': 'VAL', 'format': ':5f', 'unit': None})
+    dllogger.metadata('val_items/s', {'GOAL': 'MAXIMIZE', 'STAGE': 'VAL', 'format': ':1f', 'unit': 'items/s'})
+    dllogger.metadata('test_P10', {'GOAL': 'MINIMIZE', 'STAGE': 'TEST', 'format': ':5f', 'unit': None})
+    dllogger.metadata('test_P50', {'GOAL': 'MINIMIZE', 'STAGE': 'TEST', 'format': ':5f', 'unit': None})
+    dllogger.metadata('test_P90', {'GOAL': 'MINIMIZE', 'STAGE': 'TEST', 'format': ':5f', 'unit': None})
+    dllogger.metadata('sum', {'GOAL': 'MINIMIZE', 'STAGE': 'TEST', 'format': ':5f', 'unit': None})
+    dllogger.metadata('throughput', {'GOAL': 'MAXIMIZE', 'STAGE': 'TEST', 'format': ':1f', 'unit': 'items/s'})
+    dllogger.metadata('latency_avg', {'GOAL': 'MIMIMIZE', 'STAGE': 'TEST', 'format': ':5f', 'unit': 's'})
+    dllogger.metadata('latency_p90', {'GOAL': 'MIMIMIZE', 'STAGE': 'TEST', 'format': ':5f', 'unit': 's'})
+    dllogger.metadata('latency_p95', {'GOAL': 'MIMIMIZE', 'STAGE': 'TEST', 'format': ':5f', 'unit': 's'})
+    dllogger.metadata('latency_p99', {'GOAL': 'MIMIMIZE', 'STAGE': 'TEST', 'format': ':5f', 'unit': 's'})
+    dllogger.metadata('average_ips', {'GOAL': 'MAXIMIZE', 'STAGE': 'TEST', 'format': ':1f', 'unit': 'items/s'})
 
 
 def get_framework_env_vars():

PyTorch/LanguageModeling/BART/finetune.py

@@ -560,6 +560,9 @@ if __name__ == "__main__":
     else:
         dllogger.init(backends=[])
 
+    dllogger.metadata("avg_train_time", {"unit": "s"})
+    dllogger.metadata("avg_train_throughput", {"unit": "tokens/s"})
+
     main(args)
 
     dllogger.flush()

PyTorch/LanguageModeling/BART/run_eval.py

@@ -291,6 +291,10 @@ def run_generate(verbose=True):
     else:
         dllogger.init(backends=[])
 
+    dllogger.metadata("inference_throughput_mean", {"unit": "tokens/s"})
+    for suffix in ["mean", "conf_50", "conf_90", "conf_95", "conf_99", "conf_100"]:
+        dllogger.metadata(f"inference_latency_{suffix}", {"unit": "s"})
+
     if parsed_args and verbose:
         print(f"parsed the following generate kwargs: {parsed_args}")
 

PyTorch/LanguageModeling/BERT/run_glue.py

@@ -486,6 +486,13 @@ def main(args):
     else:
         dllogger.init(backends=[])
 
+    dllogger.metadata("e2e_train_time", {"unit": "s"})
+    dllogger.metadata("training_sequences_per_second", {"unit": "sequences/s"})
+    dllogger.metadata("e2e_inference_time", {"unit": "s"})
+    dllogger.metadata("inference_sequences_per_second", {"unit": "sequences/s"})
+    dllogger.metadata("exact_match", {"unit": None})
+    dllogger.metadata("F1", {"unit": None})
+
     dllogger.log(step="PARAMETER", data={"Config": [str(args)]})
 
     if args.gradient_accumulation_steps < 1:

PyTorch/LanguageModeling/BERT/run_pretraining.py

@@ -345,6 +345,11 @@ def setup_training(args):
     else:
         dllogger.init(backends=[])
 
+    dllogger.metadata("e2e_train_time", {"unit": "s"})
+    dllogger.metadata("training_sequences_per_second", {"unit": "sequences/s"})
+    dllogger.metadata("final_loss", {"unit": None})
+    dllogger.metadata("raw_train_time", {"unit": "s"})
+
     print("device: {} n_gpu: {}, distributed training: {}, 16-bits training: {}".format(
         device, args.n_gpu, bool(args.local_rank != -1), args.fp16))
 

PyTorch/LanguageModeling/BERT/run_squad.py

@@ -875,6 +875,14 @@ def main():
                                 dllogger.StdOutBackend(verbosity=dllogger.Verbosity.VERBOSE, step_format=format_step)])
     else:
         dllogger.init(backends=[])
+    
+    dllogger.metadata("e2e_train_time", {"unit": "s"})
+    dllogger.metadata("training_sequences_per_second", {"unit": "sequences/s"})
+    dllogger.metadata("final_loss", {"unit": None})
+    dllogger.metadata("e2e_inference_time", {"unit": "s"})
+    dllogger.metadata("inference_sequences_per_second", {"unit": "sequences/s"})
+    dllogger.metadata("exact_match", {"unit": None})
+    dllogger.metadata("F1", {"unit": None})
 
     print("device: {} n_gpu: {}, distributed training: {}, 16-bits training: {}".format(
                                 device, n_gpu, bool(args.local_rank != -1), args.fp16))

PyTorch/LanguageModeling/Transformer-XL/pytorch/eval.py

@@ -308,6 +308,14 @@ def main():
     logging.info(args)
     dllogger.log(step='PARAMETER', data=vars(args))
 
+    dllogger.metadata('eval_throughput', {'unit': 'tokens/s'})
+    dllogger.metadata('eval_loss', {'unit': None})
+    dllogger.metadata('eval_perplexity', {'unit': None})
+    dllogger.metadata('eval_latency', {'unit': 'ms'})
+    dllogger.metadata('eval_avg_latency', {'unit': 'ms'})
+    for p in args.percentiles:
+        dllogger.metadata(f'eval_{p}%_latency', {'unit': 'ms'})
+
     if not args.no_env:
         log_env_info()
 

PyTorch/LanguageModeling/Transformer-XL/pytorch/train.py

@@ -752,6 +752,14 @@ def main():
     logging.info(args)
     dllogger.log(step='PARAMETER', data=vars(args))
 
+    dllogger.metadata('train_throughput', {'unit': 'tokens/s'})
+    dllogger.metadata('train_elapsed', {'unit': 'min'})
+    dllogger.metadata('valid_elapsed', {'unit': 'min'})
+    dllogger.metadata('train_perplexity', {'unit': None})
+    dllogger.metadata('valid_perplexity', {'unit': None})
+    dllogger.metadata('train_loss', {'unit': None})
+    dllogger.metadata('valid_loss', {'unit': None})
+
     logging.info(f'world size: {utils.distributed.get_world_size()}')
 
     if not args.no_env:

PyTorch/Recommendation/DLRM/dlrm/scripts/utils.py

@@ -192,6 +192,15 @@ def init_logging(log_path):
 
     dllogger.init(backends=[json_backend, stdout_backend])
 
+    dllogger.metadata("best_auc", {"unit": None})
+    dllogger.metadata("mean_inference_latency_batch_1", {"unit": "s"})
+    dllogger.metadata("mean_inference_latency_batch_64", {"unit": "s"})
+    dllogger.metadata("mean_inference_latency_batch_4096", {"unit": "s"})
+    dllogger.metadata("average_train_throughput", {"unit": "samples/s"})
+    dllogger.metadata("mean_inference_throughput_batch_1", {"unit": "samples/s"})
+    dllogger.metadata("mean_inference_throughput_batch_64", {"unit": "samples/s"})
+    dllogger.metadata("mean_inference_throughput_batch_4096", {"unit": "samples/s"})
+
 
 class StepTimer():
     def __init__(self):

PyTorch/Recommendation/NCF/inference.py

@@ -59,6 +59,8 @@ def main():
 
     dllogger.log(data=vars(args), step='PARAMETER')
 
+
+
     model = NeuMF(nb_users=args.n_users, nb_items=args.n_items, mf_dim=args.factors,
                   mlp_layer_sizes=args.layers, dropout=args.dropout)
 
@@ -100,6 +102,11 @@ def main():
         result_data[f'batch_{batch_size}_p95_latency'] = np.percentile(latencies, 95)
         result_data[f'batch_{batch_size}_p99_latency'] = np.percentile(latencies, 99)
 
+    for batch_size in batch_sizes:
+        dllogger.metadata(f'batch_{batch_size}_mean_throughput', {'unit': 'samples/s'})
+        for p in ['mean', 'p90', 'p95', 'p99']:
+            dllogger.metadata(f'batch_{batch_size}_{p}_latency', {'unit': 's'})
+
     dllogger.log(data=result_data, step=tuple())
     dllogger.flush()
     return

PyTorch/Recommendation/NCF/ncf.py

@@ -178,11 +178,19 @@ def main():
     else:
         dllogger.init(backends=[])
 
-    dllogger.metadata('train_throughput', {"name": 'train_throughput', 'format': ":.3e"})
-    dllogger.metadata('hr@10', {"name": 'hr@10', 'format': ":.5f"})
-    dllogger.metadata('train_epoch_time', {"name": 'train_epoch_time', 'format': ":.3f"})
-    dllogger.metadata('validation_epoch_time', {"name": 'validation_epoch_time', 'format': ":.3f"})
-    dllogger.metadata('eval_throughput', {"name": 'eval_throughput', 'format': ":.3e"})
+    dllogger.metadata('train_throughput', {"name": 'train_throughput', 'unit': 'samples/s', 'format': ":.3e"})
+    dllogger.metadata('best_train_throughput', {'unit': 'samples/s'})
+    dllogger.metadata('mean_train_throughput', {'unit': 'samples/s'})
+    dllogger.metadata('eval_throughput', {"name": 'eval_throughput', 'unit': 'samples/s', 'format': ":.3e"})
+    dllogger.metadata('best_eval_throughput', {'unit': 'samples/s'})
+    dllogger.metadata('mean_eval_throughput', {'unit': 'samples/s'})
+    dllogger.metadata('train_epoch_time', {"name": 'train_epoch_time', 'unit': 's', 'format': ":.3f"})
+    dllogger.metadata('validation_epoch_time', {"name": 'validation_epoch_time', 'unit': 's', 'format': ":.3f"})
+    dllogger.metadata('time_to_target', {'unit': 's'})
+    dllogger.metadata('time_to_best_model', {'unit': 's'})
+    dllogger.metadata('hr@10', {"name": 'hr@10', 'unit': None, 'format': ":.5f"})
+    dllogger.metadata('best_accuracy', {'unit': None})
+    dllogger.metadata('best_epoch', {'unit': None})
 
     dllogger.log(data=vars(args), step='PARAMETER')
 

PyTorch/Segmentation/MaskRCNN/pytorch/tools/test_net.py

@@ -88,6 +88,14 @@ def main():
     else:
         dllogger.init(backends=[])
 
+    dllogger.metadata("BBOX_mAP", {"unit": None})
+    dllogger.metadata("MASK_mAP", {"unit": None})
+    dllogger.metadata("e2e_infer_time", {"unit": "s"})
+    dllogger.metadata("inference_perf_fps", {"unit": "images/s"})
+    dllogger.metadata("latency_avg", {"unit": "s"})
+    dllogger.metadata("latency_90", {"unit": "s"})
+    dllogger.metadata("latency_95", {"unit": "s"})
+    dllogger.metadata("latency_99", {"unit": "s"})
 
     save_dir = ""
     dllogger.log(step="PARAMETER", data={"config":cfg})

PyTorch/Segmentation/MaskRCNN/pytorch/tools/train_net.py

@@ -265,6 +265,11 @@ def main():
     else:
         dllogger.init(backends=[])
 
+    dllogger.metadata("BBOX_mAP", {"unit": None})
+    dllogger.metadata("MASK_mAP", {"unit": None})
+    dllogger.metadata("e2e_train_time", {"unit": "s"})
+    dllogger.metadata("train_perf_fps", {"unit": "images/s"})
+
     dllogger.log(step="PARAMETER", data={"gpu_count":num_gpus})
     # dllogger.log(step="PARAMETER", data={"environment_info": collect_env_info()})
     dllogger.log(step="PARAMETER", data={"config_file": args.config_file})

PyTorch/Segmentation/nnUNet/utils/logger.py

@@ -41,6 +41,10 @@ class DLLogger:
             step = ()
         logger.log(step=step, data=metrics)
 
+    @rank_zero_only
+    def log_metadata(self, metric, metadata):
+        logger.metadata(metric, metadata)
+
     @rank_zero_only
     def flush(self):
         logger.flush()
@@ -56,6 +60,12 @@ class LoggingCallback(Callback):
         self.mode = mode
         self.timestamps = []
 
+        self.dllogger.log_metadata(f"dice_score", {"unit": None})
+        self.dllogger.log_metadata(f"throughput_{self.mode}", {"unit": "images/s"})
+        self.dllogger.log_metadata(f"latency_{self.mode}_mean", {"unit": "ms"})
+        for level in [90, 95, 99]:
+            self.dllogger.log_metadata(f"latency_{self.mode}_{level}", {"unit": "ms"})
+
     def do_step(self):
         self.step += 1
         if self.step > self.warmup_steps:

PyTorch/SpeechRecognition/Jasper/common/tb_dllogger.py

@@ -103,19 +103,19 @@ def init_log(args):
         backends = []
 
     dllogger.init(backends=backends)
-    dllogger.metadata("train_lrate", {"name": "lrate", "format": ":>3.2e"})
+    dllogger.metadata("train_lrate", {"name": "lrate", "unit": None, "format": ":>3.2e"})
 
     for id_, pref in [('train', ''), ('train_avg', 'avg train '),
                       ('dev', '  avg dev '), ('dev_ema', '  EMA dev ')]:
 
         dllogger.metadata(f"{id_}_loss",
-                          {"name": f"{pref}loss", "format": ":>7.2f"})
+                          {"name": f"{pref}loss", "unit": None, "format": ":>7.2f"})
 
         dllogger.metadata(f"{id_}_wer",
-                          {"name": f"{pref}wer", "format": ":>6.2f"})
+                          {"name": f"{pref}wer", "unit": "%", "format": ":>6.2f"})
 
         dllogger.metadata(f"{id_}_throughput",
-                          {"name": f"{pref}utts/s", "format": ":>5.0f"})
+                          {"name": f"{pref}utts/s", "unit": "samples/s", "format": ":>5.0f"})
 
         dllogger.metadata(f"{id_}_took",
                           {"name": "took", "unit": "s", "format": ":>5.2f"})

PyTorch/SpeechRecognition/QuartzNet/common/tb_dllogger.py

@@ -117,19 +117,19 @@ def init_log(args):
         backends = []
 
     dllogger.init(backends=backends)
-    dllogger.metadata("train_lrate", {"name": "lrate", "format": ":>3.2e"})
+    dllogger.metadata("train_lrate", {"name": "lrate", "unit": None, "format": ":>3.2e"})
 
     for id_, pref in [('train', ''), ('train_avg', 'avg train '),
                       ('dev', '  avg dev '), ('dev_ema', '  EMA dev ')]:
 
         dllogger.metadata(f"{id_}_loss",
-                          {"name": f"{pref}loss", "format": ":>7.2f"})
+                          {"name": f"{pref}loss", "unit": None, "format": ":>7.2f"})
 
         dllogger.metadata(f"{id_}_wer",
-                          {"name": f"{pref}wer", "format": ":>6.2f"})
+                          {"name": f"{pref}wer", "unit": "%", "format": ":>6.2f"})
 
         dllogger.metadata(f"{id_}_throughput",
-                          {"name": f"{pref}utts/s", "format": ":>5.0f"})
+                          {"name": f"{pref}utts/s", "unit": "samples/s", "format": ":>5.0f"})
 
         dllogger.metadata(f"{id_}_took",
                           {"name": "took", "unit": "s", "format": ":>5.2f"})

PyTorch/SpeechSynthesis/FastPitch/common/tb_dllogger.py

@@ -99,20 +99,20 @@ def init(log_fpath, log_dir, enabled=True, tb_subsets=[], **tb_kw):
         backends = []
 
     dllogger.init(backends=backends)
-    dllogger.metadata("train_lrate", {"name": "lrate", "format": ":>3.2e"})
+    dllogger.metadata("train_lrate", {"name": "lrate", "unit": None, "format": ":>3.2e"})
 
     for id_, pref in [('train', ''), ('train_avg', 'avg train '),
                       ('val', '  avg val '), ('val_ema', '  EMA val ')]:
 
         dllogger.metadata(f"{id_}_loss",
-                          {"name": f"{pref}loss", "format": ":>5.2f"})
+                          {"name": f"{pref}loss", "unit": None, "format": ":>5.2f"})
         dllogger.metadata(f"{id_}_mel_loss",
-                          {"name": f"{pref}mel loss", "format": ":>5.2f"})
+                          {"name": f"{pref}mel loss", "unit": None, "format": ":>5.2f"})
 
         dllogger.metadata(f"{id_}_kl_loss",
-                          {"name": f"{pref}kl loss", "format": ":>5.5f"})
+                          {"name": f"{pref}kl loss", "unit": None, "format": ":>5.5f"})
         dllogger.metadata(f"{id_}_kl_weight",
-                          {"name": f"{pref}kl weight", "format": ":>5.5f"})
+                          {"name": f"{pref}kl weight", "unit": None, "format": ":>5.5f"})
 
         dllogger.metadata(f"{id_}_frames/s",
                           {"name": None, "unit": "frames/s", "format": ":>10.2f"})
@@ -127,8 +127,8 @@ def init(log_fpath, log_dir, enabled=True, tb_subsets=[], **tb_kw):
 def init_inference_metadata(batch_size=None):
 
     modalities = [('latency', 's', ':>10.5f'), ('RTF', 'x', ':>10.2f'),
-                  ('frames/s', None, ':>10.2f'), ('samples/s', None, ':>10.2f'),
-                  ('letters/s', None, ':>10.2f'), ('tokens/s', None, ':>10.2f')]
+                  ('frames/s', 'frames/s', ':>10.2f'), ('samples/s', 'samples/s', ':>10.2f'),
+                  ('letters/s', 'letters/s', ':>10.2f'), ('tokens/s', 'tokens/s', ':>10.2f')]
 
     if batch_size is not None:
         modalities.append((f'RTF@{batch_size}', 'x', ':>10.2f'))

PyTorch/SpeechSynthesis/FastPitch/hifigan/logging.py

@@ -59,23 +59,23 @@ def init_logger(output_dir, log_file, ema_decay=0.0):
 def init_train_metadata():
 
     dllogger.metadata("train_lrate_gen",
-                      {"name": "g lr", "format": ":>3.2e"})
+                      {"name": "g lr", "unit": None, "format": ":>3.2e"})
     dllogger.metadata("train_lrate_discrim",
-                      {"name": "d lr", "format": ":>3.2e"})
+                      {"name": "d lr", "unit": None, "format": ":>3.2e"})
     dllogger.metadata("train_avg_lrate_gen",
-                      {"name": "avg g lr", "format": ":>3.2e"})
+                      {"name": "avg g lr", "unit": None, "format": ":>3.2e"})
     dllogger.metadata("train_avg_lrate_discrim",
-                      {"name": "avg d lr", "format": ":>3.2e"})
+                      {"name": "avg d lr", "unit": None, "format": ":>3.2e"})
 
     for id_, pref in [('train', ''), ('train_avg', 'avg train '),
                       ('val', '  avg val '), ('val_ema', '  EMA val ')]:
 
         dllogger.metadata(f"{id_}_loss_gen",
-                          {"name": f"{pref}g loss", "format": ":>6.3f"})
+                          {"name": f"{pref}g loss", "unit": None, "format": ":>6.3f"})
         dllogger.metadata(f"{id_}_loss_discrim",
-                          {"name": f"{pref}d loss", "format": ":>6.3f"})
+                          {"name": f"{pref}d loss", "unit": None, "format": ":>6.3f"})
         dllogger.metadata(f"{id_}_loss_mel",
-                          {"name": f"{pref}mel loss", "format": ":>6.3f"})
+                          {"name": f"{pref}mel loss", "unit": None, "format": ":>6.3f"})
 
         dllogger.metadata(f"{id_}_frames/s",
                           {"name": None, "unit": "frames/s", "format": ":>8.2f"})

PyTorch/SpeechSynthesis/HiFi-GAN/hifigan/logging.py

@@ -60,23 +60,23 @@ def init_logger(output_dir, log_file, ema_decay=0.0):
 def init_train_metadata():
 
     dllogger.metadata("train_lrate_gen",
-                      {"name": "g lr", "format": ":>3.2e"})
+                      {"name": "g lr", "unit": None, "format": ":>3.2e"})
     dllogger.metadata("train_lrate_discrim",
-                      {"name": "d lr", "format": ":>3.2e"})
+                      {"name": "d lr", "unit": None, "format": ":>3.2e"})
     dllogger.metadata("train_avg_lrate_gen",
-                      {"name": "avg g lr", "format": ":>3.2e"})
+                      {"name": "avg g lr", "unit": None, "format": ":>3.2e"})
     dllogger.metadata("train_avg_lrate_discrim",
-                      {"name": "avg d lr", "format": ":>3.2e"})
+                      {"name": "avg d lr", "unit": None, "format": ":>3.2e"})
 
     for id_, pref in [('train', ''), ('train_avg', 'avg train '),
                       ('val', '  avg val '), ('val_ema', '  EMA val ')]:
 
         dllogger.metadata(f"{id_}_loss_gen",
-                          {"name": f"{pref}g loss", "format": ":>6.3f"})
+                          {"name": f"{pref}g loss", "unit": None, "format": ":>6.3f"})
         dllogger.metadata(f"{id_}_loss_discrim",
-                          {"name": f"{pref}d loss", "format": ":>6.3f"})
+                          {"name": f"{pref}d loss", "unit": None, "format": ":>6.3f"})
         dllogger.metadata(f"{id_}_loss_mel",
-                          {"name": f"{pref}mel loss", "format": ":>6.3f"})
+                          {"name": f"{pref}mel loss", "unit": None, "format": ":>6.3f"})
 
         dllogger.metadata(f"{id_}_frames/s",
                           {"name": None, "unit": "frames/s", "format": ":>8.2f"})
@@ -87,8 +87,8 @@ def init_train_metadata():
 def init_inference_metadata(batch_size=None):
 
     modalities = [('latency', 's', ':>10.5f'), ('RTF', 'x', ':>10.2f'),
-                  ('frames/s', None, ':>10.2f'), ('samples/s', None, ':>10.2f'),
-                  ('letters/s', None, ':>10.2f'), ('tokens/s', None, ':>10.2f'),
+                  ('frames/s', 'frames/s', ':>10.2f'), ('samples/s', 'samples/s', ':>10.2f'),
+                  ('letters/s', 'letters/s', ':>10.2f'), ('tokens/s', 'tokens/s', ':>10.2f'),
                   ('mel-loss', None, ':>10.5f')]
 
     if batch_size is not None:

PyTorch/SpeechSynthesis/Tacotron2/inference_perf.py

@@ -112,6 +112,9 @@ def main():
         DLLogger.log(step="PARAMETER", data={k:v})
     DLLogger.log(step="PARAMETER", data={'model_name':'Tacotron2_PyT'})
 
+    DLLogger.metadata('infer_latency', {'unit': 's'})
+    DLLogger.metadata('infer_items_per_sec', {'unit': 'items/s'})
+
     if args.synth_data:
         model = load_and_setup_model(args.model_name, parser, None, args.fp16,
                                      cpu_run=False, forward_is_infer=True)

PyTorch/SpeechSynthesis/Tacotron2/train.py

@@ -369,6 +369,11 @@ def main():
         DLLogger.log(step="PARAMETER", data={k:v})
     DLLogger.log(step="PARAMETER", data={'model_name':'Tacotron2_PyT'})
 
+    DLLogger.metadata('run_time', {'unit': 's'})
+    DLLogger.metadata('val_loss', {'unit': None})
+    DLLogger.metadata('train_items_per_sec', {'unit': 'items/s'})
+    DLLogger.metadata('val_items_per_sec', {'unit': 'items/s'})
+
     model_name = args.model_name
     parser = models.model_parser(model_name, parser)
     args, _ = parser.parse_known_args()

PyTorch/Translation/GNMT/seq2seq/utils.py

@@ -239,6 +239,13 @@ def setup_dllogger(enabled=True, filename=os.devnull):
     else:
         dllogger.init([])
 
+    dllogger.metadata("test_bleu", {"unit": None})
+    dllogger.metadata("eval_90%_latency", {"unit": "ms"})
+    dllogger.metadata("eval_avg_latency", {"unit": "ms"})
+    dllogger.metadata("train_elapsed", {"unit": "s"})
+    dllogger.metadata("eval_throughput", {"unit": "tokens/s"})
+    dllogger.metadata("train_throughput", {"unit": "tokens/s"})
+
 
 def set_device(cuda, local_rank):
     """

PyTorch/Translation/Transformer/fairseq/log_helper.py

@@ -177,10 +177,10 @@ def setup_logger(args):
     container_setup_info = get_framework_env_vars()
     dllogger.log(step='PARAMETER', data=container_setup_info, verbosity=0)
 
-    dllogger.metadata('loss', {'unit': 'nat', 'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN'})
-    dllogger.metadata('val_loss', {'unit': 'nat', 'GOAL': 'MINIMIZE', 'STAGE': 'VAL'})
+    dllogger.metadata('loss', {'unit': None, 'GOAL': 'MINIMIZE', 'STAGE': 'TRAIN'})
+    dllogger.metadata('val_loss', {'unit': None, 'GOAL': 'MINIMIZE', 'STAGE': 'VAL'})
     dllogger.metadata('speed', {'unit': 'tokens/s', 'format': ':.3f', 'GOAL': 'MAXIMIZE', 'STAGE': 'TRAIN'})
-    dllogger.metadata('accuracy', {'unit': 'bleu', 'format': ':.2f', 'GOAL': 'MAXIMIZE', 'STAGE': 'VAL'})
+    dllogger.metadata('accuracy', {'unit': None, 'format': ':.2f', 'GOAL': 'MAXIMIZE', 'STAGE': 'VAL'})
 
 
 def get_framework_env_vars():

PyTorch/Translation/Transformer/inference.py

@@ -118,8 +118,12 @@ def setup_logger(args):
             dllogger.log(step='PARAMETER', data={k:v}, verbosity=0)
         container_setup_info = log_helper.get_framework_env_vars()
         dllogger.log(step='PARAMETER', data=container_setup_info, verbosity=0)
-        dllogger.metadata('throughput',
-                          {'unit':'tokens/s', 'format':':/3f', 'GOAL':'MAXIMIZE', 'STAGE':'INFER'})
+        dllogger.metadata('throughput', {'unit':'tokens/s', 'format':':/3f', 'GOAL':'MAXIMIZE', 'STAGE':'INFER'})
+        dllogger.metadata('latency_avg', {'unit':'s', 'format':':/3f', 'GOAL':'MINIMIZE', 'STAGE':'INFER'})
+        dllogger.metadata('latency_p90', {'unit':'s', 'format':':/3f', 'GOAL':'MINIMIZE', 'STAGE':'INFER'})
+        dllogger.metadata('latency_p95', {'unit':'s', 'format':':/3f', 'GOAL':'MINIMIZE', 'STAGE':'INFER'})
+        dllogger.metadata('latency_p99', {'unit':'s', 'format':':/3f', 'GOAL':'MINIMIZE', 'STAGE':'INFER'})
+        dllogger.metadata('total_infernece_time', {'unit':'s', 'format':':/3f', 'GOAL':'MINIMIZE', 'STAGE':'INFER'})
     else:
         dllogger.init(backends=[])
 

TensorFlow/Classification/ConvNets/inference.py

@@ -44,6 +44,8 @@ def main(args: argparse.Namespace):
         dllogger.StdOutBackend(verbosity=dllogger.Verbosity.VERBOSE)
     ])
     dllogger.log(data=vars(args), step='PARAMETER')
+    dllogger.metadata("throughput", {"unit": "images/s"})
+    dllogger.metadata("accuracy", {"unit": None})
 
     if args.model is None:
         saved_model_to_load = tempfile.mkdtemp(prefix="tftrt-savedmodel")

TensorFlow/Classification/ConvNets/main.py

@@ -47,6 +47,15 @@ if __name__ == "__main__":
         dllogger.init(backends=[])
     dllogger.log(data=vars(FLAGS), step='PARAMETER')
 
+    dllogger.metadata("train_throughput", {"unit": "images/s"})
+    dllogger.metadata("eval_throughput", {"unit": "images/s"})
+    dllogger.metadata("eval_latency_avg", {"unit": "ms"})
+    dllogger.metadata("eval_latency_p90", {"unit": "ms"})
+    dllogger.metadata("eval_latency_p95", {"unit": "ms"})
+    dllogger.metadata("eval_latency_p99", {"unit": "ms"})
+    dllogger.metadata("top1_accuracy", {"unit": None})
+    dllogger.metadata("top5_accuracy", {"unit": None})
+
     runner = Runner(
         # ========= Model HParams ========= #
         n_classes=1001,

TensorFlow/Detection/SSD/models/research/object_detection/utils/exp_utils.py

@@ -54,3 +54,6 @@ def setup_dllogger(enabled=True, filename=os.devnull, rank=0):
         dllogger.init(backends)
     else:
         dllogger.init([])
+
+    dllogger.metadata("infer_throughput", {"unit": "images/s"})
+    dllogger.metadata("train_throughput", {"unit": "images/s"})

TensorFlow/LanguageModeling/BERT/utils/dllogger_class.py

@@ -40,16 +40,16 @@ class dllogger_class():
         self.logger.metadata("avg_loss_step", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "TRAIN"})
         self.logger.metadata("total_loss", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "TRAIN"})
         self.logger.metadata("loss", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "TRAIN"})
-        self.logger.metadata("f1", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
+        self.logger.metadata("f1", {"unit": None, "format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
         self.logger.metadata("precision", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
         self.logger.metadata("recall", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
         self.logger.metadata("mcc", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
-        self.logger.metadata("exact_match", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
+        self.logger.metadata("exact_match", {"unit": None, "format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
         self.logger.metadata(
             "throughput_train",
-            {"unit": "seq/s", "format": ":.3f", "GOAL": "MAXIMIZE", "STAGE": "TRAIN"},
+            {"unit": "sequences/s", "format": ":.3f", "GOAL": "MAXIMIZE", "STAGE": "TRAIN"},
         )
         self.logger.metadata(
             "throughput_inf",
-            {"unit": "seq/s", "format": ":.3f", "GOAL": "MAXIMIZE", "STAGE": "VAL"},
+            {"unit": "sequences/s", "format": ":.3f", "GOAL": "MAXIMIZE", "STAGE": "VAL"},
         )

TensorFlow/LanguageModeling/Transformer-XL/tf/exp_utils.py

@@ -54,3 +54,8 @@ def setup_dllogger(enabled=True, filename=os.devnull, rank=0):
         dllogger.init(backends)
     else:
         dllogger.init([])
+
+    dllogger.metadata("eval_avg_latency", {"unit": "ms"})
+    dllogger.metadata("eval_ppl", {"unit": None})
+    dllogger.metadata("eval_avg_throughput", {"unit": "tokens/s"})
+    dllogger.metadata("train_throughput", {"unit": "tokens/s"})

TensorFlow/Recommendation/NCF/ncf.py

@@ -176,6 +176,16 @@ def main():
     else:
         dllogger.init(backends=[])
 
+    dllogger.metadata("best_epoch", {"unit": None})
+    dllogger.metadata("first_epoch_to_hit", {"unit": None})
+    dllogger.metadata("best_hr", {"unit": None})
+    dllogger.metadata("average_eval_time_per_epoch", {"unit": "s"})
+    dllogger.metadata("average_train_time_per_epoch", {"unit": "s"})
+    dllogger.metadata("time_to_best", {"unit": "s"})
+    dllogger.metadata("time_to_train", {"unit": "s"})
+    dllogger.metadata("average_train_throughput", {"unit": "samples/s"})
+    dllogger.metadata("average_eval_throughput", {"unit": "samples/s"})
+
     args.world_size = hvd.size()
     dllogger.log(data=vars(args), step='PARAMETER')
 

TensorFlow/Recommendation/VAE-CF/main.py

@@ -107,6 +107,10 @@ def main():
         dllogger.init(backends=[])
         logger.setLevel(logging.ERROR)
 
+    dllogger.metadata("final_ndcg@100", {"unit": None})
+    dllogger.metadata("mean_inference_throughput", {"unit": "samples/s"})
+    dllogger.metadata("mean_training_throughput", {"unit": "samples/s"})
+
     if args.seed is None:
         if hvd.rank() == 0:
             seed = int(time.time())

TensorFlow/Recommendation/WideAndDeep/trainer/task.py

@@ -296,6 +296,12 @@ def main(FLAGS):
         num_gpus = 1
 
     dllogger.log(data=vars(FLAGS), step='PARAMETER')
+    dllogger.metadata('train_throughput', {'unit': 'samples/s'})
+    dllogger.metadata('infer_throughput', {'unit': 'samples/s'})
+    dllogger.metadata('map', {'unit': None})
+    dllogger.metadata('map_infer', {'unit': None})
+    dllogger.metadata('map_with_leak', {'unit': None})
+    dllogger.metadata('map_with_leak_infer', {'unit': None})
 
     local_batch_size = FLAGS.global_batch_size // num_gpus
     create_batches = local_batch_size // FLAGS.prebatch_size

TensorFlow/Segmentation/UNet_3D_Medical/runtime/setup.py

@@ -106,4 +106,7 @@ def get_logger(params):
         if params.log_dir:
             backends += [JSONStreamBackend(Verbosity.VERBOSE, params.log_dir)]
     logger.init(backends=backends)
+    logger.metadata("whole_tumor", {"unit": None})
+    logger.metadata("throughput_test", {"unit": "volumes/s"})
+    logger.metadata("throughput_train", {"unit": "volumes/s"})
     return logger

TensorFlow/Segmentation/UNet_Medical/utils/setup.py

@@ -88,4 +88,7 @@ def get_logger(params):
         if params.log_dir:
             backends += [JSONStreamBackend(Verbosity.VERBOSE, params.log_dir)]
     logger.init(backends=backends)
+    logger.metadata("eval_dice_score", {"unit": None})
+    logger.metadata("throughput_test", {"unit": "images/s"})
+    logger.metadata("throughput_train", {"unit": "images/s"})
     return logger

TensorFlow/Translation/GNMT/nmt.py

@@ -1028,6 +1028,9 @@ def main(unused_argv):
         dllogger.JSONStreamBackend(dllogger.Verbosity.VERBOSE, os.path.join(FLAGS.output_dir, FLAGS.mode + '-report.json')),
     ])
     dllogger.log('PARAMETER', vars(FLAGS))
+    dllogger.metadata("bleu", {"unit": None})
+    dllogger.metadata("train_speed_sent", {"unit": "sequences/s"})
+    dllogger.metadata("train_speed_toks", {"unit": "tokens/s"})
 
     # Load hparams.
     default_hparams = create_hparams(FLAGS)

TensorFlow2/Classification/ConvNets/main.py

@@ -86,7 +86,21 @@ if __name__== "__main__":
         ]
     DLLogger.init(backends=backends)
     DLLogger.log(data=vars(config), step='PARAMETER')
-    
+    DLLogger.metadata('avg_exp_per_second_training', {'unit': 'samples/s'})
+    DLLogger.metadata('avg_exp_per_second_training_per_GPU', {'unit': 'samples/s'})
+    DLLogger.metadata('avg_exp_per_second_eval', {'unit': 'samples/s'})
+    DLLogger.metadata('avg_exp_per_second_eval_per_GPU', {'unit': 'samples/s'})
+    DLLogger.metadata('latency_pct', {'unit': 'ms'})
+    DLLogger.metadata('latency_90pct', {'unit': 'ms'})
+    DLLogger.metadata('latency_95pct', {'unit': 'ms'})
+    DLLogger.metadata('latency_99pct', {'unit': 'ms'})
+    DLLogger.metadata('eval_loss', {'unit': None})
+    DLLogger.metadata('eval_accuracy_top_1', {'unit': None})
+    DLLogger.metadata('eval_accuracy_top_5', {'unit': None})
+    DLLogger.metadata('training_loss', {'unit': None})
+    DLLogger.metadata('training_accuracy_top_1', {'unit': None})
+    DLLogger.metadata('training_accuracy_top_5', {'unit': None})
+
     #========== initialize the runner
     runner = Runner(config, DLLogger)
 

TensorFlow2/Detection/Efficientdet/inspector.py

@@ -100,6 +100,12 @@ def main(_):
     JSONStreamBackend(verbosity=Verbosity.VERBOSE, filename=FLAGS.dllogger_path),
     StdOutBackend(verbosity=Verbosity.DEFAULT)]
   DLLogger.init(backends=backends)
+  DLLogger.metadata('inference_fps', {'unit': 'images/s'})
+  DLLogger.metadata('inference_latency_ms', {'unit': 'ms'})
+  DLLogger.metadata('latency_avg', {'unit': 's'})
+  DLLogger.metadata('latency_90', {'unit': 's'})
+  DLLogger.metadata('latency_95', {'unit': 's'})
+  DLLogger.metadata('latency_99', {'unit': 's'})
 
   if FLAGS.mode == 'export':
     if tf.io.gfile.exists(FLAGS.saved_model_dir):

TensorFlow2/Detection/Efficientdet/train.py

@@ -153,6 +153,11 @@ def main(_):
       StdOutBackend(verbosity=Verbosity.DEFAULT)]
     
   DLLogger.init(backends=backends)
+  DLLogger.metadata('avg_fps_training', {'unit': 'images/s'})
+  DLLogger.metadata('avg_fps_training_per_GPU', {'unit': 'images/s'})
+  DLLogger.metadata('avg_latency_training', {'unit': 's'})
+  DLLogger.metadata('training_loss', {'unit': None})
+  DLLogger.metadata('e2e_training_time', {'unit': 's'})
 
   def get_dataset(is_training, params):
     file_pattern = (

TensorFlow2/LanguageModeling/BERT/dllogger_class.py

@@ -41,16 +41,20 @@ class dllogger_class():
         self.logger.metadata("avg_loss_step", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "TRAIN"})
         self.logger.metadata("total_loss", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "TRAIN"})
         self.logger.metadata("loss", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "TRAIN"})
-        self.logger.metadata("f1", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
+        self.logger.metadata("f1", {"unit": None, "format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
         self.logger.metadata("precision", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
         self.logger.metadata("recall", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
         self.logger.metadata("mcc", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
         self.logger.metadata("exact_match", {"format": ":.4f", "GOAL": "MINIMIZE", "STAGE": "VAL"})
         self.logger.metadata(
             "throughput_train",
-            {"unit": "seq/s", "format": ":.3f", "GOAL": "MAXIMIZE", "STAGE": "TRAIN"},
+            {"unit": "sequences/s", "format": ":.3f", "GOAL": "MAXIMIZE", "STAGE": "TRAIN"},
         )
         self.logger.metadata(
             "throughput_inf",
-            {"unit": "seq/s", "format": ":.3f", "GOAL": "MAXIMIZE", "STAGE": "VAL"},
+            {"unit": "sequences/s", "format": ":.3f", "GOAL": "MAXIMIZE", "STAGE": "VAL"},
+        )
+        self.logger.metadata(
+            "throughput_val",
+            {"unit": "sequences/s", "format": ":.3f", "GOAL": "MAXIMIZE", "STAGE": "VAL"},
         )

TensorFlow2/LanguageModeling/ELECTRA/run_pretraining.py

@@ -289,6 +289,9 @@ def main(e2e_start_time):
     args.log_dir = config.log_dir
     # DLLogger
     setup_logger(args)
+    dllogger.metadata('training_sequences_per_second', {'unit': 'sequences/s'})
+    dllogger.metadata('final_loss', {'unit': None})
+    dllogger.metadata('e2e_train_time', {'unit': 's'})
 
     set_affinity(hvd.local_rank())
     gpus = tf.config.experimental.list_physical_devices('GPU')

TensorFlow2/LanguageModeling/ELECTRA/run_tf_squad.py

@@ -328,6 +328,11 @@ def main():
     else:
         dllogger.init(backends=[])
 
+    dllogger.metadata("exact_match", {"unit": None})
+    dllogger.metadata("F1", {"unit": None})
+    dllogger.metadata("inference_sequences_per_second", {"unit": "sequences/s"})
+    dllogger.metadata("training_sequences_per_second", {"unit": "sequences/s"})
+
     tf.random.set_seed(args.seed)
     dllogger.log(step="PARAMETER", data={"SEED": args.seed})
     # script parameters

TensorFlow2/LanguageModeling/ELECTRA/utils.py

@@ -208,6 +208,12 @@ def postprocess_dllog(args):
     with open(log_path, 'w') as dest_file:
         for lines in zip(*[f.readlines() for f in logfiles]):
             json_lines = [json.loads(l[5:]) for l in lines]
+
+            assert all(x['type'] == json_lines[0]['type'] for x in json_lines)
+            if json_lines[0]['type'] != 'LOG':
+                dest_file.write(lines[0])
+                continue
+
             assert all(x['step'] == json_lines[0]['step'] for x in json_lines)
             if json_lines[0]['step'] == 'PARAMETER':
                 dest_file.write(lines[0])

TensorFlow2/Recommendation/DLRM/utils.py

@@ -50,16 +50,15 @@ def init_logging(log_path, FLAGS):
     json_backend = dllogger.JSONStreamBackend(verbosity=dllogger.Verbosity.VERBOSE,
                                               filename=log_path)
     stdout_backend = dllogger.StdOutBackend(verbosity=dllogger.Verbosity.VERBOSE)
+    dllogger.init(backends=[json_backend, stdout_backend])
 
-    stdout_backend._metadata['auc'].update({'format': '0:.5f'})
-    stdout_backend._metadata['throughput'].update({'format': ':.2e'})
-    stdout_backend._metadata['mean_step_time_ms'].update({'format': '0:.3f'})
-    stdout_backend._metadata['mean_inference_throughput'].update({'format': ':.2e'})
-    stdout_backend._metadata['mean_inference_latency'].update({'format': '0:.5f'})
+    dllogger.metadata('auc', {'unit': None, 'format': '0:.5f'})
+    dllogger.metadata('throughput', {'unit': 'samples/s', 'format': ':.2e'})
+    dllogger.metadata('mean_step_time_ms', {'unit': 'ms', 'format': '0:.3f'})
+    dllogger.metadata('mean_inference_throughput', {'unit': 'samples/s', 'format': ':.2e'})
+    dllogger.metadata('mean_inference_latency', {'unit': 's', 'format': '0:.5f'})
     for percentile in [90, 95, 99]:
-        stdout_backend._metadata[f'p{percentile}_inference_latency'].update({'format': '0:.5f'})
-
-    dllogger.init(backends=[json_backend, stdout_backend])
+        dllogger.metadata(f'p{percentile}_inference_latency', {'unit': 's', 'format': '0:.5f'})
 
     if hvd.rank() == 0:
         dllogger.log(data=FLAGS.flag_values_dict(), step='PARAMETER')

TensorFlow2/Recommendation/SIM/main.py

@@ -83,6 +83,11 @@ def init_logger(results_dir, filename):
                 dllogger.StdOutBackend(verbosity=dllogger.Verbosity.VERBOSE),
             ]
         )
+        dllogger.metadata("test_auc", {"unit": None})
+        dllogger.metadata("latency_p90", {"unit": "ms"})
+        dllogger.metadata("train_loss", {"unit": None})
+        dllogger.metadata("time_to_train", {"unit": "s"})
+        dllogger.metadata("throughput", {"unit": "samples/s"})
     else:
         dllogger.init(backends=[])
 

TensorFlow2/Recommendation/WideAndDeep/trainer/utils/setup.py

@@ -91,6 +91,9 @@ def init_logger(args, full, logger):
         dllogger.init(backends=[])
 
     dllogger.log(data=vars(args), step="PARAMETER")
+    dllogger.metadata("streaming_map_val", {"unit": None})
+    dllogger.metadata("train_throughput", {"unit": "samples/s"})
+    dllogger.metadata("validation_throughput", {"unit": "samples/s"})
 
 
 def create_config(args):

TensorFlow2/Segmentation/MaskRCNN/mrcnn_tf2/runtime/callbacks.py

@@ -39,6 +39,10 @@ class DLLoggerMetricsCallback(KerasCallback):
         if not isinstance(log_every, dict):
             self._log_every = defaultdict(lambda: log_every)
 
+        self._dllogger.metadata('loss', {'unit': None})
+        self._dllogger.metadata('AP', {'unit': None})
+        self._dllogger.metadata('mask_AP', {'unit': None})
+
         logging.getLogger('hooks').info('Created metrics logging hook')
 
     def on_any_batch_end(self, mode, epoch, batch, logs):
@@ -94,6 +98,14 @@ class DLLoggerPerfCallback(KerasCallback):
         self._batch_timestamps = {}
         self._start_timestamps = {}
 
+        for mode in ['train', 'test', 'predict']:
+            self._dllogger.metadata(f'{mode}_throughput', {'unit': 'images/s'})
+            self._dllogger.metadata(f'{mode}_latency', {'unit': 's'})
+            self._dllogger.metadata(f'{mode}_latency_90', {'unit': 's'})
+            self._dllogger.metadata(f'{mode}_latency_95', {'unit': 's'})
+            self._dllogger.metadata(f'{mode}_latency_99', {'unit': 's'})
+            self._dllogger.metadata(f'{mode}_time', {'unit': 's'})
+
         self._logger = logging.getLogger('hooks')
         self._logger.info('Created perf logging hooks')
 

TensorFlow2/Segmentation/UNet_Medical/runtime/setup.py

@@ -74,4 +74,7 @@ def get_logger(params):
         if params.log_dir:
             backends += [JSONStreamBackend(Verbosity.VERBOSE, params.log_dir)]
     logger.init(backends=backends)
+    logger.metadata("eval_dice_score", {"unit": None})
+    logger.metadata("throughput_test", {"unit": "images/s"})
+    logger.metadata("throughput_train", {"unit": "images/s"})
     return logger

TensorFlow2/Segmentation/nnUNet/main.py

@@ -45,6 +45,12 @@ def main(args):
 
     logger = get_logger(args)
     logger.log_hyperparams(vars(args))
+    logger.log_metadata("dice_score", {"unit": None})
+    logger.log_metadata("eval_dice_nobg", {"unit": None})
+    logger.log_metadata("throughput_predict", {"unit": "images/s"})
+    logger.log_metadata("throughput_train", {"unit": "images/s"})
+    logger.log_metadata("latency_predict_mean", {"unit": "ms"})
+    logger.log_metadata("latency_train_mean", {"unit": "ms"})
 
     if args.exec_mode == "train":
         model = NNUnet(args)

TensorFlow2/Segmentation/nnUNet/runtime/logging.py

@@ -27,6 +27,11 @@ class Logger(ABC):
     def log_hyperparams(self, params):
         pass
 
+    @rank_zero_only
+    @abstractmethod
+    def log_metadata(self, metric, metadata):
+        pass
+
     @rank_zero_only
     @abstractmethod
     def log_metrics(self, metrics, step=None):
@@ -72,6 +77,11 @@ class LoggerCollection(Logger):
         for logger in self.loggers:
             logger.log_hyperparams(params)
 
+    @rank_zero_only
+    def log_metadata(self, metric, metadata):
+        for logger in self.loggers:
+            logger.log_metadata(metric, metadata)
+
     @rank_zero_only
     def flush(self):
         for logger in self.loggers:
@@ -104,6 +114,10 @@ class DLLogger(Logger):
         params = self._sanitize_params(params)
         dllogger.log(step="PARAMETER", data=params)
 
+    @rank_zero_only
+    def log_metadata(self, metric, metadata):
+        dllogger.metadata(metric, metadata)
+
     @rank_zero_only
     def log_metrics(self, metrics, step=None):
         if step is None: