Technical Tutorials

À mesure que les organisations développent leurs applications IA, un goulot d'étranglement critique apparaît souvent : le compromis entre la capacité du modèle et le coût d'inférence. DeepSeek a introduit une solution convaincante avec la sortie de DeepSeek-R1, un modèle spécifiquement conçu pour le raisonnement complexe, et DeepSeek-V3, un modèle généraliste haut de gamme, rapide et à faible coût. Individuellement, ils servent des objectifs distincts. Cependant, lorsqu'ils sont combinés via une architecture de routage hybride, ils débloquent un paradigme puissant pour les développeurs recherchant à la fois profondeur et efficacité.

Pourquoi le routage hybride ?

Dans les applications LLM traditionnelles, chaque requête est envoyée au même modèle. C'est inefficace. Une requête simple comme « Quel temps fait-il à Paris ? » n'a pas besoin des capacités de déduction logique étendues d'un modèle de raisonnement comme R1. Inversement, une preuve mathématique complexe ou une tâche de débogage de code en plusieurs étapes souffrira si elle est déléguée à un modèle plus rapide et moins profond comme V3.

Une approche hybride consiste à implémenter une Couche de Triage. Cette couche analyse le prompt entrant pour déterminer sa complexité et le route vers le point d'accès DeepSeek approprié. Cela se traduit par :

Réduction des coûts : Jusqu'à 80 % des requêtes sont simples, exploitant l'API V3 moins chère.
Optimisation de la latence : Les requêtes simples reviennent plus rapidement ; les requêtes complexes reçoivent le traitement approfondi dont elles ont besoin.
Assurance qualité : Garantit que les tâches complexes à fort enjeu sont traitées par le modèle le plus capable disponible.

Concevoir la solution

L'implémentation suit généralement un pipeline en trois étapes :

Intake : Recevoir le prompt de l'utilisateur.
Classification : Utiliser une heuristique légère ou un classifieur petit et rapide (même une petite instance V3 avec un prompt système spécifique) pour catégoriser la tâche en « Simple », « Moyenne » ou « Complexe ».
Exécution :
- Simple/Moyenne : Router vers deepseek-v3.
- Complexe : Router vers deepseek-r1.

Implémentation pratique en Python

Ci-dessous se trouve un exemple conceptuel utilisant Python et la bibliothèque openai (ou un client DeepSeek compatible) pour démontrer cette logique de routage.


import openai
from typing import Dict, Any

# Configurer les clients pour les deux modèles DeepSeek
# Note : Assurez-vous d'avoir les clés API et les URL de base correctes configurées pour DeepSeek
client_v3 = openai.OpenAI(
    api_key="your_deepseek_v3_api_key",
    base_url="https://api.deepseek.com/v1" 
)

client_r1 = openai.OpenAI(
    api_key="your_deepseek_r1_api_key",
    base_url="https://api.deepseek.com/v1"
)

def classify_complexity(prompt: str) -> str:
    """
    Un classifieur heuristique simple. 
    En production, remplacez ceci par un classifieur entraîné ou un appel LLM léger.
    """
    keywords_complex = ["prove", "derive", "optimize", "debug", "step-by-step", "logic", "math"]
    if any(kw in prompt.lower() for kw in keywords_complex):
        return "complex"
    else:
        return "simple"

def hybrid_llm_call(prompt: str, system_context: str = "") -> str:
    """
    Route le prompt vers le modèle approprié en fonction de la complexité.
    """
    complexity = classify_complexity(prompt)
    
    if complexity == "complex":
        # Utiliser DeepSeek-R1 pour le raisonnement approfondi
        print(f"[Routing] Tâche complexe détectée. Utilisation de DeepSeek-R1.")
        response = client_r1.chat.completions.create(
            model="deepseek-r1",
            messages=[
                {"role": "system", "content": system_context},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3  # Température plus basse pour le raisonnement
        )
    else:
        # Utiliser DeepSeek-V3 pour la vitesse et l'efficacité des coûts
        print(f"[Routing] Tâche simple détectée. Utilisation de DeepSeek-V3.")
        response = client_v3.chat.completions.create(
            model="deepseek-v3",
            messages=[
                {"role": "system", "content": system_context},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7  # Température plus élevée pour la créativité/discussion générale
        )
    
    return response.choices[0].message.content

# --- Exemple d'utilisation ---

# Test 1 : Requête simple
print("--- Test 1 : Requête simple ---")
simple_output = hybrid_llm_call("What is the capital of France?")
print(f"Response: {simple_output[:100]}...")

# Test 2 : Requête complexe
print("\n--- Test 2 : Requête complexe ---")
complex_output = hybrid_llm_call("Derive the quadratic formula from ax^2 + bx + c = 0 step by step.")
print(f"Response: {complex_output[:100]}...")

Perfectionner le classifieur

Bien que la correspondance de mots-clés fonctionne pour les configurations de base, les systèmes de niveau production devraient utiliser une méthode de classification plus robuste. Envisagez d'utiliser DeepSeek-V3 lui-même comme classifieur. Vous pouvez demander à V3 de retourner un objet JSON indiquant le score de complexité sans générer la réponse complète :


def advanced_classification(prompt: str) -> float:
    """
    Utilise DeepSeek-V3 pour analyser la complexité du prompt et retourner un score (0-1).
    """
    system_prompt = """You are a complexity classifier. Analyze the user's prompt.
    Return a JSON object: {"complexity_score": , "reason": ""}.
    0.0 = Trivial, 0.5 = Moderate, 1.0 = Highly Complex (requires deep logic/step-by-step reasoning)."""
    
    response = client_v3.chat.completions.create(
        model="deepseek-v3",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": prompt}
        ],
        temperature=0.0,
        response_format={"type": "json_object"} # Garantir une sortie JSON
    )
    
    import json
    data = json.loads(response.choices[0].message.content)
    return data.get("complexity_score", 0.5)

Gérer la « Zone grise »

Il y a des cas où la complexité est ambiguë. Dans de telles instances, vous pouvez implémenter une Stratégie de Chaînage :

Commencez par DeepSeek-V3 pour générer un brouillon ou une analyse préliminaire.
Transmettez la sortie de V3 et le prompt original à DeepSeek-R1 pour vérification, correction ou approfondissement.

Ce motif « Brouillon et Raffinement » garantit que même si le routage initial était légèrement inexact, la sortie finale bénéficie des capacités supérieures de raisonnement de R1. Cependant, tenez compte de la latence et du coût cumulés de cette approche.

Conclusion

La combinaison de DeepSeek-R1 et DeepSeek-V3 représente un passage des déploiements IA monolithiques à des architectures dynamiques et conscientes du contexte. En implémentant le routage hybride, les développeurs peuvent réduire significativement les coûts opérationnels tout en maintenant ou même en améliorant la qualité de la sortie pour les tâches complexes. Commencez petit avec le routage heuristique, mesurez vos performances et affinez progressivement votre logique de classification pour construire un flux de travail IA robuste et efficace en coûts.