Connect with us

Entwicklung & Code

Künstliche Neuronale Netze im Überblick 4: Verlustfunktionen


Neuronale Netze sind der Motor vieler Anwendungen in KI und GenAI. Diese Artikelserie gibt einen Einblick in die einzelnen Elemente. Der vierte Teil der Serie stellt die gängigsten Verlustfunktionen vor, leitet ihre Gradienten ab und zeigt dann, wie man die grundlegende Gradientenabstiegs-Aktualisierungsregel und ihre komplexeren Varianten entwickelt.


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.

Um einem neuronalen Netzwerk nützliche Aufgaben beizubringen, müssen wir quantifizieren, wie gut seine Vorhersagen mit den Zielwerten übereinstimmen. Eine Verlustfunktion ist ein skalares Maß für den Fehler, den der Trainingsprozess durch Anpassung der Netzwerkparameter minimieren soll.

Mittlerer quadratischer Fehler für Regression

Wenn die Aufgabe des Netzwerks darin besteht, kontinuierliche Größen vorherzusagen, ist der mittlere quadratische Fehler eine naheliegende Wahl. Angenommen, wir haben einen Datensatz mit N Beispielen, wobei jedes Beispiel i einen Zielwert yᵢ hat und das Netzwerk eine Vorhersage ŷᵢ liefert. Der mittlere quadratische Fehler L ist definiert durch

L(ŷ, y) = (1/N) Σᵢ (ŷᵢ − yᵢ)²

Dieser Ausdruck summiert die quadrierten Differenzen zwischen Vorhersage und Zielwert über alle Beispiele und dividiert sie durch N, um einen Durchschnitt zu erhalten. Durch die Quadrierung des Fehlers werden große Abweichungen stärker bestraft als kleine, und durch den Durchschnitt wird der Verlust unabhängig von der Größe des Datensatzes.

Um zu sehen, wie dieser Verlust die Parameteraktualisierungen beeinflusst, berechnen wir seine Ableitung in Bezug auf eine einzelne Vorhersage ŷⱼ:

∂L/∂ŷⱼ = (2/N) (ŷⱼ − yⱼ)

Während der Rückpropagation wird dieser Gradient durch das Netzwerk weitergeleitet und steuert jede Gewichtsaktualisierung in Richtung einer Verringerung des quadratischen Fehlers.

In PyTorch schreibt man:


import torch
import torch.nn as nn

# Angenommen, `model` ordnet Eingaben den Vorhersagen ŷ der Form (batch_size, 1) zu
loss_fn = nn.MSELoss()  # erstellt ein Modul für den mittleren quadratischen Fehler
predictions = model(inputs)  # Vorwärtsdurchlauf erzeugt ŷ
loss = loss_fn(predictions, targets)


Hier kapselt nn.MSELoss() die obige Formel. Wenn wir später loss.backward() aufrufen, berechnet PyTorch ∂L/∂parameters automatisch, indem es die partiellen Ableitungen durch den Berechnungsgraphen verkettet.

Kreuzentropie für die Klassifizierung

Wenn die Aufgabe die Klassifizierung in eine von C Klassen ist, gibt das Netzwerk typischerweise einen Vektor von Logits z ∈ ℝᶜ für jedes Beispiel aus. Um diese Logits in eine Wahrscheinlichkeitsverteilung p umzuwandeln, wenden wir die Softmax-Funktion an:

softmax(z)ᵢ = exp(zᵢ) / Σⱼ exp(zⱼ)

Wenn die wahre Klassenbezeichnung für Beispiel i als One-Hot-Vektor y codiert ist, wobei yᵢ = 1 und yⱼ = 0 für j ≠ i, dann ist der Kreuzentropieverlust

L(z, y) = − Σᵢ yᵢ · log( softmax(z)ᵢ )

Da nur ein Eintrag von y ungleich Null ist, vereinfacht sich dies zu der negativen Log-Wahrscheinlichkeit, die der richtigen Klasse zugewiesen wird. Bei Verwendung von PyTorch’s nn.CrossEntropyLoss fusioniert die Implementierung die Softmax- und Log-Schritte auf numerisch stabile Weise und erwartet rohe Logits und ganzzahlige Klassenindizes:


import torch.nn as nn

loss_fn = nn.CrossEntropyLoss() # erstellt einen kombinierten Log-Softmax + NLL-Verlust
logits = model(inputs) # Form (batch_size, num_classes)
loss = loss_fn(logits, class_indices)


Im Hintergrund ist der Gradient von L in Bezug auf jedes Logit zₖ

∂L/∂zₖ = softmax(z)ₖ − yₖ,

was genau der Differenz zwischen der vorhergesagten Wahrscheinlichkeit und der tatsächlichen Beschriftung für jede Klasse entspricht.

Grundlegender Gradientenabstieg

Sobald ein Verlust festgelegt wurde, ist die einfachste Regel zur Parameteraktualisierung der Gradientenabstieg. Bezeichnen wir mit θ einen einzelnen Skalarparameter (einen Eintrag einer Gewichtungsmatrix oder eines Bias-Vektors) und mit L(θ) den Verlust als Funktion von θ. Die Gradientenabstiegsregel aktualisiert θ in Richtung des steilsten Abstiegs:

θ ← θ − η · ∂L/∂θ

Hier ist η > 0 die Lernrate, ein Hyperparameter, der die Schrittgröße steuert. Ein kleiner η-Wert führt zu einer langsamen, aber stabilen Konvergenz, während ein großer η-Wert dazu führen kann, dass der Verlust schwankt oder divergiert.

In der Praxis unterscheidet man drei Varianten: Wenn der Gradient vor jeder Aktualisierung über den gesamten Datensatz berechnet wird, spricht man von Batch-Gradientenabstieg; wenn für jede Aktualisierung nur ein einziges Beispiel verwendet wird, spricht man von stochastischem Gradientenabstieg; und wenn kleine Teilmengen von Beispielen (Mini-Batches) verwendet werden, spricht man von Mini-Batch-Gradientenabstieg. Mini-Batch-Aktualisierungen stellen einen Kompromiss zwischen verrauschten, aber schnellen stochastischen Aktualisierungen und stabilen, aber kostspieligen Batch-Aktualisierungen dar.

PyTorch bietet über das Paket torch.optim eine einfache Möglichkeit, Gradientenabstieg mit Mini-Batches durchzuführen. Um beispielsweise den einfachen stochastischen Gradientenabstieg mit Momentum zu verwenden, schreibt man:


import torch.optim as optim

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
# für Eingaben, Ziele in data_loader: data_loader liefert Mini-Batches
optimizer.zero_grad()  # alle akkumulierten Gradienten löschen
outputs = model(inputs)  # Vorwärtsdurchlauf
loss = loss_fn(outputs, targets)  # Verlust berechnen
loss.backward()  # Rückwärtspropagierung zur Berechnung der Gradienten
optimizer.step()  # Parameter an Ort und Stelle aktualisieren


Der Aufruf von optimizer.zero_grad() löscht die Gradientenpuffer aller Parameter, sodass sich Gradienten aus früheren Iterationen nicht ansammeln. Der Aufruf von loss.backward() füllt das Attribut .grad jedes Parameters mit dem berechneten ∂L/∂θ, und optimizer.step() verwendet diese Gradienten, um die Parameter gemäß der gewählten Aktualisierungsregel zu aktualisieren.

Fortgeschrittene Optimierer: RMSProp und Adam

Während einfaches Momentum die Konvergenz in Tälern der Verlustfunktion beschleunigen kann, passen adaptive Methoden die Lernrate jedes Parameters individuell auf der Grundlage der Historie seiner Gradienten an. RMSProp behält einen exponentiell gewichteten gleitenden Durchschnitt der vergangenen quadrierten Gradienten bei:

sₜ = γ·sₜ₋₁ + (1−γ)·gₜ²

θ ← θ − (η / sqrt(sₜ + ε)) · gₜ

wobei gₜ = ∂L/∂θ zum Zeitpunkt t, γ typischerweise um 0,9 liegt und ε eine kleine Konstante für die numerische Stabilität ist. In PyTorch wird dies wie folgt konstruiert:

optimizer = optim.RMSprop(model.parameters(), lr=0.001, alpha=0.99, eps=1e-8)

Adam kombiniert Momentum und RMSProp, indem es sowohl einen gleitenden Durchschnitt der Gradienten mₜ als auch der quadrierten Gradienten vₜ beibehält und eine Bias-Korrektur anwendet:

mₜ = β₁·mₜ₋₁ + (1−β₁)·gₜ

vₜ = β₂·vₜ₋₁ + (1−β₂)·gₜ²

m̂ₜ = mₜ / (1−β₁ᵗ)

v̂ₜ = vₜ / (1−β₂ᵗ)

θ ← θ − η · ( m̂ₜ / ( sqrt(v̂ₜ) + ε ) )

mit den Standardwerten β₁=0,9, β₂=0,999 und ε=1e-8.

Im Code:

optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999), eps=1e-8)

Jeder dieser Optimierer erfordert die Abstimmung seiner Hyperparameter – Lernrate, Abklingraten und Epsilon –, um die beste Leistung für ein bestimmtes Problem zu erzielen.

Der nächste Teil der Serie zeigt, wie diese Komponenten zu einer vollständigen Trainingsschleife zusammengesetzt werden. Anschließend untersucht er die Unterschiede zwischen dem Training mit und ohne explizite Minibatches und stellt Techniken wie Dropout und Gewichtsabnahme zur Verbesserung der Generalisierung vor.


(rme)



Source link

Verwandte Themen:
Weiterlesen

Entwicklung & Code

DeepSeek senkt API-Preise um 50 Prozent und stellt V3.2-Exp vor


Das chinesische KI-Start-up DeepSeek hat mit V3.2-Exp eine experimentelle Version seines Sprachmodells veröffentlicht und gleichzeitig die Preise für seine API-Dienste um mehr als 50 Prozent gesenkt. Wie das Unternehmen auf seiner Hugging-Face-Seite mitteilte, markiert die neue Version einen Zwischenschritt zur nächsten Generation der KI-Architektur.

Das erst im Jahr 2023 gegründete Unternehmen, das Anfang des Jahres mit seinem R1-Modell für Aufsehen im Silicon Valley gesorgt hatte, arbeitet nach eigenen Angaben mit chinesischen Chipherstellern an der Weiterentwicklung seiner Modelle. Die neue Version V3.2-Exp baut auf dem älteren V3.1-Modell auf und führt eine neue Technik namens DeepSeek Sparse Attention (DSA) ein.

Die Sparse-Attention-Technologie soll die Effizienz bei der Verarbeitung langer Textsequenzen verbessern. Während herkömmliche Attention-Mechanismen bei großen Sprachmodellen alle Tokens gleichzeitig berücksichtigen, konzentriert sich DSA nur auf die relevantesten Bereiche des Inputs. Dies reduziert den Rechenaufwand laut DeepSeek erheblich, ohne die Qualität der Ausgabe wesentlich zu beeinträchtigen.

Parallel zur Modellveröffentlichung kündigte DeepSeek eine drastische Preissenkung für seine API-Dienste um mehr als 50 Prozent an. Die neuen Tarife gelten sofort und sollen dem Unternehmen helfen, mehr Nutzer zu gewinnen. Zum Vergleich bleibt das bisherige V3.1-Terminus-Modell bis zum 15. Oktober 2025 über eine temporäre API verfügbar.

Unterstützung durch Huawei und neue Datenformate

Huawei, der führende Anbieter von KI-Chips in China, kündigte an, dass seine Produkte das neueste DeepSeek-Modell unterstützen werden.

DeepSeek hat außerdem angegeben, dass die neuesten Versionen seiner Modelle mit simplen 8-Bit-Gleitkommawerten (Floating Point 8, FP8) umgehen kann, während an der Implementierung von BF16 (Brain Floating Point 16) gearbeitet wird. FP8 ermöglicht theoretisch Speichereinsparungen und schnellere Berechnungen, da es weniger Speicherplatz benötigt und die Matrizen vergleichsweise simpel sind. Obwohl FP8 weniger präzise ist als klassische Formate wie FP32, gilt es für KI-Anwendungen als ausreichend genau.

BF16 hingegen stellt einen Kompromiss zwischen Geschwindigkeit und Präzision dar. Die Unterstützung beider Formate soll es ermöglichen, große Modelle auch auf Hardware mit begrenzten Ressourcen zu betreiben.

API-Preise um 50 Prozent gesenkt

Mit der Preissenkung um mehr als 50 Prozent positioniert sich DeepSeek aggressiv im umkämpften KI-API-Markt. Das Unternehmen reiht sich damit in eine Reihe chinesischer Start-ups ein, die durch niedrige Preise Marktanteile gewinnen wollen. Input-Token kosten bei DeepSeek künftig 0,28 US-Dollar pro Million Token statt bislang 0,56 US-Dollar. Mit Cache sinkt der Preis sogar auf 0,028 US-Dollar. Eine Million Output-Token kosten 0,42 US-Dollar. Vorbehalte gegenüber chinesischen Modellen gibt es beim Datenschutz und der staatlichen Zensur Chinas.


(mki)



Source link

Weiterlesen

Entwicklung & Code

PHP 8.5 setzt auf Lesbarkeit, Debugging-Features und mehr Sicherheit


Am 20. November 2025 soll PHP 8.5 offiziell erscheinen – jetzt liegt der erste Release Candidate vor. Die kommende Version konzentriert sich auf Verbesserungen bei der Lesbarkeit von Code, neuen Utility-Funktionen, erweiterten Debugging-Möglichkeiten sowie Detailverbesserungen in der Performance und Sicherheit.

Der Pipe-Operator bringt funktionale Muster

PHP 8.5 führt den neuen Pipe-Operator |> ein. Entwicklerinnen und Entwickler können damit Funktionsaufrufe linear verketten, anstatt verschachtelte Strukturen zu schreiben. Das Beispiel aus dem RFC soll dies verdeutlichen:


function getUsers(): array {
    return [
        new User('root', isAdmin: true),
        new User('john.doe', isAdmin: false),
    ];
}
 
function isAdmin(User $user): bool {
    return $user->isAdmin;
}
 
// This is the new syntax.
$numberOfAdmins = getUsers()
    |> (fn ($list) => array_filter($list, isAdmin(...))) 
    |> count(...);
 
var_dump($numberOfAdmins); // int(1);


Neue Array-Helferfunktionen

Mit array_first() und array_last() holen Developer den ersten oder letzten Wert eines Arrays, ohne den Array-Pointer zu verändern (siehe RFC):


function array_first(array $array): mixed {}
function array_last(array $array): mixed {}


Verbesserungen bei Fehlerbehandlung und Debugging

Die neuen Funktionen get_error_handler() und get_exception_handler() geben direkten Einblick in die aktiven Handler. PHP liefert außerdem bei fatalen Fehlern nun vollständige Stack-Traces und blendet sensible Parameter automatisch aus, wenn sie mit #[\SensitiveParameter] markiert sind.

Weniger Boilerplate mit Final Property Promotion

PHP 8.5 erlaubt es, im Rahmen der Constructor Property Promotion direkt Final Properties zu deklarieren (siehe RFC). Entwickler sparen damit Boilerplate-Code und definieren finale Properties genauso wie normale Properties im Constructor.

Neue Attribute und statische Closures

Das Attribut #[\NoDiscard] warnt, wenn wichtige Rückgabewerte ungenutzt bleiben. Zudem unterstützt PHP jetzt statische Closures in Konstanten, Default-Parametern und Attributen.

Internationalisierung und neue Werkzeuge

Die Funktion locale_is_right_to_left() erkennt Sprachen, die von rechts nach links gelesen werden. curl_multi_get_handles() vereinfacht das Management von cURL-Multi-Handles. Mit der Konstante PHP_BUILD_DATE und dem CLI-Befehl php --ini=diff will das Entwicklerteam hinter der Programmiersprache Debugging und Auditing vereinfachen.

Release nach Plan

iX sprach mit Volker Dusch, Release Manager zu PHP 8.5, der bestätigte: „Die Timeline ist eingehalten, alle Feature-RFCs sind eingebaut und wie immer gut getestet.“ Bei einer von 46 Deprecations habe es Anpassungsbedarf für das PHP-Framework Symfony gegeben, wofür ein Follow-up-RFC erstellt worden sei – ein normaler Vorgang. Substanzielle Änderungen habe es seit den Betas nicht mehr gegeben. „Es gibt keine signifikanten Breaking Changes. Deprecations sind lediglich Hinweise auf künftige Anpassungen,“ so Dusch.


betterCode() PHP am 25. November 2025

betterCode() PHP am 25. November 2025

(Bild: nuevoimg / 123rf.com)

Am 25. November findet die betterCode() PHP statt, eine Online-Konferenz von iX und dpunkt.verlag in Kooperation mit thePHP.cc. Interessierte können sich in Vorträgen und Diskussionsrunden über die Programmiersprache informieren. Vergünstigte Tickets zum Early-Bird-Tarif sind über die Konferenz-Website erhältlich.

PHP 8.5 bringt keine Revolution, aber viele durchdachte Verbesserungen. Von schlankerem Code mit dem Pipe-Operator, über sicherere Fehlerbehandlung bis hin zu neuen Debugging-Werkzeugen richtet sich der Fokus klar auf die Developer Experience. Weitere Informationen zum Release finden sich auf GitHub oder auf php.net.


(mdo)



Source link

Weiterlesen

Entwicklung & Code

Postgres 18: Dreimal schnellere asynchrone Abfragen und virtuelle Spalten


Die neue Version von Postgres 18 bringt eine Reihe von Verbesserungen der Performance und neue Funktionen wie den Zugriff auf alte Werte bei INSERT oder virtuelle Spalten für Abfragen. Für die sichere Authentifizierung bietet die Datenbank OAuth 2 und für das Passwort-Hashing wird SHA-256 verpflichtend.

Die wichtigste Neuerung für beschleunigte Abfragen ist das asynchrone IO-Subsystem (AIO), das „bis zu dreifache Performance-Verbesserungen beim Lesen aus dem Speicher bewiesen hat“, heißt es in der Ankündigung. AIO beschleunigt Read-ahead-Prozesse, für die die Datenbank entsprechende Mechanismen des jeweiligen Betriebssystems nutzt. Diese Mechanismen kennen nicht alle Spezifika einer Datenbank und können oft nicht richtig vorhersagen, welche Daten demnächst benötigt werden. AIO stellt nun mehrere parallele asynchrone Anfragen und beschleunigt so Read-ahead-Abfragen. AIO-Operationen umfassen sequenzielle und Bitmap-Heap-Scans sowie den VACUUM-Befehl.

Anwenderinnen und Anwender können in den Einstellungen für io_method zwischen AIO und dem alten synchronen System umschalten. Weitere Geschwindigkeitsgewinne ergeben sich durch Skip-Scan-Suchen bei mehrspaltigen B-tree-Indizes sowie durch eine verbesserte Ausführung von table joins und hash joins. Hardware-Beschleunigung gibt es nun für ARM NEON und SVE CPU.

Lesen Sie auch

Die automatischen Statistiken gehen ab Postgres 18 auch bei großen Updates nicht verloren, sodass die durch die Statistik aufgebauten Systemerkenntnisse erhalten bleiben. Das garantiert verbesserte Leistungswerte über ein Update hinaus.

Virtuelle Spalten und Zugriff auf alte Werte

Entwicklerinnen und Entwickler legen mit Postgres 18 nun virtuelle Spalten an, die Abfragen verarbeiten, ohne dass die Datenbank diese speichert. Das ist künftig die Standardoption. Auch gespeichert erzeugte Tabellen können Anwender künftig logisch replizieren.

Erfreuen wird viele Developer, dass sie bei den Befehlen INSERT, UPDATE, DELETE und MERGE nun auch Zugriff auf alte (OLD) Werte haben und nicht nur und neuen (NEW). Außerdem können sie zufällige UUIDs mit uuidv7() einsetzen, die sich über Zeitstempel sortieren und besseres Caching erlauben.

Ferner lassen sich entfernte Tabellen auf der Basis von lokalen Schemata einfach mit dem Befehl CREATE FOREIGN TABLE ... LIKE erzeugen.

Mehr Sicherheit mit OAuth 2 und SHA-2

Für die Authentifizierung von Anwendern unterstützt Postgres 18 OAuth 2. Weitere Sicherheitsfunktionen sind eine SSL-Validierung mit FIPS und ein Parameter ssl_tls13_ciphers für TLS 1.3. Außerdem ist MD 5 für das Passwort-Hashing veraltet und wird demnächst deaktiviert. Postgres erfordert jetzt SCRAM-SHA-256

Details und weitere Neuerungen finden sich in der Ankündigung und den Release Notes.


(who)



Source link

Weiterlesen

Beliebt