Hoe OpenAI GPT-modellen te integreren in uw Django-project

De auteur heeft het Direct Relief Program geselecteerd om een donatie te ontvangen als onderdeel van het Write for Donations-programma.

Inleiding

OpenAI GPT-modellen hebben aan populariteit gewonnen vanwege hun brede gebruik bij het genereren van tekstinhoud voor verschillende taken zoals het opstellen van e-mails, het beantwoorden van klantenservice-FAQ’s en taalvertaling, om er een paar te noemen.

Deze GPT-modellen worden over het algemeen gebruikt via ChatGPT, een chatbot uitgebracht door OpenAI, of via API’s en bibliotheken die meer controle bieden. In deze tutorial wordt u begeleid bij het benutten van deze modellen met behulp van de OpenAI API binnen uw Django-webproject. U leert hoe u de ChatCompletion API kunt aanroepen met verschillende parameters en hoe u de antwoorden kunt formatteren en gebruiken.

Tegen het einde van deze tutorial heeft u een Django-eindpunt gemaakt dat, wanneer het wordt aangeroepen, een verzoek naar OpenAI stuurt om een kort verhaal te construeren met de opgegeven woorden en het antwoord teruggeeft.

Vereisten

Om deze tutorial te voltooien, heeft u nodig:

1. Een bestaand Django-project. Als je helemaal opnieuw begint, kun je een Django-project opzetten door de tutorial hoe je een Django-ontwikkelomgeving instelt te volgen.

2. Een OpenAI-account: Ga naar de OpenAI-platformwebsite en zoek naar de knop ‘Aanmelden’. Nadat je je hebt aangemeld, moet je je e-mailadres verifiëren en persoonlijke informatie invoeren.

3. Een OpenAI API-sleutel: Nadat je je account hebt ingesteld, log je in en ga je vanuit je dashboard naar de API-sleutels-sectie. Klik op ‘Nieuwe geheime sleutel maken’. Je API-sleutel wordt gegenereerd en ziet er ongeveer zo uit: sk-abcdefghijklmnop. Zorg ervoor dat je deze sleutel op een veilige locatie opslaat, want je kunt deze niet meer zien.

4. De OpenAI Python-pakket: Als u de tutorial in de eerste vereiste hebt gevolgd, zou u al een virtuele omgeving met de naam env actief moeten hebben binnen een directory met de naam django-apps. Zorg ervoor dat uw virtuele omgeving actief is door te controleren of de naam ervan tussen haakjes aan het begin van uw terminalprompt verschijnt. Als het niet actief is, kunt u het handmatig activeren door het volgende commando uit te voeren:

sammy@ubuntu:$ .env/bin/activate

In uw terminal vanuit de directory django-apps. Zodra uw omgeving actief is, voert u het volgende uit om het OpenAI Python-pakket te installeren:

(env)sammy@ubuntu:$ pip install openai

Stap 1 — Oproepen naar OpenAI

In deze stap voeg je je OpenAI API-sleutel toe aan de OpenAI-client en maak je een eenvoudige API-oproep naar de ChatCompletion API. Je zult ook de reactie onderzoeken die je van de API krijgt.

Om te beginnen, open je Python-interpreter:

(env)sammy@ubuntu:$ python

Importeer eerst de OpenAI-client en voeg je API-sleutel toe aan de client:

from openai import OpenAI
client = OpenAI(api_key="your-api-key")

Vervang "je-api-sleutel" door de daadwerkelijke API-sleutel die je hebt gekregen van het OpenAI-platform.

Latem maken we een API-oproep naar de ChatCompletion API. Gebruik de chat.completions.create() methode:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "count 1 to 10"}])

In de bovenstaande code hebben we het opgegeven model om te gebruiken als gpt-3.5-turbo, voegden we een enkel bericht object toe met de rol gebruiker (andere opties zijn systeem en assistent) en de inhoud / prompt tellen van 1 tot 10.

Om de reactie van de API-oproep te zien, kun je het reactiebericht afdrukken, dat de getallen 1 tot en met 10 in een mooie kleine lijst moet bevatten:

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

Uitvoer:

Output
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Gefeliciteerd! Je hebt met succes een eenvoudige API-oproep gedaan naar OpenAI en een reactie opgehaald. We zullen de API-reactie formatteren en gebruiken om een kort verhaal te maken in de volgende stappen.

Stap 2 — Werken met parameters

Nu je succesvol een eenvoudige API-oproep hebt gemaakt naar de ChatCompletion API, laten we eens kijken hoe je kunt werken met parameters om het gedrag van het model aan te passen. Er zijn verschillende parameters beschikbaar waarmee je de generatie van tekst kunt controleren. We zullen hieronder naar de drie kijken.

1. Temperatuur: De temperatuurparameter bepaalt hoe willekeurig de gegenereerde inhoud is. Een hogere temperatuurwaarde, zoals 0.8, zal meer diverse en creatieve reacties opleveren, terwijl een lagere temperatuurwaarde, zoals 0.1, meer vergelijkbare reacties zal produceren. Bijvoorbeeld:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

Laten we opnieuw temperatuur=0.1 proberen om de nieuw gegenereerde tekst te zien:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

De tekst bleek hetzelfde te zijn. Laten we nu twee keer temperatuur=0.8 proberen:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)
cat, apple, guitar, sky, book
response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)

Output
1. Apple
2. Sunshine
3. Happiness
4. Love
5. Technology

2. Max tokens: Hiermee kun je de lengte van de gegenereerde tekst beperken. Door een specifieke waarde in te stellen, wordt ervoor gezorgd dat de reactie niet meer dan een bepaald aantal tokens overschrijdt. Tokens zijn evenredig met het aantal woorden in de reactie. Bijvoorbeeld:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=10)
print(response.choices[0].message.content)

Output
1. Apple
2. Car

Het veranderen van de waarde naar 20:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=20)
print(response.choices[0].message.content)

Output
1. Apple
2. Car
3. Music
4. Ocean
5. Love

3. Stream: Dit bepaalt of de antwoorden moeten worden gestreamd of teruggegeven. Wanneer ingesteld op True, zal de API-respons worden gestreamd, wat betekent dat je de uitvoer in brokken ontvangt terwijl deze wordt gegenereerd. Dit is handig voor lange gesprekken of real-time toepassingen. Om streaming in te schakelen, voeg je de stream-parameter toe met een waarde van True aan de API-oproep. Bijvoorbeeld:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], stream=True)
collected_messages = []
for chunk in response:
...   chunk_message = chunk.choices[0].delta.content
...   if chunk_message is not None:
...     collected_messages.append(chunk_message)
print(collected_messages)

Output
['', 'cat', '\n', 'book', '\n', 'computer', '\n', 'sun', '\n', 'water']

In de code hierboven houdt de variabele chunk_message de berichtinhoud vast in elk stukje dat door de API wordt geretourneerd. Voordat we elk stuk aan de lijst collected_messages toevoegen, controleren we of het stuk None is, aangezien de inhoud van het laatste stuk meestal None is.

Het gebruik van deze parameters stelt u in staat om het gedrag van het model aan te passen en de gegenereerde reacties beter aan te sturen voor uw toepassing of project. Experimenteer met verschillende waarden om de gewenste resultaten te bereiken.

In de volgende stap zullen we wat context aan het model geven in de vorm van een systeemprent.

Stap 3 – Het maken van een systeemprent

In deze stap zullen we alle informatie die we hebben geleerd combineren en een systeemprent maken die context biedt aan het GPT-model, waarbij we het doel ervan specificeren en de regels vaststellen.

Eerst maken we een Python-module met daarin een functie om deze taak te verwerken. Sluit de interpreter af en maak een nieuw bestand genaamd story_generator.py in uw Django-projectdirectory.

(env)sammy@ubuntu:$ touch ~/my_blog_app/blog/blogsite/story_generator.py

Vervolgens kunt u de OpenAI API-sleutel toevoegen aan uw omgevingsvariabelen zodat u deze niet rechtstreeks aan het Python-bestand toevoegt:

(env)sammy@ubuntu:$ export OPENAI_KEY="your-api-key"

Open story_generator.py en maak daarbinnen een openai-client aan en definieer een functie genaamd generate_story die een verzameling woorden als invoer neemt:

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_story(words):
    # Roep de OpenAI API aan om het verhaal te genereren
    response = get_short_story(words)
    # Formatteer en retourneer de respons
    return format_response(response)

In deze functie roepen we een afzonderlijke functie aan, get_short_story, om de API-aanroep naar OpenAI voor het verhaal te maken en vervolgens nog een andere functie, format_response,, om de respons van de API te formatteren.

Latenn we ons nu richten op de functie get_short_story. Voeg het volgende onderaan je story_generator.py-bestand toe:

def get_short_story(words):
    # Construeer de systeemprompt
    system_prompt = f"""You are a short story generator.
    Write a short story using the following words: {words}.
    Do not go beyond one paragraph."""
    # Doe de API-aanroep
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{
            "role": "user",
            "content": system_prompt
        }],
        temperature=0.8,
        max_tokens=1000
    )

    # Retourneer de API-respons
    return response

In deze functie stellen we eerst de systeemprompt in, die het model informeert over de taak die het moet uitvoeren en specificeren hoe lang het verhaal moet zijn. Vervolgens geven we deze systeemprompt door aan de ChatCompletion API en retourneren we de respons.

Tenslotte kunnen we de functie format_response implementeren. Voeg het volgende onderaan je story_generator.py-bestand toe:

def format_response(response):
    # Haal het gegenereerde verhaal uit de respons
    story = response.choices[0].message.content
    # Verwijder eventuele ongewenste tekst of opmaak
    story = story.strip()
    # Retourneer het geformatteerde verhaal
    return story

U kunt deze functies nu testen door de functie generate_story aan te roepen, waarbij u een verzameling woorden als argument doorgeeft, en de reactie ervan te printen. Voeg het volgende toe onderaan uw bestand story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

Sla het bestand nu op en sluit het af. Voer het script uit om de gegenereerde tekst te zien:

(env) sammy@ubuntu:$ python ~/my_blog_app/blog/blogsite/story_generator.py

Uitvoer:

In a cozy corner of a sunlit room, a fluffy cat named Whiskers lounged lazily next to a towering bookshelf. Amongst the rows of books, a curious computer hummed softly. As the sun streamed through the window, casting a warm glow, Whiskers noticed a small water stain on the shelf. Intrigued, the cat pawed at the book closest to the mark. As if guided by fate, the book opened to reveal a hidden compartment containing a glittering diamond necklace. With the secret now unveiled, Whiskers embarked on an unexpected adventure, where the sun, water, and the power of knowledge merged into a thrilling tale of mystery and discovery.

Best interessant! Laten we de regel met het print-statement verwijderen, aangezien we de functie generate_story vanuit een Django-weergave zullen aanroepen. Verwijder de gemarkeerde regel uit uw bestand story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

Voel u vrij om te experimenteren met de systeemprompt en meer context en regels toe te voegen om de gegenereerde verhalen te verbeteren.

Ga verder naar de volgende stap om de module story_generator te integreren in uw Django-project.

Stap 4 – Integratie met een backend-weergave:

U moet een Django-weergave en URL-route maken om de module story_generator te integreren in uw Django-project. In de weergave haalt u de verwachte woorden uit het verzoek, roept u de functie generate_story aan en retourneert u de reactie.

Open eerst het bestand views.py in uw Django-app-map. Importeer de benodigde modules en voeg een weergavefunctie genaamd generate_story_from_words toe:

from django.http import JsonResponse
from .story_generator import generate_story

def generate_story_from_words(request):
    words = request.GET.get('words') # Haal de verwachte woorden uit het verzoek
    story = generate_story(words) # Roep de generate_story functie aan met de geëxtraheerde woorden
    return JsonResponse({'story': story}) # Geef het verhaal terug als een JSON-reactie

Vervolgens, open het urls.py bestand en voeg een URL-patroon toe voor de generate_story_from_words weergave:

urlpatterns = [
    # Andere URL-patronen...
    path('generate-story/', views.generate_story_from_words, name='generate-story'),
]

Nu kunt u het /generate-story/ eindpunt aanvragen. Bijvoorbeeld, om te testen met behulp van curl, kunt u een GET-verzoek maken naar het eindpunt met de verwachte woorden als queryparameter. Open uw terminal en voer de volgende opdracht uit:

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words=cat,book,computer,sun,water"

Zorg ervoor dat u "http://uw_domein" vervangt door het daadwerkelijke domein waar uw Django-project wordt gehost. De woorden "kat,boek,computer,zon,water" vertegenwoordigen de verwachte woorden waarmee u een verhaal wilt genereren. U kunt ze naar wens wijzigen.

Na het uitvoeren van de opdracht, zou u de reactie van de server moeten zien, die het gegenereerde verhaal zal bevatten:

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words="cat,book,computer,sun,water"

Uitvoer:

{"story": "Once upon a time, in a cozy little cottage nestled amidst a dense forest, a curious cat named Whiskers sat by the window, basking in the warm rays of the sun. As Whiskers lazily flicked his tail, his eyes caught sight of a dusty book lying on a nearby shelf. Intrigued, he carefully jumped onto the shelf, causing a cascade of books to tumble down, one opening up to reveal a hidden compartment. Inside, Whiskers discovered an ancient computer, its screen flickering to life as he brushed against the power button. Mesmerized by the glowing screen, Whiskers ventured into a world of virtual landscapes, where he roamed freely, chasing digital fish and pausing to admire breathtaking waterfalls. Lost in this newfound adventure, Whiskers discovered the wonders of both the tangible and virtual worlds, realizing that true exploration knows no bounds."}

Conclusie

Na het voltooien van deze tutorial, heb je geleerd hoe je OpenAI GPT-modellen kunt integreren in je Django-project met behulp van de OpenAI API. Je hebt oproepen gedaan naar de ChatCompletion API, het gedrag van het model aangepast door te werken met parameters zoals temperatuur en max tokens, en een systeemprompt gemaakt om context aan het model te geven. Je hebt ook de story_generator-module geïntegreerd in je Django-project. Nu kun je korte verhalen genereren door de /generate-story/-eindpunt aan te roepen met de verwachte woorden als queryparameter.

Om je Django-project verder te verbeteren, kun je de aanvullende functionaliteiten van de OpenAI API verkennen en experimenteren met verschillende systeemprompts en parameters om unieke en creatieve verhalen te genereren.