# Modelo de razonamiento DeepSeek-R1

{% hint style="success" %}
Todos los ejemplos se ejecutan en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace). Las instancias RTX 4090 comienzan en aproximadamente \~$0.50/día.
{% endhint %}

## Resumen

DeepSeek-R1 es un modelo de razonamiento de 671 mil millones de parámetros con pesos abiertos lanzado en enero de 2025 por DeepSeek bajo la **Apache 2.0** licencia. Es el primer modelo abierto que iguala a OpenAI o1 en matemáticas, programación y benchmarks científicos, a la vez que expone toda su cadena de pensamiento mediante etiquetas explícitas `<think>` tags.

El modelo completo utiliza **Mixture-of-Experts (MoE)** con 37B parámetros activos por token, haciendo la inferencia manejable a pesar del recuento de parámetros anunciado. Para la mayoría de los practicantes, los **variantes destiladas** (1.5B → 70B) son más prácticas: heredan los patrones de razonamiento de R1 mediante destilación de conocimiento en arquitecturas base Qwen-2.5 y Llama-3 y se ejecutan en GPUs de consumo.

## Características clave

* **Cadena de pensamiento explícita** — cada respuesta comienza con un `<think>` bloque donde el modelo razona, retrocede y se autocorrige antes de producir una respuesta final
* **Entrenado con aprendizaje por refuerzo** — la habilidad de razonar emerge de señales de recompensa de RL en lugar de datos de cadena de pensamiento escritos a mano
* **Seis variantes destiladas** — modelos de 1.5B, 7B, 8B, 14B, 32B y 70B parámetros destilados del R1 completo de 671B a arquitecturas Qwen y Llama
* **Licencia Apache 2.0** — totalmente comercial, sin regalías, sin restricciones de uso
* **Amplio soporte de frameworks** — Ollama, vLLM, llama.cpp, SGLang, Transformers, TGI funcionan inmediatamente
* **AIME 2024 Pass\@1: 79.8%** — empata con OpenAI o1 en matemáticas de competición
* **Elo Codeforces 2029** — supera el 1891 de o1 en programación competitiva

## Variantes de modelo

| Variante                   | Parámetros         | Arquitectura | VRAM FP16 | VRAM Q4  | Q4 Disco |
| -------------------------- | ------------------ | ------------ | --------- | -------- | -------- |
| DeepSeek-R1 (MoE completo) | 671B (37B activos) | DeepSeek MoE | \~1.3 TB  | \~350 GB | \~340 GB |
| R1-Distill-Llama-70B       | 70B                | Llama 3      | 140 GB    | 40 GB    | 42 GB    |
| R1-Distill-Qwen-32B        | 32B                | Qwen 2.5     | 64 GB     | 22 GB    | 20 GB    |
| R1-Distill-Qwen-14B        | 14B                | Qwen 2.5     | 28 GB     | 10 GB    | 9 GB     |
| R1-Distill-Llama-8B        | 8B                 | Llama 3      | 16 GB     | 6 GB     | 5.5 GB   |
| R1-Distill-Qwen-7B         | 7B                 | Qwen 2.5     | 14 GB     | 5 GB     | 4.5 GB   |
| R1-Distill-Qwen-1.5B       | 1.5B               | Qwen 2.5     | 3 GB      | 2 GB     | 1.2 GB   |

### Elegir una variante

| Caso de uso                                       | Variante recomendada   | GPU en Clore                |
| ------------------------------------------------- | ---------------------- | --------------------------- |
| Experimentos rápidos, pruebas en el extremo       | R1-Distill-Qwen-1.5B   | Cualquier GPU               |
| Despliegue con presupuesto, inferencia rápida     | R1-Distill-Qwen-7B     | RTX 3090 (\~$0.30–1/día)    |
| Punto óptimo de producción en una sola GPU        | R1-Distill-Qwen-14B Q4 | RTX 4090 (\~$0.50–2/día)    |
| Mejor calidad por dólar (recomendado)             | R1-Distill-Qwen-32B Q4 | RTX 4090 24 GB o A100 40 GB |
| Calidad destilada máxima                          | R1-Distill-Llama-70B   | 2× A100 80 GB               |
| Investigación, razonamiento de fidelidad completa | DeepSeek-R1 671B       | Clúster de 8× H100          |

### Repositorios de HuggingFace

| Variante            | Repositorio                                                                                                   |
| ------------------- | ------------------------------------------------------------------------------------------------------------- |
| R1 completo         | [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| Distilado Llama-70B | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Distilado Qwen-32B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Distilado Qwen-14B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Distilado Llama-8B  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Distilado Qwen-7B   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Distilado Qwen-1.5B | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B) |

## Requisitos

| Componente      | Mínimo (7B Q4) | Recomendado (32B Q4) |
| --------------- | -------------- | -------------------- |
| VRAM de GPU     | 6 GB           | 24 GB                |
| RAM del sistema | 16 GB          | 32 GB                |
| Disco           | 10 GB          | 30 GB                |
| CUDA            | 12.1+          | 12.4+                |
| Docker          | 24.0+          | 25.0+                |

## Inicio rápido con Ollama

Ollama maneja la cuantización, la descarga y el servicio automáticamente: el camino más rápido para poner a DeepSeek-R1 en funcionamiento.

### Instalar y ejecutar

```bash
# Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Descargar y ejecutar (elige tu variante):
ollama run deepseek-r1:1.5b    # Edge / pruebas
ollama run deepseek-r1:7b      # Presupuesto — cabe en cualquier GPU de 8 GB+
ollama run deepseek-r1:14b     # Punto óptimo para RTX 4090
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 80 GB
```

### Ejemplo de sesión interactiva

```
>>> Demuestra que √2 es irracional.

<think>
Voy a usar la prueba por contradicción.
Supongamos que √2 es racional, así que √2 = p/q donde p,q son enteros con gcd(p,q) = 1.
Entonces 2 = p²/q², lo que da p² = 2q².
Esto significa que p² es par, por lo que p debe ser par. Escriba p = 2k.
Sustituyendo: (2k)² = 2q² → 4k² = 2q² → q² = 2k².
Por lo tanto q² también es par, lo que significa que q es par.
Pero si tanto p como q son pares, gcd(p,q) ≥ 2, contradiciendo nuestra suposición.
</think>

**Prueba de que √2 es irracional (por contradicción):**

Supongamos √2 = p/q en términos irreducibles (gcd(p,q) = 1). Al cuadrar se obtiene p² = 2q².
Como p² es par, p es par — escribir p = 2k. Entonces 4k² = 2q², por lo que q² = 2k²,
lo que significa que q también es par. Esto contradice gcd(p,q) = 1. ∎
```

### Usa la API compatible con OpenAI

```bash
# Iniciar Ollama como servidor (si no está ya en funcionamiento)
ollama serve &

# Consultar vía curl
curl -s http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "Factoriza x^4 - 1 completamente sobre los enteros."}],
    "temperature": 0.6
  }' | python3 -m json.tool
```

### Cliente Python (vía 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": "Escribe una función en Python para encontrar la subcadena palíndroma más larga."}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)
```

## Configuración de producción vLLM

vLLM ofrece el mayor rendimiento para servicio multiusuario con agrupamiento continuo, PagedAttention y caché de prefijos.

### GPU única — 7B / 14B

```bash
pip install vllm

# 7B en cualquier GPU de 16 GB+
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

# 14B en RTX 4090 (24 GB)
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
```

### Multi-GPU — 32B (recomendado)

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

> **Consejo:** El checkpoint 32B Q4 GPTQ o AWQ cabe en una sola RTX 4090 (24 GB):
>
> ```bash
> vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
>     --quantization awq --host 0.0.0.0 --port 8000 \
>     --max-model-len 16384
> ```

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

### Consulta el endpoint de 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": "Resuelve: encuentra todos los primos p tales que p^2 + 2 también es primo."}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'
```

## Transformers / Python (con `<think>` Tag Parsing)

Usa HuggingFace Transformers cuando necesites control fino sobre la generación o quieras integrar R1 en una canalización Python.

### Generación básica

```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 = "¿Cuál es la suma de los primeros 100 enteros positivos?"
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)
```

### Análisis (parsing) `<think>` etiquetas

```python
def parse_r1_response(text: str) -> dict:
    """Divide una respuesta de DeepSeek-R1 en partes de pensamiento y respuesta."""
    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"El modelo razonó durante {result['thinking_tokens']} palabras")
print(f"Respuesta: {result['answer']}")
```

### Transmisión con `<think>` seguimiento de estado

```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": "Deduce la fórmula cuadrática a partir de 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("[Razonamiento] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[Respuesta] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()
```

## Despliegue Docker en Clore.ai

### Ollama Docker (el más simple)

**Imagen Docker:** `ollama/ollama` **Puertos:** `22/tcp, 11434/http`

```bash
# En la instancia de Clore
docker run -d --gpus all \
    -v ollama_data:/root/.ollama \
    -p 11434:11434 \
    --name deepseek-r1 \
    ollama/ollama

# Descargar y servir el modelo
docker exec deepseek-r1 ollama pull deepseek-r1:32b
```

### vLLM Docker (producción)

**Imagen Docker:** `vllm/vllm-openai:latest` **Puertos:** `22/tcp, 8000/http`

```yaml
# docker-compose.yml
version: "3.8"
services:
  deepseek-r1:
    imagen: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN:-}
    comando: >
      --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"]
      intervalo: 30s
      tiempo de espera: 10s
      retries: 5
      start_period: 300s
volumes:
  hf_cache:
```

Desplegar en Clore.ai:

1. Abrir [clore.ai/marketplace](https://clore.ai/marketplace)
2. Filtrar por **2× GPU, 48 GB+ VRAM total** (p. ej. 2× RTX 4090 o A100 80 GB)
3. Establece la imagen Docker en `vllm/vllm-openai:latest`
4. Mapear puerto **8000** como HTTP
5. Pega el comando del archivo compose arriba en el comando de inicio
6. Conéctate vía el endpoint HTTP una vez que la comprobación de salud pase

## Consejos para despliegues en Clore.ai

### Elegir la GPU adecuada

| Económico    | GPU              | Costo diario | Mejor variante                    |
| ------------ | ---------------- | ------------ | --------------------------------- |
| Mínima       | RTX 3090 (24 GB) | $0.30 – 1.00 | R1-Distill-Qwen-7B o 14B Q4       |
| Estándar     | RTX 4090 (24 GB) | $0.50 – 2.00 | R1-Distill-Qwen-14B FP16 o 32B Q4 |
| Producción   | A100 80 GB       | $3 – 8       | R1-Distill-Qwen-32B FP16          |
| Alta calidad | 2× A100 80 GB    | $6 – 16      | R1-Distill-Llama-70B FP16         |

### Afinación de rendimiento

* **Temperatura 0.6** es el valor por defecto recomendado para tareas de razonamiento — los propios artículos de DeepSeek usan este valor
* **Establecer `max_tokens` generosamente** — los modelos de razonamiento producen bloques largos; `<think>` 4096+ para problemas no triviales
* **Habilitar caché de prefijos** (`--enable-prefix-caching` en vLLM) al usar un prompt de sistema compartido
* **Limitar la concurrencia** (`--max-num-seqs 16`) para cargas de trabajo de razonamiento — cada solicitud usa más cómputo que un chat estándar
* **Usa cuantización Q4** para ajustar 32B en una sola GPU de 24 GB con pérdida mínima de calidad (la destilación ya comprime el conocimiento de R1)

### Consideraciones sobre la longitud del contexto

Los modelos de razonamiento consumen más contexto que los modelos de chat estándar debido al `<think>` bloque:

| Complejidad de la tarea                   | Longitud típica del pensamiento | Contexto total necesario |
| ----------------------------------------- | ------------------------------- | ------------------------ |
| Aritmética simple                         | \~100 tokens                    | \~300 tokens             |
| Generación de código                      | \~500–1000 tokens               | \~2000 tokens            |
| Matemáticas de competición (AIME)         | \~2000–4000 tokens              | \~5000 tokens            |
| Análisis de investigación en varios pasos | \~4000–8000 tokens              | \~10000 tokens           |

## Solución de problemas

### Fuera de memoria (OOM)

```bash
# Reducir la longitud de contexto
--max-model-len 8192    # en lugar de 32768

# Limitar secuencias concurrentes
--max-num-seqs 8

# Usar cuantización
--quantization awq      # o gptq
```

### El modelo no produce `<think>` bloque

Algunos prompts de sistema suprimen el pensamiento. Evita instrucciones como "sé breve" o "no expliques tu razonamiento." Usa un prompt de sistema mínimo o ninguno:

```python
# Bueno — preserva el razonamiento
messages = [{"role": "user", "content": "..."}]

# Malo — puede suprimir el pensamiento
messages = [
    {"role": "system", "content": "Sé extremadamente breve. Sin explicaciones."},
    {"role": "user", "content": "..."}
]
```

### Salida repetitiva o en bucle `<think>` salida

Reduce la temperatura para disminuir la aleatoriedad en la cadena de razonamiento:

```python
temperature = 0.0   # Determinista — mejor para matemáticas/código
temperature = 0.3   # Ligeras variaciones — bueno para análisis
```

### Primer token lento (alto TTFT)

Esto es esperado — el modelo genera `<think>` tokens antes de la respuesta visible. Para aplicaciones sensibles a la latencia donde no se necesita razonamiento, usa [DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3) en su lugar.

### La descarga se detiene en la instancia Clore

Las descargas de HuggingFace pueden ser lentas en algunos proveedores. Pre-cachea el modelo en un volumen persistente:

```bash
# Descargar una vez en un volumen
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --local-dir /data/models/deepseek-r1-32b

# Señalar vLLM a la ruta local
vllm serve /data/models/deepseek-r1-32b --host 0.0.0.0 --port 8000
```

## Lecturas adicionales

* [Artículo DeepSeek-R1](https://arxiv.org/abs/2501.12948) — *Incentivar la capacidad de razonamiento en LLMs mediante aprendizaje por refuerzo*
* [DeepSeek-R1 GitHub](https://github.com/deepseek-ai/DeepSeek-R1) — Repositorio oficial con fichas del modelo
* [Guía DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3) — Modelo de propósito general sin razonamiento del mismo laboratorio
* [Guía de vLLM](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/vllm) — Configuración completa para servicio en producción
* [Guía de Ollama](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ollama) — Despliegue local sencillo para cualquier modelo
* [Guía Open WebUI](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/open-webui) — Interfaz de chat con renderizado de `<think>` etiquetas nativas
* [Guía Qwen 2.5](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/qwen25) — La arquitectura base usada por la mayoría de los destilados de R1