# 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](/guides/guides_v2-ru/yazykovye-modeli/vllm.md) - Производственное развертывание
* [Ollama](/guides/guides_v2-ru/yazykovye-modeli/ollama.md) - Простая локальная настройка
* [DeepSeek-V3](/guides/guides_v2-ru/yazykovye-modeli/deepseek-v3.md) - Более крупная модель для рассуждений
* [DeepSeek-R1](/guides/guides_v2-ru/yazykovye-modeli/deepseek-r1.md) - Открытая модель для рассуждений
* [Донастройка LLM](/guides/guides_v2-ru/obuchenie/finetune-llm.md) - Пользовательская дообучение


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/qwen25.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.