Neuronale Netze sind der Motor vieler Anwendungen in Künstlicher Intelligenz (KI) und GenAI. Diese Artikelserie gibt einen Einblick in die einzelnen Elemente. Nach der Vorstellung der Neuronen im ersten Teil widmet sich der zweite Teil den Schichten des Netzwerks.

Wenn mehrere künstliche Neuronen so gruppiert sind, dass sie alle denselben Satz von Eingaben erhalten und ihre Ausgaben parallel erzeugen, bezeichnen wir diese Sammlung als Schicht. In einer einzelnen Schicht wendet jedes Neuron seinen eigenen Gewichtsvektor und seinen eigenen Bias-Term auf das eingehende Signal an, aber alle Neuronen teilen sich dieselbe Eingabe. Durch die Anordnung von Schichten in einer Reihenfolge erstellen wir ein Netzwerk, das einfache numerische Eingaben in beliebig reichhaltige Darstellungen umwandeln kann.

Mathematisch ausgedrückt: Wenn wir die Aktivierungen der Schicht ℓ−1 durch den Spaltenvektor aℓ−1 und die Gewichte der Schicht ℓ durch eine Matrix Wℓ bezeichnen, deren Zeilen die Gewichtsvektoren der einzelnen Neuronen sind, dann ergibt sich der Präaktivierungsvektor zℓ der Schicht ℓ aus dem Matrix-Vektor-Produkt:

zℓ = Wℓ · aℓ−1 + bℓ

Wobei bℓ der Bias-Vektor für die Schicht ℓ ist. Anschließend wenden wir eine elementweise nicht lineare Aktivierungsfunktion σ an, um die Ausgabe der Schicht zu erhalten:

aℓ = σ(zℓ)

Wenn wir einen Stapel von Eingaben einspeisen, stapeln wir einfach jede Eingabe als Spalte (oder Zeile, je nach Konvention) einer Matrix X und ersetzen die Vektoroperationen durch Matrixmultiplikationen auf dem Stapel, was zu einer hocheffizienten vektorisierten Berechnung führt.

Im Code lassen sich mit PyTorch auf einfache Weise Schichten und ihre Verbindungen ausdrücken. Die integrierte Klasse torch.nn.Linear kapselt sowohl die Gewichtsmatrix als auch den Bias-Vektor und verbindet sie für die automatische Differenziation mit dem Berechnungsgrafen. Nachfolgend finden Sie ein minimales Beispiel für ein kleines Feed-Forward-Netzwerk mit einer versteckten Schicht. Jede Zeile wird ausführlich erklärt.

import torch
import torch.nn as nn

class SimpleMLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(SimpleMLP, self).__init__()
        # Definieren Sie eine vollständig verbundene Schicht, die input_dim auf hidden_dim abbildet
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        
        # Wählen Sie eine nichtlineare Aktivierungsfunktion für die versteckte Schicht
        self.relu = nn.ReLU()
        # Definieren Sie eine zweite vollständig verbundene Schicht, die hidden_dim auf output_dim abbildet
        self.fc2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        # Wende die erste lineare Transformation an
        x = self.fc1(x)
        # Wende die nichtlineare Aktivierungsfunktion elementweise an
        x = self.relu(x)
        # Wende die zweite lineare Transformation an, um die Ausgabe zu erzeugen
        x = self.fc2(x)
        return x

Die Import-Anweisungen laden torch für Tensoroperationen und torch.nn als Namespace für Bausteine neuronaler Netze. Die Klasse SimpleMLP erbt von nn.Module, der Basisklasse von PyTorch für alle Komponenten neuronaler Netze. Der Aufruf von super(SimpleMLP, self).init()stellt sicher, dass die interne Maschinerie von Module ordnungsgemäß initialisiert wird.

Innerhalb des Konstruktors sind self.fc1 und self.fc2 Instanzen von nn.Linear. Jede Linearschicht weist eine Gewichtungsmatrix der Form (output_features, input_features) und einen Bias-Vektor der Länge output_features zu. Durch das Speichern dieser Schichten als Attribute des Moduls registriert PyTorch automatisch ihre Parameter, sodass wir beim Aufruf von model.parameters() alle Gewichtungs- und Bias-Tensoren in einem einzigen iterierbaren Objekt zurückgeben können.

Die Wahl von ReLU für self.relu spiegelt dessen weitverbreitete Verwendung wider: Die rektifizierte lineare Einheit gibt für jede negative Eingabe Null zurück und für jede nicht negative Eingabe die Eingabe selbst. Diese einfache, nicht lineare Operation führt die Nichtlinearität ein, die das Netzwerk benötigt, um komplexe Funktionen zu approximieren.

Die Vorwärtsmethode definiert die Transformation des Eingabetensors x, während er durch das Netzwerk fließt. Wenn x die Form (batch_size, input_dim) hat, hat er nach self.fc1(x) die Form (batch_size, hidden_dim) und behält nach Anwendung von ReLU die gleiche Form, wobei sich negative Werte auf Null abbilden. Der letzte Aufruf von self.fc2 erzeugt eine Ausgabe der Form (batch_size, output_dim). Durch die Rückgabe von x am Ende von forward ermöglichen wir es, das Netzwerk wie eine Funktion aufzurufen:

model = SimpleMLP(input_dim=10, hidden_dim=50, output_dim=1)
batch_of_inputs = torch.randn(32, 10)
outputs = model(batch_of_inputs)

In diesem Beispiel ist batch_of_inputs ein Tensor der Form (32, 10), der zweiunddreißig Samples mit jeweils zehn Merkmalen darstellt. Der Aufruf model(batch_of_inputs) ruft im Hintergrund forward auf, und outputs hat die Form (32, 1), sodass wir pro Sample eine Vorhersage erhalten.

Im Hintergrund erstellt PyTorch einen Berechnungsgraphen, der jede Operation – Matrixmultiplikationen, Additionen und Nichtlinearitäten – aufzeichnet, sodass bei der Berechnung eines Verlusts auf der Grundlage der Outputs und dem anschließenden Aufruf von loss.backward() sich die Gradienten aller Parameter in fc1 und fc2 automatisch berechnen lassen. Diese Gradienten lassen sich dann von Optimierern verwenden, um die Gewichtungsmatrizen und Bias-Vektoren zu aktualisieren.

Durch das Stapeln weiterer Schichten – beispielsweise durch mehrmaliges Abwechseln von linearen und Aktivierungsschichten – und durch Variieren der versteckten Dimensionen lassen sich tiefere und breitere Netzwerke erstellen, die hochkomplexe Zuordnungen lernen können.

Der nächste Teil der Serie zeigt, wie die gebatchten, vektorisierten Operationen den Vorwärtslauf in seiner Allgemeinheit bilden und wie die Wahl der Aktivierungen mit der Netzwerktiefe zusammenwirkt.

(rme)

Googles Audio Overviews sind ein Recherche-Werkzeug, bei dem Informationen als eine Art Podcast aufbereitet werden. Nun wird das um visuelle Inhalte erweitert. Die Video Overviews kommen zunächst als Präsentationen, in denen Bilder, Diagramme, Illustrationen und mehr enthalten sind. Google spricht von kommentierten Folien.

Zu nutzen ist Video Overviews wie auch die Audio Overviews via NotebookLM – das ist Google Notiz-App. Die KI ist quasi ein Gastgeber, der Inhalte für den Nutzer aufbereitet. Wahlweise macht er das, indem er Informationen zu einem vorgegebenen Thema als Podcast aufbereitet oder nun eben als Präsentation. Grundlage sind eigens ausgewählte Quellen. Diese legt man in einem Notizbuch an. Daraufhin kann man auswählen, was die KI damit machen soll. Neben Audio und Video Overviews gibt es etwa auch Mindmaps, einen Zeitstrahl und FAQs, die erstellt werden können.

Video Overviews als Lernhilfe

Obwohl der neue Modus Video Overviews heißt, gibt es noch keine KI-generierten Videos. Auf KI-Dokus zum Binge-Watchen muss man also noch eine Weile verzichten. Google verspricht jedoch, dass die Präsentationen nur ein erster Schritt seien.

Auch die Video Overviews lassen sich wie die Audio Overviews anpassen. Themen können konkretisiert, Lernziele festgehalten werden. Es gibt die Möglichkeit, eine Zielgruppe zu bestimmen. Dazu gehört auch, dass man den eigenen Wissensstand vorgeben kann und die Inhalte sowie Erklärungen an diesen angepasst werden. Somit dienen die Overviews in der Regel als Lernhilfe. Erstellte Overviews können mittels eines öffentlichen Links geteilt werden. Nun kann man unterschiedliche Berechtigungen festlegen, um gemeinsam an einem Notizbuch zu arbeiten.

Neu ist auch, dass man mehrere Outputs derselben Art innerhalb eines Notizbuchs anlegen kann. Zudem lassen sich Audio Overviews anhören, während man an einem Projekt arbeitet. Bisher ging das nicht gleichzeitig.

Zunächst sind die Video Overviews nur auf Englisch verfügbar, weitere Sprachen sollen bald folgen, schreibt Google im Blogbeitrag.

(emw)

Seit der Veröffentlichung der Samba-Version 4.19 kann man Microsofts Windows Server 2016 Functional Level auf Linux-Domain-Controllern einrichten. Dieser Level führt einige zusätzliche Sicherheitsmechanismen wie das FAST-Protokoll ein und ermöglicht zudem den Einsatz von Authentication Policies und Authentication Silos.

Beide Funktionen sorgen für eine größere Sicherheit bei der Authentifizierung. Aber erst in der im Frühjahr freigegebenen Version 4.22 hat sie das Samba-Team vollständig umgesetzt, sodass sich deren Möglichkeiten jetzt auch in einer Samba-Domäne nutzen lassen.

Das FAST-Protokoll (Flexible Authentication Secure Tunneling) ist auch als Kerberos Armoring bekannt. Es erweitert das Kerberos-Protokoll, indem es die Sicherheit des Kerberos-Authentication-Prozesses sowie die Abfrage von Servicetickets verbessert. Ohne FAST tauschen der Kerberos-Authentication-Prozess und der Service-Ticket-Request-Prozess ihre Nachrichten im Klartext aus.

Das war die Leseprobe unseres heise-Plus-Artikels „Samba: Mehr Sicherheit mit Authentication Silos“.
Mit einem heise-Plus-Abo können Sie den ganzen Artikel lesen.