tensor

id: TensorId = Field(..., description='Unique tensor identifier')

kind: AirTensorKind = Field(AirTensorKind.SCRATCH, description='The kind of tensor')

quantization: AirQuantizationParameters | None = Field(default_factory=AirQuantizationParameters, description='Quantization parameters for the tensor')

sparsity: AirSparsityParameters | None = Field(default_factory=AirSparsityParameters, description='Sparsity parameters for the tensor')

buffer_index: int | None = Field(None, description='Index of the buffer this tensor is mapped to')

local_name: str | None = Field(None, description='Local name for the tensor')

shape_signature: tuple[int, ...] | None = Field(None, description='Shape signature of the tensor')

has_rank: bool = Field(False, description='Indicates if the tensor has a rank')

alias_of: TensorId | None = Field(None, description='Optional alias for this tensor')

alignment_hint: int | None = Field(None, description='Alignment hint for the tensor in bytes')

shape: tuple[int, ...]

dtype: np.dtype

data: npt.NDArray | None

Return the data of the tensor.

quant: AirQuantizationParameters

Quantization parameters, which must carry a scale.

quantization is Optional so a tensor can carry none; kernels that require quantized inputs read through this view and get a typed error naming the tensor instead of an attribute access on None. A tensor with no scale, such as one with only a min/max range, is unquantized, as LiteRT’s kernels read it.

is_quantized: bool

Whether kernels read this tensor through its quantization.

Only an int8, uint8 or int16 tensor with a scale is. Any other tensor, such as a float tensor carrying a calibration range or a scale and zero point, is unquantized whatever it carries, as LiteRT’s kernels read it.

stored_zero_point: int

The stored value of a real 0: the first zero point of a quantized tensor, and 0 for any other.

size: int

Return the size of the tensor.

nbytes: int

Return the number of bytes in the tensor.

ndim: int

Return the number of dimensions of the tensor.

is_constant: bool

Check if the tensor is a constant.

is_persistent: bool

Check if the tensor is a persistent variable.

is_scratch: bool

Check if the tensor is a scratch tensor.

placement_id: TensorId

Id that memory.tensors rules match: the source id for a repacked copy.

name: str

ctype: str

Return the C type of the tensor.

This is used for generating C code that operates on the tensor. For example, if the tensor is of type int16, the C type will be int16_t.

dtype_alignment_floor: int

Return the alignment floor based on the tensor’s dtype.

quantized_zero_point(index: int = 0) -> int

The zero point at index of a quantized tensor, and 0 for any other tensor or a missing entry.

require_zero_point() -> None

Reject a scale without a zero point, which LiteRT refuses to load whatever the dtype.

Raises

Errors raised by require_zero_point
Type	Description
`MissingQuantizationError`	If the tensor carries a scale and no zero point.

get_shape_nhwc(pre: bool = True) -> tuple[int, int, int, int]

Return a NHWC padded shape tuple, padding missing axes with 1.

Raises

Errors raised by get_shape_nhwc
Type	Description
`ConfigValueError`	If the tensor has more than four dimensions.

get_shape_with_axis_expanded(axis: int) -> tuple[int, ...]