NeuralNetworks

Dedicated accelerator for Machine Learning workloads.

The device runs NNAPI models on single or multi-core CPU.

The device can run NNAPI models and also accelerate graphics APIs such as OpenGL ES and Vulkan.

The device does not fall into any category below.

The device type cannot be provided.

NNAPI specification available in Android O-MR1, Android NNAPI feature level 1.

NNAPI specification available in Android P, Android NNAPI feature level 2.

NNAPI specification available in Android Q, Android NNAPI feature level 3.

NNAPI specification available in Android R, Android NNAPI feature level 4.

NNAPI specification available in Android S, Android NNAPI feature level 5.

After Android S, the NNAPI specification can be updated between Android API releases.

Android NNAPI feature level 6.

Android NNAPI feature level 7.

Android NNAPI feature level 8.

NO fused activation function.

Fused ReLU activation function.

Fused ReLU1 activation function.

Fused ReLU6 activation function.

An 8 bit boolean scalar value.

Values of this operand type are either true or false. A zero value represents false; any other value represents true.

Available since NNAPI feature level 3.

An IEEE 754 16 bit floating point scalar value.

Available since NNAPI feature level 3.

A 32 bit floating point scalar value.

A signed 32 bit integer scalar value.

A reference to a model.

ANeuralNetworksModel_setOperandValueFromModel must be used to set the value for an Operand of this type.

Available since NNAPI feature level 4.

A tensor of 8 bit boolean values.

Values of this operand type are either true or false. A zero value represents false; any other value represents true.

Available since NNAPI feature level 3.

A tensor of IEEE 754 16 bit floating point values.

Available since NNAPI feature level 3.

A tensor of 32 bit floating point values.

A tensor of 32 bit integer values.

A tensor of 16 bit unsigned integers that represent real numbers.

Attached to this tensor are two numbers that can be used to convert the 16 bit integer to the real value and vice versa. These two numbers are:

• scale: a 32 bit floating point value greater than zero.
• zeroPoint: a 32 bit integer, in range [0, 65535].

The formula is: real_value = (integer_value - zeroPoint) * scale.

Available since NNAPI feature level 3.

A tensor of 16 bit signed integers that represent real numbers.

Attached to this tensor is a number representing real value scale that is used to convert the 16 bit number to a real value in the following way: realValue = integerValue * scale.

scale is a 32 bit floating point with value greater than zero.

Available since NNAPI feature level 3.

A tensor of 8 bit unsigned integers that represent real numbers.

Attached to this tensor are two numbers that can be used to convert the 8 bit integer to the real value and vice versa. These two numbers are:

• scale: a 32 bit floating point value greater than zero.
• zeroPoint: a 32 bit integer, in range [0, 255].

The formula is: real_value = (integer_value - zeroPoint) * scale.

A tensor of 8 bit signed integers that represent real numbers.

Attached to this tensor are two numbers that can be used to convert the 8 bit integer to the real value and vice versa. These two numbers are:

• scale: a 32 bit floating point value greater than zero.
• zeroPoint: a 32 bit integer, in range [-128, 127].

The formula is: real_value = (integer_value - zeroPoint) * scale.

Available since NNAPI feature level 4.

A tensor of 8 bit signed integers that represent real numbers.

Attached to this tensor is a number representing real value scale that is used to convert the 8 bit number to a real value in the following way: realValue = integerValue * scale.

scale is a 32 bit floating point with value greater than zero.

Available since NNAPI feature level 3.

A tensor of 8 bit signed integers that represent real numbers.

This tensor is associated with additional fields that can be used to convert the 8 bit signed integer to the real value and vice versa. These fields are:

• channelDim: a 32 bit unsigned integer indicating channel dimension.
• scales: an array of positive 32 bit floating point values. The size of the scales array must be equal to dimensions[channelDim].

ANeuralNetworksModel_setOperandSymmPerChannelQuantParams must be used to set the parameters for an Operand of this type.

The channel dimension of this tensor must not be unknown (dimensions[channelDim] != 0).

The formula is: realValue[..., C, ...] = integerValue[..., C, ...] * scales[C] where C is an index in the Channel dimension.

Available since NNAPI feature level 3.

An unsigned 32 bit integer scalar value.

Computes the absolute value of a tensor, element-wise.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_INT32 (since NNAPI feature level 4)

Supported tensor rank: from 1.

Inputs:

• 0: A tensor.

Outputs:

• 0: The output tensor of same shape as input0.

Available since NNAPI feature level 3.

Adds two tensors, element-wise.

Takes two input tensors of identical OperandCode and compatible dimensions. The output is the sum of both input tensors, optionally modified by an activation function.

Two dimensions are compatible when:

1. they are equal, or
2. one of them is 1

The size of the output is the maximum size along each dimension of the input operands. It starts with the trailing dimensions, and works its way forward.

Example:

input1.dimension = {4, 1, 2}
input2.dimension = {5, 4, 3, 1}
output.dimension = {5, 4, 3, 2}

Since NNAPI feature level 3, generic zero-sized input tensor is supported. Zero dimension is only compatible with 0 or 1. The size of the output dimension is zero if either of corresponding input dimension is zero.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16 (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)
• ANEURALNETWORKS_TENSOR_INT32 (since NNAPI feature level 4)

Supported tensor rank: up to 4

Inputs:

• 0: A tensor.
• 1: A tensor of the same OperandCode, and compatible dimensions as input0. For a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED tensor, the scales and zeroPoint can be different from input0 scale and zeroPoint.
• 2: An ANEURALNETWORKS_INT32 scalar, and has to be one of the FuseCode values. Specifies the activation to invoke on the result. For a ANEURALNETWORKS_TENSOR_INT32 tensor, the FuseCode must be "NONE".

Outputs:

• 0: The sum, a tensor of the same OperandCode as input0. For a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED tensor, the scale and zeroPoint can be different from inputs' scale and zeroPoint.

Available since NNAPI feature level 1.

Returns the index of the largest element along an axis.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_INT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported tensor rank: from 1

Inputs:

• 0: An n-D tensor specifying the input. Must be non-empty.
• 1: An ANEURALNETWORKS_INT32 scalar specifying the axis to reduce across. Negative index is used to specify axis from the end (e.g. -1 for the last axis). Must be in the range [-n, n).

Outputs:

• 0: An (n - 1)-D ANEURALNETWORKS_TENSOR_INT32 tensor. If input is 1-dimensional, the output shape is [1].

Available since NNAPI feature level 3.

Returns the index of the smallest element along an axis.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_INT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported tensor rank: from 1

Inputs:

• 0: An n-D tensor specifying the input. Must be non-empty.
• 1: An ANEURALNETWORKS_INT32 scalar specifying the axis to reduce across. Negative index is used to specify axis from the end (e.g. -1 for the last axis). Must be in the range [-n, n).

Outputs:

• 0: An (n - 1)-D ANEURALNETWORKS_TENSOR_INT32 tensor. If input is 1-dimensional, the output shape is [1].

Available since NNAPI feature level 3.

Performs a 2-D average pooling operation.

The output dimensions are functions of the filter dimensions, stride, and padding.

The values in the output tensor are computed as:

output[b, i, j, channel] =
    sum_{di, dj}(
        input[b, strides[1] * i + di, strides[2] * j + dj, channel]
    ) / sum(1)

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16 (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported tensor rank: 4, with "NHWC" or "NCHW" data layout. With the default data layout NHWC, the data is stored in the order of: [batch, height, width, channels]. Alternatively, the data layout could be NCHW, the data storage order of: [batch, channels, height, width]. NCHW is supported since NNAPI feature level 3.

Both explicit padding and implicit padding are supported.

Inputs (explicit padding):

• 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input. Since NNAPI feature level 3, zero batches is supported for this tensor.
• 1: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the left, in the ‘width’ dimension.
• 2: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the right, in the ‘width’ dimension.
• 3: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the top, in the ‘height’ dimension.
• 4: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the bottom, in the ‘height’ dimension.
• 5: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘width’ dimension.
• 6: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘height’ dimension.
• 7: An ANEURALNETWORKS_INT32 scalar, specifying the filter width.
• 8: An ANEURALNETWORKS_INT32 scalar, specifying the filter height.
• 9: An ANEURALNETWORKS_INT32 scalar, and has to be one of the FuseCode values. Specifies the activation to invoke on the result.
• 10: An optional ANEURALNETWORKS_BOOL scalar, default to false. Set to true to specify NCHW data layout for input0 and output0. Available since NNAPI feature level 3.

Inputs (implicit padding):

• 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input. Since NNAPI feature level 3, zero batches is supported for this tensor.
• 1: An ANEURALNETWORKS_INT32 scalar, specifying the implicit padding scheme, has to be one of the PaddingCode values.
• 2: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘width’ dimension.
• 3: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘height’ dimension.
• 4: An ANEURALNETWORKS_INT32 scalar, specifying the filter width.
• 5: An ANEURALNETWORKS_INT32 scalar, specifying the filter height.
• 6: An ANEURALNETWORKS_INT32 scalar, and has to be one of the FuseCode values. Specifies the activation to invoke on the result.
• 7: An optional ANEURALNETWORKS_BOOL scalar, default to false. Set to true to specify NCHW data layout for input0 and output0. Available since NNAPI feature level 3.

Outputs:

• 0: The output 4-D tensor, of shape [batches, out_height, out_width, depth]. For a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED tensor, the scale and zeroPoint must be the same as input0.

Available since NNAPI feature level 1.

Transform axis-aligned bounding box proposals using bounding box deltas.

Given the positions of bounding box proposals and the corresponding bounding box deltas for each class, return the refined bounding box regions. The resulting bounding boxes are cliped against the edges of the image.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_QUANT16_ASYMM

Inputs:

• 0: A 2-D Tensor of shape [num_rois, 4], specifying the locations of the bounding box proposals, each line with format [x1, y1, x2, y2]. For tensor of type ANEURALNETWORKS_TENSOR_QUANT16_ASYMM, the zeroPoint must be 0 and the scale must be 0.125. Zero num_rois is supported for this tensor.
• 1: A 2-D Tensor of shape [num_rois, num_classes * 4], specifying the bounding box delta for each region of interest and each class. The bounding box deltas are organized in the following order [dx, dy, dw, dh], where dx and dy is the relative correction factor for the center position of the bounding box with respect to the width and height, dw and dh is the log-scale relative correction factor for the width and height. For input0 of type ANEURALNETWORKS_TENSOR_QUANT16_ASYMM, this tensor should be of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM or ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED. Zero num_rois is supported for this tensor.
• 2: An 1-D ANEURALNETWORKS_TENSOR_INT32 tensor, of shape [num_rois], specifying the batch index of each box. Boxes with the same batch index are grouped together. Zero num_rois is supported for this tensor.
• 3: A 2-D Tensor of shape [batches, 2], specifying the information of each image in the batch, each line with format [image_height, image_width].

Outputs:

• 0: A tensor of the same OperandCode as input0, with shape [num_rois, num_classes * 4], specifying the coordinates of each output bounding box for each class, with format [x1, y1, x2, y2]. For type of ANEURALNETWORKS_TENSOR_QUANT16_ASYMM, the scale must be 0.125 and the zero point must be 0.

Available since NNAPI feature level 3.

Performs multiplication of two tensors in batches.

Multiplies all slices of two input tensors and arranges the individual results in a single output tensor of the same batch size. Each pair of slices in the same batch have identical OperandCode. Each slice can optionally be adjointed (transpose and conjugate) before multiplication.

The two input tensors and the output tensor must be 2-D or higher and have the same batch size.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED
• ANEURALNETWORKS_TENSOR_INT32

Supported tensor rank: at least 2 and up to 4

Inputs:

• 0: A tensor with 2-D or higher shape [..., r_x, c_x].
• 1: A tensor with 2-D or higher shape [..., r_y, c_y]. It has the same OperandCode and batch size as input0.
• 2: An optional ANEURALNETWORKS_BOOL scalar adj_x, default to false. Set to true to adjoint the slices of input0.
• 3: An optional ANEURALNETWORKS_BOOL scalar adj_y, default to false. Set to true to adjoint the slices of input1.

Outputs:

• 0: A tensor with 2-D or higher shape [..., r_o, c_o], where r_o = c_x if adj_x else r_x c_o = r_y if adj_y else c_y

Available since NNAPI feature level 6.

BatchToSpace for N-dimensional tensors.

This operation reshapes the batch dimension (dimension 0) into M + 1 dimensions of shape block_shape + [batch], interleaves these blocks back into the grid defined by the spatial dimensions [1, ..., M], to obtain a result with the same rank as the input.

This is the reverse of SpaceToBatch.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16 (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported tensor rank: 4, with "NHWC" or "NCHW" data layout. With the default data layout NHWC, the data is stored in the order of: [batch, height, width, channels]. Alternatively, the data layout could be NCHW, the data storage order of: [batch, channels, height, width]. NCHW is supported since NNAPI feature level 3.

Inputs:

• 0: An n-D tensor, specifying the tensor to be reshaped
• 1: A 1-D Tensor of ANEURALNETWORKS_TENSOR_INT32, the block sizes for each spatial dimension of the input tensor. All values must be >= 1.
• 2: An optional ANEURALNETWORKS_BOOL scalar, default to false. Set to true to specify NCHW data layout for input0 and output0. Available since API level 29.

Outputs:

• 0: A tensor of the same OperandCode as input0. For a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED tensor, the scale and zeroPoint must be the same as input0.

Available since NNAPI feature level 2.

A recurrent neural network layer that applies an LSTM cell to a sequence of inputs in forward and backward directions.

The op supports cross-linking via an auxiliary input. Regular cell feeds one input into the two RNN cells in the following way:

  INPUT  (INPUT_REVERSED)
    |         |

| FW_LSTM BW_LSTM |

| | FW_OUT BW_OUT

An op with cross-linking takes two inputs and feeds them into the RNN cells in the following way:

  AUX_INPUT   (AUX_INPUT_REVERSED)
      |             |
INPUT | (INPUT_R'D.)|
  |   |       |     |

| FW_LSTM BW_LSTM |

| | FW_OUT BW_OUT

The cross-linking mode is enabled iff auxiliary input and auxiliary weights are present. While stacking this op on top of itself, this allows to connect both forward and backward outputs from previous cell to the next cell's input.

Since NNAPI feature level 4 parallel linking mode is supported. The mode is enabled if auxiliary input is present but auxiliary weights are omitted. In this case, the cell feeds inputs into the RNN in the following way:

  INPUT (AUX_INPUT_REVERSED)
    |         |

| FW_LSTM BW_LSTM |

| | FW_OUT BW_OUT

While stacking this op on top of itself, this allows to connect both forward and backward outputs from previous cell to the next cell's corresponding inputs.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32

Supported tensor rank: 3, either time-major or batch-major.

All input and output tensors must be of the same type.

Inputs:

• 0: The input. A 3-D tensor of shape: If time-major: [max_time, batch_size, input_size] If batch-major: [batch_size, max_time, input_size] where "max_time" is the number of timesteps (sequence length), "batch_size" corresponds to the batching dimension, and "input_size" is the size of the input.
• 1: The forward input-to-input weights. Optional. A 2-D tensor of shape [fw_num_units, input_size], where “fw_num_units” corresponds to the number of forward cell units.
• 2: The forward input-to-forget weights. A 2-D tensor of shape [fw_num_units, input_size].
• 3: The forward input-to-cell weights. A 2-D tensor of shape [fw_num_units, input_size].
• 4: The forward input-to-output weights. A 2-D tensor of shape [fw_num_units, input_size].
• 5: The forward recurrent-to-input weights. Optional. A 2-D tensor of shape [fw_num_units, fw_output_size], where “fw_output_size” corresponds to either the number of cell units (i.e., fw_num_units), or the second dimension of the “fw_projection_weights”, if defined.
• 6: The forward recurrent-to-forget weights. A 2-D tensor of shape [fw_num_units, fw_output_size].
• 7: The forward recurrent-to-cell weights. A 2-D tensor of shape [fw_num_units, fw_output_size].
• 8: The forward recurrent-to-output weights. A 2-D tensor of shape [fw_num_units, fw_output_size].
• 9: The forward cell-to-input weights. Optional. A 1-D tensor of shape [fw_num_units].
• 10: The forward cell-to-forget weights. Optional. A 1-D tensor of shape [fw_num_units].
• 11: The forward cell-to-output weights. Optional. A 1-D tensor of shape [fw_num_units].
• 12: The forward input gate bias. Optional. A 1-D tensor of shape [fw_num_units].
• 13: The forward forget gate bias. A 1-D tensor of shape [fw_num_units].
• 14: The forward cell gate bias. A 1-D tensor of shape [fw_num_units].
• 15: The forward output gate bias. A 1-D tensor of shape [fw_num_units].
• 16: The forward projection weights. Optional. A 2-D tensor of shape [fw_output_size, fw_num_units].
• 17: The forward projection bias. Optional. A 1-D tensor of shape [fw_output_size].
• 18: The backward input-to-input weights. Optional. A 2-D tensor of shape [bw_num_units, input_size], where “bw_num_units” corresponds to the number of backward cell units.
• 19: The backward input-to-forget weights. A 2-D tensor of shape [bw_num_units, input_size].
• 20: The backward input-to-cell weights. A 2-D tensor of shape [bw_num_units, input_size].
• 21: The backward input-to-output weights. A 2-D tensor of shape [bw_num_units, input_size].
• 22: The backward recurrent-to-input weights. Optional. A 2-D tensor of shape [bw_num_units, bw_output_size], where “bw_output_size” corresponds to either the number of cell units (i.e., “bw_num_units”), or the second dimension of the “bw_projection_weights”, if defined.
• 23: The backward recurrent-to-forget weights. A 2-D tensor of shape [bw_num_units, bw_output_size].
• 24: The backward recurrent-to-cell weights. A 2-D tensor of shape [bw_num_units, bw_output_size].
• 25: The backward recurrent-to-output weights. A 2-D tensor of shape [bw_num_units, bw_output_size].
• 26: The backward cell-to-input weights. Optional. A 1-D tensor of shape [bw_num_units].
• 27: The backward cell-to-forget weights. Optional. A 1-D tensor of shape [bw_num_units].
• 28: The backward cell-to-output weights. Optional. A 1-D tensor of shape [bw_num_units].
• 29: The backward input gate bias. Optional. A 1-D tensor of shape [bw_num_units].
• 30: The backward forget gate bias. A 1-D tensor of shape [bw_num_units].
• 31: The backward cell gate bias. A 1-D tensor of shape [bw_num_units].
• 32: The backward output gate bias. A 1-D tensor of shape [bw_num_units].
• 33: The backward projection weights. Optional. A 2-D tensor of shape [bw_output_size, bw_num_units].
• 34: The backward projection bias. Optional. A 1-D tensor of shape [bw_output_size].
• 35: The forward input activation state. A 2-D tensor of shape [batch_size, bw_output_size].
• 36: The forward input cell state. A 2-D tensor of shape [batch_size, bw_num_units].
• 37: The backward input activation state. A 2-D tensor of shape [batch_size, bw_output_size].
• 38: The backward input cell state. A 2-D tensor of shape [batch_size, bw_num_units].
• 39: The auxiliary input. Optional. A 3-D tensor of shape [max_time, batch_size, aux_input_size], where “batch_size” corresponds to the batching dimension, and “aux_input_size” is the size of the auxiliary input. Optional. See the docs above for the usage modes explanation.
• 40: The forward auxiliary input-to-input weights. Optional. See the docs above for the usage modes explanation. A 2-D tensor of shape [fw_num_units, aux_input_size].
• 41: The forward auxiliary input-to-forget weights. Optional. See the docs above for the usage modes explanation. A 2-D tensor of shape [fw_num_units, aux_input_size].
• 42: The forward auxiliary input-to-cell weights. Optional. See the docs above for the usage modes explanation. A 2-D tensor of shape [fw_num_units, aux_input_size].
• 43: The forward auxiliary input-to-output weights. Optional. See the docs above for the usage modes explanation. A 2-D tensor of shape [fw_num_units, aux_input_size].
• 44: The backward auxiliary input-to-input weights. Optional. See the docs above for the usage modes explanation. A 2-D tensor of shape [bw_num_units, aux_input_size].
• 45: The backward auxiliary input-to-forget weights. Optional. See the docs above for the usage modes explanation. A 2-D tensor of shape [bw_num_units, aux_input_size].
• 46: The backward auxiliary input-to-cell weights. Optional. See the docs above for the usage modes explanation. A 2-D tensor of shape [bw_num_units, aux_input_size].
• 47: The backward auxiliary input-to-output weights. Optional. See the docs above for the usage modes explanation. A 2-D tensor of shape [bw_num_units, aux_input_size].
• 48: The activation function. A value indicating the activation function:
  • 0: None;
  • 1: Relu;
  • 3: Relu6;
  • 4: Tanh;
  • 6: Sigmoid.
• 49: The clipping threshold for the cell state, such that values are bound within [-cell_clip, cell_clip]. If set to 0.0 then clipping is disabled. If all the input tensors have type ANEURALNETWORKS_TENSOR_FLOAT32, this scalar must be of the type ANEURALNETWORKS_FLOAT32, otherwise if all the input tensors have the type ANEURALNETWORKS_TENSOR_FLOAT16, this scalar must be of type ANEURALNETWORKS_FLOAT16.
• 50: The clipping threshold for the output from the projection layer, such that values are bound within [-proj_clip, proj_clip]. If set to 0.0 then clipping is disabled. If all the input tensors have type ANEURALNETWORKS_TENSOR_FLOAT32, this scalar must be of the type ANEURALNETWORKS_FLOAT32, otherwise if all the input tensors have the type ANEURALNETWORKS_TENSOR_FLOAT16, this scalar must be of type ANEURALNETWORKS_FLOAT16.
• 51: merge_outputs An ANEURALNETWORKS_BOOL scalar specifying if the outputs from forward and backward cells should be merged.
• 52: time_major An ANEURALNETWORKS_BOOL scalar specifying the shape format of input and output tensors.
• 53: The forward input layer normalization weights. Optional. A 1-D tensor of shape [fw_num_units]. Used to rescale normalized inputs to activation at input gate.
• 54: The forward forget layer normalization weights. Optional. A 1-D tensor of shape [fw_num_units]. Used to rescale normalized inputs to activation at forget gate.
• 55: The forward cell layer normalization weights. Optional. A 1-D tensor of shape [fw_num_units]. Used to rescale normalized inputs to activation at cell gate.
• 56: The forward output layer normalization weights. Optional. A 1-D tensor of shape [fw_num_units]. Used to rescale normalized inputs to activation at output gate.
• 57: The backward input layer normalization weights. Optional. A 1-D tensor of shape [bw_num_units]. Used to rescale normalized inputs to activation at input gate.
• 58: The backward forget layer normalization weights. Optional. A 1-D tensor of shape [bw_num_units]. Used to rescale normalized inputs to activation at forget gate.
• 59: The backward cell layer normalization weights. Optional. A 1-D tensor of shape [bw_num_units]. Used to rescale normalized inputs to activation at cell gate.
• 60: The backward output layer normalization weights. Optional. A 1-D tensor of shape [bw_num_units]. Used to rescale normalized inputs to activation at output gate.

Outputs:

• 0: The forward output. A 3-D tensor of shape: If time-major and not merge_outputs: [max_time, batch_size, fw_output_size] If time-major and merge_outputs: [max_time, batch_size, fw_output_size + bw_output_size] If batch-major and not merge_outputs: [batch_size, max_time, fw_output_size] If batch-major and merge_outputs: [batch_size, max_time, fw_output_size + bw_output_size]
• 1: The backward output. Unused if merge_outputs is true. A 3-D tensor of shape: If time-major: [max_time, batch_size, bw_output_size] If batch-major: [batch_size, max_time, bw_output_size]
• 2: The forward activation state output. A 2-D tensor of shape [batch_size, fw_output_size] containing an activation state from the last time step in the sequence. This output is optional and can be omitted. If this output is present then outputs 3-5 must be present as well. Available since NNAPI feature level 4.
• 3: The forward cell state output. A tensor of shape [batch_size, fw_cell_size] containing a cell state from the last time step in the sequence. This output is optional and can be omitted. If this output is present then outputs 2, 4, 5 must be present as well. Available since NNAPI feature level 4.
• 4: The backward activation state output. A 2-D tensor of shape [batch_size, bw_output_size] containing an activation state from the last time step in the sequence. This output is optional and can be omitted. If this output is present then outputs 2, 3, 5 must be present as well. Available since NNAPI feature level 4.
• 5: The backward cell state output. A tensor of shape [batch_size, bw_cell_size] containing a cell state from the last time step in the sequence. This output is optional and can be omitted. If this output is present then outputs 2-4 must be present as well. Available since NNAPI feature level 4.

Available since NNAPI feature level 3.

Important: As of NNAPI feature level 3, there is no way to get the output state tensors out and NNAPI does not maintain internal states. This operator does not support the usage pattern in which multiple cells are chained and state tensors are propagated.

A recurrent neural network layer that applies a basic RNN cell to a sequence of inputs in forward and backward directions.

This Op unrolls the input along the sequence dimension, and implements the following operation for each element in the sequence s = 1...sequence_length: fw_outputs[s] = fw_state = activation(inputs[s] * fw_input_weights’ + fw_state * fw_recurrent_weights’ + fw_bias)

And for each element in sequence t = sequence_length : 1 bw_outputs[t] = bw_state = activation(inputs[t] * bw_input_weights’ + bw_state * bw_recurrent_weights’ + bw_bias)

Where:

• “{fw,bw}_input_weights” is a weight matrix that multiplies the inputs;
• “{fw,bw}_recurrent_weights” is a weight matrix that multiplies the current “state” which itself is the output from the previous time step computation;
• “{fw,bw}_bias” is a bias vector (added to each output vector in the batch);
• “activation” is the function passed as the “fused_activation_function” argument (if not “NONE”).

The op supports cross-linking via an auxiliary input. Regular cell feeds one input into the two RNN cells in the following way:

  INPUT  (INPUT_REVERSED)
    |         |

| FW_RNN BW_RNN |

| | FW_OUT BW_OUT

An op with cross-linking takes two inputs and feeds them into the RNN cells in the following way:

  AUX_INPUT   (AUX_INPUT_REVERSED)
      |             |
INPUT | (INPUT_R'D.)|
  |   |       |     |

| FW_RNN BW_RNN |

| | FW_OUT BW_OUT

The cross-linking mode is enabled iff auxiliary input and auxiliary weights are present. While stacking this op on top of itself, this allows to connect both forward and backward outputs from previous cell to the next cell's input.

Since NNAPI feature level 4 parallel linking mode is supported. The mode is enabled if auxiliary input is present but auxiliary weights are omitted. In this case, the cell feeds inputs into the RNN in the following way:

  INPUT (AUX_INPUT_REVERSED)
    |         |

| FW_RNN BW_RNN |

| | FW_OUT BW_OUT

While stacking this op on top of itself, this allows to connect both forward and backward outputs from previous cell to the next cell's corresponding inputs.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32

The input tensors must all be the same type.

Inputs:

• 0: input. A 3-D tensor. The shape is defined by the input 6 (timeMajor). If it is set to true, then the input has a shape [maxTime, batchSize, inputSize], otherwise the input has a shape [batchSize, maxTime, inputSize].
• 1: fwWeights. A 2-D tensor of shape [fwNumUnits, inputSize].
• 2: fwRecurrentWeights. A 2-D tensor of shape [fwNumUnits, fwNumUnits].
• 3: fwBias. A 1-D tensor of shape [fwNumUnits].
• 4: fwHiddenState. A 2-D tensor of shape [batchSize, fwNumUnits]. Specifies a hidden state input for the first time step of the computation.
• 5: bwWeights. A 2-D tensor of shape [bwNumUnits, inputSize].
• 6: bwRecurrentWeights. A 2-D tensor of shape [bwNumUnits, bwNumUnits].
• 7: bwBias. A 1-D tensor of shape [bwNumUnits].
• 8: bwHiddenState A 2-D tensor of shape [batchSize, bwNumUnits]. Specifies a hidden state input for the first time step of the computation.
• 9: auxInput. A 3-D tensor. The shape is defined by the input 6 (timeMajor). If it is set to true, then the input has a shape [maxTime, batchSize, auxInputSize], otherwise the input has a shape [batchSize, maxTime, auxInputSize]. Can be omitted. See the docs above for the usage modes explanation.
• 10:fwAuxWeights. A 2-D tensor of shape [fwNumUnits, auxInputSize]. Can be omitted. See the docs above for the usage modes explanation.
• 11:bwAuxWeights. A 2-D tensor of shape [bwNumUnits, auxInputSize]. Can be omitted. See the docs above for the usage modes explanation.
• 12:fusedActivationFunction. A FuseCode value indicating the activation function. If “NONE” is specified then it results in a linear activation.
• 13:timeMajor An ANEURALNETWORKS_BOOL scalar specifying the shape format of input and output tensors.
• 14:mergeOutputs An ANEURALNETWORKS_BOOL scalar specifying if the outputs from forward and backward cells are separate (if set to false) or concatenated (if set to true). Outputs:
• 0: fwOutput. A 3-D tensor. The first two dimensions of the shape are defined by the input 6 (timeMajor) and the third dimension is defined by the input 14 (mergeOutputs). If timeMajor is set to true, then the first two dimensions are [maxTime, batchSize], otherwise they are set to [batchSize, maxTime]. If mergeOutputs is set to true, then the third dimension is equal to (fwNumUnits + bwNumUnits), otherwise it is set to fwNumUnits.
• 1: bwOutput. A 3-D tensor. If the input 14 (mergeOutputs) is set to true, then this tensor is not produced. The shape is defined by the input 6 (timeMajor). If it is set to true, then the shape is set to [maxTime, batchSize, bwNumUnits], otherwise the shape is set to [batchSize, maxTime, bwNumUnits].
• 2: The forward hidden state output. A 2-D tensor of shape [batchSize, fwNumUnits] containing a hidden state from the last time step in the sequence. This output is optional and can be omitted. If this output is present then output 3 must be present as well. Available since NNAPI feature level 4.
• 3: The backward hidden state output. A 2-D tensor of shape [batchSize, bwNumUnits] containing a hidden state from the last time step in the sequence. This output is optional and can be omitted. If this output is present then output 2 must be present as well. Available since NNAPI feature level 4.

Available since NNAPI feature level 3.

Important: As of NNAPI feature level 3, there is no way to get the output state tensors out and NNAPI does not maintain internal states. This operator does not support the usage pattern in which multiple cells are chained and state tensors are propagated.

Greedily selects a subset of bounding boxes in descending order of score.

This op applies NMS algorithm to each class. In each loop of execution, the box with maximum score gets selected and removed from the pending set. The scores of the rest of boxes are lowered according to the intersection-over-union (IOU) overlapping with the previously selected boxes and a specified NMS kernel method. Any boxes with score less than a threshold are removed from the pending set.

Three NMS kernels are supported:

• Hard: score_new = score_old * (1 if IoU < threshold else 0)
• Linear: score_new = score_old * (1 if IoU < threshold else 1 - IoU)
• Gaussian: score_new = score_old * exp(- IoU^2 / sigma)

Axis-aligned bounding boxes are represented by its upper-left corner coordinate (x1,y1) and lower-right corner coordinate (x2,y2). A valid bounding box should satisfy x1 <= x2 and y1 <= y2.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Inputs:

• 0: A 2-D Tensor of shape [num_rois, num_classes], specifying the score of each bounding box proposal. The boxes are grouped by batches in the first dimension. Zero num_rois is supported for this tensor.
• 1: A 2-D Tensor specifying the bounding boxes of shape [num_rois, num_classes * 4], organized in the order [x1, y1, x2, y2]. The boxes are grouped by batches in the first dimension. The sequential order of the boxes corresponds with input0. For input0 of type ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, this tensor should be of ANEURALNETWORKS_TENSOR_QUANT16_ASYMM, with zeroPoint of 0 and scale of 0.125. For input0 of type ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED, this tensor should be of ANEURALNETWORKS_TENSOR_QUANT16_ASYMM, with zeroPoint of -128 and scale of 0.125. Zero num_rois is supported for this tensor.
• 2: A 1-D ANEURALNETWORKS_TENSOR_INT32 tensor, of shape [num_rois], specifying the batch index of each box. Boxes with the same batch index are grouped together.
• 3: An ANEURALNETWORKS_FLOAT32 scalar, score_threshold. Boxes with scores lower than the threshold are filtered before sending to the NMS algorithm.
• 4: An ANEURALNETWORKS_INT32 scalar, specifying the maximum number of selected bounding boxes for each image. Set to a negative value for unlimited number of output bounding boxes.
• 5: An ANEURALNETWORKS_INT32 scalar, specifying the NMS kernel method, options are 0:hard, 1:linear, 2:gaussian.
• 6: An ANEURALNETWORKS_FLOAT32 scalar, specifying the IoU threshold in hard and linear NMS kernel. This field is ignored if gaussian kernel is selected.
• 7: An ANEURALNETWORKS_FLOAT32 scalar, specifying the sigma in gaussian NMS kernel. This field is ignored if gaussian kernel is not selected.
• 8: An ANEURALNETWORKS_FLOAT32 scalar, nms_score_threshold. Boxes with scores lower than the threshold are dropped during the score updating phase in soft NMS.

Outputs:

• 0: A 1-D Tensor of the same OperandCode as input0, with shape [num_output_rois], specifying the score of each output box. The boxes are grouped by batches, but the sequential order in each batch is not guaranteed. For type of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, guaranteed. For type of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM or ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED, the scale and zero point must be the same as input0.
• 1: A 2-D Tensor of the same OperandCode as input1, with shape [num_output_rois, 4], specifying the coordinates of each output bounding box with the same format as input1. The sequential order of the boxes corresponds with output0. For type of ANEURALNETWORKS_TENSOR_QUANT16_ASYMM, the scale must be 0.125 and the zero point must be 0.
• 2: A 1-D ANEURALNETWORKS_TENSOR_INT32 tensor, of shape [num_output_rois], specifying the class of each output box. The sequential order of the boxes corresponds with output0.
• 3: A 1-D ANEURALNETWORKS_TENSOR_INT32 tensor, of shape [num_output_rois], specifying the batch index of each box. Boxes with the same batch index are grouped together.

Available since NNAPI feature level 3.

Casts a tensor to a type.

This operation ignores the scale and zeroPoint of quanized tensors, e.g. it treats a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM input as a tensor of uint8 values.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_INT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM Since NNAPI feature level 4, casting tensors of the following OperandCode to the same OperandCode is supported:
• ANEURALNETWORKS_TENSOR_BOOL8
• ANEURALNETWORKS_TENSOR_INT32
• ANEURALNETWORKS_TENSOR_QUANT16_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT16_SYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED
• ANEURALNETWORKS_TENSOR_QUANT8_SYMM

Supported tensor rank: from 1

Inputs:

• 0: A tensor.

Outputs:

• 0: A tensor with the same shape as input0.

Available since NNAPI feature level 3.

Shuffle the channels of the input tensor.

Given an input tensor and a integer value of num_groups, CHANNEL_SHUFFLE divide the channel dimension into num_groups groups, and reorganize the channels by grouping channels with the same index in each group.

Along the channel dimension, the output is calculated using this formula:

output_channel[k * num_groups + g] = input_channel[g * group_size + k]

where group_size = num_channels / num_groups

The number of channels must be divisible by num_groups.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported tensor rank: up to 4

Inputs:

• 0: An n-D tensor, specifying the tensor to be shuffled.
• 1: An ANEURALNETWORKS_INT32 scalar, specifying the number of groups.
• 2: An ANEURALNETWORKS_INT32 scalar, specifying the dimension channel shuffle would be performed on. Negative index is used to specify axis from the end (e.g. -1 for the last axis). Must be in the range [-n, n).

Outputs:

• 0: A tensor of the same OperandCode and same shape as input0. For a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED tensor, the scale and zeroPoint must be the same as input0.

Available since NNAPI feature level 3.

Concatenates the input tensors along the given dimension.

The input tensors must have identical OperandCode and the same dimensions except the dimension along the concatenation axis.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16 (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM (full support since NNAPI feature level 3, see the input section)
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported tensor rank: up to 4

Inputs:

• 0 ~ n-1: The list of n input tensors, of shape [D0, D1, ..., Daxis(i), ..., Dm]. Before NNAPI feature level 3, all input tensors of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM must have the same scale and zeroPoint as the output tensor. Input tensors of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED are allowed to have different scale and zeroPoint. Since NNAPI feature level 3, zero-sized tensors are supported.
• n: An ANEURALNETWORKS_INT32 scalar, specifying the concatenation axis.

Outputs:

• 0: The output, a tensor of the same OperandCode as the input tensors. The output shape is [D0, D1, ..., sum(Daxis(i)), ..., Dm]. Since NNAPI feature level 3, for a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM tensor, the scale and zeroPoint values can be different from input tensors. Before NNAPI feature level 3 they have to be the same as for the input tensors.

Available since NNAPI feature level 1.

Performs a 2-D convolution operation.

The CONV_2D op sweeps a 2-D filter that can mix channels together over a batch of images, applying the filter to each window of each image of the appropriate size.

The output dimensions are functions of the filter dimensions, stride, and padding.

The values in the output tensor are computed as:

output[b, i, j, channel] =
    sum_{di, dj, k} (
        input[b, strides[1] * i + di, strides[2] * j + dj, k] *
        filter[channel, di, dj, k]
    ) + bias[channel]

Supported tensor OperandCode configurations:

• 32 bit floating point:
• * ANEURALNETWORKS_TENSOR_FLOAT32 for input, filter, output, and bias.
• Quantized:
• * ANEURALNETWORKS_TENSOR_QUANT8_ASYMM for input, filter, and output.
• * ANEURALNETWORKS_TENSOR_INT32 for bias (with scale set to
• * input.scale * filter.scale).

Available since NNAPI feature level 3:

• 16 bit floating point:
• * ANEURALNETWORKS_TENSOR_FLOAT16 for input, filter, output, and bias.
• Quantized with symmetric per channel quantization for the filter:
• * ANEURALNETWORKS_TENSOR_QUANT8_ASYMM for input, and output.
• * ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL for filter.
• * ANEURALNETWORKS_TENSOR_INT32 for bias (scale set to 0.0,
• * each value scaling is separate and equal to input.scale * filter.scales[channel]).

Available since NNAPI feature level 4:

• Quantized signed (since NNAPI feature level 4):
• * ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED for input, filter, and output.
• * ANEURALNETWORKS_TENSOR_INT32 for bias (with scale set to
• * input.scale * filter.scale).
• Quantized signed with filter symmetric per channel quantization (since NNAPI feature level 4):
• * ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED for input, and output.
• * ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL for filter.
• * ANEURALNETWORKS_TENSOR_INT32 for bias (scale set to 0.0,
• * each value scaling is separate and equal to input.scale * filter.scales[channel]).

Supported tensor rank: 4, with "NHWC" or "NCHW" data layout. With the default data layout NHWC, the data is stored in the order of: [batch, height, width, channels]. Alternatively, the data layout could be NCHW, the data storage order of: [batch, channels, height, width]. NCHW is supported since NNAPI feature level 3.

Both explicit padding and implicit padding are supported.

Inputs (explicit padding):

• 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input. Since NNAPI feature level 3, zero batches is supported for this tensor.
• 1: A 4-D tensor, of shape [depth_out, filter_height, filter_width, depth_in], specifying the filter. For tensor of type ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL the channel dimension (ANeuralNetworksSymmPerChannelQuantParams::channelDim) must be set to 0.
• 2: A 1-D tensor, of shape [depth_out], specifying the bias. For input tensor of type ANEURALNETWORKS_TENSOR_FLOAT32 or ANEURALNETWORKS_TENSOR_FLOAT16 the bias must be of the same type. For filter tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale == input_scale * filter_scale. For filter tensor of ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale of 0. The actual scale of each value 'i' is equal to bias_scale[i] = input_scale * filter_scale[i].
• 3: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the left, in the ‘width’ dimension.
• 4: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the right, in the ‘width’ dimension.
• 5: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the top, in the ‘height’ dimension.
• 6: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the bottom, in the ‘height’ dimension.
• 7: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘width’ dimension.
• 8: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘height’ dimension.
• 9: An ANEURALNETWORKS_INT32 scalar, and has to be one of the FuseCode values. Specifies the activation to invoke on the result.
• 10: An optional ANEURALNETWORKS_BOOL scalar, default to false. Set to true to specify NCHW data layout for input0 and output0. Available since NNAPI feature level 3.
• 11: An optional ANEURALNETWORKS_INT32 scalar, specifying the dilation factor for width. Defaults to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on width dimension. If this input is set, input 12 (dilation factor for height) must be specified as well. Available since NNAPI feature level 3.
• 12: An optional ANEURALNETWORKS_INT32 scalar, specifying the dilation factor for height. Defaults to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on height dimension. If this input is set, input 11 (dilation factor for width) must be specified as well. Available since NNAPI feature level 3.

Inputs (implicit padding):

• 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input. Since NNAPI feature level 3, zero batches is supported for this tensor.
• 1: A 4-D tensor, of shape [depth_out, filter_height, filter_width, depth_in], specifying the filter. For tensor of type ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL the channel dimension (ANeuralNetworksSymmPerChannelQuantParams::channelDim) must be set to 0.
• 2: A 1-D tensor, of shape [depth_out], specifying the bias. For input tensor of type ANEURALNETWORKS_TENSOR_FLOAT32 or ANEURALNETWORKS_TENSOR_FLOAT16 the bias must be of the same type. For filter tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale == input_scale * filter_scale. For filter tensor of ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale of 0. The actual scale of each value 'i' is equal to bias_scale[i] = input_scale * filter_scale[i].
• 3: An ANEURALNETWORKS_INT32 scalar, specifying the implicit padding scheme, has to be one of the PaddingCode values.
• 4: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘width’ dimension.
• 5: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘height’ dimension.
• 6: An ANEURALNETWORKS_INT32 scalar, and has to be one of the FuseCode values. Specifies the activation to invoke on the result.
• 7: An optional ANEURALNETWORKS_BOOL scalar, default to false. Set to true to specify NCHW data layout for input0 and output0. Available since NNAPI feature level 3.
• 8: An optional ANEURALNETWORKS_INT32 scalar, specifying the dilation factor for width. Defaults to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on width dimension. If this input is set, input 9 (dilation factor for height) must be specified as well. Available since NNAPI feature level 3.
• 9: An optional ANEURALNETWORKS_INT32 scalar, specifying the dilation factor for height. Defaults to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on height dimension. If this input is set, input 8 (dilation factor for width) must be specified as well. Available since NNAPI feature level 3.

Outputs:

• 0: The output 4-D tensor, of shape [batches, out_height, out_width, depth_out]. Before NNAPI feature level 3, for output tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, the following condition must be satisfied: output_scale > input_scale * filter_scale

Available since NNAPI feature level 1.

Performs a depthwise 2-D convolution operation.

Given an input tensor of shape [batches, height, width, depth_in] and a filter tensor of shape [1, filter_height, filter_width, depth_out] containing depth_out convolutional filters of depth 1, DEPTHWISE_CONV applies a different filter to each input channel (expanding from 1 channel to channel_multiplier channels for each), then concatenates the results together.

The output has depth_out = depth_in * depth_multiplier channels. The output dimensions are functions of the filter dimensions, stride, and padding.

The values in the output tensor are computed as:

output[b, i, j, k * channel_multiplier + q] =
    sum_{di, dj} (
        input[b, strides[1] * i + di, strides[2] * j + dj, k] *
        filter[1, di, dj, k * channel_multiplier + q]
    ) + bias[k * channel_multiplier + q]

Supported tensor OperandCode configurations:

• 32 bit floating point:
• * ANEURALNETWORKS_TENSOR_FLOAT32 for input, filter, output, and bias.
• Quantized:
• * ANEURALNETWORKS_TENSOR_QUANT8_ASYMM for input, filter, and output.
• * ANEURALNETWORKS_TENSOR_INT32 for bias (with scale set to
• * input.scale * filter.scale).

Available since NNAPI feature level 3:

• 16 bit floating point:
• * ANEURALNETWORKS_TENSOR_FLOAT16 for input, filter, output, and bias.
• Quantized with symmetric per channel quantization for the filter:
• * ANEURALNETWORKS_TENSOR_QUANT8_ASYMM for input, and output.
• * ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL for filter.
• * ANEURALNETWORKS_TENSOR_INT32 for bias (scale set to 0.0,
• * each value scaling is separate and equal to input.scale * filter.scales[channel]).

Available since NNAPI feature level 4:

• Quantized signed (since NNAPI feature level 4):
• * ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED for input, filter, and output.
• * ANEURALNETWORKS_TENSOR_INT32 for bias (with scale set to
• * input.scale * filter.scale).
• Quantized signed with filter symmetric per channel quantization (since NNAPI feature level 4):
• * ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED for input, and output.
• * ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL for filter.
• * ANEURALNETWORKS_TENSOR_INT32 for bias (scale set to 0.0,
• * each value scaling is separate and equal to input.scale * filter.scales[channel]).

Supported tensor rank: 4, with "NHWC" or "NCHW" data layout. With the default data layout NHWC, the data is stored in the order of: [batch, height, width, channels]. Alternatively, the data layout could be NCHW, the data storage order of: [batch, channels, height, width]. NCHW is supported since NNAPI feature level 3.

Both explicit padding and implicit padding are supported.

Inputs (explicit padding):

• 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input.
• 1: A 4-D tensor, of shape [1, filter_height, filter_width, depth_out], specifying the filter. For tensor of type ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL the channel dimension (ANeuralNetworksSymmPerChannelQuantParams::channelDim) must be set to 3.
• 2: A 1-D tensor, of shape [depth_out], specifying the bias. For input tensor of type ANEURALNETWORKS_TENSOR_FLOAT32 or ANEURALNETWORKS_TENSOR_FLOAT16 the bias must be of the same type. For filter tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale == input_scale * filter_scale. For filter tensor of ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale of 0. The actual scale of each value 'i' is equal to bias_scale[i] = input_scale * filter_scale[i].
• 3: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the left, in the ‘width’ dimension.
• 4: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the right, in the ‘width’ dimension.
• 5: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the top, in the ‘height’ dimension.
• 6: An ANEURALNETWORKS_INT32 scalar, specifying the padding on the bottom, in the ‘height’ dimension.
• 7: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘width’ dimension.
• 8: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘height’ dimension.
• 9: An ANEURALNETWORKS_INT32 scalar, specifying the depthwise multiplier.
• 10: An ANEURALNETWORKS_INT32 scalar, and has to be one of the FuseCode values. Specifies the activation to invoke on the result.
• 11: An optional ANEURALNETWORKS_BOOL scalar, default to false. Set to true to specify NCHW data layout for input0 and output0. Available since NNAPI feature level 3.
• 12: An optional ANEURALNETWORKS_INT32 scalar, specifying the dilation factor for width. Defaults to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on width dimension. If this input is set, input 13 (dilation factor for height) must be specified as well. Available since NNAPI feature level 3.
• 13: An optional ANEURALNETWORKS_INT32 scalar, specifying the dilation factor for height. Defaults to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on height dimension. If this input is set, input 12 (dilation factor for width) must be specified as well. Available since NNAPI feature level 3.

Inputs (implicit padding):

• 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input.
• 1: A 4-D tensor, of shape [1, filter_height, filter_width, depth_out], specifying the filter.
• 2: A 1-D tensor, of shape [depth_out], specifying the bias. For input tensor of type ANEURALNETWORKS_TENSOR_FLOAT32 or ANEURALNETWORKS_TENSOR_FLOAT16 the bias must be of the same type. For filter tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale == input_scale * filter_scale. For filter tensor of ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale of 0. The actual scale of each value 'i' is equal to bias_scale[i] = input_scale * filter_scale[i].
• 3: An ANEURALNETWORKS_INT32 scalar, specifying the implicit padding scheme, has to be one of the PaddingCode values.
• 4: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘width’ dimension.
• 5: An ANEURALNETWORKS_INT32 scalar, specifying the stride when walking through input in the ‘height’ dimension.
• 6: An ANEURALNETWORKS_INT32 scalar, specifying the depthwise multiplier.
• 7: An ANEURALNETWORKS_INT32 scalar, and has to be one of the FuseCode values. Specifies the activation to invoke on the result.
• 8: An optional ANEURALNETWORKS_BOOL scalar, default to false. Set to true to specify NCHW data layout for input0 and output0. Available since NNAPI feature level 3.
• 9: An optional ANEURALNETWORKS_INT32 scalar, specifying the dilation factor for width. Defaults to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on width dimension. If this input is set, input 10 (dilation factor for height) must be specified as well. Available since NNAPI feature level 3.
• 10: An optional ANEURALNETWORKS_INT32 scalar, specifying the dilation factor for height. Defaults to 1. If set to k > 1, there will be k-1 skipped cells between each filter element on height dimension. If this input is set, input 9 (dilation factor for width) must be specified as well. Available since NNAPI feature level 3.

Outputs:

• 0: The output 4-D tensor, of shape [batches, out_height, out_width, depth_out]. Before NNAPI feature level 3, for output tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, the following condition must be satisfied: output_scale > input_scale * filter_scale

Available since NNAPI feature level 1.

Rearranges data from depth into blocks of spatial data.

More specifically, this op outputs a copy of the input tensor where values from the depth dimension are moved in spatial blocks to the height and width dimensions. The value block_size indicates the input block size and how the data is moved.

Chunks of data of size block_size * block_size from depth are rearranged into non-overlapping blocks of size block_size x block_size.

The width of the output tensor is input_depth * block_size, whereas the height is input_height * block_size. The depth of the input tensor must be divisible by block_size * block_size

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16 (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported tensor rank: 4, with "NHWC" or "NCHW" data layout. With the default data layout NHWC, the data is stored in the order of: [batch, height, width, channels]. Alternatively, the data layout could be NCHW, the data storage order of: [batch, channels, height, width]. NCHW is supported since NNAPI feature level 3.

Inputs:

• 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input.
• 1: An ANEURALNETWORKS_INT32 scalar, specifying the block_size. block_size must be >=1 and block_size * block_size must be a divisor of the input depth.
• 2: An optional ANEURALNETWORKS_BOOL scalar, default to false. Set to true to specify NCHW data layout for input0 and output0. Available since NNAPI feature level 3.

Outputs:

• 0: The output 4-D tensor, of shape [batch, height*block_size, width*block_size, depth/(block_size*block_size)]. For a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED tensor, the scale and zeroPoint must be the same as input0.

Available since NNAPI feature level 1.

Dequantizes the input tensor.

The formula is:

output = (input - zeroPoint) * scale.

Supported input tensor OperandCode:

• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_SYMM (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported output tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16 (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_FLOAT32.

Supported tensor rank: up to 4

Inputs:

• 0: A tensor. Since NNAPI feature level 3, this tensor may be zero-sized.

Outputs:

• 0: A tensor with the same shape as input0.

Available since NNAPI feature level 1.

Apply postprocessing steps to bounding box detections.

Bounding box detections are generated by applying transformation on a set of predefined anchors with the bounding box deltas from bounding box regression. A final step of hard NMS is applied to limit the number of returned boxes.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32

Inputs:

• 0: A 3-D Tensor of shape [batches, num_anchors, num_classes], specifying the score of each anchor with each class. Class 0 for each [batches, num_anchors, 0] is background and will be ignored.
• 1: A 3-D Tensor of shape [batches, num_anchors, length_box_encoding], with the first four values in length_box_encoding specifying the bounding box deltas. The box deltas are encoded in the order of [dy, dx, dh, dw], where dy and dx is the linear-scale relative correction factor for the center position of the bounding box with respect to the width and height, dh and dw is the log-scale relative correction factor for the width and height. All the entries in length_box_encoding beyond the first four values are ignored in this operation.
• 2: A 2-D Tensor of shape [num_anchors, 4], specifying the shape of each predefined anchor, with format [ctr_y, ctr_x, h, w], where ctr_y and ctr_x are the center position of the box, and h and w are the height and the width.
• 3: An ANEURALNETWORKS_FLOAT32 scalar, specifying the scaling factor for dy in bounding box deltas.
• 4: An ANEURALNETWORKS_FLOAT32 scalar, specifying the scaling factor for dx in bounding box deltas.
• 5: An ANEURALNETWORKS_FLOAT32 scalar, specifying the scaling factor for dh in bounding box deltas.
• 6: An ANEURALNETWORKS_FLOAT32 scalar, specifying the scaling factor for dw in bounding box deltas.
• 7: An ANEURALNETWORKS_BOOL scalar, set to true to use regular multi-class NMS algorithm that do NMS separately for each class, set to false for a faster algorithm that only do one single NMS using the highest class score..
• 8: An ANEURALNETWORKS_INT32 scalar, max_num_detections, specifying the maximum number of boxes for the output. Boxes with the lowest scores are discarded to meet the limit.
• 9: An ANEURALNETWORKS_INT32 scalar, only used when input7 is set to false, specifying the maximum number of classes per detection.
• 10: An ANEURALNETWORKS_INT32 scalar, only used when input7 is set to true, specifying the maximum number of detections when applying NMS algorithm for each single class.
• 11: A scalar, score_threshold. Boxes with scores lower than the threshold are filtered before sending to the NMS algorithm. The scalar must be of ANEURALNETWORKS_FLOAT16 if input0 is of ANEURALNETWORKS_TENSOR_FLOAT16 and of ANEURALNETWORKS_FLOAT32 if input0 is of ANEURALNETWORKS_TENSOR_FLOAT32.
• 12: A scalar, specifying the IoU threshold for hard NMS. The scalar must be of ANEURALNETWORKS_FLOAT16 if input0 is of ANEURALNETWORKS_TENSOR_FLOAT16 and of ANEURALNETWORKS_FLOAT32 if input0 is of ANEURALNETWORKS_TENSOR_FLOAT32.
• 13: An ANEURALNETWORKS_BOOL scalar, set to true to include background class in the list of label map for the output, set to false to not include the background. When the background class is included, it has label 0 and the output classes start at 1 in the label map, otherwise, the output classes start at 0.

Outputs:

• 0: A 2-D tensor of the same OperandCode as input0, with shape [batches, max_num_detections], specifying the score of each output detections.
• 1: A 3-D tensor of shape [batches, max_num_detections, 4], specifying the coordinates of each output bounding box, with format [y1, x1, y2, x2].
• 2: A 2-D ANEURALNETWORKS_TENSOR_INT32 tensor, of shape [batches, max_num_detections], specifying the class label for each output detection.
• 3: An 1-D ANEURALNETWORKS_TENSOR_INT32 tensor, of shape [batches], specifying the number of valid output detections for each batch.

Available since NNAPI feature level 3.

Element-wise division of two tensors.

Takes two input tensors of identical OperandCode and compatible dimensions. The output is the result of dividing the first input tensor by the second, optionally modified by an activation function.

For inputs of ANEURALNETWORKS_TENSOR_INT32, performs "floor division" ("//" in Python). For example, 5 // 2 = 2 -5 // 2 = -3

Two dimensions are compatible when:

1. they are equal, or
2. one of them is 1

The size of the output is the maximum size along each dimension of the input operands. It starts with the trailing dimensions, and works its way forward.

Example: input1.dimension = {4, 1, 2} input2.dimension = {5, 4, 3, 1} output.dimension = {5, 4, 3, 2}

Since NNAPI feature level 3, generic zero-sized input tensor is supported. Zero dimension is only compatible with 0 or 1. The size of the output dimension is zero if either of corresponding input dimension is zero.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16 (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_INT32 (since NNAPI feature level 4)

Supported tensor rank: up to 4

Inputs:

• 0: An n-D tensor, specifying the first input.
• 1: A tensor of the same OperandCode, and compatible dimensions as input0.
• 2: An ANEURALNETWORKS_INT32 scalar, and has to be one of the FuseCode values. Specifies the activation to invoke on the result. For a ANEURALNETWORKS_TENSOR_INT32 tensor, the FuseCode must be "NONE".

Outputs:

• 0: A tensor of the same OperandCode as input0.

Available since NNAPI feature level 2.

Computes exponential linear activation on the input tensor element-wise.

The output is calculated using the following formula:

ELU(x) = max(0, x) + min(0, alpha * (exp(x) - 1))

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32

Supported tensor rank: from 1.

Inputs:

• 0: A tensor, specifying the input. May be zero-sized.
• 1: A scalar, specifying the alpha parameter. For input tensor of ANEURALNETWORKS_TENSOR_FLOAT16, the alpha value must be of ANEURALNETWORKS_FLOAT16. For input tensor of ANEURALNETWORKS_TENSOR_FLOAT32, the alpha value must be of ANEURALNETWORKS_FLOAT32.

Outputs:

• 0: The output tensor of same shape and type as input0.

Available since NNAPI feature level 4.

Looks up sub-tensors in the input tensor.

This operator takes for input a tensor of values (Values) and a one-dimensional tensor of selection indices (Lookups). The output tensor is the concatenation of sub-tensors of Values as selected by Lookups.

Think of Values as being sliced along its first dimension: The entries in Lookups select which slices are concatenated together to create the output tensor.

For example, if Values has shape of [40, 200, 300] and Lookups has shape of [3], all three values found in Lookups are expected to be between 0 and 39. The resulting tensor must have shape of [3, 200, 300].

If a value in Lookups is out of bounds, the operation must fail and an error must be reported.

Supported value tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16 (since NNAPI feature level 4)
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_INT32 (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM (since NNAPI feature level 3)
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported value tensor rank: from 2

Inputs:

• 0: Lookups. A 1-D tensor of ANEURALNETWORKS_TENSOR_INT32. The values are indices into the first dimension of Values.
• 1: Values. An n-D tensor, where n >= 2, from which sub-tensors are extracted.

Output:

• 0: A n-D tensor with the same rank and shape as the Values tensor, except for the first dimension which has the same size as Lookups' only dimension. For a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED tensor, the scale and zeroPoint must be the same as input1.

Available since NNAPI feature level 1.

For input tensors x and y, computes x == y elementwise.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_BOOL8
• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_INT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported tensor rank: from 1

This operation supports broadcasting.

Inputs:

• 0: A tensor.
• 1: A tensor of the same OperandCode and dimensions compatible with input0.

Outputs:

• 0: A tensor of ANEURALNETWORKS_TENSOR_BOOL8.

Available since NNAPI feature level 3.

Computes exponential of x element-wise.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32

Supported tensor rank: from 1.

Inputs:

• 0: A tensor.

Outputs:

• 0: The output tensor of same shape as input0.

Available since NNAPI feature level 3.

Inserts a dimension of 1 into a tensor's shape.

Given a tensor input, this operation inserts a dimension of 1 at the given dimension index of input's shape. The dimension index starts at zero; if you specify a negative dimension index, it is counted backward from the end.

Supported tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_INT32
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
• ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED (since NNAPI feature level 4)

Supported tensor rank: from 1

Inputs:

• 0: An n-D tensor.
• 1: An ANEURALNETWORKS_INT32 scalar specifying the dimension index to expand. Must be in the range [-(n + 1), (n + 1)).

Outputs:

• 0: An (n + 1)-D tensor with the same OperandCode and data as input0. For a ANEURALNETWORKS_TENSOR_QUANT8_ASYMM and ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED tensor, the scale and zeroPoint must be the same as input0.

Available since NNAPI feature level 3.

Creates a tensor filled with a scalar value.

Supported output tensor OperandCode:

• ANEURALNETWORKS_TENSOR_FLOAT16
• ANEURALNETWORKS_TENSOR_FLOAT32
• ANEURALNETWORKS_TENSOR_INT32

Supported tensor rank: from 1.

Inputs:

• 0: A 1-D tensor, specifying the desired output tensor shape.
• 1: A scalar, specifying the value to fill the output tensors with. For output tensor of ANEURALNETWORKS_TENSOR_FLOAT16, the scalar must be of ANEURALNETWORKS_FLOAT16. For output tensor of ANEURALNETWORKS_TENSOR_FLOAT32, the scalar must be of ANEURALNETWORKS_FLOAT32. For output tensor of ANEURALNETWORKS_TENSOR_INT32, the scalar must be of ANEURALNETWORKS_INT32.

Outputs:

• 0: The output tensor.

Available since NNAPI feature level 4.

Computes element-wise floor() on the input tensor.

Supported tensor