Modèles de langages sur serveur nu · Primcast LLC · depuis 2004

Le modèle détermine la mémoire. Rien d'autre sur le bon de commande n'a d'incidence.

Les visiteurs arrivent sur cette page en pensant que le choix se résume à trouver l'accélérateur le plus rapide. Ce n'est pas le cas. Les poids des données tiennent dans la mémoire de la carte ou non ; une carte avec deux gigaoctets de moins ne sera pas plus lente, elle ne pourra tout simplement pas se charger. Cette page suit donc l'ordre réel du processus de décision : la taille du modèle, la précision d'exécution, l'espace nécessaire pour la communication, et enfin, la carte la plus adaptée. Les prix sont affichés sur la page suivante, intentionnellement.

Quelle carte gère mon modèle Ce que j'y installe

Un seul utilisateur par machine. La carte est transmise à votre système d'exploitation, et vous pouvez choisir et définir les versions de l'environnement d'exécution, du pilote et du framework.

Étape 1

Le poids réel des poids.

Le calcul se résume au produit des paramètres par leur taille en octets. Un poids sur 16 bits occupe deux octets, sur 8 bits un octet et sur 4 bits un demi-octet. Un modèle à sept milliards de paramètres sur 16 bits représente 14 gigaoctets de poids ; le même modèle sur 4 bits en occupe entre trois et quatre.

La quantification permet à une machine incapable de contenir un modèle d'en devenir capable. Elle a un coût en termes de qualité, et ce coût dépend bien plus du modèle et de la méthode que du seul nombre de bits. Un modèle 4 bits bien quantifié est généralement plus proche de sa pleine précision qu'on ne le pense, tandis qu'un modèle 8 bits mal quantifié peut être pire. Si la précision est l'objectif, testez les deux versions avant de choisir le matériel ; il est moins coûteux de détecter la différence maintenant qu'après la livraison.

Ces chiffres correspondent aux poids, et rien d'autre. Ils représentent le minimum, pas l'exigence. La section suivante est celle qui induit souvent en erreur.

Weights only — the runtime, the activations and the conversation are extra, and are the subject of the next section.
Model16-bit8-bit4-bit
7-8 billion parameters16 GB8 GB5 GB
13-14 billion parameters28 GB14 GB8 GB
30-34 billion parameters68 GB34 GB19 GB
70 billion parameters140 GB70 GB38 GB

Étape deux

Pourquoi un modèle qui convient ne sera pas forcément utile.

Voici l'erreur la plus fréquente lors de l'achat d'une carte graphique, et elle se produit toujours de la même manière : quelqu'un lit que son modèle a une capacité de trente-huit gigaoctets, achète une carte de quarante gigaoctets, l'installe avec succès, et découvre ensuite qu'elle peut contenir à peu près une courte conversation.

  • La durée d'exécution y est également indiquée.

    Le chargement d'un modèle n'est pas la seule chose qui occupe la carte. L'environnement d'exécution lui-même, ses tampons et les activations de tout ce qui est calculé résident tous dans la même mémoire que les poids.

  • La conversation est là, et elle prend de l'ampleur.

    Chaque jeton déjà utilisé dans une conversation laisse une trace dans le cache clé-valeur afin d'éviter son recalcul. Ce cache s'agrandit avec la longueur du contexte et à chaque requête simultanée. Un contexte long ou un point de terminaison très sollicité peuvent nécessiter autant de mémoire qu'un modèle simple.

  • Donc : un quart à la moitié à nouveau

    Prévoyez au moins un quart de mémoire supplémentaire par rapport aux poids, et encore la moitié si le contexte est long ou si le terminal est occupé. C'est la règle que le tableau de la section suivante applique : chaque carte qu'il mentionne contient une capacité une fois et demie supérieure aux poids.

  • Et si la différence est minime, signalez-le avant d'acheter.

    Indiquez-nous le modèle, la quantification, la longueur du contexte souhaitée et le nombre approximatif de requêtes simultanées. Nous préférons vous convaincre d'opter pour une carte plus performante dès maintenant, ou un modèle moins performant, plutôt que de recevoir une commande qui s'avère décevante dès la première semaine et qui donne lieu à une demande de remboursement.

Étape trois

Quelle carte fonctionne avec quel modèle ?

Consultez la section correspondant à la taille de votre modèle et la section horizontale correspondant à la précision souhaitée. Chaque case indique la plus petite carte compatible avec ces poids, avec suffisamment d'espace pour d'autres pièces, et renvoie à la machine correspondante. Si le catalogue ne propose pas de solution adaptée, la case le précise.

The smallest card we fit that holds the weights with room left to serve — that is 1.5× the weights, the generous end of the quarter-to-a-half head-room rule below. No prices here on purpose: GPU dedicated servers holds every one.
If you want to runat 16-bitat 8-bitat 4-bit
7-8 billion parametersTESLA P40 / QUADRO P600024 GB16 GB of weightsTITAN V12 GB HBM28 GB of weightsTESLA P48 GB GDDR55 GB of weights
13-14 billion parametersRTX A600048 GB GDDR6 ECC28 GB of weightsTESLA P40 / QUADRO P600024 GB14 GB of weightsTITAN V12 GB HBM28 GB of weights
30-34 billion parametersMore than one cardNothing we fit holds it alone68 GB of weightsInstinct MI21064 GB HBM2e34 GB of weightsTesla V100 32GB32 GB HBM219 GB of weights
70 billion parametersMore than one cardNothing we fit holds it alone140 GB of weightsMore than one cardNothing we fit holds it alone70 GB of weightsInstinct MI21064 GB HBM2e38 GB of weights

Trois choses que le tableau ne peut pas vous dire

  • La carte la plus petite compatible n'est pas toujours celle qu'il vous faut. La mémoire détermine le bon fonctionnement d'un modèle ; les autres caractéristiques de la carte influent sur sa vitesse d'exécution et le nombre de personnes qu'elle peut gérer simultanément. Le tableau privilégie la mémoire, car c'est une contrainte majeure, tandis que le débit est une préférence. Si le débit prime sur le budget, choisissez une carte plus performante dans la liste ci-dessous.
  • Les cartes plus anciennes ne prennent pas en charge les nouveaux formats numériques. Plusieurs composants de notre catalogue sont antérieurs à FP8 et bfloat16 ; par conséquent, un environnement d'exécution qui les requiert utilisera un format moins performant, voire refusera la commande. Il est donc important de poser cette question avant de passer commande. Nous répondrons à cette question pour chaque carte et chaque environnement d'exécution, et non de manière générale.
  • Une carte AMD utilise ROCm, et non CUDA. Les composants Instinct offrent un excellent rapport qualité-prix et répondent à plusieurs critères mentionnés précédemment, mais votre configuration doit être compatible avec ROCm. La plupart des environnements d'exécution actuels le sont ; certains outils complémentaires ne le sont pas encore. Vérifiez la compatibilité de votre configuration ou contactez-nous pour que nous puissions la vérifier ensemble.

Lorsque la réponse est « plus d'une carte », il s'agit d'une configuration spécifique et non d'une option de paiement. La page dédiée aux configurations multi-GPU et multi-nœuds explique en détail leur fonctionnement et leurs limitations. Le coût mensuel de chaque carte et du serveur associé est celui des serveurs dédiés GPU ; chaque valeur est liée à la machine concernée, c'est pourquoi cette page ne les répète pas.

De mémoire, du plus grand au plus petit

Chaque carte que nous adaptons publie une valeur de mémoire.

Le même catalogue que la page des prix des GPU, trié dans l'ordre inverse : cette page commence par la machine complète la moins chère, car elle répond à la question « quel est le prix ? », et celle-ci commence par la carte graphique la plus performante, car elle répond à la question « quelle est la configuration maximale que je peux utiliser ? ». Une carte dont le fabricant ne communique pas la mémoire est omise plutôt que d'être affichée avec une case vide, car une ligne non comparable est inutile pour une comparaison.

Plusieurs de ces cartes graphiques sont disponibles sur différents châssis, parfois à des prix variés, et la génération du bus de la machine sous-jacente influe sur les performances réelles d'une carte graphique moderne — ces deux éléments étant présents sur les serveurs dédiés GPU . La question de savoir ce qui est actuellement installé et opérationnel est une autre affaire, à laquelle répondent les serveurs instantanés .

Ce que vous installez dessus

Le temps d'exécution vous appartient, et c'est tout l'intérêt du bare metal.

La machine est livrée avec un système d'exploitation et un accès root vierges. Aucun service d'inférence fournisseur n'est requis, aucun environnement d'exécution géré ne se met à jour automatiquement la semaine précédant une échéance, et aucune API n'est présente devant votre modèle. Vous installez ce dont vous avez besoin et vous choisissez la version avec laquelle votre code a été testé.

vLLM

La solution habituelle pour gérer un trafic réel lors de la simulation d'une démo. Le traitement par lots continu et la gestion de l'attention par pagination permettent à une seule carte de répondre à plusieurs requêtes simultanément au lieu d'une seule à la fois, ce qui constitue généralement la différence entre une démo et un service. Une carte relativement récente est requise.

lama.cpp

Réponse habituelle lorsque la mémoire est limitée ou que la carte est ancienne. Ses formats quantifiés permettent à un modèle volumineux de tenir sur une petite carte, et elle exploite pleinement le processeur et la carte lorsque les poids ne correspondent pas exactement. Plus lente par requête, mais beaucoup plus tolérante.

TGI et SGLang

Serveurs de production de la même famille que vLLM, avec des atouts différents concernant la sortie structurée, la réutilisation des préfixes et la gestion de plusieurs modèles. Si vous en avez déjà un dans votre infrastructure, il fonctionnera ici sans modification.

Ollama

Le chemin le plus court entre une machine vide et un modèle répondant sur un port. À privilégier même si vous aboutissez ailleurs, car cela vous indiquera en une dizaine de minutes si votre dimensionnement était correct.

Quel que soit votre choix, vous pouvez figer le pilote, la version CUDA ou ROCm et la version du framework, et aucune mise à jour ne sera effectuée automatiquement. Si vous préférez que le pilote soit installé avant le transfert, veuillez le préciser dans la commande et indiquer la version.

À quelle vitesse cela va-t-il se passer ?

Nous ne publions pas de chiffre en jetons par seconde, et voici pourquoi.

Chaque valeur de ce type dépend du modèle, de la quantification, de l'environnement d'exécution et de sa version, de la taille du lot, de la longueur de l'invite, de la longueur de la réponse et du nombre de requêtes en cours. Modifiez l'un de ces paramètres et la valeur est multipliée. Une valeur affichée qui ne tient pas compte de tous ces éléments est choisie pour son aspect esthétique, et c'est sur la base de cette valeur que nous serons cités.

Nous allons vous expliquer ce qui le régit, afin que vous puissiez raisonner concernant votre propre cas :

  • La lecture de l'invite est limitée par la puissance de calcul. Elle a lieu une fois par requête, en parallèle sur l'ensemble de l'invite, et c'est là que le débit arithmétique de la carte et sa prise en charge des nouveaux formats numériques se manifestent.
  • La génération de la réponse est limitée par la bande passante mémoire. Chaque jeton nécessite la lecture des poids ; par conséquent, pour une requête unique, la limite est approximativement la vitesse à laquelle la carte peut accéder à sa propre mémoire. C'est pourquoi une carte dotée d'une mémoire plus lente mais plus importante peut présenter une latence plus élevée qu'une carte plus petite mais plus rapide, tout en étant plus performante quant à la compatibilité du modèle.
  • Le traitement par lots est ce qui le rend économique. Traiter plusieurs requêtes simultanément permet d'amortir l'impact de la lecture du poids sur l'ensemble d'entre elles, ce qui explique pourquoi le débit total augmente fortement avec la concurrence tandis que la latence par requête reste quasiment inchangée — jusqu'à ce que le cache clé-valeur soit saturé, auquel cas tout se dégrade d'un coup. On retrouve alors une marge de manœuvre.

Demandez plutôt une vraie réponse.

Veuillez nous indiquer le modèle, la quantification prévue, la longueur du contexte et le nombre approximatif de requêtes simultanées attendues. Si nous avons déjà effectué des tests comparables, nous vous ferons part de nos observations et du contexte. Dans le cas contraire, nous vous le préciserons également.

C'est une meilleure base pour un achat qu'un graphique de référence, et cela prend environ une minute.

L'assistance standard est disponible par téléphone, chat et tickets, tous les jours de l'année. Les délais de réponse sont indiqués par écrit.

Au-delà du service

Le réglage fin nécessite beaucoup plus d'espace que le service.

Tout ce qui précède dimensionne un modèle pour l'inférence : poids en entrée, jetons en sortie. L'entraînement ou l'ajustement fin de ce même modèle pose un problème de mémoire différent, et la différence est loin d'être négligeable.

Pourquoi cela coûte plus cher en mémoire

Le déploiement nécessite les poids. L'entraînement requiert les poids, les gradients et l'état de l'optimiseur pour chaque paramètre mis à jour, le tout simultanément, ainsi que les activations nécessaires pour remonter le réseau. Un modèle fonctionnant correctement sur une seule carte peut être beaucoup trop volumineux pour être entièrement optimisé sur cette même carte.

C'est pourquoi la plupart des gens ne le font pas pleinement.

Les méthodes économes en paramètres — adaptateurs, mises à jour de faible rang et leurs variantes quantifiées — mettent à jour une petite partie des paramètres et nécessitent donc une quantité réduite de mémoire supplémentaire. Pour la plupart des tâches de réglage fin, c'est le choix le plus pratique et celui qui s'adapte au matériel dont vous pouvez vous permettre l'entretien.

Que nous dire ?

Le modèle, la méthode, la longueur de la séquence et la taille de l'ensemble de données sont essentiels. Nous ne publierons pas de coefficient multiplicateur ici, car le coefficient réel dépend de ces quatre éléments, et une valeur arbitraire sous-dimensionnant votre machine serait contre-productive. Si la réponse est « plus d'une carte », les configurations multi-GPU et multi-nœuds détaillent la configuration requise.

Le bus a ici une importance qu'il n'a pas pour le service

Une boucle d'entraînement transmet des lots de données en continu via la liaison entre le processeur et la carte, de sorte que la génération PCIe de la machine sous-jacente constitue une contrainte réelle et non une simple spécification. L'inférence sur un modèle résident n'y est que très peu sensible. La correspondance entre les cartes et les liaisons est publiée sur les serveurs dédiés GPU et comparée entre les plateformes sur des environnements multi-GPU et multi-nœuds .

Demandé avant

Cette page a pour but de répondre aux huit questions suivantes.

Ces questions proviennent des demandes que nous recevons par chat et via les tickets, plus ou moins dans l'ordre où elles apparaissent. Les deux premières déterminent la validité d'un achat.

De combien de mémoire GPU un modèle de langage volumineux a-t-il besoin ?
Les poids correspondent au nombre de paramètres multiplié par leur taille en octets : deux octets pour les paramètres 16 bits, un octet pour les paramètres 8 bits et la moitié pour les paramètres 4 bits. Un modèle de 7 à 8 milliards de paramètres nécessite 16 Go de poids pour les paramètres 16 bits, 8 Go pour les paramètres 8 bits et 5 Go pour les paramètres 4 bits ; un modèle de 70 milliards de paramètres nécessite respectivement 140 Go, 70 Go et 38 Go. Ces chiffres ne concernent que les poids et représentent un minimum, et non une exigence absolue. Prévoyez un budget supplémentaire d’un quart à la moitié de la capacité pour l’exécution, les activations et le cache clé-valeur.
Pourquoi mon modèle se charge-t-il mais ne s'affiche-t-il pas ?
Car les poids ne sont pas les seuls éléments stockés en mémoire. L'environnement d'exécution et ses tampons y sont également présents, et chaque jeton d'une conversation laisse une entrée dans le cache clé-valeur afin d'éviter un recalcul. Ce cache s'agrandit avec la longueur du contexte et à chaque requête traitée simultanément. Ainsi, un modèle dont les poids tiennent tout juste peut contenir environ une courte conversation. Dimensionnez la carte à une valeur comprise entre 1,25 et 1,5 fois les poids.
Quel environnement d'exécution d'inférence puis-je installer ?
N'importe laquelle de ces solutions convient. La machine est livrée avec un système d'exploitation et une racine vierges, sans service d'inférence fournisseur. vLLM est généralement la solution idéale pour gérer un trafic réel, car le traitement par lots continu permet à une seule carte de répondre simultanément à de nombreuses requêtes. llama.cpp est généralement privilégié lorsque la mémoire est limitée ou que la carte est ancienne. TGI et SGLang fonctionnent sans modification. Ollama est le chemin le plus court entre une machine vierge et un modèle répondant sur un port. Vous spécifiez le pilote, la version de CUDA ou ROCm et le framework sur les versions utilisées pour tester votre code.
Combien de jetons par seconde vais-je recevoir ?
Nous ne publions pas de chiffre concernant le nombre de jetons par seconde, car ce chiffre dépend du modèle, de la quantification, de l'environnement d'exécution et de sa version, de la taille des lots, de la longueur de l'invite, de la longueur de la réponse et de la concurrence. Toute modification de ces paramètres entraîne une variation considérable du chiffre. Voici les facteurs déterminants : la lecture de l'invite est limitée par la puissance de calcul et n'a lieu qu'une fois par requête ; la génération de la réponse est limitée par la bande passante mémoire, car chaque jeton nécessite la lecture de ses poids ; et le traitement par lots amortit cette lecture entre les requêtes simultanées, ce qui rend le service économique jusqu'à saturation du cache clé-valeur. Pour obtenir une réponse basée sur nos observations, veuillez nous indiquer le modèle, la quantification et la concurrence attendue.
Le GPU est-il partagé avec quelqu'un d'autre ?
Non. Un seul locataire par machine physique, et la carte est attribuée à votre propre système d'exploitation. Il n'y a ni hyperviseur, ni partition MIG, ni profil vGPU, ni planificateur de partage de temps ; par conséquent, aucune autre application ne s'exécute sur la carte et la latence d'inférence reste inchangée, même en cas de traitement par lots par un tiers.
Que se passe-t-il si le modèle ne tient pas sur une seule carte ?
Il s'agit alors d'une configuration multi-cartes, dont la configuration est chiffrée plutôt que commandée directement : le nombre de cartes compatibles dépend de leur largeur et de la consommation électrique du boîtier. Avec deux cartes, la mémoire totale n'est atteinte que si le système d'exploitation peut répartir la charge sur les deux, ce que tous les systèmes d'exploitation sérieux prennent en charge, moyennant une légère baisse de performances. Cette configuration nécessite plusieurs cartes ou machines .
Le réglage fin nécessite-t-il plus de mémoire que le service ?
Bien plus. Le déploiement nécessite les poids ; l’entraînement requiert les poids, les gradients et l’état de l’optimiseur pour chaque paramètre mis à jour, le tout résidant simultanément, ainsi que les activations conservées pour la rétropropagation. Un modèle fonctionnant correctement sur une seule carte peut être plusieurs fois trop volumineux pour un réglage fin complet. Les méthodes économes en paramètres mettent à jour une petite fraction de ces derniers et nécessitent donc une fraction réduite de la mémoire supplémentaire, ce qui explique pourquoi la plupart des réglages fins utilisent une seule carte.
Puis-je utiliser une carte AMD, et ROCm fonctionne-t-il ?
Oui. Les cartes AMD Instinct comptent parmi celles offrant la plus grande capacité de mémoire et proposent souvent le meilleur rapport qualité-prix par gigaoctet. Cependant, votre configuration doit prendre en charge ROCm et non CUDA. La plupart des environnements d'inférence actuels le font ; certains outils associés ne le font pas encore. Veuillez nous contacter avant de commander afin que nous puissions vérifier la compatibilité avec votre environnement d'inférence spécifique plutôt que de vous donner une réponse générale.

For the record

Everything on this page, as figures.

Card memory is the manufacturers’ published figure; which cards exist is read from the order catalogue when this page was served. No monthly price appears here on purpose — GPU dedicated servers holds every one, against the exact machine it belongs to.

What decides whether a model runs
Card memory, and almost nothing else on the order form. The weights either fit or they do not — a card a couple of gigabytes short does not run slower, it fails to load. Clock speed and core count decide how fast it is once it fits.
How much memory a model needs
Parameters multiplied by bytes per parameter: two bytes each at 16-bit, one at 8-bit, half at 4-bit. That is the WEIGHTS. The runtime, the activations and the key-value cache for the conversation live in the same memory, so budget a quarter to a half again on top before choosing a card.
Largest model on a single card here
70 billion parameters at 4-bit, with room left to serve. Past that the answer is more than one card in one machine, which is a build we quote rather than a checkout option — multi-GPU and multi-node is the page for it.
Biggest card we fit
RTX PRO 6000 Blackwell 96GB, 96 GB GDDR7 ECC. Card memory figures are the manufacturers' published ones; a card whose figure we could not source is left out of the comparison rather than guessed at.
Which runtime
Yours. The machine arrives with a clean operating system and root, and you install vLLM, llama.cpp, TGI, SGLang, Ollama or anything else, pinned to the version your code was tested against. Nothing upgrades underneath you, and there is no vendor runtime you have to go through.
Throughput
We publish no tokens-per-second figure, deliberately, because we have not measured one under conditions we would be willing to have quoted back at us. What governs it is the card's memory bandwidth while generating, its arithmetic while reading the prompt, and how many requests you batch. Ask with the model, the quantisation and the expected concurrency and we will say what we have actually seen.
Fine-tuning and training
Both are ordinary work here, and both need considerably more memory than serving the same model: gradients and optimiser state sit alongside the weights. A parameter-efficient method needs a fraction of what a full fine-tune does. Tell us the method and the model and we will size it rather than have you find out after delivery.
Tenancy
One tenant per physical machine and the card passed straight through to your operating system. No hypervisor, no MIG partition, no vGPU profile, no time-slicing scheduler, and nobody else's workload on the card. What you measure on the first afternoon is what you keep.
Bandwidth
Unmetered in both directions at every port speed, with no transfer allowance and no egress line on any invoice. Pulling weights down and serving tokens back out costs nothing beyond the port.
What this page does not price
Cards, or anything else. Every card we fit, what each adds per month and what the machine under it costs are on GPU dedicated servers, each figure against the exact machine it belongs to.