# 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 \~$0.50/día.
{% endhint %}

## Descripción general

DeepSeek-R1 es un modelo de razonamiento de peso abierto con 671B de parámetros, lanzado en enero de 2025 por DeepSeek bajo la **Apache 2.0** licencia. Es el primer modelo abierto que iguala a OpenAI o1 en pruebas de matemáticas, programación y ciencias — mientras expone toda su cadena de pensamiento mediante `<think>` etiquetas.

El modelo completo usa **Mezcla de Expertos (MoE)** con 37B de parámetros activos por token, lo que hace viable la inferencia a pesar del enorme número de parámetros. Para la mayoría de los practicantes, las **variantes destiladas** (1.5B → 70B) son más prácticas: heredan los patrones de razonamiento de R1 mediante destilación de conocimiento en las arquitecturas base Qwen-2.5 y Llama-3, y se ejecutan en GPU de uso común.

## Características clave

* **Cadena de pensamiento explícita** — cada respuesta comienza con un `<think>` bloque en el que el modelo razona, retrocede y se autocorrige antes de producir una respuesta final
* **Entrenado con aprendizaje por refuerzo** — la capacidad de razonar surge de señales de recompensa de RL, en lugar de datos de cadena de pensamiento elaborados manualmente
* **Seis variantes destiladas** — modelos de parámetros 1.5B, 7B, 8B, 14B, 32B y 70B destilados del 671B completo en 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 todos de inmediato
* **AIME 2024 Pass\@1: 79.8%** — empatado con OpenAI o1 en matemáticas de competición
* **Codeforces 2029 Elo** — supera el 1891 de o1 en programación competitiva

## Variantes del modelo

| Variante                   | Parámetros         | Arquitectura | VRAM FP16 | VRAM Q4  | Disco Q4 |
| -------------------------- | ------------------ | ------------ | --------- | -------- | -------- |
| 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 borde         | R1-Distill-Qwen-1.5B   | Cualquier GPU                                                                                                              |
| Despliegue económico, inferencia rápida           | R1-Distill-Qwen-7B     | RTX 3090 (\~$0.30–1/día)                                                                                                   |
| Punto ideal de producción con una sola 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.50–2/día)    |
| Mejor relación calidad-precio (recomendado)       | 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) o A100 40 GB |
| Máxima calidad destilada                          | R1-Distill-Llama-70B   | 2× A100 80 GB                                                                                                              |
| Investigación, razonamiento de fidelidad completa | DeepSeek-R1 671B       | clúster 8× H100                                                                                                            |

### Repositorios de HuggingFace

| Variante          | Repositorio                                                                                                   |
| ----------------- | ------------------------------------------------------------------------------------------------------------- |
| R1 completo       | [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| distill Llama-70B | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| distill Qwen-32B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| distill Qwen-14B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| distill Llama-8B  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| distill Qwen-7B   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| distill 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 la 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 automáticamente la cuantización, la descarga y el servicio — la forma más rápida de poner en funcionamiento DeepSeek-R1.

### 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    # Borde / pruebas
ollama run deepseek-r1:7b      # Económico — cabe en cualquier GPU de 8 GB+
ollama run deepseek-r1:14b     # Punto ideal de la 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>
Usaré una demostración por contradicción.
Supongamos que √2 es racional, así que √2 = p/q donde p,q son enteros con mcd(p,q) = 1.
Entonces 2 = p²/q², lo que da p² = 2q².
Esto significa que p² es par, así que p debe ser par. Escribe p = 2k.
Sustituyendo: (2k)² = 2q² → 4k² = 2q² → q² = 2k².
Así que q² también es par, lo que significa que q es par.
Pero si tanto p como q son pares, mcd(p,q) ≥ 2, lo que contradice nuestra suposición.
</think>

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

Supongamos √2 = p/q en términos irreducibles (mcd(p,q) = 1). Al elevar al cuadrado se obtiene p² = 2q².
Como p² es par, p es par — escribe p = 2k. Entonces 4k² = 2q², así que q² = 2k²,
lo que significa que q también es par. Esto contradice mcd(p,q) = 1. ∎
```

### Usa la API compatible con OpenAI

```bash
# Inicia Ollama como servidor (si aún no se está ejecutando)
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 de 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 de 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 con vLLM

vLLM ofrece el mayor rendimiento para servir a múltiples usuarios con lotes continuos, PagedAttention y caché de prefijos.

### Una sola GPU — 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 sea primo."}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'
```

## Transformers / Python (con `<think>` Análisis de etiquetas)

Usa HuggingFace Transformers cuando necesites un control detallado sobre la generación o quieras integrar R1 en una canalización de 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 `<think>` etiquetas

```python
def parse_r1_response(text: str) -> dict:
    """Separa 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']}")
```

### Streaming 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": "Deriva 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 con Docker en Clore.ai

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

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

### Docker de vLLM (producción)

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

```yaml
# docker-compose.yml
versión: "3.8"
servicios:
  deepseek-r1:
    imagen: vllm/vllm-openai:latest
    puertos:
      - "8000:8000"
    volúmenes:
      - hf_cache:/root/.cache/huggingface
    entorno:
      - 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
    despliegue:
      recursos:
        reservas:
          dispositivos:
            - 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
volúmenes:
  hf_cache:
```

Desplegar en Clore.ai:

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

## Consejos para despliegues en Clore.ai

### Elegir la GPU correcta

| Presupuesto  | GPU              | Costo diario | Mejor variante                    |
| ------------ | ---------------- | ------------ | --------------------------------- |
| Mínimo       | 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         |

### Ajuste del rendimiento

* **Temperatura 0.6** es el valor predeterminado recomendado para tareas de razonamiento — los propios artículos de DeepSeek usan este valor
* **Configura `max_tokens` generosamente** — los modelos de razonamiento producen bloques largos; 4096+ para problemas no triviales `<think>` bloques; 4096+ para problemas no triviales
* **Habilita el caché de prefijos** (`--enable-prefix-caching` en vLLM) cuando uses un prompt del sistema compartido
* **Limita 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 encajar 32B en una sola GPU de 24 GB con mínima pérdida 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 de pensamiento típica | 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 de varios pasos | \~4000–8000 tokens             | \~10000 tokens           |

## Solución de problemas

### Sin memoria (OOM)

```bash
# Reducir la longitud del 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 del sistema suprimen el pensamiento. Evita instrucciones como "sé conciso" o "no expliques tu razonamiento." Usa un prompt del sistema mínimo o ninguno en absoluto:

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

# Mal — 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   # Ligera variación — bueno para análisis
```

### Primer token lento (TTFT alto)

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

### La descarga se detiene en la instancia de Clore

Las descargas de HuggingFace pueden ser lentas en algunos proveedores. Precarga 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

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

## Lectura adicional

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


---

# 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-es/modelos-de-lenguaje/deepseek-r1.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.