Neuronale Netze sind der Motor vieler Anwendungen in KI und GenAI. Diese Artikelserie gibt einen Einblick in die einzelnen Elemente. Der achte Teil widmet sich hybriden Architekturen.

Daten in der realen Welt haben oft mehrere Strukturdimensionen. Videos weisen beispielsweise sowohl räumliche Muster innerhalb jedes Frames als auch zeitliche Muster über Frames hinweg auf. Hybride Architekturen kombinieren die Stärken von Convolutional-, Recurrent- und Attention-basierten Schichten, um solche komplexen Daten zu modellieren. Dieses Kapitel veranschaulicht zwei gängige Muster: Convolution gefolgt von Recurrence und Convolution kombiniert mit Self-Attention (Selbstaufmerksamkeit).

Ein klassisches Hybridmodell für die Videoklassifizierung wendet zunächst unabhängig voneinander eine Reihe von Faltungsschichten auf jedes Bild an und erzeugt so einen Bildvektor, der die räumliche Struktur erfasst. Diese Bildvektoren werden dann in ein rekurrentes Netzwerk eingespeist, das zeitliche Abhängigkeiten modelliert. Konkret nehmen wir an, wir haben einen Stapel von Videos, die als Tensor der Form (batch_size, seq_len, channels, height, width) dargestellt sind. Wir können zunächst alle Frames umformen und durch ein 2D-CNN verarbeiten, dann die zeitliche Achse wiederherstellen und ein LSTM (Long Short-Term Memory) anwenden:

import torch  
import torch.nn as nn  

Klasse CNNLSTM(nn.Module):  
    def __init__(self, num_classes, cnn_out_dim=128, hidden_dim=64):  
        super(CNNLSTM, self).__init__()  
        # Ein einfaches CNN, das (C,H,W) auf cnn_out_dim abbildet  
        self.cnn = nn.Sequential(  
            nn.Conv2d(3, 32, kernel_size=3, padding=1),  
            nn.ReLU(),  
            nn.MaxPool2d(2),            # halbiert H,W  
            nn.Conv2d(32, 64, 3, padding=1),  
            nn.ReLU(),  
            nn.AdaptiveAvgPool2d((1,1)) # globales Merkmal  
        )  
        # Lineare Schicht zum Abflachen der CNN-Ausgabe  
        self.fc   = nn.Linear(64, cnn_out_dim)  
        # LSTM zur Modellierung der zeitlichen Abfolge von Frame-Merkmalen  
        self.lstm = nn.LSTM(input_size=cnn_out_dim,  
                            hidden_size=hidden_dim,  
                            num_layers=1,  
                            batch_first=True)  
        # Endgültiger Klassifikator, der die LSTM-Ausgabe den Klassenlogits zuordnet  
        self.classifier = nn.Linear(hidden_dim, num_classes)  

    def forward(self, videos):  
        # videos: (batch, seq_len, C, H, W)  
        b, t, c, h, w = videos.shape  
        # Batch und Zeit für CNN-Verarbeitung zusammenführen  
        frames = videos.view(b * t, c, h, w)  
        features = self.cnn(frames)         # (b*t, 64, 1, 1)  
        features = features.view(b * t, 64)  
        features = self.fc(features)        # (b*t, cnn_out_dim)  
        # Batch- und Zeitdimensionen wiederherstellen  
        features = features.view(b, t, -1)  # (b, t, cnn_out_dim)  
        # LSTM erwartet (Batch, seq_len, Merkmal)  
        lstm_out, _ = self.lstm(features)   # (b, t, hidden_dim)  
        # Verwenden Sie den endgültigen versteckten Zustand von LSTM für die Klassifizierung  
        final = lstm_out[:, -1, :]          # (b, hidden_dim)  
        logits = self.classifier(final)     # (b, num_classes)  
        return logits  

# Anwendungsbeispiel  
model = CNNLSTM(num_classes=10)  
dummy_videos = torch.randn(4, 16, 3, 64, 64)  # Stapel mit jeweils 4, 16 Frames  
outputs = model(dummy_videos)                  # (4, 10)  

In diesem Code reduziert das adaptive Average-Pooling jede Feature-Map auf eine einzige Zahl und wandelt die räumliche Karte in einen Vektor der Länge 64 um. Die lineare Schicht projiziert diesen Vektor für jedes Frame in ein 128-dimensionales Feature. Durch die Umformung des Tensors zurück zu (batch, seq_len, feature_dim) speisen wir die Frame-Features in ein LSTM ein, das erfasst, wie sich Muster im Laufe der Zeit entwickeln. Schließlich nehmen wir die letzte Ausgabe des LSTM und leiten sie durch einen linearen Klassifikator, um Klassenscores zu erzeugen.

Ein alternativer hybrider Ansatz ersetzt das rekurrente Netzwerk durch einen Aufmerksamkeitsmechanismus. Nach der Extraktion der Merkmalskarten mit einem CNN (Convolutional Neural Network) kann man jeden räumlichen Ort (oder jeden Frame) als Token behandeln und Selbstaufmerksamkeit anwenden, um langfristige Abhängigkeiten zu modellieren. Der Kern der Selbstaufmerksamkeit ist die Skalarproduktformel, die für einen Satz von Abfrage-, Schlüssel- und Wertvektoren Q, K und V berechnet:

Attention(Q, K, V) = softmax( (Q·Kᵀ) / √d_k ) · V

Hier ist d_k die Dimension der Schlüsselvektoren, und softmax erzeugt Aufmerksamkeitsgewichte, die für jede Abfrage eins ergeben. In PyTorch kann man eine einzelne Multi-Head-Attention-Schicht wie folgt implementieren:

import torch.nn.functional as F  

class CNNAttention(nn.Module):  
    def __init__(self, cnn_out_dim=128, num_heads=4):  
        super().__init__()  
        # CNN-Merkmalsextraktor (ähnlich wie zuvor)  
        self.cnn = nn.Sequential(  
            nn.Conv2d(3, 64, 3, padding=1),  
            nn.ReLU(),  
            nn.MaxPool2d(2),  
            nn.Conv2d(64, cnn_out_dim, 3, padding=1),  
            nn.ReLU()  
        )  
        # Multi-Head-Aufmerksamkeitsschicht  
        self.attn = nn.MultiheadAttention(embed_dim=cnn_out_dim,  
                                          num_heads=num_heads,  
                                          batch_first=True)  
        # Klassifikator  
        self.classifier = nn.Linear(cnn_out_dim, 10)  

    def forward(self, images):  
        # Bilder: (Batch, C, H, W)  
        features = self.cnn(images)       # (b, cnn_out_dim, H', W')  
        b, d, h, w = features.shape  
        # Räumliche Dimensionen in Sequenz abflachen  
        seq = features.view(b, d, h*w).permute(0, 2, 1)  
        # Selbstaufmerksamkeit über räumliche Token  
        attn_out, _ = self.attn(seq, seq, seq)  # (b, h*w, d)  
        # Über Tokens hinweg durch Mittelwertbildung bündeln  
        pooled = attn_out.mean(dim=1)            # (b, d)  
        logits = self.classifier(pooled)         # (b, 10)  
        return logits  

# Anwendungsbeispiel  
model = CNNAttention()  
dummy_images = torch.randn(4, 3, 32, 32)  
outputs = model(dummy_images)  # (4,10)  

Dieses hybride Design verwendet die Faltungsschichten, um ein räumliches Gitter aus Merkmalsvektoren zu erzeugen. Durch Abflachen des Gitters zu einer Sequenz der Länge H′·W′ behandeln wir jeden Ort als Token. Das Modul nn.MultiheadAttention berechnet mehrere Sätze von Abfragen, Schlüsseln und Wertprojektionen, verkettet diese und projiziert sie zurück in die ursprüngliche Dimension, sodass das Modell vielfältige Beziehungen zwischen räumlichen Regionen erfassen kann. Durch Mittelwertbildung über alle Tokens erhält man eine globale Darstellung, die der Klassifikator verwenden kann.

Hybride Architekturen ermöglichen es, Lokalität, Sequenz und globalen Kontext in einem einzigen Modell zu nutzen. Sie kommen in Anwendungen zum Einsatz, die vom Verstehen von Videos bis zur Bildbeschriftung und darüber hinaus reichen.

Der nächste Teil der Serie blickt in die Zukunft der neuronalen Netze und zeigt auf, welche Trends, die nächste Generation von Modellen prägen.

(rme)

Eclipse, die quelloffene Open-Source-IDE für Java, C/C++ und weitere Programmiersprachen, ist in der Version 2025-09 erschienen. Neu ist die Möglichkeit, markierten Text im Editor mit dem Inhalt der Zwischenablage zu vergleichen. Ebenso können Entwicklerinnen und Entwickler ganze Dateien mit der Zwischenablage vergleichen oder deren Inhalt durch den der Zwischenablage ersetzen.

Für die Java-Entwicklung gibt es Detailverbesserungen wie eine neue Schnellkorrektur und Aufräumfunktion für als deprecated (veraltet) markierte Felder sowie das Setzen eines Triggerpunktes oder eines Breakpoints mit Hit Count per Rechtsklick auf eine Zeilennummer. Unterstützung für die kommende Java-Version 25 gibt es noch nicht. Eine Vorabversion soll zum offiziellen Start von Java 25 in der kommenden Woche über den Eclipse Marketplace angeboten werden.

Allgemeine Verbesserungen

Eine neue Funktion der Eclipse-Plattform ermöglicht es, im Editor Textbereiche mit dem Inhalt der Zwischenablage im Compare-Editor zu vergleichen. Dazu wählt man zunächst den Text aus, macht einen Rechtsklick und wählt Compare With | Clipboard. Wenn kein Text ausgewählt ist oder wenn man einen Rechtsklick auf eine Datei im Project- oder Package-Explorer macht, vergleicht Eclipse stattdessen die gesamte Datei mit der Zwischenablage.

Auf die gleiche Weise lässt sich über Replace With | Clipboard ein Textbereich oder eine komplette Datei durch den Inhalt der Zwischenablage ersetzen. Die im vorigen Release begonnene Ersetzung von Bitmap-Grafiken durch Grafiken im SVG-Format wurde weitergeführt. Dadurch erscheinen Icons und Grafiken bei sehr hohen oder krummen Auflösungen schärfer.

Java-Updates

Daneben wurden auch Sticky-Scrolling und Code-Faltung im Java-Editor verbessert. Sticky-Scrolling, das Anhaften der übergeordneten Zeilen am oberen Rand anstelle des Verschwindens im nicht sichtbaren Scrollbereich, basiert im Java-Editor nun auf der Code-Struktur statt wie bei reinen Texteditoren auf der Einrückung des Texts, sodass die Zeilen, die Entwickler erwarten, und nicht andere Zeilen auch bei auskommentiertem Code oder besonderer Formatierung sichtbar bleiben. Bei der benutzerdefinierten Code-Faltung lassen sich jetzt auch Bereiche ohne explizite Endmarkierung definieren, die sich bis zum nächsten benutzerdefinierten Faltbereich oder bis zum Ende des übergeordneten Blocks erstrecken.

Parallel dazu hat das Eclipse-Team das Java-Tooling und den Eclipse-eigenen Java-Compiler weiterentwickelt, um sie fit für Java 25 zu machen – die nächste Version nach Java 21, für die Java-Anbieter Long-Term-Support bieten wollen. Zur Veröffentlichung von Java 25 in der kommenden Woche ist die Bereitstellung einer Vorabversion zum Nachinstallieren über den Eclipse Marketplace geplant. Im Dezember-Release der Eclipse IDE ist die Java-25-Unterstützung dann als fester Bestandteil vorgesehen.

Upgrade oder Download

Für Windows, Linux und macOS werden jeweils zehn erweiterbare Basispakete der Eclipse-Entwicklungsumgebung für unterschiedliche Einsatzzwecke angeboten. Sämtliche Pakete enthalten alles, was zum Ausführen von Eclipse und zum Entwickeln nötig ist: Java 21 und Git,sowie in den Java-IDE-Paketen zusätzlich Maven und Gradle.

Die Eclipse-IDE-Pakete lassen sich über den Eclipse Installer installieren oder als ZIP-Dateien herunterladen. Eine bestehende Eclipse IDE lässt sich über Help | Check for Updates aktualisieren. Weitere Informationen und die Neuerungen von den an diesem Release beteiligten Eclipse-Projekten finden sich auf der Eclipse-IDE-Webseite.

(mai)

Der KI-Coding-Assistent GitHub Copilot bekommt Verstärkung durch die Sicherheitstools der DevSecOps-Plattform JFrog. Copilot erkennt über JFrogs MCP-Server (Model Context Protocol) automatisch Schwachstellen sowie korrupte und nicht compliancegerechte Pakete im Code. Bei einem Fund bietet er sofort Korrekturvorschläge an. JFrog hat darüber hinaus einen Dienst zum Verwalten von KI-Modellen und -Ressourcen im Unternehmen vorgestellt sowie als Beta ein agentengesteuertes Repository für die Bereitstellung von Software.

Die Kommunikation vom GitHub Copilot zu JFrog erfolgt über das MCP-Protokoll, das Ressourcen von JFrogs Sicherheitsagent Curation und dem zugehörigen Schwachstellenkatalog bereitstellt. Copilot prüft den Code für Entwicklerinnen und Entwickler in der IDE auf CVE-Schwachstellen und Probleme in abhängigen Open-Source-Paketen, die entweder unsicher sind oder nicht den Complianceregeln des Unternehmens entsprechen. Die Developer erhalten inline Korrekturvorschläge im Kontext des Codes und können weitere Informationen zu den festgestellten Problemen abrufen. Diese Funktionen erfordern die JFrog-Produkte Ultimate oder Unified Security.

Gemeinsam mit GitHub bietet JFrog zudem künftig in Repositories eine Absicherung des kompletten Lebenszyklus einer Softwarekomponente bis über die Auslieferung hinaus. Diese Funktionen lassen sich über den Dienst Artifactory am Anschluss an die gängigen Tests in Actions einbinden.

KI-Management im Unternehmen

Neben den Tools in Kooperation mit GitHub hat JFrog weitere Neuerungen veröffentlicht: Für die Verwaltung von KI-Ressourcen innerhalb des Unternehmens gibt es künftig den AI Catalogue. Er dient dem Management und der Bereitstellung aller KI-Modelle und -Ressourcen im Unternehmen. Außerdem schafft er abgesicherte Verbindungen zu externen Modellen wie von OpenAI oder Anthropic, Nvidia Nemotron oder denen auf Hugging Face. Entwicklerinnen und Entwickler können über den Katalog auf sichere und compliancegerechte KI-Ressourcen zugreifen.

Deployment per Chat

„Kein Setup. Keine Skripte. Nur chatten, um zu bauen und bereitzustellen.“ – Damit wirbt das neue agentengestützte Repository JFrog Fly, das derzeit nur als Closed Beta nutzbar ist. Es soll den gesamten Lebenszyklus einer Software umspannen und per MCP mit anderen Komponenten und Repositories kommunizieren, wie GitHub oder Claude Code.

(who)