yobx.helpers.helper

yobx.helpers.helper.flatten_object(x: Any, drop_keys: bool = False) → Any

Flattens the object. It accepts some common classes used in deep learning.

Parameters:

• x – any object

• drop_keys – drop the keys if a dictionary is flattened. Keeps the order defined by the dictionary if False, sort them if True.

Returns:

flattened object

yobx.helpers.helper.make_hash(obj: Any) → str

Returns a simple hash of id(obj) in four letter.

yobx.helpers.helper.max_diff(expected: Any, got: Any, level: int = 0, flatten: bool = False, debug_info: List[str] | None = None, begin: int = 0, end: int = -1, _index: int = 0, allow_unique_tensor_with_list_of_one_element: bool = True, hist: bool | List[float] | None = None, skip_none: bool = False) → Dict[str, float | int | Tuple[Any, ...]]

Returns the maximum discrepancy.

Parameters:

• expected – expected values

• got – values

• level – for embedded outputs, used for debug purpposes

• flatten – flatten outputs

• debug_info – debug information

• begin – first output to considered

• end – last output to considered (-1 for the last one)

• _index – used with begin and end

• allow_unique_tensor_with_list_of_one_element – allow a comparison between a single tensor and a list of one tensor

• hist – compute an histogram of the discrepancies

• skip_none – skips none value

Returns:

dictionary with many values

• abs: max absolute error

• rel: max relative error

• sum: sum of the errors

• n: number of outputs values, if there is one

  output, this number will be the number of elements of this output

• dnan: difference in the number of nan

• dev: tensor on the same device, if applicable

You may use string_diff() to display the discrepancies in one string.

yobx.helpers.helper.string_sig(f: Callable, kwargs: Dict[str, Any] | None = None) → str

Displays the signature of a function if the default if the given value is different from

yobx.helpers.helper.string_signature(sig: Any) → str

Displays the signature of a functions.

yobx.helpers.helper.string_type(obj: Any, with_shape: bool = False, with_min_max: bool = False, with_device: bool = False, ignore: bool = False, limit: int = 20) → str

Displays the types of an object as a string.

Parameters:

• obj – any

• with_shape – displays shapes as well

• with_min_max – displays information about the values

• with_device – display the device

• ignore – if True, just prints the type for unknown types

Returns:

str

The function displays something like the following for a tensor.

T7s2x7[0.5:6:A3.56]
^^^+-^^----+------^
|| |       |
|| |       +-- information about the content of a tensor or array
|| |           [min,max:A<average>]
|| |
|| +-- a shape
||
|+-- integer following the code defined by onnx.TensorProto,
|    7 is onnx.TensorProto.INT64 (see onnx_dtype_name)
|
+-- A,T,F
    A is an array from numpy
    T is a Tensor from pytorch
    F is a FakeTensor from pytorch

The element types for a tensor are displayed as integer to shorten the message. The semantic is defined by onnx.TensorProto and can be obtained by yobx.helpers.onnx_helper.onnx_dtype_name().

<<<

from yobx.helpers import string_type

print(string_type((1, ["r", 6.6])))

>>>

    (int,#2[str,float])

With pytorch:

<<<

import torch
from yobx.helpers import string_type

inputs = (
    torch.rand((3, 4), dtype=torch.float16),
    [
        torch.rand((5, 6), dtype=torch.float16),
        torch.rand((5, 6, 7), dtype=torch.float16),
    ],
)

# with shapes
print(string_type(inputs, with_shape=True))

# with min max
print(string_type(inputs, with_shape=True, with_min_max=True))

>>>

    (T10s3x4,#2[T10s5x6,T10s5x6x7])
    (T10s3x4[0.021484375,0.90966796875:A0.3624267578125],#2[T10s5x6[0.01220703125,0.96826171875:A0.5489583333333333],T10s5x6x7[0.00439453125,0.984375:A0.5173479352678572]])