bigdl-core-npu 2.5.0__cp311-cp311-win_amd64.whl → 2.6.0__cp311-cp311-win_amd64.whl

intel_npu_acceleration_library/external/openvino/tools/benchmark/utils/inputs_filling.py

@@ -266,7 +266,7 @@ def get_numpy_tensors(numpy_paths: List[str], info: AppInputInfo, batch_sizes: L
                 else:
                     try:
                         if info.layout.has_name("N"):
-                            numpy_arrays[[None] * info.layout.get_index_by_name("N") + [b]] = numpy_arr
+                            numpy_arrays[[None] * info.layout.get_index_by_name("N") + [b]] = numpy_arr[b]
                         else:
                             numpy_arrays = numpy_arr
                     except ValueError:
@@ -291,7 +291,7 @@ def get_binary_tensors(binary_paths: List[str], info: AppInputInfo, batch_sizes:
     tensors = []
     for i in range(niter):
         shape_id = i % num_shapes
-        dtype = get_dtype(info.element_type)
+        dtype = np.uint8() if info.element_type.bitwidth < 8 else get_dtype(info.element_type)
         shape = list(info.shapes[shape_id])
         binaries = np.ndarray(shape=shape, dtype=dtype)
         binary_index = processed_frames
@@ -301,14 +301,14 @@ def get_binary_tensors(binary_paths: List[str], info: AppInputInfo, batch_sizes:
             binary_filename: str = binary_paths[binary_index]
             extension = binary_filename.lower().split('.')[-1]
             if extension == "bin":
-                binary_file_size = os.path.getsize(binary_filename)
-                blob_size = dtype.itemsize * int(np.prod(shape))
-                if blob_size != binary_file_size:
+                binary_file_bit_size = os.path.getsize(binary_filename) * 8
+                blob_bit_size = info.element_type.bitwidth * int(np.prod(shape))
+                if blob_bit_size != binary_file_bit_size:
                     raise Exception(
-                        f"File {binary_filename} contains {binary_file_size} bytes but model expects {blob_size}")
-                from_file = np.reshape(np.fromfile(binary_filename, dtype), shape)
+                        f"File {binary_filename} contains {binary_file_bit_size} bites but model expects {blob_bit_size}")
+                from_file = np.fromfile(binary_filename, dtype)
                 if info.layout.has_name("N"):
-                    binaries[[None] * info.layout.get_index_by_name("N") + [b]] = from_file
+                    binaries[[None] * info.layout.get_index_by_name("N") + [b]] = from_file[b]
                 else:
                     binaries = from_file
             else:
@@ -317,7 +317,7 @@ def get_binary_tensors(binary_paths: List[str], info: AppInputInfo, batch_sizes:
 
             binary_index += 1
         processed_frames += current_batch_size
-        tensors.append(Tensor(binaries))
+        tensors.append(Tensor(binaries, shape, info.element_type))
     return tensors
 
 

intel_npu_acceleration_library/external/openvino/tools/ovc/convert_impl.py

@@ -36,6 +36,10 @@ from openvino.tools.ovc.telemetry_utils import send_params_info, send_conversion
     init_mo_telemetry
 from openvino.tools.ovc.moc_frontend.pytorch_frontend_utils import get_pytorch_decoder, extract_input_info_from_example
 from openvino.tools.ovc.moc_frontend.paddle_frontend_utils import paddle_frontend_converter
+try:
+    from openvino.tools.ovc.moc_frontend.jax_frontend_utils import get_jax_decoder
+except:
+    get_jax_decoder = None
 
 # pylint: disable=no-name-in-module,import-error
 from openvino.frontend import FrontEndManager, OpConversionFailure, TelemetryExtension
@@ -228,6 +232,11 @@ def check_model_object(argv):
                                                                     paddle.fluid.dygraph.layers.Layer) or isinstance(
             model, paddle.fluid.executor.Executor):
             return "paddle"
+        
+    if 'jax' in sys.modules:
+        import jax
+        if isinstance(model, (jax.core.Jaxpr, jax.core.ClosedJaxpr)):
+            return "jax"
 
     raise Error('Unknown model type: {}'.format(type(model)))
 
@@ -319,6 +328,7 @@ def normalize_inputs(argv: argparse.Namespace):
     """
     # Parse input to list of InputCutInfo
     inputs = input_to_input_cut_info(argv.input)
+    argv.input = inputs
 
     # Make list of input names
     input_names_list = []
@@ -329,8 +339,6 @@ def normalize_inputs(argv: argparse.Namespace):
         assert len(input_names_list) == len(inputs), "\"input\" parameter has unnamed inputs and named inputs. " \
                                                      "Please either set names for all inputs, " \
                                                      "or do not set names for all inputs."
-    argv.inputs_list = input_names_list
-    argv.input = ','.join(input_names_list)
 
     if len(input_names_list) > 0:
         # Named inputs case
@@ -462,6 +470,12 @@ def _convert(cli_parser: argparse.ArgumentParser, args, python_api_used):
                                                                      outputs)
                 pdmodel = paddle_runtime_converter.convert_paddle_to_pdmodel()
                 args['input_model'] = pdmodel
+            if model_framework == "jax":
+                if get_jax_decoder is not None:
+                    get_jax_decoder(args['input_model'], args)
+                else:
+                    raise Error("JAX Frontend is not available.")
+                
 
         argv = pack_params_to_args_namespace(args, cli_parser, python_api_used)
         argv.framework = model_framework

intel_npu_acceleration_library/external/openvino/tools/ovc/main.py

@@ -10,6 +10,11 @@ except ImportError:
     import openvino.tools.ovc.telemetry_stub as tm
 from openvino.tools.ovc.convert_impl import _convert
 from openvino.tools.ovc.cli_parser import get_model_name_from_args
+from openvino.tools.ovc.utils import import_openvino_tokenizers
+
+# TODO 131000: temporal workaround to patch OpenVINO Core and frontends with tokenizers extensions
+# make OVC tool to convert models requiring openvino-tokenizers extensions
+import_openvino_tokenizers()
 
 # pylint: disable=no-name-in-module,import-error
 from openvino.runtime import save_model

intel_npu_acceleration_library/external/openvino/tools/ovc/moc_frontend/jax_frontend_utils.py

@@ -0,0 +1,19 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging as log
+
+
+def get_jax_decoder(model, args):
+    try:
+        from openvino.frontend.jax.jaxpr_decoder import JaxprPythonDecoder
+    except Exception as e:
+        log.error("JAX frontend loading failed")
+        raise e
+    
+    if not isinstance(model, JaxprPythonDecoder):
+        decoder = JaxprPythonDecoder(model)
+    else:
+        decoder = model
+    
+    args['input_model'] = decoder

intel_npu_acceleration_library/external/openvino/tools/ovc/moc_frontend/pipeline.py

@@ -72,12 +72,14 @@ def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):
             outputs = fe_output_user_data_repack(input_model, argv.output, moc_front_end.get_name())
             input_model.override_all_outputs([x['node'] for x in outputs])
     '''
-    argv.placeholder_shapes, argv.placeholder_data_types = convert_params_lists_to_dicts(
-        input_model, argv.placeholder_shapes, argv.placeholder_data_types)
 
-    user_shapes, outputs, freeze_placeholder = fe_user_data_repack(
-        input_model, argv.placeholder_shapes, argv.placeholder_data_types,
-        argv.output, {}, moc_front_end.get_name())
+    enabled_transforms, disabled_transforms = get_enabled_and_disabled_transforms()
+    if 'ANALYSIS_JSON_PRINT' in enabled_transforms:
+        # NOTE that model analysis is performed before applying user's settings (inputs's shapes etc.)
+        framework_model = moc_front_end.decode(input_model)
+        json_model_analysis_dump(framework_model)
+        # a model is not processed further in json analysis mode
+        sys.exit(0)
 
     def check_places_are_same(places_original: List[Place], places_new: List[Place]):
         """
@@ -90,6 +92,67 @@ def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):
             [item for item in places_original if any(
                 [item.is_equal(item2['node']) for item2 in places_new])]) == len(places_original)
 
+    if getattr(argv, "framework", None) == "pytorch":
+        iplaces = []
+        for idx, input_info in enumerate(argv.input):
+            if getattr(input_info, "name", None):
+                place = input_model.get_place_by_tensor_name(input_info.name)
+                if not input_info.shape and not input_info.type:
+                    # If we received place by name, we need to use it for FE to verify
+                    # that such name exist, otherwise we silently ignore it.
+                    # Using dynamic shape should be safe, because FE will not overwrite
+                    # the shape that was produced after conversion, but merge it, so
+                    # dynamic shape will not change anything.
+                    input_model.set_partial_shape(place, PartialShape.dynamic())
+            else:
+                place = input_model.get_place_by_input_index(idx)
+            iplaces.append(place)
+            if input_info.shape is not None:
+                input_model.set_partial_shape(place, input_info.shape)
+            if input_info.type is not None:
+                input_model.set_element_type(place, input_info.type)
+        model_inputs = input_model.get_inputs()
+        def merge_inputs(inputs, to_set_list):
+            # use input places instead of obtained by index if they are the same
+            res = []
+            for p in to_set_list:
+                found = False
+                for i in inputs:
+                    if p.is_equal(i):
+                        res.append(i)
+                        found = True
+                        break
+                if not found:
+                    res.append(p)
+            return res
+        iplaces = merge_inputs(model_inputs, iplaces)
+        # Currently this only work to reorder inputs/outputs
+        to_override_all_inputs = check_places_are_same(model_inputs, [{"node": p} for p in iplaces])
+        to_override_all_outputs = False
+        if argv.output:
+            oplaces = []
+            _outputs = fe_output_user_data_repack(input_model, argv.output, moc_front_end.get_name())
+            for out_desc in _outputs:
+                oplaces.append(out_desc["name"])
+            model_outputs = input_model.get_outputs()
+            to_override_all_outputs = check_places_are_same(model_outputs, [{"node": p} for p in oplaces])
+        if to_override_all_inputs and to_override_all_outputs:
+            input_model.extract_subgraph(iplaces, oplaces)
+        elif to_override_all_inputs:
+            input_model.override_all_inputs(iplaces)
+        elif to_override_all_outputs:
+            input_model.override_all_outputs(oplaces)
+
+        ov_model = moc_front_end.convert(input_model)
+        return ov_model
+
+    argv.placeholder_shapes, argv.placeholder_data_types = convert_params_lists_to_dicts(
+        input_model, argv.placeholder_shapes, argv.placeholder_data_types)
+
+    user_shapes, outputs, freeze_placeholder = fe_user_data_repack(
+        input_model, argv.placeholder_shapes, argv.placeholder_data_types,
+        argv.output, {}, moc_front_end.get_name())
+
     def add_names_to_tensors(model: InputModel, places: List[Place]):
         """
         Adds additional names to some model input tensors. This helper should be used
@@ -107,14 +170,6 @@ def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):
                 log.warning('Could not add an additional name to a tensor pointed to by \'{}\'. Details: {}'.format(
                     new_input['input_name'], str(e)))
 
-    enabled_transforms, disabled_transforms = get_enabled_and_disabled_transforms()
-    if 'ANALYSIS_JSON_PRINT' in enabled_transforms:
-        # NOTE that model analysis is performed before applying user's settings (inputs's shapes etc.)
-        framework_model = moc_front_end.decode(input_model)
-        json_model_analysis_dump(framework_model)
-        # a model is not processed further in json analysis mode
-        sys.exit(0)
-
     model_inputs = input_model.get_inputs()
     inputs_equal = True
     if user_shapes:
@@ -238,9 +293,6 @@ def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):
 
             input_model.set_tensor_value(place, value)
 
-    def shape_to_array(shape: PartialShape):
-        return [shape.get_dimension(i) for i in range(shape.rank.get_length())]
-
     ov_model = moc_front_end.convert(input_model)
 
     return ov_model

intel_npu_acceleration_library/external/openvino/tools/ovc/moc_frontend/pytorch_frontend_utils.py

@@ -8,6 +8,7 @@ import numpy as np
 # pylint: disable=no-name-in-module,import-error
 from openvino.runtime import Tensor, PartialShape
 from openvino.tools.ovc.error import Error
+from openvino.tools.ovc.cli_parser import single_input_to_input_cut_info, _InputCutInfo
 
 
 
@@ -90,76 +91,84 @@ def get_value_from_list_or_dict(container, name, idx):
     return None
 
 
+def flatten_inputs(inputs, names=None):
+    flattened = []
+    if isinstance(inputs, dict):
+        # if names are provided we need to unpack in the same order
+        if names:
+            for name in names:
+                if isinstance(inputs[name], (list, tuple, dict)):
+                    flattened.extend(flatten_inputs(inputs[name]))
+                else:
+                    flattened.append((name, inputs[name]))
+        else:
+            for name, input_data in inputs.items():
+                if isinstance(input_data, (list, tuple, dict)):
+                    flattened.extend(flatten_inputs(input_data))
+                else:
+                    flattened.append((name, input_data))
+    else:
+        for input_data in inputs:
+            if isinstance(input_data, (list, tuple, dict)):
+                flattened.extend(flatten_inputs(input_data))
+            else:
+                flattened.append(input_data)
+    return flattened
+
+
 def extract_input_info_from_example(args, inputs):
     try:
         from openvino.frontend.pytorch.utils import pt_to_ov_type_map  # pylint: disable=no-name-in-module,import-error
     except Exception as e:
         log.error("PyTorch frontend loading failed")
         raise e
-    example_inputs = args.example_input
-    data_types = args.placeholder_data_types or {}
-    input_shapes = args.placeholder_shapes or {}
+    example_inputs = args.input_model._example_input if args.input_model._example_input is not None else args.example_input
+    if example_inputs is None:
+        return
     is_dict_input = isinstance(example_inputs, dict)
-    list_inputs = list(example_inputs.values()) if is_dict_input else example_inputs
-    input_names = None
     if not isinstance(example_inputs, (list, tuple, dict)):
-        list_inputs = [list_inputs]
-    if args.input_model._input_is_list:
-        list_inputs[0] = list_inputs[0].unsqueeze(0)
-    if args.input_model._input_signature is not None and not is_dict_input:
+        example_inputs = [example_inputs]
+    input_names = None
+    if args.input_model._input_signature is not None:
         input_names = args.input_model._input_signature[1:] if args.input_model._input_signature[
                                                                    0] == "self" else args.input_model._input_signature
-        if not is_dict_input:
-            example_inputs = dict(zip(input_names, list_inputs))
-            is_dict_input = True
-    elif is_dict_input:
-        input_names = list(example_inputs)
-    if not data_types and input_names is None:
-        data_types = []
-    if not input_shapes and input_names is None:
-        input_shapes = []
-    if inputs:
-        for input_id, input_info in enumerate(inputs):
-            input_name = input_info.name
-            if is_dict_input and input_name in example_inputs:
-                example_input = example_inputs[input_name]
-            else:
-                example_input = list_inputs[input_id]
-                if is_dict_input and input_name is None:
-                    input_name = input_names[input_id]
-            dtype = getattr(example_input, "dtype", type(example_input))
-            example_dtype = pt_to_ov_type_map.get(str(dtype))
-            user_dtype = get_value_from_list_or_dict(data_types, input_name, input_id)
-            if user_dtype is not None and example_dtype is not None and example_dtype != user_dtype:
-                raise Error(
-                    f"Defined input type {user_dtype} is not equal to provided example_input type {example_dtype}")
-
-            data_rank = getattr(example_input, "ndim", 0)
-            user_input_shape = get_value_from_list_or_dict(input_shapes, input_name, input_id)
-            if user_input_shape.rank.is_static and user_input_shape.rank.get_length() != data_rank:
-                raise Error(
-                    f"Requested input shape {user_input_shape.rank.get_length()} rank"
-                    f" is not equal to provided example_input rank {data_rank}")
-
-            input_shape = user_input_shape if user_input_shape is not None else PartialShape([-1] * data_rank)
-            update_list_or_dict(data_types, input_name, input_id,
-                                example_dtype if example_dtype is not None else None)
-            update_list_or_dict(input_shapes, input_name, input_id, input_shape)
-    else:
-        for input_id, example_input in enumerate(list_inputs):
-            dtype = getattr(example_input, "dtype", type(example_input))
-            ov_dtype = pt_to_ov_type_map.get(str(dtype))
-            data_rank = getattr(example_input, "ndim", 0)
-            input_shape = PartialShape([-1] * data_rank)
-            input_name = input_names[input_id] if input_names else None
-            update_list_or_dict(input_shapes, input_name, input_id, input_shape)
-            update_list_or_dict(data_types, input_name, input_id, ov_dtype if ov_dtype is not None else None)
-
-    args.placeholder_data_types = data_types
-    args.placeholder_shapes = input_shapes
-    if not args.input and input_names:
-        args.input_list = input_names
-        args.input = ",".join(input_names)
+    if input_names and not is_dict_input:
+        example_inputs = dict(zip(input_names, example_inputs))
+    example_inputs = flatten_inputs(example_inputs, input_names)
+    input_arg = []
+    for example in example_inputs:
+        name = None
+        if isinstance(example, tuple) and len(example) == 2:
+            name = example[0]
+            example = example[1]
+        shape = PartialShape([-1] * example.ndim) if hasattr(example, "ndim") else PartialShape.dynamic()
+        dtype = getattr(example, "dtype", type(example))
+        dtype = pt_to_ov_type_map.get(str(dtype))
+        if name:
+            input_arg.append(single_input_to_input_cut_info((name, shape, dtype)))
+        else:
+            input_arg.append(single_input_to_input_cut_info((shape, dtype)))
+    if inputs is not None and len(inputs) != 0:
+        if len(inputs) == len(input_arg):
+            # we can update input argument with info from examples
+            new_input = []
+            for i in range(len(input_arg)):
+                input_desc = args.input[i]
+                name = input_desc.name
+                dtype = input_desc.type
+                shape = input_desc.shape
+                if name is None:
+                    name = input_arg[i].name
+                if dtype is None:
+                    dtype = input_arg[i].type
+                if shape is None:
+                    shape = input_arg[i].shape
+                new_input.append(_InputCutInfo(name, shape, dtype, input_desc.value))
+            input_arg = new_input
+        else:
+            # we can't update args.input
+            return
+    args.input = input_arg
 
 
 # pylint: disable=no-member

intel_npu_acceleration_library/external/openvino/tools/ovc/utils.py

@@ -1,11 +1,13 @@
 # Copyright (C) 2018-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
-import os
-from typing import Iterable, Union
-
+import importlib.util
+import logging as log
 import numpy as np
+import os
+import sys
 from openvino.tools.ovc.error import Error
+from typing import Iterable, Union
 
 try:
     import openvino_telemetry as tm
@@ -13,6 +15,11 @@ try:
 except ImportError:
     import openvino.tools.ovc.telemetry_stub as tm
 
+if sys.version_info < (3, 8):
+    import importlib_metadata
+else:
+    import importlib.metadata as importlib_metadata
+
 dynamic_dimension = np.ma.masked
 
 
@@ -107,3 +114,83 @@ def get_ir_version():
     :return: the IR version
     """
     return 11
+
+
+def import_openvino_tokenizers():
+    # extract openvino version
+    if importlib.util.find_spec("openvino") is None:
+        return False
+    try:
+        from openvino import get_version
+        openvino_version = get_version()
+        openvino_available = True
+    except ImportError:
+        openvino_available = False
+    if not openvino_available:
+        return False
+
+    if importlib.util.find_spec("openvino_tokenizers") is None:
+        return False
+
+    try:
+        pip_metadata_version = importlib_metadata.version("openvino")
+    except importlib_metadata.PackageNotFoundError:
+        pip_metadata_version = False
+    try:
+        pip_metadata_version = importlib_metadata.version("openvino-nightly")
+        is_nightly = True
+    except importlib_metadata.PackageNotFoundError:
+        is_nightly = False
+
+    try:
+        import openvino_tokenizers  # pylint: disable=no-name-in-module,import-error
+
+        openvino_tokenizers._get_factory()
+    except RuntimeError:
+        tokenizers_version = openvino_tokenizers.__version__
+
+        if tokenizers_version == "0.0.0.0":
+            try:
+                tokenizers_version = importlib_metadata.version("openvino_tokenizers") or tokenizers_version
+            except importlib_metadata.PackageNotFoundError:
+                pass
+        message = (
+            "OpenVINO and OpenVINO Tokenizers versions are not binary compatible.\n"
+            f"OpenVINO version:            {openvino_version}\n"
+            f"OpenVINO Tokenizers version: {tokenizers_version}\n"
+            "First 3 numbers should be the same. Update OpenVINO Tokenizers to compatible version. "
+        )
+        if not pip_metadata_version:
+            message += (
+                "For archive installation of OpenVINO try to build OpenVINO Tokenizers from source: "
+                "https://github.com/openvinotoolkit/openvino_tokenizers/tree/master?tab=readme-ov-file"
+                "#build-and-install-from-source"
+            )
+            if sys.platform == "linux":
+                message += (
+                    "\nThe PyPI version of OpenVINO Tokenizers is built on CentOS and may not be compatible with other "
+                    "Linux distributions; rebuild OpenVINO Tokenizers from source."
+                )
+        else:
+            message += (
+                "It is recommended to use the same day builds for pre-release version. "
+                "To install both OpenVINO and OpenVINO Tokenizers release version perform:\n"
+            )
+            if is_nightly:
+                message += "pip uninstall -y openvino-nightly && "
+            message += "pip install --force-reinstall openvino openvino-tokenizers\n"
+            if is_nightly:
+                message += (
+                    "openvino-nightly package will be deprecated in the future - use pre-release drops instead. "
+                )
+            message += "To update both OpenVINO and OpenVINO Tokenizers to the latest pre-release version perform:\n"
+            if is_nightly:
+                message += "pip uninstall -y openvino-nightly && "
+            message += (
+                "pip install --pre -U openvino openvino-tokenizers "
+                "--extra-index-url https://storage.openvinotoolkit.org/simple/wheels/nightly"
+            )
+        log.warning(message)
+        return False
+
+    return True

intel_npu_acceleration_library/external/openvino/utils.py

@@ -6,6 +6,7 @@ import os
 import sys
 from functools import wraps
 from typing import Callable, Any
+from pathlib import Path
 
 
 def _add_openvino_libs_to_search_path() -> None:
@@ -38,6 +39,22 @@ def _add_openvino_libs_to_search_path() -> None:
                 os.add_dll_directory(os.path.abspath(lib_path))
 
 
+def get_cmake_path() -> str:
+    """Searches for the directory containing CMake files within the package install directory.
+
+    :return: The path to the directory containing CMake files, if found. Otherwise, returns empty string.
+    :rtype: str
+    """
+    package_path = Path(__file__).parent
+    cmake_file = "OpenVINOConfig.cmake"
+
+    for dirpath, _, filenames in os.walk(package_path):
+        if cmake_file in filenames:
+            return dirpath
+
+    return ""
+
+
 def deprecated(name: Any = None, version: str = "", message: str = "", stacklevel: int = 2) -> Callable[..., Any]:
     """Prints deprecation warning "{function_name} is deprecated and will be removed in version {version}. {message}" and runs the function.
 

intel_npu_acceleration_library/nn/module.py

@@ -67,23 +67,23 @@ def compute_input_signature(
     return "_".join(signature)
 
 
-def patch_parameters(module: torch.nn.Module, model: NNFactory, recurse: bool = False):
-    """Patch the parameters of a PyTorch module with constants.
-
-    Args:
-        module (torch.nn.Module): The PyTorch module.
-        model (NNFactory): The NNFactory instance.
-        recurse (bool, optional): Recurse over all submodules. Defaults to False.
-    """
-    elements = list(module.named_parameters(recurse=recurse))
-    for name, param in elements:
-        del module._parameters[name]
-        setattr(module, name, model.constant(param.data.detach().numpy()))
-
-    buffers = list(module.named_buffers(recurse=recurse))
-    for name, param in buffers:
-        del module._buffers[name]
-        setattr(module, name, model.constant(param.data.detach().numpy()))
+# def patch_parameters(module: torch.nn.Module, model: NNFactory, recurse: bool = False):
+#     """Patch the parameters of a PyTorch module with constants.
+
+#     Args:
+#         module (torch.nn.Module): The PyTorch module.
+#         model (NNFactory): The NNFactory instance.
+#         recurse (bool, optional): Recurse over all submodules. Defaults to False.
+#     """
+#     elements = list(module.named_parameters(recurse=recurse))
+#     for name, param in elements:
+#         del module._parameters[name]
+#         setattr(module, name, model.constant(param.data.detach().numpy()))
+
+#     buffers = list(module.named_buffers(recurse=recurse))
+#     for name, param in buffers:
+#         del module._buffers[name]
+#         setattr(module, name, model.constant(param.data.detach().numpy()))
 
 
 def patch_modules(module: torch.nn.Module, model: NNFactory):