Llama.cpp - Historique des versions

Admin : /* Benchmark multi-GPU */

2026-06-22T15:27:08Z

Benchmark multi-GPU

← Version précédente		Version du 22 juin 2026 à 15:27
Ligne 665 :		Ligne 665 :
	=== Benchmark multi-GPU ===		=== Benchmark multi-GPU ===

	Tester les performances avec `llama-bench` :		Tester les performances avec <code>llama-bench</code> :

	# /opt/llama.cpp/build/bin/llama-bench \		# /opt/llama.cpp/build/bin/llama-bench \

Admin : /* Vérifier l'utilisation mémoire */

2026-06-22T15:26:50Z

Vérifier l'utilisation mémoire

← Version précédente		Version du 22 juin 2026 à 15:26
Ligne 510 :		Ligne 510 :
	Si une carte arrive en manque de mémoire, il faut réduire la charge :		Si une carte arrive en manque de mémoire, il faut réduire la charge :

	* diminuer `-c` ;		* diminuer <code>-c</code> ;
	* diminuer `-b` ;		* diminuer <code>-b</code> ;
	* diminuer `-ub` ;		* diminuer <code>-ub</code> ;
	* ajuster `--tensor-split` ;		* ajuster <code>--tensor-split</code> ;
	* réduire `-ngl` ;		* réduire <code>-ngl</code> ;
	* utiliser un quant plus léger.		* utiliser un quant plus léger.

Admin : /* Sélectionner les GPU visibles */

2026-06-22T15:26:13Z

Sélectionner les GPU visibles

← Version précédente		Version du 22 juin 2026 à 15:26
Ligne 464 :		Ligne 464 :
	=== Sélectionner les GPU visibles ===		=== Sélectionner les GPU visibles ===

	Pour limiter llama.cpp à certaines cartes NVIDIA, il est possible d'utiliser `CUDA_VISIBLE_DEVICES`.		Pour limiter llama.cpp à certaines cartes NVIDIA, il est possible d'utiliser <code>CUDA_VISIBLE_DEVICES</code>.

	Exemple pour n'utiliser que les GPU 1 et 2 :		Exemple pour n'utiliser que les GPU 1 et 2 :

Admin : /* Choisir le GPU principal */

2026-06-22T15:26:00Z

Choisir le GPU principal

← Version précédente		Version du 22 juin 2026 à 15:26
Ligne 449 :		Ligne 449 :
	=== Choisir le GPU principal ===		=== Choisir le GPU principal ===

	Le paramètre `--main-gpu` permet de choisir le GPU principal.		Le paramètre <code>--main-gpu</code> permet de choisir le GPU principal.

	Exemple avec le GPU 0 comme carte principale :		Exemple avec le GPU 0 comme carte principale :

Admin : /* Répartition manuelle avec tensor-split */

2026-06-22T15:25:48Z

Répartition manuelle avec tensor-split

← Version précédente		Version du 22 juin 2026 à 15:25
Ligne 421 :		Ligne 421 :
	=== Répartition manuelle avec tensor-split ===		=== Répartition manuelle avec tensor-split ===

	Par défaut, llama.cpp peut répartir les couches de manière automatique. En cas de GPU avec des quantités de VRAM différentes, ou si une carte tombe en OOM, il peut être nécessaire d'utiliser `--tensor-split`.		Par défaut, llama.cpp peut répartir les couches de manière automatique. En cas de GPU avec des quantités de VRAM différentes, ou si une carte tombe en OOM, il peut être nécessaire d'utiliser <code>--tensor-split</code>.

	Exemple avec deux GPU de 12 Go :		Exemple avec deux GPU de 12 Go :
Ligne 439 :		Ligne 439 :
	--tensor-split 24,12		--tensor-split 24,12

	Les valeurs de `--tensor-split` sont des proportions. Il n'est pas obligatoire d'indiquer exactement la VRAM en Go, mais c'est une méthode simple pour garder une répartition logique.		Les valeurs de <code>--tensor-split</code> sont des proportions. Il n'est pas obligatoire d'indiquer exactement la VRAM en Go, mais c'est une méthode simple pour garder une répartition logique.

	Ainsi, ces deux exemples sont équivalents dans l'idée :		Ainsi, ces deux exemples sont équivalents dans l'idée :

Admin : /* Exemple simple avec deux GPU */

2026-06-22T15:25:21Z

Exemple simple avec deux GPU

← Version précédente		Version du 22 juin 2026 à 15:25
Ligne 417 :		Ligne 417 :
	--split-mode layer		--split-mode layer

	Avec `-ngl 999`, llama.cpp tente de charger le maximum de couches possible sur les GPU.		Avec <code>-ngl 999</code>, llama.cpp tente de charger le maximum de couches possible sur les GPU.

	=== Répartition manuelle avec tensor-split ===		=== Répartition manuelle avec tensor-split ===

Admin : /* Split mode */

2026-06-22T15:25:03Z

Split mode

← Version précédente		Version du 22 juin 2026 à 15:25
Ligne 386 :		Ligne 386 :
	=== Split mode ===		=== Split mode ===

	Le paramètre `--split-mode` contrôle la façon dont llama.cpp répartit le modèle entre plusieurs GPU.		Le paramètre <code>--split-mode</code> contrôle la façon dont llama.cpp répartit le modèle entre plusieurs GPU.

	{\| class="wikitable"		{\| class="wikitable"
Ligne 393 :		Ligne 393 :
	! Usage conseillé		! Usage conseillé
	\|-		\|-
	\| `none`		\| <code>none</code>
	\| Pas de répartition multi-GPU.		\| Pas de répartition multi-GPU.
	\| À utiliser si un seul GPU doit être utilisé.		\| À utiliser si un seul GPU doit être utilisé.
	\|-		\|-
	\| `layer`		\| <code>layer</code>
	\| Répartit les couches du modèle entre les GPU.		\| Répartit les couches du modèle entre les GPU.
	\| Mode classique et généralement le plus simple.		\| Mode classique et généralement le plus simple.
	\|-		\|-
	\| `row`		\| <code>row</code>
	\| Répartit certains tenseurs entre les GPU.		\| Répartit certains tenseurs entre les GPU.
	\| Plus spécifique, à tester selon le modèle et le matériel.		\| Plus spécifique, à tester selon le modèle et le matériel.
	\|}		\|}

	En pratique, le mode `layer` est souvent le plus simple pour commencer.		En pratique, le mode <code>layer</code> est souvent le plus simple pour commencer.

	=== Exemple simple avec deux GPU ===		=== Exemple simple avec deux GPU ===

Admin : /* Options principales */

2026-06-22T15:24:28Z

Options principales

← Version précédente		Version du 22 juin 2026 à 15:24
Ligne 371 :		Ligne 371 :
	! Description		! Description
	\|-		\|-
	\| `-ngl` ou `--gpu-layers`		\| <code>-ngl</code> ou <code>--gpu-layers</code>
	\| Nombre de couches du modèle à envoyer sur GPU.		\| Nombre de couches du modèle à envoyer sur GPU.
	\|-		\|-
	\| `--split-mode`		\| <code>--split-mode</code>
	\| Méthode de répartition du modèle entre plusieurs GPU.		\| Méthode de répartition du modèle entre plusieurs GPU.
	\|-		\|-
	\| `--tensor-split`		\| <code>--tensor-split</code>
	\| Répartition manuelle de la charge entre les GPU.		\| Répartition manuelle de la charge entre les GPU.
	\|-		\|-
	\| `--main-gpu`		\| <code>--main-gpu</code>
	\| GPU principal utilisé notamment pour certaines allocations et opérations.		\| GPU principal utilisé notamment pour certaines allocations et opérations.
	\|}		\|}

Admin : /* Optimisation (KV cache, performances, latence) */

2026-06-22T15:23:27Z

Optimisation (KV cache, performances, latence)

← Version précédente		Version du 22 juin 2026 à 15:23
Ligne 262 :		Ligne 262 :

	== Optimisation (KV cache, performances, latence) ==		== Optimisation (KV cache, performances, latence) ==
	* Le paramètre de contexte (`-c`) influence directement la quantité de mémoire utilisée par le KV cache. Plus il est élevé, plus la consommation de VRAM augmente, ainsi que la latence de traitement du prompt.		* Le paramètre de contexte (<code>-c</code>) influence directement la quantité de mémoire utilisée par le KV cache. Plus il est élevé, plus la consommation de VRAM augmente, ainsi que la latence de traitement du prompt.
	* En pratique, une valeur de `2048` constitue souvent un bon compromis sur un GPU de 12 Go. Augmenter à `4096` peut améliorer la mémoire conversationnelle, mais au prix d’une consommation de VRAM plus importante.		* En pratique, une valeur de <code>2048</code> constitue souvent un bon compromis sur un GPU de 12 Go. Augmenter à <code>4096</code> peut améliorer la mémoire conversationnelle, mais au prix d’une consommation de VRAM plus importante.
	* Le paramètre `-ngl` détermine le nombre de couches envoyées au GPU.		* Le paramètre <code>-ngl</code> détermine le nombre de couches envoyées au GPU.
	** Plus la valeur est élevée, plus les performances augmentent.		** Plus la valeur est élevée, plus les performances augmentent.
	** Si la VRAM est insuffisante, réduire cette valeur permet de déporter une partie du modèle sur CPU.		** Si la VRAM est insuffisante, réduire cette valeur permet de déporter une partie du modèle sur CPU.
	** Il est possible d’utiliser `-ngl 999` afin de laisser llama.cpp charger automatiquement le maximum de couches possible sur le GPU.		** Il est possible d’utiliser <code>-ngl 999</code> afin de laisser llama.cpp charger automatiquement le maximum de couches possible sur le GPU.
	* Le paramètre `-fa` active Flash Attention.		* Le paramètre <code>-fa</code> active Flash Attention.
	** Cette option améliore généralement les performances de traitement du prompt et réduit légèrement la latence.		** Cette option améliore généralement les performances de traitement du prompt et réduit légèrement la latence.
	** Elle est recommandée sur GPU NVIDIA récents.		** Elle est recommandée sur GPU NVIDIA récents.
	* Le paramètre `-b` (batch size) influence la vitesse de traitement du prompt.		* Le paramètre <code>-b</code> (batch size) influence la vitesse de traitement du prompt.
	** Une valeur plus élevée peut améliorer les performances, mais augmente également la consommation de mémoire.		** Une valeur plus élevée peut améliorer les performances, mais augmente également la consommation de mémoire.
	** En cas de manque de VRAM, réduire cette valeur peut stabiliser le serveur.		** En cas de manque de VRAM, réduire cette valeur peut stabiliser le serveur.
	* Le paramètre `-ub` (micro-batch size) permet d’ajuster plus finement l’utilisation mémoire.		* Le paramètre <code>-ub</code> (micro-batch size) permet d’ajuster plus finement l’utilisation mémoire.
	** Une valeur plus faible réduit les pics de consommation mémoire.		** Une valeur plus faible réduit les pics de consommation mémoire.
	** Une valeur plus élevée peut améliorer légèrement les performances si la VRAM le permet.		** Une valeur plus élevée peut améliorer légèrement les performances si la VRAM le permet.
	* Le paramètre `-np` (n_parallel) détermine le nombre de requêtes pouvant être traitées en parallèle.		* Le paramètre <code>-np</code> (n_parallel) détermine le nombre de requêtes pouvant être traitées en parallèle.
	** Une valeur élevée augmente la consommation de VRAM.		** Une valeur élevée augmente la consommation de VRAM.
	** Pour un usage personnel ou mono-utilisateur, `-np 1` est généralement recommandé.		** Pour un usage personnel ou mono-utilisateur, <code>-np 1</code> est généralement recommandé.
	** Des valeurs supérieures sont surtout utiles pour une API ou un usage multi-utilisateurs.		** Des valeurs supérieures sont surtout utiles pour une API ou un usage multi-utilisateurs.

	* Pour les modèles multimodaux / vision, le fichier `mmproj` sert à projeter les données image vers le modèle texte.		* Pour les modèles multimodaux / vision, le fichier <code>mmproj</code> sert à projeter les données image vers le modèle texte.
	** Par défaut, les versions récentes de llama.cpp peuvent décharger ce projecteur multimodal sur le GPU.		** Par défaut, les versions récentes de llama.cpp peuvent décharger ce projecteur multimodal sur le GPU.
	** Cela améliore généralement la vitesse d’analyse des images, mais consomme un peu plus de VRAM.		** Cela améliore généralement la vitesse d’analyse des images, mais consomme un peu plus de VRAM.
	** Si la VRAM est limitée, il est possible de forcer le `mmproj` à rester sur CPU avec :		** Si la VRAM est limitée, il est possible de forcer le <code>mmproj</code> à rester sur CPU avec :

	# --no-mmproj-offload		# --no-mmproj-offload
Ligne 297 :		Ligne 297 :
	-ngl 999		-ngl 999

	** Si aucune option `--mmproj` n’est utilisée, `--no-mmproj-offload` n’a pas d’intérêt.		** Si aucune option <code>--mmproj</code> n’est utilisée, <code>--no-mmproj-offload</code> n’a pas d’intérêt.
	** En pratique :		** En pratique :
	*** VRAM suffisante : laisser le comportement par défaut, avec le `mmproj` sur GPU.		*** VRAM suffisante : laisser le comportement par défaut, avec le <code>mmproj</code> sur GPU.
	*** VRAM limitée : tester `--no-mmproj-offload` pour économiser de la VRAM, au prix d’une analyse d’image potentiellement plus lente.		*** VRAM limitée : tester <code>--no-mmproj-offload</code> pour économiser de la VRAM, au prix d’une analyse d’image potentiellement plus lente.

	Exemple de configuration optimisée pour un GPU de 12 Go :		Exemple de configuration optimisée pour un GPU de 12 Go :
	# /opt/llama.cpp/build/bin/llama-server \		# /opt/llama.cpp/build/bin/llama-server \
	-m /opt/llama.cpp/models/<font color = blue>models--HauhauCS--Qwen3.5-9B-Uncensored-HauhauCS-Aggressive/snapshots/1234567890abcdef1234567890abcdef12345678/Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf</font> \		-m /opt/llama.cpp/models/<font color=blue>models--HauhauCS--Qwen3.5-9B-Uncensored-HauhauCS-Aggressive/snapshots/1234567890abcdef1234567890abcdef12345678/Qwen3.5-9B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf</font> \
	-c 2048 \		-c 2048 \
	-ngl 999 \		-ngl 999 \
Ligne 322 :		Ligne 322 :
	-np : nombre de requêtes traitées en parallèle		-np : nombre de requêtes traitées en parallèle

	* Si le serveur démarre correctement et qu’il reste de la marge en VRAM, il est possible d’augmenter progressivement `-b` ou le contexte.		* Si le serveur démarre correctement et qu’il reste de la marge en VRAM, il est possible d’augmenter progressivement <code>-b</code> ou le contexte.
	* En cas d’erreur mémoire ou de performances instables :		* En cas d’erreur mémoire ou de performances instables :
	** réduire `-b`		** réduire <code>-b</code>
	** réduire `-ngl`		** réduire <code>-ngl</code>
	** réduire `-c`		** réduire <code>-c</code>

	=== Méthode d’ajustement recommandée ===		=== Méthode d’ajustement recommandée ===
	* Commencer avec :		* Commencer avec :
	** `-c 2048`		** <code>-c 2048</code>
	** `-ngl 999`		** <code>-ngl 999</code>
	** `-fa on`		** <code>-fa on</code>
	** `-b 512`		** <code>-b 512</code>
	** `-ub 256`		** <code>-ub 256</code>
	** `-np 1`		** <code>-np 1</code>
	* Vérifier ensuite l’utilisation mémoire :		* Vérifier ensuite l’utilisation mémoire :
	# nvidia-smi		# nvidia-smi
	* Si la VRAM est presque saturée :		* Si la VRAM est presque saturée :
	** réduire `-b`		** réduire <code>-b</code>
	** puis `-ub`		** puis <code>-ub</code>
	** puis réduire `-ngl` si nécessaire		** puis réduire <code>-ngl</code> si nécessaire
	* Si au contraire une marge importante reste disponible :		* Si au contraire une marge importante reste disponible :
	** essayer `-b 1024`		** essayer <code>-b 1024</code>
	** ou augmenter légèrement le contexte		** ou augmenter légèrement le contexte

Admin : /* Mode serveur (API compatible OpenAI) */

2026-06-22T15:22:02Z

Mode serveur (API compatible OpenAI)

← Version précédente		Version du 22 juin 2026 à 15:22
Ligne 181 :		Ligne 181 :
	\| niveau = information		\| niveau = information
	\| icône = loupe		\| icône = loupe
	\| texte = Le dossier `snapshots/<hash>` dépend du téléchargement Hugging Face et varie selon les versions. Il est recommandé de créer un lien symbolique vers le fichier `.gguf` pour simplifier son utilisation.		\| texte = Le dossier <code>snapshots/<hash></code> dépend du téléchargement Hugging Face et varie selon les versions. Il est recommandé de créer un lien symbolique vers le fichier <code>.gguf</code> pour simplifier son utilisation.
	}}		}}
	Le serveur est accessible via :		Le serveur est accessible via :

Llama.cpp - Historique des versions

Admin : /* Benchmark multi-GPU */

Admin : /* Vérifier l'utilisation mémoire */

Admin : /* Sélectionner les GPU visibles */

Admin : /* Choisir le GPU principal */

Admin : /* Répartition manuelle avec tensor-split */

Admin : /* Exemple simple avec deux GPU */

Admin : /* Split mode */

Admin : /* Options principales */

Admin : /* Optimisation (KV cache, performances, latence) */

Admin : /* Mode serveur (API compatible OpenAI) */