# Qwen2.5

Запустите семейство моделей Qwen2.5 от Alibaba — мощные многоязычные LLM с отличными возможностями в кодировании и математике на GPU CLORE.AI.

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

## Почему Qwen2.5?

* **Разнообразие размеров** - От 0.5B до 72B параметров
* **Мультиязычность** - 29 языков, включая китайский
* **Длинный контекст** - До 128K токенов
* **Специализированные варианты** - Выпуски Coder, Math
* **Открытый исходный код** - Лицензия Apache 2.0

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

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

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

**Порты:**

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

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

```bash
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000
```

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

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

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

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

### Проверьте, что всё работает

```bash
# Проверить, готова ли служба
curl https://your-http-pub.clorecloud.net/health

# Показать доступные модели
curl https://your-http-pub.clorecloud.net/v1/models
```

{% hint style="warning" %}
Если вы получаете HTTP 502, подождите 5–15 минут — модель всё ещё скачивается с HuggingFace.
{% endhint %}

## Режим рассуждения Qwen3

{% hint style="info" %}
**Новое в Qwen3:** Некоторые модели Qwen3 поддерживают режим рассуждения, который показывает процесс мышления модели в `<think>` тегах перед окончательным ответом.
{% endhint %}

При использовании моделей Qwen3 через vLLM ответы могут включать рассуждения:

```json
{
  "content": "<think>\nПозвольте мне подумать об этом шаг за шагом...\n</think>\n\nОтвет таков..."
}
```

Чтобы использовать Qwen3 с рассуждением:

```bash
vllm serve Qwen/Qwen3-0.6B --host 0.0.0.0 --port 8000
```

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

### Базовые модели

| Модель               | Параметры | VRAM (FP16) | Контекст | Примечания                    |
| -------------------- | --------- | ----------- | -------- | ----------------------------- |
| Qwen2.5-0.5B         | 0.5B      | 2GB         | 32K      | Edge/тестирование             |
| Qwen2.5-1.5B         | 1.5B      | 4 ГБ        | 32K      | Очень лёгкая                  |
| Qwen2.5-3B           | 3B        | 8GB         | 32K      | Бюджетная                     |
| Qwen2.5-7B           | 7B        | 16GB        | 128K     | Сбалансировано                |
| Qwen2.5-14B          | 14B       | 32GB        | 128K     | Высокое качество              |
| Qwen2.5-32B          | 32B       | 70GB        | 128K     | Очень высокое качество        |
| Qwen2.5-72B          | 72B       | 150GB       | 128K     | **Лучшее качество**           |
| Qwen2.5-72B-Instruct | 72B       | 150GB       | 128K     | Настроена для чата/инструкций |

### Специализированные варианты

| Модель                     | Фокус      | Лучше всего для                | VRAM (FP16) |
| -------------------------- | ---------- | ------------------------------ | ----------- |
| Qwen2.5-Coder-7B-Instruct  | Код        | Программирование, отладка      | 16GB        |
| Qwen2.5-Coder-14B-Instruct | Код        | Сложные задачи с кодом         | 32GB        |
| Qwen2.5-Coder-32B-Instruct | Код        | **Лучшая модель для кода**     | 70GB        |
| Qwen2.5-Math-7B-Instruct   | Математика | Вычисления, доказательства     | 16GB        |
| Qwen2.5-Math-72B-Instruct  | Математика | Математика уровня исследований | 150GB       |
| Qwen2.5-Instruct           | Чат        | Общий ассистент                | различается |

## Требования к аппаратному обеспечению

| Модель    | Минимальная GPU | Рекомендуется | VRAM (Q4) |
| --------- | --------------- | ------------- | --------- |
| 0.5B-3B   | RTX 3060 12GB   | RTX 3080      | 2-6GB     |
| 7B        | RTX 3090 24GB   | RTX 4090      | 6 ГБ      |
| 14B       | A100 40GB       | A100 80GB     | 12GB      |
| 32B       | A100 80GB       | 2x A100 40GB  | 22GB      |
| 72B       | 2x A100 80GB    | 4x A100 80GB  | 48GB      |
| Coder-32B | A100 80GB       | 2x A100 40GB  | 22GB      |

## Установка

### Использование vLLM (рекомендуется)

```bash
pip install vllm==0.7.3

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000
```

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

```bash
# Стандартные модели
ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull qwen2.5:72b       # Новое: крупнейший Qwen2.5

# Специализированные
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:32b  # Новое: лучшая модель для кода

# Запуск чата
ollama run qwen2.5:7b
```

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

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "Qwen/Qwen2.5-7B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

messages = [{"role": "user", "content": "Hello!"}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer([text], return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

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

### Совместимый с OpenAI API

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="не_требуется"
)

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain machine learning in simple terms."}
    ],
    temperature=0.7,
    max_tokens=500
)

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

### Потоковая передача (Streaming)

```python
stream = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Напишите стихотворение об ИИ"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

### cURL

```bash
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen2.5-7B-Instruct",
        "messages": [
            {"role": "user", "content": "Что такое Python?"}
        ]
    }'
```

## Qwen2.5-72B-Instruct

Флагманская модель Qwen2.5 — самая большая и способная в семействе. Она сопоставима с GPT-4 по многим бенчмаркам и полностью открыта под лицензией Apache 2.0.

### Запуск через vLLM (мульти-GPU)

```bash
# Конфигурация 4x A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9

# Квантование AWQ — запускается на 2x A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --quantization awq \
    --max-model-len 32768
```

### Запуск через Ollama

```bash
# Скачивание модели 72B (требуется 48GB+ VRAM для Q4)
ollama pull qwen2.5:72b

# Запуск интерактивной сессии
ollama run qwen2.5:72b

# Доступ через API
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:72b",
  "messages": [{"role": "user", "content": "Analyze this complex scenario..."}],
  "stream": false
}'
```

### Пример на Python

```python
from openai import OpenAI

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

# Модель 72B превосходна в сложных аналитических задачах
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Вы эксперт-аналитик. Предоставляйте подробные, нюансированные ответы."
        },
        {
            "role": "user",
            "content": """Сравните архитектурные различия между трансформером и 
            пространственными моделями состояния (SSM) для моделирования последовательностей. Включите компромиссы по эффективности."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

## Qwen2.5-Coder-32B-Instruct

Лучшая доступная открытая модель для кода. Qwen2.5-Coder-32B-Instruct сопоставима или превосходит GPT-4o по многим тестам на кодирование, поддерживая более 40 языков программирования.

### Запуск через vLLM

```bash
# Один A100 80GB
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.9

# Две RTX 4090 (24GB каждая = 48GB всего, с использованием квантования Q4)
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 2 \
    --quantization awq
```

### Запуск через Ollama

```bash
# Скачивание Coder-32B (требуется ~22GB VRAM для Q4)
ollama pull qwen2.5-coder:32b

# Запустить
ollama run qwen2.5-coder:32b

# Тест с подсказкой для кодирования
ollama run qwen2.5-coder:32b "Write a Python async web scraper using aiohttp"
```

### Примеры генерации кода

```python
from openai import OpenAI

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

# Генерация full-stack кода
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Вы эксперт-программист. Пишите чистый, готовый к продакшену код с надёжной обработкой ошибок и документацией."
        },
        {
            "role": "user",
            "content": """Напишите сервис на Python с FastAPI, который:
1. Принимает POST /summarize с JSON телом {"text": "...", "max_length": 150}
2. Использует локальный экземпляр Ollama для суммирования текста
3. Возвращает {"summary": "...", "original_length": N, "summary_length": N}
4. Включает корректную обработку ошибок, валидацию входа с Pydantic и поддержку async"""
        }
    ],
    temperature=0.1,  # Низкая температура для кода
    max_tokens=3000
)

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

````python
# Ревью кода и отладка
code_to_review = """
def find_duplicates(lst):
    seen = []
    duplicates = []
    for item in lst:
        if item in seen:
            duplicates.append(item)
        seen.append(item)
    return duplicates
"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "user",
            "content": f"Просмотрите этот Python-код на предмет проблем с производительностью и предложите улучшения:\n\n```python\n{code_to_review}\n```"
        }
    ],
    temperature=0.3
)

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

## Qwen2.5-Coder

Оптимизировано для генерации кода:

```bash
# Использование vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-7B-Instruct \
    --host 0.0.0.0

# Использование Ollama
ollama run qwen2.5-coder:7b
```

```python
prompt = """Напишите функцию на Python, которая:
1. Принимает список чисел
2. Возвращает медиану
3. Корректно обрабатывает пустые списки
Включите подсказки типов и докстринги."""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2
)

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

## Qwen2.5-Math

Специализирована для математического рассуждения:

```bash
# Использование vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Math-7B-Instruct \
    --host 0.0.0.0
```

```python
prompt = """Решите шаг за шагом:
Найдите все значения x, при которых: x^3 - 6x^2 + 11x - 6 = 0"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Math-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1
)

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

## Многоязычная поддержка

Qwen2.5 поддерживает 29 языков:

```python
# Китайский
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "用中文解释什么是人工智能"}]
)

# Japanese
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "人工知能について日本語で説明してください"}]
)

# Корейский
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "인공지능에 대해 한국어로 설명해주세요"}]
)
```

## Длинный контекст (128K)

```python
# Прочитать длинный документ
with open("long_document.txt", "r") as f:
    document = f.read()

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "user", "content": f"Суммируйте этот документ:\n\n{document}"}
    ],
    max_tokens=2000
)
```

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

### GGUF с Ollama

```bash
# 4-битное квантование
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:72b-instruct-q4_K_M   # 72B в 4-бит (~48GB)

# 8-битная квантизация
ollama pull qwen2.5:7b-instruct-q8_0

# Варианты Coder
ollama pull qwen2.5-coder:32b-instruct-q4_K_M
```

### AWQ с vLLM

```bash
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-72B-Instruct-AWQ \
    --quantization awq \
    --tensor-parallel-size 2
```

### GGUF с llama.cpp

```bash
# Скачивание GGUF
wget https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q4_k_m.gguf

# Запустить сервер
./llama-server -m qwen2.5-7b-instruct-q4_k_m.gguf \
    --host 0.0.0.0 \
    --port 8080 \
    -ngl 35
```

## Настройка Multi-GPU

### Тензорный параллелизм

```bash
# 72B на 4 GPU
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-72B-Instruct \
    --tensor-parallel-size 4 \
    --max-model-len 32768

# 32B на 2 GPU
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-32B-Instruct \
    --tensor-parallel-size 2

# Coder-32B на 2 GPU
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-32B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 16384
```

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

### Пропускная способность (токенов/сек)

| Модель            | RTX 3090 | RTX 4090 | A100 40GB | A100 80GB |
| ----------------- | -------- | -------- | --------- | --------- |
| Qwen2.5-0.5B      | 250      | 320      | 380       | 400       |
| Qwen2.5-3B        | 150      | 200      | 250       | 280       |
| Qwen2.5-7B        | 75       | 100      | 130       | 150       |
| Qwen2.5-7B Q4     | 110      | 140      | 180       | 200       |
| Qwen2.5-14B       | -        | 55       | 70        | 85        |
| Qwen2.5-32B       | -        | -        | 35        | 50        |
| Qwen2.5-72B       | -        | -        | 20 (2x)   | 40 (2x)   |
| Qwen2.5-72B Q4    | -        | -        | -         | 55 (2x)   |
| Qwen2.5-Coder-32B | -        | -        | 32        | 48        |

### Время до первого токена (TTFT)

| Модель | RTX 4090 | A100 40GB  | A100 80GB  |
| ------ | -------- | ---------- | ---------- |
| 7B     | 60ms     | 40ms       | 35мс       |
| 14B    | 120ms    | 80 мс      | 60ms       |
| 32B    | -        | 200ms      | 140ms      |
| 72B    | -        | 400ms (2x) | 280ms (2x) |

### Длина контекста vs VRAM (7B)

| Контекст | FP16  | Q8    | Q4    |
| -------- | ----- | ----- | ----- |
| 8K       | 16GB  | 10GB  | 6 ГБ  |
| 32K      | 24 ГБ | 16GB  | 10GB  |
| 64K      | 40GB  | 26 ГБ | 16GB  |
| 128K     | 72GB  | 48GB  | 28 ГБ |

## Бенчмарки

| Модель            | MMLU  | HumanEval | GSM8K | MATH  | LiveCodeBench |
| ----------------- | ----- | --------- | ----- | ----- | ------------- |
| Qwen2.5-7B        | 74.2% | 75.6%     | 85.4% | 55.2% | 42.1%         |
| Qwen2.5-14B       | 79.7% | 81.1%     | 89.5% | 65.8% | 51.3%         |
| Qwen2.5-32B       | 83.3% | 84.2%     | 91.2% | 72.1% | 60.7%         |
| Qwen2.5-72B       | 86.1% | 86.2%     | 93.2% | 79.5% | 67.4%         |
| Qwen2.5-Coder-7B  | 72.8% | 88.4%     | 86.1% | 58.4% | 64.2%         |
| Qwen2.5-Coder-32B | 83.1% | **92.7%** | 92.3% | 76.8% | **78.5%**     |

## Docker Compose

```yaml
version: '3.8'

services:
  qwen:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    command: >
      --model Qwen/Qwen2.5-7B-Instruct
      --host 0.0.0.0
      --port 8000
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
```

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

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

| GPU           | Почасовая ставка | Лучше всего для           |
| ------------- | ---------------- | ------------------------- |
| RTX 3090 24GB | \~$0.06          | Модели 7B                 |
| RTX 4090 24GB | \~$0.10          | Модели 7B-14B             |
| A100 40GB     | \~$0.17          | Модели 14B-32B            |
| A100 80GB     | \~$0.25          | Модели 32B, Coder-32B     |
| 2x A100 80GB  | \~$0.50          | Модели 72B                |
| 4x A100 80GB  | \~$1.00          | 72B максимальный контекст |

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

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

* Используйте **Spot** рынок для гибких рабочих нагрузок
* Платите с помощью **CLORE** токенов
* Начните с меньших моделей (7B) для тестирования

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

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

```bash
# Уменьшить контекст
--max-model-len 8192

# Включите оптимизацию памяти
--gpu-memory-utilization 0.85

# Используйте квантованную модель
ollama pull qwen2.5:7b-instruct-q4_K_M
```

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

```bash
# Включить flash attention
pip install flash-attn

# Используйте vLLM для лучшей пропускной способности
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-prefix-caching
```

### Отображение китайских символов

```python
# Убедитесь в кодировке UTF-8
import sys
sys.stdout.reconfigure(encoding='utf-8')
```

### Модель не найдена

```bash
# Проверьте имя модели
huggingface-cli search Qwen/Qwen2.5

# Распространённые имена:
# Qwen/Qwen2.5-7B-Instruct
# Qwen/Qwen2.5-72B-Instruct       ← Новое
# Qwen/Qwen2.5-Coder-7B-Instruct
# Qwen/Qwen2.5-Coder-32B-Instruct ← Новое
# Qwen/Qwen2.5-Math-7B-Instruct
```

## Qwen2.5 против других

| Функция         | Qwen2.5-7B | Qwen2.5-72B | Llama 3.1 70B | GPT-4o        |
| --------------- | ---------- | ----------- | ------------- | ------------- |
| Контекст        | 128K       | 128K        | 128K          | 128K          |
| Мультиязычность | Отлично    | Отлично     | Хорошо        | Отлично       |
| Код             | Отлично    | Отлично     | Хорошо        | Отлично       |
| Математика      | Отлично    | Отлично     | Хорошо        | Отлично       |
| Китайский       | Отлично    | Отлично     | Плохо         | Хорошо        |
| Лицензия        | Apache 2.0 | Apache 2.0  | Llama 3.1     | Проприетарный |
| Стоимость       | Бесплатно  | Бесплатно   | Бесплатно     | Платное API   |

**Используйте Qwen2.5 когда:**

* Требуется поддержка китайского языка
* Приоритет — математические/кодовые задачи
* Требуется длинный контекст
* Хотите лицензию Apache 2.0
* Нужна лучшая открытая модель для кода (Coder-32B)

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

* [vLLM](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/vllm) - Производственное развертывание
* [Ollama](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/ollama) - Простая локальная настройка
* [DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/deepseek-v3) - Более крупная модель для рассуждений
* [DeepSeek-R1](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/deepseek-r1) - Открытая модель для рассуждений
* [Донастройка LLM](https://docs.clore.ai/guides/guides_v2-ru/obuchenie/finetune-llm) - Пользовательская дообучение