Ricerca nel sito web

Come integrare i modelli GPT OpenAI nel tuo progetto Django


L'autore ha selezionato Direct Relief Program per ricevere una donazione come parte del programma Write for DOnations.

introduzione

I modelli OpenAI GPT hanno guadagnato popolarità grazie al loro ampio utilizzo nella generazione di contenuti di testo per varie attività come la redazione di e-mail, la risposta alle domande frequenti del servizio clienti e la traduzione linguistica, solo per citarne alcuni.

Questi modelli GPT vengono generalmente utilizzati tramite ChatGPT, un chatbot rilasciato da OpenAI, o tramite API e librerie che forniscono un maggiore controllo. Questo tutorial ti guiderà a sfruttare questi modelli utilizzando l'API OpenAI all'interno del tuo progetto web Django. Imparerai come chiamare l'API ChatCompletion utilizzando diversi parametri e come formattare e utilizzare le sue risposte.

Alla fine di questo tutorial, avrai creato un endpoint Django che, quando chiamato, invia una richiesta a OpenAI per costruire un racconto utilizzando le parole fornite e restituisce la sua risposta.

Prerequisiti

Per completare questo tutorial avrai bisogno di:

  1. Un progetto Django esistente. Se stai iniziando da zero, puoi impostare un progetto Django seguendo il tutorial su come impostare un ambiente di sviluppo Django.

  2. Un account OpenAI: vai al sito web della piattaforma OpenAI e cerca il pulsante "Iscriviti". Dopo la registrazione, devi verificare il tuo indirizzo email e inserire informazioni personali.

  3. Una chiave API OpenAI: una volta configurato il tuo account, accedi e vai alla sezione Chiavi API dalla dashboard. Fare clic su "Crea nuova chiave segreta". La tua chiave API verrà generata e avrà un aspetto simile a sk-abcdefghijklmnop. Assicurati di salvare questa chiave in un luogo sicuro, poiché non potrai più vederla.

  4. Il pacchetto OpenAI Python: se hai seguito il tutorial nel primo prerequisito, dovresti già avere un ambiente virtuale denominato env attivo all'interno di una directory denominata django-apps. Assicurati che il tuo ambiente virtuale sia attivo confermando che il suo nome appaia tra parentesi all'inizio del prompt del terminale. Se non è attivo, puoi attivarlo manualmente eseguendo il comando:

sammy@ubuntu:$ .env/bin/activate

Nel tuo terminale dalla directory django-apps. Una volta attivo l'ambiente, esegui quanto segue per installare il pacchetto OpenAI Python:

(env)sammy@ubuntu:$ pip install openai

Passaggio 1: effettuare chiamate a OpenAI

In questo passaggio aggiungerai la tua chiave API OpenAI al client OpenAI ed effettuerai una semplice chiamata API all'API ChatCompletion. Esaminerai anche la risposta che ottieni dall'API.

Per iniziare, apri il tuo interprete Python:

(env)sammy@ubuntu:$ python

Innanzitutto, importa il client OpenAI e aggiungi la tua chiave API al client:

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

Sostituisci "your-api-key" con la chiave API effettiva che hai ottenuto dalla piattaforma OpenAI.

Ora, effettuiamo una chiamata API all'API ChatCompletion. Utilizza il metodo chat.completions.create():

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

Nel codice sopra, abbiamo specificato il modello da utilizzare come gpt-3.5-turbo, aggiunto un singolo oggetto messaggio contenente il ruolo user (altre opzioni sono system e assist) e il contenuto/prompt conta da 1 a 10.

Per vedere la risposta dalla chiamata API, puoi stampare il messaggio di risposta, che dovrebbe contenere i numeri da 1 a 10 in un piccolo elenco carino:

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

Produzione :

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

Congratulazioni! Hai effettuato con successo una semplice chiamata API a OpenAI e recuperato una risposta. Formatteremo e utilizzeremo la risposta API per creare un breve racconto nei passaggi successivi.

Passaggio 2: lavorare con i parametri

Ora che hai effettuato con successo una semplice chiamata API all'API ChatCompletion, esploriamo come utilizzare i parametri per personalizzare il comportamento del modello. Sono disponibili diversi parametri che consentono di controllare la generazione del testo. Daremo un'occhiata ai tre seguenti.

1. Temperatura: il parametro della temperatura determina quanto è casuale il contenuto generato. Un valore di temperatura più alto, come 0,8, darà risposte più diverse e creative, mentre un valore di temperatura più basso, come 0,1, produrrà risposte più simili. Per esempio:

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)
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

Proviamo di nuovo temperature=0.1 per vedere il testo appena generato:

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)
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

Il testo si è rivelato lo stesso. Ora proviamo temperature=0.8 due volte:

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)
1. Apple
2. Sunshine
3. Happiness
4. Love
5. Technology

Token 2.Max: consente di limitare la lunghezza del testo generato. L'impostazione di un valore specifico garantisce che la risposta non superi un certo numero di token. I token sono proporzionali al numero di parole nella risposta. Per esempio:

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)
1. Apple
2. Car

Modifica del valore su 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)
1. Apple
2. Car
3. Music
4. Ocean
5. Love

3. Stream: determina se le risposte devono essere trasmesse in streaming o restituite. Se impostato su True, la risposta API verrà trasmessa in streaming, il che significa che riceverai l'output in blocchi man mano che viene generato. Ciò è utile per conversazioni lunghe o applicazioni in tempo reale. Per abilitare lo streaming, aggiungi il parametro stream con il valore True alla chiamata API. Per esempio:

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)
['', 'cat', '\n', 'book', '\n', 'computer', '\n', 'sun', '\n', 'water']

Nel codice sopra, la variabile chunk_message contiene il contenuto del messaggio in ogni blocco restituito dall'API. Prima di aggiungerli all'elenco collected_messages, controlliamo se il pezzo è None poiché il contenuto del pezzo finale è solitamente None.

L'utilizzo di questi parametri ti consente di personalizzare il comportamento del modello e controllare le risposte generate per adattarle meglio alla tua applicazione o progetto. Sperimentare valori diversi per ottenere i risultati desiderati.

Nel passaggio successivo forniremo un contesto al modello sotto forma di prompt di sistema.

Passaggio 3: creazione di un prompt di sistema

In questo passaggio, combineremo tutte le informazioni che abbiamo appreso e creeremo un prompt di sistema che fornisca il contesto al modello GPT, indicandone lo scopo e specificandone le regole.

Innanzitutto, creiamo un modulo Python contenente una funzione per gestire questa attività. Chiudi l'interprete e crea un nuovo file chiamato story_generator.py nella directory del tuo progetto Django.

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

Successivamente, puoi aggiungere la chiave API OpenAI alle variabili ambientali in modo da non aggiungerla direttamente al file Python:

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

Apri story_generator.py e al suo interno crea un client openai e definisci una funzione chiamata generate_story che accetta una raccolta di parole come input:

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_story(words):
    # Call the OpenAI API to generate the story
    response = get_short_story(words)
    # Format and return the response
    return format_response(response)

In questa funzione, chiamiamo una funzione separata, get_short_story per effettuare la chiamata API a OpenAI per la storia e quindi un'altra funzione, format_response, per formattare la risposta dall'API.

Ora concentriamoci sulla funzione get_short_story. Aggiungi quanto segue alla fine del tuo file story_generator.py:

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

    # Return the API response
    return response

In questa funzione, impostiamo innanzitutto il prompt di sistema, che informa il modello sull'attività che deve eseguire e specifica quanto dovrebbe essere lunga la storia. Passiamo quindi questo prompt di sistema all'API ChatCompletion e restituiamo la sua risposta.

Infine, possiamo implementare la funzione format_response. Aggiungi quanto segue alla fine del tuo file story_generator.py:

def format_response(response):
    # Extract the generated story from the response
    story = response.choices[0].message.content
    # Remove any unwanted text or formatting
    story = story.strip()
    # Return the formatted story
    return story

Ora puoi testare queste funzioni chiamando la funzione generate_story, passando una raccolta di parole come argomento e stampando la sua risposta. Aggiungi quanto segue alla fine del tuo file story_generator.py:

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

Ora salva ed esci dal file. Esegui lo script per vedere la storia generata:

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

Produzione :

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.

Molto interessante! Eliminiamo la riga con l'istruzione print poiché chiameremo la funzione generate_story da una vista Django. Rimuovi la riga evidenziata dal tuo file story_generator.py:

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

Sentiti libero di sperimentare con il prompt del sistema e aggiungere più contesto e regole per migliorare le storie generate.

Vai al passaggio successivo per integrare il modulo story_generator nel tuo progetto Django.

Passaggio 4: integrazione con una vista back-end:

Devi creare una vista Django e un percorso URL per integrare il modulo story_generator nel tuo progetto Django. Nella vista, estrarrai le parole previste dalla richiesta, chiamerai la funzione generate_story e restituirai la risposta.

Innanzitutto, apri il file views.py nella directory dell'app Django. Importa i moduli necessari e aggiungi una funzione di visualizzazione chiamata generate_story_from_words:

from django.http import JsonResponse
from .story_generator import generate_story

def generate_story_from_words(request):
    words = request.GET.get('words') # Extract the expected words from the request
    story = generate_story(words) # Call the generate_story function with the extracted words
    return JsonResponse({'story': story}) # Return the story as a JSON response

Successivamente, apri il file urls.py e aggiungi un pattern URL per la vista generate_story_from_words:

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

Ora puoi richiedere l'endpoint /generate-story/. Ad esempio, per testare l'utilizzo di curl, puoi effettuare una richiesta GET all'endpoint con le parole previste come parametro di query. Apri il tuo terminale ed esegui il seguente comando:

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

Assicurati di sostituire "http://tuo_dominio" con il dominio effettivo in cui è ospitato il tuo progetto Django. Le parole "gatto,libro,computer,sole,acqua" rappresentano le parole attese con cui vuoi generare una storia. Puoi cambiarli con qualsiasi parola tu preferisca.

Dopo aver eseguito il comando, dovresti vedere la risposta dal server, che conterrà la storia generata:

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

Produzione :

{"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."}

Conclusione

Dopo aver completato questo tutorial, hai imparato come integrare i modelli GPT OpenAI nel tuo progetto Django utilizzando l'API OpenAI. Hai effettuato chiamate all'API ChatCompletion, personalizzato il comportamento del modello lavorando con parametri come temperatura e token massimi e creato un prompt di sistema per fornire contesto al modello. Hai anche integrato il modulo story_generator nel tuo progetto Django. Ora puoi generare racconti richiedendo l'endpoint /generate-story/ con le parole previste come parametro di query.

Per migliorare ulteriormente il tuo progetto Django, puoi esplorare funzionalità aggiuntive dell'API OpenAI e sperimentare diversi prompt e parametri di sistema per generare storie uniche e creative.

Articoli correlati: