Llama 3 als Conversational-AI mittels AIME-API-Server betreiben

In unseren vorherigen Artikeln über die Llama-Modelle (Llama 2, Llama 1) haben wir uns ausführlich damit beschäftigt, wie man Llama als Konsolenanwendung ausführt und es mittels AIME-API-Server als Chat-Anwendung bereitstellt. Im Folgenden wird nun erklärt, wie einfach sich das Nachfolgemodell Llama 3 mit Hilfe des AIME-API-Servers als Conversational-AI-Anwendung einrichten lässt.

Bei AIME wissen wir, wie wichtig es sein wird, KI-Modelle als Dienste anbieten zu können, um das volle Potenzial von Technologien wie Llama nutzen zu können. Deshalb freuen wir uns, die Integration von Llama 3 in die AIME-API als einer der ersten Anbieter ankündigen zu können.

Die AIME API ermöglicht die Nutzbarmachung von KI-Modellen, z.B. als GenAI-Tools, und vereinfacht deren Integration als skalierbare HTTP/HTTPS-Dienste in Client-Anwendungen.

Für Entwickler von Chatbots, virtuellen Assistenten oder interaktiven Kundensupport-Systemen bietet diese Art der Anbindung die gewünschte Flexibilität, um jederzeit Modifikationen und Anpassungen am verwendeten Modell vornehmen zu können, sowie die benötigte Skalierbarkeit, um solche Lösungen als Dienst im großen Stil bereitzustellen.

Was ist neu bei Llama 3

Die Hauptverbesserung des Llama 3 Modells im Vergleich zu seinen Vorgängerversionen ist die Verdopplung der Kontextlänge von bisherigen 4K auf 8K Tokens. Verglichen zum ersten Llama-Modell vervierfacht sie sich sogar. 8K Kontextlänge entspricht etwa 5.000 deutschen bzw. 6.000 englischen Wörtern, was etwa 12 Standard-A4-Seiten Text entspricht. Dieses Kontextfenster kann nun u.a. dafür genutzt werden, einen Chatbot z.B. mit einer detaillierten "Bedienungsanleitung" (oder einem Playbook) als Systemprompt zu initialisieren, um dadurch ohne Finetuning oder die Nutzung von Vektordatenbanken fachspezifische Gespräche zu ermöglichen und sich währenddessen an jedes Detail des Gesprächs erinnern und hierauf Bezug nehmen zu können.

Obwohl die Modellgrößen aufgrund eines verbesserten und besser kuratierten Trainingsdatensatzes nicht dramatisch angestiegen sind, zeigen alle Llama 3 Modelle eine enorme Verbesserung in fast allen LLM-Benchmarks, wodurch sie mit den meisten Closed-Source-Modellen auf dem neuesten Stand der Technik gleichziehen. Der verwendete Trainingsdatensatz ist 7x größer, als der für Llama 2 verwendete.

Beim Chatten mit Llama 3 fällt auf, dass das große Sprachmodell viel freundlicher, hilfsbereiter und ansprechender ist als die Vorgängerversionen.

Das 7B-Modell wurde zu einem 8B-Modell erweitert, um den 24 GB GPU-Speicher, der sich als Standard bei Deep-Learning-GPUs für Einsteiger etabliert hat, optimal nutzen zu können. Das 13B-Modell wurde zugunsten des verbesserten 70B-Modells fallen gelassen.

Es gibt Gerüchte, dass Meta gerade an einem noch größeren Modell arbeitet, das später in diesem Jahr veröffentlicht werden soll. Warten wir ab und sehen dann weiter.

Bereit für Anweisungen: Der Llama3 Instruct-Mechanismus

Die Llama3-Modelle gibt es in zwei Varianten: die generische und die Instruct-Variante. Die Instruct-Versionen wurden mit dem sogenannten „Instruct“-Datensatz trainiert (Fine Tuning), um das generische Sprachmodell in ein Modell zu verwandeln, das die sogenannte „Instruct-Syntax“ versteht.
Das Fine-Tuning des Modells überführt das generische Sprachmodell, dessen ursprünglicher Zweck es ist, ein Textfragment fortzusetzen, in einen Chat-Assistenten, der mit einer „System-Prompt“-Anweisung gesteuert werden kann, um zu markieren, in welchem Kontext und in welchem Stil oder Format die Antwort auf die gestellten Fragen oder Befehle des Benutzers gegeben werden soll.
In unserer Mixtral-Implementierung wird der Instruct-Chat-Kontext in folgendem Format dekodiert:

<|begin_of_text|><|start_header_id|>system<|end_header_id|>

System-Prompt<|eot_id|>

<|start_header_id|>user<|end_header_id|>

Erste Benutzerfrage<|eot_id|>


<|start_header_id|>assistant<|end_header_id|>

Erste Assistentenantwort <|eot_id|>


<|start_header_id|>user<|end_header_id|>

Zweite Benutzerfrage<|eot_id|>

<|start_header_id|>assistant<|end_header_id|>

Jede Nachricht wird so mit mit einem Header versehen, welcher die Rolle festlegt. Das Modell soll dann das Ende seiner Antwort mit dem End-of-Turn-Token <|eot_id|> abschließen.

Die Anweisungen können verschiedene Formen annehmen, wie explizite Befehle, Benutzerfeedback oder kontextuelle Signale, die aus dem Gesprächsverlauf abgeleitet werden.

Hardwareanforderungen

Obwohl die Llama 3 Modelle auf einem Cluster von A100 80GB GPUs trainiert wurden, ist es möglich, die Modelle auf unterschiedlicher und kleinerer Multi-GPU-Hardware für die Inferenz auszuführen.

Um ein bestimmtes Llama 3 Modell mit Echtzeit-Leseleistung auszuführen, benötigt man die in Tabelle 1 aufgelistete minimale GPU-Konfiguration, die sich in den dort empfohlenen AIME-Systemen entsprechend wiederfinden:

Eine ausführliche Leistungsanalyse verschiedener Hardwarekonfigurationen findet sich im Abschnitt "Llama 3 Inference GPU Benchmarks" dieses Artikels.

Unsere Llama 3 Implementierung

Unsere Llama-3-Implementierung ist ein Fork des Original-Llama 3-Repositorys und unterstützt alle Llama 3 Modellgrößen (7B, 13B und 70B). Wir bieten abweichend vom originalen Llama 3 Modell zusätzlich noch die Möglichkeit, die Modell-Gewichte so zu konvertieren, dass man Llama 3 auf verschiedenen GPU-Konfiguration ausführen kann, das Modell also auf mehrere GPUs verteilen kann (siehe Tabelle 2).

Durch die Integration in die AIME-API wird es möglich, mittels Batch-Aggregation die Inferenzleistung entsprechend der vorhandenen GPU-Konfigurationen zu skalieren. Mit Hilfe des API-Servers werden also alle Anfragen als Batch-Jobs von den GPUs parallel verarbeitet. Dies erhöht die erreichbare Durchsatzleistung der Chat-Anfragen dramatisch.

Anhand der unten aufgeführten Benchmark-Tests mit verschiedenen GPU-Konfigurationen geben wir abschließend eine Antwort auf die Frage, welche Hardware die beste Durchsatzleistung für die Verarbeitung von LLaMa-Anfragen bietet.

Testen des Llama3-Chats mit dem AIME API Demonstrator

Der AIME-API-Server bietet Client-Schnittstellen für verschiedene Programmiersprachen an. Um die Leistung von Llama 3 mit dem AIME API Server zu demonstrieren, stellen wir einen voll funktionsfähigen Llama3-Demonstrator unter Verwendung einer JavaScript-Client-Schnittstelle bereit.

Los geht's: Wie man Llama3-Chat deployed

Die folgenden Schritte sind notwendig, um Llama 3 als Webanwendung betreiben zu können:

• Einrichten der Betriebsumgebung, unkompliziert mittels AIME MLC Framework
• Klonen des Llama3-Chat Repositories und Laden der Llama 3 Modellgewichte
• Testen des Llama 3 Modells als Konsolenanwendung
• Starten des API-Servers und des Llama 3 Workers zum Bedienen von HTTPS/HTTP-Anfragen

Erstellung eines AIME-ML-Containers

Für die unkomplizierte Einrichtung einer Betriebsumgebung nutzen wir das AIME-ML-Container-Management Framework. Hierfür lassen sich selbstverständlich auch andere Lösungen, wie Conda oder ähnliche Tools nutzen.

Um eine PyTorch 2.1.2-Umgebung für Installation und Betrieb des Modells einzurichten, erstellen wir, wie in aime-ml-containers beschrieben, den AIME-ML-Container, mit dem folgenden Befehl:

> mlc-create llama3 Pytorch 2.1.2-aime -w=/pfad/zu/ihrem/workspace -d=/pfad/zu/den/checkpoints

Der Parameter -d ist nur erforderlich, wenn Sie die Modell-Checkpoints nicht in Ihrem Arbeitsbereich (workspace), sondern in einem bestimmten Datenverzeichnis speichern möchten. Er bindet den Ordner /pfad/zu/den/checkpoints an den Pfad /data innerhalb des Container an. Dieser Ordner benötigt mindestens 250 GB freien Speicherplatz, wenn man alle LLaMa-Modelle dort speichern möchte.

Sobald der Container erstellt ist, öffnet man ihn mit:

> mlc-open llama3

Man arbeitet nun im virtuellen ML-Container (Docker) und kann dort alle Abhängigkeiten, wie erforderliche Pip- und Apt-Pakete, bedenkenlos installieren, ohne das Host-System zu beeinträchtigen.

Klonen des Llama3-Chat Repositories

Das Repository Llama3-Chat ist eine von AIME geforkte (abgeleitete) Version der ursprünglichen Llama 3 Referenzimplementierung von Meta mit den folgenden zusätzlichen Funktionen:

• Tool zur Konvertierung der originalen Modell-Checkpoints für verschiedene GPU-Konfigurationen
• Verbessertes Text-Sampling
• Token-weise Textausgabe
• Interaktiver Konsolen-Chat
• Integration in den AIME-API-Server

Das Llama3-Chat-Repository von AIME wird wie folgt geklont:

[llama3] user@client:/workspace$
> git clone https://github.com/aime-labs/llama3_chat

Anschließend müssen die benötigten Pip-Pakete installiert werden:

[llama3] user@client:/workspace$
> pip install -r /workspace/llama3_chat/requirements.txt

Download des Llama 3 Modell-Checkpoints

Um die Modellgewichte und den Tokenizer herunterzuladen, muss man einen Zugriffsantrag bei Meta stellen und deren Lizenz akzeptieren. Sobald der Antrag genehmigt ist, erhält man eine signierte URL per E-Mail. Nun ist noch sicherzustellen, dass wget und md5sum im Container installiert sind:

[llama3] user@client:/workspace$
> sudo apt-get install wget md5sum

Nachfolgend führt man das Skript download.sh aus:

[llama3] user@client:/workspace$
> /workspace/download.sh

Nun muss man die bereitgestellte URL eingeben, wenn man zur Durchführung des Downloads aufgefordert wird. Es ist zu beachten, dass diese Links nach 24 Stunden und einer bestimmten Anzahl von Downloads ablaufen. Wenn Fehlermeldungen wie 403: Forbidden auftreten, kann man jederzeit einen neuen Link anfordern.

Der Download-Vorgang kann je nach Geschwindigkeit der Internetverbindung einige Zeit in Anspruch nehmen. Für das 70B-Modell müssen 129 GB heruntergeladen werden.

Konvertierung der Checkpoints entsprechend der GPU-Konfiguration

Die heruntergeladenen Checkpoints sind nur für bestimmte GPU-Konfigurationen vorgesehen: 7B für 1x GPU, 13B für 2x GPUs und 70B für 8x GPUs. Um das Modell auf einer anderen GPU-Konfiguration ausführen zu können, stellt AIME ein Tool zur Verfügung, um die Modell-Gewichte entsprechend zu konvertieren. Tabelle 2 listet alle unterstützten GPU-Konfigurationen auf.

Der Konvertierungsvorgang kann mit dem folgenden Befehl gestartet werden:

[llama3] user@client:/workspace$
> python3 /workspace/llama3_chat/convert_weights.py --input_dir /data/models/Meta-Llama-3-70B-Instruct/ --model_size 70B --num_gpus <num_gpus>

Die Konvertierung kann je nach CPU- und Speichergeschwindigkeit sowie Modellgröße einige Minuten dauern.

Llama 3 als interaktiven Chat im Terminal ausführen

Um die Llama 3 Modelle als Chatbot im Terminal auszuprobieren, startet man das folgende PyTorch-Skript und gibt die gewünschte Modellgröße an, die verwendet werden soll:

[llama3] user@client:/workspace$
> torchrun --nproc_per_node <num_gpus> /workspace/llama3_chat/chat.py --ckpt_dir /data/models/Meta-Llama-3-70B-Instruct

Der Chat-Modus wird durch Angabe des folgenden Kontexts als Startprompt initiiert. Er setzt die Umgebung so, dass das Sprachmodell versucht, den Text als Chatdialog zu vervollständigen:

A dialog, where User interacts with a helpful, kind, obedient, honest and very reasonable assistant called Steve.
User: Hello, Steve
Steve: How can I assist you today?

Dadurch fungiert das Modell als einfacher Chatbot. Der Startprompt beeinflusst die Stimmung der Antworten des Chatbots. In diesem Fall erfüllt er glaubwürdig die Rolle eines hilfsbereiten Assistenten und verlässt sie auch nicht ohne Weiteres. Hierdurch können interessante, lustige bis hilfreiche Antworten entstehen - abhängig von den Eingabetexten.

Der Startprompt kann selbstverständlich auch in Deutsch verfasst werden. Llama 3 chattet dann in Deutsch.

Llama 3 Chat als Web-Service mit dem AIME-API-Server ausführen

Einrichten des AIME API Servers
Um den AIME-API-Server einzurichten und zu starten, finden sich alle Informationen im Abschnitt "Setup" der API-Dokumentation.

Starten von Llama 3 als API-Worker
Um das Llama3-Chat-Modell mit dem AIME-API-Server zu verbinden, der bereit ist, Chat-Anfragen über die JSON-HTTPS/HTTP-Schnittstelle zu empfangen, fügt man einfach die Option --api_server gefolgt von der Adresse des AIME-API-Servers hinzu, mit dem Sie sich verbinden möchten:

[llama3] user@client:/workspace$
> torchrun --nproc_per_node <num_gpus> /workspace/llama3_chat/chat.py --ckpt_dir /data/llama3-model/llama-3-70b-chat --api_server https://api.aime.info/

Nun fungiert das Llama 3 Modell als Worker-Instanz für den AIME-API-Server, bereit zur Verarbeitung von Jobs, die von Clients des AIME-API-Servers angefragt wurden.

Für die Dokumentation zum Senden von Client-Anfragen an den AIME-API-Server lesen Sie bitte hier weiter.

Llama 3 Inferenz GPU-Benchmarks

Um die Leistung des mit dem AIME-API-Server verbundenen Llama3-Workers zu messen, liegt dem AIME-API-Server ein Benchmark-Tool bei, mit dem der Server als Simulation mit einer beliebigen Anzahl von Chat-Anfragen belastet werden kann. Um die Messung anstoßen zu können, müssen vorerst alle erforderlichen Abhängigkeiten installiert werden:

user@client:/workspace/aime-api-server/$
> pip install -r requirements_api_benchmark.txt

Daraufhin kann das Benchmark-Tool mit folgendem Befehl gestartet werden:

user@client:/workspace/aime-api-server/$
> python3 run_api_benchmark.py --api_server https://api.aime.info/ --total_requests <number_of_requests>

run_api_benchmark.py sendet so viele Anfragen wie möglich parallel und bis zu <number_of_requests> Chat-Anfragen an den API-Server. Jede Anfrage beginnt mit dem Ausgangskontext "Once upon a time". Llama 3 generiert, abhängig von der verwendeten Modellgröße, eine Geschichte von etwa 400 bis 1000 Token Länge. Die verarbeiteten Tokens pro Sekunde werden gemessen und über alle verarbeiteten Anfragen gemittelt.

Ergebnis

Im Folgenden werden die Benchmark-Ergebnisse der verschiedenen Llama 3-Modellgrößen und GPU-Konfigurationen gelistet. Das Model wird so geladen, dass die GPUs es im Batchbetrieb nutzen können. Die maximal mögliche Batchgröße, die der Anzahl der parallel verarbeitbaren Chat-Sitzungen entspricht, wird in den unten stehenden Abbildungen unterhalb des GPU-Modells angegeben und steht im direkten Zusammenhang mit dem verfügbaren GPU-Speicher.

Die Ergebnisse werden dargestellt als Gesamtdurchsatz in Tokens pro Sekunde, die kleineren Balken zeigen die Tokens pro Sekunde für einzelne Chat-Sitzungen.

Die menschliche (stille) Lesegeschwindigkeit beträgt etwa 5 bis 8 Wörter pro Sekunde. Mit einem Verhältnis von 0,75 Wörtern pro Token entspricht dies einer erforderlichen Generierungsgeschwindigkeit von etwa 6 bis 11 Tokens pro Sekunde, um bei der Textausgabe als nicht zu langsam wahrgenommen zu werden.

Llama 3 8B GPU Performance

Llama 3 70B GPU Performance

Zusammenfassung

Die Integration von Llama 3 in die AIME-API und die einfache und schnelle Einrichtung des API-Servers eröffnet Entwicklern eine komfortable, skalierbare Lösung für die Bereitstellung von Conversational-AI-Lösungen. Die Integration von Llama 3 in den AIME-API-Server ermöglicht die einfache Erstellung hochperformanter, professioneller Anwendungen, wie Chatbots, virtuellen Assistenten oder interaktiven Kundensupportsystemen.

Die Flexibilität der Hardware-Anforderungen für das Ausführen von LLaMa 3 Modellen wird durch die Möglichkeit der verteilten Verarbeitung auf mehreren GPUs maximiert. Diese Flexibilität ermöglicht das skalierbare Deployment auf unterschiedlichsten GPU-Konfigurationen mit erweiterbaren Setups und Infrastrukturen, die in der Lage sind, tausende von Anfragen gleichzeitig zu bedienen. Sogar die minimalen GPU-Anforderungen und die kleinsten empfohlenen AIME-Systeme für jede der Modellgrößen garantieren eine Reaktionsgeschwindigkeit beim Lesen der Textausgabe, die über Echtzeit liegt und somit ein angenehmes Chat-Erlebnis für viele gleichzeitig aktive Nutzer bietet.