> 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

Le puissant modèle de vision de Microsoft pour la génération de légendes, la détection, la segmentation et plus encore.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](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 [CLORE.AI Marketplace](https://clore.ai/marketplace) le marketplace.
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À 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@<adresse-proxy>`

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

Florence-2 de Microsoft est un modèle de base pour la vision qui gère :

* Génération de légendes d'images (brèves et détaillées)
* Détection et localisation d'objets
* Légendage dense de régions
* Compréhension d'expressions référentielles
* OCR et reconnaissance de texte
* Question-réponse visuelle

## 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 :** [Espace HuggingFace](https://huggingface.co/spaces/microsoft/Florence-2)

## Matériel recommandé

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

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-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. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_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 le texte des images (OCR)
* Analyser le contenu visuel à grande échelle

### Annotation de données

* Étiqueter automatiquement les jeux 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 malvoyants
* Créer des descriptions audio

### Recherche et découverte

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

### Traitement de documents

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

## Utilisation de base

### Génération de légendes 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': ['chien', 'balle', ...]}}
```

### 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 dense de régions

```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 en course', 'herbe verte', ...]}}
```

### Compréhension d'expressions référentielles

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 de texte
    "<REFERRING_EXPRESSION_SEGMENTATION>", # Segmenter à partir de texte
    "<REGION_TO_SEGMENTATION>",     # Segmenter une région spécifiée
    "<OPEN_VOCABULARY_DETECTION>",  # Détecter avec des libellés textuels
    "<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 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)

# Traiter un 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"Traité : {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 tâche de 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="Tâche"
        )
    ],
    outputs=[
        gr.Image(label="Résultat"),
        gr.Textbox(label="Sortie", lines=10)
    ],
    title="Florence-2 Vision AI",
    description="Modèle visuel multi-tâches. Exécuté sur les serveurs GPU 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 | 200ms   |
| Légende            | 768x768    | RTX 4090 | 120ms   |
| Détection d'objets | 768x768    | RTX 4090 | 150ms   |
| OCR                | 768x768    | RTX 4090 | 180ms   |
| Légende dense      | 768x768    | A100     | 100ms   |

## Variantes de modèle

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

## Problèmes courants et solutions

### Mémoire insuffisante

**Problème :** Erreur OOM CUDA

**Solutions :**

```python

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

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

* Utiliser Florence-2-base pour une inférence plus rapide
* Installer flash-attention pour accélérer
* Regrouper plusieurs images en lot
* Utiliser un GPU A100 en production

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

### Mauvais résultats OCR

**Problème :** La reconnaissance de texte est inexacte

**Solutions :**

* Assurez-vous que l'image est de haute résolution (au moins 768px)
* Utilisez `<OCR_WITH_REGION>` pour une meilleure localisation
* Pré-traitement : améliorer le contraste, redresser l'image
* Rogner vers 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 plus de régions
* Essayez `<OPEN_VOCABULARY_DETECTION>` avec des libellés spécifiques
* Combiner avec GroundingDINO pour des objets spécifiques

## Dépannage

### Tâche ne fonctionnant 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

* Différentes tâches renvoient des formats différents
* Analyser 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 \~8 Go de VRAM
* Utiliser Florence-2-base pour moins de mémoire
* Activer le gradient checkpointing

### Traitement lent

* Utiliser l'inférence par lots lorsque possible
* Activer le mode FP16
* Envisager l'optimisation TensorRT

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 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 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

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

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [LLaVA](/guides/guides_v2-fr/modeles-de-vision/llava-vision-language.md) - Chat visuel et QA
* [GroundingDINO](/guides/guides_v2-fr/modeles-de-vision/groundingdino.md) - Détection zéro-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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-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.