In questo articolo vi spiegherò come creare una chatbot per conversare con Llama3 attraverso Ollama.
Potete utilizzare la chatbot, sia per conversare con Llama3, sia per imparare l'inglese, perché Llama3 oltre a rispondere in italiano, aggiunge anche la traduzione in lingua inglese.
Per creare la chatbot, servono gli strumenti seguenti: Visual Studio Code, Python e Ollama, quindi, assicuratevi che siano stati installati correttamente sul vostro computer, con i comandi seguenti:

Llama 3 è un modello linguistico di grandi dimensioni (LLM) sviluppato da Meta AI, progettato per comprendere e generare testo in linguaggio naturale.
E' disponibile in tre versioni con differenti quantità di parametri: 8 miliardi (8B), 70 miliardi (70B) e 400 miliardi (400B). Le versioni 8B e 70B sono open-source e accessibili al pubblico, mentre la versione 400B è attualmente in fase di addestramento.

L'immagine seguente mostra come potete visualizzare le caratteristiche della versione di Llama3 installata sul vostro computer:

Llama 3 è stato addestrato utilizzando dati online di alta qualità fino a dicembre 2023, impiegando tecniche di filtraggio avanzate per garantire l'eccellenza dei dati di addestramento. Le sue applicazioni spaziano dalla generazione di contenuti alla traduzione multilingue, fino all'intelligenza artificiale conversazionale.

In termini di prestazioni, Llama 3 ha ottenuto punteggi elevati in vari benchmark, superando modelli come GPT-3.5 in alcune metriche.

Per eseguire Llama3 su un computer locale serve Ollama.

Ollama è un framework leggero ed estensibile che consente di eseguire modelli di linguaggio di grandi dimensioni (LLM) localmente, fornendo un'API per creare applicazioni che comunicano con il modello associato. Per comunicare con Llama3 attraverso l'API di Ollama, installato sul vostro computer, dovete usare il protocollo applicativo HTTP e collegarvi alla porta 11434, come mostra il link seguente:

http://localhost:11434/api/generate.

Per creare il Chatbot con Python servono le librerie: tkinter, requests e json, che potete caricare con il codice seguente:

import tkinter as tk 
from tkinter import scrolledtext 
import requests 
import json 

La libreria tkinter è utilizzata nel programma per creare l'interfaccia grafica (GUI) del Chatbot.

La libreria requests è utilizzata per gestire la comunicazione HTTP con l'API di Ollama, che esegue il modello Llama3.

La libreria json nel programma serve per due motivi principali:

1.Decodifica delle risposte: Quando ricevi una risposta dal server Ollama, i dati arrivano come stringhe in formato JSON. La funzione json.loads() è utilizzata per convertire queste stringhe in oggetti Python (come dizionari), rendendo possibile accedere ai dati tramite chiavi;

2.Serializzazione dei dati da inviare: Quando invii la richiesta POST a Ollama, il payload viene passato come oggetto Python (di tipo dizionario). Il parametro json=payload nella richiesta fa sì che Python usi automaticamente la libreria json per convertire l'oggetto in una stringa JSON da inviare.

IMPOSTAZIONE DELLA GUI DEL CHATBOT

1. Creazione della Finestra Principale
root = tk.Tk()
root.title("Llama3 Chatbot")
root.configure(bg='white')

tk.Tk(): Crea la finestra principale dell'applicazione.
root.title("Llama3 Chatbot"): Imposta il titolo della finestra.
root.configure(bg='white'): Imposta lo sfondo della finestra di colore bianco.

2. Area di Visualizzazione della Chat
chat_log = scrolledtext.ScrolledText(root, wrap=tk.WORD, width=60, height=20, bg='white', fg='black', bd=0, relief='flat')
chat_log.pack(padx=10, pady=10)

scrolledtext.ScrolledText: Crea una casella di testo con una barra di scorrimento automatica.
wrap=tk.WORD: Le parole non vengono spezzate a metà quando il testo raggiunge il bordo.
width e height: Definiscono la dimensione del campo di testo.
bg='white' e fg='black': Impostano i colori di sfondo e del testo.
bd=0 e relief='flat': Rendono il bordo della casella piatto e senza spessore.
pack(padx=10, pady=10): Posiziona il widget nella finestra con un margine di 10 pixel.

3. Contenitore per l'Input dell'Utente
user_input_frame = tk.Frame(root, bg='white')
user_input_frame.pack(padx=10, pady=(0, 10))

tk.Frame: Crea un contenitore per raggruppare i widget di input e il pulsante di invio.
bg='white': Imposta il colore di sfondo del frame.
pack(padx=10, pady=(0, 10)): Posiziona il frame con un margine superiore di 0 e inferiore di 10 pixel.

4. Campo di Inserimento Testo
user_input = tk.Entry(user_input_frame, width=50, bg='white', fg='black', bd=1, relief='solid', highlightthickness=1, highlightbackground='#d9d9d9', highlightcolor='#4a90e2')
user_input.pack(side=tk.LEFT, padx=(0, 5), ipady=5, ipadx=5)

tk.Entry: Crea un campo per l'inserimento di testo da parte dell'utente.
width=50: Imposta la larghezza del campo di testo.
bd=1 e relief='solid': Definiscono un bordo sottile e solido.
highlightthickness, highlightbackground, highlightcolor: Configurano l'aspetto del bordo di evidenziazione.
pack(side=tk.LEFT, padx=(0, 5), ipady=5, ipadx=5): Posiziona il campo a sinistra del frame con un po' di padding.

5. Pulsante di Invio
send_button = tk.Button(user_input_frame, text="Invia", command=send_message, bg='black', fg='white', activebackground='#333333', activeforeground='white', bd=0, padx=10, pady=5, relief='flat')
send_button.pack(side=tk.RIGHT)

tk.Button: Crea un pulsante etichettato "Invia".
command=send_message: Associa il pulsante alla funzione send_message che verrà eseguita al click (nota: questa funzione non è definita nel codice fornito).
bg e fg: Definiscono i colori di sfondo e del testo del pulsante.
activebackground e activeforeground: Colori quando il pulsante è attivo.
bd=0 e relief='flat': Rendono il bordo del pulsante piatto e senza spessore.
pack(side=tk.RIGHT): Posiziona il pulsante a destra del frame.

Per avviare l'interfaccia viene utilizzata la funzione main():

def main():
    root.mainloop()

L'immagine seguente mostra coma appare la GUi del Chatbot in esecuzione:

COME INVIARE LE RICHIESTE AL SERVER OLLAMA

1. Dichiarazione della Funzione e Variabili Globali
La funzione send_message gestisce l'invio di un messaggio dell'utente alla chatbot e visualizza la risposta generata da Llama3 tramite Ollama.

def send_message():
    global chat_history, chat_context

global chat_history, chat_context: Indica che le variabili chat_history e chat_context sono globali.
chat_history: Conserva l'intera cronologia della chat.
chat_context: Potrebbe essere utilizzata per mantenere il contesto tra le richieste (utile per i modelli di AI che gestiscono conversazioni complesse).

2. Lettura del Messaggio dell'Utente
user_message = user_input.get()
if user_message.strip() == "":
    return

user_input.get(): Recupera il testo inserito dall'utente nel campo di input.
user_message.strip() == "": Controlla se il messaggio è vuoto o contiene solo spazi. Se sì, la funzione termina senza fare nulla (return).

3. Visualizzazione del Messaggio dell'Utente nella Chat
chat_log.insert(tk.END, f"You: {user_message}\n")
user_input.delete(0, tk.END)

chat_log.insert(tk.END, f"You: {user_message}\n"): Inserisce il messaggio dell'utente nella finestra di chat.
user_input.delete(0, tk.END): Pulisce il campo di input, pronto per un nuovo messaggio.

4. Aggiornamento della Cronologia della Chat
chat_history += f"You: {user_message}\n"

Aggiunge il messaggio dell'utente alla cronologia della chat, in modo che il modello abbia il contesto completo della conversazione.

5. Invio del Messaggio a Llama3 tramite Ollama
response, chat_context = get_llama3_response(chat_history, chat_context)

get_llama3_response(): Chiama una funzione (presumibilmente definita altrove) che:
Riceve la cronologia della chat e il contesto attuale.
Restituisce una risposta generata dal modello Llama3 e un nuovo contesto aggiornato.
response: La risposta generata da Llama3.
chat_context: Il contesto aggiornato che sarà utilizzato nelle conversazioni future.

6. Visualizzazione della Risposta del Modello
chat_log.insert(tk.END, f"Llama3: {response}\n")

Visualizza la risposta del modello nel registro della chat.

7. Aggiornamento Finale della Cronologia
chat_history += f"Llama3: {response}\n"

Aggiunge la risposta del modello alla cronologia per mantenere il contesto coerente nelle interazioni future.

COME GESTIRE LE RISPOSTE RICEVUTA DAL SERVER OLLAMA

La funzione get_llama3_response invia una richiesta POST all'API di Ollama per generare una risposta basata su un prompt e un contesto di conversazione. Gestisce anche lo streaming della risposta e aggiorna il contesto per le interazioni successive.

1. Argomenti della funzione
def get_llama3_response(prompt, context):

prompt: Il testo della conversazione, che include la cronologia dei messaggi.
context: Informazioni aggiuntive per mantenere la coerenza del dialogo (opzionale).

1. Preparazione del Payload
try:
    payload = {"prompt": prompt, "model": "llama3"}
    if context:
        payload["context"] = context

payload: Un dizionario contenente i dati da inviare all'API.
"prompt": Il testo della conversazione fino a quel momento.
"model": "llama3": Specifica il modello da utilizzare.
Se il context è disponibile, viene aggiunto per aiutare il modello a mantenere la coerenza della conversazione.

2. Invio della richiesta POST all'API
    response = requests.post(
        "http://localhost:11434/api/generate",
        json=payload,
        stream=True
    )

requests.post: Esegue una richiesta HTTP POST verso l'API locale di Ollama.
json=payload: Invia i dati della richiesta in formato JSON.
stream=True: Indica che la risposta verrà trasmessa in streaming, utile per ricevere i dati in tempo reale.

3. Gestione della Risposta
    full_response = ""
    final_context = None

full_response: Variabile per accumulare la risposta completa del modello.
final_context: Variabile per memorizzare il contesto aggiornato, se fornito.

4. Elaborazione della Risposta in Streaming
    for line in response.iter_lines():
        if line:
            data = json.loads(line.decode('utf-8'))
            full_response += data.get("response", "")
            if data.get("done") and "context" in data:
                final_context = data["context"]

response.iter_lines(): Itera sulle righe della risposta in streaming.
json.loads(): Converte ogni linea JSON in un dizionario Python.
data.get("response", ""): Estrae la parte di testo generata e la aggiunge a full_response.
data.get("done"): Verifica se la generazione della risposta è completata.
"context" in data: Se il contesto aggiornato è disponibile, lo salva in final_context.

5. Restituzione del Risultato
    return full_response or "Nessuna risposta ricevuta.", final_context

Restituisce la risposta completa.
Se la risposta è vuota, ritorna un messaggio di default: "Nessuna risposta ricevuta.".
Fornisce anche il final_context aggiornato.

6. Gestione degli Errori
except Exception as e:
    return f"Errore di connessione: {e}", context

Se si verifica un errore (come problemi di connessione o di decodifica), viene restituito un messaggio di errore insieme al contesto originale.

Per visualizzare il codice Python completo della chatbot clicca qui. 
Per eseguire il codice Python della chatbot, copialo e incollalo in Visual Studio Code.

L'immagine seguente mostra un esempio di conversazione con Llama3, utilizzando la nostra chatbot:

Nel prossimo articolo vedremo un semplice esempio di fine tuning per addestrare Llama3.

1.Intelligenza Artificiale: se la conosci non la temi
2.Intelligenza Artificiale: i modelli linguistici di grandi dimensioni
3.Intelligenza Artificiale: le reti neurali artificiali
4.Intelligenza Artificiale: tipi di reti neurali artificiali
5.Intelligenza Artificiale: IA Generativa
6.Intelligenza Artificiale: modelli pre-addestrati di IA locali