> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/deepseek-coder.md).

# DeepSeek Coder

Generación de código de primer nivel con DeepSeek Coder en Clore.ai

{% hint style="info" %}
**¡Hay versiones más nuevas disponibles!** [**DeepSeek-R1**](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1.md) (razonamiento + codificación) y [**DeepSeek-V3**](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3.md) (de propósito general) son significativamente más capaces. Véase también [**Qwen2.5-Coder**](/guides/guides_v2-es/modelos-de-lenguaje/qwen25.md) para una sólida alternativa de programación.
{% endhint %}

Generación de código de primera clase con los modelos DeepSeek Coder.

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

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
2. Filtra por tipo de GPU, VRAM y precio
3. Elige **Bajo demanda** (tarifa fija) o **Spot** (precio ofertado)
4. Configura tu pedido:
   * Selecciona la imagen de Docker
   * Configura los puertos (TCP para SSH, HTTP para interfaces web)
   * Añade variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona el método de pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera al despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Qué es DeepSeek Coder?

DeepSeek Coder ofrece:

* Generación de código de última generación
* 338 lenguajes de programación
* Compatibilidad con rellenado en el medio
* Comprensión a nivel de repositorio

## Variantes del modelo

| Modelo              | Parámetros | VRAM  | Contexto |
| ------------------- | ---------- | ----- | -------- |
| DeepSeek-Coder-1.3B | 1.3B       | 3GB   | 16K      |
| DeepSeek-Coder-6.7B | 6.7B       | 8GB   | 16K      |
| DeepSeek-Coder-33B  | 33B        | 40 GB | 16K      |
| DeepSeek-Coder-V2   | 16B/236B   | 20GB+ | 128K     |

## Despliegue rápido

**Imagen de Docker:**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime
```

**Puertos:**

```
22/tcp
8000/http
```

**Comando:**

```bash
pip install vllm && \\
vllm serve deepseek-ai/deepseek-coder-6.7b-instruct --port 8000
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis pedidos**:

1. Ve a **Mis pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (p. ej., `abc123.clorecloud.net`)

Usa `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos a continuación.

## Usando Ollama

```bash

# Ejecutar DeepSeek Coder
ollama run deepseek-coder

# Tamaños específicos
ollama run deepseek-coder:1.3b
ollama run deepseek-coder:6.7b
ollama run deepseek-coder:33b

# V2 (la más reciente)
ollama run deepseek-coder-v2
```

## Instalación

```bash
pip install transformers accelerate torch
```

## Generación de código

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "deepseek-ai/deepseek-coder-6.7b-instruct"

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

messages = [
    {"role": "user", "content": """
Escribe una clase de Python para un cliente de API REST con:
- Compatibilidad con autenticación
- Lógica de reintento con retroceso exponencial
- Registro de solicitudes/respuestas
"""}
]

inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    inputs,
    max_new_tokens=1024,
    temperature=0.2,
    do_sample=True
)

print(tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True))
```

## Rellenado en el medio (FIM)

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "deepseek-ai/deepseek-coder-6.7b-base"

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

# Formato de rellenado en el medio
prefix = """def calculate_statistics(data):
    """Calcule la media, la mediana y la desviación estándar de una lista."""
    import statistics

    mean = statistics.mean(data)
"""

suffix = """
    return {
        'mean': mean,
        'median': median,
        'std': std
    }
"""

# Tokens FIM
prompt = f"<｜fim▁begin｜>{prefix}<｜fim▁hole｜>{suffix}<｜fim▁end｜>"

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=128)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

## DeepSeek-Coder-V2

Las más recientes y potentes:

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct"

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

messages = [
    {"role": "user", "content": "Implementa una caché LRU segura para hilos en Python"}
]

inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")
outputs = model.generate(inputs, max_new_tokens=1024, temperature=0.2)
print(tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True))
```

## Servidor vLLM

```bash
vllm serve deepseek-ai/deepseek-coder-6.7b-instruct \\
    --port 8000 \\
    --dtype bfloat16 \\
    --max-model-len 16384 \
    --trust-remote-code
```

### Uso de la API

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="x")

response = client.chat.completions.create(
    model="deepseek-ai/deepseek-coder-6.7b-instruct",
    messages=[
        {"role": "system", "content": "Eres un programador experto."},
        {"role": "user", "content": "Escribe un servidor websocket de FastAPI"}
    ],
    temperature=0.2,
    max_tokens=1500
)

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

## Revisión de código

````python
code_to_review = """
def process_data(data):
    result = []
    for i in range(len(data)):
        if data[i] > 0:
            result.append(data[i] * 2)
    return result
"""

messages = [
    {"role": "user", "content": f"""
Revisa este código y sugiere mejoras:

```python
{code_to_review}
````

Céntrate en:

1. Rendimiento
2. Legibilidad
3. Mejores prácticas """} ]

````

## Corrección de errores

```python
buggy_code = """
def merge_sorted_lists(list1, list2):
    result = []
    i = j = 0
    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
    return result
"""

messages = [
    {"role": "user", "content": f"""
Encuentra y corrige el error en este código:

```python
{buggy_code}
````

"""} ]

````

## Interfaz de Gradio

```python
import gradio as gr
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "deepseek-ai/deepseek-coder-6.7b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True
)

def generate_code(prompt, temperature, max_tokens):
    messages = [{"role": "user", "content": prompt}]
    inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")
    outputs = model.generate(inputs, max_new_tokens=max_tokens, temperature=temperature, do_sample=True)
    return tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)

demo = gr.Interface(
    fn=generate_code,
    inputs=[
        gr.Textbox(label="Instrucción", lines=5, placeholder="Describe el código que necesitas..."),
        gr.Slider(0.1, 1.0, value=0.2, label="Temperatura"),
        gr.Slider(256, 2048, value=1024, step=128, label="Máx. de tokens")
    ],
    outputs=gr.Code(language="python", label="Código generado"),
    title="DeepSeek Coder"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
````

## Rendimiento

| Modelo           | GPU      | Tokens/seg |
| ---------------- | -------- | ---------- |
| DeepSeek-1.3B    | RTX 3060 | \~120      |
| DeepSeek-6.7B    | RTX 3090 | \~70       |
| DeepSeek-6.7B    | RTX 4090 | \~100      |
| DeepSeek-33B     | A100     | \~40       |
| DeepSeek-V2-Lite | RTX 4090 | \~50       |

## Comparación

| Modelo             | HumanEval | Calidad del código |
| ------------------ | --------- | ------------------ |
| DeepSeek-Coder-33B | 79.3%     | Excelente          |
| CodeLlama-34B      | 53.7%     | Bueno              |
| GPT-3.5-Turbo      | 72.6%     | Bueno              |

## Solución de problemas

### La finalización de código no funciona

* Asegúrate de usar el formato correcto del prompt con `<|fim_prefix|>`, `<|fim_suffix|>`, `<|fim_middle|>`
* Establece un valor adecuado de `max_new_tokens` para la generación de código

### El modelo genera basura

* Comprueba que el modelo se haya descargado por completo
* Verifica que se esté usando CUDA: `model.device`
* Prueba una temperatura más baja (0.2-0.5 para código)

### Inferencia lenta

* Usa vLLM para acelerar entre 5 y 10 veces
* Habilita `torch.compile()` para transformers
* Usa un modelo cuantizado para variantes grandes

### Errores de importación

* Instala las dependencias: `pip install transformers accelerate`
* Actualiza PyTorch a 2.0+

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir de 2024):

| GPU       | Tarifa por hora | Tarifa diaria | Sesión de 4 horas |
| --------- | --------------- | ------------- | ----------------- |
| RTX 3060  | \~$0.03         | \~$0.70       | \~$0.12           |
| RTX 3090  | \~$0.06         | \~$1.50       | \~$0.25           |
| RTX 4090  | \~$0.10         | \~$2.30       | \~$0.40           |
| A100 40GB | \~$0.17         | \~$4.00       | \~$0.70           |
| A100 80GB | \~$0.25         | \~$6.00       | \~$1.00           |

*Los precios varían según el proveedor y la demanda. Consulta* [*Marketplace de CLORE.AI*](https://clore.ai/marketplace) *las tarifas actuales.*

**Ahorra dinero:**

* Usa el **Spot** mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de \~13% de descuento), el resto lo iguala
* Paga con **CLORE** tokens
* Compara precios entre distintos proveedores

## Siguientes pasos

* [DeepSeek-V3](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3.md) - El modelo insignia más reciente de DeepSeek
* [CodeLlama](/guides/guides_v2-es/modelos-de-lenguaje/codellama.md) - Modelo de código alternativo
* [Qwen2.5-Coder](/guides/guides_v2-es/modelos-de-lenguaje/qwen25.md) - El modelo de código de Alibaba
* [vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) - Despliegue en producción


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/deepseek-coder.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.