Aller au contenu
English

Contraintes opérationnelles

  • Leçon 18
  • 50 min
  • Module 6 : Évaluer et livrer le pipeline

Où nous en sommes

Dans la dernière leçon, nous avons mesuré la qualité de lecture de chaque lecteur, champ par champ. Mais un bon lecteur peut quand même être trop lent, trop cher ou trop gros pour la machine. « Envoyer simplement chaque page au modèle » a un prix en secondes, en argent et en mémoire. Dans cette leçon, nous multiplions les coûts unitaires de chaque chemin par le volume prévu, et nous notons les hypothèses, comme pour planifier un voyage en voiture.

Ce que vous saurez faire

Sachez ce que coûte une page avant de recevoir la facture : secondes, jetons, argent, nouvelles tentatives, mémoire et stockage. Faites-le pour chaque façon de la lire. Multipliez ces coûts unitaires par le volume prévu et notez les hypothèses. La question d’Omar, « combien ça coûte par page? », aura alors une réponse chiffrée et justifiée.

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

Ce que vous devez savoir

  • Le temps et le coût de chaque chemin pour une page, dans Chemins texte et OCR.
  • Pourquoi le pipeline combiné appelle le modèle pour seulement 9 documents sur 54, dans Combiner les méthodes.
  • Les jetons et les prix courants, dans Modèle de coûts du cours Conception de systèmes d’IA et maîtrise des coûts, si vous l’avez suivi. Cette leçon explique chaque calcul.

Ce qu’il vous faut sur votre ordinateur

  • Votre projet à la fin de la leçon précédente : python -m pytest -q affiche 101 passed (101 tests réussis).
  • Aucune clé et aucun argent. Les jetons et les temps du modèle proviennent des appels enregistrés du cours.

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. Les temps sur votre ordinateur seront différents : comparez les rapports, pas les secondes.

  1. Copiez le module et son test depuis l’instantané :

    Fenêtre de terminal
    S=../nextia-learning-labs/C13/snapshots/end-of-m06
    cp $S/doc_extract/budget.py doc_extract/
    cp $S/tests/test_budget.py tests/
  2. Exécutez les tests :

    Fenêtre de terminal
    python -m pytest -q

    La dernière ligne est 103 passed (103 tests réussis).

Avant un long trajet, vous préparez un petit budget. Votre voiture consomme environ 7 litres de carburant aux 100 km. Vous connaissez ce chiffre parce que vous l’avez mesuré lors de voyages précédents. Le trajet prévu est d’environ 1 200 km, mais des détours peuvent survenir. Vous ajoutez donc une marge. Vous vérifiez aussi deux limites que l’argent ne règle pas : les heures de conduite par jour et la capacité du coffre.

Le budget contient deux types de chiffres. Certains sont mesurés : le carburant aux 100 km. D’autres sont des hypothèses : la distance et les détours. Vous les multipliez et vous notez leur type. Si le voyage coûte plus cher, vous savez quel chiffre était incorrect.

Le problème : « envoyons simplement chaque page au modèle »

Section intitulée « Le problème : « envoyons simplement chaque page au modèle » »

Omar, le responsable produit, pose à Mei la question que tous les responsables posent : « Combien ça coûte par page? » Tomás a déjà une réponse : « Le modèle de vision lit correctement 97,7 % des valeurs. Envoyons-lui chaque page. Ça coûte un cent par page. »

Un cent semble négligeable. Mais personne n’a encore fait la multiplication. Le service de soutien de Larkfield pourrait recevoir 300 pages par jour. Le temps de réponse médian du modèle est de 7,35 secondes, et un appel enregistré a pris 132 secondes. La réponse dépend aussi de ce qui exécute l’OCR. Avec les réglages par défaut du moteur, un processus OCR a atteint 2 180 Mo de mémoire sur les pages du cours (mesuré). Un processus limité à 2 Go de mémoire s’arrête au milieu d’un lot.

Aucune de ces limites n’apparaît dans un tableau d’exactitude. Chacune détermine si le pipeline fonctionne pendant une journée chargée.

L’idée : multiplier les coûts unitaires par le volume et noter les hypothèses

Section intitulée « L’idée : multiplier les coûts unitaires par le volume et noter les hypothèses »

Un budget opérationnel indique le coût d’une page pour chaque chemin, puis le multiplie par le volume prévu. Il comprend cinq parties :

  • Temps par page : la durée du traitement d’une page sur chaque chemin. Elle détermine le nombre de processus nécessaires et le temps d’attente d’un agent.
  • Jetons et argent par page : ce que le modèle lit et écrit. Les jetons sont les morceaux de texte qu’un fournisseur de modèles compte et facture. Une image est aussi facturée en jetons.
  • Nouvelles tentatives : certains appels échouent ou dépassent le délai, et vous les envoyez de nouveau. Chaque nouvelle tentative est un autre appel payant.
  • Mémoire par processus : la plus grande quantité de mémoire nécessaire à un processus, son pic. Elle détermine combien de processus peuvent fonctionner sur une machine.
  • Stockage par document : le fichier original et tout ce que le pipeline produit à partir de ce fichier.

Chaque chiffre reçoit une étiquette. Mesuré signifie que le cours a exécuté le code du projet et chronométré son exécution. Enregistré désigne une vraie réponse du modèle, conservée avec ses jetons et son temps. Une hypothèse est un chiffre que vous choisissez, comme le nombre de pages par jour. La commande budget du projet affiche ces étiquettes.

Prenez 300 pages par jour et supposez que 25 % nécessitent le modèle. Supposez aussi que 2 % des appels au modèle sont envoyés de nouveau. Chaque chiffre du calcul est visible :

model calls per day = 300 pages x 0.25 x 1.02 = 76.5 calls
tokens of one page = 3,164 in + 556 out (recorded medians)
price of one page = 3,164 x US$2 / 1,000,000 = US$0.0063 (input)
+ 556 x US$10 / 1,000,000 = US$0.0056 (output)
= US$0.0119
money per day = 76.5 x US$0.0119 = US$0.91
OCR time per day = 300 pages x 1.34 s = 402 s = 6.7 CPU minutes

Les jetons de sortie coûtent cinq fois plus que les jetons d’entrée au prix courant utilisé dans le cours. Les 556 jetons écrits par le modèle coûtent donc presque autant que les 3 164 jetons qu’il lit. C’est pourquoi la requête précise coûte plus cher que la requête simple : sa réponse est plus longue.

Schéma du budget d'une journée. 300 pages par jour (hypothèse) se divisent en deux groupes. 75 % passent par la couche texte ou l'OCR et les règles : 0 $ US sur votre processeur, OCR à 1,34 s par page, 6,7 minutes de processeur par jour (mesuré). 25 % passent par le modèle : 75 appels (hypothèse), plus 2 % d'appels répétés : 76 appels (hypothèse), multipliés par 0,0119 $ US par page, 3 164 jetons en entrée et 556 en sortie (enregistré, prix courant) : 0,91 $ US par jour, environ 27 $ US par mois.
Une journée de 300 pages. Les cases en pointillés sont des hypothèses; les cases vertes sont les résultats. Modifiez une hypothèse, et les résultats changent.
Description textuelle du diagramme

Schéma du budget d’une journée. 300 pages par jour, une hypothèse, se divisent en deux groupes. 75 % passent par la couche texte ou l’OCR et les règles, sans frais. L’OCR prend 1,34 seconde par page sur cet ordinateur : 6,7 minutes de processeur par jour. 25 % passent par le modèle : 75 appels, plus 2 % d’appels répétés, soit 76 appels. Chaque appel coûte 0,0119 $ US, selon les jetons médians enregistrés (3 164 en entrée, 556 en sortie) au prix courant. Le résultat est de 0,91 $ US par jour, environ 27 $ US par mois.

  1. Exécutez le budget avec les hypothèses par défaut :

    Fenêtre de terminal
    python -m doc_extract.budget
    Measured on this computer (sample of 6 documents):
    text layer 6 ms per page, US$0
    OCR 1.34 s per page (with preparation), US$0 (your CPU)
    From the course's 56 recorded vision calls (median):
    vision model 7.35 s per page, 3164 tokens in, 556 out = US$0.0119 per page at list price
    Assumptions: 300 pages a day, 25% of them sent to the model, 2% of model calls repeated
    model calls per day 76 -> US$0.91 a day, about US$27 a month
    OCR time per day 6.7 CPU minutes if every page needs OCR
    all pages to the model instead: US$3.64 a day
    storage: originals about 148 kB each (median); keep them, they are the evidence

    La commande lit six documents avec la couche texte et l’OCR, sans cache. Elle prend donc environ 7 secondes. Le temps d’OCR change d’une exécution à l’autre. Le cours a observé de 1,12 à 1,34 seconde par page, pendant l’exécution d’autres tâches. Ce n’est pas non plus la médiane du cours de 0,97 seconde sur les 54 pages de reçus. Le budget chronomètre seulement un échantillon de six documents, au moment où vous l’exécutez. Votre temps sera différent. Les chiffres du modèle ne changent pas, car ils proviennent des enregistrements.

  2. Envoyez chaque page au modèle, comme Tomás l’a proposé :

    Fenêtre de terminal
    python -m doc_extract.budget --pages 300 --model-share 1.0
    Assumptions: 300 pages a day, 100% of them sent to the model, 2% of model calls repeated
    model calls per day 306 -> US$3.64 a day, about US$109 a month

    Cela coûte quatre fois plus cher. Cela ajoute aussi 7 secondes d’attente à chaque page, même aux reçus numériques lus par la couche texte en 5 millisecondes.

  3. Mesurez la proportion réelle du pipeline combiné. Dans python :

    from doc_extract import combine, documents
    docs = documents.receipts()
    used, cost = [], 0.0
    for d in docs:
    ex, dec = combine.combine(d)
    if dec.used_model:
    used.append(d.doc_id)
    cost += ex.usage.get("cost_usd") or 0
    print(f"the model read {len(used)} of {len(docs)} documents: {', '.join(used)}")
    print(f"US${cost:.3f} in all, US${cost / len(docs):.4f} per document")
    the model read 9 of 54 documents: D017, D018, D033, D034, D045, D046, D047, D048, D049
    US$0.097 in all, US$0.0018 per document

    Six des neuf documents sont les reçus de l’autre magasin, dont les règles ne connaissent pas les mots. Les trois autres sont les photos abîmées. Neuf sur 54 donne 17 %.

  4. Insérez la proportion mesurée dans le budget :

    Fenêtre de terminal
    python -m doc_extract.budget --pages 300 --model-share 0.17
    Assumptions: 300 pages a day, 17% of them sent to the model, 2% of model calls repeated
    model calls per day 52 -> US$0.62 a day, about US$19 a month

La proportion de 17 % est mesurée sur les documents du cours, pas sur les vrais courriels de Larkfield. Si davantage de clients envoient des reçus de magasins partenaires, la proportion augmente. Elle reste donc une hypothèse dans le budget, mais elle est maintenant justifiée.

  • Proportion supposée de pages
  • Proportion mesurée sur les documents du cours
Coût du modèle pour une journée de 300 pages, selon trois proportions de pages envoyées au modèle, avec 2 % d'appels répétés. Selon la commande de budget : jetons enregistrés au prix courant, multipliés par les volumes supposés.
Description textuelle du graphique

Coût du modèle pour une journée de 300 pages, avec 2 % d’appels répétés. Toutes les pages au modèle : 3,64 $ US. Un quart des pages : 0,91 $ US. La proportion mesurée sur les documents du cours, 17 % : 0,62 $ US.

Les quatre chemins diffèrent par un facteur de plus de mille. Le cours les a mesurés sur les 54 pages de reçus :

  • S'exécute sur votre processeur
  • Un appel au modèle (enregistré)
Secondes médianes par page sur les 54 pages de reçus du cours. La couche texte et l'OCR ont été exécutés sur l'ordinateur du cours; les temps du modèle de vision proviennent des appels enregistrés.
Description textuelle du graphique

Secondes médianes par page. Couche texte : 0,0054 seconde. OCR sur l’image brute : 0,49. OCR avec préparation : 0,97. Modèle de vision : 7,35.

Une médiane cache les appels lents, et ces appels font attendre les agents. Le cours a examiné chaque appel enregistré de la requête précise (une vérification de l’ensemble complet, exécutée par le cours) :

54 receipt pages; tokens in: median 3135, min 1269, max 3194; tokens out: median 556
cost per page: median US$0.0113, max US$0.0143, all 54 pages US$0.60
seconds per page: median 7.35, p95 10.65, max 11.49
second pass (56 calls): max 132.2 s
digital_pdf 21 pages, tokens in median 1431, cost median US$0.0098
scan_pdf 7 pages, tokens in median 3194, cost median US$0.0124
scan_image 10 pages, tokens in median 3194, cost median US$0.0114
photo 15 pages, tokens in median 3135, cost median US$0.0115

Le p95 est le temps sous lequel restent 95 % des appels : 10,65 secondes. Quand le cours a envoyé les mêmes pages une deuxième fois, un appel a pris 132 secondes. Un processus qui appelle le modèle a donc besoin d’un délai maximal : une durée après laquelle il cesse d’attendre. Il envoie ensuite l’appel de nouveau ou envoie la page en révision. Chaque appel répété est facturé de nouveau. C’est le taux de nouvelles tentatives du budget.

Les reçus de caisse étroits coûtent moins de jetons que les numérisations au format lettre : 1 431 contre 3 194. L’image est plus petite. La commande de budget prend la médiane des 56 appels enregistrés, qui comprennent aussi deux fichiers problématiques. Elle établit donc le coût d’une page à 0,0119 $ US, légèrement au-dessus des 0,0113 $ US des pages de reçus. Pour un budget, le chiffre supérieur est le choix prudent.

Mémoire : combien de processus peuvent fonctionner sur une machine

Section intitulée « Mémoire : combien de processus peuvent fonctionner sur une machine »

Un processus qui exécute l’OCR garde les modèles OCR et une grande image en mémoire. L’OCR fonctionne en deux étapes : un détecteur de texte trouve les lignes de texte, puis un lecteur lit chaque ligne. Le détecteur de texte travaille sur une copie de la page, réduite à une taille maximale. Le cours a mesuré le pic de mémoire d’un processus qui a lu chaque page de reçus :

  • Taille par défaut du moteur
  • Réglage du projet
Pic de mémoire d'un processus qui lit les pages de reçus du cours avec l'OCR, pour deux tailles d'image du détecteur de texte. Les deux réglages lisent correctement 408 des 435 valeurs imprimées. Mesuré sur l'ordinateur du cours.
Description textuelle du graphique

Pic de mémoire d’un processus OCR. Avec des images jusqu’à 2 000 pixels, la valeur par défaut du moteur : 2 180 Mo. Avec des images jusqu’à 1 280 pixels, le réglage du projet : 1 447 Mo. Les deux lisent correctement 408 des 435 valeurs imprimées.

Avec la taille par défaut, un processus nécessite plus de 2 Go. Limiter l’image du détecteur de texte à 1 280 pixels économise environ 730 Mo. Le cours n’a constaté aucune perte : les mêmes 408 valeurs sont correctes. C’est le réglage par défaut du projet, OCR_MAX_SIDE=1280. La règle de planification est donc un processus OCR pour environ 1,5 Go de mémoire. Un serveur avec 8 Go libres exécute au maximum cinq processus OCR, en laissant de la mémoire pour le système. Mesurez de nouveau quand les documents changent. Dans l’étude de cas Lire de vrais reçus, un processus préparant 100 vraies photos de téléphone a atteint environ 2,5 Go avec ce réglage. Sur les photos brutes, il a atteint environ 1,25 Go.

Dans python :

import statistics
from pathlib import Path
originals = [p.stat().st_size for p in Path("data/documents").iterdir() if p.is_file()]
cache = [p.stat().st_size for p in Path("out/cache/ocr").glob("*.json")]
print(f"originals: {len(originals)} files, {sum(originals) / 1e6:.1f} MB, median {statistics.median(originals) / 1e3:.0f} kB")
print(f"OCR cache: {len(cache)} pages, {sum(cache) / 1e6:.1f} MB, median {statistics.median(cache) / 1e3:.0f} kB")
originals: 65 files, 17.3 MB, median 131 kB
OCR cache: 110 pages, 0.4 MB, median 4 kB

Votre nombre d’éléments en cache peut différer : il dépend des commandes que vous avez exécutées. Les originaux sont beaucoup plus volumineux que tout ce que le pipeline produit à partir d’eux. Gardez-les quand même : ce sont les preuves vers lesquelles pointe chaque zone. Le cache peut toujours être recréé, au prix du temps d’OCR. Prenez 300 fichiers de reçus par jour, à la taille médiane des reçus de 148 ko. Les originaux augmentent alors d’environ 44 Mo par jour, ou 16 Go par année. C’est une hypothèse multipliée par une mesure, et vos règles de conservation déterminent combien de temps vous les gardez.

Quand établir un budget et ce qu’il ne peut pas vous dire

Section intitulée « Quand établir un budget et ce qu’il ne peut pas vous dire »
  • Établissez un budget avant de choisir un chemin, avec vos propres volumes. Un chemin peu coûteux par page peut coûter cher par mois.
  • Mesurez le temps sur votre propre machine. Les temps du cours sont ceux d’un ordinateur qui exécute aussi d’autres tâches. Gardez les rapports : le modèle est environ mille fois plus lent que la couche texte.
  • Gardez les étiquettes. Quand la facture dépasse le budget, vérifiez d’abord les hypothèses : la proportion de pages envoyées au modèle et les nouvelles tentatives.
  • Les prix changent. Le cours utilise un prix courant de 2 $ US par million de jetons d’entrée et de 10 $ US par million de jetons de sortie. Vérifiez la page des prix actuels de votre fournisseur.
  • Un budget n’est pas une mesure de qualité. Le plan le moins cher, avec seulement les règles, ne peut pas lire les reçus de l’autre magasin. Utilisez l’évaluation de la leçon précédente pour choisir, puis le budget pour planifier.

Erreur courante

Le processus OCR qui s'arrêtait chaque nuit

Symptôme : Chaque nuit, un lot de numérisations s’arrête à peu près au même endroit. La file de tâches montre les mêmes pages qui échouent encore et encore. Le matin, le journal du processus se termine sans message d’erreur.

Cause : Le processus s’exécute dans un conteneur limité à 2 Go de mémoire. Quelqu’un a rétabli la taille d’image par défaut du détecteur de texte, soit 2 000 pixels. Sur les pages du cours, un processus OCR atteint alors 2 180 Mo, et le système l’arrête. Chaque nouvelle tentative reprend les mêmes pages et s’arrête encore. Ce récit est construit, mais les chiffres de mémoire sont les mesures du cours.

Diagnostic : Mesurez le pic de mémoire d’un processus sur un vrai lot, avec un cache OCR vide. Sur macOS, placez /usr/bin/time -l avant la commande du processus : elle affiche « maximum resident set size » (taille maximale de mémoire résidente) à la fin. Sur Linux, utilisez /usr/bin/time -v. Comparez le pic à la limite du conteneur.

Solution : Gardez OCR_MAX_SIDE=1280, le réglage par défaut du projet : 1 447 Mo, avec les mêmes valeurs correctes. Prévoyez un processus OCR pour environ 1,5 Go. Arrêtez les nouvelles tentatives d’une tâche après quelques échecs et envoyez ses pages en révision avec une raison.

Conséquence pour le travail en IA : les modèles ont besoin de mémoire, mais aussi de temps et d’argent. Un réglage meilleur sur une page peut arrêter un lot entier. Une nouvelle tentative sans limite transforme un échec en boucle.

Changez une condition : Larkfield achète un deuxième magasin, et le service de soutien prévoit 1 000 pages par jour. Les reçus partenaires sont plus fréquents, donc les appels échouent plus souvent : supposez que 10 % des appels au modèle sont répétés. Gardez 25 % des pages pour le modèle. Prédisez le nombre d’appels au modèle et le coût par jour. Puis exécutez :

Fenêtre de terminal
python -m doc_extract.budget --pages 1000 --model-share 0.25 --retry-rate 0.10
Afficher la réponse
Assumptions: 1000 pages a day, 25% of them sent to the model, 10% of model calls repeated
model calls per day 275 -> US$3.27 a day, about US$98 a month
OCR time per day 21.0 CPU minutes if every page needs OCR
all pages to the model instead: US$13.08 a day

À la main : 1 000 × 0,25 × 1,10 = 275 appels, et 275 × 0,0119 $ US = 3,27 $ US. Le volume a été multiplié par 3,3 et le taux de nouvelles tentatives par cinq, mais le coût seulement par 3,6. Les nouvelles tentatives représentent une petite partie de la facture. Le temps d’OCR reste faible : 21 minutes de processeur par jour conviennent facilement à un seul processus. Avec 10 % de nouvelles tentatives, vérifiez toutefois pourquoi les appels échouent avant de les payer. Un délai maximal trop court répète des appels qui auraient réussi.

Vérifiez votre compréhension

Expliquez pourquoi la commande de budget indique des hypothèses pour les pages par jour et la proportion envoyée au modèle, mais des valeurs consignées pour les jetons par page.

Afficher la réponse

Les jetons par page proviennent d’appels réels au modèle, consignés avec leur nombre de jetons. Le cours les a mesurés une fois. Ils ne changent pas quand vous exécutez la commande. Les pages par jour et la proportion envoyée au modèle sont des choix concernant l’avenir. Personne n’a encore mesuré le courrier réel de Larkfield. Les mentions indiquent quels nombres vérifier d’abord quand la facture diffère du budget : les hypothèses.

Vérifiez votre compréhension

Prédisez : l'équipe recadre chaque photo de reçu avant l'appel au modèle. Les jetons d'entrée par page passent de 3 164 à 1 300. La sortie reste à 556 jetons. Combien coûte maintenant une page, au prix courant utilisé dans le cours?

Afficher la réponse

Entrée : 1 300 × 2 $ US / 1 000 000 = 0,0026 $ US. Sortie : 556 × 10 $ US / 1 000 000 = 0,0056 $ US. Ensemble, cela donne 0,0082 $ US par page, soit environ un tiers de moins que 0,0119 $ US. La sortie ne change pas. Elle représente donc maintenant la plus grande part du coût. Le recadrage ne peut pas rendre une page moins coûteuse que sa réponse.

Vérifiez votre compréhension

Vérification pratique : exécutez python -m doc_extract.budget --pages 300 --model-share 0.17. Combien d'appels au modèle par jour la commande affiche-t-elle? Combien de processus OCR un serveur ayant 6 Go de mémoire libre pourrait-il exécuter?

Afficher la réponse

La commande affiche model calls per day 52 -> US$0.62 a day (52 appels au modèle par jour, soit 0,62 $ US par jour) : 300 × 0,17 × 1,02 = 52 appels. Un processus OCR nécessite environ 1,5 Go avec les réglages du projet. Avec 6 Go, trois processus peuvent fonctionner, en laissant de la mémoire pour le système. Un seul processus pourrait déjà traiter l’OCR d’une journée : environ 6 à 7 minutes de processeur pour 300 pages. Les processus supplémentaires aident quand plusieurs reçus arrivent en même temps.

Récapitulatif

  • Un budget multiplie les coûts unitaires par les volumes. Il indique la nature de chaque nombre : mesuré, consigné ou hypothèse.
  • Le modèle coûte environ 0,0119 $ US par page au prix courant. Envoyer chaque page au modèle : 3,64 $ US par jour pour 300 pages. Le pipeline combiné envoie 9 documents sur 54 : 0,0018 $ US par document.
  • Temps : 5 ms pour la couche de texte, environ 1 s pour l’OCR, 7,35 s pour le modèle. Les appels lents atteignent 132 s. Un processus nécessite un délai maximal, et chaque nouvelle tentative est payante.
  • Mémoire : un processus OCR nécessite 1 447 Mo avec les réglages du projet, et 2 180 Mo avec les réglages par défaut du moteur. Prévoyez un processus OCR par tranche d’environ 1,5 Go.
  • Stockage : conservez les originaux, qui servent de preuves. Le cache peut être recréé.

Ensuite, vous exécutez le pipeline en arrière-plan, aux côtés du système de billets de soutien. Vous relancez le traitement après un changement et supprimez les données d’un client. Vous protégez chaque changement avec un jeu de données de non-régression.

Leçon suivante : Intégration et maintenance