> 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/llama-vision.md).

# Llama 3.2 Vision

Запустите Llama 3.2 Vision от Meta для понимания изображений на Clore.ai

Запускайте мультимодальные модели Meta Llama 3.2 Vision для понимания изображений на GPU CLORE.AI.

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

## Почему Llama 3.2 Vision?

* **Мультимодальная** - Понимает и текст, и изображения
* **Несколько размеров** - Варианты с 11B и 90B параметров
* **Универсальный** - OCR, визуальный вопрос-ответ, описание изображений, анализ документов
* **Открытые веса** - Полностью открытый исходный код от Meta
* **Экосистема Llama** - Совместимо с Ollama, vLLM, transformers

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

| Модель                        | Параметры | VRAM (FP16) | Контекст | Лучше всего для                    |
| ----------------------------- | --------- | ----------- | -------- | ---------------------------------- |
| Llama-3.2-11B-Vision          | 11B       | 24 ГБ       | 128K     | Для общего использования, один GPU |
| Llama-3.2-90B-Vision          | 90B       | 180 ГБ      | 128K     | Максимальное качество              |
| Llama-3.2-11B-Vision-Instruct | 11B       | 24 ГБ       | 128K     | Чат/ассистент                      |
| Llama-3.2-90B-Vision-Instruct | 90B       | 180 ГБ      | 128K     | Продакшен                          |

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

**Docker-образ:**

```
vllm/vllm-openai:latest
```

**Порты:**

```
22/tcp
8000/http
```

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

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.2-11B-Vision-Instruct \\
    --host 0.0.0.0 \
    --port 8000 \\
    --max-model-len 8192
```

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

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

1. Перейдите на **Мои заказы** страницу
2. Нажмите на свой заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

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

## Требования к оборудованию

{% hint style="warning" %}
**Многопроцессорные конфигурации с GPU класса 80GB не представлены на маркетплейсе Clore.ai.** Самые крупные доступные сейчас машины — это 4× RTX PRO 6000 Blackwell (по 96GB, всего 380GB) и 8–11× RTX 5090 (по 32GB). Ёмкость A100 / H200 / B200 продаётся как [голое железо](https://clore.ai/bare-metal) по запросу. Проверьте [Цены и доступность GPU](/guides/guides_v2-ru/nachalo-raboty/pricing.md) перед выбором размера развёртывания.
{% endhint %}

| Модель     | Минимальная GPU | Рекомендуется | Оптимально |
| ---------- | --------------- | ------------- | ---------- |
| 11B Vision | RTX 4090 24GB   | A100 40 ГБ    | A100 80 ГБ |
| 90B Vision | 4x A100 40GB    | 4x A100 80GB  | 8x H100    |

## Установка

### С помощью Ollama (самый простой способ)

```bash
# Загрузить модель
ollama pull llama3.2-vision:11b

# Запустить интерактивно
ollama run llama3.2-vision:11b
```

### С помощью vLLM

```bash
pip install vllm

python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.2-11B-Vision-Instruct \\
    --host 0.0.0.0 \
    --port 8000
```

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

```python
import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor

model_id = "meta-llama/Llama-3.2-11B-Vision-Instruct"

model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
processor = AutoProcessor.from_pretrained(model_id)
```

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

### Понимание изображений

```python
import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor
from PIL import Image
import requests

model_id = "meta-llama/Llama-3.2-11B-Vision-Instruct"

model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
processor = AutoProcessor.from_pretrained(model_id)

# Загрузить изображение
url = "https://example.com/image.jpg"
image = Image.open(requests.get(url, stream=True).raw)

# Создать запрос
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Что находится на этом изображении? Опишите подробно."}
        ]
    }
]

input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(image, input_text, return_tensors="pt").to(model.device)

output = model.generate(**inputs, max_new_tokens=500)
print(processor.decode(output[0], skip_special_tokens=True))
```

### С Ollama

```bash
# Описать изображение
ollama run llama3.2-vision:11b "Опишите это изображение: /path/to/image.jpg"

# Или используйте API
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2-vision:11b",
  "prompt": "Что на этом изображении?",
  "images": ["base64_encoded_image_here"]
}'
```

### С API vLLM

```python
from openai import OpenAI
import base64

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

# Закодировать изображение в base64
with open("image.jpg", "rb") as f:
    image_base64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="meta-llama/Llama-3.2-11B-Vision-Instruct",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Что на этом изображении?"},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"}
                }
            ]
        }
    ],
    max_tokens=500
)

print(response.choices[0].message.content)
```

## Сценарии использования

### OCR / Извлечение текста

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Извлеките весь текст из этого изображения. Форматируйте как markdown."}
        ]
    }
]
```

### Анализ документа

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Проанализируйте этот документ. Кратко изложите основные моменты."}
        ]
    }
]
```

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

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Сколько людей на этой фотографии? Что они делают?"}
        ]
    }
]
```

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

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Напишите подробную подпись к этому изображению, подходящую для социальных сетей."}
        ]
    }
]
```

### Код из скриншотов

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "text", "text": "Преобразуйте этот скриншот интерфейса в HTML/CSS-код."}
        ]
    }
]
```

## Несколько изображений

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image"},
            {"type": "image"},
            {"type": "text", "text": "Сравните эти два изображения. В чем различия?"}
        ]
    }
]

# Обработать несколько изображений
inputs = processor(
    images=[image1, image2],
    text=input_text,
    return_tensors="pt"
).to(model.device)
```

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

```python
import os
from PIL import Image

def process_images(image_paths, prompt):
    results = []

    for path in image_paths:
        image = Image.open(path)

        messages = [
            {
                "role": "user",
                "content": [
                    {"type": "image"},
                    {"type": "text", "text": prompt}
                ]
            }
        ]

        input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
        inputs = processor(image, input_text, return_tensors="pt").to(model.device)

        output = model.generate(**inputs, max_new_tokens=300)
        result = processor.decode(output[0], skip_special_tokens=True)

        results.append({"file": path, "description": result})

        # Очистить кэш между изображениями
        torch.cuda.empty_cache()

    return results

# Обработать папку
images = [f"./images/{f}" for f in os.listdir("./images") if f.endswith(('.jpg', '.png'))]
results = process_images(images, "Опишите это изображение в одном абзаце.")
```

## Интерфейс Gradio

```python
import gradio as gr
import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor
from PIL import Image

model_id = "meta-llama/Llama-3.2-11B-Vision-Instruct"
model = MllamaForConditionalGeneration.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto"
)
processor = AutoProcessor.from_pretrained(model_id)

def analyze_image(image, question):
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "image"},
                {"type": "text", "text": question}
            ]
        }
    ]

    input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
    inputs = processor(image, input_text, return_tensors="pt").to(model.device)

    output = model.generate(**inputs, max_new_tokens=500)
    return processor.decode(output[0], skip_special_tokens=True)

demo = gr.Interface(
    fn=analyze_image,
    inputs=[
        gr.Image(type="pil", label="Загрузить изображение"),
        gr.Textbox(label="Вопрос", placeholder="Что на этом изображении?")
    ],
    outputs=gr.Textbox(label="Ответ"),
    title="Llama 3.2 Vision - Анализ изображений",
    description="Загрузите изображение и задавайте о нем вопросы. Работает на CLORE.AI."
)

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

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

| Задача                              | Модель | GPU        | Время  |
| ----------------------------------- | ------ | ---------- | ------ |
| Описание одного изображения         | 11B    | RTX 4090   | \~3 с  |
| Описание одного изображения         | 11B    | A100 40 ГБ | \~2 с  |
| OCR (1 страница)                    | 11B    | RTX 4090   | \~5 с  |
| Анализ документа                    | 11B    | A100 40 ГБ | \~8 с  |
| Пакетная обработка (10 изображений) | 11B    | A100 40 ГБ | \~25 с |

## Квантование

### 4-бит с bitsandbytes

```python
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16
)

model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    quantization_config=quantization_config,
    device_map="auto"
)
```

### GGUF с Ollama

```bash
# 4-битная квантизованная (помещается в 8 ГБ VRAM)
ollama pull llama3.2-vision:11b-q4_K_M

# 8-битная квантизованная
ollama pull llama3.2-vision:11b-q8_0
```

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

Типичные расценки маркетплейса CLORE.AI:

| GPU           | Почасовая ставка | Лучше всего для           |
| ------------- | ---------------- | ------------------------- |
| RTX 4090 24GB | \~$0.10          | Модель 11B                |
| A100 40 ГБ    | \~$0.17          | 11B с длинным контекстом  |
| A100 80 ГБ    | \~$0.25          | 11B — оптимальный вариант |
| 4x A100 80GB  | \~$1.00          | Модель 90B                |

*Цены варьируются. Проверьте* [*маркетплейс CLORE.AI*](https://clore.ai/marketplace) *актуальные тарифы.*

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

* Используйте **Spot** для пакетной обработки
* Платите **CLORE** токенами
* Используйте квантизованные модели (4-бит) для разработки

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

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

```python
# Используйте 4-битную квантизацию
model = MllamaForConditionalGeneration.from_pretrained(
    model_id,
    load_in_4bit=True,
    device_map="auto"
)

# Или уменьшите max_new_tokens
output = model.generate(**inputs, max_new_tokens=256)
```

### Медленная генерация

* Убедитесь, что используется GPU (проверьте `nvidia-smi`)
* Используйте bfloat16 вместо float32
* Уменьшите разрешение изображения перед обработкой
* Используйте vLLM для большей пропускной способности

### Изображение не загружается

```python
from PIL import Image
import requests
from io import BytesIO

# Из URL
response = requests.get(url)
image = Image.open(BytesIO(response.content)).convert("RGB")

# Из файла
image = Image.open("path/to/image.jpg").convert("RGB")

# Измените размер, если слишком большой
max_size = 1024
if max(image.size) > max_size:
    image.thumbnail((max_size, max_size))
```

### Требуется токен HuggingFace

```bash
# Установите токен для моделей с ограниченным доступом
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx

# Или войдите в систему
huggingface-cli login
```

## Llama Vision против других

| Функция               | Llama 3.2 Vision | LLaVA 1.6    | GPT-4V     |
| --------------------- | ---------------- | ------------ | ---------- |
| Параметры             | 11B / 90B        | 7B / 34B     | Неизвестно |
| Открытый исходный код | Да               | Да           | Нет        |
| Качество OCR          | Отлично          | Хорошо       | Отлично    |
| Контекст              | 128K             | 32K          | 128K       |
| Несколько изображений | Да               | Ограниченная | Да         |
| Лицензия              | Llama 3.2        | Apache 2.0   | Закрытый   |

**Используйте Llama 3.2 Vision, если:**

* Нужна мультимодальная модель с открытым исходным кодом
* OCR и анализ документов
* Интеграция с экосистемой Llama
* Понимание длинного контекста

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

* [LLaVA](/guides/guides_v2-ru/modeli-dlya-zreniya/llava-vision-language.md) - Альтернативная модель для зрения
* [Florence-2](/guides/guides_v2-ru/modeli-dlya-zreniya/florence2.md) - Модель зрения от Microsoft
* [компонент](/guides/guides_v2-ru/yazykovye-modeli/ollama.md) - Простое развертывание
* [vLLM](/guides/guides_v2-ru/yazykovye-modeli/vllm.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/llama-vision.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.