Transformers documentation
Respuesta a preguntas visuales
Respuesta a preguntas visuales
Visual Question Answering (VQA) es la tarea de responder preguntas abiertas basándose en una imagen. La entrada de los modelos que admiten esta tarea suele ser una combinación de una imagen y una pregunta, y la salida es una respuesta expresada en lenguaje natural.
Algunos ejemplos de casos de uso destacados para VQA incluyen:
- Aplicaciones de accesibilidad para personas con discapacidad visual.
- Educación: formular preguntas sobre materiales visuales presentados en clases o libros de texto. VQA también puede utilizarse en exhibiciones de museos interactivos o sitios históricos.
- Atención al cliente y comercio electrónico: VQA puede mejorar la experiencia del usuario al permitirle hacer preguntas sobre los productos.
- Recuperación de imágenes: los modelos de VQA se pueden utilizar para recuperar imágenes con características específicas. Por ejemplo, el usuario puede preguntar «¿Hay un perro?» para encontrar todas las imágenes con perros a partir de un conjunto de imágenes.
En esta guía aprenderás a:
- Ajusta el afinamiento de un modelo de clasificación VQA, específicamente ViLT, en el conjunto de datos
Graphcore/vqa. - Usa tu ViLT afinado para la inferencia.
- Ejecuta inferencia de VQA sin ejemplos (zero-shot) con un modelo generativo, como BLIP-2.
Ajuste fino de ViLT
El modelo ViLT incorpora embeddings de texto en un Vision Transformer (ViT), lo que le permite tener un diseño minimalista para el preentrenamiento de visión y lenguaje (VLP). Este modelo puede utilizarse para varias tareas de nivel inferior. Para la tarea de VQA, se coloca una cabeza de clasificador en la parte superior (una capa lineal sobre el estado oculto final del token [CLS]) y se inicializa de forma aleatoria. De este modo, el Visual Question Answering se trata como un problema de clasificación.
Los modelos más recientes, como BLIP, BLIP-2 e InstructBLIP, tratan el VQA como una tarea generativa. Más adelante en esta guía, ilustramos cómo utilizarlos para inferencia de VQA en cero disparos.
Antes de comenzar, asegúrate de tener instaladas todas las bibliotecas necesarias.
pip install -q transformers datasets
Te animamos a compartir tu modelo con la comunidad. Inicia sesión en tu cuenta de Hugging Face para subirlo al 🤗 Hub. Cuando se te solicite, introduce tu token para iniciar sesión:
>>> from huggingface_hub import notebook_login
>>> notebook_login()Definamos el punto de control del modelo como una variable global.
>>> model_checkpoint = "dandelin/vilt-b32-mlm"Cargar los datos
Con fines ilustrativos, en esta guía utilizamos una muestra muy pequeña del conjunto de datos de respuesta a preguntas visuales anotadas Graphcore/vqa.
Puedes encontrar el conjunto de datos completo en 🤗 Hub.
Como alternativa al conjunto de datos Graphcore/vqa, puede descargar los mismos datos manualmente desde la página oficial del conjunto de datos VQA. Si prefiere seguir el tutorial con sus datos personalizados, consulte la guía Crear un conjunto de datos de imágenes en la documentación de 🤗 Datasets.
Carguemos los primeros 200 ejemplos de la división de validación y exploremos las características del conjunto de datos:
>>> from datasets import load_dataset
>>> dataset = load_dataset("Graphcore/vqa", split="validation[:200]")
>>> dataset
Dataset({
features: ['question', 'question_type', 'question_id', 'image_id', 'answer_type', 'label'],
num_rows: 200
})Veamos un ejemplo para comprender las características del conjunto de datos:
>>> dataset[0]
{'question': 'Where is he looking?',
'question_type': 'none of the above',
'question_id': 262148000,
'image_id': '/root/.cache/huggingface/datasets/downloads/extracted/ca733e0e000fb2d7a09fbcc94dbfe7b5a30750681d0e965f8e0a23b1c2f98c75/val2014/COCO_val2014_000000262148.jpg',
'answer_type': 'other',
'label': {'ids': ['at table', 'down', 'skateboard', 'table'],
'weights': [0.30000001192092896,
1.0,
0.30000001192092896,
0.30000001192092896]}}Las características relevantes para la tarea incluyen:
question: la pregunta que debe responderse a partir de la imagenimage_id: la ruta de la imagen a la que se refiere la preguntalabel: las anotaciones
Podemos eliminar el resto de las características, ya que no serán necesarias:
>>> dataset = dataset.remove_columns(['question_type', 'question_id', 'answer_type'])Como puede ver, la característica label contiene varias respuestas a la misma pregunta (llamadas ids aquí) recopiladas por diferentes anotadores humanos.
Esto se debe a que la respuesta a una pregunta puede ser subjetiva. En este caso, la pregunta es “¿hacia dónde está mirando?”. Algunas personas
la anotaron con “abajo”, otras con “hacia la mesa”, otra con “patineta”, etc.
Mira la imagen y considera qué respuesta darías:
>>> from PIL import Image
>>> image = Image.open(dataset[0]['image_id'])
>>> image
Debido a la ambigüedad de las preguntas y las respuestas, los conjuntos de datos como este se tratan como un problema de clasificación multietiqueta (ya que pueden ser válidas varias respuestas). Además, en lugar de crear simplemente un vector codificado one-hot, se crea una codificación suave, basada en el número de veces que una respuesta determinada apareció en las anotaciones.
Por ejemplo, en el ejemplo anterior, como la respuesta “down” se selecciona con mucha más frecuencia que las demás, tiene una puntuación (llamada weight en el conjunto de datos) de 1.0, y el resto de las respuestas tienen puntuaciones < 1.0.
Para instanciar el modelo más adelante con una cabeza de clasificación adecuada, creemos dos diccionarios: uno que mapea el nombre de la etiqueta a un entero y viceversa:
>>> import itertools
>>> labels = [item['ids'] for item in dataset['label']]
>>> flattened_labels = list(itertools.chain(*labels))
>>> unique_labels = list(set(flattened_labels))
>>> label2id = {label: idx for idx, label in enumerate(unique_labels)}
>>> id2label = {idx: label for label, idx in label2id.items()}Ahora que tenemos las correspondencias, podemos reemplazar las respuestas en formato de texto por sus ids y aplanar el conjunto de datos para facilitar el preprocesamiento posterior.
>>> def replace_ids(inputs):
... inputs["label"]["ids"] = [label2id[x] for x in inputs["label"]["ids"]]
... return inputs
>>> dataset = dataset.map(replace_ids)
>>> flat_dataset = dataset.flatten()
>>> flat_dataset.features
{'question': Value(dtype='string', id=None),
'image_id': Value(dtype='string', id=None),
'label.ids': Sequence(feature=Value(dtype='int64', id=None), length=-1, id=None),
'label.weights': Sequence(feature=Value(dtype='float64', id=None), length=-1, id=None)}Preprocesamiento de datos
El siguiente paso es cargar un procesador ViLT para preparar los datos de imagen y texto para el modelo. ViltProcessor encapsula un tokenizador BERT y un procesador de imágenes ViLT en un único procesador conveniente:
>>> from transformers import ViltProcessor
>>> processor = ViltProcessor.from_pretrained(model_checkpoint)Para preprocesar los datos, necesitamos codificar las imágenes y las preguntas usando ViltProcessor. El procesador utilizará
BertTokenizerFast para tokenizar el texto y crear input_ids, attention_mask y token_type_ids para los datos de texto.
En cuanto a las imágenes, el procesador aprovechará ViltImageProcessor para redimensionar y normalizar la imagen, y crear pixel_values y pixel_mask.
Todos estos pasos de preprocesamiento se realizan internamente; solo necesitamos llamar al processor. Sin embargo, aún debemos preparar las etiquetas objetivo. En esta representación, cada elemento corresponde a una respuesta posible (etiqueta). Para las respuestas correctas, el elemento contiene su puntuación (peso) respectiva, mientras que los elementos restantes se establecen en cero.
La siguiente función aplica el processor a las imágenes y preguntas y formatea las etiquetas tal como se describió anteriormente:
>>> import torch
>>> def preprocess_data(examples):
... image_paths = examples['image_id']
... images = [Image.open(image_path) for image_path in image_paths]
... texts = examples['question']
... encoding = processor(images, texts, padding="max_length", truncation=True, return_tensors="pt")
... for k, v in encoding.items():
... encoding[k] = v.squeeze()
... targets = []
... for labels, scores in zip(examples['label.ids'], examples['label.weights']):
... target = torch.zeros(len(id2label))
... for label, score in zip(labels, scores):
... target[label] = score
... targets.append(target)
... encoding["labels"] = targets
... return encodingPara aplicar la función de preprocesamiento a todo el conjunto de datos, utiliza la función map de 🤗 Datasets. Puedes acelerar map estableciendo batched=True para procesar varios elementos del conjunto de datos a la vez. En este punto, puedes eliminar las columnas que no necesites.
>>> processed_dataset = flat_dataset.map(preprocess_data, batched=True, remove_columns=['question','question_type', 'question_id', 'image_id', 'answer_type', 'label.ids', 'label.weights'])
>>> processed_dataset
Dataset({
features: ['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values', 'pixel_mask', 'labels'],
num_rows: 200
})Como paso final, cree un lote de ejemplos usando DefaultDataCollator:
>>> from transformers import DefaultDataCollator
>>> data_collator = DefaultDataCollator()Entrenar el modelo
¡Ya está listo para comenzar a entrenar su modelo! Cargue ViLT con ViltForQuestionAnswering. Especifique el número de etiquetas junto con los mapeos de etiquetas:
>>> from transformers import ViltForQuestionAnswering
>>> model = ViltForQuestionAnswering.from_pretrained(model_checkpoint, num_labels=len(id2label), id2label=id2label, label2id=label2id)En este punto, solo quedan tres pasos:
- Defina los hiperparámetros de entrenamiento en TrainingArguments:
>>> from transformers import TrainingArguments
>>> repo_id = "MariaK/vilt_finetuned_200"
>>> training_args = TrainingArguments(
... output_dir=repo_id,
... per_device_train_batch_size=4,
... num_train_epochs=20,
... save_steps=200,
... logging_steps=50,
... learning_rate=5e-5,
... save_total_limit=2,
... remove_unused_columns=False,
... push_to_hub=True,
... )- Pasa los argumentos de entrenamiento a Trainer junto con el modelo, el conjunto de datos, el procesador y el data collator.
>>> from transformers import Trainer
>>> trainer = Trainer(
... model=model,
... args=training_args,
... data_collator=data_collator,
... train_dataset=processed_dataset,
... processing_class=processor,
... )- Llama a train() para ajustar tu modelo.
>>> trainer.train()Una vez completado el entrenamiento, comparte tu modelo en el Hub con el método push_to_hub() para compartir tu modelo final en el 🤗 Hub:
>>> trainer.push_to_hub()Inferencia
Ahora que has ajustado un modelo ViLT y lo has subido al 🤗 Hub, puedes usarlo para inferencia.
- Toma una imagen y una pregunta, y prepáralas para el modelo usando el procesador de tu modelo.
- Pase el resultado o el preprocesamiento a través del modelo.
- A partir de los logits, obtén el id de la respuesta más probable y busca la respuesta real en
id2label.
>>> processor = ViltProcessor.from_pretrained("MariaK/vilt_finetuned_200")
>>> image = Image.open(example['image_id'])
>>> question = example['question']
>>> # prepare inputs
>>> inputs = processor(image, question, return_tensors="pt")
>>> model = ViltForQuestionAnswering.from_pretrained("MariaK/vilt_finetuned_200")
>>> # forward pass
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> logits = outputs.logits
>>> idx = logits.argmax(-1).item()
>>> print("Predicted answer:", model.config.id2label[idx])
Predicted answer: downVQA sin ejemplos
El modelo anterior trataba la VQA como una tarea de clasificación. Algunos modelos recientes, como BLIP, BLIP-2 e InstructBLIP, abordan la VQA como una tarea generativa. Tomemos BLIP-2 como ejemplo. Introdujo un nuevo paradigma de preentrenamiento visual-lingüístico en el que se puede utilizar cualquier combinación de codificador visual preentrenado y LLM (más información en la publicación de blog de BLIP-2). Esto permite obtener resultados de última generación en múltiples tareas visuales-lingüísticas, incluida la respuesta a preguntas visuales.
Ilustremos cómo se puede usar este modelo para VQA. Primero, carguemos el modelo. Aquí enviaremos el modelo explícitamente a una GPU, si está disponible, algo que no fue necesario hacer al entrenar, ya que Trainer lo gestiona automáticamente:
>>> from transformers import AutoProcessor, Blip2ForConditionalGeneration
from accelerate import Accelerator
>>> import torch
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip2-opt-2.7b")
>>> model = Blip2ForConditionalGeneration.from_pretrained("Salesforce/blip2-opt-2.7b", dtype=torch.float16)
>>> device = Accelerator().device
>>> model.to(device)El modelo toma una imagen y un texto como entrada, así que usemos el mismo par de imagen/pregunta del primer ejemplo del conjunto de datos VQA:
>>> example = dataset[0]
>>> image = Image.open(example['image_id'])
>>> question = example['question']Para usar BLIP-2 en la tarea de respuesta a preguntas visuales, el prompt de texto debe seguir un formato específico: Question: {} Answer:.
>>> prompt = f"Question: {question} Answer:"Ahora necesitamos preprocesar la imagen/prompt con el procesador del modelo, pasar la entrada procesada a través del modelo y decodificar la salida:
>>> inputs = processor(image, text=prompt, return_tensors="pt").to(device, torch.float16)
>>> generated_ids = model.generate(**inputs, max_new_tokens=10)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
"He is looking at the crowd"Como puede verse, el modelo reconoció a la multitud y la dirección de la cara (mirando hacia abajo); sin embargo, parece no captar que la multitud está detrás del patinador. Aun así, en casos donde no es viable adquirir conjuntos de datos anotados por humanos, este enfoque puede producir resultados útiles rápidamente.
Update on GitHub