# Florence-2

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Todos los ejemplos en esta guía se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace) mercado.
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://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](https://huggingface.co/microsoft/Florence-2-large)
* **Artículo:** [Artículo de Florence-2](https://arxiv.org/abs/2311.06242)
* **GitHub:** [microsoft/Florence-2](https://github.com/microsoft/Florence-2)
* **Demostración:** [Espacio de HuggingFace](https://huggingface.co/spaces/microsoft/Florence-2)

## 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:**

```bash
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

```bash
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

```python
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

```python
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)

```python
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

```python
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:

```python
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

```python
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

```python
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

```python
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:**

```python

# 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

```bash
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*](https://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](/guides/guides_v2-es/modelos-de-vision/llava-vision-language.md) - Chat visual y preguntas y respuestas
* [GroundingDINO](/guides/guides_v2-es/modelos-de-vision/groundingdino.md) - Detección sin entrenamiento (zero-shot)
* [SAM2](/guides/guides_v2-es/modelos-de-vision/sam2-video.md) - Segmentar objetos detectados


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-vision/florence2.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.