> 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/yazykovye-modeli/deepseek-r1.md).

# Модель рассуждений DeepSeek-R1

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

## Обзор

DeepSeek-R1 — это reasoning-модель с открытыми весами и 671 млрд параметров, выпущенная в январе 2025 года компанией DeepSeek под **Apache 2.0** лицензией. Это первая открытая модель, сопоставимая с OpenAI o1 по задачам математики, программирования и научным бенчмаркам — при этом она раскрывает всю цепочку рассуждений через явные `<think>` теги.

Полная модель использует **Mixture-of-Experts (MoE)** с 37 млрд активных параметров на токен, что делает инференс осуществимым, несмотря на впечатляющее общее число параметров. Для большинства практиков **дистиллированные варианты** (1.5B → 70B) более практичны: они наследуют паттерны рассуждений R1 через дистилляцию знаний в базовые архитектуры Qwen-2.5 и Llama-3 и работают на обычных GPU.

## Ключевые особенности

* **Явная цепочка рассуждений** — каждый ответ начинается с `<think>` блока, где модель рассуждает, возвращается назад и сама исправляет себя перед выдачей финального ответа
* **Обученная с подкреплением** — способность к рассуждению возникает из сигналов награды RL, а не из вручную созданных данных цепочки рассуждений
* **Шесть дистиллированных вариантов** — модели с 1.5B, 7B, 8B, 14B, 32B и 70B параметрами, дистиллированные из полной 671B-модели в архитектуры Qwen и Llama
* **лицензии Apache 2.0** — полностью коммерческое использование, без роялти и ограничений на применение
* **Широкая поддержка фреймворков** — Ollama, vLLM, llama.cpp, SGLang, Transformers, TGI работают из коробки
* **AIME 2024 Pass\@1: 79.8%** — наравне с OpenAI o1 по олимпиадной математике
* **Codeforces 2029 Elo** — превосходит 1891 у o1 в соревновательном программировании

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

| Вариант                  | Параметры                   | Архитектура  | VRAM FP16 | Q4 VRAM  | Q4 Disk  |
| ------------------------ | --------------------------- | ------------ | --------- | -------- | -------- |
| DeepSeek-R1 (полная MoE) | 671 млрд (37 млрд активных) | DeepSeek MoE | \~1.3 ТБ  | \~350 ГБ | \~340 ГБ |
| R1-Distill-Llama-70B     | 70B                         | Llama 3      | 140 ГБ    | 40 ГБ    | 42 ГБ    |
| R1-Distill-Qwen-32B      | 32B                         | Qwen 2.5     | 64 ГБ     | 22 ГБ    | 20 ГБ    |
| R1-Distill-Qwen-14B      | 14B                         | Qwen 2.5     | 28 ГБ     | 10 ГБ    | 9 ГБ     |
| R1-Distill-Llama-8B      | 8B                          | Llama 3      | 16 ГБ     | 6 ГБ     | 5.5 ГБ   |
| R1-Distill-Qwen-7B       | 7B                          | Qwen 2.5     | 14 ГБ     | 5 ГБ     | 4.5 ГБ   |
| R1-Distill-Qwen-1.5B     | 1.5B                        | Qwen 2.5     | 3 ГБ      | 2 ГБ     | 1.2 ГБ   |

### Выбор варианта

| Сценарий использования                          | Рекомендуемый вариант  | GPU на Clore                                                                                                                 |
| ----------------------------------------------- | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Быстрые эксперименты, тестирование на краю      | R1-Distill-Qwen-1.5B   | Любая GPU                                                                                                                    |
| Бюджетный деплой, быстрый инференс              | R1-Distill-Qwen-7B     | RTX 3090 ($0.07–0.21/ч)                                                                                                      |
| Оптимальный вариант для продакшена на одной GPU | R1-Distill-Qwen-14B Q4 | [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) ($0.14–0.42/ч)       |
| Лучшее качество за свои деньги (рекомендуется)  | R1-Distill-Qwen-32B Q4 | [RTX 4090 24 GB](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) или A100 40 ГБ |
| Максимальное качество дистилляции               | R1-Distill-Llama-70B   | 2× A100 80 ГБ                                                                                                                |
| Исследования, рассуждения с полной точностью    | DeepSeek-R1 671B       | кластер 8× H100                                                                                                              |

### Репозитории HuggingFace

| Вариант           | Репозиторий                                                                                                   |
| ----------------- | ------------------------------------------------------------------------------------------------------------- |
| Полный R1         | [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| Llama-70B distill | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Qwen-32B distill  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Qwen-14B distill  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Llama-8B distill  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Qwen-7B distill   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Qwen-1.5B distill | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B) |

## Требования

{% 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 %}

| Компонент     | Минимальный (7B Q4) | Рекомендуемый (32B Q4) |
| ------------- | ------------------- | ---------------------- |
| VRAM GPU      | 6 ГБ                | 24 ГБ                  |
| Системная RAM | 16 ГБ               | 32 ГБ                  |
| Диск          | 10 ГБ               | 30 ГБ                  |
| CUDA          | 12.8+               | 12.8+                  |
| Docker        | 24.0+               | 25.0+                  |

## Быстрый старт с Ollama

Ollama автоматически обрабатывает квантизацию, загрузку и обслуживание — самый быстрый путь к запущенному DeepSeek-R1.

### Установить и запустить

```bash
# Установите Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Скачайте и запустите (выберите свой вариант):
ollama run deepseek-r1:1.5b    # Край / тестирование
ollama run deepseek-r1:7b      # Бюджет — подходит для любой GPU от 8 ГБ
ollama run deepseek-r1:14b     # Оптимальный вариант для RTX 4090
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 80 ГБ
```

### Пример интерактивного сеанса

```
>>> Докажите, что √2 иррационально.

<think>
Я использую доказательство от противного.
Предположим, что √2 рационально, то есть √2 = p/q, где p,q — целые числа и gcd(p,q) = 1.
Тогда 2 = p²/q², откуда p² = 2q².
Это означает, что p² — чётное, значит, p должно быть чётным. Пусть p = 2k.
Подставим: (2k)² = 2q² → 4k² = 2q² → q² = 2k².
Значит, q² тоже чётное, то есть q — чётное.
Но если p и q оба чётные, то gcd(p,q) ≥ 2, что противоречит нашему предположению.
</think>

**Доказательство того, что √2 иррационально (от противного):**

Предположим, что √2 = p/q в несократимом виде (gcd(p,q) = 1). Возведём в квадрат: p² = 2q².
Так как p² чётное, p чётное — пусть p = 2k. Тогда 4k² = 2q², значит q² = 2k²,
то есть q тоже чётное. Это противоречит gcd(p,q) = 1. ∎
```

### Используйте API, совместимый с OpenAI

```bash
# Запустите Ollama как сервер (если он ещё не запущен)
ollama serve &

# Запрос через curl
curl -s http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "Разложите x^4 - 1 на множители полностью над целыми числами."}],
    "temperature": 0.6
  }' | python3 -m json.tool
```

### Клиент Python (через OpenAI SDK)

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="deepseek-r1:32b",
    messages=[
        {"role": "user", "content": "Напишите функцию Python для поиска самой длинной палиндромной подстроки."}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)
```

## Production-настройка vLLM

vLLM обеспечивает максимальную пропускную способность для многопользовательского обслуживания благодаря непрерывному batching, PagedAttention и кэшированию префиксов.

### Одна GPU — 7B / 14B

```bash
pip install vllm

# 7B на любой GPU от 16 ГБ
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

# 14B на RTX 4090 (24 ГБ)
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-14B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.92
```

### Несколько GPU — 32B (рекомендуется)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90 \
    --enable-prefix-caching
```

> **Совет:** Контрольная точка 32B Q4 GPTQ или AWQ помещается на одну RTX 4090 (24 ГБ):
>
> ```bash
> vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
>     --quantization awq --host 0.0.0.0 --port 8000 \
>     --max-model-len 16384
> ```

### Несколько GPU — 70B

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90
```

### Запрос к конечной точке vLLM

```bash
curl -s http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    "messages": [{"role": "user", "content": "Решите: найдите все простые p, такие что p^2 + 2 тоже простое."}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'
```

## Transformers / Python (с `<think>` парсингом тегов)

Используйте HuggingFace Transformers, когда нужен тонкий контроль над генерацией или когда вы хотите встроить R1 в Python-пайплайн.

### Базовая генерация

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

MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"

tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

prompt = "Чему равна сумма первых 100 положительных целых чисел?"
messages = [{"role": "user", "content": prompt}]
input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=2048,
        temperature=0.6,
        do_sample=True,
    )

full_response = tokenizer.decode(output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
print(full_response)
```

### Парсинг `<think>` тегами

```python
def parse_r1_response(text: str) -> dict:
    """Разделить ответ DeepSeek-R1 на части размышления и ответа."""
    think_match = re.search(r"<think>(.*?)</think>", text, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
    return {
        "thinking": thinking,
        "answer": answer,
        "thinking_tokens": len(thinking.split()),
    }

result = parse_r1_response(full_response)
print(f"Модель рассуждала {result['thinking_tokens']} слов")
print(f"Ответ: {result['answer']}")
```

### Потоковая передача с `<think>` отслеживанием состояния

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="unused")

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[{"role": "user", "content": "Выведите квадратную формулу из ax² + bx + c = 0."}],
    stream=True,
    max_tokens=4096,
    temperature=0.6,
)

in_think = False
for chunk in stream:
    token = chunk.choices[0].delta.content or ""
    if "<think>" in token:
        in_think = True
        print("[Рассуждение] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[Ответ] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()
```

## Развёртывание Docker на Clore.ai

### Docker Ollama (самый простой)

**Docker-образ:** `ollama/ollama` **Порты:** `22/tcp, 11434/http`

```bash
# На инстансе Clore
docker run -d --gpus all \\
    -v ollama_data:/root/.ollama \\
    -p 11434:11434 \\
    --name deepseek-r1 \\
    ollama/ollama

# Скачайте и запустите модель
docker exec deepseek-r1 ollama pull deepseek-r1:32b
```

### Docker vLLM (продакшен)

**Docker-образ:** `vllm/vllm-openai:latest` **Порты:** `22/tcp, 8000/http`

```yaml
# docker-compose.yml
version: "3.8"
services:
  deepseek-r1:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN:-}
    command: >
      --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
      --host 0.0.0.0 --port 8000
      --tensor-parallel-size 2
      --max-model-len 32768
      --gpu-memory-utilization 0.90
      --enable-prefix-caching
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 300s
volumes:
  hf_cache:
```

Развёртывание на Clore.ai:

1. Открыть [clore.ai/marketplace](https://clore.ai/marketplace)
2. Фильтр по **2× GPU, всего 48 ГБ+ VRAM** (например, 2× RTX 4090 или A100 80 ГБ)
3. Установите Docker-образ в `vllm/vllm-openai:latest`
4. Назначьте порт **8000** как HTTP
5. Вставьте команду из compose-файла выше в команду запуска
6. Подключайтесь через HTTP endpoint после прохождения проверки работоспособности

## Советы по развёртыванию на Clore.ai

### Выбор подходящей GPU

| Бюджетная        | GPU              | Ежедневная стоимость | Лучший вариант                      |
| ---------------- | ---------------- | -------------------- | ----------------------------------- |
| Минимальная      | RTX 3090 (24 ГБ) | $0.30 – 1.00         | R1-Distill-Qwen-7B или 14B Q4       |
| Стандартный      | RTX 4090 (24 ГБ) | $0.50 – 2.00         | R1-Distill-Qwen-14B FP16 или 32B Q4 |
| Продакшен        | A100 80 ГБ       | $3 – 8               | R1-Distill-Qwen-32B FP16            |
| Высокое качество | 2× A100 80 ГБ    | $6 – 16              | R1-Distill-Llama-70B FP16           |

### Настройка производительности

* **Температура 0.6** — рекомендуемое значение по умолчанию для задач рассуждения; в собственных статьях DeepSeek используется именно оно
* **Установите `max_tokens` щедро** — reasoning-модели генерируют длинные `<think>` блоки; 4096+ для нетривиальных задач
* **Включите кэширование префиксов** (`--enable-prefix-caching` в vLLM) при использовании общего системного промпта
* **Ограничьте параллелизм** (`--max-num-seqs 16`) для задач рассуждения — каждый запрос требует больше вычислений, чем обычный чат
* **Используйте квантизацию Q4** чтобы разместить 32B на одной GPU 24 ГБ с минимальной потерей качества (дистилляция уже сжала знания R1)

### Соображения по длине контекста

Reasoning-модели потребляют больше контекста, чем стандартные чат-модели, из-за `<think>` блока:

| Сложность задачи                      | Типичная длина размышлений | Необходимый общий контекст |
| ------------------------------------- | -------------------------- | -------------------------- |
| Простая арифметика                    | \~100 токенов              | \~300 токенов              |
| Генерация кода                        | \~500–1000 токенов         | \~2000 токенов             |
| Олимпиадная математика (AIME)         | \~2000–4000 токенов        | \~5000 токенов             |
| Многошаговый исследовательский анализ | \~4000–8000 токенов        | \~10000 токенов            |

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

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

```bash
# Уменьшите длину контекста
--max-model-len 8192    # вместо 32768

# Ограничьте число одновременных последовательностей
--max-num-seqs 8

# Используйте квантизацию
--quantization awq      # или gptq
```

### Модель не выдаёт `<think>` блок

Некоторые системные промпты подавляют размышления. Избегайте инструкций вроде «будьте кратки» или «не объясняйте свои рассуждения». Используйте минимальный системный промпт или вообще без него:

```python
# Хорошо — сохраняет рассуждение
messages = [{"role": "user", "content": "..."}]

# Плохо — может подавлять размышления
messages = [
    {"role": "system", "content": "Будьте предельно кратки. Без объяснений."},
    {"role": "user", "content": "..."}
]
```

### Повторяющийся или зацикленный `<think>` вывод

Уменьшите температуру, чтобы снизить случайность в цепочке рассуждений:

```python
temperature = 0.0   # Детерминированно — лучше всего для математики/кода
temperature = 0.3   # Небольшие вариации — хорошо для анализа
```

### Медленный первый токен (высокий TTFT)

Это ожидаемо — модель генерирует `<think>` токены до видимого ответа. Для приложений, чувствительных к задержке, когда рассуждения не нужны, используйте [DeepSeek-V3](/guides/guides_v2-ru/yazykovye-modeli/deepseek-v3.md) вместо этого.

### Загрузка зависает на инстансе Clore

Скачивание с HuggingFace может быть медленным у некоторых провайдеров. Предзагрузите модель в постоянный том:

```bash
# Один раз загрузите в том
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \\
    --local-dir /data/models/deepseek-r1-32b

# Укажите vLLM локальный путь
vllm serve /data/models/deepseek-r1-32b --host 0.0.0.0 --port 8000
```

## Дополнительное чтение

* [Статья DeepSeek-R1](https://arxiv.org/abs/2501.12948) — *Стимулирование способности к рассуждению в LLM с помощью обучения с подкреплением*
* [GitHub DeepSeek-R1](https://github.com/deepseek-ai/DeepSeek-R1) — Официальный репозиторий с model cards
* [Руководство по DeepSeek-V3](/guides/guides_v2-ru/yazykovye-modeli/deepseek-v3.md) — Универсальная модель без рассуждений из той же лаборатории
* [Руководство по vLLM](/guides/guides_v2-ru/yazykovye-modeli/vllm.md) — Полная настройка продакшен-обслуживания
* [Руководство по Ollama](/guides/guides_v2-ru/yazykovye-modeli/ollama.md) — Простое локальное развёртывание для любой модели
* [Руководство по Open WebUI](/guides/guides_v2-ru/yazykovye-modeli/open-webui.md) — Чат-интерфейс с нативным `<think>` рендерингом тегов
* [Руководство по Qwen 2.5](/guides/guides_v2-ru/yazykovye-modeli/qwen25.md) — Базовая архитектура, используемая большинством дистиллятов R1


---

# 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/yazykovye-modeli/deepseek-r1.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.