@@ -4,6 +4,7 @@ import os
 import sys
 import socket
 from functools import wraps
+from typing import Any
 
 from omegaconf import OmegaConf
 
@@ -96,7 +97,7 @@ def register_hydra_resolvers():
     OmegaConf.register_new_resolver("class", lambda *args: get_cls(*args), replace=True)
 
 
-def pop_arg(arg_name: str, default_value: int = None) -> argparse.Namespace:
+def pop_arg(arg_name: str, default_value: Any = None) -> Any:
     """Get the specified args and remove them from argv"""
 
     parser = argparse.ArgumentParser()

"""
Evaluate a checkpoint resulting from an experiment that you ran previously.

Use this script if:
    - You want to evaluate a checkpoint resulting from one of your previous experiment,
        using the same parameters (dataset, valid_metrics,...) as used during the training of the experiment.

Don't use this script if:
    - You want to train and evaluate a model (use examples/train_from_recipe_example)
    - You want to evaluate a pretrained model from model zoo (use examples/evaluate_from_recipe_example)
    - You want to evaluate a checkpoint from one of your previous experiment, but with different validation parameters
        such as dataset params or metrics for instance (use examples/evaluate_from_recipe_example)

Note:
    The parameters will be unchanged even if the recipe used for that experiment was changed since then.
    This is to ensure that validation of the experiment will remain exactly the same as during training.

Example: python evaluate_checkpoint.py --experiment_name=my_experiment_name --ckpt_name=average_model.pth
-> Evaluate the checkpoint average_model from experiment my_experiment_name.

"""
from super_gradients import Trainer, init_trainer
from super_gradients.common.environment.env_helpers import pop_arg


def main() -> None:
    init_trainer()
    experiment_name = pop_arg("experiment_name")
    ckpt_name = pop_arg("ckpt_name", default_value="ckpt_latest.pth")
    ckpt_root_dir = pop_arg("ckpt_root_dir", default_value=None)
    Trainer.evaluate_checkpoint(experiment_name=experiment_name, ckpt_name=ckpt_name, ckpt_root_dir=ckpt_root_dir)


def run():
    init_trainer()
    main()


if __name__ == "__main__":
    run()

"""
Evaluate a SuperGradient's recipes.

Use this script if:
    - You want to evaluate a pretrained model from model zoo
    - You want to evaluate a checkpoint from one of your previous experiment, but with different validation parameters
        such as dataset params or metrics for instance

Don't use this script if:
    - You want to train and evaluate a model (use examples/train_from_recipe_example)
    - You want to evaluate a checkpoint from one of your previous experiment, using the same parameters as used during the
        training of the experiment (use examples/evaluate_checkpoint_example)

Note:
    This script does NOT run TRAINING, so make sure in the recipe that you load a PRETRAINED MODEL
    either from one of your checkpoint or from a pretrained model.

General use: python evaluate_from_recipe.py --config-name="DESIRED_RECIPE".
-> Evaluate a model according to parameters set in "DESIRED_RECIPE"

For recipe's specific instructions and details refer to the recipe's configuration file in the recipes directory.
"""
from omegaconf import DictConfig
import hydra
import pkg_resources

from super_gradients import Trainer, init_trainer


@hydra.main(config_path=pkg_resources.resource_filename("super_gradients.recipes", ""), version_base="1.2")
def main(cfg: DictConfig) -> None:
    Trainer.evaluate_from_recipe(cfg)


def run():
    init_trainer()
    main()


if __name__ == "__main__":
    run()

"""
Example code for resuming SuperGradient's recipes.

General use: python resume_experiment.py --experiment_name=<PREVIOUSLY-RUN-EXPERIMENT>
"""
from super_gradients import Trainer, init_trainer
from super_gradients.common.environment.env_helpers import pop_arg


def main() -> None:
    init_trainer()
    experiment_name = pop_arg("experiment_name")
    ckpt_root_dir = pop_arg("ckpt_root_dir")
    Trainer.resume_experiment(experiment_name=experiment_name, ckpt_root_dir=ckpt_root_dir)


if __name__ == "__main__":
    main()

@@ -27,4 +27,11 @@ ckpt_root_dir:
 
 architecture: resnet18_cifar
 
-experiment_name: resnet18_cifar
+experiment_name: resnet18_cifar
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -84,8 +84,9 @@ ckpt_root_dir:
 multi_gpu: DDP
 num_gpus: 4
 
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
 hydra:
   run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
     dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}
-
-

@@ -90,8 +90,9 @@ experiment_name: ${architecture}_cityscapes
 multi_gpu: AUTO
 num_gpus: 4
 
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
 hydra:
-  searchpath:
-    - pkg://super_gradients.recipes
   run:
-    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -29,3 +29,9 @@ ckpt_root_dir:
 
 multi_gpu: DDP
 
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -75,6 +75,9 @@ num_gpus: 2
 experiment_name: ${architecture}50_cityscapes
 ckpt_root_dir:
 
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
 hydra:
   run:
-    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -79,7 +79,10 @@ num_gpus: 4
 experiment_name: ${architecture}75_cityscapes
 ckpt_root_dir:
 
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
 hydra:
   run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
     dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}
 

@@ -55,3 +55,10 @@ training_hyperparams:
 
 multi_gpu: DDP
 num_gpus: 8
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -58,4 +58,9 @@ experiment_name: ${architecture}_coco2017_${experiment_suffix}
 ckpt_root_dir:
 
 
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}
 

@@ -42,6 +42,9 @@ ckpt_root_dir:
 
 architecture: shelfnet34_lw
 
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
 hydra:
   run:
-    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -34,3 +34,10 @@ multi_gpu: DDP
 num_gpus: 4
 
 architecture: efficientnet_b0
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -39,3 +39,10 @@ multi_gpu: DDP
 num_gpus: 2
 
 architecture: mobilenet_v2
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -21,3 +21,10 @@ multi_gpu: DDP
 num_gpus: 2
 
 architecture: mobilenet_v3_large
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -19,3 +19,10 @@ arch_params:
 experiment_name: mobileNetv3_large_training
 
 architecture: mobilenet_v3_large
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -19,3 +19,10 @@ arch_params:
 experiment_name: mobileNetv3_small_training
 
 architecture: mobilenet_v3_small
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -49,4 +49,11 @@ multi_gpu: Off
 
 
 architecture: regnetY800
-experiment_name: ${architecture}
+experiment_name: ${architecture}
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -36,3 +36,10 @@ multi_gpu: DDP
 num_gpus: 4
 
 architecture: repvgg_a0
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -36,4 +36,11 @@ ckpt_root_dir:
 multi_gpu: DDP
 num_gpus: 4
 
-architecture: resnet50
+architecture: resnet50
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -80,4 +80,11 @@ num_gpus: 8
 
 architecture: kd_module
 student_architecture: resnet50
-teacher_architecture: beit_base_patch16_224
+teacher_architecture: beit_base_patch16_224
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -31,4 +31,11 @@ experiment_name: vit_base_imagenet1k
 
 architecture: vit_base
 multi_gpu: DDP
-num_gpus: 8
+num_gpus: 8
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -27,4 +27,11 @@ architecture: vit_large
 
 experiment_name: vit_large_imagenet1k
 multi_gpu: DDP
-num_gpus: 8
+num_gpus: 8
+
+
+# THE FOLLOWING PARAMS ARE DIRECTLY USED BY HYDRA
+hydra:
+  run:
+    # Set the output directory (i.e. where .hydra folder that logs all the input params will be generated)
+    dir: ${hydra_output_dir:${ckpt_root_dir}, ${experiment_name}}

@@ -3,10 +3,11 @@ import os
 import sys
 from copy import deepcopy
 from typing import Union, Tuple, Mapping
+from pathlib import Path
 
-import hydra
 import numpy as np
 import torch
+import hydra
 from omegaconf import DictConfig
 from torch import nn
 from torch.utils.data import DataLoader
@@ -47,13 +48,14 @@ from super_gradients.training.utils.weight_averaging_utils import ModelWeightAve
 from super_gradients.training.metrics import Accuracy, Top5
 from super_gradients.training.utils import random_seed
 from super_gradients.training.utils.checkpoint_utils import get_ckpt_local_path, read_ckpt_state_dict, \
-    load_checkpoint_to_model, load_pretrained_weights
+    load_checkpoint_to_model, load_pretrained_weights, get_checkpoints_dir_path
 from super_gradients.training.datasets.datasets_utils import DatasetStatisticsTensorboardLogger
 from super_gradients.training.utils.callbacks import CallbackHandler, Phase, LR_SCHEDULERS_CLS_DICT, PhaseContext, \
     MetricsUpdateCallback, LR_WARMUP_CLS_DICT, ContextSgMethods, LRCallbackBase
 from super_gradients.common.environment import environment_config
 from super_gradients.training.utils import HpmStruct
 from super_gradients.training.datasets.samplers.infinite_sampler import InfiniteSampler
+from super_gradients.training.utils.hydra_utils import load_experiment_cfg, add_params_to_cfg
 
 logger = get_logger(__name__)
 
@@ -132,14 +134,7 @@ class Trainer:
         self.experiment_name = experiment_name
         self.ckpt_name = None
 
-        # CREATING THE LOGGING DIR BASED ON THE INPUT PARAMS TO PREVENT OVERWRITE OF LOCAL VERSION
-        if ckpt_root_dir:
-            self.checkpoints_dir_path = os.path.join(ckpt_root_dir, self.experiment_name)
-        elif os.path.exists(environment_config.PKG_CHECKPOINTS_DIR):
-            self.checkpoints_dir_path = os.path.join(environment_config.PKG_CHECKPOINTS_DIR, self.experiment_name)
-        else:
-            raise ValueError("Illegal checkpoints directory: pass ckpt_root_dir that exists, or add 'checkpoints' to"
-                             "resources.")
+        self.checkpoints_dir_path = get_checkpoints_dir_path(experiment_name, ckpt_root_dir)
 
         # INITIALIZE THE DEVICE FOR THE MODEL
         self._initialize_device(requested_device=device, requested_multi_gpu=multi_gpu)
@@ -203,6 +198,87 @@ class Trainer:
                       valid_loader=val_dataloader,
                       training_params=cfg.training_hyperparams)
 
+    @classmethod
+    def resume_experiment(cls, experiment_name: str, ckpt_root_dir: str = None) -> None:
+        """
+        Resume a training that was run using our recipes.
+
+        :param experiment_name:     Name of the experiment to resume
+        :param ckpt_root_dir:       Directory including the checkpoints
+        """
+        logger.info("Resume training using the checkpoint recipe, ignoring the current recipe")
+        cfg = load_experiment_cfg(experiment_name, ckpt_root_dir)
+        add_params_to_cfg(cfg, params=["training_hyperparams.resume=True"])
+        cls.train_from_config(cfg)
+
+    @classmethod
+    def evaluate_from_recipe(cls, cfg: DictConfig) -> None:
+        """
+        Evaluate according to a cfg recipe configuration.
+
+        Note:   This script does NOT run training, only validation.
+                Please make sure that the config refers to a PRETRAINED MODEL either from one of your checkpoint or from pretrained weights from model zoo.
+        :param cfg: The parsed DictConfig from yaml recipe files or a dictionary
+        """
+
+        # INSTANTIATE ALL OBJECTS IN CFG
+        cfg = hydra.utils.instantiate(cfg)
+
+        kwargs = parse_args(cfg, cls.__init__)
+
+        trainer = Trainer(**kwargs)
+
+        # INSTANTIATE DATA LOADERS
+        val_dataloader = dataloaders.get(name=cfg.val_dataloader,
+                                         dataset_params=cfg.dataset_params.val_dataset_params,
+                                         dataloader_params=cfg.dataset_params.val_dataloader_params)
+
+        checkpoints_dir = Path(get_checkpoints_dir_path(experiment_name=cfg.experiment_name, ckpt_root_dir=cfg.ckpt_root_dir))
+        ckpt_name = core_utils.get_param(cfg, 'ckpt_name', 'ckpt_latest.pth')
+        checkpoint_path = str(checkpoints_dir / ckpt_name)
+
+        # BUILD NETWORK
+        model = models.get(model_name=cfg.architecture,
+                           num_classes=cfg.arch_params.num_classes,
+                           arch_params=cfg.arch_params,
+                           pretrained_weights=cfg.checkpoint_params.pretrained_weights,
+                           checkpoint_path=checkpoint_path,
+                           load_backbone=cfg.checkpoint_params.load_backbone)
+
+        # TEST
+        val_results_tuple = trainer.test(model=model,
+                                         test_loader=val_dataloader,
+                                         test_metrics_list=cfg.training_hyperparams.valid_metrics_list)
+
+        valid_metrics_dict = get_metrics_dict(val_results_tuple, trainer.test_metrics,
+                                              trainer.loss_logging_items_names)
+
+        results = ["Validate Results"]
+        results += [f"   - {metric:10}: {value}" for metric, value in valid_metrics_dict.items()]
+        logger.info("\n".join(results))
+
+    @classmethod
+    def evaluate_checkpoint(cls, experiment_name: str, ckpt_name: str = "ckpt_latest.pth", ckpt_root_dir: str = None) -> None:
+        """
+        Evaluate a checkpoint resulting from one of your previous experiment, using the same parameters (dataset, valid_metrics,...)
+        as used during the training of the experiment
+
+        Note:
+            The parameters will be unchanged even if the recipe used for that experiment was changed since then.
+            This is to ensure that validation of the experiment will remain exactly the same as during training.
+
+        Example, evaluate the checkpoint "average_model.pth" from experiment "my_experiment_name":
+            >> evaluate_checkpoint(experiment_name="my_experiment_name", ckpt_name="average_model.pth")
+
+        :param experiment_name:     Name of the experiment to validate
+        :param ckpt_name:           Name of the checkpoint to test ("ckpt_latest.pth", "average_model.pth" or "ckpt_best.pth" for instance)
+        :param ckpt_root_dir:       Directory including the checkpoints
+        """
+        logger.info("Evaluate checkpoint")
+        cfg = load_experiment_cfg(experiment_name, ckpt_root_dir)
+        add_params_to_cfg(cfg, params=["training_hyperparams.resume=True", f"ckpt_name={ckpt_name}"])
+        cls.evaluate_from_recipe(cfg)
+
     def _set_dataset_params(self):
         self.dataset_params = {
             "train_dataset_params": self.train_loader.dataset.dataset_params if hasattr(self.train_loader.dataset,
@@ -1129,6 +1205,10 @@ class Trainer:
     def _set_valid_metrics(self, valid_metrics_list):
         self.valid_metrics = MetricCollection(valid_metrics_list)
 
+    @resolve_param('test_metrics_list', ListFactory(MetricsFactory()))
+    def _set_test_metrics(self, test_metrics_list):
+        self.test_metrics = MetricCollection(test_metrics_list)
+
     def _initialize_mixed_precision(self, mixed_precision_enabled: bool):
         # SCALER IS ALWAYS INITIALIZED BUT IS DISABLED IF MIXED PRECISION WAS NOT SET
         self.scaler = GradScaler(enabled=mixed_precision_enabled)
@@ -1391,7 +1471,7 @@ class Trainer:
             self.phase_callbacks = []
 
         if test_metrics_list:
-            self.test_metrics = MetricCollection(test_metrics_list)
+            self._set_test_metrics(test_metrics_list)
             self._add_metrics_update_callback(Phase.TEST_BATCH_END)
             self.phase_callback_handler = CallbackHandler(self.phase_callbacks)
 

@@ -1,15 +1,38 @@
 import os
 import tempfile
 import pkg_resources
+
 import torch
+
+from super_gradients.common.abstractions.abstract_logger import get_logger
 from super_gradients.common import explicit_params_validation, ADNNModelRepositoryDataInterfaces
 from super_gradients.training.pretrained_models import MODEL_URLS
+from super_gradients.common.environment import environment_config
 try:
     from torch.hub import download_url_to_file, load_state_dict_from_url
 except (ModuleNotFoundError, ImportError, NameError):
     from torch.hub import _download_url_to_file as download_url_to_file
 
 
+logger = get_logger(__name__)
+
+
+def get_checkpoints_dir_path(experiment_name: str, ckpt_root_dir: str = None):
+    """Creating the checkpoint directory of a given experiment.
+    :param experiment_name:     Name of the experiment.
+    :param ckpt_root_dir:       Local root directory path where all experiment logging directories will
+                                reside. When none is give, it is assumed that pkg_resources.resource_filename('checkpoints', "")
+                                exists and will be used.
+    :return:                    checkpoints_dir_path
+    """
+    if ckpt_root_dir:
+        return os.path.join(ckpt_root_dir, experiment_name)
+    elif os.path.exists(environment_config.PKG_CHECKPOINTS_DIR):
+        return os.path.join(environment_config.PKG_CHECKPOINTS_DIR, experiment_name)
+    else:
+        raise ValueError("Illegal checkpoints directory: pass ckpt_root_dir that exists, or add 'checkpoints' to resources.")
+
+
 def get_ckpt_local_path(source_ckpt_folder_name: str, experiment_name: str, ckpt_name: str, external_checkpoint_path: str):
     """
     Gets the local path to the checkpoint file, which will be:

from pathlib import Path
from typing import List

from hydra import initialize_config_dir, compose
from hydra.core.global_hydra import GlobalHydra
from omegaconf import OmegaConf, open_dict, DictConfig

from super_gradients.training.utils.checkpoint_utils import get_checkpoints_dir_path


def load_experiment_cfg(experiment_name: str, ckpt_root_dir: str = None) -> DictConfig:
    """
    Load the hydra config associated to a specific experiment.

    Background Information: every time an experiment is launched based on a recipe, all the hydra config params are stored in a hidden folder ".hydra".
    This hidden folder is used here to recreate the exact same config as the one that was used to launch the experiment (Also include hydra overrides).

    The motivation is to be able to resume or evaluate an experiment with the exact same config as the one that was used when the experiment was
    initially started, regardless of any change that might have been introduced to the recipe, and also while using the same overrides that were used
    for that experiment.

    :param experiment_name:     Name of the experiment to resume
    :param ckpt_root_dir:       Directory including the checkpoints
    :return:                    The config that was used for that experiment
    """
    if not experiment_name:
        raise ValueError(f"experiment_name should be non empty string but got :{experiment_name}")

    checkpoints_dir_path = Path(get_checkpoints_dir_path(experiment_name, ckpt_root_dir))
    if not checkpoints_dir_path.exists():
        raise FileNotFoundError(f"Impossible to find checkpoint dir ({checkpoints_dir_path})")

    resume_dir = Path(checkpoints_dir_path) / ".hydra"
    if not resume_dir.exists():
        raise FileNotFoundError(f"The checkpoint directory {checkpoints_dir_path} does not include .hydra artifacts to resume the experiment.")

    # Load overrides that were used in previous run
    overrides_cfg = list(OmegaConf.load(resume_dir / "overrides.yaml"))

    GlobalHydra.instance().clear()
    with initialize_config_dir(config_dir=str(resume_dir)):
        cfg = compose(config_name="config.yaml", overrides=overrides_cfg)
    return cfg


def add_params_to_cfg(cfg: DictConfig, params: List[str]):
    """Add parameters to an existing config

    :param cfg:     OmegaConf config
    :param params:  List of parameters to add, in dotlist format (i.e. ["training_hyperparams.resume=True"])"""
    new_cfg = OmegaConf.from_dotlist(params)
    with open_dict(cfg):  # This is required to add new fields to existing config
        cfg.merge_with(new_cfg)

@@ -14,6 +14,7 @@ from super_gradients.common.abstractions.abstract_logger import get_logger
 from treelib import Tree
 from termcolor import colored
 import torch
+
 from torch.utils.tensorboard import SummaryWriter
 
 from super_gradients.training.exceptions.dataset_exceptions import UnsupportedBatchItemsFormat
@@ -26,6 +27,7 @@ IS_GREATER_SYMBOLS = {True: "↗", False: "↘"}
 
 logger = get_logger(__name__)
 
+
 @dataclass
 class MonitoredValue:
     """Store a value and some indicators relative to its past iterations.