AI Layer

A Fundamente

Was du schon angefangen hast — und was fehlt, um „Inference" zu verstehen.

Beispiel 1: Hauspreis aus Quadratmetern

Du hast 6 Datensätze (qm, preis) und willst eine Formel preis = w·qm + b.

Auge: pro +1 qm steigt der Preis ~3 Tsd€ → w≈3, b≈0. Das ist lineare Regression. „Lernen" = die beiden Zahlen w,b finden.

Grafik: Punkte + gefundene Linie

Vom einen Parameter zum „Netz"

Lineare Regression: 1 Formel. Ein neuronalales Netz = viele solcher Rechnungen hintereinander geschaltet.

// Eine „Neuron"-Berechnung (vereinfacht)
z = w0*x0 + w1*x1 + ... + wn*xn + b   // gewichtete Summe
a = activation(z)                      // z.B. ReLU: max(0, z)
// hunderte/tausende davon, in Schichten — das ist das Modell

Grafik: ein kleines neuronales Netz

Jede Kante = eine Gewichtszahl w. Beim Inference fließen die Zahlen von links nach rechts.

Der „Gradient" — intuitiv

Training-Schritt, durchgespielt (Mini-Beispiel)

Annahme: preis = w·qm, Start w=1, ein Punkt (qm=100, preis=300)
1) Vorhersage: y^ = 1·100 = 100        (zu niedrig)
2) Fehler:     E = (300-100)² = 40000
3) Gradient:  dE/dw = 2·(100-300)·100 = -40000
4) Schritt:    w = w - lr·gradient = 1 - 0.00001·(-40000) = 1.4
5) nächster Durchlauf … w kriecht gegen 3

Das passiert millionenfach über alle Datenpunkte — deshalb braucht Training GPU/Zeit, Inference nicht.

Begriffe, die du ab jetzt siehst

B Modellarchitektur

Wie ist ein Modell von innen gebaut? Und vor allem: was ist ein „Transformer"?

Grafik: Layer-Pipeline

Jeder Kasten nimmt einen Tensor und gibt einen (oft anderen) Tensor zurück.

Layer-Typen im Überblick

Grafik: Convolution (Filter über Bild)

Der Kernel (3×3) wird über das Bild geschoben; an jeder Position entsteht 1 Ausgabewert. Das ist ein „Operator" (siehe Region E/H).

Operatoren vs. Layer

„Layer" ist die Modell-Sicht, „Operator" die Ausführungs-Sicht. Dein AI Layer muss beide kennen, um Modelle abstrahiert anzusprechen.

B·T Transformer — der tiefe Tauchgang

Du hast gesagt: davon habe ich gar nichts verstanden. Wir bauen es von null auf, mit Beispielen.

1) Das Problem: Was bedeutet „er"?

Betrachte: „Der Hund beißt den Mann, weil er hungrig ist." — Wer ist „er"? Der Hund. Ein Modell muss Bezüge zwischen weit auseinanderliegenden Wörtern herstellen.

Grafik: Self-Attention verbindet „er" mit „Hund"

Self-Attention baut für jedes Wort eine Gewichtung über alle anderen Wörter. „er" gewichtet „Hund" hoch, „Mann" niedrig.

2) Tokens & Embeddings: Wörter werden Vektoren

Bevor gerechnet wird, wird jedes Token in einen Vektor (Liste von Zahlen) übersetzt — das „Embedding".

"Hund"  →  [0.21, -0.84, 0.05, 0.93, ...]   (z.B. 512 Zahlen)
"Katze"  →  [0.19, -0.80, 0.07, 0.91, ...]   (ähnlich! → Modell „merkt" Verwandtschaft)
"Auto"   →  [-0.6,  0.30, -0.2, 0.10, ...]   (weit weg)

3) Q, K, V — einfach erklärt

Jedes Wort bekommt drei Vektoren. Die Bibliotheks-Analogie:

Attention = für jedes Wort: vergleiche meine Query mit allen Keys → Gewichte → gewichtete Summe der Values. Passt Query zu Key, ist das Gewicht hoch.

4) Die Rechnung (kompakt)

Attention(Q, K, V) = softmax( Q · Kᵀ / √d ) · V
                       └─── Scores ───┘     └─ neue Werte ─┘
   Q·Kᵀ : wie gut passt jedes Wort zu jedem anderen (N×N Matrix)
   /√d  : Skalierung, damit es nicht explodiert
   softmax: Gewichte summieren sich zu 1
   ·V   : gewichteter Mix der Inhalte → kontext-abhängiger Vektor

Das Ergebnis: jeder Wort-Vektor ist jetzt „angereichert" mit Kontext aus den relevanten anderen Wörtern.

Grafik: die Q·Kᵀ-Aufmerksamkeitsmatrix

5) Positional Encoding: Reihenfolge zählt

Self-Attention sieht keine Reihenfolge (alle Wörter sind „gleichzeitig" da). Deshalb wird die Position als kleiner Vektor addiert.

„Der Hund beißt den Mann" ≠ „Den Mann beißt der Hund" — die Positionssignale machen den Unterschied für das Modell sichtbar.

6) Multi-Head: mehrere Perspektiven

Statt einer Attention berechnet der Transformer mehrere parallel („Heads"). Jeder Kopf achtet auf etwas anderes:

Die Ergebnisse werden konkateniert — das ist, warum Transformer so reichhaltig „verstehen".

Grafik: ein Transformer-Block (Encoder)

Solche Blöcke werden gestapelt (z.B. 6–128 mal). „GPT" = nur Decoder-Stapel, „BERT" = nur Encoder-Stapel.

7) Warum Transformer teuer sind (für deine ECU)

Die Q·Kᵀ-Matrix ist N×N bei Sequenzlänge N. Der Rechenaufwand wächst quadratisch mit der Länge.

Modellformate & Serialisierung

⬇ nächste Region: worauf läuft das eigentlich — Hardware & Beschleuniger.

C Hardware & Beschleunigung

Wo wird gerechnet? Und was heißt SIMD, CUDA, NPU für deine ECU?

Grafik: SIMD — eine Instruktion, viele Daten

Deine ECU (ARM) hat NEON-SIMD. Quantisierung (int8) nutzt das besonders gut — 16 Int8-Werte pro 128-bit-Register.

Vergleich: Durchsatz & Effizienz

Maßstab = „Inferenz-Durchsatz pro Watt" (skizzenhaft). Auf der ECU zählt Effizienz, nicht Rohleistung.

Die ECU-Realität (deine Grenze)

                     Trainings-Welt        ECU / Embedded
RAM                 GB–TB                  KB–wenige MB
Rechenleistung      GPU-Cluster            MHz-Arm, evtl. NPU
Energie             Netzstecker            ~ Watt, thermal limit
Latenz/Sicherheit   best-effort            Echtzeit, Funktionssicherheit

D Inference-Engine

Die Laufzeit, die das Modell tatsächlich auf der Hardware ausführt. Kern deines Projekts.

Grafik: Engine-Pipeline

ExecuTorch & TFLM — deine beiden Ziele

Was eine Engine intern tut

Beispiel: ein Conv-Layer auf der ECU

Modell sagt: Conv2D(input 32x32x3, kernel 3x3x3x16, stride 1)
Engine wählt Backend: CPU-NEON
  → ruft int8-Conv-Kernel auf
  → Kernel nutzt SIMD: 16 Kanäle parallel
  → Ergebnis 30x30x16 in SRAM, nicht DRAM (schneller)
Dein AI Layer: ruft nur infer(conv_layer, input) — egal ob NEON oder NPU.

E Optimierung & Quantisierung

Die Werkzeuge, um ein zu großes Modell auf die ECU zu quetschen — ohne dass es versagt.

Grafik: fp32-Bereich auf int8-Buckets

Ein Wert wie 0.3 wird auf den nächsten int8-Bucket abgebildet. Man verliert Auflösung, gewinnt aber 4× Speicher und viel Speed.

Die Abbildung, konkret

q = round( r / scale ) + zero_point       // reelle Zahl → int8
r ≈ (q - zero_point) * scale              // int8 → reelle Zahl (zur Anzeige)
// Beispiel: range [-1,1], int8 = [-128,127]
//   scale = 2/255 ≈ 0.00784, zero_point = 0
//   r=0.3  →  q = round(0.3/0.00784) = 38
//   q=38   →  r ≈ 38*0.00784 = 0.298  (Fehler 0.002 — vernachlässigbar)

Weitere Hebel

Trade-off-Dreieck

Du kannst nicht alles gleichzeitig maximieren. Dein AI Layer definiert, welcher Punkt „qualifiziert" ist.

F Model-Serving

Wenn Inference zentral/lokal auf einem Server läuft statt auf der ECU.

Grafik: Request/Response

Begriffe rund um Serving

Entscheidung: ECU oder Server?

Dein AI Layer definiert die Grenze — manches on-device, manches ausgelagert.

G Agentic AI & Tooling

Prompts, MCP, Skills, Agenten — der Teil, der heute überall auftaucht.

Beispiel: ein konkreter Prompt

System:  Du bist ein Diagnose-Assistent für ein Steuergerät.
          Antworte kurz, nur mit JSON.
User:    Der Sensor liefert 0x7F, was bedeutet das?
Assistant:{ "code": "0x7F", "bedeutung": "Dienst nicht unterstützt",
            "aktion": "Prüfe UDS-Session-State" }

Der Prompt steuert das Verhalten — kein Code-Compile, sondern Sprache. Genau hier setzt MCP an.

Prompt, LLM, Agent — Schritt für Schritt

Skills = vorgefertigte Fähigkeits-Pakete für einen Agenten (z.B. „Suche im Repo").

MCP — das „USB-C für KI-Tools"

MCP = Model Context Protocol. Ein offener Standard, wie ein LLM/Agent mit externen Systemen spricht.

Agent-Loop, durchgespielt

1) User: „Warum ist die Zykluszeit hoch?"
2) Agent denkt → braucht Daten → ruft Tool „Lese-Metrik(zykluszeit)"
3) MCP-Server liefert Wert (z.B. 18 ms statt 8 ms)
4) Agent: „Sensor X ist Flaschenhals" → ruft Tool „Öffne-Ticket"
5) Antwort an User + Ticket erstellt
→ der Agent hat selbstständig geplant und gehandelt

H Synthese: dein AI Layer

Alle Regionen treffen sich hier. Der AI Layer ist die Abstraktion über die Inference-Engines.

        ┌───────────────── AI Layer (dein Framework) ─────────────────┐
Anwendung│  gemeinsame Schnittstelle · Governance · Tooling · Integration│
        └───────┬───────────────────┬───────────────────┬────────────┘
           Backend:             Backend:             Backend:
        ExecuTorch            TFLM (MCU)           ONNX Runtime / Server
           │                    │                    │
        ── ECU (NPU/CPU) ──  ── MCU (KB RAM) ──   ── zentral / GPU ──

Wo deine Regionen hineinfließen

Nächste Schritte für dich