Jetzt, anfang 2024, ist es gerade mal etwas mehr als ein Jahr her, dass die KI chatGPT das Thema Künstliche Intelligenz in den Mainstream katapultiert hat. Mittlerweile ist chatGPT auf dem Desk vieler Leute zum Standard-Tool geworden. Auch als Programmierer nutzt man dieses Tool, z. B. um den eigenen Code zu debuggen oder um ihn zu optimieren.
chatGPT ist ein sog. LLM, ein Large Language Model des Unternehmens OpenAI. Ein solches LLM ist ein leistungsstarkes Sprachmodell, das mithilfe von künstlicher Intelligenz entwickelt wurde, um menschenähnliche Sprachmuster zu verstehen und zu generieren. Anders als herkömmliche Programme, die spezifische Anweisungen befolgen, ist ein LLM darauf trainiert, Kontexte zu verstehen und natürliche Sprache in Form von Text zu verarbeiten. Durch umfangreiches Training auf riesigen Textdatensätzen kann ein LLM komplexe Zusammenhänge erfassen und darauf basierend kohärente und kontextsensitive Ausgaben generieren. Solche LLMs werden zunehmend eingesetzt, als Chatbots oder virtuelle Assistenten und weiteren Sprachanwendungen.
Was fast jeder kennen sollte, ist das bekannte Web-Frontend, über das man mit chatGPT chatten kann. Dabei formuliert man einen sog. Prompt, also den Eingabetext, auf dem chatGPT seine Sprach- und Kontextverarbeitung durchführt. Was weniger Leute wissen ist, dass OpenAI neben dem Web-Frontend auch eine API anbietet, über die man das Language Model von chatGPT in seine eigenen Programme integrieren kann. Nachfolgend möchte ich euch mal eine kurze Einführung geben, wie man sowas mit Python implementiert. Ich gehe mal davon aus, ihr habt Python auf eurem System installiert. Falls nicht, verweise ich euch auf diesen Blog-Artikel mit entsprechenden Videos, wo gezeigt wird, wie das geht.
https://www.data-science.icu/2024/02/04/grundlagen-wie-installiert-man-python-auf-seinem-system/
Wenn man mit der OpenAI API arbeiten möchte, benötigt man zuerst einen Account bei OpenAI. Wenn man diesen hat, dann kann man sich einen API-Key generieren lassen, über den man in den eigenen Programmen auf die API von chatGPT zugreifen kann. Hier gehts zu einem Blog-Artikel mit einem Video, das die Registrierung bei OpenAI erklärt.
https://www.data-science.icu/2024/02/04/developer-account-bei-openai-anlegen/
Ok, ihr habt Python installiert, ein Developer Konto bei OpenAI angelegt und auch schon einen API Key generieren lassen. Dann legen wir los.
Zunächst benötigen wir einen Ordner für unser Projekt. In diesem Ordner legen wir unser Script und alle benötigten Pakete rein. Damit die Pakete, die wir für unser Projekt verwenden wollen, nicht die generelle Python Installation durcheinander bringen, erstellen wir für unseren Projektordner eine virtuelle Python Umgebung. Das heißt, für unser Projekt notwendige Pakete werden nur lokal in diesem Ordner installiert.
Nehmen wir an, wir haben einen Projektordner chat_gpt. Also wechseln wir zuerst mit cd path\to\chat_gpt in diesen Ordner. Ich verwende für dieses Beispiel Windows als Betriebssystem, daher die Backslashes im Pfad. Nun legen wir in diesem Ordner eine virtuelle Entwicklungsumgebung an:
python -m venv venvBeachte, dass hier „python“ auf deinem System dem ausführbaren Dateipfad zu Python entsprechen sollte. In einigen Systemen könnte es auch „python3“ sein. Eventuell musst du den Python-Interpreter zu deiner PATH Variable hinzufügen. Wenn die virtuelle Umgebung erstellt wurde, dann musst du sie noch aktivieren. Dies erreichst du über folgende Anweisung:
venv\Scripts\activate.batWenn das erfolgreich war, dann sollte vor dem normalen Prompt, links von deinem Cursor nun (venv) oder (chat_gpt) stehen. Damit wird angezeigt, dass du dich jetzt in der virtuellen Umgebung befindest. Mit dem Kommando deactivate kommst du übrigens wieder aus der virtuellen Umgebung raus.
Nun können wir mit dem Paketmanagemer pip das notwendige Packet für den Zugriff auf die OpenAI API installieren:
pip install openaiJetzt können wir das Python Script erzeugen mit dem programmieren beginnen. Zu Beginn binden wir die notwendigen Pakete ein. Neben der OpenAI Lib benötigen wir noch die JSON Lib.
from openai import OpenAI
import jsonAls nächstes müssen wir den OpenAI Client initialisieren. Dazu benötigen wir den API Key, den wir zuvor im OpenAI Dashboard generiert haben. Zusätzlich legen wir das GPT Modell fest, das wir für unsere Abfrage verwenden wollen. Für unser Beispiel verwenden wir GPT-3.5 Turbo. Das ist auch das Modell, das kostenfrei über die chatGPT Oberfläche benutzt werden kann.
OPENAI_API_KEY = "-api-key-" # Hier kommt der generierte API Key rein
OPENAI_MODEL = "gpt-3.5-turbo" # Das zu verwendende GPT Modell
client = OpenAI(
api_key=OPENAI_API_KEY,
)Bei der Verwendung über die API kostet das GPT 3.5 Modell zwar etwas, ist aber doch deutlich günstiger als die neueren GPT Modelle. Die Kosten hängen auch von Anzahl der Tokens ab, die bei einer Anfrage benötigt werden. Die Kosten beim Entwickeln halten sich aber in Grenzen. Bei einem Dutzend Anfragen liegt man vielleicht bei ein bis zwei Dollarcent. In einer Produktivumgebung sieht das natürlich anders aus. Eine sehr gute Übersicht zu den OpenAI Modellen und den Kosten, findet man hier: OPENAI API PREISRECHNER
Bevor wir einen Request an die chatGPT API senden, benötigen wir natürlich noch den Eingabetext, also den Prompt, den wir senden wollen. Wollen wir für dieses Beispiel mal eine Frage an chatGPT stellen. chatGPT soll uns alle Spieler der Fußball Weltmeistermannschaft von 1974 ausgeben – und zwar im JSON Format.
prompt = f"""
Du bist Fußballexperte. Bitte gebe mir die Spieler der deutschen Fußballmannschaft des
Weltmeisters von 1974 aus. Bitte gebe Vorname, Nachname, Alter zum Zeitpunkt der
Weltmeisterschaft, Rückennummer, Spielposition und den Verein, bei dem der Spieler
im Jahre 1974 gespielt hat aus. Bitte gebe die Daten im JSON Format zurück.
"""Als nächstes führen wir die Abfrage aus. Dabei setzen wir noch einige Parameter wie z. B. den Prompt oder das zu verwendende GPT Model. Das Ergebnis wird in der Variable response_gpt gespeichert.
response_gpt = client.chat.completions.create(
messages=[
{
"role": "user",
"content": prompt,
}
],
model=OPENAI_MODEL, # KI Modell im Beispiel GPT 3.5
temperature=0.2, # tendeziell detailliertere und konsistente Ausgabe
)Die temperature-Einstellung beeinflusst die Zufälligkeit der generierten Ausgabe. Ein niedrigerer Temperaturwert (zum Beispiel 0.2) führt zu konservativeren und deterministischeren Ausgaben, während ein höherer Temperaturwert (zum Beispiel 0.8) zu mehr Vielfalt und Unvorhersehbarkeit also mehr Kreativität führt. Die role-Einstellung „user“ legt fest, dass ein Chat begonnen und ein Kontext sowie Anweisungen für die Chatinteraktion festgelegt werden.
Zu guter Letzt müssen wir den Response noch verarbeiten. Da wir ja eine Ausgabe im JSON-Format angefragt haben, müssen wir den Response entsprechend in das JSON Format konvertieren:
response = response_gpt.model_dump_json(indent=2)
response_json = json.loads(response)In der Variable response sollte nach der Anfrage an die API in etwa so ein Inhalt drin stehen:
{
"id": "chatcmpl-9oeAISsMqRIhLzVxF9UlOk4zX9KJd",
"choices": [
{
"finish_reason": "stop",
"index": 0,
"logprobs": null,
"message": {
"content": "{\n \"spieler\": [\n {\n \"vorname\": \"Sepp\",\n \"nachname\": \"Maier\",\n \"alter\": 30,\n \"rueckennummer\": 1,\n \"spielposition\": \"Torwart\",\n \"verein\": \"Bayern München\"\n },\n {\n \"vorname\": \"Berti\",\n \"nachname\": \"Vogts\",\n
\"alter\": 28,\n \"rueckennummer\": 2,\n \"spielposition\": \"Verteidiger\",\n \"verein\": \"Borussia Mönchengladbach\"\n },\n {\n \"vorname\": \"Paul\",\n \"nachname\": \"Breitner\",\n \"alter\": 22,\n \"rueckennummer\": 3,\n \"spielposition\": \"Verteidiger\",\n
\"verein\": \"Bayern München\"\n },\n {\n \"vorname\": \"Franz\",\n \"nachname\": \"Beckenbauer\",\n \"alter\": 29,\n \"rueckennummer\": 5,\n \"spielposition\": \"Verteidiger\",\n \"verein\": \"Bayern München\"\n },\n {\n \"vorname\": \"Hans-Georg\",\n \"nachname\": \"Schwarzenbeck\",\n \"alter\": 28,\n \"rueckennummer\": 4,\n \"spielposition\": \"Verteidiger\",\n \"verein\": \"Bayern München\"\n },\n {\n \"vorname\": \"Uli\",\n \"nachname\": \"Hoeneß\",\n \"alter\": 22,\n \"rueckennummer\": 6,\n \"spielposition\": \"Mittelfeldspieler\",\n \"verein\": \"Bayern München\"\n },\n {\n \"vorname\": \"Wolfgang\",\n \"nachname\": \"Overath\",\n \"alter\": 31,\n \"rueckennummer\": 7,\n \"spielposition\": \"Mittelfeldspieler\",\n \"verein\": \"1. FC Köln\"\n },\n {\n \"vorname\": \"Jürgen\",\n
\"nachname\": \"Grabowski\",\n \"alter\": 30,\n \"rueckennummer\": 8,\n \"spielposition\": \"Mittelfeldspieler\",\n \"verein\": \"Eintracht Frankfurt\"\n },\n {\n \"vorname\": \"Gerd\",\n \"nachname\": \"Müller\",\n \"alter\": 28,\n \"rueckennummer\": 9,\n \"spielposition\": \"Stürmer\",\n \"verein\": \"Bayern München\"\n },\n {\n \"vorname\": \"Bernd\",\n \"nachname\": \"Hölzenbein\",\n \"alter\": 27,\n \"rueckennummer\": 10,\n \"spielposition\": \"Mittelfeldspieler\",\n \"verein\": \"Eintracht Frankfurt\"\n },\n {\n \"vorname\": \"Jupp\",\n \"nachname\": \"Heynckes\",\n \"alter\": 29,\n \"rueckennummer\": 11,\n \"spielposition\": \"Stürmer\",\n \"verein\": \"Borussia Mönchengladbach\"\n }\n ]\n}",
"role": "assistant",
"function_call": null,
"tool_calls": null
}
}
],
"created": 1707081486,
"model": "gpt-3.5-turbo-0613",
"object": "chat.completion",
"system_fingerprint": null,
"usage": {
"completion_tokens": 713,
"prompt_tokens": 99,
"total_tokens": 812
}
}Die Funktion loads (load string) ist Teil des json-Moduls in Python. Sie wird verwendet, um einen JSON-String in eine Python-Datenstruktur umzuwandeln. Der Ausdruck json.loads(response) weist den Interpreter an, den JSON-String, der in der Variable response gespeichert ist, in ein Python-Dictionary umzuwandeln. Dieses Dictionary kann dann verwendet werden, um auf die in der ursprünglichen JSON-Antwort enthaltenen Daten zuzugreifen.
Der eigentliche Inhalt der Antwort befindet sich in der JSON-Struktur in dem Objekt „content“. Diesen wollen wir nun mit folgenden Code extrahieren und ausgeben lassen.
# Eigentlichen Inhalt extrahieren
if( response_json is not None ):
content = response_json["choices"][0]["message"]["content"]
json_content = json.loads(content)
print(json_content)Ausgabe:
{
"spieler":[
{
"vorname":"Sepp",
"nachname":"Maier",
"alter":30,
"rueckennummer":1,
"spielposition":"Torwart",
"verein":"Bayern München"
},
{
"vorname":"Berti",
"nachname":"Vogts",
"alter":28,
"rueckennummer":2,
"spielposition":"Verteidiger",
"verein":"Borussia Mönchengladbach"
},
{
"vorname":"Paul",
"nachname":"Breitner",
"alter":22,
"rueckennummer":3,
"spielposition":"Verteidiger",
"verein":"Bayern München"
},
{
"vorname":"Franz",
"nachname":"Beckenbauer",
"alter":28,
"rueckennummer":4,
"spielposition":"Verteidiger",
"verein":"Bayern München"
},
{
"vorname":"Hans-Georg",
"nachname":"Schwarzenbeck",
"alter":28,
"rueckennummer":5,
"spielposition":"Verteidiger",
"verein":"Bayern München"
},
{
"vorname":"Wolfgang",
"nachname":"Overath",
"alter":31,
"rueckennummer":6,
"spielposition":"Mittelfeldspieler",
"verein":"1. FC Köln"
},
{
"vorname":"Uli",
"nachname":"Hoeneß",
"alter":22,
"rueckennummer":7,
"spielposition":"Mittelfeldspieler",
"verein":"Bayern München"
},
{
"vorname":"Jürgen",
"nachname":"Grabowski",
"alter":30,
"rueckennummer":8,
"spielposition":"Mittelfeldspieler",
"verein":"Eintracht Frankfurt"
},
{
"vorname":"Gerd",
"nachname":"Müller",
"alter":28,
"rueckennummer":9,
"spielposition":"Stürmer",
"verein":"Bayern München"
},
{
"vorname":"Bernd",
"nachname":"Hölzenbein",
"alter":27,
"rueckennummer":10,
"spielposition":"Mittelfeldspieler",
"verein":"Eintracht Frankfurt"
},
{
"vorname":"Jupp",
"nachname":"Heynckes",
"alter":29,
"rueckennummer":11,
"spielposition":"Stürmer",
"verein":"Borussia Mönchengladbach"
}
]
}Voilà! Wir sind fertig mit unserem Beispiel. Wie man sieht, ist die Verwendung der OpenAI API gerade mit Python fast schon ein Kinderspiel. Natürlich müsste man noch entsprechenden Fehlerbehandlungscode einbauen und die Configs am besten in eigene Dateien auslagern.
Wozu könnte man diese API nun nutzen? Beispielsweise könnte man die chatGPT API für eine Sentimentanalyse verwenden. Tatsächlich funktioniert dies nach meiner eigenen Erfahrung mit chatGPT erstaunlich gut. Man könnte aber auch einen eigenen Chatbot bauen z. B. für die eigenen Webseite. Oder man verwendet die Speech2Text für die Spracheingabe und Text2Speech für die Sprachausgabe und fertig ist der virtuelle Callcenter Agent. Die Python-Welt bietet hier jede Menge Bibliotheken. Viel Spass beim experimentieren.
Hier nochmal das gesamte Script an einem Stück:
from openai import OpenAI
import json
#-----------------------------------------------------------------------------------------------------------
# OpenAI Client initialisieren
#-----------------------------------------------------------------------------------------------------------
OPENAI_API_KEY = "-api-key-" # Hier kommt der generierte API Key rein
OPENAI_MODEL = "gpt-3.5-turbo" # Das zu verwendende GPT Modell
client = OpenAI(
api_key=OPENAI_API_KEY,
)
prompt = f"""
Du bist Fußballexperte. Bitte gebe mir die Spieler der deutschen Fußballmannschaft des
Weltmeisters von 1974 aus. Bitte gebe Vorname, Nachname, Alter zum Zeitpunkt der
Weltmeisterschaft, Rückennummer, Spielposition und den Verein, bei dem der Spieler
im Jahre 1974 gespielt hat aus. Bitte gebe die Daten im JSON Format zurück.
"""
response_gpt = client.chat.completions.create(
messages=[
{
"role": "user",
"content": prompt,
}
],
model=OPENAI_MODEL,
temperature=0.2,
)
response = response_gpt.model_dump_json(indent=2)
response_json = json.loads(response)
# Eigentlichen Inhalt extrahieren
if( response_json is not None ):
content = response_json["choices"][0]["message"]["content"]
json_content = json.loads(content)
print(json_content)