Zum Inhalt springen
LLM Engineering Course
Deutsch
Esc
↑↓navigieren↵öffnen⌘Jvorschau
Auf dieser Seite

F01 — Python und NumPy

← Diagnose & Lernpfad · F02 — Tensoren & Shapes → · Glossar

Lernziel

Du verwandelst eine kleine Datentransformation in ein getestetes NumPy-Programm und erklärst jeden erzeugten Wert. Dieser Block ist Pflicht, wenn die Diagnose Python und Entwicklung als Pflicht markiert hat.

Schreibst du schon Python, überfliege die Schritte vor „Bauen“; das Bauen dauert 45–60 Minuten. Ist Programmieren neu, plane etwa 60–90 Minuten für alles vor „Bauen“ (einschließlich des Testschritts) und weitere 60–120 Minuten für das Bauen ein, verteilt auf mehrere Sitzungen. Die Zeiten sind Orientierung, keine Frist.

Wenn dies dein erstes Python-Programm ist

Schließe zuerst die Einrichtung ab. Erstelle mit dem Dateimanager artifacts/my-work und darin eine reine Textdatei hello.py (nicht hello.py.txt). Schreibe diesen Python-Code hinein:

name = "tiny model"
print("Hello", name)

Starte im Terminal aus dem Kursordner python artifacts/my-work/hello.py. Erwartet: Hello tiny model. = weist einem Namen einen Wert zu; Text in Anführungszeichen ist ein String; print(...) gibt seine Argumente aus. # beginnt einen Kommentar. Fehler nennen Datei und Zeile: Behebe den ersten relevanten Fehler, bevor du weitergehst.

Listen, Positionen und Ausschnitte

Eine Idee nach der anderen. Jeder Block unten bittet dich, eine Sache vorherzusagen, bevor du ihn ausführst; der Kommentar in jeder Zeile ist die Antwort, also decke ihn zuerst ab. Sammle die Blöcke bis „Einer Berechnung einen Namen geben“ in einer Datei, artifacts/my-work/lists.py, jeden unter dem vorigen, und starte nach jedem python artifacts/my-work/lists.py.

tokens = ["a", "b", "c", "d"]
print(tokens[0])       # a: Python zählt Positionen ab null
print(tokens[1:3])     # ['b', 'c']: Start inklusive, Ende exklusiv
print(tokens[:-1])     # ['a', 'b', 'c']: letztes Element weglassen
print(tokens[1:])      # ['b', 'c', 'd']: erstes Element weglassen

Eckige Klammern erzeugen eine Liste oder wählen daraus aus. Eine einzelne Zahl wählt eine Position. Ein Doppelpunkt wählt einen Ausschnitt (Slice): Der Start ist enthalten, das Ende nicht, und -1 zählt vom Ende. Eine leere Seite heißt „vom Anfang“ oder „bis zum Ende“. Sage die vier ausgegebenen Zeilen voraus, dann führe die Datei aus.

Für jedes Element wiederholen

for token in tokens:
    print(token)

for wiederholt die eingerückten Zeilen einmal pro Element; token hält dabei das aktuelle. Der Block nutzt tokens aus dem ersten Block, der muss also darüber stehen. Sage voraus, wie viele Zeilen erscheinen, dann prüfe.

Zwei Listen paaren

zip geht zwei Listen nebeneinander durch und gibt dir je ein Element aus beiden:

pairs = list(zip(["a", "b", "c"], ["b", "c", "d"], strict=True))
print(pairs)   # [('a', 'b'), ('b', 'c'), ('c', 'd')]

list(...) sammelt die Paare, damit du sie ausgeben kannst. Jedes Paar steht in runden Klammern: ein Tupel, eine feste Folge, die sich nicht ändert. strict=True lässt zip mit einem Fehler abbrechen, wenn die Listen verschieden lang sind, statt übrige Elemente stillschweigend wegzulassen. Lege jetzt die zwei Ausschnitte von oben nebeneinander und zippe sie:

left = tokens[:-1]    # ['a', 'b', 'c']
right = tokens[1:]    # ['b', 'c', 'd']
print(list(zip(left, right, strict=True)))

Sage die Paare vorher. Jedes Paar ist ein Zeichen und das Zeichen, das darauf folgt — genau das, was ein Bigramm-Modell zählt. Du hast gerade die Idee hinter T01 in zwei Zeilen geschrieben.

Interaktiv · Ausschnitte und Paare

tokens = ["a", "b", "c", "d"]

Welche Positionen wählt ein Ausschnitt?

Die Liste aus der Lektion. Tippe einen Ausschnitt oder wähle einen, und sage voraus, welche Kästchen aufleuchten, bevor du hinsiehst.

  1. 'a'
  2. 'b'
  3. 'c'
  4. 'd'

Ausgewählt: ['b', 'c']

Einer Berechnung einen Namen geben

Eine Funktion gibt einer Berechnung einen Namen, damit du sie wiederverwenden kannst:

def next_item_pairs(sequence):
    if len(sequence) < 2:
        return []
    return list(zip(sequence[:-1], sequence[1:], strict=True))

def definiert die Funktion, sequence ist ihre Eingabe. return gibt ein Ergebnis zurück. if führt seinen eingerückten Zweig nur aus, wenn die Bedingung wahr ist; < vergleicht Zahlen. Sage voraus, was next_item_pairs(["a"]) zurückgibt, dann füge die Funktion und print(next_item_pairs(["a"])) in lists.py ein und führe es aus. Sage dann voraus: Wäre die Funktion für ["a"] und [] noch korrekt, wenn du die if-Zeile und das return [] darunter entfernst?

Antwort

Ja. Für ["a"] und für [] sind sequence[:-1] und sequence[1:] beide leer, also findet zip keine Paare, und die Funktion gibt ohnehin [] zurück. Das if macht die Regel für kurze Eingaben nur für Lesende sichtbar.

Prüfen

Speichere Funktion und Test zusammen als artifacts/my-work/test_pairs.py:

def next_item_pairs(sequence):
    if len(sequence) < 2:
        return []
    return list(zip(sequence[:-1], sequence[1:], strict=True))


def test_pairs():
    assert next_item_pairs(["a", "b", "c"]) == [("a", "b"), ("b", "c")]
    assert next_item_pairs([]) == []
    assert next_item_pairs(["a"]) == []

== prüft Gleichheit und ist keine Zuweisung. assert stoppt mit einem AssertionError, wenn seine Bedingung falsch ist, und tut nichts, wenn sie wahr ist. pytest führt jede Funktion aus, deren Name mit test_ beginnt, in Dateien, deren Name mit test_ beginnt. Starte python -m pytest artifacts/my-work/test_pairs.py; die letzte Zeile zeigt 1 passed, eingerahmt von =-Zeichen und gefolgt von der benötigten Zeit. Grün heißt, dass diese Assertions bestehen; es beweist nichts über ungeprüfte Eingaben.

Ändere ein erwartetes Paar und prüfe, dass die Assertion den Fehler wirklich findet — sage voraus, welche Zeile zuerst scheitert —, dann stelle es wieder her.

Zwei Dinge, die du im Kurscode sehen wirst, aber noch nicht brauchst: Typannotationen wie sequence: list[str] beschreiben den erwarteten Typ für Menschen und Werkzeuge, und Python erzwingt sie nicht; ein Docstring ist eine Erklärung in dreifachen Anführungszeichen direkt innerhalb einer Funktion.

NumPy-Begriffe vor der nächsten Aufgabe

import numpy as np lädt die Zahlenbibliothek unter dem Kurznamen np. Ein Array enthält Werte mit gemeinsamem Zahlentyp (dtype): Ganzzahlen für IDs, Gleitkommazahlen für Wahrscheinlichkeiten. shape zählt Elemente entlang jeder Achse. Bei [[1,4,2],[3,0,2]] bedeutet (2,3) zwei Zeilen mit drei Zahlen. np.all(condition) prüft, ob alle Elemente die Bedingung erfüllen. Eine Funktion kann mit raise ValueError("reason") ungültige Eingaben erklären, statt mit ihnen weiterzurechnen. Beginne mit dem Beispiel unten und baue dann den Validator.

Vorhersagen → Verfolgen → Bauen → Brechen → Messen → Erklären

Beginne mit benachbarten Paaren:

tokens = ["a", "b", "c", "d"]
pairs = list(zip(tokens[:-1], tokens[1:], strict=True))
assert pairs == [("a", "b"), ("b", "c"), ("c", "d")]

Sage die drei Paare vor dem Lauf voraus und verfolge beide Slices. Kapsle die Transformation anschließend in einer Funktion und teste leere, einteilige und normale Eingaben. Die Schleife besucht jedes Element höchstens einmal; Laufzeit und Ausgabespeicher wachsen linear mit der Eingabelänge.

NumPy macht numerische Verträge sichtbar

import numpy as np

token_ids = np.array([[1, 4, 2], [3, 0, 2]], dtype=np.int64)
assert token_ids.shape == (2, 3)
assert token_ids.dtype == np.int64
assert np.all(token_ids >= 0)

Der Shape beschreibt zwei Beispiele mit je drei Positionen. Speichere den Block als artifacts/my-work/contract.py und starte python artifacts/my-work/contract.py; es erscheint nichts, weil jede Assertion hält. Brich den Vertrag, indem du eine ID durch -1 ersetzt (zum Beispiel [[1, -1, 2], [3, 0, 2]]), sage voraus, welche Assertion scheitert, und starte erneut: Die np.all-Zeile löst einen AssertionError aus. Repariere dann die Daten, statt die Assertion zu entfernen.

Testen, dass falsche Eingaben abgelehnt werden

Beim Bauen sollen Fehlermeldungen den fehlerhaften Wert nennen, und Tests sollen belegen, dass falsche Eingaben abgelehnt werden. Dafür gibt es zwei Werkzeuge; nimm dir etwa 15 Minuten.

Ein f-String setzt Werte in Text ein. Speichere dies als artifacts/my-work/fstring.py und führe es aus:

token_id = -1
message = f"negative ID: {token_id}"
print(message)   # negative ID: -1

Das f vor dem öffnenden Anführungszeichen lässt Python jedes {...} durch den Wert des Namens darin ersetzen.

Normalerweise scheitert ein Test, wenn ein Fehler auftritt. Innerhalb von with pytest.raises(ValueError): gilt das Gegenteil: Der Test besteht nur, wenn der eingerückte Code einen ValueError auslöst. Speichere dies als artifacts/my-work/test_raises.py:

import pytest


def check_id(token_id):
    if token_id < 0:
        raise ValueError(f"negative ID: {token_id}")


def test_check_id_rejects_negative():
    with pytest.raises(ValueError) as error:
        check_id(-1)
    assert "-1" in str(error.value)

import pytest lädt die Testbibliothek. as error behält den abgefangenen Fehler, str(error.value) ist seine Meldung, und in prüft, dass "-1" darin vorkommt. Starte python -m pytest artifacts/my-work/test_raises.py; die letzte Zeile zeigt 1 passed. Ändere jetzt check_id(-1) in check_id(1), sage voraus, was pytest meldet, und starte dann. Erwartet: Failed: DID NOT RAISE <class 'ValueError'> — nichts wurde abgelehnt, also scheitert der Test. Stelle es wieder her.

Jeder Test für ungültige Eingaben beim Bauen hat dieselben vier Teile: falsche Eingabe, pytest.raises, der Aufruf und die Prüfung der Meldung.

def test_rejects_negative_ids():
    batch = np.array([[1, -1, 2]], dtype=np.int64)
    with pytest.raises(ValueError) as error:
        validate_token_batch(batch)
    assert "-1" in str(error.value)

Er braucht import numpy as np und import pytest oben in der Datei. Kopiere ihn einmal pro ungültigem Fall und ändere Namen, falsche Eingabe und den Text, den du in der Meldung erwartest. Zwei Tests mit demselben Namen meldet ruff als F811, und nur der letzte läuft.

Bauen

Arbeite in einer Datei, artifacts/my-work/test_f01.py: oben die Imports, dann deine Funktionen, dann die Tests, wie in test_pairs.py. Implementiere next_item_pairs(sequence) ohne Kurscode zu importieren. Ergänze Typangaben, einen kurzen Docstring und drei Tests: leer, ein Element, normal. Implementiere danach validate_token_batch(array), das bei nicht-ganzzahligen, negativen oder nicht-2D-Eingaben einen ValueError auslöst. Jede Fehlermeldung nennt den fehlerhaften Wert, und jede der drei Ablehnungen bekommt einen eigenen Test nach der Vorlage oben. Hängst du fest? Öffne unten den „Hinweis zum Validator“.

Abschlussnachweis

  • Tests decken leere, einteilige, normale und ungültige Eingaben ab;
  • die Ausgabe ist deterministisch;
  • du erklärst Slicing, Iteration, dtype und jede Assertion;
  • ruff check artifacts/my-work und python -m pytest artifacts/my-work bestehen. Nenne den Ordner: Ein bloßes ruff check . und pytest prüfen den Kurscode, nicht deinen.

Wie geht es weiter?

Weiter mit F02 — Tensoren und Shapes. Kehre zu F01 zurück, wenn Python-Ablauf, Tests, Exceptions oder NumPy-dtypes Verhalten verdecken.

← Diagnose · → F02

Hinweis zum Validator

Prüfe array.ndim != 2, np.issubdtype(array.dtype, np.integer) und np.any(array < 0). Das prüft getrennt Rang, Typ und Werte.

Referenzvalidator
import numpy as np


def validate_token_batch(array):
    if array.ndim != 2:
        raise ValueError(f"expected 2D, got shape {array.shape}")
    if not np.issubdtype(array.dtype, np.integer):
        raise ValueError(f"expected integer IDs, got {array.dtype}")
    if np.any(array < 0):
        raise ValueError(f"negative IDs: {array[array < 0].tolist()}")

← Diagnose & Lernpfad · F02 — Tensoren & Shapes → · Glossar

War diese Seite hilfreich?