GPT-3.5 en GPT-4 gebruiken via de OpenAI-API in Python

Wanneer gebruik je de API in plaats van de webinterface?

De ChatGPT-webapplicatie is een fijne interface voor GPT-modellen. Maar als je AI wilt opnemen in een datapijplijn of in software, is de API geschikter. Mogelijke use-cases voor dataprofessionals zijn onder meer:

• Data ophalen uit een database of een andere API en GPT vragen om deze samen te vatten of er een rapport over te genereren
• GPT-functionaliteit in een dashboard inbedden om automatisch een tekstuele samenvatting van de resultaten te geven
• Een natuurlijke-taalinterface bieden voor je datamart
• Onderzoek doen door tijdschriftartikelen binnen te halen via het scholarly-pakket (PyPI, Conda) en GPT de resultaten te laten samenvatten

Maak een OpenAI-ontwikkelaarsaccount aan

Om de API te gebruiken, moet je een ontwikkelaarsaccount bij OpenAI aanmaken. Zorg dat je je e-mailadres, telefoonnummer en je debit- of creditcardgegevens bij de hand hebt.

Volg deze stappen:

1. Ga naar de API-signuppagina.
2. Maak je account aan (je moet je e-mailadres en telefoonnummer opgeven).
3. Ga naar de pagina met API-keys.
4. Maak een nieuwe geheime key aan.
5. Kopieer deze key. (Als je hem kwijtraakt, verwijder de key dan en maak een nieuwe.)
6. Ga naar de pagina Betalingsmethoden.
7. Klik op 'Add payment method' en vul je kaartgegevens in.

Sla je accountgegevens veilig op

De geheime key moet geheim blijven! Anders kunnen anderen er de API mee gebruiken en betaal jij de rekening. Hieronder staat hoe je je key veilig opslaat in DataLab, de AI-enabled datanotebook van DataCamp. Gebruik je een ander platform, raadpleeg dan de documentatie daarvan. Je kunt ook ChatGPT om advies vragen. Hier is een suggestieprompt:

> Je bent een IT-beveiligingsexpert. Je spreekt met een data scientist. Leg de best practices uit voor het veilig opslaan van private keys voor API-toegang.

1. Klik in je DataLab-werkboek op "Environment"
2. Klik op het plusteken naast "Environment"
3. Typ in het veld "Name" "OPENAI". Plak in het veld "Value" je geheime key
4. Geef de set omgevingsvariabelen een naam (dit kan eigenlijk van alles zijn)
5. Klik op "Create" en koppel de nieuwe integratie

Python instellen

Om GPT via de API te gebruiken, moet je de Python-pakketten os en openai importeren.

Gebruik je een Jupyter Notebook-oplossing (zoals DataLab), dan is het ook handig om enkele functies uit IPython.display te importeren.

Eén voorbeeld gebruikt ook het yfinance-pakket om aandelenkoersen op te halen.

# 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

De andere setup-taak is om de omgevingsvariabele die je zojuist hebt aangemaakt op een plek te zetten waar het openai-pakket deze kan zien.

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

Het codepatroon voor het aanroepen van GPT via de API

Het codepatroon om de OpenAI-API aan te roepen en een chatantwoord te krijgen is als volgt:

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'}
              ])

Er valt hier het nodige over uit te pakken.

OpenAI-API-modelnamen voor GPT

De modelnamen staan op de pagina Model Overview van de ontwikkelaarsdocumentatie. In deze tutorial gebruik je gpt-3.5-turbo, het nieuwste model dat door ChatGPT wordt gebruikt en openbare API-toegang heeft. (Zodra het breed beschikbaar is, wil je overschakelen naar gpt-4.)

OpenAI-API GPT-berichttypen

Er zijn drie typen berichten gedocumenteerd in de Introduction to the Chat-documentatie:

• system-berichten beschrijven het gedrag van de AI-assistent. Een nuttig system-bericht voor data science-use-cases is "You are a helpful assistant who understands data science."
• user-berichten beschrijven wat je wilt dat de AI-assistent zegt. We behandelen door de hele tutorial voorbeelden van user-berichten
• assistant-berichten beschrijven eerdere antwoorden in het gesprek. We behandelen later hoe je een interactief gesprek voert

Het eerste bericht moet een system-bericht zijn. Aanvullende berichten wisselen af tussen de gebruiker en de assistent.

Je eerste gesprek: een dataset genereren

Voorbeelddatasets genereren is handig om je code te testen in verschillende datascenario’s of om code aan anderen te demonstreren. Om een bruikbaar antwoord van GPT te krijgen, moet je precies zijn en de details van je dataset specificeren, waaronder:

• het aantal rijen en kolommen
• de namen van de kolommen
• een beschrijving van wat elke kolom bevat
• het uitvoerformaat van de dataset

Hier is een voorbeeld van een user-bericht om een dataset te maken.

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.

Laten we dit bericht opnemen in het eerdere codepatroon.

# 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}])

Controleer of het antwoord van GPT oké is

API-calls zijn "riskant" omdat er problemen kunnen optreden buiten je notebook, zoals internetstoringen, een probleem met de server die je data stuurt, of omdat je API-tegoed op is. Je moet controleren of het antwoord dat je krijgt oké is.

GPT-modellen geven een statuscode terug met een van vier waarden, gedocumenteerd in de sectie Response format van de Chat-documentatie.

• stop: API gaf volledige modeloutput terug
• length: Onvolledige modeloutput vanwege de parameter max_tokens of tokenlimiet
• content_filter: Inhoud weggelaten door een vlag van onze contentfilters
• null: API-respons is nog bezig of onvolledig

De GPT-API stuurt data naar Python in JSON-formaat, dus de response-variabele bevat diep geneste lijsten en dictionaries. Niet heel prettig om mee te werken!

Voor een response-variabele met de naam response staat de statuscode op de volgende plek.

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

Haal het bericht van de AI-assistent op

Diep in de response-variabele zit de tekst die we GPT vroegen te genereren. Gelukkig staat die altijd op dezelfde plek.

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

De response-inhoud kun je zoals gebruikelijk afdrukken met print(content), maar het is Markdown-inhoud die Jupyter-notebooks kunnen renderen via 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 |

Gebruik een helperfunctie om GPT aan te roepen

Je moet veel herhalende boilerplatecode schrijven om deze drie simpele dingen te doen. Een wrapperfunctie om de saaie stukken te verbergen is handig. Zo kunnen we ons focussen op data science-use-cases.

Hopelijk verbetert OpenAI de interface van hun Python-pakket zodat dit soort zaken ingebouwd zijn. Tot die tijd kun je dit gerust in je eigen code gebruiken.

De functie neemt twee argumenten.

• system: Een string met het system-bericht.
• user_assistant: Een array met strings die afwisselen tussen user-bericht en assistant-bericht.

De returnwaarde is de gegenereerde content.

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"]

Voorbeeldgebruik van deze functie is

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.

Antwoorden van de AI-assistent hergebruiken

In veel situaties wil je een langer gesprek voeren met de AI. Dus: je stuurt een prompt naar GPT, krijgt een antwoord terug en stuurt nog een prompt om de chat voort te zetten. In dat geval moet je het eerdere antwoord van GPT opnemen in de tweede API-call, zodat GPT de volledige context heeft. Dit verbetert de nauwkeurigheid van het antwoord en vergroot de consistentie in het gesprek.

Om het GPT-bericht te hergebruiken, haal je het uit de response en geef je het mee in een nieuwe call naar chat.

Voorbeeld: de voorbeelddataset analyseren

Laten we proberen het gemiddelde van de verkoopkolom uit de eerder gegenereerde dataset te berekenen. Let op dat we de eerste keer de functie chat() niet hebben gebruikt, dus moeten we de langere subsetcode gebruiken om bij de vorige responsetekst te komen. Als je chat() gebruikt, is de code eenvoudiger.

# 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 gebruiken in een pijplijn

Een groot voordeel van de API boven de webinterface is dat je GPT kunt combineren met andere API’s. Data ophalen uit één of meer bronnen en er vervolgens AI op toepassen is een krachtige workflow.

GPT toepassen op weerdata

Hier halen we een weersvoorspelling op met het weather2-pakket (PyPI) en gebruiken we GPT om ideeën voor activiteiten te bedenken.

# 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.

Nice! Een deel van mij wou dat ik morgen in Miami was!

Maak de volgende stap

Je kunt meer leren over het gebruik van GPT in de cursus Introduction to ChatGPT. (Een volledige cursus over werken met de OpenAI-API komt binnenkort!)

Voor naslag van wat je zojuist hebt geleerd, neem een kopie van de OpenAI API in Python Cheatsheet of bekijk de opname van de live training Getting Started with the OpenAI API and ChatGPT.

Als je geïnteresseerd bent in spraak-naar-teksttranscriptie, lees dan de tutorial Converting Speech to Text with the OpenAI Whisper API.