@@ -1,14 +1,14 @@
 from torch import nn
 from super_gradients.training.models.sg_module import SgModule
+from super_gradients.training.utils import get_param
 
 
 def create_conv_module(in_channels, out_channels, kernel_size=3, stride=1):
     padding = (kernel_size - 1) // 2
     nn_sequential_module = nn.Sequential()
-    nn_sequential_module.add_module('Conv2d', nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size,
-                                                        stride=stride, padding=padding, bias=False))
-    nn_sequential_module.add_module('BatchNorm2d', nn.BatchNorm2d(out_channels))
-    nn_sequential_module.add_module('LeakyRelu', nn.LeakyReLU())
+    nn_sequential_module.add_module("Conv2d", nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, bias=False))
+    nn_sequential_module.add_module("BatchNorm2d", nn.BatchNorm2d(out_channels))
+    nn_sequential_module.add_module("LeakyRelu", nn.LeakyReLU())
 
     return nn_sequential_module
 
@@ -72,19 +72,19 @@ class Darknet53(Darknet53Base):
         super(Darknet53, self).__init__()
 
         # IN ORDER TO ALLOW PASSING PARAMETERS WITH ARCH_PARAMS BUT NOT BREAK YOLOV3 INTEGRATION
-        self.backbone_mode = arch_params.backbone_mode if hasattr(arch_params, 'backbone_mode') else backbone_mode
-        self.num_classes = arch_params.num_classes if hasattr(arch_params, 'num_classes') else num_classes
+        self.backbone_mode = get_param(arch_params, "backbone_mode", backbone_mode)
+        self.num_classes = get_param(arch_params, "num_classes", num_classes)
 
         if not self.backbone_mode:
             # IF NOT USED AS A BACKEND BUT AS A CLASSIFIER WE ADD THE CLASSIFICATION LAYERS
             if self.num_classes is not None:
                 nn_sequential_block = nn.Sequential()
-                nn_sequential_block.add_module('global_avg_pool', nn.AdaptiveAvgPool2d((1, 1)))
-                nn_sequential_block.add_module('view', ViewModule(1024))
-                nn_sequential_block.add_module('fc', nn.Linear(1024, self.num_classes))
+                nn_sequential_block.add_module("global_avg_pool", nn.AdaptiveAvgPool2d((1, 1)))
+                nn_sequential_block.add_module("view", ViewModule(1024))
+                nn_sequential_block.add_module("fc", nn.Linear(1024, self.num_classes))
                 self.modules_list.append(nn_sequential_block)
             else:
-                raise ValueError('num_classes must be specified to use Darknet53 as a classifier')
+                raise ValueError("num_classes must be specified to use Darknet53 as a classifier")
 
     def get_modules_list(self):
         return self.modules_list

@@ -1,6 +1,7 @@
 from super_gradients.training.utils.utils import Timer, HpmStruct, WrappedModel, convert_to_tensor, get_param, tensor_container_to_device, random_seed
 from super_gradients.training.utils.checkpoint_utils import adapt_state_dict_to_fit_model_layer_names, raise_informative_runtime_error
 from super_gradients.training.utils.version_utils import torch_version_is_greater_or_equal
+from super_gradients.training.utils.config_utils import raise_if_unused_params, warn_if_unused_params
 
 __all__ = [
     "Timer",
@@ -13,4 +14,6 @@ __all__ = [
     "raise_informative_runtime_error",
     "random_seed",
     "torch_version_is_greater_or_equal",
+    "raise_if_unused_params",
+    "warn_if_unused_params",
 ]

import abc
from collections import defaultdict
from typing import Mapping, Iterable, Set, Union

__all__ = ["raise_if_unused_params", "warn_if_unused_params", "UnusedConfigParamException"]

from omegaconf import ListConfig, DictConfig

from super_gradients.common.abstractions.abstract_logger import get_logger
from super_gradients.training.utils import HpmStruct

logger = get_logger(__name__)


class UnusedConfigParamException(Exception):
    pass


class AccessCounterMixin:
    """
    Implements access counting mechanism for configuration settings (dicts/lists).
    It is achieved by wrapping underlying config and override __getitem__, __getattr__ methods to catch read operations
    and increments access counter for each property.
    """

    _access_counter: Mapping[str, int]
    _prefix: str  # Prefix string

    def maybe_wrap_as_counter(self, value, key, count_usage: bool = True):
        """
        Return an attribute value optionally wrapped as access counter adapter to trace read counts.

        Args:
            value: Attribute value
            key: Attribute name
            count_usage: Whether increment usage count for given attribute. Default is True.

        Returns:

        """
        key_with_prefix = self._prefix + str(key)
        if count_usage:
            self._access_counter[key_with_prefix] += 1
        if isinstance(value, Mapping):
            return AccessCounterDict(value, access_counter=self._access_counter, prefix=key_with_prefix + ".")
        if isinstance(value, Iterable) and not isinstance(value, str):
            return AccessCounterList(value, access_counter=self._access_counter, prefix=key_with_prefix + ".")
        return value

    @property
    def access_counter(self):
        return self._access_counter

    @abc.abstractmethod
    def get_all_params(self) -> Set[str]:
        raise NotImplementedError()

    def get_used_params(self) -> Set[str]:
        used_params = {k for (k, v) in self._access_counter.items() if v > 0}
        return used_params

    def get_unused_params(self) -> Set[str]:
        unused_params = self.get_all_params() - self.get_used_params()
        return unused_params


class AccessCounterDict(Mapping, AccessCounterMixin):
    def __init__(self, config: Mapping, access_counter: Mapping[str, int] = None, prefix: str = ""):
        super().__init__()
        self.config = config
        self._access_counter = access_counter or defaultdict(int)
        self._prefix = str(prefix)

    def __iter__(self):
        return self.config.__iter__()

    def __len__(self):
        return self.config.__len__()

    def __getitem__(self, item):
        return self.get(item)

    def __getattr__(self, item):
        value = self.config.__getitem__(item)
        return self.maybe_wrap_as_counter(value, item)

    def get(self, item, default=None):
        value = self.config.get(item, default)
        return self.maybe_wrap_as_counter(value, item)

    def get_all_params(self) -> Set[str]:
        keys = []
        for key, value in self.config.items():
            keys.append(self._prefix + str(key))
            value = self.maybe_wrap_as_counter(value, key, count_usage=False)
            if isinstance(value, AccessCounterMixin):
                keys += value.get_all_params()
        return set(keys)


class AccessCounterHpmStruct(Mapping, AccessCounterMixin):
    def __init__(self, config: HpmStruct, access_counter: Mapping[str, int] = None, prefix: str = ""):
        super().__init__()
        self.config = config
        self._access_counter = access_counter or defaultdict(int)
        self._prefix = str(prefix)

    def __iter__(self):
        return self.config.__dict__.__iter__()

    def __len__(self):
        return self.config.__dict__.__len__()

    def __repr__(self):
        return self.config.__repr__()

    def __str__(self):
        return self.config.__str__()

    def __getitem__(self, item):
        value = self.config.__dict__[item]
        return self.maybe_wrap_as_counter(value, item)

    def __getattr__(self, item):
        value = self.config.__dict__[item]
        return self.maybe_wrap_as_counter(value, item)

    def get(self, item, default=None):
        value = self.config.__dict__.get(item, default)
        return self.maybe_wrap_as_counter(value, item)

    def get_all_params(self) -> Set[str]:
        keys = []
        for key, value in self.config.__dict__.items():
            # Exclude schema field from params
            if key == "schema":
                continue
            keys.append(self._prefix + str(key))
            value = self.maybe_wrap_as_counter(value, key, count_usage=False)
            if isinstance(value, AccessCounterMixin):
                keys += value.get_all_params()
        return set(keys)


class AccessCounterList(list, AccessCounterMixin):
    def __init__(self, config: Iterable, access_counter: Mapping[str, int] = None, prefix: str = ""):
        super().__init__(config)
        self._access_counter = access_counter or defaultdict(int)
        self._prefix = str(prefix)

    def __iter__(self):
        for index, value in enumerate(super().__iter__()):
            yield self.maybe_wrap_as_counter(value, index)

    def __getitem__(self, item):
        value = super().__getitem__(item)
        return self.maybe_wrap_as_counter(value, item)

    def get_all_params(self) -> Set[str]:
        keys = []
        for index, value in enumerate(super().__iter__()):
            keys.append(self._prefix + str(index))
            value = self.maybe_wrap_as_counter(value, index, count_usage=False)
            if isinstance(value, AccessCounterMixin):
                keys += value.get_all_params()
        return set(keys)


class ConfigInspector:
    def __init__(self, wrapped_config, unused_params_action: str):
        self.wrapped_config = wrapped_config
        self.unused_params_action = unused_params_action

    def __enter__(self):
        return self.wrapped_config

    def __exit__(self, exc_type, exc_val, exc_tb):
        unused_params = self.wrapped_config.get_unused_params()
        if len(unused_params):
            message = f"Detected unused parameters in configuration object that were not consumed by caller: {unused_params}"
            if self.unused_params_action == "raise":
                raise UnusedConfigParamException(message)
            elif self.unused_params_action == "warn":
                logger.warning(message)
            elif self.unused_params_action == "ignore":
                pass
            else:
                raise KeyError(f"Encountered unknown action key {self.unused_params_action}")


def raise_if_unused_params(config: Union[HpmStruct, DictConfig, ListConfig, Mapping, list, tuple]) -> ConfigInspector:
    """
    A helper function to check whether all confuration parameters were used on given block of code. Motivation to have
    this check is to ensure there were no typo or outdated configuration parameters.
    It at least one of config parameters was not used, this function will raise an UnusedConfigParamException exception.
    Example usage:

    >>> from super_gradients.training.utils import raise_if_unused_params
    >>>
    >>> with raise_if_unused_params(some_config) as some_config:
    >>>    do_something_with_config(some_config)
    >>>

    :param config: A config to check
    :return: An instance of ConfigInspector
    """
    if isinstance(config, HpmStruct):
        wrapper_cls = AccessCounterHpmStruct
    elif isinstance(config, (Mapping, DictConfig)):
        wrapper_cls = AccessCounterDict
    elif isinstance(config, (list, tuple, ListConfig)):
        wrapper_cls = AccessCounterList
    else:
        raise RuntimeError(f"Unsupported type. Root configuration object must be a mapping or list. Got type {type(config)}")

    return ConfigInspector(wrapper_cls(config), unused_params_action="raise")


def warn_if_unused_params(config):
    """
    A helper function to check whether all confuration parameters were used on given block of code. Motivation to have
    this check is to ensure there were no typo or outdated configuration parameters.
    It at least one of config parameters was not used, this function will emit warning.
    Example usage:

    >>> from super_gradients.training.utils import warn_if_unused_params
    >>>
    >>> with warn_if_unused_params(some_config) as some_config:
    >>>    do_something_with_config(some_config)
    >>>

    :param config: A config to check
    :return: An instance of ConfigInspector
    """
    if isinstance(config, HpmStruct):
        wrapper_cls = AccessCounterHpmStruct
    elif isinstance(config, (Mapping, DictConfig)):
        wrapper_cls = AccessCounterDict
    elif isinstance(config, (list, tuple, ListConfig)):
        wrapper_cls = AccessCounterList
    else:
        raise RuntimeError("Unsupported type. Root configuration object must be a mapping or list.")

    return ConfigInspector(wrapper_cls(config), unused_params_action="warn")

@@ -66,7 +66,7 @@ class HpmStruct:
             `jsonschema.exceptions.SchemaError` if the schema itselfis invalid
         """
         if self.schema is None:
-            raise AttributeError('schema was not set')
+            raise AttributeError("schema was not set")
         else:
             validate(self.__dict__, self.schema)
 
@@ -89,7 +89,7 @@ class Timer:
         :param device: str
             'cpu'\'cuda'
         """
-        self.on_gpu = (device == 'cuda')
+        self.on_gpu = device == "cuda"
         # On GPU time is measured using cuda.events
         if self.on_gpu:
             self.starter = torch.cuda.Event(enable_timing=True)
@@ -141,8 +141,7 @@ class AverageMeter:
     def average(self):
         if self._sum is None:
             return 0
-        return ((self._sum / self._count).__float__()) if self._sum.dim() < 1 else tuple(
-            (self._sum / self._count).cpu().numpy())
+        return ((self._sum / self._count).__float__()) if self._sum.dim() < 1 else tuple((self._sum / self._count).cpu().numpy())
 
         # return (self._sum / self._count).__float__() if self._sum.dim() < 1 or len(self._sum) == 1 \
         #     else tuple((self._sum / self._count).cpu().numpy())
@@ -186,16 +185,16 @@ def get_param(params, name, default_val=None):
     :param default_val: assumed to be the same type as the value searched in the params
     :return:            the found value, or default if not found
     """
-    if isinstance(params, dict):
+    if isinstance(params, Mapping):
         if name in params:
-            if isinstance(default_val, dict):
+            if isinstance(default_val, Mapping):
                 return {**default_val, **params[name]}
             else:
                 return params[name]
         else:
             return default_val
     elif hasattr(params, name):
-        if isinstance(default_val, dict):
+        if isinstance(default_val, Mapping):
             return {**default_val, **getattr(params, name)}
         else:
             return getattr(params, name)
@@ -239,7 +238,7 @@ def random_seed(is_ddp, device, seed):
     :param device: 'cuda','cpu', 'cuda:<device_number>'
     :param seed: int, random seed to be set
     """
-    rank = 0 if not is_ddp else int(device.split(':')[1])
+    rank = 0 if not is_ddp else int(device.split(":")[1])
     torch.manual_seed(seed + rank)
     np.random.seed(seed + rank)
     random.seed(seed + rank)
@@ -266,22 +265,21 @@ def get_filename_suffix_by_framework(framework: str):
     @param framework: (str)
     @return: (str) the suffix for the specific framework
     """
-    frameworks_dict = \
-        {
-            'TENSORFLOW1': '.pb',
-            'TENSORFLOW2': '.zip',
-            'PYTORCH': '.pth',
-            'ONNX': '.onnx',
-            'TENSORRT': '.pkl',
-            'OPENVINO': '.pkl',
-            'TORCHSCRIPT': '.pth',
-            'TVM': '',
-            'KERAS': '.h5',
-            'TFLITE': '.tflite'
-        }
+    frameworks_dict = {
+        "TENSORFLOW1": ".pb",
+        "TENSORFLOW2": ".zip",
+        "PYTORCH": ".pth",
+        "ONNX": ".onnx",
+        "TENSORRT": ".pkl",
+        "OPENVINO": ".pkl",
+        "TORCHSCRIPT": ".pth",
+        "TVM": "",
+        "KERAS": ".h5",
+        "TFLITE": ".tflite",
+    }
 
     if framework.upper() not in frameworks_dict.keys():
-        raise ValueError(f'Unsupported framework: {framework}')
+        raise ValueError(f"Unsupported framework: {framework}")
 
     return frameworks_dict[framework.upper()]
 
@@ -294,15 +292,15 @@ def check_models_have_same_weights(model_1: torch.nn.Module, model_2: torch.nn.M
     @param model_2: Net to be checked
     @return: True iff the two networks have the same weights
     """
-    model_1, model_2 = model_1.to('cpu'), model_2.to('cpu')
+    model_1, model_2 = model_1.to("cpu"), model_2.to("cpu")
     models_differ = 0
     for key_item_1, key_item_2 in zip(model_1.state_dict().items(), model_2.state_dict().items()):
         if torch.equal(key_item_1[1], key_item_2[1]):
             pass
         else:
             models_differ += 1
-            if (key_item_1[0] == key_item_2[0]):
-                print(f'Layer names match but layers have different weights for layers: {key_item_1[0]}')
+            if key_item_1[0] == key_item_2[0]:
+                print(f"Layer names match but layers have different weights for layers: {key_item_1[0]}")
     if models_differ == 0:
         return True
     else:
@@ -320,7 +318,7 @@ def recursive_override(base: dict, extension: dict):
             base[k] = extension[k]
 
 
-def download_and_unzip_from_url(url, dir='.', unzip=True, delete=True):
+def download_and_unzip_from_url(url, dir=".", unzip=True, delete=True):
     """
     Downloads a zip file from url to dir, and unzips it.
 
@@ -341,14 +339,14 @@ def download_and_unzip_from_url(url, dir='.', unzip=True, delete=True):
         if Path(url).is_file():  # exists in current path
             Path(url).rename(f)  # move to dir
         elif not f.exists():
-            print(f'Downloading {url} to {f}...')
+            print(f"Downloading {url} to {f}...")
             torch.hub.download_url_to_file(url, f, progress=True)  # torch download
-        if unzip and f.suffix in ('.zip', '.gz'):
-            print(f'Unzipping {f}...')
-            if f.suffix == '.zip':
+        if unzip and f.suffix in (".zip", ".gz"):
+            print(f"Unzipping {f}...")
+            if f.suffix == ".zip":
                 ZipFile(f).extractall(path=dir)  # unzip
-            elif f.suffix == '.gz':
-                os.system(f'tar xfz {f} --directory {f.parent}')  # unzip
+            elif f.suffix == ".gz":
+                os.system(f"tar xfz {f} --directory {f.parent}")  # unzip
             if delete:
                 f.unlink()  # remove zip
 
@@ -358,7 +356,7 @@ def download_and_unzip_from_url(url, dir='.', unzip=True, delete=True):
         download_one(u, dir)
 
 
-def download_and_untar_from_url(urls: List[str], dir: Union[str, Path] = '.'):
+def download_and_untar_from_url(urls: List[str], dir: Union[str, Path] = "."):
     """
     Download a file from url and untar.
 
@@ -375,13 +373,13 @@ def download_and_untar_from_url(urls: List[str], dir: Union[str, Path] = '.'):
         if url_path.is_file():
             url_path.rename(filepath)
         elif not filepath.exists():
-            logger.info(f'Downloading {url} to {filepath}...')
+            logger.info(f"Downloading {url} to {filepath}...")
             torch.hub.download_url_to_file(url, str(filepath), progress=True)
 
         modes = {".tar.gz": "r:gz", ".tar": "r:"}
         assert filepath.suffix in modes.keys(), f"{filepath} has {filepath.suffix} suffix which is not supported"
 
-        logger.info(f'Extracting to {dir}...')
+        logger.info(f"Extracting to {dir}...")
         with tarfile.open(filepath, mode=modes[filepath.suffix]) as f:
             f.extractall(dir)
         filepath.unlink()
@@ -418,7 +416,7 @@ def get_orientation_key() -> int:
     """Get the orientation key according to PIL, which is useful to get the image size for instance
     :return: Orientation key according to PIL"""
     for key, value in ExifTags.TAGS.items():
-        if value == 'Orientation':
+        if value == "Orientation":
             return key
 
 
@@ -442,14 +440,14 @@ def exif_size(image: Image) -> Tuple[int, int]:
             elif rotation == 8:
                 image_size = (image_size[1], image_size[0])
     except Exception as ex:
-        print('Caught Exception trying to rotate: ' + str(image) + str(ex))
+        print("Caught Exception trying to rotate: " + str(image) + str(ex))
     width, height = image_size
     return height, width
 
 
 def get_image_size_from_path(img_path: str) -> Tuple[int, int]:
     """Get the image size of an image at a specific path"""
-    with open(img_path, 'rb') as f:
+    with open(img_path, "rb") as f:
         return exif_size(Image.open(f))