Skip to content

Most visited

Recently visited

navigation

NeuralNetworks

NeuralNetworks

Files

file  NeuralNetworks.h
 

Data Structures

struct  ANeuralNetworksOperandType
 

Typedefs

typedef struct ANeuralNetworksMemory ANeuralNetworksMemory
 
typedef struct ANeuralNetworksModel ANeuralNetworksModel
 
typedef struct ANeuralNetworksCompilation ANeuralNetworksCompilation
 
typedef struct ANeuralNetworksExecution ANeuralNetworksExecution
 
typedef struct ANeuralNetworksOperandType ANeuralNetworksOperandType
 
typedef int32_t ANeuralNetworksOperationType
 
typedef struct ANeuralNetworksEvent ANeuralNetworksEvent
 

Enumerations

enum  OperandCode {
  ANEURALNETWORKS_FLOAT32 = 0, ANEURALNETWORKS_INT32 = 1, ANEURALNETWORKS_UINT32 = 2, ANEURALNETWORKS_TENSOR_FLOAT32 = 3,
  ANEURALNETWORKS_TENSOR_INT32 = 4, ANEURALNETWORKS_TENSOR_QUANT8_ASYMM = 5
}
 
enum  OperationCode {
  ANEURALNETWORKS_ADD = 0, ANEURALNETWORKS_AVERAGE_POOL_2D = 1, ANEURALNETWORKS_CONCATENATION = 2, ANEURALNETWORKS_CONV_2D = 3,
  ANEURALNETWORKS_DEPTHWISE_CONV_2D = 4, ANEURALNETWORKS_DEPTH_TO_SPACE = 5, ANEURALNETWORKS_DEQUANTIZE = 6, ANEURALNETWORKS_EMBEDDING_LOOKUP = 7,
  ANEURALNETWORKS_FLOOR = 8, ANEURALNETWORKS_FULLY_CONNECTED = 9, ANEURALNETWORKS_HASHTABLE_LOOKUP = 10, ANEURALNETWORKS_L2_NORMALIZATION = 11,
  ANEURALNETWORKS_L2_POOL_2D = 12, ANEURALNETWORKS_LOCAL_RESPONSE_NORMALIZATION = 13, ANEURALNETWORKS_LOGISTIC = 14, ANEURALNETWORKS_LSH_PROJECTION = 15,
  ANEURALNETWORKS_LSTM = 16, ANEURALNETWORKS_MAX_POOL_2D = 17, ANEURALNETWORKS_MUL = 18, ANEURALNETWORKS_RELU = 19,
  ANEURALNETWORKS_RELU1 = 20, ANEURALNETWORKS_RELU6 = 21, ANEURALNETWORKS_RESHAPE = 22, ANEURALNETWORKS_RESIZE_BILINEAR = 23,
  ANEURALNETWORKS_RNN = 24, ANEURALNETWORKS_SOFTMAX = 25, ANEURALNETWORKS_SPACE_TO_DEPTH = 26, ANEURALNETWORKS_SVDF = 27,
  ANEURALNETWORKS_TANH = 28
}
 
enum  FuseCode { ANEURALNETWORKS_FUSED_NONE = 0, ANEURALNETWORKS_FUSED_RELU = 1, ANEURALNETWORKS_FUSED_RELU1 = 2, ANEURALNETWORKS_FUSED_RELU6 = 3 }
 
enum  PaddingCode { ANEURALNETWORKS_PADDING_SAME = 1, ANEURALNETWORKS_PADDING_VALID = 2 }
 
enum  PreferenceCode { ANEURALNETWORKS_PREFER_LOW_POWER = 0, ANEURALNETWORKS_PREFER_FAST_SINGLE_ANSWER = 1, ANEURALNETWORKS_PREFER_SUSTAINED_SPEED = 2 }
 
enum  ResultCode {
  ANEURALNETWORKS_NO_ERROR = 0, ANEURALNETWORKS_OUT_OF_MEMORY = 1, ANEURALNETWORKS_INCOMPLETE = 2, ANEURALNETWORKS_UNEXPECTED_NULL = 3,
  ANEURALNETWORKS_BAD_DATA = 4, ANEURALNETWORKS_OP_FAILED = 5, ANEURALNETWORKS_UNMAPPABLE = 5, ANEURALNETWORKS_BAD_STATE = 6
}
 
enum  { ANEURALNETWORKS_MAX_SIZE_OF_IMMEDIATELY_COPIED_VALUES = 128 }
 

Functions

int ANeuralNetworksMemory_createFromFd (size_t size, int protect, int fd, size_t offset, ANeuralNetworksMemory **memory)
 
void ANeuralNetworksMemory_free (ANeuralNetworksMemory *memory)
 
int ANeuralNetworksModel_create (ANeuralNetworksModel **model)
 
void ANeuralNetworksModel_free (ANeuralNetworksModel *model)
 
int ANeuralNetworksModel_finish (ANeuralNetworksModel *model)
 
int ANeuralNetworksModel_addOperand (ANeuralNetworksModel *model, const ANeuralNetworksOperandType *type)
 
int ANeuralNetworksModel_setOperandValue (ANeuralNetworksModel *model, int32_t index, const void *buffer, size_t length)
 
int ANeuralNetworksModel_setOperandValueFromMemory (ANeuralNetworksModel *model, int32_t index, const ANeuralNetworksMemory *memory, size_t offset, size_t length)
 
int ANeuralNetworksModel_addOperation (ANeuralNetworksModel *model, ANeuralNetworksOperationType type, uint32_t inputCount, const uint32_t *inputs, uint32_t outputCount, const uint32_t *outputs)
 
int ANeuralNetworksModel_identifyInputsAndOutputs (ANeuralNetworksModel *model, uint32_t inputCount, const uint32_t *inputs, uint32_t outputCount, const uint32_t *outputs)
 
int ANeuralNetworksCompilation_create (ANeuralNetworksModel *model, ANeuralNetworksCompilation **compilation)
 
void ANeuralNetworksCompilation_free (ANeuralNetworksCompilation *compilation)
 
int ANeuralNetworksCompilation_setPreference (ANeuralNetworksCompilation *compilation, int32_t preference)
 
int ANeuralNetworksCompilation_finish (ANeuralNetworksCompilation *compilation)
 
int ANeuralNetworksExecution_create (ANeuralNetworksCompilation *compilation, ANeuralNetworksExecution **execution)
 
void ANeuralNetworksExecution_free (ANeuralNetworksExecution *execution)
 
int ANeuralNetworksExecution_setInput (ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, const void *buffer, size_t length)
 
int ANeuralNetworksExecution_setInputFromMemory (ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, const ANeuralNetworksMemory *memory, size_t offset, size_t length)
 
int ANeuralNetworksExecution_setOutput (ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, void *buffer, size_t length)
 
int ANeuralNetworksExecution_setOutputFromMemory (ANeuralNetworksExecution *execution, int32_t index, const ANeuralNetworksOperandType *type, const ANeuralNetworksMemory *memory, size_t offset, size_t length)
 
int ANeuralNetworksExecution_startCompute (ANeuralNetworksExecution *execution, ANeuralNetworksEvent **event)
 
int ANeuralNetworksEvent_wait (ANeuralNetworksEvent *event)
 
void ANeuralNetworksEvent_free (ANeuralNetworksEvent *event)
 

Detailed Description

Typedef Documentation

§ ANeuralNetworksCompilation

ANeuralNetworksCompilation is an opaque type that can be used to compile a machine learning model.

To use:

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 created using the compilation.

§ ANeuralNetworksEvent

ANeuralNetworksEvent is an opaque type that represents an event that will be signaled once an execution completes.

§ ANeuralNetworksExecution

ANeuralNetworksExecution is an opaque type that can be used to apply a machine learning model to a set of inputs.

To use:

An execution cannot be modified once ANeuralNetworksExecution_startCompute has been called on it.

An execution can be applied to a model with ANeuralNetworksExecution_startCompute only once. Create new executions to do new evaluations of the model.

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 there are no other uses of the request after calling ANeuralNetworksExecution_free.

§ 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 tensor needed to define a model. ANeuralNetworksMemory_createFromFd can be used to create shared memory from a file handle. ANeuralNetworksMemory_createShared can be used to directly created shared memory.

Memory objects can also be used to specify the input and output arguments of an execution. See ANeuralNetworksExecution_setInputFromMemory and ANeuralNetworksExecution_setOutputFromMemory.

§ ANeuralNetworksModel

ANeuralNetworksModel is an opaque type that contains a description of the mathematical operations that constitute the model.

Build the model by calling

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 or execution object created using the model.

§ ANeuralNetworksOperandType

ANeuralNetworksOperandType describes the type of an operand. This structure is used to describe both scalars and tensors.

§ ANeuralNetworksOperationType

Enumeration Type Documentation

§ anonymous enum

anonymous enum

For ANeuralNetworksModel_setOperandValue, values with a length smaller or equal to this will be immediately copied into the model. The size is in bytes.

Enumerator
ANEURALNETWORKS_MAX_SIZE_OF_IMMEDIATELY_COPIED_VALUES 

§ FuseCode

enum FuseCode

Fused activation function types.

Enumerator
ANEURALNETWORKS_FUSED_NONE 

NO fused activation function.

ANEURALNETWORKS_FUSED_RELU 

Fused ReLU activation function.

ANEURALNETWORKS_FUSED_RELU1 

Fused ReLU1 activation function.

ANEURALNETWORKS_FUSED_RELU6 

Fused ReLU6 activation function.

§ OperandCode

Operand types.

The type of operands that can be added to a model.

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.

Enumerator
ANEURALNETWORKS_FLOAT32 

The following entries are used to declare scalars. A 32 bit floating point scalar value.

ANEURALNETWORKS_INT32 

A signed 32 bit integer scalar value.

ANEURALNETWORKS_UINT32 

An unsigned 32 bit integer scalar value.

ANEURALNETWORKS_TENSOR_FLOAT32 

The following entries are used to declare tensors. A tensor of 32 bit floating point values.

ANEURALNETWORKS_TENSOR_INT32 

A tensor of 32 bit integer values.

ANEURALNETWORKS_TENSOR_QUANT8_ASYMM 

A tensor of 8 bit integers that represent real numbers.

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

  • scale: a 32 bit non-negative floating point value.
  • zeroPoint: an 32 bit integer, in range [0, 255].

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

§ OperationCode

Operation types.

The type of operations that can be added to a model.

Enumerator
ANEURALNETWORKS_ADD 

Adds two tensors, element-wise.

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

Two dimensions are compatible when:

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

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

Example:

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

Supported tensor types:

Supported tensor rank: up to 4

Inputs:

  • 0: A tensor.
  • 1: A tensor of the same type, and compatible dimensions as input0.
  • 2: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Outputs:

  • 0: The sum, a tensor of the same type as input0.
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[batch, row, col, channel] =
    sum_{i, j}(input[batch, row + i, col + j, channel]) / sum(1)

Supported tensor types:

Supported tensor rank: 4, with "NHWC" (i.e., Num_samples, Height, Width, and Channels) data layout.

Both explicit padding and implicit padding are supported.

Inputs (explicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input.
  • 1: An INT32 value, specifying the padding on the left, in the ‘width’ dimension.
  • 2: An INT32 value, specifying the padding on the right,in the ‘width’ dimension.
  • 3: An INT32 value, specifying the padding on the top, in the ‘height’ dimension.
  • 4: An INT32 value, specifying the padding on the bottom, in the ‘height’ dimension.
  • 5: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 6: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 7: An INT32 value, specifying the filter width.
  • 8: An INT32 value, specifying the filter height.
  • 9: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Inputs (implicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input.
  • 1: An INT32 value, specifying the implicit padding scheme, has to be one of the PaddingCode values.
  • 2: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 3: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 4: An INT32 value, specifying the filter width.
  • 5: An INT32 value, specifying the filter height.
  • 6: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Outputs:

  • 0: The output 4-D tensor, of shape [batches, out_height, out_width, depth].
ANEURALNETWORKS_CONCATENATION 

Concatenates the input tensors along the given dimension.

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

Supported tensor types:

Supported tensor rank: up to 4

Inputs:

  • 0 ~ n-1: The list of n input tensors, of shape [D0, D1, ..., Daxis(i), ..., Dm]. For inputs of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, all input tensors must have the same scale and zeroPoint.
  • n: An INT32 value, specifying the concatenation axis.

Outputs:

  • 0: The output, a tensor of the same type as the input tensors. The output shape is [D0, D1, ..., sum(Daxis(i)), ..., Dm].
ANEURALNETWORKS_CONV_2D 

Performs an 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[batch, row, col, channel] =
    sum_{i, j} (
        input[batch, row + i, col + j, k] *
        filter[channel, row + i, col + j, k] +
        bias[channel]
    )

Supported tensor types:

Supported tensor rank: 4, with "NHWC" data layout.

Both explicit padding and implicit padding are supported.

Inputs (explicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input.
  • 1: A 4-D tensor, of shape [depth_out, filter_height, filter_width, depth_in], specifying the filter.
  • 2: A 1-D tensor, of shape [depth_out], specifying the bias. For input tensor of ANEURALNETWORKS_TENSOR_FLOAT32 type, the bias should also be of ANEURALNETWORKS_TENSOR_FLOAT32. For input tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale == input_scale * filter_scale.
  • 3: An INT32 value, specifying the padding on the left, in the ‘width’ dimension.
  • 4: An INT32 value, specifying the padding on the right,in the ‘width’ dimension.
  • 5: An INT32 value, specifying the padding on the top, in the ‘height’ dimension.
  • 6: An INT32 value, specifying the padding on the bottom, in the ‘height’ dimension.
  • 7: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 8: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 9: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Inputs (implicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input.
  • 1: A 4-D tensor, of shape [depth_out, filter_height, filter_width, depth_in], specifying the filter.
  • 2: A 1-D tensor, of shape [depth_out], specifying the bias. For input tensor of ANEURALNETWORKS_TENSOR_FLOAT32 type, the bias should also be of ANEURALNETWORKS_TENSOR_FLOAT32. For input tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale == input_scale * filter_scale.
  • 3: An INT32 value, specifying the implicit padding scheme, has to be one of the PaddingCode values.
  • 4: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 5: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 6: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Outputs:

  • 0: The output 4-D tensor, of shape [batches, out_height, out_width, depth_out]. For output tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, the following condition must be satisfied: output_scale > input_scale * filter_scale.
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]
    )

Supported tensor types:

Supported tensor rank: 4, with "NHWC" data layout.

Both explicit padding and implicit padding are supported.

Inputs (explicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input.
  • 1: A 4-D tensor, of shape [1, filter_height, filter_width, depth_out], specifying the filter.
  • 2: A 1-D tensor, of shape [depth_out], specifying the bias. For input tensor of ANEURALNETWORKS_TENSOR_FLOAT32 type, the bias should also be of ANEURALNETWORKS_TENSOR_FLOAT32. For input tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale == input_scale * filter_scale.
  • 3: An INT32 value, specifying the padding on the left, in the ‘width’ dimension.
  • 4: An INT32 value, specifying the padding on the right,in the ‘width’ dimension.
  • 5: An INT32 value, specifying the padding on the top, in the ‘height’ dimension.
  • 6: An INT32 value, specifying the padding on the bottom, in the ‘height’ dimension.
  • 7: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 8: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 9: An INT32 value, specifying the depthwise multiplier.
  • 10: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Inputs (explicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input.
  • 1: A 4-D tensor, of shape [1, filter_height, filter_width, depth_out], specifying the filter.
  • 2: A 1-D tensor, of shape [depth_out], specifying the bias. For input tensor of ANEURALNETWORKS_TENSOR_FLOAT32 type, the bias should also be of ANEURALNETWORKS_TENSOR_FLOAT32. For input tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale == input_scale * filter_scale.
  • 3: An INT32 value, specifying the implicit padding scheme, has to be one of the PaddingCode values.
  • 4: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 5: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 6: An INT32 value, specifying the depthwise multiplier.
  • 7: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Outputs:

  • 0: The output 4-D tensor, of shape [batches, out_height, out_width, depth_out]. For output tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, the following condition must be satisfied: output_scale > input_scale * filter_scale.
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 types:

Supported tensor rank: 4, with "NHWC" data layout.

Inputs:

  • 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input.
  • 1: An INT32 value, specifying the block_size. block_size must be >=1 and block_size * block_size must be a divisor of the input depth.

Outputs:

  • 0: The output 4-D tensor, of shape [batch, height*block_size, width*block_size, depth/(block_size*block_size)].
ANEURALNETWORKS_DEQUANTIZE 

Dequantizes the input tensor.

The formula is:

output = (input - zeroPoint) * scale.

Supported tensor types:

Supported tensor rank: up to 4

Inputs:

Outputs:

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], we would expect all three values found in Lookups to be between 0 and 39. The resulting tensor will have shape of [3, 200, 300].

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

Inputs:

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

Output:

  • 0: A n-D tensor with the same rank and shape as the Values tensor, except for the first dimension which has the same size as Lookups' only dimension.
ANEURALNETWORKS_FLOOR 

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

Supported tensor types:

Supported tensor rank: up to 4

Inputs:

  • 0: A tensor.

Outputs:

  • 0: The output tensor, of the same type and dimensions as the input tensor.
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 types:

Supported tensor rank: up to 4.

Inputs:

  • 0: A tensor, specifying the input. If rank is greater than 2, then it gets flattened to a 2-D Tensor. The 2-D Tensor is handled as if dimensions corresponded to shape [batch_size, input_size], where “batch_size” corresponds to the batching dimension, and “input_size” is the size of the input.
  • 1: A 2-D tensor, specifying the weights, of shape [num_units, input_size], where "num_units" corresponds to the number of output nodes.
  • 2: A 1-D tensor, of shape [num_units], specifying the bias. For input tensor of ANEURALNETWORKS_TENSOR_FLOAT32 type, the bias should also be of ANEURALNETWORKS_TENSOR_FLOAT32. For input tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, the bias should be of ANEURALNETWORKS_TENSOR_INT32, with zeroPoint of 0 and bias_scale == input_scale * filter_scale.
  • 3: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Outputs:

  • 0: The output tensor, of shape [batch_size, num_units]. For output tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, the following condition must be satisfied: output_scale > input_scale * filter_scale.
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 will 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], we're concatenating three slices, so the resulting tensor will have the shape of [3, 200, 300]. If the first entry in Lookups has the value 123456, we'll look for that value in Keys tensor. If the sixth entry of Keys contains 123456, we'll select the sixth slice of Values. If no entry in Keys has 123456, a slice of zeroes will be concatenated.

Inputs:

  • 0: Lookups. A 1-D ANEURALNETWORKS_TENSOR_INT32 tensor with shape [ k ].
  • 1: Keys. A 1-D ANEURALNETWORKS_TENSOR_INT32 tensor with shape [ n ]; Keys and Values pair represent a map, i.e., the ith element in Keys (Keys[i]) is the key to select the ith sub-tensor in Values (Values[i]), where 0 <= i <= n-1. Keys tensor MUST be sorted in ascending order.
  • 2: Values. A tensor with shape of [ n, … ]; i.e., the first dimension must be n.

Outputs:

  • 0: Output. A tensor with shape [ k …].
  • 1: Hits. A boolean tensor with shape [ k ] indicates whether the lookup hits (True) or not (False). Stored as ANEURALNETWORKS_TENSOR_QUANT8_ASYMM with offset 0 and scale 1.0f. A non-zero byte represents True, a hit. A zero indicates otherwise.
ANEURALNETWORKS_L2_NORMALIZATION 

Applies L2 normalization along the depth 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))

For input tensor with more dimensions, independently normalizes each 1-D slice along dimension dim.

Supported tensor types:

Supported tensor rank: 4, with "NHWC" data layout (i.e., Num_samples, Height, Width, and Channels).

Inputs:

  • 0: A 4-D tensor, of shape [batches, height, width, depth].

Outputs:

  • 0: The output 4-D tensor, of shape [batches, out_height, out_width, depth].
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[batch, row, col, channel] =
    sqrt(sum_{i, j} pow(input[batch, row + i, col + j, channel], 2) / sum(1))

Supported tensor types:

Supported tensor rank: 4, with "NHWC" data layout.

Both explicit padding and implicit padding are supported.

Inputs (explicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input.
  • 1: An INT32 value, specifying the padding on the left, in the ‘width’ dimension.
  • 2: An INT32 value, specifying the padding on the right,in the ‘width’ dimension.
  • 3: An INT32 value, specifying the padding on the top, in the ‘height’ dimension.
  • 4: An INT32 value, specifying the padding on the bottom, in the ‘height’ dimension.
  • 5: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 6: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 7: An INT32 value, specifying the filter width.
  • 8: An INT32 value, specifying the filter height.
  • 9: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Inputs (implicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input.
  • 1: An INT32 value, specifying the implicit padding scheme, has to be one of the PaddingCode values.
  • 2: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 3: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 4: An INT32 value, specifying the filter width.
  • 5: An INT32 value, specifying the filter height.
  • 6: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Outputs:

  • 0: The output 4-D tensor, of shape [batches, out_height, out_width, depth].
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)

Supported tensor types:

Supported tensor rank: 4, with "NHWC" data layout.

Inputs:

  • 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input.
  • 1: An INT32 value, specifying the radius of the normalization window.
  • 2: A FLOAT32 value, specifying the bias, must not be zero.
  • 3: A FLOAT32 value, specifying the scale factor, alpha.
  • 4: A FLOAT32 value, specifying the exponent, beta.

Outputs:

  • 0: The output tensor of same shape as input0.
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 types:

Supported tensor rank: up to 4.

Inputs:

  • 0: A tensor, specifying the input.

Outputs:

ANEURALNETWORKS_LSH_PROJECTION 

Projects an input to a bit vector via locality senstive hashing.

Inputs:

  • 0: Hash functions. Dim.size == 2, DataType: Float. Tensor[0].Dim[0]: Number of hash functions. Tensor[0].Dim[1]: Number of seeds per hash functions. Tensor[0].Dim[1] <= 32 in sparse case.
  • 1: Input. Dim.size >= 1, no restriction on DataType.
  • 2: Weight. Optional. Dim.size == 1, DataType: Float. If not set, each input element is considered to have the same weight of 1.0. Tensor[1].Dim[0] == Tensor[2].Dim[0]
  • 3: Type: Sparse: Value LSHProjectionType_SPARSE(=1). Computed bit vector is considered to be sparse. Each output element is an int32 made up of multiple bits computed from hash functions.

    Dense: Value LSHProjectionType_DENSE(=2). Computed bit vector is considered to be dense. Each output element represents a bit and can take the value of either 0 or 1.

Outputs:

  • 0: If the projection type is sparse: Output.Dim == { Tensor[0].Dim[0] } A tensor of int32 that represents hash signatures. If the projection type is Dense: Output.Dim == { Tensor[0].Dim[0] * Tensor[0].Dim[1] } A flattened tensor that represents projected bit vectors.
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:

  • $x_t$ is the input,
  • $i_t$ is the input gate,
  • $f_t$ is the forget gate,
  • $C_t$ is the cell state,
  • $o_t$ is the output,
  • $h_t$ is the output state,
  • $\sigma$ is the logistic sigmoid function,
  • $g$ is the cell input and cell output activation function, usually $tahn$,
  • $W_{xi}$ is the input-to-input weight matrix,
  • $W_{hi}$ is the recurrent to input weight matrix,
  • $W_{ci}$ is the cell-to-input weight matrix,
  • $b_i$ is the input gate bias,
  • $W_{xf}$ is the input-to-forget weight matrix,
  • $W_{hf}$ is the recurrent-to-forget weight matrix,
  • $W_{cf}$ is the cell-to-forget weight matrix,
  • $b_f$ is the forget gate bias,
  • $W_{xc}$ is the input-to-cell weight matrix,
  • $W_{hc}$ is the recurrent-to-cell weight matrix,
  • $b_c$ is the cell bias,
  • $W_{xo}$ is the input-to-output weight matrix,
  • $W_{ho}$ is the recurrent-to-output weight matrix,
  • $W_{co}$ is the cell-to-output weight matrix,
  • $b_o$ is the output gate bias,
  • $W_{proj}$ is the projection weight matrix,
  • $b_{proj}$ is the projection bias,
  • $t_{cell}$ is the threshold for clipping the cell state, and
  • $t_{proj}$ is the threshold for clipping the projected output.
  • $\odot$ is the Hadamard product that takes two matrices and produces another matrix, each element of which is the product of the corresponding elements of the input matrices.

The operation has the following independently optional inputs:

  • The input-to-input weights ( $W_{xi}$), recurrent-to-input weights ( $W_{hi}$), cell-to-input ( $W_{ci}$) weights, and input gate bias ( $b_i$) either all have values, or none of them have values (i.e., all set to null). If they have no values, coupling of input and forget gates (CIFG) is used, in which case the input gate ( $i_t$) is calculated using the following equation instead.

    \begin{eqnarray*} i_t = 1 - f_t \end{eqnarray*}

  • The cell-to-input weights ( $W_{ci}$), cell-to-forget weights ( $W_{cf}$), and cell-to-output weights ( $W_{co}$) either all have values or none of them have values. If they have values, the peephole optimization is used.
  • The projection weights ( $W_{proj}$) is required only for the recurrent projection layer, and should otherwise have no value.
  • The projection bias ( $b_{proj}$) may (but not required to) have a value if the recurrent projection layer exists, and should otherwise have no value.

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"

Supported tensor types (type T):

Inputs:

  • 0: The input ( $x_t$). A 2-D tensor of type T, of shape [batch_size, input_size], where “batch_size” corresponds to the batching dimension, and “input_size” is the size of the input.
  • 1: The input-to-input weights ( $W_{xi}$). Optional. A 2-D tensor of type T, of shape [num_units, input_size], where “num_units” corresponds to the number of cell units.
  • 2: The input-to-forget weights ( $W_{xf}$). A 2-D tensor of type T, of shape [num_units, input_size].
  • 3: The input-to-cell weights ( $W_{xc}$). A 2-D tensor of type T, of shape [num_units, input_size].
  • 4: The input-to-output weights ( $W_{xo}$). A 2-D tensor of type T, of shape [num_units, input_size].
  • 5: The recurrent-to-input weights ( $W_{hi}$). Optional. A 2-D tensor of type T, of shape [num_units, output_size], where “output_size” corresponds to either the number of cell units (i.e., “num_units”), or the second dimension of the “projection_weights”, if defined.
  • 6: The recurrent-to-forget weights ( $W_{hf}$). A 2-D tensor of type T, of shape [num_units, output_size].
  • 7: The recurrent-to-cell weights ( $W_{hc}$). A 2-D tensor of type T, of shape [num_units, output_size].
  • 8: The recurrent-to-output weights ( $W_{ho}$). A 2-D tensor of type T, of shape [num_units, output_size].
  • 9: The cell-to-input weights ( $W_{ci}$). Optional. A 1-D tensor of type T, of shape [num_units].
  • 10:The cell-to-forget weights ( $W_{cf}$). Optional. A 1-D tensor of type T, of shape [num_units].
  • 11:The cell-to-output weights ( $W_{co}$). Optional. A 1-D tensor of type T, of shape [num_units].
  • 12:The input gate bias ( $b_i$). Optional. A 1-D tensor of type T, of shape [num_units].
  • 13:The forget gate bias ( $b_f$). A 1-D tensor of type T, of shape [num_units].
  • 14:The cell bias ( $b_c$). A 1-D tensor of type T, of shape [num_units].
  • 15:The output gate bias ( $b_o$). A 1-D tensor of type T, of shape [num_units].
  • 16:The projection weights ( $W_{proj}$). Optional. A 2-D tensor of type T, of shape [output_size, num_units].
  • 17:The projection bias ( $b_{proj}$). Optional. A 1-D tensor of type T, of shape [output_size].
  • 18:The output state (in) ( $h_{t-1}$). A 2-D tensor of type T, of shape [batch_size, output_size].
  • 19:The cell state (in) ( $C_{t-1}$). A 2-D tensor of type T, of shape [batch_size, num_units].
  • 20:The activation function ( $g$). A value indicating the activation function:
    • 0: None;
    • 1: Relu;
    • 3: Relu6;
    • 4: Tanh;
    • 6: Sigmoid.
  • 21:The clipping threshold ( $t_{cell}$) for the cell state, such that values are bound within [-cell_clip, cell_clip]. If set to 0.0 then clipping is disabled.
  • 22:The clipping threshold ( $t_{proj}$) for the output from the projection layer, such that values are bound within [-proj_clip, proj_clip]. If set to 0.0 then clipping is disabled.

Outputs:

  • 0: The scratch buffer. A 2-D tensor of type T, of shape [batch_size, num_units * 4] with CIFG, or [batch_size, num_units * 3] without CIFG.
  • 1: The output state (out) ( $h_t$). A 2-D tensor of type T, of shape [batch_size, output_size].
  • 2: The cell state (out) ( $C_t$). A 2-D tensor of type T, of shape [batch_size, num_units].
  • 3: The output ( $o_t$). A 2-D tensor of type T, of shape [batch_size, output_size]. This is effectively the same as the current “output state (out)” value.
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[batch, row, col, channel] =
    max_{i, j} (input[batch, row + i, col + j, channel])

Supported tensor types:

Supported tensor rank: 4, with "NHWC" data layout.

Both explicit padding and implicit padding are supported.

Inputs (explicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input.
  • 1: An INT32 value, specifying the padding on the left, in the ‘width’ dimension.
  • 2: An INT32 value, specifying the padding on the right,in the ‘width’ dimension.
  • 3: An INT32 value, specifying the padding on the top, in the ‘height’ dimension.
  • 4: An INT32 value, specifying the padding on the bottom, in the ‘height’ dimension.
  • 5: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 6: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 7: An INT32 value, specifying the filter width.
  • 8: An INT32 value, specifying the filter height.
  • 9: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Inputs (implicit padding):

  • 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input.
  • 1: An INT32 value, specifying the implicit padding scheme, has to be one of the PaddingCode values.
  • 2: An INT32 value, specifying the stride when walking through input in the ‘width’ dimension.
  • 3: An INT32 value, specifying the stride when walking through input in the ‘height’ dimension.
  • 4: An INT32 value, specifying the filter width.
  • 5: An INT32 value, specifying the filter height.
  • 6: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Outputs:

  • 0: The output 4-D tensor, of shape [batches, out_height, out_width, depth].
ANEURALNETWORKS_MUL 

Multiplies two tensors, element-wise.

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

Two dimensions are compatible when:

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

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

Supported tensor types:

Supported tensor rank: up to 4

Inputs:

  • 0: A tensor.
  • 1: A tensor of the same type, and compatible dimensions as input0.
  • 2: An INT32 value, and has to be one of the FuseCode values. Specifies the activation to invoke on the result of each addition.

Outputs:

  • 0: The product, a tensor of the same type as input0. For output tensor of ANEURALNETWORKS_TENSOR_QUANT8_ASYMM type, the following condition must be satisfied: output_scale > input1_scale * input2_scale.
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 types:

Supported tensor rank: up to 4.

Inputs:

  • 0: A tensor, specifying the input.

Outputs:

  • 0: The output tensor of same shape as input0.
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 types:

Supported tensor rank: up to 4.

Inputs:

  • 0: A tensor, specifying the input.

Outputs:

  • 0: The output tensor of same shape as input0.
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 types:

Supported tensor rank: up to 4.

Inputs:

  • 0: A tensor, specifying the input.

Outputs:

  • 0: The output tensor of same shape as input0.
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 types:

Supported tensor rank: up to 4.

Inputs:

  • 0: A tensor, specifying the tensor to be reshaped.
  • 1: A 1-D tensor of type ANEURALNETWORKS_TENSOR_INT32, defining the shape of the output tensor. The number of elements implied by shape must be the same as the number of elements in the input tensor.

Outputs:

  • 0: The output tensor, of shape specified by the input shape.
ANEURALNETWORKS_RESIZE_BILINEAR 

Resizes images to given size using the bilinear interpretation.

Resized images will be distorted if their output aspect ratio is not the same as input aspect ratio.

Supported tensor types:

Supported tensor rank: 4, with "NHWC" data layout.

Inputs:

  • 0: A 4-D tensor, of shape [batches, height, width, depth], specifying the input.
  • 1: An INT32 value, specifying the output height of the output tensor.
  • 2: An INT32 value, specifying the output width of the output tensor.

Outputs:

  • 0: The output 4-D tensor, of shape [batches, new_height, new_width, depth].
ANEURALNETWORKS_RNN 

A basic recurrent neural network layer.

This layer implements the operation: outputs = state = activation(inputs * input_weights + state * recurrent_weights + bias)

Where:

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

Supported tensor types (Type T):

Inputs:

  • 0: input. A 2-D tensor of type T, of shape [batch_size, input_size], where “batch_size” corresponds to the batching dimension, and “input_size” is the size of the input.
  • 1: weights. A 2-D tensor of type T, of shape [num_units, input_size], where “num_units” corresponds to the number of units.
  • 2: recurrent_weights. A 2-D tensor of type T, of shape [num_units, num_units], with columns corresponding to the weights from each unit.
  • 3: bias. A 1-D tensor of type T, of shape [num_units].
  • 4: hidden state (in). A 2-D tensor of type T, of shape [batch_size, num_units].
  • 5: fused_activation_function. An optional FuseCode value indicating the activation function. If “NONE” is specified then it results in a linear activation.

Outputs:

  • 0: hidden state (out). A 2-D tensor of type T, of shape [batch_size, num_units].
  • 1: output. A 2-D tensor of type T, of shape [batch_size, num_units]. This is effectively the same as the current state value.
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)}

Supported tensor types:

Supported tensor rank: 2 or 4.

Inputs:

  • 0: A 2-D or 4-D tensor, specifying the tensor to be reshaped.
  • 1: A FLOAT32 value, specifying the positive scaling factor for the exponent, beta.

Outputs:

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 types:

Supported tensor rank: 4, with "NHWC" data layout.

Inputs:

  • 0: A 4-D tensor, of shape [batches, height, width, depth_in], specifying the input.
  • 1: An INT32 value, specifying the block_size. block_size must be >=1 and block_size must be a divisor of both the input height and width.

Outputs:

  • 0: The output 4-D tensor, of shape [batch, height/block_size, width/block_size, depth*block_size*block_size].
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:

  • stage 1 performs filtering on the "features" dimension, whose outputs get pushed into a memory of fixed-size memory_size.
  • stage 2 performs filtering on the "time" dimension of the memory_size memoized outputs of stage 1.

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:

  • “weights_feature” is a weights matrix that processes the inputs (by convolving the input with every “feature filter”), and whose outputs get pushed, stacked in order, into the fixed-size “memory” (the oldest entry gets dropped);
  • “weights_time” is a weights matrix that processes the “memory” (by a batched matrix multiplication on the num_units);
  • “bias” is an optional bias vector (added to each output vector in the batch); and
  • “activation” is the function passed as the “fused_activation_function” argument (if not “NONE”).

Each rank adds a dimension to the weights matrices by means of stacking the filters.

Supported tensor types (type T):

Inputs:

  • 0: input. A 2-D tensor of type T, of shape [batch_size, input_size], where “batch_size” corresponds to the batching dimension, and “input_size” is the size of the input.
  • 1: weights_feature. A 2-D tensor of type T, of shape [num_units, input_size], where “num_units” corresponds to the number of units.
  • 2: weights_time. A 2-D tensor of type T, of shape [num_units, memory_size], where “memory_size” corresponds to the fixed-size of the memory.
  • 3: bias. An optional 1-D tensor of type T, of shape [num_units].
  • 4: state (in). A 2-D tensor of type T, of shape [batch_size, (memory_size - 1) * num_units * rank].
  • 5: rank. The rank of the SVD approximation.
  • 6: fused_activation_function. An optional FuseCode value indicating the activation function. If “NONE” is specified then it results in a linear activation.

Outputs:

  • 0: state (out). A 2-D tensor of type T, of shape [batch_size, (memory_size - 1) * num_units * rank].
  • 1: output. A 2-D tensor of type T, of shape [batch_size, num_units].
ANEURALNETWORKS_TANH 

Computes hyperbolic tangent of input tensor element-wise.

The output is calculated using this formula:

output = tanh(input)

Supported tensor types:

Supported tensor rank: up to 4.

Inputs:

  • 0: A tensor, specifying the input.

Outputs:

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

§ PaddingCode

Implicit padding algorithms.

Enumerator
ANEURALNETWORKS_PADDING_SAME 

SAME padding. Padding on both ends are the "same": padding_to_beginning = total_padding / 2 padding_to_end = (total_padding + 1)/2. i.e., for even number of padding, padding to both ends are exactly the same; for odd number of padding, padding to the ending is bigger than the padding to the beginning by 1.

total_padding is a function of input, stride and filter size. It could be computed as follows: out_size = (input + stride - 1) / stride; needed_input = (out_size - 1) * stride + filter_size total_padding = max(0, needed_input - output_size) The computation is the same for the horizontal and vertical directions.

ANEURALNETWORKS_PADDING_VALID 

VALID padding. No padding. When the input size is not evenly divisible by the filter size, the input at the end that could not fill the whole filter tile will simply be ignored.

§ PreferenceCode

Execution preferences.

Enumerator
ANEURALNETWORKS_PREFER_LOW_POWER 

Prefer executing in a way that minimizes battery drain. This is desirable for compilations that will be executed often.

ANEURALNETWORKS_PREFER_FAST_SINGLE_ANSWER 

Prefer returning a single answer as fast as possible, even if this causes more power consumption.

ANEURALNETWORKS_PREFER_SUSTAINED_SPEED 

Prefer maximizing the throughput of successive frames, for example when processing successive frames coming from the camera.

§ ResultCode

enum ResultCode

Result codes.

Enumerator
ANEURALNETWORKS_NO_ERROR 
ANEURALNETWORKS_OUT_OF_MEMORY 
ANEURALNETWORKS_INCOMPLETE 
ANEURALNETWORKS_UNEXPECTED_NULL 
ANEURALNETWORKS_BAD_DATA 
ANEURALNETWORKS_OP_FAILED 
ANEURALNETWORKS_UNMAPPABLE 
ANEURALNETWORKS_BAD_STATE 

Function Documentation

§ ANeuralNetworksCompilation_create()

int ANeuralNetworksCompilation_create ( ANeuralNetworksModel model,
ANeuralNetworksCompilation **  compilation 
)

Create a ANeuralNetworksCompilation to compile the given model.

This 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.

Parameters
modelThe ANeuralNetworksModel to be compiled.
compilationThe newly created object or NULL if unsuccessful.
Returns
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_BAD_DATA if the model is invalid.

§ ANeuralNetworksCompilation_finish()

int ANeuralNetworksCompilation_finish ( ANeuralNetworksCompilation compilation)

Indicate that we have finished modifying a compilation. Required before calling ANeuralNetworksExecution_create.

An application is responsible to make sure that no other thread uses the compilation at the same time.

This function must only be called once for a given compilation.

See ANeuralNetworksCompilation for information on multithreaded usage.

Parameters
compilationThe compilation to be finished.
Returns
ANEURALNETWORKS_NO_ERROR if successful.

§ ANeuralNetworksCompilation_free()

void ANeuralNetworksCompilation_free ( ANeuralNetworksCompilation compilation)

Destroy a compilation.

The compilation need not have been finished by a call to ANeuralNetworksModel_finish.

See ANeuralNetworksCompilation for information on multithreaded usage.

Parameters
compilationThe compilation to be destroyed. Passing NULL is acceptable and results in no operation.

§ ANeuralNetworksCompilation_setPreference()

int ANeuralNetworksCompilation_setPreference ( ANeuralNetworksCompilation compilation,
int32_t  preference 
)

Sets the execution preference.

Provides guidance to the runtime when trade-offs are possible.

See ANeuralNetworksCompilation for information on multithreaded usage.

Parameters
compilationThe compilation to be modified.
preferenceEither PREFER_LOW_POWER, PREFER_SINGLE_FAST_ANSWER, or PREFER_SUSTAINED_SPEED.
Returns
ANEURALNETWORKS_NO_ERROR if successful.

§ ANeuralNetworksEvent_free()

void ANeuralNetworksEvent_free ( ANeuralNetworksEvent event)

Destroys the event.

See ANeuralNetworksExecution for information on multithreaded usage.

§ ANeuralNetworksEvent_wait()

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.

See ANeuralNetworksExecution for information on multithreaded usage.

Returns
ANEURALNETWORKS_NO_ERROR if the execution completed normally.

§ ANeuralNetworksExecution_create()

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_startCompute is invoked.

The provided compilation must outlive the execution.

See ANeuralNetworksExecution for information on multithreaded usage.

Parameters
compilationThe ANeuralNetworksCompilation to be evaluated.
executionThe newly created object or NULL if unsuccessful.
Returns
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_BAD_DATA if the compilation is invalid.

§ ANeuralNetworksExecution_free()

void ANeuralNetworksExecution_free ( ANeuralNetworksExecution execution)

Destroy an execution.

If called on an execution for which ANeuralNetworksExecution_startCompute has been called, the function will return immediately but will mark the execution to be deleted once the computation completes. The related ANeuralNetworksEvent will be signaled and the ANeuralNetworksEvent_wait will return ANEURALNETWORKS_ERROR_DELETED.

See ANeuralNetworksExecution for information on multithreaded usage.

Parameters
executionThe execution to be destroyed. Passing NULL is acceptable and results in no operation.

§ ANeuralNetworksExecution_setInput()

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.

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.

See ANeuralNetworksExecution for information on multithreaded usage.

Parameters
executionThe execution to be modified.
indexThe index of the input argument we are setting. It is an index into the lists passed to ANeuralNetworksModel_identifyInputsAndOutputs. It is not the index associated with ANeuralNetworksModel_addOperand.
typeThe type of the operand. This should be used to specify the dimensions that were set to 0 when the operand was added to the model. All other properties of the type must be the same as specified in the model. If the type is the same as specified when the model was built, NULL can be passed.
bufferThe buffer containing the data.
lengthThe length in bytes of the buffer.
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()

int ANeuralNetworksExecution_setInputFromMemory ( ANeuralNetworksExecution execution,
int32_t  index,
const ANeuralNetworksOperandType type,
const ANeuralNetworksMemory memory,
size_t  offset,
size_t  length 
)

Associate part of a memory object with an input of the model of the ANeuralNetworksExecution.

The provided memory must outlive the execution.

If the input is optional, you can indicate that it is omitted by using ANeuralNetworks_setInput instead, passing nullptr for buffer and 0 for length.

See ANeuralNetworksExecution for information on multithreaded usage.

Parameters
executionThe execution to be modified.
indexThe index of the input argument we are setting. It is an index into the lists passed to ANeuralNetworksModel_identifyInputsAndOutputs. It is not the index associated with ANeuralNetworksModel_addOperand.
typeThe type of the operand. This can be used to specify the dimensions that were set to 0 when the operand was added to the model. All other values must be the same as specified in the model. If the type is the same as specified when the model was built, NULL can be passed.
memoryThe memory containing the data.
offsetThis specifies the location of the data whithin the memory. The offset is in bytes from the start of memory.
lengthThe size in bytes of the data value.
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_setOutput()

int ANeuralNetworksExecution_setOutput ( ANeuralNetworksExecution execution,
int32_t  index,
const ANeuralNetworksOperandType type,
void *  buffer,
size_t  length 
)

Associate a user buffer with an output of the model of the ANeuralNetworksExecution.

If the output is optional, you can indicate that it is omitted by passing nullptr for buffer and 0 for length.

The provided buffer must outlive the execution.

See ANeuralNetworksExecution for information on multithreaded usage.

Parameters
executionThe execution to be modified.
indexThe index of the output argument we are setting. It is an index into the lists passed to ANeuralNetworksModel_identifyInputsAndOutputs. It is not the index associated with ANeuralNetworksModel_addOperand.
typeThe type of the operand. This can be used to specify the dimensions that were set to 0 when the operand was added to the model. All other values must be the same as specified in the model. If the type is the same as specified when the model was built, NULL can be passed.
bufferThe buffer where the data is to be written.
lengthThe length in bytes of the buffer.
Returns
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_BAD_DATA if the name is not recognized or the buffer is too small for the output.

§ ANeuralNetworksExecution_setOutputFromMemory()

int ANeuralNetworksExecution_setOutputFromMemory ( ANeuralNetworksExecution execution,
int32_t  index,
const ANeuralNetworksOperandType type,
const ANeuralNetworksMemory memory,
size_t  offset,
size_t  length 
)

Associate part of a memory object with an output of the model of the ANeuralNetworksExecution.

If the output is optional, you can indicate that it is omitted by using ANeuralNetworks_setOutput instead, passing nullptr for buffer and 0 for length.

The provided memory must outlive the execution.

See ANeuralNetworksExecution for information on multithreaded usage.

Parameters
executionThe execution to be modified.
indexThe index of the output argument we are setting. It is an index into the lists passed to ANeuralNetworksModel_identifyInputsAndOutputs. It is not the index associated with ANeuralNetworksModel_addOperand.
typeThe type of the operand. This can be used to specify the dimensions that were set to 0 when the operand was added to the model. All other values must be the same as specified in the model. If the type is the same as specified when the model was built, NULL can be passed.
memoryThe memory where the data is to be stored.
offsetThis specifies the location of the data whithin the memory. The offset is in bytes from the start of memory.
lengthThe length in bytes of the data value.
Returns
ANEURALNETWORKS_NO_ERROR if successful, ANEURALNETWORKS_BAD_DATA if the name is not recognized or the buffer is too small for the output.

§ ANeuralNetworksExecution_startCompute()

int ANeuralNetworksExecution_startCompute ( ANeuralNetworksExecution execution,
ANeuralNetworksEvent **  event 
)

Schedule evaluation of the execution.

Schedules evaluation of the execution. Once the model has been applied and the outputs are ready to be consumed, the returned event will be signaled. Use ANeuralNetworksEvent_wait to wait for that event.

Multiple executions can be scheduled and evaluated concurrently. 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 using ANeuralNetworksEvent_wait.

ANeuralNetworksEvent_wait must be called to recuperate the resources used by the execution.

See ANeuralNetworksExecution for information on multithreaded usage.

Parameters
executionThe execution to be scheduled and executed.
eventThe event that will be signaled on completion. event is set to NULL if there's an error.
Returns
ANEURALNETWORKS_NO_ERROR if successful.

§ ANeuralNetworksMemory_createFromFd()

int ANeuralNetworksMemory_createFromFd ( size_t  size,
int  protect,
int  fd,
size_t  offset,
ANeuralNetworksMemory **  memory 
)

Creates a shared memory object from a file descriptor.

The shared memory is backed by a file descriptor via mmap. See ANeuralNetworksMemory for a description on how to use this shared memory.

Parameters
sizeThe requested size in bytes. Must not be larger than the file size.
protThe desired memory protection for the mapping. It is either PROT_NONE or the bitwise OR of one or more of the following flags: PROT_READ, PROT_WRITE.
fdThe requested file descriptor. The file descriptor has to be mmap-able. The file descriptor will be duplicated.
offsetThe offset to the beginning of the file of the area to map. The offset has to be aligned to a page size.
memoryThe memory object to be created. Set to NULL if unsuccessful.
Returns
ANEURALNETWORKS_NO_ERROR if the request completed normally.

§ ANeuralNetworksMemory_free()

void ANeuralNetworksMemory_free ( ANeuralNetworksMemory memory)

Delete a memory object.

Destroys the object used by the run time to keep track of the memory. This will free the underlying actual memory if no other code has open handles to this memory.

Parameters
memoryThe memory object to be freed.

§ ANeuralNetworksModel_addOperand()

int ANeuralNetworksModel_addOperand ( ANeuralNetworksModel model,
const ANeuralNetworksOperandType type 
)

Add an operand to a model.

The order in which the operands are added is important. The first one added to a model will have the index value 0, the second 1, etc. These indexes are used as operand identifiers in ANeuralNetworksModel_addOperation, ANeuralNetworksExecution_setInput, ANeuralNetworksExecution_setInputFromMemory, ANeuralNetworksExecution_setOutput, ANeuralNetworksExecution_setOutputFromMemory and ANeuralNetworksExecution_setOperandValue.

To build a model that can accomodate inputs of various sizes, as you may want to do for a CNN, set the size of the dimensions that will vary at run time to 0. If you do so, provide the full dimensions when calling ANeuralNetworksExecution_setInput or ANeuralNetworksExecution_setInputFromMemory.

Attempting to modify a model once ANeuralNetworksModel_finish has been called will return an error.

See ANeuralNetworksModel for information on multithreaded usage.

Parameters
modelThe model to be modified.
typeThe ANeuralNetworksOperandType that describes the shape of the operand.
Returns
ANEURALNETWORKS_NO_ERROR if successful.

§ ANeuralNetworksModel_addOperation()

int ANeuralNetworksModel_addOperation ( ANeuralNetworksModel model,
ANeuralNetworksOperationType  type,
uint32_t  inputCount,
const uint32_t *  inputs,
uint32_t  outputCount,
const uint32_t *  outputs 
)

Add an operation to a model.

Parameters
modelThe model to be modified.
typeThe type of the operation.
inputCountThe number of entries in the inputs array.
inputsAn array of indexes identifying each operand.
outputCountThe number of entries in the outputs array.
outputsAn array of indexes identifying each operand.

The operands specified by inputs and outputs must have been previously added by calls to ANeuralNetworksModel_addOperand.

Attempting to modify a model once ANeuralNetworksModel_finish has been called will return an error.

See ANeuralNetworksModel for information on multithreaded usage.

Returns
ANEURALNETWORKS_NO_ERROR if successful.

§ ANeuralNetworksModel_create()

int ANeuralNetworksModel_create ( ANeuralNetworksModel **  model)

Create an empty ANeuralNetworksModel.

This only creates the object. Computation is performed once ANeuralNetworksExecution_startCompute is invoked.

The model should be constructed with calls to ANeuralNetworksModel_addOperation and ANeuralNetworksModel_addOperand

ANeuralNetworksModel_finish should be called once the model has been fully constructed.

ANeuralNetworksModel_free should be called once the model is no longer needed.

Parameters
modelThe ANeuralNetworksModel to be created. Set to NULL if unsuccessful.
Returns
ANEURALNETWORKS_NO_ERROR if successful.

§ ANeuralNetworksModel_finish()

int ANeuralNetworksModel_finish ( ANeuralNetworksModel model)

Indicate that we have finished modifying a model. Required before calling ANeuralNetworksCompilation_create.

An application is responsible to make sure that no other thread uses the model at the same time.

This function must only be called once for a given model.

See ANeuralNetworksModel for information on multithreaded usage.

Parameters
modelThe model to be finished.
Returns
ANEURALNETWORKS_NO_ERROR if successful.

§ ANeuralNetworksModel_free()

void ANeuralNetworksModel_free ( ANeuralNetworksModel model)

Destroy a model.

The model need not have been finished by a call to ANeuralNetworksModel_finish.

See ANeuralNetworksModel for information on multithreaded usage.

Parameters
modelThe model to be destroyed. Passing NULL is acceptable and results in no operation.

§ ANeuralNetworksModel_identifyInputsAndOutputs()

int ANeuralNetworksModel_identifyInputsAndOutputs ( ANeuralNetworksModel model,
uint32_t  inputCount,
const uint32_t *  inputs,
uint32_t  outputCount,
const uint32_t *  outputs 
)

Specfifies which operands will be the model's inputs and outputs.

An operand cannot be used for both input and output. Doing so will return an error.

Parameters
modelThe model to be modified.
inputCountThe number of entries in the inputs array.
inputsAn array of indexes identifying the input operands.
outputCountThe number of entries in the outputs array.
outputsAn array of indexes identifying the output operands.

The operands specified by inputs and outputs must have been previously added by calls to ANeuralNetworksModel_addOperand.

Attempting to modify a model once ANeuralNetworksModel_finish has been called will return an error.

See ANeuralNetworksModel for information on multithreaded usage.

§ ANeuralNetworksModel_setOperandValue()

int ANeuralNetworksModel_setOperandValue ( ANeuralNetworksModel model,
int32_t  index,
const void *  buffer,
size_t  length 
)

Sets an operand to a constant value.

Values of length smaller or equal to ANEURALNETWORKS_MAX_SIZE_OF_IMMEDIATELY_COPIED_VALUES are immediately copied into the model.

For values of length greater than ANEURALNETWORKS_MAX_SIZE_OF_IMMEDIATELY_COPIED_VALUES, a pointer to the buffer is stored within the model. The application is responsible for not changing the content of this region until all executions using this model have completed. As the data may be copied during processing, modifying the data after this call yields undefined results.

For large tensors, using ANeuralNetworksModel_setOperandValueFromMemory is likely to be more efficient.

To indicate that an optional operand should be considered missing, pass nullptr for buffer and 0 for length.

Attempting to modify a model once ANeuralNetworksModel_finish has been called will return an error.

See ANeuralNetworksModel for information on multithreaded usage.

Parameters
modelThe model to be modified.
indexThe index of the model operand we're setting.
bufferA pointer to the data to use.
lengthThe size in bytes of the data value.
Returns
ANEURALNETWORKS_NO_ERROR if successful.

§ ANeuralNetworksModel_setOperandValueFromMemory()

int ANeuralNetworksModel_setOperandValueFromMemory ( ANeuralNetworksModel model,
int32_t  index,
const ANeuralNetworksMemory memory,
size_t  offset,
size_t  length 
)

Sets an operand to a value stored in a memory object.

The content of the memory is not copied. A reference to that memory is stored inside the model. The application is responsible for not changing the content of the memory region until all executions using this model have completed. As the data may be copied during processing, modifying the data after this call yields undefined results.

To indicate that an optional operand should be considered missing, use ANeuralNetworksModel_setOperandValue instead, passing nullptr for buffer.

Attempting to modify a model once ANeuralNetworksModel_finish has been called will return an error.

See ANeuralNetworksModel for information on multithreaded usage.

Parameters
modelThe model to be modified.
indexThe index of the model operand we're setting.
bufferA pointer to the data to use.
memoryThe memory containing the data.
offsetThis specifies the location of the data within the memory. The offset is in bytes from the start of memory.
lengthThe size in bytes of the data value.
Returns
ANEURALNETWORKS_NO_ERROR if successful.
This site uses cookies to store your preferences for site-specific language and display options.

Follow Google Developers on WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience.
(Sep 2017 survey)