> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-vision/florence2.md).

# Florence-2

Microsoft Florence-2 pour la génération de légendes, la détection et la segmentation

Le puissant modèle de vision de Microsoft pour la légende d’images, la détection, la segmentation et bien plus encore.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace) la place de marché.
{% endhint %}

## Louer sur CLORE.AI

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
2. Filtrez par type de GPU, VRAM et prix
3. Choisissez **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<proxy-address>`

## Qu’est-ce que Florence-2 ?

Florence-2 de Microsoft est un modèle fondation de vision qui prend en charge :

* Légendage d’images (bref et détaillé)
* Détection et localisation d’objets
* Légendage de régions denses
* Compréhension d’expressions de référence
* OCR et reconnaissance de texte
* Réponse visuelle aux questions

## Ressources

* **HuggingFace :** [microsoft/Florence-2-large](https://huggingface.co/microsoft/Florence-2-large)
* **Article :** [Article Florence-2](https://arxiv.org/abs/2311.06242)
* **GitHub :** [microsoft/Florence-2](https://github.com/microsoft/Florence-2)
* **Démo :** [HuggingFace Space](https://huggingface.co/spaces/microsoft/Florence-2)

## Matériel recommandé

| Composant | Minimum        | Recommandé     | Optimal        |
| --------- | -------------- | -------------- | -------------- |
| GPU       | RTX 3060 12 Go | RTX 4080 16 Go | RTX 4090 24 Go |
| VRAM      | 8 Go           | 12 Go          | 16 Go          |
| CPU       | 4 cœurs        | 8 cœurs        | 16 cœurs       |
| RAM       | 16 Go          | 32 Go          | 64 Go          |
| Stockage  | 30 Go SSD      | 50 Go NVMe     | 100 Go NVMe    |
| Internet  | 100 Mbps       | 500 Mbps       | 1 Gbps         |

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Ports :**

```
22/tcp
7860/http
```

**Commande :**

```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')
"
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://YOUR_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Installation

```bash
pip install transformers accelerate einops timm
pip install flash-attn --no-build-isolation  # Optionnel, pour une inférence plus rapide
```

## Ce que vous pouvez créer

### Analyse de contenu

* Générer automatiquement des descriptions d’images
* Extraire du texte à partir d’images (OCR)
* Analyser le contenu visuel à grande échelle

### Annotation de données

* Étiqueter automatiquement les ensembles de données avec des légendes
* Générer des boîtes englobantes pour les objets
* Créer des annotations denses

### Accessibilité

* Générer du texte alternatif pour les images
* Décrire les images pour les personnes malvoyantes
* Créer des descriptions audio

### Recherche et découverte

* Indexer les images par contenu
* Créer des systèmes de recherche visuelle
* Modération du contenu

### Traitement de documents

* Extraire du texte des documents
* Comprendre les graphiques et les diagrammes
* Traiter les documents numérisés

## Utilisation de base

### Légendage d’images

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

# Légende brève
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)

# Sortie : {'<CAPTION>': 'Un chien jouant dans le parc'}

# Légende détaillée
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)
```

### Détection d’objets

```python
task = "<OD>"  # Détection d’objets
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)

# Sortie : {'<OD>': {'bboxes': [[x1, y1, x2, y2], ...], 'labels': ['dog', 'ball', ...]}}
```

### OCR (reconnaissance de texte)

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

# Sortie : {'<OCR>': 'Texte trouvé dans l’image...'}
```

### Légendage de régions denses

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

# Sortie : {'<DENSE_REGION_CAPTION>': {'bboxes': [...], 'labels': ['un chien brun qui court', 'herbe verte', ...]}}
```

### Compréhension d’expressions de référence

Trouver des objets à partir de descriptions textuelles :

```python
task = "<CAPTION_TO_PHRASE_GROUNDING>"
text_input = "la voiture rouge à gauche"

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)

# Renvoie la boîte englobante de "la voiture rouge à gauche"
```

## Toutes les tâches disponibles

```python
TASKS = [
    "<CAPTION>",                    # Légende brève
    "<DETAILED_CAPTION>",           # Description détaillée
    "<MORE_DETAILED_CAPTION>",      # Description très détaillée
    "<OD>",                          # Détection d’objets
    "<DENSE_REGION_CAPTION>",       # Descriptions de régions
    "<REGION_PROPOSAL>",            # Proposer des régions d’intérêt
    "<CAPTION_TO_PHRASE_GROUNDING>", # Trouver des objets à partir du texte
    "<REFERRING_EXPRESSION_SEGMENTATION>", # Segmenter à partir du texte
    "<REGION_TO_SEGMENTATION>",     # Segmenter la région spécifiée
    "<OPEN_VOCABULARY_DETECTION>",  # Détection avec des étiquettes textuelles
    "<REGION_TO_CATEGORY>",         # Classer la région
    "<REGION_TO_DESCRIPTION>",      # Décrire la région
    "<OCR>",                         # Extraire le texte
    "<OCR_WITH_REGION>",            # Extraire le texte avec les emplacements
]
```

## Traitement par lots

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

# Traitement du répertoire
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"Processed: {filename}")

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

## Interface 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)

    # Dessiner des boîtes si la tâche est une détection
    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="Image d’entrée"),
        gr.Dropdown(
            choices=["<CAPTION>", "<DETAILED_CAPTION>", "<OD>", "<DENSE_REGION_CAPTION>", "<OCR>"],
            value="<CAPTION>",
            label="Task"
        )
    ],
    outputs=[
        gr.Image(label="Result"),
        gr.Textbox(label="Output", lines=10)
    ],
    title="Florence-2 Vision AI",
    description="Modèle de vision multitâche. Fonctionne sur les serveurs GPU de CLORE.AI."
)

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

## Performances

| Tâche              | Résolution | GPU      | Vitesse |
| ------------------ | ---------- | -------- | ------- |
| Légende            | 768x768    | RTX 3090 | 200 ms  |
| Légende            | 768x768    | RTX 4090 | 120 ms  |
| Détection d’objets | 768x768    | RTX 4090 | 150 ms  |
| OCR                | 768x768    | RTX 4090 | 180 ms  |
| Légende dense      | 768x768    | A100     | 100 ms  |

## Variantes de modèle

| Modèle              | Paramètres | VRAM | Vitesse |
| ------------------- | ---------- | ---- | ------- |
| Florence-2-base     | 232 M      | 4 Go | Rapide  |
| Florence-2-large    | 771 M      | 8 Go | Moyen   |
| Florence-2-base-ft  | 232 M      | 4 Go | Rapide  |
| Florence-2-large-ft | 771 M      | 8 Go | Moyen   |

## Problèmes courants et solutions

### Mémoire insuffisante

**Problème :** Erreur de mémoire CUDA insuffisante

**Solutions :**

```python

# Utilisez le modèle de base au lieu du grand
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-base",
    torch_dtype=torch.float16,
    trust_remote_code=True
).to("cuda")

# Ou activez le déchargement CPU
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-large",
    torch_dtype=torch.float16,
    trust_remote_code=True,
    device_map="auto"
)
```

### Inférence lente

**Problème :** Le traitement prend trop de temps

**Solutions :**

* Utilisez Florence-2-base pour une inférence plus rapide
* Installez flash-attention pour accélérer
* Regroupez plusieurs images en lots
* Utilisez un GPU A100 pour la production

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

### Résultats OCR médiocres

**Problème :** La reconnaissance de texte est imprécise

**Solutions :**

* Assurez-vous que l’image est en haute résolution (au moins 768 px)
* Utilisez `<OCR_WITH_REGION>` pour une meilleure localisation
* Prétraitement : améliorer le contraste, redresser l’image
* Découpez les régions de texte avant l’OCR

### Détection : objets manquants

**Problème :** Objets non détectés

**Solutions :**

* Utilisez `<DENSE_REGION_CAPTION>` pour davantage de régions
* Essayez `<OPEN_VOCABULARY_DETECTION>` avec des étiquettes spécifiques
* Combinez avec GroundingDINO pour des objets spécifiques

## Dépannage

### La tâche ne fonctionne pas

* Vérifiez la syntaxe exacte du nom de la tâche
* Certaines tâches nécessitent un format d’entrée spécifique
* Vérifiez que la version du modèle correspond à la tâche

### Format de sortie inattendu

* Les différentes tâches renvoient des formats différents
* Analysez la sortie selon le type de tâche
* Consultez la documentation pour les sorties des tâches

### Problèmes de mémoire CUDA

* Florence-2-large nécessite environ 8 Go de VRAM
* Utilisez Florence-2-base pour consommer moins de mémoire
* Activez le checkpointing des gradients

### Traitement lent

* Utilisez l’inférence par lots lorsque c’est possible
* Activez le mode FP16
* Envisagez une optimisation TensorRT

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

| GPU        | Tarif horaire | Tarif journalier | Session de 4 heures |
| ---------- | ------------- | ---------------- | ------------------- |
| 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 40 Go | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80 Go | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*la place de marché CLORE.AI*](https://clore.ai/marketplace) *les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez le **Spot** marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane \~13 % de remise), les autres s'alignent dessus
* Payez avec **CLORE** jetons
* Comparez les prix entre différents fournisseurs

## Étapes suivantes

* [LLaVA](/guides/guides_v2-fr/modeles-de-vision/llava-vision-language.md) - Chat visuel et questions-réponses
* [GroundingDINO](/guides/guides_v2-fr/modeles-de-vision/groundingdino.md) - Détection zero-shot
* [SAM2](/guides/guides_v2-fr/modeles-de-vision/sam2-video.md) - Segmenter les objets détectés


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-vision/florence2.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.