@@ -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))
 
 

@@ -47,6 +47,7 @@ from tests.unit_tests.detection_caching import TestDetectionDatasetCaching
 from tests.unit_tests.multi_scaling_test import MultiScaleTest
 from tests.unit_tests.ppyoloe_unit_test import PPYoloETests
 from tests.unit_tests.bbox_formats_test import BBoxFormatsTest
+from tests.unit_tests.config_inspector_test import ConfigInspectTest
 
 
 class CoreUnitTestSuiteRunner:
@@ -105,6 +106,7 @@ class CoreUnitTestSuiteRunner:
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(ResumeTrainingTest))
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(CallTrainAfterTestTest))
         self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(TestDetectionOutputAdapter))
+        self.unit_tests_suite.addTest(self.test_loader.loadTestsFromModule(ConfigInspectTest))
 
     def _add_modules_to_end_to_end_tests_suite(self):
         """

@@ -21,6 +21,7 @@ from tests.unit_tests.pretrained_models_unit_test import PretrainedModelsUnitTes
 from tests.unit_tests.conv_bn_relu_test import TestConvBnRelu
 from tests.unit_tests.initialize_with_dataloaders_test import InitializeWithDataloadersTest
 from tests.unit_tests.training_params_factory_test import TrainingParamsTest
+from tests.unit_tests.config_inspector_test import ConfigInspectTest
 
 
 __all__ = [
@@ -46,4 +47,5 @@ __all__ = [
     "CallTrainTwiceTest",
     "ResumeTrainingTest",
     "CallTrainAfterTestTest",
+    "ConfigInspectTest",
 ]

import copy
import os
import unittest

import pkg_resources
from omegaconf import OmegaConf

from super_gradients.training.models import SgModule, get_arch_params
from super_gradients.training.models.model_factory import get_architecture
from super_gradients.training.utils import HpmStruct
from super_gradients.training.utils.config_utils import raise_if_unused_params, UnusedConfigParamException, AccessCounterDict, AccessCounterHpmStruct
from super_gradients.training.utils.sg_trainer_utils import get_callable_param_names


class ConfigInspectTest(unittest.TestCase):
    def test_inspector_raise_on_unused_args(self):
        def model_factory(cfg):
            return cfg["a"] + cfg["b"]

        original_config = {"unused_param": True, "a": 1, "b": 2}

        with self.assertRaisesRegex(UnusedConfigParamException, "Detected unused parameters in configuration object that were not consumed by caller"):
            config = copy.deepcopy(original_config)
            with raise_if_unused_params(config) as config:
                _ = model_factory(config)

        with self.assertRaisesRegex(UnusedConfigParamException, "Detected unused parameters in configuration object that were not consumed by caller"):
            config = OmegaConf.create(copy.deepcopy(original_config))
            with raise_if_unused_params(config) as config:
                _ = model_factory(config)

        with self.assertRaisesRegex(UnusedConfigParamException, "Detected unused parameters in configuration object that were not consumed by caller"):
            config = HpmStruct(**copy.deepcopy(original_config))
            with raise_if_unused_params(copy.deepcopy(config)) as config:
                _ = model_factory(config)

    def test_inspector_raise_on_unused_args_with_modification_of_the_config(self):
        def model_factory(cfg):
            cfg["this_is_a_test_property_that_is_set_but_not_used"] = 42
            cfg["this_is_a_test_property_that_is_set_and_used"] = 39
            return cfg["a"] + cfg["b"] + cfg["this_is_a_test_property_that_is_set_and_used"]

        original_config = {"unused_param": True, "a": 1, "b": 2}

        with self.assertRaisesRegex(UnusedConfigParamException, "Detected unused parameters in configuration object that were not consumed by caller"):
            config = copy.deepcopy(original_config)
            with raise_if_unused_params(config) as config:
                result = model_factory(config)
                self.assertEqual(result, 42)

            self.assertTrue("this_is_a_test_property_that_is_set_and_used" in config.get_used_params())

        with self.assertRaisesRegex(UnusedConfigParamException, "Detected unused parameters in configuration object that were not consumed by caller"):
            config = OmegaConf.create(copy.deepcopy(original_config))
            with raise_if_unused_params(config) as config:
                result = model_factory(config)
                self.assertEqual(result, 42)
            self.assertTrue("this_is_a_test_property_that_is_set_and_used" in config.get_used_params())

        with self.assertRaisesRegex(UnusedConfigParamException, "Detected unused parameters in configuration object that were not consumed by caller"):
            config = HpmStruct(**copy.deepcopy(original_config))
            with raise_if_unused_params(copy.deepcopy(config)) as config:
                result = model_factory(config)
                self.assertEqual(result, 42)
            self.assertTrue("this_is_a_test_property_that_is_set_and_used" in config.get_used_params())

    def test_inspector_with_dict_and_list(self):
        config = {
            "beta": 0.73,
            "lr": 1e-4,
            "encoder": {
                "indexes": [1, 2, 3],
                "pretrained": True,
                "backbone": "yolov3",
                "layers": [
                    {"blocks": 4},
                    {"blocks": 3},
                    {"blocks": 6},
                    {"blocks": 9},
                ],
            },
        }

        c = AccessCounterDict(config)

        # Simulate parameters usage
        print(c["beta"])
        print(c["encoder"]["layers"])
        print(sum(c["encoder"]["indexes"]))
        print(c["beta"])
        print(c["encoder"]["layers"][0])
        print(c["encoder"]["layers"][3]["blocks"])

        print("All parameters")
        print(c.get_all_params())

        print("Unused parameters")
        print(c.get_unused_params())

        self.assertSetEqual(
            c.get_unused_params(),
            {
                "lr",
                "encoder.pretrained",
                "encoder.backbone",
                "encoder.layers.0.blocks",
                "encoder.layers.1",
                "encoder.layers.1.blocks",
                "encoder.layers.2",
                "encoder.layers.2.blocks",
                "encoder.layers.2.blocks",
            },
        )

    def test_inspector_with_omegaconf(self):
        config = {
            "beta": 0.73,
            "lr": 1e-4,
            "encoder": {
                "indexes": [1, 2, 3],
                "pretrained": True,
                "backbone": "yolov3",
                "layers": [
                    {"blocks": 4},
                    {"blocks": 3},
                    {"blocks": 6},
                    {"blocks": 9},
                ],
            },
        }
        config = OmegaConf.create(config)

        c = AccessCounterDict(config)

        # Simulate parameters usage
        print(c.beta)
        print(c.encoder.layers)
        print(sum(c.encoder.indexes))
        print(c.encoder.layers[0])
        print(c.encoder.layers[3].blocks)

        print("All parameters")
        print(c.get_all_params())

        print("Unused parameters")
        print(c.get_unused_params())

        self.assertSetEqual(
            c.get_unused_params(),
            {
                "lr",
                "encoder.pretrained",
                "encoder.backbone",
                "encoder.layers.0.blocks",
                "encoder.layers.1",
                "encoder.layers.1.blocks",
                "encoder.layers.2",
                "encoder.layers.2.blocks",
                "encoder.layers.2.blocks",
            },
        )

    def test_inspector_with_hpm_struct(self):
        config = {
            "beta": 0.73,
            "lr": 1e-4,
            "encoder": {
                "indexes": [1, 2, 3],
                "pretrained": True,
                "backbone": "yolov3",
                "layers": [
                    {"blocks": 4},
                    {"blocks": 3},
                    {"blocks": 6},
                    {"blocks": 9},
                ],
            },
        }
        config = HpmStruct(**config)

        c = AccessCounterHpmStruct(config)

        # Simulate parameters usage
        print(c.beta)
        print(c.encoder.layers)
        print(sum(c.encoder.indexes))
        print(c.encoder.layers[0])
        print(c.encoder.layers[3].blocks)

        print("All parameters")
        print(c.get_all_params())

        print("Unused parameters")
        print(c.get_unused_params())

        self.assertSetEqual(
            c.get_unused_params(),
            {
                "lr",
                "encoder.pretrained",
                "encoder.backbone",
                "encoder.layers.0.blocks",
                "encoder.layers.1",
                "encoder.layers.1.blocks",
                "encoder.layers.2",
                "encoder.layers.2.blocks",
                "encoder.layers.2.blocks",
            },
        )

    def get_all_arch_params_configs(self):
        config_path = pkg_resources.resource_filename("super_gradients.recipes", "arch_params")
        configs = [path.replace(".yaml", "") for path in sorted(os.listdir(config_path)) if path.endswith(".yaml")]
        return configs

    def test_resnet18_cifar_arch_params(self):
        arch_params = get_arch_params("resnet18_cifar_arch_params")
        architecture_cls, arch_params, pretrained_weights_path, is_remote = get_architecture("resnet18", HpmStruct(**arch_params))

        with raise_if_unused_params(arch_params) as tracked_arch_params:
            _ = architecture_cls(arch_params=tracked_arch_params)

        with self.assertRaisesRegex(UnusedConfigParamException, "Detected unused parameters in configuration object that were not consumed by caller"):
            arch_params.override(me_is_not_used=True)
            with raise_if_unused_params(arch_params) as tracked_arch_params:
                _ = architecture_cls(arch_params=tracked_arch_params)

    @unittest.expectedFailure
    def test_model_from_arch_params(self):
        all_configs = self.get_all_arch_params_configs()
        for config_name in all_configs:
            with self.subTest(config_name):
                model_name = config_name.replace("_arch_params", "")
                arch_params = get_arch_params(config_name)
                architecture_cls, arch_params, pretrained_weights_path, is_remote = get_architecture(model_name, HpmStruct(**arch_params))
                self.assertIsNotNone(arch_params, msg=model_name)

                if not issubclass(architecture_cls, SgModule):
                    # This instantiation method is not supported as unpacking arch_params would cause root params to be considered "used"
                    # net = architecture_cls(**arch_params.to_dict(include_schema=False))
                    self.skipTest("Skipping test since model class is not subclass of SgModule")
                else:
                    # Most of the SG models work with a single params names "arch_params" of type HpmStruct, but a few take **kwargs instead
                    if "arch_params" not in get_callable_param_names(architecture_cls):
                        self.skipTest("Skipping test since model c'tor does not receive arch_params argument")
                        # This instantiation method is not supported as unpacking arch_params would cause root params to be considered "used"
                        # net = architecture_cls(**arch_params.to_dict(include_schema=False))
                        pass
                    else:
                        try:
                            _ = architecture_cls(arch_params=arch_params)
                        except Exception as e:
                            self.skipTest(f"Skipping test since model cannot be instantiated at all {e}")

                        with raise_if_unused_params(arch_params) as tracked_arch_params:
                            _ = architecture_cls(arch_params=tracked_arch_params)