ailia TFLite Runtime

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

// Load 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 *model = malloc(len);
fread(model, 1, len, f);
fclose(f);

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

// Quantize float → int8 and write into the first input tensor
int32_t in_idx;
ailiaTFLiteGetInputTensorIndex(interp, &in_idx, 0);
float in_scale; int64_t in_zp;
ailiaTFLiteGetTensorQuantizationScale(interp, &in_scale, in_idx);
ailiaTFLiteGetTensorQuantizationZeroPoint(interp, &in_zp, in_idx);
int8_t *in_buf = NULL;
ailiaTFLiteGetTensorBuffer(interp, (void**)&in_buf, in_idx);
for (size_t i = 0; i < in_count; i++) {
    int32_t q = (int32_t)lroundf(input_float[i] / in_scale) + (int32_t)in_zp;
    in_buf[i] = (int8_t)(q < -128 ? -128 : q > 127 ? 127 : q);
}

ailiaTFLitePredict(interp);

// Dequantize int8 → float from the first output tensor
int32_t out_idx;
ailiaTFLiteGetOutputTensorIndex(interp, &out_idx, 0);
float out_scale; int64_t out_zp;
ailiaTFLiteGetTensorQuantizationScale(interp, &out_scale, out_idx);
ailiaTFLiteGetTensorQuantizationZeroPoint(interp, &out_zp, out_idx);
const int8_t *out_buf = NULL;
ailiaTFLiteGetTensorBuffer(interp, (void**)&out_buf, out_idx);
for (size_t i = 0; i < out_count; i++) {
    output_float[i] = (out_buf[i] - (int32_t)out_zp) * out_scale;
}

ailiaTFLiteDestroy(interp);
free(model);

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()