NPU Programlama —
Coral · Hailo · RK NPU.

# Edge TPU Compiler kurulumu (Debian/Ubuntu)
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" \
     | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
sudo apt-get update && sudo apt-get install -y edgetpu-compiler

# Model derleme
edgetpu_compiler gesture_int8.tflite

# Çıktı:
# Edge TPU Compiler version 16.0
# Model compiled successfully in 3832 ms.
# Model: gesture_int8.tflite
#   INFO: Number of operations that will run on Edge TPU: 28/28
#   INFO: Compiler successfully mapped all operations to Edge TPU.
# Output: gesture_int8_edgetpu.tflite

from pycoral.utils import edgetpu
from pycoral.adapters import common, classify
from PIL import Image
import numpy as np, time

# Edge TPU interpreter oluştur
interpreter = edgetpu.make_interpreter("gesture_int8_edgetpu.tflite")
interpreter.allocate_tensors()

# Giriş boyutları
size = common.input_size(interpreter)  # (96, 96)
print(f"Giriş boyutu: {size}")

# Görüntü yükle ve çıkarım yap
img  = Image.open("test_gesture.jpg").resize(size, Image.LANCZOS)
common.set_input(interpreter, img)

t0 = time.perf_counter()
interpreter.invoke()
dt = (time.perf_counter() - t0) * 1000

# Sınıflandırma çıktısını al
classes = classify.get_classes(interpreter, top_k=3, score_threshold=0.0)
for c in classes:
    print(f"  Sınıf {c.id}: {c.score:.4f}")

print(f"Edge TPU çıkarım: {dt:.2f} ms")

# HailoRT DEB paketi kur (hailo.ai developer zone)
sudo dpkg -i hailort_4.17.0_arm64.deb

# Python binding
pip install hailort

# Cihaz tespiti
hailortcli scan
# Hailo-8 PCIe device found [0000:01:00.0]

# Benchmark
hailortcli benchmark yolov8n.hef --batch-size 1 --time-to-run 30

import hailo_platform as hp
import numpy as np, time

# HEF modeli yükle
hef = hp.HEF("yolov8n.hef")

# Cihaz ve yapılandırma
target = hp.VDevice()
network_group = target.configure(hef)[0]
network_params = network_group.create_params()

# Giriş/çıkış stream bilgisi
input_vstreams  = hp.InputVStreamParams.make(network_group)
output_vstreams = hp.OutputVStreamParams.make(network_group)

input_name  = list(input_vstreams)[0]
output_name = list(output_vstreams)[0]

# Çıkarım döngüsü
with hp.InferVStreams(network_group, input_vstreams, output_vstreams) as infer:
    img = np.random.randint(0, 255, (1, 3, 640, 640), dtype=np.uint8)

    t0 = time.perf_counter()
    infer_results = infer.infer({input_name: img})
    dt = (time.perf_counter() - t0) * 1000

    output = infer_results[output_name]
    print(f"Hailo-8 çıkarım: {dt:.2f} ms")
    print(f"Çıkış şekli: {output.shape}")

# Python 3.8-3.11 ortamı
conda create -n rknn python=3.10
conda activate rknn

# RKNN Toolkit 2 (host PC - model compile için)
pip install rknn-toolkit2==2.2.0

# RKNN Lite (hedef cihazda - runtime için)
# Hedef cihazda (RK3588 üzerinde):
pip install rknn-toolkit-lite2==2.2.0

# C runtime library: /usr/lib/librknnrt.so (cihazda önceden kurulu)

from rknn.api import RKNN
import numpy as np, cv2, glob

rknn = RKNN(verbose=True)

# 1. Model yükle (ONNX veya TFLite)
rknn.load_onnx(model="yolov8n.onnx")

# 2. Konfigürasyon
rknn.config(
    mean_values=[[0, 0, 0]],           # RGB ortalama
    std_values=[[255, 255, 255]],       # normalleştirme
    target_platform="rk3588",          # hedef SoC
    quant_img_RGB2BGR=False,
    quantized_algorithm="normal",       # "normal" | "kl_divergence"
    quantized_method="channel",         # per-channel quantization
    optimization_level=3
)

# 3. Model oluştur
rknn.build(do_quantization=True,
           dataset="calib_dataset.txt")  # kalibrasyon görüntü yolları

# 4. Doğruluk analizi (ONNX vs RKNN karşılaştırma)
rknn.accuracy_analysis(
    inputs=["calib_dataset.txt"],
    target=None,                        # simülasyon modu
    output_dir="./snapshot"
)

# 5. Model dışa aktar
rknn.export_rknn("yolov8n.rknn")
print("RKNN model dışa aktarıldı")
rknn.release()

import glob, os

images = glob.glob("./calib_images/*.jpg")[:200]
with open("calib_dataset.txt", "w") as f:
    for img_path in images:
        f.write(os.path.abspath(img_path) + "\n")
print(f"{len(images)} kalibrasyon görüntüsü yazıldı")

from rknnlite.api import RKNNLite
import numpy as np, cv2, time

rknn_lite = RKNNLite()

# Model yükle
ret = rknn_lite.load_rknn("yolov8n.rknn")
if ret != 0:
    print("RKNN model yükleme hatası!")
    exit(ret)

# Runtime başlat (NPU core seçimi: 0,1,2 veya NPU_CORE_AUTO)
rknn_lite.init_runtime(
    core_mask=RKNNLite.NPU_CORE_0   # tek core
    # core_mask=RKNNLite.NPU_CORE_0_1_2  # 3 core, büyük modeller için
)

# Görüntü hazırlama
img = cv2.imread("test.jpg")
img = cv2.resize(img, (640, 640))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

# Çıkarım
t0 = time.perf_counter()
outputs = rknn_lite.inference(inputs=[img])
dt = (time.perf_counter() - t0) * 1000

print(f"RKNN çıkarım: {dt:.2f} ms")
print(f"Çıkış şekli: {outputs[0].shape}")

rknn_lite.release()

# Vela kurulumu
pip install ethos-u-vela

# Model derleme (Ethos-U55, 256 MAC konfigürasyonu)
vela gesture_int8.tflite \
     --accelerator-config ethos-u55-256 \
     --system-config Ethos_U55_High_End \
     --memory-mode Shared_Sram \
     --output-dir vela_output/

# Çıktı: vela_output/gesture_int8_vela.tflite

# Optimizasyon raporu
vela --show-cpu-operations gesture_int8.tflite \
     --accelerator-config ethos-u55-256

#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
#include "ethosu_driver.h"                    // Ethos-U driver
#include "tensorflow/lite/micro/cortex_m_generic/debug_log_callback.h"

// Ethos-U55 NPU sürücüsü başlat
static struct ethosu_driver ethosu_drv;
extern "C" void NPU_IRQHandler(void) {
    ethosu_irq_handler(ðosu_drv);
}

void setup_ethos() {
    ethosu_init(ðosu_drv,
                (void*)ETHOS_U_NPU_BASE,   // NPU base address
                NULL, 0,                    // cache flush callback
                1, 0);                      // secure, privileged
}

// TFLM ile Ethos delegate kullanımı
#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
// Ethos-U op resolver'a ekleme
resolver.AddEthosU();  // NPU delegate op ekle

// Interpreter'da delegate otomatik aktif olur

import threading, queue, time
import numpy as np

# Thread-safe kuyruklar
raw_queue   = queue.Queue(maxsize=4)   # Ham frame
det_queue   = queue.Queue(maxsize=4)   # Tespit sonuçları
result_queue= queue.Queue(maxsize=4)   # Son sonuçlar

def capture_thread():
    """CPU: Kamera yakalama"""
    import cv2
    cap = cv2.VideoCapture(0)
    while True:
        ret, frame = cap.read()
        if not ret: break
        if not raw_queue.full():
            raw_queue.put(frame)

def detection_npu_thread(det_session):
    """NPU: Yüz tespiti"""
    while True:
        frame = raw_queue.get()
        # Ön işleme (CPU)
        inp = preprocess(frame, size=(640,640))
        # NPU çıkarım
        boxes = det_session.run(None, {"images": inp})[0]
        det_queue.put((frame, boxes))

def recognition_npu_thread(rec_session, face_db):
    """NPU: Yüz tanıma"""
    while True:
        frame, boxes = det_queue.get()
        results = []
        for box in parse_boxes(boxes):
            roi = crop_align(frame, box)           # CPU affine
            emb = rec_session.run(None, {"input": roi})[0]
            name, sim = find_match(emb, face_db)   # CPU cosine
            results.append((box, name, sim))
        result_queue.put((frame, results))

# Thread'leri başlat
threading.Thread(target=capture_thread, daemon=True).start()
threading.Thread(target=detection_npu_thread,
                 args=(det_session,), daemon=True).start()
threading.Thread(target=recognition_npu_thread,
                 args=(rec_session, face_db), daemon=True).start()

# libedgetpu (USB runtime)
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" \
     | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
sudo apt-get update
sudo apt-get install -y libedgetpu1-std   # max hız için: libedgetpu1-max

# pycoral
pip install pycoral

# Hazır model: face detection SSD MobileNet INT8
wget https://github.com/google-coral/test_data/raw/master/ssd_mobilenet_v2_face_quant_postprocess_edgetpu.tflite
wget https://raw.githubusercontent.com/google-coral/test_data/master/face_labels.txt

from pycoral.utils import edgetpu
from pycoral.adapters import detect, common
import cv2, time, numpy as np

MODEL = "ssd_mobilenet_v2_face_quant_postprocess_edgetpu.tflite"
THRESHOLD  = 0.5

interpreter = edgetpu.make_interpreter(MODEL)
interpreter.allocate_tensors()
_, height, width, _ = interpreter.get_input_details()[0]['shape']

cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH,  640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

frame_count = 0
fps_time    = time.time()

while True:
    ret, frame = cap.read()
    if not ret: break

    # Ön işleme: resize + BGR→RGB
    rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    resized = cv2.resize(rgb, (width, height))

    # Edge TPU çıkarım
    common.set_input(interpreter, resized)
    t0 = time.perf_counter()
    interpreter.invoke()
    inference_ms = (time.perf_counter() - t0) * 1000

    # Tespit sonuçları
    objs = detect.get_objects(interpreter, score_threshold=THRESHOLD)

    # Bounding box çiz
    h, w = frame.shape[:2]
    for obj in objs:
        bbox = obj.bbox
        x0 = int(bbox.xmin * w); y0 = int(bbox.ymin * h)
        x1 = int(bbox.xmax * w); y1 = int(bbox.ymax * h)
        cv2.rectangle(frame, (x0,y0), (x1,y1), (0,255,0), 2)
        cv2.putText(frame, f"{obj.score:.2f}",
                    (x0, y0-5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,0), 2)

    # FPS hesaplama
    frame_count += 1
    if frame_count % 30 == 0:
        elapsed = time.time() - fps_time
        fps = 30.0 / elapsed
        fps_time = time.time()
        print(f"FPS: {fps:.1f}  Çıkarım: {inference_ms:.1f}ms  Yüz: {len(objs)}")

    cv2.putText(frame, f"{inference_ms:.1f}ms  {len(objs)} yuz",
                (10,30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0,0,255), 2)
    cv2.imshow("Coral Face Detection", frame)
    if cv2.waitKey(1) == ord('q'): break

cap.release()
cv2.destroyAllWindows()