DeepSeek-V3

Ejecuta DeepSeek-V3 con razonamiento excepcional en GPUs de Clore.ai

Ejecute DeepSeek-V3, el LLM de código abierto de última generación con capacidades excepcionales de razonamiento en GPUs de CLORE.AI.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Actualizado: DeepSeek-V3-0324 (marzo de 2024) — La última revisión de DeepSeek-V3 trae mejoras significativas en generación de código, razonamiento matemático y resolución general de problemas. Vea el registro de cambios para más detalles.

¿Por qué DeepSeek-V3?

• Última generación - Compite con GPT-4o y Claude 3.5 Sonnet

• 671B MoE - 671B parámetros totales, 37B activos por token (inferencia eficiente)

• Razonamiento mejorado - DeepSeek-V3-0324 es significativamente mejor en matemáticas y código

• Eficiente - La arquitectura MoE reduce los costos de cómputo frente a modelos densos

• Código abierto - Pesos completamente abiertos bajo licencia MIT

• Contexto largo - Ventana de contexto de 128K tokens

Novedades en DeepSeek-V3-0324

DeepSeek-V3-0324 (revisión de marzo de 2024) introduce mejoras significativas en dominios clave:

Generación de código

• +8-12% en HumanEval comparado con el V3 original

• Mejor en bases de código multiarchivo y tareas complejas de refactorización

• Mejor comprensión de frameworks modernos (FastAPI, Pydantic v2, LangChain v0.3)

• Más fiable al generar código completo y ejecutable sin omisiones

Razonamiento matemático

• +5% en MATH-500 benchmark

• Mejor construcción paso a paso de demostraciones

• Mayor precisión numérica para problemas de múltiples pasos

• Mayor capacidad para identificar y corregir errores a mitad de la solución

Razonamiento general

• Mayor deducción lógica e inferencia causal

• Mejor en tareas de planificación multi-paso

• Rendimiento más consistente en casos límite y prompts ambiguos

• Mejora en el seguimiento de instrucciones en solicitudes complejas con múltiples restricciones

Despliegue rápido en CLORE.AI

Imagen Docker:

vllm/vllm-openai:latest

Puertos:

22/tcp
8000/http

Comando (Se requieren múltiples GPUs):

python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 8 \
    --trust-remote-code

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Verificar que funciona

# Comprobar si el servicio está listo
curl https://your-http-pub.clorecloud.net/health

# Listar modelos disponibles
curl https://your-http-pub.clorecloud.net/v1/models

# Obtener versión
curl https://your-http-pub.clorecloud.net/version

Importante: DeepSeek-V3 requiere 8x A100 80GB GPUs y un tiempo de descarga significativo. El HTTP 502 puede persistir durante 15-30 minutos mientras se descarga el modelo.

Variantes de modelo

Modelo	Parámetros	Activo	VRAM requerida	HuggingFace
DeepSeek-V3-0324	671B	37B	8x80GB	deepseek-ai/DeepSeek-V3-0324
DeepSeek-V3	671B	37B	8x80GB	deepseek-ai/DeepSeek-V3
DeepSeek-V3-Base	671B	37B	8x80GB	deepseek-ai/DeepSeek-V3-Base
DeepSeek-V2.5	236B	21B	4x80GB	deepseek-ai/DeepSeek-V2.5
DeepSeek-V2-Lite	16B	2.4B	16GB	deepseek-ai/DeepSeek-V2-Lite
DeepSeek-Coder-V2	236B	21B	4x80GB	deepseek-ai/DeepSeek-Coder-V2-Instruct

Requisitos de hardware

Precisión completa

Modelo	Mínimo	Recomendado
DeepSeek-V3-0324	8x A100 80GB	8x H100 80GB
DeepSeek-V2.5	4x A100 80GB	4x H100 80GB
DeepSeek-V2-Lite	RTX 4090 24GB	A100 40GB

Cuantizado (AWQ/GPTQ)

Modelo	Cuantización	VRAM
DeepSeek-V3-0324	INT4	4x80GB
DeepSeek-V2.5	INT4	2x80GB
DeepSeek-V2-Lite	INT4	8GB

Instalación

Usando vLLM (Recomendado)

pip install vllm==0.7.3

# DeepSeek-V3-0324 (último, 8 GPUs)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

# V3 original (todavía disponible)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

Usando Transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "deepseek-ai/DeepSeek-V3-0324"

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

messages = [{"role": "user", "content": "Explica la computación cuántica en términos sencillos."}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

outputs = model.generate(inputs, max_new_tokens=512, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Usando Ollama

# Descargar DeepSeek-V3 (requiere recursos significativos)
ollama pull deepseek-v3

# O variante más ligera
ollama pull deepseek-coder-v2:16b

# Ejecutar
ollama run deepseek-v3

Uso de la API

API compatible con OpenAI (vLLM)

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="no-necesaria"
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[
        {"role": "system", "content": "Eres un asistente de IA servicial."},
        {"role": "user", "content": "Escribe una función en Python para encontrar números primos."}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)

Streaming

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": "Explica el aprendizaje automático"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

cURL

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-ai/DeepSeek-V3-0324",
        "messages": [
            {"role": "user", "content": "¿Cuál es la capital de Francia?"}
        ],
        "temperature": 0.7
    }'

DeepSeek-V2-Lite (GPU única)

Para usuarios con hardware limitado:

# Usando vLLM
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2-Lite \
    --trust-remote-code \
    --host 0.0.0.0

# Usando Ollama
ollama run deepseek-coder-v2:16b

# Usando Transformers en GPU única
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model = AutoModelForCausalLM.from_pretrained(
    "deepseek-ai/DeepSeek-V2-Lite",
    torch_dtype=torch.float16,
    device_map="cuda",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V2-Lite", trust_remote_code=True)

Generación de código

DeepSeek-V3-0324 es de primera clase para código:

prompt = """Escribe una clase en Python para un árbol binario de búsqueda con:
- insertar
- buscar
- eliminar
- recorrido en orden
Incluye anotaciones de tipo y docstrings."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2  # Menor para código
)

print(response.choices[0].message.content)

Tareas avanzadas de código donde V3-0324 destaca:

# Refactorización multiarchivo
prompt = """Tengo una aplicación Flask con todo el código en app.py (500 líneas).
Refactorízala para usar el patrón application factory con blueprints para:
- auth (login, register, logout)
- api (endpoints REST)
- admin (panel de control)
Muestra la estructura completa de archivos y todos los archivos."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,
    max_tokens=4000
)

Matemáticas y razonamiento

# Problema matemático complejo
prompt = """Demuestra que para cualquier entero n >= 1, la suma 1^2 + 2^2 + ... + n^2 = n(n+1)(2n+1)/6.
Usa inducción matemática y muestra todos los pasos claramente."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1  # Muy baja para matemáticas
)

print(response.choices[0].message.content)

Configuración multi-GPU

8x GPU (Modelo completo — V3-0324)

python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9 \
    --trust-remote-code

4x GPU (V2.5)

python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2.5 \
    --tensor-parallel-size 4 \
    --max-model-len 16384 \
    --trust-remote-code

Rendimiento

Rendimiento (tokens/seg)

Modelo	GPUs	Contexto	Tokens/seg
DeepSeek-V3-0324	8x H100	32K	~85
DeepSeek-V3-0324	8x A100 80GB	32K	~52
DeepSeek-V3-0324 INT4	4x A100 80GB	16K	~38
DeepSeek-V2.5	4x A100 80GB	16K	~70
DeepSeek-V2.5	2x A100 80GB	8K	~45
DeepSeek-V2-Lite	RTX 4090	8K	~40
DeepSeek-V2-Lite	RTX 3090	4K	~25

Tiempo hasta el primer token (TTFT)

Modelo	Configuración	TTFT
DeepSeek-V3-0324	8x H100	~750ms
DeepSeek-V3-0324	8x A100	~1100ms
DeepSeek-V2.5	4x A100	~500ms
DeepSeek-V2-Lite	RTX 4090	~150ms

Uso de memoria

Modelo	Precisión	VRAM requerida
DeepSeek-V3-0324	FP16	8x 80GB
DeepSeek-V3-0324	INT4	4x 80GB
DeepSeek-V2.5	FP16	4x 80GB
DeepSeek-V2.5	INT4	2x 80GB
DeepSeek-V2-Lite	FP16	20GB
DeepSeek-V2-Lite	INT4	10GB

Benchmarks

DeepSeek-V3-0324 vs Competencia

Benchmark	V3-0324	V3 (original)	GPT-4o	Claude 3.5 Sonnet
MMLU	88.5%	87.1%	88.7%	88.3%
HumanEval	90.2%	82.6%	90.2%	92.0%
MATH-500	67.1%	61.6%	76.6%	71.1%
GSM8K	92.1%	89.3%	95.8%	96.4%
LiveCodeBench	72.4%	65.9%	71.3%	73.8%
Clasificación en Codeforces	1850	1720	1780	1790

Nota: la mejora en MATH-500 de V3 → V3-0324 es de +5.5 puntos porcentuales.

Docker Compose

versión: '3.8'

services:
  deepseek:
    imagen: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    comando: >
      --model deepseek-ai/DeepSeek-V2-Lite
      --host 0.0.0.0
      --port 8000
      --trust-remote-code
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Resumen de requisitos de GPU

Caso de uso	Configuración recomendada	Costo/Hora
DeepSeek-V3-0324 completo	8x A100 80GB	~$2.00
DeepSeek-V2.5	4x A100 80GB	~$1.00
Desarrollo/Pruebas	RTX 4090 (V2-Lite)	~$0.10
API de producción	8x H100 80GB	~$3.00

Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

Configuración de GPU	Tarifa por hora	Tarifa diaria
RTX 4090 24GB	~$0.10	~$2.30
A100 40GB	~$0.17	~$4.00
A100 80GB	~$0.25	~$6.00
4x A100 80GB	~$1.00	~$24.00
8x A100 80GB	~$2.00	~$48.00

Los precios varían según el proveedor. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

• Usa Spot mercado para desarrollo (a menudo 30-50% más barato)

• Paga con CLORE tokens

• Use DeepSeek-V2-Lite para pruebas antes de escalar

Solución de problemas

Memoria insuficiente

# Reducir la longitud de contexto
--max-model-len 8192

# O usar cuantización
--quantization awq

# Para V2-Lite en GPU de 12GB
--gpu-memory-utilization 0.85
--max-model-len 4096

Descarga lenta del modelo

# Pre-descarga
huggingface-cli download deepseek-ai/DeepSeek-V3-0324

# O use un espejo
export HF_ENDPOINT=https://hf-mirror.com

Error trust_remote_code

# Incluya siempre este flag para modelos DeepSeek
--trust-remote-code

Multi-GPU no funciona

# Verifique NCCL
nvidia-smi topo -m

# Establecer variables NCCL
export NCCL_DEBUG=INFO
export NCCL_P2P_DISABLE=0

DeepSeek vs Otros

Función	DeepSeek-V3-0324	Llama 3.1 405B	Mixtral 8x22B
Parámetros	671B (37B activos)	405B	176B (44B activos)
Contexto	128K	128K	64K
Código	Excelente	Genial	Bueno
Matemáticas	Excelente	Bueno	Bueno
VRAM mínima	8x80GB	8x80GB	2x80GB
Licencia	MIT	Llama 3.1	Apache 2.0

Use DeepSeek-V3 cuando:

• Se necesite el mejor rendimiento en razonamiento

• La generación de código sea el uso principal

• Las tareas de matemáticas/lógica sean importantes

• Disponga de una configuración multi-GPU

• Desee pesos totalmente de código abierto (licencia MIT)

Próximos pasos

• vLLM - Servidor de despliegue

• DeepSeek-R1 - Variante especializada en razonamiento

• DeepSeek Coder - Variante específica para código

• Ollama - Despliegue más sencillo

• Ajustar LLM - Entrenamiento personalizado