bigdl-core-npu 2.6.0b20241119__cp311-cp311-win_amd64.whl → 2.6.0b20241122__cp311-cp311-win_amd64.whl

intel_npu_acceleration_library/external/openvino/frontend/pytorch/ts_decoder.py

@@ -7,7 +7,14 @@
 from openvino.frontend.pytorch.py_pytorch_frontend import _FrontEndPytorchDecoder as Decoder
 from openvino.frontend.pytorch.py_pytorch_frontend import _Type as DecoderType
 from openvino.runtime import op, PartialShape, Type as OVType, OVAny
-from openvino.frontend.pytorch.utils import ivalue_to_constant, get_value_from_getattr, pt_to_ov_type_map, prepare_example_inputs_and_model, convert_quantized_tensor, graph_has_ops
+from openvino.frontend.pytorch.utils import (
+    ivalue_to_constant,
+    get_value_from_getattr,
+    pt_to_ov_type_map,
+    prepare_example_inputs_and_model,
+    convert_quantized_tensor,
+    graph_has_ops,
+)
 from openvino.runtime import opset11 as ops
 from openvino.frontend.pytorch import gptq
 from openvino.frontend.pytorch import patch_model
@@ -15,20 +22,22 @@ from openvino.frontend.pytorch.module_extension import ModuleExtension
 
 import typing
 import torch
+import inspect
 
 
-class TorchScriptPythonDecoder (Decoder):
+class TorchScriptPythonDecoder(Decoder):
     def __init__(
-            self,
-            pt_module,
-            graph_element=None,
-            example_input=None,
-            alias_db=None,
-            shared_memory=True,
-            skip_freeze=False,
-            constant_cache=None,
-            module_extensions=None):
-        Decoder.__init__(self)
+        self,
+        pt_module,
+        graph_element=None,
+        example_input=None,
+        alias_db=None,
+        shared_memory=True,
+        skip_freeze=False,
+        constant_cache=None,
+        module_extensions=None,
+    ):
+        super().__init__()
         # We store every decoder created by this decoder so that all them are not deleted until the first decoder is deleted
         self.m_decoders = []
         self._input_signature = None
@@ -36,7 +45,12 @@ class TorchScriptPythonDecoder (Decoder):
         self._input_is_list = False
         self.constant_cache = constant_cache if constant_cache is not None else dict()
         self.module_extensions = module_extensions
+        self.config = None
+        self.out_debug_name_overwrites = {}
         if graph_element is None:
+            if hasattr(pt_module, "config"):
+                self.config = pt_module.config.to_dict() if not isinstance(
+                    pt_module.config, dict) else pt_module.config
             try:
                 pt_module = self._get_scripted_model(
                     pt_module, example_input, skip_freeze)
@@ -53,7 +67,8 @@ class TorchScriptPythonDecoder (Decoder):
                     f"Couldn't get TorchScript module by {msg}. With exception:\n{e}\n{help_msg} "
                     "You can also provide TorchScript module that you obtained"
                     " yourself, please refer to PyTorch documentation: "
-                    "https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html.")
+                    "https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html."
+                )
             self.graph_element = pt_module.inlined_graph
             self.alias_db = self.graph_element.alias_db()
         else:
@@ -77,27 +92,27 @@ class TorchScriptPythonDecoder (Decoder):
             self._transform_tensor_list_constants_to_listconstruct(
                 self.graph_element)
             self._transform_optional_constants(self.graph_element)
-        self.out_debug_name_overwrites = {}
 
     @staticmethod
     def _get_preserved_attributes(model) -> list:
         preserved_attributes = []
         for name, module in model.named_modules():
-            if hasattr(module, "weight"):
-                if module.weight is not None and getattr(module.weight, "dtype", None) in [torch.int8, torch.uint8, torch.float16, torch.bfloat16]:
-                    preserved_attributes.append(name)
+            compressed_types = [torch.int8, torch.uint8,
+                                torch.float16, torch.bfloat16]
+            if hasattr(module, "weight") and getattr(module.weight, "dtype", None) in compressed_types:
+                preserved_attributes.append(name)
         return preserved_attributes
 
     def _get_scripted_model(self, pt_module, example_inputs=None, skip_freeze=False):
-        import torch
-        import inspect
-
         freeze_by_default = False
         if isinstance(pt_module, torch.nn.Module):
             pt_module.eval()
         input_signature = None
         input_parameters = None
-        if isinstance(pt_module, torch.nn.Module) and not isinstance(pt_module, (torch.jit._trace.TopLevelTracedModule, torch.jit._script.RecursiveScriptModule)):
+        if isinstance(pt_module, torch.nn.Module) and not isinstance(
+            pt_module, (torch.jit._trace.TopLevelTracedModule,
+                        torch.jit._script.RecursiveScriptModule)
+        ):
             # input params is dictionary contains input names and their signature values (type hints and default values if any)
             input_params = inspect.signature(pt_module.forward if hasattr(
                 pt_module, "forward") else pt_module.__call__).parameters
@@ -105,7 +120,8 @@ class TorchScriptPythonDecoder (Decoder):
 
             if example_inputs is None:
                 if self.module_extensions:
-                    raise RuntimeError("ModuleExtension is not supported for scripting. Please provide valid example_input argument to run tracing.")
+                    raise RuntimeError(
+                        "ModuleExtension is not supported for scripting. Please provide valid example_input argument to run tracing.")
                 scripted = torch.jit.script(pt_module)
                 freeze_by_default = True
             else:
@@ -113,9 +129,10 @@ class TorchScriptPythonDecoder (Decoder):
                     example_inputs, input_params, pt_module)
 
                 # name of attribute in a patched module where the original forward method is kept
-                orig_forward_name = '_openvino_module_extension_patch_orig_forward'
+                orig_forward_name = "_openvino_module_extension_patch_orig_forward"
                 if self.module_extensions:
-                    patch_model.patch_model(pt_module, self.module_extensions, orig_forward_name)
+                    patch_model.patch_model(
+                        pt_module, self.module_extensions, orig_forward_name)
 
                 gptq_patched = False
                 if gptq.detect_gptq_model(pt_module):
@@ -124,9 +141,9 @@ class TorchScriptPythonDecoder (Decoder):
                         gptq_patched = True
                     except Exception as error:
                         print(
-                            '[ WARNING ] Failed patching of AutoGPTQ model. Error message:\n', error)
+                            "[ WARNING ] Failed patching of AutoGPTQ model. Error message:\n", error)
                         print(
-                            '[ WARNING ] Tracing of the model will likely be unsuccessful or incorrect')
+                            "[ WARNING ] Tracing of the model will likely be unsuccessful or incorrect")
                         gptq.unpatch_model(pt_module)
                         gptq_patched = False
 
@@ -139,10 +156,13 @@ class TorchScriptPythonDecoder (Decoder):
                     if self.module_extensions:
                         patch_model.unpatch_model(pt_module, orig_forward_name)
 
-            if not freeze_by_default and graph_has_ops(scripted.inlined_graph, ["prim::Uninitialized", "prim::unchecked_cast", "aten::append"]):
+            have_to_freeze_ops = ["prim::Uninitialized",
+                                  "prim::unchecked_cast", "aten::append"]
+            if not freeze_by_default and graph_has_ops(scripted.inlined_graph, have_to_freeze_ops):
                 # freeze models with unsupported ops
                 freeze_by_default = True
-            if freeze_by_default and graph_has_ops(scripted.inlined_graph, ["quantized", "aten::as_strided"]):
+            quantized_hint_ops = ["quantized", "aten::as_strided"]
+            if freeze_by_default and graph_has_ops(scripted.inlined_graph, quantized_hint_ops):
                 # do not freeze quantized models and can't freeze for aten::as_strided it will result in incorrect inference
                 freeze_by_default = False
             if freeze_by_default and not skip_freeze:
@@ -253,12 +273,14 @@ class TorchScriptPythonDecoder (Decoder):
     def visit_subgraph(self, node_visitor) -> None:
         # make sure topological order is satisfied
         for node in self.graph_element.nodes():
-            decoder = TorchScriptPythonDecoder(self.pt_module,
-                                               node,
-                                               alias_db=self.alias_db,
-                                               shared_memory=self._shared_memory,
-                                               constant_cache=self.constant_cache,
-                                               module_extensions=self.module_extensions)
+            decoder = TorchScriptPythonDecoder(
+                self.pt_module,
+                node,
+                alias_db=self.alias_db,
+                shared_memory=self._shared_memory,
+                constant_cache=self.constant_cache,
+                module_extensions=self.module_extensions,
+            )
             self.m_decoders.append(decoder)
             node_visitor(decoder)
 
@@ -278,31 +300,32 @@ class TorchScriptPythonDecoder (Decoder):
         return list(self.graph_element.blocks())
 
     def get_subgraph_decoder(self, index: int):
-        decoder = TorchScriptPythonDecoder(self.pt_module,
-                                           self.get_subgraphs()[index],
-                                           alias_db=self.alias_db,
-                                           shared_memory=self._shared_memory,
-                                           module_extensions=self.module_extensions)
+        decoder = TorchScriptPythonDecoder(
+            self.pt_module, self.get_subgraphs(
+            )[index], alias_db=self.alias_db, shared_memory=self._shared_memory, module_extensions=self.module_extensions
+        )
         self.m_decoders.append(decoder)
         return decoder
 
     def get_op_type(self) -> str:
         assert isinstance(
             self.graph_element, torch.Node), "Function can be called only when self.graph_element is of type torch.Node"
-        if self.graph_element.kind() == "prim::PythonOp":
-            if hasattr(self.graph_element, 'pyobj') and callable(self.graph_element.pyobj) and hasattr(self.graph_element.pyobj(), '__self__'):
-                trampoline = self.graph_element.pyobj().__self__
-                if hasattr(trampoline, 'target_extension') and isinstance(trampoline.target_extension, ModuleExtension):
-                    target_op = trampoline.target_extension.target_op
-                    if callable(target_op):
-                        target = target_op(trampoline.original_module)
-                    elif isinstance(target_op, str):
-                        target = target_op
-                    # TODO: Support target as a callable that will play a role of ConversionExtension for an entire module instead of a single op.
-                    # Without supporting target as a callable here, ConversionExtension functionality is still possible to implement
-                    # by combining two extensions: ModuleExtension that use temporary name as a target op and another extension of type ConversionExtension
-                    # that translates that particular temporary name to custom graph. But providing conversion code as a callable `target` is more convenient.
-                    return target
+        if self.graph_element.kind() == "prim::PythonOp" and callable(getattr(self.graph_element, "pyobj", None)):
+            pyobj = self.graph_element.pyobj()
+            trampoline = getattr(pyobj, "__self__", None)
+            target_extension = getattr(trampoline, "target_extension", None)
+
+            if isinstance(target_extension, ModuleExtension):
+                target_op = target_extension.target_op
+                if callable(target_op):
+                    target = target_op(trampoline.original_module)
+                elif isinstance(target_op, str):
+                    target = target_op
+                # TODO: Support target as a callable that will play a role of ConversionExtension for an entire module instead of a single op.
+                # Without supporting target as a callable here, ConversionExtension functionality is still possible to implement
+                # by combining two extensions: ModuleExtension that use temporary name as a target op and another extension of type ConversionExtension
+                # that translates that particular temporary name to custom graph. But providing conversion code as a callable `target` is more convenient.
+                return target
         return self.graph_element.kind()
 
     def get_schema(self) -> str:
@@ -342,8 +365,8 @@ class TorchScriptPythonDecoder (Decoder):
         self.constant_cache[name] = outputs
 
     def try_decode_get_attr(self):
-        pt_value, name = get_value_from_getattr(self.graph_element,
-                                                self.pt_module)
+        pt_value, name = get_value_from_getattr(
+            self.graph_element, self.pt_module)
         assert pt_value is not None, "Couldn't retrieve value from prim::GetAttr"
         if isinstance(pt_value, torch.ScriptObject):
             # We assume this is __torch__.torch.classes.quantized.Conv2dPackedParamsBase or __torch__.torch.classes.quantized.LinearPackedParamsBase
@@ -389,8 +412,8 @@ class TorchScriptPythonDecoder (Decoder):
             if name in self.constant_cache:
                 const = self.constant_cache[name]
             else:
-                const = ivalue_to_constant(pt_value,
-                                           shared_memory=self._shared_memory)
+                const = ivalue_to_constant(
+                    pt_value, shared_memory=self._shared_memory)
                 self._add_name_to_const_and_cache(const, name)
             return const
         else:
@@ -404,12 +427,11 @@ class TorchScriptPythonDecoder (Decoder):
         pt_value = self._raw_output(0)
         pt_type = pt_value.type()
         if isinstance(pt_type, torch.TensorType):
-            return ivalue_to_constant(pt_value.toIValue(),
-                                      shared_memory=self._shared_memory)
+            return ivalue_to_constant(pt_value.toIValue(), shared_memory=self._shared_memory)
         if isinstance(pt_type, torch.ListType):
             return self._as_constant_list(pt_value)
-        const = ivalue_to_constant(pt_value.toIValue(),
-                                   shared_memory=self._shared_memory)
+        const = ivalue_to_constant(
+            pt_value.toIValue(), shared_memory=self._shared_memory)
         if len(const) > 0:
             # set name corresponding to state_dict name
             const[0].get_node().set_friendly_name(
@@ -463,8 +485,8 @@ class TorchScriptPythonDecoder (Decoder):
             else:
                 in_node = r_input.node()
                 if in_node.kind() == "prim::GetAttr":
-                    pt_value, _ = get_value_from_getattr(in_node,
-                                                         self.pt_module)
+                    pt_value, _ = get_value_from_getattr(
+                        in_node, self.pt_module)
                     return pt_value is None
         return False
 
@@ -490,6 +512,13 @@ class TorchScriptPythonDecoder (Decoder):
     def get_named_input(self, name):
         raise RuntimeError("There is no named inputs in TS graph")
 
+    def get_rt_info(self):
+        rt_info = {}
+        if self.config is not None and "quantization_config" in self.config and "sym" in self.config["quantization_config"]:
+            rt_info["symmetric_quantization"] = OVAny(
+                self.config["quantization_config"]["sym"])
+        return rt_info
+
     @staticmethod
     def _transform_tensor_list_constants_to_listconstruct(graph: torch.Graph):
         # Function replaces prim::Constant containing List of Tensors with

intel_npu_acceleration_library/external/openvino/frontend/pytorch/utils.py

@@ -25,7 +25,7 @@ def fetch_attr(self_module, target: str):
     Return:
         Any: The value of the attribute.
     """
-    target_atoms = target.split('.')
+    target_atoms = target.split(".")
     attr_itr = self_module
     for i, atom in enumerate(target_atoms):
         if not hasattr(attr_itr, atom):
@@ -91,12 +91,13 @@ def get_value_from_getattr(getattr_node, self_module):
         node = stack.pop()
         attr_name = node.s("name")
         assert hasattr(
-            module, attr_name), f"No attribute with name \"{attr_name}\" found in module."
+            module, attr_name), f'No attribute with name "{attr_name}" found in module.'
         path_name = ".".join([path_name, attr_name])
         module = getattr(module, attr_name)
     return module, path_name
 
-def graph_has_ops(graph, op_types:list) -> bool:
+
+def graph_has_ops(graph, op_types: list) -> bool:
     res = False
     for n in graph.nodes():
         if any(kind in n.kind() for kind in op_types):
@@ -106,7 +107,7 @@ def graph_has_ops(graph, op_types:list) -> bool:
         if res:
             return res
     return res
-    
+
 
 pt_to_ov_type_map = {
     "float": OVType.f32,
@@ -134,7 +135,7 @@ pt_to_ov_type_map = {
     "torch.BoolTensor": OVType.boolean,
     "torch.quint8": OVType.u8,
     "torch.qint8": OVType.i8,
-    "torch.qint32": OVType.i32
+    "torch.qint32": OVType.i32,
 }
 
 
@@ -159,7 +160,7 @@ def process_dict_inputs(inputs, input_params, model):
             ordered_inputs.append(input_name)
 
     input_signature = list(input_params)
-    if ordered_inputs == input_signature[:len(ordered_inputs)]:
+    if ordered_inputs == input_signature[: len(ordered_inputs)]:
         example_inputs = [inputs[input_name] for input_name in ordered_inputs]
         if all([isinstance(inp, torch.Tensor) for inp in example_inputs]):
             return {"example_inputs": [inputs[name] for name in ordered_inputs]}, ordered_inputs, model
@@ -191,8 +192,8 @@ def process_dict_inputs(inputs, input_params, model):
             str(input_params[input_name]).replace("NoneType", "None"))
         input_params_str.append(f"{input_name}={input_name}")
 
-    wrapper_class = wrapper_template.format(input_sign=', '.join(
-        input_sign_str), example_input=', '.join(input_params_str))
+    wrapper_class = wrapper_template.format(input_sign=", ".join(
+        input_sign_str), example_input=", ".join(input_params_str))
     result = {}
     try:
         exec(wrapper_class, result)
@@ -210,7 +211,8 @@ def prepare_example_inputs_and_model(inputs, input_params, model):
     input_is_list = False
     input_signature = list(input_params)
     if isinstance(inputs, dict):
-        examples, ordered, wrapped = process_dict_inputs(inputs, input_params, model)
+        examples, ordered, wrapped = process_dict_inputs(
+            inputs, input_params, model)
         return examples, ordered, wrapped, input_is_list
     if isinstance(inputs, list) and len(inputs) == 1 and isinstance(inputs[0], torch.Tensor):
         if "typing.List" in str(input_params[input_signature[0]].annotation):
@@ -219,7 +221,7 @@ def prepare_example_inputs_and_model(inputs, input_params, model):
 
     if isinstance(inputs, torch.Tensor):
         inputs = [inputs]
-    input_signature = input_signature[:len(inputs)]
+    input_signature = input_signature[: len(inputs)]
     return {"example_inputs": inputs}, input_signature, model, input_is_list
 
 

intel_npu_acceleration_library/external/openvino/frontend/tensorflow/utils.py

@@ -6,13 +6,12 @@
 
 
 import logging as log
+import numpy as np
 import sys
+from openvino.runtime import PartialShape, Dimension, Type
 from packaging.version import parse, Version
 from typing import List, Dict, Union
 
-import numpy as np
-from openvino.runtime import PartialShape, Dimension, Type
-
 
 # TODO: reuse this method in ovc and remove duplication
 def get_static_shape(shape: [PartialShape, list, tuple], dynamic_value=None):
@@ -106,13 +105,32 @@ def trace_tf_model_if_needed(input_model, placeholder_shapes, placeholder_data_t
     return trace_tf_model(input_model, placeholder_shapes, placeholder_data_types, example_input)
 
 
-def get_input_spec_from_model(model):
+def partial_shape_to_list(partial_shape: PartialShape):
+    if partial_shape.rank.is_dynamic:
+        return None
+    res_list = []
+    for dim in partial_shape:
+        if dim.is_static:
+            res_list.append(dim.get_length())
+        else:
+            res_list.append(None)
+    return res_list
+
+
+def get_input_spec_from_model(model, input_shapes=None):
     import tensorflow as tf
     if hasattr(model, "_build_input_shape") and model._build_input_shape is not None:
         if isinstance(model._build_input_shape, list):
             input_spec = [[tf.TensorSpec(shape) for shape in model._build_input_shape]]
         else:
             input_spec = [tf.TensorSpec(model._build_input_shape)]
+    elif input_shapes and isinstance(input_shapes, list) and len(input_shapes) > 0:
+        input_spec = []
+        for input_shape in input_shapes:
+            if isinstance(input_shape, PartialShape):
+                input_spec.append(tf.TensorSpec(partial_shape_to_list(input_shape)))
+            else:
+                input_spec.append(tf.TensorSpec(None))
     else:
         input_spec = [tf.TensorSpec(None)]
     return input_spec
@@ -199,10 +217,13 @@ def create_generic_function_from_keras_model(keras_model):
     if tf_input_signature is not None:
         @tf.function(input_signature=tf_input_signature)
         def wrapper_function_dict(*args):
-            input_dict = {}
-            for ind, tensor_spec in enumerate(tf_input_signature):
-                input_dict[tensor_spec.name] = args[ind]
-            outputs = keras_model(input_dict)
+            if isinstance(keras_input_signature, list):
+                outputs = keras_model(args)
+            else:
+                input_dict = {}
+                for ind, tensor_spec in enumerate(tf_input_signature):
+                    input_dict[tensor_spec.name] = args[ind]
+                outputs = keras_model(input_dict)
             # need to wrap the output into dictionary
             # it helps to preserve original keras tensor names
             post_outputs = {}
@@ -276,7 +297,7 @@ def trace_tf_model(model, input_shapes, input_types, example_input):
                                               "Could not trace the TF model with the following error: {}",
                                               use_example_input=False)
         else:
-            input_spec = get_input_spec_from_model(model)
+            input_spec = get_input_spec_from_model(model, input_shapes)
             concrete_func = get_concrete_func(tf_function, input_spec, input_needs_packing,
                                               "Could not trace the TF model with the following error: {}.\n"
                                               "Please provide 'example_input'.")
@@ -457,4 +478,4 @@ def tf_type_to_ov_type(val):
     }
     if val not in tf_to_ov_type:
         raise Exception("The provided data type is not supported by OpenVino {}.".format(val))
-    return tf_to_ov_type[val]
+    return tf_to_ov_type[val]

intel_npu_acceleration_library/external/openvino/runtime/ie_api.py

@@ -507,7 +507,7 @@ class Core(CoreBase):
         device_name: Optional[str] = None,
         config: Optional[dict] = None,
         *,
-        weights: Optional[bytes] = None
+        weights: Optional[bytes] = None,
     ) -> CompiledModel:
         """Creates a compiled model.
 

intel_npu_acceleration_library/external/openvino/runtime/opset15/__init__.py

@@ -10,3 +10,8 @@ from openvino.runtime.opset15.ops import col2im
 from openvino.runtime.opset15.ops import embedding_bag_offsets
 from openvino.runtime.opset15.ops import embedding_bag_packed
 from openvino.runtime.opset15.ops import scatter_nd_update
+from openvino.runtime.opset15.ops import roi_align_rotated
+from openvino.runtime.opset15.ops import string_tensor_pack
+from openvino.runtime.opset15.ops import string_tensor_unpack
+from openvino.runtime.opset15.ops import bitwise_left_shift
+from openvino.runtime.opset15.ops import bitwise_right_shift

intel_npu_acceleration_library/external/openvino/runtime/opset15/ops.py

@@ -11,7 +11,7 @@ from openvino.runtime import Node, Type
 from openvino.runtime.opset1 import convert_like
 from openvino.runtime.opset14 import constant
 from openvino.runtime.opset_utils import _get_node_factory
-from openvino.runtime.utils.decorators import nameable_op
+from openvino.runtime.utils.decorators import binary_op, nameable_op
 from openvino.runtime.utils.types import NodeInput, as_nodes
 
 _get_node_factory_opset15 = partial(_get_node_factory, "opset15")
@@ -144,3 +144,133 @@ def embedding_bag_packed(
         inputs.append(per_sample_weights)
 
     return _get_node_factory_opset15().create("EmbeddingBagPacked", as_nodes(*inputs, name=name), {"reduction": reduction})
+
+
+@nameable_op
+def roi_align_rotated(
+    data: NodeInput,
+    rois: NodeInput,
+    batch_indices: NodeInput,
+    pooled_h: int,
+    pooled_w: int,
+    sampling_ratio: int,
+    spatial_scale: float,
+    clockwise_mode: bool,
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs ROIAlignRotated operation.
+
+    :param data: Input data.
+    :param rois: RoIs (Regions of Interest) to pool over.
+    :param batch_indices: Tensor with each element denoting the index of
+                          the corresponding image in the batch.
+    :param pooled_h: Height of the ROI output feature map.
+    :param pooled_w: Width of the ROI output feature map.
+    :param sampling_ratio: Number of bins over height and width to use to calculate
+                           each output feature map element.
+    :param spatial_scale: Multiplicative spatial scale factor to translate ROI coordinates.
+    :param clockwise_mode:  If true, rotation angle is interpreted as clockwise,
+                            otherwise as counterclockwise
+    :param name: The optional name for the output node
+
+    :return: The new node which performs ROIAlignRotated
+    """
+    return _get_node_factory_opset15().create(
+        "ROIAlignRotated",
+        as_nodes(data, rois, batch_indices, name=name),
+        {
+            "pooled_h": pooled_h,
+            "pooled_w": pooled_w,
+            "sampling_ratio": sampling_ratio,
+            "spatial_scale": spatial_scale,
+            "clockwise_mode": clockwise_mode,
+        },
+    )
+
+
+@nameable_op
+def string_tensor_unpack(
+    data: NodeInput,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform an operation which unpacks a batch of strings into three tensors.
+
+    :param data: The node providing input data.
+
+    :return: The new node performing StringTensorUnpack operation.
+    """
+    return _get_node_factory_opset15().create(
+        "StringTensorUnpack",
+        as_nodes(data, name=name)
+    )
+
+
+@nameable_op
+def string_tensor_pack(
+    begins: NodeInput,
+    ends: NodeInput,
+    symbols: NodeInput,
+    name: Optional[str] = None,
+) -> Node:
+    """Perform an operation which packs a concatenated batch of strings into a batched string tensor.
+
+    :param begins: ND tensor of non-negative integer numbers containing indices of each string's beginnings.
+    :param ends: ND tensor of non-negative integer numbers containing indices of each string's endings.
+    :param symbols: 1D tensor of concatenated strings data encoded in utf-8 bytes.
+
+    :return: The new node performing StringTensorPack operation.
+    """
+    return _get_node_factory_opset15().create(
+        "StringTensorPack",
+        as_nodes(begins, ends, symbols, name=name)
+    )
+
+
+@binary_op
+def bitwise_left_shift(
+    arg0: NodeInput,
+    arg1: NodeInput,
+    auto_broadcast: str = "NUMPY",
+    name: Optional[str] = None,
+) -> Node:
+    """Return node which performs BitwiseLeftShift operation on input nodes element-wise.
+
+    :param arg0: Node with data to be shifted.
+    :param arg1: Node with number of shifts.
+    :param auto_broadcast: The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
+                           Defaults to “NUMPY”.
+
+    :return: The new node performing BitwiseLeftShift operation.
+    """
+    return _get_node_factory_opset15().create(
+        "BitwiseLeftShift",
+        as_nodes(arg0, arg1, name=name),
+        {
+            "auto_broadcast": auto_broadcast.upper(),
+        },
+    )
+
+
+@binary_op
+def bitwise_right_shift(
+    arg0: NodeInput,
+    arg1: NodeInput,
+    auto_broadcast: str = "NUMPY",
+    name: Optional[str] = None,
+) -> Node:
+    """Return node which performs BitwiseRightShift operation on input nodes element-wise.
+
+    :param arg0: Tensor with data to be shifted.
+    :param arg1: Tensor with number of shifts.
+    :param auto_broadcast: The type of broadcasting specifies rules used for auto-broadcasting of input tensors.
+                           Defaults to “NUMPY”.
+
+    :return: The new node performing BitwiseRightShift operation.
+    """
+    return _get_node_factory_opset15().create(
+        "BitwiseRightShift",
+        as_nodes(arg0, arg1, name=name),
+        {
+            "auto_broadcast": auto_broadcast.upper(),
+        },
+    )