Comparer les configurations
- Leçon 18
- 55 min
- Module 6 : Valider et justifier les changements
Où nous en sommes
Dans la leçon précédente, nous avons planifié des tests de charge avec une question, une charge de travail et un environnement peu sollicité. Mais un seul passage d'un test donne un seul nombre, et ce nombre change d'une exécution à l'autre. Dans cette leçon, nous exécutons chaque configuration plusieurs fois de la même façon, et nous comparons un tableau de résultats, avec le coût par billet. Pensons à deux trajets pour aller au travail, chacun fait un seul matin.
Leçon 18 sur 19 · Mettre à l'échelle les API et les charges de travail d'IAComparer les configurations
1. Mesurer avant de mettre à l'échelle
2. Concurrence et limites des services
3. Utiliser le cache sans fausser les résultats
4. Files d'attente et travailleurs en arrière-plan
5. Résilience et mise à l'échelle automatique
6. Valider et justifier les changements
Ce que vous saurez faire
Vérifiez si un changement a vraiment aidé. Exécutez chaque configuration de la même façon, plusieurs fois. Comparez un tableau de résultats : débit, p95 et p99, erreurs, ressources utilisées et coût par billet de soutien.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les quatre parties d’un test de charge et
PACE_SECONDS, présentées dans Concevoir un test de charge. - Les passages, les médianes et les étendues, présentés dans Latence et capacité.
- L’utilisation de plusieurs processus, présentée dans Mise à l’échelle horizontale et Cycle de vie d’une tâche.
Ce qu’il vous faut sur votre ordinateur
- Le projet après Concevoir un test de charge : les fichiers de profil dans
loadtest/, etpython -m pytestaffiche172 passed, 1 deselected(172 tests réussis, 1 non sélectionné). - PostgreSQL, Azurite et Valkey en cours d’exécution :
docker compose up -d db azurite cache.
Testé sur macOS (puce Apple); les commandes Windows ne sont pas testées. Le fournisseur d’IA est celui qui est simulé. Les sorties proviennent de l’ordinateur de l’auteur : vos chiffres seront différents.
Deux trajets pour aller au travail
Section intitulée « Deux trajets pour aller au travail »Vous trouvez un nouveau trajet pour aller au travail. Le lundi, il prend 24 minutes; l’ancien trajet prenait 29 minutes vendredi dernier. Le nouveau trajet est-il plus rapide? Impossible de le savoir. Il y avait peut-être moins de circulation lundi, ou tous les feux étaient verts.
Vous empruntez donc chaque trajet pendant cinq matins ordinaires, à la même heure. Le nouveau trajet prend de 23 à 27 minutes, l’ancien de 26 à 31 minutes. Vous comparez les matins typiques, mais aussi les pires. Vous remarquez que le nouveau trajet comporte un péage et consomme plus de carburant. Vous pouvez maintenant décider.
Comparer deux configurations d’un service fonctionne de la même façon. Une seule exécution de chacune vous apprend peu de choses. Plusieurs exécutions dans les mêmes conditions, avec un examen de tous les coûts, vous montrent ce qui a changé.
Le problème : un passage, un chiffre
Section intitulée « Le problème : un passage, un chiffre »Un seul passage peut vous induire en erreur. Le cours a mesuré la conception du module 1 avec 4 utilisateurs, sur un ordinateur peu sollicité. Il y avait cinq passages de 60 secondes. Rien n’a changé entre les passages. Pourtant, le fournisseur a refusé 41 appels pendant un passage et 115 pendant un autre. Supposons qu’Amira ait fait un seul passage avant un changement et un seul après. Une « baisse de 115 à 41 refus » pourrait alors relever du pur hasard.
Un seul chiffre peut vous induire en erreur. Le cours a aussi comparé un processus d’API à quatre, avec 32 utilisateurs et la conception du module 1. Quatre processus ont terminé presque trois fois plus de billets par seconde. C’est vrai, mais ce n’est pas toute l’histoire. Chaque processus possède son propre pool de connexions (pool) de 10 connexions à la base de données. Quatre processus peuvent donc occuper 40 connexions. Dans Limites des dépendances, douze de ces processus demandaient plus de connexions que PostgreSQL n’en permet. Une comparaison qui montre seulement le débit cache ce coût.
L’idée : une comparaison équitable et un tableau de résultats
Section intitulée « L’idée : une comparaison équitable et un tableau de résultats »Une configuration est un ensemble de paramètres pour le même code. Par exemple : le nombre de processus, le mode d’admission, la taille du pool et la limite de la file d’attente. Pour comparer deux configurations équitablement, gardez tout le reste identique :
- Un seul changement. Si vous changez deux paramètres, vous ne pouvez pas savoir lequel a fait la différence.
- La même charge de travail et le même profil. Le même fichier Locust, les mêmes utilisateurs, le même rythme, la même durée et le même échauffement.
- Le même état initial. Rechargez les données, videz le cache et réinitialisez le fournisseur avant chaque passage.
- Plusieurs passages. Au moins trois, de préférence cinq, pour chaque configuration. Indiquez la médiane de chaque mesure, avec les valeurs minimale et maximale des passages. Si les étendues de deux configurations se chevauchent, le test n’a pas démontré de différence.
- Un ordinateur peu sollicité. Notez la charge moyenne avant et après. Les deux configurations doivent fonctionner dans les mêmes conditions.
Comparez ensuite un tableau de résultats : une ligne par configuration et les mêmes colonnes chaque fois. docs/benchmark-template.md les contient déjà :
| Colonne | Ce qu’elle mesure | Pourquoi elle est là |
|---|---|---|
| Débit | Travail terminé par seconde : pour la file d’attente, tâches dont le travail d’IA a réussi, pas les réponses 202 |
Le travail que les clients reçoivent |
| p50, p95, p99 | Durées des requêtes typiques, lentes et les plus lentes; pour la file d’attente, aussi le délai entre soumission et résultat | Le temps d’attente des clients |
| Erreurs | Codes d’état autres que ceux de réussite, par code | Ce que les clients perdent |
| Ressources | Utilisation du processeur par l’API, connexions à la base de données, appels et refus du fournisseur | Ce que le changement consomme |
| Coût par tâche | Coût en argent par billet | Ce que le changement coûte |
Voici la comparaison du cours entre un et quatre processus, sous forme de tableau de résultats. Chaque valeur est la médiane de 5 passages sur un ordinateur peu sollicité, avec l’étendue entre parenthèses :
| Configuration (32 utilisateurs, conception du module 1, quota désactivé) | Débit (billets/s) | p50 ms | p95 ms | p99 ms | Erreurs par passage | Processeur de l’API | Connexions BD permises (pools) | Coût d’IA par billet |
|---|---|---|---|---|---|---|---|---|
| 1 processus | 3,37 (3,30–3,41) | 6 831 | 7 480 (7 406–7 717) | 7 879 | 10–14 × 503 database_busy (base de données occupée) |
1,1 % | 10 | 0,0000614 $ US |
| 4 processus | 9,59 (8,96–10,74) | 2 621 | 4 410 (3 757–4 822) | 4 944 | aucune | 3,0 % (2,6–10,0) | 40 | 0,0000611 $ US |
Description textuelle du graphique
Deux rangées de cinq points. Un processus : 3.37, 3.3, 3.41, 3.41, 3.36 billets par seconde, tous regroupés près de 3,4. Quatre processus : 8.96, 9.59, 10.74, 9.36, 9.76 billets par seconde, répartis entre environ 9 et 11. Le passage le plus bas avec quatre processus dépasse largement le passage le plus haut avec un seul processus.
Ce que cela nous apprend. Le gain de débit et de p95 est réel : les étendues sont très éloignées. Les erreurs ont disparu. Avec un processus, le pool de 10 connexions était plein. De 10 à 14 requêtes par passage attendaient trop longtemps pour obtenir une connexion. Le coût d’IA par billet n’a pas changé, car chaque billet fait toujours les trois mêmes appels. Le prix de ce gain apparaît dans la colonne des ressources : les pools permettent jusqu’à 40 connexions plutôt que 10. Remarquez aussi l’étendue d’utilisation du processeur avec quatre processus, de 2,6 % à 10,0 %. Un passage a connu un moment plus chargé, et la médiane protège la comparaison contre cet effet.
Coût par tâche : jetons multipliés par prix
Section intitulée « Coût par tâche : jetons multipliés par prix »Un modèle hébergé facture chaque jeton (token), un morceau de texte d’environ quatre caractères. Le prix diffère entre les jetons que vous envoyez (entrée) et ceux que le modèle écrit (sortie). Le projet conserve les prix dans ticket_api/prices.py. Chat-small coûte 0,10 $ US par million de jetons d’entrée et 0,50 $ US par million de jetons de sortie. Embed-small coûte 0,02 $ US par million de jetons d’entrée. Les prix changent : consultez la page des prix actuels du fournisseur avant de les utiliser.
Voici un petit exemple détaillé, avec les nombres médians de jetons d’un billet provenant des appels réels enregistrés :
| Tâche | Jetons d’entrée × prix | Jetons de sortie × prix | Coût |
|---|---|---|---|
| classify | 199 × 0,10 ÷ 1 000 000 = 0,0000199 $ US | 15 × 0,50 ÷ 1 000 000 = 0,0000075 $ US | 0,0000274 $ US |
| draft_reply | 130 × 0,10 ÷ 1 000 000 = 0,0000130 $ US | 41,5 × 0,50 ÷ 1 000 000 = 0,0000208 $ US | 0,0000338 $ US |
| embed | 33,5 × 0,02 ÷ 1 000 000 = 0,0000007 $ US | aucun | 0,0000007 $ US |
| Un billet | environ 0,0000618 $ US |
Le travail d’IA d’un billet coûte donc environ 0,00006 $ US, soit 6 cents US pour 1 000 billets. Les enregistrements donnaient une médiane de 0,0000617 $ US par billet. L’exécution de 30 billets du cours, avec le fournisseur simulé, donnait 0,0000615 $ US. La réponse est la tâche la plus coûteuse, car les jetons de sortie coûtent cinq fois plus que les jetons d’entrée.
Description textuelle du graphique
Trois barres. Classify coûte US$0.0273 pour 1 000 billets, draft_reply US$0.0335, et embed US$0.0006. Ensemble, environ 0,06 $ US pour 1 000 billets.
python -m scripts.cost fait le même calcul à partir de la table ai_runs, pour les billets passés par l’API. Avec --compute-usd-per-hour et --hours, il répartit aussi le coût de vos machines entre les billets de cette période. Sur un portable, cette colonne n’a pas de valeur réelle. Sur une plateforme, ce coût dépasse souvent celui du travail d’IA.
Larkfield : un deuxième processus aide-t-il au Vendredi fou?
Section intitulée « Larkfield : un deuxième processus aide-t-il au Vendredi fou? »Tomás propose la solution évidente à une longue file d’attente : « ajouter des processus ». Amira la mesure. Sa question : avec le quota enregistré, un deuxième processus termine-t-il plus de billets du Vendredi fou par seconde? Sa charge de travail dépasse légèrement la minute la plus chargée, pour garder une marge. Elle utilise 4 utilisateurs avec PACE_SECONDS=2, soit 2 billets par seconde, pendant 70 secondes, en excluant les 10 premières. Les deux configurations diffèrent par un seul paramètre : WORKERS=1 ou WORKERS=2.
scripts.compare assure l’équité de la comparaison pour elle. À chaque passage, il recharge les données, vide le cache et réinitialise le fournisseur simulé. Il démarre ensuite l’API sur le port 8790 (un autre port avec --port) et les processus, puis lance Locust. Il attend jusqu’à 120 secondes que la file se vide, puis arrête tout. Il indique la médiane et l’étendue de chaque colonne.
Voici son résultat : l’exécution de l’auteur sur un ordinateur peu sollicité, avec une charge sur 1 minute de 1,9 avant et 2,2 après. Vos chiffres seront différents. Médianes de 3 passages, avec l’étendue :
| Configuration (2 billets/s, 70 s, quota activé) | Billets terminés par seconde | p95 des requêtes | Soumission au résultat, p50 | Soumission au résultat, p95 | Erreurs | Processeur de l’API | Réponses 429 du fournisseur | Coût d’IA par billet |
|---|---|---|---|---|---|---|---|---|
| file d’attente, 1 processus | 1,45 (1,42–1,50) | 20,2 ms | 7,6 s | 55,8 s (53,0–58,4) | aucune | 0,7 % | 90 (78–94) | 0,0000614 $ US |
| file d’attente, 2 processus | 1,43 (1,40–1,47) | 19,5 ms | 2,9 s | 53,9 s (49,8–54,8) | aucune | 0,7 % | 108 (76–119) | 0,0000614 $ US |
Description textuelle du graphique
Quatre rangées de trois points. Avec le quota enregistré, un processus a terminé 1.5, 1.42, 1.45 billets par seconde, et deux processus 1.47, 1.43, 1.4 : les rangées se chevauchent. Avec le quota désactivé, un processus a terminé 1.75, 1.82, 1.75, et deux processus 2, 2, 2.02 : les rangées sont séparées. La section « À vous de jouer » ci-dessous explique la deuxième paire.
Ce que cela nous apprend. Le deuxième processus n’a pas terminé plus de billets par seconde : les étendues se chevauchent et restent près de 1,45. Le quota impose le rythme : une minute complète d’appels au départ, puis 100 appels par minute. Les billets les plus lents ont donc attendu environ 55 secondes, avec un ou deux processus. Le deuxième processus a changé deux choses. Le billet typique a reçu sa réponse plus tôt, après 2,9 secondes plutôt que 7,6 secondes. En effet, plus de tâches s’exécutaient pendant que le quota était encore plein. Et le fournisseur a refusé plus d’appels, 108 plutôt que 90 par passage : davantage de processus demandaient plus souvent. La réponse à Tomás est « pas tant que le quota est la limite ». Le tableau de résultats montre pourquoi, et à quel coût.
Exercice guidé : comparer un et deux processus
Section intitulée « Exercice guidé : comparer un et deux processus »Vous exécutez la même comparaison. Cela prend environ 15 minutes. Pendant ce temps, n’utilisez pas l’ordinateur pour d’autres travaux lourds.
-
Copiez les fichiers de cette leçon depuis l’instantané :
Fenêtre de terminal S=../nextia-learning-labs/C21/snapshots/end-of-m06for f in scripts/compare.py scripts/cost.py tests/test_load_tests.py; do cp "$S/$f" "$f"; doneFenêtre de terminal $S = "..\nextia-learning-labs\C21\snapshots\end-of-m06"foreach ($f in 'scripts\compare.py', 'scripts\cost.py', 'tests\test_load_tests.py') { Copy-Item "$S\$f" $f } -
Exécutez les tests :
python -m pytest. Attendez-vous à176 passed, 1 deselected(176 tests réussis, 1 non sélectionné). -
Arrêtez l’API et tous les processus encore actifs depuis la dernière leçon (Ctrl+C dans leurs terminaux).
scripts.comparedémarre les siens. Un processus oublié prendrait les tâches de la comparaison. -
Dans le terminal 1, démarrez le fournisseur simulé avec le quota enregistré :
python -m simulator. -
Dans le terminal 2, affichez les renseignements sur la machine :
python -m scripts.machine. -
Lancez la comparaison :
Fenêtre de terminal python -m scripts.compare --config "queue, 1 worker:INTAKE_MODE=queue,WORKERS=1" --config "queue, 2 workers:INTAKE_MODE=queue,WORKERS=2" --users 4 --pace 2 --seconds 70 --passes 3 --json compare.json -
Affichez de nouveau les renseignements sur la machine :
python -m scripts.machine. -
Affichez le coût d’IA des billets du dernier passage :
python -m scripts.cost. -
Copiez
docs/benchmark-template.mdversdocs/workers.md, puis remplissez le tableau de résultats avec vos médianes et vos étendues.
Afficher le résultat attendu
L’exécution de l’auteur (vos chiffres seront différents). L’avertissement de l’API concernant API_KEY apparaît une fois par passage; il est omis ici :
queue, 1 worker pass 1: done 1.5/s, p95 20.2 ms, codes {'202': 120}queue, 1 worker pass 2: done 1.42/s, p95 21.2 ms, codes {'202': 120}queue, 1 worker pass 3: done 1.45/s, p95 18.2 ms, codes {'202': 120}queue, 2 workers pass 1: done 1.47/s, p95 19.8 ms, codes {'202': 120}queue, 2 workers pass 2: done 1.43/s, p95 18.7 ms, codes {'202': 120}queue, 2 workers pass 3: done 1.4/s, p95 19.5 ms, codes {'202': 120}
Median of 3 passes (lowest-highest); 4 users, pace 2.0 s, 70 s, first 10 s left out- queue, 1 worker: done per s 1.45 (1.42-1.5) | p50 15.4 (15.1-15.8) ms | p95 20.2 (18.2-21.2) ms | p99 22.3 (18.9-22.4) ms | submit to result p95 55771.8 (53002.1-58357.1) ms | API CPU 0.7 (0.7-0.7)% | 429 from provider 90 (78-94)- queue, 2 workers: done per s 1.43 (1.4-1.47) | p50 15.9 (15.8-16.1) ms | p95 19.5 (18.7-19.8) ms | p99 21.2 (20.8-23.6) ms | submit to result p95 53869.4 (49826.1-54836.9) ms | API CPU 0.7 (0.7-0.7)% | 429 from provider 108 (76-119)Étape 8. La première ligne, qui donne la date des prix dans prices.py, est omise :
classify chat-small 140 calls 27799 in 2100 out US$0.003830 draft_reply chat-small 140 calls 18139 in 5772 out US$0.004700 embed embed-small 140 calls 3166 in 0 out US$0.000063AI cost per ticket: US$0.0000614 (US$0.0614 per 1,000 tickets)scripts.cost lit les billets dans la base de données; il compte donc seulement le dernier passage : 140 billets. Cela représente 70 secondes à 2 billets par seconde : 120 pendant la période mesurée et 20 pendant l’échauffement. Comparez le coût à l’exemple détaillé ci-dessus : 0,0000614 $ US contre environ 0,0000618 $ US dans les enregistrements.
À vous de jouer : la même comparaison sans quota
Section intitulée « À vous de jouer : la même comparaison sans quota »Changez une condition : le quota. Arrêtez le simulateur, puis redémarrez-le avec le quota désactivé : SIM_QUOTA=off python -m simulator (PowerShell : $env:SIM_QUOTA = "off"; python -m simulator). C’est comme si Larkfield disposait d’un quota beaucoup plus grand. Répétez l’étape 6 avec --json compare-no-quota.json.
Faites d’abord une prédiction. Un processus exécute 4 tâches à la fois, et une tâche prend environ 2,2 secondes. Combien de billets par seconde un processus peut-il terminer? Est-ce suffisant pour 2 billets par seconde? Quel effet attendez-vous maintenant du deuxième processus?
Afficher la réponse
Un processus exécute 4 tâches à la fois, et une tâche prend environ 2,2 secondes : 4 ÷ 2,2 = environ 1,8 billet par seconde. C’est moins que les 2 billets qui arrivent chaque seconde; avec un processus, la file s’allonge donc lentement. Deux processus peuvent en terminer environ 3,6 par seconde, ce qui suffit largement. Les processus sont maintenant la limite; le deuxième devrait donc aider.
L’exécution de l’auteur, quota désactivé (charge sur 1 minute de 2,0 avant et 4,3 après; vos chiffres seront différents). Médianes de 3 passages, avec l’étendue :
| Configuration | Billets terminés par seconde | p95 des requêtes | Soumission au résultat, p95 | Réponses 429 du fournisseur |
|---|---|---|---|---|
| file d’attente, 1 processus | 1,75 (1,75–1,82) | 20,3 ms | 11,5 s (10,6–11,9) | 0 |
| file d’attente, 2 processus | 2,0 (2,0–2,02) | 18,5 ms | 3,2 s (3,0–3,2) | 0 |
Les étendues ne se chevauchent pas. Le deuxième processus a permis de terminer tout le travail à mesure qu’il arrivait. Il a réduit l’attente entre soumission et résultat d’environ 11,5 à 3,2 secondes. Donc, « ajouter des processus » convient quand les processus sont la limite, mais pas quand c’est le quota. La comparaison vous indique dans quel cas vous êtes.
Erreur courante
Le req/s de Locust comptait des promesses, pas du travail
Symptôme : une comparaison de deux configurations avec file d’attente montre le même « req/s » élevé dans le tableau de Locust. Dans la forte pointe de Concevoir un test de charge, Locust affichait 5.92 requêtes réussies par seconde. Pourtant, le travail d’IA se terminait au rythme de quelques billets par minute.
Cause : avec la conception à file d’attente, une requête se termine par 202 Accepted (acceptée) dès que le billet est enregistré. Locust compte cette réponse. Le travail que le client attend se déroule plus tard, dans le processus, et Locust ne le voit jamais.
Diagnostic : comparez le nombre de requêtes de Locust aux tâches réussies pendant la même période. python -m scripts.queue_watch affiche done/min (terminées par minute); scripts.compare indique done per s (terminées par seconde) depuis la table jobs.
Solution : pour toute conception qui répond avant la fin du travail, mesurez le débit en travail terminé. Mesurez la latence comme le délai entre soumission et résultat. Gardez aussi le p95 de la requête elle-même : il indique à quelle vitesse les clients reçoivent leur 202.
Quand comparer, et à quel coût
Section intitulée « Quand comparer, et à quel coût »Comparez avant de conserver un changement qui a un coût : plus de processus, plus de processus en arrière-plan, un plus grand pool, un cache. Comparez de nouveau quand une hypothèse change, comme un nouveau quota ou un nouveau fournisseur. Ne comparez pas des réglages qui ne changent rien pour le client.
Une comparaison équitable prend du temps. Trois essais de deux configurations, avec les réinitialisations et le vidage de la file d’attente, prennent environ quinze minutes. C’est peu face à une décision pour le Vendredi fou fondée sur un seul essai chanceux. Elle demande aussi de l’attention : un seul changement, la même charge de travail, un ordinateur peu sollicité. scripts.compare exécute tous les essais de la première configuration avant ceux de la seconde. Si votre ordinateur devient plus occupé pendant le test, la seconde configuration en subit les effets. Vérifiez donc la charge moyenne avant et après.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
La configuration A a un p95 de 2 410 ms (2 200–2 630) sur 5 essais. Celui de B est de 2 350 ms (2 150–2 700). B est-elle plus rapide?
Afficher la réponse
Le test ne l’a pas démontré. Les plages se chevauchent presque entièrement : certains essais de A étaient plus rapides que certains essais de B. Les 60 ms entre les médianes représentent moins que l’écart entre les essais d’une même configuration. Indiquez « aucune différence démontrée ». Si la différence compte, faites plus d’essais ou un test plus long.
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
Quatre processus d'API ont terminé 9,59 billets par seconde au lieu de 3,37, sans erreur. Nommez un élément du tableau comparatif qui s'est dégradé et expliquez pourquoi il compte.
Afficher la réponse
Les connexions à la base de données : jusqu’à 40 au lieu de 10, car chaque processus a son propre pool. PostgreSQL en permet 100, donc le nombre de processus ne peut pas augmenter beaucoup plus. L’utilisation du processeur par l’API a aussi augmenté, de 1,1 % à 3,0 %, mais elle reste faible. Le coût de l’IA par billet n’a pas 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.
Vérifiez votre compréhension
Vérification pratique : à partir de votre comparaison, donnez la ligne du tableau comparatif pour chaque configuration. Dites en une phrase si le second processus en arrière-plan a aidé, avec les preuves.
Afficher la réponse
Votre ligne contient la médiane et la plage du nombre de billets terminés par seconde, ainsi que les p50, p95 et p99 des requêtes. Elle contient aussi le p95 entre la soumission et le résultat, les erreurs et l’utilisation du processeur par l’API. Ajoutez les réponses 429 du fournisseur et le coût de l’IA par billet. Au-dessus du tableau, indiquez la charge de travail et la machine, avec sa charge moyenne. Avec le quota enregistré, la réponse devrait être « aucune différence démontrée ». Les plages du travail terminé par seconde avec un et deux processus en arrière-plan se chevauchent, car le quota impose le rythme. Vos chiffres seront différents.
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
- Une comparaison équitable change un seul réglage et conserve la charge de travail, sa forme, l’état initial et la machine.
- Faites au moins trois essais par configuration et indiquez la médiane, avec les valeurs minimale et maximale des essais. Des plages qui se chevauchent signifient « aucune différence démontrée ».
- Le tableau comparatif garde les mêmes colonnes : débit du travail terminé, p50, p95 et p99, erreurs, ressources et coût par tâche.
- Le travail d’IA pour un billet coûte environ 0,00006 $ US : le nombre de jetons multiplié par les prix datés. La réponse coûte le plus cher, car les jetons de sortie sont coûteux.
scripts.compareréinitialise tout avant chaque essai et indique les médianes et les plages. Ajouter des processus en arrière-plan aide seulement quand ces processus constituent la limite.
Leçon suivante : Recommandation de capacité