Come Integrare i Modelli OpenAI GPT nel Tuo Progetto Django

L’autore ha selezionato il Programma Direct Relief per ricevere una donazione come parte del programma Scrivere per le Donazioni.

Introduzione

I modelli OpenAI GPT hanno guadagnato popolarità grazie al loro ampio utilizzo nella generazione di contenuti testuali per vari compiti come la stesura di email, la risposta alle FAQ del servizio clienti e la traduzione linguistica, per citarne alcuni.

Questi modelli GPT sono generalmente utilizzati tramite ChatGPT, un chatbot rilasciato da OpenAI, o tramite API e librerie che forniscono un maggiore controllo. Questo tutorial ti guiderà nell’utilizzo di 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 una breve storia utilizzando le parole fornite e restituisce la sua risposta.

PrerequisitiPer completare questo tutorial, avrai bisogno di:

Per completare questo tutorial, avrai bisogno:

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

2. Un account OpenAI: Vai al sito web della piattaforma OpenAI e cerca il pulsante ‘Registrati’. Dopo esserti registrato, devi verificare la tua email e inserire informazioni personali.

3. Una chiave API OpenAI: Una volta configurato l’account, accedi e naviga nella sezione API Keys dal tuo dashboard. Fai clic su ‘Crea nuova chiave segreta’. La tua chiave API verrà generata e avrà un aspetto simile a sk-abcdefghijklmnop. Assicurati di salvarla in un luogo sicuro, poiché non sarai in grado di vederla di nuovo.

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

sammy@ubuntu:$ .env/bin/activate

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

(env)sammy@ubuntu:$ pip install openai

Passo 1 — Effettuare chiamate a OpenAI

In questo passaggio, aggiungerai la tua chiave API di OpenAI al client di OpenAI e effettuerai una semplice chiamata API all’API di ChatCompletion. Esaminerai anche la risposta che ricevi dall’API.

Per iniziare, apri il tuo interprete Python:

(env)sammy@ubuntu:$ python

Prima di tutto, importa il client di 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 di 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 utente (le altre opzioni sono sistema e assistente) 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 bel piccolo elenco:

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

Output:

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

Congratulazioni! Hai effettuato con successo una semplice chiamata API a OpenAI e hai recuperato una risposta. Formatteremo e utilizzeremo la risposta dell’API per creare una breve storia nei prossimi passaggi.

Passaggio 2 — Lavorare con i parametri

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

1. Temperatura: Il parametro temperatura determina quanto casuale sia 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. Ad 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)

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

Proviamo nuovamente temperatura=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)

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

Il testo è risultato essere lo stesso. Ora, proviamo temperatura=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)

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

2. Massimo token: Questo ti consente di limitare la lunghezza del testo generato. Impostando un valore specifico si assicura che la risposta non superi un certo numero di token. I token sono proporzionali al numero di parole nella risposta. Ad 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)

Output
1. Apple
2. Car

Cambiando il valore a 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: Questo determina se le risposte devono essere trasmesse in streaming o restituite. Quando impostato su True, la risposta dell’API verrà trasmessa in streaming, il che significa che riceverai l’output a pezzi man mano che viene generato. Questo è utile per conversazioni lunghe o applicazioni in tempo reale. Per abilitare lo streaming, aggiungi il parametro stream con un valore di True alla chiamata API. Ad 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)

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

Nel codice sopra, la variabile chunk_message contiene il contenuto del messaggio in ciascun frammento restituito dall’API. Prima di aggiungerlo alla lista collected_messages, verifichiamo se il frammento è None poiché il contenuto del frammento finale è di solito None.

Utilizzando questi parametri è possibile personalizzare il comportamento del modello e controllare le risposte generate per adattarle meglio alla propria applicazione o progetto. Sperimentare con valori diversi per ottenere i risultati desiderati.

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

Passo 3 — Creazione di un prompt di sistema

In questo passaggio, combineremo tutte le informazioni apprese e creeremo un prompt di sistema che fornisce contesto al modello GPT, comunicandogli il suo scopo e specificando le sue regole.

Prima, creiamo un modulo Python contenente una funzione per gestire questo compito. Chiudere l’interprete e creare un nuovo file chiamato story_generator.py nella directory del progetto Django.

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

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

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

Aprire story_generator.py e al suo interno creare un client openai e definire una funzione chiamata generate_story che accetta una raccolta di parole in input:

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_story(words):
    # Chiama l'API di OpenAI per generare la storia
    response = get_short_story(words)
    # Formatta e restituisci la risposta
    return format_response(response)

In questa funzione, chiamiamo una funzione separata, get_short_story, per effettuare la chiamata all’API di OpenAI per la storia e poi un’altra funzione, format_response,, per formattare la risposta dall’API.

Ora, concentriamoci sulla funzione get_short_story. Aggiungi quanto segue in fondo al tuo file story_generator.py:

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

    # Restituisci la risposta dell'API
    return response

In questa funzione, impostiamo innanzitutto il prompt di sistema, che informa il modello del compito che deve svolgere e specifica quanto lunga dovrebbe essere 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 in fondo al tuo file story_generator.py:

def format_response(response):
    # Estrai la storia generata dalla risposta
    story = response.choices[0].message.content
    # Rimuovi eventuali testi indesiderati o formattazioni
    story = story.strip()
    # Restituisci la storia formattata
    return story

È possibile testare queste funzioni chiamando la funzione generate_story, passando una collezione di parole come suo 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

Output:

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.

Piuttosto 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 di sistema e aggiungere più contesto e regole per migliorare le storie generate.

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

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

Per prima cosa, apri il file views.py nella directory della tua app Django. Importa i moduli necessari e aggiungi una funzione di vista 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') # Estrarre le parole attese dalla richiesta
    story = generate_story(words) # Chiamare la funzione generate_story con le parole estratte
    return JsonResponse({'story': story}) # Restituire la storia come una risposta JSON

Successivamente, aprire il file urls.py e aggiungere un modello di URL per la vista generate_story_from_words:

urlpatterns = [
    # Altri modelli di URL...
    path('generate-story/', views.generate_story_from_words, name='generate-story'),
]

Ora è possibile richiedere il punto di accesso /generate-story/. Ad esempio, per testare usando curl, è possibile effettuare una richiesta GET al punto di accesso con le parole attese come parametro di query. Aprire il terminale e eseguire il seguente comando:

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

Assicurarsi di sostituire "http://il_tuo_dominio" con il dominio effettivo dove è ospitato il tuo progetto Django. Le parole "gatto,libro,computer,sole,acqua" rappresentano le parole attese con cui si desidera generare una storia. È possibile cambiarle con qualsiasi parole si preferisca.

Dopo aver eseguito il comando, si dovrebbe 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"

Output:

{"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 OpenAI GPT 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 max token, 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 brevi storie richiedendo il punto di accesso /generate-story/ con le parole attese come parametro di query.

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