Ricerca nel sito web

Creare un assistente personale con LLaMA 3.2


Una delle applicazioni dell’intelligenza artificiale più immediatamente utilizzabili è il chatbot. Sebbene esistano in qualche modo da 30 anni, gli ultimi due hanno visto la vera ascesa di queste interfacce di chat per assistenti personali. Si sono diffusi dai circoli altamente tecnici a tutti i ceti sociali, alle situazioni sociali e ai casi d'uso aziendali.

Sebbene siano disponibili e facili da usare, molti dei migliori chatbot sono rinchiusi dietro giardini recintati di tecnologia closed source. Questi ambienti presentano vantaggi specifici, come la connettività per la ricerca su Internet, profili personalizzati per interagire con gli agenti e l'accesso ad alcuni dei migliori modelli linguistici di grandi dimensioni (LLM) disponibili. Tuttavia, la comunità open source è sempre stata al passo con questi sviluppi e gli strumenti open source presentano vantaggi specifici, ovvero personalizzazione, messa a punto e integrazioni complesse con altre tecnologie.

In questo articolo daremo uno sguardo a una delle più recenti e migliori suite di modelli open source: LLaMA 3.2. Questi modelli abilitati alla visione con parametri 11b vantano prestazioni paragonabili a GPT-4o mini e Claude 3 - Haiku in un'ampia varietà di benchmark ottimizzati per le istruzioni visive a costi significativamente inferiori. Inoltre, i loro modelli leggeri con parametri 2b offrono prestazioni paragonabili ai modelli SOTA edge come PHI mini it e Gemma 2b. Inizieremo questo tutorial con un'analisi di ciò che rende speciali questi modelli. Successivamente, mostreremo come prendere questo potente modello open source e creare un chatbot con assistente personale. Questo assistente personale può aiutarti con qualsiasi cosa, dalla scrittura alla codifica alla traduzione, ed è completamente abilitato a lavorare con i dati delle immagini con la stessa facilità del testo.

Seguici per approfondire i vantaggi dell'utilizzo di questi incredibili modelli su DigitalOcean GPU Droplet con la nostra guida all'esecuzione di una potente applicazione di assistenza, adattata dal progetto originale dello staff di HuggingFace Projects merve.

Prerequisiti

Per seguire questo articolo, avrai bisogno di esperienza con il codice Python e di una conoscenza principiante del Deep Learning. Opereremo partendo dal presupposto che tutti i lettori abbiano accesso a macchine sufficientemente potenti da poter eseguire il codice fornito.

Se non hai accesso a una GPU, ti suggeriamo di accedervi tramite il cloud. Esistono molti provider cloud che offrono GPU. I Droplet GPU DigitalOcean sono attualmente in disponibilità anticipata, scopri di più e iscriviti per interessarti ai Droplet GPU qui.

Per istruzioni su come iniziare con il codice Python, ti consigliamo di provare questa guida per principianti per configurare il tuo sistema e prepararti a eseguire tutorial per principianti.

La suite di modelli LLaMa 3.2

La suite del modello LLaMA 3.2 è composta da quattro modelli principali: un piccolo modello di linguaggio visivo 11B, un modello di linguaggio visivo più grande 90B e due modelli leggeri di solo testo (1B e 3B). I primi modelli sono in grado di visualizzare e comprendere sia dati di testo che di immagini, mentre i secondi si attengono al testo. Ognuno di questi offre prestazioni SOTA o quasi SOTA per le proprie classi.

Fonte

I creatori presumono che i loro modelli offrano prestazioni paragonabili ai noti modelli di base GPT-4o Mini e Claude 3 - Haiku. Possiamo vedere dal grafico sopra che queste affermazioni sono supportate da benchmarking su un'ampia varietà di attività di linguaggio visivo, comprese attività di matematica e di risoluzione dei problemi. Ciò è particolarmente interessante laddove il modello 11B sembra relativamente potente, in quanto mostra il potenziale per eseguire questi LLM con prestazioni di punta su GPU più deboli o addirittura hardware vicino all'edge. Ciò significa che possiamo aspettarci prestazioni competitive da questi modelli se utilizzati insieme a modelli closed source di alto livello.

Fonte

Nel grafico successivo, possiamo vedere il confronto riportato dei modelli leggeri, solo testo, con i principali concorrenti PHI Mini IT e Gemma 2b. In tutti i benchmark, i modelli leggeri hanno ottenuto risultati migliori o quasi uguali a quelli di questi noti modelli di base. Ciò dimostra che i modelli LLaMA 3.2 possono funzionare al massimo livello per l'esecuzione su processori più deboli, con la possibilità che anche i dispositivi portatili generino testo.

Come possiamo vedere, entrambe le categorie della suite di modelli sono altamente competitive con i modelli di fondazione SOTA dello stesso calibro e possono persino sovraperformare anche le alternative closed source.

Punti di forza e di debolezza di LLaMA 3.2

Quando si esaminano i punti di forza e di debolezza, la prima cosa fondamentale da capire su LLaMA 3.2 è che non include le stesse funzionalità di molti strumenti closed-source, ma può essere personalizzato in modi che i modelli closed-source non possono. Cose come i profili utente con informazioni salvate e impostazioni personalizzate, connettività Internet o ricerca e componenti aggiuntivi a basso codice per RAG o altre funzionalità non verranno integrati con LLaMA 3.2, a meno che non li facciamo noi stessi.

Detto questo, diamo un'occhiata a ciascuno dei principali punti di forza di LLaMA 3.2 rispetto ad altri modelli esistenti:

Punti di forza

  • Fine tuning e LoRA: la capacità di personalizzare il modello esistente sarà sempre il punto di forza più grande dei modelli closed source. Grazie a queste tecniche, è semplice prendere l'incredibile lavoro già svolto su questi LLM e specializzarli per il nostro compito. Che si tratti di creare un chatbot per i clienti o una macchina matematica, le possibilità qui sono abbastanza infinite.
  • Prestazioni SOTA: prestazioni paragonabili a modelli all'avanguardia di ogni dimensione, compresi potenti modelli closed-source
  • Integrazioni personalizzate: modelli come LLaMA 3.2 sono facili da integrare in un'ampia varietà di applicazioni esistenti senza la necessità di costruire o utilizzare un client API potenzialmente costoso o difficile da utilizzare.
  • Analisi del linguaggio visivo: dove LLaMA ci ha davvero impressionato è la comprensione dei dati delle immagini. È capace di qualsiasi cosa, dall'OCR all'interpretazione al rilevamento di oggetti, anche se ovviamente questi sono limitati all'output di testo.
  • Riepilogo e riscrittura: come mostrato nel blog di rilascio, i modelli sono altamente capaci in un'ampia varietà di attività di testo, ma vengono evidenziati soprattutto per quanto riguarda queste due attività.
  • Costo: LLaMA 3.2 è gratuito sia per l'uso (non commerciale) che per il download ed è uno dei modelli più efficienti nella sua categoria. I modelli leggeri possono funzionare su processori estremamente deboli come quelli presenti nei dispositivi portatili.

Punti deboli

  • Raggiungere le massime prestazioni: nonostante i grandi passi avanti, LLaMA 3.2 non è ancora del tutto al livello dei più grandi modelli GPT disponibili, come Claude Sonnet o GPT 4o.
  • Accessibilità a Internet: senza uno sviluppo significativo da parte dell'utente, i modelli non sono in grado di accedere a Internet o apprendere nuove informazioni senza qualcosa come RAG in atto per favorirle. Questo è un vantaggio fondamentale per molti degli attuali modelli di punta come quelli di Anthropic.
  • Licenza: a differenza di alcuni modelli completamente open source, vale la pena notare ancora una volta che il modello di LLaMA consente solo un uso non commerciale.

Ora che abbiamo esaminato gli aspetti positivi del modello, mostriamo come eseguire la demo. Ciò ci consentirà di esaminare il modello in modo approfondito mentre creiamo il nostro strumento di assistente personale.

Avvio della demo LLaMA 3.2 su un Droplet GPU DigitalOcean

Per questa demo prenderemo in prestito il lavoro del team di HuggingFace Projects. Hanno pubblicato una demo Gradio davvero perfetta sul loro sito Web che utilizza i modelli Vision LLaMA 3.2 11B. Prima di continuare, assicurati di andare a vedere il loro lavoro originale qui.

Per adattare l'applicazione, utilizzeremo le appena rilasciate DigitalOcean GPU Droplets. Per proseguire, ti consigliamo di utilizzare questa guida per creare una nuova droplet GPU con un notebook Jupyter. Eseguiremo il codice mostrato in questa sezione all'interno di un Jupyter Notebook in esecuzione sul nostro Droplet GPU, a cui si accede nel nostro browser locale tramite hosting SSH con Visual Studio Code.

Una volta che il tuo computer è in esecuzione, hai avviato il Notebook e hai effettuato l'accesso nel browser locale, continua con la sezione successiva.

Analisi dell'applicazione dell'assistente personale LLaMA 3.2

L'applicazione LLaMA 3.2 di HuggingFace, di per sé, è eccellente. Ti consente di chattare con un potente chatbot, in grado di interagire con qualsiasi immagine che carichiamo. Questo da solo ci consente di eseguire azioni complicate come il riconoscimento del contenuto di un oggetto o il rilevamento di oggetti o persino la lettura. Inoltre, grazie alla scrittura con Gradio, è anche completamente abilitato per FastAPI ed è possibile interagire direttamente con l'applicazione utilizzando l'endpoint API che crea.

Dai un'occhiata al blocco di codice seguente, che contiene l'intera applicazione, con alcune piccole modifiche per misure di risparmio di spazio.

from transformers import MllamaForConditionalGeneration, AutoProcessor, TextIteratorStreamer
from PIL import Image
import requests
import torch
from threading import Thread
import gradio as gr
from gradio import FileData
import time
import spaces
ckpt = "meta-llama/Llama-3.2-11B-Vision-Instruct"
model = MllamaForConditionalGeneration.from_pretrained(ckpt,
    torch_dtype=torch.bfloat16).to("cuda")
processor = AutoProcessor.from_pretrained(ckpt)


@spaces.GPU
def bot_streaming(message, history, max_new_tokens=250):
    
    txt = message["text"]
    ext_buffer = f"{txt}"
    
    messages= [] 
    images = []
    

    for i, msg in enumerate(history): 
        if isinstance(msg[0], tuple):
            messages.append({"role": "user", "content": [{"type": "text", "text": history[i+1][0]}, {"type": "image"}]})
            messages.append({"role": "assistant", "content": [{"type": "text", "text": history[i+1][1]}]})
            images.append(Image.open(msg[0][0]).convert("RGB"))
        elif isinstance(history[i-1], tuple) and isinstance(msg[0], str):
            # messages are already handled
            pass
        elif isinstance(history[i-1][0], str) and isinstance(msg[0], str): # text only turn
            messages.append({"role": "user", "content": [{"type": "text", "text": msg[0]}]})
            messages.append({"role": "assistant", "content": [{"type": "text", "text": msg[1]}]})

    # add current message
    if len(message["files"]) == 1:
        
        if isinstance(message["files"][0], str): # examples
            image = Image.open(message["files"][0]).convert("RGB")
        else: # regular input
            image = Image.open(message["files"][0]["path"]).convert("RGB")
        images.append(image)
        messages.append({"role": "user", "content": [{"type": "text", "text": txt}, {"type": "image"}]})
    else:
        messages.append({"role": "user", "content": [{"type": "text", "text": txt}]})


    texts = processor.apply_chat_template(messages, add_generation_prompt=True)

    if images == []:
        inputs = processor(text=texts, return_tensors="pt").to("cuda")
    else:
        inputs = processor(text=texts, images=images, return_tensors="pt").to("cuda")
    streamer = TextIteratorStreamer(processor, skip_special_tokens=True, skip_prompt=True)

    generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=max_new_tokens)
    generated_text = ""
    
    thread = Thread(target=model.generate, kwargs=generation_kwargs)
    thread.start()
    buffer = ""
    
    for new_text in streamer:
        buffer += new_text
        generated_text_without_prompt = buffer
        time.sleep(0.01)
        yield buffer


demo = gr.ChatInterface(fn=bot_streaming, title="Multimodal Llama", 
      textbox=gr.MultimodalTextbox(), 
      additional_inputs = [gr.Slider(
              minimum=10,
              maximum=1024,
              value=250,
              step=10,
              label="Maximum number of new tokens to generate",
              
          )
        ],
      cache_examples=False,
      description="Try Multimodal Llama by Meta with transformers in this demo. Upload an image, and start chatting about it, or simply try one of the examples below. To learn more about Llama Vision, visit [our blog post](https://huggingface.co/blog/llama32). ",
      stop_btn="Stop Generation", 
      fill_height=True,
    multimodal=True)
    
demo.launch(debug=True)

In effetti, ciò che viene mostrato sopra è una pipeline incredibilmente concisa. Innanzitutto, lo script carica i file del modello sulla GPU. Successivamente, avvia l'applicazione Gradio che ci consente di interagire con il modello tramite il nostro browser web. Se seguiamo le istruzioni dell'articolo menzionato in precedenza, possiamo prendere l'URL che esce dall'esecuzione della cella, incollarlo nella semplice barra degli URL del browser in VS Code e aprire la nuova finestra Gradio nel nostro browser. In alternativa, puoi impostare il parametro demo.launch() public su True per aprire un collegamento accessibile pubblicamente.

Mettendo tutto insieme, quando eseguiamo otteniamo qualcosa del genere:

Questa applicazione interattiva ci consente di interagire con il modello utilizzando input di dati di testo o immagini. Nei nostri esperimenti, abbiamo riscontrato che questo processo è incredibilmente robusto per quanto riguarda la comprensione delle immagini, l'OCR e il riconoscimento degli oggetti. Abbiamo provato una varietà di diversi tipi di immagini e abbiamo ricevuto risultati estremamente affidabili che mostrano un profondo connubio di conoscenze tra il regno testuale e quello visivo per il modello.

Inoltre, l'applicazione da sola funziona abbastanza bene per le normali attività LLM. Siamo stati in grado di usarlo per generare codice Python funzionante, raccontare una trama e persino assistere nella scrittura di una breve parte di questo post sul blog! Tutto sommato, questa applicazione è incredibilmente versatile e continueremo a utilizzarla per le nostre attività LLM in futuro.

Pensieri conclusivi

LLaMA 3.2 è incredibile. In termini di versioni open source, rappresenta un passo tangibile verso la qualità dei popolari modelli closed source che hanno dominato il mercato nell'ultimo anno. È capace di tutto ciò che sono quasi alla stessa capacità, incluso qualsiasi cosa, dalla generazione di codice alla comprensione visiva alla lunga scrittura di storie. Incoraggiamo tutti i nostri lettori a provare la demo dei progetti HuggingFace su un Droplet GPU DigitalOcean.

Le possibilità per questi modelli sono davvero infinite. Dalle telecamere di sicurezza dinamiche alla gestione completa delle forniture fino a chatbot migliori, LLaMA sta già migliorando tutti i tipi di tecnologie che ci circondano. Una cosa che siamo interessati a vedere nel prossimo futuro è se LLaMA 3.2 potrebbe essere adattato come sostituto adeguato dei modelli T5 nella popolare modellazione testo-immagine, una tecnica sfruttata da team come PixArt nel loro ultimo modello per ottenere la qualità SOTA .

Assicurati di prestare attenzione a LLaMA 4 nel prossimo futuro, se anche le nostre aspettative sono corrette!

Articoli correlati: