Eine KI selbst bauen – wo fangen wir an?
Ein Sprachmodell bekommt einen Text und setzt ihn fort. Wie kommt es zu seiner nächsten Ausgabe? Welche Zahlen laufen dabei durch das Modell? Und woher kommen diese Zahlen überhaupt?
In dieser Reihe bauen wir Schritt für Schritt ein kleines Programm, das Text fortsetzen kann. Dafür fangen wir bei einem einzelnen künstlichen Neuron an und arbeiten uns bis zu einem winzigen Sprachmodell vor. Wir rechnen Beispiele von Hand nach, zeichnen die Datenwege auf und führen die Programme selbst aus.
Das Ziel ist ein lokal trainiertes Lehrmodell. Es soll zeigen, wie die Bausteine zusammenarbeiten. Es wird kein Chatbot mit den Fähigkeiten großer Sprachmodelle. Seine Ausgabe hängt stark von den wenigen Texten ab, mit denen wir es trainieren. Eine schnelle Grafikkarte ist für den geplanten Einstieg nicht erforderlich. Welcher Zeit- und Speicherbedarf beim späteren Training tatsächlich entsteht, müssen wir noch messen.
Heute richten wir die Arbeitsumgebung ein und bauen zuerst etwas anderes: ein Programm mit einer festen Regel. An ihm lässt sich erkennen, was beim maschinellen Lernen anders läuft.
Was bedeutet künstliche Intelligenz?
Künstliche Intelligenz, kurz KI, bezeichnet ein breites Gebiet der Informatik. Dazu gehören unterschiedliche Ansätze für Aufgaben, die wir beispielsweise mit Wahrnehmung, Schlussfolgern oder der Verarbeitung von Sprache verbinden. Eine einzige allgemein verwendete technische Bauanleitung für „die KI“ gibt es nicht. Auch die OECD beschreibt KI-Systeme über ihre Fähigkeiten und Ausgaben, nicht über eine bestimmte Netzarchitektur.
Ein Teilgebiet ist das maschinelle Lernen. Dabei wird aus Daten ein Modell erstellt oder angepasst. Ein neuronales Netz ist eine mögliche Art eines solchen Modells. Unser späteres Sprachmodell wird auf einem neuronalen Netz beruhen.
Künstliche Intelligenz
├── weitere Ansätze, z. B. regelbasierte Expertensysteme
└── maschinelles Lernen
├── weitere Modelle, z. B. Entscheidungsbäume
└── neuronale Netze
└── unser geplantes kleines Sprachmodell
Künstliche Intelligenz
├── weitere Ansätze, z. B. regelbasierte Expertensysteme
└── maschinelles Lernen
├── weitere Modelle, z. B. Entscheidungsbäume
└── neuronale Netze
└── unser geplantes kleines Sprachmodell
Die Darstellung ist eine Orientierung, keine scharfe Grenze für jedes denkbare System. Ein System kann Regeln und gelernte Modelle kombinieren. Und nicht jedes Programm mit einer if-Abfrage wird deshalb zu einem KI-System.
Erst die Umgebung: Linux und Python
Als gemeinsame Referenz dient eine Linux-Mint-VM. Die Anleitung für Linux Mint in VirtualBox beschreibt die Einrichtung. Ein bestehendes Linux-System eignet sich grundsätzlich ebenfalls, die Befehle und Paketnamen können dort aber abweichen.
Praxistest: Der Ablauf dieses Artikels wurde in einer Linux-VM nachvollzogen und bestätigt. Die nachträglich ergänzte optionale Automatisierung mit direnv ist darin noch nicht enthalten. Der Ressourcenbedarf für das spätere Training steht noch nicht fest.
Du brauchst ein Terminal, grundlegende Kenntnisse zum Erstellen einer Textdatei und einen Editor. Die folgenden Befehle laufen innerhalb des Linux-Gasts, nicht in der Windows-Eingabeaufforderung. Für die Paketinstallation ist eine Netzwerkverbindung nötig.
Prüfe zuerst, ob Python vorhanden ist:
python3 --version
python3 --version
Es sollte eine Versionsnummer erscheinen. Falls Python oder das Modul für virtuelle Umgebungen fehlt, lassen sich auf Linux Mint die benötigten Pakete installieren:
sudo apt update
sudo apt install python3 python3-venv
sudo apt update
sudo apt install python3 python3-venv
sudo fragt gegebenenfalls nach deinem Linux-Passwort. Beim Tippen erscheinen normalerweise keine Zeichen. Nun legen wir einen Projektordner und darin eine isolierte Python-Umgebung an:
mkdir -p ~/eigene-ki
cd ~/eigene-ki
python3 -m venv .venv
source .venv/bin/activate
python --version
mkdir -p ~/eigene-ki
cd ~/eigene-ki
python3 -m venv .venv
source .venv/bin/activate
python --version
Nach dem Aktivieren steht häufig (.venv) am Anfang der Eingabezeile. Die Versionsnummer sollte zu dem installierten Python passen. Die Umgebung enthält einen eigenen Bereich für später benötigte Python-Pakete. Für das heutige Beispiel brauchen wir keine zusätzlichen Pakete. Die Python-Dokumentation zu venv erklärt Aufbau und Aktivierung ausführlicher.
Wenn du das Terminal später neu öffnest, wechselst du wieder mit cd ~/eigene-ki in den Ordner und aktivierst die Umgebung erneut mit source .venv/bin/activate. Mit deactivate verlässt du sie. Deine Projektdateien bleiben dabei erhalten.
Falls python3 -m venv fehlschlägt, prüfe zuerst, ob python3-venv installiert ist. Falls source die Datei nicht findet, prüfe mit pwd, ob du in ~/eigene-ki bist, und ob der vorherige Befehl erfolgreich war. Das hier verwendete source gilt für die übliche Bash-Shell.
Optional: Die Umgebung automatisch aktivieren
Wenn du häufig zwischen Projekten wechselst, kann direnv die Umgebung beim Betreten des Projektordners laden und beim Verlassen wieder entladen. Die folgenden Schritte gelten für Bash unter Linux Mint. Sie sind eine optionale Ergänzung und für das Beispiel nicht erforderlich.
Wir haben .venv oben bereits erstellt und für das aktuelle Terminal manuell aktiviert. Bevor wir auf die automatische Aktivierung wechseln, verlassen wir diese Umgebung und installieren direnv:
deactivate
deactivate
Falls du inzwischen ein neues Terminal geöffnet und die Umgebung nicht erneut aktiviert hast, kannst du deactivate überspringen. Installiere anschließend direnv:
sudo apt update
sudo apt install direnv
sudo apt update
sudo apt install direnv
Öffne die Datei ~/.bashrc in deinem Texteditor und füge am Ende der Datei beide Zeilen hinzu:
eval "$(direnv hook bash)"
PS1='${VIRTUAL_ENV:+${FAXL_KI_PROMPT}}'"$PS1"
eval "$(direnv hook bash)"
PS1='${VIRTUAL_ENV:+${FAXL_KI_PROMPT}}'"$PS1"
Speichere die Datei und starte ein neues Terminal. Der Hook sorgt dafür, dass Bash direnv vor der nächsten Eingabeaufforderung aufruft. Wechsle dann in den Projektordner:
cd ~/eigene-ki
cd ~/eigene-ki
Erstelle dort mit deinem Texteditor eine neue Datei namens .envrc und speichere darin diese beiden Zeilen:
source .venv/bin/activate
export FAXL_KI_PROMPT='(.venv) '
source .venv/bin/activate
export FAXL_KI_PROMPT='(.venv) '
Erlaube direnv anschließend einmalig, diese Datei auszuführen:
direnv allow
direnv allow
Direnv führt .envrc als Shell-Code aus. Erlaube deshalb nur Dateien, deren Inhalt du geprüft hast. Nach einer Änderung an .envrc verlangt direnv erneut eine Freigabe. Beim Verlassen des Ordners werden die von direnv gesetzten Umgebungsvariablen wieder zurückgenommen. Beim erneuten Betreten des Projektordners oder eines Unterordners werden sie geladen. Der Ablauf und die Freigabe sind in der direnv-Dokumentation beschrieben.
Prüfe die Aktivierung im Projektordner mit:
python -c 'import sys; print(sys.executable)'
python -c 'import sys; print(sys.executable)'
Die Ausgabe sollte auf eigene-ki/.venv/bin/python innerhalb deines Home-Verzeichnisses enden. Außerdem sollte nun (.venv) vor der Eingabeaufforderung stehen. Verlässt du den Projektordner mit cd ~, verschwindet die Anzeige. Mit cd ~/eigene-ki erscheint sie wieder. Die PS1-Zeile zeigt den Hinweis an, wenn sowohl die von direnv gesetzte Kennzeichnung als auch VIRTUAL_ENV vorhanden sind. Der Pfad aus dem Python-Befehl ist die genauere Kontrolle, welcher Interpreter tatsächlich verwendet wird.
Wenn die Anzeige fehlt, prüfe, ob du ein neues Bash-Terminal geöffnet, beide Zeilen in ~/.bashrc ergänzt und die geänderte .envrc mit direnv allow freigegeben hast. Eine spätere Einstellung der Eingabeaufforderung kann die PS1-Zeile überschreiben.
Um die Automatisierung rückgängig zu machen, führe im Projektordner direnv deny aus und entferne die ergänzte PS1-Zeile sowie den direnv-Hook aus ~/.bashrc, sofern du ihn nicht für andere Projekte benötigst. Die virtuelle Umgebung selbst und deine Projektdateien bleiben dabei erhalten.
Ein Programm mit einer festen Regel
Als kleines Beispiel soll ein Programm anhand der Länge einer Zeichenfolge entscheiden, ob sie als „kurz“ oder „lang“ gilt. Das ist eine einfache Aufgabe, bei der wir die Entscheidung vollständig nachvollziehen können. Sie hat noch nichts mit Textverständnis zu tun.
Erstelle im Ordner ~/eigene-ki eine Datei namens regel.py mit diesem Inhalt:
def klassifiziere(text):
laenge = len(text)
if laenge >= 5:
return "lang"
return "kurz"
for beispiel in ["Katze", "Maus", "Hund"]:
print(f"{beispiel}: {len(beispiel)} Zeichen -> {klassifiziere(beispiel)}")
def klassifiziere(text):
laenge = len(text)
if laenge >= 5:
return "lang"
return "kurz"
for beispiel in ["Katze", "Maus", "Hund"]:
print(f"{beispiel}: {len(beispiel)} Zeichen -> {klassifiziere(beispiel)}")
Starte das Programm im Terminal:
python regel.py
python regel.py
Die erwartete Ausgabe:
Katze: 5 Zeichen -> lang
Maus: 4 Zeichen -> kurz
Hund: 4 Zeichen -> kurz
Katze: 5 Zeichen -> lang
Maus: 4 Zeichen -> kurz
Hund: 4 Zeichen -> kurz
Der Datenweg sieht so aus:
Die Schritte zeigen den tatsächlich gewählten Weg für diese Eingabe.
- Eingabe
Die Zeichenfolge lautet „Katze“.
- Länge bestimmen
len zählt 5 Zeichen.
- Regel prüfen
5 ist größer oder gleich 5. Die Bedingung ist erfüllt.
- Ausgabe
Das Programm gibt „lang“ zurück.
Für „Maus“ ergibt len dagegen 4. Die Bedingung ist nicht erfüllt, also lautet das Ergebnis „kurz“.
Die Zahl 5 steht ausdrücklich im Programm. Ändern wir sie auf 4, wird auch „Maus“ als lang eingeordnet. Das Programm lernt dabei nichts: Wir selbst ändern die Regel. len zählt bei diesen Beispielen Python-Zeichen, nicht die Bedeutung der Wörter. Für komplexe Unicode-Zeichen können sichtbare Zeichen und Zählung voneinander abweichen.
Probiere es aus: Ergänze "Elefant" und "Ei" in der Liste und sage die Ausgaben voraus. Ändere anschließend den Grenzwert. Welche Ausgaben ändern sich? Falls regel.py nicht gefunden wird, prüfe mit pwd und ls, ob du im richtigen Ordner bist und die Datei den richtigen Namen hat.
Was wäre beim maschinellen Lernen anders?
Statt den Grenzwert fest vorzugeben, könnten wir ein Verfahren mit Beispielen versorgen. Für eine einfache, bewusst künstliche Aufgabe etwa so:
| Eingabe | Länge | gewünschte Ausgabe |
|---|---|---|
| Ei | 2 | kurz |
| Maus | 4 | kurz |
| Katze | 5 | lang |
| Elefant | 7 | lang |
Ein geeignetes Lernverfahren könnte aus solchen Beispielen einen Parameter für seine Entscheidung bestimmen. Es bekommt dabei sowohl die Eingaben als auch die gewünschten Ausgaben. Das heißt überwachtes Lernen. Die Trainingsdaten, die Art des Modells und die Berechnung des Fehlers legen gemeinsam fest, was überhaupt gelernt werden kann.
Die Beispiele und ihre gewünschten Ausgaben dienen zur Anpassung der Modellparameter.
- Trainingsdaten
Beispiele und gewünschte Ausgaben
- Lernverfahren
Es passt die Parameter anhand der Beispiele an.
- Ergebnis
Ein Modell mit angepassten Parametern
Das angepasste Modell verarbeitet eine neue Eingabe.
- Neue Eingabe
Ein Beispiel, für das eine Vorhersage gesucht wird
- Modell
Es berechnet mit den angepassten Parametern ein Ergebnis.
- Vorhersage
Die Ausgabe kann richtig oder falsch sein.
Das Modell ist die Rechenvorschrift mit ihren einstellbaren Parametern. Das Lernen verändert diese Parameter anhand der Daten. Ein Modell kann dabei auch falsch liegen. Wir prüfen es deshalb mit geeigneten Beispielen, die beim Training nicht verwendet wurden. Wenige Beispiele wie in unserer Tabelle reichen nicht aus, um verlässlich zu beurteilen, wie gut ein Modell auf unbekannte Daten reagiert.
Es gibt auch Lernverfahren ohne vorgegebene Zielausgaben. Für den Einstieg reicht uns zunächst die überwachte Variante. Später verwenden wir beim Sprachmodell Textfolgen, aus denen wir Eingaben und Ziele für die Vorhersage des nächsten Zeichens ableiten.
Ein Rechenschritt als Vorschau
Angenommen, ein Modell bildet zunächst Ausgabe = Gewicht × Eingabe. Bei Eingabe 2 und Gewicht 0,5 ergibt das 2 × 0,5 = 1. Wäre die gewünschte Ausgabe 2, läge die Vorhersage um 1 daneben. Bei Gewicht 1 wäre sie für dieses Beispiel genau 2.
Das zeigt, was sich ändern kann: eine Zahl im Modell. Es ist noch kein vollständiges Lernverfahren und beweist nicht, dass Gewicht 1 für andere Beispiele gut ist. Wie man den Fehler berechnet und Gewichte systematisch verändert, folgt später. Zunächst untersuchen wir, wie mehrere solcher Berechnungen zu einem neuronalen Netz verbunden werden.
Wie geht es weiter?
Im nächsten Teil zeichnen und programmieren wir ein kleines neuronales Netz mit Ein-, Zwischen- und Ausgabeschicht. Das heutige Regelprogramm bleibt als Vergleich im Projektordner. Später ersetzen wir das einfache Lehrnetz nicht heimlich durch ein großes Modell, sondern erklären den Übergang und die zusätzlichen Bausteine ausdrücklich.