Florence-2

Microsoft Florence-2 для описания, обнаружения и сегментации

Мощная модель зрения Microsoft для подписывания изображений, обнаружения, сегментации и многого другого.

Все примеры можно запускать на GPU-серверах, арендованных через маркетплейс CLORE.AI.

Все примеры в этом руководстве можно запускать на GPU-серверах, арендованных через маркетплейс CLORE.AI маркетплейс.

Аренда на CLORE.AI

1. Перейдите на маркетплейс CLORE.AI

2. Отфильтруйте по типу GPU, объёму VRAM и цене

3. Выберите On-Demand (фиксированная ставка) или Spot (цена ставки)

4. Настройте свой заказ:

   • Выберите Docker-образ

   • Установите порты (TCP для SSH, HTTP для веб-интерфейсов)

   • При необходимости добавьте переменные окружения

   • Введите команду запуска

5. Выберите способ оплаты: CLORE, BTC, или USDT/USDC

6. Создайте заказ и дождитесь развертывания

Получите доступ к своему серверу

• Найдите данные для подключения в Мои заказы

• Веб-интерфейсы: используйте URL HTTP-порта

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

Что такое Florence-2?

Florence-2 от Microsoft — это базовая модель зрения, которая умеет:

• Подписи к изображениям (краткие и подробные)

• Обнаружение объектов и локализация

• Подписи к плотным областям

• Понимание ссылочных выражений

• OCR и распознавание текста

• Визуальный ответ на вопросы

Ресурсы

• HuggingFace: microsoft/Florence-2-large

• Статья: Документ Florence-2

• GitHub: microsoft/Florence-2

• Демо: HuggingFace Space

Рекомендуемое оборудование

Компонент	Минимум	Рекомендуется	Оптимально
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	8 ГБ	12GB	16GB
CPU	4 ядра	8 ядер	16 ядер
ОЗУ	16GB	32GB	64GB
Хранилище	30GB SSD	50GB NVMe	100GB NVMe
Интернет	100 Мбит/с	500 Мбит/с	1 Гбит/с

Быстрое развертывание на CLORE.AI

Docker-образ:

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

Порты:

22/tcp
7860/http

Команда:

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

Доступ к вашему сервису

После развертывания найдите свой http_pub URL в Мои заказы:

1. Перейдите на Мои заказы страницу

2. Нажмите на свой заказ

3. Найдите http_pub URL (например, abc123.clorecloud.net)

Используйте https://YOUR_HTTP_PUB_URL вместо localhost в примерах ниже.

Установка

pip install transformers accelerate einops timm
pip install flash-attn --no-build-isolation  # Опционально, для более быстрого вывода

Что вы можете создать

Анализ контента

• Автоматически генерировать описания изображений

• Извлекать текст из изображений (OCR)

• Анализировать визуальный контент в масштабе

Разметка данных

• Автоматически помечать датасеты подписями

• Генерировать ограничивающие рамки для объектов

• Создавать плотные аннотации

Доступность

• Генерировать alt-текст для изображений

• Описывать изображения для людей с нарушениями зрения

• Создавать аудиоописания

Поиск и обнаружение

• Индексировать изображения по содержанию

• Создавать системы визуального поиска

• Модерация контента

Обработка документов

• Извлекать текст из документов

• Понимать диаграммы и схемы

• Обрабатывать отсканированные материалы

Базовое использование

Подписи к изображениям

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

# Краткая подпись
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)

# Вывод: {'<CAPTION>': 'Собака играет в парке'}

# Подробная подпись
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)

Обнаружение объектов

task = "<OD>"  # Обнаружение объектов
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)

# Вывод: {'<OD>': {'bboxes': [[x1, y1, x2, y2], ...], 'labels': ['собака', 'мяч', ...]}}

OCR (распознавание текста)

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)

# Вывод: {'<OCR>': 'Текст, найденный на изображении...'}

Подписи к плотным областям

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)

# Вывод: {'<DENSE_REGION_CAPTION>': {'bboxes': [...], 'labels': ['бежит коричневая собака', 'зелёная трава', ...]}}

Понимание ссылочных выражений

Находить объекты на основе текстовых описаний:

task = "<CAPTION_TO_PHRASE_GROUNDING>"
text_input = "красная машина слева"

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)

# Возвращает ограничивающую рамку для "красной машины слева"

Все доступные задачи

TASKS = [
    "<CAPTION>",                    # Краткая подпись
    "<DETAILED_CAPTION>",           # Подробное описание
    "<MORE_DETAILED_CAPTION>",      # Очень подробное описание
    "<OD>",                          # Обнаружение объектов
    "<DENSE_REGION_CAPTION>",       # Описания областей
    "<REGION_PROPOSAL>",            # Предложить области интереса
    "<CAPTION_TO_PHRASE_GROUNDING>", # Найти объекты по тексту
    "<REFERRING_EXPRESSION_SEGMENTATION>", # Сегментация по тексту
    "<REGION_TO_SEGMENTATION>",     # Сегментировать указанную область
    "<OPEN_VOCABULARY_DETECTION>",  # Обнаружение с текстовыми метками
    "<REGION_TO_CATEGORY>",         # Классифицировать область
    "<REGION_TO_DESCRIPTION>",      # Описать область
    "<OCR>",                         # Извлечь текст
    "<OCR_WITH_REGION>",            # Извлечь текст с местоположениями
]

Пакетная обработка

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)

# Обработка каталога
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"Обработано: {filename}")

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

Интерфейс 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)

    # Нарисовать рамки, если задача — обнаружение
    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="Входное изображение"),
        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="Многозадачная модель зрения. Работает на GPU-серверах CLORE.AI."
)

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

Производительность

Задача	Разрешение	GPU	Скорость
Подпись	768×768	RTX 3090	200 мс
Подпись	768×768	RTX 4090	120 мс
Обнаружение объектов	768×768	RTX 4090	150 мс
OCR	768×768	RTX 4090	180 мс
Плотная подпись	768×768	A100	100 мс

Варианты модели

Модель	Параметры	VRAM	Скорость
Florence-2-base	232 млн	4 ГБ	Быстро
Florence-2-large	771 млн	8 ГБ	Средне
Florence-2-base-ft	232 млн	4 ГБ	Быстро
Florence-2-large-ft	771 млн	8 ГБ	Средне

Распространённые проблемы и решения

Недостаточно памяти

Проблема: Ошибка нехватки памяти CUDA

Решения:

# Используйте базовую модель вместо большой
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-base",
    torch_dtype=torch.float16,
    trust_remote_code=True
).to("cuda")

# Или включите выгрузку на CPU
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Florence-2-large",
    torch_dtype=torch.float16,
    trust_remote_code=True,
    device_map="auto"
)

Медленный вывод

Проблема: Обработка занимает слишком много времени

Решения:

• Используйте Florence-2-base для более быстрого вывода

• Установите flash-attention для ускорения

• Обрабатывайте несколько изображений пакетно

• Используйте GPU A100 для продакшена

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

Плохие результаты OCR

Проблема: Распознавание текста неточно

Решения:

• Убедитесь, что изображение имеет высокое разрешение (не менее 768 px)

• Используйте <OCR_WITH_REGION> для лучшей локализации

• Предобработка: повысить контраст, выровнять изображение

• Обрезайте области с текстом перед OCR

Обнаружение пропущенных объектов

Проблема: Объекты не обнаружены

Решения:

• Используйте <DENSE_REGION_CAPTION> для большего количества областей

• Попробуйте <OPEN_VOCABULARY_DETECTION> с конкретными метками

• Сочетайте с GroundingDINO для конкретных объектов

Устранение неполадок

Задача не работает

• Проверьте точный синтаксис имени задачи

• Для некоторых задач нужен особый формат ввода

• Убедитесь, что версия модели соответствует задаче

Неожиданный формат вывода

• Разные задачи возвращают разные форматы

• Разбирайте вывод в соответствии с типом задачи

• См. документацию по выходным данным задачи

Проблемы с памятью CUDA

• Florence-2-large требует около 8 ГБ видеопамяти

• Используйте Florence-2-base для меньшего расхода памяти

• Включите gradient checkpointing

Медленная обработка

• По возможности используйте пакетный вывод

• Включите режим FP16

• Рассмотрите оптимизацию TensorRT

Оценка стоимости

Типичные цены на маркетплейсе CLORE.AI (по состоянию на 2024 год):

GPU	Почасовая ставка	Дневная ставка	4-часовая сессия
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 ГБ	~$0.17	~$4.00	~$0.70
A100 80 ГБ	~$0.25	~$6.00	~$1.00

Цены зависят от провайдера и спроса. Проверьте маркетплейс CLORE.AI актуальные тарифы.

Сэкономьте деньги:

• Используйте Spot рынок для прерываемых задач — примерно треть серверов оценивает spot-цены ниже on-demand (медиана ~13% скидки), остальные совпадают с ними

• Платите CLORE токенами

• Сравните цены у разных провайдеров

Дальнейшие шаги

• LLaVA - Чат и ответы на вопросы по изображениям

• GroundingDINO - Обнаружение без предварительного обучения

• SAM2 - Сегментировать обнаруженные объекты