AI-Klassifikation: CRNN & Deep Learning
Convolutional Recurrent Neural Networks für die automatische Klassifikation von Radar-Mikro-Doppler-Spektrogrammen – von CNN-Grundlagen über LSTM bis zur vollständigen Trainingspipeline.
Convolutional Neural Networks
Convolutional Neural Networks (CNNs) sind die Grundlage moderner Bildverarbeitung und eignen sich hervorragend für die Extraktion räumlicher Merkmale aus 2D-Eingaben wie Spektrogrammen. Sie nutzen lokal begrenzte, lernbare Filter (Kernel), die über die Eingabe gleiten und translationsinvariante Features erkennen.
Diskrete 2D-Faltung (Convolution):
(f * g)(i, j) = Σm Σn f(m, n) · g(i − m, j − n)
Der Kernel g (z. B. 3×3 oder 5×5) gleitet über die Eingabe f. An jeder Position wird das Skalarprodukt berechnet. Die resultierenden Werte bilden die Feature Map. Die Gewichte des Kernels sind lernbar und werden durch Backpropagation optimiert.
Pooling-Operationen
Max-Pooling: Wählt den Maximalwert in jedem Fenster (z. B. 2×2) – erhält die stärksten Aktivierungen und reduziert die räumliche Auflösung um Faktor 2.
Average-Pooling: Berechnet den Mittelwert im Fenster – glättet die Feature Map, weniger aggressiv als Max-Pooling.
Hierarchische Feature-Extraktion
Frühe Schichten erkennen Kanten und Gradienten. Mittlere Schichten kombinieren diese zu Texturen und lokalen Mustern. Tiefe Schichten repräsentieren komplexe Strukturen und Objektteile. Diese Hierarchie ist der Schlüssel zur Leistungsfähigkeit von CNNs.
Aktivierungsfunktionen:
ReLU(x) = max(0, x)
Standard-Aktivierung. Schnell zu berechnen, mildert das Vanishing-Gradient-Problem. Nachteil: “Dying ReLU” – Neuronen mit negativer Eingabe lernen nicht mehr.
LeakyReLU(x) = max(αx, x)
Typisch α = 0.01. Erlaubt einen kleinen Gradienten für negative Eingaben und verhindert so das Absterben von Neuronen.
Batch Normalization
Normalisiert die Aktivierungen jeder Schicht auf Mittelwert 0 und Varianz 1 (pro Mini-Batch). Stabilisiert das Training, erlaubt höhere Lernraten und wirkt leicht regularisierend. Wird typischerweise zwischen Convolution und Aktivierung eingefügt.
Dropout
Während des Trainings werden zufällig ein Anteil p (z. B. 0.3) der Neuronen deaktiviert. Dies zwingt das Netzwerk, redundante Repräsentationen zu lernen, und wirkt als starke Regularisierung gegen Overfitting.
Rekurrente Neuronale Netze
Radar-Spektrogramme sind zeitliche Sequenzen: Jede Spalte repräsentiert einen Zeitschritt mit einem Frequenz-Vektor. Feedforward-Netze (CNNs) behandeln alle Positionen unabhängig – sie “vergessen” die zeitliche Abfolge. Rekurrente Netze (RNNs) besitzen hingegen einen Hidden State, der Information über vorherige Zeitschritte speichert.
Vanilla RNN – Zustandsgleichung:
h(t) = tanh(Wh · h(t−1) + Wx · x(t) + b)
h(t) ist der Hidden State zum Zeitpunkt t, x(t) die Eingabe, Wh und Wx sind lernbare Gewichtsmatrizen. Das Netz “erinnert sich” an vorherige Zeitschritte über h(t−1).
Vanishing-Gradient-Problem:
Bei Backpropagation Through Time (BPTT) werden Gradienten über viele Zeitschritte hinweg multipliziert. Da tanh-Ableitungen ≤ 1 sind, schrumpfen die Gradienten exponentiell → das Netz kann keine Langzeitabhängigkeiten lernen (typisch > 10–20 Zeitschritte). Die Lösung: LSTM und GRU.
LSTM – Long Short-Term Memory
Das LSTM führt einen separaten Cell State c(t) ein, der als “Langzeitgedächtnis” fungiert. Drei Gates steuern, welche Information gespeichert, gelöscht oder ausgegeben wird:
# Forget Gate: Was aus dem Cell State löschen?
f(t) = σ(Wf · [h(t-1), x(t)] + bf)
# Input Gate: Welche neuen Informationen speichern?
i(t) = σ(Wi · [h(t-1), x(t)] + bi)
c̃(t) = tanh(Wc · [h(t-1), x(t)] + bc)
# Cell State Update
c(t) = f(t) ⊙ c(t-1) + i(t) ⊙ c̃(t)
# Output Gate: Was wird als Hidden State ausgegeben?
o(t) = σ(Wo · [h(t-1), x(t)] + bo)
h(t) = o(t) ⊙ tanh(c(t))
GRU – Gated Recurrent Unit
Vereinfachte LSTM-Variante mit nur zwei Gates (Reset und Update) und ohne separaten Cell State. Weniger Parameter, oft vergleichbare Leistung:
z(t) = σ(Wz · [h(t-1), x(t)])
r(t) = σ(Wr · [h(t-1), x(t)])
h(t) = (1−z(t)) ⊙ h(t-1) + z(t) ⊙ tanh(W · [r(t) ⊙ h(t-1), x(t)])
Bidirektionale RNNs
Zwei separate RNN-Schichten verarbeiten die Sequenz in Vorwärts- und Rückwärtsrichtung. Die Ausgaben werden konkateniert. Das Netz hat so Zugang zu vergangenem und zukünftigem Kontext – besonders nützlich, wenn die gesamte Sequenz bereits vorliegt (Offline-Analyse von Spektrogrammen).
h(t) = [h⃗(t) ; h⃖(t)]
CRNN für Radar-Spektrogramme
Das Convolutional Recurrent Neural Network (CRNN) kombiniert die Stärken beider Ansätze: CNN-Schichten extrahieren räumliche Merkmale aus jedem Zeitfenster des Spektrogramms, während RNN-Schichten (LSTM/GRU) die zeitliche Evolution dieser Merkmale modellieren. Der Eingang ist ein Mikro-Doppler-Spektrogramm der Dimension Zeit × Frequenz × 1.
Input: Spektrogramm # Shape: (T=128, F=64, 1)
# --- CNN Feature Extractor ---
Conv2D(32, 3×3, padding=same) # → (128, 64, 32)
BatchNorm + ReLU
MaxPool2D(2×2) # → (64, 32, 32)
Conv2D(64, 3×3, padding=same) # → (64, 32, 64)
BatchNorm + ReLU
MaxPool2D(2×2) # → (32, 16, 64)
Conv2D(128, 3×3, padding=same)# → (32, 16, 128)
BatchNorm + ReLU
MaxPool2D(1×2) # → (32, 8, 128) – nur Frequenz pooling
# --- Reshape: räumliche Dims flatten, Zeitachse beibehalten ---
Reshape(→ (32, 8×128)) # → (32, 1024) = (Zeitschritte, Features)
# --- RNN Temporal Modelling ---
BiLSTM(128, return_sequences=True) # → (32, 256)
Dropout(0.3)
BiLSTM(64) # → (128) – letzter Hidden State
Dropout(0.3)
# --- Klassifikation ---
Dense(64, activation='relu')
Dense(n_classes, activation='softmax')# → (n_classes,)
Warum CRNN > reines CNN?
Ein reines CNN behandelt das Spektrogramm als statisches Bild. Es erkennt zwar räumliche Muster (Propeller-Signaturen, Flügelschlag-Frequenzen), kann aber die zeitliche Entwicklung nicht explizit modellieren. Beispiel: Ein Vogel hat unregelmäßige Flügelschlag-Perioden – ein CRNN erkennt dieses Muster über die LSTM-Schicht.
Warum CRNN > reines RNN?
Ein reines RNN erhält pro Zeitschritt einen rohen Frequenz-Vektor (z. B. 64 Bins). Es fehlt die Fähigkeit, lokale Frequenzmuster zu extrahieren (z. B. harmonische Strukturen eines Rotors). Die CNN-Schichten komprimieren die Frequenz-Dimension intelligent und liefern dem RNN aussagekräftigere Features.
Vom Radar-Signal zum trainierten Modell
Die Trainingspipeline umfasst die gesamte Kette von der Datenerfassung über die Vorverarbeitung und Augmentierung bis zum Training und der Evaluation des CRNN-Modells.
1. Datenerfassung & Preprocessing
Radar-Rohdaten (I/Q-Samples) werden über STFT (Short-Time Fourier Transform) in Spektrogramme umgewandelt. Typische Parameter: Fensterlänge 256, Overlap 75 %, Hann-Fenster. Anschließend: Logarithmische Skalierung (dB), Normalisierung auf [0, 1] oder Zero-Mean/Unit-Variance.
2. Datenaugmentierung
Time Shift
Zufälliges Verschieben entlang der Zeitachse (±10–20 Frames). Simuliert unterschiedliche Startzeitpunkte.
Frequency Shift
Verschiebung entlang der Frequenzachse (±2–5 Bins). Simuliert leichte Doppler-Offsets durch Windeinfluss.
Noise Injection
Addieren von Gaußschem Rauschen (SNR = 5–20 dB). Macht das Modell robuster gegenüber Rauschvariationen.
Time Warping
Leichtes Stauchen/Strecken der Zeitachse (Faktor 0.9–1.1). Simuliert variierende Geschwindigkeiten.
3. Datensplit – Achtung: Data Leakage!
Typischer Split: 70 % Training / 15 % Validation / 15 % Test. Kritisch: Alle Spektrogramme einer Aufnahme-Session müssen im gleichen Split landen. Sonst lernt das Modell session-spezifische Artefakte (Hintergrund, Sensorposition) statt der Ziel-Signaturen. Idealerweise Split nach Aufnahme-Tag oder Ort.
model = CRNN(n_classes=4) # Drohne, Vogel, Clutter, Mensch
loss_fn = CrossEntropyLoss()
optimizer = Adam(lr=1e-3)
scheduler = CosineAnnealing(T_max=50)
for epoch in range(100):
for batch_x, batch_y in train_loader:
batch_x = augment(batch_x) # Online-Augmentierung
pred = model(batch_x)
loss = loss_fn(pred, batch_y)
loss.backward()
optimizer.step()
optimizer.zero_grad()
val_acc = evaluate(model, val_loader)
scheduler.step()
print(f"Epoch {epoch}: Loss={loss:.4f}, Val-Acc={val_acc:.2%}")
# Finale Evaluation auf dem Test-Set
test_acc, conf_matrix = evaluate(model, test_loader, return_cm=True)
Verlustfunktion
Cross-Entropy Loss für Multi-Class-Klassifikation:
L = −Σc yc · log(p̂c)
Bei unbalancierten Klassen: Gewichtete Cross-Entropy oder Focal Loss (γ = 2).
Evaluationsmetriken
Accuracy: Anteil korrekt klassifizierter Samples.
Precision: TP / (TP + FP) pro Klasse.
Recall: TP / (TP + FN) pro Klasse.
F1-Score: 2 · Prec · Rec / (Prec + Rec).
Confusion Matrix: Zeigt Verwechslungsmuster zwischen Klassen.
Domänenanpassung & wenige Daten
In der Praxis stehen oft nur wenige gelabelte Realdaten zur Verfügung, da Radar-Messkampagnen aufwendig und teuer sind. Gleichzeitig existieren Radar-Simulatoren, die große Datenmengen erzeugen können – allerdings mit einer Domain Gap gegenüber realen Messungen.
Transfer Learning
Phase 1 (Pre-Training): Trainiere das CRNN auf großem simuliertem Datensatz (z. B. 100.000 Spektrogramme). Die CNN-Schichten lernen allgemeine Frequenz-/Zeitmuster.
Phase 2 (Fine-Tuning): Ersetze die letzte Dense-Schicht und trainiere mit wenigen realen Daten (z. B. 500 Samples). Friere die ersten CNN-Schichten ein, trainiere nur die oberen Schichten und das LSTM.
Domain Adaptation
Adversarial Training: Ein Domain-Diskriminator versucht, Simulations- von Realdaten zu unterscheiden. Der Feature-Extractor wird so trainiert, dass er domäneninvariante Features erzeugt (Gradient Reversal Layer).
Feature Alignment: Minimiere die Maximum Mean Discrepancy (MMD) zwischen den Feature-Verteilungen beider Domänen.
Few-Shot Learning für seltene Klassen
Manche Zielklassen (z. B. Militär-Drohnen, seltene Vögel) haben nur 5–20 Trainingsbeispiele. Ansätze: Prototypical Networks (vergleiche Embedding des neuen Samples mit Klassen-Prototypen im Feature-Raum), MAML (Model-Agnostic Meta-Learning) oder einfache Nearest-Neighbor-Klassifikation im gelernten Feature-Raum.
Praktische Tipps für Radar-ML
• Logge alle Hyperparameter und Metriken systematisch (MLflow, Weights&Biases).
• Verwende Early Stopping auf der Validation-Loss (Patience: 10–15 Epochen).
• Teste das Modell auf Daten von anderen Standorten und anderen Tagen – nur so zeigt sich echte Generalisierung.
• Berücksichtige Echtzeit-Anforderungen: Das Modell muss innerhalb der Frame-Dauer inferieren (< 50 ms).
CNN vs. RNN vs. CRNN
Die Wahl der Architektur hängt vom verfügbaren Datensatz, den Echtzeit-Anforderungen und der Komplexität der Klassifikationsaufgabe ab. Die folgende Tabelle fasst die wichtigsten Unterschiede zusammen.
| Kriterium | CNN | RNN (LSTM) | CRNN |
|---|---|---|---|
| Eingabeformat | 2D-Bild (Spektrogramm) | Sequenz von Vektoren | 2D-Bild → Sequenz |
| Räumliche Features | Stark | Schwach | Stark |
| Zeitliche Features | Schwach | Stark | Stark |
| Typische Accuracy (Drohne/Vogel) | 88–92 % | 82–87 % | 93–97 % |
| Parameteranzahl | 0.5–2 M | 0.3–1 M | 1–4 M |
| Inferenzzeit (GPU) | < 5 ms | 10–30 ms | 15–40 ms |
| Trainingsaufwand | Mittel | Hoch (Sequenzen) | Hoch |
Wann welche Architektur?
CNN: Wenn Echtzeit kritisch ist und die Zeitdynamik weniger relevant (z. B. einzelne Range-Doppler-Frames).
RNN: Wenn nur 1D-Zeitreihen vorliegen (z. B. Doppler-Zeitverläufe ohne Frequenzauflösung).
CRNN: Wenn Spektrogramme mit zeitlicher Struktur vorliegen und höchste Genauigkeit gefragt ist.
Aktuelle Ergebnisse aus der Literatur
Kim & Moon (2017): DCNN auf Mikro-Doppler → 90.8 % Accuracy (12 Klassen).
Seyfioglu et al. (2018): Deep CNN + Transfer → 94.5 % (Drohne vs. Vogel).
Ritchie et al. (2020): CRNN mit Attention → 96.2 % (4 Klassen, reale Daten).
Rahman & Robertson (2022): Bi-LSTM + CNN → 97.1 % (simulierte + reale Daten).
Netzwerk-Architektur-Visualisierung
Die folgende interaktive Visualisierung zeigt den Datenfluss durch das CRNN. Fahre mit der Maus über eine Schicht, um Details zu sehen (Typ, Parameter, Ausgabedimension). Klicke auf Animate, um einen Datenpuls durch das Netzwerk zu verfolgen.