Llama 3.2 Vision

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

Ejecute los modelos multimodales Llama 3.2 Vision de Meta para comprensión de imágenes en las GPU de CLORE.AI.

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

¿Por qué Llama 3.2 Vision?

• Multimodal - Comprende tanto texto como imágenes

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

• Versátil - OCR, preguntas y respuestas visuales, generación de subtítulos de imágenes, análisis de documentos

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

• Ecosistema Llama - Compatible con Ollama, vLLM, transformers

Variantes de modelo

Modelo	Parámetros	VRAM (FP16)	Contexto	Mejor para
Llama-3.2-11B-Vision	11B	24GB	128K	Uso general, GPU única
Llama-3.2-90B-Vision	90B	180GB	128K	Calidad máxima
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 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. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Requisitos de hardware

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 (Más fácil)

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

# Ejecutar interactivo
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)

# Crear prompt
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "¿Qué hay en esta imagen? Describe 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

# Describir una imagen
ollama run llama3.2-vision:11b "Describe esta imagen: /ruta/a/imagen.jpg"

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

Con la API de vLLM

from openai import OpenAI
import base64

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

# Codificar 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. Formatea como markdown."}
        ]
    }
]

Análisis de documentos

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

Preguntas y respuestas 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 para imágenes

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Escribe un subtítulo 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?"}
        ]
    }
]

# Procesar con múltiples 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})

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

    return results

# Procesar 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 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="Response"),
    title="Llama 3.2 Vision - Análisis de imágenes",
    description="Sube una imagen y hazle preguntas. Ejecutándose en CLORE.AI."
)

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

Rendimiento

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

Cuantización

4-bit 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 8GB 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	Mejor 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 CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

• Usa Spot órdenes para procesamiento por lotes

• Paga con CLORE tokens

• Use modelos cuantizados (4 bits) para desarrollo

Solución de problemas

Memoria insuficiente

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

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

Generación lenta

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

• Use bfloat16 en lugar de float32

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

• Use vLLM para mejor rendimiento

Imagen no cargando

from PIL import Image
import requests
from io import BytesIO

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

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

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

Token de HuggingFace requerido

# Establecer token para modelos con acceso restringido
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx

# O iniciar sesión
huggingface-cli login

Llama Vision vs 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
Multi-imagen	Sí	Limitado	Sí
Licencia	Llama 3.2	Apache 2.0	Proprietario

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

Próximos pasos

• LLaVA - Modelo de visión alternativo

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

• Ollama - Despliegue sencillo

• vLLM - Servir en producción