Microsoft hat den Quellcode seines historischen 6502-BASIC-Interpreters aus dem Jahr 1976 erstmals offiziell als Open Source freigegeben und somit einen wichtigen Beitrag zur Bewahrung der Geschichte der Heimcomputer geleistet. Die Software wurde ursprünglich von Bill Gates und Ric Weiland für den beliebten 8-Bit-Prozessor MOS 6502 entwickelt. Später lag sie den einflussreichen Computern Commodore PET, VIC-20 und Commodore 64 zugrunde – Millionen von Nutzern lernten damit programmieren und prägen bis heute die Kulturszene rund ums Retro-Computing.

Die jetzt unter der MIT-Lizenz veröffentlichte Version 1.1 enthält laut Microsoft unter anderem Verbesserungen an der Speicherverwaltung, die 1978 gemeinsam mit Commodore-Entwickler John Feagans umgesetzt wurden. Damit handelt es sich um die Variante, die als BASIC V2 auf dem PET ausgeliefert wurde und bis heute in den ROM-Archiven von Computermuseen und Emulatoren lebt. Der 6955 Zeilen umfassende Assembly-Sourcecode steht ab sofort auf GitHub bereit – samt Unterstützung für verschiedene historische Systeme wie Apple II oder Commodore PET.

Mit an Bord sind außerdem die dokumentierten Easter Eggs von Bill Gates selbst. Denn in den Quellcodes von Microsoft 6502 BASIC sind mehrere versteckte Funktionen verborgen, darunter die berühmten Labels STORDO und STORD0, wie Bill Gates selbst 2010 bestätigte. Besonders bekannt ist das WAIT 6502,1-Kommando, das auf einem Commodore PET mit BASIC V2 das Wort MICROSOFT! auf dem Bildschirm erscheinen lässt – das versteckte Markenzeichen hatte Bill Gates gezielt eingebaut.

Microsoft betont mit der Veröffentlichung die historische Bedeutung des BASIC-Interpreters für die eigenen Anfänge. Gleichzeitig verweist der Konzern in seiner Ankündigung darauf, dass sich die Community – von Museumsarchiven bis hin zu modernen FPGA- und Emulator-Projekten – schon seit Jahrzehnten für dessen Erhalt und praktische Anwendung eingesetzt hat. 2020 hatte Microsoft bereits den GW-BASIC-Interpreter als Open Source veröffentlicht, der aus dem Jahr 1983 stammt und für IBM-kompatible PCs beziehungsweise MS-DOS zum Einsatz kam.

(fo)

Neuronale Netze sind der Motor vieler Anwendungen in KI und GenAI. Diese Artikelserie gibt einen Einblick in die einzelnen Elemente. Der siebte Teil widmet sich rekursiven neuronalen Netzen, nachdem der sechste Teil der Serie Convolutional Neural Networks vorgestellt hat.

Rekursive neuronale Netze sind für die Verarbeitung sequenzieller Daten ausgelegt, indem sie einen versteckten Zustand aufrechterhalten, der sich im Laufe der Zeit weiterentwickelt. Im Gegensatz zu Feedforward-Netzwerken, die davon ausgehen, dass jede Eingabe unabhängig von allen anderen ist, ermöglichen rekursive Netzwerke das Speichern von Informationen über Zeiträume hinweg. Bei jedem Schritt t empfängt eine rekurrente Zelle sowohl den neuen Eingabevektor xₜ als auch den vorherigen versteckten Zustand hₜ₋₁. Die Zelle berechnet einen neuen versteckten Zustand hₜ gemäß einer gelernten Transformation und erzeugt (optional) eine Ausgabe yₜ.

In ihrer einfachsten Form berechnet eine Vanilla-RNN-Zelle einen Präaktivierungsvektor zₜ als Summe einer Eingabetransformation und einer versteckten Zustandstransformation plus einer Verzerrung:

zₜ = Wₓ · xₜ + Wₕ · hₜ₋₁ + b

Der neue Zustand entsteht durch elementweise Anwendung einer nicht linearen Aktivierung σ:

hₜ = σ(zₜ)

Wenn bei jedem Zeitschritt eine Ausgabe yₜ erforderlich ist, kann eine Ausleseschicht hinzugefügt werden:

yₜ = V · hₜ + c

wobei V und c eine Ausgabegewichtungsmatrix und ein Bias-Vektor sind.

In PyTorch kapselt die Klasse torch.nn.RNN dieses Verhalten und verarbeitet das Stapeln mehrerer Schichten und Batches nahtlos. Das folgende Beispiel zeigt, wie man eine einlagige RNN-Zelle erstellt, ihr einen Stapel von Sequenzen zuführt und den endgültigen versteckten Zustand extrahiert:

import torch
import torch.nn as nn

# Angenommen, wir haben Sequenzen der Länge 100, jedes Element ist ein 20-dimensionaler Vektor,
# und wir verarbeiten sie in Batches der Größe 16.
seq_len, batch_size, input_size = 100, 16, 20
hidden_size = 50

# Erstellen Sie einen zufälligen Stapel von Eingabesequenzen: Form (seq_len, batch_size, input_size)
inputs = torch.randn(seq_len, batch_size, input_size)

# Instanziieren Sie ein einlagiges RNN mit tanh-Aktivierung (Standard)
rnn = nn.RNN(input_size=input_size,
             hidden_size=hidden_size,
             num_layers=1,
             nonlinearity='tanh',
             batch_first=False)

# Initialisiere den versteckten Zustand: Form (Anzahl_Schichten, Batchgröße, versteckte Größe)
h0 = torch.zeros(1, batch_size, hidden_size)

# Vorwärtspropagierung durch das RNN
outputs, hn = rnn(inputs, h0)

# `outputs` hat die Form (seq_len, batch_size, hidden_size)
# `hn` ist der versteckte Zustand beim letzten Zeitschritt, Form (1, batch_size, hidden_size)

Jede Zeile dieses Ausschnitts hat eine klare Aufgabe. Durch das Erstellen von Eingaben simuliert man ein Batch von Zeitreihendaten. Das RNN-Modul weist zwei Parametermatrizen zu: eine mit der Form (hidden_size, input_size) für Wₓ und eine mit der Form (hidden_size, hidden_size) für Wₕ sowie einen Bias-Vektor der Länge hidden_size. Beim Aufrufen des Moduls für Eingaben und den Anfangszustand h0 durchläuft es die 100 Zeitschritte und berechnet bei jedem Schritt die Rekursionsbeziehung. Der Ausgabetensor sammelt alle Zwischenzustände, während hn nur den letzten zurückgibt.

Obwohl Vanilla-RNNs konzeptionell einfach sind, haben sie Schwierigkeiten, langfristige Abhängigkeiten zu lernen, da über viele Zeitschritte zurückfließende Gradienten dazu neigen, zu verschwinden oder zu explodieren. Um das abzumildern, führen Gated Recurrent Units wie LSTM und GRU interne Gates ein, die steuern, wie stark die Eingabe und der vorherige Zustand den neuen Zustand beeinflussen sollen.

Die LSTM-Zelle (Long Short-Term Memory) verwaltet sowohl einen versteckten Zustand hₜ als auch einen Zellzustand cₜ. Sie verwendet drei Gates – Forget Gate fₜ, Input Gate iₜ und Output Gate oₜ –, die als Sigmoid-Aktivierungen berechnet werden, sowie eine Kandidaten-Zellaktualisierung ĉₜ, die sich mit einer Tanh-Aktivierung berechnen lässt. Konkret:

fₜ = σ( W_f · xₜ + U_f · hₜ₋₁ + b_f )

iₜ = σ( W_i · xₜ + U_i · hₜ₋₁ + b_i )

oₜ = σ( W_o · xₜ + U_o · hₜ₋₁ + b_o )

ĉₜ = tanh( W_c · xₜ + U_c · hₜ₋₁ + b_c )

Der Zellzustand wird dann durch Kombination des vorherigen Zellzustands und des Kandidaten aktualisiert, gewichtet durch die Vergessens- und Eingangsgatter:

cₜ = fₜ * cₜ₋₁ + iₜ * ĉₜ

Schließlich erstellt das System den neuen versteckten Zustand, indem es das Ausgangs-Gate auf die Nichtlinearität des Zellzustands anwendet:

hₜ = oₜ * tanh(cₜ)

PyTorchs torch.nn.LSTM kapselt all diese Berechnungen unter der Haube. Folgender Code zeigt ein Beispiel für eine Reihe von Sequenzen:

import torch
import torch.nn as nn

# Sequenzparameter wie zuvor
seq_len, batch_size, input_size = 100, 16, 20
hidden_size, num_layers = 50, 2

# Zufälliger Eingabebatch
inputs = torch.randn(seq_len, batch_size, input_size)

# Instanziieren eines zweischichtigen LSTM
lstm = nn.LSTM(input_size=input_size,
               hidden_size=hidden_size,
               num_layers=num_layers,
               batch_first=False)

# Initialisiere versteckte und Zellzustände: jeweils mit der Form (Anzahl_Schichten, Batchgröße, versteckte Größe)
h0 = torch.zeros(num_layers, batch_size, hidden_size)
c0 = torch.zeros(num_layers, batch_size, hidden_size)

# Vorwärtsdurchlauf durch das LSTM
outputs, (hn, cn) = lstm(inputs, (h0, c0))

# `outputs` hat die Form (seq_len, batch_size, hidden_size)
# `hn` und `cn` haben jeweils die Form (num_layers, batch_size, hidden_size)

Die Gated Recurrent Unit (GRU) vereinfacht das LSTM, indem sie die Vergessens- und Eingangsgatter zu einem einzigen Aktualisierungsgatter zₜ kombiniert und die Zell- und versteckten Zustände zusammenführt. Die Gleichungen lauten:

zₜ = σ( W_z · xₜ + U_z · hₜ₋₁ + b_z )

rₜ = σ( W_r · xₜ + U_r · hₜ₋₁ + b_r )

ħₜ = tanh( W · xₜ + U · ( rₜ * hₜ₋₁ ) + b )

hₜ = (1 − zₜ) * hₜ₋₁ + zₜ * ħₜ

In PyTorch bietet torch.nn.GRU diese Funktionalität mit derselben Schnittstelle wie nn.LSTM, außer dass nur die versteckten Zustände zurückgegeben werden.

Bei der Arbeit mit Sequenzen variabler Länge benötigt man häufig torch.nn.utils.rnn.pack_padded_sequence und pad_packed_sequence, um Sequenzen effizient im Batch zu verarbeiten, ohne Rechenleistung für das Auffüllen von Tokens zu verschwenden.

Rekursive Netzwerke eignen sich hervorragend für Aufgaben wie Sprachmodellierung, Zeitreihenprognosen und Sequenz-zu-Sequenz-Übersetzungen, wurden jedoch in vielen Anwendungsbereichen von aufmerksamkeitsbasierten Modellen übertroffen.

Zunächst widmet sich der nächste Teil dieser Serie jedoch der Kombination aus konvolutionalen und rekursiven Schichten, um Daten mit sowohl räumlicher als auch zeitlicher Struktur zu verarbeiten. Bei der Videoklassifizierung kann ein Convolutional Neural Network beispielsweise Merkmale auf Frame-Ebene extrahieren, die dann in ein LSTM eingespeist werden, um Bewegungsdynamiken zu erfassen.

(rme)

Version 1.1 der auf Event Sourcing spezialisierten Datenbank EventSourcingDB flexibilisiert die Konsistenzsteuerung und erhöht die Sicherheit mit digitalen Signaturen für Events. Event Sourcing ist ein Architekturverfahren, das alle Veränderungen des Zustands einer Anwendung als Sequenz von Events abbildet.

In der neuen Version der EventSourcingDB lassen Konsistenzgrenzen nicht nur über Aggregate festlegen, sondern auch flexibel über EventQL-Abfragen beschreiben. Mit diesen Dynamic Consistency Boundaries (DCBs) definieren Teams genau, wann strikte Konsistenz notwendig ist und wo Eventual Consistency konform zur offiziellen Spezifikation genügt. Dazu implementierte der Freiburger Hersteller the native web eine neue Precondition, die die Datenbank vor dem Schreiben von Events prüft.

Ebenfalls neu sind per Ed25519 signierte Events. Die Datenbank erzeugt die Signaturen on-the-fly, was Schlüsselwechsel ermöglicht, ohne bestehende Events anpassen zu müssen. Client-SDKs unterstützen die Verifikation inklusive Hash-Prüfung in Go und JavaScript, weitere Sprachen sollen folgen. Damit lassen sich Integrität und Authentizität von Events gegenüber Auditoren und Regulatoren zuverlässig nachweisen.

Im Detail gibt es weitere Verbesserungen: Der integrierte EventQL-Editor bietet Autovervollständigung für Event-Typen, neue sowie konsistentere API-Endpunkte erleichtern den Zugriff, und das Management-UI wurde leicht überarbeitet. Zahlreiche Optimierungen im Hintergrund sollen Stabilität und Entwicklerfreundlichkeit erhöhen.

Die EventSourcingDB steht als Docker-Image und als Binary für Linux, macOS und Windows bereit. Offizielle SDKs existieren für Go, JavaScript/TypeScript, .NET, PHP, Python, Rust und die JVM. Die Nutzung ist bis 25.000 Events pro Instanz kostenlos. Zudem startet der Anbieter eine gemanagte Version als private Beta. Sie richtet sich an Teams, die die Datenbank nutzen möchten, ohne selbst Infrastruktur betreiben zu müssen.

(who)