Intégration et maintenance
- Leçon 19
- 50 min
- Module 6 : Évaluer et livrer le pipeline
Où nous en sommes
Dans les deux dernières leçons, nous avons mesuré la qualité du pipeline et son coût par page. Mais il s'exécute encore seulement quand nous le lançons. À côté d'un système de billets très occupé, il ne doit faire attendre personne, et il doit gérer la correction d'un bogue ou la demande d'un client de supprimer ses données. Dans cette leçon, nous l'exécutons en arrière-plan, versionnons chaque résultat et protégeons chaque modification avec un jeu de régression, en partant d'une chemise laissée chez le nettoyeur.
Leçon 19 sur 19 · IA documentaire et multimodaleIntégration et maintenance
1. Comprendre les documents en entrée
2. Préparer et extraire le contenu
3. Retrouver la structure et les tableaux
4. Utiliser les modèles multimodaux de façon réfléchie
5. Valider et réviser les résultats
6. Évaluer et livrer le pipeline
7. Études de cas
Ce que vous saurez faire
Exécutez le pipeline à côté du système de billets de soutien, sans faire attendre personne. Notez la version qui a produit chaque résultat, retraitez les anciens résultats après une modification et supprimez les données sur demande. Vérifiez chaque modification avec un jeu fixe de documents avant sa mise en production.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- La file de révision et les corrections, dans Confiance et acheminement vers la révision et Flux de correction.
- L’avertissement
3 x 74.85 is not 74.85(3 × 74,85 n’est pas égal à 74,85), dans Validation selon les règles d’affaires. Cette leçon corrige le bogue qui le cause. - Une file de tâches avec des processus, dans Cycle de vie d’une tâche du cours Mettre à l’échelle les API et les charges de travail d’IA, si vous l’avez suivi. Cette leçon explique l’idée en quelques paragraphes.
Ce qu’il vous faut sur votre ordinateur
- Votre projet à la fin de la leçon précédente :
python -m pytest -qaffiche103 passed(103 tests réussis).
Testé avec Python 3.12.13 et RapidOCR 3.10.0 sur macOS (Apple silicon). Les commandes Windows et Linux ne sont pas testées.
Obtenir les fichiers de la leçon
Section intitulée « Obtenir les fichiers de la leçon »-
Copiez le pipeline, son test, le jeu de régression et deux notes pour le dossier
docs/:Fenêtre de terminal S=../nextia-learning-labs/C13/snapshots/end-of-m06cp $S/doc_extract/pipeline.py doc_extract/cp $S/tests/test_pipeline.py tests/mkdir -p tests/regressioncp $S/tests/regression/expected.json tests/regression/cp $S/docs/operations.md $S/docs/evaluation-report.md docs/Fenêtre de terminal $S = "..\nextia-learning-labs\C13\snapshots\end-of-m06"Copy-Item "$S\doc_extract\pipeline.py" doc_extract\Copy-Item "$S\tests\test_pipeline.py" tests\New-Item -ItemType Directory -Force tests\regression | Out-NullCopy-Item "$S\tests\regression\expected.json" tests\regression\Copy-Item "$S\docs\operations.md", "$S\docs\evaluation-report.md" docs\Ne copiez pas encore
fields.py. Vous le modifiez vous-même dans cette leçon. -
Exécutez les tests :
Fenêtre de terminal python -m pytest -qLa dernière ligne est
107 passed(107 tests réussis).
Laisser votre chemise chez le nettoyeur
Section intitulée « Laisser votre chemise chez le nettoyeur »Vous apportez une chemise chez un nettoyeur à sec. Vous ne restez pas au comptoir pendant le nettoyage. On vous donne un billet tout de suite, et vous revenez plus tard. Le billet indique le travail effectué : la date et le procédé. Quand le nettoyeur achète une nouvelle machine, il nettoie d’abord quelques chemises d’essai, une de chaque tissu. Il les compare aux anciens résultats. Ensuite seulement, il l’utilise pour les vêtements de tout le monde. Et quand vous lui demandez de vous oublier, il retire votre nom de ses registres.
Chacune de ces habitudes résout un problème que le pipeline rencontre aussi : l’attente, les modifications, les tests et la suppression.
Le problème : un pipeline dans un système occupé
Section intitulée « Le problème : un pipeline dans un système occupé »Amira connecte le pipeline à ticket-api, le système de billets de Larkfield. Sa première idée est simple : quand un client joint un reçu, le système appelle le pipeline et attend les valeurs. Pour un reçu numérique, cela prend quelques millisecondes. Pour une photo, l’OCR prend environ une seconde. Quand le modèle est nécessaire, l’appel médian prend 7 secondes, et un appel enregistré a pris 132 secondes. Le téléversement du client attend la fin de toutes ces étapes. Une requête Web qui attend deux minutes échoue.
Puis le pipeline change. Dans Validation selon les règles d’affaires, la vérification des articles a trouvé un bogue dans les règles. Après la correction, quels résultats stockés sont anciens? Lesquels portent encore l’ancien avertissement? Personne ne le sait, car un résultat n’indique pas quel code l’a produit.
Grace et la loi soulèvent deux autres questions. Un client demande à Larkfield de supprimer ses données : que faut-il supprimer? Et comment l’équipe sait-elle qu’une correction ne perturbe pas un autre type de document?
L’idée : tâches en arrière-plan, résultats versionnés et jeu de régression
Section intitulée « L’idée : tâches en arrière-plan, résultats versionnés et jeu de régression »Quatre habitudes, comme chez le nettoyeur :
- Traitement en arrière-plan. Le système de billets stocke le fichier et place une tâche dans une file : « lire la pièce jointe 7 du billet 1234 ». Il répond au client tout de suite. Un programme distinct, un processus, prend la tâche suivante, exécute le pipeline et stocke le résultat. Personne n’attend le modèle.
- Résultats versionnés. Chaque résultat conserve les versions qui l’ont produit : le pipeline, le contrat, le moteur OCR et ses paramètres, et la requête (prompt) du modèle. Après une modification, vous trouvez les anciens résultats et les retraitez : vous les produisez à nouveau avec le nouveau code.
- Suppression. Une commande supprime tout ce que le pipeline a produit à partir d’un document. Elle écrit une ligne dans un journal (log) : quoi et quand, jamais le contenu.
- Un jeu de régression. Une régression est une modification qui dégrade quelque chose qui fonctionnait auparavant. Le jeu de régression est une liste fixe de documents, au moins un de chaque type, avec leurs résultats attendus. Chaque modification doit donner les mêmes résultats, ou expliquer chaque différence.
Description textuelle du diagramme
Un diagramme de séquence. Le client joint un reçu à un billet. Le système de billets stocke le fichier original, place une tâche dans la file et répond au client tout de suite. Un agent qui ouvre le billet voit « lecture du reçu ». Le processus prend la tâche suivante et exécute la réception, la lecture, l’extraction, la validation et la décision de révision. Cela prend de 5 millisecondes avec la couche texte à environ 10 secondes avec le modèle. Le processus envoie le résultat, avec les valeurs, leurs cadres et les versions, au système de billets. Quand l’agent ouvre de nouveau le billet, il voit les valeurs avec leurs cadres, ou « révision nécessaire ».
Le projet du cours n’a pas de file, car la file appartient au système de billets. Cycle de vie d’une tâche en construit une. Le projet donne au processus sa seule fonction : pipeline.process lit un document et retourne un résultat. docs/operations.md décrit comment les deux parties s’assemblent.
Exécuter le pipeline complet
Section intitulée « Exécuter le pipeline complet »-
Faites passer chaque document dans le pipeline :
Fenêtre de terminal python -m doc_extract.pipeline run65 documents: straight to the agents 48, to review 12, stopped at intake 5results in out/results/Les 48 comprennent les quatre documents qui ne sont pas des reçus : les deux politiques, la liste de prix et la feuille de calcul. Les 12 à réviser sont les 11 du module précédent et D060, une deuxième numérisation de D020. Les 5 arrêtés sont la copie exacte, le fichier endommagé, le fichier verrouillé, le fichier trop volumineux et le fichier texte.
-
Examinez un résultat. Dans
python:import jsonr = json.load(open("out/results/D011.json", encoding="utf-8"))print("versions:", r["versions"])print("intake: ", r["intake"]["status"])total = r["fields"]["total"]print("total: ", total["value"], total["status"], "page", total["evidence"]["page"],total["evidence"]["box"], total["evidence"]["unit"], repr(total["evidence"]["seen"]))print("review: ", r["review"])versions: {'pipeline': '1.0.0', 'contract': 'receipt-v1', 'ocr': 'rapidocr 3.10.0, 200 dpi, max side 1280', 'vision': 'recorded chat-strong, prompt v2'}intake: acceptedtotal: 211.68 found page 1 [14.2, 226.8, 212.6, 235.8] pt 'TOTAL CAD 211.68'review: {'needed': False, 'reasons': []}Un fichier contient tout ce dont un agent et un auditeur ont besoin. Il contient la valeur, son cadre sur la page et le texte qui s’y trouve. Il contient aussi la décision de révision et les quatre versions.
-
Demandez quels résultats sont anciens :
Fenêtre de terminal python -m doc_extract.pipeline status65 results; 0 made by an older version: -current versions: {'pipeline': '1.0.0', 'contract': 'receipt-v1', 'ocr': 'rapidocr 3.10.0, 200 dpi, max side 1280', 'vision': 'recorded chat-strong, prompt v2'} -
Exécutez le jeu de régression :
Fenêtre de terminal python -m doc_extract.pipeline regressionregression set: 15 documents, no change
Le jeu de régression contient 15 documents, au moins un de chaque catégorie connue dans le cours : un reçu numérique (D001), un reçu français (D004), l’autre magasin (D017), une numérisation française (D021), une numérisation tournée (D025), une photo française (D036), la photo coupée en bas (D045) et en haut (D047), la photo illisible (D046), une photo d’un partenaire (D049), le total incorrect (D050), la demande en deux parties (D058), la copie exacte (D059), le fichier endommagé (D061) et le JPEG nommé .pdf. (D064). Pour chacun, tests/regression/expected.json stocke la décision de réception, la valeur et le statut de chaque champ, et la décision de révision.
Corriger un bogue de façon sûre
Section intitulée « Corriger un bogue de façon sûre »Utilisez maintenant ces outils sur un vrai bogue. Dans le module précédent, la vérification des articles a signalé un avertissement pour de nombreux reçus. Comptez les résultats stockés qui ont cet avertissement. Dans python :
import jsonfrom pathlib import Pathhit = [p.stem for p in sorted(Path("out/results").glob("D*.json")) if any(v["rule"] == "line" for v in json.loads(p.read_text(encoding="utf-8")).get("validation", []))]print(len(hit), "results with a 'line' warning:", ", ".join(hit) or "-")16 results with a 'line' warning: D001, D003, D005, D007, D009, D013, D015, D022, D027, D028, D031, D036, D039, D043, D047, D058python -m doc_extract.validate D001D001 receipt-lk-986875.pdf: warning items line 3 x 74.85 is not 74.85 (Pruning shears)
Description textuelle du diagramme
Une partie du reçu numérique D001, avec les cadres de la couche texte : le nom d’article Pruning shears, la ligne 3 x 24.95 et le montant 74.85 sur la même ligne. Avant la correction, le motif d’une ligne de quantité prend « 24.95 74.85 » comme un seul montant. Le lecteur de montants garde le dernier nombre. Le prix unitaire est donc 74,85, et 3 × 74,85 = 224,55 n’est pas le total de ligne 74,85 : un avertissement. Après la correction, le motif prend un seul montant, 24,95. Alors 3 × 24,95 = 74,85, et la vérification des articles réussit.
Le reçu est correct, et la vérification aussi. Le lecteur se trompe. Une correction prudente comporte quatre étapes : un test qui échoue, la correction, une nouvelle version et les vérifications.
-
Écrivez un test qui montre le bogue. Ajoutez ce test à la fin de
tests/test_fields.py:def test_a_quantity_line_keeps_the_unit_price():# Found by the item check of validate.py: "3 x 24.95 74.85" gave a unit price of 74.85.rows = [(1, [Line("Pruning shears", (14, 227, 90, 236))]),(1, [Line("3 x 24.95", (25, 239, 74, 248)), Line("74.85", (186, 239, 213, 248))]),(1, [Line("Tuyau d'arrosage", (14, 252, 90, 261))]),(1, [Line("2 x 1 011,78", (25, 264, 74, 273)), Line("2 023,56", (180, 264, 213, 273))])]got = [(i["quantity"], i["unit_price"], i["line_total"]) for i in fields.items(rows)]assert got == [(3, "24.95", "74.85"), (2, "1011.78", "2023.56")]Le test construit à la main deux lignes d’articles, avec des cadres. La première est la ligne de D001. La deuxième est une ligne française avec une espace dans les milliers, pour laquelle l’ancien motif avait été écrit. Le fichier importe déjà
fieldsetLine.Fenêtre de terminal python -m pytest -q tests/test_fields.pyE AssertionError: assert [(3, '74.85',...', '2023.56')] == [(3, '24.95',...', '2023.56')]EE At index 0 diff: (3, '74.85', '74.85') != (3, '24.95', '74.85')E Use -v to get more diff<project>/tests/test_fields.py:58: AssertionError=========================== short test summary info ============================FAILED tests/test_fields.py::test_a_quantity_line_keeps_the_unit_price - Asse...1 failed, 5 passed in 5.36sLe test échoue pour la bonne raison : le prix unitaire est
74.85.<project>représente le dossier de votre projet. Un test qui échoue d’abord prouve qu’il peut détecter le bogue. -
Corrigez le lecteur. Dans
doc_extract/fields.py, modifiez la ligne qui définitQTY_LINE:QTY_LINE = re.compile(r"^(\d{1,2})\s*[x×X*]\s*\$?\s*(\d[\d ,.]*)")# "3 x 24.95 74.85": group 2 is the unit price, one amount ("1 011,78" in French). The second# choice keeps a line whose price OCR misread (no decimals) as an item, as before.QTY_LINE = re.compile(r"^(\d{1,2})\s*[x×X*]\s*\$?\s*(\d{1,3}(?:[ ,.]\d{3})*[.,]\d{2}(?!\d)|\d[\d ,.]*)")L’ancien motif prenait toute suite de chiffres, d’espaces, de virgules et de points. Le nouveau essaie d’abord un seul montant : un à trois chiffres, des groupes de trois chiffres, puis deux décimales. Si l’OCR a mal lu le prix et que cela échoue, l’ancien choix s’applique encore. Aucune ligne d’article n’est donc perdue. Si vous préférez, copiez
doc_extract/fields.pydepuis l’instantanéend-of-m06: c’est la même modification.Fenêtre de terminal python -m pytest -q tests/test_fields.pypython -m pytest -q6 passed in 5.34s108 passed in 17.26sFenêtre de terminal python -m doc_extract.validate D001D001 receipt-lk-986875.pdf: no problem -
Demandez quels résultats sont anciens :
Fenêtre de terminal python -m doc_extract.pipeline status65 results; 0 made by an older version: -current versions: {'pipeline': '1.0.0', 'contract': 'receipt-v1', 'ocr': 'rapidocr 3.10.0, 200 dpi, max side 1280', 'vision': 'recorded chat-strong, prompt v2'}Zéro. Le code a changé, mais pas la version. Le pipeline ne peut donc pas distinguer les anciens résultats des nouveaux. Les 16 avertissements stockés restent. Donnez une version à la modification : dans
doc_extract/__init__.py, écrivez__version__ = "1.0.1", et danspyproject.toml, écrivezversion = "1.0.1". Puis demandez de nouveau :Fenêtre de terminal python -m doc_extract.pipeline status65 results; 65 made by an older version: D001, D002, D003, D004, D005, D006, D007, D008, D009, D010, D011, D012, D013, D014, D015, D016, D017, D018, D019, D020, D021, D022, D023, D024, D025, D026, D027, D028, D029, D030, D031, D032, D033, D034, D035, D036, D037, D038, D039, D040, D041, D042, D043, D044, D045, D046, D047, D048, D049, D050, D051, D052, D053, D054, D055, D056, D057, D058, D059, D060, D061, D062, D063, D064, D065current versions: {'pipeline': '1.0.1', 'contract': 'receipt-v1', 'ocr': 'rapidocr 3.10.0, 200 dpi, max side 1280', 'vision': 'recorded chat-strong, prompt v2'} -
Retraitez, puis exécutez le jeu de régression :
Fenêtre de terminal python -m doc_extract.pipeline reprocesspython -m doc_extract.pipeline statuspython -m doc_extract.pipeline regressionreprocessed 65 documents65 results; 0 made by an older version: -current versions: {'pipeline': '1.0.1', 'contract': 'receipt-v1', 'ocr': 'rapidocr 3.10.0, 200 dpi, max side 1280', 'vision': 'recorded chat-strong, prompt v2'}regression set: 15 documents, no changeRecomptez les avertissements
line(ligne) comme au début de cette section :0 results with a 'line' warning: -
Le jeu de régression ne montre aucun changement, et c’est correct. Il compare les champs, leurs statuts et les décisions de révision. La correction ne change aucun de ces éléments, car les lignes d’articles ne font pas partie des neuf champs. Le jeu de régression n’a donc pas détecté le bogue, et il ne détecte pas la correction non plus. Le nouveau test unitaire protège la correction. Voilà pourquoi la correction d’un bogue commence par un test. Le jeu de régression vérifie que rien d’autre n’a changé.
Description textuelle du diagramme
L’ordre d’une modification sûre. Un avertissement désigne le lecteur. Vous écrivez un test qui échoue, puis corrigez le lecteur et exécutez tous les tests. Vous donnez une nouvelle version à la modification, pour que la commande de statut trouve les anciens résultats, puis les retraitez. Ensuite, vous exécutez le jeu de régression. Sans changement, vous mettez en production. Avec un changement, vous expliquez chaque changement, ou corrigez le code et recommencez avec un test.
Supprimer les données d’un client
Section intitulée « Supprimer les données d’un client »Grace reçoit une demande : le client de D045 veut que Larkfield supprime ses données. Dans le module précédent, un réviseur a stocké une correction pour D045. Stockez-en une maintenant si votre base de données n’en a pas, pour voir ce que la suppression retire :
python -m doc_extract.corrections load D045python -m doc_extract.corrections correct D045 total 405.61 --reviewer Grace --note "From the paper receipt the customer sent: TOTAL CAD 405.61"Puis supprimez :
python -m doc_extract.pipeline delete D045 removed out/results/D045.json removed out/cache/ocr/6e73e737a59b3abb-p1-200-1280-raw-rapidocr-3.10.0.json removed out/cache/ocr/6e73e737a59b3abb-p1-200-1280-prep-rapidocr-3.10.0.json removed out/review.db: 9 extraction rows, 1 correction rowsThe original file belongs to the ticket system: delete it there (this pipeline never changes it).Si vous avez gardé la base de données du module précédent, D045 y a 3 lignes de correction, pas 1. Le pipeline supprime ce qu’il a produit : le résultat, le cache OCR des deux images et les lignes de la base de révision, y compris la correction. La suppression est la seule opération qui retire les corrections, volontairement et avec un journal. Le journal est le fichier out/deletions.log. Sa ligne indique quoi et quand, jamais les valeurs. Votre ligne indique l’heure de votre propre exécution :
{"doc_id": "D045", "deleted_at": "<the date and time of your run, in UTC>", "removed": 4}La photo originale n’est pas supprimée. Elle appartient au système de billets, qui la supprime avec le billet. Dans le projet du cours, la photo reste dans data/documents/, donc une exécution ultérieure de pipeline run la relit. En production, le système de billets supprime d’abord le fichier, puis rien ne peut ramener les données.
Quand utiliser chaque habitude, et son coût
Section intitulée « Quand utiliser chaque habitude, et son coût »- Le traitement en arrière-plan est utile dès qu’un chemin peut être lent, dès que le pipeline utilise l’OCR ou un modèle. Il nécessite une file, un processus à exécuter et à surveiller, et un état « lecture… » à l’écran de l’agent.
- Les versions coûtent une ligne par résultat. Changez la version à chaque modification du code, du contrat, des paramètres OCR ou de la requête. Sinon,
status(statut) ne peut pas vous aider. - Le retraitement coûte autant que la première exécution : du temps OCR et des appels au modèle. Avec le cache, les 65 documents du cours prennent environ une seconde. Un nouveau paramètre OCR relit chaque image. Une nouvelle requête appelle de nouveau le modèle pour chaque page qui en a besoin. Prévoyez ce coût avec la leçon précédente.
- Les corrections survivent au retraitement. La correction d’une personne est la ligne la plus récente. Une nouvelle extraction ne la remplace donc jamais, comme l’indique
docs/operations.md. - Un jeu de régression coûte des étiquettes et quelques secondes par modification. Gardez au moins un document de chaque type et de chaque échec observé. Ajoutez un document chaque fois que vous corrigez un bogue qu’il aurait révélé.
Erreur courante
La correction que personne n'a retraitée
Symptôme : Un développeur corrige le bogue du prix unitaire et le met en production. Une semaine plus tard, l’équipe de Grace voit encore 3 x 74.85 is not 74.85 sur les anciens reçus. Les nouveaux reçus sont corrects. Le développeur dit : « C’est impossible, le code est corrigé. »
Cause : Le code a changé, mais pas la version. pipeline status compare les versions stockées aux versions actuelles, donc il n’a trouvé aucun résultat ancien. Les résultats stockés ont gardé les anciens avertissements. Vous l’avez vu à l’étape 3 : 0 made by an older version (0 produit par une ancienne version) juste après la correction. La semaine de plaintes est une histoire construite.
Diagnostic : Examinez les versions stockées et la version du code : python -m doc_extract.pipeline status. Si elles sont égales, mais qu’un résultat stocké montre un problème absent avec le code actuel, la version n’a pas changé.
Correction : Changez la version avec le code, dans le même commit (enregistrement des modifications). Puis exécutez status, reprocess (retraiter) et regression (régression).
Conséquence pour le travail en IA : les sorties stockées durent plus longtemps que le code qui les a produites. Les plongements (embeddings), étiquettes, résumés et extractions ont tous besoin des versions du modèle, de la requête et du code utilisés. Sans elles, vous ne pouvez pas trouver les sorties à actualiser.
À vous de jouer : une image plus petite pour l’OCR
Section intitulée « À vous de jouer : une image plus petite pour l’OCR »Changez une condition : le réglage de l’OCR. Avec OCR_MAX_SIDE=960, l’OCR lit des images plus petites, et un processus utilise moins de mémoire. Faites une prédiction : le jeu de régression change-t-il? Exécutez-le ensuite avec le nouveau réglage :
OCR_MAX_SIDE=960 python -m doc_extract.pipeline regression$env:OCR_MAX_SIDE = "960"python -m doc_extract.pipeline regressionRemove-Item Env:OCR_MAX_SIDELa commande relit chaque image avec le nouveau réglage. Elle prend donc environ 40 secondes. Rétablissez ensuite les résultats avec le réglage normal :
python -m doc_extract.pipeline statuspython -m doc_extract.pipeline reprocesspython -m doc_extract.pipeline regressionAfficher la réponse
D045 currency: expected ['CAD', 'unverified'], got ['CAD', 'inferred']La commande s’arrête avec une erreur (code de sortie 1), et le jeu de régression montre un changement. Tout le reste demeure identique dans les 15 documents. Sur la photo coupée D045, la devise conserve sa valeur, CAD, mais pas son statut. Avec le réglage normal, l’OCR ne trouve aucune devise. Le modèle donne CAD, mais cette valeur n’est pas imprimée sur la page. Elle est donc « non vérifiée ». Avec des images plus petites, l’OCR lit la ligne d’adresse Toronto ON M5H 2M5. Les règles en déduisent CAD, et le modèle donne la même valeur. Une valeur non vérifiée justifie une révision, mais pas une valeur déduite. D045 passe quand même en révision, car son total manque. Sur un autre reçu, ce même changement pourrait décider de l’acheminement. Ce changement exige donc une décision, et non une mise en production sans avertissement.
L’exécution du jeu de régression a enregistré les 65 résultats avec le nouveau réglage. Ainsi, status (état) liste 65 résultats produits par une ancienne version. reprocess (retraiter) les traite à nouveau avec 1 280 pixels. Le jeu de régression ne montre alors plus aucun changement. D045 est aussi rétabli, car sa photo originale est toujours dans data/documents/.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Expliquez pourquoi le système de billets devrait placer une tâche dans une file plutôt qu'appeler le pipeline et attendre.
Afficher la réponse
Le traitement d’un document prend de 5 millisecondes pour un PDF numérique à plusieurs secondes avec le modèle. Un appel au modèle enregistré a pris 132 secondes. Le téléversement d’un client qui attend aussi longtemps échoue. Plusieurs téléversements simultanés bloqueraient le système de billets. Avec une file, le système de billets stocke le fichier et répond immédiatement. Un processus lit les documents un à un. L’agent voit « lecture du reçu » jusqu’à l’arrivée du résultat.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Faites une prédiction : l'équipe passe la requête du modèle de vision de v2 à v3, sans rien oublier. Quels résultats pipeline status liste-t-il, et combien coûte le retraitement?
Afficher la réponse
Les versions incluent la requête. Chaque résultat stocké indique donc prompt v2 (requête v2) et diffère des versions actuelles. status les liste tous, même les reçus numériques qui n’ont jamais utilisé le modèle. Le retraitement les relit ensuite tous. Avec le cache, la couche texte et l’OCR ne coûtent presque rien. Le pipeline rappelle le modèle seulement pour les documents qui en ont besoin. Dans le cours, cela représente 9 des 54 reçus, soit environ 0,10 $ US aux tarifs enregistrés. Le jeu de régression montre ensuite quelles valeurs la nouvelle requête change.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Vérification pratique : après la correction et la nouvelle version, exécutez python -m doc_extract.pipeline regression. Pourquoi aucun changement n'apparaît-il, alors que 16 résultats ont perdu un avertissement?
Afficher la réponse
La commande affiche regression set: 15 documents, no change (jeu de régression : 15 documents, aucun changement). Le jeu de régression compare la décision d’admission, la valeur et le statut de chaque champ, et la décision de révision. La correction change seulement le prix unitaire des lignes d’articles et les avertissements qui les concernent. Les lignes d’articles ne font pas partie des neuf champs. Un avertissement ne change pas la décision de révision. Le jeu ne peut donc détecter ni le bogue ni sa correction. Le nouveau test dans tests/test_fields.py protège la correction. Le jeu de régression confirme que rien d’autre n’a changé.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif du module
Section intitulée « Récapitulatif du module »Ce module a mesuré le pipeline et l’a préparé à fonctionner. Dans Métriques par champ, vous avez évalué chaque champ de chaque document selon cinq résultats possibles. La requête simple lit correctement 97,5 % des valeurs imprimées. Mais elle ne complète que 40 des 54 documents, car elle invente des numéros de commande. Le pipeline combiné en complète 53. Dans Contraintes opérationnelles, vous avez établi le budget d’une journée de 300 pages. Elle coûte 0,91 $ US si le modèle traite le quart des pages, et 3,64 $ US s’il les traite toutes. Un processus OCR utilise environ 1,5 Go de mémoire. Dans cette leçon, le pipeline est devenu un processus en arrière-plan avec des résultats versionnés. Vous avez corrigé un vrai bogue en commençant par un test, puis retraité les documents après une nouvelle version. Vous avez supprimé les données d’un client avec une entrée de journal. Vous avez aussi vérifié chaque changement avec un jeu de régression. Votre projet correspond à l’instantané end-of-m06 : python -m pytest -q affiche 108 passed (108 tests réussis). Seul README.md diffère : la version de l’instantané liste les commandes de ce module. Copiez-la depuis l’instantané si vous le souhaitez.
Exercice du module : un plan de prototype, des exemples de sorties et un rapport d’évaluation
Section intitulée « Exercice du module : un plan de prototype, des exemples de sorties et un rapport d’évaluation »Livrez les trois documents nécessaires à une équipe avant de mettre un prototype entre les mains des utilisateurs. Ce sont un plan de fonctionnement du pipeline, des exemples de sorties montrant leurs preuves et un rapport d’évaluation.
Exercice guidé : la livraison du cours
Section intitulée « Exercice guidé : la livraison du cours »-
Lisez le rapport d’évaluation
docs/evaluation-report.md. C’est l’exemple détaillé. Il contient un tableau par chemin, une analyse des erreurs par type de document et une section « What this does not show » (ce que cela ne montre pas). Vérifiez deux de ses nombres avec votre propre sortie depython -m doc_extract.evaluate --systems text,ocr,ocr_prepared,vision,vision_v1,combined. -
Rassemblez des exemples de sorties pour un document lisible, un document illisible et un document endommagé :
out/results/D011.json,out/results/D046.jsonetout/results/D061.json. La vérification de fin ci-dessous explique ce que chacun montre. -
Lisez le plan
docs/operations.md. Il couvre le traitement en arrière-plan, les versions et le retraitement, la suppression, le jeu de régression et la correction de cette leçon. Ajoutez les nombres de votre budget de la leçon précédente : pages par jour, part confiée au modèle, coût quotidien et nombre de processus OCR.
Exercice autonome : les reçus en français
Section intitulée « Exercice autonome : les reçus en français »L’équipe de Camille, à Montréal, traite les reçus en français. Elle demande son propre court rapport avant d’utiliser le pipeline. Changez une condition : évaluez seulement les reçus en français. Rédigez une demi-page :
- Quels documents en français font partie du jeu, et de quels types sont-ils?
- Quels résultats obtiennent la requête simple, la requête précise et le pipeline combiné : valeurs correctes, valeurs inventées, documents complets?
- Pour combien de documents en français le pipeline combiné appelle-t-il le modèle?
- Qu’est-ce que votre rapport ne montre pas?
Utilisez out/evaluation.json de la première leçon de ce module, et documents.receipts(), dont les documents ont un language (langue).
Afficher une solution détaillée
Dans python :
import jsonfrom doc_extract import combine, documentsresult = json.load(open("out/evaluation.json", encoding="utf-8"))french = [d for d in documents.receipts() if d.language == "fr"]print("French receipt documents:", ", ".join(f"{d.doc_id} {d.source}" for d in french))for system in ("vision_v1", "vision", "combined"): rows = [result["systems"][system]["per_doc"][d.doc_id] for d in french] outcomes = [o for r in rows for o in r["fields"].values()] printed = sum(o in ("correct", "missing", "wrong") for o in outcomes) print(f"{system:<10} right {outcomes.count('correct')} of {printed}, missing {outcomes.count('missing')}, " f"wrong {outcomes.count('wrong')}, invented {outcomes.count('invented')}, " f"complete {sum(r['complete'] for r in rows)} of {len(rows)}")used = [d.doc_id for d in french if combine.combine(d)[1].used_model]print("the combined pipeline called the model for:", ", ".join(used) or "none")French receipt documents: D004 digital_pdf, D009 digital_pdf, D012 digital_pdf, D015 digital_pdf, D021 scan_pdf, D026 scan_image, D031 scan_pdf, D036 photo, D040 photo, D044 photovision_v1 right 82 of 84, missing 0, wrong 2, invented 0, complete 8 of 10vision right 83 of 84, missing 0, wrong 1, invented 0, complete 9 of 10combined right 84 of 84, missing 0, wrong 0, invented 0, complete 10 of 10the combined pipeline called the model for: noneUn court rapport à partir de ces nombres :
- Les documents. Dix des 54 reçus sont en français : quatre PDF numériques (D004, D009, D012, D015), trois numérisations (D021, D026, D031) et trois photos (D036, D040, D044).
- Les résultats. Le pipeline combiné lit correctement les 84 valeurs imprimées, et les 10 documents sont complets. La requête simple lit mal deux dates, sur D021 et D036. La requête précise lit le fournisseur de D009 comme
LARKEFIELD. Aucune requête n’invente de valeur ici, car chaque reçu en français affiche son numéro de commande. Aucun champ vide n’est à remplir. - Le modèle. Le pipeline combiné ne l’appelle jamais pour ces documents. Les règles connaissent les mots français de Larkfield, comme Sous-total, TPS, TVQ et Paiement. Les reçus en français n’entraînent donc aucun coût de modèle.
- Ce que cela ne montre pas. Dix documents représentent un petit échantillon. Une valeur erronée change la proportion de plus d’un point, et un document change le taux de complétion de 10 points. Chaque document en français utilise une mise en page Larkfield créée par le générateur du cours. Un reçu en français d’un magasin partenaire nécessiterait le modèle, et personne n’a encore mesuré ce cas.
Vérification de fin : des sorties traçables pour les documents lisibles, illisibles et endommagés
Section intitulée « Vérification de fin : des sorties traçables pour les documents lisibles, illisibles et endommagés »Montrez d’où vient chaque sortie pour un document lisible, un document illisible et un document endommagé. Expliquez aussi pourquoi le pipeline a pris chaque décision. Utilisez D011, D046 et D061.
Afficher une solution détaillée
Dans python :
import jsonfor doc in ("D011", "D046", "D061"): r = json.load(open(f"out/results/{doc}.json", encoding="utf-8")) print(f"{doc} {r['file']} intake: {r['intake']['status']} {r['intake']['reason']}".rstrip()) for name in ("vendor", "total"): f = r.get("fields", {}).get(name) if f: ev = f["evidence"] where = f"page {ev['page']}, box {ev['box']} {ev['unit']}" if ev and ev.get("box") else "no box" print(f" {name:<7} {str(f['value']):<10} {f['status']:<7} {f['reason'] or '':<11} {where}") print(f" review: {r['review']['needed']}; {'; '.join(r['review']['reasons'])[:150]}") print(f" made by pipeline {r['versions']['pipeline']}, contract {r['versions']['contract']}")D011 receipt-lk-103119.pdf intake: accepted vendor Larkfield found page 1, box [75.6, 22.7, 151.2, 36.7] pt total 211.68 found page 1, box [14.2, 226.8, 212.6, 235.8] pt review: False; made by pipeline 1.0.1, contract receipt-v1D046 IMG_4887.jpg intake: accepted vendor None absent unreadable no box total None absent unreadable no box review: True; vendor: vendor is missing; date: date is missing; currency: currency is missing; subtotal: subtotal is missing; tax: tax is missing; total: total is m made by pipeline 1.0.1, contract receipt-v1D061 receipt-download.pdf intake: corrupt EOF marker not found review: True; intake: corrupt: EOF marker not found made by pipeline 1.0.1, contract receipt-v1- Lisible (D011, un reçu numérique) : chaque valeur indique sa page et son cadre en points sur le PDF original. Un agent peut donc voir la ligne d’origine. Aucun motif de révision : le document va directement aux agents.
- Illisible (D046, une photo floue) : les valeurs sont absentes avec le motif
unreadable(illisible). Il n’y a aucun cadre, car rien n’a été lu. Rien n’est inventé. Les motifs de révision nomment chaque champ obligatoire manquant. Une personne demande donc une meilleure photo au client. - Endommagé (D061, un téléchargement interrompu) : l’admission l’arrête avec le motif
EOF marker not found(marqueur de fin de fichier introuvable). Il n’y a aucun champ, car rien n’a été lu. Le résultat existe quand même, avec sa décision de révision. L’agent sait donc pourquoi il n’y a aucune valeur.
Les trois résultats indiquent les versions du pipeline et du contrat qui les ont produits. Chaque sortie est donc traçable jusqu’à un fichier, une page, un cadre, un motif et une version.
Récapitulatif
- Le pipeline fonctionne comme un processus en arrière-plan. Le système de billets répond immédiatement, et personne n’attend l’OCR ou le modèle.
- Chaque résultat stocke les versions qui l’ont produit. Changez la version avec le code. Ensuite,
statustrouve les anciens résultats etreprocessles traite à nouveau. pipeline deletesupprime le résultat, le cache OCR et les lignes de révision d’un document. Il écrit une ligne de journal sans contenu. L’original appartient au système de billets.- Le jeu de régression contient 15 documents, un de chaque type. Chaque modification doit ne produire aucun changement ou expliquer chacun d’eux, comme la devise de D045 avec des images plus petites.
- Corrigez un bogue avec un test qui échoue d’abord. La correction du prix unitaire dans le cours a supprimé 16 faux avertissements sans changer le jeu de régression.
Ensuite, les études de cas exécutent le pipeline sur de vrais documents publics : des photos de reçus étiquetées et un tableau d’un rapport statistique public.
Leçon suivante : Lire de vrais reçus