ndonnx package

Submodules

• ndonnx.extensions module
  • datetime_to_year_month_day()
  • fill_null()
  • get_data()
  • get_mask()
  • is_float_dtype()
  • is_integer_dtype()
  • is_nullable_dtype()
  • is_nullable_float_dtype()
  • is_nullable_integer_dtype()
  • is_nullable_numeric_dtype()
  • is_numeric_dtype()
  • is_onnx_dtype()
  • is_signed_integer_dtype()
  • is_time_unit()
  • is_unsigned_integer_dtype()
  • isin()
  • make_nullable()
  • put()
  • shape()
  • static_map()
• ndonnx.types module

Module contents

class ndonnx.Array(*args, **kwargs)

Bases: object

User-facing objects that makes no assumption about any data type related logic.

property T: Array

all(axis: int | tuple[int, ...] | None = 0, keepdims: bool = False) → Array

See ndonnx.all() for documentation.

any(axis: int | tuple[int, ...] | None = 0, keepdims: bool = False) → Array

See ndonnx.any() for documentation.

astype(dtype: DType, *, copy=True) → Array

copy() → Array

property device: Device

disassemble() → dict[str, Var] | Var

Disassemble into the constituent spox.Var objects.

The particular layout depends on the data type.

property dtype: DType

property dynamic_shape: Array

Runtime shape of this array as a 1D int64 tensor.

property dynamic_size: Array

Return the size of an array as scalar array.

Contrary to Array.size this function also works on dynamically sized arrays.

property mT: Array

max(axis: int | tuple[int, ...] | None = 0, keepdims: bool = False) → Array

See ndonnx.max() for documentation.

min(axis: int | tuple[int, ...] | None = 0, keepdims: bool = False) → Array

See ndonnx.min() for documentation.

property ndim: int

property null: None | Array

prod(axis: int | tuple[int, ...] | None = 0, keepdims: bool = False) → Array

See ndonnx.prod() for documentation.

property shape: tuple[int | None, ...]

property size: int | None

spox_var() → Var

Unwrap the underlying spox.Var object if self is of primitive data type.

Otherwise, raise an exception.

sum(axis: int | tuple[int, ...] | None = 0, keepdims: bool = False) → Array

See ndonnx.sum() for documentation.

to_device(device: Any, /, *, stream: int | Any | None = None) → Array

to_numpy() → ndarray | None

unwrap_numpy() → ndarray

Return the propagated value as a NumPy array if available.

Raises:

ValueError:

If no propagated value is available.

unwrap_spox() → Var

Unwrap the underlying spox.Var object if self is of primitive data type.

Otherwise, raise an exception.

property values: Array

class ndonnx.DType

Bases: ABC, Generic[TY_ARRAY_BASE]

to_numpy_dtype() → dtype

unwrap_numpy() → dtype

class ndonnx.DateTime64DType(unit: Literal['ns', 'us', 'ms', 's'])

Bases: BaseTimeDType[TyArrayDateTime]

class ndonnx.TimeDelta64DType(unit: Literal['ns', 'us', 'ms', 's'])

Bases: BaseTimeDType[TyArrayTimeDelta]

ndonnx.abs(array: Array, /) → Array

ndonnx.acos(array: Array, /) → Array

ndonnx.acosh(array: Array, /) → Array

ndonnx.add(a: Array | int | float, b: Array | int | float) → Array

ndonnx.all(x: Array, /, *, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) → Array

ndonnx.any(x: Array, /, *, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) → Array

ndonnx.arange(start: int | float | Array, /, stop: int | float | Array | None = None, step: int | float | Array = 1, *, dtype: DType | None = None, device: None | Device = None) → Array

ndonnx.argmax(x: Array, /, *, axis: int | None = None, keepdims: bool = False) → Array

ndonnx.argmin(x: Array, /, *, axis: int | None = None, keepdims: bool = False) → Array

ndonnx.argsort(x: Array, /, *, axis: int = -1, descending: bool = False, stable: bool = True) → Array

ndonnx.argument(*, shape: tuple[int | str | None, ...], dtype: DType) → Array

Creates a new lazy ndonnx array.

This is used to define inputs to an ONNX model.

shape

The shape of the array. String-dimensions denote symbolic dimensions and must be globally consistent. None-dimensions denote unknown dimensions.

dtype

The data type of the array.

Returns:

Array

The new array representing input(s) of the computational graphs.

ndonnx.asarray(obj: Array | bool | int | float | str | ndarray | Sequence[bool | int | float | str | Sequence[PyScalar | NestedSequence]] | Var, /, *, dtype: DType | None = None, device: None | Device = None, copy: bool | None = None) → Array

ndonnx.asin(array: Array, /) → Array

ndonnx.asinh(array: Array, /) → Array

ndonnx.astype(x: Array, dtype: DType, /, *, copy: bool = True, device: None | Device = None) → Array

ndonnx.atan(array: Array, /) → Array

ndonnx.atan2(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.atanh(array: Array, /) → Array

ndonnx.bitwise_and(x1: Array | int | bool, x2: Array | int | bool, /) → Array

ndonnx.bitwise_invert(x: Array, /) → Array

ndonnx.bitwise_left_shift(x1: Array | int, x2: Array | int, /) → Array

ndonnx.bitwise_or(x1: Array | int | bool, x2: Array | int | bool, /) → Array

ndonnx.bitwise_right_shift(x1: Array | int, x2: Array | int, /) → Array

ndonnx.bitwise_xor(x1: Array | int | bool, x2: Array | int | bool, /) → Array

ndonnx.broadcast_arrays(*arrays: Array) → list[Array]

ndonnx.broadcast_to(x: Array, /, shape: tuple[int, ...] | Array) → Array

ndonnx.build(inputs: dict[str, Array], outputs: dict[str, Array], drop_unused=False) → ModelProto

Build and ONNX model from the provided argument-Arrays and outputs.

Parameters:

inputs

Inputs of the model

outputs

Outputs of the model

Returns:

onnx.ModelProto

ONNX model

ndonnx.can_cast(from_: DType | Array, to: DType, /) → bool

ndonnx.ceil(array: Array, /) → Array

ndonnx.clip(x: Array, /, min: None | int | float | Array = None, max: None | int | float | Array = None) → Array

ndonnx.concat(arrays: tuple[Array, ...] | list[Array], /, *, axis: None | int = 0) → Array

ndonnx.conj(x: Array, /) → Array

ndonnx.copysign(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.cos(x: Array, /) → Array

ndonnx.cosh(x: Array, /) → Array

ndonnx.count_nonzero(x: Array, /, *, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) → Array

ndonnx.cumulative_prod(x: Array, /, *, axis: int | None = None, dtype: DType | None = None, include_initial: bool = False) → Array

ndonnx.cumulative_sum(x: Array, /, *, axis: int | None = None, dtype: DType | None = None, include_initial: bool = False) → Array

ndonnx.diff(a: Array, /, *, axis: int = -1, n: int = 1, prepend: Array | None = None, append: Array | None = None) → Array

ndonnx.divide(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.empty(shape: int | tuple[int, ...], *, dtype: DType | None = None, device: None | Device = None) → Array

ndonnx.empty_like(x: Array, /, *, dtype: DType | None = None, device: None | Device = None) → Array

ndonnx.equal(x1: Array | int | float | bool, x2: Array | int | float | bool, /) → Array

ndonnx.exp(array: Array, /) → Array

ndonnx.expand_dims(x: Array, /, *, axis: int = 0) → Array

ndonnx.expm1(x: Array, /) → Array

ndonnx.eye(n_rows: int, n_cols: int | None = None, /, *, k: int = 0, dtype: DType | None = None, device: None | Device = None) → Array

ndonnx.finfo(ty: DType | Array, /)

ndonnx.flip(x: Array, /, *, axis: int | tuple[int, ...] | None = None) → Array

ndonnx.floor(array: Array, /) → Array

ndonnx.floor_divide(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.from_dlpack(x: object, /, *, device: None = None, copy: bool | None = None) → Array

ndonnx.from_numpy_dtype(np_dtype: dtype) → Float16 | Float32 | Float64 | Int8 | Int16 | Int32 | Int64 | UInt8 | UInt16 | UInt32 | UInt64 | Utf8 | Bool | TimeDelta64DType | DateTime64DType

ndonnx.full(shape: int | tuple[int, ...] | Array, fill_value: bool | int | float | str, *, dtype: DType | None = None, device: None | Device = None) → Array

ndonnx.full_like(x: Array, /, fill_value: bool | int | float | str, *, dtype: DType | None = None, device: None | Device = None) → Array

ndonnx.greater(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.greater_equal(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.hypot(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.iinfo(ty: DType | Array, /) → Iinfo

ndonnx.imag(x: Array, /) → Array

ndonnx.isdtype(dtype: DType, kind: DType | str | tuple[DType | str, ...]) → bool

ndonnx.isfinite(array: Array, /) → Array

ndonnx.isinf(array: Array, /) → Array

ndonnx.isnan(array: Array, /) → Array

ndonnx.less(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.less_equal(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.linspace(start: int | float | complex, stop: int | float | complex, /, num: int, *, dtype: DType | None = None, device: None | Device = None, endpoint: bool = True) → Array

ndonnx.log(x: Array, /) → Array

ndonnx.log10(x: Array, /) → Array

ndonnx.log1p(x: Array, /) → Array

ndonnx.log2(x: Array, /) → Array

ndonnx.logaddexp(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.logical_and(x1: Array | bool, x2: Array | bool, /) → Array

ndonnx.logical_not(x: Array, /) → Array

ndonnx.logical_or(x1: Array | bool, x2: Array | bool, /) → Array

ndonnx.logical_xor(x1: Array | bool, x2: Array | bool, /) → Array

ndonnx.matmul(x1: Array, x2: Array, /) → Array

ndonnx.matrix_transpose(x: Array, /) → Array

ndonnx.max(x: Array, /, *, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) → Array

Calculates the maximum value of the input array x.

Reduction over zero-sized inputs return the minimum possible value for the input data type.

ndonnx.maximum(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.mean(x: Array, /, *, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) → Array

ndonnx.meshgrid(*arrays: Array, indexing: str = 'xy') → list[Array]

ndonnx.min(x: Array, /, *, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) → Array

Calculates the minimum value of the input array x.

Reduction over zero-sized inputs return the maximum possible value for the input data type.

ndonnx.minimum(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.moveaxis(x: Array, source: int | tuple[int, ...], destination: int | tuple[int, ...], /) → Array

ndonnx.multiply(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.negative(x: Array, /) → Array

ndonnx.nextafter(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.nonzero(x: Array, /) → tuple[Array, ...]

ndonnx.not_equal(x1: Array | int | float | bool, x2: Array | int | float | bool, /) → Array

ndonnx.ones(shape: int | tuple[int, ...], *, dtype: DType | None = None, device: None | Device = None) → Array

ndonnx.ones_like(x: Array, /, *, dtype: DType | None = None, device: None | Device = None) → Array

ndonnx.permute_dims(x: Array, /, axes: tuple[int, ...]) → Array

ndonnx.positive(x: Array, /) → Array

ndonnx.pow(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.prod(x: Array, /, *, axis: int | tuple[int, ...] | None = None, dtype: DType | None = None, keepdims: bool = False) → Array

ndonnx.real(x: Array, /) → Array

ndonnx.reciprocal(x: Array, /) → Array

ndonnx.remainder(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.repeat(x: Array, repeats: int | Array, /, *, axis: int | None = None) → Array

ndonnx.reshape(x: Array, /, shape: tuple[int, ...] | Array, *, copy: bool | None = None) → Array

ndonnx.result_type(*arrays_and_dtypes: Array | DType | bool | int | float | str) → DType

ndonnx.roll(x: Array, /, shift: int | tuple[int, ...], *, axis: int | tuple[int, ...] | None = None) → Array

ndonnx.round(x: Array, /) → Array

ndonnx.searchsorted(x1: Array, x2: Array, /, *, side: Literal['left', 'right'] = 'left', sorter: Array | None = None) → Array

ndonnx.sign(x: Array, /) → Array

ndonnx.signbit(x: Array, /) → Array

ndonnx.sin(x: Array, /) → Array

ndonnx.sinh(x: Array, /) → Array

ndonnx.sort(x: Array, /, *, axis: int = -1, descending: bool = False, stable: bool = True) → Array

ndonnx.sqrt(x: Array, /) → Array

ndonnx.square(x: Array, /) → Array

ndonnx.squeeze(x: Array, /, axis: int | tuple[int, ...]) → Array

ndonnx.stack(arrays: tuple[Array, ...] | list[Array], /, *, axis: int = 0) → Array

ndonnx.std(x: Array, /, *, axis: int | tuple[int, ...] | None = None, correction: int | float = 0.0, keepdims: bool = False) → Array

ndonnx.subtract(x1: Array | int | float, x2: Array | int | float, /) → Array

ndonnx.sum(x: Array, /, *, axis: int | tuple[int, ...] | None = None, dtype: DType | None = None, keepdims: bool = False) → Array

ndonnx.take(x: Array, indices: Array, /, *, axis: int | None = None) → Array

ndonnx.take_along_axis(x: Array, indices: Array, /, *, axis: int = -1) → Array

ndonnx.tan(x: Array, /) → Array

ndonnx.tanh(x: Array, /) → Array

ndonnx.tensordot(x1: Array, x2: Array, /, *, axes: int | tuple[Sequence[int], Sequence[int]] = 2) → Array

ndonnx.tile(x: Array, repetitions: tuple[int, ...], /) → Array

ndonnx.to_nullable_dtype(dtype: _OnnxDType | NBool | NFloat16 | NFloat32 | NFloat64 | NInt8 | NInt16 | NInt32 | NInt64 | NUInt8 | NUInt16 | NUInt32 | NUInt64 | NUtf8) → NBool | NFloat16 | NFloat32 | NFloat64 | NInt8 | NInt16 | NInt32 | NInt64 | NUInt8 | NUInt16 | NUInt32 | NUInt64 | NUtf8

ndonnx.tril(x: Array, /, *, k: int = 0) → Array

ndonnx.triu(x: Array, /, *, k: int = 0) → Array

ndonnx.trunc(x: Array, /) → Array

ndonnx.unique_all(x: Array, /) → UniqueAll

ndonnx.unique_counts(x: Array, /) → UniqueCounts

ndonnx.unique_inverse(x: Array, /) → UniqueInverse

ndonnx.unique_values(x: Array, /) → Array

ndonnx.unstack(x: Array, /, *, axis: int = 0) → tuple[Array, ...]

ndonnx.var(x: Array, /, *, axis: int | tuple[int, ...] | None = None, correction: int | float = 0.0, keepdims: bool = False) → Array

ndonnx.vecdot(x1: Array, x2: Array, /, *, axis: int = -1) → Array

ndonnx.where(cond: Array, a: Array | int | float | bool | str, b: Array | int | float | bool | str) → Array

ndonnx.zeros(shape: int | tuple[int, ...], *, dtype: DType | None = None, device: None | Device = None) → Array

ndonnx.zeros_like(x: Array, /, *, dtype: DType | None = None, device: None | Device = None) → Array