Operator catalog

Explore 76 registered operators. Search by name or restriction, combine family and data-type filters, then expand an operator for its requirements.

Data types describe individual tensors, not complete A8W8 or A16W8 inference paths. Support also depends on tensor roles, shapes, attributes and target; conversion validates your actual graph.

76 of 76 operators

Accelerator

ETHOS_UAcceleratorint8

Restrictions

Requires a target platform that declares an NPU.
The command-stream tensor must be a constant carrying its data.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to ETHOS_U

Activation

GELUActivationint8float16float32

Restrictions

Exactly one input and one output with the same dtype, identical shapes, positive dimensions and int32 element counts.
int8 input and output carry one scale and zero point each; scales are finite and positive, and the dequantized input range and inverse output scale are finite in float32.
float16 and float32 GELU support the exact form only; the tanh approximation is rejected.
float16 GELU needs an FP16-capable (Cortex-M55-class) platform.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to GELU

HARD_SWISHActivationint8int16float16float32

Restrictions

Input and output must share one dtype and one shape.
Float HARD_SWISH requires positive dimensions and at most INT32_MAX elements.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to HARD_SWISH

LEAKY_RELUActivationint8int16

Restrictions

Input and output must share one supported dtype.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to LEAKY_RELU

LOGISTICActivationint8int16float16float32

Restrictions

Input and output must share one dtype.
Quantized input and output must carry quantization parameters.
An int8 output must use zero-point -128.
int16 input and output tensors must use zero-point 0.
An int16 output must use scale 2^-15.
An int16 input scale must be below 8/3, so the input multiplier fits in int16.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to LOGISTIC

PRELUActivationint8float16float32

Restrictions

Input, alpha and output tensors must share one dtype.
The float alpha shape must broadcast to the input: every alpha dimension equals the input dimension or is 1.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to PRELU

RELUActivationint8int16float16float32

Restrictions

Input and output must share one dtype.
Float RELU supports the RELU and RELU6 activation types only.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to RELU

SOFTMAXActivationint8int16float16float32

Restrictions

An int8 input produces an int8 or int16 output; an int16 input produces an int16 output.
Float softmax requires matching input and output dtypes.
Float softmax requires beta == 1.0: the CMSIS-NN float kernels take no beta.
Quantized output parameters are fixed: int8 output zero point -128 and scale 1/256; from int8 to int16, zero point -32768 and scale 1/65536; int16 input zero point 0 and output zero point 0 with scale 1/32768.
An int8 input needs a beta of 0 or more, and beta × input scale × 2^26 that flushes to a zero multiplier (below 2^-32), or is 0.5 or more, which the CORE kernel's left shift can carry. An int16 input needs a finite beta with beta × input scale × 6553.5 of magnitude below 2^15, past which the CORE kernel's int32 requantize of a 16-bit difference would overflow; LiteRT may run larger products.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SOFTMAX

TANHActivationint8int16float16float32

Restrictions

Input and output must share one dtype.
Quantized input and output must carry quantization parameters.
int16 input and output tensors must use zero-point 0.
An int16 output must use scale 2^-15.
An int16 input scale must be below 8/3, so the input multiplier fits in int16.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to TANH

Comparison

COMPARISONComparisonint8int16int32bool

Restrictions

INT8/INT16 inputs require quantization; INT32 supports rank 0–4 singleton broadcasting.
BOOL supports EQUAL/NOT_EQUAL with static nonempty rank 0–4 broadcasting.
The output tensor must be boolean.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: ignored

Link to COMPARISON

LOGICALComparisonbool

Restrictions

BOOL only; static nonempty rank 0–4 tensors; singleton broadcasting for AND/OR.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to LOGICAL

SELECT_V2Comparisonint8int16int32

Restrictions

The condition tensor must be boolean; the x, y and output tensors must be int8, int16 or int32 sharing one dtype.
Rank must be 8 or lower and the output shape must be the broadcast of the input shapes.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to SELECT_V2

WHEREComparisonint8int16

Restrictions

The condition tensor must be int8 or int16 with rank 1 to 8.
The output tensor must be int64 and must match the shape the kernel derives from the condition.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to WHERE

Convolution

CONV_2DConvolutionint8int16float16float32

Restrictions

Input and output must share one dtype, and float weights and bias must use that same dtype.
INT4 weights are not supported; quantize them to int8.
Weight scales must be per-tensor or one per output channel on the output-channel axis (0 for OHWI).
Upscale factors must be 1 or greater, and upscaling is supported on the int8 kernel path only.
The weights and bias tensors must be constants so the weight sums can be precomputed.
Quantized weight zero points must be 0, and int16 input and output zero points must be 0.
A quantized bias is int32 for int8 activations and int64 or int32 for int16 ones. An int32 bias is read as int32 whatever quantized_bias_type says, where LiteRT reads it so only with quantized_bias_type INT32. With an int32 bias the int16 kernels accumulate in int32, which can overflow past about 516 full-scale input columns.
A bias holds at least one value per output channel; the kernels read one per channel.
Strides and dilations must be at least 1.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: conditional

Link to CONV_2D

DEPTHWISE_CONV_2DConvolutionint8int16float16float32

Restrictions

Input and output must share one dtype, and float weights and bias must use that same dtype.
INT4 weights are not supported; quantize them to int8.
Weight scales must be per-tensor or one per output channel on the output-channel axis (3 for 1HWO).
The weights and bias tensors must be constants so the weight sums can be precomputed.
The weights must be rank 4 in the LiteRT layout [1, H, W, O].
A quantized bias must be rank 1.
Quantized weight zero points must be 0.
A quantized bias is int32 for int8 activations and int64 for int16 ones.
With one input channel and per-channel weight scales, the default DEPTHWISE_TO_CONV rewrite needs a bias.
A bias holds at least one value per output channel, and exactly one for a quantized operator.
Strides and dilations must be at least 1.
INT16 geometry must fit the selected CORE path: generic and DSP tap indices fit int16; MVE indices and products fit int32. MVE intrinsic paths require a matching CORE/module build.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: conditional

Link to DEPTHWISE_CONV_2D

TRANSPOSE_CONVConvolutionint8int16float16float32

Restrictions

Input and output must share one dtype.
The int8 path requires int8 weights with zero points of 0 and, when present, an int32 bias.
Weight scales must be per-tensor or one per output channel (axis 0 for OHWI), labelled on any axis of that length.
The int16 path requires symmetric int16 input/output, int8 weights and an optional constant int64 bias.
Int16 conversion conservatively bounds the full filter dot product plus bias below 2^47 and its requantized magnitude within int32; shifts must be in [-31, 7]. Runtime bias is unsupported.
The float path requires weights and any bias to use the input dtype.
With per-channel weight scales on an axis other than 0, the default TRANSPOSE_REVERSE_CONV rewrite needs a bias.
The input channels must equal the weights' (axis 3) and the output channels the weights' (axis 0), and a bias holds at least one value per output channel.
Strides must be at least 1, and (input - 1) * stride + max(kernel, stride) must fit int32 on each axis.
An int8 output, padding included, may be at most (input - 1) * stride + max(kernel, stride) on each axis unless TRANSPOSE_REVERSE_CONV rewrites it as a CONV_2D.
A run-time output_shape must hold the declared output shape: the module computes the declared shape and does not read the value.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: conditional

Link to TRANSPOSE_CONV

Dense

FULLY_CONNECTEDDenseint8int16float16float32

Restrictions

Input and output must share one supported dtype.
INT4 weights are not supported; quantize them to int8.
Weights must be 2-D [units, depth]. The input is read as rows of depth values, so its size must be a multiple of the depth, and with keep_num_dims its last dimension must equal the depth; the output's last dimension must equal the number of units, and its size the row count times the units.
On MVE targets an int8 layer's weights and bias must be constants, since the kernel sums are precomputed from them.
Integer weights carry one zero point, or one per scale. Per-channel weights are quantized on axis 0, the units. Per-channel weights and weights for int16 activations must have zero points of 0; a per-tensor int8 zero point must lie in -128..127.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: conditional

Link to FULLY_CONNECTED

Elementwise

ABSElementwiseint8int16float16float32

Restrictions

Input and output must have the same dtype and the same shape.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to ABS

ADDElementwiseint8int16float16float32

Restrictions

Both inputs and the output must share one dtype.
Float ADD broadcasts rank-4-or-lower tensors after left-padding them to NHWC; equal shapes of any rank keep the flat kernel.
Float ADD requires positive dimensions and at most INT32_MAX elements.
Quantized ADD takes rank-4-or-lower tensors; its output must be the broadcast of its inputs, with no zero dimension and fewer than 2^31 elements.
int16 input and output zero points must be 0.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to ADD

DIVElementwisefloat16float32

Restrictions

Both inputs and the output must share FP16 or FP32 dtype.
Broadcasting supports scalar through rank-four tensors, left-padded to NHWC.
Equal shapes of any rank use the flat kernel; all dimensions must be positive.
Each tensor's byte count must fit INT32_MAX. No scratch or expanded operand is needed.
FP16 requires a Cortex-M55-class platform.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to DIV

MAXIMUMElementwiseint8int16float16float32

Restrictions

Takes exactly two input tensors and one output tensor, all of one supported dtype.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: ignored

Link to MAXIMUM

MINIMUMElementwiseint8int16float16float32

Restrictions

Takes exactly two input tensors and one output tensor, all of one supported dtype.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: ignored

Link to MINIMUM

MULElementwiseint8int16float16float32

Restrictions

Both inputs and the output must share one dtype.
Float MUL broadcasts rank-4-or-lower tensors after left-padding them to NHWC; equal shapes of any rank retain the flat kernel.
Float MUL requires positive dimensions and at most INT32_MAX elements.
int16 input and output zero points must be 0.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to MUL

NEGElementwisefloat16float32

Restrictions

Input and output must share FP32 or FP16 dtype and identical positive static shapes; scalars are supported.
Tensor byte count must fit INT32_MAX. FP16 requires a Cortex-M55-class platform.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to NEG

RSQRTElementwiseint8int16float16float32

Restrictions

Input and output must share one dtype and one shape.
Quantized tensors must carry a scale and a zero-point, and int16 tensors must use zero-point 0.
Float RSQRT requires genuine integer input and output dimensions (not bool or duration), positive dimensions and at most INT32_MAX elements.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to RSQRT

SQRTElementwiseint8int16float16float32

Restrictions

Input and output must share one dtype and one shape.
Quantized tensors must carry a scale and a zero-point.
float16 SQRT requires genuine integer input and output dimensions (not bool or duration), positive dimensions and at most INT32_MAX elements.
float32 SQRT allows scalar and empty tensors; input and output dimensions must be integers (not bool or duration), and every dimension and the full element count must fit nonnegative int32.
float32 SQRT uses the native floating kernel; negative non-NaN inputs produce a positive canonical quiet NaN, while subnormal behavior follows the floating-point flush mode.
int16 SQRT requires zero points of 0.
int16 SQRT requires positive scales whose s_in / s_out^2 is finite and positive in float32.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SQRT

SQUAREElementwisefloat32

Restrictions

Exactly one FP32 input and output with identical shapes and positive int32 element counts.

Float dependency: float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SQUARE

SQUARED_DIFFERENCEElementwiseint8int16float16float32

Restrictions

Two inputs and one output share int8, int16, FP16 or FP32 dtype.
Float operands require equal layouts with positive static dimensions; broadcasting is unsupported.
Float byte counts must fit INT32_MAX; FP16 requires a Cortex-M55-class platform.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SQUARED_DIFFERENCE

SUBElementwiseint8int16float16float32

Restrictions

Both inputs and the output must share one dtype.
Float SUB supports elementwise shapes, a scalar operand, or NumPy/TFLite broadcasting of operands of rank 4 or lower, compared in the left-padded NHWC view.
Scalar-broadcast float SUB supports the NONE fused activation only.
Float dimensions must be genuine positive integers and element counts must fit int32.
int16 input and output zero points must be 0.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SUB

Matmul

BATCH_MATMULMatmulint8int16float16float32

Restrictions

Both operands and the output must share one dtype.
Quantized operands and output must be per-tensor: one scale and at most one zero point each, in -128..127 for int8 and 0 for int16.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: conditional

Link to BATCH_MATMUL

Pooling

AVERAGE_POOL_2DPoolingint8int16float16float32

Restrictions

Takes exactly one input tensor and one output tensor.
Input and output must share one supported dtype; pooling does not convert element types.
Every pooling window must overlap the input along both axes, with every window bound within int32.
Input and output must have the same batch and channel counts, neither of them 0.
Strides must be at least 1.
An integer pool converted for an MVE target is planned without scratch, so it needs an MVE build.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: conditional

Link to AVERAGE_POOL_2D

MAX_POOL_2DPoolingint8int16float16float32

Restrictions

Input and output must share one supported dtype; pooling does not convert element types.
Every pooling window must overlap the input along both axes, with every window bound within int32.
Input and output must have the same batch and channel counts, neither of them 0.
Strides must be at least 1.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: ignored

Link to MAX_POOL_2D

Quantization

DEQUANTIZEQuantizationint8int16float16float32

Restrictions

Accepts int8, int16 or float16 input and produces float32 output.
An int8 or int16 input needs a quantization scale and zero point.
Input and output shapes must match.

Float dependency: None declared
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to DEQUANTIZE

QUANTIZEQuantizationint8uint8int16float32

Restrictions

Accepts float32 input to int8/int16 output, or requantizes int8 to int8, int16 to int16, int8 to uint8 and uint8 to int8.
Every int8, uint8 or int16 input and output needs a quantization scale and zero point.

Float dependency: None declared
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to QUANTIZE

Reduction

ARG_MAXReductionint8int16float16float32

Restrictions

The output tensor must be int32.
The axis attribute must be in range for the input rank.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to ARG_MAX

ARG_MINReductionint8int16float16float32

Restrictions

The output tensor must be int32.
The axis attribute must be in range for the input rank.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to ARG_MIN

MEANReductionint8int16float16float32

Restrictions

Input and output must share one supported dtype.
Input rank must be 1 to 4 with positive dimensions.
Reduction axes must be constant and in range; integer MEAN requires at least one axis.
Float input and output dimensions must be genuine integers and element counts must fit int32.
Float output shape must match the reduction with reduced dimensions kept or removed.
Integer output shape must match keep_dims; when unspecified, kept or removed dimensions are accepted.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to MEAN

REDUCE_BOOLReductionbool

Restrictions

BOOL only; nonempty rank 0–4 tensors; constant INT32 scalar/vector axes.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to REDUCE_BOOL

REDUCE_MAXReductionint8int16float16float32

Restrictions

Input and output must share one dtype; there is no requantization.
Quantized tensors must share one scale and zero point, as in LiteRT.
Float results follow TFLM: a NaN is never selected, a window holding only -Inf or NaN gives -FLT_MAX (-65504 for float16), and with no axes reduced each element is folded from -FLT_MAX rather than copied. LiteRT's default kernels can differ on any window holding a NaN or only -Inf, and copy when no axes are reduced; its reference kernels differ only on a whole-tensor reduction whose first element is a NaN or whose other elements are all -Inf.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to REDUCE_MAX

REDUCE_MINReductionint8int16float16float32

Restrictions

Input and output must share one dtype; there is no requantization.
Quantized tensors must share one scale and zero point, as in LiteRT.
Float results follow TFLM: a NaN is never selected, a window holding only +Inf or NaN gives +FLT_MAX (+65504 for float16), and with no axes reduced each element is folded from +FLT_MAX rather than copied. LiteRT's default kernels can differ on any window holding a NaN or only +Inf, and copy when no axes are reduced; its reference kernels differ only on a whole-tensor reduction whose first element is a NaN or whose other elements are all +Inf.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to REDUCE_MIN

SUMReductionint8int16float16float32

Restrictions

Input and output must share one dtype; integer tensors must carry quantization parameters.
The axes tensor must be constant int32 with axes in the input rank's range.
Input and output rank must be at most 4.
The output shape must match the reduction with reduced dimensions kept or removed.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SUM

Stateful

ASSIGN_VARIABLEStatefulint8int16float16float32

Restrictions

Resource and assigned tensors must have the same numeric dtype.
Float16 tensors require a platform with FP16 kernel support.

Float dependency: None declared
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to ASSIGN_VARIABLE

GRUStatefulfloat16

Restrictions

Takes two inputs (sequence and initial state) and two outputs (sequence and final state).
Every tensor must be float16, and the weight tensors must be constants.
Sequence tensors must be rank 3 with positive dimensions, batch-major, and batch size 1.
Only reset_after=True is supported.
The initial state and the final state must be distinct tensors.

Float dependency: float16
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to GRU

READ_VARIABLEStatefulint8int16float16float32

Restrictions

Resource and output tensors must have the same numeric dtype.
Float16 tensors require a platform with FP16 kernel support.
A variable starts at its CALL_ONCE constant, else at its zero point.

Float dependency: None declared
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to READ_VARIABLE

SVDFStatefulint8float16float32

Restrictions

Kernel rank limits are 1..32767 for integer paths and 1..2147483647 for float paths.
Input and output must share one dtype.
On the float path the bias and weight tensors must use the input dtype.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: required

Link to SVDF

UNIDIRECTIONAL_SEQUENCE_LSTMStatefulint8float16float32

Restrictions

Only the standard Keras LSTM tensor subset is supported, with TANH cell activation.
Projection clipping, diagonal recurrent tensors and asymmetric_quantize_inputs are not supported.
Input and output must share one dtype.
Weight and bias tensors must be constants whose shapes follow the input and hidden sizes.
The output state and the cell state must each hold batch size times hidden size elements.
On the int8 path the weights must be symmetric (zero-point 0) and the output state must be int8.
On the int8 path the output state must carry the quantization of the primary output.
On the int8 path a quantized hidden intermediate (operator intermediate 4) must carry the quantization of the output state.
On the int8 path the cell state must be int16 with zero-point 0 and a power-of-two scale.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to UNIDIRECTIONAL_SEQUENCE_LSTM

Tensor

BATCH_TO_SPACE_NDTensorint8int16

Restrictions

Input rank must be 3 or 4, with one block_shape entry per spatial dimension.
Block shape entries must be non-zero and the batch dimension must divide by each of them.
Crops must be non-negative and every computed output dimension must be positive.
Input and output must share one dtype; there is no requantization.
Quantized tensors must share one scale and zero point, as in LiteRT.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to BATCH_TO_SPACE_ND

BROADCAST_TOTensorint8int16

Restrictions

Input and output tensors must be int8 or int16 with rank 1 to 8.
The shape tensor must be a constant rank-1 int32 or int64 tensor holding only positive dimensions.
The output shape must equal the shape tensor and must be a valid broadcast of the input shape.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to BROADCAST_TO

CONCATENATIONTensorint8int16int32float16float32

Restrictions

Takes one or more input tensors, all with the same non-zero rank as the output.
All inputs and the output must share one dtype.
int8 tensors must share one scale and zero point, as in LiteRT.
int16 zero points must be 0.
Fused activations are rejected, as in LiteRT.
Float concatenation supports rank-three row-major and rank-four NHWC tensors.
Float dimensions must be Python or NumPy integers; bool, durations and noninteger metadata are rejected.
Float inputs and output must have matching non-axis extents; the output axis extent must equal the input axis sum.
Float dimensions and full element counts, plus outer and inner counts at the normalized axis, must fit nonnegative int32 (0 to 2147483647).
Float rank-three inputs and output must also have outer-times-axis prefixes that fit int32; this extra prefix restriction does not apply to rank-four or integer tensors.
Float zero extents are allowed within these count limits; negative axes are normalized relative to the tensor rank.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to CONCATENATION

DEPTH_TO_SPACETensorint8int16

Restrictions

Input and output must share one dtype; there is no requantization.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to DEPTH_TO_SPACE

DILATETensorint8int16float16float32

Restrictions

Requires DILATE options and a constant int32 dilations tensor with one entry per input dimension.
Input rank must be 1 to 4 and every dilation factor must be 1 or greater.
Each output dimension must equal (input dimension - 1) * dilation + 1.
The padding value must be a finite constant scalar in the input dtype.
Input and output must share one dtype.
When both tensors carry quantization metadata, first scales must be close (numpy.isclose) and first zero-points must be equal.

Float dependency: float16
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to DILATE

DYNAMIC_UPDATE_SLICETensorint8int16

Restrictions

Operand, update and output tensors must be int8 or int16 and share one dtype.
Operand rank must be 1 to 8, the update rank must match it, and no update dimension may exceed the operand.
start_indices must be a rank-1 tensor with one entry per operand dimension.
start_indices must be int32, or a constant int64 tensor whose values fit in int32.
The output shape must equal the operand shape.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to DYNAMIC_UPDATE_SLICE

EXPAND_DIMSTensorint8int16int32float16float32

Restrictions

Takes exactly one input tensor and one output tensor.
Moves tensor bytes without numeric conversion; aliased input/output buffers require no copy.
Input and output must share one dtype and the same total byte count.
Quantized tensors must share one scale and zero point, as in LiteRT.
int16 zero points must be 0.

Float dependency: None declared
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to EXPAND_DIMS

FILLTensorint8int16float16float32

Restrictions

Dimensions must be constant; generated output storage is fixed at conversion.
The fill value must use the output dtype: the emitted cast reinterprets it rather than requantizing it.
Quantized tensors must share one scale and zero point, as in LiteRT.
int16 zero points must be 0.

Float dependency: float16
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to FILL

GATHERTensorint8int16float16float32

Restrictions

The indices tensor must be int32 and the output dtype must match the data tensor.
The axis must be in range for the input rank.
The output rank must equal input rank plus indices rank minus batch_dims minus one.
Float tensors must have positive dimensions; data rank is 1 to 4 and indices/output rank is 0 to 4.
Each float-path tensor buffer must fit within INT32_MAX bytes.
Float batch_dims must be nonnegative, at most axis and indices rank, and less than data rank.
Float data and indices must have matching leading batch dimensions.
The float output shape must match the shape inferred from data, indices, axis and batch_dims.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to GATHER

GATHER_NDTensorint8int16float16float32

Restrictions

The indices tensor must be int32 and the output dtype must match the params tensor.
Float option shapes must match the actual data, indices and output tensor shapes.
Float tensors must have positive dimensions; data/indices rank is 1 to 4 and output rank is 0 to 4.
Each float-path tensor buffer must fit within INT32_MAX bytes.
Float index depth must not exceed data rank.
The float output shape must equal indices.shape[:-1] followed by data.shape[index_depth:].

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to GATHER_ND

MIRROR_PADTensorint8int16

Restrictions

Input and output tensors must be int8 or int16, rank 1 to 8, sharing one dtype, scale and zero-point.
int16 tensors must use zero-point 0.
The paddings tensor must have shape [rank, 2] and hold non-negative values.
Paddings must stay within the input-size limits of the selected mirror mode.
The output shape must equal the padded input shape.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to MIRROR_PAD

PACKTensorint8int16int32float16float32

Restrictions

Takes at least one input, and the input count must equal both values_count and the size of the pack axis.
Every input must use the output dtype and must equal the output shape with the pack axis removed.
Quantized tensors must share one scale and zero point, as in LiteRT.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to PACK

PADTensorint8int16float16float32

Restrictions

Pre- and post-padding values must be given.
Input and output must share one supported dtype.
Quantized input and output must share one scale.
For quantized tensors, the constant padding value must fit the output dtype range.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to PAD

RESHAPETensorint8int16float16float32

Restrictions

Input and output must share one dtype and the same total byte count.

Float dependency: None declared
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to RESHAPE

RESIZE_BILINEARTensorint8int16

Restrictions

Input and output tensors must be int8 or int16 with rank 4 or lower, sharing one scale and zero-point.
The size tensor must be a constant int32 tensor of exactly two elements matching the output height and width.
half_pixel_centers and align_corners must not both be true.
The output batch and channel dimensions must match the input.
INT8 shapes must be positive with at most INT32_MAX elements; CORE must provide ARM_NN_HAS_RESIZE_BILINEAR_S8.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to RESIZE_BILINEAR

RESIZE_NEAREST_NEIGHBORTensorint8int16float16float32

Restrictions

The size tensor must be a constant int32 tensor of two elements: the kernel precomputes its coordinate map.
The size tensor values must match the output height and width.
Rank must be 1 to 4 with positive dimensions, and the output batch and channels must match the input.
The element count and the coordinate map must both fit int32 indexing.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: required

Link to RESIZE_NEAREST_NEIGHBOR

REVERSE_SEQUENCETensorint8int16

Restrictions

Input and output tensors must be int8 or int16, sharing one dtype and one shape, with rank 1 to 8.
seq_lengths must be a rank-1 int32 tensor as long as the batch dimension.
seq_lengths values must be non-negative and no larger than the sequence dimension.
seq_dim and batch_dim must be non-negative, different, and in range for the input rank.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to REVERSE_SEQUENCE

REVERSE_V2Tensorint8int16float16float32

Restrictions

Input and output must share one dtype and one shape, with rank 1 or higher.
Axes must be unique once normalized and in range for the input rank.

Float dependency: None declared
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to REVERSE_V2

SCATTER_NDTensorint8int16

Restrictions

Updates and output tensors must be int8 or int16 and share one dtype.
The indices tensor and the shape tensor must be int32, and the shape tensor must be a constant.
The output shape must equal the contents of the shape tensor.
The index depth must be between 1 and the output rank.
Indices and updates must share their leading dimensions, and updates must match the output suffix dimensions.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to SCATTER_ND

SHAPETensorint8int16float16float32

Restrictions

Only the input's static shape is read, so the input may be any dtype.
The output holds that shape as int32 or int64.

Float dependency: None declared
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SHAPE

SLICETensorint8int16float16float32

Restrictions

Input rank must be 4 or lower.
The output must use the input dtype.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SLICE

SPACE_TO_BATCH_NDTensorint8int16

Restrictions

Input rank must be 3 or 4, with one non-zero block_shape entry per spatial dimension.
Each padded spatial dimension must divide by its block_shape entry.
Input and output must share one dtype; there is no requantization.
Quantized tensors must share one scale and zero point, as in LiteRT.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to SPACE_TO_BATCH_ND

SPACE_TO_DEPTHTensorint8int16

Restrictions

Input and output must share one dtype; there is no requantization.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to SPACE_TO_DEPTH

SPLITTensorint8int16int32float16float32

Restrictions

Takes one input tensor and at least one output, and split_lengths must have one entry per output.
The axis must be in range, every split length must be positive, and the lengths must sum to the axis size.
Every output must use the input dtype.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SPLIT

SQUEEZETensorint8int16float16float32

Restrictions

SQUEEZE only drops size-1 dimensions: input and output must share one dtype and the same byte count.

Float dependency: float16
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to SQUEEZE

STRIDED_SLICETensorint8int16int32float16float32

Restrictions

Input rank must be 4 or lower.
The output must use the input dtype.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to STRIDED_SLICE

TILETensorint8int16

Restrictions

Input and output tensors must be int8 or int16 and share one dtype.
The multipliers tensor must be int32, or a constant int64 tensor whose values fit int32.
There must be one non-negative multiplier per input dimension.
The output shape must equal the input shape multiplied elementwise by the multipliers.

Float dependency: None declared
Minimum ns-cmsis-nn for float: Not applicable
Context buffer: no_ctx

Link to TILE

TRANSPOSETensorint8int16float16float32

Restrictions

Input and output must share one supported dtype.
The rank must be 1 to 4, and the permutation must name each input axis once.
The output shape must be the input shape permuted.
Every input and output extent must be at least 1.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to TRANSPOSE

UNPACKTensorint8int16int32float16float32

Restrictions

Takes one input tensor and at least one output, and the output count must equal both num and the axis size.
Every output must use the input dtype and must equal the input shape with the unpack axis removed.
Quantized tensors must share one scale and zero point, as in LiteRT.

Float dependency: float16, float32
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to UNPACK

ZEROS_LIKETensorint32float32

Restrictions

Input and output must have the same shape and the same dtype.
The dtype must be int32 or float32: LiteRT's ZEROS_LIKE runs only int32, int64 and float32.

Float dependency: None declared
Minimum ns-cmsis-nn for float: 7.47.0
Context buffer: no_ctx

Link to ZEROS_LIKE

Reading a row

Column	What it says
Data types	A summary of data tensor types, including conversion input/output types. This is not every legal input/output pairing or the type of every index, mask, weight or state tensor. Byte-copy and metadata rows may admit additional types.
Float dependency	The types for which the lowering declares a gated float API or C type dependency. This may cover arithmetic or only data movement. `no` means no such dependency is declared; it does not rule out integer-library helpers or inline float code. Neither value proves SIMD optimization.
Minimum ns-cmsis-nn	The oldest library the float path builds against. The module-wide floor is `7.47.0`; an operator with no float support says —.
Context buffer	How the lowering uses `cmsis_nn_context::buf`: `no_ctx`, `ignored`, `required`, `conditional`.
Restrictions	Documented shape, quantization, attribute, platform and kernel limits. Individual validators enforce the applicable subset.

For example, DEQUANTIZE takes int8, int16 or float16 and produces float32; QUANTIZE takes float32 to int8/int16, requantizes within the same integer width, or requantizes int8 to uint8 and uint8 to int8. ARG_MIN/MAX produce int32 indices, comparisons produce bool, and WHERE produces int64 indices. The int8 LSTM path has int8 output state and int16 cell state; an int16 state is not an int16 inference path.

Lowering can call heliaCORE, emit inline arithmetic or lookup loops, copy bytes, reuse an aliased buffer, or invoke the ETHOS-U accelerator. EXPAND_DIMS copies bytes or becomes a no-op; DILATE and RESIZE_BILINEAR emit inline loops. A heliaCORE call may itself select a vector, DSP or scalar path. Check the generated source and the linked library configuration when comparing optimized coverage.

Each context buffer size must fit 0..2147483647 bytes. Dimensions and sizing parameters passed through signed 32-bit kernel fields must also fit those fields. Whether zero dimensions are permitted depends on the operator, converter and selected kernel or sizer; do not infer one universal lower bound. Products can overflow even when individual dimensions fit.

Full reference tables by family

Accelerator operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`ETHOS_U`	`int8`	no	—	`no_ctx`	Requires a target platform that declares an NPU. The command-stream tensor must be a constant carrying its data.

Activation operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`GELU`	`int8`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Exactly one input and one output with the same dtype, identical shapes, positive dimensions and int32 element counts. int8 input and output carry one scale and zero point each; scales are finite and positive, and the dequantized input range and inverse output scale are finite in float32. float16 and float32 GELU support the exact form only; the tanh approximation is rejected. float16 GELU needs an FP16-capable (Cortex-M55-class) platform.
`HARD_SWISH`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one dtype and one shape. Float HARD_SWISH requires positive dimensions and at most INT32_MAX elements.
`LEAKY_RELU`	`int8`, `int16`	no	—	`no_ctx`	Input and output must share one supported dtype.
`LOGISTIC`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one dtype. Quantized input and output must carry quantization parameters. An int8 output must use zero-point -128. int16 input and output tensors must use zero-point 0. An int16 output must use scale 2^-15. An int16 input scale must be below 8/3, so the input multiplier fits in int16.
`PRELU`	`int8`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input, alpha and output tensors must share one dtype. The float alpha shape must broadcast to the input: every alpha dimension equals the input dimension or is 1.
`RELU`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one dtype. Float RELU supports the RELU and RELU6 activation types only.
`SOFTMAX`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	An int8 input produces an int8 or int16 output; an int16 input produces an int16 output. Float softmax requires matching input and output dtypes. Float softmax requires beta == 1.0: the CMSIS-NN float kernels take no beta. Quantized output parameters are fixed: int8 output zero point -128 and scale 1/256; from int8 to int16, zero point -32768 and scale 1/65536; int16 input zero point 0 and output zero point 0 with scale 1/32768. An int8 input needs a beta of 0 or more, and beta × input scale × 2^26 that flushes to a zero multiplier (below 2^-32), or is 0.5 or more, which the CORE kernel’s left shift can carry. An int16 input needs a finite beta with beta × input scale × 6553.5 of magnitude below 2^15, past which the CORE kernel’s int32 requantize of a 16-bit difference would overflow; LiteRT may run larger products.
`TANH`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one dtype. Quantized input and output must carry quantization parameters. int16 input and output tensors must use zero-point 0. An int16 output must use scale 2^-15. An int16 input scale must be below 8/3, so the input multiplier fits in int16.

Comparison operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`COMPARISON`	`int8`, `int16`, `int32`, `bool`	no	—	`ignored`	INT8/INT16 inputs require quantization; INT32 supports rank 0–4 singleton broadcasting. BOOL supports EQUAL/NOT_EQUAL with static nonempty rank 0–4 broadcasting. The output tensor must be boolean.
`LOGICAL`	`bool`	no	—	`no_ctx`	BOOL only; static nonempty rank 0–4 tensors; singleton broadcasting for AND/OR.
`SELECT_V2`	`int8`, `int16`, `int32`	no	—	`no_ctx`	The condition tensor must be boolean; the x, y and output tensors must be int8, int16 or int32 sharing one dtype. Rank must be 8 or lower and the output shape must be the broadcast of the input shapes.
`WHERE`	`int8`, `int16`	no	—	`no_ctx`	The condition tensor must be int8 or int16 with rank 1 to 8. The output tensor must be int64 and must match the shape the kernel derives from the condition.

Convolution operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`CONV_2D`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`conditional`	Input and output must share one dtype, and float weights and bias must use that same dtype. INT4 weights are not supported; quantize them to int8. Weight scales must be per-tensor or one per output channel on the output-channel axis (0 for OHWI). Upscale factors must be 1 or greater, and upscaling is supported on the int8 kernel path only. The weights and bias tensors must be constants so the weight sums can be precomputed. Quantized weight zero points must be 0, and int16 input and output zero points must be 0. A quantized bias is int32 for int8 activations and int64 or int32 for int16 ones. An int32 bias is read as int32 whatever quantized_bias_type says, where LiteRT reads it so only with quantized_bias_type INT32. With an int32 bias the int16 kernels accumulate in int32, which can overflow past about 516 full-scale input columns. A bias holds at least one value per output channel; the kernels read one per channel. Strides and dilations must be at least 1.
`DEPTHWISE_CONV_2D`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`conditional`	Input and output must share one dtype, and float weights and bias must use that same dtype. INT4 weights are not supported; quantize them to int8. Weight scales must be per-tensor or one per output channel on the output-channel axis (3 for 1HWO). The weights and bias tensors must be constants so the weight sums can be precomputed. The weights must be rank 4 in the LiteRT layout [1, H, W, O]. A quantized bias must be rank 1. Quantized weight zero points must be 0. A quantized bias is int32 for int8 activations and int64 for int16 ones. With one input channel and per-channel weight scales, the default DEPTHWISE_TO_CONV rewrite needs a bias. A bias holds at least one value per output channel, and exactly one for a quantized operator. Strides and dilations must be at least 1. INT16 geometry must fit the selected CORE path: generic and DSP tap indices fit int16; MVE indices and products fit int32. MVE intrinsic paths require a matching CORE/module build.
`TRANSPOSE_CONV`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`conditional`	Input and output must share one dtype. The int8 path requires int8 weights with zero points of 0 and, when present, an int32 bias. Weight scales must be per-tensor or one per output channel (axis 0 for OHWI), labelled on any axis of that length. The int16 path requires symmetric int16 input/output, int8 weights and an optional constant int64 bias. Int16 conversion conservatively bounds the full filter dot product plus bias below 2^47 and its requantized magnitude within int32; shifts must be in [-31, 7]. Runtime bias is unsupported. The float path requires weights and any bias to use the input dtype. With per-channel weight scales on an axis other than 0, the default TRANSPOSE_REVERSE_CONV rewrite needs a bias. The input channels must equal the weights’ (axis 3) and the output channels the weights’ (axis 0), and a bias holds at least one value per output channel. Strides must be at least 1, and (input - 1) * stride + max(kernel, stride) must fit int32 on each axis. An int8 output, padding included, may be at most (input - 1) * stride + max(kernel, stride) on each axis unless TRANSPOSE_REVERSE_CONV rewrites it as a CONV_2D. A run-time output_shape must hold the declared output shape: the module computes the declared shape and does not read the value.

Dense operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`FULLY_CONNECTED`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`conditional`	Input and output must share one supported dtype. INT4 weights are not supported; quantize them to int8. Weights must be 2-D [units, depth]. The input is read as rows of depth values, so its size must be a multiple of the depth, and with keep_num_dims its last dimension must equal the depth; the output’s last dimension must equal the number of units, and its size the row count times the units. On MVE targets an int8 layer’s weights and bias must be constants, since the kernel sums are precomputed from them. Integer weights carry one zero point, or one per scale. Per-channel weights are quantized on axis 0, the units. Per-channel weights and weights for int16 activations must have zero points of 0; a per-tensor int8 zero point must lie in -128..127.

Elementwise operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`ABS`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must have the same dtype and the same shape.
`ADD`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Both inputs and the output must share one dtype. Float ADD broadcasts rank-4-or-lower tensors after left-padding them to NHWC; equal shapes of any rank keep the flat kernel. Float ADD requires positive dimensions and at most INT32_MAX elements. Quantized ADD takes rank-4-or-lower tensors; its output must be the broadcast of its inputs, with no zero dimension and fewer than 2^31 elements. int16 input and output zero points must be 0.
`DIV`	`float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Both inputs and the output must share FP16 or FP32 dtype. Broadcasting supports scalar through rank-four tensors, left-padded to NHWC. Equal shapes of any rank use the flat kernel; all dimensions must be positive. Each tensor’s byte count must fit INT32_MAX. No scratch or expanded operand is needed. FP16 requires a Cortex-M55-class platform.
`MAXIMUM`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`ignored`	Takes exactly two input tensors and one output tensor, all of one supported dtype.
`MINIMUM`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`ignored`	Takes exactly two input tensors and one output tensor, all of one supported dtype.
`MUL`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Both inputs and the output must share one dtype. Float MUL broadcasts rank-4-or-lower tensors after left-padding them to NHWC; equal shapes of any rank retain the flat kernel. Float MUL requires positive dimensions and at most INT32_MAX elements. int16 input and output zero points must be 0.
`NEG`	`float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share FP32 or FP16 dtype and identical positive static shapes; scalars are supported. Tensor byte count must fit INT32_MAX. FP16 requires a Cortex-M55-class platform.
`RSQRT`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one dtype and one shape. Quantized tensors must carry a scale and a zero-point, and int16 tensors must use zero-point 0. Float RSQRT requires genuine integer input and output dimensions (not bool or duration), positive dimensions and at most INT32_MAX elements.
`SQRT`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one dtype and one shape. Quantized tensors must carry a scale and a zero-point. float16 SQRT requires genuine integer input and output dimensions (not bool or duration), positive dimensions and at most INT32_MAX elements. float32 SQRT allows scalar and empty tensors; input and output dimensions must be integers (not bool or duration), and every dimension and the full element count must fit nonnegative int32. float32 SQRT uses the native floating kernel; negative non-NaN inputs produce a positive canonical quiet NaN, while subnormal behavior follows the floating-point flush mode. int16 SQRT requires zero points of 0. int16 SQRT requires positive scales whose s_in / s_out^2 is finite and positive in float32.
`SQUARE`	`float32`	`float32`	`7.47.0`	`no_ctx`	Exactly one FP32 input and output with identical shapes and positive int32 element counts.
`SQUARED_DIFFERENCE`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Two inputs and one output share int8, int16, FP16 or FP32 dtype. Float operands require equal layouts with positive static dimensions; broadcasting is unsupported. Float byte counts must fit INT32_MAX; FP16 requires a Cortex-M55-class platform.
`SUB`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Both inputs and the output must share one dtype. Float SUB supports elementwise shapes, a scalar operand, or NumPy/TFLite broadcasting of operands of rank 4 or lower, compared in the left-padded NHWC view. Scalar-broadcast float SUB supports the NONE fused activation only. Float dimensions must be genuine positive integers and element counts must fit int32. int16 input and output zero points must be 0.

Matmul operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`BATCH_MATMUL`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`conditional`	Both operands and the output must share one dtype. Quantized operands and output must be per-tensor: one scale and at most one zero point each, in -128..127 for int8 and 0 for int16.

Pooling operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`AVERAGE_POOL_2D`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`conditional`	Takes exactly one input tensor and one output tensor. Input and output must share one supported dtype; pooling does not convert element types. Every pooling window must overlap the input along both axes, with every window bound within int32. Input and output must have the same batch and channel counts, neither of them 0. Strides must be at least 1. An integer pool converted for an MVE target is planned without scratch, so it needs an MVE build.
`MAX_POOL_2D`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`ignored`	Input and output must share one supported dtype; pooling does not convert element types. Every pooling window must overlap the input along both axes, with every window bound within int32. Input and output must have the same batch and channel counts, neither of them 0. Strides must be at least 1.

Quantization operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`DEQUANTIZE`	`int8`, `int16`, `float16`, `float32`	no	`7.47.0`	`no_ctx`	Accepts int8, int16 or float16 input and produces float32 output. An int8 or int16 input needs a quantization scale and zero point. Input and output shapes must match.
`QUANTIZE`	`int8`, `uint8`, `int16`, `float32`	no	`7.47.0`	`no_ctx`	Accepts float32 input to int8/int16 output, or requantizes int8 to int8, int16 to int16, int8 to uint8 and uint8 to int8. Every int8, uint8 or int16 input and output needs a quantization scale and zero point.

Reduction operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`ARG_MAX`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	The output tensor must be int32. The axis attribute must be in range for the input rank.
`ARG_MIN`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	The output tensor must be int32. The axis attribute must be in range for the input rank.
`MEAN`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one supported dtype. Input rank must be 1 to 4 with positive dimensions. Reduction axes must be constant and in range; integer MEAN requires at least one axis. Float input and output dimensions must be genuine integers and element counts must fit int32. Float output shape must match the reduction with reduced dimensions kept or removed. Integer output shape must match keep_dims; when unspecified, kept or removed dimensions are accepted.
`REDUCE_BOOL`	`bool`	no	—	`no_ctx`	BOOL only; nonempty rank 0–4 tensors; constant INT32 scalar/vector axes.
`REDUCE_MAX`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one dtype; there is no requantization. Quantized tensors must share one scale and zero point, as in LiteRT. Float results follow TFLM: a NaN is never selected, a window holding only -Inf or NaN gives -FLT_MAX (-65504 for float16), and with no axes reduced each element is folded from -FLT_MAX rather than copied. LiteRT’s default kernels can differ on any window holding a NaN or only -Inf, and copy when no axes are reduced; its reference kernels differ only on a whole-tensor reduction whose first element is a NaN or whose other elements are all -Inf.
`REDUCE_MIN`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one dtype; there is no requantization. Quantized tensors must share one scale and zero point, as in LiteRT. Float results follow TFLM: a NaN is never selected, a window holding only +Inf or NaN gives +FLT_MAX (+65504 for float16), and with no axes reduced each element is folded from +FLT_MAX rather than copied. LiteRT’s default kernels can differ on any window holding a NaN or only +Inf, and copy when no axes are reduced; its reference kernels differ only on a whole-tensor reduction whose first element is a NaN or whose other elements are all +Inf.
`SUM`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one dtype; integer tensors must carry quantization parameters. The axes tensor must be constant int32 with axes in the input rank’s range. Input and output rank must be at most 4. The output shape must match the reduction with reduced dimensions kept or removed.

Stateful operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`ASSIGN_VARIABLE`	`int8`, `int16`, `float16`, `float32`	no	`7.47.0`	`no_ctx`	Resource and assigned tensors must have the same numeric dtype. Float16 tensors require a platform with FP16 kernel support.
`GRU`	`float16`	`float16`	`7.47.0`	`no_ctx`	Takes two inputs (sequence and initial state) and two outputs (sequence and final state). Every tensor must be float16, and the weight tensors must be constants. Sequence tensors must be rank 3 with positive dimensions, batch-major, and batch size 1. Only reset_after=True is supported. The initial state and the final state must be distinct tensors.
`READ_VARIABLE`	`int8`, `int16`, `float16`, `float32`	no	`7.47.0`	`no_ctx`	Resource and output tensors must have the same numeric dtype. Float16 tensors require a platform with FP16 kernel support. A variable starts at its CALL_ONCE constant, else at its zero point.
`SVDF`	`int8`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`required`	Kernel rank limits are 1..32767 for integer paths and 1..2147483647 for float paths. Input and output must share one dtype. On the float path the bias and weight tensors must use the input dtype.
`UNIDIRECTIONAL_SEQUENCE_LSTM`	`int8`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Only the standard Keras LSTM tensor subset is supported, with TANH cell activation. Projection clipping, diagonal recurrent tensors and asymmetric_quantize_inputs are not supported. Input and output must share one dtype. Weight and bias tensors must be constants whose shapes follow the input and hidden sizes. The output state and the cell state must each hold batch size times hidden size elements. On the int8 path the weights must be symmetric (zero-point 0) and the output state must be int8. On the int8 path the output state must carry the quantization of the primary output. On the int8 path a quantized hidden intermediate (operator intermediate 4) must carry the quantization of the output state. On the int8 path the cell state must be int16 with zero-point 0 and a power-of-two scale.

Tensor operators

Operator	Data types	Float dependency	Minimum ns-cmsis-nn	Context buffer	Restrictions
`BATCH_TO_SPACE_ND`	`int8`, `int16`	no	—	`no_ctx`	Input rank must be 3 or 4, with one block_shape entry per spatial dimension. Block shape entries must be non-zero and the batch dimension must divide by each of them. Crops must be non-negative and every computed output dimension must be positive. Input and output must share one dtype; there is no requantization. Quantized tensors must share one scale and zero point, as in LiteRT.
`BROADCAST_TO`	`int8`, `int16`	no	—	`no_ctx`	Input and output tensors must be int8 or int16 with rank 1 to 8. The shape tensor must be a constant rank-1 int32 or int64 tensor holding only positive dimensions. The output shape must equal the shape tensor and must be a valid broadcast of the input shape.
`CONCATENATION`	`int8`, `int16`, `int32`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Takes one or more input tensors, all with the same non-zero rank as the output. All inputs and the output must share one dtype. int8 tensors must share one scale and zero point, as in LiteRT. int16 zero points must be 0. Fused activations are rejected, as in LiteRT. Float concatenation supports rank-three row-major and rank-four NHWC tensors. Float dimensions must be Python or NumPy integers; bool, durations and noninteger metadata are rejected. Float inputs and output must have matching non-axis extents; the output axis extent must equal the input axis sum. Float dimensions and full element counts, plus outer and inner counts at the normalized axis, must fit nonnegative int32 (0 to 2147483647). Float rank-three inputs and output must also have outer-times-axis prefixes that fit int32; this extra prefix restriction does not apply to rank-four or integer tensors. Float zero extents are allowed within these count limits; negative axes are normalized relative to the tensor rank.
`DEPTH_TO_SPACE`	`int8`, `int16`	no	—	`no_ctx`	Input and output must share one dtype; there is no requantization.
`DILATE`	`int8`, `int16`, `float16`, `float32`	`float16`	`7.47.0`	`no_ctx`	Requires DILATE options and a constant int32 dilations tensor with one entry per input dimension. Input rank must be 1 to 4 and every dilation factor must be 1 or greater. Each output dimension must equal (input dimension - 1) * dilation + 1. The padding value must be a finite constant scalar in the input dtype. Input and output must share one dtype. When both tensors carry quantization metadata, first scales must be close (numpy.isclose) and first zero-points must be equal.
`DYNAMIC_UPDATE_SLICE`	`int8`, `int16`	no	—	`no_ctx`	Operand, update and output tensors must be int8 or int16 and share one dtype. Operand rank must be 1 to 8, the update rank must match it, and no update dimension may exceed the operand. start_indices must be a rank-1 tensor with one entry per operand dimension. start_indices must be int32, or a constant int64 tensor whose values fit in int32. The output shape must equal the operand shape.
`EXPAND_DIMS`	`int8`, `int16`, `int32`, `float16`, `float32`	no	`7.47.0`	`no_ctx`	Takes exactly one input tensor and one output tensor. Moves tensor bytes without numeric conversion; aliased input/output buffers require no copy. Input and output must share one dtype and the same total byte count. Quantized tensors must share one scale and zero point, as in LiteRT. int16 zero points must be 0.
`FILL`	`int8`, `int16`, `float16`, `float32`	`float16`	`7.47.0`	`no_ctx`	Dimensions must be constant; generated output storage is fixed at conversion. The fill value must use the output dtype: the emitted cast reinterprets it rather than requantizing it. Quantized tensors must share one scale and zero point, as in LiteRT. int16 zero points must be 0.
`GATHER`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	The indices tensor must be int32 and the output dtype must match the data tensor. The axis must be in range for the input rank. The output rank must equal input rank plus indices rank minus batch_dims minus one. Float tensors must have positive dimensions; data rank is 1 to 4 and indices/output rank is 0 to 4. Each float-path tensor buffer must fit within INT32_MAX bytes. Float batch_dims must be nonnegative, at most axis and indices rank, and less than data rank. Float data and indices must have matching leading batch dimensions. The float output shape must match the shape inferred from data, indices, axis and batch_dims.
`GATHER_ND`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	The indices tensor must be int32 and the output dtype must match the params tensor. Float option shapes must match the actual data, indices and output tensor shapes. Float tensors must have positive dimensions; data/indices rank is 1 to 4 and output rank is 0 to 4. Each float-path tensor buffer must fit within INT32_MAX bytes. Float index depth must not exceed data rank. The float output shape must equal indices.shape[:-1] followed by data.shape[index_depth:].
`MIRROR_PAD`	`int8`, `int16`	no	—	`no_ctx`	Input and output tensors must be int8 or int16, rank 1 to 8, sharing one dtype, scale and zero-point. int16 tensors must use zero-point 0. The paddings tensor must have shape [rank, 2] and hold non-negative values. Paddings must stay within the input-size limits of the selected mirror mode. The output shape must equal the padded input shape.
`PACK`	`int8`, `int16`, `int32`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Takes at least one input, and the input count must equal both values_count and the size of the pack axis. Every input must use the output dtype and must equal the output shape with the pack axis removed. Quantized tensors must share one scale and zero point, as in LiteRT.
`PAD`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Pre- and post-padding values must be given. Input and output must share one supported dtype. Quantized input and output must share one scale. For quantized tensors, the constant padding value must fit the output dtype range.
`RESHAPE`	`int8`, `int16`, `float16`, `float32`	no	`7.47.0`	`no_ctx`	Input and output must share one dtype and the same total byte count.
`RESIZE_BILINEAR`	`int8`, `int16`	no	—	`no_ctx`	Input and output tensors must be int8 or int16 with rank 4 or lower, sharing one scale and zero-point. The size tensor must be a constant int32 tensor of exactly two elements matching the output height and width. half_pixel_centers and align_corners must not both be true. The output batch and channel dimensions must match the input. INT8 shapes must be positive with at most INT32_MAX elements; CORE must provide ARM_NN_HAS_RESIZE_BILINEAR_S8.
`RESIZE_NEAREST_NEIGHBOR`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`required`	The size tensor must be a constant int32 tensor of two elements: the kernel precomputes its coordinate map. The size tensor values must match the output height and width. Rank must be 1 to 4 with positive dimensions, and the output batch and channels must match the input. The element count and the coordinate map must both fit int32 indexing.
`REVERSE_SEQUENCE`	`int8`, `int16`	no	—	`no_ctx`	Input and output tensors must be int8 or int16, sharing one dtype and one shape, with rank 1 to 8. seq_lengths must be a rank-1 int32 tensor as long as the batch dimension. seq_lengths values must be non-negative and no larger than the sequence dimension. seq_dim and batch_dim must be non-negative, different, and in range for the input rank.
`REVERSE_V2`	`int8`, `int16`, `float16`, `float32`	no	`7.47.0`	`no_ctx`	Input and output must share one dtype and one shape, with rank 1 or higher. Axes must be unique once normalized and in range for the input rank.
`SCATTER_ND`	`int8`, `int16`	no	—	`no_ctx`	Updates and output tensors must be int8 or int16 and share one dtype. The indices tensor and the shape tensor must be int32, and the shape tensor must be a constant. The output shape must equal the contents of the shape tensor. The index depth must be between 1 and the output rank. Indices and updates must share their leading dimensions, and updates must match the output suffix dimensions.
`SHAPE`	`int8`, `int16`, `float16`, `float32`	no	`7.47.0`	`no_ctx`	Only the input’s static shape is read, so the input may be any dtype. The output holds that shape as int32 or int64.
`SLICE`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input rank must be 4 or lower. The output must use the input dtype.
`SPACE_TO_BATCH_ND`	`int8`, `int16`	no	—	`no_ctx`	Input rank must be 3 or 4, with one non-zero block_shape entry per spatial dimension. Each padded spatial dimension must divide by its block_shape entry. Input and output must share one dtype; there is no requantization. Quantized tensors must share one scale and zero point, as in LiteRT.
`SPACE_TO_DEPTH`	`int8`, `int16`	no	—	`no_ctx`	Input and output must share one dtype; there is no requantization.
`SPLIT`	`int8`, `int16`, `int32`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Takes one input tensor and at least one output, and split_lengths must have one entry per output. The axis must be in range, every split length must be positive, and the lengths must sum to the axis size. Every output must use the input dtype.
`SQUEEZE`	`int8`, `int16`, `float16`, `float32`	`float16`	`7.47.0`	`no_ctx`	SQUEEZE only drops size-1 dimensions: input and output must share one dtype and the same byte count.
`STRIDED_SLICE`	`int8`, `int16`, `int32`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input rank must be 4 or lower. The output must use the input dtype.
`TILE`	`int8`, `int16`	no	—	`no_ctx`	Input and output tensors must be int8 or int16 and share one dtype. The multipliers tensor must be int32, or a constant int64 tensor whose values fit int32. There must be one non-negative multiplier per input dimension. The output shape must equal the input shape multiplied elementwise by the multipliers.
`TRANSPOSE`	`int8`, `int16`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Input and output must share one supported dtype. The rank must be 1 to 4, and the permutation must name each input axis once. The output shape must be the input shape permuted. Every input and output extent must be at least 1.
`UNPACK`	`int8`, `int16`, `int32`, `float16`, `float32`	`float16`, `float32`	`7.47.0`	`no_ctx`	Takes one input tensor and at least one output, and the output count must equal both num and the axis size. Every output must use the input dtype and must equal the input shape with the unpack axis removed. Quantized tensors must share one scale and zero point, as in LiteRT.
`ZEROS_LIKE`	`int32`, `float32`	no	`7.47.0`	`no_ctx`	Input and output must have the same shape and the same dtype. The dtype must be int32 or float32: LiteRT’s ZEROS_LIKE runs only int32, int64 and float32.