Modelo de razonamiento DeepSeek-R1

Ejecuta el modelo de razonamiento de código abierto DeepSeek-R1 en GPUs de Clore.ai

Todos los ejemplos se ejecutan en servidores GPU alquilados a través de la Marketplace de CLORE.AI. Las instancias RTX 4090 comienzan en $0.14–0.42/h.

Descripción general

DeepSeek-R1 es un modelo de razonamiento de peso abierto de 671 mil millones 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 matemáticas, programación y pruebas científicas — mientras expone toda su cadena de pensamiento mediante <think> etiquetas.

El modelo completo usa Mezcla de expertos (MoE) con 37 mil millones de parámetros activos por token, lo que hace viable la inferencia a pesar del gran número total 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 funcionan en GPUs de consumo.

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 razonamiento surge de señales de recompensa de RL en lugar de datos de cadena de pensamiento escritos manualmente

• Seis variantes destiladas — modelos de 1.5B, 7B, 8B, 14B, 32B y 70B parámetros destilados del modelo completo de 671B 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 y TGI funcionan de inmediato

• AIME 2024 Pass@1: 79.8% — empata con OpenAI o1 en matemáticas de competición

• Elo de Codeforces 2029 — supera los 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.07–0.21/hr)
Punto ideal de producción con una sola GPU	R1-Distill-Qwen-14B Q4	RTX 4090 ($0.14–0.42/hr)
Mejor calidad por dólar (recomendado)	R1-Distill-Qwen-32B Q4	RTX 4090 24 GB o A100 de 40 GB
Máxima calidad destilada	R1-Distill-Llama-70B	2× A100 de 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
Destilado Llama-70B	deepseek-ai/DeepSeek-R1-Distill-Llama-70B
Destilado Qwen-32B	deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
Destilado Qwen-14B	deepseek-ai/DeepSeek-R1-Distill-Qwen-14B
Destilado Llama-8B	deepseek-ai/DeepSeek-R1-Distill-Llama-8B
Destilado Qwen-7B	deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
Destilado Qwen-1.5B	deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B

Requisitos

Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai. Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

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.8+	12.8+
Docker	24.0+	25.0+

Inicio rápido de Ollama

Ollama maneja automáticamente la cuantización, la descarga y la publicación — la ruta más rápida para tener un DeepSeek-R1 en ejecución.

Instalar y ejecutar

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

# Descarga y ejecuta (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 de 80 GB

Ejemplo de sesión interactiva

>>> Demuestra que √2 es irracional.

<think>
Usaré una demostración por contradicción.
Supón que √2 es racional, así que √2 = p/q, donde p y 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):**

Supón que √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

# Inicia Ollama como servidor (si aún no se está ejecutando)
ollama serve &

# Consultar mediante 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 (mediante OpenAI SDK)

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 de vLLM

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

Una sola GPU — 7B / 14B

pip install vllm

# 7B en cualquier GPU de 16 GB o más
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)

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 GPTQ o AWQ Q4 de 32B cabe en una sola RTX 4090 (24 GB):

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

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

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 preciso sobre la generación o quieras integrar R1 en una canalización de Python.

Generación básica

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

def parse_r1_response(text: str) -> dict:
    """Divide una respuesta de DeepSeek-R1 en las partes de razonamiento 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

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 (lo más simple)

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

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

# Descarga y sirve el modelo
docker exec deepseek-r1 ollama pull deepseek-r1:32b

Docker de vLLM (producción)

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

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

Despliega en Clore.ai:

1. Abre clore.ai/marketplace

2. Filtrar por 2× GPU, 48 GB o más de VRAM en total (p. ej., 2× RTX 4090 o A100 de 80 GB)

3. Configura la imagen de Docker en vllm/vllm-openai:latest

4. Mapea el puerto 8000 como HTTP

5. Pega el comando del archivo compose anterior en el comando de inicio

6. Conéctate mediante el endpoint HTTP una vez que pase la comprobación de salud

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 de 80 GB	$6 – 16	R1-Distill-Llama-70B FP16

Ajuste de rendimiento

• Temperatura 0.6 es el valor predeterminado recomendado para tareas de razonamiento — los propios artículos de DeepSeek usan este valor

• Establece max_tokens generosamente — los modelos de razonamiento producen <think> bloques largos; 4096+ para problemas no triviales

• Habilita el almacenamiento en caché de prefijos (--enable-prefix-caching (en vLLM) al usar un prompt del sistema compartido

• Limita la concurrencia (--max-num-seqs 16para 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 una 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 razonamiento	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

Fuera de memoria (OOM)

# Reduce la longitud de contexto
--max-model-len 8192    # en lugar de 32768

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

# Usa cuantización
--quantization awq      # o gptq

El modelo no produce <think> bloque

Algunos prompts del sistema suprimen el razonamiento. Evita instrucciones como "sé conciso" o "no expliques tu razonamiento". Usa un prompt del sistema mínimo o ninguno en absoluto:

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

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

Repetitivo o en bucle <think> salida

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

temperature = 0.0   # Determinista — mejor para matemáticas/código
temperature = 0.3   # Variación leve — 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 en su lugar.

La descarga se atasca en la instancia de Clore

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

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

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

Lecturas adicionales

• Documento de DeepSeek-R1 — Incentivar la capacidad de razonamiento en los LLM mediante aprendizaje por refuerzo

• GitHub de DeepSeek-R1 — repositorio oficial con fichas de modelo

• Guía de DeepSeek-V3 — modelo de propósito general sin razonamiento del mismo laboratorio

• Guía de vLLM — configuración integral de serving en producción

• Guía de Ollama — despliegue local sencillo para cualquier modelo

• Guía de Open WebUI — interfaz de chat con renderizado nativo de <think> etiquetas

• Guía de Qwen 2.5 — la arquitectura base utilizada por la mayoría de las destilaciones de R1