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

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

## Обзор

DeepSeek-R1 — открытая модель рассуждения с 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 в соревновательной математике
* **Elo на Codeforces 2029** — превосходит 1891 у o1 в соревновательном программировании

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

| Вариант                  | Параметры           | Архитектура  | FP16 VRAM | Q4 VRAM  | Q4 на диске |
| ------------------------ | ------------------- | ------------ | --------- | -------- | ----------- |
| DeepSeek-R1 (полный MoE) | 671B (37B активных) | 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 GB     | 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 GB     | 1.2 ГБ      |

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

| Случай использования                                  | Рекомендуемый вариант  | GPU на Clore                  |
| ----------------------------------------------------- | ---------------------- | ----------------------------- |
| Быстрые эксперименты, тестирование на периферии       | R1-Distill-Qwen-1.5B   | Любой GPU                     |
| Развертывание при ограниченном бюджете, быстрый вывод | R1-Distill-Qwen-7B     | RTX 3090 (\~$0.30–1/день)     |
| Оптимальное решение для продакшна на одном GPU        | R1-Distill-Qwen-14B Q4 | RTX 4090 (\~$0.50–2/день)     |
| Лучшее соотношение качества и цены (рекомендуется)    | R1-Distill-Qwen-32B Q4 | RTX 4090 24 ГБ или 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 | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Дистиллят Qwen-32B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Дистиллят Qwen-14B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Дистиллят Llama-8B  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Дистиллят Qwen-7B   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Дистиллят Qwen-1.5B | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B) |

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

| Компонент   | Минимум (7B Q4) | Рекомендуется (32B Q4) |
| ----------- | --------------- | ---------------------- |
| VRAM GPU    | 6 GB            | 24 ГБ                  |
| ОЗУ системы | 16 ГБ           | 32 ГБ                  |
| Диск        | 10 ГБ           | 30 GB                  |
| CUDA        | 12.1+           | 12.4+                  |
| 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)
```

## Настройка vLLM для продакшна

vLLM обеспечивает наивысшую пропускную способность для многопользовательского сервинга с непрерывной пакетизацией, 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 endpoint

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

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

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

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

**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-эндпоинт после прохождения health check

## Советы по развертыванию на 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 GB       | $3 – 8            | R1-Distill-Qwen-32B FP16            |
| Высокое качество | 2× A100 80 ГБ    | $6 – 16           | R1-Distill-Llama-70B FP16           |

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

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

### Особенности длины контекста

Модели рассуждений потребляют больше контекста, чем стандартные чат-модели, из-за `<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](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/deepseek-v3) вместо этого.

### Загрузка застревает на инстансе 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 с помощью обучения с подкреплением*
* [DeepSeek-R1 на GitHub](https://github.com/deepseek-ai/DeepSeek-R1) — Официальный репозиторий с карточками моделей
* [Руководство DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/deepseek-v3) — Общая модель без фокуса на рассуждениях от той же лаборатории
* [Руководство по vLLM](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/vllm) — Комплексная настройка для продакшн-сервинга
* [Руководство по Ollama](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/ollama) — Простое локальное развёртывание для любой модели
* [Руководство по Open WebUI](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/open-webui) — Чат-интерфейс с нативной `<think>` отрисовкой тегов
* [Руководство Qwen 2.5](https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/qwen25) — Базовая архитектура, используемая большинством дистиллятов R1