Intelligence artificielle · Chapitre 36 · Cours 12

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.
Prérequis

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.
Exemple concret

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.

CHARGEMENT DU MODÈLE | v TRAITEMENT DU PROMPT (PREFILL) | v GÉNÉRATION DES TOKENS (DECODE) | v RÉPONSE FINALE
Distinction importante

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

Vitesse de génération = Nombre de tokens générés ÷ Durée de génération en secondes

4.2. Exemple

Un modèle génère 480 tokens en 40 secondes.

480 ÷ 40 = 12 tokens/seconde

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

MesureCe 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.
Attention

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

FormatCaracté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.
Nuance essentielle

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.
Attention

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

{ « model »: « gemma3:1b », « prompt »: « Explique ce qu’est un pare-feu. », « stream »: false, « options »: { « num_predict »: 120 } }

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 :

Ctrl + Maj + Échap

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

free -h

Cette commande affiche un résumé de la mémoire et de l’espace d’échange.

13.2. Consulter les processus

top

Elle permet d’observer la charge des processus et certaines statistiques système.

13.3. Utiliser htop

htop

htop propose une interface interactive, mais n’est pas nécessairement installé par défaut.

13.4. Surveiller certains GPU NVIDIA

nvidia-smi

Lorsque les pilotes et le matériel sont compatibles, cette commande peut afficher notamment l’utilisation du GPU et de sa mémoire.

Important

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

ollama ps

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

CommandeFonction
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

ollama stop gemma3:1b

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

ollama ps

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

CommandeEffet
ollama stop Décharge un modèle en cours d’exécution.
ollama rm Supprime un modèle de l’installation locale.
Attention

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

{ « model »: « gemma3:1b », « prompt »: « Bonjour. », « stream »: false, « keep_alive »: « 2m » }

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

{ « model »: « gemma3:1b », « keep_alive »: 0 }

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

{ « model »: « gemma3:1b », « prompt »: « Résume ce texte en cinq lignes. », « stream »: false, « options »: { « num_ctx »: 2048 } }

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.

Méthode recommandée

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.

ActionEffet possibleCompromis
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.

1
Choisir une tâche

Préparer un prompt identique pour tous les essais.

2
Fixer les paramètres

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é.

3
Stabiliser l’environnement

Éviter les téléchargements et les applications gourmandes pendant le test.

4
Mesurer

Relever la durée, les tokens générés et les ressources utilisées.

5
Répéter

Effectuer plusieurs essais pour limiter l’influence des variations ponctuelles.

6
Comparer

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

{ « model »: « gemma3:1b », « prompt »: « Explique le fonctionnement d’un routeur. », « stream »: false }

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

Tokens/seconde = eval_count × 1 000 000 000 ÷ eval_duration

La formule suppose une durée eval_duration strictement positive.

23.4. Exemple chiffré

Supposons :

eval_count = 360 eval_duration = 30 000 000 000 ns 360 × 1 000 000 000 ÷ 30 000 000 000 = 12 tokens/seconde

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é.

$body = @{ model = « gemma3:1b » prompt = « Explique le rôle d’un routeur. » stream = $false } | ConvertTo-Json $result = Invoke-RestMethod ` -Uri « http://localhost:11434/api/generate » ` -Method Post ` -ContentType « application/json; charset=utf-8 » ` -Body $body if ($result.eval_duration -gt 0) { $vitesse = ( $result.eval_count * 1000000000 ) / $result.eval_duration « Tokens générés : $($result.eval_count) » « Vitesse : $([math]::Round($vitesse, 2)) tokens/s » } else { « Mesure indisponible. » }

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 :

ConfigurationRAM utiliséeVitesse
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

  1. Quel problème peut expliquer la lenteur initiale ?
  2. Pourquoi la fermeture des applications améliore-t-elle les performances ?
  3. Quel est le gain de vitesse entre les deux premiers essais ?
  4. Pourquoi le modèle B peut-il être plus rapide ?
  5. Le modèle B est-il nécessairement meilleur ?
  6. 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ômeCause possibleAction
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

1
Identifier le matériel

Relever le CPU, le GPU, la RAM, la VRAM et le stockage.

2
Identifier le modèle

Noter son nom exact, sa taille, sa quantification et le moteur utilisé.

3
Mesurer la configuration initiale

Relever le temps de chargement, les tokens par seconde et les ressources consommées.

4
Identifier le facteur limitant

Déterminer si le problème vient principalement de la mémoire, des calculs, du contexte ou d’une autre contrainte.

5
Modifier un seul paramètre

Tester un ajustement mesurable : contexte, quantification, modèle ou répartition CPU/GPU.

6
Répéter les mesures

Comparer plusieurs essais dans des conditions similaires.

7
Vérifier la qualité

Confirmer que les réponses restent adaptées à l’utilisation prévue.

8
Documenter la configuration

Conserver les réglages retenus et les résultats mesurés.

28. Fiche de suivi des performances

Utilisez cette fiche pour comparer vos essais.

SYSTÈME Système d’exploitation : CPU : GPU : RAM totale : VRAM disponible : Stockage : MODÈLE Nom : Version : Quantification : Taille du fichier : Moteur : Mode CPU / GPU / hybride : PARAMÈTRES Taille du contexte : Limite de génération : Nombre de threads : Offload GPU : Autres paramètres : MESURES Temps de chargement : Temps de préremplissage : Temps de génération : Tokens générés : Tokens/seconde : RAM utilisée : VRAM utilisée : Température observée : ÉVALUATION Qualité satisfaisante : Oui / Non Stabilité : Oui / Non Ralentissements observés : Modification testée : Résultat : Configuration retenue :

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 ps affiche les modèles chargés.
  • ollama stop permet de décharger un modèle sans le supprimer.
  • keep_alive permet de gérer la durée de maintien en mémoire.
  • num_ctx permet 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é.
Vérifiez votre compréhension

Question 1 : Quelle différence existe-t-il entre RAM et VRAM ?

Voir la réponse
La RAM est la mémoire vive principale du système. La VRAM est la mémoire graphique dédiée utilisée par certains GPU. Certaines architectures utilisent toutefois une mémoire unifiée.

Question 2 : Un modèle génère 600 tokens en 50 secondes. Quelle est sa vitesse moyenne ?

Voir la réponse
600 ÷ 50 = 12 tokens par seconde.

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
Parce que l’exécution nécessite aussi des buffers, des structures internes et éventuellement un cache de contexte.

Question 4 : Pourquoi une quantification plus forte n’est-elle pas systématiquement plus rapide ?

Voir la réponse
Parce que la vitesse dépend du matériel, du moteur et des opérations nécessaires pour exploiter les poids quantifiés.

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
Parce qu’un contexte plus court peut diminuer la quantité de données à traiter et les besoins du cache d’attention.

Question 7 : Pourquoi faut-il comparer plusieurs essais dans des conditions similaires ?

Voir la réponse
Pour limiter l’influence des variations ponctuelles et identifier l’effet réel d’un paramètre.

Question 8 : Pourquoi le modèle le plus rapide n’est-il pas toujours le meilleur choix ?

Voir la réponse
Parce qu’il faut également considérer la qualité des réponses, la stabilité et l’adéquation aux besoins.
À suivre — Cours 13 Protéger les données locales →

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é.