Deploy Edge Ai Model

---
name: deploy-edge-ai-model
description: >
  Deploy machine learning models to edge devices using Google AI Edge Gallery,
  TensorFlow Lite, ONNX Runtime, and MediaPipe. Covers model quantization
  (INT8/INT4), on-device inference with Gemma 4 models, Android/iOS deployment
  via AI Edge Gallery, hardware delegate selection (GPU/NPU/DSP), and
  performance benchmarking on constrained devices. Use when deploying models
  to mobile phones, IoT devices, or embedded systems where cloud inference
  is impractical due to latency, cost, or connectivity constraints.
license: MIT
allowed-tools: Read Write Edit Bash Grep Glob WebFetch
metadata:
  author: Philipp Thoss
  version: "1.0"
  domain: edge-computing
  complexity: advanced
  language: multi
  tags: edge-ai, google-ai-edge, gemma, tflite, onnx, quantization, on-device
  locale: de
  source_locale: en
  source_commit: 11edabf5
  fence_basis_commit: 11edabf5
  translator: "Claude + human review"
  translation_date: "2026-05-03"
---

# Edge-KI-Modell deployen

> Siehe [Erweiterte Beispiele](references/EXAMPLES.md) fuer komplette Konfigurationsdateien, Quantisierungsskripte und Benchmark-Templates.

ML-Modelle zu Edge-Geraeten mit optimierter Inferenz, Hardware-Beschleunigung und On-Device-Modell-Management deployen.

## Wann verwenden

- LLMs (Gemma 4, Phi, Llama) zu Mobilgeraeten via Google AI Edge Gallery deployen
- Modelle zu TensorFlow Lite oder ONNX fuer On-Device-Inferenz konvertieren
- Modelle zu INT8/INT4 fuer reduzierten Speicher und schnellere Inferenz quantisieren
- Android/iOS-Apps mit lokalen KI-Faehigkeiten bauen
- Hardware-Delegates auswaehlen (GPU, NPU, DSP, Hexagon, CoreML)
- Inferenz-Latenz und -Speicher auf Ziel-Geraeten benchmarken
- MediaPipe-Tasks (Vision, Text, Audio) zu mobilen oder eingebetteten Plattformen deployen

## Eingaben

- **Erforderlich**: Trainiertes Modell (SavedModel, PyTorch, ONNX oder Hugging-Face-Checkpoint)
- **Erforderlich**: Ziel-Plattform (Android, iOS, Linux-eingebettet, Browser)
- **Erforderlich**: Ziel-Geraet-Beschraenkungen (RAM, Speicher, Compute-Faehigkeit)
- **Optional**: Kalibrierungsdatensatz fuer Post-Training-Quantisierung
- **Optional**: Google-AI-Edge-Gallery-Konfiguration fuer LLM-Deployment
- **Optional**: Hardware-Delegate-Praeferenzen (GPU, NPU, nur CPU)

## Vorgehensweise

### Schritt 1: Modell fuer Edge-Deployment evaluieren

Modellgroesse, Latenzanforderungen und Ziel-Geraet-Faehigkeiten einschaetzen.

```python
# assess_model.py
import os
import tensorflow as tf

def assess_model_for_edge(saved_model_path, target_ram_mb=4096):
    """Evaluate whether a model is suitable for edge deployment."""
    model = tf.saved_model.load(saved_model_path)

    # Check model size on disk
    model_size_mb = sum(
        os.path.getsize(os.path.join(dp, f))
        for dp, _, filenames in os.walk(saved_model_path)
        for f in filenames
    ) / (1024 * 1024)

    print(f"Model size: {model_size_mb:.1f} MB")
    print(f"Target RAM: {target_ram_mb} MB")
    print(f"Size/RAM ratio: {model_size_mb / target_ram_mb:.2%}")

    if model_size_mb > target_ram_mb * 0.25:
        print("WARNING: Model exceeds 25% of device RAM - quantization recommended")
        return False
    return True
```

Edge-Deployment-Entscheidungsmatrix:

| Modellgroesse | Geraet-RAM | Empfohlene Aktion |
|---|---|---|
| < 50 MB | 2+ GB | Direkte TFLite-Konvertierung |
| 50-500 MB | 4+ GB | INT8-Quantisierung + TFLite |
| 500 MB-2 GB | 6+ GB | INT4-Quantisierung + AI Edge Gallery |
| 2-4 GB | 8+ GB | Gemma 4 via AI Edge Gallery mit INT4 |
| > 4 GB | 12+ GB | Weight-Streaming oder Cloud-Edge-Hybrid |

**Erwartet:** Modellbewertung abgeschlossen, Groessen- und RAM-Verhaeltnisse berechnet, Quantisierungs-Empfehlung basierend auf Geraet-Beschraenkungen erzeugt.

**Bei Fehler:** SavedModel-Pfad als gueltig verifizieren (`ls saved_model/`), TensorFlow-Installation pruefen (`python -c "import tensorflow"`), ausreichend Festplattenspeicher fuer Modell-Laden sicherstellen, verifizieren dass Modell-Format unterstuetzt wird.

### Schritt 2: LLMs via Google AI Edge Gallery deployen

Google AI Edge Gallery nutzen um Gemma 4 und andere LLMs zu Android-Geraeten zu deployen.

```bash
# Clone AI Edge Gallery
git clone https://github.com/nickoala/ai-edge-gallery.git
cd ai-edge-gallery

# Build the Android app
./gradlew assembleDebug

# Install on connected device
adb install -r app/build/outputs/apk/debug/app-debug.apk
```

Gemma-4-Modell fuer AI Edge Gallery konfigurieren:

```json
{
  "models": [
    {
      "name": "Gemma 4 2B IT",
      "url": "https://huggingface.co/google/gemma-4-2b-it-gpu-int4",
      "format": "tflite",
      "backend": "gpu",
      "config": {
        "max_tokens": 1024,
        "temperature": 0.7,
        "top_k": 40,
        "top_p": 0.95
      }
    },
    {
      "name": "Gemma 4 4B IT",
      "url": "https://huggingface.co/google/gemma-4-4b-it-gpu-int4",
      "format": "tflite",
      "backend": "gpu",
      "config": {
        "max_tokens": 2048,
        "temperature": 0.7
      }
    }
  ]
}
```

Programmatische On-Device-Inferenz mit LLM-Inferenz-API:

```python
# gemma_edge_inference.py
from mediapipe.tasks.genai import llm_inference

# Configure the LLM
options = llm_inference.LlmInferenceOptions(
    model_path="/data/local/tmp/gemma-4-2b-it-int4.tflite",
    max_tokens=512,
    temperature=0.7,
    top_k=40,
    supported_lora_ranks=[4, 8, 16]  # Optional LoRA support
)

# Create inference engine
engine = llm_inference.LlmInference(options=options)

# Run inference
response = engine.generate_response("Explain edge computing in one sentence.")
print(response)

# Streaming inference
for chunk in engine.generate_response_async("List three benefits of on-device AI."):
    print(chunk, end="", flush=True)
```

**Erwartet:** AI-Edge-Gallery-App baut und installiert erfolgreich, Gemma-4-Modell laedt aufs Geraet, On-Device-Inferenz produziert kohaerente Antworten, GPU-Delegate aktiviert sich fuer Beschleunigung.

**Bei Fehler:** Android-SDK-Version >= 26 pruefen (`adb shell getprop ro.build.version.sdk`), verifizieren dass Geraet ausreichend Speicher fuer Modell-Download hat, sicherstellen dass GPU-Delegate unterstuetzt wird (`adb logcat | grep -i delegate`), Hugging-Face-Modell-Zugriffsberechtigungen pruefen, ADB-Verbindung verifizieren (`adb devices`).

### Schritt 3: Modelle mit TFLite konvertieren und quantisieren

Standardmodelle in TFLite-Format mit Post-Training-Quantisierung konvertieren.

```python
# convert_tflite.py
import os
import tensorflow as tf
import numpy as np

def convert_to_tflite(saved_model_path, output_path, quantization="dynamic"):
    """Convert SavedModel to TFLite with quantization."""
    converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_path)

    if quantization == "dynamic":
        converter.optimizations = [tf.lite.Optimize.DEFAULT]

    elif quantization == "int8":
        converter.optimizations = [tf.lite.Optimize.DEFAULT]
        converter.target_spec.supported_ops = [
            tf.lite.OpsSet.TFLITE_BUILTINS_INT8
        ]
        converter.inference_input_type = tf.int8
        converter.inference_output_type = tf.int8

        # Representative dataset for calibration
        def representative_dataset():
            for _ in range(100):
                yield [np.random.randn(1, 224, 224, 3).astype(np.float32)]
        converter.representative_dataset = representative_dataset

    elif quantization == "float16":
        converter.optimizations = [tf.lite.Optimize.DEFAULT]
        converter.target_spec.supported_types = [tf.float16]

    tflite_model = converter.convert()

    with open(output_path, "wb") as f:
        f.write(tflite_model)

    original_size = sum(
        os.path.getsize(os.path.join(dp, f))
        for dp, _, filenames in os.walk(saved_model_path)
        for f in filenames
    ) / (1024 * 1024)
    quantized_size = len(tflite_model) / (1024 * 1024)
    print(f"Original: {original_size:.1f} MB -> Quantized: {quantized_size:.1f} MB")
    print(f"Compression ratio: {original_size / quantized_size:.1f}x")

# Usage
convert_to_tflite("saved_model/", "model_int8.tflite", quantization="int8")
```

ONNX-Runtime-Quantisierungs-Alternative:

```python
# quantize_onnx.py
from onnxruntime.quantization import quantize_dynamic, quantize_static, QuantType

# Dynamic quantization (no calibration data needed)
quantize_dynamic(
    model_input="model.onnx",
    model_output="model_int8.onnx",
    weight_type=QuantType.QInt8
)

# Static quantization (better accuracy, needs calibration)
# ... (see EXAMPLES.md for complete calibration workflow)
```

**Erwartet:** TFLite-Modell am angegebenen Pfad erzeugt, Modellgroesse um 2-4x reduziert mit INT8, Inferenzgenauigkeit innerhalb 1-2% des Originals, ONNX-Quantisierung produziert gueltiges Modell.

**Bei Fehler:** TensorFlow-Version >= 2.15 fuer neueste Quantisierungs-Unterstuetzung pruefen, verifizieren dass repraesentativer Datensatz mit Modell-Eingabe-Form uebereinstimmt, sicherstellen dass alle Ops in TFLite unterstuetzt sind (`converter.allow_custom_ops = True` als Fallback), ONNX-Opset-Version-Kompatibilitaet pruefen.

### Schritt 4: Hardware-Delegates konfigurieren

Hardware-Beschleunigungs-Delegates fuer Ziel-Geraete auswaehlen und konfigurieren.

```python
# configure_delegates.py
import tensorflow as tf

def create_interpreter_with_delegate(model_path, delegate="gpu"):
    """Create TFLite interpreter with hardware delegate."""

    if delegate == "gpu":
        delegate_obj = tf.lite.experimental.load_delegate(
            "libtensorflowlite_gpu_delegate.so",
            options={"precision": "fp16", "allow_quantized_models": "true"}
        )
    elif delegate == "nnapi":
        # Android Neural Networks API - routes to NPU/DSP
        delegate_obj = tf.lite.experimental.load_delegate(
            "libtensorflowlite_nnapi_delegate.so"
        )
    elif delegate == "xnnpack":
        # Optimized CPU inference
        delegate_obj = None  # XNNPACK is default in TFLite

    interpreter = tf.lite.Interpreter(
        model_path=model_path,
        experimental_delegates=[delegate_obj] if delegate_obj else None,
        num_threads=4
    )
    interpreter.allocate_tensors()
    return interpreter
```

Delegate-Auswahl-Guide:

| Geraet | Bester Delegate | Fallback | Hinweise |
|---|---|---|---|
| Android (Qualcomm) | NNAPI -> Hexagon DSP | GPU -> XNNPACK | `nnapi_accelerator_name` pruefen |
| Android (MediaTek) | NNAPI -> APU | GPU -> XNNPACK | Dimensity-Chips haben dedizierte APU |
| Android (Samsung) | NNAPI -> NPU | GPU -> XNNPACK | Exynos NPU via NNAPI |
| iOS | CoreML-Delegate | Metal GPU | `coreml_delegate` fuer ANE nutzen |
| Linux-eingebettet | GPU (falls verfuegbar) | XNNPACK | RPi nutzt XNNPACK CPU |
| Browser | WebGL / WebGPU | WASM SIMD | Via TensorFlow.js |

**Erwartet:** Delegate laedt ohne Fehler, Inferenz laeuft auf Ziel-Beschleuniger, Latenz verbessert sich 2-10x ueber CPU-only abhaengig von Modell und Geraet.

**Bei Fehler:** Verifizieren dass Delegate-Bibliothek auf Geraet existiert, pruefen dass Geraet angeforderten Delegate unterstuetzt (`adb shell cat /proc/cpuinfo` fuer CPU-Features), auf XNNPACK fallen wenn GPU/NPU nicht verfuegbar, OpenCL-Unterstuetzung fuer GPU-Delegate pruefen, NNAPI-Version verifizieren (`adb shell getprop ro.android.ndk.version`).

### Schritt 5: On-Device-Performance benchmarken

Inferenz-Latenz, Speicherverbrauch und Stromverbrauch auf Ziel-Geraeten messen.

```bash
# Use TFLite benchmark tool
adb push model_int8.tflite /data/local/tmp/

# CPU benchmark
adb shell /data/local/tmp/benchmark_model \
  --graph=/data/local/tmp/model_int8.tflite \
  --num_threads=4 \
  --num_runs=50 \
  --warmup_runs=5

# GPU benchmark
adb shell /data/local/tmp/benchmark_model \
  --graph=/data/local/tmp/model_int8.tflite \
  --use_gpu=true \
  --num_runs=50

# NNAPI benchmark
adb shell /data/local/tmp/benchmark_model \
  --graph=/data/local/tmp/model_int8.tflite \
  --use_nnapi=true \
  --nnapi_accelerator_name=google-edgetpu \
  --num_runs=50
```

Python-Benchmarking:

```python
# benchmark_edge.py
import time
import numpy as np
import psutil

def benchmark_inference(interpreter, input_data, num_runs=100):
    """Benchmark TFLite model inference."""
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()

    # Warmup
    for _ in range(10):
        interpreter.set_tensor(input_details[0]["index"], input_data)
        interpreter.invoke()

    # Benchmark
    latencies = []
    mem_before = psutil.Process().memory_info().rss / (1024 * 1024)
    for _ in range(num_runs):
        start = time.perf_counter()
        interpreter.set_tensor(input_details[0]["index"], input_data)
        interpreter.invoke()
        latencies.append((time.perf_counter() - start) * 1000)
    mem_after = psutil.Process().memory_info().rss / (1024 * 1024)

    print(f"Latency (p50): {np.percentile(latencies, 50):.1f} ms")
    print(f"Latency (p95): {np.percentile(latencies, 95):.1f} ms")
    print(f"Latency (p99): {np.percentile(latencies, 99):.1f} ms")
    print(f"Memory delta: {mem_after - mem_before:.1f} MB")
    print(f"Throughput: {1000 / np.mean(latencies):.1f} inferences/sec")
```

**Erwartet:** Benchmark produziert Latenz-Perzentile, Speicherverbrauch und Durchsatz-Metriken; GPU-Delegate zeigt 2-5x Speedup ueber CPU fuer Vision-Modelle; Gemma 4 2B erreicht 10-30 Tokens/Sek auf Flagship-Telefonen.

**Bei Fehler:** Sicherstellen dass Benchmark-Binary mit Geraet-Architektur uebereinstimmt (arm64-v8a), verifizieren dass Modell aufs Geraet geschoben (`adb shell ls /data/local/tmp/`), ausreichenden Geraetespeicher pruefen, Hintergrund-Apps killen um Speicherdruck zu reduzieren, verifizieren dass Thermal-Throttling nicht aktiv (`adb shell cat /sys/class/thermal/thermal_zone*/temp`).

### Schritt 6: Fuer Production-Deployment paketieren

Die finale Mobile-Anwendung mit eingebettetem oder herunterladbarem Modell bauen.

```kotlin
// Android: EdgeAIManager.kt
import com.google.mediapipe.tasks.genai.llminference.LlmInference

class EdgeAIManager(private val context: Context) {
    private var llmInference: LlmInference? = null

    fun initialize(modelPath: String) {
        val options = LlmInference.LlmInferenceOptions.builder()
            .setModelPath(modelPath)
            .setMaxTokens(512)
            .setTemperature(0.7f)
            .setTopK(40)
            .setResultListener { result, done ->
                // Handle streaming tokens
                onTokenReceived(result, done)
            }
            .build()

        llmInference = LlmInference.createFromOptions(context, options)
    }

    fun generateResponse(prompt: String): String {
        return llmInference?.generateResponse(prompt)
            ?: throw IllegalStateException("Model not initialized")
    }

    fun release() {
        llmInference?.close()
        llmInference = null
    }
}
```

Modell-Download- und Caching-Strategie:

```kotlin
// ModelDownloader.kt
class ModelDownloader(private val context: Context) {
    private val modelDir = File(context.filesDir, "models")

    suspend fun ensureModel(modelName: String, url: String): File {
        val modelFile = File(modelDir, modelName)
        if (modelFile.exists()) return modelFile

        modelDir.mkdirs()
        // Download with progress tracking
        // ... (see EXAMPLES.md for complete implementation)
        return modelFile
    }
}
```

**Erwartet:** Android-App baut mit MediaPipe-Abhaengigkeit, Modell laedt beim ersten Start, Inferenz laeuft innerhalb Latenzbudget, Modell nach erstem Download gecacht, anmutiger Fallback wenn Geraet nicht unterstuetzt wird.

**Bei Fehler:** minSdk >= 26 in `build.gradle` pruefen, MediaPipe-Abhaengigkeitsversion verifizieren, sicherstellen dass Modelldatei nicht korrupt (SHA256 pruefen), ausreichenden Geraetespeicher fuer Modell verifizieren, ProGuard-Regeln pruefen die MediaPipe-Klassen erhalten, auf mehreren Geraet-Stufen testen.

## Validierung

- [ ] Modell konvertiert zu TFLite/ONNX ohne Op-Kompatibilitaetsfehler
- [ ] Quantisierte Modellgenauigkeit innerhalb akzeptabler Toleranz (< 2% Verschlechterung)
- [ ] Hardware-Delegate laedt und beschleunigt Inferenz
- [ ] Benchmark-Latenz erfuellt Ziel (z.B. < 100 ms fuer Vision, < 50 ms/Token fuer LLM)
- [ ] Speicherverbrauch bleibt innerhalb Geraetbudget
- [ ] AI Edge Gallery laedt und betreibt Gemma-4-Modell erfolgreich
- [ ] On-Device-LLM erzeugt kohaerente Antworten
- [ ] Anwendung handhabt Modell-Download, -Caching und -Updates
- [ ] Anmutige Degradierung auf nicht unterstuetzten Geraeten
- [ ] Batterieauswirkung innerhalb akzeptablem Bereich fuer Ziel-Anwendungsfall

## Haeufige Stolperfallen

- **Nicht unterstuetzte Ops in TFLite**: Custom Ops scheitern an Konvertierung - `converter.allow_custom_ops = True` nutzen oder durch unterstuetzte Alternativen ersetzen, Op-Kompatibilitaetsliste pruefen
- **Quantisierungs-Genauigkeitsverlust**: INT4 verschlechtert Qualitaet fuer sensible Tasks - Mixed-Precision nutzen, mit repraesentativen Daten kalibrieren, auf Edge-spezifischem Test-Set evaluieren
- **Delegate-Initialisierungsfehler**: GPU-Delegate stuerzt auf aelteren Geraeten ab - immer CPU-Fallback implementieren, Delegate-Kompatibilitaet vor dem Laden pruefen
- **Speicherdruck auf Geraet**: Modell + App ueberschreitet verfuegbares RAM - speicher-mapped Modelle nutzen, Modell-Unloading implementieren, Batch-Groesse auf 1 reduzieren
- **Thermal-Throttling**: Anhaltende Inferenz verursacht Geraet-Ueberhitzung - Duty-Cycling implementieren, Inferenz-Frequenz reduzieren, Thermal-Zonen ueberwachen
- **Modell-Download-Groesse**: Grosse Modelle ueber Mobilfunkdaten - Wi-Fi-only-Download anbieten, fortsetzbare Downloads implementieren, progressives Modell-Laden nutzen
- **Versions-Fragmentierung**: Modell funktioniert auf manchen Geraeten aber nicht anderen - auf repraesentativer Geraet-Matrix testen, NNAPI-Versions-Pruefungen nutzen, Geraet-Kompatibilitaets-Datenbank pflegen

## Verwandte Skills

- `deploy-ml-model-serving` - Cloud-basiertes Modell-Serving (Komplement zu Edge)
- `monitor-model-drift` - Modell-Qualitaet ueber Zeit ueberwachen
- `register-ml-model` - Modelle vor Edge-Deployment registrieren
- `create-dockerfile` - Edge-Modell-Konvertierungs-Pipeline containerisieren
- `create-multistage-dockerfile` - Multi-Stage-Builds fuer Modell-Konvertierungs-Pipelines