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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI la place de marché.

Louer sur CLORE.AI

Visitez la place de marché CLORE.AI
Filtrez par type de GPU, VRAM et prix
Choisissez À 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@<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
Article : Article Florence-2
GitHub : microsoft/Florence-2
Démo : HuggingFace Space

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 :

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:

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

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

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': ['dog', 'ball', ...]}}

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

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 :

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

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

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 :


# 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

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 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 - Chat visuel et questions-réponses
GroundingDINO - Détection zero-shot
SAM2 - Segmenter les objets détectés

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

SuivantSAM2 Video

Mis à jour il y a 1 mois

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