Llama 3.2 Vision

Ejecuta Llama 3.2 Vision de Meta para comprensión de imágenes en Clore.ai

Ejecuta los modelos multimodales Llama 3.2 Vision de Meta para la comprensión de imágenes en GPUs de CLORE.AI.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

¿Por qué Llama 3.2 Vision?

• Multimodal - Entiende tanto texto como imágenes

• Múltiples tamaños - Versiones de parámetros 11B y 90B

• Versátil - OCR, QA visual, descripción de imágenes, análisis de documentos

• Pesos abiertos - Completamente de código abierto de Meta

• Ecosistema Llama - Compatible con Ollama, vLLM, transformers

Variantes del modelo

Modelo	Parámetros	VRAM (FP16)	Contexto	Ideal para
Llama-3.2-11B-Vision	11B	24GB	128K	Uso general, una sola GPU
Llama-3.2-90B-Vision	90B	180GB	128K	Máxima calidad
Llama-3.2-11B-Vision-Instruct	11B	24GB	128K	Chat/asistente
Llama-3.2-90B-Vision-Instruct	90B	180GB	128K	Producción

Despliegue rápido en CLORE.AI

Imagen de Docker:

vllm/vllm-openai:latest

Puertos:

22/tcp
8000/http

Comando:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.2-11B-Vision-Instruct \\
    --host 0.0.0.0 \\
    --port 8000 \\
    --max-model-len 8192

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis pedidos:

1. Ve a Mis pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (p. ej., abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

Requisitos de hardware

Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai. Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

Modelo	GPU mínima	Recomendado	Óptimo
11B Vision	RTX 4090 24GB	A100 40GB	A100 80GB
90B Vision	4x A100 40GB	4x A100 80GB	8x H100

Instalación

Usando Ollama (lo más fácil)

# Descarga el modelo
ollama pull llama3.2-vision:11b

# Ejecuta de forma interactiva
ollama run llama3.2-vision:11b

Usando vLLM

pip install vllm

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.2-11B-Vision-Instruct \\
    --host 0.0.0.0 \\
    --port 8000

Usando Transformers

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor

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)

Uso básico

Comprensión de imágenes

import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor
from PIL import Image
import requests

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)

# Cargar imagen
url = "https://example.com/image.jpg"
image = Image.open(requests.get(url, stream=True).raw)

# Crea el prompt
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "¿Qué hay en esta imagen? Descríbelo en detalle."}
        ]
    }
]

input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=500)
print(processor.decode(output[0], skip_special_tokens=True))

Con Ollama

# Describe una imagen
ollama run llama3.2-vision:11b "Describe esta imagen: /path/to/image.jpg"

# O usa la API
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2-vision:11b",
  "prompt": "¿Qué hay en esta imagen?",
  "images": ["base64_encoded_image_here"]
}'

Con la API de vLLM

from openai import OpenAI
import base64

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="no necesario"
)

# Codifica la imagen a base64
with open("image.jpg", "rb") as f:
    image_base64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="meta-llama/Llama-3.2-11B-Vision-Instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "¿Qué hay en esta imagen?"},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"}
                }
            ]
        }
    ],
    max_tokens=500
)

print(response.choices[0].message.content)

Casos de uso

OCR / Extracción de texto

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Extrae todo el texto de esta imagen. Dale formato como markdown."}
        ]
    }
]

Análisis de documentos

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Analiza este documento. Resume los puntos clave."}
        ]
    }
]

Respuesta a preguntas visuales

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "¿Cuántas personas hay en esta foto? ¿Qué están haciendo?"}
        ]
    }
]

Generación de subtítulos de imagen

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Escribe un pie de foto detallado para esta imagen adecuado para redes sociales."}
        ]
    }
]

Código a partir de capturas de pantalla

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Convierte esta captura de pantalla de la interfaz en código HTML/CSS."}
        ]
    }
]

Múltiples imágenes

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "image"},
            {"type": "text", "text": "Compara estas dos imágenes. ¿Cuáles son las diferencias?"}
        ]
    }
]

# Procesa con varias imágenes
inputs = processor(
    images=[image1, image2],
    text=input_text,
    return_tensors="pt"
).to(model.device)

Procesamiento por lotes

import os
from PIL import Image

def process_images(image_paths, prompt):
    results = []

    for path in image_paths:
        image = Image.open(path)

        messages = [
            {
                "role": "user",
                "content": [
                    {"type": "image"},
                    {"type": "text", "text": prompt}
                ]
            }
        ]

        input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
        inputs = processor(image, input_text, return_tensors="pt").to(model.device)

        output = model.generate(**inputs, max_new_tokens=300)
        result = processor.decode(output[0], skip_special_tokens=True)

        results.append({"file": path, "description": result})

        # Limpia la caché entre imágenes
        torch.cuda.empty_cache()

    return results

# Procesa la carpeta
images = [f"./images/{f}" for f in os.listdir("./images") if f.endswith(('.jpg', '.png'))]
results = process_images(images, "Describe esta imagen en un párrafo.")

Interfaz de Gradio

import gradio as gr
import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor
from PIL import Image

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)

def analyze_image(image, question):
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "image"},
                {"type": "text", "text": question}
            ]
        }
    ]

    input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
    inputs = processor(image, input_text, return_tensors="pt").to(model.device)

    output = model.generate(**inputs, max_new_tokens=500)
    return processor.decode(output[0], skip_special_tokens=True)

demo = gr.Interface(
    fn=analyze_image,
    inputs=[
        gr.Image(type="pil", label="Subir imagen"),
        gr.Textbox(label="Pregunta", placeholder="¿Qué hay en esta imagen?")
    ],
    outputs=gr.Textbox(label="Respuesta"),
    title="Llama 3.2 Vision - Análisis de imágenes",
    description="Sube una imagen y haz preguntas sobre ella. Ejecutándose en CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Rendimiento

Tarea	Modelo	GPU	Tiempo
Descripción de una sola imagen	11B	RTX 4090	~3s
Descripción de una sola imagen	11B	A100 40GB	~2s
OCR (1 página)	11B	RTX 4090	~5 s
Análisis de documentos	11B	A100 40GB	~8s
Lote (10 imágenes)	11B	A100 40GB	~25 s

Cuantización

4 bits con bitsandbytes

from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16
)

model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    quantization_config=quantization_config,
    device_map="auto"
)

GGUF con Ollama

# Cuantizado a 4 bits (cabe en 8 GB de VRAM)
ollama pull llama3.2-vision:11b-q4_K_M

# Cuantizado a 8 bits
ollama pull llama3.2-vision:11b-q8_0

Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

GPU	Tarifa por hora	Ideal para
RTX 4090 24GB	~$0.10	modelo 11B
A100 40GB	~$0.17	11B con contexto largo
A100 80GB	~$0.25	11B óptimo
4x A100 80GB	~$1.00	modelo 90B

Los precios varían. Consulta Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa Spot órdenes para procesamiento por lotes

• Paga con CLORE tokens

• Usa modelos cuantizados (4 bits) para desarrollo

Solución de problemas

Sin memoria

# Usar cuantización de 4 bits
model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    load_in_4bit=True,
    device_map="auto"
)

# O reduce max_new_tokens
output = model.generate(**inputs, max_new_tokens=256)

Generación lenta

• Asegúrate de que se esté usando la GPU (comprueba nvidia-smi)

• Usa bfloat16 en lugar de float32

• Reduce la resolución de la imagen antes de procesarla

• Usa vLLM para obtener un mejor rendimiento

La imagen no se carga

from PIL import Image
import requests
from io import BytesIO

# Desde una URL
response = requests.get(url)
image = Image.open(BytesIO(response.content)).convert("RGB")

# Desde un archivo
image = Image.open("path/to/image.jpg").convert("RGB")

# Redimensiona si es demasiado grande
max_size = 1024
if max(image.size) > max_size:
    image.thumbnail((max_size, max_size))

Se requiere token de HuggingFace

# Establece el token para modelos con acceso restringido
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx

# O inicia sesión
huggingface-cli login

Llama Vision frente a otros

Función	Llama 3.2 Vision	LLaVA 1.6	GPT-4V
Parámetros	11B / 90B	7B / 34B	Desconocido
Código abierto	Sí	Sí	No
Calidad de OCR	Excelente	Bueno	Excelente
Contexto	128K	32K	128K
Múltiples imágenes	Sí	Limitado	Sí
Licencia	Llama 3.2	Apache 2.0	Propietario

Usa Llama 3.2 Vision cuando:

• Necesitas multimodal de código abierto

• OCR y análisis de documentos

• Integración con el ecosistema Llama

• Comprensión de contexto largo

Siguientes pasos

• LLaVA - Modelo de visión alternativo

• Florence-2 - Modelo de visión de Microsoft

• Ollama - Despliegue fácil

• vLLM - Servicio en producción