El procesamiento del lenguaje visual (VLP) está a la vanguardia de la IA generativa, impulsando avances en el aprendizaje multimodal que abarca la inteligencia del lenguaje, la comprensión de la visión y el procesamiento. Combinados con modelos de lenguaje grande (LLM) y entrenamiento previo de imagen-lenguaje contrastivo (CLIP) entrenados con una gran cantidad de datos multimodales, los modelos de lenguaje visual (VLM) son particularmente hábiles en tareas como subtítulos de imágenes, detección y segmentación de objetos, y visualización. respuesta a preguntas. Sus casos de uso abarcan varios ámbitos, desde entretenimiento multimedia hasta diagnóstico médico y control de calidad en la fabricación.

Las fortalezas clave de VLP incluyen la utilización efectiva de VLM y LLM previamente entrenados, lo que permite predicciones de cero o pocos disparos sin necesidad de modificaciones específicas de la tarea, y categoriza imágenes de un amplio espectro a través de diálogos casuales de múltiples rondas. Aumentado por Segmento conectado a tierra Cualquier cosa, VLP exhibe destreza en el reconocimiento visual, siendo particularmente notable la detección y segmentación de objetos. Existe la posibilidad de perfeccionar aún más los VLM y LLM utilizando datos de dominios específicos, con el objetivo de aumentar la precisión y mitigar las alucinaciones. Sin embargo, al igual que otras tecnologías incipientes, persisten obstáculos para gestionar la complejidad del modelo, armonizar diversas modalidades y formular métricas de evaluación uniformes.

Cortesía de NOMIC para OBELICS, HuggingFaceM4 para IDEFICS, Charles Bensimon para Gradio y Amazon Polly para TTS

En esta publicación, exploramos los matices técnicos de la creación de prototipos VLP utilizando JumpStart de Amazon SageMaker junto con los modelos contemporáneos de IA generativa. A través de diálogos de múltiples rondas, destacamos las capacidades del procesamiento del lenguaje de visión de tiro cero y de pocos tiros orientado a la instrucción, enfatizando su versatilidad y apuntando a captar el interés de la comunidad multimodal en general. El código de implementación de demostración está disponible en el siguiente Repositorio GitHub.

Resumen de la solución

La solución VLP propuesta integra un conjunto de módulos de IA generativa de última generación para generar resultados multimodales precisos. Un elemento central de la arquitectura son los VLM y LLM optimizados, ambos fundamentales para decodificar flujos de datos visuales y textuales. El marco TGI sustenta la capa de inferencia del modelo y proporciona API RESTful para una integración sólida y una accesibilidad sin esfuerzo. Como complemento a nuestro procesamiento de datos auditivos, Whisper ASR también está equipado con una API RESTful, que permite conversiones optimizadas de voz a texto. Para abordar desafíos complejos como la segmentación de imagen a texto, utilizamos el contenedor Segmento conectado a tierra Cualquier cosa módulo, haciendo sinergia con el DINO conectado a tierra y Segmentar cualquier modelo (SAM) mecanismo para la detección y segmentación de objetos basados ​​en texto. El sistema se perfecciona aún más con DestilarBERT, optimizando nuestro proceso de clasificación multiclase guiado por diálogo. La orquestación de estos componentes es el proceso de procesamiento LangChain, un mecanismo sofisticado capaz de analizar entradas de texto o voz, discernir las intenciones del usuario y delegar metódicamente subtareas a los servicios relevantes. La síntesis de estas operaciones produce resultados agregados, que brindan respuestas multimodales precisas y conscientes del contexto.

El siguiente diagrama ilustra la arquitectura de nuestra solución VLP guiada por diálogo.

Inferencia de generación de texto

Text Generation Inference (TGI) es un conjunto de herramientas de código abierto desarrollado por Hugging Face para implementar LLM y VLM para inferencia. Permite la generación de texto de alto rendimiento utilizando paralelismo tensorial, paralelismo de modelos y procesamiento por lotes dinámico, compatible con algunos LLM de código abierto líderes como Falcon y Llama V2, así como VLM como IDEFICS. Utilizando los últimos módulos de Hugging Face LLM en Amazon SageMaker, Los clientes de AWS ahora pueden aprovechar el poder de los contenedores de aprendizaje profundo (DLC) de SageMaker. Esto permite la implementación perfecta de LLM desde los centros de Hugging Face a través de SageMaker prediseñado. DLCs apoyando a TGI. Esta configuración de inferencia no solo ofrece un rendimiento excepcional, sino que también elimina la necesidad de administrar la pesada infraestructura de GPU. Además, se beneficiará de funciones avanzadas como el escalado automático de puntos finales de inferencia, seguridad mejorada y monitoreo de modelos integrado.

TGI ofrece velocidades de generación de texto hasta 100 veces más rápidas que los métodos de inferencia tradicionales y se escala de manera eficiente para manejar mayores solicitudes. Su diseño garantiza la compatibilidad con varios LLM y, al ser de código abierto, democratiza las funciones avanzadas para la comunidad tecnológica. La versatilidad de TGI se extiende a todos los dominios, mejorando los chatbots, mejorando las traducciones automáticas, resumiendo textos y generando contenido diverso, desde poesía hasta código. Por lo tanto, TGI surge como una solución integral para los desafíos de generación de texto. TGI está implementado en Python y utiliza el marco PyTorch. Es de código abierto y está disponible en GitHub. También admite PEFT con QLoRA para un rendimiento más rápido y deformación logits para controlar los atributos del texto generado, como determinar su longitud y diversidad, sin modificar el modelo subyacente.

Puede crear un contenedor TGI Docker personalizado directamente desde lo siguiente Dockerfile y luego envíe la imagen del contenedor a Amazon Registro de contenedores elásticos (ECR) para el despliegue de inferencia. Vea el siguiente código:

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

Inferencia LLM con TGI

La solución VLP en esta publicación emplea el LLM junto con LangChain, aprovechando el enfoque de cadena de pensamiento (CoT) para una clasificación de intenciones más precisa. CoT procesa consultas para discernir la intención y activar subtareas asociadas para cumplir los objetivos de la consulta. llama-2-7b-chat-hf (acuerdo de licencia) es la versión simplificada de la línea Llama-2, diseñada para contextos de diálogo. La inferencia de Llama-2-7b-chat-hf se basa en la imagen del contenedor TGI, lo que la hace disponible como un servicio habilitado para API.

Para la inferencia de Llama-2-7b-chat-hf, se recomienda un g5.2xlarge (24G VRAM) para lograr el máximo rendimiento. Para aplicaciones que requieren un LLM más robusto, los modelos Llama-v2-13b encajan bien con una instancia g5.12xlarge (96G VRAM). Para los modelos Llama-2-70b, considere la GPU [2xlarge] – 2x Nvidia A100 que utiliza cuantificación de bits y bytes o el g5.48xlarge. En particular, el empleo de la cuantificación de bits y bytes puede reducir la VRAM de GPU de inferencia requerida en un 50 %.

Puede usar DLC de SageMaker con la imagen del contenedor TGI detallada anteriormente para implementar Llama-2-7b-chat-hf para inferencia (consulte el siguiente código). Alternativamente, puede realizar una inferencia local rápida para una prueba de concepto en una instancia g5.2xlarge utilizando un contenedor Docker.

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)

Afina y personaliza tu LLM

SageMaker JumpStart ofrece numerosos ejemplos de cuadernos que demuestran el uso de ajuste fino eficiente de parámetros (PEFT), incluido QLoRA para capacitación y ajuste de LLM. QLoRA mantiene los pesos del modelo previamente entrenado en un estado estático e introduce matrices de descomposición de rangos entrenables en cada capa de la estructura del Transformador. Este método reduce sustancialmente la cantidad de parámetros entrenables necesarios para las tareas posteriores.

Alternativamente, puedes explorar Optimización de preferencias directas (DPO), lo que elimina la necesidad de configurar un modelo de recompensa, extraer muestras durante el ajuste del LLM o realizar ajustes extensos de hiperparámetros. Investigaciones recientes han demostrado que el ajuste fino del DPO supera RLHF en la gestión de la generación de sentimientos y mejora la calidad de los resúmenes y las respuestas de conversaciones únicas, al mismo tiempo que es considerablemente más fácil de configurar y educar. Hay tres pasos principales para el proceso de capacitación de DPO (consulte GitHub repo para detalles):

1. Realice un ajuste supervisado de un LLM base previamente capacitado para crear un LLM ajustado.
2. Ejecute el entrenador de DPO utilizando el modelo ajustado para crear un modelo de aprendizaje por refuerzo.
3. Fusione los adaptadores de DPO en el modelo LLM base para la inferencia de generación de texto.

Puede implementar el modelo combinado para realizar inferencias utilizando la imagen del contenedor TGI.

modelo de lenguaje visual

Los modelos de lenguaje visual (VLM, por sus siglas en inglés) que combinan las modalidades de visión y lenguaje han demostrado su efectividad mejorada en la generalización, lo que lleva a varios casos de uso práctico con indicaciones de cero disparos o de pocos disparos con instrucciones. Un VLM normalmente consta de tres elementos clave: un codificador de imágenes, un codificador de texto y una estrategia para fusionar información de los dos codificadores. Estos elementos clave están estrechamente vinculados porque las funciones de pérdida están diseñadas en torno tanto a la arquitectura del modelo como a la estrategia de aprendizaje. Muchos VLM de última generación utilizan CLIP/ViT (como OpenCLIP) y LLM (como Llama-v1) y están capacitados en múltiples conjuntos de datos disponibles públicamente, como Wikipedia, LAION y Public Multimodal Dataset.

Esta demostración utilizó un pre-entrenado IDEFICS-9b-instrucción modelo desarrollado por AbrazandoCaraM4, una versión mejorada de IDEFICS-9b, que sigue el procedimiento de entrenamiento establecido en Flamingo combinando los dos modelos previamente entrenados (laion/CLIP-ViT-H-14-laion2B-s32B-b79K y huggyllama/llama-7b) con bloques transformadores modificados. El IDEFICS-9b se entrenó en conjuntos de datos multimodales OBELIC, Wikipedia, LAION y PMD con un total de 150 mil millones de tokens y 1.582 mil millones de imágenes con una resolución de 224 × 224 cada una. El IDEFICS-9b se basó en Llama-7b con un tamaño de lote efectivo de 1.31 millones. Luego, la instrucción IDEFICS-9b se perfeccionó con 6.8 millones de conjuntos de datos de instrucciones multimodales creados a partir del aumento utilizando IA generativa al descongelar todos los parámetros (codificador de visión, modelo de lenguaje, atenciones cruzadas). Los conjuntos de datos de ajuste incluyen los datos previos al entrenamiento con las siguientes proporciones de muestreo: 5.1% de pares de imagen-texto y 30.7% de documentos web multimodales OBELICS.

El software de capacitación se basa en Hugging Face Transformers y Accelerate, y Velocidad profunda ZeRO-3 para entrenamiento, además Conjunto de datos web y Conjuntos de datos de imagen2 para la carga de datos. El entrenamiento previo de IDEFICS-9b tardó 350 horas en 128 GPU Nvidia A100, mientras que el ajuste fino de IDEFICS-9b-instruct tardó 70 horas en 128 GPU Nvidia A100, ambas en instancias AWS p4.24xlarge.

Con SageMaker, puede implementar IDEFICS-9b-instruct sin problemas en una instancia g5.2xlarge para tareas de inferencia. El siguiente fragmento de código ilustra cómo lanzar un contenedor local de aprendizaje profundo personalizado integrado con la imagen personalizada de TGI Docker:

%%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) ¿Qué dispositivo produjo esta imagen? Explique el propósito clínico principal de dicha imagen. ¿Puede escribir un informe radiológico basado en esta imagen? ", 

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

Puede ajustar IDEFICS u otros VLM, incluidos Flamenco abierto con sus propios datos específicos de dominio con instrucciones. Consulte lo siguiente README para la preparación de conjuntos de datos multimodales y la guión de ajuste fino para más información.

Clasificación de intenciones con cadena de pensamiento.

Una imagen vale más que mil palabras, por lo tanto, VLM requiere orientación para generar un título preciso a partir de una imagen y una pregunta determinadas. Podemos utilizar indicaciones breves para permitir el aprendizaje en contexto, donde proporcionamos demostraciones en las indicaciones para guiar el modelo hacia un mejor rendimiento. Las demostraciones sirven como condicionamiento para ejemplos posteriores en los que nos gustaría que el modelo genere una respuesta.

Las indicaciones estándar de pocos intentos funcionan bien para muchas tareas, pero aún no son una técnica perfecta, especialmente cuando se trata de tareas de razonamiento más complejas. La plantilla de indicaciones de pocos intentos no es suficiente para obtener respuestas confiables. Podría ser útil dividir el problema en pasos y demostrárselo al modelo. Más recientemente, cadena de pensamiento (CoT) se ha popularizado para abordar tareas más complejas de aritmética, sentido común y razonamiento simbólico.

CoT elimina los esfuerzos manuales mediante el uso de LLM con un mensaje "Pensemos paso a paso" para generar cadenas de razonamiento para demostraciones una por una. Sin embargo, este proceso automático aún puede terminar con errores en las cadenas generadas. Para mitigar los efectos de los errores, importa la diversidad de las manifestaciones. Este post propone Auto-CoT, que muestrea preguntas con diversidad y genera cadenas de razonamiento para construir las demostraciones. CoT consta de dos etapas principales:

• Agrupación de preguntas: dividir las preguntas de un conjunto de datos determinado en unos pocos grupos
• Muestreo de demostración: seleccione una pregunta representativa de cada grupo y genere su cadena de razonamiento utilizando CoT de tiro cero con heurísticas simples.

Vea el siguiente fragmento de código:

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??")

Reconocimiento automático de voz

La solución VLP incorpora Whisper, un modelo de reconocimiento automático de voz (ASR) de OpenAI, para manejar consultas de audio. Whisper se puede implementar sin esfuerzo a través de SageMaker JumpStart usando su plantilla. SageMaker JumpStart, conocido por su configuración sencilla, alto rendimiento, escalabilidad y confiabilidad, es ideal para desarrolladores que buscan crear aplicaciones excepcionales basadas en voz. El siguiente GitHub repo demuestra cómo aprovechar Puntos finales de inferencia en tiempo real de SageMaker para ajustar y alojar Whisper para la transcripción instantánea de audio a texto, mostrando la sinergia entre el alojamiento de SageMaker y los modelos generativos.

Alternativamente, puede descargar directamente el Dockerfile.gpu de GitHub desarrollado por ahmetóner, que incluye una API RESTful preconfigurada. Luego puede construir una imagen de Docker y ejecutar el contenedor en un Amazon con GPU. Nube de computación elástica (EC2) instancia para una prueba rápida de concepto. Vea el siguiente código:

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

En el ejemplo proporcionado, se selecciona el puerto 8083 para alojar la API de Whisper, con las reglas de seguridad de la red entrante activadas. Para probar, dirija un navegador web a http://<IP_or_hostname>:8083/docs e iniciar una prueba de solicitud POST al punto final ASR. Como alternativa, ejecute el comando proporcionado o emplee el módulo susurro-live para verificar la conectividad API.

!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

Clasificación de texto multiclase y extracción de palabras clave.

La clasificación de clases múltiples juega un papel fundamental en la detección y segmentación de objetos basada en mensajes de texto. El distilbert-base-sin caja-finetuned-sst-2-inglés El modelo es un refinado punto de control de DistilBERT-base-sin carcasa, optimizado en el Banco de árboles de sentimientos de Stanford (SST2) conjunto de datos de Hugging Face. Este modelo logra una precisión del 91.3% en el conjunto de desarrollo, mientras que su contraparte bert-base-uncased cuenta con una precisión del 92.7%. Hugging Face Hub brinda acceso a más de 1,000 modelos de clasificación de texto previamente entrenados. Para quienes buscan mayor precisión, SageMaker JumpStart proporciona plantillas para ajustar DistilBERT utilizando conjuntos de datos anotados personalizados para tareas de clasificación más personalizadas.

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) 

El proceso de extracción de palabras clave emplea el claveBERT módulo, un método simplificado y fácil de usar que aprovecha las incrustaciones de BERT para generar palabras clave y frases clave estrechamente alineadas con un documento, en este caso, los objetos especificados en la consulta:

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

Detección y clasificación de objetos basada en mensajes de texto

La solución VLP emplea detección y segmentación de objetos guiada por diálogo analizando el significado semántico del texto e identificando la acción y los objetos a partir del mensaje de texto. SAM conectado a tierra es un paquete de código abierto creado por IDEA-Research para detectar y segmentar cualquier cosa de una imagen determinada con entradas de texto. Combina las fortalezas de DINO a tierra y Segment Anything para construir un canal muy poderoso para resolver problemas complejos.

La siguiente figura ilustra cómo Grounded-SAM puede detectar objetos y realizar la segmentación de instancias al comprender la entrada de texto.

SAM destaca como un modelo de segmentación robusto, aunque requiere indicaciones, como cuadros delimitadores o puntos, para producir máscaras de objetos de alta calidad. Grounding DINO sobresale como detector de disparo cero, creando hábilmente cajas y etiquetas de alta calidad mediante indicaciones de texto de formato libre. Cuando estos dos modelos se combinan, ofrecen la notable capacidad de detectar y segmentar cualquier objeto simplemente mediante entradas de texto. El script de la utilidad Python dino_sam_inpainting.py fue desarrollado para integrar métodos 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' # 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)

Puede elegir HQ-SAM para actualizar SAM y lograr una segmentación de disparo cero de alta calidad. Consulte lo siguiente y código muestra en GitHub para más detalles.

Canal de procesamiento VLP

El objetivo principal del proceso de procesamiento VLP es combinar las fortalezas de diferentes modelos, creando un flujo de trabajo sofisticado especializado para VLP. Es importante resaltar que esta configuración prioriza la integración de modelos de primer nivel en dominios visuales, de texto y de voz. Cada segmento de la tubería es modular, lo que facilita el uso independiente o la operación combinada. Además, el diseño garantiza flexibilidad, lo que permite la sustitución de componentes por modelos más avanzados aún por venir, al tiempo que admite subprocesos múltiples y manejo de errores con una implementación confiable.

La siguiente figura ilustra un flujo de datos de canalización de VLP y componentes de servicio.

En nuestra exploración del canal VLP, diseñamos uno que puede procesar tanto indicaciones de texto en formato de texto abierto como entradas de voz casuales desde micrófonos. El procesamiento de audio lo facilita Whisper, capaz de reconocimiento y traducción de voz multilingüe. Luego, el texto transcrito se canaliza a un módulo de clasificación de intenciones, que discierne la esencia semántica de las indicaciones. Esto funciona en conjunto con un motor CoT impulsado por LangChain, diseccionando la intención principal en subtareas más detalladas para una recuperación y generación de información más detallada. Si el procesamiento de la imagen se infiere a partir de la entrada, la canalización comienza un proceso de extracción de palabras clave, seleccionando las N palabras clave principales mediante referencias cruzadas de los objetos detectados en la imagen original. Posteriormente, estas palabras clave se enrutan al motor Grounded-SAM, que genera cuadros delimitadores. Estos cuadros delimitadores luego se suministran al modelo SAM, que crea máscaras de segmentación precisas, identificando cada instancia de objeto única en la imagen de origen. El paso final implica superponer las máscaras y los cuadros delimitadores sobre la imagen original, generando una imagen procesada que se presenta como una salida multimodal.

Cuando la consulta de entrada busca interpretar una imagen, el proceso contrata al LLM para organizar las subtareas y refinar la consulta con objetivos específicos. Posteriormente, el resultado se dirige a la API de VLM, acompañado de instrucciones breves, la URL de la imagen de entrada y el mensaje de texto reformulado. En respuesta, el VLM proporciona la salida textual. La canalización de VLP se puede implementar mediante una canalización de flujo de trabajo basada en Python o utilidades de orquestación alternativas. Dichos canales operan encadenando un conjunto secuencial de modelos sofisticados, que culminan en un procedimiento de modelado estructurado secuencialmente. La tubería se integra con el motor Gradio con fines de demostración:

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)

Limitaciones

El uso de modelos VLM previamente entrenados para VLP ha demostrado un potencial prometedor para la comprensión de imágenes. Junto con la detección y segmentación de objetos basada en el lenguaje, VLP puede producir resultados útiles con una calidad razonable. Sin embargo, VLP todavía presenta resultados inconsistentes, faltan detalles en las imágenes e incluso puede provocar alucinaciones. Además, los modelos pueden producir textos objetivamente incorrectos y no se debe confiar en ellos para producir información objetivamente precisa. Dado que ninguno de los modelos VLM, SAM o LLM previamente entrenados a los que se hace referencia ha sido entrenado o ajustado para aplicaciones de grado de producción de dominios específicos, esta solución no está diseñada para aplicaciones de misión crítica que podrían afectar los medios de vida o causar pérdidas materiales.

Con una ingeniería rápida, el modelo IDEFICS a veces puede reconocer detalles adicionales después de una sugerencia de texto; sin embargo, el resultado dista mucho de ser consistente y confiable. Puede ser persistente en el mantenimiento de imprecisiones y puede no poder o no querer hacer correcciones incluso cuando los usuarios las resaltan durante una conversación. Mejorar el modelo troncal integrando Swin-ViT y fusionándolo con modelos basados ​​en CNN como DualToken-ViT, junto con el entrenamiento utilizando modelos más avanzados como Llama-v2, podría abordar algunas de estas limitaciones.

Próximos pasos

La solución VLP está preparada para lograr un progreso notable. De cara al futuro, existen varias oportunidades clave para avanzar en las soluciones VLP:

• Priorice la integración de instrucciones dinámicas y sugerencias de aprendizaje breves. Estas mejoras permitirán una retroalimentación de IA más precisa.
• Los equipos de clasificación de intenciones deben centrar sus esfuerzos en perfeccionar el clasificador para captar intenciones matizadas y específicas del dominio a partir de indicaciones abiertas. Ser capaz de comprender las intenciones precisas de los usuarios será fundamental.
• Implemente un modelo de árbol de pensamientos de agentes en el proceso de razonamiento. Esta estructura permitirá pasos de razonamiento explícitos para completar subtareas.
• Poner a prueba iniciativas de ajuste en modelos líderes. Será fundamental adaptar los modelos VLM, LLM y SAM a industrias y casos de uso clave mediante ajustes.

Acknowledgment

Los autores extienden su agradecimiento a Vivek Madan y Ashish Rawat por sus valiosos comentarios y revisión de esta publicación.

Sobre los autores

alfredo shen es especialista sénior en inteligencia artificial y aprendizaje automático en AWS. Ha estado trabajando en Silicon Valley, ocupando cargos técnicos y gerenciales en diversos sectores, incluidos el de la salud, las finanzas y la alta tecnología. Es un investigador dedicado de AI/ML aplicado, que se concentra en CV, NLP y multimodalidad. Su trabajo ha sido exhibido en publicaciones como EMNLP, ICLR y Public Health.

Dra. Li Zhang es gerente técnico principal de productos para Amazon SageMaker JumpStart y los algoritmos integrados de Amazon SageMaker, un servicio que ayuda a los científicos de datos y profesionales del aprendizaje automático a comenzar a entrenar e implementar sus modelos, y utiliza el aprendizaje reforzado con Amazon SageMaker. Su trabajo anterior como miembro principal del personal de investigación e inventor maestro en IBM Research le ha valido el premio al artículo de prueba del tiempo en IEEE INFOCOM.

Dra. Changsha Ma es un especialista en IA/ML en AWS. Es tecnóloga con un doctorado en Ciencias de la Computación, una maestría en Psicología de la Educación y años de experiencia en ciencia de datos y consultoría independiente en AI/ML. Le apasiona investigar enfoques metodológicos para la inteligencia artificial y humana. Fuera del trabajo, le encanta hacer caminatas, cocinar, buscar comida, asesorar a estudiantes universitarios para que sean emprendedores y pasar tiempo con amigos y familiares.

XinHuang es un científico senior aplicado para los algoritmos integrados de Amazon SageMaker JumpStart y Amazon SageMaker. Se centra en el desarrollo de algoritmos escalables de aprendizaje automático. Sus intereses de investigación se encuentran en el área del procesamiento del lenguaje natural, el aprendizaje profundo explicable en datos tabulares y el análisis sólido de la agrupación de espacio-tiempo no paramétrica. Ha publicado muchos artículos en conferencias ACL, ICDM, KDD y Royal Statistical Society: Serie A.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/dialogue-guided-visual-language-processing-with-amazon-sagemaker-jumpstart/