Provocando modelos de lenguaje de visión. Explorando técnicas para solicitar VLMS | por Anand Subramanian | Enero de 2025

En general, un modelo de detección de objetos está entrenado con un vocabulario fijo, lo que significa que solo puede reconocer un conjunto predefinido de categorías de objetos. Sin embargo, en nuestra tubería, dado que no podemos predecir de antemano qué objetos aparecerán en la imagen, necesitamos un modelo de detección de objetos que sea versátil y capaz de reconocer una amplia gama de clases de objetos. Para lograr esto, uso el modelo OWL-VIT [11]un modelo de detección de objetos de vocabulario abierto. Este modelo requiere indicaciones de texto que especifican los objetos que se detectarán.

Otro desafío que debe abordarse es obtener una idea de alto nivel de los objetos presentes en la imagen antes de utilizar el modelo OWL-VIT, ya que requiere un mensaje de texto que describe los objetos. ¡Aquí es donde vlms vienen al rescate! Primero, pasamos la imagen al VLM con un mensaje para identificar los objetos de alto nivel en la imagen. Estos objetos detectados se usan como indicaciones de texto, junto con la imagen, para que el modelo OWL-VIT genere detecciones. A continuación, trazamos las detecciones como cajas delimitadoras en la misma imagen y pasamos esta imagen actualizada al VLM, lo que lo solicita a generar un título. El código de inferencia se adapta parcialmente de [12].

# Load model directly
from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection
processor = AutoProcessor.from_pretrained("google/owlvit-base-patch32")
model = AutoModelForZeroShotObjectDetection.from_pretrained("google/owlvit-base-patch32")

Detecto los objetos presentes en cada imagen usando el VLM:

IMAGE_QUALITY = "high"
system_prompt_object_detection = """You are provided with an image. You must identify all important objects in the image, and provide a standardized list of objects in the image.
Return your output as follows:
Output: object_1, object_2"""
user_prompt = "Extract the objects from the provided image:"
detected_objects = process_images_in_parallel(image_paths, system_prompt=system_prompt_object_detection, user_prompt=user_prompt, model = "gpt-4o-mini", few_shot_prompt= None, detail=IMAGE_QUALITY, max_workers=5)

detected_objects_cleaned = {}
for key, value in detected_objects.items():
detected_objects_cleaned[key] = list(set([x.strip() for x in value.replace("Output: ", "").split(",")]))

Los objetos detectados ahora se pasan como un texto que solicita al modelo OWL-VIT para obtener las predicciones para las imágenes. Implemento una función de ayuda que predice los cuadros delimitadores para las imágenes, y luego traza el cuadro delimitador en la imagen original.

from PIL import Image, ImageDraw, ImageFont
import numpy as np
import torch
def detect_and_draw_bounding_boxes(
image_path,
text_queries,
model,
processor,
output_path,
score_threshold=0.2
):
"""
Detect objects in an image and draw bounding boxes over the original image using PIL.
Parameters:
- image_path (str): Path to the image file.
- text_queries (list of str): List of text queries to process.
- model: Pretrained model to use for detection.
- processor: Processor to preprocess image and text queries.
- output_path (str): Path to save the output image with bounding boxes.
- score_threshold (float): Threshold to filter out low-confidence predictions.
Returns:
- output_image_pil: A PIL Image object with bounding boxes and labels drawn.
"""
img = Image.open(image_path).convert("RGB")
orig_w, orig_h = img.size  # original width, height
inputs = processor(
text=text_queries,
images=img,
return_tensors="pt",
padding=True,
truncation=True
).to("cpu")
model.eval()
with torch.no_grad():
outputs = model(**inputs)
logits = torch.max(outputs["logits"][0], dim=-1)       # shape (num_boxes,)
scores = torch.sigmoid(logits.values).cpu().numpy()    # convert to probabilities
labels = logits.indices.cpu().numpy()                  # class indices
boxes_norm = outputs["pred_boxes"][0].cpu().numpy()    # shape (num_boxes, 4)
converted_boxes = []
for box in boxes_norm:
cx, cy, w, h = box
cx_abs = cx * orig_w
cy_abs = cy * orig_h
w_abs  = w  * orig_w
h_abs  = h  * orig_h
x1 = cx_abs - w_abs / 2.0
y1 = cy_abs - h_abs / 2.0
x2 = cx_abs + w_abs / 2.0
y2 = cy_abs + h_abs / 2.0
converted_boxes.append((x1, y1, x2, y2))
draw = ImageDraw.Draw(img)
for score, (x1, y1, x2, y2), label_idx in zip(scores, converted_boxes, labels):
if score < score_threshold:
continue
draw.rectangle([x1, y1, x2, y2], outline="red", width=3)
label_text = text_queries[label_idx].replace("An image of ", "")
text_str = f"{label_text}: {score:.2f}"
text_size = draw.textsize(text_str)  # If no font used, remove "font=font"
text_x, text_y = x1, max(0, y1 - text_size[1])  # place text slightly above box
draw.rectangle(
[text_x, text_y, text_x + text_size[0], text_y + text_size[1]],
fill="white"
)
draw.text((text_x, text_y), text_str, fill="red")  # , font=font)
img.save(output_path, "JPEG")
return img

for key, value in tqdm(detected_objects_cleaned.items()):
value = ["An image of " + x for x in value]
detect_and_draw_bounding_boxes(key, value, model, processor, "images_with_bounding_boxes/" + key.split("/")[-1], score_threshold=0.15)

Las imágenes con los objetos detectados trazados ahora se pasan al VLM para subtítulos:

IMAGE_QUALITY = "high"
image_paths_obj_detected_guided = [x.replace("downloaded_images", "images_with_bounding_boxes") for x in image_paths] 
system_prompt="""You are a helpful assistant that can analyze images and provide captions. You are provided with images that also contain bounding box annotations of the important objects in them, along with their labels.
Analyze the overall image and the provided bounding box information and provide an appropriate caption for the image.""",
user_prompt="Please analyze the following image:",
obj_det_zero_shot_high_quality_captions = process_images_in_parallel(image_paths_obj_detected_guided, model = "gpt-4o-mini", few_shot_prompt= None, detail=IMAGE_QUALITY, max_workers=5)

En esta tarea, dada la naturaleza simple de las imágenes que utilizamos, la ubicación de los objetos no agrega ninguna información significativa al VLM. Sin embargo, la solicitud guiada por detección de objetos puede ser una herramienta poderosa para tareas más complejas, como la comprensión de los documentos, donde la información de diseño se puede proporcionar de manera efectiva a través de la detección de objetos al VLM para su posterior procesamiento. Además, la segmentación semántica se puede emplear como un método para guiar la solicitud al proporcionar máscaras de segmentación al VLM.

Los VLM son una herramienta poderosa en el arsenal de ingenieros y científicos de IA para resolver una variedad de problemas que requieren una combinación de habilidades de visión y texto. En este artículo, exploro las estrategias de incorporación en el contexto de VLMS para usar de manera efectiva estos modelos para tareas como el subtiteo de imágenes. Esta de ninguna manera es una lista exhaustiva o completa de estrategias de solicitud. Una cosa que se ha vuelto cada vez más clara con los avances en Genai es el potencial ilimitado para enfoques creativos e innovadores para solicitar y guiar a LLM y VLM para resolver tareas.

[1] J. Chen, H. Guo, K. Yi, B. Li y M. Elhoseiny, “VisualGPT: adaptación eficiente de datos de modelos de lenguaje previos a la pretrada para el subtítulos de imágenes”, 2022 Conferencia IEEE/CVF sobre visión por computadora y reconocimiento de patrones (CVPR)Nueva Orleans, LA, EE. UU., 2022, pp. 18009–18019, doi: 10.1109/CVPR52688.2022.01750.

[2] Luo, Z., Xi, Y., Zhang, R. y Ma, J. (2022). Un enfoque frustrantemente simple para la subtítulos de imágenes de extremo a extremo.

[3] Jean-Baptiste Alayrac, Jeff Donahue, Pauline Luc, Antoine Miech, Iain Barr, Yana Hasson, Karel Lenc, Arthur Mensch, Katie Millicah, Malcolm Reynolds, Roman Ring, Eliza Rutherford, Serkan, Tengda Han, Zhitao Gong, Sina Samangaoee, Marianne Monteiro, Jacob Menick, Sebastian Borgeaud, Andrew Brock, Aida Nematzadeh, Sahand Sharifzadeh, Mikolaj Binkowski, Ricardo Barreira, Oriol Vinyals, Andrew Zisserman y Karen Simonyan. 2022. Flamingo: un modelo de lenguaje visual para el aprendizaje de pocos disparos. En Actas de la 36ª Conferencia Internacional sobre Sistemas de Procesamiento de Información Neural (NIPS ’22). Curran Associates Inc., Red Hook, NY, EE. UU., Artículo 1723, 23716–23736.

[4] https://huggingface.co/blog/visision_language_preetraining

[5] Piyush Sharma, Nan Ding, Sebastian Goodman y Radu Soricut. 2018. Subtítulos conceptuales: un conjunto de datos de texto alternativo limpio, hipernedmado e de imagen para subtítulos de imágenes automáticas. En Actas de la 56ª Reunión Anual de la Asociación de Lingüística Computacional (Volumen 1: Documentos largos)páginas 2556–2565, Melbourne, Australia. Asociación de Lingüística Computacional.

[6] https://platform.openai.com/docs/guides/Vision

[7] Chin-Yew Lin. 2004. Rouge: un paquete para la evaluación automática de resúmenes. En Se ramifican las ramas de resumen de textopáginas 74–81, Barcelona, ​​España. Asociación de Lingüística Computacional.

[8]https://docs.ragas.io/en/stable/concepts/metrics/available_metrics/traditional/#rouge-score

[9] Wei, J., Wang, X., Schuurmans, D., Bosma, M., Xia, F., Chi, E., … y Zhou, D. (2022). La provisión de cadena de pensamiento provoca un razonamiento en modelos de idiomas grandes. Avances en los sistemas de procesamiento de información neural, 3524824–24837.

[10] https://aws.amazon.com/blogs/machine-letarning/foundational-vision-models-and-visual-prompt-ingineering-for-autonomous-driving-applications/

[11] Matthias Minderer, Alexey Gritsenko, Austin Stone, Maxim Neumann, Dirk Weissenborn, Alexey Dosovitskiy, Aravindh Mahendran, Anurag Arnab, Mostafa Dehghani, Zhuoran Shen, Xiao Wang, Xiaohua Zhai, Thomas Kipf y Neil Hoúlby. 2022. Detección simple de objetos de vocabulario abierto. En Vision Computer-ECCV 2022: 17ª Conferencia Europea, Tel Aviv, Israel, 23-27 de octubre de 2022, Actas, Parte X. Springer-Verlag, Berlín, Heidelberg, 728–755. https://doi.org/10.1007/978-3-031-20080-9_42

[12]https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/zeroshot_object_detection_with_owlvit.ipynb

[13] https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/gpt-4-v-prompt-ingineering