Florence-2

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

Microsofts leistungsstarkes Visionsmodell für Beschriftung, Erkennung, Segmentierung und mehr.

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

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

Mieten auf CLORE.AI

1. Besuchen Sie CLORE.AI Marketplace

2. Nach GPU-Typ, VRAM und Preis filtern

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

4. Konfigurieren Sie Ihre Bestellung:

   • Docker-Image auswählen

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

   • Umgebungsvariablen bei Bedarf hinzufügen

   • Startbefehl eingeben

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

6. Bestellung erstellen und auf Bereitstellung warten

Zugriff auf Ihren Server

• Verbindungsdetails finden Sie in Meine Bestellungen

• Webschnittstellen: Verwenden Sie die HTTP-Port-URL

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

Was ist Florence-2?

Florence-2 von Microsoft ist ein Vision-Foundation-Modell, das Folgendes handhabt:

• Bildbeschriftung (kurz und ausführlich)

• Objekterkennung und -lokalisierung

• Dichte Regionen-Beschriftung

• Verweisende Ausdrucksverständnis

• OCR und Texterkennung

• Visuelle Fragebeantwortung

Ressourcen

• HuggingFace: microsoft/Florence-2-large

• Paper: Florence-2 Papier

• GitHub: microsoft/Florence-2

• Demo: HuggingFace Space

Empfohlene Hardware

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

Schnelle Bereitstellung auf CLORE.AI

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-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')
"

Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen:

1. Gehen Sie zur Meine Bestellungen Seite

2. Klicken Sie auf Ihre Bestellung

3. Finden Sie die http_pub URL (z. B., abc123.clorecloud.net)

Verwenden Sie https://IHRE_HTTP_PUB_URL anstelle von localhost in den Beispielen unten.

Installation

pip install transformers accelerate einops timm
pip install flash-attn --no-build-isolation  # Optional, für schnellere Inferenz

Was Sie erstellen können

Inhaltsanalyse

• Bilderbeschreibungen automatisch erzeugen

• Text aus Bildern extrahieren (OCR)

• Visuellen Inhalt in großem Maßstab analysieren

Datenannotation

• Datensätze automatisch mit Beschriftungen versehen

• Begrenzungsrahmen für Objekte erzeugen

• Dichte Annotationen erstellen

Barrierefreiheit

• Alt-Text für Bilder generieren

• Bilder für Sehbehinderte beschreiben

• Audio-Beschreibungen 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 Beschriftung
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 spielt im Park'}

# Ausführliche Beschriftung
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': ['dog', '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...'}

Dichte Regionen-Beschriftung

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 Hund rennt', 'grünes Gras', ...]}}

Verweisende Ausdrucksverständnis

Finde Objekte basierend auf 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 Beschriftung
    "<DETAILED_CAPTION>",           # Ausführliche Beschreibung
    "<MORE_DETAILED_CAPTION>",      # Sehr ausführliche Beschreibung
    "<OD>",                          # Objekterkennung
    "<DENSE_REGION_CAPTION>",       # Regionsbeschreibungen
    "<REGION_PROPOSAL>",            # Vorschlagen von Interessensregionen
    "<CAPTION_TO_PHRASE_GROUNDING>", # Objekte anhand von Text finden
    "<REFERRING_EXPRESSION_SEGMENTATION>", # Segmentierung anhand von Text
    "<REGION_TO_SEGMENTATION>",     # Angegebene Region segmentieren
    "<OPEN_VOCABULARY_DETECTION>",  # Erkennung mit Textbeschriftungen
    "<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"Processed: {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)

    # Zeichne Boxen, wenn Erkennungsaufgabe
    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 AI",
    description="Multitask-Visionsmodell. Läuft auf CLORE.AI GPU-Servern."
)

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

Leistung

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

Modellvarianten

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

Häufige Probleme & Lösungen

Kein Speicher mehr

Problem: CUDA OOM-Fehler

Lösungen:

# Verwenden Sie 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:

• Verwenden Sie Florence-2-base für schnellere Inferenz

• Installieren Sie flash-attention zur Beschleunigung

• Bündeln Sie mehrere Bilder in einem Batch

• Verwenden Sie eine A100-GPU für die Produktion

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

Schlechte OCR-Ergebnisse

Problem: Texterkennung ist ungenau

Lösungen:

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

• Verwenden Sie <OCR_WITH_REGION> für bessere Lokalisierung

• Vorverarbeitung: Kontrast verbessern, Bild begradigen

• Auf Textregionen zuschneiden vor OCR

Erkennung fehlt Objekte

Problem: Objekte werden nicht erkannt

Lösungen:

• Verwenden Sie <DENSE_REGION_CAPTION> für mehr Regionen

• Versuchen Sie <OPEN_VOCABULARY_DETECTION> mit spezifischen Labels

• Kombinieren Sie mit GroundingDINO für spezifische Objekte

Fehlerbehebung

Aufgabe funktioniert nicht

• Überprüfen Sie die genaue Tasksyntax

• Einige Aufgaben erfordern ein spezifisches Eingabeformat

• Stellen Sie sicher, dass die Modellversion zur Aufgabe passt

Ausgabeformat unerwartet

• Verschiedene Aufgaben liefern unterschiedliche Formate

• Parsen Sie die Ausgabe entsprechend dem Aufgabentyp

• Überprüfen Sie die Dokumentation zu den Aufgaben-Ausgaben

CUDA-Speicherprobleme

• Florence-2-large benötigt ~8GB VRAM

• Verwenden Sie Florence-2-base für weniger Speicherbedarf

• Aktivieren Sie Gradient Checkpointing

Langsame Verarbeitung

• Verwenden Sie, wenn möglich, Batch-Inferenz

• Aktivieren Sie den FP16-Modus

• Erwägen Sie TensorRT-Optimierung

Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (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

Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI Marketplace auf aktuelle Preise.

Geld sparen:

• Verwenden Sie Spot Markt für flexible Workloads (oft 30–50% günstiger)

• Bezahlen mit CLORE Token

• Preise bei verschiedenen Anbietern vergleichen

Nächste Schritte

• LLaVA - Visueller Chat und QA

• GroundingDINO - Zero-Shot-Erkennung

• SAM2 - Segmentieren erkannter Objekte