ailia TFLite Runtime

Getting Started

Choose your platform and run your first TFLite inference.

Install

Install the ailia TFLite Python package from PyPI.

pip3 install ailia_tflite

View on PyPI

Run a Sample

ailia-models-tflite bundles per-model inference scripts. Clone once, install the shared requirements, then cd into any model folder and run — pass -v 0 for webcam input or -i image.png for a still. python3 launcher.py at the repo root opens a GUI that browses every quantized TFLite model.

git clone https://github.com/ailia-ai/ailia-models-tflite.git
cd ailia-models-tflite
pip3 install -r requirements.txt
cd object_detection/yolox
python3 yolox.py -v 0

Sample Repository

Get Evaluation Package

Apply for the free trial to obtain the evaluation package, which contains the C99 binding (ailia_tflite.h), the runtime library, the license file, and a runnable sample.

Apply for Free Trial

Build & Run

Compile against the runtime library; the API mirrors TensorFlow Lite's C API. Designed for NonOS / RTOS targets, the C99 implementation is dependency-free aside from libailia_tflite.

# macOS
clang -o tflite_sample tflite_sample.c \
  libailia_tflite.dylib -Wl,-rpath,./

./tflite_sample model.tflite

C API Reference

Install via UPM

Open Window > Package Manager in Unity (2021.3.10f1+), click + > Add package from git URL, and enter the binding URL below.

https://github.com/ailia-ai/ailia-tflite-unity.git

Unity API Reference

Run a Sample

Clone ailia-models-unity, open it in the Unity Editor (2021.3.10f1+), and play ObjectDetection/ObjectDetectionSample.unity. The YOLOX TFLite path delegates to AiliaTFLiteYoloxSample.cs for NNAPI / mobile inference.

git clone https://github.com/ailia-ai/ailia-models-unity.git

AiliaTFLiteYoloxSample.cs

Clone Binding

For your own project, clone the JNI binding repository and add it to your Android Studio project.

git clone https://github.com/ailia-ai/ailia-tflite-jni.git

Binding

Run a Sample

Clone ailia-models-kotlin with submodules and open it in Android Studio. Run the TFLite object-detection sample on a connected device.

git clone https://github.com/ailia-ai/ailia-models-kotlin.git
cd ailia-models-kotlin
git submodule update --init --recursive

AiliaTFLiteObjectDetectionSample.kt

Use the API in Your Project

Minimal examples for loading a TFLite model and running inference. The Python API mirrors tflite_runtime.interpreter, so existing TFLite code works with one import change.

import ailia_tflite
import numpy as np

interpreter = ailia_tflite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

input_data = np.zeros(input_details[0]["shape"], dtype=np.float32)
interpreter.set_tensor(input_details[0]["index"], input_data)
interpreter.invoke()

output = interpreter.get_tensor(output_details[0]["index"])
print(output.shape)

#include "ailia_tflite.h"
#include <stdio.h>
#include <stdlib.h>

// Read model.tflite into a buffer
FILE *f = fopen("model.tflite", "rb");
fseek(f, 0, SEEK_END);
size_t len = ftell(f);
fseek(f, 0, SEEK_SET);
void *buf = malloc(len);
fread(buf, 1, len, f);
fclose(f);

struct AILIATFLiteInstance *interp = NULL;
ailiaTFLiteCreate(&interp, buf, len,
                  NULL, NULL, NULL, NULL,    // default allocators
                  AILIA_TFLITE_ENV_REFERENCE,
                  AILIA_TFLITE_MEMORY_MODE_DEFAULT,
                  AILIA_TFLITE_FLAG_NONE);

ailiaTFLiteAllocateTensors(interp);
ailiaTFLitePredict(interp);
ailiaTFLiteDestroy(interp);
free(buf);

using ailiaTFLite;

var interpreter = new AiliaTFLiteModel();
interpreter.OpenFile("model.tflite");
interpreter.AllocateTensors();

var input = new float[1 * 224 * 224 * 3];
interpreter.SetInputTensorData(0, input);
interpreter.Predict();

var output = interpreter.GetOutputTensorData<float>(0);

val tflite = AiliaTFLite()
tflite.open(modelData, AiliaTFLite.AILIA_TFLITE_ENV_REFERENCE)
tflite.allocateTensors()

val inputIdx = tflite.getInputTensorIndex(0)
val outputIdx = tflite.getOutputTensorIndex(0)
tflite.setTensorData(inputIdx, inputBuffer)
tflite.predict()

val output = tflite.getTensorData(outputIdx)
tflite.close()

FAQ

Common questions about ailia TFLite Runtime.

Is it really a drop-in replacement for TensorFlow Lite?

Yes. The Python ailia_tflite.Interpreter class mirrors tflite_runtime.interpreter.Interpreter — same constructor, same allocate_tensors() / set_tensor() / invoke() / get_tensor() methods. Existing TFLite Python scripts typically need only an import change.

Where does ailia TFLite shine compared to upstream TFLite?

Two main areas: high-speed PC inference via Intel MKL, and embedded deployment on NonOS / RTOS thanks to a lightweight C99 implementation. On Android it can also drive the on-device NPU through NNAPI.

You can compare against upstream behaviour by passing --tflite to the sample scripts in ailia-models-tflite.

Does it support quantized models?

Yes. INT8 quantized TFLite models are first-class — quantization is the recommended path for embedded targets and NPUs. The model zoo at ailia-models-tflite is built around quantized variants.

Can I use it on microcontrollers?

The C99 core is designed for NonOS / RTOS and small footprint deployments. Specific MCU support depends on available memory and toolchain — contact ailia for embedded port details.

How do I switch back-ends (CPU / NPU / MKL)?

Pass env_id (and optional flags / num_threads) when constructing ailia_tflite.Interpreter. The default chooses the fastest available back-end for your platform.

How does licensing work?

An evaluation license is downloaded automatically at runtime, suitable for development and trial. For commercial deployment — including embedded redistribution — request a production license. See the ailia license terms.

Getting Started

Install

Run a Sample

Get Evaluation Package

Build & Run

Install via UPM

Run a Sample

Clone Binding

Run a Sample

System Requirements

Operating Systems

Languages

Acceleration

Model Formats

Use the API in Your Project

API Reference by Platform

Python

C99

Unity

JNI

FAQ

Materials