Kurs
Konzepte großer Sprachmodelle (LLMs)
2 Std.
109.8K
Einführung
Large Language Models (LLMs) stehen im Zentrum der Generativen KI und verändern, wie Maschinen menschliche Sprache verstehen und erzeugen. LLMs wie GPT, Claude, LLaMA, Mistral, usw. treiben Innovationen bei Chatbots, Content-Erstellung und weit darüber hinaus voran und ermöglichen nie dagewesene Fähigkeiten in der Verarbeitung und Generierung natürlicher Sprache.
Die wahre Stärke von LLMs geht jedoch über ihre reine Rechenleistung hinaus; Zugänglichkeit ist entscheidend. APIs (Application Programming Interfaces) fungieren als Brücken und erlauben es, die Leistung von LLMs in unterschiedlichste Anwendungen einzubinden. So integrieren Entwickler fortgeschrittenes Sprachverständnis und -generierung – von einfacher Textanalyse bis zu komplexen Dialogsystemen – direkt in ihre Anwendungen.
In diesem Tutorial bauen wir eine einfache Python-Anwendung mit dem OpenAI-GPT-Modell und stellen sie über einen API-Endpoint bereit, der mit dem FastAPI-Framework in Python entwickelt wird.
Large Language Models
Large Language Models (LLMs) sind fortgeschrittene KI-Systeme, die darauf ausgelegt sind, menschlich anmutenden Text zu verstehen und zu erzeugen. Sie werden auf riesigen Datenmengen trainiert, erkennen komplexe Muster, verstehen sprachliche Nuancen und generieren kohärente Antworten.
LLMs beherrschen zahlreiche sprachbezogene Aufgaben, darunter Übersetzung, Textvervollständigung, Zusammenfassung und sogar dialogische Interaktionen. GPT ist ein Beispiel für ein LLM.
In diesem Beitrag erstellen wir eine einfache Python-Anwendung mithilfe der GPT-API von OpenAI und bauen anschließend einen REST-Endpoint für unsere Anwendung mit dem FastAPI-Framework in Python.
LLMs sind eine Ausprägung der Generativen KI. Wenn du mehr über Generative KI und ihren kreativen Mehrwert erfahren möchtest, lies unsere Blogposts zu Mehr Kreativität mit Generativer KI und unseren Podcast Inside the Generative AI Revolution.
Du kannst dich auch für unseren kommenden Kurs zu Konzepten zu Large Language Models anmelden.
Was ist eine API?
Eine Application Programming Interface (API) ist das Rückgrat der Softwarekommunikation und ermöglicht es verschiedenen Systemen, Anwendungen und Geräten, nahtlos zu interagieren und Daten auszutauschen. Sie definiert Regeln und Protokolle, über die Softwarekomponenten miteinander kommunizieren – eine standardisierte Möglichkeit, Funktionen oder Daten einer Anwendung zu nutzen, ohne deren interne Funktionsweise kennen zu müssen.
APIs sind allgegenwärtig im heutigen digitalen Ökosystem: Sie treiben Web-Services, Mobile Apps und Cloud Computing an, erleichtern die Kommunikation zwischen Anwendungen und die Integration von Drittanbieterdiensten. Sie vereinfachen die Entwicklung, indem sie Bausteine bereitstellen, mit denen Entwickler neue Software schneller erstellen – für mehr Funktionalität und bessere Nutzererlebnisse, ohne bei null zu starten.
Über APIs lassen sich Anwendungen auf Arten erweitern, die sonst komplex oder unmöglich wären. Darum sind sie ein zentrales Element moderner Softwareentwicklung.
Wenn du dich dafür interessierst, wie Machine-Learning-Modelle in der Praxis ausgerollt werden, schau dir unseren umfassenden Leitfaden zu Machine Learning, Pipelines, Deployment und MLOps an. Außerdem gibt es den kostenlosen Kurs Introduction to API auf Datacamp.
FastAPI
FastAPI ist ein Python-Framework für performante APIs. Sein Aufstieg basiert auf Geschwindigkeit, einfacher Handhabung und der Unterstützung asynchroner Programmierung. Mit FastAPI lassen sich LLM-Funktionen als API-Endpoints exponieren – ideal, um KI-gestützte Services bereitzustellen, zu verwalten und zu skalieren.
FastAPI zeichnet sich durch Leistung und Effizienz aus. Es nutzt moderne Python-Features wie Typannotationen und asynchrones Programmieren und erreicht Geschwindigkeiten, die mit NodeJS und sogar Go mithalten.
Dieser Performancevorteil ist entscheidend für Anwendungen mit Echtzeitdatenverarbeitung und parallelen Anfragen, etwa beim Anbinden von LLMs. Die automatische Validierung eingehender Daten und Serialisierung von Antworten reduziert Boilerplate und macht API-Entwicklung übersichtlicher.
Die automatische Dokumentation nach Standards wie OpenAPI liefert klare, interaktive API-Dokumente – das vereinfacht Integration und Tests zusätzlich.
Beispiel: API-Erstellung
from typing import Union
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
return {"item_id": item_id, "q": q}Dieser Code erstellt einen einfachen Webserver mit FastAPI. Der Server beantwortet zwei Arten von Anfragen: Beim Aufruf der Startseite ("/") gibt er "Hello World" zurück. Beim Aufruf einer bestimmten Item-Seite ("/items/{item_id}") liefert er die Item-ID sowie optional den Query-Parameter "q". Die Item-ID ist Pflicht und muss eine ganze Zahl sein; der Parameter "q" ist optional und kann ein String sein oder fehlen.
Starte den FastAPI-Server mit:
End-to-End-Anwendung in Python bauen
Das Ziel dieses Blogs ist zu zeigen, wie du schnell REST-API-Endpoints für deine LLM-Anwendungen aufsetzt. Wir erstellen eine einfache Python-App (nur eine Funktion), die die OpenAI-GPT-4-API nutzt und englischen Text ins Französische übersetzt. Diese Anwendung hat lediglich eine Funktion, translate_text:
from openai import OpenAI
import os
os.environ["OPENAI_API_KEY"] = "..."
# Initialize OpenAI client with your API key
client = OpenAI()
def translate_text(input_str):
completion = client.chat.completions.create(
model="gpt-4-0125-preview",
messages=[
{
"role": "system",
"content": "You are an expert translator who translates text from english to french and only return translated text",
},
{"role": "user", "content": input_str},
],
)
return completion.choices[0].message.contentDiese Funktion nimmt einen Eingabetext entgegen und übergibt ihn an das OpenAI-GPT-4-Modell. Ein System-Prompt definiert den Kontext, der User-Prompt ist der Text aus input_str.
Du kannst die Funktion so testen. Es sollte französischer Text zurückkommen.
# test the function
translate_text("this is a test string to translate")Wenn du die Anwendung mit anderen teilen willst, könntest du ihnen einfach die Python-Datei schicken und sie diese in der Kommandozeile ausführen lassen – das funktioniert für manche, vor allem für Nutzer, die mit Python und der CLI vertraut sind.
Doch dieser Ansatz hat Grenzen. Nicht alle sind mit der Kommandozeile vertraut, und selbst dann braucht es eine korrekt eingerichtete Python-Umgebung mit allen Abhängigkeiten. Das ist umständlich und bremst den Zugang zu deiner Übersetzungsanwendung.
Hier kommt FastAPI ins Spiel: Wenn du deine Anwendung als REST-API-Endpoint bereitstellst, entsteht eine zugängliche Schnittstelle, die über das Internet erreichbar ist – ganz ohne dass Nutzer selbst Python-Skripte ausführen müssen. Sie können per einfachem Webrequest interagieren, von unterschiedlichsten Plattformen und Programmiersprachen aus, nicht nur Python.
Mit FastAPI automatisierst du das Empfangen von Übersetzungsanfragen und das Zurücksenden der Ergebnisse. Nutzer können Text über ein Web-Interface oder per programmgesteuertem API-Call schicken – einfacher und flexibler für viele Use Cases.
Um die Funktion mit FastAPI in einen API-Endpoint zu verwandeln, passen wir den Code so an:
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import os
os.environ["OPENAI_API_KEY"] = "..."
# Initialize OpenAI client with your API key
client = OpenAI()
# Initialize FastAPI client
app = FastAPI()
# Create class with pydantic BaseModel
class TranslationRequest(BaseModel):
input_str: str
def translate_text(input_str):
completion = client.chat.completions.create(
model="gpt-4-0125-preview",
messages=[
{
"role": "system",
"content": "You are an expert translator who translates text from english to french and only return translated text",
},
{"role": "user", "content": input_str},
],
)
return completion.choices[0].message.content
@app.post("/translate/") # This line decorates 'translate' as a POST endpoint
async def translate(request: TranslationRequest):
try:
# Call your translation function
translated_text = translate_text(request.input_str)
return {"translated_text": translated_text}
except Exception as e:
# Handle exceptions or errors during translation
raise HTTPException(status_code=500, detail=str(e))Starte und teste die API lokal mit folgendem Befehl:
uvicorn main:app --reloadHier verweist main.py auf die Datei mit deinem Code. Der Begriff app zeigt auf die FastAPI-Instanz in deinem Code, also app = FastAPI().
Rufe localhost:8000/docs auf, um die UI zu sehen. Sie sollte so aussehen:
Klicke auf POST, dann auf Try it out, gib deinen Text ein und klicke auf Execute.
Du siehst den an die API gesendeten curl-Befehl, die Request-URL (aktuell dein Localhost) und die Serverantwort. Code 200 bedeutet Erfolg; daneben findest du die französische Übersetzung.
Fazit
Dieser Blog hat gezeigt, wie du mit FastAPI einen API-Endpoint einrichtest, um Anwendungen mit Large Language Models wie GPT bereitzustellen. FastAPI kombiniert Performance mit einfacher Bedienung und ist damit eine hervorragende Wahl, wenn du LLMs in deine Projekte integrieren möchtest.
Wenn du das volle Potenzial von LLMs entdecken willst – mit einem einzigartigen, konzeptionellen Kurs zu Anwendungen, Trainingsmethoden, ethischen Aspekten und aktueller Forschung –, sieh dir den kostenlosen Kurs Mastering Large Language Models (LLMs) auf Datacamp an.
Du willst dein Skillset und deine Tools erweitern? Erfahre mehr über die 21 unverzichtbaren Python-Tools für Softwareentwicklung, Web Scraping und -Development, Datenanalyse und -visualisierung sowie Machine Learning.
Themen