NeuralNetworks
Summary
Typedefs |
|
---|---|
ANeuralNetworksBurst
|
typedefstruct ANeuralNetworksBurst
ANeuralNetworksBurst is an opaque type that can be used to reduce the latency of a rapid sequence of executions. |
ANeuralNetworksCompilation
|
typedefstruct ANeuralNetworksCompilation
ANeuralNetworksCompilation is an opaque type that can be used to compile a machine learning model. |
ANeuralNetworksDevice
|
typedefstruct ANeuralNetworksDevice
ANeuralNetworksDevice is an opaque type that represents a device. |
ANeuralNetworksEvent
|
typedefstruct ANeuralNetworksEvent
ANeuralNetworksEvent is an opaque type that represents an event that will be signaled once an execution completes. |
ANeuralNetworksExecution
|
typedefstruct ANeuralNetworksExecution
ANeuralNetworksExecution is an opaque type that can be used to apply a machine learning model to a set of inputs. |
ANeuralNetworksMemory
|
typedefstruct ANeuralNetworksMemory
ANeuralNetworksMemory is an opaque type that represents memory. |
ANeuralNetworksMemoryDesc
|
typedefstruct ANeuralNetworksMemoryDesc
ANeuralNetworksMemoryDesc is an opaque type that represents a memory descriptor. |
ANeuralNetworksModel
|
typedefstruct ANeuralNetworksModel
ANeuralNetworksModel is an opaque type that contains a description of the mathematical operations that constitute the model. |
ANeuralNetworksOperandType
|
typedefstruct ANeuralNetworksOperandType
ANeuralNetworksOperandType describes the type of an operand. |
ANeuralNetworksOperationType
|
typedefint32_t
Aliasing to OperationCode, used in function ANeuralNetworksModel_addOperation. |
ANeuralNetworksSymmPerChannelQuantParams
|
typedef Parameters for ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL operand. |
Functions |
|
---|---|
ANeuralNetworksBurst_create(ANeuralNetworksCompilation *compilation, ANeuralNetworksBurst **burst)
|
int
Create a ANeuralNetworksBurst to apply the given compilation.
|
ANeuralNetworksBurst_free(ANeuralNetworksBurst *burst)
|
void
Destroys the burst object.
|
ANeuralNetworksCompilation_create(ANeuralNetworksModel *model, ANeuralNetworksCompilation **compilation)
|
int
Create a ANeuralNetworksCompilation to compile the given model.
|
ANeuralNetworksCompilation_createForDevices(ANeuralNetworksModel *model, const ANeuralNetworksDevice *const *devices, uint32_t numDevices, ANeuralNetworksCompilation **compilation)
|
int
Create a ANeuralNetworksCompilation to compile the given model for a specified set of devices.
|
ANeuralNetworksCompilation_finish(ANeuralNetworksCompilation *compilation)
|
int
Indicate that we have finished modifying a compilation.
|
ANeuralNetworksCompilation_free(ANeuralNetworksCompilation *compilation)
|
void
Destroy a compilation.
|
ANeuralNetworksCompilation_getPreferredMemoryAlignmentForInput(const ANeuralNetworksCompilation *compilation, uint32_t index, uint32_t *alignment)
|
int
Get the preferred buffer and memory alignment of an input to an execution created from a particular compilation.
|
ANeuralNetworksCompilation_getPreferredMemoryAlignmentForOutput(const ANeuralNetworksCompilation *compilation, uint32_t index, uint32_t *alignment)
|
int
Get the preferred buffer and memory alignment of an output to an execution created from a particular compilation.
|
ANeuralNetworksCompilation_getPreferredMemoryPaddingForInput(const ANeuralNetworksCompilation *compilation, uint32_t index, uint32_t *padding)
|
int
Get the preferred buffer and memory end padding of an input to an execution created from a particular compilation.
|
ANeuralNetworksCompilation_getPreferredMemoryPaddingForOutput(const ANeuralNetworksCompilation *compilation, uint32_t index, uint32_t *padding)
|
int
Get the preferred memory end padding of an output to an execution created from a particular compilation.
|
ANeuralNetworksCompilation_setCaching(ANeuralNetworksCompilation *compilation, const char *cacheDir, const uint8_t *token)
|
int
Sets the compilation caching signature and the cache directory.
|
ANeuralNetworksCompilation_setPreference(ANeuralNetworksCompilation *compilation, int32_t preference)
|
int
Sets the execution preference.
|
ANeuralNetworksCompilation_setPriority(ANeuralNetworksCompilation *compilation, int priority)
|
int
Set the execution priority.
|
ANeuralNetworksCompilation_setTimeout(ANeuralNetworksCompilation *compilation, uint64_t duration)
|
int
Set the maximum expected duration for compiling the model.
|
ANeuralNetworksDevice_getFeatureLevel(const ANeuralNetworksDevice *device, int64_t *featureLevel)
|
int
Get the NNAPI feature level of the specified NNAPI device.
|
ANeuralNetworksDevice_getName(const ANeuralNetworksDevice *device, const char **name)
|
int
Get the name of the specified device.
|
ANeuralNetworksDevice_getType(const ANeuralNetworksDevice *device, int32_t *type)
|
int
Get the type of a given device.
|
ANeuralNetworksDevice_getVersion(const ANeuralNetworksDevice *device, const char **version)
|
int
Get the version of the driver implementation of the specified device.
|
ANeuralNetworksDevice_wait(const ANeuralNetworksDevice *device)
|
int
Wait until the device is in a live state.
|
ANeuralNetworksEvent_createFromSyncFenceFd(int sync_fence_fd, ANeuralNetworksEvent **event)
|
int
Create a ANeuralNetworksEvent from a sync_fence file descriptor.
|
ANeuralNetworksEvent_free(ANeuralNetworksEvent *event)
|
void
Destroys the event.
|
ANeuralNetworksEvent_getSyncFenceFd(const ANeuralNetworksEvent *event, int *sync_fence_fd)
|
int
Get sync_fence file descriptor from the event.
|
ANeuralNetworksEvent_wait(ANeuralNetworksEvent *event)
|
int
Waits until the execution completes.
|
ANeuralNetworksExecution_burstCompute(ANeuralNetworksExecution *execution, ANeuralNetworksBurst *burst)
|
int
Schedule synchronous evaluation of the execution on a burst object.
|
ANeuralNetworksExecution_compute(ANeuralNetworksExecution *execution)
|
int
Schedule synchronous evaluation of the execution.
|
ANeuralNetworksExecution_create(ANeuralNetworksCompilation *compilation, ANeuralNetworksExecution **execution)
|
int
Create a ANeuralNetworksExecution to apply the given compilation.
|
ANeuralNetworksExecution_enableInputAndOutputPadding(ANeuralNetworksExecution *execution, bool enable)
|
int
Specifies whether the ANeuralNetworksExecution is able to accept padded input and output buffers and memory objects.
|
ANeuralNetworksExecution_free(ANeuralNetworksExecution *execution)
|
void
Destroy an execution.
|
ANeuralNetworksExecution_getDuration(const ANeuralNetworksExecution *execution, int32_t durationCode, uint64_t *duration)
|
int
Get the time spent in the latest computation evaluated on the specified ANeuralNetworksExecution, in nanoseconds.
|
ANeuralNetworksExecution_getOutputOperandDimensions(ANeuralNetworksExecution *execution, int32_t index, uint32_t *dimensions)
|
int
Get the dimensional information of the specified output operand of the model of the latest computation evaluated on ANeuralNetworksExecution.
|
ANeuralNetworksExecution_getOutputOperandRank(ANeuralNetworksExecution *execution, int32_t index, uint32_t *rank)
|
int
Get the dimensional information of the specified output operand of the model of the latest computation evaluated on ANeuralNetworksExecution.
|
ANeuralNetworksExecution_setInput(ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, const void *buffer, size_t length)
|
int
Associate a user buffer with an input of the model of the ANeuralNetworksExecution.
|
ANeuralNetworksExecution_setInputFromMemory(ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, const ANeuralNetworksMemory *memory, size_t offset, size_t length)
|
int
Associate a region of a memory object with an input of the model of the ANeuralNetworksExecution.
|
ANeuralNetworksExecution_setLoopTimeout(ANeuralNetworksExecution *execution, uint64_t duration)
|
int
Set the maximum duration of WHILE loops in the specified execution.
|
ANeuralNetworksExecution_setMeasureTiming(ANeuralNetworksExecution *execution, bool measure)
|
int
Specifies whether duration of the ANeuralNetworksExecution is to be measured.
|
ANeuralNetworksExecution_setOutput(ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, void *buffer, size_t length)
|
int
Associate a user buffer with an output of the model of the ANeuralNetworksExecution.
|
ANeuralNetworksExecution_setOutputFromMemory(ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, const ANeuralNetworksMemory *memory, size_t offset, size_t length)
|
int
Associate a region of a memory object with an output of the model of the ANeuralNetworksExecution.
|
ANeuralNetworksExecution_setReusable(ANeuralNetworksExecution *execution, bool reusable)
|
int
Specifies whether the ANeuralNetworksExecution can be reused for multiple computations.
|
ANeuralNetworksExecution_setTimeout(ANeuralNetworksExecution *execution, uint64_t duration)
|
int
Set the maximum expected duration of the specified execution.
|
ANeuralNetworksExecution_startCompute(ANeuralNetworksExecution *execution, ANeuralNetworksEvent **event)
|
int
Schedule asynchronous evaluation of the execution.
|
ANeuralNetworksExecution_startComputeWithDependencies(ANeuralNetworksExecution *execution, const ANeuralNetworksEvent *const *dependencies, uint32_t num_dependencies, uint64_t duration, ANeuralNetworksEvent **event)
|
int
Schedule asynchronous evaluation of the execution with dependencies.
|
ANeuralNetworksMemoryDesc_addInputRole(ANeuralNetworksMemoryDesc *desc, const ANeuralNetworksCompilation *compilation, uint32_t index, float frequency)
|
int
Specify that a memory object will be playing the role of an input to an execution created from a particular compilation.
|
ANeuralNetworksMemoryDesc_addOutputRole(ANeuralNetworksMemoryDesc *desc, const ANeuralNetworksCompilation *compilation, uint32_t index, float frequency)
|
int
Specify that a memory object will be playing the role of an output to an execution created from a particular compilation.
|
ANeuralNetworksMemoryDesc_create(ANeuralNetworksMemoryDesc **desc)
|
int
Create a ANeuralNetworksMemoryDesc with no properties.
|
ANeuralNetworksMemoryDesc_finish(ANeuralNetworksMemoryDesc *desc)
|
int
Indicate that we have finished modifying a memory descriptor.
|
ANeuralNetworksMemoryDesc_free(ANeuralNetworksMemoryDesc *desc)
|
void
Destroy a memory descriptor.
|
ANeuralNetworksMemoryDesc_setDimensions(ANeuralNetworksMemoryDesc *desc, uint32_t rank, const uint32_t *dimensions)
|
int
Set the dimensional information of the memory descriptor.
|
ANeuralNetworksMemory_copy(const ANeuralNetworksMemory *src, const ANeuralNetworksMemory *dst)
|
int
Copies data from one memory object to another.
|
ANeuralNetworksMemory_createFromAHardwareBuffer(const AHardwareBuffer *ahwb, ANeuralNetworksMemory **memory)
|
int
Creates a shared memory object from an AHardwareBuffer handle.
|
ANeuralNetworksMemory_createFromDesc(const ANeuralNetworksMemoryDesc *desc, ANeuralNetworksMemory **memory)
|
int
Creates a memory object from a memory descriptor.
|
ANeuralNetworksMemory_createFromFd(size_t size, int protect, int fd, size_t offset, ANeuralNetworksMemory **memory)
|
int
Creates a shared memory object from a file descriptor.
|
ANeuralNetworksMemory_free(ANeuralNetworksMemory *memory)
|
void
Delete a memory object.
|
ANeuralNetworksModel_addOperand(ANeuralNetworksModel *model, const ANeuralNetworksOperandType *type)
|
int
Add an operand to a model.
|
ANeuralNetworksModel_addOperation(ANeuralNetworksModel *model, ANeuralNetworksOperationType type, uint32_t inputCount, const uint32_t *inputs, uint32_t outputCount, const uint32_t *outputs)
|
int
Add an operation to a model.
|
ANeuralNetworksModel_create(ANeuralNetworksModel **model)
|
int
Create an empty ANeuralNetworksModel.
|
ANeuralNetworksModel_finish(ANeuralNetworksModel *model)
|
int
Indicate that we have finished modifying a model.
|
ANeuralNetworksModel_free(ANeuralNetworksModel *model)
|
void
Destroy a model.
|
ANeuralNetworksModel_getSupportedOperationsForDevices(const ANeuralNetworksModel *model, const ANeuralNetworksDevice *const *devices, uint32_t numDevices, bool *supportedOps)
|
int
Get the supported operations for a specified set of devices.
|
ANeuralNetworksModel_identifyInputsAndOutputs(ANeuralNetworksModel *model, uint32_t inputCount, const uint32_t *inputs, uint32_t outputCount, const uint32_t *outputs)
|
int
Specifies which operands will be the model's inputs and outputs.
|
ANeuralNetworksModel_relaxComputationFloat32toFloat16(ANeuralNetworksModel *model, bool allow)
|
int
Specifies whether ANEURALNETWORKS_TENSOR_FLOAT32 is allowed to be calculated with range and/or precision as low as that of the IEEE 754 16-bit floating-point format.
|
ANeuralNetworksModel_setOperandSymmPerChannelQuantParams(ANeuralNetworksModel *model, int32_t index, const ANeuralNetworksSymmPerChannelQuantParams *channelQuant)
|
int
Sets an operand's per channel quantization parameters.
|
ANeuralNetworksModel_setOperandValue(ANeuralNetworksModel *model, int32_t index, const void *buffer, size_t length)
|
int
Sets an operand to a constant value.
|
ANeuralNetworksModel_setOperandValueFromMemory(ANeuralNetworksModel *model, int32_t index, const ANeuralNetworksMemory *memory, size_t offset, size_t length)
|
int
Sets an operand to a value stored in a memory object.
|
ANeuralNetworksModel_setOperandValueFromModel(ANeuralNetworksModel *model, int32_t index, const ANeuralNetworksModel *value)
|
int
Sets an operand to a value that is a reference to another NNAPI model.
|
ANeuralNetworks_getDefaultLoopTimeout()
|
uint64_t
Get the default timeout value for WHILE loops.
|
ANeuralNetworks_getDevice(uint32_t devIndex, ANeuralNetworksDevice **device)
|
int
Get the representation of the specified device.
|
ANeuralNetworks_getDeviceCount(uint32_t *numDevices)
|
int
Get the number of available devices.
|
ANeuralNetworks_getMaximumLoopTimeout()
|
uint64_t
Get the maximum timeout value for WHILE loops.
|
ANeuralNetworks_getRuntimeFeatureLevel()
|
int64_t
Get the NNAPI runtime feature level.
|
Structs |
|
---|---|
ANeuralNetworksOperandType |
ANeuralNetworksOperandType describes the type of an operand. |
ANeuralNetworksSymmPerChannelQuantParams |
Parameters for ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL operand. |
Enumerations
Anonymous Enum 53
Declared inandroid/NeuralNetworksTypes.h
Anonymous Enum 53
For ANeuralNetworksModel_setOperandValue, values with a length smaller or equal to this will be immediately copied into the model.
The size is in bytes.
Available since NNAPI feature level 1.
Properties | |
---|---|
ANEURALNETWORKS_MAX_SIZE_OF_IMMEDIATELY_COPIED_VALUES
|
Anonymous Enum 54
Declared inandroid/NeuralNetworksTypes.h
Anonymous Enum 54
For ANeuralNetworksCompilation_setCaching, specify the size of the cache token required from the application.
The size is in bytes.
Available since NNAPI feature level 3.
Properties | |
---|---|
ANEURALNETWORKS_BYTE_SIZE_OF_CACHE_TOKEN
|
DeviceTypeCode
Declared inandroid/NeuralNetworksTypes.h
DeviceTypeCode
Device types.
The type of NNAPI device.
DurationCode
Declared inandroid/NeuralNetworksTypes.h
DurationCode
FeatureLevelCode
Declared inandroid/NeuralNetworksTypes.h
FeatureLevelCode
NNAPI feature levels.
Each update of the NNAPI specification yields a new NNAPI feature level enum value. NNAPI feature level corrseponds to an NNAPI specification version that a driver and/or the NNAPI runtime can implement.
A feature level up to and including "FEATURE_LEVEL_5" maps directly to the Android API level that introduced the corresponding update of the NNAPI specification. Feature levels after Android API level 31 have no association with API level because the NNAPI specification can be updated between Android API releases. Outputs of ANeuralNetworksDevice_getFeatureLevel and ANeuralNetworks_getRuntimeFeatureLevel must be compared against these enum values instead of the Android API level.
FuseCode
Declared inandroid/NeuralNetworksTypes.h
FuseCode
Fused activation function types.
Available since NNAPI feature level 1.
OperandCode
Declared inandroid/NeuralNetworksTypes.h
OperandCode
Operand types.
The type of an operand in a model.
Types prefaced with ANEURALNETWORKS_TENSOR_* must be used for tensor data (i.e., tensors with at least one dimension). Types not prefaced by ANEURALNETWORKS_TENSOR_* represent scalar values and must have no dimensions.
Although we define many types, most operators accept just a few types. Most used are ANEURALNETWORKS_TENSOR_FLOAT32, ANEURALNETWORKS_TENSOR_QUANT8_ASYMM, and ANEURALNETWORKS_INT32.
Available since NNAPI feature level 1.
Properties | |
---|---|
ANEURALNETWORKS_BOOL
|
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. |
ANEURALNETWORKS_FLOAT16
|
An IEEE 754 16 bit floating point scalar value. Available since NNAPI feature level 3. |
ANEURALNETWORKS_FLOAT32
|
A 32 bit floating point scalar value. |
ANEURALNETWORKS_INT32
|
A signed 32 bit integer scalar value. |
ANEURALNETWORKS_MODEL
|
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. |
ANEURALNETWORKS_TENSOR_BOOL8
|
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. |
ANEURALNETWORKS_TENSOR_FLOAT16
|
A tensor of IEEE 754 16 bit floating point values. Available since NNAPI feature level 3. |
ANEURALNETWORKS_TENSOR_FLOAT32
|
A tensor of 32 bit floating point values. |
ANEURALNETWORKS_TENSOR_INT32
|
A tensor of 32 bit integer values. |
ANEURALNETWORKS_TENSOR_QUANT16_ASYMM
|
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:
The formula is: real_value = (integer_value - zeroPoint) * scale. Available since NNAPI feature level 3. |
ANEURALNETWORKS_TENSOR_QUANT16_SYMM
|
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. |
ANEURALNETWORKS_TENSOR_QUANT8_ASYMM
|
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:
The formula is: real_value = (integer_value - zeroPoint) * scale. |
ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED
|
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:
The formula is: real_value = (integer_value - zeroPoint) * scale. Available since NNAPI feature level 4. |
ANEURALNETWORKS_TENSOR_QUANT8_SYMM
|
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. |
ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL
|
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:
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. |
ANEURALNETWORKS_UINT32
|
An unsigned 32 bit integer scalar value. |
OperationCode
Declared inandroid/NeuralNetworksTypes.h
OperationCode
Operation types.
The type of an operation in a model.
Available since NNAPI feature level 1.
Properties | |
---|---|
ANEURALNETWORKS_ABS
|
Computes the absolute value of a tensor, element-wise. Supported tensor OperandCode:
Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_ADD
|
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:
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:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_ARGMAX
|
Returns the index of the largest element along an axis. Supported tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_ARGMIN
|
Returns the index of the smallest element along an axis. Supported tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_AVERAGE_POOL_2D
|
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:
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):
Inputs (implicit padding):
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_AXIS_ALIGNED_BBOX_TRANSFORM
|
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: Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_BATCH_MATMUL
|
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:
Supported tensor rank: at least 2 and up to 4 Inputs:
Outputs:
Available since NNAPI feature level 6. |
ANEURALNETWORKS_BATCH_TO_SPACE_ND
|
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:
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:
Outputs:
Available since NNAPI feature level 2. |
ANEURALNETWORKS_BIDIRECTIONAL_SEQUENCE_LSTM
|
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: Supported tensor rank: 3, either time-major or batch-major. All input and output tensors must be of the same type. Inputs:
Outputs:
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. |
ANEURALNETWORKS_BIDIRECTIONAL_SEQUENCE_RNN
|
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:
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: The input tensors must all be the same type. Inputs:
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. |
ANEURALNETWORKS_BOX_WITH_NMS_LIMIT
|
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:
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:
Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_CAST
|
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:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_CHANNEL_SHUFFLE
|
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:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_CONCATENATION
|
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:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_CONV_2D
|
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:
Available since NNAPI feature level 3:
Available 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):
Inputs (implicit padding):
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_DEPTHWISE_CONV_2D
|
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:
Available since NNAPI feature level 3:
Available 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):
Inputs (implicit padding):
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_DEPTH_TO_SPACE
|
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:
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:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_DEQUANTIZE
|
Dequantizes the input tensor. The formula is: output = (input - zeroPoint) * scale. Supported input tensor OperandCode:
Supported output tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_DETECTION_POSTPROCESSING
|
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: Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_DIV
|
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:
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:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 2. |
ANEURALNETWORKS_ELU
|
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: Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 4. |
ANEURALNETWORKS_EMBEDDING_LOOKUP
|
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:
Supported value tensor rank: from 2 Inputs:
Output:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_EQUAL
|
For input tensors x and y, computes x == y elementwise. Supported tensor OperandCode:
Supported tensor rank: from 1 This operation supports broadcasting. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_EXP
|
Computes exponential of x element-wise. Supported tensor OperandCode: Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_EXPAND_DIMS
|
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:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_FILL
|
Creates a tensor filled with a scalar value. Supported output tensor OperandCode: Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 4. |
ANEURALNETWORKS_FLOOR
|
Computes element-wise floor() on the input tensor. Supported tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_FULLY_CONNECTED
|
Denotes a fully (densely) connected layer, which connects all elements in the input tensor with each element in the output tensor. This layer implements the operation: outputs = activation(inputs * weights’ + bias) Supported tensor OperandCode:
Supported tensor rank: up to 4. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_GATHER
|
Gathers values along an axis. Produces an output tensor with shape input0.dimension[:axis] + indices.dimension + input0.dimension[axis + 1:] where: Vector indices (output is rank(input0)).output[a_0, ..., a_n, i, b_0, ..., b_n] = input0[a_0, ..., a_n, indices[i], b_0, ..., b_n]
Higher rank indices (output is rank(input0) + rank(indices) - 1).output[a_0, ..., a_n, i, ..., j, b_0, ... b_n] = input0[a_0, ..., a_n, indices[i, ..., j], b_0, ..., b_n] Supported tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_GENERATE_PROPOSALS
|
Generate aixs-aligned bounding box proposals. Bounding box proposals 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. 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:
Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_GREATER
|
For input tensors x and y, computes x > y elementwise. Supported tensor OperandCode:
Supported tensor rank: from 1 This operation supports broadcasting. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_GREATER_EQUAL
|
For input tensors x and y, computes x >= y elementwise. Supported tensor OperandCode:
Supported tensor rank: from 1 This operation supports broadcasting. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_GROUPED_CONV_2D
|
Performs a grouped 2-D convolution operation. Given an input tensor of shape [batches, height, width, depth_in] and a filter tensor of shape [depth_out, filter_height, filter_width, depth_group] containing depth_out convolutional filters of depth depth_group, GROUPED_CONV applies a group of different filters to each input channel group, then concatenates the results together. Specifically, the input channels are divided into num_groups groups, each with depth depth_group, i.e. depth_in = num_groups * depth_group. The convolutional filters are also divided into num_groups groups, i.e. depth_out is divisible by num_groups. GROUPED_CONV applies each group of filters to the corresponding input channel group, and the result are concatenated together. 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, g * channel_multiplier + q] = sum_{di, dj, dk} ( input[b, strides[1] * i + di, strides[2] * j + dj, g * depth_group + dk] * filter[g * channel_multiplier + q, di, dj, dk] ) + bias[channel] where channel_multiplier = depth_out / num_groups Supported tensor OperandCode configurations:
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]. Both explicit padding and implicit padding are supported. Inputs (explicit padding):
Inputs (implicit padding):
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_HARD_SWISH
|
Computes hard-swish activation on the input tensor element-wise. Hard swish activation is introduced in https://arxiv.org/pdf/1905.02244.pdf The output is calculated using the following formula: h-swish(x) = x * max(0, min(6, (x + 3))) / 6 Supported tensor OperandCode:
Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 4. |
ANEURALNETWORKS_HASHTABLE_LOOKUP
|
Looks up sub-tensors in the input tensor using a key-value map. This operator takes for input a tensor of values (Values), a one-dimensional tensor of selection values (Lookups) and a one-dimensional tensor that maps these values to Values indexes. The output tensor is the concatenation of sub-tensors of Values as selected by Lookups via Keys. Think of Values as being sliced along its outer-most dimension. The output is a concatenation of selected slices, with one slice for each entry of Lookups. The slice selected is the one at the same index as the Maps entry that matches the value in Lookups. For a hit, the corresponding sub-tensor of Values is included in the Output tensor. For a miss, the corresponding sub-tensor in Output must have zero values. For example, if Values has shape of [40, 200, 300], Keys should have a shape of [40]. If Lookups tensor has shape of [3], three slices are being concatenated, so the resulting tensor must have the shape of [3, 200, 300]. If the first entry in Lookups has the value 123456, that value must be located in Keys tensor. If the sixth entry of Keys contains 123456, the sixth slice of Values must be selected. If no entry in Keys has 123456, a slice of zeroes must be concatenated. Supported value tensor OperandCode: Supported value tensor rank: from 2 Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_HEATMAP_MAX_KEYPOINT
|
Localize the maximum keypoints from heatmaps. This operation approximates the accurate maximum keypoint scores and indices after bicubic upscaling by using Taylor expansion up to the quadratic term. The bounding box is represented by its upper-left corner coordinate (x1,y1) and lower-right corner coordinate (x2,y2) in the original image. A valid bounding box should satisfy x1 <= x2 and y1 <= y2. Supported tensor OperandCode:
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]. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_IF
|
Executes one of the two referenced models as determined by a boolean value. The inputs and outputs of the two referenced models must agree with the signature of this operation. That is, if the operation has (3 + n) inputs and m outputs, both models must have n inputs and m outputs with the same types, ranks (if specified), dimensions (if specified), scales, zeroPoints, and other operand parameters as the corresponding operation inputs and outputs. Inputs:
Outputs:
Available since NNAPI feature level 4. |
ANEURALNETWORKS_INSTANCE_NORMALIZATION
|
Applies instance normalization to the input tensor. The values in the output tensor are computed as: output[b, h, w, c] = (input[b, h, w, c] - mean[b, c]) * gamma / sqrt(var[b, c] + epsilon) + beta Where the mean and variance are computed across the spatial dimensions: mean[b, c] = sum_{h, w}(input[b, h, w, c]) / sum(1) var[b, c] = sum_{h, w}(pow(input[b, h, w, c] - mean[b, c], 2)) / sum(1) Supported tensor OperandCode: 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]. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_L2_NORMALIZATION
|
Applies L2 normalization along the axis dimension. The values in the output tensor are computed as: output[batch, row, col, channel] = input[batch, row, col, channel] / sqrt(sum_{c} pow(input[batch, row, col, c], 2)) By default the axis dimension is the last dimension of the input tensor. Supported tensor OperandCode:
Supported tensor rank: up to 4 Tensors with rank less than 4 are only supported since NNAPI feature level 3. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_L2_POOL_2D
|
Performs an 2-D L2 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, c] =
sqrt(sum_{di, dj} pow(input[b, strides[1] * i + di, strides[2] * j + dj, c], 2) /
sum(1)) Supported tensor OperandCode:
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):
Inputs (implicit padding):
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_LESS
|
For input tensors x and y, computes x < y elementwise. Supported tensor OperandCode:
Supported tensor rank: from 1 This operation supports broadcasting. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_LESS_EQUAL
|
For input tensors x and y, computes x <= y elementwise. Supported tensor OperandCode:
Supported tensor rank: from 1 This operation supports broadcasting. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_LOCAL_RESPONSE_NORMALIZATION
|
Applies Local Response Normalization along the depth dimension. The 4-D input tensor is treated as a 3-D array of 1-D vectors (along the last dimension), and each vector is normalized independently. Within a given vector, each component is divided by the weighted, squared sum of inputs within depth_radius. The output is calculated using this formula: sqr_sum[a, b, c, d] = sum( pow(input[a, b, c, d - depth_radius : d + depth_radius + 1], 2)) output = input / pow((bias + alpha * sqr_sum), beta) For input tensor with rank less than 4, independently normalizes each 1-D slice along specified dimension. Supported tensor OperandCode:
Supported tensor rank: up to 4 Tensors with rank less than 4 are only supported since NNAPI feature level 3. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_LOG
|
Computes natural logarithm of x element-wise. Supported tensor OperandCode: Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_LOGICAL_AND
|
Returns the truth value of x AND y element-wise. Supported tensor OperandCode: Supported tensor rank: from 1 This operation supports broadcasting. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_LOGICAL_NOT
|
Computes the truth value of NOT x element-wise. Supported tensor OperandCode: Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_LOGICAL_OR
|
Returns the truth value of x OR y element-wise. Supported tensor OperandCode: Supported tensor rank: from 1 This operation supports broadcasting. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_LOGISTIC
|
Computes sigmoid activation on the input tensor element-wise. The output is calculated using this formula: output = 1 / (1 + exp(-input)) Supported tensor OperandCode:
Supported tensor rank: up to 4. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_LOG_SOFTMAX
|
Computes the log softmax activations given logits. The output is calculated using this formula: output = logits * beta - log(reduce_sum(exp(logits * beta), axis)) Supported tensor OperandCode: Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_LSH_PROJECTION
|
Projects an input to a bit vector via locality senstive hashing. Supported input tensor OperandCode:
Supported input tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 1. The offset value for sparse projections was added in NNAPI feature level 3. |
ANEURALNETWORKS_LSTM
|
Performs a single time step in a Long Short-Term Memory (LSTM) layer. The LSTM operation is described by the following equations. \begin{eqnarray*} i_t =& \sigma(W_{xi}x_t+W_{hi}h_{t-1}+W_{ci}C_{t-1}+b_i) & \\ f_t =& \sigma(W_{xf}x_t+W_{hf}h_{t-1}+W_{cf}C_{t-1}+b_f) & \\ C_t =& clip(f_t \odot C_{t-1} + i_t \odot g(W_{xc}x_t+W_{hc}h_{t-1}+b_c),\ t_{cell}) & \\ o_t =& \sigma(W_{xo}x_t+W_{ho}h_{t-1}+W_{co}C_t+b_o) & \\ & & \\ & clip(W_{proj}(o_t \odot g(C_t))+b_{proj},\ t_{proj}) & if\ there\ is\ a\ projection; \\ h_t =& & \\ & o_t \odot g(C_t) & otherwise. \\ \end{eqnarray*} Where:
Since NNAPI feature level 3 LSTM supports layer normalization. In case layer normalization is used, the inputs to internal activation functions (sigmoid and $g$) are normalized, rescaled and recentered following an approach from section 3.1 from https://arxiv.org/pdf/1607.06450.pdf The operation has the following independently optional inputs:
References: The default non-peephole non-CIFG implementation is based on: http://www.bioinf.jku.at/publications/older/2604.pdf S. Hochreiter and J. Schmidhuber. "Long Short-Term Memory". Neural Computation, 9(8):1735-1780, 1997. The peephole implementation and projection layer is based on: https://research.google.com/pubs/archive/43905.pdf Hasim Sak, Andrew Senior, and Francoise Beaufays. "Long short-term memory recurrent neural network architectures for large scale acoustic modeling." INTERSPEECH, 2014. (However, the concept of peephole optimization was introduced in work prior to this paper.) The coupling of input and forget gate (CIFG) is based on: http://arxiv.org/pdf/1503.04069.pdf Greff et al. "LSTM: A Search Space Odyssey" The layer normalization is based on: https://arxiv.org/pdf/1607.06450.pdf Jimmy Ba et al. "Layer Normalization" Supported tensor OperandCode:
All input and output tensors must be of the same type. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_MAXIMUM
|
Returns the element-wise maximum of two tensors. Supported tensor OperandCode:
Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_MAX_POOL_2D
|
Performs an 2-D max 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] =
max_{di, dj} (
input[b, strides[1] * i + di, strides[2] * j + dj, channel]
) Supported tensor OperandCode:
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):
Inputs (implicit padding):
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_MEAN
|
Computes the mean of elements across dimensions of a tensor. Reduces the input tensor along the given dimensions to reduce. Unless keep_dims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keep_dims is true, the reduced dimensions are retained with length 1. Supported tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 2. |
ANEURALNETWORKS_MINIMUM
|
Returns the element-wise minimum of two tensors. Supported tensor OperandCode:
Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_MIRROR_PAD
|
Pads a tensor with mirrored values. This operator specifies one of two padding modes: REFLECT or SYMMETRIC. In the case of REFLECT mode, the mirroring excludes the border element on the padding side. In the case of SYMMETRIC mode, the mirroring includes the border element on the padding side. For example, if the input is the 1-D tensor
Supported tensor OperandCode:
Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 7. |
ANEURALNETWORKS_MUL
|
Multiplies two tensors, element-wise. Takes two input tensors of identical OperandCode and compatible dimensions. The output is the product of both input tensors, optionally modified by an activation function. Two dimensions are compatible when:
The size of the resulting output is the maximum size along each dimension of the input operands. It starts with the trailing dimensions, and works its way forward. 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:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_NEG
|
Computes numerical negative value element-wise. Supported tensor OperandCode: Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_NOT_EQUAL
|
For input tensors x and y, computes x != y elementwise. Supported tensor OperandCode:
Supported tensor rank: from 1 This operation supports broadcasting. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_PACK
|
Packs N input tensors (N >= 1) of rank R into one output tensor of rank R+1. The tensors are packed along a given axis. The input tensors must have identical OperandCode and dimensions. For example, suppose there are N input tensors of shape (A, B, C). If axis is 0, the output tensor will have shape (N, A, B, C). If axis is 1, the output tensor will have shape (A, N, B, C). All dimensions through the axis dimension determine the output tile count; the remaining dimensions determine the tile shape. Return to the example of N input tensors of shape (A, B, C). If axis is 0, there are N tiles in the output, each of shape (A, B, C). If axis is 1, there are A*N tiles in the output, each of shape (B, C). The coordinates of a tile within the output tensor are (t[0],...,t[axis]). The coordinates of a tile within an input tensor are (t[0],...,t[axis-1]). (If axis is 0, an input tensor consists of a single tile.) If we index input tensors starting with 0 (rather than by operand number), then output_tile[t[0],...,t[axis]] = input_tile[t[axis]][t[0],...,t[axis-1]]. That is, all output tile coordinates except for the axis coordinate select the corresponding location within some input tensor; and the axis coordinate selects the input tensor. Supported tensor OperandCode:
Supported input tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 6. |
ANEURALNETWORKS_PAD
|
Pads a tensor. This operation pads a tensor according to the specified paddings. Supported tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 2. |
ANEURALNETWORKS_PAD_V2
|
Pads a tensor with the given constant value according to the specified paddings. Supported tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_POW
|
Computes the power of one value to another. Given a tensor base and a tensor exponent, this operation computes base^exponent elementwise. This operations supports broadcasting. 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. For example: base.dimension = {4, 1, 2} exponent.dimension = {5, 4, 3, 1} output.dimension = {5, 4, 3, 2} Supported tensor OperandCode: Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_PRELU
|
Parametric Rectified Linear Unit. It follows: f(x) = alpha * x for x < 0, f(x) = x for x >= 0, where alpha is a learned array with the same OperandCode and compatible dimensions as input x. Two dimensions are compatible when:
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: input.dimension = {4, 1, 2} alpha.dimension = {5, 4, 3, 1} output.dimension = {5, 4, 3, 2} Supported tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_QUANTIZE
|
Quantizes the input tensor. The formula for ANEURALNETWORKS_TENSOR_QUANT8_ASYMM output tensor is: output = max(0, min(255, round(input / scale) + zeroPoint) The formula for ANEURALNETWORKS_TENSOR_QUANT8_ASYMM_SIGNED output tensor is: output = max(-128, min(127, round(input / scale) + zeroPoint) Supported input tensor OperandCode: Supported output tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_QUANTIZED_16BIT_LSTM
|
A version of quantized LSTM, using 16 bit quantization for internal state. There is no projection layer, so cell state size is equal to the output size. Inputs:
Outputs:
|
ANEURALNETWORKS_QUANTIZED_LSTM
|
Quantized version of ANEURALNETWORKS_LSTM. The input and the output use asymmetric quantized types, while the rest use symmetric ones. Inputs:
Outputs:
Available since NNAPI feature level 4. |
ANEURALNETWORKS_RANDOM_MULTINOMIAL
|
Draws samples from a multinomial distribution. Supported tensor OperandCode: Inputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_RANK
|
Returns the rank of a tensor. The rank of a tensor is the number of dimensions in it. Also known as "order", "degree", "ndims". Supported tensor OperandCode:
Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 4. |
ANEURALNETWORKS_REDUCE_ALL
|
Reduces a tensor by computing the "logical and" of elements along given dimensions. If keep_dims is true, the reduced dimensions are retained with length 1. Otherwise, the rank of the tensor is reduced by 1 for each entry in dimensions. Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_REDUCE_ANY
|
Reduces a tensor by computing the "logical or" of elements along given dimensions. If keep_dims is true, the reduced dimensions are retained with length 1. Otherwise, the rank of the tensor is reduced by 1 for each entry in dimensions. Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_REDUCE_MAX
|
Reduces a tensor by computing the maximum of elements along given dimensions. If keep_dims is true, the reduced dimensions are retained with length 1. Otherwise, the rank of the tensor is reduced by 1 for each entry in dimensions. Supported tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_REDUCE_MIN
|
Reduces a tensor by computing the minimum of elements along given dimensions. If keep_dims is true, the reduced dimensions are retained with length 1. Otherwise, the rank of the tensor is reduced by 1 for each entry in dimensions. Supported tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_REDUCE_PROD
|
Reduces a tensor by multiplying elements along given dimensions. If keep_dims is true, the reduced dimensions are retained with length 1. Otherwise, the rank of the tensor is reduced by 1 for each entry in dimensions. Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_REDUCE_SUM
|
Reduces a tensor by summing elements along given dimensions. If keep_dims is true, the reduced dimensions are retained with length 1. Otherwise, the rank of the tensor is reduced by 1 for each entry in dimensions. Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_RELU
|
Computes rectified linear activation on the input tensor element-wise. The output is calculated using this formula: output = max(0, input) Supported tensor OperandCode:
Supported tensor rank: up to 4. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_RELU1
|
Computes rectified linear 1 activation on the input tensor element-wise. The output is calculated using this formula: output = min(1.f, max(-1.f, input)) Supported tensor OperandCode:
Supported tensor rank: up to 4. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_RELU6
|
Computes rectified linear 6 activation on the input tensor element-wise. The output is calculated using this formula: output = min(6, max(0, input)) Supported tensor OperandCode:
Supported tensor rank: up to 4. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_RESHAPE
|
Reshapes a tensor. Given tensor, this operation returns a tensor that has the same values as tensor, but with a newly specified shape. Supported tensor OperandCode:
Supported tensor rank: up to 4. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_RESIZE_BILINEAR
|
Resizes images to given size using the bilinear interpretation. Resized images must be distorted if their output aspect ratio is not the same as input aspect ratio. The corner pixels of output may not be the same as corner pixels of input. Supported tensor OperandCode:
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 resizing by shape and resizing by scale are supported. Inputs (resizing by shape):
Inputs (resizing by scale, since NNAPI feature level 3):
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_RESIZE_NEAREST_NEIGHBOR
|
Resizes images to given size using the nearest neighbor interpretation. Resized images must be distorted if their output aspect ratio is not the same as input aspect ratio. The corner pixels of output may not be the same as corner pixels of input. Supported tensor OperandCode:
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]. Both resizing by shape and resizing by scale are supported. Inputs (resizing by shape):
Inputs (resizing by scale):
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_REVERSE
|
Reverses a specified dimension of a tensor. Supported tensor OperandCode:
Supported tensor rank: up to 8. Inputs:
Outputs:
Available since NNAPI feature level 7. |
ANEURALNETWORKS_RNN
|
A basic recurrent neural network layer. This layer implements the operation: outputs = state = activation(inputs * input_weights + state * recurrent_weights + bias) Where:
Supported tensor OperandCode:
The input tensors must all be the same type. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_ROI_ALIGN
|
Select and scale the feature map of each region of interest to a unified output size by average pooling sampling points from bilinear interpolation. The region of interest is represented by its upper-left corner coordinate (x1,y1) and lower-right corner coordinate (x2,y2) in the original image. A spatial scaling factor is applied to map into feature map coordinate. A valid region of interest should satisfy x1 <= x2 and y1 <= y2. No rounding is applied in this operation. The sampling points are unified distributed in the pooling bin and their values are calculated by bilinear interpolation. Supported tensor OperandCode:
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]. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_ROI_POOLING
|
Select and scale the feature map of each region of interest to a unified output size by max-pooling. The region of interest is represented by its upper-left corner coordinate (x1,y1) and lower-right corner coordinate (x2,y2) in the original image. A spatial scaling factor is applied to map into feature map coordinate. A valid region of interest should satisfy x1 <= x2 and y1 <= y2. Rounding is applied in this operation to ensure integer boundary for regions of interest and pooling bins. Supported tensor OperandCode:
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]. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_RSQRT
|
Computes reciprocal of square root of x element-wise. Supported tensor OperandCode:
Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_SELECT
|
Using a tensor of booleans c and input tensors x and y select values elementwise from both input tensors: O[i] = C[i] ? x[i] : y[i]. Supported tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_SIN
|
Computes sin of x element-wise. Supported tensor OperandCode: Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_SLICE
|
Extracts a slice of specified size from the input tensor starting at a specified location. The starting location is specified as a 1-D tensor containing offsets for each dimension. The size is specified as a 1-D tensor containing either size of a slice along corresponding dimension or -1. In the latter case, all the remaining elements in dimension are included in the slice. A sum of begin offset and a size of a slice must not exceed size of a corresponding dimension. Supported tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_SOFTMAX
|
Computes the softmax activation on the input tensor element-wise, per batch, by normalizing the input vector so the maximum coefficient is zero. The output is calculated using this formula: output[batch, i] = exp((input[batch, i] - max(input[batch, :])) * beta) / sum_{k}{exp((input[batch, k] - max(input[batch, :])) * beta)} For input tensor with rank other than 2, the activation will be applied independently on each 1-D slice along specified dimension. Supported tensor OperandCode:
Supported tensor rank: up to 4. Tensors with rank other than 2 or 4 are only supported since NNAPI feature level 3. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_SPACE_TO_BATCH_ND
|
SpaceToBatch for N-Dimensional tensors. This operation divides "spatial" dimensions [1, ..., M] of the input into a grid of blocks of shape block_shape, and interleaves these blocks with the "batch" dimension (0) such that in the output, the spatial dimensions [1, ..., M] correspond to the position within the grid, and the batch dimension combines both the position within a spatial block and the original batch position. Prior to division into blocks, the spatial dimensions of the input are optionally zero padded according to paddings. Supported tensor OperandCode:
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:
Outputs:
Available since NNAPI feature level 2. |
ANEURALNETWORKS_SPACE_TO_DEPTH
|
Rearranges blocks of spatial data, into depth. More specifically, this op outputs a copy of the input tensor where values from the height and width dimensions are moved to the depth dimension. 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 depth of the output tensor is input_depth * block_size * block_size. The input tensor's height and width must be divisible by block_size. Supported tensor OperandCode:
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:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_SPLIT
|
Splits a tensor along a given axis into num_splits subtensors. Supported tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_SQRT
|
Computes square root of x element-wise. Supported tensor OperandCode: Supported tensor rank: from 1. Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_SQUEEZE
|
Removes dimensions of size 1 from the shape of a tensor. Given a tensor input, this operation returns a tensor of the same OperandCode with all dimensions of size 1 removed. If you don't want to remove all size 1 dimensions, you can remove specific size 1 dimensions by specifying the axes (input1). Supported tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 2. |
ANEURALNETWORKS_STRIDED_SLICE
|
Extracts a strided slice of a tensor. Roughly speaking, this op extracts a slice of size (end - begin) / stride from the given input tensor. Starting at the location specified by begin the slice continues by adding stride to the index until all dimensions are not less than end. Note that a stride can be negative, which causes a reverse slice. Supported tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 2. |
ANEURALNETWORKS_SUB
|
Element-wise subtraction of two tensors. Takes two input tensors of identical OperandCode and compatible dimensions. The output is the result of subtracting the second input tensor from the first one, optionally modified by an activation function. Two dimensions are compatible when:
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:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 2. |
ANEURALNETWORKS_SVDF
|
SVDF op is a kind of stateful layer derived from the notion that a densely connected layer that's processing a sequence of input frames can be approximated by using a singular value decomposition of each of its nodes. The implementation is based on: https://research.google.com/pubs/archive/43813.pdf P. Nakkiran, R. Alvarez, R. Prabhavalkar, C. Parada. “Compressing Deep Neural Networks using a Rank-Constrained Topology”. INTERSPEECH, 2015. It processes the incoming input using a 2-stage filtering mechanism:
Specifically, for rank 1, this layer implements the operation: memory = push(conv1d(inputs, weights_feature, feature_dim, "ANEURALNETWORKS_PADDING_VALID")); outputs = activation(memory * weights_time + bias); Where:
Each rank adds a dimension to the weights matrices by means of stacking the filters. Supported tensor OperandCode:
All input tensors must be the same type. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_TANH
|
Computes hyperbolic tangent of input tensor element-wise. The output is calculated using this formula: output = tanh(input) Supported tensor OperandCode:
Supported tensor rank: up to 4. Inputs:
Outputs:
Available since NNAPI feature level 1. |
ANEURALNETWORKS_TILE
|
Constructs a tensor by tiling a given tensor. This operation creates a new tensor by replicating Supported tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_TOPK_V2
|
Finds values and indices of the k largest entries for the last dimension. Resulting values in each dimensions are sorted in descending order. If two values are equal, the one with larger index appears first. Supported tensor OperandCode:
Supported tensor rank: from 1 Inputs:
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_TRANSPOSE
|
Transposes the input tensor, permuting the dimensions according to the perm tensor. The returned tensor's dimension i corresponds to the input dimension perm[i]. If perm is not given, it is set to (n-1...0), where n is the rank of the input tensor. Hence by default, this operation performs a regular matrix transpose on 2-D input Tensors. Supported tensor OperandCode:
Supported tensor rank: up to 4 Inputs:
Outputs:
Available since NNAPI feature level 2. |
ANEURALNETWORKS_TRANSPOSE_CONV_2D
|
Performs the transpose of 2-D convolution operation. This operation is sometimes called "deconvolution" after Deconvolutional Networks, but is actually the transpose (gradient) of ANEURALNETWORKS_CONV_2D rather than an actual deconvolution. The output dimensions are functions of the filter dimensions, stride, and padding. Supported tensor OperandCode configurations:
Available 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]. Both explicit padding and implicit padding are supported. Inputs (explicit padding):
Inputs (implicit padding):
Outputs:
Available since NNAPI feature level 3. |
ANEURALNETWORKS_UNIDIRECTIONAL_SEQUENCE_LSTM
|
A recurrent neural network specified by an LSTM cell. Performs (fully) dynamic unrolling of input. This Op unrolls the input along the time dimension, and implements the following operation for each element in the sequence s = 1...sequence_length: outputs[s] = projection(state = activation(LSTMOp(inputs[s]))) Where LSTMOp is the LSTM op as in ANEURALNETWORKS_LSTM, the "projection" is an optional projection layer from state and output and the “activation” is the function passed as the “fused_activation_function” argument (if not “NONE”). Supported tensor OperandCode: Supported tensor rank: 3, either time-major or batch-major. All input and output tensors must be of the same type. Inputs:
Outputs:
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. |
ANEURALNETWORKS_UNIDIRECTIONAL_SEQUENCE_RNN
|
A recurrent neural network layer that applies a basic RNN cell to a sequence of inputs. This layer unrolls the input along the sequence dimension, and implements the following operation for each element in the sequence s = 1...sequence_length: outputs[s] = state = activation(inputs[s] * input_weights’ + state * recurrent_weights’ + bias) Where:
Supported tensor OperandCode: The input tensors must all be the same type. Inputs:
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. |
ANEURALNETWORKS_WHILE
|
Executes the body model until the condition model outputs false. The inputs to this operation are the condition model, the body model, and operand values for the first iteration of the loop. The values are implicitly split into three groups of input-output, state-only, and input-only values, as described below. The outputs of this operation are the final values of input-output operands. Both the condition and body model receive (m + k + n) inputs.
The body model produces (m + k) outputs.
The numbers m, k, and n are inferred by the runtime as follows: m = (WHILE operation output count) k = (body model output count) - m n = (body model input count) - m - k The pseudo-code below illustrates the flow of a WHILE operation with inputs condition, body, initial_input_output, initial_state, input_only (m = 1, k = 1, n = 1): input_output = initial_input_output state = initial_state while condition(input_output, state, input_only): input_output, state = body(input_output, state, input_only) return input_output To prevent infinite loops, there is an implicit execution timeout associated with each loop ("loop timeout duration"). See ANeuralNetworksExecution_setLoopTimeout. Inputs:
Outputs:
Available since NNAPI feature level 4. |
PaddingCode
Declared inandroid/NeuralNetworksTypes.h
PaddingCode
Implicit padding algorithms.
Available since NNAPI feature level 1.
PreferenceCode
Declared inandroid/NeuralNetworksTypes.h
PreferenceCode
Execution preferences.
Available since NNAPI feature level 1.
PriorityCode
Declared inandroid/NeuralNetworksTypes.h
PriorityCode
ResultCode
Declared inandroid/NeuralNetworksTypes.h
ResultCode
Result codes.
Any NNAPI function can return any result code, including result codes not currently documented. Any value other than ANEURALNETWORKS_NO_ERROR indicates a failure of some kind.
Additional information about the nature of a failure can be obtained from the device log after enabling NNAPI debugging by setting the debug.nn.vlog property to 1, e.g., by calling "adb shell setprop debug.nn.vlog 1".
Available since NNAPI feature level 1.
Typedefs
ANeuralNetworksBurst
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksBurst ANeuralNetworksBurst
ANeuralNetworksBurst is an opaque type that can be used to reduce the latency of a rapid sequence of executions.
It will likely cause overhead if only used for a single execution.
ANeuralNetworksBurst serves as a context object for any number of inferences using ANeuralNetworksExecution objects. An ANeuralNetworksBurst object and the ANeuralNetworksExecution objects used with it must all have been created from the same ANeuralNetworksCompilation object.
This object is also used as a hint to drivers, providing insight to the lifetime of a rapid sequence of executions. For example, a driver may choose to increase the clock frequency of its accelerator for the lifetime of a burst object.
To use:
- Create a new burst object by calling the ANeuralNetworksBurst_create function.
- For each execution:
- Create ANeuralNetworksExecution and configure its properties (see ANeuralNetworksExecution for details).
- Apply the model synchronously with ANeuralNetworksExecution_burstCompute, reusing the same ANeuralNetworksBurst with the new ANeuralNetworksExecution.
- Use and free the ANeuralNetworksExecution.
- Destroy the burst with ANeuralNetworksBurst_free.
Available since NNAPI feature level 3.
ANeuralNetworksCompilation
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksCompilation ANeuralNetworksCompilation
ANeuralNetworksCompilation is an opaque type that can be used to compile a machine learning model.
To use:
- Create a new compilation instance by calling the ANeuralNetworksCompilation_create function or ANeuralNetworksCompilation_createForDevices.
- Set any desired properties on the compilation (for example, ANeuralNetworksCompilation_setPreference).
- Optionally, set the caching signature and the cache directory on the compilation by calling ANeuralNetworksCompilation_setCaching.
- Complete the compilation with ANeuralNetworksCompilation_finish.
- Use the compilation as many times as needed with ANeuralNetworksExecution_create and ANeuralNetworksBurst_create.
- Destroy the compilation with ANeuralNetworksCompilation_free once all executions using the compilation have completed.
A compilation is completed by calling ANeuralNetworksCompilation_finish. A compilation is destroyed by calling ANeuralNetworksCompilation_free.
A compilation cannot be modified once ANeuralNetworksCompilation_finish has been called on it.
It is the application's responsibility to make sure that only one thread modifies a compilation at a given time. It is however safe for more than one thread to use the compilation once ANeuralNetworksCompilation_finish has returned.
It is also the application's responsibility to ensure that there are no other uses of the compilation after calling ANeuralNetworksCompilation_free. This includes any execution object or burst object created using the compilation, or any memory descriptor with the compilation as part of one of the roles specified by ANeuralNetworksMemoryDesc_addInputRole or ANeuralNetworksMemoryDesc_addOutputRole.
Available since NNAPI feature level 1.
ANeuralNetworksDevice
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksDevice ANeuralNetworksDevice
ANeuralNetworksDevice is an opaque type that represents a device.
This type is used to query basic properties and supported operations of the corresponding device, and control which device(s) a model is to be run on.
Available since NNAPI feature level 3.
ANeuralNetworksEvent
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksEvent ANeuralNetworksEvent
ANeuralNetworksEvent is an opaque type that represents an event that will be signaled once an execution completes.
Available since NNAPI feature level 1.
ANeuralNetworksExecution
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksExecution ANeuralNetworksExecution
ANeuralNetworksExecution is an opaque type that can be used to apply a machine learning model to a set of inputs.
To use:
- Create a new execution instance by calling the ANeuralNetworksExecution_create function.
- Associate input buffers or memory regions to the model inputs with ANeuralNetworksExecution_setInput or ANeuralNetworksExecution_setInputFromMemory.
- Associate output buffers or memory regions to the model outputs with ANeuralNetworksExecution_setOutput or ANeuralNetworksExecution_setOutputFromMemory.
- Optionally, configure the execution with ANeuralNetworksExecution_setLoopTimeout, ANeuralNetworksExecution_setMeasureTiming, ANeuralNetworksExecution_setReusable, or ANeuralNetworksExecution_setTimeout.
- Apply the model with one of the following:
- Asynchronously with ANeuralNetworksExecution_startCompute or with ANeuralNetworksExecution_startComputeWithDependencies, waiting for the execution to complete with ANeuralNetworksEvent_wait.
- Synchronously with ANeuralNetworksExecution_compute.
- Synchronously as part of an execution burst with ANeuralNetworksExecution_burstCompute.
- Destroy the execution with ANeuralNetworksExecution_free.
An output buffer or memory region must not overlap with any other output buffer or memory region, with an input buffer or memory region, or with an operand value in a memory object (ANeuralNetworksModel_setOperandValueFromMemory).
An execution is in the preparation state after it is created by ANeuralNetworksExecution_create. An execution may only be modified in the preparation state. Scheduling a computation by calling ANeuralNetworksExecution_burstCompute, ANeuralNetworksExecution_compute, ANeuralNetworksExecution_startCompute, or ANeuralNetworksExecution_startComputeWithDependencies will change the state of the execution object to the computation state. When the computation completes, the state of the execution object will change from the computation state to the completed state. The computation is completed when ANeuralNetworksExecution_compute, ANeuralNetworksExecution_burstCompute, or ANeuralNetworksEvent_wait has returned.
An execution can be applied to a model with ANeuralNetworksExecution_burstCompute, ANeuralNetworksExecution_compute, ANeuralNetworksExecution_startCompute or ANeuralNetworksExecution_startComputeWithDependencies only once. Create new executions to do new evaluations of the model.
Starting at NNAPI feature level 5, the application may call ANeuralNetworksExecution_setReusable to set an execution to be reusable for multiple computations. The application may schedule and evaluate a computation again from the completed state of a reusable execution. The execution cannot be modified between computations.
It is the application's responsibility to make sure that only one thread modifies an execution at a given time. It is however safe for more than one thread to use ANeuralNetworksEvent_wait at the same time.
It is also the application's responsibility to ensure that the execution either has never been scheduled or has completed (i.e., that ANeuralNetworksExecution_burstCompute, ANeuralNetworksExecution_compute, or ANeuralNetworksEvent_wait has returned) before calling ANeuralNetworksExecution_free.
.
It is also the application's responsibility to ensure that there are no other uses of the execution after calling ANeuralNetworksExecution_free.
It is the application's responsibility to ensure that there are no concurrent computations scheduled and evaluated on the same execution, either by means of ANeuralNetworksExecution_compute or ANeuralNetworksExecution_burstCompute (which are synchronous) in different threads, or by means of ANeuralNetworksExecution_startCompute or ANeuralNetworksExecution_startComputeWithDependencies (which are asynchronous). It is however safe to schedule and evaluate multiple computations on different executions concurrently. (Concurrent uses of ANeuralNetworksExecution_burstCompute must be on different burst objects.) The runtime makes no guarantee on the ordering of completion of executions. If it's important to the application, the application should enforce the ordering by ensuring that one execution completes before the next is scheduled (for example, by scheduling all executions synchronously within a single thread, or by scheduling all executions asynchronously and using ANeuralNetworksEvent_wait between calls to ANeuralNetworksExecution_startCompute); or by using ANeuralNetworksExecution_startComputeWithDependencies to make the execution wait for a list of events to be signaled before starting the actual evaluation.
Available since NNAPI feature level 1.
ANeuralNetworksMemory
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksMemory ANeuralNetworksMemory
ANeuralNetworksMemory is an opaque type that represents memory.
This type is used to represent shared memory, memory mapped files, and similar memories.
By using shared memory, a program can efficiently communicate to the runtime and drivers the tensors that define a model. See ANeuralNetworksModel_setOperandValueFromMemory. An application should typically create one shared memory object that contains every constant tensor needed to define a model. ANeuralNetworksMemory_createFromFd can be used to create shared memory from a file handle. ANeuralNetworksMemory_createFromAHardwareBuffer can be used to create shared memory from an AHardwareBuffer handle.
Memory objects can also be used to specify the input and output arguments of an execution. See ANeuralNetworksExecution_setInputFromMemory and ANeuralNetworksExecution_setOutputFromMemory.
When calling ANeuralNetworksModel_setOperandValueFromMemory, ANeuralNetworksExecution_setInputFromMemory and ANeuralNetworksExecution_setOutputFromMemory, each operand in the shared memory object must be aligned on a boundary of a byte size that is a multiple of the element type byte size, e.g., a tensor with ANEURALNETWORKS_TENSOR_FLOAT32 type must be aligned on 4-byte boundary.
It is the application's responsibility to ensure that there are no uses of the memory after calling ANeuralNetworksMemory_free. This includes any model which references this memory because of a call to ANeuralNetworksModel_setOperandValueFromMemory, any compilation created using such a model, any execution object or burst object created using such a compilation, or any execution which references this memory because of a call to ANeuralNetworksExecution_setInputFromMemory or ANeuralNetworksExecution_setOutputFromMemory.
Available since NNAPI feature level 1.
Starting at NNAPI feature level 4, the application may request creation of device native memory from ANeuralNetworksMemoryDesc to avoid potential memory copying and transformation overhead between executions. See also ANeuralNetworksMemoryDesc and ANeuralNetworksMemory_createFromDesc.
ANeuralNetworksMemoryDesc
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksMemoryDesc ANeuralNetworksMemoryDesc
ANeuralNetworksMemoryDesc is an opaque type that represents a memory descriptor.
A memory descriptor describes the properties of a memory object, and is used by ANeuralNetworksMemory_createFromDesc.
To use:
- Create a new memory descriptor by calling ANeuralNetworksMemoryDesc_create.
- Specify all of the intended input and output roles by calling ANeuralNetworksMemoryDesc_addInputRole and ANeuralNetworksMemoryDesc_addOutputRole.
- Optionally, specify the memory dimensions by calling ANeuralNetworksMemoryDesc_setDimensions.
- Complete the memory descriptor with ANeuralNetworksMemoryDesc_finish.
- Use the memory descriptor as many times as needed with ANeuralNetworksMemory_createFromDesc.
- Destroy the memory descriptor with ANeuralNetworksMemoryDesc_free.
A memory descriptor is completed by calling ANeuralNetworksMemoryDesc_finish. A memory descriptor is destroyed by calling ANeuralNetworksMemoryDesc_free.
A memory descriptor must not be modified once ANeuralNetworksMemoryDesc_finish has been called on it.
It is the application's responsibility to make sure that only one thread modifies a memory descriptor at a given time. It is however safe for more than one thread to use the memory descriptor once ANeuralNetworksMemoryDesc_finish has returned.
It is also the application's responsibility to ensure that there are no other uses of the memory descriptor after calling ANeuralNetworksMemoryDesc_free. It is however safe to continue using a ANeuralNetworksMemory object created from the memory descriptor.
Available since NNAPI feature level 4.
ANeuralNetworksModel
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksModel ANeuralNetworksModel
ANeuralNetworksModel is an opaque type that contains a description of the mathematical operations that constitute the model.
Build the model by calling
This forms a graph in which each operation and operand is a node, a directed edge from an operand to an operation indicates that the operand is an input to the operation, and a directed edge from an operation to an operand indicates that the operand is an output from the operation. This graph must be acyclic.
A model is completed by calling ANeuralNetworksModel_finish. A model is destroyed by calling ANeuralNetworksModel_free.
A model cannot be modified once ANeuralNetworksModel_finish has been called on it.
It is the application's responsibility to make sure that only one thread modifies a model at a given time. It is however safe for more than one thread to use the model once ANeuralNetworksModel_finish has returned.
It is also the application's responsibility to ensure that there are no other uses of the model after calling ANeuralNetworksModel_free. This includes any compilation, execution object or burst object created using the model.
Available since NNAPI feature level 1.
ANeuralNetworksOperandType
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksOperandType ANeuralNetworksOperandType
ANeuralNetworksOperandType describes the type of an operand.
This structure is used to describe both scalars and tensors.
A tensor operand type with all dimensions specified is "fully specified". Whenever possible (i.e., whenever the dimensions are known at model construction time), a tensor operand type should be (but is not required to be) fully specified, in order to enable the best possible performance.
If a tensor operand's type is not fully specified, the dimensions of the operand are deduced from the operand types and values of the operation for which that operand is an output or from the corresponding ANEURALNETWORKS_IF or ANEURALNETWORKS_WHILE operation input operand type in the case of referenced model input operands.
In the following situations, a tensor operand type must be fully specified:
- The operand has a constant value, set by ANeuralNetworksModel_setOperandValue (with a non-nullptr buffer) or ANeuralNetworksModel_setOperandValueFromMemory.
- The operand is a model input (see ANeuralNetworksModel_identifyInputsAndOutputs) of the main model within a compilation. A fully specified tensor operand type must either be provided to ANeuralNetworksModel_addOperand; or it must be provided to the corresponding ANeuralNetworksExecution_setInput, or ANeuralNetworksExecution_setInputFromMemory. EXCEPTION: If the input is optional and omitted (by passing nullptr for buffer to ANeuralNetworksExecution_setInput) then it need not have a fully specified tensor operand type.
- The operand is a model output (see ANeuralNetworksModel_identifyInputsAndOutputs) of the main model within a compilation and is to be used with ANeuralNetworksExecution_startComputeWithDependencies. A fully specified tensor operand type must either be provided to ANeuralNetworksModel_addOperand; or it must be provided to the corresponding ANeuralNetworksExecution_setOutput, or ANeuralNetworksExecution_setOutputFromMemory.
A tensor operand type of specified rank but some number of unspecified dimensions is represented by setting dimensionCount to the rank and each unspecified dimension to 0.
Available since NNAPI feature level 1.
Starting at NNAPI feature level 3, a tensor operand type of unspecified rank is represented by setting dimensionCount to 0 and dimensions to NULL (just as if it were a scalar operand type).
ANeuralNetworksOperationType
Declared inandroid/NeuralNetworksTypes.h
int32_t ANeuralNetworksOperationType
Aliasing to OperationCode, used in function ANeuralNetworksModel_addOperation.
ANeuralNetworksSymmPerChannelQuantParams
Declared inandroid/NeuralNetworksTypes.h
struct ANeuralNetworksSymmPerChannelQuantParams ANeuralNetworksSymmPerChannelQuantParams
Parameters for ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL operand.
Functions
ANeuralNetworksBurst_create
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksBurst_create( ANeuralNetworksCompilation *compilation, ANeuralNetworksBurst **burst )
Create a ANeuralNetworksBurst to apply the given compilation.
This only creates the burst object. Computation is only performed once ANeuralNetworksExecution_burstCompute is invoked with a valid ANeuralNetworksExecution and ANeuralNetworksBurst.
The provided compilation must outlive the burst object.
Available since NNAPI feature level 3.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_BAD_DATA if the compilation is invalid.
|
ANeuralNetworksBurst_free
Declared inandroid/NeuralNetworks.h
void ANeuralNetworksBurst_free( ANeuralNetworksBurst *burst )
Destroys the burst object.
Available since NNAPI feature level 3.
Details | |||
---|---|---|---|
Parameters |
|
ANeuralNetworksCompilation_create
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_create( ANeuralNetworksModel *model, ANeuralNetworksCompilation **compilation )
Create a ANeuralNetworksCompilation to compile the given model.
The model passed to this function is termed the "main model" of the compilation, to distinguish it from other models referred to by an Operand of type ANEURALNETWORKS_MODEL within this compilation.
This function only creates the object. Compilation is only performed once ANeuralNetworksCompilation_finish is invoked.
ANeuralNetworksCompilation_finish should be called once all desired properties have been set on the compilation.
ANeuralNetworksModel_free should be called once the compilation is no longer needed.
The provided model must outlive the compilation.
The model must already have been finished by a call to ANeuralNetworksModel_finish.
See ANeuralNetworksCompilation for information on multithreaded usage.
Available since NNAPI feature level 1.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_BAD_DATA if the model is invalid.
|
ANeuralNetworksCompilation_createForDevices
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_createForDevices( ANeuralNetworksModel *model, const ANeuralNetworksDevice *const *devices, uint32_t numDevices, ANeuralNetworksCompilation **compilation )
Create a ANeuralNetworksCompilation to compile the given model for a specified set of devices.
If more than one device is specified, the compilation will distribute the workload automatically across the devices. The model must be fully supported by the specified set of devices. This means that ANeuralNetworksModel_getSupportedOperationsForDevices() must have returned true for every operation for that model/devices pair.
The user must handle all compilation and execution failures from the specified set of devices. This is in contrast to a use of ANeuralNetworksCompilation_create, where the runtime will attempt to recover from such failures.
The model passed to this function is termed the "main model" of the compilation, to distinguish it from other models referred to by an Operand of type ANEURALNETWORKS_MODEL within this compilation.
Available since NNAPI feature level 3.
Details | |||||||||
---|---|---|---|---|---|---|---|---|---|
Parameters |
|
||||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_BAD_DATA if the model is invalid.
|
ANeuralNetworksCompilation_finish
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_finish( ANeuralNetworksCompilation *compilation )
Indicate that we have finished modifying a compilation.
Required before calling ANeuralNetworksBurst_create or ANeuralNetworksExecution_create.
An application must ensure that no other thread uses the compilation at the same time.
This function must only be called once for a given compilation.
If ANeuralNetworksCompilation_setTimeout was called on this compilation, and the compilation is not able to be finished before the timeout duration is exceeded, then compilation may be aborted, in which case ANEURALNETWORKS_MISSED_DEADLINE_* ResultCode will be returned.
See ANeuralNetworksCompilation for information on multithreaded usage.
Available since NNAPI feature level 1.
Details | |||
---|---|---|---|
Parameters |
|
||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksCompilation_free
Declared inandroid/NeuralNetworks.h
void ANeuralNetworksCompilation_free( ANeuralNetworksCompilation *compilation )
Destroy a compilation.
The compilation need not have been finished by a call to ANeuralNetworksCompilation_finish.
See ANeuralNetworksCompilation for information on multithreaded usage.
Available since NNAPI feature level 1.
Details | |||
---|---|---|---|
Parameters |
|
ANeuralNetworksCompilation_getPreferredMemoryAlignmentForInput
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_getPreferredMemoryAlignmentForInput( const ANeuralNetworksCompilation *compilation, uint32_t index, uint32_t *alignment )
Get the preferred buffer and memory alignment of an input to an execution created from a particular compilation.
The user may use the returned alignment value to guide the layout of the input buffer or memory pool. To achieve the best performance, make sure the address of the buffer passed in ANeuralNetworksExecution_setInput, or the offset value passed in ANeuralNetworksExecution_setInputFromMemory, is a multiple of the perferred alignment value of the same input. A driver may choose to allocate a separate buffer and do memory copying if the provided buffer or memory does not satisfy the preferred alignment.
See ANeuralNetworksCompilation for information on multithreaded usage.
Available since NNAPI feature level 5.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameters |
|
||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful. ANEURALNETWORKS_UNEXPECTED_NULL if either compilation or alignment is NULL. ANEURALNETWORKS_BAD_STATE if the compilation has not been finished. ANEURALNETWORKS_BAD_DATA if the index is out of range.
|
ANeuralNetworksCompilation_getPreferredMemoryAlignmentForOutput
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_getPreferredMemoryAlignmentForOutput( const ANeuralNetworksCompilation *compilation, uint32_t index, uint32_t *alignment )
Get the preferred buffer and memory alignment of an output to an execution created from a particular compilation.
The user may use the returned alignment value to guide the layout of the output buffer or memory pool. To achieve the best performance, make sure the address of the buffer passed in ANeuralNetworksExecution_setOutput, or the offset value passed in ANeuralNetworksExecution_setOutputFromMemory, is a multiple of the perferred alignment value of the same output. A driver may choose to allocate a separate buffer and do memory copying if the provided buffer or memory does not satisfy the preferred alignment.
See ANeuralNetworksCompilation for information on multithreaded usage.
Available since NNAPI feature level 5.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameters |
|
||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful. ANEURALNETWORKS_UNEXPECTED_NULL if either compilation or alignment is NULL. ANEURALNETWORKS_BAD_STATE if the compilation has not been finished. ANEURALNETWORKS_BAD_DATA if the index is out of range.
|
ANeuralNetworksCompilation_getPreferredMemoryPaddingForInput
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_getPreferredMemoryPaddingForInput( const ANeuralNetworksCompilation *compilation, uint32_t index, uint32_t *padding )
Get the preferred buffer and memory end padding of an input to an execution created from a particular compilation.
The user may use the returned padding value to guide the layout of the input buffer or memory pool. To achieve the best performance, make sure the length value passed in ANeuralNetworksExecution_setInput or ANeuralNetworksExecution_setInputFromMemory is greater than or equal to the raw size of the input (i.e. the size of an element multiplied by the number of elements) rounding up to a multiple of the perferred padding value of the same input. A driver may choose to allocate a separate buffer and do memory copying if the provided buffer or memory value does not satisfy the preferred padding.
See ANeuralNetworksCompilation for information on multithreaded usage. See ANeuralNetworksExecution_enableInputAndOutputPadding, ANeuralNetworksExecution_setInput, and ANeuralNetworksExecution_setInputFromMemory for information on passing input buffer or memory padding to the driver.
Available since NNAPI feature level 5.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameters |
|
||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful. ANEURALNETWORKS_UNEXPECTED_NULL if either compilation or padding is NULL. ANEURALNETWORKS_BAD_STATE if the compilation has not been finished. ANEURALNETWORKS_BAD_DATA if the index is out of range.
|
ANeuralNetworksCompilation_getPreferredMemoryPaddingForOutput
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_getPreferredMemoryPaddingForOutput( const ANeuralNetworksCompilation *compilation, uint32_t index, uint32_t *padding )
Get the preferred memory end padding of an output to an execution created from a particular compilation.
The user may use the returned padding value to guide the layout of the output buffer or memory pool. To achieve the best performance, make sure the length value passed in ANeuralNetworksExecution_setOutput or ANeuralNetworksExecution_setOutputFromMemory is greater than or equal to the raw size of the output (i.e. the size of an element multiplied by the number of elements) rounding up to a multiple of the perferred padding value of the same output. A driver may choose to allocate a separate buffer and do memory copying if the provided buffer or memory value does not satisfy the preferred padding.
See ANeuralNetworksCompilation for information on multithreaded usage. See ANeuralNetworksExecution_enableInputAndOutputPadding, ANeuralNetworksExecution_setOutput, and ANeuralNetworksExecution_setOutputFromMemory for information on passing output buffer or memory padding to the driver.
Available since NNAPI feature level 5.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameters |
|
||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful. ANEURALNETWORKS_UNEXPECTED_NULL if either compilation or padding is NULL. ANEURALNETWORKS_BAD_STATE if the compilation has not been finished. ANEURALNETWORKS_BAD_DATA if the index is out of range.
|
ANeuralNetworksCompilation_setCaching
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_setCaching( ANeuralNetworksCompilation *compilation, const char *cacheDir, const uint8_t *token )
Sets the compilation caching signature and the cache directory.
Provides optional caching information to the runtime for faster repeated compilation.
See ANeuralNetworksCompilation for information on multithreaded usage.
Available since NNAPI feature level 3.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameters |
|
||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksCompilation_setPreference
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_setPreference( ANeuralNetworksCompilation *compilation, int32_t preference )
Sets the execution preference.
Provides guidance to the runtime when trade-offs are possible. By default the runtime uses PREFER_SINGLE_FAST_ANSWER
See ANeuralNetworksCompilation for information on multithreaded usage.
Available since NNAPI feature level 1.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksCompilation_setPriority
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_setPriority( ANeuralNetworksCompilation *compilation, int priority )
Set the execution priority.
Execution priorities are relative to other executions created by the same application (specifically same uid) for the same device. Specifically, priorities of executions from one application will not affect executions from another application. Similarly, priorities of executions on one device will not affect executions on another device.
Higher priority executions may use more compute resources than lower priority executions, and may preempt or starve lower priority executions.
See ANeuralNetworksCompilation for information on multithreaded usage.
Available since NNAPI feature level 4.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksCompilation_setTimeout
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksCompilation_setTimeout( ANeuralNetworksCompilation *compilation, uint64_t duration )
Set the maximum expected duration for compiling the model.
If the device is not able to complete the compilation within the specified duration, the compilation may be aborted. The timeout duration begins at the call to ANeuralNetworksCompilation_finish.
This timeout duration acts as a hint to drivers, and can be used to both free up compute resources within the driver and return control back to the application quicker than is possible without the hint. It enables drivers that are able to estimate how long a compilation will take to abort the compilation before it has even started if the driver believes the compilation cannot be completed within the timeout duration. Similarly, it enables drivers to abort an ongoing compilation if it is taking too long. However, this call does not guarantee that the compilation will complete or abort within the timeout duration.
By default (i.e., unless ANeuralNetworksCompilation_setTimeout is called), the timeout duration for compiling the model is considered infinite.
The ANeuralNetworksCompilation must have been created with ANeuralNetworksCompilation_createForDevices with numDevices = 1, otherwise this function will fail with ANEURALNETWORKS_BAD_DATA. If the device has a feature level reported by ANeuralNetworksDevice_getFeatureLevel that is lower than ANEURALNETWORKS_FEATURE_LEVEL_4, then the timeout duration hint will be ignored.
See ANeuralNetworksCompilation for information on multithreaded usage.
Available since NNAPI feature level 4.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksDevice_getFeatureLevel
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksDevice_getFeatureLevel( const ANeuralNetworksDevice *device, int64_t *featureLevel )
Get the NNAPI feature level of the specified NNAPI device.
Each device has a supported feature level, which is the most advanced NNAPI specification and features this driver implements. For example, if the driver implements the features introduced in ANEURALNETWORKS_FEATURE_LEVEL_2, but does not implement the features introduced after ANEURALNETWORKS_FEATURE_LEVEL_2, the value would be ANEURALNETWORKS_FEATURE_LEVEL_2. Developers could decide whether or not the specified device should be used for a model that has certain feature requirements.
NNAPI device feature level is closely related to NNAPI runtime feature level (ANeuralNetworks_getRuntimeFeatureLevel), which indicates an NNAPI runtime feature level (the most advanced NNAPI specification and features that the runtime implements). An NNAPI device feature level is always less than or equal to the runtime feature level.
This function produces a FeatureLevelCode enum value, NOT an Android API level.
Available since NNAPI feature level 3.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksDevice_getName
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksDevice_getName( const ANeuralNetworksDevice *device, const char **name )
Get the name of the specified device.
Available since NNAPI feature level 3.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksDevice_getType
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksDevice_getType( const ANeuralNetworksDevice *device, int32_t *type )
Get the type of a given device.
The device type can be used to help application developers to distribute Machine Learning workloads and other workloads such as graphical rendering. E.g., for an app which renders AR scenes based on real time object detection results, the developer could choose an ACCELERATOR type device for ML workloads, and reserve GPU for graphical rendering.
Available since NNAPI feature level 3.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksDevice_getVersion
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksDevice_getVersion( const ANeuralNetworksDevice *device, const char **version )
Get the version of the driver implementation of the specified device.
It’s the responsibility of the driver implementor to insure that this version string uniquely distinguishes this implementation from all previous implementations.
This version string must not be confused with the feature level which is solely defined by ANeuralNetworksDevice_getFeatureLevel. There is no implicit ordering of the versions. For example, it is not possible to filter all drivers older than a certain version.
Application developers may use this version string to avoid or prefer specific driver implementations. For example, an application may want to do so because:
- A specific version of the driver does not provide the required performance, perhaps because of a performance regression.
- A specific version of the driver has a bug or returns results that don’t match the minimum precision requirement for the application.
Available since NNAPI feature level 3.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksDevice_wait
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksDevice_wait( const ANeuralNetworksDevice *device )
Wait until the device is in a live state.
A device may encounter internal errors and temporarily enter a dead state. A call that uses a device in such a state will return with the error ANEURALNETWORKS_DEAD_OBJECT. ANeuralNetworksDevice_wait will block until the device is in a live state.
Available since NNAPI feature level 4.
Details | |||
---|---|---|---|
Parameters |
|
||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksEvent_createFromSyncFenceFd
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksEvent_createFromSyncFenceFd( int sync_fence_fd, ANeuralNetworksEvent **event )
Create a ANeuralNetworksEvent from a sync_fence file descriptor.
The newly created ANeuralNetworksEvent does not take ownership of the provided sync_fence_fd, it will instead dup the provided sync_fence_fd and own the duplicate.
Available since NNAPI feature level 4.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksEvent_free
Declared inandroid/NeuralNetworks.h
void ANeuralNetworksEvent_free( ANeuralNetworksEvent *event )
Destroys the event.
See ANeuralNetworksExecution for information on multithreaded usage.
Available since NNAPI feature level 1.
Details | |||
---|---|---|---|
Parameters |
|
ANeuralNetworksEvent_getSyncFenceFd
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksEvent_getSyncFenceFd( const ANeuralNetworksEvent *event, int *sync_fence_fd )
Get sync_fence file descriptor from the event.
If the ANeuralNetworksEvent is not backed by a sync fence, the sync_fence_fd will be set to -1, and ANEURALNETWORKS_BAD_DATA will be returned.
See ANeuralNetworksEvent_createFromSyncFenceFd and ANeuralNetworksExecution_startComputeWithDependencies to see how to create an event backed by a sync fence.
The user takes ownership of the returned fd, and must close the returned file descriptor when it is no longer needed.
Available since NNAPI feature level 4.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksEvent_wait
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksEvent_wait( ANeuralNetworksEvent *event )
Waits until the execution completes.
More than one thread can wait on an event. When the execution completes, all threads will be released.
If ANeuralNetworksExecution_setTimeout was called on the execution corresponding to this event, and the execution is not able to complete before the duration is exceeded, the execution may be aborted, in which case ANEURALNETWORKS_MISSED_DEADLINE_* ResultCode will be returned here.
If the execution contains a ANEURALNETWORKS_WHILE operation, and the condition model does not output false within the loop timeout duration, the execution will be aborted, and ANEURALNETWORKS_MISSED_DEADLINE_* ResultCode will be returned here.
See ANeuralNetworksExecution for information on execution states and multithreaded usage.
Available since NNAPI feature level 1.
Details | |||
---|---|---|---|
Parameters |
|
||
Returns |
ANEURALNETWORKS_NO_ERROR if the execution completed normally. ANEURALNETWORKS_UNMAPPABLE if the execution input or output memory cannot be properly mapped.
|
ANeuralNetworksExecution_burstCompute
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksExecution_burstCompute( ANeuralNetworksExecution *execution, ANeuralNetworksBurst *burst )
Schedule synchronous evaluation of the execution on a burst object.
Schedules synchronous evaluation of the execution. Returns once the execution has completed and the outputs are ready to be consumed.
If ANeuralNetworksExecution_setTimeout was called on the execution, and the execution is not able to complete before the timeout duration is exceeded, then execution may be aborted, in which case ANEURALNETWORKS_MISSED_DEADLINE_* ResultCode will be returned.
If the execution contains a ANEURALNETWORKS_WHILE operation, and the condition model does not output false within the loop timeout duration, then execution will be aborted and ANEURALNETWORKS_MISSED_DEADLINE_* ResultCode will be returned. If the device has a feature level reported by ANeuralNetworksDevice_getFeatureLevel that is lower than ANEURALNETWORKS_FEATURE_LEVEL_4, then the timeout duration hint will be ignored.
There must be at most one ANeuralNetworksExecution processing at any given time for any given burst object. Any ANeuralNetworksExecution launched before the previous has finished will result in ANEURALNETWORKS_BAD_STATE.
Before NNAPI feature level 5, this function may only be invoked when the execution is in the preparation state. Starting at NNAPI feature level 5, if the user sets the execution to be reusable by ANeuralNetworksExecution_setReusable, this function may also be invoked when the execution is in the completed state.
See ANeuralNetworksExecution for information on execution states and multithreaded usage.
See ANeuralNetworksExecution_compute for synchronous execution. See ANeuralNetworksExecution_startCompute for regular asynchronous execution. See ANeuralNetworksExecution_startComputeWithDependencies for asynchronous execution with dependencies.
Available since NNAPI feature level 3.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if the execution completed normally.
|
ANeuralNetworksExecution_compute
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksExecution_compute( ANeuralNetworksExecution *execution )
Schedule synchronous evaluation of the execution.
Schedules synchronous evaluation of the execution. Returns once the execution has completed and the outputs are ready to be consumed.
If ANeuralNetworksExecution_setTimeout was called on this execution, and the execution is not able to complete before the timeout duration is exceeded, then execution may be aborted, in which case ANEURALNETWORKS_MISSED_DEADLINE_* ResultCode will be returned. If the device has a feature level reported by ANeuralNetworksDevice_getFeatureLevel that is lower than 30, then the timeout duration hint will be ignored.
If this execution contains a ANEURALNETWORKS_WHILE operation, and the condition model does not output false within the loop timeout duration, then execution will be aborted and ANEURALNETWORKS_MISSED_DEADLINE_* ResultCode will be returned.
Before NNAPI feature level 5, this function may only be invoked when the execution is in the preparation state. Starting at NNAPI feature level 5, if the user sets the execution to be reusable by ANeuralNetworksExecution_setReusable, this function may also be invoked when the execution is in the completed state.
See ANeuralNetworksExecution for information on execution states and multithreaded usage.
See ANeuralNetworksExecution_burstCompute for burst synchronous execution. See ANeuralNetworksExecution_startCompute for regular asynchronous execution. See ANeuralNetworksExecution_startComputeWithDependencies for asynchronous execution with dependencies.
Available since NNAPI feature level 3.
Details | |||
---|---|---|---|
Parameters |
|
||
Returns |
ANEURALNETWORKS_NO_ERROR if the execution completed normally. ANEURALNETWORKS_UNMAPPABLE if the execution input or output memory cannot be properly mapped.
|
ANeuralNetworksExecution_create
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksExecution_create( ANeuralNetworksCompilation *compilation, ANeuralNetworksExecution **execution )
Create a ANeuralNetworksExecution to apply the given compilation.
This only creates the object. Computation is only performed once ANeuralNetworksExecution_burstCompute, ANeuralNetworksExecution_compute, ANeuralNetworksExecution_startCompute or ANeuralNetworksExecution_startComputeWithDependencies is invoked.
The provided compilation must outlive the execution.
See ANeuralNetworksExecution for information on multithreaded usage.
Available since NNAPI feature level 1.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_BAD_DATA if the compilation is invalid.
|
ANeuralNetworksExecution_enableInputAndOutputPadding
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksExecution_enableInputAndOutputPadding( ANeuralNetworksExecution *execution, bool enable )
Specifies whether the ANeuralNetworksExecution is able to accept padded input and output buffers and memory objects.
By default, the input and output buffers and memory objects of ANeuralNetworksExecution do not allow padding.
Setting the execution to accept padded input and output buffers and memory objects enables the length argument of ANeuralNetworksExecution_setInput, ANeuralNetworksExecution_setInputFromMemory, ANeuralNetworksExecution_setOutput, and ANeuralNetworksExecution_setOutputFromMemory to be greater than the raw size of the operand (i.e. the size of an element multiplied by the number of elements). The extra bytes at the end of the buffer or memory region may be used by the driver to access data in chunks, for efficiency.
This method must not be called after ANeuralNetworksExecution_setInput, ANeuralNetworksExecution_setInputFromMemory, ANeuralNetworksExecution_setOutput, or ANeuralNetworksExecution_setOutputFromMemory.
See ANeuralNetworksExecution for information on multithreaded usage.
Available since NNAPI feature level 5.
Details | |||||
---|---|---|---|---|---|
Parameters |
|
||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful. ANEURALNETWORKS_UNEXPECTED_NULL if execution is NULL. ANEURALNETWORKS_BAD_STATE if ANeuralNetworksExecution_setInput, ANeuralNetworksExecution_setInputFromMemory, ANeuralNetworksExecution_setOutput, or ANeuralNetworksExecution_setOutputFromMemory has been called on the execution.
|
ANeuralNetworksExecution_free
Declared inandroid/NeuralNetworks.h
void ANeuralNetworksExecution_free( ANeuralNetworksExecution *execution )
Destroy an execution.
The execution need not have been scheduled by a call to ANeuralNetworksExecution_burstCompute, ANeuralNetworksExecution_compute, ANeuralNetworksExecution_startCompute or ANeuralNetworksExecution_startComputeWithDependencies; but if it has been scheduled, then the application must not call ANeuralNetworksExecution_free until the execution has completed (i.e., ANeuralNetworksExecution_burstCompute, ANeuralNetworksExecution_compute, or ANeuralNetworksEvent_wait has returned).
See ANeuralNetworksExecution for information on multithreaded usage.
Available since NNAPI feature level 1.
Details | |||
---|---|---|---|
Parameters |
|
ANeuralNetworksExecution_getDuration
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksExecution_getDuration( const ANeuralNetworksExecution *execution, int32_t durationCode, uint64_t *duration )
Get the time spent in the latest computation evaluated on the specified ANeuralNetworksExecution, in nanoseconds.
This function may only be invoked when the execution is in the completed state.
See ANeuralNetworksExecution for information on execution states.
Available since NNAPI feature level 3.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameters |
|
||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful.
|
ANeuralNetworksExecution_getOutputOperandDimensions
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksExecution_getOutputOperandDimensions( ANeuralNetworksExecution *execution, int32_t index, uint32_t *dimensions )
Get the dimensional information of the specified output operand of the model of the latest computation evaluated on ANeuralNetworksExecution.
The target output operand cannot be a scalar.
This function may only be invoked when the execution is in the completed state.
See ANeuralNetworksExecution for information on execution states.
Available since NNAPI feature level 3.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameters |
|
||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_OUTPUT_INSUFFICIENT_SIZE if the target output is provided an insufficient buffer at execution time, ANEURALNETWORKS_BAD_DATA if the index is invalid or if the target is a scalar.
|
ANeuralNetworksExecution_getOutputOperandRank
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksExecution_getOutputOperandRank( ANeuralNetworksExecution *execution, int32_t index, uint32_t *rank )
Get the dimensional information of the specified output operand of the model of the latest computation evaluated on ANeuralNetworksExecution.
This function may only be invoked when the execution is in the completed state.
See ANeuralNetworksExecution for information on execution states.
Available since NNAPI feature level 3.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameters |
|
||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_OUTPUT_INSUFFICIENT_SIZE if the target output is provided an insufficient buffer at execution time, ANEURALNETWORKS_BAD_DATA if the index is invalid.
|
ANeuralNetworksExecution_setInput
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksExecution_setInput( ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, const void *buffer, size_t length )
Associate a user buffer with an input of the model of the ANeuralNetworksExecution.
Evaluation of the execution must not have been scheduled. Once evaluation of the execution has been scheduled, the application must not change the content of the buffer until the execution has completed. Evaluation of the execution will not change the content of the buffer.
The provided buffer must outlive the execution.
If the input is optional, you can indicate that it is omitted by passing nullptr for buffer and 0 for length.
Otherwise, if the user has not set the execution to accept padded input buffers by calling ANeuralNetworksExecution_enableInputAndOutputPadding, then the length argument must be equal to the raw size of the input (i.e. the size of an element multiplied by the number of elements). Passing a length argument with value not equal to the raw size of the input will result in ANEURALNETWORKS_BAD_DATA.
Otherwise, if the user has set the execution to accept padded input buffers by calling ANeuralNetworksExecution_enableInputAndOutputPadding, the length argument may be greater than the raw size of the input, and the extra bytes at the end of the buffer may be used by the driver to access data in chunks, for efficiency. Passing a length argument with value less than the raw size of the input will result in ANEURALNETWORKS_BAD_DATA.
This function may only be invoked when the execution is in the preparation state.
See ANeuralNetworksExecution for information on execution states and multithreaded usage. See ANeuralNetworksCompilation_getPreferredMemoryAlignmentForInput and ANeuralNetworksCompilation_getPreferredMemoryPaddingForInput for information on getting preferred buffer alignment and padding, to improve performance.
Available since NNAPI feature level 1.
Details | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parameters |
|
||||||||||
Returns |
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_BAD_DATA if the name is not recognized or the buffer is too small for the input.
|
ANeuralNetworksExecution_setInputFromMemory
Declared inandroid/NeuralNetworks.h
int ANeuralNetworksExecution_setInputFromMemory( ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, const ANeuralNetworksMemory *memory, size_t offset, size_t length )
Associate a region of a memory object with an input of the model of the ANeuralNetworksExecution.
Evaluation of the execution must not have been scheduled. Once evaluation of the execution has been scheduled, the application must not change the content of the region until the execution has completed. Evaluation of the execution will not change the content of the region.
The provided memory must outlive the execution.
If the input is optional, you can indicate that it is omitted by using ANeuralNetworksExecution_setInput instead, passing nullptr for buffer and 0 for length.
If the memory is an AHardwareBuffer of a format other than AHARDWAREBUFFER_FORMAT_BLOB created from ANeuralNetworksMemory_createFromAHardwareBuffer, or an opaque memory object created from ANeuralNetworksMemory_createFromDesc, both offset and length must be 0, indicating the whole memory is used.
Otherwise, if the user has not set the execution to accept padded input memory objects by calling ANeuralNetworksExecution_enableInputAndOutputPadding, then the length argument must be equal to the raw size of the input (i.e. the size of an element multiplied by the number of elements). Passing a length argument with value not equal to the raw size of the input will result in ANEURALNETWORKS_BAD_DATA.
Otherwise, if the user has set the execution to accept padded input memory objects by calling ANeuralNetworksExecution_enableInputAndOutputPadding, the length argument may be greater than the raw size of the input, and the extra bytes at the end of the memory region may be used by the driver to access data in chunks, for efficiency. Passing a length argument with value less than the raw size of the input will result in ANEURALNETWORKS_BAD_DATA.
This function may only be invoked when the execution is in the preparation state.
See ANeuralNetworksExecution for information on execution states and multithreaded usage. See ANeuralNetworksMemory_createFromAHardwareBuffer for information on AHardwareBuffer usage. See ANeuralNetworksMemory_createFromDesc for information on usage of memory objects created from memory descriptors. See ANeuralNetworksCompilation_getPreferredMemoryAlignmentForInput and ANeuralNetworksCompilation_getPreferredMemoryPaddingForInput for information on getting preferred memory alignment and padding, to improve performance.
Available since NNAPI feature level 1.
Details | |||||
---|---|---|---|---|---|
Parameters |
|