---
title: "Jeux de tests d'une application d'IA"
description: "Écrire les cas, noter les réponses, suivre les régressions à chaque changement."
url: https://meridal.fr/apprendre/jeux-de-tests/
language: fr
written: 2026-10-08
verified: 2026-10-08
license: CC BY 4.0
---

[Apprendre](https://meridal.fr/apprendre/) › [Construction et programmation](https://meridal.fr/apprendre/dossier/construire/)

Faire · Niveau 3, Construire · 15 minutes

# Jeux de tests d'une application d'IA

Une application d'IA change dès qu'on touche au modèle, à la demande ou aux données. Un jeu de tests dit, en quelques minutes, si elle fait encore ce qu'on attend. Les cas à écrire, les trois façons de noter, les biais d'un modèle juge, et Promptfoo, DeepEval ou Ragas pour le faire tourner.

Écrit le 8 octobre 2026 · Vérifié le 8 octobre 2026

## Vous saurez

- Écrire vingt à cinquante cas qui comptent
- Choisir entre une note par le code, par un modèle juge ou par une personne
- Se méfier des biais d'un modèle juge
- Relancer les tests à chaque changement, et lire une régression

## Dans le parcours

[Développement d'applications d'IA](https://meridal.fr/apprendre/parcours/dev-avance/)

Étape 5 sur 10

- [← Avant Réponse dans un format imposé](https://meridal.fr/apprendre/format-impose/)
- [↑ Plus général Évaluation d'un outil d'IA](https://meridal.fr/apprendre/evaluer-un-outil-d-ia/)
- [↓ Plus concret Premier appel à un modèle](https://meridal.fr/apprendre/premier-appel/)
- [→ Ensuite Observabilité : traces, coût et délai](https://meridal.fr/apprendre/observabilite/)

L'essentiel

1. Commencez petit : vingt à cinquante cas simples, tirés de vrais échecs, suffisent pour démarrer, selon Anthropic.
2. Un bon cas est un cas où deux experts du métier rendraient seuls le même verdict, réussi ou raté.
3. Notez par le code quand c'est possible, par un modèle juge quand c'est nécessaire, par une personne avec parcimonie.
4. Un modèle juge a des biais : la place des réponses, leur longueur, sa préférence pour ses propres textes. Vérifiez qu'il s'accorde avec des avis humains avant de lui confier la note.
5. OpenAI ferme sa plateforme Evals le 30 novembre 2026 et renvoie vers Promptfoo, outil libre qu'il a racheté et qui reste ouvert aux autres éditeurs.

## Prérequis

- Une application d'IA qui fait une tâche précise : classer, extraire, rédiger, répondre sur des documents ; par exemple [une réponse dans un format imposé](https://meridal.fr/apprendre/format-impose/).
- Un poste prêt, avec Python ou Node et les clés d'API ( [le poste de développement](https://meridal.fr/apprendre/poste-de-developpement/) ).
- Des exemples réels, ou les erreurs déjà signalées par les utilisateurs.
- Une personne du métier, pour dire ce qu'est une bonne réponse.

## Étapes

Trois façons de noter une réponse

Par le code

une valeur exacte, un champ, un format

**Pour** le plus rapide, et toujours le même

**Contre** ne juge pas un texte libre

Par un modèle juge

un critère écrit : juste, complet, poli

**Pour** rapide et souple, une fois éprouvé

**Contre** des biais, à calibrer contre des avis humains

Par une personne

le dernier mot, et la calibration du juge

**Pour** le plus souple

**Contre** lent, et coûteux

*Le classement d'Anthropic, qui conseille de privilégier le volume de cas notés automatiquement sur quelques cas notés à la main.*

1. Rassembler vingt à cinquante cas **Ce qu'on fait :** des demandes réelles, en partant de celles qui ont échoué ; chacune avec ce qu'on attend. **À vérifier :** deux experts doivent pouvoir rendre seuls le même verdict sur chaque cas.
2. Choisir la façon de noter chaque cas **Ce qu'on fait :** une valeur exacte quand il y en a une ; un critère écrit pour un modèle juge sinon ; une personne pour trancher et calibrer.
3. Écrire le fichier de tests **Ce qu'on fait :** les demandes, le ou les modèles essayés, et pour chaque cas les vérifications : contient, est égal à, respecte tel critère.
4. Lancer, puis lire chaque échec **Ce qu'on fait :** un tableau des cas réussis et ratés, modèle par modèle ; lire les réponses ratées, pas seulement le score. **À vérifier :** un score bas peut venir d'une erreur de notation : Anthropic cite un test passé de 42 % à 95 % une fois ses erreurs de notation corrigées.
5. Calibrer le modèle juge **Ce qu'on fait :** le comparer à des notes humaines sur un échantillon ; lui laisser répondre « inconnu » ; un juge par critère ; une échelle courte, réussi ou raté, ou de 1 à 5. **À vérifier :** comparer par paires, ou par réussi et raté, et neutraliser la longueur, recommande OpenAI.
6. Relancer à chaque changement **Ce qu'on fait :** un autre modèle, une demande retouchée, de nouvelles données : on relance, on compare, on garde la meilleure version.

**Un fichier de tests, avec Promptfoo.** Deux demandes de traduction, deux modèles, une vérification par cas ; puis la commande qui lance les tests et ouvre le tableau des résultats. Le code est celui de la documentation, non exécuté ici.

`promptfooconfig.yaml`

```
prompts:
  - 'Convert the following English text to {{language}}: {{input}}'
providers:
  - openai:gpt-6-sol
  - openai:gpt-6-luna
tests:
  - vars:
      language: French
      input: Hello world
    assert:
      - type: contains
        value: 'Bonjour le monde'
  - vars:
      language: Spanish
      input: Where is the library?
    assert:
      - type: icontains
        value: 'Dónde está la biblioteca'
```

`Lancer, puis voir les résultats`

```
npx promptfoo@latest eval
npx promptfoo@latest view
```

## Contrôle du résultat

Une tâche réussie 75 fois sur 100, lancée plusieurs fois

Au moins une réussite sur k essais : pass@k

1. 1 essai 75 %
2. 2 essais 93,8 %
3. 3 essais 98,4 %
4. 5 essais 99,9 %

Toutes les réussites sur k essais : pass^k

1. 1 essai 75 %
2. 2 essais 56,2 %
3. 3 essais 42,2 %
4. 5 essais 23,7 %

*Calculé, en supposant les essais indépendants : 1 − 0,25^k et 0,75^k. Anthropic donne l'exemple de trois essais, environ 42 %, et conseille pass@k quand une seule réussite suffit, pass^k quand la constance compte : un agent qui traite le même dossier tous les jours, par exemple.*

- Les cas viennent du terrain, dont les échecs connus
- Chaque cas dit ce qu'on attend, et comment c'est noté
- Le modèle juge a été comparé à des notes humaines et peut répondre « inconnu »
- Les échecs ont été lus, pas seulement comptés une erreur de notation se voit à la lecture
- Les tests tournent à chaque changement de modèle, de demande ou de données
- La constance est mesurée quand elle compte plusieurs essais du même cas

## Problèmes fréquents

Trois biais d'un modèle juge

La place

Avec ChatGPT pour juge, intervertir l'ordre des réponses a suffi à faire gagner Vicuna-13B sur 66 questions sur 80.

La longueur

Un juge tend à préférer la réponse la plus longue ; OpenAI demande de neutraliser la longueur.

Soi-même

Un modèle qui reconnaît ses propres textes tend à les préférer.

*Dans l'étude de Zheng et ses coauteurs, GPT-4 juge s'accordait à plus de 80 % avec des préférences humaines, autant que deux personnes entre elles ; les meilleurs juges restent pourtant en deçà de l'accord entre personnes, jusqu'à 5 points d'écart, et tendent à l'indulgence.*

**Le juge donne de bonnes notes à tout**

**Cause**Un juge tend à l'indulgence, surtout sur des demandes longues ou complexes.

**À faire**Le comparer à des notes humaines ; une échelle courte ; un juge par critère.

**Le score baisse sans que l'application ait changé**

**Cause**Une erreur de notation, ou un critère flou.

**À faire**Lire les cas ratés ; corriger le test avant de corriger l'application.

**Les seuils de coût et de délai n'arrêtent rien**

**Cause**Dans Promptfoo, ils vérifient les réponses une fois rendues ; ils ne plafonnent ni la dépense ni la durée.

**À faire**Plafonner la dépense ailleurs, chez l'éditeur ou dans le code.

**Les tests sont dans OpenAI Evals**

**Cause**La plateforme passe en lecture seule le 31 octobre 2026 et ferme le 30 novembre ; un utilisateur a signalé en juillet que le menu d'export vers Promptfoo n'apparaissait pas.

**À faire**Recopier les cas et les vérifications à la main si l'export manque.

## Retour en arrière

- **Garder la version d'avant** : la demande, le modèle et ses réglages, à côté des résultats de leurs tests.
- **Comparer avant de remplacer** : la nouvelle version passe les mêmes cas ; elle ne remplace l'ancienne que si elle fait au moins aussi bien.
- **Revenir** à la version d'avant dès qu'un cas qui passait se met à échouer, le temps de comprendre pourquoi.

## Variantes par outil

Le code des onglets est celui des documentations, noms de modèles compris, non exécuté ici.

Promptfoo DeepEval Ragas OpenAI Evals

Un outil libre en ligne de commande, qui tourne sur votre machine et appelle les modèles directement ; plus de soixante fournisseurs ; utilisable dans une chaîne d'intégration continue. Version 0.124.0, sous licence MIT. OpenAI a annoncé son rachat le 9 mars 2026 ; Promptfoo dit rester libre et ouvert aux autres éditeurs.

`Seuils de coût et de délai, et critères notés par un modèle`

```
defaultTest:
  assert:
    # Example per-response cost threshold (USD)
    - type: cost
      threshold: 0.15
    # Example per-response latency threshold (milliseconds)
    - type: latency
      threshold: 60000

tests:
  - vars:
      riddle: 'I speak without a mouth and hear without ears. I have no body, but I come alive with wind. What am I?'
    assert:
      # Make sure the LLM output contains this word
      - type: icontains
        value: echo
      # Use model-graded assertions to enforce free-form instructions
      - type: llm-rubric
        value: Do not apologize
  - vars:
      riddle: "You see a boat filled with people. It has not sunk, but when you look again you don't see a single person on the boat. Why?"
    assert:
      - type: llm-rubric
        value: explains that there are no single people (they are all married)
  - vars:
      riddle: 'The more of this there is, the less you see. What is it?'
    assert:
      - type: icontains
        value: darkness
```

Un cadre libre qui ressemble à Pytest, pour tester une application d'IA comme du code ; G-Eval note un critère écrit avec un modèle juge. Version 4.2.8, sous licence Apache 2.0 ; son éditeur vend une plateforme hébergée, Confident AI.

`test_chatbot.py`

```
import pytest
from deepeval import assert_test
from deepeval.metrics import GEval
from deepeval.test_case import LLMTestCase, SingleTurnParams

def test_case():
    correctness_metric = GEval(
        name="Correctness",
        criteria="Determine if the 'actual output' is correct based on the 'expected output'.",
        evaluation_params=[SingleTurnParams.ACTUAL_OUTPUT, SingleTurnParams.EXPECTED_OUTPUT],
        threshold=0.5
    )
    test_case = LLMTestCase(
        input="What if these shoes don't fit?",
        # Replace this with the actual output from your LLM application
        actual_output="You have 30 days to get a full refund at no extra cost.",
        expected_output="We offer a 30-day full refund at no extra costs.",
        retrieval_context=["All customers are eligible for a 30 day full refund at no extra costs."]
    )
    assert_test(test_case, [correctness_metric])
```

`Lancer`

```
deepeval test run test_chatbot.py
```

Des mesures pour les applications d'IA, dont quatre pour un RAG : la précision et le rappel du contexte, la pertinence et la fidélité de la réponse ; et la création de jeux de tests. Version 0.4.3, de janvier 2026. Le RAG : [un RAG en production](https://meridal.fr/apprendre/rag-en-production/).

`Une note par un modèle juge, à deux valeurs`

```
import asyncio
from openai import AsyncOpenAI
from ragas.metrics import DiscreteMetric
from ragas.llms import llm_factory

# Setup your LLM
client = AsyncOpenAI()
llm = llm_factory("gpt-4o", client=client)

# Create a custom aspect evaluator
metric = DiscreteMetric(
    name="summary_accuracy",
    allowed_values=["accurate", "inaccurate"],
    prompt="""Evaluate if the summary is accurate and captures key information.

Response: {response}

Answer with only 'accurate' or 'inaccurate'."""
)

# Score your application's output
async def main():
    score = await metric.ascore(
        llm=llm,
        response="The summary of the text is..."
    )
    print(f"Score: {score.value}")  # 'accurate' or 'inaccurate'
    print(f"Reason: {score.reason}")

if __name__ == "__main__":
    asyncio.run(main())
```

Dépréciée le 3 juin 2026 : lecture seule le 31 octobre, fermeture du tableau de bord et de l'API le 30 novembre 2026 ; OpenAI renvoie vers Promptfoo. Le projet libre openai/evals existe encore, mais son paquet n'a pas été publié depuis 2024.

Les quatre outils, côte à côte

| Outil | Forme | Licence | Note par un modèle | Pour un RAG | État |
|---|---|---|---|---|---|
| Promptfoo | Ligne de commande et fichier YAML | MIT | des critères notés par un modèle | non | actif ; racheté par OpenAI, reste libre |
| DeepEval | Tests en Python, comme Pytest | Apache 2.0 | G-Eval, sur un critère écrit | non | actif |
| Ragas | Mesures en Python | Apache 2.0 | des mesures notées par un modèle | quatre mesures | dernière version en janvier 2026 |
| OpenAI Evals | Plateforme en ligne | sans objet | des correcteurs | non | fermeture le 30 novembre 2026 |

*Disque plein : actif ; demi-disque : à surveiller ; cercle vide : à ne plus commencer. D'après les dépôts, la documentation et les registres, lus le 8 octobre 2026.*

## Vérification

**1 Comprendre Par quoi commencer un jeu de tests ?**

Vingt à cinquante cas réels, tirés de vrais échecs, chacun avec ce qu'on attend ; des cas sur lesquels deux experts rendraient le même verdict.

**2 Comprendre Pourquoi calibrer un modèle juge avant de s'y fier ?**

Parce qu'il a des biais, la place des réponses, leur longueur, sa préférence pour ses propres textes : on vérifie qu'il s'accorde avec des notes humaines.

**3 Appliquer Un agent réussit une tâche 75 fois sur 100 ; il traitera le même dossier trois jours de suite. Quelle chance qu'il réussisse les trois fois ?**

Environ 42 %, soit 0,75 au cube : c'est pass^k, la mesure qui compte quand la constance est nécessaire.

## Lectures suivantes

↑ Plus général [Évaluation d'un outil d'IA Faire · Niveau 3 · 14 minutes](https://meridal.fr/apprendre/evaluer-un-outil-d-ia/)

← Avant [Réponse dans un format imposé S'exercer · Niveau 3 · 20 minutes](https://meridal.fr/apprendre/format-impose/)

Vous êtes ici

Jeux de tests d'une application d'IA

→ Ensuite [Observabilité : traces, coût et délai Faire · Niveau 3 · 14 minutes](https://meridal.fr/apprendre/observabilite/)

Développement d'applications d'IA · étape 6 sur 10

↓ Plus concret [Premier appel à un modèle S'exercer · Niveau 3 · 15 minutes](https://meridal.fr/apprendre/premier-appel/)

[Tout le dossier « Construction et programmation »](https://meridal.fr/apprendre/dossier/construire/)

Les pages qui renvoient ici

- [Projet : un banc d'évaluation de modèles](https://meridal.fr/apprendre/projet-banc-d-evaluation-de-modeles/)
- [Serveurs MCP existants](https://meridal.fr/apprendre/serveurs-mcp-existants/)

**Limites et sources**

Les études sur les modèles juges portent sur des modèles de 2023 et 2024 ; elles disent la nature des biais, pas leur ampleur sur le modèle du jour.

Le code des onglets n'a pas été exécuté ici ; les versions sont celles du 8 octobre 2026.

1. [Anthropic, évaluer un agent](https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents) ; [Anthropic, écrire des tests](https://platform.claude.com/docs/en/test-and-evaluate/develop-tests) ; [OpenAI, bonnes pratiques](https://developers.openai.com/api/docs/guides/evaluation-best-practices) ; [OpenAI, dépréciations](https://developers.openai.com/api/docs/deprecations).
2. [Zheng et al., 2023](https://arxiv.org/abs/2306.05685) ; [Wang et al., 2023](https://arxiv.org/abs/2305.17926) ; [Panickssery et al., 2024](https://arxiv.org/abs/2404.13076) ; [Thakur et al., 2024](https://arxiv.org/abs/2406.12624).
3. [Promptfoo](https://github.com/promptfoo/promptfoo/blob/main/site/docs/getting-started.md) ; [DeepEval](https://github.com/confident-ai/deepeval/blob/main/README.md) ; [Ragas](https://github.com/vibrantlabsai/ragas/blob/main/README.md). Le relevé : `apprendre/recherches/2026-10-08-dev-avance.json`.

Écrit par Meridal, avec l'aide de l'IA ; chaque fait vérifié à sa source et relu avant publication. Texte et schémas sous licence [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/deed.fr) : reprenez-les en citant Meridal. Le code sous licence MIT.

Service correspondant

Garder vos outils en état

200 € à 1 500 € par mois

[Voir le service](https://meridal.fr/offre/#suivi)

## Un premier échange de 30 minutes

En visio et sans frais : vous décrivez votre situation, nous vous indiquons ce qui est réalisable, avec quels outils et pour quel ordre de prix. Vous pouvez aussi nous écrire ; chaque message reçoit une réponse écrite.

[Réserver 30 minutes](https://meridal.fr/contact/#reserver) [Écrire un message](https://meridal.fr/contact/)