Aller au contenu
English

Cache et traitement par lots

  • Leçon 12
  • 55 min
  • Module 4 : Optimiser avec des compromis mesurés

Où nous en sommes

Dans la leçon précédente, nous avons mesuré qu'un modèle plus puissant n'est pas rentable pour nos questions. Une autre façon de réduire la facture est de cesser de payer à nouveau pour du travail que le système a déjà fait. Dans cette leçon, nous décidons quoi réutiliser et combien de temps une réponse enregistrée reste juste, et nous mesurons les gains réels d'un succès de cache et d'un appel par lots, comme une bibliothécaire qui garde une réponse sur une fiche.

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

Ce que vous saurez faire

Cessez de payer à nouveau pour du travail que le système a déjà fait. Vous repérez le travail réutilisable dans l’assistant et décidez combien de temps une réponse enregistrée reste juste. Ensuite, vous mesurez les gains réels d’un accès réussi au cache et d’un appel par lots. Le cache de réponses fait partie de la conception depuis le module 2. Cette leçon définit son taux de succès et sa valeur.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre dossier design-pack de la dernière leçon : options.py et le nouveau design.toml copiés dedans, et python -m pytest -q qui affiche 35 passed (35 tests réussis).

Testé avec Python 3.12 sur macOS (Apple silicon). Les commandes Windows (PowerShell) et Linux sont fournies, mais non testées.

Une bibliothécaire scolaire entend la même question chaque semaine : « Quand la bibliothèque est-elle ouverte pendant les vacances? » La première fois, elle ouvre le dossier du calendrier et le lit pendant quelques minutes. Ensuite, elle écrit la réponse sur une fiche et la garde au comptoir. La fois suivante, la réponse prend deux secondes. Quand le calendrier change, elle jette la fiche. Sinon, celle-ci donnerait rapidement une mauvaise réponse.

Le facteur de sa rue travaille autrement. Il ne se rend pas dans la rue une fois pour chaque lettre. Il apporte toutes les lettres de la rue en un seul voyage. Chaque lettre a toujours besoin de son timbre, mais il fait moins de voyages.

La boîte de fiches est un cache. Le sac du facteur est un lot. Les deux évitent du travail que le système répéterait autrement. Ils évitent des tâches différentes.

Chaque question à l’assistant entraîne le coût du parcours complet. Il crée le plongement (embedding) de la question (0,34 s), cherche et reclasse les résultats (0,32 s). Il demande ensuite à chat-small de rédiger la réponse (1,52 s). Cela représente 2,18 secondes et environ 0,000175 $ US en jetons et en nouvelles tentatives. Supposons que les agents de Larkfield demandent vingt fois par jour : « Combien de jours ai-je pour retourner un article? » L’assistant fait le même travail vingt fois.

Au volume de base, ce gaspillage est faible. Dans le scénario élevé, il devient une limite. Sans cache, la minute la plus chargée du scénario élevé nécessite 148,8 appels de génération. Le quota du fournisseur est de 100 par minute. Le fournisseur refuserait une partie de ces appels.

L’ingestion entraîne un deuxième type de gaspillage. Un nouveau document est découpé en segments, et chaque segment a besoin d’un plongement. Avec un segment envoyé par appel, l’exécution de l’équipe du cours prenait 2,81 secondes par document. Les allers-retours occupaient la majeure partie de ce temps, pas le travail.

Un cache garde le résultat d’un travail pour que le système puisse le réutiliser. Une requête cherche d’abord dans le cache. Un accès réussi trouve un résultat enregistré et le renvoie. Un échec entraîne tout le travail, puis l’enregistrement du résultat. Le taux de succès est la proportion de requêtes qui trouvent un résultat dans le cache. Le mot vient du français cacher : une réserve à l’abri des regards.

Une clé permet de trouver chaque résultat enregistré. La clé doit contenir toutes les entrées qui changent le résultat. Le module 2 a choisi la clé du cache de réponses : locataire, audience, version des documents et question. Comme la clé contient la version des documents, une nouvelle version d’une politique empêche les anciennes réponses de correspondre. Personne n’a besoin de les supprimer.

Cela répond à la question de la fraîcheur : combien de temps peut-on garder une réponse enregistrée? Tant que toutes les entrées de sa clé restent identiques. Deux entrées ne sont pas dans les documents : la requête (prompt) et le modèle. La clé doit donc aussi contenir les versions de la requête et du modèle. Sinon, la mise en production d’une nouvelle requête doit vider le cache. Une limite de temps, par exemple une semaine, ajoute une protection pour tout ce que la clé omet.

Kwame pose deux questions sur chaque type de travail dans la conception. La même entrée revient-elle? Jusqu’à quand l’ancien résultat reste-t-il juste?

Travail Quand la même entrée revient-elle? Le résultat reste juste tant que… Où il est conservé
Une réponse même question, même locataire et même audience les versions des documents, de la requête et du modèle restent identiques le cache de réponses dans PostgreSQL
Les plongements des segments et le résumé d’un document jamais : ils sont créés une fois par version du document la version du document reste identique les lignes des segments et des documents; elles fonctionnent déjà comme un cache
Le plongement d’une question même texte de question le modèle de plongement reste identique un cache n’en vaut pas la peine : l’ensemble coûte 0,01 $ US par mois
Le début d’une longue requête mêmes instructions et mêmes passages le fournisseur le décide le cache de requêtes du fournisseur

Seule la première ligne exige une vraie décision. La deuxième fait déjà partie de la conception, et la troisième économise moins d’un cent.

Dix questions arrivent à l’assistant dans une matinée. Trois répètent une question précédente avec la même clé. Il y a donc 7 échecs et 3 accès réussis.

  • Temps total : 7 × 2,18 + 3 × 0,014 = 15,26 + 0,04 = 15,30 s, contre 21,80 s sans cache.
  • Coût du modèle : 7 × 0,000171 $ US = 0,001197 $ US, contre 0,00171 $ US. Chaque accès réussi évite un appel de génération.
  • Attente médiane : triez les dix temps : 0,014, 0,014, 0,014, 2,18, 2,18 … Au milieu de la liste, c’est encore un échec : 2,18 s.

Les accès réussis sont rapides, mais la question typique ne semble pas obtenir de réponse plus vite. La médiane change seulement quand plus de la moitié des questions trouvent une réponse dans le cache. Le cours sur la mise à l’échelle constatait la même chose dans Choisir ce qui peut être mis en cache.

Un flux. Une question, avec son locataire, son audience et la version des documents, arrive au cache de réponses dans PostgreSQL. Celui-ci demande : la même clé est-elle enregistrée? Lors d'un accès réussi, la réponse enregistrée revient en 0,014 s sans appel au modèle. Lors d'un échec, le flux crée le plongement de la question en 0,34 s, puis cherche et reclasse en 0,32 s. chat-small répond en 1,52 s pour 0,000171 $ US. La réponse est enregistrée sous la clé, et elle prend 2,18 s.
Le cache de réponses dans le parcours de la requête. Un accès réussi évite trois étapes et l'appel au modèle. Un échec entraîne tous ces coûts, puis l'enregistrement de la réponse.
Description textuelle du diagramme

Une question arrive avec son locataire, son audience et la version des documents. L’API cherche la même clé dans le cache de réponses de PostgreSQL. Lors d’un accès réussi, elle renvoie la réponse enregistrée en environ 0,014 s, sans appel au modèle. (Ce temps a été mesuré dans le cours sur la mise à l’échelle, avec Valkey comme cache.) Lors d’un échec, elle crée le plongement de la question en 0,34 s et cherche en 0,32 s. Ensuite, chat-small répond en 1,52 s pour 0,000171 $ US. Elle enregistre la réponse sous la clé et la renvoie : 2,18 s au total.

Personne ne sait à quelle fréquence les questions de Larkfield se répètent : l’assistant ne fonctionne pas encore. Le taux de succès est donc une hypothèse, avec une plage : 0 % dans le scénario faible, 10 % dans le scénario de base, 30 % dans le scénario élevé. Le mélange construit de billets de soutien du cours sur la mise à l’échelle atteignait 46,5 % avec une clé correcte. Les vrais magasins seront différents. Le cours a mesuré le temps et l’argent qu’un accès réussi économise. Kwame distingue les deux types de nombres.

  1. Dans votre dossier design-pack, avec l’environnement actif, relancez les options et lisez le deuxième tableau :

    Fenêtre de terminal
    python -m costmodel options
    Caching answers: the hit share is an ASSUMPTION; the time saved per hit is measured
    a miss takes 2.18 s (embed + search + answer, medians); a hit takes 0.014 s
    hit share US$/month saved median wait s
    0% 52.67 0.00 2.18
    10% 51.90 0.77 2.18
    30% 50.37 2.30 2.18
    50% 48.83 3.83 2.18
    The median wait does not change until more than half of the questions are hits.

    C’est le deuxième des trois tableaux que la commande affiche. Chaque ligne chiffre à nouveau toute la conception avec un taux de succès.

  2. Affichez le coût mensuel avec l’hypothèse de la conception, soit 10 % dans le scénario de base :

    Fenêtre de terminal
    python -m costmodel costs

    Les dernières lignes :

    Total 51.90
    Biggest driver: Compute: API (53% of the total)

    Dans le dernier module, la même commande affichait 52,67 $ US. Le cache explique la différence : désormais, le cours cite 51,90 $ US.

  3. Regardez le quota du fournisseur dans le scénario élevé :

    Fenêtre de terminal
    python -m costmodel workload --scenario high

    La ligne à lire :

    chat calls, busiest min. 104.2 (provider quota: 100 per minute)

    Sans cache, la même ligne indiquait 148,8. Le scénario élevé suppose 30 % d’accès réussis, donc 30 % moins d’appels de génération.

  4. Ouvrez design.toml et changez la valeur de base du taux de succès de 0,1 à 0,3 :

    cache_hit_share = [0.0, 0.3, 0.3]

    Relancez python -m costmodel costs. Le total est maintenant 50.37. Remettez ensuite la ligne à [0.0, 0.1, 0.3].

Trois nombres expliquent le résultat :

Le coût mensuel du scénario de base pour quatre taux de succès. L'hypothèse de la conception, 10 %, est la deuxième colonne. Même si le cache répond à la moitié des questions, l'économie n'est que de 7 %.
Description textuelle du graphique

Un graphique à quatre colonnes. Avec 0 % d’accès réussis, le scénario de base coûte 52,67 $ US par mois. Avec 10 %, l’hypothèse de la conception, il coûte 51,90 $ US. Avec 30 %, il coûte 50,37 $ US. Avec 50 %, il coûte 48,83 $ US. Les colonnes ont presque la même hauteur.

L’économie est faible. Avec 10 % d’accès réussis, le cache économise 0,77 $ US par mois; avec 50 %, 3,83 $ US. Un accès réussi économise seulement le coût variable d’une question, environ 0,000175 $ US. La part variable représente 13 % de la facture. La réplique de l’API toujours active et la base de données coûtent autant avec ou sans accès réussis.

L’attente typique ne change pas. Sous 50 % d’accès réussis, la question médiane est un échec : 2,18 secondes. Seules les personnes dont la question trouve une réponse dans le cache obtiennent une réponse rapide.

C’est pour le quota que le cache compte. Dans le scénario élevé, chaque accès réussi évite un appel de génération au fournisseur :

La minute la plus chargée du scénario élevé pour quatre taux de succès, et le quota de 100 appels par minute. Avec 30 % d'accès réussis, les appels approchent du quota, mais restent au-dessus.
Description textuelle du graphique

Un graphique à cinq colonnes. Dans la minute la plus chargée du scénario élevé, avec 0 % d’accès réussis, l’assistant nécessite 148,8 appels de génération. Avec 10 %, il en nécessite 133,9. Avec 30 %, l’hypothèse élevée de la conception, il en nécessite 104,2, et avec 46,5 %, 79,6. La dernière colonne est le quota du fournisseur : 100 appels par minute. Les trois premières colonnes dépassent le quota.

Le cache fait passer le scénario élevé de 148,8 à 104,2 appels, mais 104,2 reste supérieur à 100. Le cache aide, mais il ne suffit pas pour respecter le quota. Plan de croissance, au module 5, prévoit le reste.

Kwame écrit donc dans la proposition : « Le cache de réponses reste, car il ne coûte presque rien. Ce sont quelques lignes dans la base de données que nous payons déjà. Il économise peu d’argent. Sa valeur est la marge qu’il crée par rapport au quota du fournisseur. Nous mesurerons le taux de succès réel au premier mois et mettrons la plage à jour. »

Les fournisseurs de modèles ont aussi un cache. Le cache de requêtes garde le début d’une requête que le fournisseur a vue récemment. Sa grille tarifaire indique un prix réduit pour les jetons d’entrée qu’il déclare mis en cache. Pour chat-small, c’est 0,01 $ US par million, contre 0,10 $ US. Elle indique aussi un prix d’écriture dans le cache : 0,125 $ US par million. Le cours n’a pas déterminé quand le fournisseur utilise chaque prix; sa page le précise. Nous avons mesuré seulement ce que l’API signalait.

L’équipe du cours a envoyé deux requêtes, quatre fois chacune. La première était longue : la question avec toute la collection de documents, soit 17 852 jetons. La deuxième était la requête de réponse normale de l’assistant : 863 jetons.

Quatre appels d'une longue requête, L1 à L4 (17 852 jetons), et quatre de la requête de réponse normale, S1 à S4 (863 jetons). Dès le deuxième appel, le fournisseur déclarait 17 849 jetons de la longue requête mis en cache. Les appels n'étaient pas plus rapides. La requête courte n'a jamais été mise en cache.
Description textuelle du graphique

Un graphique à huit colonnes. La longue requête avec toute la collection a pris 1,47 s au premier appel, avec 0 jeton mis en cache. Ensuite, elle a pris 1,89 s, 3,59 s et 1,47 s. Chaque fois, 17 849 des 17 852 jetons étaient déclarés mis en cache. La requête de réponse normale a pris 1,86, 1,77, 1,39 et 1,71 s, avec 0 jeton mis en cache chaque fois.

C’était une surprise. Dès le deuxième appel, le fournisseur déclarait 17 849 des 17 852 jetons mis en cache. Pourtant, les appels n’étaient pas plus rapides. La requête de réponse courte n’a jamais été mise en cache en quatre appels. Le cache de requêtes du fournisseur économise donc de l’argent sur les longues requêtes répétées, mais pas de temps. Il n’économise rien sur les courtes requêtes de réponse de l’assistant.

L’idée du facteur est le traitement par lots : regrouper plusieurs petites requêtes dans un seul appel. Chaque appel a une partie fixe, le trajet : l’aller-retour réseau et le démarrage du travail chez le fournisseur. Un lot paie cette partie fixe une seule fois.

L’équipe du cours a créé les plongements des 8 documents les plus longs, soit 61 segments, de deux façons. Elle a fait trois passages pour chaque façon, puis comparé le temps médian par document :

Création des plongements d'un document : un appel par segment, ou tous ses segments dans un seul appel. Les mêmes 3 439 jetons et les mêmes 0,000069 $ US pour les 8 documents; 6,4 fois plus rapide en un seul appel.
Description textuelle du graphique

Un graphique à deux colonnes. Avec un appel par segment, créer les plongements d’un document prenait 2,81 s (médiane). Avec un appel par document, cela prenait 0,44 s. Les deux façons envoyaient les mêmes 3 439 jetons et coûtaient les mêmes 0,000069 $ US pour les 8 documents.

Un appel par document est 6,4 fois plus rapide. Il envoie les mêmes 3 439 jetons et coûte les mêmes 0,000069 $ US. Le prix est par jeton, pas par appel. Le traitement par lots a économisé du temps, pas de l’argent. La séquence d’ingestion du module 2 crée déjà les plongements de tous les segments d’un document en un seul appel.

Certains travaux peuvent aussi attendre. Le résumé d’un document est créé en arrière-plan; personne ne l’attend. Pour le travail qui accepte un délai, la grille tarifaire propose un prix Flex pour chat-small. C’est la moitié du prix normal : 0,05 $ US et 0,25 $ US par million de jetons. Cela ferait passer un résumé d’environ 0,00012 $ US à environ 0,00006 $ US. Avec 11 documents modifiés par mois, l’économie est inférieure à un dixième de cent. Le cours n’a pas testé Flex. Considérez-le comme une option pour une ingestion importante, comme toute la collection d’un nouveau locataire.

Mettez en cache le travail qui se répète avec les mêmes entrées. La clé doit contenir toutes les entrées pour éviter une réponse rapide mais fausse. Notez la règle de fraîcheur à côté de la clé. Ne mettez pas en cache des réponses dont vous ne pouvez pas inclure les entrées dans une clé. C’est le cas du statut en temps réel de la commande d’une personne. Les coûts sont le stockage, quelques lignes de code et un risque supplémentaire. Une clé qui omet une entrée donne une réponse rapide, mais fausse. Flux de données et d’identité montrait ce qui arrive quand le locataire manque.

Regroupez en lots le travail qui arrive en petits morceaux et n’exige pas une réponse pour chaque morceau. Par exemple : les plongements à l’ingestion, les résumés et les rapports. Ne faites pas attendre une personne pour remplir un lot. Les coûts : un lot échoué doit être relancé en entier ou divisé, et le fournisseur limite la taille d’une requête.

Erreur courante

30 % d'accès réussis ne réduisent pas la facture de 30 %

Symptôme : Tomás s’attend à voir le coût mensuel passer de 52,67 $ US à environ 37 $ US avec 30 % d’accès réussis. Le calculateur indique 50,37 $ US.

Cause : un accès réussi économise seulement le coût variable d’une question : jetons et nouvelles tentatives, environ 0,000175 $ US. La part fixe de la facture, environ 85 % sans cache, ne dépend pas des accès réussis.

Solution : chiffrez un cache comme vous chiffrez l’utilisation : seules les lignes variables changent. Regardez ensuite les lignes qui changent dans une minute chargée, comme les appels comptés dans le quota.

Erreur courante

Anciennes réponses après une modification de requête

Symptôme : Amira met en production une nouvelle requête qui cite la section de chaque politique. Un jour plus tard, Grace voit encore des réponses sans sections.

Cause : les réponses viennent du cache. La clé contient le locataire, l’audience, la version des documents et la question, mais pas la version de la requête. Toutes les réponses mises en cache correspondent encore.

Solution : ajoutez les versions de la requête et du modèle à la clé, ou videz le cache pendant la mise en production. Ajoutez un test : changez la version de la requête, posez une question mise en cache et attendez-vous à un échec.

À vous de jouer : la proportion de succès du cours sur la mise à l’échelle

Section intitulée « À vous de jouer : la proportion de succès du cours sur la mise à l’échelle »

Le mélange construit de billets de soutien du cours Mettre à l’échelle les API et les charges de travail d’IA a atteint 46,5 % de succès avec une clé correcte. Supposez que les questions de Larkfield se répètent aussi souvent. Prédisez trois nombres pour le scénario de base : le coût mensuel, le coût total par question et les appels de clavardage pendant la minute la plus chargée.

Puis, dans design.toml, remplacez la ligne par cache_hit_share = [0.0, 0.465, 0.465]. La valeur haute doit au moins égaler la valeur de base, sinon le dossier refuse la plage. Exécutez python -m costmodel units et python -m costmodel workload, puis remettez la ligne à [0.0, 0.1, 0.3].

Afficher la réponse

Seule la partie variable diminue. Les 43 950 questions donnent maintenant 46,5 % de succès au lieu de 10 %. Cela donne 0,365 × 43 950 = 16 042 succès de plus. Chacun économise environ 0,000175 $ US. Le total est donc environ 2,80 $ US sous les 51,90 $ US.

Unit economics, scenario base, month 0
total US$ 49.10 per month (fixed 92%, variable 8%)
per question (variable only) US$ 0.000094
per question (everything) US$ 0.001117
per document change US$ 0.000169 (embed + summary + worker)
Larkfield US$ 26.43 per month
Bramble Books US$ 22.68 per month

La commande workload (charge de travail) affiche chat calls, busiest min. 8.6 (appels de clavardage, minute la plus chargée : 8,6). Un très bon cache réduit presque de moitié les appels au modèle, et réduit la facture d’environ 5 %. La part fixe monte à 92 %. Plus le cache économise, plus les composants toujours actifs représentent une grande part de la facture. Remettez la ligne à [0.0, 0.1, 0.3].

Vérifiez votre compréhension

Prédisez : si 30 % des questions utilisent le cache, la question médiane reçoit-elle sa réponse en moins de 2,18 secondes? Expliquez avec la liste triée des durées.

Afficher la réponse

Non. Triez les durées : 30 % sont des succès à environ 0,014 s, et 70 % sont des échecs à environ 2,18 s. Le milieu de la liste, à 50 %, tombe parmi les échecs. La médiane reste à 2,18 s. Elle change seulement quand plus de la moitié des questions donnent un succès. Les personnes qui obtiennent un succès reçoivent une réponse rapide; la personne typique, non.

Vérifiez votre compréhension

Mei demande pourquoi la conception conserve le cache de réponses s'il économise seulement 0,77 $ US par mois dans le scénario de base. Donnez-lui deux raisons, avec des nombres.

Afficher la réponse

Premièrement, il ne coûte presque rien. Les réponses sauvegardées sont des lignes dans le serveur PostgreSQL que la conception paie déjà. Il n’ajoute aucun stockage, aucune sauvegarde ni aucune règle de sécurité. Deuxièmement, sa valeur concerne la minute chargée, pas la facture. Dans le scénario haut, il réduit les appels de clavardage de 148,8 à 104,2 par minute, pour un quota de 100. Un succès donne aussi une réponse en environ 0,014 s plutôt que 2,18 s aux personnes qui répètent une question.

Vérifiez votre compréhension

L'équipe du cours a créé les plongements des documents segment par segment, puis avec un appel par document. Une méthode était 6,4 fois plus rapide. Laquelle, et pourquoi n'a-t-elle pas économisé d'argent?

Afficher la réponse

Un appel par document : 0,44 s contre 2,81 s par document. Chaque appel comporte une partie fixe : l’aller-retour réseau et le démarrage du travail chez le fournisseur. Un appel par document paie cette partie une seule fois, plutôt qu’une fois par segment. Il n’a pas économisé d’argent, car le prix est par jeton. Les deux méthodes ont envoyé les mêmes 3 439 jetons : 0,000069 $ US pour les 8 documents.

Récapitulatif

  • Un cache conserve le résultat d’un travail pour le réutiliser; un succès le trouve, un échec exécute le travail. La clé contient chaque entrée qui change le résultat. La règle de fraîcheur indique combien de temps un résultat reste juste.
  • La clé du cache de réponses : locataire, audience, version des documents, question, plus les versions de la requête et du modèle. Les plongements des segments et les résumés sont déjà créés une fois par version de document.
  • La proportion de succès est une hypothèse : 0 / 10 / 30 %. Un succès (0,014 s, cours Mettre à l’échelle les API et les charges de travail d’IA) évite 2,18 s et environ 0,000175 $ US. Avec 10 % de succès, le scénario de base coûte 51,90 $ US. Même 50 % de succès économiseraient seulement 3,83 $ US.
  • Sous 50 % de succès, l’attente médiane ne change pas. La vraie valeur du cache est la marge sous le quota : dans le scénario haut, 148,8 → 104,2 appels par minute.
  • Le cache de requêtes du fournisseur a signalé 17 849 jetons en cache sur 17 852 pour une longue requête répétée. Les appels n’étaient pas plus rapides, et la requête de réponse courte n’a jamais été mise en cache.
  • Traitement par lots : un appel de plongement par document est 6,4 fois plus rapide qu’un appel par segment, pour les mêmes jetons et le même coût. Les tarifs Flex sont à moitié prix pour le travail qui peut attendre; ils ne sont pas testés ici.

Ensuite, vous décidez s’il faut exploiter une partie vous-même ou payer un fournisseur pour le faire, et vous comparez trois conceptions de façon équitable.

Leçon suivante : Construire ou acheter