Visuell språkbehandling (VLP) er i forkant av generativ AI, og driver fremskritt innen multimodal læring som omfatter språkintelligens, synsforståelse og prosessering. Kombinert med store språkmodeller (LLM) og Contrastive Language-Image Pre-Training (CLIP) trent med en stor mengde multimodalitetsdata, er visuelle språkmodeller (VLM-er) spesielt dyktige til oppgaver som bildeteksting, gjenkjenning og segmentering av objekter, og visuell spørsmål besvare. Deres brukstilfeller spenner over ulike domener, fra medieunderholdning til medisinsk diagnostikk og kvalitetssikring i produksjon.
Nøkkelstyrkene til VLP inkluderer effektiv bruk av forhåndstrente VLM-er og LLM-er, som muliggjør null- eller få-skudds spådommer uten å kreve oppgavespesifikke modifikasjoner, og kategorisering av bilder fra et bredt spekter gjennom tilfeldige flerrunde dialoger. Forsterket med Jordet segmenter hva som helst, VLP viser dyktighet i visuell gjenkjenning, med gjenstandsdeteksjon og segmentering som spesielt bemerkelsesverdig. Potensialet eksisterer for å finjustere VLM-er og LLM-er ytterligere ved å bruke domenespesifikke data, med sikte på å øke presisjonen og dempe hallusinasjoner. I likhet med andre gryende teknologier, gjenstår det imidlertid hindringer for å håndtere intrikate modeller, harmonisere ulike modaliteter og formulere enhetlige evalueringsverdier.
Med tillatelse fra NOMIC for OBELICS, HuggingFaceM4 for IDEFICS, Charles Bensimon for Gradio og Amazon Polly for TTS
I dette innlegget utforsker vi de tekniske nyansene ved bruk av VLP-prototyping Amazon SageMaker JumpStart i forbindelse med moderne generative AI-modeller. Gjennom flerrunde dialoger fremhever vi evnene til instruksjonsorientert null- og få-skudds visjonsspråkbehandling, og understreker dets allsidighet og tar sikte på å fange interessen til det bredere multimodale fellesskapet. Demoimplementeringskoden er tilgjengelig i det følgende GitHub repo.
Løsningsoversikt
Den foreslåtte VLP-løsningen integrerer en pakke med toppmoderne generative AI-moduler for å gi nøyaktige multimodale utdata. Sentralt i arkitekturen er de finjusterte VLM og LLM, begge medvirkende til å dekode visuelle og tekstlige datastrømmer. TGI-rammeverket underbygger modellslutningslaget, og gir RESTful APIer for robust integrasjon og enkel tilgjengelighet. Som et supplement til vår auditive databehandling, er Whisper ASR også utstyrt med en RESTful API, som muliggjør strømlinjeformede tale-til-tekst-konverteringer. For å løse komplekse utfordringer som bilde-til-tekst-segmentering, bruker vi containeriserte Jordet segmenter hva som helst modul, synergi med Jordet DINO og Segmenter hva som helst modell (SAM) mekanisme for tekstdrevet objektdeteksjon og segmentering. Systemet er videreutviklet med DistilBERT, optimaliserer vår dialogstyrte flerklasseklassifiseringsprosess. Orkestrering av disse komponentene er LangChain-behandlingspipelinen, en sofistikert mekanisme som er dyktig i å dissekere tekst- eller stemmeinndata, se brukerintensjoner og metodisk delegere underoppgaver til de relevante tjenestene. Syntesen av disse operasjonene produserer aggregerte resultater, og leverer presise og kontekstbevisste multimodale svar.
Følgende diagram illustrerer arkitekturen til vår dialogstyrte VLP-løsning.
Tekstgenerasjonsslutning
Text Generation Inference (TGI) er et åpen kildekodeverktøy utviklet av Hugging Face for distribusjon av LLM-er så vel som VLM-er for inferens. Den muliggjør tekstgenerering med høy ytelse ved bruk av tensorparallellisme, modellparallellisme og dynamisk batching som støtter noen ledende åpen kildekode LLM-er som Falcon og Llama V2, samt VLM-er som IDEFICS. Bruker de nyeste Hugging Face LLM-modulene på Amazon SageMaker, AWS-kunder kan nå utnytte kraften til SageMaker dyplæringsbeholdere (DLC). Dette gir mulighet for sømløs distribusjon av LLM-er fra Hugging Face-hubene via forhåndsbygd SageMaker DLCs støtter TGI. Dette konklusjonsoppsettet tilbyr ikke bare eksepsjonell ytelse, men eliminerer også behovet for å administrere den tunge GPU-infrastrukturen. I tillegg drar du nytte av avanserte funksjoner som automatisk skalering av inferensendepunkter, forbedret sikkerhet og innebygd modellovervåking.
TGI tilbyr tekstgenereringshastigheter opptil 100 ganger raskere enn tradisjonelle slutningsmetoder og skalerer effektivt for å håndtere økte forespørsler. Designet sikrer kompatibilitet med ulike LLM-er og, som åpen kildekode, demokratiserer avanserte funksjoner for teknologisamfunnet. TGIs allsidighet strekker seg på tvers av domener, forbedrer chatbots, forbedrer maskinoversettelser, oppsummerer tekster og genererer mangfoldig innhold, fra poesi til kode. Derfor fremstår TGI som en helhetlig løsning for tekstgenereringsutfordringer. TGI er implementert i Python og bruker PyTorch-rammeverket. Det er åpen kildekode og tilgjengelig på GitHub. Den støtter også PEFT med QLoRA for raskere ytelse og logits deformering for å kontrollere genererte tekstattributter, for eksempel å bestemme lengden og mangfoldet, uten å endre den underliggende modellen.
Du kan bygge en tilpasset TGI Docker-beholder direkte fra følgende Dockerfile og skyv deretter beholderbildet til Amazon Elastisk beholderregister (ECR) for slutningsdistribusjon. Se følgende kode:
%%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-slutning med TGI
VLP-løsningen i dette innlegget bruker LLM sammen med LangChain, og utnytter chain-of-thought (CoT)-tilnærmingen for mer nøyaktig intensjonsklassifisering. CoT behandler spørringer for å finne hensikt og utløse assosierte underoppgaver for å oppfylle spørringens mål. Lama-2-7b-chat-hf (lisensavtale) er den strømlinjeformede versjonen av Llama-2-linjen, designet for dialogsammenheng. Konklusjonen til Llama-2-7b-chat-hf er drevet av TGI-beholderbildet, noe som gjør det tilgjengelig som en API-aktivert tjeneste.
For Llama-2-7b-chat-hf-slutninger anbefales en g5.2xlarge (24G VRAM) for å oppnå topp ytelse. For applikasjoner som krever en mer robust LLM, passer Llama-v2-13b-modellene godt med en g5.12xlarge (96G VRAM)-forekomst. For Llama-2-70b-modellene bør du vurdere enten GPU [2xlarge] – 2x Nvidia A100 som bruker bitsandbyte-kvantisering eller g5.48xlarge. Spesielt kan bruk av bitsandbyte kvantisering redusere den nødvendige inferens GPU VRAM med 50%.
Du kan bruke SageMaker DLCer med TGI-beholderbildet beskrevet tidligere for å distribuere Llama-2-7b-chat-hf for slutning (se følgende kode). Alternativt kan du stå opp med en rask lokal slutning for et proof of concept på en g5.2xlarge-forekomst ved å bruke en Docker-beholder.
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)
Finjuster og tilpass din LLM
SageMaker JumpStart tilbyr en rekke bærbare eksempler som demonstrerer bruken av Parameter Efficient Fine Tuning (PEFT), inkludert QLoRA for trening og finjustering av LLM. QLoRA opprettholder de forhåndstrente modellvektene i en statisk tilstand og introduserer trenbare rangeringsmatriser i hvert lag av transformatorstrukturen. Denne metoden reduserer antallet trenbare parametere som trengs for nedstrømsoppgaver betydelig.
Alternativt kan du utforske Direkte preferanseoptimalisering (DPO), som unngår nødvendigheten av å sette opp en belønningsmodell, trekke prøver under finjustering fra LLM, eller omfattende hyperparameterjusteringer. Nyere forskning har vist at DPOs finjustering overgår RLHF i å administrere sentimentgenerering og forbedrer kvaliteten på sammendrag og enkeltsamtalersvar, samtidig som det er betydelig enklere å sette opp og utdanne. Det er tre hovedtrinn i DPO-opplæringsprosessen (se GitHub repo for detaljer):
- Utfør overvåket finjustering av en forhåndstrent base LLM for å lage en finjustert LLM.
- Kjør DPO-treneren ved å bruke den finjusterte modellen for å lage en forsterkende læringsmodell.
- Slå sammen adaptere fra DPO til basis LLM-modellen for tekstgenerering.
Du kan distribuere den sammenslåtte modellen for slutninger ved å bruke TGI-beholderbildet.
Visuell språkmodell
Visuelle språkmodeller (VLM) som kombinerer både visjons- og språkmodaliteter har vist sin forbedrede effektivitet i generalisering, noe som har ført til ulike praktiske brukstilfeller med instruksjoner med null skudd eller få skudd med instruksjoner. En VLM består vanligvis av tre nøkkelelementer: en bildekoder, en tekstkoder og en strategi for å smelte sammen informasjon fra de to koderne. Disse nøkkelelementene er tett koblet sammen fordi tapsfunksjonene er designet rundt både modellarkitekturen og læringsstrategien. Mange state-of-the-art VLM-er bruker CLIP/ViT (som OpenCLIP) og LLM-er (som Llama-v1) og er trent på flere offentlig tilgjengelige datasett som Wikipedia, LAION og Public Multimodal Dataset.
Denne demoen brukte en forhåndstrent IDEFICS-9b-instruks modell utviklet av HuggingFaceM4, en finjustert versjon av IDEFICS-9b, som følger opplæringsprosedyren som er lagt ut i Flamingo ved å kombinere de to forhåndstrente modellene (laion/CLIP-ViT-H-14-laion2B-s32B-b79K og huggyllama/llama-7b) med modifiserte transformatorblokker. IDEFICS-9b ble trent på OBELIC, Wikipedia, LAION og PMD multimodale datasett med totalt 150 milliarder tokens og 1.582 milliarder bilder med 224×224 oppløsning hver. IDEFICS-9b var basert på Llama-7b med en effektiv batchstørrelse på 1.31 millioner. IDEFICS-9b-instruksen ble deretter finjustert med 6.8 millioner multimodalitetsinstruksjonsdatasett laget fra utvidelse ved bruk av generativ AI ved å frigjøre alle parametere (synskoder, språkmodell, kryssoppmerksomhet). Finjusteringsdatasettene inkluderer før-treningsdata med følgende samplingsforhold: 5.1 % av bilde-tekst-parene og 30.7 % av OBELICS multimodale nettdokumenter.
Treningsprogramvaren er bygget på toppen av Hugging Face Transformers og Accelerate, og DeepSpeed ZeRO-3 for trening, pluss WebDataset og Image2DataSets for datalasting. Foropplæringen av IDEFICS-9b tok 350 timer å fullføre på 128 Nvidia A100 GPUer, mens finjustering av IDEFICS-9b-instruct tok 70 timer på 128 Nvidia A100 GPUer, begge på AWS p4.24xlarge forekomster.
Med SageMaker kan du sømløst distribuere IDEFICS-9b-instruct på en g5.2xlarge-instans for slutningsoppgaver. Følgende kodebit illustrerer hvordan du lanserer en skreddersydd lokal beholder for dyp læring integrert med det tilpassede TGI Docker-bildet:
%%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://<im
age_url>/image.png) Hvilken enhet produserte dette bildet? Vennligst forklar hovedformålet med et slikt bilde? Kan du skrive en radiologirapport basert på dette bildet? ",
"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 }'
Du kan finjustere IDEFICS eller andre VLM-er inkludert Åpne Flamingo med dine egne domenespesifikke data med instruksjoner. Se følgende README for utarbeidelse av multimodalitetsdatasett og finjustering av manus for ytterligere detaljer.
Intensjonsklassifisering med tankekjede
Et bilde er verdt tusen ord, derfor krever VLM veiledning for å generere en nøyaktig bildetekst fra et gitt bilde og spørsmål. Vi kan bruke få-shot-spørring for å muliggjøre læring i kontekst, der vi gir demonstrasjoner i ledeteksten for å styre modellen til bedre ytelse. Demonstrasjonene fungerer som kondisjonering for påfølgende eksempler der vi ønsker at modellen skal generere en respons.
Standard få-skudd-oppfordring fungerer bra for mange oppgaver, men er fortsatt ikke en perfekt teknikk, spesielt når du arbeider med mer komplekse resonneringsoppgaver. Spørringsmalen med få skudd er ikke nok til å få pålitelige svar. Det kan hjelpe hvis vi deler problemet ned i trinn og demonstrerer det for modellen. Mer nylig, tankekjede (CoT)-spørring har blitt populært for å adressere mer komplekse regneoppgaver, sunn fornuft og symbolske resonnementoppgaver
CoT eliminerer manuell innsats ved å bruke LLM-er med en "La oss tenke steg for steg"-forespørsel for å generere resonnementskjeder for demonstrasjoner én etter én. Imidlertid kan denne automatiske prosessen fortsatt ende opp med feil i genererte kjeder. For å dempe effektene av feilene er mangfoldet av demonstrasjoner viktig. Dette innlegget foreslår Auto-CoT, som prøver spørsmål med mangfold og genererer resonnementskjeder for å konstruere demonstrasjonene. CoT består av to hovedstadier:
- Spørsmålsgruppering – Del opp spørsmål fra et gitt datasett i noen få klynger
- Demonstrasjonsprøvetaking – Velg et representativt spørsmål fra hver klynge og generer resonnementskjeden ved hjelp av null-skudd CoT med enkel heuristikk
Se følgende kodebit:
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??")
Automatisk talegjenkjenning
VLP-løsningen inkluderer Whisper, en Automatic Speech Recognition (ASR)-modell fra OpenAI, for å håndtere lydforespørsler. Whisper kan enkelt distribueres via SageMaker JumpStart ved å bruke malen. SageMaker JumpStart, kjent for sitt enkle oppsett, høye ytelse, skalerbarhet og pålitelighet, er ideell for utviklere som tar sikte på å lage eksepsjonelle stemmedrevne applikasjoner. Følgende GitHub repo viser hvordan man bruker SageMaker sanntidsslutningsendepunkter å finjustere og være vert for Whisper for umiddelbar lyd-til-tekst-transkripsjon, som viser synergien mellom SageMaker-hosting og generative modeller.
Alternativt kan du laste ned direkte Dockerfile.gpu fra GitHub utviklet av ahmetoner, som inkluderer en forhåndskonfigurert RESTful API. Du kan deretter konstruere et Docker-bilde og kjøre beholderen på en GPU-drevet Amazon Elastisk Compute Cloud (EC2) forekomst for et raskt bevis på konseptet. Se følgende kode:
%%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'
I det angitte eksemplet er port 8083 valgt for å være vert for Whisper API, med sikkerhetsregler for innkommende nettverk aktivert. For å teste, direkte en nettleser til http://<IP_or_hostname>:8083/docs
og initier en POST-forespørselstest til ASR-endepunktet. Som et alternativ, kjør den gitte kommandoen eller bruk whisper-live-modulen for å bekrefte API-tilkobling.
!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
Tekstklassifisering i flere klasser og uttrekk av nøkkelord
Flerklasseklassifisering spiller en sentral rolle i tekstprompt-drevet objektdeteksjon og segmentering. De distilbert-base-uncased-finetuned-sst-2-engelsk modellen er et raffinert sjekkpunkt av DistilBERT-base-ukappet, optimalisert på Stanford Sentiment Treebank (SST2) datasett av Hugging Face. Denne modellen oppnår en nøyaktighet på 91.3 % på utviklingssettet, mens dens motstykke bert-base-uncased har en nøyaktighet på 92.7 %. Hugging Face Hub gir tilgang til over 1,000 ferdigtrente tekstklassifiseringsmodeller. For de som søker økt presisjon, tilbyr SageMaker JumpStart maler å finjustere DistilBERT ved å bruke tilpassede kommenterte datasett for mer skreddersydde klassifiseringsoppgaver.
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)
Søkeordutvinningsprosessen bruker KeyBERT modul, en strømlinjeformet og brukervennlig metode som utnytter BERT-innbygginger for å generere søkeord og nøkkelsetninger tett på linje med et dokument – i dette tilfellet objektene spesifisert i spørringen:
# Keyword extraction
from keybert import KeyBERT
kw_model = KeyBERT()
words_list = kw_model.extract_keywords(docs=<user_prompt_str>, keyphrase_ngram_range=(1,3))
Tekstprompt-drevet objektgjenkjenning og klassifisering
VLP-løsningen bruker dialogstyrt objektdeteksjon og segmentering ved å analysere den semantiske betydningen av teksten og identifisere handlingen og objektene fra tekstforespørselen. Jordet-SAM er en åpen kildekode-pakke laget av IDEA-Research for å oppdage og segmentere alt fra et gitt bilde med tekstinndata. Den kombinerer styrkene til Jording DINO og Segment Anything for å bygge en veldig kraftig pipeline for å løse komplekse problemer.
Følgende figur illustrerer hvordan Grounded-SAM kan oppdage objekter og utføre instanssegmentering ved å forstå tekstinndata.
SAM skiller seg ut som en robust segmenteringsmodell, selv om den krever meldinger, for eksempel avgrensningsbokser eller punkter, for å produsere objektmasker av høy kvalitet. Jording av DINO utmerker seg som en nullskuddsdetektor, og skaper esker og etiketter av høy kvalitet ved hjelp av tekstmeldinger i fritt format. Når disse to modellene kombineres, tilbyr de den bemerkelsesverdige muligheten til å oppdage og segmentere ethvert objekt rent gjennom tekstinndata. Python-verktøyskriptet dino_sam_inpainting.py ble utviklet for å integrere Grounded-SAM-metoder:
!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)
Du kan velge HQ-SAM for å oppgradere SAM for høykvalitets zero-shot segmentering. Se følgende papir og kode eksempel på GitHub for flere detaljer.
VLP-behandlingsrørledning
Hovedmålet med VLP-behandlingspipelinen er å kombinere styrken til forskjellige modeller, og skape en sofistikert arbeidsflyt spesialisert for VLP. Det er viktig å fremheve at dette oppsettet prioriterer integrering av toppmodeller på tvers av visuelle, tekst- og taledomener. Hvert segment av rørledningen er modulært, noe som muliggjør enten frittstående bruk eller kombinert drift. Videre sikrer designen fleksibilitet, og muliggjør erstatning av komponenter med mer avanserte modeller som ennå ikke kommer, samtidig som den støtter multithreading og feilhåndtering med anerkjent implementering.
Følgende figur illustrerer en VLP-rørledningsdataflyt og servicekomponenter.
I vår utforskning av VLP-rørledningen designer vi en som kan behandle både tekstmeldinger fra åpent tekstformat og tilfeldige stemmeinndata fra mikrofoner. Lydbehandlingen tilrettelegges av Whisper, som er i stand til flerspråklig talegjenkjenning og oversettelse. Den transkriberte teksten kanaliseres deretter til en intentklassifiseringsmodul, som skiller den semantiske essensen av ledetekstene. Dette fungerer sammen med en LangChain-drevet CoT-motor, og dissekerer hovedhensikten til finere underoppgaver for mer detaljert informasjonsinnhenting og generering. Hvis bildebehandling utledes fra inndataene, starter rørledningen en nøkkelordekstraksjonsprosess, og velger de øverste N nøkkelordene ved å kryssreferanser objekter oppdaget i det originale bildet. Deretter blir disse nøkkelordene rutet til Grounded-SAM-motoren, som genererer avgrensende bokser. Disse avgrensningsboksene leveres deretter til SAM-modellen, som lager presise segmenteringsmasker, og identifiserer hver unike objektforekomst i kildebildet. Det siste trinnet innebærer å legge maskene og grenseboksene over på det originale bildet, noe som gir et bearbeidet bilde som presenteres som en multimodal utgang.
Når inndataspørringen søker å tolke et bilde, engasjerer pipelinen LLM for å organisere underoppgavene og avgrense spørringen med målrettede mål. Deretter sendes resultatet til VLM API, ledsaget av instruksjoner med få bilder, URL-en til inndatabildet og den omformulerte tekstmeldingen. Som svar gir VLM tekstutgangen. VLP-rørledningen kan implementeres ved hjelp av en Python-basert arbeidsflyt-pipeline eller alternative orkestreringsverktøy. Slike rørledninger fungerer ved å kjede et sekvensielt sett av sofistikerte modeller, som kulminerer i en strukturert modelleringsprosedyre sekvensielt. Rørledningen integreres med Gradio-motoren for demonstrasjonsformål:
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)
Begrensninger
Bruk av forhåndstrente VLM-modeller for VLP har vist et lovende potensial for bildeforståelse. Sammen med språkbasert objektdeteksjon og segmentering kan VLP produsere nyttige utdata med rimelig kvalitet. Imidlertid lider VLP fortsatt av inkonsekvente resultater, manglende detaljer fra bilder, og det kan til og med hallusinere. Dessuten kan modeller produsere faktisk ukorrekte tekster og bør ikke stoles på for å produsere faktisk nøyaktig informasjon. Siden ingen av de refererte forhåndstrente VLM-, SAM- eller LLM-modellene har blitt trent eller finjustert for domenespesifikke produksjonsgradsapplikasjoner, er ikke denne løsningen designet for virksomhetskritiske applikasjoner som kan påvirke levebrødet eller forårsake materielle tap
Med rask utvikling kan IDEFICS-modellen noen ganger gjenkjenne ekstra detaljer etter et teksthint; men resultatet er langt fra konsistent og pålitelig. Den kan være vedvarende i å opprettholde unøyaktigheter og kan være ute av stand til eller villige til å gjøre rettelser selv når brukere fremhever disse under en samtale. Å forbedre ryggradsmodellen ved å integrere Swin-ViT og smelte den sammen med CNN-baserte modeller som DualToken-ViT, sammen med trening med mer avanserte modeller som Llama-v2, kan potensielt løse noen av disse begrensningene.
Neste trinn
VLP-løsningen er klar for betydelig fremgang. Når vi ser fremover, er det flere viktige muligheter for å fremme VLP-løsninger:
- Prioriter integrering av dynamiske instruksjoner og læringstips. Disse forbedringene vil muliggjøre mer nøyaktig AI-tilbakemelding.
- Intensjonsklassifiseringsteam bør fokusere innsatsen på å avgrense klassifiseringen for å fange opp nyanserte, domenespesifikke hensikter fra åpne forespørsler. Å kunne forstå nøyaktige brukerhensikter vil være kritisk.
- Implementer en agenttre av tanker-modell i resonnementrørledningen. Denne strukturen vil tillate eksplisitte resonnementtrinn for å fullføre underoppgaver.
- Pilot finjusteringsinitiativer på ledende modeller. Å skreddersy VLM-, LLM- og SAM-modeller til nøkkelbransjer og brukstilfeller gjennom finjustering vil være sentralt.
Bekreftelse
Forfatterne takker Vivek Madan og Ashish Rawat for deres innsiktsfulle tilbakemeldinger og gjennomgang av dette innlegget.
Om forfatterne
Alfred Shen er senior AI/ML-spesialist hos AWS. Han har jobbet i Silicon Valley, og hatt tekniske og lederstillinger i forskjellige sektorer, inkludert helsevesen, finans og høyteknologi. Han er en dedikert anvendt AI/ML-forsker, som konsentrerer seg om CV, NLP og multimodalitet. Arbeidet hans har blitt vist frem i publikasjoner som EMNLP, ICLR og Public Health.
Dr. Li Zhang er en hovedproduktsjef-teknisk for Amazon SageMaker JumpStart og Amazon SageMaker innebygde algoritmer, en tjeneste som hjelper dataforskere og maskinlæringsutøvere å komme i gang med å trene og distribuere modellene sine, og bruker forsterkende læring med Amazon SageMaker. Hans tidligere arbeid som ledende forskningsmedarbeider og mesteroppfinner ved IBM Research har vunnet test of time paper-prisen hos IEEE INFOCOM.
Dr. Changsha Ma er AI/ML-spesialist hos AWS. Hun er teknolog med doktorgrad i informatikk, mastergrad i utdanningspsykologi, og mange års erfaring innen datavitenskap og uavhengig rådgivning innen AI/ML. Hun brenner for å forske på metodiske tilnærminger for maskin- og menneskelig intelligens. Utenom jobben elsker hun å gå tur, lage mat, jakte på mat, veilede studenter for entreprenørskap og tilbringe tid med venner og familier.
Xin Huang er Senior Applied Scientist for Amazon SageMaker JumpStart og Amazon SageMaker innebygde algoritmer. Han fokuserer på å utvikle skalerbare maskinlæringsalgoritmer. Hans forskningsinteresser er innen naturlig språkbehandling, forklarbar dyp læring på tabelldata og robust analyse av ikke-parametrisk rom-tid-klynger. Han har publisert mange artikler i ACL, ICDM, KDD-konferanser og Royal Statistical Society: Series A.
- SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
- PlatoData.Network Vertical Generative Ai. Styrk deg selv. Tilgang her.
- PlatoAiStream. Web3 Intelligence. Kunnskap forsterket. Tilgang her.
- PlatoESG. Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
- PlatoHelse. Bioteknologisk og klinisk etterretning. Tilgang her.
- kilde: https://aws.amazon.com/blogs/machine-learning/dialogue-guided-visual-language-processing-with-amazon-sagemaker-jumpstart/
- : har
- :er
- :ikke
- :hvor
- $OPP
- 000
- 1
- 10
- 100
- 150
- 160
- 20
- 30
- 31
- 7
- 70
- 8
- 80
- 91
- a
- I stand
- Om oss
- abstraksjon
- akselerere
- Aksepterer
- adgang
- tilgjengelighet
- ledsaget
- Logg inn
- nøyaktighet
- nøyaktig
- Oppnå
- oppnår
- tvers
- Handling
- I tillegg
- adresse
- adressering
- dyktig
- justeringer
- avansere
- avansert
- fremskritt
- Etter
- Agent
- fremover
- AI
- AI-modeller
- AI / ML
- Sikter
- algoritmer
- justert
- Alle
- tillate
- tillater
- langs
- også
- alternativ
- Amazon
- Amazon Polly
- Amazon SageMaker
- Amazon SageMaker JumpStart
- Amazon Web Services
- an
- analyse
- analyserer
- og
- En annen
- besvare
- svar
- noen
- hva som helst
- api
- APIer
- søknader
- anvendt
- tilnærming
- tilnærminger
- arkitektur
- ER
- AREA
- rundt
- AS
- forsikring
- At
- attributter
- lyd
- augmented
- forfattere
- auto
- Automatisk
- tilgjengelig
- unngå
- AWS
- Backbone
- basen
- basert
- BE
- fordi
- vært
- være
- nytte
- Bedre
- mellom
- Milliarder
- Milliarder tokens
- Blocks
- skryte
- øke
- både
- Eske
- bokser
- Break
- bred
- bredere
- nett~~POS=TRUNC leseren~~POS=HEADCOMP
- bygge
- bygget
- innebygd
- men
- by
- CAN
- kandidater
- evner
- evne
- stand
- fangst
- saken
- saker
- tilfeldig
- kategorisering
- Årsak
- forsiktige
- sentral
- kjede
- kjeder
- utfordringer
- endring
- Charles
- chatbots
- Velg
- klarhet
- klassifisering
- kunde
- Klinisk
- tett
- Cluster
- gruppering
- kode
- Høyskole
- COM
- kombinere
- kombinert
- skurtreskerne
- kombinere
- Kom
- ingen starter
- Felles
- Common Sense
- samfunnet
- kompatibilitet
- fullføre
- komplekse
- komponenter
- omfattende
- Beregn
- datamaskin
- informatikk
- konsept
- Gjennomføre
- konferanser
- Konfigurasjon
- sammen
- Tilkobling
- Vurder
- konsistent
- består
- konstruere
- konsulent
- Container
- Containere
- moderne
- innhold
- kontekst
- sammenhenger
- kontroll
- Samtale
- konverteringer
- Korreksjoner
- kunne
- motstykke
- kombinert
- lage
- skape
- opprettet
- Opprette
- skaperverket
- kritisk
- kryssreferanser
- kulminerte
- skikk
- Kunder
- tilpasse
- tilpasset
- dato
- databehandling
- datavitenskap
- datasett
- håndtering
- Dekoding
- avtar
- dedikert
- dyp
- dyp læring
- definere
- Grad
- levere
- demo
- demokratiserer
- demonstrere
- demonstrert
- demonstrerer
- utplassere
- utplassert
- utplasserings
- distribusjon
- beskrive
- utforming
- designet
- detalj
- detaljert
- detaljer
- oppdage
- oppdaget
- Gjenkjenning
- bestemme
- utviklet
- utviklere
- utvikle
- Utvikling
- enhet
- diagnostikk
- Dialog
- forskjellig
- dino
- direkte
- regissert
- direkte
- skjelne
- diverse
- Mangfold
- do
- Docker
- dokumenter
- domener
- Don
- ned
- nedlasting
- tegne
- tegning
- drevet
- kjøring
- under
- dynamisk
- hver enkelt
- Tidligere
- enklere
- utdanne
- Kunnskap
- Effektiv
- effektivitet
- effekter
- effektiv
- effektivt
- uanstrengt
- uanstrengt
- innsats
- enten
- elementer
- eliminere
- eliminerer
- ellers
- framgår
- streker
- ansette
- anvender
- muliggjøre
- muliggjør
- muliggjør
- Omfatter
- slutt
- Endpoint
- engasjerer
- Motor
- Ingeniørarbeid
- forbedret
- Forbedrer
- styrke
- nok
- sikrer
- Entertainment
- entreprenørskap
- feil
- spesielt
- essens
- evaluering
- Selv
- eksempel
- eksempler
- eksepsjonell
- henrette
- utstillinger
- finnes
- erfaring
- Forklar
- leting
- utforske
- utvide
- strekker
- omfattende
- ekstra
- utdrag
- Face
- tilrettelagt
- tilrettelegging
- falsk
- familier
- langt
- raskere
- Egenskaper
- tilbakemelding
- Noen få
- Figur
- filet
- slutt~~POS=TRUNC
- finansiere
- slutt
- passer
- fem
- fleksibilitet
- flyten
- Fokus
- fokuserer
- etter
- mat
- Til
- teten
- format
- formulering
- Rammeverk
- venner
- fra
- funksjoner
- videre
- Dess
- smelting
- generere
- generert
- genererer
- genererer
- generasjonen
- generative
- Generativ AI
- Tysk
- få
- gå
- GitHub
- gitt
- Mål
- GPU
- GPU
- takknemlighet
- veiledning
- håndtere
- Håndtering
- seletøy
- Utnyttelse
- Ha
- he
- Helse
- helsetjenester
- tung
- tung løfting
- hjelpe
- hjelper
- Høy
- høy ytelse
- høykvalitets
- Uthev
- hint
- hans
- holder
- vert
- Hosting
- TIMER
- Hvordan
- Hvordan
- Men
- HTML
- http
- HTTPS
- Huang
- Hub
- huber
- Klem ansikt
- menneskelig
- menneskelig intelligens
- Jakt
- i
- IBM
- ideell
- identifisering
- IEEE
- if
- illustrerer
- bilde
- bilder
- Påvirkning
- gjennomføring
- implementert
- importere
- viktig
- forbedringer
- bedre
- in
- inkludere
- inkluderer
- Inkludert
- inkorporerer
- økt
- uavhengig
- bransjer
- informasjon
- Infrastruktur
- initiere
- initiativer
- inngang
- innganger
- forespørsler
- innsiktsfull
- installere
- f.eks
- Instanssegmentering
- instant
- instruksjoner
- instrumental
- integrere
- integrert
- Integrerer
- Integrering
- integrering
- Intelligens
- hensikt
- intensjoner
- interesse
- interesser
- inn
- Introduserer
- IT
- DET ER
- jpg
- JSON
- bare
- Hold
- nøkkel
- nøkkelord
- Vet
- kjent
- Etiketten
- etiketter
- Språk
- stor
- siste
- lansere
- lag
- ledende
- læring
- Lengde
- mindre
- Li
- løfte
- i likhet med
- begrensninger
- linje
- Liste
- Llama
- LLM
- laste
- lasting
- lokal
- lokalt
- Logg inn
- Se
- tap
- elsker
- maskin
- maskinlæring
- Hoved
- Vedlike
- opprettholder
- gjøre
- Making
- ledelses
- administrerende
- håndbok
- produksjon
- mange
- maske
- masker
- Master
- mestere
- matchende
- materiale
- Saken
- maksimal
- Kan..
- betyr
- mekanisme
- Media
- medisinsk
- Møt
- medlem
- mentoring
- Meta
- metode
- metoder
- Metrics
- mikrofon
- kunne
- millioner
- minutter
- mangler
- feil
- Minske
- ML
- modell
- modellering
- modeller
- modifikasjoner
- modifisert
- modulære
- Moduler
- Moduler
- overvåking
- mer
- Videre
- flere
- navn
- begynnende
- Naturlig
- Natural Language Processing
- Natur
- nødvendiggjør
- nødvendighet
- Trenger
- nødvendig
- nettverk
- Nettverkssikkerhet
- nlp
- Nei.
- none
- bemerkelsesverdig
- spesielt
- bærbare
- nå
- skyggelegging
- Antall
- mange
- Nvidia
- objekt
- Objektdeteksjon
- Målet
- gjenstander
- hindringer
- å skaffe seg
- of
- off
- tilby
- Tilbud
- on
- ONE
- bare
- videre til
- åpen
- åpen kildekode
- OpenAI
- betjene
- drift
- Drift
- Muligheter
- optimalisert
- optimalisere
- or
- orkestre
- rekkefølge
- original
- OS
- Annen
- andre
- vår
- ut
- Utfallet
- produksjon
- utganger
- utenfor
- enn
- egen
- pakke
- par
- Papir
- papirer
- parameter
- parametere
- spesielt
- lidenskapelig
- Past
- banen
- Topp
- perfekt
- ytelse
- phd
- fotograf
- setninger
- plukke
- bilde
- Bilder
- stykker
- rør
- rørledning
- sentral
- plato
- Platon Data Intelligence
- PlatonData
- spiller
- vær så snill
- i tillegg til
- Poesi
- poeng
- klar
- stillinger
- mulig
- Post
- potensiell
- potensielt
- makt
- powered
- kraftig
- Praktisk
- presis
- Precision
- spådd
- prediksjon
- Spådommer
- Predictor
- forberedelse
- presentert
- forrige
- Principal
- prioriterer
- Problem
- problemer
- prosedyren
- prosess
- Bearbeidet
- Prosesser
- prosessering
- produsere
- produsert
- produserer
- Produkt
- Progress
- prosjekt
- lovende
- bevis
- proof of concept
- foreslått
- foreslår
- prototyping
- gi
- forutsatt
- gir
- gi
- tapperhet
- Psykologi
- offentlig
- folkehelsen
- publikasjoner
- offentlig
- publisert
- rent
- formål
- formål
- Skyv
- Python
- pytorch
- kvalitet
- kvantitet
- spørsmål
- spørsmål
- spørsmål
- Rask
- rangerer
- Raw
- ekte
- sanntids
- rimelig
- nylig
- nylig
- anerkjennelse
- gjenkjenne
- anbefales
- redusere
- referere
- avgrense
- raffinert
- raffinering
- regime
- relevant
- pålitelig
- forbli
- bemerkelsesverdig
- erstatning
- rapporterer
- representant
- hederlig
- anmode
- forespørsler
- påkrevd
- behov
- Krever
- forskning
- forsker
- oppløsning
- svar
- svar
- resultere
- Resultater
- retur
- anmeldelse
- Belønn
- ikke sant
- robust
- Rolle
- kongelig
- regler
- Kjør
- s
- sagemaker
- Sam
- sier
- skalerbarhet
- skalerbar
- vekter
- skalering
- Vitenskap
- Forsker
- forskere
- script
- sømløs
- sømløst
- SEK
- sektorer
- sikkerhet
- se
- seed
- søker
- søker
- segmentet
- segmentering
- valgt
- velge
- send
- senior
- forstand
- sentiment
- Serien
- Serie A
- betjene
- tjeneste
- Tjenester
- sett
- innstilling
- oppsett
- flere
- hun
- bør
- showcased
- utstillingsvindu
- vist
- Silicon
- Silicon Valley
- Enkelt
- siden
- Størrelse
- tekstutdrag
- Samfunnet
- Software
- løsning
- Solutions
- løse
- noen
- noen ganger
- sofistikert
- kilde
- span
- spesialist
- spesialisert
- spesifisert
- Spectrum
- tale
- Talegjenkjenning
- hastigheter
- utgifter
- Staff
- stadier
- stå
- stående
- står
- startet
- Tilstand
- state-of-the-art
- statistisk
- styre
- Trinn
- Steps
- Still
- Stopp
- rett fram
- Strategi
- stream
- strømlinjeformet
- bekker
- styrker
- struktur
- strukturert
- Studenter
- senere
- I ettertid
- i det vesentlige
- slik
- lider
- suite
- medfølgende
- Støtte
- Støtter
- symbolsk
- synergi
- syntese
- system
- TAG
- skreddersydd
- sying
- tandem
- Pek
- målrettet
- oppgaver
- lag
- tech
- Teknisk
- teknikk
- Technologies
- teknolog
- mal
- ti
- test
- tekst
- Tekstklassifisering
- tekstlig
- enn
- Det
- De
- Området
- Kilden
- deres
- deretter
- Der.
- derfor
- Disse
- de
- tror
- denne
- De
- selv om?
- tusen
- tre
- Gjennom
- tett
- tid
- ganger
- til
- sammen
- tokens
- tok
- verktøykasse
- topp
- Tema
- temaer
- lommelykt
- Totalt
- tradisjonelle
- trent
- Kurs
- Transform
- transformator
- transformers
- Oversettelse
- Treet
- sant
- prøve
- to
- typisk
- ute av stand
- underliggende
- forstå
- forståelse
- unik
- oppgradering
- URL
- bruke
- brukt
- Bruker
- brukervennlig
- Brukere
- bruker
- ved hjelp av
- verktøy
- verktøyet
- utnytte
- v1
- Dal
- ulike
- verifisere
- allsidighet
- versjon
- veldig
- av
- syn
- visualisere
- Voice
- W
- var
- vannmerke
- we
- web
- nettleser
- webtjenester
- VI VIL
- når
- mens
- hvilken
- mens
- Hviske
- Wikipedia
- vil
- med
- uten
- Vant
- ord
- Arbeid
- arbeidsflyt
- arbeid
- virker
- verdt
- ville
- skrive
- år
- ennå
- Utbytte
- givende
- Du
- Din
- zephyrnet