NeuralNetworks
#include <NeuralNetworks.h>
Summary
Typedefs 


ANeuralNetworksCompilation

typedefstruct ANeuralNetworksCompilation
ANeuralNetworksCompilation is an opaque type that can be used to compile a machine learning model. 
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. 
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

Functions 


ANeuralNetworksCompilation_create(ANeuralNetworksModel *model, ANeuralNetworksCompilation **compilation)

int
Create a ANeuralNetworksCompilation to compile the given model.

ANeuralNetworksCompilation_finish(ANeuralNetworksCompilation *compilation)

int
Indicate that we have finished modifying a compilation.

ANeuralNetworksCompilation_free(ANeuralNetworksCompilation *compilation)

void
Destroy a compilation.

ANeuralNetworksCompilation_setPreference(ANeuralNetworksCompilation *compilation, int32_t preference)

int
Sets the execution preference.

ANeuralNetworksEvent_free(ANeuralNetworksEvent *event)

void
Destroys the event.

ANeuralNetworksEvent_wait(ANeuralNetworksEvent *event)

int
Waits until the execution completes.

ANeuralNetworksExecution_create(ANeuralNetworksCompilation *compilation, ANeuralNetworksExecution **execution)

int
Create a ANeuralNetworksExecution to apply the given compilation.

ANeuralNetworksExecution_free(ANeuralNetworksExecution *execution)

void
Destroy an execution.

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 part of a memory object with an input of the model of the ANeuralNetworksExecution.

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 part of a memory object with an output of the model of the ANeuralNetworksExecution.

ANeuralNetworksExecution_startCompute(ANeuralNetworksExecution *execution, ANeuralNetworksEvent **event)

int
Schedule evaluation of the execution.

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_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 16bit floatingpoint format.

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.

Structs 


ANeuralNetworksOperandType 
ANeuralNetworksOperandType describes the type of an operand. 
Enumerations
Anonymous Enum 39
Anonymous Enum 39
For ANeuralNetworksModel_setOperandValue, values with a length smaller or equal to this will be immediately copied into the model.
The size is in bytes.
Properties  

ANEURALNETWORKS_MAX_SIZE_OF_IMMEDIATELY_COPIED_VALUES

FuseCode
FuseCode
Fused activation function types.
Properties  

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

ANEURALNETWORKS_FLOAT32

A 32 bit floating point scalar value. 
ANEURALNETWORKS_INT32

A signed 32 bit integer scalar value. 
ANEURALNETWORKS_TENSOR_FLOAT32

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:
The formula is: real_value = (integer_value  zeroPoint) * scale. 
ANEURALNETWORKS_UINT32

An unsigned 32 bit integer scalar value. 
OperationCode
OperationCode
Operation types.
The type of operations that can be added to a model.
Properties  

ANEURALNETWORKS_ADD

Adds two tensors, elementwise. 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} Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:

ANEURALNETWORKS_AVERAGE_POOL_2D

Performs a 2D 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 OperandCode: 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):
Inputs (implicit padding):
Outputs:

ANEURALNETWORKS_BATCH_TO_SPACE_ND

BatchToSpace for Ndimensional 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 Inputs:
Outputs:

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:

ANEURALNETWORKS_CONV_2D

Performs an 2D convolution operation. The CONV_2D op sweeps a 2D 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 OperandCode: Supported tensor rank: 4, with "NHWC" data layout. Both explicit padding and implicit padding are supported. Inputs (explicit padding):
Inputs (implicit padding):
Outputs:

ANEURALNETWORKS_DEPTHWISE_CONV_2D

Performs a depthwise 2D 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 OperandCode: Supported tensor rank: 4, with "NHWC" data layout. Both explicit padding and implicit padding are supported. Inputs (explicit padding):
Inputs (implicit padding):
Outputs:

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 nonoverlapping 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" data layout. Inputs:
Outputs:

ANEURALNETWORKS_DEQUANTIZE

Dequantizes the input tensor. The formula is: output = (input  zeroPoint) * scale. Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:

ANEURALNETWORKS_DIV

Elementwise 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. 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} Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:

ANEURALNETWORKS_EMBEDDING_LOOKUP

Looks up subtensors in the input tensor. This operator takes for input a tensor of values (Values) and a onedimensional tensor of selection indices (Lookups). The output tensor is the concatenation of subtensors 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. Inputs:
Output:

ANEURALNETWORKS_FLOOR

Computes elementwise floor() on the input tensor. Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:

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:

ANEURALNETWORKS_HASHTABLE_LOOKUP

Looks up subtensors in the input tensor using a keyvalue map. This operator takes for input a tensor of values (Values), a onedimensional tensor of selection values (Lookups) and a onedimensional tensor that maps these values to Values indexes. The output tensor is the concatenation of subtensors of Values as selected by Lookups via Keys. Think of Values as being sliced along its outermost 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 subtensor of Values is included in the Output tensor. For a miss, the corresponding subtensor 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. Inputs:
Outputs:

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 1D slice along dimension dim. Supported tensor OperandCode: Supported tensor rank: 4, with "NHWC" data layout (i.e., Num_samples, Height, Width, and Channels). Inputs:
Outputs:

ANEURALNETWORKS_L2_POOL_2D

Performs an 2D 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 OperandCode: Supported tensor rank: 4, with "NHWC" data layout. Both explicit padding and implicit padding are supported. Inputs (explicit padding):
Inputs (implicit padding):
Outputs:

ANEURALNETWORKS_LOCAL_RESPONSE_NORMALIZATION

Applies Local Response Normalization along the depth dimension. The 4D input tensor is treated as a 3D array of 1D 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 OperandCode: Supported tensor rank: 4, with "NHWC" data layout. Inputs:
Outputs:

ANEURALNETWORKS_LOGISTIC

Computes sigmoid activation on the input tensor elementwise. The output is calculated using this formula: output = 1 / (1 + exp(input)) Supported tensor OperandCode: Supported tensor rank: up to 4. Inputs:
Outputs:

ANEURALNETWORKS_LSH_PROJECTION

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

ANEURALNETWORKS_LSTM

Performs a single time step in a Long ShortTerm Memory (LSTM) layer. The LSTM operation is described by the following equations. \begin{eqnarray*} i_t =& \sigma(W_{xi}x_t+W_{hi}h_{t1}+W_{ci}C_{t1}+b_i) & \\ f_t =& \sigma(W_{xf}x_t+W_{hf}h_{t1}+W_{cf}C_{t1}+b_f) & \\ C_t =& clip(f_t \odot C_{t1} + i_t \odot g(W_{xc}x_t+W_{hc}h_{t1}+b_c),\ t_{cell}) & \\ o_t =& \sigma(W_{xo}x_t+W_{ho}h_{t1}+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:
The operation has the following independently optional inputs:
References: The default nonpeephole nonCIFG implementation is based on: http://www.bioinf.jku.at/publications/older/2604.pdf S. Hochreiter and J. Schmidhuber. "Long ShortTerm Memory". Neural Computation, 9(8):17351780, 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 shortterm 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 OperandCode: Inputs:
Outputs:

ANEURALNETWORKS_MAX_POOL_2D

Performs an 2D 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 OperandCode: Supported tensor rank: 4, with "NHWC" data layout. Both explicit padding and implicit padding are supported. Inputs (explicit padding):
Inputs (implicit padding):
Outputs:

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. If dimensions to reduce have no entries, all dimensions are reduced, and a tensor with a single element is returned. Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:

ANEURALNETWORKS_MUL

Multiplies two tensors, elementwise. 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. Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:

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:

ANEURALNETWORKS_RELU

Computes rectified linear activation on the input tensor elementwise. The output is calculated using this formula: output = max(0, input) Supported tensor OperandCode: Supported tensor rank: up to 4. Inputs:
Outputs:

ANEURALNETWORKS_RELU1

Computes rectified linear 1 activation on the input tensor elementwise. 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:

ANEURALNETWORKS_RELU6

Computes rectified linear 6 activation on the input tensor elementwise. The output is calculated using this formula: output = min(6, max(0, input)) Supported tensor OperandCode: Supported tensor rank: up to 4. Inputs:
Outputs:

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:

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" data layout. Inputs:
Outputs:

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: Inputs:
Outputs:

ANEURALNETWORKS_SOFTMAX

Computes the softmax activation on the input tensor elementwise, 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 OperandCode: Supported tensor rank: 2 or 4. Inputs:
Outputs:

ANEURALNETWORKS_SPACE_TO_BATCH_ND

SpaceToBatch for NDimensional 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 Inputs:
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 nonoverlapping 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" data layout. Inputs:
Outputs:

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:

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:

ANEURALNETWORKS_SUB

Elementwise 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} Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:

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 RankConstrained Topology”. INTERSPEECH, 2015. It processes the incoming input using a 2stage 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: Inputs:
Outputs:

ANEURALNETWORKS_TANH

Computes hyperbolic tangent of input tensor elementwise. The output is calculated using this formula: output = tanh(input) Supported tensor OperandCode: Supported tensor rank: up to 4. Inputs:
Outputs:

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 (n1...0), where n is the rank of the input tensor. Hence by default, this operation performs a regular matrix transpose on 2D input Tensors. Supported tensor OperandCode: Supported tensor rank: up to 4 Inputs:
Outputs:

PaddingCode
PaddingCode
Implicit padding algorithms.
Properties  

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
PreferenceCode
Execution preferences.
Properties  

ANEURALNETWORKS_PREFER_FAST_SINGLE_ANSWER

Prefer returning a single answer as fast as possible, even if this causes more power consumption. 
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_SUSTAINED_SPEED

Prefer maximizing the throughput of successive frames, for example when processing successive frames coming from the camera. 
ResultCode
ResultCode
Typedefs
ANeuralNetworksCompilation
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.
 Set any desired properties on the compilation (for example, ANeuralNetworksCompilation_setPreference).
 Complete the compilation with ANeuralNetworksCompilation_finish.
 Use the compilation as many times as needed with ANeuralNetworksExecution_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 created using the compilation.
ANeuralNetworksEvent
struct ANeuralNetworksEvent ANeuralNetworksEvent
ANeuralNetworksEvent is an opaque type that represents an event that will be signaled once an execution completes.
ANeuralNetworksExecution
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 data to the model inputs with ANeuralNetworksExecution_setInput or ANeuralNetworksExecution_setInputFromMemory.
 Associate output buffers to the model outputs with ANeuralNetworksExecution_setOutput or ANeuralNetworksExecution_setOutputFromMemory.
 Apply the model with ANeuralNetworksExecution_startCompute.
 Wait for the execution to complete with ANeuralNetworksEvent_wait.
 Destroy the execution with ANeuralNetworksExecution_free.
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
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 tensor needed to define a model. ANeuralNetworksMemory_createFromFd can be used to create shared memory from a file handle.
Memory objects can also be used to specify the input and output arguments of an execution. See ANeuralNetworksExecution_setInputFromMemory and ANeuralNetworksExecution_setOutputFromMemory.
ANeuralNetworksModel
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
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
struct ANeuralNetworksOperandType ANeuralNetworksOperandType
ANeuralNetworksOperandType describes the type of an operand.
This structure is used to describe both scalars and tensors.
A tensor operand type must have a specified rank (number of dimensions) but may have any of its dimensions unspecified.
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.
In the following situations, a tensor operand type must be fully specified:
 The operand has a constant value, set by ANeuralNetworksModel_setOperandValue (with a nonnullptr buffer) or ANeuralNetworksModel_setOperandValueFromMemory.
 The operand is a model input or model output (see ANeuralNetworksModel_identifyInputsAndOutputs). A fully specified tensor operand type must either be provided to ANeuralNetworksModel_addOperand; or it must be provided to the corresponding ANeuralNetworksExecution_setInput, ANeuralNetworksExecution_setInputFromMemory, ANeuralNetworksExecution_setOutput, or ANeuralNetworksModel_setOperandValueFromMemory. EXCEPTION: If the input or output is optional and omitted (by passing nullptr for buffer to ANeuralNetworksExecution_setInput or ANeuralNetworksExecution_setOutput) then it need not have a fully specified tensor operand type.
A tensor operand type with some number of unspecified dimensions is represented by setting each unspecified dimension to 0.
ANeuralNetworksOperationType
int32_t ANeuralNetworksOperationType
Functions
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.
Details  

Parameters 


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

Parameters 


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

Parameters 

ANeuralNetworksCompilation_setPreference
int ANeuralNetworksCompilation_setPreference( ANeuralNetworksCompilation *compilation, int32_t preference )
Sets the execution preference.
Provides guidance to the runtime when tradeoffs are possible.
See ANeuralNetworksCompilation for information on multithreaded usage.
Details  

Parameters 


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

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

Parameters 


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

Parameters 

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.
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
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.
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_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.
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 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.
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 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.
Details  

Parameters 


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

Parameters 


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

Parameters 

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 accommodate inputs of various sizes, as you may want to do for a CNN, leave unspecified the dimensions that will vary at run time. If you do so, fully specify 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.
Details  

Parameters 


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.
The operands specified by inputs and outputs must have been previously added by calls to ANeuralNetworksModel_addOperand.
Details  

Parameters 

Attempting to modify a model once ANeuralNetworksModel_finish has been called will return an error.
See ANeuralNetworksModel for information on multithreaded usage.
Details  

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

Parameters 


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

Parameters 


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

Parameters 

ANeuralNetworksModel_identifyInputsAndOutputs
int ANeuralNetworksModel_identifyInputsAndOutputs( ANeuralNetworksModel *model, uint32_t inputCount, const uint32_t *inputs, uint32_t outputCount, const uint32_t *outputs )
Specifies 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.
The operands specified by inputs and outputs must have been previously added by calls to ANeuralNetworksModel_addOperand.
Details  

Parameters 

Attempting to modify a model once ANeuralNetworksModel_finish has been called will return an error.
See ANeuralNetworksModel for information on multithreaded usage.
ANeuralNetworksModel_relaxComputationFloat32toFloat16
int ANeuralNetworksModel_relaxComputationFloat32toFloat16( ANeuralNetworksModel *model, bool allow )
Specifies whether ANEURALNETWORKS_TENSOR_FLOAT32 is allowed to be calculated with range and/or precision as low as that of the IEEE 754 16bit floatingpoint format.
By default, ANEURALNETWORKS_TENSOR_FLOAT32 must be calculated using at least the range and precision of the IEEE 754 32bit floatingpoint format.
Attempting to modify a model once ANeuralNetworksModel_finish has been called will return an error.
Details  

Parameters 

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

Parameters 


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

Parameters 


Returns 
ANEURALNETWORKS_NO_ERROR if successful.
