bigdl-core-npu 2.6.0b20250114__cp311-cp311-win_amd64.whl

intel_npu_acceleration_library/external/openvino/runtime/properties/hint/__init__.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# Enums
+from openvino._pyopenvino.properties.hint import Priority
+from openvino._pyopenvino.properties.hint import SchedulingCoreType
+from openvino._pyopenvino.properties.hint import ModelDistributionPolicy
+from openvino._pyopenvino.properties.hint import ExecutionMode
+from openvino._pyopenvino.properties.hint import PerformanceMode
+
+# Properties
+from openvino._pyopenvino.properties.hint import inference_precision
+from openvino._pyopenvino.properties.hint import model_priority
+from openvino._pyopenvino.properties.hint import performance_mode
+from openvino._pyopenvino.properties.hint import enable_cpu_pinning
+from openvino._pyopenvino.properties.hint import scheduling_core_type
+from openvino._pyopenvino.properties.hint import model_distribution_policy
+from openvino._pyopenvino.properties.hint import enable_hyper_threading
+from openvino._pyopenvino.properties.hint import execution_mode
+from openvino._pyopenvino.properties.hint import num_requests
+from openvino._pyopenvino.properties.hint import model
+from openvino._pyopenvino.properties.hint import allow_auto_batching
+from openvino._pyopenvino.properties.hint import dynamic_quantization_group_size
+from openvino._pyopenvino.properties.hint import kv_cache_precision

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

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+"""Generic utilities. Factor related functions out to separate files."""
+
+from openvino._pyopenvino.util import numpy_to_c, replace_node, replace_output_update_name

intel_npu_acceleration_library/external/openvino/runtime/utils/broadcasting.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from typing import List, Optional
+
+from openvino.runtime import AxisSet, Node
+from openvino.runtime.utils.types import (
+    NodeInput,
+    TensorShape,
+    get_dtype,
+    make_constant_node,
+)
+
+log = logging.getLogger(__name__)
+
+
+def get_broadcast_axes(
+    output_shape: TensorShape,
+    input_shape: TensorShape,
+    axis: Optional[int] = None,
+) -> AxisSet:
+    """Generate a list of broadcast axes for openvino broadcast.
+
+    Informally, a broadcast "adds" axes to the input tensor,
+    replicating elements from the input tensor as needed to fill the new dimensions.
+    Function calculate which of the output axes are added in this way.
+
+    :param output_shape: The new shape for the output tensor.
+    :param input_shape: The shape of input tensor.
+    :param axis: The axis along which we want to replicate elements.
+
+    returns: The indices of added axes.
+    """
+    axes_indexes = list(range(0, len(output_shape)))
+    if axis is None:
+        output_begin = len(output_shape) - len(input_shape)
+    else:
+        output_begin = axis
+    right_axes_indexes = list(range(output_begin, output_begin + len(input_shape)))
+    for index in reversed(right_axes_indexes):
+        del axes_indexes[index]
+    return AxisSet(set(axes_indexes))

intel_npu_acceleration_library/external/openvino/runtime/utils/data_helpers/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from openvino.runtime.utils.data_helpers.data_dispatcher import _data_dispatch
+from openvino.runtime.utils.data_helpers.wrappers import tensor_from_file
+from openvino.runtime.utils.data_helpers.wrappers import _InferRequestWrapper
+from openvino.runtime.utils.data_helpers.wrappers import OVDict

intel_npu_acceleration_library/external/openvino/runtime/utils/data_helpers/data_dispatcher.py

@@ -0,0 +1,447 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+from functools import singledispatch
+from typing import Any, Dict, Union, Optional
+
+import numpy as np
+
+from openvino._pyopenvino import ConstOutput, Tensor, Type, RemoteTensor
+from openvino.runtime.utils.data_helpers.wrappers import _InferRequestWrapper, OVDict
+
+ContainerTypes = Union[dict, list, tuple, OVDict]
+ScalarTypes = Union[np.number, int, float]
+ValidKeys = Union[str, int, ConstOutput]
+
+
+def is_list_simple_type(input_list: list) -> bool:
+    for sublist in input_list:
+        if isinstance(sublist, list):
+            for element in sublist:
+                if not isinstance(element, (str, float, int, bytes)):
+                    return False
+        else:
+            if not isinstance(sublist, (str, float, int, bytes)):
+                return False
+    return True
+
+
+def get_request_tensor(
+    request: _InferRequestWrapper,
+    key: Optional[ValidKeys] = None,
+) -> Tensor:
+    if key is None:
+        return request.get_input_tensor()
+    elif isinstance(key, int):
+        return request.get_input_tensor(key)
+    elif isinstance(key, (str, ConstOutput)):
+        return request.get_tensor(key)
+    else:
+        raise TypeError(f"Unsupported key type: {type(key)} for Tensor under key: {key}")
+
+
+@singledispatch
+def value_to_tensor(
+    value: Union[Tensor, np.ndarray, ScalarTypes, str],
+    request: Optional[_InferRequestWrapper] = None,
+    is_shared: bool = False,
+    key: Optional[ValidKeys] = None,
+) -> None:
+    raise TypeError(f"Incompatible inputs of type: {type(value)}")
+
+
+@value_to_tensor.register(Tensor)
+def _(
+    value: Tensor,
+    request: Optional[_InferRequestWrapper] = None,
+    is_shared: bool = False,
+    key: Optional[ValidKeys] = None,
+) -> Tensor:
+    return value
+
+
+@value_to_tensor.register(RemoteTensor)
+def _(
+    value: RemoteTensor,
+    request: Optional[_InferRequestWrapper] = None,
+    is_shared: bool = False,
+    key: Optional[ValidKeys] = None,
+) -> RemoteTensor:
+    return value
+
+
+@value_to_tensor.register(np.ndarray)
+def _(
+    value: np.ndarray,
+    request: _InferRequestWrapper,
+    is_shared: bool = False,
+    key: Optional[ValidKeys] = None,
+) -> Tensor:
+    tensor = get_request_tensor(request, key)
+    tensor_type = tensor.get_element_type()
+    tensor_dtype = tensor_type.to_dtype()
+    # String edge-case, always copy.
+    # Scalars are also handled by C++.
+    if tensor_type == Type.string:
+        return Tensor(value, shared_memory=False)
+    # Scalars edge-case:
+    if value.ndim == 0:
+        tensor_shape = tuple(tensor.shape)
+        if tensor_dtype == value.dtype and tensor_shape == value.shape:
+            return Tensor(value, shared_memory=is_shared)
+        elif tensor.size == 0:
+            # the first infer request for dynamic input cannot reshape to 0 shape
+            return Tensor(value.astype(tensor_dtype).reshape((1)), shared_memory=False)
+        else:
+            return Tensor(value.astype(tensor_dtype).reshape(tensor_shape), shared_memory=False)
+    # WA for FP16-->BF16 edge-case, always copy.
+    if tensor_type == Type.bf16:
+        tensor = Tensor(tensor_type, value.shape)
+        tensor.data[:] = value.view(tensor_dtype)
+        return tensor
+    # WA for "not writeable" edge-case, always copy.
+    if value.flags["WRITEABLE"] is False:
+        tensor = Tensor(tensor_type, value.shape)
+        tensor.data[:] = value.astype(tensor_dtype) if tensor_dtype != value.dtype else value
+        return tensor
+    # If types are mismatched, convert and always copy.
+    if tensor_dtype != value.dtype:
+        return Tensor(value.astype(tensor_dtype), shared_memory=False)
+    # Otherwise, use mode defined in the call.
+    return Tensor(value, shared_memory=is_shared)
+
+
+@value_to_tensor.register(list)
+def _(
+    value: list,
+    request: _InferRequestWrapper,
+    is_shared: bool = False,
+    key: Optional[ValidKeys] = None,
+) -> Tensor:
+    return Tensor(value)
+
+
+@value_to_tensor.register(np.number)
+@value_to_tensor.register(int)
+@value_to_tensor.register(float)
+@value_to_tensor.register(str)
+@value_to_tensor.register(bytes)
+def _(
+    value: Union[ScalarTypes, str, bytes],
+    request: _InferRequestWrapper,
+    is_shared: bool = False,
+    key: Optional[ValidKeys] = None,
+) -> Tensor:
+    # np.number/int/float/str/bytes edge-case, copy will occur in both scenarios.
+    tensor_type = get_request_tensor(request, key).get_element_type()
+    tensor_dtype = tensor_type.to_dtype()
+    tmp = np.array(value)
+    # String edge-case -- it converts the data inside of Tensor class.
+    # If types are mismatched, convert.
+    if tensor_type != Type.string and tensor_dtype != tmp.dtype:
+        return Tensor(tmp.astype(tensor_dtype), shared_memory=False)
+    return Tensor(tmp, shared_memory=False)
+
+
+def to_c_style(value: Any, is_shared: bool = False) -> Any:
+    if not isinstance(value, np.ndarray):
+        if hasattr(value, "__array__"):
+            if np.lib.NumpyVersion(np.__version__) >= "2.0.0":
+                # https://numpy.org/devdocs/numpy_2_0_migration_guide.html#adapting-to-changes-in-the-copy-keyword
+                return to_c_style(np.asarray(value), is_shared) if is_shared else np.asarray(value, copy=True)  # type: ignore
+            else:
+                return to_c_style(np.array(value, copy=False), is_shared) if is_shared else np.array(value, copy=True)
+        return value
+    return value if value.flags["C_CONTIGUOUS"] else np.ascontiguousarray(value)
+
+
+###
+# Start of array normalization.
+###
+@singledispatch
+def normalize_arrays(
+    inputs: Any,
+    is_shared: bool = False,
+) -> Any:
+    # Check the special case of the array-interface
+    if hasattr(inputs, "__array__"):
+        if np.lib.NumpyVersion(np.__version__) >= "2.0.0":
+            # https://numpy.org/devdocs/numpy_2_0_migration_guide.html#adapting-to-changes-in-the-copy-keyword
+            return to_c_style(np.asarray(inputs), is_shared) if is_shared else np.asarray(inputs, copy=True)  # type: ignore
+        else:
+            return to_c_style(np.array(inputs, copy=False), is_shared) if is_shared else np.array(inputs, copy=True)
+    # Error should be raised if type does not match any dispatchers
+    raise TypeError(f"Incompatible inputs of type: {type(inputs)}")
+
+
+@normalize_arrays.register(dict)
+def _(
+    inputs: dict,
+    is_shared: bool = False,
+) -> dict:
+    return {k: to_c_style(v, is_shared) if is_shared else v for k, v in inputs.items()}
+
+
+@normalize_arrays.register(OVDict)
+def _(
+    inputs: OVDict,
+    is_shared: bool = False,
+) -> dict:
+    return {i: to_c_style(v, is_shared) if is_shared else v for i, (_, v) in enumerate(inputs.items())}
+
+
+@normalize_arrays.register(list)
+@normalize_arrays.register(tuple)
+def _(
+    inputs: Union[list, tuple],
+    is_shared: bool = False,
+) -> dict:
+    return {i: to_c_style(v, is_shared) if is_shared else v for i, v in enumerate(inputs)}
+
+
+@normalize_arrays.register(np.ndarray)
+def _(
+    inputs: dict,
+    is_shared: bool = False,
+) -> Any:
+    return to_c_style(inputs, is_shared) if is_shared else inputs
+###
+# End of array normalization.
+###
+
+
+###
+# Start of "shared" dispatcher.
+# (1) Each method should keep Tensors "as-is", regardless to them being shared or not.
+# (2) ...
+###
+# Step to keep alive input values that are not C-style by default
+@singledispatch
+def create_shared(
+    inputs: Any,
+    request: _InferRequestWrapper,
+) -> None:
+    # Check the special case of the array-interface
+    if hasattr(inputs, "__array__"):
+        request._inputs_data = normalize_arrays(inputs, is_shared=True)
+        return value_to_tensor(request._inputs_data, request=request, is_shared=True)
+    # Error should be raised if type does not match any dispatchers
+    raise TypeError(f"Incompatible inputs of type: {type(inputs)}")
+
+
+@create_shared.register(dict)
+@create_shared.register(tuple)
+@create_shared.register(OVDict)
+def _(
+    inputs: Union[dict, tuple, OVDict],
+    request: _InferRequestWrapper,
+) -> dict:
+    request._inputs_data = normalize_arrays(inputs, is_shared=True)
+    return {k: value_to_tensor(v, request=request, is_shared=True, key=k) for k, v in request._inputs_data.items()}
+
+
+# Special override to perform list-related dispatch
+@create_shared.register(list)
+def _(
+    inputs: list,
+    request: _InferRequestWrapper,
+) -> dict:
+    # If list is passed to single input model and consists only of simple types
+    # i.e. str/bytes/float/int, wrap around it and pass into the dispatcher.
+    request._inputs_data = normalize_arrays([inputs] if request._is_single_input() and is_list_simple_type(inputs) else inputs, is_shared=True)
+    return {k: value_to_tensor(v, request=request, is_shared=True, key=k) for k, v in request._inputs_data.items()}
+
+
+@create_shared.register(np.ndarray)
+def _(
+    inputs: np.ndarray,
+    request: _InferRequestWrapper,
+) -> Tensor:
+    request._inputs_data = normalize_arrays(inputs, is_shared=True)
+    return value_to_tensor(request._inputs_data, request=request, is_shared=True)
+
+
+@create_shared.register(Tensor)
+@create_shared.register(np.number)
+@create_shared.register(int)
+@create_shared.register(float)
+@create_shared.register(str)
+@create_shared.register(bytes)
+def _(
+    inputs: Union[Tensor, ScalarTypes, str, bytes],
+    request: _InferRequestWrapper,
+) -> Tensor:
+    return value_to_tensor(inputs, request=request, is_shared=True)
+###
+# End of "shared" dispatcher methods.
+###
+
+
+###
+# Start of "copied" dispatcher.
+###
+def set_request_tensor(
+    request: _InferRequestWrapper,
+    tensor: Tensor,
+    key: Optional[ValidKeys] = None,
+) -> None:
+    if key is None:
+        request.set_input_tensor(tensor)
+    elif isinstance(key, int):
+        request.set_input_tensor(key, tensor)
+    elif isinstance(key, (str, ConstOutput)):
+        request.set_tensor(key, tensor)
+    else:
+        raise TypeError(f"Unsupported key type: {type(key)} for Tensor under key: {key}")
+
+
+@singledispatch
+def update_tensor(
+    inputs: Any,
+    request: _InferRequestWrapper,
+    key: Optional[ValidKeys] = None,
+) -> None:
+    if hasattr(inputs, "__array__"):
+        update_tensor(normalize_arrays(inputs, is_shared=False), request, key)
+        return None
+    raise TypeError(f"Incompatible inputs of type: {type(inputs)} under {key} key!")
+
+
+@update_tensor.register(np.ndarray)
+def _(
+    inputs: np.ndarray,
+    request: _InferRequestWrapper,
+    key: Optional[ValidKeys] = None,
+) -> None:
+    if inputs.ndim != 0:
+        tensor = get_request_tensor(request, key)
+        # Update shape if there is a mismatch
+        if tuple(tensor.shape) != inputs.shape:
+            tensor.shape = inputs.shape
+        # When copying, type should be up/down-casted automatically.
+        if tensor.element_type == Type.string:
+            tensor.bytes_data = inputs
+        else:
+            tensor.data[:] = inputs[:]
+    else:
+        # If shape is "empty", assume this is a scalar value
+        set_request_tensor(
+            request,
+            value_to_tensor(inputs, request=request, is_shared=False, key=key),
+            key,
+        )
+
+
+@update_tensor.register(np.number)  # type: ignore
+@update_tensor.register(float)
+@update_tensor.register(int)
+@update_tensor.register(str)
+def _(
+    inputs: Union[ScalarTypes, str],
+    request: _InferRequestWrapper,
+    key: Optional[ValidKeys] = None,
+) -> None:
+    set_request_tensor(
+        request,
+        value_to_tensor(inputs, request=request, is_shared=False, key=key),
+        key,
+    )
+
+
+def update_inputs(inputs: dict, request: _InferRequestWrapper) -> dict:
+    """Helper function to prepare inputs for inference.
+
+    It creates copy of Tensors or copy data to already allocated Tensors on device
+    if the item is of type `np.ndarray`, `np.number`, `int`, `float` or has numpy __array__ attribute.
+    If value is of type `list`, create a Tensor based on it, copy will occur in the Tensor constructor.
+    """
+    # Create new temporary dictionary.
+    # new_inputs will be used to transfer data to inference calls,
+    # ensuring that original inputs are not overwritten with Tensors.
+    new_inputs: Dict[ValidKeys, Tensor] = {}
+    for key, value in inputs.items():
+        if not isinstance(key, (str, int, ConstOutput)):
+            raise TypeError(f"Incompatible key type for input: {key}")
+        # Copy numpy arrays to already allocated Tensors.
+        # If value object has __array__ attribute, load it to Tensor using np.array
+        if isinstance(value, (np.ndarray, np.number, int, float, str)) or hasattr(value, "__array__"):
+            update_tensor(value, request, key)
+        elif isinstance(value, list):
+            new_inputs[key] = Tensor(value)
+        # If value is of Tensor type, put it into temporary dictionary.
+        elif isinstance(value, Tensor):
+            new_inputs[key] = value
+        # Throw error otherwise.
+        else:
+            raise TypeError(f"Incompatible inputs of type: {type(value)} under {key} key!")
+    return new_inputs
+
+
+@singledispatch
+def create_copied(
+    inputs: Union[ContainerTypes, np.ndarray, ScalarTypes, str, bytes],
+    request: _InferRequestWrapper,
+) -> Union[dict, None]:
+    # Check the special case of the array-interface
+    if hasattr(inputs, "__array__"):
+        update_tensor(normalize_arrays(inputs, is_shared=False), request, key=None)
+        return {}
+    # Error should be raised if type does not match any dispatchers
+    raise TypeError(f"Incompatible inputs of type: {type(inputs)}")
+
+
+@create_copied.register(dict)
+@create_copied.register(tuple)
+@create_copied.register(OVDict)
+def _(
+    inputs: Union[dict, tuple, OVDict],
+    request: _InferRequestWrapper,
+) -> dict:
+    return update_inputs(normalize_arrays(inputs, is_shared=False), request)
+
+
+# Special override to perform list-related dispatch
+@create_copied.register(list)
+def _(
+    inputs: list,
+    request: _InferRequestWrapper,
+) -> dict:
+    # If list is passed to single input model and consists only of simple types
+    # i.e. str/bytes/float/int, wrap around it and pass into the dispatcher.
+    return update_inputs(normalize_arrays([inputs] if request._is_single_input() and is_list_simple_type(inputs) else inputs, is_shared=False), request)
+
+
+@create_copied.register(np.ndarray)
+def _(
+    inputs: np.ndarray,
+    request: _InferRequestWrapper,
+) -> dict:
+    update_tensor(normalize_arrays(inputs, is_shared=False), request, key=None)
+    return {}
+
+
+@create_copied.register(Tensor)
+@create_copied.register(np.number)
+@create_copied.register(int)
+@create_copied.register(float)
+@create_copied.register(str)
+@create_copied.register(bytes)
+def _(
+    inputs: Union[Tensor, ScalarTypes, str, bytes],
+    request: _InferRequestWrapper,
+) -> Tensor:
+    return value_to_tensor(inputs, request=request, is_shared=False)
+###
+# End of "copied" dispatcher methods.
+###
+
+
+def _data_dispatch(
+    request: _InferRequestWrapper,
+    inputs: Union[ContainerTypes, Tensor, np.ndarray, ScalarTypes, str] = None,
+    is_shared: bool = False,
+) -> Union[dict, Tensor]:
+    if inputs is None:
+        return {}
+    return create_shared(inputs, request) if is_shared else create_copied(inputs, request)

intel_npu_acceleration_library/external/openvino/runtime/utils/data_helpers/wrappers.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+
+from functools import singledispatchmethod
+from collections.abc import Mapping
+from typing import Dict, Set, Tuple, Union, Iterator, Optional
+from typing import KeysView, ItemsView, ValuesView
+
+from openvino._pyopenvino import Tensor, ConstOutput
+from openvino._pyopenvino import InferRequest as InferRequestBase
+
+
+def tensor_from_file(path: str) -> Tensor:
+    """Create Tensor from file. Data will be read with dtype of unit8."""
+    return Tensor(np.fromfile(path, dtype=np.uint8))  # type: ignore
+
+
+class _InferRequestWrapper(InferRequestBase):
+    """InferRequest class with internal memory."""
+
+    def __init__(self, other: InferRequestBase) -> None:
+        # Private memeber to store newly created shared memory data
+        self._inputs_data = None
+        super().__init__(other)
+
+    def _is_single_input(self) -> bool:
+        return len(self.input_tensors) == 1
+
+
+class OVDict(Mapping):
+    """Custom OpenVINO dictionary with inference results.
+
+    This class is a dict-like object. It provides possibility to
+    address data tensors with three key types:
+
+    * `openvino.runtime.ConstOutput` - port of the output
+    * `int` - index of the output
+    * `str` - names of the output
+
+    This class follows `frozenset`/`tuple` concept of immutability.
+    It is prohibited to assign new items or edit them.
+
+    To revert to the previous behavior use `to_dict` method which
+    return shallow copy of underlaying dictionary.
+    Note: It removes addressing feature! New dictionary keeps
+          only `ConstOutput` keys.
+
+    If a tuple returns value is needed, use `to_tuple` method which
+    converts values to the tuple.
+
+    :Example:
+
+    .. code-block:: python
+
+        # Reverts to the previous behavior of the native dict
+        result = request.infer(inputs).to_dict()
+        # or alternatively:
+        result = dict(request.infer(inputs))
+
+    .. code-block:: python
+
+        # To dispatch outputs of multi-ouput inference:
+        out1, out2, out3, _ = request.infer(inputs).values()
+        # or alternatively:
+        out1, out2, out3, _ = request.infer(inputs).to_tuple()
+    """
+    def __init__(self, _dict: Dict[ConstOutput, np.ndarray]) -> None:
+        self._dict = _dict
+        self._names: Optional[Dict[ConstOutput, Set[str]]] = None
+
+    def __iter__(self) -> Iterator:
+        return self._dict.__iter__()
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __repr__(self) -> str:
+        return self._dict.__repr__()
+
+    def __get_names(self) -> Dict[ConstOutput, Set[str]]:
+        """Return names of every output key.
+
+        Insert empty set if key has no name.
+        """
+        return {key: key.get_names() for key in self._dict.keys()}
+
+    def __get_key(self, index: int) -> ConstOutput:
+        return list(self._dict.keys())[index]
+
+    @singledispatchmethod
+    def __getitem_impl(self, key: Union[ConstOutput, int, str]) -> np.ndarray:
+        raise TypeError(f"Unknown key type: {type(key)}")
+
+    @__getitem_impl.register
+    def _(self, key: ConstOutput) -> np.ndarray:
+        return self._dict[key]
+
+    @__getitem_impl.register
+    def _(self, key: int) -> np.ndarray:
+        try:
+            return self._dict[self.__get_key(key)]
+        except IndexError:
+            raise KeyError(key)
+
+    @__getitem_impl.register
+    def _(self, key: str) -> np.ndarray:
+        if self._names is None:
+            self._names = self.__get_names()
+        for port, port_names in self._names.items():
+            if key in port_names:
+                return self._dict[port]
+        raise KeyError(key)
+
+    def __getitem__(self, key: Union[ConstOutput, int, str]) -> np.ndarray:
+        return self.__getitem_impl(key)
+
+    def keys(self) -> KeysView[ConstOutput]:
+        return self._dict.keys()
+
+    def values(self) -> ValuesView[np.ndarray]:
+        return self._dict.values()
+
+    def items(self) -> ItemsView[ConstOutput, np.ndarray]:
+        return self._dict.items()
+
+    def names(self) -> Tuple[Set[str], ...]:
+        """Return names of every output key.
+
+        Insert empty set if key has no name.
+        """
+        if self._names is None:
+            self._names = self.__get_names()
+        return tuple(self._names.values())
+
+    def to_dict(self) -> Dict[ConstOutput, np.ndarray]:
+        """Return underlaying native dictionary.
+
+        Function performs shallow copy, thus any modifications to
+        returned values may affect this class as well.
+        """
+        return self._dict
+
+    def to_tuple(self) -> tuple:
+        """Convert values of this dictionary to a tuple."""
+        return tuple(self._dict.values())