Visuele taalverwerking (VLP) loopt voorop in generatieve AI en stimuleert de vooruitgang op het gebied van multimodaal leren, dat taalintelligentie, inzicht in visie en verwerking omvat. Gecombineerd met grote taalmodellen (LLM) en Contrastive Language-Image Pre-Training (CLIP), getraind met een grote hoeveelheid multimodale gegevens, zijn visuele taalmodellen (VLM's) bijzonder bedreven in taken zoals het ondertitelen van afbeeldingen, objectdetectie en -segmentatie, en visuele taalmodellen. vraag beantwoorden. Hun gebruiksscenario's bestrijken verschillende domeinen, van media-entertainment tot medische diagnostiek en kwaliteitsborging in de productie.

De belangrijkste sterke punten van VLP zijn onder meer het effectieve gebruik van vooraf getrainde VLM's en LLM's, waardoor nul- of weinig-shot-voorspellingen mogelijk zijn zonder dat taakspecifieke aanpassingen nodig zijn, en het categoriseren van beelden uit een breed spectrum via informele dialogen met meerdere rondes. aangevuld met Geaard segment Alles, VLP vertoont vaardigheid in visuele herkenning, waarbij vooral objectdetectie en segmentatie opvallen. Het potentieel bestaat om VLM's en LLM's verder te verfijnen met behulp van domeinspecifieke gegevens, met als doel de precisie te vergroten en hallucinaties te verminderen. Maar net als bij andere opkomende technologieën blijven er nog steeds obstakels bestaan ​​bij het beheersen van de complexiteit van modellen, het harmoniseren van diverse modaliteiten en het formuleren van uniforme evaluatiemaatstaven.

Met dank aan NOMIC voor OBELICS, HuggingFaceM4 voor IDEFICS, Charles Bensimon voor Gradio en Amazon Polly voor TTS

In dit bericht onderzoeken we de technische nuances van VLP-prototyping met behulp van Amazon SageMaker JumpStart in combinatie met hedendaagse generatieve AI-modellen. Door middel van multi-ronde dialogen benadrukken we de mogelijkheden van instructiegerichte zero-shot en weinig-shot taalverwerking, waarbij we de veelzijdigheid ervan benadrukken en ernaar streven de interesse van de bredere multimodale gemeenschap te wekken. De demo-implementatiecode is hieronder beschikbaar GitHub repo.

Overzicht oplossingen

De voorgestelde VLP-oplossing integreert een reeks ultramoderne generatieve AI-modules om nauwkeurige multimodale outputs te verkrijgen. Centraal in de architectuur staan ​​de verfijnde VLM en LLM, beide instrumenteel bij het decoderen van visuele en tekstuele datastromen. Het TGI-framework ondersteunt de modelinferentielaag en biedt RESTful API's voor robuuste integratie en moeiteloze toegankelijkheid. Als aanvulling op onze auditieve gegevensverwerking is de Whisper ASR ook uitgerust met een RESTful API, waardoor gestroomlijnde spraak-naar-tekst-conversies mogelijk zijn. Om complexe uitdagingen zoals beeld-naar-tekst-segmentatie aan te pakken, gebruiken we de containerized Geaard segment Alles module, synergetisch met de Geaarde DINO en Segmenteer alles-model (SAM) mechanisme voor tekstgestuurde objectdetectie en segmentatie. Het systeem is verder verfijnd met DestillerenBERT, waardoor ons dialooggestuurde classificatieproces met meerdere klassen wordt geoptimaliseerd. Deze componenten worden georkestreerd door de LangChain-verwerkingspijplijn, een geavanceerd mechanisme dat bedreven is in het ontleden van tekst- of spraakinvoer, het onderscheiden van gebruikersintenties en het methodisch delegeren van subtaken aan de relevante services. De synthese van deze operaties levert geaggregeerde resultaten op en levert nauwkeurige en contextbewuste multimodale antwoorden op.

Het volgende diagram illustreert de architectuur van onze dialooggestuurde VLP-oplossing.

Inferentie voor het genereren van tekst

Text Generation Inference (TGI) is een open-source toolkit ontwikkeld door Hugging Face voor het inzetten van zowel LLM's als VLM's voor inferentie. Het maakt hoogwaardige tekstgeneratie mogelijk met behulp van tensor-parallellisme, model-parallellisme en dynamische batching en ondersteunt enkele toonaangevende open-source LLM's zoals Falcon en Llama V2, evenals VLM's zoals IDEFICS. Gebruikmakend van de nieuwste Hugging Face LLM-modules Amazon SalieMaker, AWS-klanten kunnen nu profiteren van de kracht van SageMaker deep learning containers (DLC's). Dit maakt de naadloze implementatie van LLM's vanuit de Hugging Face-hubs mogelijk via vooraf gebouwde SageMaker DLCs ondersteuning van TGI. Deze gevolgtrekkingsopstelling biedt niet alleen uitzonderlijke prestaties, maar elimineert ook de noodzaak voor het beheer van de zware GPU-infrastructuur. Bovendien profiteert u van geavanceerde functies zoals het automatisch schalen van inferentie-eindpunten, verbeterde beveiliging en ingebouwde modelmonitoring.

TGI biedt snelheden voor het genereren van tekst die tot 100 keer sneller zijn dan traditionele inferentiemethoden en kan efficiënt worden geschaald om de toegenomen verzoeken af ​​te handelen. Het ontwerp zorgt voor compatibiliteit met verschillende LLM's en democratiseert, omdat het open-source is, geavanceerde functies voor de technische gemeenschap. De veelzijdigheid van TGI strekt zich uit over domeinen, waarbij chatbots worden verbeterd, automatische vertalingen worden verbeterd, teksten worden samengevat en diverse inhoud wordt gegenereerd, van poëzie tot code. Daarom komt TGI naar voren als een alomvattende oplossing voor uitdagingen op het gebied van tekstgeneratie. TGI is geïmplementeerd in Python en maakt gebruik van het PyTorch-framework. Het is open source en beschikbaar op GitHub. Het ondersteunt ook PEFT met QLoRA voor snellere prestaties en logits-warping om gegenereerde tekstattributen te controleren, zoals het bepalen van de lengte en diversiteit ervan, zonder het onderliggende model te wijzigen.

U kunt rechtstreeks vanuit het volgende een aangepaste TGI Docker-container bouwen Dockerfile en duw vervolgens de containerimage naar Amazon Elastic Container-register (ECR) voor gevolgtrekkingsimplementatie. Zie de volgende code:

%%sh
# Define docker image name and container's Amazon Reource Name on ECR
container_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" # Get the login command from ECR and execute it directly
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${account}.dkr.ecr.${region}.amazonaws.com # Build the TGI docker image locally
docker build . -f Dockerfile -t ${container_name}
docker tag ${container_name} ${full_name}
docker push ${full_name}

LLM-gevolgtrekking met TGI

De VLP-oplossing in dit bericht maakt gebruik van de LLM in combinatie met LangChain, waarbij gebruik wordt gemaakt van de Chain of Thought (CoT)-benadering voor een nauwkeurigere intentieclassificatie. CoT verwerkt query's om de intentie te onderscheiden en bijbehorende subtaken te activeren om aan de doelen van de query te voldoen. Lama-2-7b-chat-hf (licentieovereenkomst) is de gestroomlijnde versie van de Llama-2-lijn, ontworpen voor dialoogcontexten. De gevolgtrekking van Llama-2-7b-chat-hf wordt mogelijk gemaakt door de TGI-containerimage, waardoor deze beschikbaar is als een API-service.

Voor Llama-2-7b-chat-hf-inferentie wordt een g5.2xlarge (24G VRAM) aanbevolen om topprestaties te bereiken. Voor toepassingen die een robuustere LLM vereisen, passen de Llama-v2-13b-modellen goed bij een g5.12xlarge (96G VRAM) exemplaar. Overweeg voor de Llama-2-70b-modellen de GPU [2xlarge] – 2x Nvidia A100 met behulp van bitsandbytes-kwantisering of de g5.48xlarge. Met name kan het gebruik van bitsandbytes-kwantisering de vereiste gevolgtrekking GPU VRAM met 50% verminderen.

U kunt SageMaker DLC's gebruiken met de eerder beschreven TGI-containerimage om Llama-2-7b-chat-hf te implementeren voor gevolgtrekking (zie de volgende code). Als alternatief kunt u een snelle lokale gevolgtrekking maken voor een proof of concept op een g5.2xlarge-instantie met behulp van een Docker-container.

import json
from time import gmtime, strftime
from sagemaker.huggingface import get_huggingface_llm_image_uri
from sagemaker.huggingface import HuggingFaceModel
from sagemaker import get_execution_role # Prerequisite:create an unique model name
model_name = 'Llama-7b-chat-hf' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) # retrieve the llm image uri of SageMaker pre-built DLC TGI v1.03 tgi_image_ecr_uri = get_huggingface_llm_image_uri( "huggingface", version="1.0.3"
) # Define Model and Endpoint configuration parameter
hf_config = { 'HF_MODEL_ID': "meta-research/Llama-2-7b-chat-hf", # Matching model_id on Hugging Face Hub 'SM_NUM_GPUS': json.dumps(number_of_gpu), 'MAX_TOTAL_TOKENS': json.dumps(1024), 'HF_MODEL_QUANTIZE': "bitsandbytes", # Use quantization for less vram requirement, commet it if no needed.
} # create HuggingFaceModel with the SageMaker pre-built DLC TGI image uri
sm_llm_model = HuggingFaceModel( role=get_execution_role(), image_uri=tgi_image_ecr_uri, env=hf_config
) # Deploy the model
llm = sm_llm_model.deploy( initial_instance_count=1, instance_type="ml.g5.2xlarge", container_startup_health_check_timeout=300, # in sec. Allow 5 minutes to be able to load the model
) # define inference payload
prompt="""<|prompter|>How to select a right LLM for your generative AI project?<|endoftext|><|assistant|>""" # hyperparameters for llm
payload = { "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
} # send request to endpoint
response = llm.predict(payload)

Verfijn en pas uw LLM aan

SageMaker JumpStart biedt talloze voorbeelden van notebooks die het gebruik van Parameter Efficient Fine Tuning (PEFT) demonstreren, inclusief QLoRA voor het trainen en verfijnen van LLM's. QLoRA houdt de vooraf getrainde modelgewichten in een statische toestand en introduceert trainbare rangontbindingsmatrices in elke laag van de Transformer-structuur. Deze methode vermindert aanzienlijk het aantal trainbare parameters dat nodig is voor stroomafwaartse taken.

Als alternatief kunt u verkennen Directe voorkeursoptimalisatie (DPO), waardoor de noodzaak voor het opzetten van een beloningsmodel, het trekken van monsters tijdens het verfijnen van de LLM of uitgebreide hyperparameteraanpassingen overbodig wordt. Uit recent onderzoek is gebleken dat de finetuning van DPO overtreft RLHF bij het beheren van het genereren van sentimenten en verbetert de kwaliteit van samenvattingen en reacties op individuele gesprekken, terwijl het aanzienlijk eenvoudiger is om op te zetten en te onderwijzen. Er zijn drie hoofdstappen in het DPO-trainingsproces (zie GitHub repo voor details):

1. Voer onder toezicht een fijnafstemming uit van een vooraf getrainde basis-LLM om een ​​verfijnde LLM te creëren.
2. Voer de DPO-trainer uit met behulp van het verfijnde model om een ​​versterkend leermodel te creëren.
3. Voeg de adapters van DPO samen met het basis-LLM-model voor inferentie over het genereren van tekst.

U kunt het samengevoegde model implementeren voor gevolgtrekking met behulp van de TGI-containerimage.

Visueel taalmodel

Visuele Taalmodellen (VLM) die zowel de visie- als de taalmodaliteiten combineren, hebben hun toenemende effectiviteit bij generalisatie laten zien, wat heeft geleid tot verschillende praktische gebruiksscenario's met zero-shot-prompts of weinig-shot-prompts met instructies. Een VLM bestaat doorgaans uit drie sleutelelementen: een afbeeldingsencoder, een tekstencoder en een strategie om informatie van de twee encoders samen te voegen. Deze sleutelelementen zijn nauw met elkaar verbonden omdat de verliesfuncties zijn ontworpen rond zowel de modelarchitectuur als de leerstrategie. Veel geavanceerde VLM's gebruiken CLIP/ViT (zoals OpenCLIP) en LLM's (zoals Llama-v1) en zijn getraind op meerdere openbaar beschikbare datasets zoals Wikipedia, LAION en Public Multimodal Dataset.

Bij deze demo werd gebruik gemaakt van een vooraf getrainde IDEFICS-9b-instruct model ontwikkeld door KnuffelenGezichtM4, een verfijnde versie van IDEFICS-9b, volgens de trainingsprocedure uiteengezet in Flamingo door de twee vooraf getrainde modellen te combineren (laion/CLIP-ViT-H-14-laion2B-s32B-b79K en Hugyllama/llama-7b) met aangepaste Transformer-blokken. De IDEFICS-9b is getraind op multimodale datasets van OBELIC, Wikipedia, LAION en PMD met in totaal 150 miljard tokens en 1.582 miljard afbeeldingen met elk een resolutie van 224×224. De IDEFICS-9b was gebaseerd op Llama-7b met een effectieve batchgrootte van 1.31 miljoen. De IDEFICS-9b-instruct werd vervolgens verfijnd met 6.8 miljoen multimodale instructiedatasets gemaakt op basis van augmentatie met behulp van generatieve AI door alle parameters (visie-encoder, taalmodel, kruisaandachten) te deblokkeren. De verfijnde datasets omvatten de pre-trainingsgegevens met de volgende steekproefverhoudingen: 5.1% van beeld-tekstparen en 30.7% van OBELICS multimodale webdocumenten.

De trainingssoftware is gebouwd bovenop Hugging Face Transformers en Accelerate, en DeepSpeed ​​ZeRO-3 voor opleiding, plus Webgegevensset en Image2DataSets voor het laden van gegevens. De pre-training van IDEFICS-9b duurde 350 uur op 128 Nvidia A100 GPU's, terwijl het afstemmen van IDEFICS-9b-instruct 70 uur duurde op 128 Nvidia A100 GPU's, beide op AWS p4.24xlarge-instanties.

Met SageMaker kunt u IDEFICS-9b-instruct naadloos implementeren op een g5.2xlarge-instantie voor inferentietaken. Het volgende codefragment illustreert hoe u een op maat gemaakte lokale deep learning-container kunt starten, geïntegreerd met de aangepaste TGI Docker-image:

%%sh
llm_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} # Test the LLM API using curl
curl -X 'POST' 'http://<hostname_or_ip>:8080/' -H 'accept: application/json' -H 'Content-Type: application/json' -d '{ "inputs": "User:![](http://<image_url>/image.png)Welk apparaat heeft deze afbeelding geproduceerd? Kunt u het belangrijkste klinische doel van een dergelijk beeld uitleggen? Kunt u een radiologisch rapport schrijven op basis van dit beeld? ", 

 "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 }'

U kunt IDEFICS of andere VLM's verfijnen, inclusief Flamingo openen met uw eigen domeinspecifieke gegevens met instructies. Raadpleeg het volgende README voor de voorbereiding van multimodale datasets en de script verfijnen voor meer details.

Intentieclassificatie met gedachteketen

Een afbeelding zegt meer dan duizend woorden, daarom heeft VLM begeleiding nodig om een ​​accuraat bijschrift te genereren op basis van een bepaalde afbeelding en vraag. We kunnen gebruik maken van enkele-shot-prompts om in-context leren mogelijk te maken, waarbij we demonstraties geven in de prompt om het model naar betere prestaties te sturen. De demonstraties dienen als conditionering voor volgende voorbeelden waarbij we willen dat het model een reactie genereert.

Standaard prompts met enkele shots werken goed voor veel taken, maar zijn nog steeds geen perfecte techniek, vooral als het gaat om complexere redeneringstaken. Het sjabloon voor een paar vragen is niet voldoende om betrouwbare antwoorden te krijgen. Het kan helpen als we het probleem in stappen opsplitsen en dat aan het model laten zien. Recenter, keten van gedachten (CoT) prompting is gepopulariseerd om complexere rekenkundige, gezond verstand- en symbolische redeneringstaken aan te pakken

CoT elimineert handmatige inspanningen door LLM's te gebruiken met de prompt 'Laten we stap voor stap nadenken' om redeneringsketens voor demonstraties één voor één te genereren. Dit automatische proces kan echter nog steeds leiden tot fouten in gegenereerde ketens. Om de gevolgen van de fouten te verzachten, is de diversiteit van demonstraties van belang. Dit bericht stelt Auto-CoT voor, dat vragen met diversiteit bemonstert en redeneringsketens genereert om de demonstraties te construeren. CoT bestaat uit twee hoofdfasen:

• Vraagclustering – Verdeel vragen van een bepaalde dataset in een paar clusters
• Demonstratiesteekproef – Selecteer een representatieve vraag uit elk cluster en genereer de redeneringsketen ervan met behulp van zero-shot CoT met eenvoudige heuristieken

Zie het volgende codefragment:

from langchain.llms import HuggingFaceTextGenInference
from langchain import PromptTemplate, LLMChain inference_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 = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer. Use ten five maximum and keep the answer as subtle as possible. List all actionable sub-tasks step by step in detail. Be cautious to avoid phrasing that might replicate previous inquiries. This will help in obtaining an accurate and detailed answer. Avoid repetition for clarity. Question: {question}
Answer: Understand the intent of the question then break down the {question} in to sub-tasks. """ prompt = PromptTemplate( template=template, input_variables= ["question"]
) llm_chain_local = LLMChain(prompt=prompt, llm=llm_local)
llm_chain_local("Can you describe the nature of this image? Do you think it's real??")

Automatische spraakherkenning

De VLP-oplossing bevat Whisper, een Automatic Speech Recognition (ASR)-model van OpenAI, om audioquery's af te handelen. Whisper kan moeiteloos worden geïmplementeerd via SageMaker JumpStart met behulp van de sjabloon. SageMaker JumpStart, bekend om zijn eenvoudige installatie, hoge prestaties, schaalbaarheid en betrouwbaarheid, is ideaal voor ontwikkelaars die uitzonderlijke spraakgestuurde applicaties willen maken. De volgende GitHub repo laat zien hoe je moet inzetten SageMaker realtime inferentie-eindpunten om Whisper te verfijnen en te hosten voor onmiddellijke transcriptie van audio naar tekst, waarbij de synergie tussen SageMaker-hosting en generatieve modellen wordt getoond.

Als alternatief kunt u de Dockerbestand.gpu van GitHub ontwikkeld door Ahmetoner, die een vooraf geconfigureerde RESTful API bevat. U kunt vervolgens een Docker-image maken en de container uitvoeren op een GPU-aangedreven Amazon Elastische Compute Cloud (EC2) voorbeeld voor een snelle proof of concept. Zie de volgende code:

%%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'

In het gegeven voorbeeld is poort 8083 geselecteerd om de Whisper API te hosten, waarbij de beveiligingsregels voor inkomende netwerken zijn geactiveerd. Om te testen, richt u een webbrowser naar http://<IP_or_hostname>:8083/docs en start een POST-aanvraagtest naar het ASR-eindpunt. Als alternatief kunt u de gegeven opdracht uitvoeren of de fluister-live-module gebruiken om de API-connectiviteit te verifiëren.

!pip install whisper-live
from whisper_live.client import TranscriptionClient
client = TranscriptionClient("<whisper_hostname_or_IP>", 8083, is_multilingual=True, lang="zh", translate=True)
client(audio_file_path) # Use sudio file
client() # Use microphone for transcribe

Tekstclassificatie in meerdere klassen en trefwoordextractie

Classificatie met meerdere klassen speelt een cruciale rol bij tekstpromptgestuurde objectdetectie en -segmentatie. De distilbert-base-uncased-finetuned-sst-2-engels model is een verfijnd controlepunt van DistillBERT-basis, niet ingepakt, geoptimaliseerd op de Stanford Sentiment Boombank (SST2) dataset door Hugging Face. Dit model behaalt een nauwkeurigheid van 91.3% op de ontwikkelingsset, terwijl zijn tegenhanger bert-base-uncased een nauwkeurigheid van 92.7% heeft. De Hugging Face Hub biedt toegang tot meer dan 1,000 vooraf getrainde tekstclassificatiemodellen. Voor degenen die op zoek zijn naar verbeterde precisie, biedt SageMaker JumpStart templates om DistilBERT te verfijnen met behulp van aangepaste geannoteerde datasets voor meer op maat gemaakte classificatietaken.

import torch
from transformers import pipeline def mclass(text_prompt, top_k=3, topics = ['Mask creation', 'Object detection', 'Inpainting', 'Segmentation', 'Upscaling', 'Creating an image from another one', 'Generating:q an image from text'], model='distilbert-base-uncased-finetuned-sst-2-english'): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Define a german hypothesis template and the potential candidates for entailment/contradiction template_de = 'The topic is {}' # Pipeline abstraction from hugging face pipe = pipeline(task='zero-shot-classification', model=model, tokenizer=model, device=device) # Run pipeline with a test case prediction = pipe(text_prompt, topics, hypothesis_template=template_de) # Top 3 topics as predicted in zero-shot regime return zip(prediction['labels'][0:top_k], prediction['scores'][0:top_k]) top_3_intend = mclass(text_prompt=user_prompt_str, topics=['Others', 'Create image mask', 'Image segmentation'], top_k=3) 

Het trefwoordextractieproces maakt gebruik van de SleutelBERT module, een gestroomlijnde en gebruiksvriendelijke methode die BERT-insluitingen gebruikt om trefwoorden en sleutelzinnen te genereren die nauw aansluiten bij een document – ​​in dit geval de objecten die zijn gespecificeerd in de query:

# Keyword extraction
from keybert import KeyBERT
kw_model = KeyBERT()
words_list = kw_model.extract_keywords(docs=<user_prompt_str>, keyphrase_ngram_range=(1,3))

Tekstpromptgestuurde objectdetectie en classificatie

De VLP-oplossing maakt gebruik van dialooggestuurde objectdetectie en segmentatie door de semantische betekenis van de tekst te analyseren en de actie en objecten te identificeren vanaf de tekstprompt. Geaard-SAM is een open-sourcepakket gemaakt door IDEA-Research om alles van een bepaalde afbeelding te detecteren en te segmenteren met tekstinvoer. Het combineert de sterke punten van Aarding DINO en alles segmenteren om een ​​zeer krachtige pijplijn op te bouwen voor het oplossen van complexe problemen.

De volgende afbeelding illustreert hoe Grounded-SAM objecten kan detecteren en instantiesegmentatie kan uitvoeren door tekstuele invoer te begrijpen.

SAM onderscheidt zich als een robuust segmentatiemodel, hoewel het aanwijzingen nodig heeft, zoals kaders of punten, om objectmaskers van hoge kwaliteit te produceren. Grounding DINO blinkt uit als een zero-shot-detector, die vakkundig hoogwaardige dozen en labels creëert met behulp van vrije tekstprompts. Wanneer deze twee modellen worden gecombineerd, bieden ze de opmerkelijke mogelijkheid om elk object puur via tekstinvoer te detecteren en te segmenteren. Het Python-hulpprogrammascript dino_sam_inpainting.py is ontwikkeld om Grounded-SAM-methoden te integreren:

!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' # change the path of the model config file grounded_checkpoint = './models/groundingdino_swint_ogc.pth' # change the path of the model sam_checkpoint = './models/sam_vit_h_4b8939.pth' sam_hq_checkpoint = '' #if to use high quality, like sam_hq_vit_h.pth use_sam_hq = '' output_dir = '/tmp/gradio/outputs' device = 'cuda' # make dir os.makedirs(output_dir, exist_ok=True) # load image image_pil, image = D.load_image(image_path) # load model model = D.load_model(config_file, grounded_checkpoint, device=device) output_file_name = f'{format(os.path.basename(image_path))}' # visualize raw image image_pil.save(os.path.join(output_dir, output_file_name)) # run grounding dino model boxes_filt, pred_phrases = D.get_grounding_output( model, image, text_prompt, box_threshold, text_threshold, device=device ) # initialize 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, ) # draw output image 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)

U kunt HQ-SAM kiezen om SAM te upgraden voor hoogwaardige zero-shot-segmentatie. Raadpleeg het volgende papier en code voorbeeld op GitHub voor meer details.

VLP-verwerkingspijplijn

Het belangrijkste doel van de VLP-verwerkingspijplijn is het combineren van de sterke punten van verschillende modellen, waardoor een geavanceerde workflow ontstaat die gespecialiseerd is voor VLP. Het is belangrijk om te benadrukken dat deze opzet prioriteit geeft aan de integratie van topmodellen in visuele, tekst- en spraakdomeinen. Elk segment van de pijpleiding is modulair, waardoor zowel zelfstandig gebruik als gecombineerd gebruik mogelijk is. Bovendien zorgt het ontwerp voor flexibiliteit, waardoor de vervanging van componenten door nog meer geavanceerde modellen mogelijk wordt gemaakt, terwijl multithreading en foutafhandeling worden ondersteund met een gerenommeerde implementatie.

De volgende afbeelding illustreert een gegevensstroom en servicecomponenten van een VLP-pijplijn.

In onze verkenning van de VLP-pijplijn ontwerpen we er een die zowel tekstprompts uit een open tekstformaat als gewone steminvoer van microfoons kan verwerken. De audioverwerking wordt mogelijk gemaakt door Whisper, dat in staat is tot meertalige spraakherkenning en vertaling. De getranscribeerde tekst wordt vervolgens doorgestuurd naar een intentieclassificatiemodule, die de semantische essentie van de aanwijzingen onderscheidt. Dit werkt samen met een LangChain-aangedreven CoT-engine, waarbij de hoofddoelstelling wordt opgedeeld in fijnere subtaken voor het gedetailleerder ophalen en genereren van informatie. Als beeldverwerking wordt afgeleid uit de invoer, start de pijplijn een zoekwoordextractieproces, waarbij de top N trefwoorden worden geselecteerd door kruisverwijzingen naar objecten die in het originele beeld zijn gedetecteerd. Vervolgens worden deze trefwoorden doorgestuurd naar de Grounded-SAM-engine, die selectiekaders genereert. Deze selectiekaders worden vervolgens aan het SAM-model geleverd, dat nauwkeurige segmentatiemaskers maakt, waarbij elke unieke objectinstantie in de bronafbeelding wordt geïdentificeerd. De laatste stap bestaat uit het over elkaar leggen van de maskers en kaders op het originele beeld, waardoor een verwerkt beeld ontstaat dat wordt gepresenteerd als een multimodale uitvoer.

Wanneer de invoerquery een afbeelding probeert te interpreteren, schakelt de pijplijn de LLM in om de subtaken te organiseren en de query te verfijnen met gerichte doelen. Vervolgens wordt het resultaat doorgestuurd naar de VLM API, vergezeld van enkele instructies, de URL van de invoerafbeelding en de opnieuw geformuleerde tekstprompt. Als reactie hierop levert de VLM de tekstuele uitvoer. De VLP-pijplijn kan worden geïmplementeerd met behulp van een op Python gebaseerde werkstroompijplijn of alternatieve orkestratiehulpprogramma's. Dergelijke pijpleidingen werken door een opeenvolgende reeks geavanceerde modellen aan elkaar te koppelen, culminerend in een gestructureerde modelleringsprocedure. De pijpleiding kan voor demonstratiedoeleinden worden geïntegreerd met de Gradio-motor:

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 {supported intents}: 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)

Beperkingen

Het gebruik van vooraf getrainde VLM-modellen voor VLP heeft een veelbelovend potentieel voor beeldbegrip aangetoond. Samen met op taal gebaseerde objectdetectie en segmentatie kan VLP nuttige resultaten van redelijke kwaliteit produceren. VLP heeft echter nog steeds last van inconsistente resultaten, ontbrekende details van foto's en kunnen zelfs hallucineren. Bovendien kunnen modellen feitelijk onjuiste teksten produceren en mag er niet op worden vertrouwd dat zij feitelijk nauwkeurige informatie produceren. Omdat geen van de vooraf getrainde VLM-, SAM- of LLM-modellen waarnaar wordt verwezen, is getraind of verfijnd voor domeinspecifieke productietoepassingen, is deze oplossing niet ontworpen voor bedrijfskritische toepassingen die van invloed kunnen zijn op het levensonderhoud of materiële verliezen kunnen veroorzaken.

Met snelle engineering kan het IDEFICS-model soms extra details herkennen na een teksthint; het resultaat is echter verre van consistent en betrouwbaar. Het kan volhardend zijn in het handhaven van onnauwkeurigheden en is mogelijk niet in staat of niet bereid om correcties aan te brengen, zelfs wanneer gebruikers deze tijdens een gesprek benadrukken. Het verbeteren van het backbone-model door Swin-ViT te integreren en te combineren met op CNN gebaseerde modellen zoals DualToken-ViT, samen met training met meer geavanceerde modellen zoals Llama-v2, zou mogelijk een aantal van deze beperkingen kunnen wegnemen.

Volgende stappen

De VLP-oplossing staat klaar voor opmerkelijke vooruitgang. Als we vooruitkijken, zijn er verschillende belangrijke kansen om VLP-oplossingen vooruit te helpen:

• Geef prioriteit aan het integreren van dynamische promptinstructies en enkele leertips. Deze verbeteringen zullen nauwkeurigere AI-feedback mogelijk maken.
• Intentieclassificatieteams moeten hun inspanningen richten op het verfijnen van de classificatie om genuanceerde, domeinspecifieke intenties uit open prompts op te pikken. Het is van cruciaal belang dat we de precieze gebruikersintenties kunnen begrijpen.
• Implementeer een agent-gedachtenboommodel in de redeneringspijplijn. Deze structuur maakt expliciete redeneerstappen mogelijk om subtaken te voltooien.
• Pilot-initiatieven voor het verfijnen van toonaangevende modellen. Het afstemmen van VLM-, LLM- en SAM-modellen op belangrijke industrieën en gebruiksscenario's door middel van verfijning zal van cruciaal belang zijn.

Erkenning

De auteurs betuigen hun dank aan Vivek Madan en Ashish Rawat voor hun inzichtelijke feedback en beoordeling van dit bericht.

Over de auteurs

Alfred Schen is een Senior AI/ML-specialist bij AWS. Hij heeft in Silicon Valley gewerkt en bekleedde technische en leidinggevende functies in diverse sectoren, waaronder de gezondheidszorg, financiën en hightech. Hij is een toegewijde toegepaste AI/ML-onderzoeker, die zich concentreert op CV, NLP en multimodaliteit. Zijn werk is tentoongesteld in publicaties zoals EMNLP, ICLR en Public Health.

Dokter Li Zhang is een Principal Product Manager-Technical voor de ingebouwde algoritmen van Amazon SageMaker JumpStart en Amazon SageMaker, een service die datawetenschappers en machine learning-beoefenaars aan de slag helpt met het trainen en implementeren van hun modellen, en gebruik maakt van versterkend leren met Amazon SageMaker. Zijn eerdere werk als hoofdonderzoeksmedewerker en meesteruitvinder bij IBM Research heeft de test of time paper award gewonnen op IEEE INFOCOM.

Dr Changsha Ma is AI/ML-specialist bij AWS. Ze is een technoloog met een doctoraat in computerwetenschappen, een masterdiploma in onderwijspsychologie en jarenlange ervaring in datawetenschap en onafhankelijk advies in AI/ML. Ze is gepassioneerd door het onderzoeken van methodologische benaderingen voor machine- en menselijke intelligentie. Buiten haar werk houdt ze van wandelen, koken, op voedsel jagen, studenten begeleiden in ondernemerschap en tijd doorbrengen met vrienden en familie.

Xin Huang is een Senior Applied Scientist voor Amazon SageMaker JumpStart en Amazon SageMaker ingebouwde algoritmen. Hij richt zich op het ontwikkelen van schaalbare machine learning-algoritmen. Zijn onderzoeksinteresses liggen op het gebied van natuurlijke taalverwerking, verklaarbaar diep leren op tabelgegevens en robuuste analyse van niet-parametrische ruimte-tijd clustering. Hij heeft veel artikelen gepubliceerd in ACL-, ICDM-, KDD-conferenties en Royal Statistical Society: Series A.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/dialogue-guided-visual-language-processing-with-amazon-sagemaker-jumpstart/