TFLite Micro —
MCU/Edge çıkarımı.

import tensorflow as tf
import numpy as np

# Eğitilmiş modeli yükle
model = tf.keras.models.load_model("gesture_mobilenet.h5")

# Kalibrasyon veri seti oluştur (temsili örnekler)
def representative_dataset():
    for _ in range(200):
        data = np.random.rand(1, 96, 96, 3).astype(np.float32)
        yield [data]

# TFLite Converter
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset

# Tam INT8: hem ağırlıklar hem aktivasyonlar
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type  = tf.int8
converter.inference_output_type = tf.int8

tflite_model = converter.convert()
with open("gesture_int8.tflite", "wb") as f:
    f.write(tflite_model)

print(f"Model boyutu: {len(tflite_model) / 1024:.1f} KB")

# RPi OS / Debian tabanlı (arm64)
pip install tflite-runtime

# PC'de geliştirme için (tam TF)
pip install tensorflow

import numpy as np
import tflite_runtime.interpreter as tflite
import time

# Model yükle
interpreter = tflite.Interpreter(model_path="gesture_int8.tflite",
                                  num_threads=4)
interpreter.allocate_tensors()

# Tensor bilgilerini al
input_details  = interpreter.get_input_details()
output_details = interpreter.get_output_details()

print("Input  shape:", input_details[0]['shape'])   # [1, 96, 96, 1]
print("Input  dtype:", input_details[0]['dtype'])   # int8
print("Output shape:", output_details[0]['shape'])  # [1, 5]

# INT8 giriş için quantization parametreleri
scale, zero_point = input_details[0]['quantization']
# float_input → int8: int8_val = float_val / scale + zero_point

# Örnek çıkarım
img_float = np.random.rand(1, 96, 96, 1).astype(np.float32)
img_int8  = (img_float / scale + zero_point).astype(np.int8)

interpreter.set_tensor(input_details[0]['index'], img_int8)

t0 = time.perf_counter()
interpreter.invoke()
t1 = time.perf_counter()

output = interpreter.get_tensor(output_details[0]['index'])
print(f"Çıkarım süresi: {(t1-t0)*1000:.2f} ms")
print(f"Sınıf skorları: {output}")
print(f"Tahmin: sınıf {np.argmax(output)}")

# benchmark_model binary'ini indir veya derle
wget https://storage.googleapis.com/tensorflow-nightly-public/prod/tensorflow/release/lite/tools/nightly/latest/linux_aarch64/benchmark_model

chmod +x benchmark_model

./benchmark_model \
  --graph=gesture_int8.tflite \
  --num_threads=4 \
  --num_runs=50 \
  --warmup_runs=5

# Örnek çıktı:
# Inference timings in us: Avg=28471, Min=27842, Max=31205
# INIT: 45231 us, 1st inference: 30123 us
# Warmup iterations: 5, Inferences: 50

// TFLM başlıkları
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/schema/schema_generated.h"

// Model (xxd ile C array'e dönüştürülmüş .tflite)
#include "gesture_model_data.h"

namespace {
  tflite::MicroErrorReporter micro_error_reporter;
  tflite::ErrorReporter*     error_reporter = µ_error_reporter;

  const tflite::Model* model = nullptr;
  tflite::MicroInterpreter* interpreter = nullptr;
  TfLiteTensor* input  = nullptr;
  TfLiteTensor* output = nullptr;

  // Tensor arena — SRAM'de statik dizi
  constexpr int kTensorArenaSize = 70 * 1024;  // 70 KB
  static uint8_t tensor_arena[kTensorArenaSize];
}

void setup() {
  // Model flatbuffer'ı yükle
  model = tflite::GetModel(g_gesture_model_data);
  if (model->version() != TFLITE_SCHEMA_VERSION) {
    TF_LITE_REPORT_ERROR(error_reporter, "Model schema uyumsuz!");
    return;
  }

  // Yalnızca kullanılan op'ları kaydet (binary boyutu küçültür)
  static tflite::MicroMutableOpResolver<5> resolver;
  resolver.AddConv2D();
  resolver.AddDepthwiseConv2D();
  resolver.AddMaxPool2D();
  resolver.AddFullyConnected();
  resolver.AddSoftmax();

  // Interpreter oluştur
  static tflite::MicroInterpreter static_interpreter(
      model, resolver, tensor_arena, kTensorArenaSize, error_reporter);
  interpreter = &static_interpreter;

  // Tensörleri tahsis et
  TfLiteStatus alloc_status = interpreter->AllocateTensors();
  if (alloc_status != kTfLiteOk) {
    TF_LITE_REPORT_ERROR(error_reporter,
        "AllocateTensors başarısız! Arena: %d KB", kTensorArenaSize/1024);
    return;
  }

  input  = interpreter->input(0);
  output = interpreter->output(0);

  // Kullanılan arena miktarını yazdır
  TF_LITE_REPORT_ERROR(error_reporter,
      "Arena kullanımı: %d bytes",
      interpreter->arena_used_bytes());
}

void loop() {
  // Giriş tensörüne kamera görüntüsü yaz (INT8 format)
  int8_t* input_data = input->data.int8;
  // ... kamera'dan piksel kopyala ...

  // Çıkarım
  if (interpreter->Invoke() != kTfLiteOk) {
    TF_LITE_REPORT_ERROR(error_reporter, "Invoke başarısız!");
    return;
  }

  // Çıkış tensöründen sınıfı al
  int8_t* scores = output->data.int8;
  int     best   = 0;
  for (int i = 1; i < output->dims->data[1]; i++) {
    if (scores[i] > scores[best]) best = i;
  }
  // best → 0=idle, 1=up, 2=down, 3=left, 4=right
}

# .tflite dosyasını C array'e çevir
xxd -i gesture_int8.tflite > gesture_model_data.cc

# gesture_model_data.cc içeriği:
# unsigned char g_gesture_model_data[] = { 0x1c, 0x00, ... };
# unsigned int  g_gesture_model_data_len = 1348216;

# Yöntem 1: pip ile Python runtime (en hızlı)
pip3 install tflite-runtime

# Yöntem 2: libtensorflow-lite.so ile C++ uygulamaları için
# TFLite'ı kaynaktan derle (aarch64 üzerinde)
git clone --depth 1 https://github.com/tensorflow/tensorflow
cd tensorflow

# Bağımlılıklar
sudo apt-get install -y cmake libabsl-dev libflatbuffers-dev

# CMake ile derle
mkdir tflite-build && cd tflite-build
cmake ../tensorflow/lite \
    -DCMAKE_BUILD_TYPE=Release \
    -DTFLITE_ENABLE_XNNPACK=ON \
    -DTFLITE_ENABLE_NNAPI=OFF
make -j4 libtensorflow-lite.a

# Host PC'den cross-compile (aarch64-linux-gnu toolchain)
cmake ../tensorflow/lite \
    -DCMAKE_TOOLCHAIN_FILE=../tensorflow/lite/tools/cmake/toolchains/aarch64_linux.cmake \
    -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)

import tflite_runtime.interpreter as tflite

# XNNPACK delegate etkinleştir (RPi4'te varsayılan olarak açık)
interpreter = tflite.Interpreter(
    model_path="gesture_int8.tflite",
    experimental_delegates=[
        tflite.load_delegate('libxnnpack_delegate.so')
    ],
    num_threads=4
)
interpreter.allocate_tensors()

from picamera2 import Picamera2
import numpy as np
import tflite_runtime.interpreter as tflite
import cv2, time

interpreter = tflite.Interpreter("gesture_int8.tflite", num_threads=4)
interpreter.allocate_tensors()
inp_det = interpreter.get_input_details()[0]
out_det = interpreter.get_output_details()[0]
scale, zp = inp_det['quantization']

picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration(
    main={"size": (640, 480), "format": "RGB888"}))
picam2.start()

LABELS = ["idle", "up", "down", "left", "right"]

while True:
    frame = picam2.capture_array()                    # (480,640,3) uint8
    roi   = cv2.resize(frame[:, 80:560], (96, 96))    # kare kırp, yeniden boyutlandır
    gray  = cv2.cvtColor(roi, cv2.COLOR_RGB2GRAY)
    inp   = (gray.astype(np.float32)/255.0 / scale + zp).astype(np.int8)
    inp   = inp[np.newaxis, ..., np.newaxis]          # (1,96,96,1)

    interpreter.set_tensor(inp_det['index'], inp)
    t0 = time.perf_counter()
    interpreter.invoke()
    dt = (time.perf_counter() - t0) * 1000

    scores = interpreter.get_tensor(out_det['index'])[0]
    pred   = int(np.argmax(scores))
    print(f"{LABELS[pred]}  ({dt:.1f} ms)")

#include "app_x-cube-ai.h"
#include "network.h"
#include "network_data.h"

static ai_handle network = AI_HANDLE_NULL;
static ai_u8 activations[AI_NETWORK_DATA_ACTIVATIONS_SIZE];

void MX_X_CUBE_AI_Init(void) {
    ai_network_create_and_init(&network,
        activations, AI_NETWORK_DATA_CONFIG);
}

void MX_X_CUBE_AI_Process(int8_t *input_buf, int8_t *output_buf) {
    ai_buffer ai_input[]  = AI_NETWORK_IN_1_ARGS(input_buf);
    ai_buffer ai_output[] = AI_NETWORK_OUT_1_ARGS(output_buf);
    ai_network_run(network, ai_input, ai_output);
}

./benchmark_model \
  --graph=gesture_int8.tflite \
  --enable_op_profiling=true \
  --num_threads=4 \
  --num_runs=20

# Örnek çıktı:
# Node type              | avg (ms) | avg%  | cdf%
# CONV_2D                |   8.241  | 42.1% | 42.1%
# DEPTHWISE_CONV_2D      |   6.112  | 31.2% | 73.3%
# FULLY_CONNECTED        |   2.834  | 14.5% | 87.8%
# SOFTMAX                |   0.231  |  1.2% | 89.0%
# MAX_POOL_2D            |   2.154  | 11.0% |100.0%

import tensorflow as tf

# Model analizi
analyzer = tf.lite.experimental.Analyzer
analyzer.analyze(
    model_path="gesture_int8.tflite",
    gpu_compatibility=True
)

# Netron ile aç (yerel)
import netron
netron.start("gesture_int8.tflite", port=8080)

import RPi.GPIO as GPIO

LED_PINS = {
    "up":    17,
    "down":  18,
    "left":  27,
    "right": 22,
    "idle":  None
}

GPIO.setmode(GPIO.BCM)
for pin in LED_PINS.values():
    if pin: GPIO.setup(pin, GPIO.OUT, initial=GPIO.LOW)

def set_gesture_led(label: str):
    for name, pin in LED_PINS.items():
        if pin:
            GPIO.output(pin, GPIO.HIGH if name == label else GPIO.LOW)
    print(f"Hareket: {label}")