Florence-2

Microsoft Florence-2 für Bildbeschriftung, Erkennung und Segmentierung

Microsofts leistungsstarkes Vision-Modell für Bildbeschriftung, Erkennung, Segmentierung und mehr.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Alle Beispiele in diesem Leitfaden können auf GPU-Servern ausgeführt werden, die über CLORE.AI-Marktplatz Marktplatz gemietet werden.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

2. Filtern nach GPU-Typ, VRAM und Preis

3. Wähle On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfiguriere deine Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Bei Bedarf Umgebungsvariablen hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf die Bereitstellung warten

Greife auf deinen Server zu

• Verbindungsdetails finden in Meine Bestellungen

• Web-Oberflächen: Verwende die HTTP-Port-URL

• SSH: ssh -p <port> root@<proxy-address>

Was ist Florence-2?

Florence-2 von Microsoft ist ein Vision-Grundlagenmodell, das Folgendes verarbeitet:

• Bildbeschreibung (kurz und detailliert)

• Objekterkennung und Lokalisierung

• Beschriftung dichter Bildbereiche

• Verstehen referenzierender Ausdrücke

• OCR und Texterkennung

• Visuelle Fragebeantwortung

Ressourcen

• HuggingFace: microsoft/Florence-2-large

• Paper: Florence-2-Paper

• GitHub: microsoft/Florence-2

• Demo: HuggingFace Space

Empfohlene Hardware

Komponente	Minimum	Empfohlen	Optimal
GPU	RTX 3060 12 GB	RTX 4080 16 GB	RTX 4090 24GB
VRAM	8 GB	12 GB	16 GB
CPU	4 Kerne	8 Kerne	16 Kerne
RAM	16 GB	32 GB	64 GB
Speicher	30 GB SSD	50 GB NVMe	100 GB NVMe
Internet	100 Mbit/s	500 Mbit/s	1 Gbit/s

Schnellbereitstellung auf CLORE.AI

Docker-Image:

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

Ports:

22/tcp
7860/http

Befehl:

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

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Installation

pip install transformers accelerate einops timm
pip install flash-attn --no-build-isolation  # Optional, for faster inference

Was du erstellen kannst

Inhaltsanalyse

• Bildbeschreibungen automatisch generieren

• Text aus Bildern extrahieren (OCR)

• Visuellen Inhalt in großem Maßstab analysieren

Datenannotation

• Datensätze automatisch mit Bildbeschreibungen versehen

• Begrenzungsboxen für Objekte generieren

• Dichte Annotationen erstellen

Barrierefreiheit

• Alt-Text für Bilder generieren

• Bilder für sehbehinderte Menschen beschreiben

• Audiodeskriptionen erstellen

Suche & Entdeckung

• Bilder nach Inhalt indexieren

• Visuelle Suchsysteme aufbauen

• Inhaltsmoderation

Dokumentenverarbeitung

• Text aus Dokumenten extrahieren

• Diagramme und Grafiken verstehen

• Gescanntes Material verarbeiten

Grundlegende Verwendung

Bildbeschriftung

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

# Kurze Bildbeschreibung
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)

# Ausgabe: {'<CAPTION>': 'Ein Hund, der im Park spielt'}

# Detaillierte Bildbeschreibung
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)

Objekterkennung

task = "<OD>"  # Objekterkennung
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)

# Ausgabe: {'<OD>': {'bboxes': [[x1, y1, x2, y2], ...], 'labels': ['Hund', 'Ball', ...]}}

OCR (Texterkennung)

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)

# Ausgabe: {'<OCR>': 'Im Bild gefundener Text...'}

Beschriftung dichter Bildbereiche

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)

# Ausgabe: {'<DENSE_REGION_CAPTION>': {'bboxes': [...], 'labels': ['ein brauner laufender Hund', 'grünes Gras', ...]}}

Verstehen referenzierender Ausdrücke

Finde Objekte anhand von Textbeschreibungen:

task = "<CAPTION_TO_PHRASE_GROUNDING>"
text_input = "das rote Auto links"

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)

# Gibt die Begrenzungsbox von "das rote Auto links" zurück

Alle verfügbaren Aufgaben

TASKS = [
    "<CAPTION>",                    # Kurze Bildbeschreibung
    "<DETAILED_CAPTION>",           # Detaillierte Beschreibung
    "<MORE_DETAILED_CAPTION>",      # Sehr detaillierte Beschreibung
    "<OD>",                          # Objekterkennung
    "<DENSE_REGION_CAPTION>",       # Beschreibungen von Bildbereichen
    "<REGION_PROPOSAL>",            # Interessante Regionen vorschlagen
    "<CAPTION_TO_PHRASE_GROUNDING>", # Objekte anhand von Text finden
    "<REFERRING_EXPRESSION_SEGMENTATION>", # Aus Text segmentieren
    "<REGION_TO_SEGMENTATION>",     # Angegebene Region segmentieren
    "<OPEN_VOCABULARY_DETECTION>",  # Mit Textlabels erkennen
    "<REGION_TO_CATEGORY>",         # Region klassifizieren
    "<REGION_TO_DESCRIPTION>",      # Region beschreiben
    "<OCR>",                         # Text extrahieren
    "<OCR_WITH_REGION>",            # Text mit Positionen extrahieren
]

Batch-Verarbeitung

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)

# Verzeichnis verarbeiten
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"Verarbeitet: {filename}")

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

Gradio-Oberfläche

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)

    # Boxen zeichnen, wenn es sich um eine Erkennungsaufgabe handelt
    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="Eingabebild"),
        gr.Dropdown(
            choices=["<CAPTION>", "<DETAILED_CAPTION>", "<OD>", "<DENSE_REGION_CAPTION>", "<OCR>"],
            value="<CAPTION>",
            label="Aufgabe"
        )
    ],
    outputs=[
        gr.Image(label="Ergebnis"),
        gr.Textbox(label="Ausgabe", lines=10)
    ],
    title="Florence-2 Vision-KI",
    description="Multitasking-Visionmodell. Läuft auf den GPU-Servern von CLORE.AI."
)

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

Leistung

Aufgabe	Auflösung	GPU	Geschwindigkeit
Bildbeschreibung	768x768	RTX 3090	200ms
Bildbeschreibung	768x768	RTX 4090	120ms
Objekterkennung	768x768	RTX 4090	150ms
OCR	768x768	RTX 4090	180ms
Dichte Bildbeschreibung	768x768	A100	100ms

Modellvarianten

Modell	Parameter	VRAM	Geschwindigkeit
Florence-2-base	232M	4 GB	Schnell
Florence-2-large	771M	8 GB	Mittel
Florence-2-base-ft	232M	4 GB	Schnell
Florence-2-large-ft	771M	8 GB	Mittel

Häufige Probleme & Lösungen

Speicher erschöpft

Problem: CUDA-Out-of-Memory-Fehler

Lösungen:

# Verwende das Base-Modell statt des Large-Modells
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-base",
    torch_dtype=torch.float16,
    trust_remote_code=True
).to("cuda")

# Oder CPU-Offload aktivieren
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-large",
    torch_dtype=torch.float16,
    trust_remote_code=True,
    device_map="auto"
)

Langsame Inferenz

Problem: Die Verarbeitung dauert zu lange

Lösungen:

• Verwende Florence-2-base für schnellere Inferenz

• Installiere flash-attention für mehr Geschwindigkeit

• Verarbeite mehrere Bilder im Batch

• Verwende A100-GPU für den Produktionseinsatz

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

Schlechte OCR-Ergebnisse

Problem: Die Texterkennung ist ungenau

Lösungen:

• Stelle sicher, dass das Bild hochauflösend ist (mindestens 768 px)

• Verwende <OCR_WITH_REGION> für bessere Lokalisierung

• Vorverarbeitung: Kontrast verstärken, Bild entzerren

• Vor der OCR auf Textbereiche zuschneiden

Objekte werden bei der Erkennung nicht gefunden

Problem: Objekte nicht erkannt

Lösungen:

• Verwende <DENSE_REGION_CAPTION> für mehr Regionen

• Versuche <OPEN_VOCABULARY_DETECTION> mit spezifischen Labels

• Mit GroundingDINO für bestimmte Objekte kombinieren

Fehlerbehebung

Aufgabe funktioniert nicht

• Überprüfe die exakte Syntax des Aufgabennamens

• Einige Aufgaben benötigen ein bestimmtes Eingabeformat

• Überprüfe, ob die Modellversion zur Aufgabe passt

Unerwartetes Ausgabeformat

• Verschiedene Aufgaben geben unterschiedliche Formate zurück

• Analysiere die Ausgabe entsprechend dem Aufgabentyp

• Prüfe die Dokumentation zu den Ausgaben der Aufgabe

CUDA-Speicherprobleme

• Florence-2-large benötigt ca. 8 GB VRAM

• Verwende Florence-2-base für geringeren Speicherbedarf

• Gradient Checkpointing aktivieren

Langsame Verarbeitung

• Verwende nach Möglichkeit Batch-Inferenz

• FP16-Modus aktivieren

• TensorRT-Optimierung in Betracht ziehen

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

GPU	Stundensatz	Tagessatz	4-Stunden-Sitzung
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

Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI-Marktplatz für aktuelle Preise.

Geld sparen:

• Nutzen Sie den Spot Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf

• Bezahlen Sie mit CLORE Tokens

• Vergleichen Sie Preise zwischen verschiedenen Anbietern

Nächste Schritte

• LLaVA - Visueller Chat und Fragebeantwortung

• GroundingDINO - Zero-Shot-Erkennung

• SAM2 - Erkannte Objekte segmentieren