# DeepSeek Coder

{% hint style="info" %}
**Des versions plus récentes disponibles !** [**DeepSeek-R1**](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-r1) (raisonnement + codage) et [**DeepSeek-V3**](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-v3) (usage général) sont nettement plus capables. Voir aussi [**Qwen2.5-Coder**](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/qwen25) pour une solide alternative de codage.
{% endhint %}

Génération de code de premier ordre avec les modèles DeepSeek Coder.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Qu'est-ce que DeepSeek Coder ?

DeepSeek Coder offre :

* Génération de code à la pointe
* 338 langages de programmation
* Prise en charge du remplissage au milieu
* Compréhension au niveau du dépôt

## Variantes de modèle

| Modèle              | Paramètres | VRAM   | Contexte |
| ------------------- | ---------- | ------ | -------- |
| DeepSeek-Coder-1.3B | 1,3B       | 3 Go   | 16K      |
| DeepSeek-Coder-6.7B | 6,7B       | 8 Go   | 16K      |
| DeepSeek-Coder-33B  | 33B        | 40Go   | 16K      |
| DeepSeek-Coder-V2   | 16B/236B   | 20 Go+ | 128K     |

## Déploiement rapide

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**Ports :**

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

**Commande :**

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

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Utilisation d'Ollama

```bash

# Lancer DeepSeek Coder
ollama run deepseek-coder

# Tailles spécifiques
ollama run deepseek-coder:1.3b
ollama run deepseek-coder:6.7b
ollama run deepseek-coder:33b

# V2 (dernière)
ollama run deepseek-coder-v2
```

## Installation

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

## Génération de code

```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": """
Écrire une classe Python pour un client d'API REST avec :
- Prise en charge de l'authentification
- Logique de retry avec backoff exponentiel
- Journalisation des requêtes/réponses
"""}
]

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

## Remplissage au milieu (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
)

# Format fill-in-the-middle
prefix = """def calculate_statistics(data):
    \"\"\"Calculate mean, median, and std of a list.\"\"\"
    import statistics

    mean = statistics.mean(data)
"""

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

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

Dernier et plus puissant :

```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": "Implement a thread-safe LRU cache in 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))
```

## Serveur vLLM

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

### Utilisation de l'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": "You are an expert programmer."},
        {"role": "user", "content": "Write a FastAPI websocket server"}
    ],
    temperature=0.2,
    max_tokens=1500
)

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

## Revue de code

````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"""
Examinez ce code et suggérez des améliorations :

```python
{code_to_review}
````

Se concentrer sur :

1. Performances
2. Lisibilité
3. Meilleures pratiques """} ]

````

## Correction de bugs

```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"""
Trouvez et corrigez le bug dans ce code :

```python
{buggy_code}
````

"""} ]

````

## Interface 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="Prompt", lines=5, placeholder="Décrivez le code dont vous avez besoin..."),
        gr.Slider(0.1, 1.0, value=0.2, label="Température"),
        gr.Slider(256, 2048, value=1024, step=128, label="Max Tokens")
    ],
    outputs=gr.Code(language="python", label="Code généré"),
    title="DeepSeek Coder"
)

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

## Performances

| Modèle           | GPU      | Tokens/sec |
| ---------------- | -------- | ---------- |
| 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       |

## Comparaison

| Modèle             | HumanEval | Qualité du code |
| ------------------ | --------- | --------------- |
| DeepSeek-Coder-33B | 79.3%     | Excellent       |
| CodeLlama-34B      | 53.7%     | Bon             |
| GPT-3.5-Turbo      | 72.6%     | Bon             |

## Dépannage

### La complétion de code ne fonctionne pas

* Assurez-vous du format correct de l'invite avec `<|fim_prefix|>`, `<|fim_suffix|>`, `<|fim_middle|>`
* Définir approprié `max_new_tokens` pour la génération de code

### Le modèle produit des déchets

* Vérifiez que le modèle est entièrement téléchargé
* Vérifiez que CUDA est utilisé : `model.device`
* Essayez une température plus basse (0,2-0,5 pour le code)

### Inférence lente

* Utilisez vLLM pour un gain de vitesse de 5 à 10x
* Activez `torch.compile()` pour transformers
* Utilisez un modèle quantifié pour les variantes volumineuses

### Erreurs d'importation

* Installez les dépendances : `pip install transformers accelerate`
* Mettez à jour PyTorch vers 2.0+

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

| GPU       | Tarif horaire | Tarif journalier | Session de 4 heures |
| --------- | ------------- | ---------------- | ------------------- |
| 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             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-v3) - Modèle phare DeepSeek le plus récent
* [CodeLlama](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/codellama) - Modèle de code alternatif
* [Qwen2.5-Coder](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/qwen25) - Le modèle de code d'Alibaba
* [vLLM](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/vllm) - Déploiement en production