Gérer les performances et les ressources
Un modèle d’intelligence artificielle local peut fonctionner correctement tout en étant lent, gourmand en mémoire ou instable. Apprenez à identifier les ressources utilisées, mesurer les performances, comprendre les ralentissements et ajuster les paramètres d’exécution pour obtenir le meilleur équilibre entre vitesse, qualité et stabilité.
À la fin de ce cours, vous saurez :
- Identifier les ressources utilisées pendant une inférence locale.
- Distinguer les rôles du CPU, du GPU, de la RAM et de la VRAM.
- Comprendre les phases de chargement, de préremplissage et de génération.
- Mesurer le temps de réponse et les tokens par seconde.
- Reconnaître une saturation de mémoire.
- Comprendre l’effet de la quantification et du contexte.
- Surveiller les ressources sous Windows et Linux.
- Consulter les modèles chargés avec Ollama.
- Modifier certains paramètres d’exécution.
- Comparer deux configurations de manière méthodique.
- Diagnostiquer les principales causes de lenteur.
- Définir une configuration adaptée à son matériel.
Il est conseillé d’avoir suivi les cours précédents du chapitre, notamment ceux consacrés au matériel, à la quantification, à Ollama, à LM Studio et à l’installation d’un modèle. Un modèle local fonctionnel est nécessaire pour réaliser les manipulations.
1. Pourquoi optimiser une IA locale ?
Lorsqu’un modèle fonctionne sur un ordinateur personnel, ses performances dépendent directement des ressources disponibles.
Deux ordinateurs utilisant le même modèle peuvent produire des réponses de qualité comparable, mais avec des vitesses très différentes.
Les performances peuvent également varier sur un même ordinateur selon :
- Les applications ouvertes.
- La quantité de mémoire libre.
- Le modèle utilisé.
- Le niveau de quantification.
- La longueur de la conversation.
- Les paramètres de génération.
- La température et les limites d’alimentation du matériel.
Un ordinateur dispose de 16 Go de RAM et exécute un modèle local quantifié.
Lorsque plusieurs applications gourmandes sont ouvertes, la mémoire disponible diminue. Le système peut commencer à déplacer des données vers le stockage, ce qui ralentit fortement la génération.
Fermer les applications inutiles peut alors améliorer la situation sans modifier le modèle.
2. Comprendre les quatre ressources principales
CPU
Le processeur généraliste exécute les instructions et peut réaliser l’inférence lorsque le modèle n’utilise pas entièrement le GPU.
GPU
Le processeur graphique peut accélérer les calculs massivement parallèles, sous réserve de compatibilité avec le moteur utilisé.
RAM
La mémoire vive accueille notamment les données du système, les applications et une partie ou la totalité des données nécessaires au modèle.
VRAM
La mémoire graphique dédiée stocke les données nécessaires aux calculs sur certains GPU. Les architectures à mémoire unifiée fonctionnent différemment.
Le stockage intervient également : il contient les fichiers du modèle et influence leur temps de chargement.
3. Comprendre les étapes de l’inférence
L’inférence désigne l’utilisation d’un modèle entraîné pour produire un résultat.
Dans le cas d’un modèle de langage, il faut distinguer plusieurs phases.
3.1. Chargement du modèle
Le moteur lit les fichiers du modèle et prépare les structures nécessaires à son exécution.
Cette étape peut prendre du temps, surtout si le modèle est volumineux ou si le stockage est lent.
3.2. Préremplissage du contexte
Le moteur traite les tokens d’entrée : instruction, historique de conversation et autres informations transmises.
Cette phase est souvent appelée prefill.
3.3. Génération des tokens
Le modèle produit ensuite les tokens de sortie, généralement de manière autorégressive.
La vitesse de cette phase est souvent exprimée en tokens par seconde.
Un modèle peut être rapide une fois chargé, mais présenter un délai important lors de la première requête. Il faut donc mesurer séparément le chargement, le traitement de l’entrée et la génération lorsque les outils le permettent.
4. Comprendre les tokens par seconde
Un token est une unité de texte utilisée par un modèle de langage.
Un token ne correspond pas systématiquement à un mot : il peut représenter un mot entier, une partie de mot, un signe ou un autre élément.
4.1. Formule
4.2. Exemple
Un modèle génère 480 tokens en 40 secondes.
La vitesse moyenne est donc de 12 tokens par seconde.
4.3. Interpréter la vitesse
Une vitesse élevée améliore généralement le confort d’utilisation, mais il n’existe pas de seuil universel définissant une IA locale rapide.
Le confort dépend notamment de la longueur des réponses, du délai avant le premier token et des attentes de l’utilisateur.
4.4. Attention aux mesures
Pour calculer correctement la vitesse de génération, il faut utiliser la durée correspondant à la génération des tokens, et non systématiquement le temps total de la requête.
5. Mesurer le temps de réponse
Le temps total de réponse est la durée écoulée entre l’envoi d’une requête et la réception complète du résultat.
Il peut inclure :
- Le chargement du modèle.
- Le traitement du prompt.
- La génération.
- Les traitements du serveur.
- Les échanges entre le client et le serveur.
5.1. Deux mesures différentes
| Mesure | Ce qu’elle indique |
|---|---|
| Temps avant le premier token | Délai avant le début de l’affichage de la réponse. |
| Temps total | Durée complète de traitement et de transmission de la réponse. |
Une interface utilisant le streaming peut afficher les premiers tokens avant la fin de la génération.
6. Comprendre la consommation de RAM
La RAM est une ressource essentielle pour l’exécution locale.
Un modèle ne consomme pas uniquement l’espace correspondant à ses poids.
Il faut également tenir compte :
- Des structures internes du moteur.
- Du cache d’attention.
- Des buffers de calcul.
- Des applications ouvertes.
- De la mémoire réservée par le système.
6.1. Exemple indicatif
Un fichier de modèle occupe 4,5 Go sur le disque.
Son exécution peut nécessiter davantage de mémoire selon le contexte, le moteur et les paramètres utilisés.
Il serait donc incorrect de conclure qu’un ordinateur disposant de 5 Go de RAM libre peut nécessairement l’exécuter confortablement.
6.2. Que se passe-t-il lorsque la RAM manque ?
Le système peut :
- Utiliser davantage le fichier d’échange ou la mémoire virtuelle.
- Ralentir fortement les applications.
- Interrompre certains processus.
- Refuser le chargement du modèle.
Le fichier d’échange peut éviter certaines interruptions, mais il ne remplace pas la vitesse de la RAM. Une forte activité de pagination est souvent un signe de pression mémoire.
7. Comprendre la consommation de VRAM
Sur un GPU disposant de mémoire graphique dédiée, la VRAM permet de conserver les données nécessaires aux calculs graphiques et à l’inférence.
Une quantité suffisante de VRAM peut permettre de charger davantage de couches du modèle sur le GPU.
7.1. Exemple
Un ordinateur possède une carte graphique avec 8 Go de VRAM.
Un modèle quantifié peut être suffisamment compact pour être exécuté principalement sur ce GPU, à condition que les poids et les autres allocations nécessaires tiennent dans la mémoire disponible.
7.2. Si la VRAM est insuffisante
Selon le moteur et la configuration :
- Une partie du modèle peut être exécutée sur le CPU.
- Le moteur peut réduire la quantité de données placées sur le GPU.
- Le chargement peut échouer.
- Les performances peuvent diminuer.
7.3. Mémoire dédiée et mémoire unifiée
Certains ordinateurs utilisent une architecture à mémoire unifiée dans laquelle le CPU et le GPU partagent une même réserve de mémoire.
Il ne faut donc pas appliquer mécaniquement les règles des GPU à VRAM dédiée à toutes les architectures.
8. Comprendre l’utilisation du CPU et du GPU
Le GPU peut accélérer certains calculs, mais il ne garantit pas automatiquement une meilleure vitesse dans toutes les situations.
Les performances dépendent notamment :
- De l’architecture du GPU.
- De la mémoire disponible.
- De la compatibilité des pilotes.
- Du moteur d’inférence.
- Du nombre de couches exécutées sur le GPU.
- Des transferts de données entre CPU et GPU.
8.1. Exécution CPU
Le modèle est principalement calculé par le processeur généraliste.
Cette configuration peut fonctionner sans carte graphique dédiée, mais elle peut être plus lente pour certains modèles.
8.2. Exécution GPU
Le modèle utilise les capacités de calcul du processeur graphique.
Les gains peuvent être importants si le moteur et le matériel sont adaptés.
8.3. Exécution hybride
Une partie du travail est réalisée sur le GPU et une autre sur le CPU.
Cette solution peut permettre d’utiliser un modèle trop volumineux pour la seule VRAM disponible, avec un compromis sur les performances.
9. Comprendre l’effet de la quantification
La quantification consiste à représenter les poids d’un modèle avec une précision numérique réduite.
Elle peut diminuer la taille des poids et les besoins mémoire.
9.1. Exemple conceptuel
| Format | Caractéristique générale |
|---|---|
| FP16 | Poids en précision 16 bits, avec des besoins mémoire relativement élevés. |
| Quantification 8 bits | Représentation plus compacte des poids. |
| Quantification 4 bits | Représentation encore plus compacte, avec des compromis possibles. |
9.2. Effets possibles
- Réduction de l’occupation mémoire.
- Possibilité d’utiliser un modèle plus volumineux.
- Modification des performances selon le matériel.
- Éventuelle dégradation de certaines réponses.
Une quantification plus agressive n’est pas systématiquement plus rapide. La vitesse dépend aussi de l’implémentation, du matériel et des opérations nécessaires pour exploiter les poids quantifiés.
10. Comprendre la taille du contexte
La fenêtre de contexte définit la quantité maximale de tokens que le modèle peut prendre en compte dans une requête, selon sa configuration et ses capacités.
Le contexte peut contenir :
- Les instructions système.
- Le message utilisateur.
- L’historique de conversation.
- Des documents ou extraits.
- Les autres éléments transmis au modèle.
10.1. Pourquoi le contexte consomme-t-il des ressources ?
Les modèles de type Transformer utilisent généralement des structures de mémoire, notamment un cache de clés et valeurs appelé KV cache.
Ce cache contribue à éviter de recalculer certaines informations pendant la génération.
Sa consommation mémoire dépend de l’architecture du modèle, de la longueur du contexte et de la précision utilisée.
10.2. Exemple
Une conversation de quelques messages courts peut demander moins de mémoire qu’une conversation contenant des dizaines de milliers de tokens.
10.3. Réduire le contexte
Pour limiter les ressources :
- Supprimer les messages inutiles.
- Éviter les documents redondants.
- Transmettre uniquement les passages nécessaires.
- Utiliser une fenêtre de contexte adaptée au besoin.
Réduire le contexte peut améliorer l’utilisation des ressources, mais peut également faire perdre des informations nécessaires à la réponse. Il faut trouver un équilibre.
11. Comprendre le nombre de tokens générés
Le nombre maximal de tokens de sortie peut être limité par un paramètre du moteur.
Dans l’API native d’Ollama, le paramètre num_predict permet de contrôler cette limite selon les conventions du logiciel.
11.1. Exemple
Cette requête limite le nombre de tokens que le modèle peut générer.
11.2. Intérêt
Limiter la sortie peut réduire le temps de génération lorsque le modèle aurait autrement produit une réponse plus longue.
11.3. Limite
Une valeur trop faible peut interrompre une réponse avant sa conclusion.
12. Surveiller les ressources sous Windows
Windows propose plusieurs outils intégrés pour observer les ressources utilisées par une IA locale.
12.1. Ouvrir le Gestionnaire des tâches
Utiliser le raccourci :
Ouvrir ensuite l’onglet Performances.
12.2. Observer le CPU
Consulter :
- Le pourcentage d’utilisation.
- La fréquence.
- Le nombre de processeurs logiques.
- L’évolution de la charge.
12.3. Observer la mémoire
Consulter :
- La mémoire utilisée.
- La mémoire disponible.
- La mémoire engagée.
- L’activité du système pendant la génération.
12.4. Observer le GPU
Si un GPU compatible est présent, consulter :
- L’activité du GPU.
- La mémoire GPU dédiée.
- La mémoire GPU partagée.
- Les moteurs de calcul disponibles dans l’outil.
Les indicateurs affichés dépendent du matériel et des pilotes.
12.5. Identifier le processus
Dans l’onglet Processus ou Détails, rechercher les processus liés au moteur d’inférence.
Selon le logiciel, le nom du processus peut différer du nom commercial de l’application.
13. Surveiller les ressources sous Linux
Linux propose plusieurs commandes pour observer les ressources système.
13.1. Consulter la mémoire
Cette commande affiche un résumé de la mémoire et de l’espace d’échange.
13.2. Consulter les processus
Elle permet d’observer la charge des processus et certaines statistiques système.
13.3. Utiliser htop
htop propose une interface interactive, mais n’est pas nécessairement installé par défaut.
13.4. Surveiller certains GPU NVIDIA
Lorsque les pilotes et le matériel sont compatibles, cette commande peut afficher notamment l’utilisation du GPU et de sa mémoire.
nvidia-smi est propre à l’écosystème NVIDIA compatible. D’autres GPU nécessitent d’autres outils de surveillance.
14. Observer les modèles chargés avec Ollama
Ollama permet de consulter les modèles actuellement chargés en mémoire.
14.1. Commande
14.2. Informations disponibles
Selon la version, la commande peut afficher :
- Le nom du modèle.
- La taille mémoire indiquée.
- La répartition du traitement entre CPU et GPU.
- Le délai avant déchargement.
14.3. Interprétation
Si un modèle utilise principalement le CPU alors qu’un GPU était attendu, il faut examiner la compatibilité matérielle, les ressources disponibles et la configuration du moteur.
14.4. Ne pas confondre deux commandes
| Commande | Fonction |
|---|---|
ollama list |
Liste les modèles présents localement. |
ollama ps |
Liste les modèles actuellement chargés. |
15. Libérer les ressources utilisées par Ollama
Un modèle peut rester chargé pendant un certain temps après une requête afin d’accélérer les appels suivants.
Ce fonctionnement améliore le confort, mais conserve une partie des ressources occupées.
15.1. Décharger un modèle
Cette commande demande l’arrêt de l’exécution du modèle indiqué et permet de libérer les ressources associées à son chargement.
15.2. Vérifier
Le modèle arrêté ne doit plus apparaître parmi les modèles chargés, une fois le déchargement effectué.
15.3. Différence avec la suppression
| Commande | Effet |
|---|---|
ollama stop |
Décharge un modèle en cours d’exécution. |
ollama rm |
Supprime un modèle de l’installation locale. |
Supprimer un modèle n’est pas nécessaire pour libérer sa mémoire d’exécution. La suppression concerne les fichiers du modèle et peut imposer un nouveau téléchargement si vous souhaitez le réutiliser.
16. Contrôler la durée de maintien en mémoire
L’API native d’Ollama propose un paramètre appelé keep_alive.
Il permet de préciser combien de temps un modèle doit rester chargé après une requête.
16.1. Exemple
Dans cet exemple, la durée demandée est de deux minutes.
16.2. Pourquoi modifier ce paramètre ?
Une durée plus longue peut limiter les rechargements fréquents.
Une durée plus courte peut libérer plus rapidement les ressources lorsque le modèle n’est plus utilisé.
16.3. Exemple de déchargement immédiat
Selon les conventions de l’API Ollama, une requête appropriée avec keep_alive à zéro peut servir à décharger un modèle.
17. Ajuster le contexte dans Ollama
Ollama permet de régler la longueur du contexte à l’aide de paramètres adaptés au mode d’utilisation.
17.1. Exemple par API native
num_ctx correspond à une taille de contexte demandée au moteur.
17.2. Effet attendu
Une taille plus faible peut réduire certains besoins mémoire.
Une taille plus élevée peut permettre de traiter davantage de tokens, mais peut accroître la consommation de ressources.
17.3. Limite
Le contexte réellement utilisable dépend également des capacités du modèle, du moteur et de la configuration.
18. Ajuster les paramètres dans LM Studio
LM Studio propose des réglages permettant d’adapter l’exécution du modèle au matériel disponible.
Les intitulés et les possibilités exactes dépendent de la version et du moteur utilisé.
18.1. Taille du contexte
Réduire le contexte lorsque les besoins ne justifient pas une fenêtre importante.
18.2. GPU offload
Ce réglage, lorsqu’il est disponible, permet de contrôler la quantité de couches ou de travail confiée au GPU.
Il peut être nécessaire de réduire l’offload si la VRAM est insuffisante.
18.3. Nombre de threads CPU
Certains moteurs permettent d’ajuster le nombre de threads utilisés.
Une valeur plus élevée ne garantit pas toujours une meilleure vitesse.
18.4. Taille du lot de traitement
Selon le moteur, des paramètres de batch peuvent influencer les performances de traitement du prompt et les besoins mémoire.
Modifier un seul paramètre à la fois, relancer le même test et noter les résultats. Sans protocole constant, il devient difficile de déterminer quel réglage a réellement amélioré les performances.
19. Comprendre les ralentissements thermiques
Les composants informatiques produisent de la chaleur lorsqu’ils travaillent.
Si la température atteint certaines limites, le matériel peut réduire automatiquement sa fréquence pour se protéger.
Ce mécanisme est appelé thermal throttling.
19.1. Symptômes possibles
- Performances correctes au début puis dégradation.
- Ventilation importante.
- Fréquences CPU ou GPU réduites.
- Vitesse de génération instable.
19.2. Mesures préventives
- Ne pas obstruer les aérations.
- Utiliser l’ordinateur sur une surface adaptée.
- Vérifier l’état du refroidissement.
- Éviter les charges simultanées inutiles.
- Surveiller les températures avec des outils compatibles.
Les températures acceptables dépendent des composants et des recommandations de leurs fabricants.
20. Comprendre l’effet de l’alimentation électrique
Les performances peuvent varier selon les réglages énergétiques de l’ordinateur.
20.1. Ordinateur portable
Sur batterie, certains appareils limitent les performances du CPU ou du GPU pour économiser l’énergie.
20.2. Mode économie d’énergie
Un profil énergétique restrictif peut réduire la puissance disponible pour l’inférence.
20.3. Bonnes pratiques
- Comparer les résultats dans des conditions d’alimentation identiques.
- Observer les paramètres énergétiques.
- Éviter de conclure qu’un modèle est lent à partir d’un seul test.
21. Optimiser sans changer de matériel
Avant d’envisager un nouvel équipement, plusieurs ajustements peuvent être testés.
| Action | Effet possible | Compromis |
|---|---|---|
| Fermer les applications inutiles | Libérer de la RAM et des ressources CPU/GPU. | Réduit le multitâche. |
| Choisir un modèle plus petit | Réduire la mémoire et les calculs. | Capacités potentiellement différentes. |
| Utiliser une quantification adaptée | Réduire la taille des poids. | Compromis possibles sur la qualité. |
| Réduire le contexte | Diminuer certains besoins mémoire. | Moins d’informations conservées. |
| Limiter les tokens de sortie | Réduire la durée des réponses longues. | Réponse potentiellement tronquée. |
| Décharger les modèles inutilisés | Libérer des ressources. | Rechargement lors de la prochaine utilisation. |
| Ajuster l’offload GPU | Mieux exploiter la VRAM disponible. | Gain dépendant du matériel. |
22. Construire un protocole de comparaison
Pour comparer deux configurations, il faut reproduire des conditions aussi proches que possible.
Préparer un prompt identique pour tous les essais.
Conserver le même modèle, le même contexte et les mêmes limites de génération, sauf pour le paramètre étudié.
Éviter les téléchargements et les applications gourmandes pendant le test.
Relever la durée, les tokens générés et les ressources utilisées.
Effectuer plusieurs essais pour limiter l’influence des variations ponctuelles.
Analyser les résultats et vérifier que la qualité reste suffisante.
23. Mesurer les performances avec l’API Ollama
L’API native d’Ollama peut retourner des statistiques de traitement, notamment des durées et des nombres de tokens.
23.1. Exemple de requête
23.2. Informations possibles
total_duration: durée totale.load_duration: durée de chargement.prompt_eval_count: nombre de tokens du prompt traités.prompt_eval_duration: durée d’évaluation du prompt.eval_count: nombre de tokens générés.eval_duration: durée de génération.
Dans l’API native Ollama, ces durées sont généralement exprimées en nanosecondes.
23.3. Calculer les tokens par seconde
La formule suppose une durée eval_duration strictement positive.
23.4. Exemple chiffré
Supposons :
La vitesse moyenne de génération est de 12 tokens par seconde.
24. Mesurer automatiquement avec PowerShell
Le script suivant effectue une requête auprès d’Ollama puis calcule une vitesse moyenne de génération.
Il suppose qu’Ollama est accessible sur son port habituel et que le modèle gemma3:1b est installé.
Ce calcul mesure la vitesse moyenne pendant la phase de génération, et non le temps total de la requête.
25. Étude de cas — Optimiser un ordinateur avec 16 Go de RAM
Une personne utilise un ordinateur disposant de :
- 16 Go de RAM.
- Un processeur généraliste récent.
- Aucun GPU dédié exploitable par le moteur.
- Un SSD.
- Ollama.
Elle constate qu’un modèle local répond lentement lorsque plusieurs applications sont ouvertes.
25.1. Observations
Les mesures fictives suivantes ont été relevées :
| Configuration | RAM utilisée | Vitesse |
|---|---|---|
| Modèle A, applications ouvertes | 15,2 Go | 4 tokens/s |
| Modèle A, applications fermées | 11,4 Go | 7 tokens/s |
| Modèle B plus petit, applications fermées | 8,1 Go | 16 tokens/s |
Ces valeurs sont des données pédagogiques fictives et ne constituent pas des performances garanties.
25.2. Questions
- Quel problème peut expliquer la lenteur initiale ?
- Pourquoi la fermeture des applications améliore-t-elle les performances ?
- Quel est le gain de vitesse entre les deux premiers essais ?
- Pourquoi le modèle B peut-il être plus rapide ?
- Le modèle B est-il nécessairement meilleur ?
- Quelles mesures faut-il réaliser avant de retenir une configuration ?
Afficher la correction détaillée
1. Problème initial
La RAM est fortement occupée. Le système peut subir une pression mémoire importante et recourir davantage à la pagination. Il faut vérifier cette hypothèse avec les indicateurs système.
2. Fermeture des applications
Elle libère de la mémoire et peut réduire la concurrence pour les ressources CPU et stockage.
3. Gain de vitesse
La vitesse passe de 4 à 7 tokens par seconde.
Le gain relatif est :
(7 − 4) ÷ 4 × 100 = 75 %.
4. Modèle B
Un modèle plus petit peut nécessiter moins de calculs et moins de mémoire. Cela peut expliquer sa vitesse supérieure.
5. Qualité
Non. Une vitesse plus élevée ne garantit pas une meilleure qualité de réponse. Les deux modèles doivent être évalués sur des tâches représentatives.
6. Mesures
Il faut notamment comparer les tokens par seconde, les temps de chargement, la consommation mémoire, la stabilité et la qualité des réponses, sur plusieurs essais.
26. Diagnostiquer les problèmes courants
| Symptôme | Cause possible | Action |
|---|---|---|
| Chargement très long | Modèle volumineux, stockage lent ou ressources limitées. | Mesurer le chargement et vérifier le stockage. |
| Génération lente | CPU saturé, modèle exigeant ou exécution hybride peu efficace. | Observer les ressources et comparer les configurations. |
| RAM presque saturée | Modèle trop volumineux ou applications concurrentes. | Libérer de la mémoire ou choisir un modèle adapté. |
| VRAM insuffisante | Poids et allocations trop volumineux. | Réduire l’offload, le contexte ou choisir une autre quantification. |
| Réponse initiale lente | Modèle non chargé ou prompt long. | Distinguer chargement et préremplissage. |
| Ralentissement progressif | Contexte croissant ou limitation thermique. | Mesurer le contexte et surveiller les températures. |
| Réponse tronquée | Limite de tokens de sortie. | Vérifier les paramètres de génération. |
| Application instable | Manque de mémoire ou problème logiciel. | Consulter les journaux et réduire la charge. |
| GPU peu utilisé | Offload limité ou incompatibilité. | Contrôler les pilotes, le moteur et la répartition CPU/GPU. |
27. Méthode complète d’optimisation
Relever le CPU, le GPU, la RAM, la VRAM et le stockage.
Noter son nom exact, sa taille, sa quantification et le moteur utilisé.
Relever le temps de chargement, les tokens par seconde et les ressources consommées.
Déterminer si le problème vient principalement de la mémoire, des calculs, du contexte ou d’une autre contrainte.
Tester un ajustement mesurable : contexte, quantification, modèle ou répartition CPU/GPU.
Comparer plusieurs essais dans des conditions similaires.
Confirmer que les réponses restent adaptées à l’utilisation prévue.
Conserver les réglages retenus et les résultats mesurés.
28. Fiche de suivi des performances
Utilisez cette fiche pour comparer vos essais.
29. Questions fréquentes
Pourquoi mon modèle est-il lent alors que mon ordinateur est récent ?
Les performances dépendent de la taille du modèle, de la mémoire, du moteur d’inférence et du matériel réellement utilisé. Un ordinateur récent n’est pas nécessairement optimisé pour les calculs d’IA.
Une carte graphique est-elle obligatoire ?
Non. De nombreux modèles peuvent fonctionner sur CPU, mais la vitesse et les besoins mémoire varient fortement selon leur taille et leur configuration.
Pourquoi un modèle occupe-t-il plus de mémoire que la taille de son fichier ?
L’exécution nécessite aussi des buffers, des structures internes et éventuellement un cache de contexte. La taille du fichier ne représente donc pas l’ensemble des besoins mémoire.
Pourquoi la première réponse est-elle plus lente ?
Le moteur peut devoir charger les poids du modèle et préparer les ressources nécessaires. Les requêtes suivantes peuvent être plus rapides si le modèle reste chargé.
La quantification 4 bits est-elle toujours plus rapide ?
Non. Elle réduit généralement la taille des poids, mais la vitesse dépend du matériel, du moteur et des opérations utilisées.
Une fenêtre de contexte plus grande améliore-t-elle toujours les réponses ?
Non. Elle permet de transmettre davantage de tokens, mais peut augmenter la consommation mémoire et le temps de traitement. La pertinence des informations reste essentielle.
Comment libérer la mémoire occupée par Ollama ?
La commande ollama stop nom-du-modele permet de demander le déchargement d’un modèle. La commande ollama ps permet de consulter les modèles chargés.
Pourquoi le GPU n’est-il pas utilisé à 100 % ?
La charge peut dépendre d’autres facteurs : mémoire, transferts CPU/GPU, taille du modèle, moteur utilisé ou phases de traitement. Une utilisation inférieure à 100 % n’indique pas nécessairement une anomalie.
Comment savoir si un modèle est adapté à mon ordinateur ?
Il faut vérifier ses besoins mémoire, sa compatibilité, sa stabilité, sa vitesse et la qualité des réponses sur des tâches représentatives.
Faut-il toujours chercher le maximum de tokens par seconde ?
Non. Le bon objectif est d’obtenir des réponses suffisamment rapides, fiables et adaptées aux besoins, tout en conservant un système stable.
À retenir
- Les performances d’une IA locale dépendent du modèle, du moteur et du matériel.
- Le CPU et le GPU assurent les calculs, tandis que la RAM et la VRAM accueillent les données nécessaires.
- La taille du fichier du modèle ne représente pas toute la mémoire requise.
- Il faut distinguer chargement, traitement du prompt et génération.
- Les tokens par seconde mesurent une vitesse moyenne de génération.
- Une forte pression mémoire peut entraîner des ralentissements importants.
- La quantification réduit généralement la taille des poids, mais ne garantit pas un gain de vitesse.
- Un contexte plus long peut augmenter les besoins mémoire.
- Une exécution CPU/GPU hybride permet parfois d’utiliser des modèles plus volumineux.
- Le Gestionnaire des tâches et les outils Linux permettent de surveiller les ressources.
ollama psaffiche les modèles chargés.ollama stoppermet de décharger un modèle sans le supprimer.keep_alivepermet de gérer la durée de maintien en mémoire.num_ctxpermet d’ajuster la taille du contexte dans les configurations compatibles d’Ollama.- Les limitations thermiques et énergétiques peuvent affecter les performances.
- Une comparaison fiable nécessite un protocole reproductible.
- Il faut modifier un seul paramètre à la fois.
- La meilleure configuration est celle qui équilibre vitesse, qualité, mémoire et stabilité.
Question 1 : Quelle différence existe-t-il entre RAM et VRAM ?
Voir la réponse
Question 2 : Un modèle génère 600 tokens en 50 secondes. Quelle est sa vitesse moyenne ?
Voir la réponse
Question 3 : Pourquoi un modèle de 4 Go peut-il nécessiter plus de 4 Go de mémoire pour fonctionner ?
Voir la réponse
Question 4 : Pourquoi une quantification plus forte n’est-elle pas systématiquement plus rapide ?
Voir la réponse
Question 5 : Quelle commande permet de consulter les modèles chargés dans Ollama ?
Voir la réponse
ollama ps.Question 6 : Pourquoi réduire le contexte peut-il améliorer l’utilisation des ressources ?
Voir la réponse
Question 7 : Pourquoi faut-il comparer plusieurs essais dans des conditions similaires ?
Voir la réponse
Question 8 : Pourquoi le modèle le plus rapide n’est-il pas toujours le meilleur choix ?
Voir la réponse
Découvrez les risques liés aux modèles et aux interfaces locales, la protection des fichiers, les accès réseau, les journaux et les bonnes pratiques de confidentialité.
