Elaborazione del linguaggio visivo guidata dal dialogo con Amazon SageMaker JumpStart

Esplorazione del linguaggio visivo attraverso il dialogo con Amazon SageMaker JumpStart

Elaborazione del linguaggio visivo (VLP) è all’avanguardia dell’AI generativa, guidando gli sviluppi nell’apprendimento multimodale che comprende l’intelligenza del linguaggio, la comprensione della visione e l’elaborazione. Combinati con grandi modelli linguistici (LLM) e il Pre-Training contrastivo linguaggio-immagine (CLIP) allenato con una grande quantità di dati di multimodalità, i modelli di linguaggio visivo (VLM) sono particolarmente abili in compiti come la sottotitolazione delle immagini, la rilevazione e la segmentazione degli oggetti e la risposta alle domande visive. I loro casi d’uso abbracciano vari settori, dall’intrattenimento multimediale alla diagnostica medica e al controllo della qualità nella produzione.

I punti di forza chiave del VLP includono l’utilizzo efficace di VLM e LLM pre-addestrati, consentendo previsioni a prova zero o a prova di poche senza richiedere modifiche specifiche del compito e la categorizzazione delle immagini di uno spettro ampio attraverso dialoghi casuali a più round. Potenziato da Grounded Segment Anything, il VLP mostra competenze nel riconoscimento visivo, con una particolare nota di rilievo alla rilevazione e alla segmentazione degli oggetti. Esiste il potenziale per un ulteriore messa a punto di VLM e LLM utilizzando dati specifici del dominio, al fine di aumentare la precisione e mitigare le allucinazioni. Tuttavia, come altre tecnologie emergenti, rimangono ostacoli nella gestione della complessità del modello, nell’armonizzazione delle diverse modalità e nella formulazione di metriche di valutazione uniformi.

Cortesia di NOMIC per OBELICS, HuggingFaceM4 per IDEFICS, Charles Bensimon per Gradio e Amazon Polly per TTS

In questo post, esploriamo le sfumature tecniche del prototipazione VLP utilizzando Amazon SageMaker JumpStart in combinazione con modelli AI generativi contemporanei. Attraverso dialoghi a più round, evidenziamo le capacità del processo del linguaggio visivo orientato alle istruzioni a prova zero e a prova di poche, enfatizzando la sua versatilità e cercando di catturare l’interesse della comunità multimodale più ampia. Il codice di implementazione demo è disponibile nel seguente repository GitHub.

Panoramica della soluzione

La soluzione proposta di VLP integra una serie di moduli di AI generativa all’avanguardia per ottenere output multimodali precisi. Al centro dell’architettura si trovano VLM e LLM sintonizzati, entrambi strumentali nella decodifica di flussi di dati visivi e testuali. Il framework TGI sottostà al livello di inferenza del modello, fornendo API RESTful per un’integrazione robusta e un accesso senza sforzo. Supplementando il nostro elaborazione dati auditivo, il Whisper ASR è anche dotato di un’API RESTful, consentendo conversioni di voce in testo senza soluzione di continuità. Affrontando sfide complesse come la segmentazione da immagine a testo, utilizziamo il modulo Grounded Segment Anything containerizzato, che si sinergizza con il meccanismo del Grounded DINO e del Segment Anything Model (SAM) per la rilevazione e la segmentazione degli oggetti guidate dal testo. Il sistema è ulteriormente raffinato con DistilBERT, ottimizzando il nostro processo di classificazione multi-classe guidato dal dialogo. Orchestrazione di queste componenti è la pipeline di elaborazione LangChain, un meccanismo sofisticato competente nel sezionare input di testo o voce, discernendo le intenzioni dell’utente e delegando metodicamente i sotto-task ai servizi pertinenti. La sintesi di queste operazioni produce output aggregati, fornendo risposte multimodali precise e consapevoli del contesto.

Il seguente diagramma illustra l’architettura della nostra soluzione VLP guidata dal dialogo.

Inferenza generazione di testo

Text Generation Inference (TGI) è un toolkit open-source sviluppato da Hugging Face per distribuire LLM e VLM per l’inferenza. Consente la generazione di testi ad alte prestazioni utilizzando parallelismo tensoriale, parallelismo del modello e batching dinamico, supportando alcuni dei principali LLM open-source come Falcon e Llama V2, così come VLM come IDEFICS. Utilizzando gli ultimi moduli Hugging Face LLM su Amazon SageMaker, i clienti di AWS possono ora sfruttare la potenza dei contenitori di deep learning SageMaker (DLC). Ciò consente la distribuzione senza soluzione di continuità di LLM dai centri Hugging Face tramite DLC pre-costruiti di SageMaker DLC che supportano TGI. Questa configurazione di inferenza non solo offre prestazioni eccezionali, ma elimina anche la necessità di gestire l’infrastruttura GPU di grandi dimensioni. Inoltre, si beneficia di funzionalità avanzate come il ridimensionamento automatico dei punti di ingresso di inferenza, la sicurezza migliorata e il monitoraggio del modello integrato.

TGI offre velocità di generazione del testo fino a 100 volte più veloci rispetto ai metodi di inferenza tradizionali e scala efficientemente per gestire un maggior numero di richieste. Il suo design assicura la compatibilità con vari LLM e, essendo open-source, rende accessibili le funzionalità avanzate alla comunità tecnologica. La versatilità di TGI si estende su diversi domini, migliorando chatbot, traduzioni automatiche, sintesi di testi e generazione di contenuti diversi, dalla poesia al codice. Pertanto, TGI si presenta come una soluzione completa per le sfide della generazione di testo. TGI è implementato in Python e utilizza il framework PyTorch. È open-source e disponibile su GitHub. Supporta inoltre PEFT con QLoRA per prestazioni più rapide e logits warping per controllare gli attributi del testo generato, come la sua lunghezza e diversità, senza modificare il modello sottostante.

Puoi creare un contenitore TGI Docker personalizzato direttamente dal seguente Dockerfile e quindi caricare l’immagine del contenitore nel Registro dei contenitori elastici (ECR) di Amazon per il rilascio delle inferenze. Ecco il codice:

%%sh# Definisci il nome dell'immagine docker e il nome Amazon Resource Name del contenitore su ECRcontainer_name="tgi1.03"region=`aws configure get region`account=`aws sts get-caller-identity --query "Account" --output text`full_name="${account}.dkr.ecr.${region}.amazonaws.com/${container_name}:latest"# Ottieni il comando di accesso da ECR ed eseguilo direttamenteaws ecr get-login-password --region ${region}|docker login --username AWS \    --password-stdin ${account}.dkr.ecr.${region}.amazonaws.com# Crea l'immagine Docker TGI in localedocker build . -f Dockerfile -t ${container_name}docker tag ${container_name} ${full_name}docker push ${full_name}

Inferenza LLM con TGI

La soluzione VLP in questo post utilizza LLM in combinazione con LangChain, sfruttando l’approccio chain-of-thought (CoT) per una classificazione delle intenzioni più accurata. CoT elabora le richieste per discernere l’intento e avviare sotto-task associati per raggiungere gli obiettivi della richiesta. Llama-2-7b-chat-hf (contratto di licenza) è la versione semplificata della linea Llama-2, progettata per contesti di dialogo. L’inferenza di Llama-2-7b-chat-hf è alimentata dall’immagine del contenitore TGI, rendendola disponibile come servizio abilitato API.

Per l’inferenza di Llama-2-7b-chat-hf, è consigliato l’utilizzo di una istanza g5.2xlarge (24G VRAM) per ottenere prestazioni ottimali. Per applicazioni che richiedono un LLM più robusto, i modelli Llama-v2-13b si adattano bene a un’istanza g5.12xlarge (96G VRAM). Per i modelli Llama-2-70b, considera sia la GPU [2xlarge] – 2x Nvidia A100 che utilizza la quantizzazione bitsandbytes, sia la g5.48xlarge. È importante notare che l’utilizzo della quantizzazione bitsandbytes può ridurre del 50% la VRAM GPU di inferenza richiesta.

Puoi utilizzare i DLC SageMaker con l’immagine del contenitore TGI descritta in precedenza per effettuare il rilascio delle inferenze di Llama-2-7b-chat-hf (vedi il codice seguente). In alternativa, puoi avviare un’infenza locale rapida per dimostrare il concetto in un’istanza g5.2xlarge utilizzando un contenitore Docker.

import jsonfrom time import gmtime, strftimefrom sagemaker.huggingface import get_huggingface_llm_image_urifrom sagemaker.huggingface import HuggingFaceModelfrom sagemaker import get_execution_role# Prerequisito: creare un nome univoco del modello.model_name = 'Llama-7b-chat-hf' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())# recupera l'URI dell'immagine llm di SageMaker pre-built DLC TGI v1.03  tgi_image_ecr_uri = get_huggingface_llm_image_uri(  "huggingface",  version="1.0.3")# Definisci i parametri di configurazione del modello e del punto di apoconfigurazione_modello = {  'HF_MODEL_ID': "meta-research/Llama-2-7b-chat-hf", # corrispondente a model_id su Hugging Face Hub  'SM_NUM_GPUS': json.dumps(numero_di_gpu),   'MAX_TOTAL_TOKENS': json.dumps(1024),   'HF_MODEL_QUANTIZE': "bitsandbytes", # Utilizza la quantizzazione per richiesta di VRAM inferiore, commentalo se non necessario.}# Crea HuggingFaceModel con l'URI dell'immagine TGI pre-built DLChf_modello_llm = HuggingFaceModel(  role=get_execution_role(),  image_uri=tgi_image_ecr_uri,  env=configurazione_modello)# Effettua il deploy del modellollm = hf_modello_llm.deploy(  initial_instance_count=1,  instance_type="ml.g5.2xlarge",  container_startup_health_check_timeout=300, # in sec. Consenti 5 minuti per caricare il modello)# Definisci il payload di inferenzaprompt="""<|prompter|>How to select a right LLM for your generative AI project?<|endoftext|><|assistant|>"""# Iperparametri per llmpayload = {  "inputs": prompt,  "parameters": {    "best_of": 1,    "decoder_input_details": true,    "details": true,    "do_sample": true,    "max_new_tokens": 20,    "repetition_penalty": 1.03,    "return_full_text": false,    "seed": null,    "stop": [      "photographer"    ],    "temperature": 0.5,    "top_k": 10,    "top_p": 0.95,    "truncate": null,    "typical_p": 0.95,    "watermark": true  },  "stream": false}# Invia la richiesta all'endpointresponse = llm.predict(payload)

Raffina e personalizza il tuo LLM

SageMaker JumpStart offre numerosi esempi di notebook che mostrano l’utilizzo del Parameter Efficient Fine Tuning (PEFT), incluso QLoRA per l’addestramento e il raffinamento dei LLM. QLoRA mantiene i pesi del modello pre-addestrato in uno stato statico e introduce matrici di decomposizione dei ranghi addestrabili in ogni livello della struttura del Transformer. Questo metodo riduce sostanzialmente il numero di parametri addestrabili necessari per le attività successive.

In alternativa, puoi esplorare l’ottimizzazione delle preferenze dirette (DPO), che evita la necessità di impostare un modello di ricompensa, estrarre campioni durante il raffinamento dei LLM o effettuare estese regolazioni degli iperparametri. Ricerche recenti hanno dimostrato che il raffinamento dei DPO supera l’RLHF nella gestione della generazione di sentimenti e migliora la qualità dei riassunti e delle risposte in singole conversazioni, il tutto risultando considerevolmente più facile da impostare ed educare. Il processo di addestramento dei DPO prevede tre passaggi principali (per ulteriori dettagli fare riferimento al repo su GitHub):

  1. Eseguire il raffinamento supervisionato di un LLM base pre-addestrato per creare un LLM raffinato.
  2. Eseguire il trainer DPO utilizzando il modello raffinato per creare un modello di apprendimento per rinforzo.
  3. Fondere gli adattatori dai DPO nel modello LLM base per l’elaborazione del testo durante l’inferenza.

Puoi distribuire il modello fuso per l’inferenza utilizzando l’immagine del contenitore TGI.

Modello linguaggio visuale

I modelli di linguaggio visuale (VLM), che combinano le modalità di visione e linguaggio, stanno dimostrando la loro efficacia migliorata nella generalizzazione, portando a vari casi d’uso pratici con prompt a zero o a pochi colpi con istruzioni. Un VLM è tipicamente composto da tre elementi chiave: un codificatore di immagini, un codificatore di testo e una strategia per fondere le informazioni provenienti dai due codificatori. Questi elementi chiave sono strettamente legati tra loro perché le funzioni di perdita sono progettate intorno sia all’architettura del modello che alla strategia di apprendimento. Molti VLM all’avanguardia utilizzano CLIP/ViT (come OpenCLIP) e LLM (come Llama-v1) e vengono addestrati su più set di dati pubblicamente disponibili come Wikipedia, LAION e Public Multimodal Dataset.

In questa demo è stato utilizzato un modello pre-addestrato IDEFICS-9b-instruct sviluppato da HuggingFaceM4, una versione raffinata di IDEFICS-9b, seguendo la procedura di addestramento descritta in Flamingo combinando i due modelli pre-addestrati (laion/CLIP-ViT-H-14-laion2B-s32B-b79K e huggyllama/llama-7b) con blocchi di Transformer modificati. L’IDEFICS-9b è stato addestrato su OBELIC, Wikipedia, LAION e PMD multimodal datasets con un totale di 150 miliardi di token e 1,582 miliardi di immagini con una risoluzione di 224×224 ciascuna. L’IDEFICS-9b si basava su Llama-7b con una dimensione di batch efficace di 1,31 milioni. L’IDEFICS-9b-instruct è stato quindi raffinato con 6,8 milioni di dataset di istruzioni multimodalità creati tramite l’uso di generative AI scongelando tutti i parametri (codificatore di visione, modello di linguaggio, cross-attenzioni). I dataset di raffinamento includono i dati di pre-addestramento con i seguenti rapporti di campionamento: 5,1% di coppie immagine-testo e 30,7% di documenti web multimodali OBELICS.

Il software di addestramento è basato su Hugging Face Transformers e Accelerate, e DeepSpeed ZeRO-3 per l’addestramento, oltre a WebDataset e Image2DataSets per il caricamento dei dati. Il pre-addestramento di IDEFICS-9b ha richiesto 350 ore per essere completato su 128 GPU Nvidia A100, mentre il raffinamento di IDEFICS-9b-instruct ha richiesto 70 ore su 128 GPU Nvidia A100, entrambi su istanze AWS p4.24xlarge.

Con SageMaker, puoi distribuire senza problemi IDEFICS-9b-instruct su un’istanza g5.2xlarge per compiti di inferenza. Il seguente frammento di codice illustra come avviare un contenitore locale di deep learning personalizzato integrato con l’immagine Docker personalizzata TGI:

%%shllm_model='HuggingFaceM4/idefics-9b-instruct'docker_rt_name='idefics-9b-instruct'docker_image_name='tgi1.03'docker run --gpus="1,2,3,4" --shm-size 20g -p 8080:80 --restart unless-stopped --name ${docker_rt_name} ${docker_image_name} --model-id ${llm_model}# Testa l'API LLM usando curlcurl -X 'POST' \  'http://<hostname_or_ip>:8080/' \      -H 'accept: application/json' \      -H 'Content-Type: application/json' \      -d '{          "inputs": "Utente:![](http://<image_url>/image.png)Quale dispositivo ha prodotto questa immagine? Per favore, spiega il principale scopo clinico di tale immagine? Puoi scrivere una relazione radiologica basata su questa immagine?<end_of_utterance>", \

        "parameters": {                "best_of": 1,    "decoder_input_details": true,   \            "details": true,    "do_sample": true,    "max_new_tokens": 20,  \            "repetition_penalty": 1.03,    "return_full_text": false,    \            "seed": null,    "stop": [      "fotografo"    ],    \            "temperature": 0.5,    "top_k": 10,    "top_p": 0.95,   \            "truncate": null,    "typical_p": 0.95,    "watermark": true  },  \        "stream": false \        }'

Puoi adattare IDEFICS o altri VLM, inclusi Open Flamingo con i tuoi dati specifici del dominio, con istruzioni. Fai riferimento al seguente README per la preparazione del dataset di multimodalità e allo script di fine-tuning per ulteriori dettagli.

Classificazione delle intenzioni con la catena del pensiero

Un’immagine vale più di mille parole, quindi VLM richiede una guida per generare una didascalia accurata da un’immagine e una domanda fornita. Possiamo usare il prompting few-shot per consentire l’apprendimento in contesto, in cui forniamo dimostrazioni nel prompt per orientare il modello verso una migliore prestazione. Le dimostrazioni servono come condizionamento per esempi successivi in cui vorremmo che il modello generi una risposta.

Il prompting few-shot standard funziona bene per molti compiti, ma non è ancora una tecnica perfetta, specialmente quando si tratta di compiti di ragionamento più complessi. Il modello di prompting few-shot non è sufficiente per ottenere risposte affidabili. Potrebbe essere utile se suddividiamo il problema in passaggi e dimostriamo ciò al modello. Più di recente, la catena del pensiero (CoT) di prompting è stata resa popolare per affrontare compiti di ragionamento aritmetico, di senso comune e simbolico più complessi

La CoT elimina gli sforzi manuali utilizzando LLM con un prompt “Pensiamo passo dopo passo” per generare catene di ragionamento per le dimostrazioni uno per uno. Tuttavia, questo processo automatico può ancora generare catene con errori. Per mitigare gli effetti degli errori, la diversità delle dimostrazioni è importante. Questo post propone Auto-CoT, che campiona domande con diversità e genera catene di ragionamento per costruire le dimostrazioni. La CoT è composta da due fasi principali:

  • Clustering delle domande: suddivide le domande di un determinato dataset in pochi cluster
  • campionamento delle dimostrazioni: seleziona una domanda rappresentativa da ogni cluster e genera la sua catena di ragionamento utilizzando CoT zero-shot con euristiche semplici

Vedi il seguente frammento di codice:

from langchain.llms import HuggingFaceTextGenInferencefrom langchain import PromptTemplate, LLMChaininference_server_url_local = <Your_local_url_for_llm_on_tgi:port>llm_local = HuggingFaceTextGenInference(    inference_server_url=inference_server_url_local,    max_new_tokens=512,    top_k=10,    top_p=0.95,    typical_p=0.95,    temperature=0.1,    repetition_penalty=1.05,     template = """Utilizza i seguenti contesti per rispondere alla domanda alla fine. Se non sai la risposta, semplicemente di che non lo sai, non cercare di inventare una risposta. Utilizza al massimo dieci-cinque e mantieni la risposta il più sottile possibile. Elencare tutte le sottoattività praticabili passo dopo passo nel dettaglio. Fai attenzione a evitare frasi che potrebbero ripetere domande precedenti. Ciò aiuterà a ottenere una risposta accurata e dettagliata. Evita le ripetizioni per una maggiore chiarezza.Domanda: {question}Risposta: Capire l'intento della domanda e quindi scomporre la {question} in sottoattività. """prompt = PromptTemplate(    template=template,     input_variables= ["question"])llm_chain_local = LLMChain(prompt=prompt, llm=llm_local)llm_chain_local("Puoi descrivere la natura di questa immagine? Pensi che sia reale??")

Riconoscimento Vocale Automatico

La soluzione VLP incorpora Whisper, un modello di riconoscimento vocale automatico (ASR) sviluppato da OpenAI, per gestire le query audio. Whisper può essere facilmente implementato tramite SageMaker JumpStart utilizzando il suo modello. SageMaker JumpStart, noto per la sua semplice configurazione, alte prestazioni, scalabilità e affidabilità, è ideale per gli sviluppatori che desiderano creare eccezionali applicazioni basate sulla voce. Il seguente repo su GitHub illustra come sfruttare gli endpoint di inferenza in tempo reale di SageMaker per perfezionare e ospitare Whisper per la trascrizione audio-testo istantanea, mostrando la sinergia tra l’hosting di SageMaker e i modelli generativi.

In alternativa, puoi scaricare direttamente il Dockerfile.gpu da GitHub sviluppato da ahmetoner, che include un’API REST preconfigurata. Puoi quindi costruire un’immagine Docker ed eseguire il container su un’istanza Elastic Compute Cloud (EC2) di Amazon alimentata da GPU per una rapida prova concettuale. Ecco il codice seguente:

%%sh
docker_iamge_name = 'whisper-asr-webservice-gpu'
docker build -f Dockerfile.gpu -t ${docker_iamge_nam}
docker run -d --gpus all -p 8083:9000 --restart unless-stopped -e ASR_MODEL=base ${docker_iamge_nam}
curl -X 'POST' \
  'http://<asr_api_hostname>:<port>/asr?task=transcribe&encode=true&output=txt' \
      -H 'accept: application/json' \
      -H 'Content-Type: multipart/form-data' \
      -F 'audio_file=@dgvlp_3_5.mp3;type=audio/mpeg'

Nell’esempio fornito, la porta 8083 viene selezionata per ospitare l’API Whisper, con regole di sicurezza di rete in ingresso attivate. Per testare, indirizza un browser web a http://<IP_o_hostname>:8083/docs e avvia una richiesta POST di test all’endpoint ASR. In alternativa, esegui il comando fornito o utilizza il modulo whisper-live per verificare la connettività dell’API.

!pip install whisper-live
from whisper_live.client import TranscriptionClient
client = TranscriptionClient("<whisper_hostname_o_IP>", 8083, is_multilingual=True, lang="zh", translate=True)
client(audio_file_path) # Usa un file audio
client() # Usa il microfono per la trascrizione

Classificazione di testo multi-classe ed estrazione di parole chiave

La classificazione multi-classe svolge un ruolo fondamentale nella rilevazione e segmentazione degli oggetti guidata da prompt di testo. Il modello distilbert-base-uncased-finetuned-sst-2-english è un checkpoint raffinato di DistilBERT-base-uncased, ottimizzato sul dataset Stanford Sentiment Treebank (SST2) da Hugging Face. Questo modello raggiunge un’accuratezza del 91,3% sul set di sviluppo, mentre il suo corrispettivo bert-base-uncased vanta un’accuratezza del 92,7%. Il portale Hugging Face fornisce accesso a oltre 1000 modelli pre-addestrati di classificazione del testo. Per coloro che cercano una precisione migliorata, SageMaker JumpStart fornisce modelli per ottimizzare DistilBERT utilizzando dataset annotati personalizzati per compiti di classificazione più specifici.

import torch
from transformers import pipeline

def mclass(text_prompt, top_k=3, topics=['Creazione di maschere', 'Rilevamento oggetti',
 'Inpainting', 'Segmentazione', 'Upscaling', 'Creazione di un'immagine da un'altra', 'Generazione di un'immagine da un testo'],
 'distilbert-base-uncased-finetuned-sst-2-english'):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')    # Definisci un modello di ipotesi tedesca e i candidati potenziali per implicazione/contraddizione
    template_de = 'L'argomento è {}'
    # Astrazione pipeline da Hugging Face
    pipe = pipeline(task='zero-shot-classification', model=model, tokenizer=model, device=device)
    # Esegui pipeline con un caso di test
    prediction = pipe(text_prompt, topics, hypothesis_template=template_de)
    # I primi 3 argomenti previsti in un regime zero-shot
    return zip(prediction['labels'][0:top_k], prediction['scores'][0:top_k])

top_3_intend = mclass(text_prompt=user_prompt_str, topics=['Altro', 'Creazione maschera immagine', 'Segmentazione immagine'], top_k=3) 

Il processo di estrazione delle parole chiave utilizza il modulo KeyBERT, un metodo efficiente e semplice da utilizzare che sfrutta i BERT embeddings per generare parole chiave e frasi chiave strettamente allineate ad un documento – in questo caso, gli oggetti specificati nella query:

# Estrazione delle parole chiave
from keybert import KeyBERT
kw_model = KeyBERT()
words_list = kw_model.extract_keywords(docs=<user_prompt_str>, keyphrase_ngram_range=(1,3))

Rilevamento e classificazione degli oggetti guidato da testo

La soluzione VLP utilizza il rilevamento e la segmentazione degli oggetti guidati dal dialogo analizzando il significato semantico del testo e identificando l’azione e gli oggetti dal prompt di testo. Grounded-SAM è un pacchetto open-source creato da IDEA-Research per rilevare e segmentare qualsiasi cosa da un’immagine data con input di testo. Combina i punti di forza di Grounding DINO e Segment Anything per creare una pipeline molto potente per risolvere problemi complessi.

La figura seguente illustra come Grounded-SAM può rilevare gli oggetti e condurre la segmentazione delle istanze comprendendo l’input testuale.

SAM si distingue come un modello di segmentazione robusto, anche se richiede prompt come bounding box o punti per produrre maschere ad alta qualità degli oggetti. Grounding DINO eccelle come rilevatore zero-shot, creando abilmente box e label ad alta qualità utilizzando prompt di testo liberi. Quando questi due modelli vengono combinati, offrono la notevole capacità di rilevare e segmentare qualsiasi oggetto esclusivamente attraverso input di testo. Lo script di utilità Python dino_sam_inpainting.py è stato sviluppato per integrare i metodi di Grounded-SAM:

!pip install git+https://github.com/facebookresearch/segment-anything.git
import dino_sam_inpainting as D
def dino_sam(image_path, text_prompt, text_threshold=0.4, box_threshold=0.5, output_dir='/temp/gradio/outputs'):
    config_file = 'GroundingDINO/groundingdino/config/GroundingDINO_SwinT_OGC.py'  # cambia percorso del file di configurazione del modello
    grounded_checkpoint = './models/groundingdino_swint_ogc.pth'  # cambia percorso del modello
    sam_checkpoint = './models/sam_vit_h_4b8939.pth'
    sam_hq_checkpoint = '' # se usi versione ad alta qualità, come sam_hq_vit_h.pth
    use_sam_hq = ''
    output_dir = '/tmp/gradio/outputs'
    device = 'cuda'    # crea cartella
    os.makedirs(output_dir, exist_ok=True)
    # carica immagine
    image_pil, image = D.load_image(image_path)
    # carica modello
    model = D.load_model(config_file, grounded_checkpoint, device=device)
    output_file_name = f'{format(os.path.basename(image_path))}'
    # visualizza immagine grezza
    image_pil.save(os.path.join(output_dir, output_file_name))
    # esegui modello grounding dino
    boxes_filt, pred_phrases = D.get_grounding_output(
        model, image, text_prompt, box_threshold, text_threshold, device=device
    )
    # inizializza SAM
    if use_sam_hq:
        predictor = D.SamPredictor(D.build_sam_hq(checkpoint=sam_hq_checkpoint).to(device))
    else:
        predictor = D.SamPredictor(D.build_sam(checkpoint=sam_checkpoint).to(device))
    image = cv2.imread(image_path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    predictor.set_image(image)
    size = image_pil.size
    H, W = size[1], size[0]
    for i in range(boxes_filt.size(0)):
        boxes_filt[i] = boxes_filt[i] * torch.Tensor([W, H, W, H])
        boxes_filt[i][:2] -= boxes_filt[i][2:] / 2
        boxes_filt[i][2:] += boxes_filt[i][:2]
    boxes_filt = boxes_filt.cpu()
    transformed_boxes = predictor.transform.apply_boxes_torch(boxes_filt, image.shape[:2]).to(device)
    masks, _, _ = predictor.predict_torch(
        point_coords = None,
        point_labels = None,
        boxes = transformed_boxes.to(device),
        multimask_output = False,
    )
    # disegna immagine di output
    plt.figure(figsize=(10, 10))
    plt.imshow(image)
    for mask in masks:
        D.show_mask(mask.cpu().numpy(), plt.gca(), random_color=True)
    for box, label in zip(boxes_filt, pred_phrases):
        D.show_box(box.numpy(), plt.gca(), label)
    output_file_name = f'{format(os.path.basename(image_path))}'
    plt.axis('off')
    plt.savefig(
        os.path.join(output_dir, f'grounded_sam_{output_file_name}'),
        bbox_inches="tight", dpi=300, pad_inches=0.0
    )
    D.save_mask_data(output_dir, masks, boxes_filt, pred_phrases)
    return f'grounded_sam_{output_file_name}'

    filename = dino_sam(image_path=<image_path_str>, text_prompt=<object_name_str>, output_dir=<output_image_filename_path_str>, box_threshold=0.5, text_threshold=0.55)

Puoi scegliere HQ-SAM per aggiornare SAM per una segmentazione senza shot di alta qualità. Consulta il seguente articolo e l’esempio di codice su GitHub per ulteriori dettagli.

Pipeline di elaborazione VLP

L’obiettivo principale della pipeline di elaborazione VLP è combinare i punti di forza di diversi modelli, creando un flusso di lavoro sofisticato specializzato per VLP. È importante sottolineare che questa configurazione privilegia l’integrazione di modelli di alta qualità nelle aree di visualizzazione, testo e voce. Ogni segmento della pipeline è modulare, facilitando l’uso indipendente o l’operazione combinata. Inoltre, il design assicura flessibilità, consentendo la sostituzione dei componenti con modelli più avanzati ancora da venire, supportando allo stesso tempo il multithreading e la gestione degli errori con un’implementazione affidabile.

La seguente figura illustra il flusso dati e i componenti di servizio di una pipeline VLP.

Nella nostra esplorazione della pipeline VLP, ne abbiamo progettata una che può elaborare sia prompt di testo da un formato di testo aperto che input vocali casuali dai microfoni. L’elaborazione audio è facilitata da Whisper, in grado di riconoscimento vocale e traduzione multilingue. Il testo trascritto viene quindi inviato a un modulo di classificazione degli intenti, che distingue l’essenza semantica dei prompt. Questo lavora in tandem con un motore CoT guidato da LangChain, che analizza l’intento principale in sotto-task più dettagliati per il recupero e la generazione di informazioni più dettagliate. Se l’elaborazione delle immagini è dedotta dall’input, la pipeline avvia un processo di estrazione delle parole chiave, selezionando le prime N parole chiave mediante incrocio dei dati sugli oggetti rilevati nell’immagine originale. Successivamente, queste parole chiave vengono inviate al motore Grounded-SAM, che genera bounding box. Queste bounding box vengono quindi fornite al modello SAM, che crea maschere di segmentazione precise, individuando ogni istanza di oggetto unica nell’immagine di origine. L’ultimo passo prevede l’applicazione delle maschere e delle bounding box sull’immagine originale, ottenendo un’immagine elaborata che viene presentata come output multimodale.

Quando la query in ingresso cerca di interpretare un’immagine, la pipeline coinvolge il LLM nell’organizzazione dei sotto-task e nel perfezionamento della query con obiettivi mirati. Successivamente, il risultato viene indirizzato all’API VLM, accompagnato da istruzioni a pochi passi, l’URL dell’immagine di input e il prompt di testo riformulato. In risposta, il VLM fornisce l’output testuale. La pipeline VLP può essere implementata utilizzando una pipeline di flusso di lavoro basata su Python o utilità di orchestrazione alternative. Tali pipeline operano concatenando un insieme sequenziale di modelli sofisticati, culminando in una procedura di modellazione strutturata in sequenza. La pipeline si integra con il motore Gradio per scopi dimostrativi:

def vlp_text_pipeline(str input_text, str original_image_path, chat_history):   intent_class = intent_classification(input_text)   key_words = keyword_extraction(input_text)   image_caption = vlm(input_text, original_image_path)   chat_history.append(image_caption)   if intent_class in {intenti supportati}:        object_bounding_box = object_detection(intent_class, key_words, original_image_path)        mask_image_path = image_segmentation(object_bounding_box, key_words, original_image_path)        chat_history.append(mask_image_path)   return chat_history    def vlp_voice_pipeline(str audio_file_path, str original_image_path, chat_history):   asr_text = whisper_transcrib(audio_file_path)   chat_history.append(asr_text, original_image_path, chat_history)   return chat_history    chat_history = map(vlp_pipelines, input_text, original_image_path, chat_history) \               if (audio_file_path is None) \               else map(vlp_voice_pipelines, original_image_path, chat_history)

Limitazioni

L’utilizzo di modelli VLM pre-allenati per VLP ha dimostrato un potenziale promettente per la comprensione delle immagini. Insieme alla rilevazione e segmentazione degli oggetti basati sul linguaggio, VLP può produrre output utili con una qualità ragionevole. Tuttavia, VLP soffre ancora di risultati non coerenti, perdita di dettagli da immagini e potrebbe addirittura creare allucinazioni. Inoltre, i modelli potrebbero produrre testi non corretti dal punto di vista fattuale e non dovrebbero essere affidati per produrre informazioni fattualmente accurate. Poiché nessuno dei modelli di riferimento VLM, SAM o LLM pre-allenati è stato addestrato o ottimizzato per applicazioni specifiche di produzione in un determinato settore, questa soluzione non è progettata per applicazioni critiche che potrebbero influire sul sostentamento o causare perdite finanziarie

Con un’ingegneria tempestiva, il modello IDEFICS a volte può riconoscere ulteriori dettagli dopo un suggerimento di testo; tuttavia, il risultato è lontano dall’essere coerente e affidabile. Può essere persistente nel mantenere inesattezze e potrebbe essere incapace o riluttante a correggere anche quando gli utenti evidenziano queste durante una conversazione. Potenziando il modello di base integrando Swin-ViT e fondonolo con modelli basati su CNN come DualToken-ViT, insieme alla formazione utilizzando modelli più avanzati come Llama-v2, potrebbe affrontare alcune di queste limitazioni potenzialmente.

Passaggi successivi

La soluzione VLP è pronta per un notevole progresso. Guardando avanti, ci sono diverse opportunità chiave per avanzare nelle soluzioni VLP:

  • Dare priorità all’integrazione di istruzioni dinamiche prompt e suggerimenti di apprendimento nelle sessioni di poche iterazioni. Questi miglioramenti consentiranno un feedback AI più accurato.
  • Le squadre di classificazione delle intenzioni dovrebbero concentrare gli sforzi nel perfezionare il classificatore per cogliere sfumature di intenzioni specifiche del dominio da prompt aperti. La capacità di comprendere le intenzioni precise degli utenti sarà fondamentale.
  • Implementare un modello a albero di pensieri per il ragionamento. Questa struttura permetterà di completare passaggi di ragionamento espliciti per svolgere sottotask.
  • Pilotare iniziative di fine-tuning su modelli leader. Adattare i modelli VLM, LLM e SAM a settori chiave e casi d’uso attraverso il fine-tuning sarà decisivo.

Riconoscimenti

Gli autori estendono la loro gratitudine a Vivek Madan e Ashish Rawat per il loro prezioso feedback e revisione di questo post.