Aller au contenu
English

Un service de routage

  • Leçon 35
  • 45 min
  • Module 9 : Exploiter le routeur en production

Où nous en sommes

Nous pouvons choisir un modèle, ses seuils et ses zones dans un carnet (*notebook*) Jupyter. Un carnet ne peut pas répondre à la boîte de réception toute la journée. Dans cette leçon, Amira exécute le routeur comme un petit service. Il charge le modèle une seule fois, vérifie son entrée et renvoie l'étiquette, la confiance et la version du modèle.

Leçon 35 sur 37 · Classification et routage de textes : envoyer chaque message au bon endroitUn service de routage
Aperçu du cours

Ce que vous saurez faire

Exécutez le routeur comme un petit service que la boîte de réception peut appeler toute la journée. Il charge le modèle une seule fois, refuse les entrées invalides et répond avec la destination, la zone, la confiance et les versions. Il consigne chaque décision sans le texte du message et place les messages incertains dans la file de révision de Chloé.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le dossier du projet larkroute du module 8, avec son environnement virtuel .venv et son dossier data/. Le dossier d’exercices nextia-learning-labs se trouve à côté. Exécutez git -C nextia-learning-labs pull dans le dossier parent pour obtenir les fichiers les plus récents.
  • Si vous n’avez pas le projet du module 8, copiez l’instantané nextia-learning-labs/C36/snapshots/end-of-m08 dans un nouveau dossier larkroute. Suivez ensuite son README.md pour créer l’environnement et obtenir les données.
  • Deux fenêtres de terminal : l’une exécute le service, l’autre lui envoie des messages.

Testé sur macOS avec Python 3.12.13, FastAPI 0.162.0, uvicorn 0.54.0 et scikit-learn 1.9.1. Les commandes Windows (PowerShell) sont fournies, mais nous ne les avons pas exécutées.

Imaginez le comptoir de tri d’un bureau de poste. Le matin, la commis ouvre le guide et apprend les règles de la journée. Elle ne relit pas tout le guide pour chaque lettre. Quand une lettre arrive, elle la vérifie d’abord : y a-t-il une adresse? Une lettre sans adresse est retournée, avec une note qui explique pourquoi.

Ensuite, elle place la lettre dans un casier. Si elle est certaine, la lettre va directement dans le casier d’une rue. Sinon, elle la place dans un casier pour la superviseure. À la fin de la journée, la superviseure examine ce casier.

La commis tient aussi un registre. Pour chaque lettre, elle note son numéro, le casier et l’édition du guide qu’elle a utilisée. Elle ne copie jamais le contenu de la lettre : c’est privé. Si quelqu’un demande plus tard pourquoi une lettre est allée à la mauvaise rue, le registre donne la réponse.

Larkfield a besoin du même comptoir pour sa boîte de réception, et il doit rester ouvert toute la journée.

Le problème : un carnet ne peut pas répondre à la boîte de réception

Section intitulée « Le problème : un carnet ne peut pas répondre à la boîte de réception »

Jusqu’ici, Priya exécutait le routeur dans un carnet ou avec une seule commande route. Chaque exécution lit les données, entraîne ou charge un modèle, calcule les scores des messages, puis s’arrête. La boîte de réception de Larkfield fonctionne autrement. Les messages arrivent un à la fois, par courriel, clavardage et réseaux sociaux, toute la journée. Le logiciel du centre d’assistance a besoin d’une réponse pour chacun en quelques millisecondes.

Amira, la développeuse, énumère les problèmes si elle se contente de placer le code de Priya dans une boucle :

  1. Charger le modèle pour chaque message est lent. Sur le portable de test, charger le modèle enregistré prenait 26,7 ms chaque fois. Router un message prenait 0,49 ms. La majeure partie du temps sert donc au chargement, pas au routage.
  2. Une entrée invalide reçoit une réponse qui semble confiante. Nous avons donné un texte vide au modèle, sans vérification préalable. Il a envoyé le texte vide à product (produit), avec une confiance de 0,3036. Un message vide attendrait dans la file de révision pour un agent chargé des produits.
  3. Personne ne peut dire quel modèle a décidé. Priya réentraîne souvent le modèle. Si les réponses ne nomment pas le modèle, impossible de retracer une mauvaise destination le mois prochain.
  4. Un journal contenant le texte des messages présente un risque pour la vie privée. Les messages contiennent des noms, des numéros de commande et des adresses. Les gens copient les fichiers de journaux (logs), les partagent et les conservent longtemps.
Charger le modèle pour chaque message ajoute environ 27 ms. Une fois le modèle en mémoire, un message prend 0,49 ms. Mesuré sur le portable de test; vos temps seront différents.
Description textuelle du graphique

Un graphique à deux colonnes. La première colonne montre le temps pour un message quand le service charge le modèle pour chaque message : 27,2 ms. La deuxième montre le temps quand le modèle est déjà en mémoire : 0,49 ms. La deuxième colonne est si courte que seule son étiquette de valeur apparaît.

Le premier chargement de la journée est encore plus lent : 673 ms, car Python doit aussi charger scikit-learn. Un service paie ce coût une seule fois, au démarrage.

Un service est un programme qui fonctionne en permanence et répond aux requêtes d’autres programmes. Ici, le logiciel du centre d’assistance envoie un message, et le service répond avec une destination. Les deux programmes communiquent par HTTP, le même protocole qu’utilise un navigateur Web. Le service écoute sur un port, un numéro qui désigne une porte sur l’ordinateur. Le nôtre est 8036.

Le service possède un point de terminaison pour le routage : une adresse et une méthode, POST /route. Une requête POST transporte des données dans son corps. Ici, le corps est en JSON : du texte contenant des noms et des valeurs, comme {"message_id": "M-999001", "text": "…"}. La réponse est aussi en JSON.

Chaque étape du comptoir de tri devient une règle du service :

Quatre groupes, de haut en bas. Une seule fois, au démarrage du service : models/current indique la version v1, et le service charge model.joblib et card.json et les garde en mémoire. Ensuite, pour chaque message, vérifier l'entrée : un message arrive à POST /route avec message_id, text et channel. Une question : l'entrée est-elle valide? Un identifiant comme M-999001, un texte non vide, un canal connu. Sinon : HTTP 422 avec la raison, et aucune décision. Si oui, avec le modèle en mémoire : router vers une zone. Le modèle donne une confiance pour chaque destination. Une deuxième question : quelle zone? Si la meilleure destination est needs_person : personne. Si la confiance est de 0,58 ou plus : décision. Sous 0,58 : révision. Ce qui sort : la réponse avec route, zone, confidence, model_version et label_version; queue/decisions.jsonl avec chaque décision, mais jamais le texte; queue/review_queue.jsonl avec les décisions à réviser, pour Chloé.
Le service de routage. Le modèle est chargé une seule fois. Chaque message est vérifié, routé vers une zone et consigné sans son texte.
Description textuelle du diagramme

Le schéma comporte quatre groupes, de haut en bas. Le premier groupe se produit une seule fois, au démarrage du service. Le fichier models/current indique la version, v1. Le service charge model.joblib et card.json depuis models/v1/ et les garde en mémoire. Le deuxième groupe vérifie l’entrée de chaque message. Un message arrive à POST /route, avec un identifiant de message, un texte et un canal. Le service demande : l’entrée est-elle valide? L’identifiant doit ressembler à M-999001, le texte doit être non vide et le canal doit être utilisé par Larkfield. Sinon, la réponse est HTTP 422 avec la raison, et aucune décision n’est prise. Si l’entrée est valide, le troisième groupe route le message vers une zone, avec le modèle en mémoire. Le modèle donne une confiance pour chaque destination. Si la meilleure destination est needs_person (besoin d’une personne), la zone est personne. Si la confiance est de 0,58 ou plus, la zone est décision. Sous 0,58, la zone est révision. Le quatrième groupe représente ce qui sort. La réponse contient la destination, la zone, la confiance, la version du modèle et la version des étiquettes. Chaque décision va dans queue/decisions.jsonl, sans le texte. Les décisions à réviser vont aussi dans queue/review_queue.jsonl, pour Chloé.

Le service charge le modèle au démarrage et le garde en mémoire. C’est la commis qui apprend le guide le matin. Dans le code, FastAPI appelle une fonction nommée lifespan une seule fois au démarrage, et cette fonction charge le modèle.

Ensuite, le service vérifie chaque requête avant que le modèle la voie. Le service utilise FastAPI, une bibliothèque Python pour créer des services. FastAPI vérifie les requêtes avec des modèles Pydantic. Un modèle Pydantic est une classe qui énumère les champs de la requête et la règle de chaque champ. La classe Message dans larkroute/service.py indique :

  • message_id doit ressembler à M-999001 : une à trois lettres majuscules, un trait d’union et des chiffres.
  • text doit contenir entre 1 et 5 000 caractères, et pas seulement des espaces.
  • channel doit être email (courriel), chat (clavardage), social (réseaux sociaux) ou marketplace (place de marché). S’il manque, sa valeur est email.

Si un champ ne respecte pas sa règle, FastAPI n’appelle pas notre code. Il répond avec le code d’état 422 (« Unprocessable Content », contenu impossible à traiter). Le corps nomme le champ et le problème. Un code d’état est le numéro au début de chaque réponse HTTP : 200 signifie « OK ». Les codes 400 à 499 signifient « votre requête est incorrecte ».

Pour une requête valide, le modèle donne une confiance pour chaque destination. Le service prend la meilleure destination et choisit la zone avec les seuils de la fiche du modèle :

Message (construit) Meilleure destination Confiance Règle Zone Destination dans la réponse
M-999001: parcel delivered, nothing at my door delivery 0,9937 0,9937 ≥ 0,58 decide delivery
M-999005: a question about my order and the invoice billing 0,394 0,394 < 0,58 review billing
M-999006: the hedge trimmer caught fire, my hand is burned needs_person 0,8519 la meilleure destination est needs_person person needs_person

Nous avons écrit ces messages pour la leçon, et les valeurs sont les réponses réelles du service. Remarquez la troisième ligne. Une personne lit chaque message que le modèle envoie à needs_person, même quand il est certain. Sur les données de validation, le choix le moins coûteux n’avait pas de seuil de faible confiance pour la zone personne. Son seuil est de 0,00. Dans ce modèle, la zone personne contient donc seulement les messages needs_person.

Chaque réponse nomme aussi deux versions :

  • La version du modèle, comme v1, indique quel modèle enregistré a décidé. Chaque version possède son propre dossier, models/v1/, et le projet n’écrase jamais une version.
  • La version des étiquettes, comme labels-4bad2e4ef7, est une empreinte des étiquettes utilisées pour entraîner le modèle. Le projet la calcule à partir des identifiants des messages et de leurs destinations avec SHA-256. Cette fonction transforme tout texte en un code de longueur fixe. Les mêmes étiquettes donnent toujours le même code, et une seule étiquette modifiée donne un nouveau code.

Le service écrit une ligne de JSON pour chaque décision dans queue/decisions.jsonl. Le format JSON lines contient un objet JSON par ligne, pour que d’autres programmes puissent le lire ligne par ligne. La ligne contient l’identifiant du message, la destination, la zone, la confiance, les deux versions, le canal et l’heure. Elle ne contient jamais le texte. L’identifiant du message suffit. Une personne autorisée peut retrouver le message dans le centre d’assistance, où ses règles d’accès s’appliquent déjà.

Les décisions à réviser vont aussi dans queue/review_queue.jsonl. C’est le casier de Chloé : l’identifiant du message, la destination suggérée et la confiance. Dans un vrai centre d’assistance, le service placerait le message dans un écran de file d’attente plutôt qu’un fichier. L’idée reste la même.

Vous ajoutez maintenant le service à votre projet. Le projet est l’instantané end-of-m08 du module 8. Vous copiez les fichiers de ce module depuis l’instantané end-of-m09. Un instantané est une copie du projet à un moment du cours. Ce module possède un seul instantané pour ses trois leçons. Vous copiez donc aussi maintenant les fichiers des deux prochaines leçons.

  1. Ouvrez un terminal dans le dossier parent de larkroute. Entrez dans le projet et activez son environnement :

    Fenêtre de terminal
    cd larkroute
    source .venv/bin/activate
    python -m pytest -q

    La dernière ligne indique 28 passed (28 tests réussis).

  2. Copiez les huit nouveaux fichiers de code, les quatre nouveaux fichiers de tests, requirements.txt et README.md depuis l’instantané end-of-m09 :

    Fenêtre de terminal
    S=../nextia-learning-labs/C36/snapshots/end-of-m09
    for f in model_store service drift release; do cp "$S/larkroute/$f.py" larkroute/; done
    for f in train serve drift release; do cp "$S/larkroute/commands/$f.py" larkroute/commands/; done
    for t in service drift release model_store; do cp "$S/tests/test_$t.py" tests/; done
    cp "$S/requirements.txt" "$S/README.md" .

    Les commandes sont repérées par leurs noms de fichiers. route possède donc maintenant quatre nouvelles commandes : train, serve, drift et release.

  3. Installez les nouveaux paquets. requirements.txt fixe maintenant les versions de FastAPI, uvicorn et httpx :

    Fenêtre de terminal
    python -m pip install -r requirements.txt

    Parmi les paquets que pip installe, vous voyez fastapi-0.162.0, uvicorn-0.54.0, httpx-0.28.1 et starlette-1.10.0. uvicorn est le programme serveur qui exécute un service FastAPI. httpx permet aux tests d’appeler le service sans réseau.

  4. Exécutez les tests et la vérification du style :

    Fenêtre de terminal
    python -m pytest -q
    ruff check .

    Vous voyez 42 passed (42 tests réussis) et All checks passed! (toutes les vérifications ont réussi). Neuf des 14 nouveaux tests vérifient le service. Un test envoie un message connu et vérifie que la réponse nomme les deux versions. Six envoient des entrées invalides et attendent le code 422. Un vérifie que le journal ne contient aucun texte de message, et un autre qu’une version n’est jamais écrasée.

  5. Entraînez le modèle et enregistrez-le comme version v1. --make-current indique au service de charger cette version :

    Fenêtre de terminal
    route train --version v1 --make-current
    Saved models/v1: 6000 messages, 7 routes, labels-4bad2e4ef7; validation accuracy 0.958; decide at 0.58, person below 0.00. Now the current model.
  6. Ouvrez models/v1/card.json dans votre éditeur. La fiche du modèle présente son identité : sa version, ses destinations, sa version des étiquettes, ses seuils et ses scores de validation. Ses résultats de validation sont les mêmes que dans le module 8. Sur les données de validation, 90,2 % des messages reçoivent une décision automatique. 5,4 % vont en révision et 4,4 % vont à une personne. Le coût est de 305,8 $ US par 1 000 messages. Le fichier models/current contient un seul mot : v1.

  1. Dans le premier terminal, démarrez le service :

    Fenêtre de terminal
    route serve
    INFO: Started server process [2493]
    INFO: Waiting for application startup.
    INFO: Application startup complete.
    INFO: Uvicorn running on http://127.0.0.1:8036 (Press CTRL+C to quit)

    Votre numéro de processus sera différent. L’adresse 127.0.0.1 signifie « cet ordinateur seulement », donc aucun autre ordinateur ne peut joindre le service.

  2. Ouvrez un deuxième terminal dans le dossier larkroute. Demandez au service quel modèle il exécute :

    Fenêtre de terminal
    curl -s http://127.0.0.1:8036/health
    {"status":"ok","model_version":"v1","label_version":"labels-4bad2e4ef7","routes":["account","billing","delivery","needs_person","orders","product","returns_refunds"]}

    PowerShell affiche les mêmes champs sous forme de liste, pas sur une seule ligne de JSON.

  3. Envoyez le premier message du tableau ci-dessus :

    Fenêtre de terminal
    curl -s http://127.0.0.1:8036/route -H 'content-type: application/json' \
    -d '{"message_id": "M-999001", "text": "Tracking says my parcel was delivered yesterday, but nothing is at my door. Order LK-123456.", "channel": "chat"}'
    {"message_id":"M-999001","route":"delivery","zone":"decide","confidence":0.9937,"model_version":"v1","label_version":"labels-4bad2e4ef7"}
  4. Envoyez deux autres messages de la même façon, avec ces corps. Modifiez seulement la partie -d (ou -Body dans PowerShell) :

    {"message_id": "M-999006", "text": "The hedge trimmer caught fire while I was using it. My hand is burned. I will contact my lawyer.", "channel": "email"}
    {"message_id": "M-999007", "text": "My new Grow Hub keeps blinking orange and will not connect to the Wi-Fi.", "channel": "social"}

    Les réponses :

    {"message_id":"M-999006","route":"needs_person","zone":"person","confidence":0.8519,"model_version":"v1","label_version":"labels-4bad2e4ef7"}
    {"message_id":"M-999007","route":"product","zone":"review","confidence":0.4671,"model_version":"v1","label_version":"labels-4bad2e4ef7"}

    Le Grow Hub est le nouveau produit d’Omar. Le modèle n’a jamais vu de message à son sujet. Il propose donc product avec une faible confiance, et le message va en révision. Gardez cela en tête pour la prochaine leçon.

  5. Envoyez un message avec un texte vide :

    Fenêtre de terminal
    curl -s http://127.0.0.1:8036/route -H 'content-type: application/json' -d '{"message_id": "M-999002", "text": ""}'
    {"detail":[{"type":"string_too_short","loc":["body","text"],"msg":"String should have at least 1 character","input":"","ctx":{"min_length":1}}]}

    Le code d’état est 422 : ajoutez -w "\nHTTP %{http_code}\n" à la commande curl pour le voir. Dans PowerShell, Invoke-RestMethod affiche le code 422 comme une erreur, avec le même corps. Le corps indique quel champ a échoué (loc) et pourquoi (msg).

  6. Dans le premier terminal, arrêtez le service avec Ctrl+C. La dernière ligne est INFO: Finished server process [2493] (processus serveur terminé).

  7. Ouvrez queue/decisions.jsonl et queue/review_queue.jsonl dans votre éditeur.

queue/decisions.jsonl contient une ligne pour chaque message routé. Voici les lignes de notre exécution pour les trois messages :

{"message_id": "M-999001", "route": "delivery", "zone": "decide", "confidence": 0.9937, "model_version": "v1", "label_version": "labels-4bad2e4ef7", "channel": "chat", "time": 1794062680.778}
{"message_id": "M-999006", "route": "needs_person", "zone": "person", "confidence": 0.8519, "model_version": "v1", "label_version": "labels-4bad2e4ef7", "channel": "email", "time": 1794062680.796}
{"message_id": "M-999007", "route": "product", "zone": "review", "confidence": 0.4671, "model_version": "v1", "label_version": "labels-4bad2e4ef7", "channel": "social", "time": 1794062680.805}

Vos valeurs time seront différentes. time est le nombre de secondes depuis le 1 janvier 1970, la façon habituelle dont les ordinateurs stockent un instant. Le message vide n’a aucune ligne, car le service l’a refusé avant toute décision. Cherchez les mots d’un message dans le fichier : « Grow Hub » n’y figure pas. queue/review_queue.jsonl contient une ligne pour M-999007, avec "suggested_route": "product".

Le terminal du service a aussi affiché une ligne pour chaque requête, par exemple "POST /route HTTP/1.1" 422 Unprocessable Entity (entité impossible à traiter). C’est le journal d’accès d’uvicorn : l’adresse, la méthode et le code d’état, jamais le corps.

Écrivez trois messages. Essayez d’en écrire un pour chaque zone : décision automatique, révision et transfert à une personne. Avant d’envoyer chacun, prédisez sa destination, sa zone et sa confiance approximative. Envoyez-les, puis trouvez chacun dans queue/decisions.jsonl, et celui à réviser dans queue/review_queue.jsonl.

Afficher un exemple

Nous avons envoyé les trois messages du tableau, et un autre : « Hi, I have a question about my order and the invoice. Can someone call me? » Deux sujets dans un message (commandes et facturation) donnent au modèle deux bonnes réponses. Il n’est donc sûr d’aucune. La réponse était billing (facturation), zone review (révision), confiance de 0,394. Le message est allé dans la file de révision.

Un message qui nomme un problème avec les mots habituels arrive dans la zone de décision automatique, comme M-999001 (0,9937). Un problème de sécurité ou une menace arrive dans la zone de transfert à une personne, comme M-999006. Un message sur quelque chose que le modèle n’a jamais vu arrive dans la zone de révision, comme celui sur Grow Hub (0,4671). Si tous vos messages arrivent dans la zone de décision automatique, écrivez-en un plus vague : « Hello, I wrote to you last week. Any news? »

Utilisez un service quand un autre programme a besoin d’une réponse à chaque message, dès son arrivée. C’est le cas d’une boîte de réception qui achemine les messages à mesure qu’ils arrivent. Le service coûte peu ici : un processus, environ 260 Mo sur disque pour l’environnement et une demi-milliseconde de calcul par message.

Ne créez pas de service si un lot quotidien suffit. Si l’équipe de Grace doit seulement trier chaque matin les messages de la veille, une commande route planifiée est plus simple. Aucun processus ne doit rester en marche, et rien n’écoute sur un port.

Un service a ses propres coûts. Quelqu’un doit le redémarrer après une panne et le surveiller. Journaux, métriques et traces, dans le cours MLOps et LLMOps : exploiter l’IA en production, montre comment une équipe le fait. Un service accessible depuis d’autres ordinateurs a aussi besoin d’authentification et de limites. Le nôtre n’en a pas : il écoute seulement sur 127.0.0.1. Et le fichier du modèle est un pickle, un format Python qui peut exécuter du code au chargement. Chargez seulement des fichiers de modèle que vous avez créés vous-même.

Tomás demande : « Pourquoi ne pas appeler le LLM hébergé depuis le service, pour chaque message? » Vous pouvez, mais chaque appel prend 1,7 seconde au lieu d’une demi-milliseconde. Il faut aussi une connexion réseau, et le texte du client est envoyé à une autre entreprise. Les cascades présentait une meilleure combinaison : le modèle peu coûteux d’abord, et le LLM seulement pour les messages incertains.

Erreur courante

Deux modèles différents, tous deux nommés v1

Symptôme : Priya corrige quelques étiquettes et entraîne de nouveau le modèle sous le même nom, v1. La semaine suivante, Grace demande pourquoi une demande de remboursement est allée à product (produit). Le journal indique "model_version": "v1", mais deux modèles différents portaient ce nom. Personne ne peut savoir lequel a décidé.

Dans ce projet, le deuxième entraînement s’arrête plutôt avec une erreur :

$ route train --version v1
models/v1 exists: a version is never overwritten. Choose a new version name.

Cause : un nom de version est utile seulement s’il désigne toujours le même modèle. Si vous écrasez une version, son nom ne désigne plus un seul modèle, et le journal perd son sens.

Solution : donnez un nouveau nom de version à chaque modèle entraîné, comme v2. Gardez l’ancien dossier. La version des étiquettes ajoute une deuxième vérification : de nouvelles étiquettes donnent une nouvelle empreinte, même si quelqu’un réutilise un nom dans un autre système.

Conséquence pour le travail en IA : sans versions stables, vous ne pouvez pas expliquer une décision passée ni comparer équitablement deux modèles. Vous ne pouvez pas non plus revenir au modèle qui fonctionnait. Les deux prochaines leçons ont besoin des trois.

Vérifiez votre compréhension

Nommez les quatre choses que le service de routage fait, contrairement à un appel dans un carnet Jupyter. Quel problème chacune résout-elle?

Afficher la réponse
  • Il charge le modèle une seule fois, au démarrage. Sur le portable de test, le chargement prenait environ 27 ms chaque fois. Acheminer un message prenait environ 0,5 ms. Un chargement pour chaque message ralentirait beaucoup chaque réponse.
  • Il vérifie l’entrée. Une requête invalide reçoit HTTP 422 avec la raison, sans décision. Sans cette vérification, un texte vide allait à product avec une confiance de 0,3036.
  • Il indique la version du modèle et celle des étiquettes dans chaque réponse. On peut retrouver le modèle et les étiquettes à l’origine d’une mauvaise destination.
  • Il consigne les décisions sans le texte, et envoie les décisions à réviser dans la file de Chloé. Le journal répond à « Que s’est-il passé? » sans copier les messages privés.

Vérifiez votre compréhension

Prédisez : le modèle envoie un message à needs_person avec une confiance de 0,99. Quelle zone le service choisit-il, et pourquoi? Que se passerait-il avec un seuil person_below de 0,40 et un message de livraison ayant une confiance de 0,35?

Afficher la réponse

La zone est person (transfert à une personne), peu importe la confiance. Une personne lit chaque message que le modèle envoie à needs_person (besoin d’une personne). Ces messages concernent des problèmes de sécurité, des menaces de poursuites ou des plaintes transmises à un niveau supérieur. La confiance ne change rien à cela.

Avec person_below à 0,40, un message de livraison ayant une confiance de 0,35 irait aussi dans la zone de transfert à une personne. Sa destination serait needs_person. Le modèle est trop incertain pour proposer une équipe. Avec la fiche actuelle (person_below à 0,00), le même message va en révision avec la destination proposée delivery (livraison).

Vérifiez votre compréhension

Vérification pratique : démarrez le service et envoyez un message dont le texte contient seulement des espaces. Dites ce que vous recevez et ce que le service écrit dans ses deux fichiers.

Afficher la réponse

La réponse est HTTP 422 avec un corps comme {"detail":[{"type":"value_error","loc":["body","text"],"msg":"Value error, text is empty","input":" ",…}]} (erreur de valeur : le texte est vide). La classe Message refuse un texte composé seulement d’espaces. FastAPI n’appelle jamais le code de routage. Le service n’écrit donc rien dans queue/decisions.jsonl ni dans queue/review_queue.jsonl. Seul le journal d’accès d’uvicorn dans le terminal affiche la requête, avec le statut 422.

Récapitulatif

  • Un service fonctionne en permanence et répond à chaque message par HTTP. Le nôtre offre POST /route et GET /health, sur le port 8036 de cet ordinateur seulement.
  • Il charge le modèle une seule fois. Sur le portable de test, un chargement prenait environ 27 ms et un message prenait 0,49 ms.
  • Il vérifie l’entrée avec FastAPI et Pydantic : un identifiant invalide, un texte vide ou un canal inconnu reçoit HTTP 422, sans décision.
  • Chaque réponse contient la destination, la zone, la confiance, la version du modèle et la version des étiquettes. Une version n’est jamais écrasée.
  • Il consigne chaque décision sans le texte dans queue/decisions.jsonl, et envoie les décisions à réviser dans queue/review_queue.jsonl pour Chloé.

Le service répond maintenant toute la journée. Mais la boîte de réception change : le message sur Grow Hub est déjà allé en révision. Ensuite, vous réexécutez le mois du lancement d’Omar avec le modèle du service et observez ce qui change.

Leçon suivante : La dérive et les nouveaux sujets