Florence-2

Microsoft Florence-2 pour le captioning, la détection et la segmentation

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace le marketplace.

Location sur CLORE.AI

Visitez CLORE.AI Marketplace
Filtrer par type de GPU, VRAM et prix
Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)
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
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
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
Article : Article Florence-2
GitHub : microsoft/Florence-2
Démo : Espace HuggingFace

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 :

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:

Aller à la Mes commandes page
Cliquez sur votre commande
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

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

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

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)

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

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 :

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

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

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

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 :


# 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

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 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 - Chat visuel et QA
GroundingDINO - Détection zéro-shot
SAM2 - Segmenter les objets détectés

PrécédentModèle vision-langage Qwen2.5-VL SuivantSAM2 Vidéo

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagLocation sur CLORE.AI

hashtagAccédez à votre serveur

hashtagQu'est-ce que Florence-2 ?

hashtagRessources

hashtagMatériel recommandé

hashtagDéploiement rapide sur CLORE.AI

hashtagAccéder à votre service

hashtagInstallation

hashtagCe que vous pouvez créer

hashtagAnalyse de contenu

hashtagAnnotation de données

hashtagAccessibilité

hashtagRecherche et découverte

hashtagTraitement de documents

hashtagUtilisation de base

hashtagGénération de légendes d'images

hashtagDétection d'objets

hashtagOCR (Reconnaissance de texte)

hashtagLégendage dense de régions

hashtagCompréhension d'expressions référentielles

hashtagToutes les tâches disponibles

hashtagTraitement par lots

hashtagInterface Gradio

hashtagPerformances

hashtagVariantes de modèle

hashtagProblèmes courants et solutions

hashtagMémoire insuffisante

hashtagInférence lente

hashtagMauvais résultats OCR

hashtagDétection : objets manquants

hashtagDépannage

hashtagTâche ne fonctionnant pas

hashtagFormat de sortie inattendu

hashtagProblèmes de mémoire CUDA

hashtagTraitement lent

hashtagEstimation des coûts

hashtagProchaines étapes

Location sur CLORE.AI

Accédez à votre serveur

Qu'est-ce que Florence-2 ?

Ressources

Matériel recommandé

Déploiement rapide sur CLORE.AI

Accéder à votre service

Installation

Ce que vous pouvez créer

Analyse de contenu

Annotation de données

Accessibilité

Recherche et découverte

Traitement de documents

Utilisation de base

Génération de légendes d'images

Détection d'objets

OCR (Reconnaissance de texte)

Légendage dense de régions

Compréhension d'expressions référentielles

Toutes les tâches disponibles

Traitement par lots

Interface Gradio

Performances

Variantes de modèle

Problèmes courants et solutions

Mémoire insuffisante

Inférence lente

Mauvais résultats OCR

Détection : objets manquants

Dépannage

Tâche ne fonctionnant pas

Format de sortie inattendu

Problèmes de mémoire CUDA

Traitement lent

Estimation des coûts

Prochaines étapes