Aprenda cómo construir Llama 3.2-Vision localmente en un modo similar a un chat y explore sus habilidades multimodales en una computadora portátil Colab.
La integración de capacidades de visión con modelos de lenguaje grande (LLM) está revolucionando el campo de la visión por computadora a través de LLM multimodales (MLLM). Estos modelos combinan texto y entradas visuales, mostrando habilidades impresionantes en la comprensión y el razonamiento de imágenes. Si bien anteriormente solo se podía acceder a estos modelos a través de API, las opciones recientes de código abierto ahora permiten la ejecución local, lo que los hace más atractivos para entornos de producción.
En este tutorial, aprenderemos cómo chatear con nuestras imágenes utilizando el modelo de código abierto Llama 3.2-Vision, y te sorprenderá su OCR, comprensión de imágenes y capacidades de razonamiento. Todo el código se proporciona cómodamente en un práctico cuaderno de Colab.
Fondo
Llama, abreviatura de “Large Language Model Meta AI” es una serie de LLM avanzados desarrollados por Meta. Su último modelo, Llama 3.2, se presentó con capacidades de visión avanzadas. La variante de visión viene en dos tamaños: parámetros 11B y 90B, lo que permite la inferencia en dispositivos periféricos. Con una ventana de contexto de hasta 128k tokens y soporte para imágenes de alta resolución de hasta 1120×1120 píxeles, Llama 3.2 puede procesar información visual y textual compleja.
Arquitectura
La serie de modelos Llama son Transformers solo con decodificador. Llama 3.2-Vision está construido sobre un modelo de solo texto Llama 3.1 previamente entrenado. Utiliza una arquitectura Transformer auto-regresiva densa y estándar, que no se desvía significativamente de sus predecesores, Llama y Llama 2.
Para respaldar las tareas visuales, Llama 3.2 extrae vectores de representación de imágenes utilizando un codificador de visión previamente entrenado (ViT-H/14) e integra estas representaciones en el modelo de lenguaje congelado utilizando un adaptador de visión. El adaptador consta de una serie de capas de atención cruzada que permiten que el modelo se centre en partes específicas de la imagen que corresponden al texto que se está procesando. [1].
El adaptador está entrenado en pares texto-imagen para alinear representaciones de imágenes con representaciones de lenguaje. Durante el entrenamiento del adaptador, los parámetros del codificador de imágenes se actualizan, mientras que los parámetros del modelo de lenguaje permanecen congelados para preservar las capacidades del lenguaje existente.
Este diseño permite a Llama 3.2 sobresalir en tareas multimodales manteniendo su sólido rendimiento de solo texto. El modelo resultante demuestra capacidades impresionantes en tareas que requieren comprensión tanto de imágenes como de lenguaje, y permite a los usuarios comunicarse interactivamente con sus entradas visuales.
Con nuestra comprensión de la arquitectura de Llama 3.2, podemos sumergirnos en la implementación práctica. Pero primero, necesitamos hacer algunos preparativos.
Preparativos
Antes de ejecutar Llama 3.2 — Vision 11B en Google Colab, debemos hacer algunos preparativos:
- Configuración de GPU:
- Se recomienda una GPU de gama alta con al menos 22 GB de VRAM para una inferencia eficiente [2].
- Para usuarios de Google Colab: navegue hasta ‘Tiempo de ejecución’ > ‘Cambiar tipo de tiempo de ejecución’ > ‘GPU A100’. Tenga en cuenta que es posible que las GPU de alta gama no estén disponibles para los usuarios de Colab gratuitos.
2. Permisos de modelo:
- Solicitar acceso a los modelos Llama 3.2 aquí.
3. Configuración de cara de abrazo:
- Crea una cuenta de Hugging Face si aún no la tienes aquí.
- Genera un token de acceso desde tu cuenta de Hugging Face si no tienes uno, aquí.
- Para los usuarios de Google Colab, configure el token Hugging Face como una variable ambiental secreta llamada ‘HF_TOKEN’ en Google Colab Secrets.
4. Instale las bibliotecas necesarias.
Cargando el Modelo
Una vez que hayamos configurado el entorno y adquirido los permisos necesarios, usaremos la biblioteca Hugging Face Transformers para crear una instancia del modelo y su procesador asociado. El procesador es responsable de preparar las entradas para el modelo y formatear sus salidas.
model_id = "meta-llama/Llama-3.2-11B-Vision-Instruct"model = MllamaForConditionalGeneration.from_pretrained(
model_id,
torch_dtype=torch.bfloat16,
device_map="auto")
processor = AutoProcessor.from_pretrained(model_id)
Plantilla de chat esperada
Las plantillas de chat mantienen el contexto a través del historial de conversaciones al almacenar los intercambios entre el “usuario” (nosotros) y el “asistente” (el modelo de IA). El historial de conversaciones está estructurado como una lista de diccionarios llamados messagesdonde cada diccionario representa un único turno conversacional, que incluye respuestas tanto del usuario como del modelo. Los turnos de usuario pueden incluir entradas de imagen-texto o solo texto, con {"type": "image"} indicando una entrada de imagen.
Por ejemplo, después de algunas iteraciones de chat, el messages La lista podría verse así:
messages = [
{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": prompt1}]},
{"role": "assistant", "content": [{"type": "text", "text": generated_texts1}]},
{"role": "user", "content": [{"type": "text", "text": prompt2}]},
{"role": "assistant", "content": [{"type": "text", "text": generated_texts2}]},
{"role": "user", "content": [{"type": "text", "text": prompt3}]},
{"role": "assistant", "content": [{"type": "text", "text": generated_texts3}]}
]
Esta lista de mensajes se pasa posteriormente al apply_chat_template() Método para convertir la conversación en una única cadena tokenizable en el formato que espera el modelo.
Función principal
Para este tutorial proporcioné un chat_with_mllm Función que permite una conversación dinámica con Llama 3.2 MLLM. Esta función maneja la carga de imágenes, preprocesa tanto las imágenes como las entradas de texto, genera respuestas modelo y administra el historial de conversaciones para permitir interacciones en modo chat.
def chat_with_mllm (model, processor, prompt, images_path=[],do_sample=False, temperature=0.1, show_image=False, max_new_tokens=512, messages=[], images=[]):# Ensure list:
if not isinstance(images_path, list):
images_path = [images_path]
# Load images
if len (images)==0 and len (images_path)>0:
for image_path in tqdm (images_path):
image = load_image(image_path)
images.append (image)
if show_image:
display ( image )
# If starting a new conversation about an image
if len (messages)==0:
messages = [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": prompt}]}]
# If continuing conversation on the image
else:
messages.append ({"role": "user", "content": [{"type": "text", "text": prompt}]})
# process input data
text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(images=images, text=text, return_tensors="pt", ).to(model.device)
# Generate response
generation_args = {"max_new_tokens": max_new_tokens, "do_sample": True}
if do_sample:
generation_args["temperature"] = temperature
generate_ids = model.generate(**inputs,**generation_args)
generate_ids = generate_ids[:, inputs['input_ids'].shape[1]:-1]
generated_texts = processor.decode(generate_ids[0], clean_up_tokenization_spaces=False)
# Append the model's response to the conversation history
messages.append ({"role": "assistant", "content": [ {"type": "text", "text": generated_texts}]})
return generated_texts, messages, images
Chatea con Llama
- Ejemplo de imagen de mariposa
En nuestro primer ejemplo, charlaremos con Llama 3.2 sobre una imagen de una mariposa eclosionando. Dado que Llama 3.2-Vision no admite indicaciones con mensajes del sistema cuando se usan imágenes, agregaremos instrucciones directamente al mensaje del usuario para guiar las respuestas del modelo. Al establecer do_sample=True y temperature=0.2 permitimos una ligera aleatoriedad manteniendo la coherencia de la respuesta. Para una respuesta fija, puede configurar do_sample==False . El messages El parámetro, que contiene el historial de chat, está inicialmente vacío, como en el images parámetro.
instructions = "Respond concisely in one sentence."
prompt = instructions + "Describe the image."response, messages,images= chat_with_mllm ( model, processor, prompt,
images_path=[img_path],
do_sample=True,
temperature=0.2,
show_image=True,
messages=[],
images=[])
# Output: "The image depicts a butterfly emerging from its chrysalis,
# with a row of chrysalises hanging from a branch above it."
Como podemos ver, el resultado es preciso y conciso, lo que demuestra que el modelo entendió efectivamente la imagen.
Para la próxima iteración del chat, pasaremos un nuevo mensaje junto con el historial de chat (history) y el archivo de imagen (images). El nuevo mensaje está diseñado para evaluar la capacidad de razonamiento de Llama 3.2:
prompt = instructions + "What would happen to the chrysalis in the near future?"
response, messages, images= chat_with_mllm ( model, processor, prompt,
images_path=[img_path,],
do_sample=True,
temperature=0.2,
show_image=False,
messages=messages,
images=images)# Output: "The chrysalis will eventually hatch into a butterfly."
Continuamos este chat en el cuaderno de Colab proporcionado y obtuvimos la siguiente conversación:
La conversación resalta la capacidad de comprensión de imágenes del modelo al describir con precisión la escena. También demuestra sus habilidades de razonamiento al conectar lógicamente información para concluir correctamente qué pasará con la crisálida y explicar por qué algunas son marrones mientras que otras son verdes.
2. Ejemplo de imagen de meme
En este ejemplo, le mostraré al modelo un meme que creé yo mismo para evaluar las capacidades de OCR de Llama y determinar si comprende mi sentido del humor.
instructions = "You are a computer vision engineer with sense of humor."
prompt = instructions + "Can you explain this meme to me?"response, messages,images= chat_with_mllm ( model, processor, prompt,
images_path=[img_path,],
do_sample=True,
temperature=0.5,
show_image=True,
messages=[],
images=[])
Este es el meme de entrada:
Y esta es la respuesta de la modelo:
Como podemos ver, el modelo demuestra grandes capacidades de OCR y comprende el significado del texto en la imagen. En cuanto a su sentido del humor, ¿qué opinas? ¿Lo entendió? ¿Lo entendiste? ¡Quizás también debería trabajar en mi sentido del humor!
En este tutorial, aprendimos cómo construir el modelo Llama 3.2-Vision localmente y administrar el historial de conversaciones para interacciones similares a las de un chat, mejorando la participación del usuario. Exploramos las capacidades de disparo cero de Llama 3.2 y quedamos impresionados por su comprensión de la escena, su razonamiento y sus habilidades de OCR.
Se pueden aplicar técnicas avanzadas a Llama 3.2, como el ajuste de datos únicos o el uso de generación de recuperación aumentada (RAG) para fundamentar las predicciones y reducir las alucinaciones.
En general, este tutorial proporciona información sobre el campo en rápida evolución de los LLM multimodales y sus poderosas capacidades para diversas aplicaciones.
Felicitaciones por llegar hasta aquí. Haga clic en 👍x50 para mostrar su agradecimiento y aumentar la autoestima del algoritmo 🤓
¿Quieres aprender más?
[0] Código en el cuaderno Colab: enlace