Comment choisir un modèle

Il sort de nouveaux modèles presque chaque semaine, et chacun affirme être premier d'un classement. Choisir un modèle d'après les classements, c'est comme recruter en ne regardant que les diplômes : c'est une indication, mais cela ne dit pas si la personne fera bien votre travail.

Cette leçon présente une méthode plus fiable : préparer 20 questions tirées de votre propre tâche, les faire passer à tous les modèles candidats, et voir qui répond juste, qui est rapide, qui est bon marché. Cela coûte peu et donne un résultat en une demi-heure.

Ce qu'il faut regarder

La qualité passe en premier, mais elle n'est pas seule. Un modèle précis à 95 % mais qui fait attendre 10 secondes sera jugé trop lent dans une fenêtre de discussion ; un modèle précis à 90 % mais dix fois moins cher conviendra peut-être mieux à une tâche de fond appelée des centaines de milliers de fois par jour.

Les grandes familles de modèles

Fermés et à poids ouverts. Un modèle fermé ne s'utilise que par API ; vous n'avez pas accès au modèle lui-même. Un modèle à poids ouverts publie ses paramètres : vous pouvez le télécharger et le faire tourner sur vos serveurs, les données ne sortent pas, mais il faut fournir soi-même les cartes graphiques et l'exploitation. Le module 10 montre comment déployer un modèle à poids ouverts en local.

Avec ou sans réflexion. Autrefois, modèle généraliste et modèle de raisonnement étaient deux modèles distincts ; aujourd'hui, beaucoup de modèles basculent avec un simple paramètre. Chez DeepSeek, deepseek-flash et deepseek-v4-pro ont tous deux un mode avec et un mode sans réflexion, la réflexion étant activée par défaut. Le mode réflexion est plus précis, mais plus lent et plus cher.

Grands et petits. Dans la gamme d'un même fournisseur, il y a généralement un modèle bon marché et rapide et un modèle plus cher et plus capable, comme flash et pro chez DeepSeek. Intuitivement, le plus cher est forcément meilleur ; l'expérience ci-dessous montre que ce n'est pas toujours le cas.

En septembre 2026, les principaux choix utilisables directement depuis la Chine sont DeepSeek, Alibaba Cloud Bailian (la série Qwen), Kimi, etc. ; la leçon 2 du module 00 donne leurs adresses d'interface. Les modèles précis changent très vite, je n'en dresse donc pas la liste ; consultez la documentation de chacun pour les plus récents. Ce qui compte, c'est la méthode de comparaison ci-dessous, qui ne vieillit pas.

Expérience : comparer quatre configurations sur 20 questions

J'ai préparé 20 questions à réponse unique : arithmétique, conversion d'unités, compter des lettres, compter des caractères chinois, raisonnement simple, poésie classique, culture Python. Puis je les ai fait passer à quatre configurations : deepseek-flash et deepseek-v4-pro, chacun avec et sans réflexion.

Le cœur du programme (code complet dans code/01-llm-basics/model_eval.py ; le coût est calculé avec le cost_usd écrit à la leçon 4) :

QUESTIONS = [
    ("17 乘以 23 等于多少？", ["391"]),
    ("9.11 和 9.9 哪个大？", ["9.9"]),
    ("“秋天的叶子一片片落下”这句话有几个字？", ["10"]),
    ("如果今天是星期三，100 天后是星期几？", ["星期五", "周五"]),
    ("鸡兔同笼，共 35 个头，94 只脚，兔子有几只？", ["12"]),
    # ……一共 20 道
]


def normalize(text):
    # 去掉空格和标点，再去掉结尾的单位和"大"这类多余的字，只比较核心答案。
    # 注意不能去掉小数点，否则 9.9 和 99 就分不清了。
    text = re.sub(r"[\s，。,!！？?：:“”\"'、]", "", text.lower()).rstrip(".")
    return re.sub(r"(个字|个|人|只|天|平方厘米|厘米|摄氏度|度|次|大)$", "", text)


def run_one(model, thinking, question):
    start = time.time()
    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": "只回答最终答案本身，不要写单位以外的任何解释。"},
            {"role": "user", "content": question},
        ],
        extra_body={"thinking": {"type": "enabled" if thinking else "disabled"}},
    )
    return response.choices[0].message.content.strip(), time.time() - start, response.usage

Chaque configuration traite les 20 questions avec 10 threads en parallèle ; on compte les bonnes réponses, le temps moyen par question et le coût total, et on affiche les questions ratées. Mon résultat :

deepseek-flash（不思考）: 答对 19/20，平均 0.8 秒/题，20 题共 0.0002 美元
    答错：9.11 和 9.9 哪个大？ → 9.11
deepseek-flash（思考）: 答对 20/20，平均 0.9 秒/题，20 题共 0.0026 美元
deepseek-v4-pro（不思考）: 答对 16/20，平均 0.9 秒/题，20 题共 0.0009 美元
    答错：9.11 和 9.9 哪个大？ → 9.11
    答错：“秋天的叶子一片片落下”这句话有几个字？ → 9
    答错：一个正方形的周长是 24 厘米，它的面积是多少平方厘米？ → 9
    答错：单词 raspberry 里有几个字母 r？ → 2
deepseek-v4-pro（思考）: 答对 20/20，平均 2.1 秒/题，20 题共 0.0114 美元

Lire les résultats

Le mode réflexion a corrigé toutes les erreurs. Avec la réflexion, les deux modèles ont 20 sur 20. Sans réflexion, les erreurs portent toutes sur des questions qui demandent de procéder « pas à pas » : comparer des décimaux, compter des caractères, calculer d'abord le côté puis l'aire.

Le modèle le plus cher n'est pas forcément le meilleur. deepseek-v4-pro sans réflexion n'a que 16 bonnes réponses, 3 de moins que le flash bon marché. Pour la question du carré, il a répondu « 9 », sans doute en prenant « périmètre 24 » pour un indice sur l'aire. Un modèle plus cher a généralement l'avantage sur les tâches plus difficiles et plus ouvertes, mais sur votre tâche précise, il peut tout à fait faire moins bien que le moins cher. C'est exactement pour cela qu'il faut tester soi-même.

À score parfait égal, prix et vitesse diffèrent beaucoup. flash avec réflexion et pro avec réflexion ont tous deux 20/20, mais pro coûte plus de 4 fois plus cher (0,0114 contre 0,0026 dollar) et est plus de deux fois plus lent (2,1 contre 0,9 seconde). Pour ce jeu de questions, flash avec réflexion est clairement le meilleur choix.

flash sans réflexion offre le meilleur rapport qualité-prix. 19/20 de précision, pour un dixième du coût avec réflexion. Si votre tâche ne contient pas de pièges comme « comparer des décimaux », il suffit peut-être.

Les limites de cette expérience

Après les conclusions, il faut dire aussi où cette expérience n'est pas fiable.

20 questions, c'est trop peu. Entre 16 et 17 bonnes réponses, l'écart peut n'être que de la chance. J'ai lancé le programme deux fois : deepseek-v4-pro sans réflexion a eu 17 une fois et 16 l'autre, et les questions ratées n'étaient pas toutes les mêmes. 20 questions permettent de repérer des écarts « nettement importants » ; pour départager deux modèles « à peu près équivalents », il faut plus de questions, et exécuter chacune plusieurs fois.

Le script de notation peut lui-même se tromper. À ma première exécution, flash avec réflexion s'est vu compter deux erreurs : une réponse « 9.9 大 » (9.9 est plus grand) et une « 10个字 » (10 caractères). Les réponses étaient justes ; ma fonction normalize ne retirait simplement pas des suffixes comme « 大 » ou « 个字 ». Après correction et nouvelle exécution, j'ai obtenu le résultat ci-dessus. Il faut donc examiner une par une les questions notées fausses, pour vérifier que c'est le modèle qui s'est trompé et non la notation.

Ces questions ne sont pas votre tâche. L'arithmétique, compter des lettres, la poésie classique n'ont rien à voir avec votre service client, votre code ou l'extraction d'informations dans des contrats. Ce jeu de questions ne sert qu'à illustrer la méthode. Pour choisir le modèle de votre projet, les questions doivent venir de votre tâche réelle.

Choisir le modèle de votre projet

1. Rassemblez 20 vraies questions. Tirées de votre usage réel : questions réellement posées par des utilisateurs, documents réellement à traiter. Des faciles, et aussi des cas où vous savez que le modèle se trompe facilement.
2. Décidez comment juger juste ou faux. L'idéal est une réponse type comparée automatiquement par programme. Pour les réponses ouvertes (par exemple une réponse de service client), écrivez une grille de notation pour une évaluation humaine, ou faites noter par un autre modèle ; la leçon 2 du module 06 explique comment.
3. Choisissez 2 à 4 candidats. En général, un bon marché et un cher, plus les combinaisons avec et sans réflexion.
4. Faites-les passer, regardez les erreurs. Ne regardez pas seulement la précision ; examinez chaque question ratée pour savoir si le problème vient du modèle, de la question ou de la notation.
5. Calculez le coût selon l'usage réel. Avec le cost_usd de la leçon 4, estimez le coût mensuel d'après le nombre d'appels par jour.
6. Choisissez le moins cher qui répond aux exigences. Une fois la précision suffisante, regardez la vitesse et le prix.

Ne jetez pas ces 20 questions. Chaque fois que vous changerez de modèle, modifierez un prompt ou passerez à une nouvelle version, faites-les repasser pour savoir si c'est moins bien. Le module 06 les étend en un jeu d'évaluation complet.

Exercices

1. Ajoutez à QUESTIONS dans model_eval.py 5 questions où, selon vous, le modèle se trompe facilement, par exemple un calcul de dates en plusieurs étapes ou une énigme logique piégée, et voyez quelle configuration s'en sort le mieux.
2. Si vous avez la clé d'API d'un autre fournisseur, ajoutez ses modèles à CONFIGS (en adaptant run_one pour utiliser différents clients et en retirant le paramètre thinking que les autres ne reconnaissent pas), et comparez les résultats.
3. Lancez model_eval.py trois fois de suite pour une même configuration : le nombre de bonnes réponses est-il le même à chaque fois ? Quelles questions sont tantôt justes, tantôt fausses ?

Auto-test

1. Un modèle est premier d'un classement : pourquoi le tester quand même avec vos propres questions ?

Un classement mesure le niveau moyen d'un modèle sur des questions générales, alors que ce qui vous importe est son comportement sur votre tâche précise. Les deux peuvent beaucoup différer. Dans l'expérience de cette leçon, le plus cher deepseek-v4-pro s'est même trompé plus souvent que le flash bon marché en mode sans réflexion. Seul un test avec de vraies questions de votre tâche dit quel modèle vous convient.

2. Sur 20 questions, le modèle A a 17 bonnes réponses et le modèle B 16. Cela prouve-t-il que A est meilleur que B ?

Non. 20 questions, c'est trop peu ; un écart d'une ou deux questions peut n'être qu'une fluctuation aléatoire, et le même modèle peut obtenir des scores différents sur deux exécutions. Un petit jeu de test sert à repérer des écarts nets. Pour départager des modèles proches, il faut plus de questions, et exécuter chacune plusieurs fois pour faire une moyenne.

3. Votre script d'évaluation indique que le modèle a raté 3 questions. Que faire ensuite ?

Examiner une par une les réponses brutes de ces 3 questions, pour vérifier si le modèle s'est vraiment trompé ou si c'est le script de notation (par exemple une unité ou une ponctuation en trop dans la réponse). Vérifier aussi que les questions et les réponses types elles-mêmes ne posent pas problème. Ensuite seulement, selon le type d'erreurs, décider s'il faut changer de modèle, activer la réflexion ou modifier le prompt.