ChatGPT e Python - Crea il Tuo Assistente Personale

Pubblicato il 04 Marzo 2023 da Michele Saba

Intelligenza artificiale, OpenAI, Large Language Models, ChatGPT: in questi mesi non si parla praticamente di nient'altro. Comprensibilmente.

In molti ci avete richiesto di parlarne, ed ora che OpenAI ha aperto l'API di ChatGPT al pubblico, il momento è finalmente arrivato.

Vedremo come utilizzare Python per connetterci all'API di OpenAI e utilizzare lo stesso modello che anima ChatGPT, chiamato gpt-3.5-turbo, integrandolo così all'interno delle nostre applicazioni per sfruttarne tutte le sue potenzialità.

Per poter integrare ChatGPT e altri modelli di OpenAI all’interno di un progetto Python via API dobbiamo anzitutto generare una chiave di accesso (secret key) all’interno del portale platform di OpenAI, selezionando la voce del menù API Keys.

Una volta ottenuta la chiave d'accesso possiamo iniziare con la scrittura del codice.

Di cosa avrete bisogno?

Per poter applicare al meglio quanto mostrato in questo tutorial dovreste conoscere almeno le basi di Python.

Come prima cosa, creiamo un nuovo ambiente virtuale tramite venv e installiamo il package openai tramite pip

pip install openai

Nella cartella del nostro progetto creiamo un nuovo script e un file .json chiamato secrets. Useremo il file json per salvare la nostra chiave di accesso

{
    "api_key": "la-vostra-secret-key"
}

Ricordiamoci di aggiungere il file secrets.json a .gitignore nel caso stessimo utilizzando un VCS come git.

Come Integrare ChatGPT in Python

Creiamo un file python ed importiamo i moduli json e openai. Assicuratevi di non chiamare il file su cui scriverete codice "openai.py" perché questo causerebbe dei conflitti con la libreria omonima appena importata! Noi chiameremo il nostro file semplicemente assistant.py

import json

import openai

Importiamo la nostra secret key per autenticarci leggendola dal file json tramite il modulo apposito.

with open("secrets.json") as f:
    secrets = json.load(f)
    api_key = secrets("api_key")

Per poterci autenticare ed essere quindi in grado di comunicare con il backend di OpenAI, assegniamo la nostra chiave ad openai.api_key

openai.api_key = api_key

Per poter dialogare con il modello AI possiamo ora utilizzare openai.ChatCompletion.create().

Definiamo una variabile response alla quale passare il response ottenuto dal backend di OpenAI. Passiamo a create 3 parametri: model, messages e temperature

response = openai.ChatCompletion.create(
    model = "gpt-3.5-turbo",
    messages = [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Who won the world series in 2020?"},
        {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
        {"role": "user", "content": "Where was it played?"}
    ]
    temperature = 1.0
)

I parametri model, messages e temperature

OpenAI dispone di vari modelli di Intelligenza Artificiale utilizzabili tramite API.

Per questo motivo al primo parametro model passiamo il codename del modello che intendiamo utilizzare, ovvero del "sistema" vero e proprio con cui stiamo interagendo a livello testuale. Daremo una definizione di modello linguistico più avanti nella lezione.

Con temperature possiamo controllare il “livello di confidenza” del modello quando effettua queste previsioni. Un valore di temperatura basso determina previsioni più deterministiche e accurate, mentre l'aumento della temperatura si tradurrà in risposte più diversificate. Il valore di default per la temperature è 1.0 e accetta valori in range 0.0 - 2.0.

Infine, messages è lista di dizionari, dove ciascuno ha un ruolo (”sistema”, “utente” o “assistente”) e un contenuto. I messaggi con role system aiutano ad impostare il comportamento dell'assistente impostando il contesto iniziale, i messaggi user impartiscono le istruzioni all'assistente e possono essere generati dagli utenti, mentre i messaggi assistant rappresentano le risposte precedenti inviate da ChatGPT.

Per un elenco completo dei parametri potete dare uno sguardo alla pagina dedicata della documentazione sul sito ufficiale.

Come usare questo codice su più moduli?

Lo scopo di questo articolo è permettervi di integrare questo modello linguistico nei vostri progetti, e per fare ciò è necessario che il codice sia utilizzabile su più moduli. Possiamo quindi usare una funzione, da importare quando necessario.

La funzione accetterà come parametro una lista chiamata messages, che potremo quindi passare alla funzione create(). La notazione messages: list utilizza la nomenclature dei type hint di Python, ovvero il controllo del tipo passato alla variabile non è validato in runtime ma può essere da strumenti di sviluppo come IDEs, linters, type checkers ecc.

Notate il valore restituito da get_response(): response.choices[0].message. Di tutto l'output restituito dal backend di OpenAI ci interessa solamente il messaggio restituito, così che possa essere aggiunto alla lista messages ed inviato assieme a tutti gli altri messaggi precedentemente scambiati nelle richieste successive.

def get_response(messages:list):
    response = openai.ChatCompletion.create(
        model = "gpt-3.5-turbo",
        messages=messages,
        temperature = 1.0 # 0.0 - 2.0
    )
    return response.choices[0].message

Il nostro assistente personale

Per creare il modello in modalità assistente personale è ora sufficiente creare un ciclo while infinito in cui richiedere input all'utente, fare richieste al backend per una risposta e mostrare tutto in output.

Utilizziamo if __name__ == "__main__" , per fare in modo di eseguire questo codice ogni qualvolta il file dove stiamo eseguendo questo codice (nel nostro caso assistant.py) venga eseguito come script, ad esempio lanciandolo da un terminale di sistema come mostrato nel video.

Definiamo inoltre messages e definiamo in questa un primo messaggio con role: system

import json
import openai

with open("secrets.json") as f:
    secrets = json.load(f)
    api_key = secrets["api_key"]

openai.api_key = api_key

def get_response(messages:list):
    response = openai.ChatCompletion.create(
        model = "gpt-3.5-turbo",
        messages=messages,
        temperature = 1.0 # 0.0 - 2.0
    )
    return response.choices[0].message


if __name__ == "__main__":
    messages = [
        {"role": "system", "content": "Sei un assistente virtuale chiamata JOI e parli italiano."}
    ]
    try:
        while True:
            user_input = input("\nTu: ")
            messages.append({"role": "user", "content": user_input})
            new_message = get_response(messages=messages)
            print(f"\nJOI: {new_message['content']}")
            messages.append(new_message)
    except KeyboardInterrupt:
        print("A presto!")

Repository GitHub

Preferite visionare il codice da un repository git, in modo magari da farci un fork? Potete trovarlo qui sul mio profilo GitHub con licenza MIT.