> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/modeli-dlya-zreniya/florence2.md).

# Florence-2

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

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

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Все примеры в этом руководстве можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](https://clore.ai/marketplace) маркетплейс.
{% endhint %}

## Аренда на CLORE.AI

1. Перейдите на [маркетплейс CLORE.AI](https://clore.ai/marketplace)
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](https://huggingface.co/microsoft/Florence-2-large)
* **Статья:** [Документ Florence-2](https://arxiv.org/abs/2311.06242)
* **GitHub:** [microsoft/Florence-2](https://github.com/microsoft/Florence-2)
* **Демо:** [HuggingFace Space](https://huggingface.co/spaces/microsoft/Florence-2)

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

| Компонент | Минимум       | Рекомендуется | Оптимально    |
| --------- | ------------- | ------------- | ------------- |
| 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
```

**Команда:**

```bash
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` в примерах ниже.

## Установка

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

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

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

* Автоматически генерировать описания изображений
* Извлекать текст из изображений (OCR)
* Анализировать визуальный контент в масштабе

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

* Автоматически помечать датасеты подписями
* Генерировать ограничивающие рамки для объектов
* Создавать плотные аннотации

### Доступность

* Генерировать alt-текст для изображений
* Описывать изображения для людей с нарушениями зрения
* Создавать аудиоописания

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

* Индексировать изображения по содержанию
* Создавать системы визуального поиска
* Модерация контента

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

* Извлекать текст из документов
* Понимать диаграммы и схемы
* Обрабатывать отсканированные материалы

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

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

```python
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)
```

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

```python
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 (распознавание текста)

```python
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>': 'Текст, найденный на изображении...'}
```

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

```python
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': ['бежит коричневая собака', 'зелёная трава', ...]}}
```

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

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

```python
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)

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

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

```python
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>",            # Извлечь текст с местоположениями
]
```

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

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

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

**Решения:**

```python

# Используйте базовую модель вместо большой
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 для продакшена

```bash
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*](https://clore.ai/marketplace) *актуальные тарифы.*

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

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

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

* [LLaVA](/guides/guides_v2-ru/modeli-dlya-zreniya/llava-vision-language.md) - Чат и ответы на вопросы по изображениям
* [GroundingDINO](/guides/guides_v2-ru/modeli-dlya-zreniya/groundingdino.md) - Обнаружение без предварительного обучения
* [SAM2](/guides/guides_v2-ru/modeli-dlya-zreniya/sam2-video.md) - Сегментировать обнаруженные объекты


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/modeli-dlya-zreniya/florence2.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.