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 CLORE.AI Marketplace. Las instancias RTX 4090 comienzan en aproximadamente ~$0.50/día.

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
Distilado Llama-70B	deepseek-ai/DeepSeek-R1-Distill-Llama-70B
Distilado Qwen-32B	deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
Distilado Qwen-14B	deepseek-ai/DeepSeek-R1-Distill-Qwen-14B
Distilado Llama-8B	deepseek-ai/DeepSeek-R1-Distill-Llama-8B
Distilado Qwen-7B	deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
Distilado Qwen-1.5B	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

# 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

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

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

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)

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

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

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

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

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

# 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

# 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

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)

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

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

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

# 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 — Incentivar la capacidad de razonamiento en LLMs mediante aprendizaje por refuerzo

• DeepSeek-R1 GitHub — Repositorio oficial con fichas del modelo

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

• Guía de vLLM — Configuración completa para servicio en producción

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

• Guía Open WebUI — Interfaz de chat con renderizado de <think> etiquetas nativas

• Guía Qwen 2.5 — La arquitectura base usada por la mayoría de los destilados de R1