Florence-2

Microsoft Florence-2 para subtitulado, detección y segmentación

El potente modelo visual de Microsoft para subtitulado, detección, segmentación y más.

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

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

Alquilar en CLORE.AI

1. Visita CLORE.AI Marketplace

2. Filtrar por tipo de GPU, VRAM y precio

3. Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)

4. Configura tu pedido:

   • Selecciona imagen Docker

   • Establece puertos (TCP para SSH, HTTP para interfaces web)

   • Agrega variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera el despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis Pedidos

• Interfaces web: Usa la URL del puerto HTTP

• SSH: ssh -p <port> root@<proxy-address>

¿Qué es Florence-2?

Florence-2 de Microsoft es un modelo base de visión que maneja:

• Generación de subtítulos para imágenes (breve y detallado)

• Detección y localización de objetos

• Subtitulado denso de regiones

• Comprensión de expresiones referenciales

• OCR y reconocimiento de texto

• Respuesta visual a preguntas

Recursos

• HuggingFace: microsoft/Florence-2-large

• Artículo: Artículo de Florence-2

• GitHub: microsoft/Florence-2

• Demostración: Espacio de HuggingFace

Hardware recomendado

Componente	Mínimo	Recomendado	Óptimo
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	8GB	12GB	16GB
CPU	4 núcleos	8 núcleos	16 núcleos
RAM	16GB	32GB	64GB
Almacenamiento	30GB SSD	50GB NVMe	100GB NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Despliegue rápido en CLORE.AI

Imagen Docker:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Puertos:

22/tcp
7860/http

Comando:

pip install transformers accelerate einops timm gradio && \
python -c "
import gradio as gr
from transformers import AutoProcessor, AutoModelForCausalLM
import torch
from PIL import Image

model = AutoModelForCausalLM.from_pretrained('microsoft/Florence-2-large', torch_dtype=torch.float16, trust_remote_code=True).to('cuda')
processor = AutoProcessor.from_pretrained('microsoft/Florence-2-large', trust_remote_code=True)

def process(image, task):
    inputs = processor(text=task, images=image, return_tensors='pt').to('cuda', torch.float16)
    generated_ids = model.generate(input_ids=inputs['input_ids'], pixel_values=inputs['pixel_values'], max_new_tokens=1024)
    result = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
    return processor.post_process_generation(result, task=task, image_size=image.size)

gr.Interface(fn=process, inputs=[gr.Image(type='pil'), gr.Dropdown(['<CAPTION>', '<DETAILED_CAPTION>', '<OD>'])], outputs='json').launch(server_name='0.0.0.0')
"

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.

Instalación

pip install transformers accelerate einops timm
pip install flash-attn --no-build-isolation  # Opcional, para inferencia más rápida

Lo que puedes crear

Análisis de contenido

• Generar descripciones de imágenes automáticamente

• Extraer texto de imágenes (OCR)

• Analizar contenido visual a gran escala

Anotación de datos

• Etiquetar conjuntos de datos automáticamente con subtítulos

• Generar cuadros delimitadores para objetos

• Crear anotaciones densas

Accesibilidad

• Generar texto alternativo para imágenes

• Describir imágenes para personas con discapacidad visual

• Crear descripciones de audio

Búsqueda y descubrimiento

• Indexar imágenes por contenido

• Construir sistemas de búsqueda visual

• Moderación de contenido

Procesamiento de documentos

• Extraer texto de documentos

• Entender gráficos y diagramas

• Procesar materiales escaneados

Uso básico

Generación de subtítulos para imágenes

from transformers import AutoProcessor, AutoModelForCausalLM
from PIL import Image
import torch

model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-large",
    torch_dtype=torch.float16,
    trust_remote_code=True
).to("cuda")

processor = AutoProcessor.from_pretrained(
    "microsoft/Florence-2-large",
    trust_remote_code=True
)

image = Image.open("photo.jpg")

# Subtítulo breve
task = "<CAPTION>"
inputs = processor(text=task, images=image, return_tensors="pt").to("cuda", torch.float16)
generated_ids = model.generate(
    input_ids=inputs["input_ids"],
    pixel_values=inputs["pixel_values"],
    max_new_tokens=1024
)
result = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
caption = processor.post_process_generation(result, task=task, image_size=image.size)
print(caption)

# Salida: {'<CAPTION>': 'Un perro jugando en el parque'}

# Subtítulo detallado
task = "<DETAILED_CAPTION>"
inputs = processor(text=task, images=image, return_tensors="pt").to("cuda", torch.float16)
generated_ids = model.generate(
    input_ids=inputs["input_ids"],
    pixel_values=inputs["pixel_values"],
    max_new_tokens=1024
)
result = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
detailed = processor.post_process_generation(result, task=task, image_size=image.size)
print(detailed)

Detección de objetos

task = "<OD>"  # Detección de objetos
inputs = processor(text=task, images=image, return_tensors="pt").to("cuda", torch.float16)
generated_ids = model.generate(
    input_ids=inputs["input_ids"],
    pixel_values=inputs["pixel_values"],
    max_new_tokens=1024
)
result = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
detections = processor.post_process_generation(result, task=task, image_size=image.size)

# Salida: {'<OD>': {'bboxes': [[x1, y1, x2, y2], ...], 'labels': ['perro', 'pelota', ...]}}

OCR (Reconocimiento de texto)

task = "<OCR>"
inputs = processor(text=task, images=image, return_tensors="pt").to("cuda", torch.float16)
generated_ids = model.generate(
    input_ids=inputs["input_ids"],
    pixel_values=inputs["pixel_values"],
    max_new_tokens=1024
)
result = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
text = processor.post_process_generation(result, task=task, image_size=image.size)
print(text)

# Salida: {'<OCR>': 'Texto encontrado en la imagen...'}

Subtitulado denso de regiones

task = "<DENSE_REGION_CAPTION>"
inputs = processor(text=task, images=image, return_tensors="pt").to("cuda", torch.float16)
generated_ids = model.generate(
    input_ids=inputs["input_ids"],
    pixel_values=inputs["pixel_values"],
    max_new_tokens=1024
)
result = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
regions = processor.post_process_generation(result, task=task, image_size=image.size)

# Salida: {'<DENSE_REGION_CAPTION>': {'bboxes': [...], 'labels': ['un perro marrón corriendo', 'hierba verde', ...]}}

Comprensión de expresiones referenciales

Encontrar objetos basados en descripciones de texto:

task = "<CAPTION_TO_PHRASE_GROUNDING>"
text_input = "el coche rojo a la izquierda"

inputs = processor(
    text=task + text_input,
    images=image,
    return_tensors="pt"
).to("cuda", torch.float16)

generated_ids = model.generate(
    input_ids=inputs["input_ids"],
    pixel_values=inputs["pixel_values"],
    max_new_tokens=1024
)
result = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
grounding = processor.post_process_generation(result, task=task, image_size=image.size)

# Devuelve el cuadro delimitador de "el coche rojo a la izquierda"

Todas las tareas disponibles

TASKS = [
    "<CAPTION>",                    # Subtítulo breve
    "<DETAILED_CAPTION>",           # Descripción detallada
    "<MORE_DETAILED_CAPTION>",      # Descripción muy detallada
    "<OD>",                          # Detección de objetos
    "<DENSE_REGION_CAPTION>",       # Descripciones de regiones
    "<REGION_PROPOSAL>",            # Proponer regiones de interés
    "<CAPTION_TO_PHRASE_GROUNDING>", # Encontrar objetos desde texto
    "<REFERRING_EXPRESSION_SEGMENTATION>", # Segmentar desde texto
    "<REGION_TO_SEGMENTATION>",     # Segmentar región especificada
    "<OPEN_VOCABULARY_DETECTION>",  # Detectar con etiquetas de texto
    "<REGION_TO_CATEGORY>",         # Clasificar región
    "<REGION_TO_DESCRIPTION>",      # Describir región
    "<OCR>",                         # Extraer texto
    "<OCR_WITH_REGION>",            # Extraer texto con ubicaciones
]

Procesamiento por lotes

import os
from transformers import AutoProcessor, AutoModelForCausalLM
from PIL import Image
import torch
import json

model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-large",
    torch_dtype=torch.float16,
    trust_remote_code=True
).to("cuda")
processor = AutoProcessor.from_pretrained("microsoft/Florence-2-large", trust_remote_code=True)

def process_image(image_path, task):
    image = Image.open(image_path)
    inputs = processor(text=task, images=image, return_tensors="pt").to("cuda", torch.float16)
    generated_ids = model.generate(
        input_ids=inputs["input_ids"],
        pixel_values=inputs["pixel_values"],
        max_new_tokens=1024
    )
    result = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
    return processor.post_process_generation(result, task=task, image_size=image.size)

# Procesar directorio
input_dir = "./images"
results = {}

for filename in os.listdir(input_dir):
    if not filename.endswith(('.jpg', '.png')):
        continue

    path = os.path.join(input_dir, filename)
    results[filename] = {
        "caption": process_image(path, "<CAPTION>"),
        "objects": process_image(path, "<OD>"),
        "text": process_image(path, "<OCR>")
    }
    print(f"Procesado: {filename}")

with open("results.json", "w") as f:
    json.dump(results, f, indent=2)

Interfaz Gradio

import gradio as gr
from transformers import AutoProcessor, AutoModelForCausalLM
from PIL import Image, ImageDraw
import torch

model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-large",
    torch_dtype=torch.float16,
    trust_remote_code=True
).to("cuda")
processor = AutoProcessor.from_pretrained("microsoft/Florence-2-large", trust_remote_code=True)

def run_task(image, task):
    inputs = processor(text=task, images=image, return_tensors="pt").to("cuda", torch.float16)
    generated_ids = model.generate(
        input_ids=inputs["input_ids"],
        pixel_values=inputs["pixel_values"],
        max_new_tokens=1024
    )
    result = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
    parsed = processor.post_process_generation(result, task=task, image_size=image.size)

    # Dibujar cuadros si la tarea es detección
    output_image = image.copy()
    if task in ["<OD>", "<DENSE_REGION_CAPTION>"]:
        draw = ImageDraw.Draw(output_image)
        if "bboxes" in parsed.get(task, {}):
            for box, label in zip(parsed[task]["bboxes"], parsed[task]["labels"]):
                draw.rectangle(box, outline="red", width=2)
                draw.text((box[0], box[1]-15), label, fill="red")

    return output_image, str(parsed)

demo = gr.Interface(
    fn=run_task,
    inputs=[
        gr.Image(type="pil", label="Imagen de entrada"),
        gr.Dropdown(
            choices=["<CAPTION>", "<DETAILED_CAPTION>", "<OD>", "<DENSE_REGION_CAPTION>", "<OCR>"],
            value="<CAPTION>",
            label="Tarea"
        )
    ],
    outputs=[
        gr.Image(label="Resultado"),
        gr.Textbox(label="Salida", lines=10)
    ],
    title="Florence-2 Vision AI",
    description="Modelo de visión multitarea. Ejecutándose en servidores GPU de CLORE.AI."
)

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

Rendimiento

Tarea	Resolución	GPU	Velocidad
Subtítulo	768x768	RTX 3090	200ms
Subtítulo	768x768	RTX 4090	120ms
Detección de objetos	768x768	RTX 4090	150ms
OCR	768x768	RTX 4090	180ms
Subtítulo denso	768x768	A100	100ms

Variantes de modelo

Modelo	Parámetros	VRAM	Velocidad
Florence-2-base	232M	4GB	Rápido
Florence-2-large	771M	8GB	Medio
Florence-2-base-ft	232M	4GB	Rápido
Florence-2-large-ft	771M	8GB	Medio

Problemas comunes y soluciones

Memoria insuficiente

Problema: Error de OOM en CUDA

Soluciones:

# Usar el modelo base en lugar del grande
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-base",
    torch_dtype=torch.float16,
    trust_remote_code=True
).to("cuda")

# O habilitar descarga a CPU
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-large",
    torch_dtype=torch.float16,
    trust_remote_code=True,
    device_map="auto"
)

Inferencia lenta

Problema: El procesamiento tarda demasiado

Soluciones:

• Usar Florence-2-base para inferencia más rápida

• Instalar flash-attention para acelerar

• Procesar múltiples imágenes en lote

• Usar GPU A100 para producción

pip install flash-attn --no-build-isolation

Resultados pobres de OCR

Problema: El reconocimiento de texto es inexacto

Soluciones:

• Asegúrese de que la imagen tenga alta resolución (al menos 768px)

• Usa <OCR_WITH_REGION> para una mejor localización

• Preprocesamiento: mejorar contraste, enderezar la imagen

• Recortar las regiones de texto antes del OCR

Detección: objetos faltantes

Problema: Objetos no detectados

Soluciones:

• Usa <DENSE_REGION_CAPTION> para más regiones

• Intenta <OPEN_VOCABULARY_DETECTION> con etiquetas específicas

• Combinar con GroundingDINO para objetos específicos

Solución de problemas

La tarea no funciona

• Verifique la sintaxis exacta del nombre de la tarea

• Algunas tareas requieren un formato de entrada específico

• Verifique que la versión del modelo coincida con la tarea

Formato de salida inesperado

• Diferentes tareas devuelven diferentes formatos

• Analice la salida según el tipo de tarea

• Consulte la documentación para las salidas de las tareas

Problemas de memoria de CUDA

• Florence-2-large necesita ~8GB de VRAM

• Usar Florence-2-base para menos memoria

• Habilitar gradient checkpointing

Procesamiento lento

• Usar inferencia por lotes cuando sea posible

• Habilitar modo FP16

• Considerar la optimización con TensorRT

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

• Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)

• Paga con CLORE tokens

• Compara precios entre diferentes proveedores

Próximos pasos

• LLaVA - Chat visual y preguntas y respuestas

• GroundingDINO - Detección sin entrenamiento (zero-shot)

• SAM2 - Segmentar objetos detectados