GPT-3.5 und GPT-4 über die OpenAI API in Python verwenden

Wann solltest du die API und nicht das Webinterface verwenden?

Die ChatGPT-Webanwendung ist eine tolle Schnittstelle zu den GPT-Modellen. Wenn du jedoch KI in eine Datenpipeline oder in eine Software einbinden willst, ist die API besser geeignet. Einige mögliche Anwendungsfälle für Datenpraktiker sind:

• Daten aus einer Datenbank oder einer anderen API abrufen und GPT dann bitten, sie zusammenzufassen oder einen Bericht darüber zu erstellen
• Einbettung der GPT-Funktionalität in ein Dashboard, um automatisch eine Textzusammenfassung der Ergebnisse zu liefern
• Bereitstellung einer natürlichsprachlichen Schnittstelle zu deinem Data Mart
• Recherchieren, indem du Zeitschriftenartikel über das Paket scholarly(PyPI, Conda) abrufst und GPT die Ergebnisse zusammenfassen lässt

Einrichten eines OpenAI Entwickler-Kontos

Um die API zu nutzen, musst du ein Entwicklerkonto bei OpenAI anlegen. Du musst deine E-Mail-Adresse, Telefonnummer und die Daten deiner Bank- oder Kreditkarte bereithalten.

Befolge diese Schritte:

1. Gehe zur API-Anmeldeseite.
2. Erstelle dein Konto (du musst deine E-Mail-Adresse und deine Telefonnummer angeben).
3. Gehe zur Seite mit den API-Schlüsseln.
4. Erstelle einen neuen geheimen Schlüssel.
5. Mach eine Kopie von diesem Schlüssel. (Wenn du ihn verlierst, lösche den Schlüssel und erstelle einen neuen).
6. Gehe auf die Seite Zahlungsarten.
7. Klicke auf "Zahlungsmethode hinzufügen" und gib deine Kartendaten ein.

Sichere Aufbewahrung deiner Kontodaten

Der geheime Schlüssel muss geheim gehalten werden! Andernfalls können andere Personen die API nutzen, und du musst dafür bezahlen. Die folgenden Schritte beschreiben, wie du deinen Schlüssel sicher in DataLab, dem KI-fähigen Daten-Notizbuch von DataCamp, speichern kannst. Wenn du eine andere Plattform verwendest, schau bitte in der Dokumentation für diese Plattform nach. Du kannst auch ChatGPT um Rat fragen. Hier ist ein Vorschlag für eine Aufforderung:

> Du bist ein IT-Sicherheitsexperte. Du sprichst mit einem Datenwissenschaftler. Erkläre die besten Praktiken für die sichere Aufbewahrung privater Schlüssel, die für den API-Zugang verwendet werden.

1. Klicke in deiner DataLab-Arbeitsmappe auf "Umgebung".
2. Klicke auf das Pluszeichen neben "Umwelt".
3. In das Feld "Name" gibst du "OPENAI" ein. Füge in das Feld "Wert" deinen geheimen Schlüssel ein
4. Gib der Gruppe von Umgebungsvariablen einen Namen (das kann wirklich alles sein)
5. Klicke auf "Erstellen", und verbinde die neue Integration

Python einrichten

Um GPT über die API zu nutzen, musst du die Python-Pakete os und openai importieren.

Wenn du eine Jupyter-Notebook-Lösung (wie DataLab) verwendest, ist es auch hilfreich, einige Funktionen von IPython.display zu importieren.

Ein Beispiel verwendet auch das yfinance-Paket, um Aktienkurse abzurufen.

# Import the os package
import os

# Import the openai package
import openai

# From the IPython.display package, import display and Markdown
from IPython.display import display, Markdown

# Import yfinance as yf
import yfinance as yf

Die andere Aufgabe besteht darin, die Umgebungsvariable, die du gerade erstellt hast, an einem Ort zu platzieren, an dem das openai-Paket sie sehen kann.

# Set openai.api_key to the OPENAI environment variable
openai.api_key = os.environ["OPENAI"]

Das Code-Muster für den Aufruf von GPT über die API

Das Codemuster, um die OpenAI API aufzurufen und eine Chat-Antwort zu erhalten, lautet wie folgt:

response = openai.ChatCompletion.create(
              model="MODEL_NAME",
              messages=[{"role": "system", "content": 'SPECIFY HOW THE AI ASSISTANT SHOULD BEHAVE'},
                        {"role": "user", "content": 'SPECIFY WANT YOU WANT THE AI ASSISTANT TO SAY'}
              ])

Hier gibt es mehrere Dinge auszupacken.

OpenAI API-Modellnamen für GPT

Die Modellnamen sind auf der Seite Modellübersicht in der Entwicklerdokumentation aufgeführt. In diesem Lernprogramm verwendest du gpt-3.5-turbo, das neueste Modell von chatGPT mit öffentlichem API-Zugang. (Sobald es allgemein verfügbar ist, solltest du auf gpt-4 umsteigen).

OpenAI API GPT Nachrichtentypen

Es gibt drei Arten von Nachrichten, die in der Einführung in die Chat-Dokumentation beschrieben sind:

• system Nachrichten beschreiben das Verhalten des KI-Assistenten. Eine nützliche Systemnachricht für Anwendungsfälle der Datenwissenschaft lautet: "Du bist ein hilfreicher Assistent, der sich mit Datenwissenschaft auskennt."
• user Nachrichten beschreiben, was du dem KI-Assistenten sagen willst. Im Laufe dieses Tutorials werden wir Beispiele für Benutzernachrichten behandeln
• assistant Nachrichten beschreiben frühere Antworten in der Konversation. Wie du ein interaktives Gespräch führst, erfährst du in späteren Aufgaben

Die erste Meldung sollte eine Systemmeldung sein. Zusätzliche Nachrichten sollten abwechselnd zwischen dem Nutzer und dem Assistenten erscheinen.

Dein erstes Gespräch: Erzeugen eines Datensatzes

Die Erstellung von Beispieldatensätzen ist nützlich, um deinen Code mit verschiedenen Datenszenarien zu testen oder um ihn anderen zu demonstrieren. Um eine brauchbare Antwort von GPT zu erhalten, musst du genau sein und die Details deines Datensatzes angeben, einschließlich:

• die Anzahl der Zeilen und Spalten
• die Namen der Spalten
• eine Beschreibung, was jede Spalte enthält
• das Ausgabeformat des Datensatzes

Hier ist ein Beispiel für eine Benutzernachricht zum Erstellen eines Datensatzes.

Create a small dataset about total sales over the last year. 
The format of the dataset should be a data frame with 12 rows and 2 columns. 
The columns should be called "month" and "total_sales_usd". 
The "month" column should contain the shortened forms of month names 
from "Jan" to "Dec". The "total_sales_usd" column should 
contain random numeric values taken from a normal distribution 
with mean 100000 and standard deviation 5000. Provide Python code to 
generate the dataset, then provide the output in the format of a markdown table.

Lass uns diese Nachricht in das vorherige Codemuster einfügen.

# Define the system message
system_msg = 'You are a helpful assistant who understands data science.'

# Define the user message
user_msg = 'Create a small dataset about total sales over the last year. The format of the dataset should be a data frame with 12 rows and 2 columns. The columns should be called "month" and "total_sales_usd". The "month" column should contain the shortened forms of month names from "Jan" to "Dec". The "total_sales_usd" column should contain random numeric values taken from a normal distribution with mean 100000 and standard deviation 5000. Provide Python code to generate the dataset, then provide the output in the format of a markdown table.'

# Create a dataset using GPT
response = openai.ChatCompletion.create(model="gpt-3.5-turbo",
                                        messages=[{"role": "system", "content": system_msg},
                                         {"role": "user", "content": user_msg}])

Prüfe, ob die Antwort von GPT OK ist

API-Aufrufe sind "riskant", weil Probleme außerhalb deines Notebooks auftreten können, z. B. Probleme mit der Internetverbindung, Probleme mit dem Server, der dir Daten sendet, oder weil dein API-Guthaben aufgebraucht ist. Du solltest überprüfen, ob die Antwort, die du erhältst, in Ordnung ist.

GPT-Modelle geben einen Statuscode mit einem von vier Werten zurück, die im Abschnitt Antwortformat in der Chat-Dokumentation dokumentiert sind.

• stop: API liefert vollständige Modellausgabe
• length: Unvollständige Modellausgabe aufgrund von max_tokens-Parameter oder Token-Limit
• content_filter: Ausgelassene Inhalte aufgrund einer Markierung durch unsere Inhaltsfilter
• null: API-Antwort noch in Bearbeitung oder unvollständig

Die GPT-API sendet Daten im JSON-Format an Python, sodass die Antwortvariable tief verschachtelte Listen und Wörterbücher enthält. Es ist ein bisschen mühsam, damit zu arbeiten!

Für eine Antwortvariable namens response wird der Statuscode an folgender Stelle gespeichert.

response["choices"][0]["finish_reason"]

Extrahiere die Nachricht des KI-Assistenten

In der Antwortvariable ist der Text versteckt, den wir GPT gebeten haben, zu erstellen. Zum Glück ist es immer am selben Ort.

response["choices"][0]["message"]["content"]

Der Inhalt der Antwort kann wie üblich mit print(content) ausgedruckt werden, aber es handelt sich um Markdown-Inhalte, die Jupyter-Notebooks über display(Markdown(content))

Here's the Python code to generate the dataset:

import numpy as np
import pandas as pd
# Set random seed for reproducibility
np.random.seed(42)
# Generate random sales data
sales_data = np.random.normal(loc=100000, scale=5000, size=12)
# Create month abbreviation list
month_abbr = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
# Create dataframe
sales_df = pd.DataFrame({'month': month_abbr, 'total_sales_usd': sales_data})
# Print dataframe
print(sales_df)

And here's the output in markdown format:

| month | total_sales_usd |

|-------|----------------|

| Jan | 98728.961189 |

| Feb | 106931.030292 |

| Mar | 101599.514152 |

| Apr | 97644.534384 |

| May | 103013.191014 |

| Jun | 102781.514665 |

| Jul | 100157.741173 |

| Aug | 104849.281004 |

| Sep | 100007.081991 |

| Oct | 94080.272682 |

| Nov | 96240.993328 |

| Dec | 104719.371461 |

Verwende eine Hilfsfunktion, um GPT aufzurufen

Du musst eine Menge sich wiederholenden Standardcode schreiben, um diese drei einfachen Dinge zu tun. Eine Wrapper-Funktion, die die langweiligen Teile abstrahiert, ist nützlich. Auf diese Weise können wir uns auf die Anwendungsfälle der Datenwissenschaft konzentrieren.

Es bleibt zu hoffen, dass OpenAI die Schnittstelle zu ihrem Python-Paket verbessert, damit solche Dinge eingebaut werden können. In der Zwischenzeit kannst du das gerne in deinem eigenen Code verwenden.

Die Funktion benötigt zwei Argumente.

• system: Eine Zeichenkette, die die Systemmeldung enthält.
• user_assistant: Ein Array von Strings, die abwechselnd die Benutzernachricht und die Assistentennachricht enthalten.

Der Rückgabewert ist der generierte Inhalt.

def chat(system, user_assistant):
  assert isinstance(system, str), "`system` should be a string"
  assert isinstance(user_assistant, list), "`user_assistant` should be a list"
  system_msg = [{"role": "system", "content": system}]
  user_assistant_msgs = [
      {"role": "assistant", "content": user_assistant[i]} if i % 2 else {"role": "user", "content": user_assistant[i]}
      for i in range(len(user_assistant))]

  msgs = system_msg + user_assistant_msgs
  response = openai.ChatCompletion.create(model="gpt-3.5-turbo",
                                          messages=msgs)
  status_code = response["choices"][0]["finish_reason"]
  assert status_code == "stop", f"The status code was {status_code}."
  return response["choices"][0]["message"]["content"]

Ein Beispiel für die Verwendung dieser Funktion ist

response_fn_test = chat("You are a machine learning expert.",["Explain what a neural network is."])

display(Markdown(response_fn_test))

A neural network is a type of machine learning model that is inspired by the architecture of the human brain. It consists of layers of interconnected processing units, called neurons, that work together to process and analyze data.

Each neuron receives input from other neurons or from external sources, processes that input using a mathematical function, and then produces an output that is passed on to other neurons in the network.

The structure and behavior of a neural network can be adjusted by changing the weights and biases of the connections between neurons. During the training process, the network learns to recognize patterns and make predictions based on the input it receives.

Neural networks are often used for tasks such as image classification, speech recognition, and natural language processing, and have been shown to be highly effective at solving complex problems that are difficult to solve with traditional rule-based programming methods.

Antworten des KI-Assistenten wiederverwenden

In vielen Situationen wirst du ein längeres Gespräch mit der KI führen wollen. Das heißt, du sendest einen Prompt an GPT, bekommst eine Antwort zurück und sendest einen weiteren Prompt, um den Chat fortzusetzen. In diesem Fall musst du die vorherige Antwort von GPT in den zweiten Aufruf der API einbeziehen, damit GPT den vollständigen Kontext hat. Dadurch wird die Genauigkeit der Antwort verbessert und die Konsistenz der Konversation erhöht.

Um die Nachricht von GPT wiederzuverwenden, holst du sie aus der Antwort und übergibst sie dann an einen neuen Aufruf an den Chat.

Beispiel: Analysieren des Beispieldatensatzes

Versuchen wir nun, den Mittelwert der Umsatzspalte aus dem zuvor erstellten Datensatz zu berechnen. Da wir beim ersten Mal nicht die Funktion chat() verwendet haben, müssen wir den längeren Untersetzungscode verwenden, um an den vorherigen Antworttext zu gelangen. Wenn du chat() verwendest, ist der Code einfacher.

# Assign the content from the response in Task 1 to assistant_msg
assistant_msg = response["choices"][0]["message"]["content"]

# Define a new user message
user_msg2 = 'Using the dataset you just created, write code to calculate the mean of the `total_sales_usd` column. Also include the result of the calculation.'

# Create an array of user and assistant messages
user_assistant_msgs = [user_msg, assistant_msg, user_msg2]

# Get GPT to perform the request
response_calc = chat(system_msg, user_assistant_msgs)

# Display the generated content
display(Markdown(response_calc))

Sure! Here's the code to calculate the mean of the `total_sales_usd` column: 

```python 
mean_sales = sales_df['total_sales_usd'].mean() 
print("Mean sales: $", round(mean_sales, 2)) 
``` 

And here's the output of this code: 

``` 
Mean sales: $ 100077.57 
``` 

Therefore, the mean of total sales over the last year is about $100,077.57. 

GPT in einer Pipeline verwenden

Ein großer Vorteil der API gegenüber dem Webinterface ist, dass du GPT mit anderen APIs kombinieren kannst. Daten aus einer oder mehreren Quellen zu beziehen und dann KI darauf anzuwenden, ist ein leistungsstarker Workflow.

Anwendung von GPT AI auf Wetterdaten

Hier ziehen wir eine Wettervorhersage mit dem Paket weather2(PyPI) heran und nutzen GPT, um Ideen für Aktivitäten zu entwickeln.

# Import the weather2 package
import weather

# Get the forecast for Miami
location = "Miami"
forecast = weather.forecast(location)

# Pull out forecast data for midday tomorrow
fcast = forecast.tomorrow["12:00"]

# Create a prompt
user_msg_weather = f"In {location} at midday tomorrow, the temperature is forecast to be {fcast.temp}, the wind speed is forecast to be {fcast.wind.speed} m/s, and the amount of precipitation is forecast to be {fcast.precip}. Make a list of suitable leisure activities."

# Call GPT
response_activities = chat("You are a travel guide.", [user_msg_weather])

display(Markdown(response_activities))

With mild temperatures and calm winds, Miami is the perfect place for leisure activities. Here are some suggestions:

1. Visit Miami's beaches and soak up some sun or take a dip in the ocean!

2. Explore Miami's art scene with a visit to the Perez Art Museum Miami or the Wynwood Walls.

3. Take a stroll along the famous Ocean Drive and enjoy the colorful Art Deco architecture.

4. Head to Little Havana to experience the Cuban culture and delicious cuisine.

5. Enjoy a scenic walk or bike ride through one of Miami's many parks, such as Bayfront Park or South Pointe Park.

6. Visit the Miami Seaquarium and see some incredible marine life up close.

7. Take a boat tour to see the stunning Miami skyline from the water.

8. Shopping enthusiasts can explore the many high-end boutiques and outdoor shopping malls, such as Lincoln Road Mall.

9. Foodies can venture to one of the many food festivals happening throughout the year.

10. Finally, there are plenty of nightclubs and live music venues to keep the night going.

Schön! Ein Teil von mir wünscht sich, ich wäre morgen in Miami!

Bring es auf die nächste Stufe

Mehr über die Verwendung von GPT erfährst du im Kurs Einführung in ChatGPT. (Ein vollständiger Kurs über die Arbeit mit der OpenAI API folgt in Kürze!)

Als Referenz für das, was du gerade gelernt hast, nimm dir das OpenAI API in Python Cheat Sheet oder schau dir die Aufzeichnung der Live-Schulung Getting Started with the OpenAI API and ChatGPT an.

Wenn du dich für die Text-zu-Sprache-Transkription interessierst, lies das Tutorial Umwandlung von Sprache in Text mit der OpenAI Whisper API.