Comment optimiser les modèles d'IA

Comment optimiser les modèles d'IA

En résumé : pour optimiser les modèles d’IA, choisissez une contrainte principale (latence, coût, mémoire, qualité, stabilité ou débit), puis établissez une base de référence fiable avant toute modification. Commencez par supprimer les goulots d’étranglement du pipeline, puis appliquez des améliorations à faible risque comme la précision mixte et le traitement par lots. Si la qualité est maintenue, passez aux outils de compilation et d’exécution, et enfin, si nécessaire, réduisez la taille du modèle par quantification ou distillation.

Points clés à retenir :

Contrainte : Choisissez une ou deux métriques cibles ; l'optimisation est un domaine fait de compromis, et non de gains faciles.

Mesure : Profil des charges de travail réelles avec p50/p95/p99, débit, utilisation et pics de mémoire.

Pipeline : Corrigez la tokenisation, les chargeurs de données, le prétraitement et le traitement par lots avant de toucher au modèle.

Service : Utilisez la mise en cache, le traitement par lots délibéré, l'optimisation de la concurrence et surveillez de près la latence de queue.

Mesures de sécurité : Exécutez des invites de commande, des mesures de tâches et des vérifications ponctuelles après chaque modification des performances.

Infographie : Comment optimiser les modèles d’IA

🔗 Comment évaluer efficacement les modèles d'IA ?
Critères et étapes clés pour juger les modèles de manière juste et fiable.

🔗 Comment mesurer les performances de l'IA avec des indicateurs réels ?
Utilisez des benchmarks, la latence, le coût et des signaux de qualité pour comparer.

🔗 Comment tester les modèles d'IA avant la production
Flux de travail de test pratique : divisions des données, cas de charge et surveillance.

🔗 Comment utiliser l'IA pour la création de contenu ?
Transformez plus rapidement vos idées en brouillons grâce à des invites structurées et à l'itération.

1) Ce que signifie « optimiser » en pratique (car chacun l'utilise différemment) 🧠

Quand on parle d’« optimiser un modèle d’IA », on peut vouloir dire :

  • Accélérer le processus (réduire la latence)

  • Réduire les coûts (moins d'heures de calcul du GPU, moins de dépenses liées au cloud)

  • Réduire sa taille (empreinte mémoire, déploiement en périphérie)

  • Améliorer la précision (amélioration de la qualité, moins d'hallucinations)

  • Rendre le système plus stable (moins de variance, moins de défaillances en production)

  • Faciliter le service (débit, traitement par lots, performances prévisibles)

Voici une vérité un peu agaçante : il est impossible d’optimiser tous ces aspects simultanément. L’optimisation, c’est comme presser un ballon : si on appuie d’un côté, l’autre se gonfle. Ce n’est pas systématique, mais suffisamment fréquent pour qu’il faille prévoir des compromis.

Avant de toucher à quoi que ce soit, choisissez votre contrainte principale :

  • Si vous proposez des services en direct à vos utilisateurs, vous vous souciez de la latence p95 ( percentiles AWS CloudWatch ) et des performances de queue ( bonnes pratiques relatives à la latence de queue ) 📉

  • Si vous vous entraînez, vous vous souciez du temps nécessaire pour obtenir un résultat de qualité et de l'utilisation du GPU 🔥

  • Si vous déployez sur des appareils, la RAM et la consommation d'énergie 🔋

2) À quoi ressemble une bonne version d'optimisation de modèle d'IA ✅

Une bonne optimisation ne se résume pas à « appliquer la quantification et croiser les doigts ». C'est un système. Les meilleures configurations comprennent généralement :

  • Un point de référence fiable.
    Si vous ne parvenez pas à reproduire vos résultats actuels, vous ne pouvez pas savoir si vous avez progressé. C'est simple… mais on néglige souvent cette étape. Et c'est la spirale infernale.

  • Un objectif clair comme
    « Plus rapide » est vague. « Réduire la latence p95 de 900 ms à 300 ms avec le même score de qualité » est un véritable objectif.

  • Des garde-fous pour la qualité :
    chaque gain de performance comporte un risque de dégradation silencieuse de la qualité. Il vous faut des tests, des évaluations, ou au moins une suite de tests de validation.

  • Compréhension du matériel :
    un modèle « rapide » sur un GPU peut être extrêmement lent sur un autre. Les CPU constituent un cas à part entière.

  • Des changements progressifs, pas une refonte complète.
    Quand on modifie cinq éléments à la fois et que les performances s'améliorent, on ne sait pas pourquoi. Ce qui est… déconcertant.

L'optimisation devrait ressembler à l'accordage d'une guitare : de petits ajustements, une écoute attentive, et on recommence 🎸. Si c'est comme jongler avec des couteaux, c'est qu'il y a un problème.

3) Tableau comparatif : Options populaires pour optimiser les modèles d’IA 📊

Vous trouverez ci-dessous un tableau comparatif rapide et quelque peu brouillon des outils et approches d'optimisation courants. Certes, il n'est pas parfaitement « juste » — la réalité ne l'est pas non plus.

Outil / Option Public Prix Pourquoi ça marche
PyTorch torch.compile ( Documentation PyTorch ) Les gens de PyTorch Gratuit Capture de graphes + astuces de compilation peuvent réduire la surcharge… parfois, c'est magique ✨
Environnement d'exécution ONNX ( Documentation de l'environnement d'exécution ONNX ) Équipes de déploiement Gratuit Optimisations d'inférence robustes, large compatibilité, idéal pour un service standardisé
TensorRT ( Documentation NVIDIA TensorRT ) Déploiement NVIDIA Ambiance payante (souvent incluse dans un forfait) Fusion agressive du noyau + gestion précise, très rapide une fois le clic effectué
DeepSpeed ​​( Documentation ZeRO ) Équipes d'entraînement Gratuit Optimisations de la mémoire et du débit (ZeRO, etc.). On a l'impression d'être dans un réacteur d'avion
FSDP (PyTorch) ( Documentation FSDP de PyTorch ) Équipes d'entraînement Gratuit Les paramètres/gradients de fragmentation rendent les grands modèles moins intimidants
quantification bitsandbytes ( bitsandbytes ) bricoleurs LLM Gratuit Faible poids en bits, économies de mémoire considérables – la qualité dépend, mais quel gain ! 😬
Distillation ( Hinton et al., 2015 ) Équipes produit « Coût en temps » Un modèle étudiant plus restreint hérite des comportements, offrant généralement le meilleur retour sur investissement à long terme
Élagage ( Tutoriel d'élagage PyTorch ) Recherche + production Gratuit Élimine les éléments superflus. Son efficacité est accrue lorsqu'il est associé à un programme de rééducation
Attention éclair / noyaux fusionnés ( article FlashAttention ) Les mordus de la performance Gratuit Attention plus rapide, meilleure mémoire. Un vrai avantage pour les Transformers
Serveur d'inférence Triton ( traitement par lots dynamique ) Opérations/Infrastructure Gratuit Production en service, traitement par lots, pipelines multi-modèles : une ambiance d’entreprise

Petit aveu : le mot « Prix » est mal écrit car l’open source peut quand même vous coûter un week-end de débogage, ce qui… a un prix. 😵💫

4) Commencez par les mesures : un profil réaliste 🔍

Si vous ne devez retenir qu'une seule chose de ce guide, faites ceci : mesurez correctement.

Lors de mes propres tests, les plus grandes « avancées en matière d’optimisation » sont venues de la découverte de choses d’une simplicité déconcertante, comme :

  • Le chargeur de données sature le GPU

  • Goulot d'étranglement du prétraitement du processeur

  • Les petites tailles de lots entraînent une surcharge au lancement du noyau

  • tokenisation lente (les tokeniseurs peuvent être de petits traîtres)

  • Fragmentation de la mémoire ( Notes sur l'allocateur de mémoire CUDA pour PyTorch )

  • une seule couche dominant le calcul

Éléments à mesurer (ensemble minimum)

  • Latence (p50, p95, p99) ( SRE sur les percentiles de latence )

  • Débit (jetons/s, requêtes/s)

  • Utilisation du GPU (calcul + mémoire)

  • pics de VRAM/RAM

  • Coût par tranche de 1 000 jetons (ou par inférence)

mentalité de profilage pratique

  • Décrivez un scénario qui vous tient à cœur (pas une consigne liée à un jouet).

  • Notez tout dans un petit « journal intime ».
    Oui, c'est fastidieux… mais cela vous évitera de vous faire du tort plus tard.

(Si vous souhaitez un outil concret pour commencer : PyTorch Profiler ( documentation torch.profiler ) et Nsight Systems ( NVIDIA Nsight Systems ) sont les plus courants.)

5) Optimisation des données et de l'entraînement : le super-pouvoir discret 📦🚀

On s'attarde trop sur l'architecture du modèle et on oublie le pipeline. Pendant ce temps, ce dernier consomme discrètement la moitié des ressources du GPU.

Des victoires faciles qui se manifestent rapidement

  • Utilisez une précision mixte (FP16/BF16 lorsque stable) ( PyTorch AMP / torch.amp ).
    Généralement plus rapide, souvent convenable - mais attention aux bizarreries numériques.

  • L'accumulation de gradients lorsque la taille du lot est limitée ( 🤗 Guide d'accélération )
    maintient l'optimisation stable sans explosion de mémoire.

  • Le point de contrôle de gradient ( torch.utils.checkpoint )
    échange la puissance de calcul contre de la mémoire - rend possibles des contextes plus grands.

  • Une tokenisation efficace ( 🤗 Tokeniseurs )
    La tokenisation peut devenir un goulot d'étranglement à grande échelle. Ce n'est pas glamour, mais c'est important.

  • Optimisation du chargeur de données :
    Plus de workers, mémoire épinglée, préchargement – ​​discret mais efficace 😴➡️💪 ( Guide d’optimisation des performances PyTorch )

réglage fin efficace des paramètres

Pour l'optimisation de grands modèles, les méthodes PEFT (comme les adaptateurs de type LoRA) permettent de réduire considérablement le coût d'entraînement tout en conservant une performance étonnamment bonne ( 🤗 Guide PEFT pour Transformers , article sur LoRA ). On se dit alors : « Pourquoi n'y avons-nous pas pensé plus tôt ? »

6) Optimisation au niveau de l'architecture : dimensionner correctement le modèle 🧩

Parfois, la meilleure façon d'optimiser, c'est… d'arrêter d'utiliser un modèle trop volumineux pour la tâche. Je sais, c'est un sacrilège 😄.

Prenez une décision sur quelques points essentiels :

  • Décidez si vous avez besoin d'un renseignement généraliste complet ou d'un spécialiste.

  • Gardez la fenêtre de contexte à la taille nécessaire, pas plus grande.

  • Utilisez un modèle entraîné pour la tâche à accomplir (modèles de classification pour les travaux de classification, etc.).

Stratégies pratiques de redimensionnement

  • Passez à une infrastructure plus légère pour la plupart des requêtes,
    puis acheminez les requêtes complexes vers un modèle plus important.

  • Utilisez une méthode en deux étapes :
    une première version rapide, puis une version plus aboutie pour la vérification ou la correction.
    C’est comme écrire avec un ami pointilleux : agaçant, mais efficace.

  • Réduisez la longueur des résultats.
    Les jetons de sortie coûtent du temps et de l'argent. Si votre modèle est trop long, vous en subirez les conséquences.

J'ai vu des équipes réduire considérablement leurs coûts en imposant des délais de livraison plus courts. Ça peut paraître mesquin, mais ça marche.

7) Optimisations du compilateur et des graphes : d’où vient la vitesse 🏎️

Il s'agit de la couche « permettre à l'ordinateur d'effectuer des tâches informatiques plus intelligentes ».

Techniques courantes :

En clair : votre modèle peut être rapide mathématiquement, mais lent opérationnellement. Les compilateurs corrigent en partie ce problème.

Notes pratiques (alias cicatrices)

  • Ces optimisations peuvent être sensibles aux changements de forme du modèle.

  • Certains modèles accélèrent beaucoup, d'autres à peine.

  • Parfois, on a une accélération soudaine et un bug déroutant – comme si un gremlin avait emménagé 🧌

Néanmoins, quand ça fonctionne, c'est une des victoires les plus nettes.

8) Quantification, élagage, distillation : plus petit sans trop pleurer 🪓📉

C'est cette partie que les gens réclament… car elle évoque une performance gratuite. Elle peut l'être, mais il faut l'aborder comme une opération chirurgicale.

Quantification (poids/activations de précision inférieure)

  • Idéal pour la vitesse d'inférence et la mémoire

  • Risque : baisse de qualité, notamment dans les cas limites

  • Meilleure pratique : évaluer sur un jeu de test réel, et non pas sur des impressions

Saveurs courantes dont vous entendrez parler :

Élagage (suppression des paramètres)

  • Supprime les poids ou structures « non importants » ( Tutoriel d'élagage PyTorch )

  • Un recyclage est généralement nécessaire pour retrouver la qualité

  • Ça marche mieux qu'on ne le pense… quand c'est fait avec précaution

Distillation (l'élève apprend du professeur)

C'est mon levier préféré à long terme. La distillation permet d'obtenir un modèle plus petit au comportement similaire, et elle est souvent plus stable qu'une quantification extrême ( Distilling the Knowledge in a Neural Network ).

Une métaphore imparfaite : la distillation, c’est comme verser une soupe complexe à travers un filtre et obtenir… une soupe plus légère. Ce n’est pas comme ça que fonctionne la soupe, mais vous comprenez l’idée 🍲.

9) Service et déduction : le véritable champ de bataille 🧯

On peut « optimiser » un modèle et pourtant mal le déployer. C’est au niveau du déploiement que la latence et le coût deviennent vraiment problématiques.

Les victoires au service qui comptent

  • Le traitement par lots
    améliore le débit, mais augmente la latence en cas d'excès. Il est donc important de trouver un juste milieu. ( Traitement par lots dynamique Triton )

  • La
    cache des invites et la réutilisation du cache KV peuvent s'avérer extrêmement efficaces pour les contextes répétés. ( Explication du cache KV )

  • Le streaming
    donne l'impression d'une diffusion plus rapide, même si la durée totale est similaire. L'impression compte 🙂.

  • Réduction des coûts par jeton :
    Certains systèmes effectuent un travail supplémentaire pour chaque jeton. Réduisez ces coûts et vous gagnerez gros.

Attention à la latence de queue

Votre moyenne peut sembler excellente alors que votre p99 est catastrophique. Malheureusement, les utilisateurs se trouvent dans la queue de distribution. ( « Latence de queue » et pourquoi les moyennes sont trompeuses )

10) Optimisation prenant en compte le matériel : adapter le modèle à la machine 🧰🖥️

Optimiser sans tenir compte du matériel, c'est comme régler une voiture de course sans vérifier les pneus. Bien sûr, c'est possible, mais c'est un peu absurde.

Considérations relatives au GPU

  • La bande passante mémoire est souvent le facteur limitant, et non la puissance de calcul brute

  • Des lots plus importants peuvent aider, jusqu'à un certain point

  • La fusion de noyaux et les optimisations d'attention sont cruciales pour les transformateurs ( FlashAttention : attention exacte prenant en compte les E/S ).

Considérations relatives au processeur

  • Le multithreading, la vectorisation et la localité de la mémoire sont très importants

  • La surcharge liée à la tokenisation peut être prépondérante ( 🤗 tokeniseurs « rapides » )

  • Vous pourriez avoir besoin de stratégies de quantification différentes de celles utilisées sur GPU

Considérations relatives à la périphérie et au mobile

  • L'empreinte mémoire devient la priorité numéro un

  • La variation de latence est importante car les appareils sont… capricieux

  • Les modèles plus petits et spécialisés surpassent souvent les grands modèles généralistes

11) Garde-fous de qualité : Ne vous « optimisez » pas au point de devenir un insecte 🧪

Chaque victoire rapide doit s'accompagner d'un contrôle qualité. Sinon, vous fêterez ça, expédierez la commande, et recevrez ensuite un message du genre : « Pourquoi l'assistant parle-t-il soudainement comme un pirate ? » 🏴☠️

Garde-fous pragmatiques :

  • Invites en or (ensemble fixe d'invites que vous testez toujours)

  • Métriques de la tâche (précision, F1, BLEU, etc.)

  • Contrôles humains ponctuels (oui, sérieusement)

  • Seuil de régression (« pas plus de X % de baisse autorisée »)

Suivre également les modes de défaillance :

  • dérive de formatage

  • changements de comportement de refus

  • fréquence des hallucinations

  • l'inflation de la longueur de réponse

L'optimisation peut modifier les comportements de façon surprenante. Étrange. Irritante. Prévisible, avec le recul.

12) Liste de contrôle : Comment optimiser les modèles d’IA étape par étape ✅🤖

Si vous souhaitez connaître l'ordre des opérations pour optimiser les modèles d'IA , voici le flux de travail qui a tendance à préserver la santé mentale des utilisateurs :

  1. Définir le succès.
    Choisir 1 à 2 indicateurs principaux (latence, coût, débit, qualité).

  2. Mesurer
    les charges de travail réelles de référence, enregistrer les temps de réponse à 50/95 secondes, la mémoire et le coût. ( PyTorch Profiler )

  3. Résoudre les goulots d'étranglement du pipeline :
    chargement des données, tokenisation, prétraitement, traitement par lots.

  4. Appliquer des gains de calcul à faible risque :
    précision mixte, optimisations du noyau, meilleur traitement par lots.

  5. Essayez les optimisations du compilateur et de l'exécution :
    capture de graphes, inférences, fusion d'opérateurs. ( Tutoriel torch.compile , documentation ONNX Runtime )

  6. Réduisez le coût du modèle.
    Quantifiez soigneusement, simplifiez si possible, élaguez si nécessaire.

  7. Optimisation du service :
    mise en cache, concurrence, tests de charge, corrections de latence en queue.

  8. Validez la qualité.
    Exécutez des tests de régression et comparez les résultats côte à côte.

  9. Itérer.
    Petites modifications, notes claires, répéter. Discret, mais efficace.

Et oui, il s'agit toujours de « Comment optimiser les modèles d'IA », même si cela ressemble davantage à « Comment éviter de marcher sur des râteaux ». C'est la même chose.

13) Erreurs courantes (pour que vous ne les répétiez pas comme nous tous) 🙃

  • Optimiser avant de mesurer,
    c'est perdre du temps. Et ensuite, vous optimiserez la mauvaise chose avec assurance…

  • Se focaliser sur un seul indicateur de performance
    est trompeur. Les indicateurs de performance sont trompeurs par omission. Votre charge de travail est la réalité.

  • Ignorer la mémoire :
    les problèmes de mémoire entraînent des ralentissements, des plantages et des saccades. ( Comprendre l’utilisation de la mémoire CUDA dans PyTorch )

  • La surquantification précoce : une
    quantification à faible nombre de bits peut être incroyable, mais commencez par des étapes plus sûres.

  • Pas de plan de retour en arrière :
    si vous ne pouvez pas revenir en arrière rapidement, chaque déploiement devient source de stress. Et le stress engendre des bugs.

Conclusion : L'optimisation par l'humain 😌⚡

L'optimisation des modèles d'IA ne se résume pas à une simple astuce. C'est un processus par étapes : mesurer, corriger le pipeline, utiliser des compilateurs et des environnements d'exécution, optimiser le déploiement, puis réduire la taille du modèle par quantification ou distillation si nécessaire. Procédez étape par étape, en veillant à respecter des critères de qualité stricts, et ne vous fiez pas à une simple impression de vitesse (vos impressions sont agréables, mais elles ne constituent pas un outil de profilage).

En résumé :

  • Mesurez d'abord 🔍

  • Optimisez ensuite le pipeline 🧵

  • Ensuite, optimisez le modèle 🧠

  • Ensuite, optimisez le service 🏗️

  • Effectuez toujours des contrôles qualité ✅

Et si cela peut vous aider, rappelez-vous : l'objectif n'est pas un « modèle parfait ». L'objectif est un modèle suffisamment rapide, abordable et fiable pour que vous puissiez dormir sur vos deux oreilles… la plupart des nuits 😴.

FAQ

En pratique, qu'implique l'optimisation d'un modèle d'IA ?

« Optimiser » signifie généralement améliorer une contrainte principale : latence, coût, empreinte mémoire, précision, stabilité ou débit. La difficulté réside dans les compromis : améliorer un aspect peut nuire à un autre. Une approche pratique consiste à choisir un objectif clair (comme la latence p95 ou le temps de réponse) et à optimiser en fonction de celui-ci. Sans objectif, il est facile de « s'améliorer » et de perdre malgré tout.

Comment optimiser les modèles d'IA sans nuire à la qualité ?

Considérez chaque modification de vitesse ou de coût comme une potentielle régression silencieuse. Mettez en place des garde-fous tels que des alertes claires, des indicateurs de performance et des vérifications humaines ponctuelles. Définissez un seuil précis pour une dérive de qualité acceptable et comparez les résultats. Ainsi, après la mise en production, vous éviterez que le constat d'une amélioration de la vitesse ne se transforme en une interrogation : « Pourquoi le comportement est-il soudainement devenu étrange ? ».

Que mesurer avant de commencer l'optimisation ?

Commencez par analyser les percentiles de latence (p50, p95, p99), le débit (jetons/s ou requêtes/s), l'utilisation du GPU et le pic d'utilisation de la VRAM/RAM. Suivez le coût par inférence ou par tranche de 1 000 jetons si le coût est une contrainte. Analysez un scénario réel que vous utilisez, et non une requête simplifiée. Tenir un journal de performances succinct vous permettra d'éviter les approximations et de ne pas répéter les mêmes erreurs.

Des victoires rapides et peu risquées pour améliorer les performances d'entraînement

La précision mixte (FP16/BF16) est souvent la première option la plus rapide, mais attention aux particularités numériques. Si la taille des lots est limitée, l'accumulation des gradients peut stabiliser l'optimisation sans saturer la mémoire. La sauvegarde des gradients permet de réduire la consommation de mémoire au détriment de la puissance de calcul, autorisant ainsi des contextes plus larges. N'oubliez pas la tokenisation et l'optimisation du chargeur de données : elles peuvent insidieusement saturer le GPU.

Quand utiliser torch.compile, ONNX Runtime ou TensorRT

Ces outils ciblent les surcharges opérationnelles : capture de graphes, fusion de noyaux et optimisations de graphes à l’exécution. Ils peuvent accélérer considérablement l’inférence, mais les résultats varient selon la forme du modèle et le matériel. Certaines configurations sont extrêmement performantes ; d’autres sont quasiment inexistantes. Il faut s’attendre à une sensibilité aux changements de forme et à des bugs occasionnels ; effectuez des mesures avant et après traitement sur votre charge de travail réelle.

La quantification est-elle pertinente et comment éviter d'aller trop loin ?

La quantification permet de réduire considérablement la mémoire et d'accélérer l'inférence, notamment avec INT8, mais la qualité peut se dégrader dans certains cas particuliers. Les options à plus faible nombre de bits (comme INT4/k-bit) offrent des économies plus importantes, mais présentent un risque accru. La méthode la plus sûre consiste à évaluer les résultats sur un jeu de test réel et à les comparer, plutôt que de se fier à son intuition. Commencez par des étapes plus sûres, puis réduisez la précision uniquement si nécessaire.

La différence entre l'élagage et la distillation pour la réduction de la taille du modèle

L'élagage supprime les paramètres « inutiles » et nécessite souvent un réentraînement pour retrouver la qualité, surtout lorsqu'il est effectué de manière excessive. La distillation, quant à elle, entraîne un modèle élève plus petit à imiter le comportement d'un modèle enseignant plus grand et peut offrir un meilleur retour sur investissement à long terme qu'une quantification extrême. Si vous souhaitez un modèle plus petit, au comportement similaire et stable, la distillation est souvent la solution la plus élégante.

Comment réduire le coût d'inférence et la latence grâce à des améliorations du service

C'est au niveau du service que l'optimisation devient concrète : le traitement par lots augmente le débit, mais peut alourdir la latence s'il est excessif ; il convient donc de l'optimiser avec soin. La mise en cache (mise en cache des invites et réutilisation du cache clé-valeur) peut s'avérer très gourmande en ressources lorsque les contextes se répètent. Le flux de données améliore la vitesse perçue, même si le temps total reste similaire. Surveillez également la surcharge liée à chaque jeton dans votre architecture : même une petite quantité de travail par jeton peut rapidement s'accumuler.

Pourquoi la latence de queue est-elle si importante lors de l'optimisation des modèles d'IA ?

Les moyennes peuvent paraître excellentes tandis que le p99 est catastrophique, et les utilisateurs se retrouvent généralement dans la partie basse du spectre. Cette latence est souvent due à des fluctuations : fragmentation de la mémoire, pics de prétraitement du processeur, ralentissements de la tokenisation ou mauvaise gestion des lots. C'est pourquoi ce guide met l'accent sur les percentiles et les charges de travail réelles. Si vous n'optimisez que le p50, vous risquez de proposer une expérience utilisateur qui « donne parfois l'impression d'être lente »

Références

  1. Amazon Web Services (AWS) - Percentiles AWS CloudWatch (définitions statistiques) - docs.aws.amazon.com

  2. Google - La queue à grande échelle (bonnes pratiques en matière de latence de queue) - sre.google

  3. Google - Objectifs de niveau de service (Livre SRE) - Percentiles de latence - sre.google

  4. PyTorch - torch.compile - docs.pytorch.org

  5. PyTorch - FullyShardedDataParallel (FSDP) - docs.pytorch.org

  6. PyTorch - Profileur PyTorch - docs.pytorch.org

  7. PyTorch - Sémantique CUDA : gestion de la mémoire (notes sur l'allocateur de mémoire CUDA) - docs.pytorch.org

  8. PyTorch - Précision mixte automatique (torch.amp / AMP) - docs.pytorch.org

  9. PyTorch - torch.utils.checkpoint - docs.pytorch.org

  10. Guide d'optimisation des performances de PyTorch - docs.pytorch.org

  11. PyTorch - Tutoriel sur l'élagage - docs.pytorch.org

  12. PyTorch - Comprendre l'utilisation de la mémoire CUDA dans PyTorch - docs.pytorch.org

  13. PyTorch - Tutoriel/présentation de torch.compile - docs.pytorch.org

  14. ONNX Runtime - Documentation ONNX Runtime - onnxruntime.ai

  15. NVIDIA - TensorRT - docs.nvidia.com

  16. NVIDIA - Types quantifiés TensorRT - docs.nvidia.com

  17. NVIDIA - Systèmes Nsight - developer.nvidia.com

  18. NVIDIA - Serveur d'inférence Triton - Traitement par lots dynamique - docs.nvidia.com

  19. DeepSpeed ​​- ZeRO Stage 3 - deepspeed.readthedocs.io

  20. bitsandbytes (fondation bitsandbytes) - bitsandbytes - github.com

  21. Hugging Face - Accélérer : Guide d'accumulation de gradient - huggingface.co

  22. Documentation sur les tokeniseurs Hugging Face - huggingface.co

  23. Hugging Face - Guide Transformers : PEFT - huggingface.co

  24. Hugging Face - Transformers : Explication du cache KV - huggingface.co

  25. Hugging Face - Transformers : tokeniseurs « rapides » (classes de tokeniseurs) - huggingface.co

  26. arXiv - Extraire les connaissances d'un réseau neuronal (Hinton et al., 2015) - arxiv.org

  27. arXiv - LoRA : Adaptation de faible rang des grands modèles de langage - arxiv.org

  28. arXiv - FlashAttention : Attention exacte rapide et économe en mémoire avec prise en compte des E/S - arxiv.org

Découvrez les dernières fonctionnalités d'IA sur la boutique officielle des assistants IA

À propos de nous

Retour au blog