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

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

@@ -0,0 +1,256 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# flake8: noqa
+# mypy: ignore-errors
+
+import torch
+import numpy as np
+
+from openvino.runtime import op, Type as OVType, Shape, Tensor
+from openvino.runtime import opset11 as ops
+
+
+def make_constant(*args, **kwargs):
+    return op.Constant(*args, **kwargs)
+
+
+def fetch_attr(self_module, target: str):
+    """
+    Fetch an attribute from the ``Module`` hierarchy of ``self.module``.
+
+    Args:
+        target (str): The fully-qualified name of the attribute to fetch
+
+    Return:
+        Any: The value of the attribute.
+    """
+    target_atoms = target.split('.')
+    attr_itr = self_module
+    for i, atom in enumerate(target_atoms):
+        if not hasattr(attr_itr, atom):
+            raise RuntimeError(
+                f"Node referenced nonexistent target {'.'.join(target_atoms[:i])}")
+        attr_itr = getattr(attr_itr, atom)
+    return attr_itr
+
+
+def get_type_from_py_type(value):
+    if isinstance(value, float):
+        return OVType.f32
+    if isinstance(value, bool):
+        return OVType.boolean
+    if isinstance(value, int):
+        return OVType.i64
+    return OVType.dynamic
+
+
+def torch_tensor_to_ov_const(torch_t: torch.Tensor, shared_memory=True):
+    torch_t = torch_t.contiguous()
+    if torch_t.dtype == torch.bfloat16:
+        # reinterpret bfloat16 data as float16 to allow conversion to numpy
+        torch_t = torch_t.view(torch.float16)
+        narr = torch_t.numpy(force=True)
+        tensor = Tensor(narr, torch_t.shape, OVType.bf16)
+        ov_const = op.Constant(tensor, shared_memory=shared_memory)
+    else:
+        narr = torch_t.numpy(force=True)
+        ov_const = op.Constant(narr, shared_memory=shared_memory)
+    return ov_const
+
+
+def ivalue_to_constant(ivalue, shared_memory=True):
+    ov_type = get_type_from_py_type(ivalue)
+    if ov_type.is_static():
+        return op.Constant(ov_type, Shape([]), [ivalue]).outputs()
+
+    if isinstance(ivalue, (list, tuple)):
+        assert len(ivalue) > 0, "Can't deduce type for empty list"
+        ov_type = get_type_from_py_type(ivalue[0])
+        assert ov_type.is_static(), "Can't deduce type for list"
+        return op.Constant(ov_type, Shape([len(ivalue)]), ivalue).outputs()
+
+    if isinstance(ivalue, torch.Tensor):
+        return torch_tensor_to_ov_const(ivalue, shared_memory=shared_memory).outputs()
+    return None
+
+
+def get_value_from_getattr(getattr_node, self_module):
+    assert getattr_node.kind() == "prim::GetAttr", "Got node of kind not equal to prim::GetAttr"
+    # GetAttr nodes can be nested
+    stack = []
+    while getattr_node.kind() == "prim::GetAttr":
+        stack.append(getattr_node)
+        inputs = list(getattr_node.inputs())
+        if len(inputs) == 0:
+            break
+        getattr_node = inputs[0].node()
+    module = self_module
+    path_name = "self"
+    while len(stack) > 0:
+        node = stack.pop()
+        attr_name = node.s("name")
+        assert hasattr(
+            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:
+    res = False
+    for n in graph.nodes():
+        if any(kind in n.kind() for kind in op_types):
+            return True
+        for b in n.blocks():
+            res = graph_has_ops(b, op_types)
+        if res:
+            return res
+    return res
+    
+
+pt_to_ov_type_map = {
+    "float": OVType.f32,
+    "int": OVType.i64,
+    "bool": OVType.boolean,
+    "torch.bfloat16": OVType.bf16,
+    "torch.float16": OVType.f16,
+    "torch.float32": OVType.f32,
+    "torch.float64": OVType.f64,
+    "torch.uint8": OVType.u8,
+    "torch.int8": OVType.i8,
+    "torch.int16": OVType.i16,
+    "torch.int32": OVType.i32,
+    "torch.int64": OVType.i64,
+    "torch.bool": OVType.boolean,
+    "torch.DoubleTensor": OVType.f64,
+    "torch.FloatTensor": OVType.f32,
+    "torch.HalfTensor": OVType.f16,
+    "torch.BFloat16Tensor": OVType.bf16,
+    "torch.IntTensor": OVType.i32,
+    "torch.LongTensor": OVType.i64,
+    "torch.ShortTensor": OVType.i16,
+    "torch.CharTensor": OVType.i8,
+    "torch.ByteTensor": OVType.u8,
+    "torch.BoolTensor": OVType.boolean,
+    "torch.quint8": OVType.u8,
+    "torch.qint8": OVType.i8,
+    "torch.qint32": OVType.i32
+}
+
+
+wrapper_template = """
+import torch
+from typing import *
+
+class ModelWrapper(torch.nn.Module):
+    def __init__(self, model):
+        super().__init__()
+        self.model = model
+
+    def forward(self, {input_sign}):
+        return self.model({example_input})
+"""
+
+
+def process_dict_inputs(inputs, input_params, model):
+    ordered_inputs = []
+    for input_name in input_params:
+        if input_name in inputs:
+            ordered_inputs.append(input_name)
+
+    input_signature = list(input_params)
+    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
+        return {"example_inputs": example_inputs}, ordered_inputs, model
+
+    # PyTorch has some difficulties to trace models with named unordered parameters:
+    # torch < 2.0.0 supports only positional arguments for tracing
+    # pytorch == 2.0.0 supports input kwargs tracing,
+    # but does not support complex nested objects (e. g. tuple of tuples of tensors)
+    # We will use wrapper for making them positional as workaround.
+
+    input_sign_str = []
+    input_params_str = []
+
+    for input_name in ordered_inputs:
+        if str(input_params[input_name].annotation).startswith("typing.Union"):
+            filter_custom_args = []
+            for arg in input_params[input_name].annotation.__args__:
+                str_arg = str(arg)
+                is_typing = str_arg.startswith("typing.")
+                is_torch = "torch." in str_arg
+                is_builten = str_arg in (str(int), str(float), str(type(None)))
+                if not (is_typing or is_torch or is_builten):
+                    continue
+                filter_custom_args.append(arg)
+            input_params[input_name].annotation.__args__ = tuple(
+                filter_custom_args)
+        input_sign_str.append(
+            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))
+    result = {}
+    try:
+        exec(wrapper_class, result)
+
+        wrapped_model = result["ModelWrapper"](model)
+        wrapped_model.eval()
+    # if wrapping failed, it is better to return original model for avoid user confusion regarding error message
+    except Exception:
+        wrapped_model = model
+
+    return {"example_inputs": [inputs[name] for name in ordered_inputs]}, ordered_inputs, wrapped_model
+
+
+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)
+        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):
+            inputs = inputs[0].unsqueeze(0)
+            input_is_list = True
+
+    if isinstance(inputs, torch.Tensor):
+        inputs = [inputs]
+    input_signature = input_signature[:len(inputs)]
+    return {"example_inputs": inputs}, input_signature, model, input_is_list
+
+
+def convert_quantized_tensor(qtensor: torch.Tensor, shared_memory: bool):
+    # represents torch quantized tensor as
+    # Constant(u8) -> Convert(f32) -> Subtract(zero_point) -> Multiply(scale)
+    qscheme = qtensor.qscheme()
+    if qscheme == torch.per_channel_affine:
+        int8_tensor = qtensor.int_repr()
+        scale = qtensor.q_per_channel_scales().numpy().astype(np.float32)
+        zero_point = qtensor.q_per_channel_zero_points().numpy().astype(np.float32)
+        axis = np.int32(qtensor.q_per_channel_axis())
+
+        new_shape = np.ones(len(int8_tensor.shape), dtype=np.int32)
+        new_shape[axis] = -1
+        zero_point_bc = np.reshape(zero_point, new_shape)
+        scale_bc = np.reshape(scale, new_shape)
+
+        int8_const = torch_tensor_to_ov_const(
+            int8_tensor, shared_memory=shared_memory)
+        convert = ops.convert(int8_const, np.float32)
+        sub = ops.subtract(convert, zero_point_bc)
+        return ops.multiply(sub, scale_bc).outputs()
+    elif qscheme == torch.per_tensor_affine:
+        int8_tensor = qtensor.int_repr()
+        scale = np.float32(qtensor.q_scale())
+        zero_point = np.float32(qtensor.q_zero_point())
+
+        int8_const = torch_tensor_to_ov_const(
+            int8_tensor, shared_memory=shared_memory)
+        convert = ops.convert(int8_const, np.float32)
+        sub = ops.subtract(convert, zero_point)
+        return ops.multiply(sub, scale).outputs()
+    assert False, "Unsupported qscheme"

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

@@ -0,0 +1,16 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Package: openvino
+Low level wrappers for the FrontEnd C++ API.
+"""
+
+# flake8: noqa
+
+try:
+    from openvino.frontend.tensorflow.py_tensorflow_frontend import _FrontEndPyGraphIterator as GraphIterator
+    from openvino.frontend.tensorflow.py_tensorflow_frontend import ConversionExtensionTensorflow as ConversionExtension
+    from openvino.frontend.tensorflow.py_tensorflow_frontend import OpExtensionTensorflow as OpExtension
+except ImportError as err:
+    raise ImportError("OpenVINO Tensorflow frontend is not available, please make sure the frontend is built. " "{}".format(err))

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

@@ -0,0 +1,116 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# flake8: noqa
+# mypy: ignore-errors
+
+import tensorflow as tf
+from openvino.frontend.tensorflow.node_decoder import TFGraphNodeDecoder
+from openvino.frontend.tensorflow.py_tensorflow_frontend import _FrontEndPyGraphIterator as GraphIterator
+
+
+class GraphIteratorTFGraph(GraphIterator):
+    def __init__(self, tf_graph: tf.Graph, share_weights: bool, inner_graph: bool = False,
+                 input_names_map: dict = None, output_names_map: dict = None):
+        GraphIterator.__init__(self)
+        self.m_graph = tf_graph
+        self.m_node_index = 0
+        self.m_decoders = []
+        self.m_inner_graph = inner_graph
+        self.m_share_weights = share_weights
+        self.m_input_names_map = input_names_map or {}
+        self.m_output_names_map = output_names_map or {}
+        self.m_vars = None
+        if hasattr(tf_graph, "variables"):
+            # This field is needed to keep the link to graph variables,
+            # otherwise Python releases memory kept by variables when it is accessed from c++ bindings
+            self.m_vars = tf_graph.variables
+
+        for op in tf_graph.get_operations():
+            self.m_decoders.append(TFGraphNodeDecoder(op, share_weights, inner_graph))
+
+        self.m_iterators = {}
+        for func_name, _ in self.m_graph._functions.items():
+            self.m_iterators[func_name] = None
+
+    def get_input_names(self) -> list:
+        # returns a vector of input names in the original order
+        # Note: used only for the library functions
+        if not self.m_inner_graph:
+            return []
+        inp_ops = filter(lambda op: op.type == "Placeholder", self.m_graph.get_operations())
+        inp_names = []
+        if hasattr(self.m_graph, 'inputs') and self.m_graph.inputs:
+            for inp in self.m_graph.inputs:
+                inp_names.append(inp.name)
+            return inp_names
+        for inp in inp_ops:
+            assert isinstance(inp, tf.Operation), "Unknown node type. Expected tf.Operation, got {}".format(type(inp))
+            assert hasattr(inp, "node_def") and isinstance(inp.node_def, tf.compat.v1.NodeDef), \
+                "Could not find node_def in node {}".format(inp.name)
+            type_attr = inp.node_def.attr["dtype"].type
+
+            # Placeholders with type "resource" have exact values in "variables" field,
+            # so they are passed to TF FE as constants.
+            # For this reason they are not listed as model inputs.
+            if tf.dtypes.DType(type_attr).name != "resource" or self.m_inner_graph:
+                inp_names.append(inp.name)
+        return inp_names
+
+    def get_output_names(self) -> list:
+        # returns a vector of output names in the original order
+        # Note: used only for the library functions
+        if not self.m_inner_graph:
+            return []
+
+        if hasattr(self.m_graph, 'outputs') and self.m_graph.outputs:
+            outputs = []
+            for out in self.m_graph.outputs:
+                outputs.append(out.name)
+            return outputs
+        # If graph has no 'outputs' field, find nodes without outputs and consider them graph outputs.
+        # The order of outputs is important and wrong order may lead to conversion error.
+        non_outputs = set()
+        for op in self.m_graph.get_operations():
+            assert isinstance(op, tf.Operation), "Unknown node type. Expected tf.Operation, got {}".format(type(op))
+            for inp in op.inputs:
+                non_outputs.add(inp.op.name)
+
+        outputs = []
+        for op in self.m_graph.get_operations():
+            if op.name not in non_outputs:
+                for output in op.outputs:
+                    outputs = [output.name] + outputs
+        return outputs
+
+    def get_input_names_map(self) -> dict:
+        # returns a map from (user-defined) external tensor name to internal name for inputs
+        return self.m_input_names_map
+
+    def get_output_names_map(self) -> dict:
+        # returns a map from (user-defined) external tensor name to internal name for outputs
+        return self.m_output_names_map
+
+    def is_end(self) -> bool:
+        return self.m_node_index >= len(self.m_decoders)
+
+    def reset(self):
+        self.m_node_index = 0
+
+    def size(self) -> int:
+        return len(self.m_decoders)
+
+    def next_impl(self):
+        self.m_node_index += 1
+
+    def get_decoder(self):
+        return self.m_decoders[self.m_node_index]
+
+    def get_body_graph_iterator(self, func_name):
+        if func_name not in self.m_iterators:
+            return None
+        if self.m_iterators[func_name] is None:
+            self.m_iterators[func_name] = GraphIteratorTFGraph(self.m_graph._functions[func_name].graph,
+                                                               self.m_share_weights,
+                                                               True)
+        return self.m_iterators[func_name]

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

@@ -0,0 +1,219 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# flake8: noqa
+# mypy: ignore-errors
+
+import numpy as np
+import tensorflow as tf
+from openvino.frontend.tensorflow.py_tensorflow_frontend import _FrontEndDecoderBase as DecoderBase
+from openvino.runtime import PartialShape, Type, OVAny, Tensor
+
+
+def tf_type_to_ov_type(tf_type_int):
+    tf_type = tf.dtypes.as_dtype(tf_type_int)
+    if tf_type.name == "variant":
+        return Type.dynamic
+    if tf_type.name == "string":
+        return Type.string
+    numpy_type = tf_type.as_numpy_dtype
+    try:
+        ret_type = Type(numpy_type)
+    except:
+        ret_type = Type.undefined
+    return ret_type
+
+
+def tf_attr_to_numpy(attr):
+    attr_type = attr.WhichOneof("value")
+    # described in https://www.tensorflow.org/api_docs/python/tf/compat/v1/AttrValue
+    if attr_type == "func":
+        return attr.func.name
+    elif attr_type == "s":
+        try:
+            return attr.s.decode("utf-8")
+        except UnicodeDecodeError:
+            return attr.s
+    elif attr_type == "f":
+        return np.float32(attr.f)
+    elif attr_type == "type":
+        return tf_type_to_ov_type(attr.type)
+    elif attr_type == "list":
+        list_value = attr.list
+        fields = list_value.ListFields()
+        if fields and len(fields) > 0 and len(fields[0]) > 1:
+            return list(fields[0][1])
+        else:
+            return None
+    elif attr_type == "shape":
+        tf_shape = attr.shape
+        if tf_shape.unknown_rank:
+            return PartialShape.dynamic()
+        shape_dims = tf_shape.dim
+        shape = [dim.size for dim in shape_dims]
+        return PartialShape(shape)
+    elif attr_type is None:
+        return None
+    return getattr(attr, attr.WhichOneof("value"))
+
+
+def tf_attr_to_ov(attr):
+    return OVAny(tf_attr_to_numpy(attr))
+
+
+class TFGraphNodeDecoder(DecoderBase):
+    def __init__(self, operation: tf.Operation, share_weights: bool, inner_graph: bool):
+        DecoderBase.__init__(self)
+        assert isinstance(operation, tf.Operation), "Unknown operation type. " \
+                                                    "Expected tf.Operation, got {}".format(type(operation))
+        self.m_operation = operation
+        self.m_inner_graph = inner_graph
+        self.m_data_type = None
+        self.m_parsed_content = None
+
+        # Copies value from inner buffer of TF_Operation to NodeDef class.
+        self.m_node_def = self.m_operation.node_def
+        self.m_shared_memory = share_weights
+
+        if self.m_operation.type == "Const":
+            self.m_data_type = tf.dtypes.DType(self.m_node_def.attr["dtype"].type).name
+
+            # Copies tensor value to parsed TensorProto
+            value = self.m_node_def.attr["value"].tensor
+
+            # As the tensor was copied, shared memory may be lost
+            # after destruction of GraphIteratorTFGraph() when convert_model() finishes its work.
+            # To prevent it we need to turn off sharing.
+            self.m_shared_memory = False
+
+            if self.m_data_type == "string":
+                self.m_parsed_content = [str(val) for val in value.string_val]
+            else:
+                if value.tensor_content:
+                    shape = [d.size for d in value.tensor_shape.dim]
+                    tensor_dtype = tf.dtypes.as_dtype(value.dtype)
+                    dtype = tensor_dtype.as_numpy_dtype
+                    # no copy of content
+                    self.m_parsed_content = (np.frombuffer(value.tensor_content,
+                                                           dtype=dtype).reshape(shape))
+                else:
+                    # TODO: remove copy of content for cases when tensor value is not in tensor_content field, ticket: 114797
+                    self.m_parsed_content = tf.make_ndarray(value)
+
+        if self.m_operation.type == "Placeholder":
+            self.m_data_type = tf.dtypes.DType(self.m_node_def.attr["dtype"].type).name
+
+            if not self.m_inner_graph:
+                variable_value = TFGraphNodeDecoder.get_variable(self.m_operation)
+                if variable_value is not None:
+                    # Disable sharing for variables which are not on CPU
+                    if "device:CPU" not in variable_value.device:
+                        self.m_shared_memory = False
+                    # does not copy data
+                    self.m_parsed_content = variable_value.__array__()
+
+                    if isinstance(self.m_parsed_content, bytes):
+                        self.m_data_type = "string"
+                        self.m_parsed_content = [str(self.m_parsed_content)]
+
+    def get_op_name(self) -> str:
+        return self.m_operation.name
+
+    def get_op_type(self) -> str:
+        if self.m_operation.type == "Placeholder":
+            type_attr = tf.dtypes.DType(self.m_node_def.attr["dtype"].type)
+            if not self.m_inner_graph and self.m_parsed_content is not None:
+                if TFGraphNodeDecoder.get_variable(self.m_operation) is not None:
+                    return "Const"
+                raise Exception("Could not get variable for resource Placeholder {0}".format(self.m_operation.name))
+        return self.m_operation.type
+
+    @staticmethod
+    def get_variable(operation):
+        tf_graph = operation.graph
+        if not hasattr(tf_graph, "captures"):
+            return None
+        for var_tensor, op_tensor in tf_graph.captures:
+            if operation.outputs[0].name == op_tensor.name:
+                if var_tensor.dtype.name != 'resource':
+                    return var_tensor
+                for variable_value in operation.graph.variables:
+                    if id(variable_value.handle) == id(var_tensor):
+                        return variable_value.read_value_no_copy()
+                return None
+        return None
+
+    def get_attribute(self, name):
+        if name == "shape" or name == "_output_shapes":
+            if self.m_node_def.attr["shape"].shape.unknown_rank:
+                return OVAny(PartialShape.dynamic())
+            shape_dims = self.m_node_def.attr["shape"].shape.dim
+            shape = [dim.size for dim in shape_dims]
+            type_num = self.m_node_def.attr["dtype"].type
+            if type_num is not None and tf.dtypes.DType(type_num).name == "resource":
+                if self.m_inner_graph:
+                    return OVAny(PartialShape.dynamic())
+                variable_value = TFGraphNodeDecoder.get_variable(self.m_operation)
+                if variable_value is None:
+                    # variable can be not found if this is Hash table
+                    return OVAny(PartialShape.dynamic())
+                return OVAny(PartialShape(list(variable_value.shape)))
+            return OVAny(PartialShape(shape))
+        if name == "dtype":
+            type_num = self.m_node_def.attr["dtype"].type
+            if tf.dtypes.DType(type_num).name == "resource":
+                if not self.m_inner_graph:
+                    variable_value = TFGraphNodeDecoder.get_variable(self.m_operation)
+                    if variable_value is None:
+                        # variable can be not found if this is Hash table
+                        return OVAny(Type.dynamic)
+                    return OVAny(tf_type_to_ov_type(variable_value.dtype))
+                else:
+                    return OVAny(Type.undefined)
+            return OVAny(tf_type_to_ov_type(type_num))
+
+        if name == "value":
+            if self.m_data_type == 'string':
+                return OVAny(Tensor(self.m_parsed_content))
+            if self.m_parsed_content.size == 1:
+                if isinstance(self.m_parsed_content, np.ndarray):
+                    return OVAny(Tensor(self.m_parsed_content))
+                self.m_parsed_content = np.array(self.m_parsed_content)
+                return OVAny(Tensor(self.m_parsed_content))
+            ov_tensor = Tensor(self.m_parsed_content, shared_memory=self.m_shared_memory)
+            ov_tensor = OVAny(ov_tensor)
+            return ov_tensor
+        attr_value = self.m_node_def.attr[name]
+
+        return tf_attr_to_ov(attr_value)
+
+    def get_input_size(self) -> int:
+        return len(self.m_operation.inputs)
+
+    def get_input_node_name(self, input_port_idx):
+        assert input_port_idx >= 0, "Got negative input node index."
+        assert input_port_idx < len(self.m_operation.inputs), "Input node index is out of range. Got {}, " \
+                                                              "when number of input nodes {}.".format(input_port_idx,
+                                                                                                      len(self.m_operation.inputs))
+        return self.m_operation.inputs[input_port_idx].op.name
+
+    def get_input_node_name_output_port_index(self, input_port_idx):
+        tensor_name = self.m_operation.inputs[input_port_idx].name
+        if ":" in tensor_name:
+            port_idx_str = tensor_name[tensor_name.rfind(":") + 1:len(tensor_name)]
+            if port_idx_str.isdigit():
+                return int(port_idx_str)
+            else:
+                return 0
+        return 0
+
+    def get_input_node_name_output_port_name(self, input_port_idx):
+        tensor_name = self.m_operation.inputs[input_port_idx].name
+        if ":" not in tensor_name:
+            return ""
+        first_col_idx = tensor_name.find(":")
+        last_col_idx = tensor_name.rfind(":")
+        if first_col_idx == last_col_idx:
+            return ""
+
+        return tensor_name[first_col_idx + 1: last_col_idx]