Die Aufgabenstellung ist sehr speziell, und dementsprechend wird dieser Beitrag vermutlich nur wenig Leute interessieren. Aber egal: Ich habe mich drei Tage damit geärgert, vielleicht profitieren ein paar Leser von meinen Erfahrungen …

Die Zielsetzung ist bereits in der Überschrift beschrieben. Ich besitze einen Mini-PC mit AMD 8745H-CPU und 32 GiB RAM. Die CPU enthält auch eine integrierte GPU (Radeon 780M). Auf diesem Rechner wollte ich das momentan sehr beliebte Sprachmodell gpt-oss-20b ausführen. Dieses Sprachmodell ist ca. 11 GiB groß, umfasst 20 Milliarden Parameter in einer etwas exotischen Quantifizierung. (MXFP4 wurde erst 2024 standardisiert und bildet jeden Parameter mit nur 4 Bit ab. Die Besonderheit besteht darin, dass für unterschiedliche Teile des Modells unterschiedliche Skalierungsfaktoren verwendet werden, so dass die Parameter trotz der wenigen möglichen Werte einigermaßen exakt abgebildet werden können.)

Das Sprachmodell wird von der Firma OpenAI kostenlos angeboten. Die Firma gibt an, dass die 20b-Variante ähnlich gute Ergebnisse wie das bis 2024 eingesetzt kommerzielle Modell o3-mini liefert, und auch KI-Experte Simon Willison singt wahre Lobeshymnen auf das Modell.

PS: Ich habe alle Tests unter Fedora 42 durchgeführt.

Warum nicht Ollama?

Für alle, die nicht ganz tief in die lokale Ausführung von Sprachmodellen eintauchen wollen, ist Ollama zumeist die erste Wahl. Egal, ob unter Windows, Linux oder macOS, viele gängige Sprachmodelle können damit unkompliziert ausgeführt werden, in der Regel mit GPU-Unterstützung (macOS, Windows/Linux mit NVIDIA-GPU bzw. mit ausgewählten AMD-GPUs).

Bei meiner Hardware — und ganz allgemein bei Rechnern mit einer AMD-iGPU — ist Ollama aktuell aber NICHT die erste Wahl:

ROCm: Ollama setzt bei NVIDIA-GPUs auf das Framework CUDA (gut), bei AMD-GPUs auf das Framework ROCm (schlecht). Dieses Framework reicht alleine vermutlich als Grund, warum AMD so chancenlos gegen NVIDIA ist. Im konkreten Fall besteht das Problem darin, dass die iGPU 780M (interner ID gfx1103) offiziell nicht unterstützt wird. Die Empfehlung lautet, ROCm per Umgebungsvariable zu überzeugen, dass die eigene GPU kompatibel zu einem anderen Modell ist (HSA_OVERRIDE_GFX_VERSION=11.0.2). Tatsächlich können Sprachmodelle dann ausgeführt werden, aber bei jeder Instabilität (derer es VIELE gibt), stellt sich die Frage, ob nicht genau dieser Hack der Anfang aller Probleme ist.

Speicherverwaltung: Auch mit diesem Hack scheitert Ollama plus ROCm-Framework an der Speicherverwaltung. Bei AMD-iGPUs gibt es zwei Speicherbereiche: fix per BIOS allozierten VRAM sowie dynamisch zwischen CPU + GPU geteiltem GTT-Speicher. (Physikalisch ist der Speicher immer im RAM, den sich CPU und GPU teilen. Es geht hier ausschließlich um die Speicherverwaltung durch den Kernel + Grafiktreiber.)

Ollama alloziert zwar den GTT-Speicher, aber maximal so viel, wie VRAM zur Verfügung steht. Diese (Un)Logik ist am besten anhand von zwei Beispielen zu verstehen. Auf meinem Testrechner habe ich 32 GiB RAM. Standardmäßig reserviert das BIOS 2 GiB VRAM. Der Kernel markiert dann 14 GiB als GTT. (Das kann bei Bedarf mit den Kerneloptionen amdttm.pages_limit und amdttm.page_pool_size verändert werden.) Obwohl mehr als genug Speicher zur Verfügung steht, sieht Ollama eine Grenze von 2 GiB und kann nur winzige LLMs per GPU ausführen.

Nun habe ich im BIOS das VRAM auf 16 GiB erhöht. Ollama verwendet nun 16 GiB als Grenze (gut), nutzt aber nicht das VRAM, sondern den GTT-Speicher (schlecht). Wenn ich nun ein 8 GiB großes LLM mit Ollama ausführen, dann bleiben fast 16 GiB VRAM ungenutzt! Ollama verwendet 8 GiB GTT-Speicher, und für Ihr Linux-System bleiben gerade einmal 8 GiB RAM übrig. Es ist zum aus der Haut fahren! Im Internet gibt es diverse Fehlerberichte zu diesem Problem und sogar einen schon recht alten Pull-Request mit einem Vorschlag zur Behebung des Problems. Eine Lösung ist aber nicht Sicht.

Ich habe mich mehrere Tage mit Ollama geärgert. Schade um die Zeit. (Laut Internet-Berichten gelten die hier beschriebenen Probleme auch für die gehypte Strix-Halo-CPU.)

Next Stop: llama.cpp

Etwas Internet-Recherche liefert den Tipp, anstelle von Ollama das zugrundeliegende Framework llama.cpp eben direkt zu verwenden. Ollama greift zwar selbst auf llama.cpp zurück, aber die direkte Verwendung von llama.cpp bietet andere GPU-Optionen. Dieser Low-Level-Ansatz ist vor allem bei der Modellauswahl etwas umständlicher. Zwei Vorteile können den Zusatzaufwand aber rechtfertigen:

• Die neuste Version von llama.cpp unterstützt oft ganz neue Modelle, mit denen Ollama noch nicht zurechtkommt.

• llama.cpp kann die GPU auf vielfältigere Weise nutzen als Ollama. Je nach Hardware und Treiber kann so eventuell eine höhere Geschwindigkeit erzielt bzw. der GPU-Speicher besser genutzt werden, um größere Modelle auszuführen.

Die GitHub-Projektseite beschreibt mehrere Installationsvarianten: Sie können llama.cpp selbst kompilieren, den Paketmanager nix verwenden, als Docker-Container ausführen oder fertige Binärpakete herunterladen (https://github.com/ggml-org/llama.cpp/releases). Ich habe den einfachsten Weg beschritten und mich für die letzte Option entschieden. Der Linux-Download enthält genau die llama.cpp-Variante, die für mich am interessantesten war — jene mit Vulkan-Unterstützung. (Vulkan ist eine 3D-Grafikbibliothek, die von den meisten GPU-Treibern unter Linux durch das Mesa-Projekt gut unterstützt wird.) Die Linux-Version von llama.cpp wird anscheinend unter Ubuntu kompiliert und getestet, dementsprechend heißt der Download-Name llama-<version>-bin-ubuntu-vulkan-x86.zip. Trotz dieser Ubuntu-Affinität ließen sich die Dateien bei meinen Tests aber problemlos unter Fedora 42 verwenden.

Nach dem Download packen Sie die ZIP-Datei aus. Die resultierenden Dateien landen im Unterverzeichnis build/bin. Es bleibt Ihnen überlassen, ob Sie die diversen llama-xxx-Kommandos direkt in diesem Verzeichnis ausführen, das Verzeichnis zu PATH hinzufügen oder seinen Inhalt in ein anderes Verzeichnis kopieren (z.B. nach /usr/local/bin).

cd Downloads
unzip llama-b6409-bin-ubuntu-vulkan-x64.zip
cd build/bin
./llama-cli --version

  loaded RPC backend from ./build/bin/libggml-rpc.so
  ggml_vulkan: Found 1 Vulkan devices:
  ggml_vulkan: 0 = AMD Radeon 780M Graphics (RADV PHOENIX) (radv) ...
  loaded Vulkan backend from ./build/bin/libggml-vulkan.so
  loaded CPU backend from ./build/bin/libggml-cpu-icelake.so
  version: 6409 (d413dca0)
  built with cc (Ubuntu 11.4.0-1ubuntu1~22.04.2) for x86_64-linux-gnu

Für die GPU-Unterstützung ist entscheidend, dass auf Ihrem Rechner die Bibliotheken für die 3D-Bibliothek Vulkan installiert sind. Davon überzeugen Sie sich am einfachsten mit vulkaninfo aus dem Paket vulkan-tools. Das Kommando liefert fast 4000 Zeilen Detailinformationen. Mit einem Blick in die ersten Zeilen stellen Sie fest, ob Ihre GPU unterstützt wird.

vulkaninfo | less

  Vulkan Instance Version: 1.4.313
  Instance Extensions: count = 24
    VK_EXT_acquire_drm_display  : extension revision 1
    VK_EXT_acquire_xlib_display : extension revision 1
    ...
  Layers: count = 1
     VK_LAYER_MESA_device_select
     Devices: count = 2
       GPU id = 0 (AMD Radeon 780M Graphics (RADV PHOENIX))
       GPU id = 1 (llvmpipe (LLVM 20.1.8, 256 bits))
  ...

Erste Tests

Um llama.cpp auszuprobieren, brauchen Sie ein Modell. Bereits für Ollama heruntergeladene Modelle sind leider ungeeignet. llama.cpp erwartet Modelle als GGUF-Dateien (GPT-Generated Unified Format). Um die Ergebnisse mit anderen Tools leicht vergleichen zu können, verwende ich als ersten Testkandidat immer Llama 3. Eine llama-taugliche GGUF-Variante von Llama 3.1 mit 8 Milliarden Parametern finden Sie auf der HuggingFace-Website unter dem Namen bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M.

Das folgende Kommando lädt das Modell von HuggingFace herunter (Option -hf), speichert es im Verzeichnis .cache/llama.cpp, lädt es, führt den als Parameter -p angegebenen Prompt aus und beendet die Ausführung dann. In diesem und allen weiteren Beispielen gehe ich davon aus, dass sich die llama-Kommandos in einem PATH-Verzeichnis befinden. Alle Ausgaben sind aus Platzgründen stark gekürzt.

llama-cli -hf bartowski/Meta-Llama-3.1-8B-Instruct-GGUF:Q4_K_M \
  -p 'bash/Linux: explain the usage of rsync over ssh'

  ... (diverse Debugging-Ausgaben)
  Running in interactive mode.
  - Press Ctrl+C to interject at any time.
  - Press Return to return control to the AI.
  - To return control without starting a new line, end your input with '/'.
  - If you want to submit another line, end your input with '\'.
  - Not using system message. To change it, set a different value via -sys PROMPT

> bash/Linux: explain the usage of rsync over ssh

  rsync is a powerful command-line utility that enables you to 
  synchronize files and directories between two locations. Here's 
  a breakdown of how to use rsync over ssh: ...

> <Strg>+<D>

         load time =  2231.02 ms
  prompt eval time =   922.83 ms /  43 tokens (46.60 tokens per second)
         eval time = 31458.46 ms / 525 runs   (16.69 tokens per second)

Sie können llama-cli mit diversen Optionen beeinflussen, z.B. um verschiedene Rechenparameter einzustellen, die Länge der Antwort zu limitieren, den Systemprompt zu verändern usw. Eine Referenz gibt llama-cli --help. Deutlich lesefreundlicher ist die folgende Seite:

https://github.com/ggml-org/llama.cpp/discussions/15709

Mit llama-bench können Sie diverse Benchmark-Tests durchführen. Im einfachsten Fall übergeben Sie nur das Modell in der HuggingFace-Notation — dann ermittelt das Kommando die Token-Geschwindigkeit für das Einlesen des Prompts (Prompt Processing = pp) und die Generierung der Antwort (Token Generation = tg). Allerdings kennt llama-bench die Option -hf nicht; vielmehr müssen Sie mit -m den Pfad zur Modelldatei übergeben:

llama-bench -m ~/.cache/llama.cpp/bartowski_Meta-Llama-3.1-8B-Instruct-GGUF_Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf

  model                         size     test   token/s (Tabelle gekürzt ...)
  -----------------------  ---------  -------  --------
  llama 8B Q4_K - Medium    4.58 GiB    pp512    204.03
  llama 8B Q4_K - Medium    4.58 GiB    tg128     17.04

Auf meinem Rechner erreicht llama.cpp mit Vulkan nahezu eine identische Token-Rate wie Ollama mit ROCm (aber ohne die vielen Nachteile dieser AMD-Bibliothek).

AMD-Optimierung

Bei meinen Tests auf dem schon erwähnten Mini-PC mit AMD 8745H-CPU mit der iGPU 780M und 32 GiB RAM funktionierte llama.cpp mit Vulkan viel unkomplizierter als Ollama mit ROCm. Ich habe die VRAM-Zuordnung der GPU wieder zurück auf den Defaultwert von 2 GiB gestellt. Per Default steht llama.cpp auf meinem Rechner dann ca. der halbe Arbeitsspeicher (2 GiB VRAM plus ca. 14 GiB GTT) zur Verfügung. Vulkan kann diesen Speicher ohne merkwürdige Hacks mit Umgebungsvariablen korrekt allozieren. Das reicht ohne jedes Tuning zur Ausführung des Modells gpt-20b aus (siehe den folgenden Abschnitt). So soll es sein!

Wenn Sie noch mehr Speicher für die LLM-Ausführung reservieren wollen, müssen Sie die Kerneloptionen pages_limit und pages_pool_size des AMDGPU-Treibers verändern. Wenn Sie 20 GiB GGT-Speicher nutzen wollen, müssen Sie für beide Optionen den Wert 5242880 angeben (Anzahl der 4-kByte-Blöcke):

# neue Datei /etc/modprobe.d/amd.conf
# 20 * 1024 * 1024 * 1024 / 4096 = 20 * 1024 * 256 = 5242880
options ttm pages_limit=5242880
options ttm page_pool_size=5242880

Danach aktualisieren Sie die Initrd-Dateien und führen einen Neustart durch:

sudo update-initramfs -u                   # Debian und Ubuntu
sudo dracut --regenerate-all --force       # Fedora, RHEL, SUSE

sudo reboot

sudo dmesg | grep "amdgpu.*memory"

  amdgpu: 2048M of VRAM memory ready   (<-- laut BIOS-Einstellung)
  amdgpu: 20480M of GTT memory ready   (<-- laut /etc/modprobe.d/amd.conf)

Modellauswahl

Mit llama.cpp können Sie grundsätzlich jedes Modell im GPT-Generated Unified Format (GGUF) ausführen. Auf der Website von HuggingFace stehen Tausende Modelle zur Wahl:

https://huggingface.co/models?pipeline_tag=text-generation&library=gguf

Die Herausforderung besteht darin, für die eigenen Zwecke relevante Modelle zu finden. Generell ist es eine gute Idee, besonders populäre Modelle vorzuziehen. Außerdem werden Sie rasch feststellen, welche Modellgrößen für Ihre Hardware passen. Die höhere Qualität großer Modelle bringt nichts, wenn die Geschwindigkeit gegen Null sinkt.

gpt-oss-20b

Eine llama.cpp-kompatible Version finden hat ggml-org auf HuggingFace gespeichert. Sofern ca. 15 GiB freier VRAM zur Verfügung stehen (unter AMD: VRAM + GTT), führt llama.cpp das Modell problemlos und beachtlich schnell aus. Beachten Sie, dass es sich hier um ein »Reasoning-Modell« handelt, das zuerst über das Problem nachdenkt und diesen Denkprozess auch darstellt. Danach wird daraus das deutlich kompaktere Ergebnis präsentiert.

llama-cli -hf ggml-org/gpt-oss-20b-GGUF -p 'bash: explain array usage'

  ...

llama-bench -m ~/.cache/llama.cpp/ggml-org_gpt-oss-20b-GGUF_gpt-oss-20b-mxfp4.gguf

  model                         size     test   token/s
  -----------------------  ---------  -------  --------
  gpt-oss 20B MXFP4 MoE    11.27 GiB    pp512    305.68
  gpt-oss 20B MXFP4 MoE    11.27 GiB    tg128     27.93

Server-Betrieb

Die Kommandos llama-cli und llama-bench dienen in erster Linie zum Testen und Debuggen. Sobald Sie sich einmal überzeugt haben, dass llama.cpp grundsätzlich funktioniert, werden Sie das Programm vermutlich im Server-Betrieb einsetzen. Das entsprechende Kommando lautet llama-server und ist grundsätzlich wie llama-cli aufzurufen. Falls Sie llama-server unter einem anderen Account als llama-cli aufrufen, aber schon heruntergeladene Modelle weiterverwenden wollen, übergeben Sie deren Pfad mit der Option -m:

llama-server -c 0 -fa on --jinja -m /home/kofler/.cache/llama.cpp/ggml-org_gpt-oss-20b-GGUF_gpt-oss-20b-mxfp4.gguf

Sie können nun unter http://localhost:8080 auf einen Webserver zugreifen und das gestartete Modell komfortabel bedienen. Im Unterschied zu Ollama hält llama.cpp das Modell dauerhaft im Arbeitsspeicher. Das Modell kann immer nur eine Anfrage beantworten. Die Verarbeitung mehrere paralleler Prompts erlaubt --parallel <n>.

Es ist unmöglich, mit einem Server mehrere Modelle parallel anzubieten. Vielmehr müssen Sie mehrere Instanzen von llama-server ausführen und jedem Dienst mit --port 8081, --port 8082 usw. eine eigene Port-Nummer zuweisen. (Das setzt voraus, dass Sie genug Video-Speicher für alle Modelle zugleich haben!)

Falls auch andere Rechner Server-Zugang erhalten sollen, übergeben Sie mit --host einen Hostnamen oder eine IP-Nummer im lokalen Netzwerk. Mit --api-key oder --api-key-file können Sie den Server-Zugang mit einem Schlüssel absichern. Mehr Details zu den genannten Optionen sowie eine schier endlose Auflistung weiterer Optionen finden Sie hier:

https://github.com/ggml-org/llama.cpp/tree/master/tools/server

Was bringt die GPU? Nicht viel …

Jetzt habe ich drei Tage versucht, gpt-oss per GPU auszuführen. Hat sich das gelohnt? Na ja. Mit -ngl 0 kann die Token Generation (also das Erzeugen der Antwort per Sprachmodell) von der GPU auf die CPU verlagert werden. Das ist natürlich langsamer — aber erstaunlicherweise nur um 25%.

llama-bench -ngl 0 -m ~/.cache/llama.cpp/ggml-org_gpt-oss-20b-GGUF_gpt-oss-20b-mxfp4.gguf

  model                         size     test   token/s
  -----------------------  ---------  -------  --------
  ...
  gpt-oss 20B MXFP4 MoE    11.27 GiB    tg128     21.15

Warum ist der Unterschied nicht größer? Weil die 780M keine besonders mächtige GPU ist und weil die Speicherbandbreite der iGPU viel kleiner ist als bei einer dezidierten GPU mit »echtem« VRAM.

Zur Einordnung noch zwei Vergleichszahlen: MacBook Pro M3: 42 Token/s (mit GPU) versus 39 Token/s (nur CPU)

Quellen/Links

Sprachmodell gpt-oss

• https://huggingface.co/openai/gpt-oss-20b
• https://huggingface.co/ggml-org/gpt-oss-20b-GGUF
• https://simonwillison.net/2025/Aug/5/gpt-oss
• https://github.com/ggml-org/llama.cpp/discussions/15095

Ollama

• https://ollama.com
• https://github.com/ollama/ollama/blob/main/docs/gpu.md#overrides
• https://github.com/ollama/ollama/issues/12062
• https://github.com/ollama/ollama/pull/6282

llama.cpp

• https://github.com/ggml-org/llama.cpp
• https://github.com/ggml-org/llama.cpp/discussions/15709
• https://huggingface.co/models?pipeline_tag=text-generation&library=gguf
• https://community.frame.work/t/igpu-vram-how-much-can-be-assigned/73081/7
• https://github.com/ggml-org/llama.cpp/tree/master/tools/server

Heute berichte ich über meine Nutzung großer Sprachmodelle (engl. Large Language Model, kurz LLM) und freue mich, wenn ihr eure Erfahrungen in den Kommentaren oder vielleicht sogar einem eigenen Blog mit mir teilt.

Ich konzentriere mich in diesem Text auf Beispiele, in denen mich die Nutzung von LLMs in meiner Arbeit unterstützt. Dies soll nicht darüber hinwegtäuschen, dass LLMs halluzinieren und falsche Antworten produzieren können. Auch hierzu finden sich diverse Beispiele, die den Fokus des Artikels jedoch verschieben und den Umfang sprengen würden.

Bilder für Präsentationen

Ich nutze ChatGPT und Gemini, um Bilder für Präsentationen zu generieren. Dabei hat bis jetzt ChatGPT die Nase vorn.

Zuvor habe ich Bilder entweder selbst erstellt oder Stunden mit der Suche in Datenbanken mit lizenzfreien Bildern verbracht. Dies war für mich stets eine sehr frustrierende Erfahrung. Nun kann ich beschreiben, was ich in einem Bild sehen möchte und die Künstliche Intelligenz in Form eines LLM generiert mir entsprechende Bilder. Dies bringt für mich eine große Zeitersparnis und ich habe weniger Stress.

Zusammenfassung langer Texte und Diskussionen

Damit ist jetzt nicht gemeint, dass ich mir E-Mails mit mehr als fünf Sätzen zusammenfassen lasse. Aber auf der Arbeit erlebe ich es häufig, dass ich mal kurz nicht in eine Google Group geschaut habe und plötzlich eine Diskussion mit 40-70 Beiträgen darin finde. Diesen Diskussionen zu folgen war in der Vergangenheit sehr zeitaufwendig bis hinzu unmöglich. Und wir haben sehr viele Maillinglisten.

Wir haben auf der Arbeit Google Workspace und ich gebe gerne zu, dass sich damit bereits ohne KI-Unterstützung super arbeiten lässt. Die nahtlose Integration von Gemini macht es allerdings noch besser.

Wenn ich eine E-Mail Diskussion öffne, kann ich mir mit einem Klick eine Zusammenfassung erstellen lassen. Folgender Prompt hat sich bisher als nützlich erwiesen, um mir einen Überblick zu verschaffen: „Erstelle eine kurze Zusammenfassung, die den Diskussionsgegenstand wiedergibt. Führe auf, wer welche Argumente vertritt. Falls es Lösungsvorschläge und Action Items gibt, liste diese stichpunktartig auf.“

Anhand der Zusammenfassung kann ich in kurzer Zeit beurteilen, ob eine Diskussion für mich von Relevanz ist oder nicht. Auch hier ist der Vorteil durch Nutzung der KI im Allgemeinen die Zeitersparnis und im Speziellen die gute Integration in die vorhandenen Werkzeuge. Ich würde mir nicht die Mühe machen, alle Nachrichten einer langen Diskussion in einen Prompt zu kopieren, um diese dann von einem LLM analysieren zu lassen.

Generierung von Textvorschlägen für E-Mails

Ich weiß, was ich sagen möchte und drücke mich gerne direkt aus. Das kommt in der Kommunikation mit internationalen Empfängern aus anderen Kulturkreisen nicht immer gut an. Ich schätze auch hier die gute Integration von Gemini in Google Mail, wo ich es manchmal als Formulierungshilfe nutze.

Gemini bietet 3-4 Antwortvarianten an, die in einer Vorschau im Nachrichtenfenster angezeigt werden. Manche sind fernab meiner Vorstellung, andere kommen erstaunlich nah heran. So kann ich die am besten zutreffende Antwort auswählen, kürze sie etwas ein, ergänze evtl. noch 1-2 Sätze und bin fertig.

Vorteile auch hier die Zeitersparnis und die etwas höflicher bzw. runder formulierten E-Mails.

Zusammenfassung von Videokonferenzen

Ihr ahnt vielleicht schon, wo es jetzt hingeht. Google Gemini integriert sich auch hervorragend in Google Meet. Und so haben wir in einer internen Besprechung mit Zustimmung aller Beteiligten die Funktion ausprobiert, ein Besprechungs-Protokoll zu erstellen. Wir waren positiv überrascht.

Die Besprechung wurde auf Deutsch durchgeführt. Gemini war für diese Sprache offiziell noch als Alpha markiert, was das Ergebnis umso beeindruckender macht. Nach der Besprechung wurde ein Google Doc mit einer deutschsprachigen Zusammenfassung erstellt und im Kalender in den Termin eingefügt, so dass alle Teilnehmer es finden und darauf zugreifen können.

Ich habe das Protokoll gelesen und musste lediglich einige Schreibfehler bei Namen und englischen Fachbegriffen korrigieren. Alle Teilnehmer waren sich einig, dass die wesentlichen Punkte korrekt zusammengefasst wurden. Bei englischsprachigen Meetings, welche aufgezeichnet werden, enthält die Zusammenfassung sogar die Zeitstempel, zu denen protokollierte Aussagen gemacht wurden.

Es muss nun also kein Protokollant mehr ausgelost werden und alle Teilnehmer:innen können sich auf die Besprechung konzentrieren.

Da sich die Zusammenfassung auf das Wesentliche konzentriert, finde ich diese noch besser als ein Transkript, welches auch die belanglosen Beiträge wiedergibt und viel Redundanz enthalten kann.

Als Organisator verlasse ich mich nicht blind auf die KI. Ich lese das Protokoll zeitnah nach der Besprechung und korrigiere es ggf. Es ist bei uns auch nicht unüblich, dass Teilnehmer:innen auch im Nachgang zu einer Besprechung Ergänzungen und Korrekturen zum gemeinsamen Dokument beitragen.

Google NotebookLM

Google NotebookLM bietet eine Umgebung, in der mit KI-Unterstützung Inhalte von PDFs, Google Docs & Slides sowie Webseiten verarbeitet werden können. Ich möchte die Nutzung anhand eines konkreten Beispiels erläutern.

Leider habe ich mir die konkreten Prompts und detaillierten Antworten nicht gespeichert, so dass ich meine Erfahrung aus dem Gedächtnis aufschreibe.

Ich betreibe einen Server für Laborumgebungen aus der Hetzner-Serverbörse. Zu diesem gab es eine IPv4-Adresse und ein IPv6-Subnetz. Des Weiteren hat Hetzner eine Richtlinie zur Nutzung von MAC-Adressen. In meinem Fall darf nur die MAC der physischen Netzwerkkarte auf dem Switch im Rechenzentrum erscheinen, nicht jedoch die virtuellen MACs meiner virtuellen Maschinen (VM). Möchte ich meinen Server als Hypervisor-Host verwenden und die darauf laufenden VMs im Internet erreichbar machen, benötige ich dafür ein geroutetes Netzwerk auf dem Hypervisor.

Prinzipiell weiß ich, was zu tun ist. Es gibt bei Hetzner auch eine Anleitung, wie man Debian für Proxmox entsprechend konfiguriert, die ich auf RHEL mit Network Manager adaptieren kann. Deshalb schien mir diese Aufgabe geeignet, um zu testen, wie sich ChatGPT und NotebookLM dabei schlagen.

Ich habe beide Lösungen dabei angewiesen, mit folgenden Quellen zu arbeiten:

• RHEL 9: Configuring and managing networking
• RHEL 9: Configuring and managing virtualization
• Hetzner-FAQ: Reasons you received an abuse email regarding MAC-Errors
• Libvirt: Virtual Networking

Bei ChatGPT sind die URLs zu den Quellen in den Prompt einzugeben. Bei NotebookLM kann zu Beginn konfiguriert werden, welche Quellen im aktuellen Notebook zu verwenden sind. Diese kann man flexibel selektieren oder abwählen, um zu steuern, mit welchen Quellen die KI arbeiten soll.

Beiden Werkzeugen habe ich über den Prompt mitgeteilt, welche IPv6-Adresse ich auf der physischen Netzwerkkarte des Hosts nutzen möchte. Anschließend habe ich via Prompt eine zu RHEL 9 passende Schritt-für-Schritt-Anleitung gefordert, mit der die gewünschte Netzwerkkonfiguration umgesetzt werden kann. Die angebotenen Lösungen wurden in beiden Fällen durch weitere Prompts verfeinert.

ChatGPT

Die von ChatGPT generierte Lösung war komplex und falsch. Aufgrund meiner eigenen Erfahrung hatte ich direkt Zweifel und glaubte nicht, dass der vorgeschlagene wilde Mix aus Bridge und Teaming mit Master- und Slave-Interface auf der Bridge funktionieren würde.

Um meine Annahme zu verifizieren, habe ich die vorgeschlagene Lösung trotzdem umgesetzt und nach der Hetzner-MAC-Abuse-Meldung wieder zurückgebaut.

Ich hatte keine Lust, ChatGPT mit dem Ergebnis zu konfrontieren und weiter mit dem Bot zu chatten, da ich wenig Hoffnung hatte, dass ich noch zu einer funktionierenden Lösung komme.

NotebookLM

Hier hat mir die Erfahrung deutlich besser gefallen. Gemini hat auf meinen Prompt mit einer Zusammenfassung reagiert, welche Informationen über die bereitgestellten Quellen zu meinem Prompt bieten. Dabei wurden auch Referenzen mit ausgegeben, um direkt zur Quelle springen zu können. Im Anschluss gab es eine Schritt-für-Schritt-Anleitung mit Code-Beispielen. Zu jedem Code-Beispiel erfolgte dazu eine Erklärung, was man dort sieht und was die einzelnen Parameter bedeuten. Dies hat mir gut gefallen.

Die ersten zwei Anleitungen waren noch etwas ungenau, ließen sich jedoch durch weitere Prompts soweit verfeinern, dass ich sie fast 1-zu-1 übernehmen konnte.

Warum nur fast? Ich habe mir die in der Schritt-für-Schritt-Anleitung referenzierten Quellen angeschaut und mit den dortigen Informationen die Code-Beispiele weiter optimiert, so dass sie besser zu meiner Umgebung passen. Evtl. hätte Gemini dies mit besseren Prompts ebenfalls hinbekommen.

Auch diese Lösung habe ich implementiert und sie läuft bis heute. Die KI hat mich auf dem Weg zur Lösung unterstützt und ich musste nicht die vier Quellen komplett und im Detail lesen, um mir die Lösung komplett selbst zu erarbeiten. Ich bin mit dem Ergebnis sehr zufrieden.

Fazit

Künstliche Intelligenz und deren Nutzung ist nicht unumstritten. Der aktuelle Energiebedarf ist enorm und es ist zu befürchten, dass dies negative Umweltauswirkungen zur Folge hat. KI-Modelle können halluzinieren, was zu Fehlern führt, wenn man die Antworten der Modelle nicht verifiziert.

Die Weigerung, KI im Beruf zu benutzen und ihre Möglichkeiten zu erkunden, führt meiner Einschätzung nach jedoch nur dazu, dass man sich selbst benachteiligt. KI mag Arbeitsplätze nicht so schnell ersetzen. Aber Menschen, die KI effizient nutzen können, werden Menschen von Stellen verdrängen, die dies nicht können. Es erscheint mir daher sinnvoll, den Einsatz von KI im Beruf und Alltag zu erkunden.

Den größten Vorteil bietet mir die KI-Nutzung aktuell dort, wo sie gut in meine Anwendungen und Werkzeuge wie z.B. Mail, Videokonferenzen und Kalender integriert ist. Der Vorteil besteht überwiegend in Zeitersparnis. Ich habe die gewünschten Informationen schneller mit weniger eigenem Aufwand in ausreichender Qualität zur Verfügung, wobei die Qualität mit geringem Aufwand durch manuelle Überarbeitung schnell gesteigert werden kann, um ein gutes Ergebnis zu erzielen.

KI-Assistenten lassen sich nutzen, um die Zeit zur Lösung zu verkürzen. Ich hätte die Dokumentationen alle selbst lesen und mir die Lösung erarbeiten können. Ich bin mir jedoch sicher, dass ich dafür deutlich mehr Zeit hätte investieren müssen.

Im Endeffekt hilft mir KI dabei, mehr Aufgaben im gleichen Zeitintervall zu erledigen.

Das Buch „ChatGPT Power-Prompting“ von Ulrich Engelke ist in der 1. Auflage 2025 im mitp-Verlag erschienen und umfasst 336 Seiten. Es trägt den Untertitel Profi-Strategien für den erfolgreichen Einsatz von KI und richtet sich vor allem an Menschen, die kreativ mit einem Chatbot wie ChatGPT arbeiten möchten.

Ich denke, mittlerweile hat fast jeder, der aktiv im Internet unterwegs ist, in irgendeiner Form bereits Kontakt mit Künstlicher Intelligenz (KI) bzw. Artificial Intelligence (AI) gehabt – sei es über Gemini, Krok oder ChatGPT. Spätestens seit 2022, als ChatGPT den KI-Bereich revolutionierte, ist das Thema in aller Munde. Dabei existiert Künstliche Intelligenz schon deutlich länger. Doch mit ChatGPT hat die Firma OpenAI unter der Leitung von CEO Sam Altman ein Tool geschaffen, das erstmals einer breiten Öffentlichkeit zugänglich ist – und das Nutzerinnen und Nutzern erlaubt, KI sowohl im privaten als auch im beruflichen Kontext einzusetzen. Das zugrunde liegende Large Language Model (LLM) funktioniert nach dem Prinzip „Finde das nächste Wort“ und verarbeitet Anfragen mit einer bemerkenswert hohen Relevanz. Wie man solche Anfragen – sogenannte Prompts – optimal formuliert, damit die Ergebnisse möglichst präzise und hilfreich sind, genau darum geht es in dem Buch „ChatGPT Power-Prompting“ von Ulrich Engelke.

Inhalt und Stärken des Buches

Das Buch ist sehr gut strukturiert und folgt einer logischen, durchdachten und nachvollziehbaren Abfolge. Zunächst erklärt der Autor anschaulich, wie KI-Chatbots funktionieren. Ich hatte bereits den Algorithmus „Finde das nächste Wort“ erwähnt, auf dem das Sprachmodell basiert. Darüber hinaus geht das Buch ausführlich auf das Thema Datenschutz ein – ein Aspekt, der für viele Leserinnen und Leser im Umgang mit dieser neuen Technologie von großer Bedeutung sein dürfte. Um ChatGPT nutzen zu können, benötigt man ein OpenAI-Konto. Wie man dieses einrichtet, wird im Buch detailliert erklärt. Ebenso werden die wichtigsten Unterschiede zwischen der kostenlosen Version und den kostenpflichtigen Pro-Modellen erläutert. Zentrale Begriffe wie Machine Learning, Deep Learning, Kohärenz, Kohäsion oder Halluzinieren werden verständlich erklärt, um Nutzerinnen und Nutzern zu helfen, möglichst präzise und hochwertige Ergebnisse vom Chatbot zu erhalten. Im weiteren Verlauf des Buches geht es dann gezielt um die Kunst der richtigen Eingabe – das sogenannte Prompting. Der Bogen spannt sich vom einfachen Prompt bis hin zum komplexen Power-Prompting. Dabei werden die wichtigsten Eingabeparameter erläutert. Man lernt, wie man mit dem Chatbot in einen interaktiven Dialog eintaucht oder durch präzise Prompts direkt das gewünschte Ergebnis erzeugt. Auf solche Techniken geht der Autor sehr detailliert ein. Außerdem wird erklärt, wie man mit dem GPT-Builder einen angepassten GPT (Generative Pre-trained Transformer) erstellt, um bestimmte Prompts immer wieder automatisch nutzen zu können. Zahlreiche praxisnahe Beispiele – etwa zur Erstellung von Rezepten, Trainings- und Ernährungsplänen oder sogar von Meta-Descriptions für suchmaschinenoptimierte Beiträge – machen das Buch besonders nützlich. Die sogenannte Fünf-Absatz-Essay-Struktur wird beispielsweise als hilfreiches Werkzeug für Blogger vorgestellt. Ulrich Engelke zeigt eindrucksvoll, wie sich mit ChatGPT komplexe Ausgaben für nahezu jeden Anwendungsbereich erzeugen lassen.

Kapitelübersicht

Das Buch gliedert sich in folgende Kapitel:

Teil I Grundlagen

• Wie funktionieren KI-Chatbots?
• Datenschutz, Urheberrecht und Einschränkungen
• Erste Schritte mit ChatGPT

Teil II Professionelle Strategien für bessere Prompts

• Prompting-Techniken für Einsteiger
• Power-Prompting für Profis
• Custom GPTs

Teil III ChatGPT für Alltag und Beruf

• ChatGPT im Alltag
• ChatGPT in der Arbeitswelt
• Lernen mit KI
• Kreativität

Besonderheiten

• Das Buch ist sowohl als Printausgabe als auch als E-Book erhältlich.

Leseproben und Downloads

• Inhaltsverzeichnis und Leseprobe

Fazit

„ChatGPT Power-Prompting“ ist ein gut strukturiertes, verständlich geschriebenes Buch, das sowohl Einsteigern als auch Fortgeschrittenen einen fundierten Einstieg in die Arbeit mit KI-Chatbots bietet. Besonders die vielen praktischen Beispiele und klaren Erklärungen machen es zu einer wertvollen Hilfe im Alltag. Der Autor vermittelt nicht nur technisches Wissen, sondern auch den verantwortungsvollen Umgang mit KI. Wer ChatGPT effizient nutzen möchte, findet in diesem Buch einen umfassenden Leitfaden. Es ist sowohl als Printausgabe als auch als E-Book erhältlich.

Der Beitrag ChatGPT Power-Prompting erschien zuerst auf intux.de.

Vor einem dreiviertel Jahr haben Bernd Öggl, Sebastian Springer und ich das Buch Coding mit KI geschrieben und uns während dieser Zeit intensiv mit diversen KI-Tools und Ihrer Anwendung beschäftigt.

Was hat sich seither geändert? Wie sieht die berufliche Praxis mit KI-Tools heute aus? Im folgenden Fragebogen teilen wir drei unsere Erfahrungen, Wünsche und Ärgernisse. Sie sind herzlich eingeladen, in den Kommentaren eigene Anmerkungen hinzuzufügen.

Bei welchen Projekten hast du KI-Tools im letzten Monat eingesetzt? Mit welchem Erfolg?

Bernd: KI-Tools haben in meine tägliche Programmierung Einzug gehalten und sparen mir Zeit. Oft traue ich der Ki zu wenig zu und stelle Fragen, die nicht weit genug gehen. Zum „vibe-coding“ bin ich noch nicht gekommen :-) Ich verwende KI-Tools in diesen Projekten:

1. ein großes Code Repo mit Angular und C#: Einsatz sowohl in VSCode (Angular) und Visual Studio (C#, die Unterstützung ist überraschend gut).
2. ein kleines Projekt (HTML, JS, MongoDB (ca. 20.000 MongoDocs)).
3. zwei verschiedene Flutter Apps für Android
4. für eine größere PHP/MariaDB Codebase

Sebastian: Ich setze mittlerweile verschiedene KI-Tools flächendeckend in den Projekten ein. Wir haben das mittlerweile auch in unsere Verträge mit aufgenommen, dass das explizit erlaubt ist.

Die letzten Projekte waren in JavaScript/TypeScript im Frontend React, im Backend Node.js, und es waren immer mittelgroße Projekte mit 2 – 4 Personen über mehrere Monate.

Die verschiedenen Tools sind mittlerweile zum Standard geworden und ich möchte nicht mehr darauf verzichten müssen, gerade bei den langweiligen Routineaufgaben helfen sie enorm.

Michael: Ich habe zuletzt einige Swift/SwiftUI-Beispielprogramme entwickelt. Weil Swift und insbesondere SwiftUI ja noch sehr dynamisch in der Weiterentwicklung ist, hatten die KI-Tools die Tendenz, veraltete Programmiertechniken vorzuschlagen. Aber mit entsprechenden Prompts (use modern features, use async/await etc.) waren die Ergebnisse überwiegend gut (wenn auch nicht sehr gut).

Ansonsten habe ich in den letzten Monaten immer wieder kleinere Mengen Code in PHP/MySQL, Python und der bash geschrieben bzw. erweitert. Mein Problem ist zunehmend, dass ich beim ständigen Wechsel die Syntaxeigenheiten der diversen Sprachen durcheinanderbringe. KI-Tools sind da meine Rettung! Der Code ist in der Regel trivial. Mit einem sorgfältig formulierten Prompt funktioniert KI-generierter Code oft im ersten oder zweiten Versuch. Ich kann derartige Routine-Aufgaben mit KI-Unterstützung viel schneller erledigen als früher, und die KI-Leistungen sind diesbezüglich ausgezeichnet (besser als bei Swift).

Welches KI-Tool verwendest du bevorzugt? In welchem Setup?

Michael: Ich habe in den vergangenen Monaten fast ausschließlich Claude Pro verwendet (über die Weboberfläche). Was die Code-Qualität betrifft, bin ich damit sehr zufrieden und empfand diese oft besser als bei ChatGPT.

In VSCode läuft bei mir Cody (Free Tier). Ich verwende es nur für Vervollständigungen. Es ist OK.

Ansonsten habe ich zuletzt den Großteil meiner Arbeitszeit in Xcode verbracht. Xcode ist im Vergleich zu anderen IDEs noch in der KI-Steinzeit, die aktuell ausgelieferten KI-Werkzeuge in Xcode sind unbrauchbar. Eine Integration von Claude in Xcode hätte mir viel Hin und Her zwischen Xcode und dem Webbrowser erspart. (Es gibt ein Github-Copilot-Plugin für Xcode, das ich aber noch nicht getestet habe. Apple hat außerdem vor fast einem Jahr Swift Code angekündigt, das bessere KI-Funktionen verspricht. Leider ist davon nichts zu sehen. Apple = Gute Hardware, schlechte Software, zumindest aus Entwicklerperspektive.)

Für lokale Modelle habe ich aktuell leider keine geeignete Hardware.

Sebastian: Ich habe über längere Zeit verschiedene IDE-Plugins mit lokalen Modellen ausprobiert, nutze aber seit einigen Monaten nur noch GitHub Copilot. Die Qualität und Performance ist deutlich besser als die von lokalen Modellen.

Für Konzeption und Ideenfindung nutze ich ebenfalls größere kommerzielle Werkzeuge. Aktuell stehen die Gemini-Modelle bei mir ganz hoch im Kurs. Die haben mit Abstand den größten Kontext (1 – 2 Millionen Tokens) und die Ergebnisse sind mindestens genauso gut wie bei ChatGPT, Claude & Co.

Lokale Modelle nutze ich eher punktuell oder für die Integration in Applikationen. Gerade wenn es um Übersetzung, RAG und ähnliches geht, wo es entweder um Standardaufgaben oder um Teilaufgaben geht, wo man mit weiteren Tools wie Vektordatenbanken die Qualität steuern kann. Bei den lokalen Modellen hänge ich nach wie vor bei Llama3 wobei sich auch die Ergebnisse von DeepSeek sehen lassen können.

Für eine kleine Applikation habe ich auch europäische Modelle (eurollm und teuken) ausprobiert, wobei ich da nochmal deutlich mehr Zeit investieren muss.

Für die Ausführung lokaler Modelle habe ich auf die Verfügbarkeit der 50er-Serie von NVIDIA gewartet, wobei mir die RTX 5090 deutlich zu teuer ist. Ich habe seit Jahresbeginn ein neues MacBook Pro (M4 Max) das bei der Ausführung lokaler Modelle echt beeindruckend ist. Mittlerweile nutze ich das MacBook deutlich mehr als meinen Windows PC mit der alten 3070er.

Bernd: Ich verwende aus Interesse vor allem lokale Modelle, die auf meinem MacBook Pro (M2/64GB) wunderbar schnell performen (aktuell gemma3:27b und deepseek-r1:32b, aber das ändert sich schnell). Am MacBook laufen die über ollama. Ich muss aber beruflich auch unter Windows arbeiten und arbeite eigentlich (noch) am liebsten unter Linux mit neovim.

Dazu ist das Macbook jetzt immer online und im lokalen Netz erreichbar. Unter Windows verwenden ich in VSCode das Continue Plugin mit dem Zugriff auf die lokalen Modelle am MacBook. In Visual Studio läuft CoPilot (die „Gratis“-Version). Unter Linux verwende ich sehr oft neovim (mit lazyvim) mit dem avante-Plugin. Während ich früher AI nur für code-completion verwendet habe, ist es inzwischen oft so, dass ich Code-Blöcke markiere und der AI dazu Fragen stelle. Avante macht dann wunderbare Antworten mit Code-Blöcken, die ich wie einen git conflict einbauen kann. Sie sagen es ist so wie cursor.ai, aber das habe ich noch nicht verwendet.

Daneben habe ich unter Linux natürlich auch VSCode mit Continue. Und wenn ich gerade einmal nicht im Büro arbeite (also das Macbook nicht im aktuellen Netz erreichbar ist), so wie gerade eben, dann habe ich Credits für Anthropic und verwende Claude (3.5 Sonnet aktuell) für AI support.

Wo haben dich KI-Tools in letzter Zeit überrascht bzw. enttäuscht?

Sebastian: Ich bin nach wie vor enttäuscht wie viel Zeit es braucht, um den Kontext aufzubauen, damit dir ein LLM wirklich bei der Arbeit hilft. Gerade wenn es um neuere Themen wie aktuelle Frameworks geht. Allerdings lohnt es sich bei größeren Projekten, hier Zeit zu investieren. Ich habe in ein Test-Setup für eine Applikation gleich mehrere Tage investiert und konnte am Ende qualitativ gute Tests generieren, indem ich den Testcase mit einem Satz beschrieben habe und alles weitere aus Beispielen und Templates kam.

Ich bin sehr positiv überrascht vom Leistungssprung den Apple bei der Hardware hingelegt hat. Gerade das Ausführen mittelgroßer lokaler LLMs merkt man das extrem. Ein llama3.2-vision, qwq:32b oder teuken-7b funktionieren echt gut.

Bernd: Überrascht hat mich vor allem der Qualitäts-Gewinn bei lokalen Modellen. Im Vergleich zu vor einem Jahr sind da Welten dazwischen. Ich mache nicht ständig Vergleiche, aber was die aktuellen Kauf-Modelle liefern ist nicht mehr so ganz weit weg von gemma3 und vergleichbaren Modellen.

Michael: Ich musste vor ein paar Wochen eine kleine REST-API in Python realisieren. Datenbank und API-Design hab‘ ich selbst gemacht, aber das Coding hat nahezu zu 100 Prozent die KI erledigt (Claude). Ich habe mich nach KI-Beratung für das FastAPI-Framework entschieden, das ich vorher noch nie verwendet habe. Insgesamt ist die (einzige) Python-Datei knapp 400 Zeilen lang. Acht Requests mit den dazugehörigen Datenstrukturen, Absicherung durch ein Time-based-Token, komplette, automatisch generierte OpenAPI-Dokumentation, Wahnsinn! Und ich habe wirklich nur einzelne Zeilen geändert. (Andererseits: Ich wusste wirklich ganz exakt, was ich wollte, und ich habe viel Datenbank- und Python-Basiswissen. Das hilft natürlich schon.)

So richtig enttäuscht haben mich KI-Tools in letzter Zeit selten. In meinem beruflichen Kontext ergeben sich die größten Probleme bei ganz neuen Frameworks, zu denen die KI zu wenig Trainingsmaterial hat. Das ist aber erwartbar und insofern keine Überraschung. Es ist vielmehr eine Bestätigung, dass KI-Tools keineswegs von sich aus ‚intelligent‘ sind, sondern zuerst genug Trainingsmaterial zum Lernen brauchen.

Was wäre dein größter Wunsch an KI-Coding-Tools?

Bernd: Gute Frage. Aktuell nerven mich ein bisschen die verschiedenen Plugins und die Konfigurationen für unterschiedliche Editoren. Wie gesagt, neovim ist für mich wichtig, da hast du, wie in OpenSource üblich, 23 verschiedene Plugins zur Auswahl :-) Zum Glück gibt es ollama, weil da können alle anbinden. Ich glaub M$ versucht das eh mit CoPilot, eine Lösung, die überall funktioniert, nur ich will halt lokale Modelle und nicht Micro$oft….

Sebastian: Im Moment komme ich mit dem Wünschen ehrlich gesagt gar nicht hinterher, so rasant wie sich alles entwickelt. Microsoft hat GitHub Copilot den Agent Mode spendiert, TypeScript wird “mehr copiloty” und bekommt APIs die eine engere Einbindung von LLMs in den Codingprozess erlauben. Wenn das alles in einer ausreichenden Qualität kommt, hab ich erstmal keine weiteren Wünsche.

Michael: Ich bin wie gesagt ein starker Nutzer der webbasierten KI-Tools. Was ich dabei über alles schätze ist die Möglichkeit, mir die gesamte Konversation zu merken (als Bookmark oder indem ich den Link als Kommentar in den Code einbaue). Ich finde es enorm praktisch, wenn ich mir später noch einmal anschauen kann, was meine Prompts waren und welche Antworten das damalige KI-Modell geliefert hat.

Eine vergleichbare Funktion würde ich mir für IDE-integrierte KI-Tools wünschen. Eine KI-Konversation in VSCode mit GitHub Copilot oder einem anderen Tool sowie die nachfolgenden Code-Umbauten sind später nicht mehr reproduzierbar — aus meiner Sicht ein großer Nachteil.

Beeinflusst die lokale Ausführbarkeit von KI-Tools deinen geplanten bzw. zuletzt durchgeführten Hardware-Kauf?

Bernd: zu 100%! Mein MacBook Pro (gebraucht gekauft, M2 Max mit 64GB) wurde ausschließlch aus diesem Grund gekauft und es war ein großer Gewinn.

Ich habe jetzt ein 2.100 EUR Thinkpad und ein 2.200 EUR MacBook. Rate mal was ich öfter verwende :-) . Die Hardware beim Mac (besonders das Touchpad) ist besser und ich habe quasi alle Linux-Tools auch am Mac (fish-shell, neovim, git, Browser, alle anderen UI-Programme). Wenn ich unter Linux arbeite, denke ich mir oft: »Ah, das kann ich jetzt nicht ollama fragen, weil das nur am MacBook läuft«. Natürlich könnte ich Claude verwenden, aber irgend etwas im Kopf ist dann doch so: »Das muss man jetzt nicht über den großen Teich schicken.«

4000 EUR für die Nvidia-Maschine, die ich zusätzlich zum Laptop mitnehmen muss, ist kein Ding für mich. Ich möchte einen Linux Laptop, der die LLMs so schnell wie der Mac auswerten kann (und noch ein gutes Touchpad hat). Das ist der Wunsch ans Christkind …

Michael: Ein ärgerliches Thema! Ich bin bei Hardware eher sparsam. Vor einem Jahr habe ich mir ein Apple-Notebook (M3 Pro mit 36 GB RAM) gegönnt und damit gerade mein Swift-Buch aktualisiert. Leider waren mir zum Zeitpunkt des Kaufs die Hardware-Anforderungen für lokale LLMs zu wenig klar. Das Notebook ist großartig, aber es hat zu wenig RAM. Den Speicher brauche ich für Docker, virtuelle Maschinen, IDEs, Webbrowser etc. weitgehend selbst, da ist kein Platz mehr für große LLMs.

Aus meiner Sicht sind 64 GB RAM aktuell das Minimum für einen Entwickler-PC mit lokalen LLMs. Im Apple-Universum ist das sündhaft teuer. Im Intel/AMD-Lager gibt es wiederum kein einziges Notebook, das — was die Hardware betrifft — auch nur ansatzweise mit Apple mithalten kann. Meine Linux- und Windows-Rechner kann ich zwar billig mit mehr RAM ausstatten, aber die GPU-Leistung + Speicher-Bandbreite sind vollkommen unzureichend. Deprimierend.

Ein externer Nvidia-Mini-PC (kein Notebook, siehe z.B. die diversen Ankündigungen auf notebookcheck.com) mit 128 GB RAM als LLM-Server wäre eine Verlockung, aber ich bin nicht bereit, dafür plus/minus 4000 EUR auszugeben. Da zahle ich lieber ca. 20 EUR/Monat für ein externes kommerzielles Tool. Aber derartige Rechner, wenn sie denn irgendwann lieferbar sind, wären sicher ein spannendes Angebot für Firmen, die einen lokalen LLM-Server einrichten möchten.

Generell bin ich überrascht, dass die LLM-Tauglichkeit bis jetzt kein großes Thema für Firmen-Rechner und -Notebooks zu sein scheint. Dass gerade Apple hier so gut performt, war ja vermutlich auch nicht so geplant, sondern hat sich mit den selbst entwickelten CPUs als eher zufälliger Nebeneffekt ergeben.

Sebastian: Ursprünglich war mein Plan auf die neuen NVIDIA-Karten zu warten. Nachdem ich aber im Moment eher auf kommerzielle Tools setze und sich mein neues MacBook zufällig als richtige KI-Maschine entpuppt, werde ich erstmal warten, wie sich die Preise entwickeln. Ich bin auch enttäuscht, dass NVIDIA den kleineren karten so wenig Speicher spendiert hat. Meine Hoffnung ist, dass nächstes Jahr die 5080 mit 24GB rauskommt, das wär dann genau meins.

Unser Buch Coding mit KI wird gerade übersetzt. Heute musste ich diverse Fragen zur Übersetzung beantworten und habe bei der Gelegenheit ein paar Beispiele aus unserem Buch mit aktuellen Versionen von ChatGPT und Claude noch einmal ausprobiert. Dabei ging es um die Frage, ob KI-Tools technische Diagramme (z.B. UML-Diagramme) zeichnen können. Die Ergebnisse sind niederschmetternd, aber durchaus unterhaltsam :-)

UML-Diagramme

Vor einem halben Jahr habe ich ChatGPT gebeten, zu zwei einfachen Java-Klassen ein UML-Diagram zu zeichnen. Das Ergebnis sah so aus (inklusive der falschen Einrückungen):

+-------------------------+
|         Main            |
+-------------------------+
| + main(args: String[]): void |
| + initializeQuestionPool(): List<Question> |
+-------------------------+

+-------------------------+
|        Question         |
+-------------------------+
| - text: String          |
| - answers: List<Answer> |
| - correctAnswers: List<Answer> |
+-------------------------+
| + Question(text: String, answers: List<Answer>, 
|            correctAnswers: List<Answer>) |
| + askQuestion(): void   |
| - validateAnswer(userInput: String): boolean |
+-------------------------+

Dabei war ChatGPT schon damals in der Lage, PlantUML- oder Mermaid-Code zu liefern. Der Prompt Please generate PlantUML code instead liefert brauchbaren Code, der dann in https://www.planttext.com/ visualisiert werden kann. Das sieht dann so aus:

Heute habe ich das ganze Beispiel noch einmal ausprobiert. Ich habe also den Java-Code für zwei Klassen an ChatGPT übergeben und um ein UML-Diagramm gebeten. Vorbei sind die ASCII-Zeiten. Das Ergebnis sieht jetzt so aus:

Leider kann ich hier keinen Link zum ganzen Chat-Verlauf angeben, weil ChatGPT anscheinend nur reine Text-Chat-Verläufe teilen kann.

Visualisierung eines Docker-Setups

Beispiel zwei ergibt sich aus zwei Prompts:

Prompt: I want to build a REST application using Python and Django. The application will run in a Docker container. Do I need a proxy server in this case to make my application visible to the internet?

Prompt: Can you visualize the setup in a diagram?

In der Vergangenheit (Mitte 2024) lieferte ChatGPT das Diagramm als ASCII-Art.

+---------------------------+
|      Client Browser       |
+-----------+---------------+
            |
            v
+-----------+---------------+
|       Nginx Reverse Proxy |
|  (Handles SSL, Load       |
|   Balancing, etc.)        |
+-----------+---------------+
            |
            v
+-----------+----------------+
| Docker Container Network   |
|                            |
|  +----------+   +---------+|
|  |  Web     |   |  DB     ||
|  | Container|   |Container||
|  +----------+   +---------+|
|   (Django)       (Postgres)|
+----------------------------+

Erst auf die explizite Bitte liefert es auch Mermaid-Code, der dann unter https://mermaid.live/ gezeichnet werden kann.

Heute (Dez. 2024) gibt sich ChatGPT nicht mehr mit ASCII-Art ab sondern leitet den Diagrammwunsch an DALL-E weiter. Das Ergebnis ist eine Katastrophe.

Auch Claude.ai zeichnet selbstbewusst ein Diagramm des Docker-Setups. Dabei wird intern Mermaid verwendet.

Fazit

Die Diagramme haben durchaus einen hohen Unterhaltungswert. Aber offensichtlich wird es noch ein wenig dauern, bis KI-Tools brauchbare technische Diagramme zeichnen können. Der Ansatz von Claude wirkt dabei erfolgsversprechender. Technische Diagramme mit DALL-E zu erstellen wollen ist doch eine sehr gewagte Idee von OpenAI.

Die besten Ergebnisse erzielen Sie weiterhin, wenn Sie ChatGPT, Claude oder das KI-Tool Ihrer Wahl explizit um Code in PlantUML oder Mermaid bitten. Den Code können Sie dann selbst visualisieren und bei Bedarf auch weiter optimieren.

Als ich vor 40 Jahren zu schreiben begann, war klar, was ein IT-Fachbuch liefern musste: Korrekte Information zu einem Thema, zu einer Programmiersprache, zu Linux etc. … Je mehr Information, desto besser. Ein dickes Buch war also im Regelfall wertvoller als ein dünnes.

Das IT-Buch war damals nahezu konkurrenzlos: Zu kommerziellen Software-Produkten gab es im Idealfall ein gedrucktes Handbuch (oft lieblos gestaltet und von dürftiger Qualität), dazu eventuell noch ein paar Readme-Dateien; ansonsten waren Administratorinnen und Programmierer weitgehend auf sich selbst gestellt. Mit etwas Glück veröffentlichte eine der damals noch viel zahlreicheren Zeitschriften einen Artikel mit Lösungsideen für ein spezifisches Problem. Aber ansonsten galt: Learning by doing.

Mit dem Siegeszug des Internets änderte sich der IT-Buchmarkt zum ersten Mal radikal: Der Vorteil des Buchs lag nun darin, dass die dort zusammengestellten Informationen (hoffentlich!) besser recherchiert und besser strukturiert waren als die über das Internet und in Videos verstreuten Informationsschnipsel, Tipps und Tricks. Ein gutes Buch konnte ganz einfach Zeit sparen.

Das IT-Buch stand plötzlich in Konkurrenz zur Informationsfülle des Internets. Es liegt in der Natur der Sache, dass ein Buch nie so aktuell sein kann wie das Internet, nie so allumfassend bei der Themenauswahl. Im Internet finden sich selbst für exotische Funktionen Anleitungen, selbst zu selten auftretenden Fehlern Tipps oder zumindest Leidensberichte anderer Personen. Es hilft ja schon zu wissen, dass ein Problem nicht nur auf dem eigenen Rechner oder Server auftritt.

Natürlich habe auch ich als Autor von der einfachen Zugänglichkeit der Informationen profitiert. Während früher Ausprobieren der einzige Weg war, um bestimmte Techniken verlässlich zu dokumentieren, konnte ich jetzt auf den Erfahrungsschatz der riesigen Internet-Community zurückgreifen. Gleichzeitig sank aber der Bedarf nach IT-Büchern — und zwar in einem dramatischen Ausmaß. Viele Verlage, für die ich im Laufe der letzten Jahrzehnte geschrieben habe, existieren heute nicht mehr.

Mit der freien Verfügbarkeit von KI-Tools wie ChatGPT stehen wir heute vor einem weiteren Umbruch: Wozu noch nach einem Buch, einem StackOverflow-Artikel oder einem Blog-Beitrag suchen, wenn KI-Werkzeuge in Sekunden den Code für scheinbar jedes Problem, eine strukturierte Anleitung für jede Aufgabe liefern?

Möglichkeiten und Grenzen von KI-Tools

Seit die erste Version von ChatGPT online war, habe ich mich intensiv mit diesem und vielen anderen KI-Tools auseinandergesetzt. Natürlich habe ich darüber auch geschrieben, sowohl in diesem Blog als auch in Buchform: In Coding mit KI fassen Bernd Öggl, Sebastian Springer und ich zusammen, wie weit KI-Tools heute beim Coding und bei Administrationsaufgaben helfen — und wo ihre Grenzen liegen. Kurz gefasst: Claude, Copilot, Ollama etc. bieten bereits heute eine großartige Unterstüzung bei vielen Aufgaben. Sie machen Coding und Administration effizienter, schneller.

Ja, die Tools machen Fehler, aber sie sind dennoch nützlich, und sie werden jedes Monat besser. Ja, es gibt Datenschutzbedenken, aber die lassen sich lösen (am einfachsten, indem Sprachmodelle lokal ausgeführt werden). Ja, KI-Tools stellen mit ihrem exorbitaten Stromverbrauch vor allem in der Trainings-Phase eine massive ökologische Belastung dar; aber ich glaube/hoffe, dass sich KI-Tools mit bessere Hard- und Software in naher Zukunft ohne ein allzugroßes schlechtes Öko-Gewissen nutzen lassen.

Es ist für mich offensichtlich, dass viele IT-Arbeiten in Zukunft ohne KI-Unterstützung undenkbar sein werden. KI-Tools können bei der Lösung vieler Probleme die Effizienz steigern. Keine Firma, kein Admin, keine Entwicklerin wird es sich auf Dauer leisten können, darauf zu verzichten.

Die Zukunft des IT-Buchs

Ist »Coding mit KI« also das letzte IT-Buch, das Sie lesen müssen/sollen? Vermutlich nicht. (Aus meiner Sicht als Autor: Hoffentlich nicht!)

Auf jeden Fall ändern KI-Tools die Erwartungshaltung an IT-Bücher. Aktuell arbeite ich an einer Neuauflage meines Swift-Buchs. Weil sich inhaltlich viel ändert und ich bei vielen Teilen sowieso quasi bei Null anfangen muss, ist es das erste Buch, das ich von Grund auf im Hinblick auf das KI-Zeitalter neu konzipiere. In der vorigen Auflage habe ich über 1300 Seiten geschrieben und versucht, Swift und die App-Programmierung so allumfassend wie möglich darzustellen.

Dieses Mal bemühe ich mich im Gegenteil, die Seitenanzahl grob auf die Hälfte zu reduzieren. Warum? Weil ich glaube, dass sich das IT-Buch der Zukunft auf die Vermittlung der Grundlagen konzentriert. Es richtet den Blick auf das Wesentliche. Es erklärt die Konzepte. Es gibt Beispiele (durchaus auch komplexe). Aber es verzichtet darauf, endlose Details aufzulisten.

Was sind Ihre Erwartungen?

Ich weiß schon, immer mehr angehende und tatsächliche IT-Profis kommen ohne Bücher aus. Eigenes Ausprobieren in Kombination mit Videos, Blog-Artikeln und KI-Hilfe reichen aus, um neue Konzepte zu erlernen oder ganz pragmatisch ein Problem zu lösen (oft ohne es wirklich zu verstehen). Bleibt nur die Frage, warum Sie überhaupt auf meiner Website gelandet sind :-)

Persönlich lese ich mich in ein neues Thema aber weiterhin gerne ein, lasse mich von einem Autor oder einer Autorin von neuen Denkweisen überzeugen (zuletzt: Prometheus: Up & Running von Julien Pivotto und Brian Brazil). Bevorzugt mache ich das weit weg vom Computer. Wenn ich später ein Detail nochmals nachsehen will, ist mir ein E-Book willkommen. Aber beim ersten Lesen bevorzuge ich den analogen Zugang, ungestört und werbefrei.

Falls also auch Sie noch gelegentlich ein Buch zur Hand nehmen, dann interessiert mich Ihrer Meinung: Was erwarten Sie heute von einem IT-Buch? Was sind Ihre Wünsche an mich als Autor? Was ist aus Ihrer Sicht ein gutes IT-Buch, was ist ein schlechtes? Ich sage es sicherheitshalber gleich: Alle Wünsche kann ich nie erfüllen … Aber ich freue mich auf jeden Fall über Ihr Feedback!

Ein halbes Jahr lang haben wir zu dritt intensiv getestet:

• Was ist möglich?
• Was ist sinnvoll?
• Welche Anwendungsfälle gibt es, die über das reine Erstellen von Code hinausgehen?
• Wo liegen die Grenzen?
• Was sind die Risken?
• Ist der KI-Einsatz ethisch vertretbar?

Wir haben mit ChatGPT und Claude gearbeitet und deren Ergebnisse mit lokalen Sprachmodellen (via Ollama, GPT4All, Continue, Tabby) verglichen. Wir haben Llama, Mistral/Mixtral, CodeLlama, Starcoder, Gemma und andere »freie« Sprachmodelle ausprobiert. Wir haben nicht nur Pair Programming getestet, sondern haben die KI-Werkzeuge auch zum Debugging, Refactoring, Erstellen von Unit-Tests, Design von Datenbanken, Scripting sowie zur Administration eingesetzt. Dabei haben wir mit verschiedenen Prompt-Formulierungen experimentiert und geben dazu eine Menge Tipps.

Der nächste Schritt beim Coding mit KI sind semi-selbstständige Level-3-Tools. Also haben wir uns OpenHands und Aider angesehen und waren von letzterem ziemlich angetan. Wir haben die Grenzen aktueller Sprachmodelle mit Retrieval Augmented Generation (RAG) und Text-to-SQL verschoben. Wir haben Scripts entwickelt, die mit KI-APIs kommunizieren und automatisiert dutzende oder auch hunderte von Code-Dateien verarbeiten.

Kurz und gut: Wir haben uns das Thema »Coding mit KI« so gesamtheitlich wie möglich angesehen und teilen mit Ihnen unsere Erfahrungen. Die Quintessenz ist vielleicht ein wenig banal: Es kommt darauf an. In vielen Fällen haben wir sehr gute Ergebnisse erzielt. Oft sind wir aber auch an die Grenzen gestoßen — umso eher, je spezieller die Probleme, je exotischer die Programmiersprachen und je neuer die genutzten Sprach-Features/Frameworks/Bibliotheken sind.

Was bleibt, ist die Überzeugung, dass an KI-Tools in der Software-Entwicklung kein Weg vorbei geht. Wer KI-Tools richtig einsetzt, spart Zeit, kürzer lässt es sich nicht zusammenfassen. Aber wer sie falsch einsetzt, agiert unverantwortlich und produziert fehlerhaften und unwartbaren Code!

Mehr Details zum (Vorwort, Leseprobe) finden Sie hier.

Bei der Arbeit für unser KI-Buch bin ich kürzlich über Aider gestolpert. Dabei handelt es sich um ein Konsolenwerkzeug zum Coding. Im Gegensatz zu anderen Tools (ChatGPT, GitHub Copilot etc.), die Sie beim Coding nur unterstützen, ist Aider viel selbstständiger: Sie sagen, was Ihr Programm machen soll. Aider erzeugt die notwendigen Dateien, implementiert die Funktion und macht gleich einen git-Commit. Sie testen den Code, optimieren vielleicht ein paar Details, dann geben Sie Aider weitere Aufträge. Den Großteil der Coding-Aufgaben übernimmt Aider. Sie sind im Prinzip nur noch für das Ausprobieren und Debugging zuständig.

Wie Sie gleich sehen werden, funktioniert das durchaus (noch) nicht perfekt. Aber das Konzept ist überzeugend, und es ist verblüffend, wie viel schon klappt. Aider kann auch auf ein bestehendes Projekt angewendet werden, das ist aber nicht Thema dieses Blog-Beitrags. Generell geht es mir hier nur darum, das Konzept vorzustellen. Viel mehr Details können Sie in der guten Dokumentation nachlesen. Es gibt auch diverse YouTube-Videos. Besonders überzeugend fand ich Claude 3.5 and Aider: Use AI Assistants to Build AI Apps.

Voraussetzungen

Damit Sie Aider ausprobieren können, brauchen Sie einen Rechner mit einer aktuellen Python-Installation, git sowie einen (kostenpflichtigen!) Key für ein KI-Sprachmodell. Ich habe meine Tests mit GPT-4o von OpenAI sowie mit Claude 3.5 Sonnet (Anthrophic) durchgeführt. Ein wenig überraschend hat Claude 3.5 Sonnet merklich besser funktioniert.

Damit Sie einen API-Key bekommen, müssen Sie bei OpenAI oder Anthrophic einen Account anlegen und Ihre Kontakt- und Kreditkartendaten hinterlegen. Sie kaufen dort vorab »Credits«, die dann durch API-Abfragen aufgebraucht werden. Für erste Tests reichen 10 EUR aus. Sie müssen also kein Vermögen investieren, um Aider auszuprobieren.

Installation von aider

aider ist ein Python-Programm. Die Installation führen Sie am besten in einem Virtual Environment aus, im Prinzip so:

mkdir aider
cd aider
python3 -m venv .
source bin/activate
pip3 install aider-chat

Jetzt müssen Sie noch eine Umgebungsvariable für Ihren API-Key definieren (am besten in .bashrc oder .zshrc).

export OPENAI_API_KEY='sk-xxxxx'
export ANTHROPIC_API_KEY='sk-yyyyy'

Falls beide Variablen definiert sind, nutzt Aider das Modell Sonnet von Anthrophic. Mit den Optionen --4o oder --sonnet können Sie das Sprachmodell explizit auswählen. Aider unterstützt auch andere Sprachmodelle, empfiehlt aber explizit diese beiden Modell sowie DeepSeek Coder (siehe auch https://aider.chat/docs/leaderboards/).

»Hello World« mit GPT-4o von OpenAI

Um Aider kennenzulernen habe ich mir gedacht, ich beauftrage das Tool, ein ganz simples Webscraping-Tool in Python zu programmieren, das aus einer Wetterseite von orf.at die aktuelle Temperatur in Graz extrahiert. (Warnung: Das Script hat reinen Demonstrations-Charakter. Das regelmäßige Auslesen von Wetterseiten und die Nutzung der so gewonnen Daten — wofür auch immer — ist bei nahezu allen Websites verboten.)

Für den Test habe ich ein neues Verzeichnis eingerichtet, dieses aktiviert und (immer noch im Virtual-Environment) aider gestartet.

mkdir ~/my-projects/test1
cd ~/my-projects/test1
aider --4o
  No git repo found, create one to track GPT's changes (recommended)? y
  Models: gpt-4o with diff edit format, weak model gpt-4o-mini
  Git repo: .git with 0 files
  Repo-map: using 1024 tokens
  Use /help <question> for help, run "aider --help" to see cmd line args

Die weitere Bedienung erfolgt durch Konsolenkommandos. Ich habe damit begonnen, mit /web die Wetterseite zu laden. Beim ersten /web-Kommando installiert Aider nach einer Rückfrage das Webscraping-Tool Playwright. Mit der folgenden Frage habe ich überprüft, dass Aider den Inhalt der gelesenen Seite versteht.

> /web https://wetter.orf.at/steiermark

I see that you've shared a webpage content. How can I assist you with this? Are
you looking to extract specific information, transform the data, or something
else? Please provide more details about what you need.

Tokens: 7,057 sent, 43 received. Cost: $0.04 request, $0.04 session.

> what is the temperature in Graz?

The temperature in Graz, according to the provided content, is 27.2°C.

Nach diesem einleitenden Test habe ich nun versucht, eine App zu entwickeln, die diese Aufgabe übernimmt. Aider erzeugt eine neue Datei und speichert die Datei dort. Von der Programmiersprache war nie die Rede, Aider hat sich für Python entschieden. In einem zweiten Prompt habe ich Aider darum gebeten, das Projekt mit einer requirement-Datei auszustatten.

> write a Python script which extracts the temperature of Graz 
  from https://wetter.orf.at/steiermark/

Add https://wetter.orf.at/steiermark/ to the chat? y

Let's create a Python script that extracts the temperature of Graz from the
given URL. We'll use the requests library to fetch the webpage content and
BeautifulSoup from the bs4 library to parse the HTML.

Here is the script:

    import requests
    from bs4 import BeautifulSoup

    def get_graz_temperature():
        url = "https://wetter.orf.at/steiermark/"
        response = requests.get(url)
        response.raise_for_status()  # Ensure we notice bad responses

        soup = BeautifulSoup(response.text, 'html.parser')
        graz_section = soup.find('a', href="https://wetter.ORF.at/steiermark/grazuniversitaet/")

        if graz_section:
            temperature_text = graz_section.find_next_sibling(text=True)
            if temperature_text:
                temperature = temperature_text.strip().split(' ')[0]
                return temperature
        return None

    if __name__ == "__main__":
        temperature = get_graz_temperature()
        if temperature:
            print(f"The temperature in Graz is {temperature}°C.")
        else:
            print("Could not find the temperature for Graz.")

This script will:

 1 Fetch the webpage content from the given URL.
 2 Parse the HTML content to find the section related to Graz.
 3 Extract and print the temperature for Graz.

You can run this script in your Python environment to get the current
temperature in Graz.

Tokens: 7,196 sent, 314 received. Cost: $0.04 request, $0.11 session.

Allow creation of new file new_file_path: extract_graz_temperature.py? y

Applied edit to new_file_path: extract_graz_temperature.py
Commit beb001f feat: add script to extract temperature of Graz from weather website
You can use /undo to revert and discard commit beb001f.

> add a requirement file to the project

To add a requirements file to the project, we need to create a new file named
requirements.txt and list the necessary dependencies.

requests
beautifulsoup4

Tokens: 2,372 sent, 66 received. Cost: $0.01 request, $0.13 session.

In einem zweiten Terminal-Fenster oder -Tab habe ich nun ein weiteres Virtual Environment eingerichtet, um alle erforderlichen Module zu installieren und das neue Script zu testen.

cd ~/my-projects/test1
python3 -m venv .
source bin/activate
pip3 install -r requirements.txt

Dabei habe ich auch schon den ersten Fehler entdeckt. Aider hat das neue Python-Script nicht extract_graz_temperature.py genannt, sondern new_file_path: extract_graz_temperature.py. Diesen Fehler habe ich mit git behoben.

git mv 'new_file_path: `extract_graz_temperature.py' extract_graz_temperature.py
git commit -m 'fixed wrong filename'

Der erste Test verläuft enttäuschend:

python3 extract_graz_temperature.py 

  extract_graz_temperature.py:13: DeprecationWarning: The 
  'text' argument to find()-type methods is deprecated. 
  Use 'string' instead.

  Could not find the temperature for Graz.

Der Code enthält offensichtlich einen veralteten Parameter. Zurück im ersten Terminal/Tab bitte ich Aider, das Problem zu beheben. Aider sieht den Fehler ein und korrigiert den Code.

> tried to run the code, got this error: 
  extract_graz_temperature.py:13: DeprecationWarning: The 'text' 
  argument to find()-type methods is deprecated. Use 'string'
  instead. Can you fix the code? I renamed the code file to
  extract_graz_temperature.py.

extract_graz_temperature.py
Add these files to the chat? y

 <<<<<<< SEARCH
         temperature_text = graz_section.find_next_sibling(text=True)
 =======
         temperature_text = graz_section.find_next_sibling(string=True)
 >>>>>>> REPLACE

...

Tokens: 2,585 sent, 86 received. Cost: $0.01 request, $0.14 session.

Aber auch nach diesem Fix funktioniert das Script nicht. Das Problem ist, dass das Script die Struktur der Wetter-Website nicht korrekt analysiert hat und Beautiful Soup (eine HTML-Parser-Bibliothek für Python) falsch anwendet. Etwas enttäuscht habe ich an dieser Stelle den ersten Versuch abgebrochen. Die bis dahin angefallenen Kosten von 14 US Cent sind immerhin verschmerzbar.

»Hello World« mit Sonnet 3.5 von Anthrophic

Anstatt mich mit der Fehlersuche zu ärgern, habe ich das ganze Experiment mit dem Sprachmodell Sonnet wiederholt. Die folgenden Ausgaben sind stark gekürzt.

mkdir ~/my-projects/test2
cd ~/my-projects/test2
aider --sonnet

> /web https://wetter.orf.at/steiermark

> what is the temperature in Graz?

Based on the information provided in the weather report for Steiermark, there
are multiple temperature readings for Graz:

 1 Graz Heinrichstrasse: 30.3°C
 2 Graz-Straßgang: 29.8°C
 3 Graz-Thalerhof: 29.2°C
 4 Graz-Universität: 30.3°C

The temperatures in Graz range from 29.2°C to 30.3°C, with most locations
reporting around 30°C. The warmest spots in Graz appear to be Heinrichstrasse
and the University area, both at 30.3°C.

Tokens: 7,323 sent, 129 received. Cost: $0.02 request, $0.05 session.

> write a Python script which extracts the temperature of Graz 
  from https://wetter.orf.at/steiermark/

...

> add a requirement file to the project

...

In einem weiteren Terminal habe ich nun auch für dieses Projekt ein Python Environment eingerichtet und das Script ausprobiert:

(Virtual Environment einrichten, Requirements mit pip installieren ...)

python3 extract_graz_temperature.py 

  Graz Heinrichstrasse: 30,3 °C

Bingo! Das Script wählt eine der vier Messstellen von Graz aus und zeigt die Temperatur dort an. Wunderbar.

Dementsprechend ermutigt habe ich mein Glück weiter strapaziert. Das Script soll die Durchschnittstemperatur aller vier Messstellen ausrechnen. Zurück in Terminal 1 mit Aider. Wie die folgenden Prompts zeigen, sind fünf Versuche notwendig, bis Aider endlich funktionierenden Code zusammenbringt. (Die ursprüngliche Fassung versucht aus Zeichenketten wie ‚30,3 C‘ in Fließkommazahlen umzuwandeln. Es ignoriert sowohl das deutsche Dezimalformat als auch die Zeichenkette ‚ C‘ am Ende. Die ganze Prozedur dauert inklusive meiner Tests eine Viertelstunde.

> please change extract_graz_temperature.py to calculate the average temperature for Graz

> does not work because of german number format (1,3 instead of 1.3); please fix

> still fails, probably because temperature string contains ' C' at the end; please fix once more

> still fails, the space in ' C' is a fixed space; try again

> it's the unicode fixed blank; just drop the last two characters

Tokens: 3,153 sent, 211 received. Cost: $0.01 request, $0.16 session.

Immerhin, das Script funktioniert jetzt:

python3 extract_graz_temperature.py 

  Average temperature for Graz: 29.9°C

Die API-Kosten für die Entwicklung des Scripts betrugen 13 US Cents. Meine Arbeitszeit habe ich nicht gerechnet ;-)

Fazit

Im Internet finden Sie diverse Videos, wo Aider scheinbar auf Anhieb perfekt funktioniert. Meine Tests haben gezeigt, dass das durchaus nicht immer der Fall ist.

Was mich trotz aller Fehler begeistert, ist das Konzept: Am besten führen Sie Aider in einem VSCode-Terminal aus, während in VSCode das Projektverzeichnis geöffnet ist. (Das Ganze funktioniert natürlich auch mit jedem anderen Editor.) Dann haben Sie eine grandiose Umgebung zum Testen des Codes sowie für dessen Weiterentwickung mit Aider.

Ja, weder Aider noch die von Aider genutzten Sprachmodelle sind zum jetzigen Zeitpunkt perfekt. Aber das Potenzial, das hier schlummert, ist enorm. Sie sind damit quasi eine Abstraktionsebene über dem Code. Sie geben Aider Kommandos, wie es den Code weiterentwickeln oder verbessern soll, ohne sich im Detail mit Funktionen, Schleifen oder Variablen zu beschäftigen. (Dieses Wissen brauchen Sie zum Debugging aber weiterhin!)

Quellen/Links

• https://github.com/paul-gauthier/aider
• https://aider.chat/docs/usage/tutorials.html
• https://aider.chat/docs/leaderboards
• https://simonwillison.net/2024/Jul/31/aider
• YouTube: Claude 3.5 and aider: Use AI Assistants to Build AI Apps
• https://www.anthropic.com/api
• https://openai.com/index/openai-api/

Dies ist die Fortsetzung von „Mit InstructLab zu Large Language Models beitragen“. Hier beschreibe ich, wie es nach dem Training weitergeht.

Das Training auf einer virtuellen Maschine mit Fedora 40 Server, 10 CPU-Threads und 32 GB RAM dauerte 180 Std. 44 Min. 7 Sek. Ich halte an dieser Stelle fest, ohne GPU-Beschleunigung fehlt es mir persönlich an Geduld. So macht das Training keinen Spaß.

Nach dem Training mit ilab train findet man ein brandneues LLM auf dem eigenen System:

(venv) tronde@instructlab:~/src/instructlab$ ls -ltrh models
total 18G
-rw-r--r--. 1 tronde tronde 4.1G May 28 20:34 merlinite-7b-lab-Q4_K_M.gguf
-rw-r--r--. 1 tronde tronde  14G Jun  6 12:07 ggml-model-f16.gguf

Test des neuen Modells

Den Chat mit dem LLM starte ich mit dem Befehl ilab chat -m models/ggml-model-f16.gguf. Das folgende Bild zeigt zwei Chats mit jeweils unterschiedlichem Ergebnis:

Fazit

Schade, das hat nicht so funktioniert, wie ich mir das vorgestellt habe. Es kommt weiterhin zu KI-Halluzinationen und nur gelegentlich gesteht das LLM seine Unkenntnis bzw. seine Unsicherheit ein.

Für mich sind damit 180 Stunden Rechenzeit verschwendet. Ich werde bis auf Weiteres keine Trainings ohne Beschleuniger-Karten mehr durchführen. Jedoch werde ich mir von Zeit zu Zeit aktualisierte Releases der verfügbaren Modelle herunterladen und diesen Fragen stellen, deren Antworten ich bereits kenne.

Wenn sich mir die Gelegenheit bietet, diesen Versuch auf einem Rechner mit entsprechender GPU-Hardware zu wiederholen, werde ich die Erkenntnisse hier im Blog teilen.

Dies ist mein Erfahrungsbericht zu den ersten Schritten mit InstructLab. Ich gehe darauf ein, warum ich mich über die Existenz dieses Open Source-Projekts freue, was ich damit mache und was ich mir von Large Language Models (kurz: LLMs, zu Deutsch: große Sprachmodelle) erhoffe. Der Text enthält Links zu tiefergehenden Informationen, die euch mit Hintergrundwissen versorgen und einen Einstieg in das Thema ermöglichen.

Dieser Text ist keine Schritt-für-Schritt-Anleitung für:

• die Installation von InstructLab CLI,
• die Installation und das Training von LLMs

Terminologie und Abkürzungen in diesem Text

Die Begriffe Künstliche Intelligenz (KI) oder englisch artificial intelligence (AI) werden in diesem Text synonym verwendet und zumeist einheitlich durch KI abgekürzt.

Beim Bezug auf große Sprachmodelle bediene ich mich der englischen Abkürzung LLM oder bezeichne diese als KI-ChatBot bzw. nur ChatBot.

Was ist InstructLab?

InstructLab ist ein von IBM und Red Hat ins Leben gerufenes Open Source-Projekt, mit dem die Gemeinschaft zur Verbesserung von LLMs beitragen kann. Jeder

• mit einem Linux-Notebook oder
• MacBook und
• der Fähigkeit Anleitungen zu folgen und
• wer YAML-Dateien schreiben kann,

der kann nun teilhaben und ausgewählte LLMs lokal auf seinem Endgerät ausführen, testen und verbessern. Für eine ausführliche Beschreibung siehe:

• Was ist InstructLab?
• InstructLab: Advancing generative AI through open source
• Welcome to the InstructLab Project

Informationen zu Open Source LLMs und Basismodellen für InstructLab bieten diese Links:

• Open Source Large Language Models selbst betreiben. Thorsten Honroth, Dr. Julien Siebert und Patricia Kelbert. Blog des Frauenhofer-Institut für Experimentelles Software Engineering. 2024-01-19.
• Open source large language models: Benefits, risks and types. IBM Data and AI Team. IBM Blog. 2023-09-27.
• Open sourcing IBM’s Granite code models. Mike Murphy. IBM Research Blog. 2024-05-06.
• InstructLab-kompatible Basismodelle. IBM watsonx Docs.
• Hugging Face. The AI community building the future. The platform where the machine learning community collaborates on models, datasets, and applications. URL: https://huggingface.co/

Meine Einstellung gegenüber KI-ChatBots

Gegenüber KI-Produkten im Allgemeinen und KI-ChatBots im Speziellen bin ich stets kritisch, was nicht bedeutet, dass ich diese Technologien und auf ihnen basierende Produkte und Services ablehne. Ich versuche mir lediglich eine gesunde Skepsis zu bewahren.

Was Spielereien mit ChatBots betrifft, bin ich sicherlich spät dran. Ich habe schlicht keine Lust, mich irgendwo zu registrieren und unnötig Informationen über mich preiszugeben, nur um anschließend mit einer Büchse chatten und ihr Fragen stellen zu können, um den Wahrheitsgehalt der Antworten anschließend noch verifizieren zu müssen.

Mittlerweile gibt es LLMs, welche ohne spezielle Hardware auch lokal ausgeführt werden können. Diese sprechen meine Neugier und meinen Spieltrieb schon eher an, weswegen ich mich nun doch mit einem ChatBot unterhalten möchte.

Mein InstructLab-Setup

Für meine ersten Versuche nutze ich mein Lenovo ThinkPad T14s (AMD) in der Ausstattung von 2021. Aktuell installiert ist Fedora 40 Workstation, welches zu den getesteten Betriebssystemen von InstructLab zählt.

Die Einrichtung des InstructLab-CLI und der erste Chat

Für die Einrichtung halte ich mich an den Getting Started Guide. Es sind folgende Befehle auszuführen, bis das erste LLM gestartet werden kann:

sudo dnf install gcc-c++ gcc make pip python3 python3-devel python3-GitPython
mkdir instructlab
cd instructlab
python3 -m venv --upgrade-deps venv
source venv/bin/activate
pip cache remove llama_cpp_python
pip install git+https://github.com/instructlab/instructlab.git@stable --extra-index-url=https://download.pytorch.org/whl/cpu
eval "$(_ILAB_COMPLETE=bash_source ilab)"
ilab init
ilab download
ilab serve

Der lokale LLM-Server wird mit dem Befehl ilab serve gestartet. Mit dem Befehl ilab chat wird die Unterhaltung mit dem Modell eingeleitet.

Im folgenden Video sende ich zwei Anweisungen an das LLM merlinite-7b-lab-Q4_K_M. Den Chatverlauf seht ihr in der rechten Bildhälfte. In der linken Bildhälfte seht ihr die Ressourcenauslastung meines Laptops.

Wie ihr seht, sind die Antwortzeiten des LLM auf meinem Laptop nicht gerade schnell, aber auch nicht so langsam, dass ich währenddessen einschlafe oder das Interesse an der Antwort verliere. An der CPU-Auslastung im Cockpit auf der linken Seite lässt sich erkennen, dass das LLM durchaus Leistung abruft und die CPU fordert.

Exkurs: Die Studie Energieverbrauch Index-basierter und KI-basierter Websuchmaschinen gibt einen interessanten Einblick in den Ressourcenverbrauch. Leider war ich nicht in der Lage, diese Studie als PDF aufzutreiben.

Mit den Antworten des LLM bin ich zufrieden. Sie decken sich mit meiner Erinnerung und ein kurzer Blick auf die Seite https://www.json.org/json-de.html bestätigt, dass die Aussagen des LLM korrekt sind.

Anmerkung: Der direkte Aufruf der Seite https://json.org, der mich mittels Redirect zu obiger URL führte, hat sicher deutlich weniger Energie verbraucht als das LLM oder eine Suchanfrage in irgendeiner Suchmaschine. Ich merke dies nur an, da ich den Eindruck habe, dass es aus der Mode zu geraten scheint, URLs einfach direkt in die Adresszeile eines Webbrowsers einzugeben, statt den Seitennamen in eine Suchmaske zu tippen.

Ich halte an dieser Stelle fest, der erste kleine Test wird zufriedenstellend absolviert.

KI-Halluzinationen

Da ich einige Zeit im Hochschulrechenzentrum der Universität Bielefeld gearbeitet habe, interessiert mich, was das LLM über meine ehemalige Dienststelle weiß. Im nächsten Video frage ich, wer der Kanzler der Universität Bielefeld ist.

Da ich bis März 2023 selbst an der Universität Bielefeld beschäftigt war, kann ich mit hinreichender Sicherheit sagen, dass diese Antwort falsch ist und das Amt des Kanzlers nicht von Prof. Dr. Karin Vollmerd bekleidet wird. Im Personen- und Einrichtungsverzeichnis (PEVZ) findet sich für Prof. Dr. Vollmerd keinerlei Eintrag. Für den aktuellen Kanzler Dr. Stephan Becker hingegen schon.

Da eine kurze Recherche in der Suchmaschine meines geringsten Misstrauens keine Treffer zu Frau Vollmerd brachte, bezweifle ich, dass diese Person überhaupt existiert. Es kann allerdings auch in meinen unzureichenden Fähigkeiten der Internetsuche begründet liegen.

Bei der vorliegenden Antwort handelt es sich um eine Halluzination der Künstlichen Intelligenz.

Im Bereich der Künstlichen Intelligenz (KI) ist eine Halluzination (alternativ auch Konfabulation genannt) ein überzeugend formuliertes Resultat einer KI, das nicht durch Trainingsdaten gerechtfertigt zu sein scheint und objektiv falsch sein kann.

Solche Phänomene werden in Analogie zum Phänomen der Halluzination in der menschlichen Psychologie als von Chatbots erzeugte KI-Halluzinationen bezeichnet. Ein wichtiger Unterschied ist, dass menschliche Halluzinationen meist auf falschen Wahrnehmungen der menschlichen Sinne beruhen, während eine KI-Halluzination ungerechtfertigte Resultate als Text oder Bild erzeugt. Prabhakar Raghavan, Leiter von Google Search, beschrieb Halluzinationen von Chatbots als überzeugend formulierte, aber weitgehend erfundene Resultate.

Quelle: https://de.wikipedia.org/wiki/Halluzination_(K%C3%BCnstliche_Intelligenz)

Oder wie ich es umschreiben möchte: „Der KI-ChatBot demonstriert sichereres Auftreten bei völliger Ahnungslosigkeit.“

Wenn ihr selbst schon mit ChatBots experimentiert habt, werdet ihr sicher selbst schon auf Halluzinationen gestoßen sein. Wenn ihr mögt, teilt doch eure Erfahrungen, besonders jene, die euch fast aufs Glatteis geführt haben, in den Kommentaren mit uns.

Welche Auswirkungen überzeugend vorgetragene Falschmeldungen auf Nutzer haben, welche nicht über das Wissen verfügen, diese Halluzinationen sofort als solche zu entlarven, möchte ich für den Moment eurer Fantasie überlassen.

Ich denke an Fahrplanauskünfte, medizinische Diagnosen, Rezepturen, Risikoeinschätzungen, etc. und bin plötzlich doch ganz froh, dass sich die EU-Staaten auf ein erstes KI-Gesetz einigen konnten, um KI zu regulieren. Es wird sicher nicht das letzte sein.

Um das Beispiel noch etwas auszuführen, frage ich das LLM erneut nach dem Kanzler der Universität und weise es auf seine Falschaussagen hin. Der Chatverlauf ist in diesem Video zu sehen:

Die Antworten des LLM enthalten folgende Fehler:

• Professor Dr. Ulrich Heidt ist nicht der Kanzler der Universität Bielefeld
• Die URL ‚https://www.uni-bielefeld.de/english/staff/‘ existiert nicht
• Die URL ‚http://www.universitaet-bielefeld.de/en/‘ existiert ebenfalls nicht
• Die Universität hieß niemals „Technische Universitaet Braunschweig“
• Sie wurde 2009 auch nicht umbenannt
• Es gibt nicht 8, sondern 14 Fakultäten

Der Chatverlauf erweckt den Eindruck, dass der ChatBot sich zu rechtfertigen versucht und nach Erklärungen und Ausflüchten sucht. Hier wird nach meinem Eindruck menschliches Verhalten nachgeahmt. Dabei sollten wir Dinge nicht vermenschlichen. Denn unser Chatpartner ist kein Mensch. Er ist eine leblose Blechbüchse. Das LLM belügt uns auch nicht in böser Absicht, es ist schlicht nicht in der Lage, uns eine korrekte Antwort zu liefern, da ihm dazu das nötige Wissen bzw. der notwendige Datensatz fehlt. Daher versuche ich im nächsten Schritt, dem LLM mit InstructLab das notwendige Wissen zu vermitteln.

Wissen und Fähigkeiten hinzufügen und das Modell anlernen

Das README.md im Repository instructlab/taxonomy enthält die Beschreibung, wie man dem LLM Wissen (englisch: knowledge) hinzufügt. Weitere Hinweise finden sich in folgenden Dateien:

• https://github.com/instructlab/taxonomy/blob/main/README.md#getting-started-with-knowledge-contributions
• https://github.com/instructlab/taxonomy/blob/main/docs/knowledge-contribution-guide.md
• https://github.com/instructlab/instructlab/blob/main/README.md#-creating-new-knowledge-or-skills-and-training-the-model

Diese Dateien befinden sich auch in dem lokalen Repository unterhalb von ~/instructlab/taxonomy/. Ich hangel mich an den Leitfäden entlang, um zu sehen, wie weit ich damit komme.

Wissen erschaffen

Die Überschrift ist natürlich maßlos übertrieben. Ich stelle lediglich existierende Informationen in erwarteten Dateiformaten bereit, um das LLM damit trainieren zu können.

Da aktuell nur Wissensbeiträge von Wikipedia-Artikeln akzeptiert werden, gehe ich wie folgt vor:

1. Erstelle das Repository https://github.com/Tronde/instructlab_knowledge_contributions_unibi mit einer README.md, ohne .gitignore und LICENCE
2. Konvertiere den Wikipedia-Artikel Bielefeld University ohne Bilder und Tabellen in eine Markdown-Datei und füge sie dem in Schritt 1 erstellten Repository unter dem Namen unibi.md hinzu
3. Füge dem lokalen Taxonomy-Repository neue Verzeichnisse hinzu: mkdir -p university/germany/bielefeld_university
4. Erstelle in dem neuen Verzeichnis eine qna.yaml und eine attribution.txt Datei
5. Führe ilab diff aus, um die Daten zu validieren

Der folgende Code-Block zeigt den Inhalt der Dateien qna.yaml und eine attribution.txt sowie die Ausgabe des Kommandos ilab diff:

(venv) [tronde@t14s instructlab]$ cat /home/tronde/src/instructlab/taxonomy/knowledge/university/germany/bielefeld_university/qna.yaml
version: 2
task_description: 'Teach the model the who facts about Bielefeld University'
created_by: tronde
domain: university
seed_examples:
 - question: Who is the chancellor of Bielefeld Universtiy?
   answer: Dr. Stephan Becker is the chancellor of the Bielefeld University.
 - question: When was the University founded?
   answer: |
     The Bielefeld Universtiy was founded in 1969.
 - question: How many students study at Bielefeld University?
   answer: |
     In 2017 there were 24,255 students encrolled at Bielefeld Universtity?
 - question: Do you know something about the Administrative staff?
   answer: |
     Yes, in 2017 the number for Administrative saff was published as 1,100.
 - question: What is the number for Academic staff?
   answer: |
     In 2017 the number for Academic staff was 1,387.
document:
 repo: https://github.com/Tronde/instructlab_knowledge_contributions_unibi.git
 commit: c2d9117
 patterns:
  - unibi.md
(venv) [tronde@t14s instructlab]$ 
(venv) [tronde@t14s instructlab]$ 
(venv) [tronde@t14s instructlab]$ cat /home/tronde/src/instructlab/taxonomy/knowledge/university/germany/bielefeld_university/attribution.txt 
Title of work: Bielefeld University
Link to work: https://en.wikipedia.org/wiki/Bielefeld_University
License of the work: CC-BY-SA-4.0
Creator names: Wikipedia Authors
(venv) [tronde@t14s instructlab]$ 
(venv) [tronde@t14s instructlab]$ 
(venv) [tronde@t14s instructlab]$ ilab diff
knowledge/university/germany/bielefeld_university/qna.yaml
Taxonomy in /taxonomy/ is valid :)
(venv) [tronde@t14s instructlab]$

Synthetische Daten generieren

Aus der im vorherigen Abschnitt erstellten Taxonomie generiere ich im nächsten Schritt synthetische Daten, welche in einem folgenden Schritt für das Training des LLM genutzt werden.

Dazu wird der Befehl ilab generate aufgerufen, während sich das LLM noch in Ausführung befindet. Dieser endet bei mir erfolgreich mit folgendem Ergebnis:

(venv) [tronde@t14s instructlab]$ ilab generate
[…]
INFO 2024-05-28 12:46:34,249 generate_data.py:565 101 instructions generated, 62 discarded due to format (see generated/discarded_merlinite-7b-lab-Q4_K_M_2024-05-28T09_12_33.log), 4 discarded due to rouge score
INFO 2024-05-28 12:46:34,249 generate_data.py:569 Generation took 12841.62s
(venv) [tronde@t14s instructlab]$ ls generated/
discarded_merlinite-7b-lab-Q4_K_M_2024-05-28T09_12_33.log
generated_merlinite-7b-lab-Q4_K_M_2024-05-28T09_12_33.json
test_merlinite-7b-lab-Q4_K_M_2024-05-28T09_12_33.jsonl
train_merlinite-7b-lab-Q4_K_M_2024-05-28T09_12_33.jsonl

Zur Laufzeit werden alle CPU-Threads voll ausgelastet. Auf meinem Laptop dauerte dieser Vorgang knapp 4 Stunden.

Das Training beginnt

Jetzt wird es Zeit, das LLM mit den synthetischen Daten anzulernen bzw. zu trainieren. Dieser Vorgang wird mehrere Stunden in Anspruch nehmen und ich verplane mein Laptop in dieser Zeit für keine weiteren Arbeiten.

Um möglichst viele Ressourcen freizugeben, beende ich das LLM (ilab serve und ilab chat). Das Training beginnt mit dem Befehl ilab train… und dauert wirklich lange.

Nach 2 von 101 Durchläufen wird die geschätzte Restlaufzeit mit 183 Stunden angegeben. Das Ergebnis spare ich mir dann wohl für einen Folgeartikel auf und gehe zum Fazit über.

Fazit

Mit dem InstructLab Getting Started Guide gelingt es in kurzer Zeit, das Projekt auf einem lokalen Linux-Rechner einzurichten, ein LLM auszuführen und mit diesem zu chatten.

KI-Halluzinationen stellen in meinen Augen ein Problem dar. Da LLMs überzeugend argumentieren, kann es Nutzern schwerfallen oder gar misslingen, die Falschaussagen als solche zu erkennen. Im schlimmsten Fall lernen Nutzer somit dummen Unfug und verbreiten diesen ggf. weiter. Dies ist allerdings kein Problem bzw. Fehler des InstructLab-Projekts, da alle LLMs in unterschiedlicher Ausprägung von KI-Halluzinationen betroffen sind.

Wie Knowledge und Skills hinzugefügt werden können, musste ich mir aus drei Guides anlesen. Dies ist kein Problem, doch kann der Leitfaden evtl. noch etwas verbessert werden.

Knowledge Contributions werden aktuell nur nach vorheriger Genehmigung und nur von Wikipedia-Quellen akzeptiert. Der Grund wird nicht klar kommuniziert, doch ich vermute, dass dies etwas mit geistigem Eigentum und Lizenzen zu tun hat. Wikipedia-Artikel stehen unter einer Creative Commons Attribution-ShareAlike 4.0 International License und können daher unkompliziert als Quelle verwendet werden. Da sich das Projekt in einem frühen Stadium befindet, kann ich diese Limitierung nachvollziehen. Ich wünsche mir, dass grundsätzlich auch Primärquellen wie Herstellerwebseiten und Publikationen zugelassen werden, wenn Rechteinhaber dies autorisieren.

Der von mir herangezogene Wikipedia-Artikel ist leider nicht ganz aktuell. Nutze ich ihn als Quelle für das Training eines LLM, bringe ich dem LLM damit veraltetes und nicht mehr gültiges Wissen bei. Das ist für meinen ersten Test unerheblich, für Beiträge zum Projekt jedoch nicht sinnvoll.

Die Generierung synthetischer Daten dauert auf Alltagshardware schon entsprechend lange, das anschließende Training jedoch nochmals bedeutend länger. Dies ist meiner Ansicht nach nichts, was man nebenbei auf seinem Laptop ausführt. Daher habe ich den Test auf meinem Laptop abgebrochen und lasse das Training aktuell auf einem Fedora 40 Server mit 32 GB RAM und 10 CPU-Kernen ausführen. Über das Ergebnis und einen Test des verbesserten Modells werde ich in einem folgenden Artikel berichten.

Was ist mit euch? Kennt ihr das Projekt InstructLab und habt evtl. schon damit gearbeitet? Wie sind eure Erfahrungen?

Arbeitet ihr mit LLMs? Wenn ja, nutzt ihr diese nur oder trainiert ihr sie auch? Was nutzt ihr für Hardware?

Ich freue mich, wenn ihr eure Erfahrungen hier mit uns teilt.

Die Geschwindigkeit bei der lokalen Ausführung großer Sprachmodelle (LLMs) wird in Zukunft zu einem entscheidenden Kriterium für die CPU/GPU-Auswahl werden. Das gilt insbesondere für Software-Entwickler, die LLMs lokal nutzen möchten anstatt alle Daten an Anbieter wie ChatGPT in die Cloud zu übertragen.

Umso verblüffender ist es, dass es dafür aktuell kaum brauchbare Benchmarks gibt. In Anknüpfung an meinen Artikel Sprachmodelle lokal ausführen und mit Hilfe des Forum-Feedbacks habe ich die folgende Abbildung zusammengestellt.

Die Geschwindigkeit in Token/s wird — zugegeben unwissenschaftlich — mit der Ausführung des folgenden Kommandos ermittelt:

ollama run  llama2 "write a python function to extract email addresses from a string" --verbose

oder

ollama run  llama3 "write a python function to extract email addresses from a string" --verbose

Bei den Tests ist llama3 um ca. 10 Prozent langsamer als llama2, liefert also etwas weniger Token/s. Möglicherweise liegt dies ganz einfach daran, dass das Sprachmodell llama3 in der Standardausführung etwas größer ist als llama2 (7 versus 8 Mrd. Parameter). Aber an der Größenordnung der Ergebnisse ändert das wenig, die Werte sind noch vergleichbar.

Beachten Sie, dass die im Diagramm angegebenen Werte variieren können, je nach installierten Treiber, Stromversorgung, Kühlung (speziell bei Notebooks) etc.

Helfen Sie mit! Wenn Sie Ollama lokal installiert haben, posten Sie bitte Ihre Ergebnisse zusammen mit den Hardware-Eckdaten im Forum. Verwenden Sie als Sprachmodell llama2 bzw. llama3 in der Defaultgröße (also mit 7 bzw. 8 Mrd. Parameter, entspricht llama2:7b oder llama3:8b). Das Sprachmodell ist dann ca. 4 bzw. 5 GByte groß, d.h. die Speicheranforderungen sind gering. (Falls Sie das LLM mit einer dezidierten GPU ausführen, muss diese einen ausreichend großen Speicher haben, in dem das ganze Sprachmodell Platz findet. Je nach Betriebssystem sind u.U. zusätzliche Treiber notwendig, damit die GPU überhaupt genutzt wird.)

Ich werde das Diagramm gelegentlich mit neuen Daten aktualisieren.

Mit GPT4All gibt es bereits einen Chatbot wie ChatGPT, den Du auf Deinem Computer installieren und offline benutzen kannst. Möchtest Du offline Bilder mithilfe einer KI erstellen, dann eignet sich Stable Diffusion hervorragend dafür. Auch diese Software kannst Du offline installieren und nutzen. Vorteilhaft ist ein schneller Computer mit ordentlich Speicher und im Idealfall eine schnelle Grafikkarte. Mein Tuxedo Fusion ist auf jeden Fall schnell genug und hat ausreichend RAM, um binnen weniger Sekunden KI-Bilder mit Stable Diffusion zu erstellen […]

Der Beitrag Stable Diffusion auf Ubuntu /Linux Mint – KI-Bilder offline erstellen ist von bitblokes.de.

ChatGPT, Copilot & Co. verwenden Large Language Models (LLMs). Diese werden auf leistungsstarken Servern ausgeführt und als Cloud-Services angeboten. Das funktioniert wunderbar. Aber nicht jeder will Daten, Text und Code ständig in die Cloud hochladen. Kann man also — mit »gewöhnlicher« Hardware — LLMs auch lokal ausführen?

Tatsächlich ist das verblüffend einfach. Das Tool der Wahl heißt Ollama. Was Docker für Container ist, ist Ollama für LLMs!

Ollama kann ziemlich mühelos unter Linux, macOS und Windows installiert werden. Unter Windows und macOS starten Sie Ollama als Hintergrunddienst mit einer winzigen grafischen Oberfläche (im Prinzip nur ein Icon, das den Status anzeigt). Unter Linux richten Sie den Dienst mit systemctl ein:

systemctl enable --now ollama

Ollama anwenden

Jetzt können Sie Ollama mit dem gleichnamigen Kommando im Terminal ausführen. Mit ollama run <llmname> installieren Sie eines der öffentlich verfügbaren Sprachmodelle (mehr dazu im nächsten Abschnitt) und können dann im Textmodus Kommandos ausführen:

ollama run llama2

>>> I need a regex to verify a date in US format. Can you help?

Of course! To match a date in the format of "MM/DD/YYYY" (month-day-year) 
or "MM/DD/YYYY HH:MM AM/PM", you can use the following regular expression:

\b(\d{1,2}/\d{1,2}/\d{4})|(\d{1,2}/\d{1,2}/\d{4} \d{0,2})?\b

Here's a breakdown of how this regex works:

* \b: Matches a word boundary (the start or end of a word) to ensure 
  we're matching the entire date field.

* (\d{1,2}/\d{1,2}/\d{4}): Matches the month/day/year format. The 
  (\d{1,2}) captures the month and day as individual digits (0-2 
  digits for the month and 1-2 digits for the day). The / separates 
  the date components.

* |: Or, used to match the alternative format.

* (\d{1,2}/\d{1,2}/\d{4} \d{0,2})?: Matches the month/day/year with 
  time format. The (\d{1,2}) captures the month and day as individual 
  digits (0-2 digits for the month and 1-2 digits for the day). The / 
  separates the date components. The \d{0,2} matches the time component 
  (0-2 digits representing the hour and minute).

* \b: Matches a word boundary to ensure we're matching the entire date field again.

Note that this regex will match both US and international dates in the 
"MM/DD/YYYY" format, as well as dates in the "MM/DD/YYYY HH:MM AM/PM" 
format. If you need a more specific format (e.g., only US dates), 
feel free to modify the regex accordingly.

Manche Sprachmodelle können auch Deutsch (nochmals llama2), wenngleich die sprachliche Qualität mitunter nur mittelmäßig ist.

>>> Was ist der Dopplereffekt?

Der Dopplereffekt ist ein physikalischer Effekt, der durch die Beugung von
Lichtwellen verursacht wird, wenn diese durch eine mediummässige Materie
passt. In einer bestimmten Umgebung oder Situation kann das Licht, das durch
eine bestimmte Fläche oder ein Objekt passt, sich "verlangsamen" und eine
Dopplereffekthelligkeit erzeugen.

Der Dopplereffekt ist ein spezifischer Effekt, der auf der Beugung von
Lichtwellen basiert. Wenn Licht durch ein Medium passt, wird es durch die Faser
des Mediums beugt und umgestaltet. Die Intensität des Lichts, das durch ein
Medium passt, kann sich durch den Dopplereffekt ändern.

Im Alltag können wir den Dopplereffekt beispielsweise bei der Anähnlichkeit von
Objekten in einer Ferne sehen. Wenn ein Auto oder eine andere Objekte in der
Ferne auf uns zukommt, wird es durch die Luft des Raumes beugt und erscheint
größer und weiter weg, als es tatsächlich ist.

Der Dopplereffekt kann auch in anderen Bereichen wie der Optik, Elektrotechnik
oder Medizin verwendet werden. Zum Beispiel können Dopplereffekte in der
Medizin verwendet werden, um die Blutungen in einem Körperteil zu bestimmen.

Es gibt verschiedene Arten von Dopplereffekten, darunter:

* LichtDopplereffekt: Der Effekt, den das Licht erzeugt, wenn es durch ein
  Medium passt.
* ZeitDopplereffekt: Der Effekt, den die Zeit erzeugt, wenn sie durch ein
  Objekt oder eine bestimmte Umgebung verändert wird.
* Räumliche Dopplereffekte: Der Effekt, den die räumliche Position von Objekten
  oder der Standort eines Beobachters auf die Erscheinung des Dopplereffekts
  ausübt.

Insgesamt ist der Dopplereffekt ein interessanter und wichtiger
physikalischerEffekt, der in vielen Bereichen der Wissenschaft und Technologie
Verwendung findet.

Ollama stellt seine Funktionen über eine REST-API zur Verfügung und kann somit lokal auch durch eigene Scripts und Editor-Plugins (z.B. Continue für VSCode) genutzt werden. Natürlich gibt es auch Module/Bibliotheken für diverse Sprachen, z.B. für Python.

Öffentliche Sprachmodelle

Die bekanntesten Sprachmodelle sind zur Zeit GPT-3.5 und GPT-4. Sie wurden von der Firma openAI entwickelt und sind die Basis für ChatGPT. Leider sind die aktellen GPT-Versionen nicht öffentlich erhältlich.

Zum Glück gibt es aber eine Menge anderer Sprachmodelle, die wie Open-Source-Software kostenlos heruntergeladen und von Ollama ausgeführt werden können. Gut geeignet für erste Experimente sind llama2, gemma und mistral. Einen Überblick über wichtige, Ollama-kompatible LLMs finden Sie hier:

https://ollama.com/library

Noch viel mehr LLMs finden Sie auf HuggingFace, einer öffentlichen Plattform für KI-Forscher und -Anwender:

https://huggingface.co/models

Viele Sprachmodelle stehen in unterschiedlicher Größe zur Verfügung. Die Größe wird in der Anzahl der Parameter gemessen (7b = 7 billions = 7 Milliarden). Die Formel »größer ist besser« gilt dabei nur mit Einschränkungen. Mehr Parameter versprechen eine bessere Qualität, das Modell ist dann aber langsamer in der Ausführung und braucht mehr Platz im Arbeitsspeicher. Die folgende Tabelle gilt für llama2, einem frei verfügbaren Sprachmodell der Firma Meta (Facebook & Co.).

Name.        Parameter     Größe
----------  ----------  --------
llama2           7 Mrd.     4 GB
llama2:13b      13 Mrd.     7 GB
llama2:70b      70 Mrd.    39 GB

Wenn Sie llama2:70b ausführen wollen, sollte Ihr Rechner über 64 GB RAM verfügen.

Update: Quasi zugleich mit diesem Artikel wurde llama3 fertiggestellt (Details und noch mehr Details). Aktuell gibt es zwei Größen, 8b (5 GB) und 80b (40 GB).

Bildverarbeitung

Ollama kann aber auch KI-Modelle zur Bildverarbeitung ausführen, z.B. LLaVA (siehe https://ollama.com/blog/vision-models).

ollama run llava:13b

>>> describe this image: raspap3.jpg 

Added image 'raspap3.jpg' 

The image shows a small, single-board computer like the Raspberry Pi 3, which is 
known for its versatility and uses in various projects. It appears to be connected 
to an external device via what looks like a USB cable with a small, rectangular
module on the end, possibly an adapter or expansion board. This connection
suggests that the device might be used for communication purposes, such as
connecting it to a network using an antenna. The antenna is visible in the
upper part of the image and is connected to the single-board computer by a
cable, indicating that this setup could be used for Wi-Fi or other wireless
connectivity.

The environment seems to be an indoor setting with wooden flooring, providing a
simple and clean background for the electronic components. There's also a label
on the antenna, though it's not clear enough to read in this image. The setup
is likely part of an electronics project or demonstration, given the simplicity
and focus on the connectivity equipment rather than any additional peripherals
or complex arrangements.

Eigentlich eine ganz passable Beschreibung für das folgende Bild!

Praktische Erfahrungen, Qualität

Es ist erstaunlich, wie rasch die Qualität kommerzieller KI-Tools — gerade noch als IT-Wunder gefeiert — zur Selbstverständlichkeit wird. Lokale LLMs funktionieren auch gut, können aber in vielerlei Hinsicht (noch) nicht mit den kommerziellen Modellen mithalten. Dafür gibt es mehrere Gründe:

• Bei kommerziellen Modellen fließt mehr Geld und Mühe in das Fine-Tuning.

• Auch das Budget für das Trainingsmaterial ist größer.

• Kommerzielle Modelle sind oft größer und laufen auf besserer Hardware. Das eigene Notebook ist mit der Ausführung (ganz) großer Sprachmodelle überfordert. (Siehe auch den folgenden Abschnitt.)

Wodurch zeichnet sich die geringere Qualität im Vergleich zu ChatGPT oder Copilot aus?

• Die Antworten sind weniger schlüssig und sprachlich nicht so ausgefeilt.

• Wenn Sie LLMs zum Coding verwenden, passt der produzierte Code oft weniger gut zur Fragestellung.

• Die Antworten werden je nach Hardware viel langsamer generiert. Der Rechner läuft dabei heiß.

• Die meisten von mir getesteten Modelle funktionieren nur dann zufriedenstellend, wenn ich in englischer Sprache mit ihnen kommuniziere.

Die optimale Hardware für Ollama

Als Minimal-Benchmark haben Bernd Öggl und ich das folgende Ollama-Kommando auf diversen Rechnern ausgeführt:

ollama run  llama2 "write a python function to extract email addresses from a string" --verbose

Die Ergebnisse dieses Kommandos sehen immer ziemlich ähnlich aus, aber die erforderliche Wartezeit variiert beträchtlich!

Update: Grafische Darstellung der Geschwindigkeit unter https://kofler.info/mini-benchmark-fuer-die-ausfuehrung-lokaler-sprachmodelle/

Lenovo T16, Linux. 12th Gen Intel i5-1250P cores=12, 32 GiB RAM, Alder Lake-P Integrated Graphics Controller

total duration:       4m7.981004535s
load duration:        979.201µs
prompt eval count:    31 token(s)
prompt eval duration: 3.061771s
prompt eval rate:     10.12 tokens/s
eval count:           478 token(s)
eval duration:        4m4.913456s
eval rate:            1.95 tokens/s

Lenovo P1 (2018), Linux. Intel i8750H 6 cores / 12 threads, 32 GiB RAM, NVIDIA Quadro P1000

Die GPU wurde nicht genutzt.

total duration:       1m48.168754835s
load duration:        204.369µs
prompt eval duration: 146.12ms
prompt eval rate:     0.00 tokens/s
eval count:           629 token(s)
eval duration:        1m48.021933s
eval rate:            5.82 tokens/s 

MacBook Air 2020, M1, 8GiB RAM

total duration:       52.303529042s
load duration:        4.741221334s
prompt eval count:    31 token(s)
prompt eval duration: 331.908ms
prompt eval rate:     93.40 tokens/s
eval count:           567 token(s)
eval duration:        47.211456s
eval rate:            12.01 tokens/s

MacBook Air M2 2023, 24 GB

total duration:       35.853232792s
load duration:        5.297790333s
prompt eval count:    32 token(s)
prompt eval duration: 211.272ms
prompt eval rate:     151.46 tokens/s
eval count:           617 token(s)
eval duration:        30.343375s
eval rate:            20.33 tokens/s

MacBook Pro M3 Pro 2023, 36 GB

total duration:       28.392226667s
load duration:        5.532561667s
prompt eval count:    31 token(s)
prompt eval duration: 119.313ms
prompt eval rate:     259.82 tokens/s
eval count:           667 token(s)
eval duration:        22.740198s
eval rate:            29.33 tokens/s 

Bzw. mit llama3:8b: 26,6 tokens/s.

Windows PC i7 64GB RAM + Nvidia 3070

total duration:       12.9912206s
load duration:        5.2628606s
prompt eval count:    31 token(s)
prompt eval duration: 83.136ms
prompt eval rate:     372.88 tokens/s
eval count:           514 token(s)
eval duration:        7.644094s
eval rate:            67.24 tokens/s 

Linux PC, AMD Ryzen 5 7600 64 GB RAM + Nvidia RTX3090 mit 24 GB RAM

(mit llama3)

total duration:       5.008054596s
load duration:        899.374µs
prompt eval duration: 17.275ms
prompt eval rate:     0.00 tokens/s
eval count:           473 token(s)
eval duration:        4.948306s
eval rate:            95.59 tokens/s

Grundsätzlich kann Ollama GPUs nutzen (siehe auch hier und hier). Im Detail hängt es wie immer vom spezifischen GPU-Modell, von den installierten Treibern usw. ab. Wenn Sie unter Linux mit einer NVIDIA-Grafikkarte arbeiten, müssen Sie CUDA-Treiber installieren und ollama-cuda ausführen. Beachten Sie auch, dass das Sprachmodell im Speicher der Grafikkarte Platz finden muss, damit die GPU genutzt werden kann.

Apple-Rechner mit M1/M2/M3-CPUs sind für Ollama aus zweierlei Gründen ideal: Es gibt keinen Ärger mit Treibern, und der gemeinsame Speicher für CPU/GPU ist vorteilhaft. Die GPUs verfügen über so viel RAM wie der Rechner. Außerdem bleibt der Rechner lautlos, wenn Sie Ollama nicht ununterbrochen mit neuen Abfragen beschäftigen. Allerdings verlangt Apple leider vollkommen absurde Preise für RAM-Erweiterungen.

Zum Schluss noch eine Bitte: Falls Sie Ollama auf Ihrem Rechner installiert haben, posten Sie bitte Ihre Ergebnisse des Kommandos ollama run llama2 "write a python function to extract email addresses from a string" --verbose im Forum!

Quellen/Links

• https://ollama.com
• https://github.com/ollama/ollama
• https://github.com/ollama/ollama-python
• https://continue.dev/docs/intro
• https://ollama.com/library
• https://huggingface.co/models
• https://ollama.com/blog/llama3
• https://huggingface.co/meta-llama/Meta-Llama-3-70B-Instruct
• https://ollama.com/blog/vision-models
• https://llama.meta.com
• https://llava-vl.github.io
• https://github.com/ollama/ollama/blob/main/docs/gpu.md
• https://github.com/ollama/ollama/issues/1651

Weitere Links zum Thema GPU/NPU-Nutzung:

• https://github.com/ollama/ollama/issues/1986 (macOS: max. 2/3 bzw. 3/4 des RAMS für GPU)
• https://www.reddit.com/r/LocalLLaMA/comments/1ckoyn4/mac_studio_with_192gb_still_the_best_option_for_a/
• https://blog.tarsis.org/2024/04/22/the-case-for-mac-power-usage/

Das Team von Nextcloud hat ein großes Update für den Nextcloud KI-Assistenten zur Verfügung gestellt. Ab sofort gibt es Context Chat und Context Write. Zudem ist GPU-Beschleunigung möglich und der Nextcloud-Server lässt sich vom KI-Server abspalten. Ferner arbeitet das Nextcloud-Team mit mehreren bekannten europäischen Hosting-Unternehmen zusammen, darunter IONOS und OVHcloud, um KI-as-a-Service-Lösungen anzubieten, die Privatsphäre und digitale Souveränität respektieren. In diesem Fall benötigst Du selbst keine teuren GPUs, um KI und Nextcloud zu vereinen. Nextcloud Assistant 2.0 Die Oberfläche wurde […]

Der Beitrag Nextcloud veröffentlicht großes Update für KI-Assistant – 2.0 ist von bitblokes.de.

Ich habe bei meiner Nextcloud-Testinstanz die Beta-Version von Nextcloud 29 installiert und war etwas neugierig. Insbesondere die Optionen für KI haben mich interessiert. Bei der letzten Version wurden Möglichkeiten erwähnt, Bilder via KI erstellen zu lassen und so weiter. Allerdings habe ich keine Möglichkeiten gefunden, die erwähnten Funktionen einfach zu nutzen. Mit Nextcloud 29 scheint die Sache nun ein Gesicht zu bekommen. Werfen wir zunächst einen Blick darauf, wie der Nextcloud-Assistent in Version 28 aussieht. Betreibst Du selbst eine NC, […]

Der Beitrag Nextcloud 29 wird viel mehr KI-Optionen zur Verfügung stellen ist von bitblokes.de.

Ab sofort kannst Du die Open-Source-Fotoverwaltungs-Software digiKam 8.3 herunterladen. Es gibt 250 Bugfixes, aber auch interessante Neuerungen. Es gibt etwa ein Tool, womit Du Fotos und Bildern automatisch Tags zuweisen kannst. Dafür wird ein neuronales Netzwerk für Deep Learning benutzt. Du findest hier genaue Details zu dieser Funktion. Du findest die Funktion unter Extras > Wartung > Auto tags. Die Funktion mit dem automatischen Zuordnen von Tags ist auch im QueueManager verfügbar. Ebenso gibt es im QueueManager ein neues Tool, […]

Der Beitrag digiKam 8.3 – Tags mit KI automatisch hinzufügen ist von bitblokes.de.

Ein neuer adminForge Service kann ab sofort genutzt werden. Mit BreezeWiki habt ihr ein alternatives und quelloffenes Fandom-Frontend, welches euch ein aufgeräumtes und werbefreies stöbern ermöglicht. BreezeWiki: Fandom-Frontend Mit BreezeWiki habt ihr ein alternatives...

by adminForge.