Llama 3.2 90B Tutorial: app per didascalie di immagini con Groq & Streamlit

Meta ha finalmente aggiunto la multimodalità all’ecosistema Llama introducendo i modelli di visione Llama 3.2 11B & 90B. Questi due modelli eccellono nell’elaborazione sia di testo che di immagini, il che mi ha spinto a provare a realizzare un progetto usando la versione da 90B.

In questo articolo condivido il mio lavoro e ti guido nella creazione di un’app interattiva per generare didascalie di immagini usando Streamlit per il front end e Llama 3.2 90B come motore per la generazione delle didascalie.

Perché usare Llama 3.2 90B per un’app di didascalie di immagini

Llama 3.2-Vision 90B è un modello multimodale all’avanguardia progettato per task che coinvolgono input sia di immagini che di testo.

Si distingue per la capacità di affrontare compiti complessi come ragionamento visivo, riconoscimento di immagini e generazione di didascalie. È stato addestrato su un enorme dataset di 6 miliardi di coppie immagine-testo.

Llama 3.2-Vision è un’ottima scelta per la nostra app perché supporta più lingue per i task testuali, anche se l’inglese è il suo focus principale per le applicazioni legate alle immagini. Le sue caratteristiche chiave lo rendono eccellente per attività come Visual Question Answering (VQA), Document VQA e recupero immagine-testo, con la generazione di didascalie tra le sue applicazioni di punta.

Vediamo come queste capacità si traducono in un’applicazione reale come la generazione di didascalie.

Pipeline per la generazione di didascalie

La generazione di didascalie di immagini è il processo automatico di creare un testo descrittivo che riassuma il contenuto di un’immagine. Combina computer vision e elaborazione del linguaggio naturale per interpretare ed esprimere dettagli visivi in linguaggio.

Tradizionalmente, la generazione di didascalie ha richiesto una pipeline complessa, spesso con fasi separate per l’elaborazione dell’immagine e la generazione del linguaggio. L’approccio standard prevede tre passaggi principali: pre-elaborazione dell’immagine, estrazione di feature e generazione della didascalia.

1. Pre-elaborazione dell’immagine: le immagini vengono in genere ridimensionate, normalizzate e talvolta ritagliate per rispettare le specifiche di input del modello.
2. Estrazione di feature: si estraggono caratteristiche visive per identificare oggetti, scene o dettagli rilevanti nell’immagine. Nella maggior parte dei modelli, ciò richiede un modello di visione separato per interpretare l’immagine, producendo dati strutturati comprensibili ai modelli linguistici.
3. Generazione della didascalia: le feature estratte vengono poi usate da un modello linguistico per elaborare una descrizione coerente, combinando oggetti, contesto e relazioni identificate nei dati visivi.

Con Llama 3.2 90B, questo processo tradizionalmente complesso diventa più semplice. L’adapter di visione del modello integra le caratteristiche visive nel modello linguistico principale, consentendogli di interpretare direttamente le immagini e generare didascalie tramite semplici prompt.

Inserendo strati di cross-attention nella sua architettura, Llama 3.2 90B permette di descrivere un’immagine semplicemente promptando il modello, eliminando la necessità di fasi di elaborazione separate. Questa semplicità rende la generazione di didascalie più accessibile ed efficiente, dove un singolo prompt può produrre una didascalia naturale e descrittiva che cattura efficacemente l’essenza di un’immagine.

Panoramica dell’app per le didascalie

Per dare vita alla potenza di Llama 3.2 90B, costruiremo una semplice ma efficace applicazione per generare didascalie di immagini usando Streamlit per il front end e Groq per la generazione delle didascalie.

L’app permetterà agli utenti di caricare un’immagine e ricevere una didascalia descrittiva generata dal modello con appena due clic. Questa configurazione è intuitiva e richiede conoscenze minime di codice per iniziare.

La nostra applicazione includerà le seguenti funzionalità:

1. Titolo: un titolo ben visibile, Llama Captioner, per chiarire lo scopo dell’app.
2. Pulsante di upload: un’interfaccia per caricare immagini dal dispositivo dell’utente.
3. Pulsante di generazione: un pulsante per avviare il processo di generazione della didascalia.
4. Output della didascalia: l’app mostrerà la didascalia generata direttamente nell’interfaccia.

Implementazione del codice per la nostra app Llama 3.2 90B

L’API di Groq fungerà da ponte tra l’immagine caricata dall’utente e il modello Llama 3.2-Vision. Se vuoi seguire passo passo e codificare insieme a me, prima assicurati di:

1. Ottenere la tua chiave API Groq registrandoti alla Groq Console.
2. Salvare la tua chiave API in un file credentials.json per semplificarne l’accesso.
3. Seguire la guida rapida di Groq per installazione e configurazione.

Questo snippet Python qui sotto configura un’app Streamlit per interagire con l’API di Groq. Include:

1. Import delle librerie per lo sviluppo web (Streamlit), interazioni con l’IA (Groq), gestione delle immagini (base64) e operazioni su file (os, json).
2. Lettura della chiave API Groq da un file JSON separato per una maggiore sicurezza.
3. Definizione di una funzione per codificare le immagini in formato base64 per una trasmissione ed elaborazione efficienti.

import streamlit as stfrom groq import Groqimport base64import osimport json# Set up Groq API Keyos.environ['GROQ_API_KEY'] = json.load(open('credentials.json', 'r'))['groq_token']# Function to encode the imagedef encode_image(image_path):   with open(image_path, "rb") as image_file:       return base64.b64encode(image_file.read()).decode('utf-8')Offerto da

Proseguiamo scrivendo la funzione seguente, progettata per generare una descrizione testuale di un’immagine caricata tramite l’API di Groq. Ecco una panoramica delle sue funzionalità:

1. Codifica dell’immagine: l’immagine caricata viene convertita in una stringa codificata in base64. Questo formato consente di trasmettere facilmente i dati dell’immagine all’interno della richiesta API.
2. Interazione con l’API di Groq: viene istanziato un client Groq per facilitare la comunicazione con il servizio Groq. Si formula una richiesta di chat completion, composta da:

• Un prompt utente: "What's in this image?"
• I dati dell’immagine codificata in base64, incorporati in un data URI. Si specifica il modello llama-3.2-90b-vision-preview per elaborare l’immagine e generare una descrizione testuale.

3. Estrazione della didascalia: la didascalia generata viene estratta dalla risposta dell’API di Groq. Si restituisce il contenuto del messaggio della prima scelta, che contiene la didascalia.

# Function to generate captiondef generate_caption(uploaded_image):   base64_image = base64.b64encode(uploaded_image.read()).decode('utf-8')   client = Groq()   chat_completion = client.chat.completions.create(       messages=[           {               "role": "user",               "content": [                   {"type": "text", "text": "What's in this image?"},                   {                       "type": "image_url",                       "image_url": {                           "url": f"data:image/jpeg;base64,{base64_image}",                       },                   },               ],           }       ],       model="llama-3.2-90b-vision-preview",   )   return chat_completion.choices[0].message.contentOfferto da

Infine, generiamo la nostra web app interattiva con Streamlit:

# Streamlit Appst.title("Llama Captioner")uploaded_file = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])if uploaded_file is not None:   # Show the uploaded image   st.image(uploaded_file, caption="Uploaded Image", use_container_width=True)   if st.button("Generate Caption"):       with st.spinner("Generating caption..."):           caption = generate_caption(uploaded_file)       st.success("Caption Generated!")       st.write("**Caption:**", caption)Offerto da

La Streamlit app finale: Llama Captioner

Questa applicazione Streamlit offre un’interfaccia intuitiva per la generazione di didascalie. Ecco come funziona:

1. Titolo e caricamento file:

• L’app mostra un titolo: "Llama Captioner".
• Un componente per il caricamento consente di selezionare un file immagine (JPG, JPEG o PNG).

2. Visualizzazione dell’immagine:

• Dopo il caricamento, l’immagine viene mostrata con la funzione st.image.

3. Generazione della didascalia:

• Un pulsante, "Generate Caption", avvia il processo di generazione.
• Quando cliccato, un indicatore di caricamento mostra che la didascalia è in elaborazione.
• La funzione generate_caption viene chiamata per elaborare l’immagine caricata e ottenere una didascalia.
• Al termine, viene mostrato un messaggio di successo seguito dalla didascalia generata.

Lo snippet seguente mostra il codice in azione: è stata caricata un’immagine di Eddie Hall per generare la didascalia. Sorprendentemente ha estratto anche informazioni non chiaramente visibili come “Strongest Man” ecc.

Conclusione

Costruire un’app per didascalie di immagini con Llama 3.2 90B e Streamlit mostra come l’IA avanzata possa semplificare compiti complessi. Questo progetto combina un modello potente con un’interfaccia semplice per creare uno strumento intuitivo e facile da usare.

Come AI Engineer, vedo un enorme potenziale in strumenti come questi. Possono rendere la tecnologia più accessibile, aiutare le persone a interagire meglio con i contenuti e automatizzare i processi in modo più intelligente.

Per continuare ad approfondire Llama, ti consiglio le seguenti risorse:

• Come eseguire Llama 3.2 1B su uno smartphone Android con Torchchat
• Llama 3.2 e Gradio: tutorial per creare una web app multimodale
• Llama Stack: guida con esempi pratici
• Fine-tuning di Llama 3.2 e uso in locale: guida passo passo
• Llama 3.3: tutorial passo passo con progetto demo