Connect with us

Entwicklung & Code

Künstliche Neuronale Netze im Überblick 8: Hybride Architekturen


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.


Michael Stal

Michael Stal

Prof. Dr. Michael Stal arbeitet seit 1991 bei Siemens Technology. Seine Forschungsschwerpunkte umfassen Softwarearchitekturen für große komplexe Systeme (Verteilte Systeme, Cloud Computing, IIoT), Eingebettte Systeme und Künstliche Intelligenz.

Er berät Geschäftsbereiche in Softwarearchitekturfragen und ist für die Architekturausbildung der Senior-Software-Architekten bei Siemens verantwortlich.

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)



Source link

Verwandte Themen:
Weiterlesen

Entwicklung & Code

Infrastructure-as-Code: Die neue Plattform formae soll Terraform & Co. ablösen


Das Unternehmen Platform Engineering Labs kündigt formae als neue Infrastructure-as-Code-Plattform (IaC) an. Der offiziellen Verlautbarung zufolge soll sie die Einschränkungen („fundamentale Unzulänglichkeiten“) von Tools wie Terraform reformieren und einen grundlegend neuen Weg beschreiten: Die unter der FSL-Lizenz (Fair Source) veröffentlichte quelloffene Software verspricht, bestehende Cloud-Infrastrukturen automatisch zu erkennen und in verwaltbaren Code zu überführen. Damit sei formae die erste IaC-Plattform, die sich nicht auf einen idealisierten Plan stütze, sondern von der Realität ausgehe, wie Pavlo Baron, Mitgründer und CEO von Platform Engineering Labs, erklärt.

Weiterlesen nach der Anzeige

Automatische Infrastruktur-Erkennung als Kernfunktion

Während Terraform und vergleichbare IaC-Werkzeuge auf manuell erstellten Konfigurationsdateien basieren, soll formae automatisch die gesamte bestehende Cloud-Infrastruktur einer Organisation erfassen und in Code überführen – unabhängig davon, wie diese ursprünglich erstellt wurde. Die Plattform arbeitet mit sogenannten „formas“, versionierten Code-Artefakten, die sowohl temporär als auch dauerhaft gespeichert werden können. Laut dem Entwicklungsteam eliminiert dieser Ansatz das Problem der State-Dateien, die bei Terraform häufig zu Inkonsistenzen zwischen dem geplanten und dem tatsächlichen Zustand der Infrastruktur führen.

Die neue Plattform soll dabei nicht nur einfach die Komplexität vom Development zum Betrieb hin verlagern, sondern tatsächlich die kognitive Belastung sowohl für Entwicklungs- als auch für Betriebsteams reduzieren. Dazu trägt Platform Engineering Labs zufolge eine Agent-basierte Architektur bei, die Änderungs- und Zustandsverwaltung von den Clients entkoppelt. Auf diese Weise sei eine sorgfältige, asynchrone Annäherung an den erklärten Zielzustand möglich. Um zudem das Risiko verminderter Zuverlässigkeit bei Infrastrukturänderungen gering zu halten, setzt formae auf Patch-basierte Updates, die sich präzise und inkrementell mit minimalem Ausmaß durchführen lassen.



Die IaC-Plattform formae verspricht eine Vereinheitlichung aller Ressourcen für Infrastructure-as-Code.

(Bild:  Platform Engineering Labs)

IaC-Markt: Terraform unter Druck

Die Ankündigung von formae erfolgt in einer Zeit, in der der IaC-Markt in Bewegung ist. Terraform-Hersteller HashiCorp – seit dem Frühjahr 2025 ein Teil von IBM – hatte 2023 seine Lizenzierung von der Mozilla Public License (MPL) auf die umstrittene Business Source License (BSL) umgestellt. Darauf reagierte die Community mit dem Open-Source-Fork OpenTofu, der inzwischen unter der Schirmherrschaft der Cloud Native Computing Foundation steht und zudem von einer wachsenden Zahl von Unternehmen Unterstützung erfährt.

Weiterlesen nach der Anzeige

Unterdessen arbeitet HashiCorp an neuen Funktionen für Terraform, darunter die Integration mit Ansible und erweiterte Such- und Import-Möglichkeiten für bestehende Cloud-Ressourcen. Die jüngsten Entwicklungen deuten darauf hin, dass HashiCorp den Fokus vermehrt auf KI-Integration legt, etwa durch das interne Projekt „Infragraph“, das als vollständiges Infrastruktur-Inventar für das KI-Training dienen soll.

Verfügbarkeit und Community

Mit formae strebt Platform Engineering Labs eine Vereinheitlichung aller Ressourcen für Infrastructure-as-Code an, unabhängig davon, ob diese über Patches mit minimalem Auswirkungsradius, Terraform, OpenTofu, Pulumi, ClickOps oder Legacy-Skripte erstellt wurden. Die Plattform soll die Grundlage für ein offenes und erweiterbares Ökosystem schaffen.

formae ist ab sofort auf GitHub verfügbar. Community-Diskussionen finden auf Discord statt. Die FSL-Lizenz habe Platform Engineering Labs gewählt, um Entwicklerinnen und Entwicklern zunächst alle Möglichkeiten offenzuhalten, sich intensiv und uneingeschränkt mit der Software auseinanderzusetzen – auch eigene Beiträge dazu zu leisten – und gleichzeitig ein nachhaltiges kommerzielles Modell zu ermöglichen.


(map)



Source link

Weiterlesen

Entwicklung & Code

Python-Webframework: Django-Developer nutzen zunehmend HTMX und Alpine.js


Die Django Software Foundation und das Team hinter der Python-Entwicklungsumgebung JetBrains PyCharm haben die Ergebnisse zur Umfrage „State of Django 2025“ veröffentlicht. Weltweit haben gut 4600 Entwicklerinnen und Entwickler teilgenommen, die Django verwenden – ein Open-Source-Webframework für die Programmiersprache Python. Die Studie zeigt die Trends und Tools im Django-Ökosystem: React und jQuery erweisen sich als die beliebtesten JavaScript-Bibliotheken, doch HTMX und Alpine.js holen auf und auch die KI-Verwendung nimmt zu.

Weiterlesen nach der Anzeige


enterJS 2026

enterJS 2026

(Bild: jaboy/123rf.com)

Call for Proposals für die enterJS 2026 am 16. und 17. Juni in Mannheim: Die Veranstalter suchen nach Vorträgen und Workshops rund um JavaScript und TypeScript, Frameworks, Tools und Bibliotheken, Security, UX und mehr. Vergünstigte Blind-Bird-Tickets sind bis zum Programmstart erhältlich.

Django-Developer nutzen zunehmend KI

Während laut der Studie knapp 80 Prozent der befragten Developer weiterhin die offizielle Dokumentation unter djangoproject.com als ihre Lernquelle nutzen, sind KI-Tools mit 38 Prozent auf dem Vormarsch und haben sowohl Blogs (33 Prozent) als auch Bücher (22 Prozent) überholt.


The State of Django 2025: Django-Entwicklerinnen und -Entwickler informieren sich vorrangig mittels der offiziellen Dokumentation.

The State of Django 2025: Django-Entwicklerinnen und -Entwickler informieren sich vorrangig mittels der offiziellen Dokumentation.

The State of Django 2025: Django-Entwicklerinnen und -Entwickler informieren sich vorrangig mittels der offiziellen Dokumentation.

(Bild: Django Software Foundation/JetBrains PyCharm)

In der Entwicklung mit Django sind KI-Tools ebenfalls beliebt, insbesondere für Aufgaben wie Autovervollständigung, Codegenerierung und das Schreiben von Boilerplate-Code. Beispielsweise nutzen 69 Prozent der Befragten ChatGPT und 34 Prozent GitHub Copilot. Wie die Studienmacher vermuten, wird sich im nächsten Jahr eine noch stärkere KI-Nutzung zeigen.

JavaScript: React und jQuery an der Spitze, HTMX und Alpine.js im Aufwind

Weiterlesen nach der Anzeige

In Kombination mit Django kommen wie bereits in den Vorjahren am häufigsten die JavaScript-Bibliotheken React und jQuery zum Einsatz. Allerdings zeigt sich ein deutlicher Anstieg in der Nutzung von HTMX und Alpine.js, die beide den Ansatz serverseitiger Templates verfolgen. Seit 2021 hat HTMX von fünf auf 24 Prozent zugelegt, Alpine.js von drei auf 14 Prozent. Das anstehende Release Django 6.0 wird offiziellen Support für Template Partials bieten, was die Kombination mit HTMX und Alpine.js als gangbare Alternative offenbar weiter festigen wird.


The State of Django 2025: Diese JavaScript-Frameworks nutzen Django-Developer.

The State of Django 2025: Diese JavaScript-Frameworks nutzen Django-Developer.

The State of Django 2025: Diese JavaScript-Frameworks nutzen Django-Developer.

(Bild: Django Software Foundation/JetBrains PyCharm)

Zu den weiteren Funden der Studie zählt, dass Django-Developer tendenziell sehr erfahren sind: Knapp ein Drittel arbeitet bereits mindestens elf Jahre mit dem Framework. Zudem kommt Django hauptsächlich beruflich zum Einsatz. Diese und weitere Ergebnisse präsentiert der JetBrains-Blog.

20 Jahre Django – mit inklusiver Community

Bei Django handelt es sich um ein High-Level-Webframework für die Programmiersprache Python, mit Fokus auf Schnelligkeit, Sicherheit und Skalierbarkeit. Am 13. Juli 2025 hat Django bereits sein zwanzigjähriges Jubiläum gefeiert. Wie das Django-Team in dem Zuge ankündigte, sind auch in Zukunft viele Releases mit mehreren Jahren Support sowie Tausende neue Packages im Django-Ökosystem zu erwarten – in einer großen, inklusiven Online-Community.

Auch die Python Software Foundation, die hinter der Programmiersprache steht, legt Wert auf eine vielfältige Entwicklergemeinschaft. Erst kürzlich wurde bekannt, dass sie einen Antrag auf Fördergelder der US-Regierung aufgrund von Anti-DEI-Vorgaben (Diversity, Equity and Inclusion) zurückgezogen hat.


(mai)



Source link

Weiterlesen

Entwicklung & Code

Python Software Foundation: Chancengleichheit wichtiger als US-Fördergelder


Die Python Software Foundation (PSF) hat einen Anfang des Jahres gestellten Antrag auf Fördergelder der US-Regierung zurückgezogen.Konkret hatte die PSF bei der National Science Foundation der US-Regierung 1,5 Millionen US-Dollar Fördergelder nach dem Safety, Security, and Privacy of Open-Source Ecosystems (Safe-OSE) beantragt. Das Programm soll die Sicherheit in Open-Source-Ökosystemen stärken und gegen Angriffe schützen.

Weiterlesen nach der Anzeige

Nach einigen Monaten wurde der Antrag offenbar für die Förderung empfohlen. Laut des PSF-Blogs sind nur 36 Prozent, also gut ein Drittel, aller Erstanträge erfolgreich.

Inakzeptable Bedingungen für die Förderung

Die anfängliche Freude wich allerdings schnell ernsten Bedenken, als die Stiftung die Bedingungen für die Förderung zugesandt bekam.

Konkret fand sich darin die Aussage, dass geförderte Organisationen „keine Programme durchführen und während der Laufzeit dieser finanziellen Unterstützung auch keine Programme durchführen werden, die DEI oder eine diskriminierende Gleichstellungsideologie fördern oder unterstützen, die gegen die Bundesgesetze gegen Diskriminierung verstößt“.

Trumps Kampf gegen DEI

DEI steht für Diversity, Equity and Inclusion, also Vielfalt, Gerechtigkeit und Inklusion. Es geht vor allem darum, unterrepräsentierte Gruppen zu fördern. Kurz nach dem Start seiner zweiten Amtszeit hat US-Präsident Donald Trump in seinem Kampf gegen „Wokeness“ die DEI-Programme massiv eingeschränkt. In der Ankündigung auf der offiziellen Seite des Weißen Hauses ist von „illegalen und unmoralischen Diskriminierungsprogrammen“ die Rede, die von der Biden-Administration erzwungen worden seien.

Die Bedingungen für die Förderungen inklusive der Anti-DEI-Vorgaben gelten nicht nur für die Security-Bemühungen, sondern für die gesamte Arbeit der geförderten Organisationen.

Weiterlesen nach der Anzeige

Widerspruch zur Mission der PSF

Die Python Software Foundation hat die Chancengleichheit in ihrem offiziellen Mission-Statement verankert. Darin heißt es „Die Mission der Python Software Foundation besteht darin, die Programmiersprache Python zu fördern, zu schützen und weiterzuentwickeln sowie das Wachstum einer vielfältigen und internationalen Gemeinschaft von Python-Programmierern zu unterstützen und zu erleichtern.“




(Bild: Python Software Foundation)

Der Autor der Programmiersprache Python Guido van Rossum hat am 6. März 2001 die Python Software Foundation als US-amerikanischen Non-Profit-Organistion gegründet.

Die PSF kümmert sich um die Weiterentwicklung von Python und verwaltet zudem den Paketmanager Python Package Index (PyPI). Letzterer ist ebenso wie der JavaScript-Paketmanager npm immer wieder Ziel von Supply-Chain-Angriffen.

Laut des Blogbeitrags hat die PSF keinen Weg gefunden, die Fördergelder zu erhalten und gleichzeitig an der Mission festzuhalten. Da sie zu dem Schluss gekommen sei, dass sie die Gelder nicht annehmen kann, ohne ihre eigene Mission zu verraten.

Die PSF ist nicht die erste Organisation, die ihren Fördergeldantrag wegen der Bedingungen zurückzieht. Im Juni war die in Deutschland wenig bekannte Organisation The Carpentries denselben Schritt gegangen. The Carpentries bietet Trainings für Softwareentwicklung und Data Science an, und stellt alle Schulungsmaterialien unter der Creative-Commons-Lizenz bereit.

Die Gelder der National Science Foundation wären nicht die erste finanzielle Unterstützung für die Python Software Foundation zur Förderung der Sicherheit gewesen. Im Juni 2022 hatte die Open Source Security Foundation (OpenSSF), die unter dem Dach der Linux Foundation steht, die PSF mit 400.000 US-Dollar unterstützt.


(rme)



Source link

Weiterlesen

Beliebt