Groq LPU Inference Engine Tutorial

Wenn du schon mal frustriert auf eine Antwort von ChatGPT gewartet hast, wirst du vom Groq Language Processing Unit (LPU) Inference Engine begeistert sein.

Mit Groq bekommst du Antworten auf deine Anfragen in Sekundenbruchteilen – die Wartezeit sinkt von 40 Sekunden auf gerade mal 2 Sekunden.

In diesem Tutorial:

1. Lernen wir den Groq LPU Inference Engine kennen.
2. Vergleichen wir die Features und Struktur der OpenAI- und Groq-APIs. 
3. Nutzten wir Groq online und lokal.
4. Integrieren wir die Groq API in VSCode.
5. Nutzen wir die Groq Python API.
6. Bauen wir kontextbewusste KI-Anwendungen mit der Groq API und LlamaIndex.

Wenn du neu bei Large Language Models (LLMs) bist, empfehlen wir dir den Skill-Lernpfad Developing Large Language Models, um die Grundlagen des Finetunings von LLMs zu lernen und dein eigenes Modell von Grund auf zu bauen.

Was ist der Groq LPU Inference Engine?

Der LPU (Language Processing Unit) Inference Engine von Groq ist ein neuartiges Verarbeitungssystem für rechenintensive Aufgaben mit sequentiellen Komponenten – insbesondere bei der Antwortgenerierung großer Sprachmodelle. Diese Technologie verändert die Textverarbeitung und -generierung grundlegend und liefert eine Performance und Präzision, die ihresgleichen sucht.

Im Vergleich zu klassischen Central Processing Units (CPU) und Graphics Processing Units (GPU) bietet die LPU deutlich mehr Rechenkapazität. Dadurch verkürzt sich die Zeit zur Vorhersage des nächsten Tokens erheblich – Texte werden also viel schneller generiert. Außerdem adressiert die LPU Speicher-Engpässe, die bei GPUs im Umgang mit LLMs häufig auftreten. 

Groq hat die LPU so entwickelt, dass sie Herausforderungen wie Rechendichte, Speicherbandbreite, niedrige Latenz und hohen Durchsatz meistert. Die Performance übertrifft GPU und TPU (Tensor Processing Unit). So kann die LPU beispielsweise auf Llama-3 70B über 310 Tokens pro Sekunde und Nutzer erzeugen.

Mehr zur LPU-Architektur findest du im offiziellen Forschungspaper Groq ISCA 2022 Paper.

OpenAI vs. Groq API

Aktuell sind Groq-LLMs über groq.com, die Groq Cloud API, den Groq Playground und Drittplattformen wie Poe zugänglich. 

In diesem Abschnitt schauen wir uns die Features und Modelle von OpenAI und Groq Cloud an. Außerdem testen wir die Geschwindigkeit von API-Calls mit CURL und vergleichen das API-Design.

OpenAI

Die OpenAI API deckt ein breites Spektrum an Features und Modellen ab. Unter anderem:

1. Embedding-Modelle.
2. Zugriff auf Textgenerierungsmodelle wie GPT-4o und GPT-4 Turbo.
3. Code Interpreter und Dateisuche.
4. Möglichkeit zum Finetuning auf eigenen Datensätzen.
5. Zugriff auf Bildgenerierungsmodelle.
6. Audio-Modelle für Transkription, Übersetzung und Text-to-Speech.
7. Vision-Modelle zum Verstehen von Bildern.
8. Function Calling.

Die OpenAI API ist schnell und wird mit der Zeit günstiger.

Auf das aktuelle OpenAI-Modell greifen wir mit folgendem Terminal-Befehl zu. Die API benötigt den OpenAI-API-Key, den Modellnamen und Messages mit System-Prompt und Nutzeranfrage. 

curl -X POST https://api.openai.com/v1/chat/completions \ 
  -H "Content-Type: application/json" \ 
  -H "Authorization: Bearer $OPENAI_API_KEY" \ 
  -d '{ 
    "model": "gpt-4o", 
    "messages": [ 
      {        "role": "system", 
        "content": "You are a helpful assistant." 
      }, 
      { 
        "role": "user", 
        "content": "How do I get better at programming?" 
      } 
    ] 
  }'

Die Antwort dauerte 13 Sekunden. 

Mehr zur OpenAI API und ihren Features findest du in diesem Beginner's Guide to The OpenAI API: Hands-On Tutorial and Best Practices.

Groq

Groq ist ein neuer Player im KI-Markt und bietet derzeit noch eine überschaubare Auswahl an Features und Modellen. Darunter:

1. Textgenerierungsmodelle wie LLaMA3 70b, Gemma 7b und Mixtral 8x7b.
2. Transkription und Übersetzung mit dem Whisper Large V3 Modell (nicht öffentlich verfügbar).
3. Kompatibilität zur OpenAI API.
4. Function Calling.

Die Groq Cloud API liefert im Vergleich zur OpenAI API deutlich schnellere Antworten. Um das zu testen, nutzen wir im Terminal wieder CURL und schicken dieselbe Nachricht an die Groq API.

Die Groq API ist der OpenAI API sehr ähnlich – der Unterschied liegt im URL-Endpunkt.

curl -X POST "https://api.groq.com/openai/v1/chat/completions" \ 
    -H "Authorization: Bearer $GROQ_API_KEY" \ 
    -H "Content-Type: application/json" \ 
    -d '{"messages": [ 
     { 
       "role": "system", 
       "content": "You are a helpful assistant." 
     }, 
     {        "role": "user", 
       "content": "How do I get better at programming?" 
     } 
   ], 
   "model": "llama3-70b-8192"}'

Die Antwort kam nach zwei Sekunden – damit 6,5-mal schneller als bei der OpenAI API. 

Mit Groq erhältst du eine nahezu Echtzeit-Generierung von Antworten – entscheidend für manche Anwendungen.

Groq Cloud nutzen

Groq Cloud kommt mit einem AI Playground, in dem du alle Modelle und APIs ausprobieren kannst, die du für KI-Produkte und -Anwendungen verwenden möchtest. 

Für den Zugriff auf Groq Cloud musst du zunächst ein Konto erstellen: hier entlang.

Klicke anschließend im linken Panel auf den Playground-Tab, wähle das Modell llama3-70b-8192 und gib deine Prompts in das USER-Eingabefeld ein. 

Für die vollständige Antwort brauchte es 2,94 Sekunden bei 305 Tokens pro Sekunde. Diese Spitzenleistung bekommst du so nicht mit ChatGPT. 

Wählen wir nun das kleinere Modell mitral-8x7b-32768 und schreiben einen Folgeprompt.

Kleinere Modelle sind bei der Generierung oft noch schneller – hier mit 577 Tokens pro Sekunde.

Eine Übersicht über verfügbare LLM-Optionen und Auswahlkriterien findest du in diesem Tutorial: LLM Classification: How to Select the Best LLM for Your Application.

Groq lokal nutzen

Um lokal auf Groq-LLMs zuzugreifen, erzeugen wir zunächst einen API-Key im Tab API Keys per Klick auf Create API Key. 

Jan AI ermöglicht die lokale Nutzung von LLMs – sowohl Open-Source- als auch proprietäre Modelle. Unterstützte Anbieter sind u. a. OpenAI, Anthropic, Cohere, MistralAI und Groq.

Lade Jan AI über die offizielle Website herunter und installiere es. Danach kannst du die App starten.

Öffne die Einstellungen, wähle den Tab Groq Inference Engine und füge den eben erstellten API-Key ein. 

Verlasse das Einstellungsmenü, gehe zu Thread und wähle das Modell Groq Llama 3 70b aus.

Stelle eine Frage oder schreibe einen Prompt, um die Antwort in Echtzeit zu erhalten:

Das kostenlose Groq-Cloud-Abo hat bestimmte Ratenlimits. Beim Plan llama3-70b-8192 sind es z. B. 30 Requests pro Minute, 14.400 pro Tag und 6.000 Tokens pro Minute. Diese Limits sind großzügig, aber wenn du eine produktionsreife KI-Anwendung mit der Groq API bauen willst, solltest du On Demand oder Enterprise in Betracht ziehen.

Sieben einfache Wege, LLMs lokal auszuführen, findest du in diesem Tutorial zum lokalen Betrieb von LLMs.

Groq in VSCode integrieren

Neben Chatbot-Anwendungen kannst du die Groq API auch in VSCode per CodeGPT-Erweiterung einbinden. So wird sie zu deinem superschnellen KI-Coding-Assistenten. 

Installiere dafür die CodeGPT-Erweiterung über den Extension Marketplace.

Nach der Installation hinterlegst du den Groq API-Key: Klicke im linken Panel auf das CodeGPT-Chat-Icon und wähle Provider und Modell. Wir wählen Groq als Provider und llama3-70b-8192 als Modell.

Danach kannst du im Chatfeld deinen Prompt schreiben und Code generieren. In wenigen Sekunden stand der passende Code für unser E-Mail-System.

Anschließend lässt sich der Code dokumentieren, refaktorieren und mit eingebauten Befehlen ein Unittest erstellen. 

Mehr zu VSCode findest du in diesem Tutorial zum Einrichten von VSCode für Python.

Schritt-für-Schritt: Groq Python API nutzen

In diesem Abschnitt lernst du die Grundlagen der Groq Python API und zentrale Features wie Streaming und Async Chat Completion. 

Für diese Anleitung nutzen wir DataCamps DataLab. DataLab ist ein AI Cloud Jupyter Notebook mit vielen Funktionen zum Coden, Analysieren und Teilen von Insights.

Setup

Zuerst hinterlegen wir den Groq API-Key in DataLab: Klicke links auf Environment und füge per Plus-Button eine Umgebungsvariable hinzu.

Vergib einen Variablennamen und füge den Groq API-Key ein, wie unten gezeigt.

Aktiviere die Variable, indem du auf die drei Punkte neben der Groq-Variable klickst und dann Connect wählst.

Zum Schluss installieren wir das Groq-Python-Paket mit pip. 

%pip install groq -q

Einfache Completion und Chat

Wenn du die OpenAI Python API kennst, wirkt die Codestruktur vertraut. Für eine Chat Completion:

1. Erstelle den Groq-Client mit dem API-Key.
2. Erzeuge eine einfache Antwort mit der Chat-Completion-Funktion. 
3. Die Funktion benötigt den Modellnamen und die Message. 
4. Wandle die Ausgabe in Markdown um.

import os
from groq import Groq
from IPython.display import display, Markdown

client = Groq(    
   api_key=os.environ.get("GROQ_API_KEY"),
)

chat_completion = client.chat.completions.create(    
   messages=[        
       {"role": "system", "content": "You are a professional Data Scientist."},        
       {"role": "user", "content": "Can you explain how the neural networks work?"},    
   ],    
   model="llama3-70b-8192",)

Markdown(chat_completion.choices[0].message.content)

Das Ergebnis ist eine sauber formatierte Erklärung, was neuronale Netze sind.

Streaming Chat Completion

Beim Streaming generieren LLMs Text Token für Token. Das spart Speicher und erhöht die wahrgenommene Geschwindigkeit der Anwendung.

In diesem Beispiel aktivieren wir Streaming und passen Hyperparameter wie temperature, max_tokens und top_p an.

chat_streaming = client.chat.completions.create( 
    messages=[ 
       {"role": "system", "content": "You are a monk from Thailand."}, 
       {"role": "user", "content": "Can you explain the meaning of life?"}, 
    ], 
    model="llama3-70b-8192", 
    temperature=0.3, 
    max_tokens=360, 
    top_p=1, 
    stop=None, 
    stream=True,
)

for chunk in chat_streaming: 
    print(chunk.choices[0].delta.content, end="")

Die Antwort traf ein, sobald der Code gestartet wurde. 

Async Chat Completion

Asynchrone APIs verarbeiten parallele Anfragen ohne Blockieren und antworten pro Request unabhängig. Das ist effizienter und skalierbarer – mehr Volumen, schnellere Reaktionszeiten.

Für asynchrone API-Calls ändern wir die Codestruktur. Wir:

1. Erstellen einen asynchronen Groq-Client mit API-Key. 
2. Definieren die asynchrone main-Funktion.
3. Schreiben die Chat-Completion mit await.
4. Starten main mit await.

Hinweis: Der folgende Code läuft in Jupyter Notebook. In einer .py-Datei musst du die letzte Zeile ggf. durch asyncio.run(main()) ersetzen.

import asyncio
from groq import AsyncGroq

client = AsyncGroq(

    api_key=os.environ.get("GROQ_API_KEY"),

)

async def main(): 

   chat_completion = await client.chat.completions.create( 
       messages=[            {"role": "system", "content": "You are a psychiatrist helping young minds"}, 
                  {                "role": "user",                "content": "I panicked during the test, even though I knew everything on the test paper.",            }, 
                ], 
                model="llama3-70b-8192", 
                temperature=0.3, 
                max_tokens=360, 
                top_p=1, 
                stop=None, 
                stream=False, 
       ) 

       print(chat_completion.choices[0].message.content)

await main()  # for Python file use asyncio.run(main())

Streaming einer Async Chat Completion

Auch asynchrone Chats lassen sich streamen: Aktiviere stream in der Completion-Funktion und passe die Ausgabe an. Wir drucken jeden Chunk in einer asynchronen for-Schleife.

import asyncio

from groq import AsyncGroq


client = AsyncGroq()

async def main(): 

    chat_streaming = await client.chat.completions.create( 
        messages=[ 
           {"role": "system", "content": "You are a psychiatrist helping young minds"}, 
           {                "role": "user",                "content": "I panicked during the test, even though I knew everything on the test paper.",            }, 
        ], 
        model="llama3-70b-8192", 
        temperature=0.3, 
        max_tokens=360, 
        top_p=1, 
        stop=None, 
        stream=True, 
     ) 
     async for chunk in chat_streaming: 
            print(chunk.choices[0].delta.content, end="")

await main()  # for Python file use asyncio.run(main())

Wenn du Probleme beim Ausführen hast, schau in dieses DataLab-Notebook: Groq Cloud API.

KI-Anwendung mit Groq API und LlamaIndex bauen

Jetzt gehen wir einen Schritt weiter und bauen mit der Groq API und LlamaIndex (einem LLM-Framework) eine KI-Anwendung. Die App lädt Text aus einer PDF, wandelt ihn in Embeddings um und speichert diese im Vektorspeicher. Anschließend machen wir aus dem Vektorspeicher einen Retriever und bauen damit einen RAG-Chat-Engine mit Verlauf. 

Kurz: Wir bauen ein kontextbewusstes ChatPDF, mit dem du Dokumente deutlich schneller verstehst.

Wie du private oder domänenspezifische Daten per natürlicher Sprache ingestest, verwaltest und abrufst, erfährst du in diesem Tutorial: LlamaIndex: A Data Framework for Large Language Models (LLMs).

Python-Pakete installieren

Zuerst installieren wir alle benötigten Python-Pakete mit pip. Mit der Magic-Funktion %%capture unterdrücken wir die Logs.

%%capture
%pip install llama-index
%pip install llama-index-llms-groq
%pip install llama-index-embeddings-huggingface

LLM mit Groq einrichten

Wir erstellen den Groq-LLM-Client über die Funktion von llama_index. Er benötigt den Modellnamen und den API-Key.

from llama_index.llms.groq import Groq
import os

llm = 
Groq(model="llama3-70b-8192",api_key=os.environ.get("GROQ_API_KEY"))

Embedding-Modell einrichten

Als Nächstes laden wir das Hugging-Face-Embedding-Modell über die Embeddings-API von LlamaIndex. 

Wir verwenden das populäre Hugging-Face-Embedding-Modell mxbai-embed-large-v1.

from llama_index.embeddings.huggingface import HuggingFaceEmbedding

embed_model = 
HuggingFaceEmbedding(model_name="mixedbread-ai/mxbai-embed-large-v1")

Globale Einstellungen konfigurieren

LlamaIndex erlaubt globale Konfigurationen, sodass LLM- oder Embedding-Objekte nicht überall erneut übergeben werden müssen.

from llama_index.core import Settings

Settings.llm = llm
Settings.embed_model = embed_model

Daten laden

Als Datenquelle verwenden wir den Blogpost 14 Essential Data Engineering Tools to Use in 2024 und konvertieren ihn per Druckfunktion in eine PDF.

Mit SimpleDirectoryReader kannst du alle möglichen Dokumente aus einem Ordner laden. Gib einfach den Ordnerpfad und die gewünschten Dateiendungen an. 

from llama_index.core import SimpleDirectoryReader

de_tools_blog = SimpleDirectoryReader("./",required_exts=[".pdf", ".docx"]).load_data()

Vektorsuche

VectorStoreIndex ist der schnellste Weg, um aus Dokumenten einen Vektorspeicher zu erstellen und einen Index aufzubauen. Der Index kann für Query Engines, Retriever und Query-Pipelines genutzt werden.

Wir erstellen den Index, indem wir die Dokumente an den Vektorspeicher übergeben. Dieser erzeugt Embeddings und speichert sie.  

Danach konvertieren wir den Index in eine Query Engine für grundlegendes RAG (Retrieval Augmented Generation), die Retrieval und KI-Modell kombiniert, um kontextbewusste Antworten zu erzeugen.

from llama_index.core import VectorStoreIndex

index = VectorStoreIndex.from_documents(de_tools_blog)
query_engine = index.as_query_engine(similarity_top_k=3)

response = query_engine.query("How many tools are there?")
print(response)

RAG-Chat-Engine mit Verlauf

Jetzt bauen wir eine RAG-Chat-Engine mit Verlauf. Der Verlauf ermöglicht es, sowohl frühere Nutzerfragen als auch generierte Antworten zu berücksichtigen und dadurch kontextbewusster zu antworten.

Dafür erstellen wir einen ChatMemoryBuffer mit 3.900 Tokens und übergeben ihn zusammen mit dem Retriever und dem LLM an die Chat-Engine.

Wenn du eine Frage stellst, nutzt die Chat-Engine die PDF und die bisherigen Nachrichten als Kontext und antwortet entsprechend.

from llama_index.core.memory import ChatMemoryBuffer
from llama_index.core.chat_engine import CondensePlusContextChatEngine

memory = ChatMemoryBuffer.from_defaults(token_limit=3900)

chat_engine = CondensePlusContextChatEngine.from_defaults(    
   index.as_retriever(),    
   memory=memory,    
   llm=llm
)

response = chat_engine.chat(    
   "What tools are suitable for data processing?"
)
print(str(response))

Wir haben eine allgemeine Frage gestellt. Die Engine hat die passenden Tools zur Datenverarbeitung im Dokument gefunden und als Liste zurückgegeben. Alle Tools stammen aus dem Blog.

Stellen wir eine Rückfrage, um das Gedächtnis der Chat-Engine zu testen.

response = chat_engine.chat(
    "Can you create a diagram of a data pipeline using these tools?"
)
print(str(response))

Die Chat-Engine hat sich die vorherige Unterhaltung gemerkt und entsprechend geantwortet. 

Den gesamten Code findest du in diesem DataLab-Notebook: Groq Cloud API — DataLab.

Fazit

Der Groq LPU Inference Engine ist ein Gamechanger in der KI. Während große Anbieter wie OpenAI und Google hochwertige LLMs entwickeln, macht Groq diese Modelle schneller. Trotz der kurzen Zeit am Markt sorgt Groq in der KI-Community bereits für ordentlich Bewegung.

In diesem Blog haben wir den Groq LPU Inference Engine kennengelernt, Groq Cloud erkundet und die Groq API in VSCode und Jan AI integriert. Außerdem sind wir mit Codebeispielen in das Groq-Python-Paket eingestiegen und haben eine kontextbewusste KI-Anwendung gebaut, die aus Chatverlauf und PDF-Dokumenten lernt.

Ein sinnvoller nächster Schritt ist das Finetuning von LLMs auf eigenen Datensätzen. Wie das geht, zeigt dieses Tutorial: Fine Tuning Google Gemma: Enhancing LLMs with Customized Instructions.