Edge AI: Modelleri Cihazda Çalıştırmanın Gücü

Modelleri Neden Cihazda Çalıştırıyoruz?

Yıllardır AI inference için varsayılan yöntem şuydu: veriyi buluta gönder, güçlü bir sunucu modeli çalıştırsın, sonucu geri al. İşe yarıyor ve neredeyse sınırsız hesaplama gücü sunuyor. Ama bir bedeli var — gecikme, ağ bağlantısına sürekli bağımlılık ve ciddi veri gizliliği sorunları. Edge AI bu denklemi tersine çeviriyor: modelleri verinin üretildiği yerde çalıştırıyor. Yani akıllı telefonlarda, gömülü kartlarda, IoT sensörlerinde ya da şirket içi sunucularda.

Bazı senaryolar bulut gidiş-dönüşünü kaldıramaz. Otonom araçlar milisaniyenin altında tepki vermek zorunda. Endüstriyel kalite kontrol kameraları internetsiz fabrikalarda çalışıyor. Medikal giyilebilir cihazlar şebekenin olmadığı yerlerde de işlevsel olmalı. Bu durumlarda on-device inference bir lüks değil, zorunluluk.

Bir de işin maliyet tarafı var. Edge'de inference çalıştırmak bulut faturanızı düşürüyor ve hassas verileri — biyometrik okumalar, hasta kayıtları, özel sensör verileri — cihazın üzerinde tutuyor. KVKK, HIPAA gibi regülasyonlarla uyum sağlamak da böylece çok daha kolay oluyor.

En iyi inference çağrısı, cihazdan hiç çıkmayan çağrıdır. Edge'de kazandığınız her milisaniye daha iyi bir kullanıcı deneyimi ve daha düşük bulut faturası olarak geri döner.

Model Sıkıştırma: Pruning, Distillation ve Quantization

Şöyle bir gerçek var: üretim seviyesindeki sinir ağları genellikle yüz milyonlarca parametre içeriyor. Bu, kısıtlı donanımlar için fazla büyük ve fazla yavaş. Model sıkıştırma, modelin bellek ayak izini ve hesaplama maliyetini doğruluğu mümkün olduğunca koruyarak azaltan tekniklerin genel adı.

Pruning (Budama)

Pruning, modelin çıktısına pek katkısı olmayan ağırlıkları ya da nöronları çıkarır. Unstructured pruning tek tek ağırlıkları sıfırlayarak sparse matrisler oluşturur — ama bu matrisleri verimli kullanmak için özel kernel'ler gerekir. Structured pruning farklı bir yol izler: komple kanalları veya attention head'leri kaldırarak, standart donanımda daha hızlı çalışan gerçekten daha küçük bir dense model ortaya çıkarır.

Knowledge Distillation (Bilgi Damıtma)

Knowledge distillation'da küçük bir "öğrenci" modeli, büyük bir "öğretmen" modelinin çıktı dağılımını taklit edecek şekilde eğitilir. Öğrenci sadece kesin etiketleri değil, tüm sınıflar arasındaki soft probability'leri de öğrenir. Böylece ham eğitim verisinin doğrudan öğretmediği sınıflar arası ilişkileri de yakalar. Pratikte distillation modeli 4-10 kat küçültebilir ve doğruluk kaybı oldukça düşük kalır. Ortaya çıkan öğrenci standart bir dense ağ olduğu için tüm klasik inference optimizasyonlarından faydalanır.

Quantization

Quantization, ağırlıkların ve aktivasyonların sayısal hassasiyetini düşürür — genellikle 32-bit float'tan (FP32) 16-bit'e (FP16), 8-bit integer'a (INT8) veya 4-bit'e (INT4) kadar. Post-training quantization (PTQ) zaten eğitilmiş bir modeli küçük bir kalibrasyon verisiyle dönüştürür. Quantization-aware training (QAT) ise daha ileri gider: eğitim sırasında düşük hassasiyetli matematiği simüle eder, böylece model azalan hassasiyetle başa çıkmayı öğrenir.

• FP32'den FP16'ya: yaklaşık 2 kat bellek tasarrufu, çoğu mimaride göz ardı edilebilir doğruluk kaybı.
• FP32'den INT8'e (PTQ): yaklaşık 4 kat bellek tasarrufu, düzgün kalibrasyon yaparsanız genelde %1'den az doğruluk düşüşü.
• FP32'den INT4'e (QAT): 8 kata kadar bellek tasarrufu, ama doğruluk kaybı değişken — en iyi sonuçlar quantization-aware fine-tuning ile gelir.
• Mixed precision: kritik katmanları yüksek hassasiyette tutup daha az hassas katmanları agresif şekilde quantize edin.

ONNX Runtime ve TensorRT

Modeli sıkıştırdıktan sonra sıradaki soru şu: hedef donanımda nasıl verimli çalıştıracağız? En popüler iki inference motoru ONNX Runtime ve NVIDIA TensorRT. İkisi de ONNX (Open Neural Network Exchange) formatıyla çalışıyor — PyTorch, TensorFlow ve diğer büyük framework'lerin desteklediği, üreticiden bağımsız bir ara format.

Microsoft'un geliştirdiği ONNX Runtime, CPU, CUDA GPU, DirectML, OpenVINO ve daha birçok execution provider'ı destekleyen cross-platform bir motor. Bulut VM'lerden ARM tabanlı edge kartlarına kadar geniş bir yelpazede kullanabilirsiniz. NVIDIA'nın TensorRT'si ise NVIDIA GPU'larına özel. Agresif kernel fusion, katman auto-tuning ve precision calibration uygulayarak donanımdan son damlasına kadar performans çıkarır.

import torch
import onnx
import onnxruntime as ort
from torchvision.models import mobilenet_v3_small

# 1. PyTorch modelini ONNX'e dışa aktarma
model = mobilenet_v3_small(pretrained=True).eval()
dummy_input = torch.randn(1, 3, 224, 224)

torch.onnx.export(
    model,
    dummy_input,
    "mobilenet_v3_small.onnx",
    input_names=["input"],
    output_names=["output"],
    dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}},
    opset_version=17,
)

# 2. Dışa aktarılan ONNX modelini doğrulama
onnx_model = onnx.load("mobilenet_v3_small.onnx")
onnx.checker.check_model(onnx_model)

# 3. ONNX Runtime ile çıkarım çalıştırma
session = ort.InferenceSession(
    "mobilenet_v3_small.onnx",
    providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
)
result = session.run(None, {"input": dummy_input.numpy()})
print("Tahmin edilen sınıf:", result[0].argmax(axis=1))

TensorRT işi bir adım öteye taşır: belirli bir GPU mimarisine özel serileştirilmiş bir engine oluşturur. Bu engine dosyası farklı GPU aileleri arasında taşınamaz, ama performans kazancı — genelde vanilla CUDA'ya göre 2-5 kat — gecikmenin kritik olduğu deployment'larda bu ekstra adımı fazlasıyla haklı çıkarır.

import tensorrt as trt
import numpy as np

TRT_LOGGER = trt.Logger(trt.Logger.WARNING)

def build_engine(onnx_path: str, precision: str = "fp16"):
    builder = trt.Builder(TRT_LOGGER)
    network = builder.create_network(
        1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
    )
    parser = trt.OnnxParser(network, TRT_LOGGER)

    with open(onnx_path, "rb") as f:
        if not parser.parse(f.read()):
            for i in range(parser.num_errors):
                print(parser.get_error(i))
            raise RuntimeError("ONNX ayrıştırma başarısız oldu")

    config = builder.create_builder_config()
    config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 1 << 30)

    if precision == "fp16":
        config.set_flag(trt.BuilderFlag.FP16)
    elif precision == "int8":
        config.set_flag(trt.BuilderFlag.INT8)
        # INT8 kalibrasyon veri seti gerektirir (kısalık için atlanmıştır)

    serialized_engine = builder.build_serialized_network(network, config)
    with open("model.engine", "wb") as f:
        f.write(serialized_engine)
    print(f"TensorRT motoru {precision} hassasiyetiyle oluşturuldu.")

build_engine("mobilenet_v3_small.onnx", precision="fp16")

Mobil Deployment: Core ML ve TensorFlow Lite

Akıllı telefonlar dünyadaki en yaygın edge cihazlar. On-device inference tarafında iki framework öne çıkıyor: iOS için Apple'ın Core ML'i, Android için Google'ın TensorFlow Lite'ı (TFLite).

Core ML, Apple'ın Neural Engine, GPU ve CPU'suyla sıkı bir şekilde entegre çalışır ve runtime'da en uygun hesaplama birimini otomatik seçer. Modelleri PyTorch veya TensorFlow'dan Apple'ın coremltools paketiyle dönüştürebilirsiniz. INT8'e kadar quantization ve palettization (ağırlık kümeleme) desteği var. Apple'ın son çipleri gerçekten etkileyici — A17 Pro Neural Engine 35 TOPS gücünde.

TensorFlow Lite ise Android, embedded Linux ve mikrodenetleyicileri hedefliyor. Converter'ı FP16 ve INT8 quantization, operator fusion ve buffer sharing gibi optimizasyonları otomatik uyguluyor. Benim özellikle beğendiğim tarafı delegate sistemi: mobil GPU'lar için GPU delegate, Android'in Neural Networks API'si için NNAPI delegate, Qualcomm DSP'leri için Hexagon delegate var. Çok küçük cihazlar için de TensorFlow Lite for Microcontrollers sadece 16 KB RAM ile model çalıştırabiliyor.

Donanım Seçimi: NPU, GPU ve CPU

Hangi donanımda inference çalıştırdığınız throughput, gecikme ve güç tüketimini doğrudan etkiler. Modern edge cihazlar üç hesaplama hedefi sunuyor ve her birinin kendine özgü artı-eksileri var.

1. NPU (Neural Processing Unit): Matris işlemleri için özel tasarlanmış silikon. Watt başına en yüksek TOPS değerini verir ama desteklediği operatör seti daha dar. Desteklenmeyen katmanlar CPU'ya düşer ve pipeline stall'larına yol açar. Örnekler: Apple Neural Engine, Google Edge TPU, Qualcomm Hexagon.
2. GPU: Mobil ve gömülü GPU'lar (Adreno, Mali, Apple GPU) güçlü paralel throughput ve NPU'lardan daha geniş operatör desteği sunar. Convolution veya attention ağırlıklı modeller için çok uygun. Güç tüketimi NPU ile CPU arasında kalır.
3. CPU: Evrensel fallback — her operatör CPU'da çalışır, bu da onu en uyumlu hedef yapar. NEON (ARM) veya AVX-512 (x86) SIMD uzantılı modern CPU'lar küçük modeller için gayet iyi throughput sağlar. Model küçükse ve cihazda güçlü bir NPU ya da GPU yoksa CPU inference tercih edilir.

Pratikte birçok edge inference motoru heterojen bir çalıştırma stratejisi kullanır — model grafiğini birden fazla hesaplama birimine böler. Gecikmenin kritik olduğu yollar NPU'da çalışırken, desteklenmeyen operasyonlar GPU veya CPU'ya düşer. NVIDIA Nsight, Xcode Instruments ve Android GPU Inspector gibi profiling araçları bu karma senaryolardaki darboğazları bulmak için şart.

Gerçek Dünya Örnekleri ve Dikkat Edilmesi Gerekenler

Edge AI birçok sektörde zaten geniş ölçekte kullanılıyor. Akıllı telefon kameraları super-resolution ve computational photography modellerini gerçek zamanlı çalıştırıyor. Sesli asistanlar keyword spotting ve konuşma tanımayı tamamen cihaz üzerinde yapıyor. Otomotiv sistemleri kamera, LiDAR ve radar verisini araç içi sinir ağlarıyla birleştirerek object detection ve yol planlaması gerçekleştiriyor.

Endüstriyel tarafta predictive maintenance öne çıkıyor — titreşim sensörü verileri edge modelleriyle analiz edilerek yatak arızaları daha oluşmadan tespit ediliyor. Tarım drone'ları bağlantı olmadan mahsul sağlığı sınıflandırıcılarını yerleşik olarak çalıştırarak ilaçlama kararları veriyor. Perakende mağazaları raf envanter takibi ve otonom ödeme için edge vision modelleri kullanıyor.

Ama edge deployment beraberinde dikkatle düşünmeniz gereken trade-off'lar da getiriyor. Agresif sıkıştırmadan sonra doğruluk genelde düşer — minimum doğruluk eşikleri belirleyip quantize edilmiş modelleri golden-reference çıktılarıyla test etmeniz gerekir. Model güncellemelerini yaymak daha zor; sağlam bir OTA altyapısı kurmanız şart. Debugging de zorlaşır çünkü edge cihazlar bulut ortamlarına kıyasla çok daha az observability sunar. Bir de donanım ekosistemi parçalı: bir çip için optimize ettiğiniz model başka bir çipte kötü performans gösterebilir, bu yüzden hedefe özel benchmarking kaçınılmaz.

Önemli Çıkarımlar

1. Edge AI bulut inference gecikmesini ortadan kaldırır, maliyetleri düşürür ve hassas verileri cihazda tutar — ama dikkatli model optimizasyonu şart.
2. Pruning, distillation ve quantization ile modelleri 4-8 kat küçültebilirsiniz; doğru uygulandığında doğruluk kaybı minimal kalır.
3. ONNX taşınabilir bir ara format sağlar; ONNX Runtime cross-platform, TensorRT ise NVIDIA'ya özel deployment için en güçlü motorlar.
4. Core ML ve TensorFlow Lite mobil inference dünyasına hükmediyor. İkisi de donanım farkındalıklı hızlandırma ve yerleşik quantization desteği sunuyor.
5. NPU, GPU veya CPU seçimi operatör kapsamı, throughput ve güç tüketimi arasında bir denge kurmak demek. Hedef donanımda profiling yapmadan karar vermeyin.
6. Gerçek dünya edge deployment'ları OTA güncelleme altyapısı, sıkıştırma sonrası doğruluk kontrolü ve parçalı donanım ekosistemi için hazırlıklı olmalı.

NPU'lar güçlendikçe ve compiler toolchain'leri olgunlaştıkça bulut ile edge inference arasındaki fark kapanmaya devam ediyor. Şimdiden edge deployment konusunda yatırım yapan ekipler, kullanıcılarına daha hızlı, daha güvenli ve daha dayanıklı AI deneyimleri sunmak için çok avantajlı bir konumda olacak.