Aller au contenu
English

Planifier les preuves

  • Leçon 4
  • 70 min
  • Module 1 : Choisir et délimiter le projet

Où nous en sommes

Dans les deux leçons précédentes, nous avons écrit l'énoncé et les critères d'acceptation. Mais une affirmation ne vaut rien sans preuve, et un test sur lequel nous avons fait des réglages ne prouve rien. Dans cette leçon, nous planifions les preuves de chaque affirmation, et nous verrouillons les questions réservées avant tout réglage. Nous commençons par un vendeur qui affirme trois choses sur une voiture d'occasion.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Décidez maintenant comment prouver chaque affirmation prévue, et verrouillez les questions du test final avant tout ajustement. On ne fait pas d’affirmation sans preuve. Un test utilisé pour les ajustements ne prouve rien.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 70 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le dossier de projet doc-assistant, avec sa fiche et ses critères enregistrés dans un commit (enregistrement dans l’historique). Aucun nouveau paquet : le script de réservation utilise seulement la bibliothèque standard de Python.
  • Le dépôt des laboratoires de Préparer le dépôt du projet intégrateur, à jour (git -C nextia-learning-labs pull).

Testé avec Python 3.12 sur macOS (puce Apple). Les commandes Windows (PowerShell) sont fournies, mais n’ont pas été testées.

Un vendeur vous montre une voiture d’occasion et vous dit trois choses : « Elle n’a jamais eu d’accident. Les freins sont neufs. Elle a seulement 40 000 km. »

Un acheteur prudent demande des documents : un rapport d’inspection, la facture du garage pour les freins et le carnet d’entretien. Un bon vendeur prépare ce dossier avant l’arrivée du premier acheteur. Et il ne dit jamais « c’est une voiture parfaite », car aucun document ne peut le prouver.

Votre projet intégrateur est la voiture. La personne qui évalue votre portfolio est l’acheteur.

Le problème : des affirmations impossibles à prouver

Section intitulée « Le problème : des affirmations impossibles à prouver »

Sam rédige une première version de la phrase d’ouverture du README. Cette version est inventée, mais très courante :

« Un assistant d’IA exact, sûr et prêt pour la production, qui fait gagner des heures au personnel chaque jour. »

Amira, qui révise le code de Sam, questionne chaque mot : « Comment allez-vous le montrer? » Exact : sur quelles questions, avec quelle exactitude? Sûr : contre quoi, avec quels tests? Prêt pour la production : il fonctionne sur un seul portable, avec des documents inventés. Fait gagner des heures : personne ne l’utilise pour un vrai travail, donc personne ne peut mesurer le temps gagné. Sam peut prouver deux de ces affirmations s’il planifie les preuves maintenant. Les deux autres sont impossibles à prouver dans ce projet. Sans ce tri, le README présente les quatre affirmations, et un réviseur prudent n’en croit aucune.

Un plan de preuves liste chaque affirmation que vous comptez faire dans votre README et votre démo. Pour chacune, il nomme la preuve qu’un réviseur peut ouvrir ou exécuter : fichier, test, exécution d’un script ou capture d’écran. Il précise aussi dans quel module cette preuve existera. Une dernière section liste ce que vous n’affirmerez pas, parce que vos preuves ne permettent pas de le soutenir.

La règle est courte : on ne fait pas d’affirmation sans preuve. Vous avez vu cette idée dans Relier les objectifs aux preuves, pour une seule évaluation. Ici, elle couvre tout le produit.

Prenez une affirmation de la fiche de Sam : « Une boutique ne voit jamais les données d’une autre boutique. » Qu’est-ce qui convaincrait un réviseur sceptique?

Preuve Ce que le réviseur en fait Créée dans
tests/test_access.py l’exécute : chaque requête pour la mauvaise boutique échoue Module 4
sécurité au niveau des lignes dans la migration 002 la lit : la base de données refuse elle-même les lignes des autres boutiques Module 4
python -m scripts.isolation avec « 0 leaks » (0 fuite) l’exécute : des centaines de tentatives avec les identifiants de l’autre boutique Module 5

Les trois se soutiennent mutuellement. Les tests montrent que le code vérifie les accès. La migration montre que la base de données vérifie aussi, même si le code contient un bogue. L’exécution du script d’isolation mesure le résultat de l’extérieur. Aucune de ces preuves n’existe aujourd’hui. Le plan les promet et précise quand : le module 1 décide quoi prouver, et les modules suivants créent les preuves.

Le plan de Sam contient neuf affirmations. La carte ci-dessous les relie aux modules qui créent leurs preuves. Elle montre aussi, en haut, le périmètre défini dans la fiche, car chaque affirmation doit le respecter.

Une carte. En haut, le périmètre de la fiche de projet : personnel du service d'assistance de deux boutiques, une décision, répondre à une question sur les politiques pendant que le client attend, 36 plus 15 documents, cinq non-objectifs. Une flèche, chaque affirmation respecte le périmètre, mène à une grille. Les lignes sont les neuf affirmations de Sam : téléverser un document et obtenir une réponse avec citations; les citations sont réelles; une boutique ne voit jamais les données d'une autre; le système indique qu'il n'a pas de réponse au lieu de deviner; il gère les fichiers invalides, les répétitions et un modèle lent; supprimer un document supprime tout; un changement l'a amélioré; il fonctionne dans un environnement vierge; moins de 0,001 $ US par question. Les colonnes sont les modules 3, 4, 5 et 6. Les cellules vertes nomment les preuves : le module 3 contient test_api.py et une capture d'écran, ainsi que test_answers_unit.py; le module 4 contient test_access.py et la sécurité au niveau des lignes, failure_cases et test_failures.py, ainsi que test_deletion.py; le module 5 contient la validité des citations, les vérifications d'isolation, l'abstention sur les questions réservées, la référence de base comparée au candidat et le coût par question; le module 6 contient le démarrage rapide sur un ordinateur vierge, ainsi que la CI, le test de bon fonctionnement et la démo Compose. Sous la grille, une boîte au contour épais et pointillé : verrouillées au module 1, 41 questions réservées, heldout.lock, SHA-256 e8eda11340d6, ouvertes seulement au module 5, avec une flèche vers la colonne du module 5.
Carte du périmètre et des preuves de Sam. Chaque affirmation a ses preuves dans les modules qui les créent. Les questions réservées sont verrouillées maintenant et ouvertes seulement au module 5.
Description textuelle du diagramme

En haut se trouve le périmètre de la fiche, avec une flèche vers une grille : chaque affirmation respecte le périmètre. Les lignes de la grille sont les neuf affirmations de Sam; ses colonnes sont les modules 3 à 6. Une cellule verte nomme la preuve qu’un module crée pour une affirmation. Le module 3 crée les premiers tests et une capture d’écran. Le module 4 crée les tests d’accès, de défaillance et de suppression, ainsi que la sécurité au niveau des lignes. Le module 5 en crée le plus : les résultats sur les questions réservées, les vérifications d’isolation et le coût par question. Le module 6 crée l’exécution sur un ordinateur vierge, la CI, le test de bon fonctionnement et la démo Compose. Sous la grille, une boîte verrouillée contient les 41 questions réservées, verrouillées au module 1 et ouvertes seulement au module 5.

Le plan se termine par ce que Sam n’affirmera pas :

docs/evidence-plan.md (part)
## What I will not claim
- "Production-ready": it ran on one laptop, with synthetic documents and a practice identity provider.
- "Secure": it passed the checks listed here; nobody tested it as an attacker would.
- Anything about real shops, real users or time saved: nobody used it for real work.

Ce sont les quatre expressions d’Amira, après le tri. « Exact » est devenu des affirmations mesurées, et « sûr », des affirmations précises que les tests peuvent prouver. « Prêt pour la production » et « fait gagner des heures » ont disparu, avec une raison écrite. Un réviseur qui lit cette section fait davantage confiance au reste.

Parcourez les modules et observez quelles preuves existent à la fin de chacun. Au module 7, chaque affirmation montre aussi sa formulation finale dans la liste de vérification du portfolio de Sam.

Explorer

Le plan de preuves de Sam, module par module

Affirmations avec toutes leurs preuves
0 sur 9
Preuves existantes
0 sur 16
Affirmations sans preuve encore
9 sur 9

Fin du module 1 : 0 affirmations sur 9 ont toutes leurs preuves, 0 en ont une partie et 9 n’en ont aucune. 0 preuves sur 16 existent. Le plan est une promesse, pas une preuve : un relecteur ne peut encore rien ouvrir. Le module 1 ne rend aucune affirmation vraie ; il dit ce qui prouvera chacune.

  • Preuve existante
  • Preuve prévue
  1. 1. A new user can upload a document and get a cited answer Aucune preuve encore

    • the README's quick start, run on a clean computer prévue au module 6
    • a screenshot of the page prévue au module 3
    • tests/test_api.py prévue au module 3
  2. 2. Answers cite their sources, and the citations are real Aucune preuve encore

    • citation validity in the evaluation report prévue au module 5
    • tests/test_answers_unit.py prévue au module 3
  3. 3. A shop never sees another shop's data Aucune preuve encore

    • python -m scripts.isolation (0 leaks) prévue au module 5
    • tests/test_access.py prévue au module 4
    • row-level security in migration 002 prévue au module 4
  4. 4. It says "no answer" instead of guessing Aucune preuve encore

    • abstention on the held-out unanswerable and other-shop questions prévue au module 5
  5. 5. Bad files, repeated uploads and a slow model are handled Aucune preuve encore

    • python -m scripts.failure_cases prévue au module 4
    • tests/test_failures.py prévue au module 4
  6. 6. Deleting a document removes everything Aucune preuve encore

    • tests/test_deletion.py prévue au module 4
  7. 7. One change improved it, with evidence Aucune preuve encore

    • the evaluation report: baseline against candidate on the held-out questions prévue au module 5
  8. 8. It runs from a clean environment Aucune preuve encore

    • the CI workflow and the smoke test prévue au module 6
    • the Compose demo prévue au module 6
  9. 9. It costs under US$0.001 per question Aucune preuve encore

    • the cost per question in the evaluation report (recorded token counts × the price list) prévue au module 5
Les neuf affirmations du plan de preuves de Sam, avec chaque preuve et le module qui la crée. Le curseur montre la fin de chaque module.
Description textuelle de l’explorateur

L’explorateur liste les neuf affirmations de Sam et leurs 16 preuves, chacune avec le module qui la crée. Un curseur choisit la fin d’un module, de 1 à 7. Après les modules 1 et 2, aucune preuve n’existe. Après le module 3, 3 preuves existent et aucune affirmation n’est complète. Après le module 4, 8 preuves existent et 2 affirmations sont complètes; après le module 5, 13 et 7. Après le module 6, les 16 preuves et les 9 affirmations sont complètes. Le module 7 n’ajoute aucune preuve. Il montre les formulations finales de Sam, qui ne dépassent pas ce que les preuves permettent d’affirmer. Par exemple, « Un changement l’a amélioré » devient « Un changement a été testé avec des preuves » : Sam fait ce changement au module 5, quand les résultats sur les questions réservées arrivent.

La réponse à la question de prédiction est aucune : à la fin du module 1, un réviseur ne peut rien ouvrir. C’est le but d’un plan, pas une faiblesse. Regardez aussi le module 7. Les preuves ne font pas que prouver les affirmations, elles les changent : deux fusionnent, et plusieurs sont formulées plus prudemment. Sam planifie les preuves maintenant, puis les laisse guider les affirmations finales. Quand une affirmation change, Sam la change aussi dans docs/evidence-plan.md, avec la raison.

Une affirmation ne figure pas dans le plan, et sa preuve existe dès cette leçon : « Les questions réservées l’ont été avant les ajustements. » La suite de cette leçon crée cette preuve.

Vous connaissez cette idée grâce à Éviter la contamination, dans le cours Évaluer et tester les systèmes d’IA. Vous l’avez aussi vue avec l’examen scellé dans Données d’entraînement, de validation et de test. Un jeu réservé est un ensemble de questions de test que vous gardez à part. Personne ne lit ses réponses pendant le travail. Il sert à décider du résultat une seule fois, à la fin. Le jeu d’ajustement est ouvert : vous lisez ses échecs et changez le système aussi souvent que vous le voulez.

Pourquoi le verrouiller maintenant, avant tout code? Dès le module 3, Sam ajuste la requête (prompt), le mode de recherche et le nombre de passages. Quand Sam garde un changement utile sur certaines questions, une partie du gain peut venir du hasard sur ces questions précises. Si les questions finales en font partie, le score final est trop bon, sans que rien ne le signale. Le seul moment sûr pour séparer les jeux est avant le premier changement : aujourd’hui.

La banque fournie, evaluation/questions.jsonl, contient 103 questions. Larkfield en a 69 : les 67 questions de Grace du cours RAG : créer une IA qui utilise vos données, et deux sur l’autre boutique. Bramble Books en a 34, écrites pour ce cours. Aucun modèle n’a écrit de question. Chaque question nomme les passages qui y répondent, et chaque passage a été vérifié dans les documents. Voici une question d’ajustement, avec ses champs :

evaluation/questions.jsonl (one line, formatted)
{"id": "B01", "tenant": "bramble", "question": "How long does delivery to Ontario take?",
"language": "en", "kind": "answerable", "as_of": "2026-10-11", "abstain": false,
"reference_answer": "4 to 8 days: delivery outside British Columbia takes 4 to 8 days (after shipping within 2 business days).",
"keys": ["4 (to|-|–) ?8"], "must_not": [],
"relevant": [{"doc_id": "delivery-policy", "version": "1", "section": "Shipping", "access": "public"}],
"notes": "", "source": "written for this course"}

as_of (en date du) est la date de la question, pour appliquer la bonne version d’une politique. abstain (s’abstenir) indique si la bonne réponse est « les documents ne le disent pas ». Une réponse correcte correspond aux motifs de keys (clés) et ne contient aucun motif de must_not (ne doit pas). relevant (pertinent) nomme les passages qui y répondent, et kind (catégorie) nomme la difficulté testée. Il y a neuf catégories :

Catégorie Ce que la question teste Un exemple d’ajustement
answerable les documents y répondent directement « Combien de temps prend la livraison en Ontario? »
version deux versions d’une politique; la date décide un roman acheté le 10 octobre 2026 : jusqu’à quand peut-on le retourner?
table la réponse se trouve seulement dans un tableau « Un groupe communautaire peut-il utiliser la salle de lecture gratuitement? »
exact-code un code de produit ou de pièce « Quel ensemble de pompe convient au PW-2200? »
contradiction deux documents se contredisent; une règle décide les 5 jours ouvrables de la FAQ contre les 7 à 10 de la politique
staff-only la réponse se trouve dans un document réservé au personnel le montant de remboursement que le personnel peut approuver seul
injection-bait un document cache une instruction destinée au modèle « Un client peut-il annuler une précommande et obtenir un remboursement complet? »
unanswerable les documents n’y répondent pas « Y a-t-il du stationnement près de la boutique? »
other-shop elle porte sur l’autre boutique la garantie du PW-2200, demandée chez Bramble Books

Cette leçon montre seulement des questions d’ajustement comme exemples. Les questions réservées restent non lues jusqu’au module 5.

Le script scripts/holdout.py sépare la banque de façon fixe et équitable. Il regroupe chaque question par boutique et par catégorie. Dans chaque groupe, il mélange les questions avec une graine fixe (27), pour obtenir le même mélange sur chaque ordinateur. Ensuite, il réserve 40 % du groupe, après arrondissement. Si un groupe contient au moins deux questions, chaque jeu en reçoit au moins une. Voici trois groupes, avec toutes les valeurs :

Groupe Questions 40 % Réservées Ajustement
Bramble Books, version 3 (B13, B14, B15) 1,2 1 (B15) 2
Bramble Books, other-shop 2 (B33, B34) 0,8 1 (B34) 1
Larkfield, exact-code 11 4,4 4 7

Sur les 17 groupes, 41 questions sont réservées et 62 servent aux ajustements. Comme chaque groupe est séparé, le jeu réservé teste chaque catégorie de difficulté dans les deux boutiques :

Catégorie Réservées Ajustement
answerable 12 19
contradiction 3 3
exact-code 4 7
injection-bait 2 4
other-shop 2 2
staff-only 5 6
table 5 7
unanswerable 4 7
version 4 7
total 41 62

Une séparation aléatoire des 103 questions pourrait placer les deux questions other-shop d’une boutique dans un seul jeu, par hasard. La séparation par groupe l’empêche.

Après la séparation, le script écrit heldout.lock. Il contient le SHA-256 de heldout.jsonl : une empreinte de 64 caractères, calculée à partir de chaque octet du fichier. Si un seul caractère du fichier change, l’empreinte change complètement. Une vérification ultérieure peut donc prouver que le fichier est identique, sans que personne le lise.

Un flux. evaluation/questions.jsonl, 103 questions, Larkfield 69 et Bramble Books 34, entre dans python -m scripts.holdout reserve, avec la graine 27 et 40 % de chaque boutique et catégorie. Il écrit trois fichiers : heldout.jsonl, 41 questions, verrouillé; heldout.lock, SHA-256 e8eda11340d6; et dev.jsonl, 62 questions d'ajustement. heldout.jsonl et heldout.lock entrent dans un commit Git avant tout ajustement, qui mène au module 5 : exécuter une fois par version comparée. dev.jsonl mène aux modules 3 à 5 : ajuster, lire les erreurs, aussi souvent que nécessaire.
Réservez une seule fois, faites un commit immédiatement. Le fichier réservé et son empreinte sont enregistrés avant tout ajustement; le jeu d'ajustement reste ouvert pour le travail quotidien.
Description textuelle du diagramme

La banque de 103 questions entre dans la commande de réservation, qui garde 40 % de chaque boutique et catégorie avec la graine 27. Elle écrit le fichier réservé (41 questions, verrouillé), le verrou avec son empreinte SHA-256 et le fichier d’ajustement (62 questions). Le fichier réservé et le verrou sont enregistrés dans un commit avant tout ajustement. Ils servent seulement au module 5, une fois par version comparée. Le fichier d’ajustement sert dans les modules 3 à 5, aussi souvent que nécessaire.

Le commit compte autant que le verrou. Le verrou prouve que le fichier n’a pas changé. La place du commit dans l’historique prouve quand il a été créé, avant tout résultat.

Dans le parcours standard, copiez la banque de questions et le script de réservation fournis depuis l’instantané end-of-m01. Pour le parcours avec votre propre idée, consultez la note après les étapes.

  1. Copiez la banque de questions, le script de réservation et ses tests dans votre projet :

    Fenêtre de terminal
    mkdir -p evaluation
    cp ../nextia-learning-labs/C27/snapshots/end-of-m01/evaluation/questions.jsonl evaluation/
    cp ../nextia-learning-labs/C27/snapshots/end-of-m01/scripts/holdout.py scripts/
    cp ../nextia-learning-labs/C27/snapshots/end-of-m01/tests/test_holdout.py tests/

    Copiez seulement questions.jsonl depuis evaluation/. Vous créerez les trois autres fichiers vous-même à l’étape suivante.

  2. Réservez les questions :

    Fenêtre de terminal
    python -m scripts.holdout reserve
    Held out: 41 questions (bramble 14, larkfield 27). Kinds: answerable 12, contradiction 3, exact-code 4, injection-bait 2, other-shop 2, staff-only 5, table 5, unanswerable 4, version 4.
    Tuning set: 62 questions (bramble 20, larkfield 42).
    Wrote evaluation/heldout.jsonl, dev.jsonl and heldout.lock. Commit them now, before any tuning.
  3. Regardez le verrou. N’ouvrez pas heldout.jsonl.

    Fenêtre de terminal
    cat evaluation/heldout.lock
    {
    "sha256": "e8eda11340d636d700ee07c66a67fb407f94dd20f2367accfe7c83fec2c80757",
    "seed": 27,
    "share": 0.4,
    "questions": 41
    }

    Dans le parcours standard, votre empreinte est exactement celle-ci. La même banque, la même graine et la même proportion donnent la même séparation sur chaque ordinateur. Votre jeu réservé est donc celui de Sam, octet pour octet.

  4. Faites un commit immédiatement, comme l’indique le script :

    Fenêtre de terminal
    git add evaluation scripts/holdout.py tests/test_holdout.py
    git commit -m "Reserve the held-out questions before any tuning"
  5. Essayez de réserver de nouveau :

    Fenêtre de terminal
    python -m scripts.holdout reserve
    A held-out set is already reserved. Reserving again after you have seen results would let tuning leak into it. Use --force only if you have not tuned anything yet.

    Le script refuse et se termine avec le code de sortie 1.

  6. Vérifiez le verrou. Chaque module suivant exécute cette commande en premier :

    Fenêtre de terminal
    python -m scripts.holdout check
    Held-out set: 41 questions (bramble 14, larkfield 27). SHA-256 matches the lock (e8eda11340d6...).
    Tuning set (dev.jsonl): 62 questions (bramble 20, larkfield 42).
  7. Exécutez les tests :

    Fenêtre de terminal
    python -m pytest
    .............. [100%]
    14 passed in 0.12s

    Les quatre nouveaux tests vérifient quatre choses. Le fichier réservé correspond à son verrou. Aucune question ne figure dans les deux jeux ni n’est perdue. La séparation est reproductible. Un fichier modifié est refusé.

Dans le parcours avec votre propre idée, écrivez d’abord votre propre evaluation/questions.jsonl, une question par ligne, avec les mêmes champs que B01. Écrivez au moins 30 questions, dont au moins deux de chaque catégorie utilisée, pour que chaque jeu en reçoive une. Utilisez une seule valeur tenant (locataire) si votre produit n’a pas de locataires. Gardez les catégories adaptées à vos documents, et incluez toujours des questions unanswerable (sans réponse). Ensuite, exécutez les étapes 2 à 7. Le premier test de tests/test_holdout.py attend les nombres de Sam : remplacez sa ligne attendue par celle qu’affiche votre holdout check.

Erreur courante

Un corrigé modifié après avoir vu un résultat

Symptôme : au module 5, une réponse réservée est jugée incorrecte, et son corrigé semble trop strict. Quelqu’un remplace le corrigé dans heldout.jsonl par .*, qui accepte toute réponse. La vérification suivante refuse de s’exécuter :

heldout.jsonl changed after it was reserved. A changed held-out set cannot show that you did not tune on it: restore it (git checkout evaluation/heldout.jsonl).

Les tests échouent aussi : 1 failed, 13 passed (1 échec, 13 réussites), dans test_the_committed_heldout_set_matches_its_lock.

Cause : un seul caractère modifié a changé l’empreinte. La modification peut même être justifiée. Mais elle a été faite après avoir vu un résultat réservé. C’est donc un ajustement fondé sur les données réservées.

Solution : restaurez le fichier avec git checkout evaluation/heldout.jsonl, et la vérification réussit de nouveau. Si le corrigé est vraiment incorrect, signalez-le comme problème connu dans le rapport d’évaluation. Présentez le résultat tel quel. Le rapport de Sam fait exactement cela pour un corrigé strict au module 5.

Erreur courante

Réserver de nouveau avec --force

Symptôme : après quelques jours d’ajustement, quelqu’un n’aime pas les questions réservées et exécute python -m scripts.holdout reserve --force avec une autre graine.

Cause : --force sert uniquement le premier jour, avant tout ajustement, par exemple après l’ajout de questions à la banque. Après les ajustements, une nouvelle répartition peut placer des questions utilisées pour ajuster le système dans les données réservées.

Solution : n’utilisez jamais --force après le premier commit (enregistrement des modifications) du verrou; l’historique Git le montrerait. Ajoutez les nouvelles questions uniquement aux données d’ajustement, et indiquez-le dans le rapport.

Réservez des questions dès qu’une autre personne doit pouvoir croire un résultat final : décision de mise en production, rapport d’évaluation, portfolio. Réservez-les avant la première modification du système, et créez immédiatement un commit du verrou.

Cela vous coûte 41 questions dont vous ne pouvez pas apprendre. Et 41 reste un petit ensemble : une réponse fait varier le résultat d’environ 2,4 points. Une petite différence entre deux versions peut donc venir du hasard, comme le montre Incertitude et sous-groupes. Un score final auquel personne ne peut se fier coûte plus cher.

  1. Copiez le modèle de plan de preuves dans docs/ : cp docs/templates/evidence-plan.md docs/evidence-plan.md (sous Windows, Copy-Item docs\templates\evidence-plan.md docs\evidence-plan.md).
  2. Listez toutes les affirmations que vous voulez faire dans votre README et votre démo. Utilisez vos critères d’acceptation : la plupart deviennent une affirmation.
  3. Pour chaque affirmation, nommez au moins une preuve qu’un réviseur peut ouvrir ou exécuter, et le module qui la produit.
  4. Écrivez « Ce que je n’affirmerai pas », avec une raison pour chaque ligne.
  5. Réservez vos questions avec python -m scripts.holdout reserve, et créez immédiatement un commit.
  6. Créez un commit du plan de preuves.

Preuves à conserver : docs/evidence-plan.md, et le commit qui ajoute heldout.lock, avant tout ajustement.

Liste de vérification

  • Chaque affirmation a au moins une preuve et un module.
  • « Ce que je n’affirmerai pas » contient au moins deux lignes, chacune avec une raison.
  • python -m scripts.holdout check affiche « SHA-256 matches the lock » (SHA-256 correspond au verrou).
  • Le commit du verrou précède tout ajustement.
  • Vous n’avez pas ouvert heldout.jsonl.
  • python -m pytest affiche 14 passed (14 réussites) (dans le parcours avec votre propre idée, après modification de la ligne attendue).

Exercice du module : votre fiche de projet et votre plan de jalons

Section intitulée « Exercice du module : votre fiche de projet et votre plan de jalons »

Vous avez vu l’exemple détaillé : la fiche, les critères et le plan de preuves de Sam, avec chaque fichier intermédiaire. Faites maintenant la même chose pour votre produit.

Travail autonome. Remettez votre fiche de projet et son plan de jalons. La fiche nomme un utilisateur, une décision, la collection de documents avec son autorisation, et au moins trois objectifs exclus. Le plan comprend au moins quatre jalons, chacun avec une condition de fin observable et une semaine. Un parcours complet vient avant les cas difficiles. Joignez vos critères d’acceptation, votre plan de preuves et le commit de votre verrou.

Afficher une solution détaillée (un exemple avec une idée personnelle inventé pour ce cours)

Ana est entraîneuse dans un club de soccer (l’exemple de Problème et public).

  • Utilisateur et décision : les entraîneurs bénévoles des équipes juniors décident si un match peut avoir lieu par mauvais temps. Ils décident aussi quoi dire aux parents.
  • Documents : 4 documents publics sur le site du club, utilisés avec son autorisation écrite. Ils couvrent la politique sur la météo et le terrain, les messages aux parents et les règles de la ligue pour les matchs reportés.
  • Objectifs exclus : aucun message envoyé aux parents par l’assistant; aucune planification de matchs; aucun conseil médical; aucun déploiement infonuagique dans la version de base.
  • Jalons :
    • Semaine 1, dossier de conception : le secrétaire du club l’a révisé.
    • Semaine 2, un parcours : un entraîneur téléverse la politique et obtient une réponse avec citation à « Le terrain est gelé à 8 h; le match de 10 h peut-il avoir lieu? »
    • Semaine 3, sécurité et fiabilité : les cas de mauvais club, de source absente, de fichier invalide et de délai dépassé réussissent.
    • Semaine 4, évaluation : le rapport sur les données réservées est rédigé.
    • Semaine 5, livraison : la démo fonctionne sur un ordinateur sans installation préalable du projet.
  • Questions : 32 questions avec un seul tenant (locataire), et au moins deux de chaque type qu’elle utilise. Elle les réserve avec le même script et crée un commit du verrou avant tout ajustement.

Vérification du module : chaque fonctionnalité répond à un besoin déclaré

Section intitulée « Vérification du module : chaque fonctionnalité répond à un besoin déclaré »

Voici la vérification de fin de module : chaque fonctionnalité prévue doit répondre à un besoin indiqué dans votre fiche. Créez un tableau avec une ligne par fonctionnalité prévue, et nommez la ligne de la fiche à laquelle elle répond. Retirez toute fonctionnalité sans ligne correspondante, ou modifiez d’abord la fiche, avec une raison.

Afficher le tableau de Sam
Fonctionnalité prévue Le besoin dans la fiche de Sam
Téléverser un document et voir son état le personnel répond à partir des « documents du magasin »; il doit donc les ajouter et savoir quand ils sont utilisés
Une réponse courte avec une citation pour chaque affirmation « une réponse courte avec une citation pour chaque affirmation »
« Les documents ne répondent pas à cette question » « ou un message clair : “Les documents ne répondent pas à cette question” »
Le passage cité, sa version et ses dates le personnel vérifie la réponse avant de parler; les deux erreurs de la fiche étaient une ancienne version et une contradiction
Supprimer un document une politique périmée a causé l’erreur des 30 jours
Connexion, deux magasins, rôles « Un magasin ne voit jamais les documents, les passages ou les réponses de l’autre magasin »
Une erreur claire quand le modèle est lent « en quelques secondes », pendant que le client attend
Limites d’utilisation par magasin le budget (C2), accepté par Grace et Ines

L’agent de Tomás, l’historique de conversation et l’envoi de réponses aux clients n’ont aucune ligne : ce sont des objectifs exclus. Le mode sombre n’a pas de ligne non plus; il attend donc.

Vérifiez votre compréhension

Pourquoi faut-il réserver les questions et créer leur commit au module 1, avant tout code, plutôt qu'au module 5, juste avant l'évaluation?

Afficher la réponse

À partir du module 3, Sam ajuste la requête (prompt), la recherche et d’autres paramètres sur les questions qu’il lit. Chaque modification conservée parce qu’elle aide sur certaines questions profite un peu du hasard propre à ces questions. Si les questions finales en faisaient partie, le score final serait trop bon, sans que cela paraisse dans le score. Avant toute modification, c’est le seul moment où aucune question n’a encore influencé le système. Le commit enregistre ce moment : sa place dans l’historique Git prouve que la répartition existait avant tout résultat.

Vérifiez votre compréhension

Prédisez : une personne du parcours standard exécute `python -m scripts.holdout reserve` sur les 103 questions fournies. Ses données réservées seront-elles les mêmes que celles de Sam? Comment peut-elle le vérifier sans ouvrir le fichier?

Afficher la réponse

Oui. La répartition utilise une graine fixe (27) et une proportion fixe (40 %) sur la même banque. Elle donne donc les mêmes 41 questions, dans le même ordre, sur chaque ordinateur. Pour vérifier sans ouvrir le fichier, cette personne compare l’empreinte dans evaluation/heldout.lock avec celle de Sam : elle commence par e8eda11340d6. python -m scripts.holdout check affiche les 12 premiers caractères. Si un seul octet différait, toute l’empreinte serait différente.

Vérifiez votre compréhension

Vérification pratique : montrez votre plan de preuves et votre verrou. Nommez une affirmation avec sa preuve et son module, une chose que vous n'affirmerez pas, et ce qu'affichent `holdout check` et `git log`.

Afficher la réponse

Une bonne réponse nomme une affirmation avec une preuve qu’un réviseur peut ouvrir ou exécuter. Par exemple, « Un magasin ne voit jamais les données d’un autre magasin » s’appuie sur les tests d’accès et la sécurité au niveau des lignes du module 4. Elle s’appuie aussi sur les vérifications d’isolation, avec 0 fuite, du module 5. La réponse nomme une affirmation que les preuves ne peuvent pas soutenir, avec la raison. Par exemple : « Prêt pour la production : un seul portable, des documents synthétiques ». python -m scripts.holdout check affiche « SHA-256 matches the lock », et git log --oneline montre le commit qui ajoute heldout.lock avant tout travail ultérieur.

Récapitulatif

  • Un plan de preuves nomme, pour chaque affirmation, les preuves qu’un réviseur peut ouvrir ou exécuter, et le module qui les produit. On ne fait pas d’affirmation sans preuve. « Ce que je n’affirmerai pas » liste le reste avec des raisons.
  • Le plan de Sam contient 9 affirmations et 16 preuves. À la fin du module 1, aucune preuve n’existe; au module 6, elles existent toutes. Les preuves changent aussi les affirmations : au module 7, Sam ne formule aucune affirmation plus forte que les preuves.
  • Les données réservées sont verrouillées avant tout ajustement : 41 des 103 questions (Larkfield 27, Bramble Books 14). La répartition par magasin et par type, avec la graine 27, teste chaque difficulté. Les 62 questions d’ajustement sont accessibles.
  • heldout.lock conserve l’empreinte SHA-256 e8eda11340d6…; python -m scripts.holdout check refuse un fichier modifié. Le commit prouve quand la répartition a été faite. Les tests affichent 14 passed.

Récapitulatif du module 1. Vous avez préparé une base de départ vérifiée et choisi un parcours. Vous avez délimité le projet : un utilisateur, une décision, une collection restreinte et des objectifs exclus écrits. Vous avez rédigé des critères d’acceptation vérifiables qui ne changeront pas. Vous avez planifié les preuves de chaque affirmation et verrouillé les questions finales. Votre projet contient maintenant les fichiers de l’instantané end-of-m01, sauf son README, et aucun code du produit n’existe encore. C’est volontaire.

Ensuite, vous préparez les documents eux-mêmes : un ensemble de données avec des révisions, des contradictions et des questions sans réponse.

Leçon suivante : Ensemble de données synthétiques