Large Language Models selbst programmieren : Mit Python und PyTorch ein eigenes LLM entwickeln / Sebastian Raschka, Frank Langenau.

Format:

Book

Author/Creator:

Raschka, Sebastian, author.

Langenau, Frank, author.

Language:

German

Subjects (All):

Artificial intelligence.

Machine learning.

Physical Description:

1 online resource (400 pages)

Edition:

1st ed.

Place of Publication:

Heidelberg : dpunkt.verlag, 2025.

Summary:

LLMs selbst erstellen und von Grund auf verstehen! -Der Bestseller aus den USA jetzt in deutscher Übersetzung - der ideale Einstieg in das Thema Large Language Models Auf dem eigenen Laptop entwickeln, trainieren und tunen Sie ein LLM, das mit GPT-2 vergleichbar ist, und bekommen dadurch einen tiefen Einblick in die Funktionsweise von LLMs Bestsellerautor Sebastian Raschka erklärt die Grundlagen und die Vorgehensweise Schritt für Schritt und sehr gut verständlich Dieses Buch ist eine spannende Reise in die Blackbox der Generativen KI: Ohne auf bestehende LLM-Bibliotheken zurückzugreifen, programmieren Sie ein LLM-Basismodell, entwickeln es zu einem Textklassifikator weiter und erstellen schließlich einen Chatbot, den Sie als persönlichen KI-Assistenten verwenden können. Auf diese Weise eignen Sie sich aktiv und ganz praktisch grundlegendes Wissen zur aktuell wichtigsten KI-Technologie an - denn Sie haben Ihren Chatbot selbst gebaut! Sie lernen in diesem Buch, alle Bestandteile eines LLMs zu planen und zu programmieren. Sie bereiten einen Datensatz für das LLM-Training vor und optimieren das LLM mit Ihren eigenen Daten. Sie erfahren auch, wie Sie menschliches Feedback nutzen, um sicherzustellen, dass das LLM Ihren Anweisungen folgt, und wie Sie vortrainierte Gewichte in das LLM laden. Während Sie die einzelnen Phasen der LLM-Erstellung durchlaufen, entwickeln Sie eine klarere Vorstellung davon, wie LLMs unter der Haube funktionieren.

Contents:

Cover

Hinweise zur Benutzung

Titel

Impressum

Inhalt

Vorwort

Über dieses Buch

1 LLMs verstehen

1.1 Was ist ein LLM?

1.2 Anwendungen von LLMs

1.3 Phasen beim Erstellen und Verwenden von LLMs

1.4 Einführung in die Transformer-Architektur

1.5 Große Datensätze nutzen

1.6 Die GPT-Architektur unter der Lupe

1.7 Ein großes Sprachmodell aufbauen

1.8 Zusammenfassung

2 Mit Textdaten arbeiten

2.1 Wort-Embeddings

2.2 Text tokenisieren

2.3 Tokens in Token-IDs konvertieren

2.4 Spezielle Kontexttokens hinzufügen

2.5 Bytepaar-Codierung

2.6 Daten-Sampling mit einem gleitenden Fenster

2.7 Token-Embeddings erzeugen

2.8 Wortpositionen codieren

2.9 Zusammenfassung

3 Attention-Mechanismen programmieren

3.1 Das Problem beim Modellieren langer Sequenzen

3.2 Datenabhängigkeiten mit Attention-Mechanismen erfassen

3.3 Verschiedene Teile der Eingabe mit Self-Attention berücksichtigen

3.3.1 Ein einfacher Self-Attention-Mechanismus ohne trainierbare Gewichte

3.3.2 Attention-Gewichte für alle Eingabetokens berechnen

3.4 Self-Attention mit trainierbaren Gewichten implementieren

3.4.1 Attention-Gewichte Schritt für Schritt berechnen

3.4.2 Eine kompakte Python-Klasse für Self-Attention implementieren

3.5 Zukünftige Wörter mit kausaler Attention ausblenden

3.5.1 Eine kausale Attention-Maske anwenden

3.5.2 Zusätzliche Attention-Gewichte mit Dropout maskieren

3.5.3 Eine kompakte Klasse für kausale Attention implementieren

3.6 Single-Head-Attention zur Multi-Head-Attention erweitern

3.6.1 Mehrere Single-Head-Attention-Schichten stapeln

3.6.2 Multi-Head-Attention mit Gewichtsteilungen implementieren

3.7 Zusammenfassung

4 Ein GPT-Modell von Grund auf neu erstellen, um Text zu generieren

4.1 Eine LLM-Architektur programmieren.

4.2 Aktivierungen mit Schichtnormalisierung normalisieren

4.3 Ein Feedforward-Netz mit GELU-Aktivierungen implementieren

4.4 Shortcut-Verbindungen hinzufügen

4.5 Attention und lineare Schichten in einem Transformer-Block verbinden

4.6 Das GPT-Modell programmieren

4.7 Text generieren

4.8 Zusammenfassung

5 Vortraining mit ungelabelten Daten

5.1 Generative Textmodelle bewerten

5.1.1 Text mithilfe von GPT erzeugen

5.1.2 Den Texterzeugungsverlust berechnen

5.1.3 Die Verluste der Trainings- und Validierungsdatensätze berechnen

5.2 Ein LLM trainieren

5.3 Decodierungsstrategien, um Zufälligkeit zu steuern

5.3.1 Temperaturskalierung

5.3.2 Top-k-Sampling

5.3.3 Die Funktion zur Textgenerierung modifizieren

5.4 Modellgewichte in PyTorch laden und speichern

5.5 Vortrainierte Gewichte von OpenAI laden

5.6 Zusammenfassung

6 Feintuning zur Klassifizierung

6.1 Verschiedene Kategorien des Feintunings

6.2 Den Datensatz vorbereiten

6.3 DataLoader erstellen

6.4 Ein Modell mit vortrainierten Gewichten initialisieren

6.5 Einen Klassifizierungskopf hinzufügen

6.6 Klassifizierungsverlust und -genauigkeit berechnen

6.7 Das Modell mit überwachten Daten feintunen

6.8 Das LLM als Spam-Klassifizierer verwenden

6.9 Zusammenfassung

7 Feintuning, um Anweisungen zu befolgen

7.1 Einführung in die Anweisungsoptimierung

7.2 Einen Datensatz für die Anweisungsoptimierung vorbereiten

7.3 Daten in Trainingsstapeln organisieren

7.4 DataLoader für einen Anweisungsdatensatz erstellen

7.5 Ein vortrainiertes LLM laden

7.6 Das LLM mit Anweisungsdaten feintunen

7.7 Antworten extrahieren und speichern

7.8 Das feingetunte LLM bewerten

7.9 Fazit

7.9.1 Was kommt als Nächstes?

7.9.2 In einem sich schnell entwickelnden Bereich auf dem neuesten Stand bleiben.

7.9.3 Ein paar Worte zum Schluss

7.10 Zusammenfassung

A Einführung in PyTorch

A.1 Was ist PyTorch?

A.1.1 Die drei Kernkomponenten von PyTorch

A.1.2 Deep Learning definieren

A.1.3 PyTorch installieren

A.2 Tensoren

A.2.1 Skalare, Vektoren, Matrizen und Tensoren

A.2.2 Tensor-Datentypen

A.2.3 Allgemeine PyTorch-Tensor-Operationen

A.3 Modelle als Berechnungsgraphen sehen

A.4 Automatisches Differenzieren leicht gemacht

A.4.1 Partielle Ableitungen und Gradienten

A.5 Mehrschichtige neuronale Netze implementieren

A.6 Effiziente DataLoader einrichten

A.7 Eine typische Trainingsschleife

A.8 Modelle speichern und laden

A.9 Die Trainingsperformance mit GPUs optimieren

A.9.1 PyTorch-Berechnungen auf GPU-Geräten

A.9.2 Training auf einer einzelnen GPU

A.9.3 Training mit mehreren GPUs

A.10 Zusammenfassung

B Referenzen und weiterführende Literatur

C Lösungen zu den Übungen

D Die Trainingsschleife mit allem Drum und Dran

D.1 Aufwärmen der Lernrate

D.2 Cosinus-Decay

D.3 Gradienten-Clipping

D.4 Die modifizierte Trainingsfunktion

E Parametereffizientes Feintuning mit LoRA

E.1 Einführung in LoRA

E.2 Den Datensatz vorbereiten

E.3 Das Modell initialisieren

E.4 Parametereffizientes Feintuning mit LoRA

Fußnoten

Index

Über den Autor.

Notes:

Description based on publisher supplied metadata and other sources.

ISBN:

3-9889026-6-7

3-9889026-5-9

9783988902658

OCLC:

1525257737