Florence-2

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

El potente modelo de visión de Microsoft para subtítulos, detección, segmentación y más.

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

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

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

2. Filtra por tipo de GPU, VRAM y precio

3. Elige Bajo demanda (tarifa fija) o Spot (precio ofertado)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Añade variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el método de pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera al 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 fundacional de visión que maneja:

• Generación de subtítulos de imagen (breves y detallados)

• Detección y localización de objetos

• Generación de subtítulos de regiones densas

• Comprensión de expresiones de referencia

• OCR y reconocimiento de texto

• Respuesta a preguntas visuales

Recursos

• HuggingFace: microsoft/Florence-2-large

• Artículo: Documento de Florence-2

• GitHub: microsoft/Florence-2

• Demo: Espacio de Hugging Face

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 de Docker:

pytorch/pytorch:2.11.0-cuda12.8-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. 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.

Instalación

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

Lo que puedes crear

Análisis de contenido

• Generar automáticamente descripciones de imágenes

• Extraer texto de imágenes (OCR)

• Analizar contenido visual a escala

Anotación de datos

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

• Generar cajas delimitadoras 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

• Crear sistemas de búsqueda visual

• Moderación de contenido

Procesamiento de documentos

• Extraer texto de documentos

• Comprender gráficos y diagramas

• Procesar materiales escaneados

Uso básico

Generación de subtítulos de imagen

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...'}

Generación de subtítulos de regiones densas

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 de referencia

Encuentra objetos basados en descripciones de texto:

task = "<CAPTION_TO_PHRASE_GROUNDING>"
text_input = "el coche rojo de 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 la caja delimitadora de "el coche rojo de la izquierda"

Todas las tareas disponibles

TAREAS = [
    "<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 a partir de texto
    "<REFERRING_EXPRESSION_SEGMENTATION>", # Segmentación a partir de texto
    "<REGION_TO_SEGMENTATION>",     # Segmentar la 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 de 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 cajas si es una tarea de 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	200 ms
Subtítulo	768x768	RTX 4090	120 ms
Detección de objetos	768x768	RTX 4090	150 ms
OCR	768x768	RTX 4090	180 ms
Subtítulo denso	768x768	A100	100 ms

Variantes del modelo

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

Problemas comunes y soluciones

Sin memoria

Problema: error de memoria CUDA OOM

Soluciones:

# Usa 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 habilita la 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:

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

• Instala flash-attention para acelerar

• Agrupa varias imágenes juntas

• Usa una GPU A100 para producción

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

Resultados de OCR deficientes

Problema: El reconocimiento de texto es inexacto

Soluciones:

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

• Usa <OCR_WITH_REGION> para una mejor localización

• Preprocesa: mejora el contraste, endereza la imagen

• Recorta las regiones de texto antes del OCR

La detección omite objetos

Problema: Los objetos no se detectan

Soluciones:

• Usa <DENSE_REGION_CAPTION> para más regiones

• Prueba <OPEN_VOCABULARY_DETECTION> con etiquetas específicas

• Combínalo con GroundingDINO para objetos específicos

Solución de problemas

La tarea no funciona

• Comprueba la sintaxis exacta del nombre de la tarea

• Algunas tareas necesitan un formato de entrada específico

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

Formato de salida inesperado

• Las distintas tareas devuelven formatos diferentes

• Analiza la salida según el tipo de tarea

• Consulta la documentación para ver las salidas de la tarea

Problemas de memoria CUDA

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

• Usa Florence-2-base para menos memoria

• Activa el checkpointing de gradiente

Procesamiento lento

• Usa inferencia por lotes cuando sea posible

• Habilita el modo FP16

• Considera la optimización con TensorRT

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir 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 Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa el Spot mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de ~13% de descuento), el resto lo iguala

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Siguientes pasos

• LLaVA - Chat visual y preguntas y respuestas

• GroundingDINO - Detección sin ejemplos previos

• SAM2 - Segmentar objetos detectados