# DeepSeek-V3

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**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](#whats-new-in-deepseek-v3-0324) para más detalles.
{% endhint %}

## ¿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):**

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

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

{% hint style="warning" %}
**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.
{% endhint %}

## Variantes de modelo

| Modelo            | Parámetros | Activo | VRAM requerida | HuggingFace                                                                                             |
| ----------------- | ---------- | ------ | -------------- | ------------------------------------------------------------------------------------------------------- |
| DeepSeek-V3-0324  | 671B       | 37B    | 8x80GB         | [deepseek-ai/DeepSeek-V3-0324](https://huggingface.co/deepseek-ai/DeepSeek-V3-0324)                     |
| DeepSeek-V3       | 671B       | 37B    | 8x80GB         | [deepseek-ai/DeepSeek-V3](https://huggingface.co/deepseek-ai/DeepSeek-V3)                               |
| DeepSeek-V3-Base  | 671B       | 37B    | 8x80GB         | [deepseek-ai/DeepSeek-V3-Base](https://huggingface.co/deepseek-ai/DeepSeek-V3-Base)                     |
| DeepSeek-V2.5     | 236B       | 21B    | 4x80GB         | [deepseek-ai/DeepSeek-V2.5](https://huggingface.co/deepseek-ai/DeepSeek-V2.5)                           |
| DeepSeek-V2-Lite  | 16B        | 2.4B   | 16GB           | [deepseek-ai/DeepSeek-V2-Lite](https://huggingface.co/deepseek-ai/DeepSeek-V2-Lite)                     |
| DeepSeek-Coder-V2 | 236B       | 21B    | 4x80GB         | [deepseek-ai/DeepSeek-Coder-V2-Instruct](https://huggingface.co/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)

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

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

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

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

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

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

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

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

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

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

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

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

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

```yaml
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*](https://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

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

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

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

### Multi-GPU no funciona

```bash
# 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](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/vllm) - Servidor de despliegue
* [DeepSeek-R1](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1) - Variante especializada en razonamiento
* [DeepSeek Coder](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/deepseek-coder) - Variante específica para código
* [Ollama](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ollama) - Despliegue más sencillo
* [Ajustar LLM](https://docs.clore.ai/guides/guides_v2-es/entrenamiento/finetune-llm) - Entrenamiento personalizado