tflite Namespace

# tflite

\file

## Summary

For documentation, see tensorflow/lite/core/interpreter.h.

Memory management for TF Lite.

This provides a few C++ helpers that are useful for manipulating C structures in C++.

Main abstraction controlling the tflite interpreter. Do NOT include this file directly, instead include third_party/tensorflow/lite/interpreter.h See third_party/tensorflow/lite/c/common.h for the API for defining operations (TfLiteRegistration).

Provides functionality to construct an interpreter for a model.

WARNING: Users of TensorFlow Lite should not include this file directly, but should instead include "third_party/tensorflow/lite/interpreter_builder.h". Only the TensorFlow Lite implementation itself should include this file directly.

Deserialization infrastructure for tflite. Provides functionality to go from a serialized tflite model in flatbuffer format to an in-memory representation of the model.

WARNING: Users of TensorFlow Lite should not include this file directly, but should instead include "third_party/tensorflow/lite/model_builder.h". Only the TensorFlow Lite implementation itself should include this file directly.

### Typedefs
`FlatBufferModel` | using `impl::FlatBufferModel`
`Interpreter` | typedef `::tflite::impl::Interpreter` An interpreter for a graph of nodes that input and output from tensors.
`InterpreterBuilder` | using `impl::InterpreterBuilder` Build an interpreter capable of interpreting `model`.

### Functions
`DefaultErrorReporter()` | `ErrorReporter *`
`GetRegistrationFromOpCode(const OperatorCode *opcode, const OpResolver & op_resolver, ErrorReporter *error_reporter, const TfLiteRegistration **registration)` | `TfLiteStatus`

### Classes
tflite::Allocation | A memory allocation handle. This could be a mmap or shared memory.
tflite::ErrorReporter | A functor that reports error to supporting system.
tflite::FileCopyAllocation |
tflite::MMAPAllocation | Note that not all platforms support MMAP-based allocation.
tflite::MemoryAllocation |
tflite::MutableOpResolver | An OpResolver that is mutable, also used as the op in gen_op_registration.
tflite::OpResolver | Abstract interface that returns TfLiteRegistrations given op codes or custom op names.
tflite::TfLiteIntArrayView | Provides a range iterable wrapper for TfLiteIntArray* (C lists) that TfLite C api uses.

### Structs
tflite::StderrReporter |

### Namespaces
tflite::impl | An RAII object that represents a read-only tflite model, copied from disk, or mmapped.
tflite::op_resolver_hasher |

## Typedefs

### FlatBufferModel

    impl::FlatBufferModel FlatBufferModel

### Interpreter

    ::tflite::impl::Interpreter Interpreter

An interpreter for a graph of nodes that input and output from tensors.

Each node of the graph processes a set of input tensors and produces a set of output Tensors. All inputs/output tensors are referenced by index.

Usage:

    // Create model from file. Note that the model instance must outlive the
    // interpreter instance.
    auto model = tflite::FlatBufferModel::BuildFromFile(...);
    if (model == nullptr) {
      // Return error.
    }
    // Create an Interpreter with an InterpreterBuilder.
    std::unique_ptr interpreter;
    tflite::ops::builtin::BuiltinOpResolver resolver;
    if (InterpreterBuilder(*model, resolver)(&interpreter) != kTfLiteOk) {
      // Return failure.
    }
    if (interpreter->AllocateTensors() != kTfLiteOk) {
      // Return failure.
    }

    auto input = interpreter->typed_tensor(0);
    for (int i = 0; i < input_size; i++) {
      input[i] = ...;  interpreter->Invoke();

Note: For nearly all practical use cases, one should not directly construct an Interpreter object, but rather use the InterpreterBuilder.

\warning This class is not thread-safe. The client is responsible for ensuring serialized interaction to avoid data races and undefined behavior.

### InterpreterBuilder

    impl::InterpreterBuilder InterpreterBuilder

Build an interpreter capable of interpreting `model`.

- `model`: A model whose lifetime must be at least as long as any interpreter(s) created by the builder. In principle multiple interpreters can be made from a single model.
- `op_resolver`: An instance that implements the `OpResolver` interface, which maps custom op names and builtin op codes to op registrations. The lifetime of the provided `op_resolver` object must be at least as long as the `InterpreterBuilder`; unlike `model` and `error_reporter`, the `op_resolver` does not need to exist for the duration of any created `Interpreter` objects.
- `error_reporter`: a functor that is called to report errors that handles printf var arg semantics. The lifetime of the `error_reporter` object must be greater than or equal to the `Interpreter` created by `operator()`.
- `options_experimental`: Options that can change behavior of interpreter. WARNING: this parameter is an experimental API and is subject to change.

Returns a kTfLiteOk when successful and sets interpreter to a valid Interpreter. Note: The user must ensure the lifetime of the model (and error reporter, if provided) is at least as long as interpreter's lifetime, and a single model instance may safely be used with multiple interpreters.

## Functions

### DefaultErrorReporter

    ErrorReporter * DefaultErrorReporter()

### GetRegistrationFromOpCode

    TfLiteStatus GetRegistrationFromOpCode(
      const OperatorCode *opcode,
      const OpResolver & op_resolver,
      ErrorReporter *error_reporter,
      const TfLiteRegistration **registration
    )