How much GPU memory does a large language model need?

The weights are the parameter count multiplied by the bytes per parameter: two bytes each at 16-bit, one at 8-bit, half at 4-bit. A 7-8 billion parameter model is 16 GB of weights at 16-bit, 8 GB at 8-bit and 5 GB at 4-bit; a 70 billion parameter model is 140 GB, 70 GB and 38 GB. Those figures are the weights alone and are a floor rather than a requirement -- budget a quarter to a half again on top for the runtime, the activations and the key-value cache.

Why does my model load but fail to serve?

Because the weights are not the only thing in card memory. The runtime and its buffers are resident, and every token in a conversation leaves an entry in the key-value cache so it does not have to be recomputed. That cache grows with the context length and again with each request served concurrently, so a model whose weights only just fit will hold roughly one short conversation. Size the card at one and a quarter to one and a half times the weights.

Which inference runtime can I install?

Any of them. The machine arrives with a clean operating system and root, and there is no vendor inference service in front of it. vLLM is the usual answer for serving real traffic because continuous batching lets one card answer many requests at once. llama.cpp is the usual answer when memory is tight or the card is older. TGI and SGLang run unchanged. Ollama is the shortest path from an empty machine to a model answering on a port. You pin the driver, the CUDA or ROCm release and the framework to the versions your code was tested against.

How many tokens per second will I get?

Primcast does not publish a tokens-per-second figure, because every such number depends on the model, the quantisation, the runtime and its version, the batch size, the prompt length, the reply length and the concurrency, and changing any one moves it by a multiple. What governs it: reading the prompt is compute-bound and happens once per request; generating the reply is memory-bandwidth-bound because each token requires reading the weights; and batching amortises that reading across concurrent requests, which is what makes serving economical until the key-value cache runs out of room. Ask with the model, quantisation and expected concurrency for an answer based on what has actually been observed.

Is the GPU shared with anyone else?

No. One tenant per physical machine, and the card is passed through to your own operating system. There is no hypervisor, no MIG partition, no vGPU profile and no time-slicing scheduler, so nothing else runs on the card and inference latency does not move because of somebody else's batch job.

What if the model does not fit on one card?

Then it is a multi-card build, which is quoted rather than ordered from a checkout: how many cards fit depends on the physical width of the specific card and the power budget of the chassis. Two cards give you the sum of their memory only if the runtime can split the model across both, which every serious runtime supports at some cost in throughput. https://primcast.com/hpc covers what more than one card and more than one machine look like.

Does fine-tuning need more memory than serving?

Considerably more. Serving needs the weights; training needs the weights, the gradients and the optimiser state for every parameter being updated, all resident at once, plus the activations kept for the backward pass. A model that serves comfortably on one card can be several times too large to fully fine-tune on it. Parameter-efficient methods update a small fraction of the parameters and need a correspondingly small fraction of the extra memory, which is why most fine-tuning here uses one.

Can I run an AMD card, and does ROCm work?

Yes. The AMD Instinct parts are among the largest-memory cards fitted and are frequently the best value per gigabyte, but your stack has to support ROCm rather than CUDA. Most current inference runtimes do; some surrounding tooling still does not. Ask before ordering and it will be checked against your specific runtime rather than answered in general.

Modelos de linguagem em hardware dedicado · Primcast LLC · desde 2004

O modelo determina a memória. Nada mais no formulário de pedido o faz.

As pessoas chegam a esta página acreditando que a decisão se resume a qual acelerador é o mais rápido. Não é. Os pesos ou cabem na memória do cartão ou não — um cartão com dois gigabytes a menos não fica mais lento, ele simplesmente não carrega. Portanto, esta página segue a ordem em que a decisão realmente acontece: qual o tamanho do modelo, qual a precisão necessária para executá-lo, quanto espaço a conversação exige e somente então qual cartão atende aos requisitos. Os preços estão em uma página de distância, propositalmente.

Qual placa executa meu modelo? O que eu instalo nele

Um usuário por máquina. O cartão é repassado para o seu sistema operacional, e você pode escolher e fixar as versões do runtime, do driver e da estrutura.

Passo um

O peso real desses pesos.

Os parâmetros são multiplicados pelos bytes por parâmetro, e esse é todo o cálculo. Pesos de dezesseis bits ocupam dois bytes cada, de oito bits um byte e de quatro bits meio byte. Um modelo com sete bilhões de parâmetros em dezesseis bits resulta em quatorze gigabytes de pesos; o mesmo modelo em quatro bits ocupa entre três e quatro gigabytes.

A quantização é o que transforma uma máquina incapaz de armazenar um modelo em uma capaz. Ela tem um custo em termos de qualidade, e o quanto depende do modelo e do método utilizado depende muito mais do modelo e do método utilizado do que da contagem de bits em si — um modelo de quatro bits bem quantizado geralmente se aproxima mais da sua versão de precisão total do que se imagina, enquanto um modelo de oito bits mal quantizado pode ser pior. Se o objetivo é a precisão, teste ambas as abordagens antes de investir em hardware; é mais barato descobrir a diferença agora do que depois da entrega.

Esses valores representam os pesos e nada mais. São o mínimo exigido, não o requisito. A próxima seção é a parte que costuma confundir as pessoas.

Weights only — the runtime, the activations and the conversation are extra, and are the subject of the next section.
Model	16-bit	8-bit	4-bit
7-8 billion parameters	16 GB	8 GB	5 GB
13-14 billion parameters	28 GB	14 GB	8 GB
30-34 billion parameters	68 GB	34 GB	19 GB
70 billion parameters	140 GB	70 GB	38 GB

Passo dois

Por que um modelo que se encaixa ainda assim não será útil.

Essa é a forma mais comum de dar errado na compra de uma placa de vídeo, e sempre dá errado da mesma maneira: alguém lê que o modelo tem 38 gigabytes, compra uma placa de 40 gigabytes, instala com sucesso e depois descobre que ela só consegue manter uma conversa curta.

O ambiente de execução também está incluído.
Carregar um modelo não é a única coisa que ocupa espaço na memória. O próprio ambiente de execução, seus buffers e as ativações de tudo o que está sendo computado residem na mesma memória que os pesos.
A conversa está lá, e cresce.
Cada token já presente em uma conversa deixa um rastro no cache de chave-valor para que não precise ser recalculado. Esse cache cresce com o tamanho do contexto e também a cada requisição atendida simultaneamente. Um contexto longo ou um endpoint ocupado podem exigir tanta memória quanto um modelo pequeno.
Então: um quarto a metade novamente
Reserve pelo menos um quarto a mais de memória no cartão do que o número de pesos, e mais metade se o contexto for longo ou o ponto final estiver ocupado. Essa é a regra que a tabela na próxima seção aplica a você — cada cartão mencionado nela comporta o número de pesos uma vez e meia.
E se estiver perto, avise antes de comprar.
Informe-nos o modelo, a quantização, o comprimento do contexto necessário e aproximadamente quantas requisições simultâneas. Preferimos convencê-lo a optar por uma placa maior agora, ou por um modelo menor, do que aceitar um pedido que apresente problemas na primeira semana e resulte em um pedido de reembolso.

Passo três

Qual placa executa qual modelo?

Leia de cima para baixo até o tamanho do seu modelo e, na horizontal, até a precisão que você pretende usar. Cada célula indica o menor cartão que comporta esses pesos com espaço de sobra e um link para a máquina em que ele será usado. Quando o catálogo não indicar nada que faça isso sozinho, a célula especificará a necessidade, em vez de deixar um campo em branco.

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 run	at 16-bit	at 8-bit	at 4-bit
7-8 billion parameters	TESLA P40 / QUADRO P600024 GB16 GB of weights	TITAN V12 GB HBM28 GB of weights	TESLA P48 GB GDDR55 GB of weights
13-14 billion parameters	RTX A600048 GB GDDR6 ECC28 GB of weights	TESLA P40 / QUADRO P600024 GB14 GB of weights	TITAN V12 GB HBM28 GB of weights
30-34 billion parameters	More than one cardNothing we fit holds it alone68 GB of weights	Instinct MI21064 GB HBM2e34 GB of weights	Tesla V100 32GB32 GB HBM219 GB of weights
70 billion parameters	More than one cardNothing we fit holds it alone140 GB of weights	More than one cardNothing we fit holds it alone70 GB of weights	Instinct MI21064 GB HBM2e38 GB of weights

Três coisas que a tabela não pode te dizer

A placa de vídeo menor que cabe nem sempre é a ideal. A memória determina se um modelo funciona; todos os outros componentes da placa determinam a velocidade de processamento e a quantidade de usuários que ela pode atender simultaneamente. A tabela otimiza o primeiro requisito, pois ele representa um limite inegociável, enquanto o segundo é uma questão de preferência. Se o desempenho for mais importante que o orçamento, suba um degrau na lista abaixo.
Placas de vídeo mais antigas não são compatíveis com os formatos numéricos mais recentes. Vários componentes em nosso catálogo são anteriores ao FP8 e ao bfloat16, portanto, um ambiente de execução que espera esses formatos recorrerá a algo mais lento ou recusará o processamento. Essa é uma questão importante a ser esclarecida antes de fazer o pedido, e responderemos a ela considerando uma placa e um ambiente de execução específicos, e não de forma genérica.
Uma placa AMD executa ROCm, não CUDA. Os componentes Instinct oferecem excelente custo-benefício por gigabyte e são a solução em mais de um dos casos mencionados acima, mas seu conjunto de ferramentas precisa ser compatível com ROCm. A maioria dos runtimes atuais é; algumas ferramentas complementares ainda não. Verifique o seu ou entre em contato conosco e verificaremos para você.

Quando a resposta é "mais de uma placa", trata-se de uma configuração que orçamos, e não de uma opção de compra. A página sobre multi-GPU e multi-nó explica como essa configuração funciona e quais são suas limitações. O custo mensal de cada uma dessas placas e o custo da máquina correspondente referem-se a servidores dedicados a GPUs — todos os valores ali apresentados estão vinculados à máquina específica, por isso esta página não os repete.

De memória, o maior primeiro.

Cada cartão que encaixamos publica uma figura de memória.

O mesmo catálogo da página de GPUs apresenta os preços, porém ordenados ao contrário: aquela página começa com a máquina completa mais barata, pois responde à pergunta "quanto custa isso?", enquanto esta começa com a placa de vídeo mais potente, pois responde à pergunta "qual o maior computador que posso usar?". Placas cuja memória o fabricante não divulga são omitidas aqui, em vez de serem exibidas com um campo em branco, pois uma linha que não pode ser comparada é inútil em uma comparação.

Vários desses modelos aparecem em mais de um chassi, às vezes com preços diferentes, e a geração do barramento da máquina subjacente altera o que uma placa moderna pode realmente fazer — ambos os casos em servidores dedicados a GPUs . O que está disponível para instalação imediata é uma questão diferente, respondida pelos servidores instantâneos .

O que você instala nele

O ambiente de execução é seu, e essa é a essência do bare metal.

A máquina chega com um sistema operacional e root limpos. Não há serviço de inferência de fornecedor que você precise usar, nenhum ambiente de execução gerenciado que se atualize na semana anterior ao prazo final e nenhuma API interferindo no seu modelo. Você instala o que quiser e fixa a versão com a qual seu código foi testado.

vLLM

A solução usual para servir um modelo a tráfego real. O processamento em lote contínuo e a atenção paginada permitem que uma única placa responda a várias solicitações simultaneamente, em vez de uma por vez, o que normalmente diferencia uma demonstração de um serviço. Requer uma placa relativamente moderna.

lhama.cpp

A resposta usual quando a memória é limitada ou a placa de vídeo é antiga. Seus formatos quantizados são o motivo pelo qual um modelo grande cabe em uma placa pequena, e ele usará processador e placa em conjunto sem problemas quando os pesos não se encaixarem perfeitamente. Mais lento por solicitação, mas muito mais tolerante.

TGI e SGLang

Servidores de produção da mesma família do vLLM, com diferentes pontos fortes em relação à saída estruturada, reutilização de prefixos e serviço multimodelos. Se você já possui um em sua infraestrutura, ele funcionará aqui sem alterações.

Ollama

O caminho mais curto de uma máquina vazia até um modelo que responde em uma porta. Vale a pena começar por ele, mesmo que você acabe em outro lugar, porque ele dirá em cerca de dez minutos se o seu dimensionamento estava correto.

Independentemente da sua escolha, o driver, a versão do CUDA ou ROCm e a compilação do framework são seus para fixar e nenhuma atualização será feita automaticamente. Se preferir que o driver seja instalado antes da entrega, indique isso no pedido e especifique a versão.

Quão rápido será?

Não divulgamos um número de tokens por segundo, e aqui está o porquê.

Cada um desses números depende do modelo, da quantização, do tempo de execução e sua versão, do tamanho do lote, do comprimento da solicitação, do comprimento da resposta e de quantas solicitações estão em andamento. Alterar qualquer um desses fatores multiplica o número por um valor maior. Um número principal que não inclua todos esses fatores é um número escolhido apenas para causar boa impressão, e seríamos citados com base nele.

O que vamos lhe dizer é o que rege isso, para que você possa analisar o seu próprio caso:

A leitura do prompt é um processo que depende da capacidade de processamento. Ela ocorre uma vez por solicitação, em paralelo em todo o prompt, e é nesse momento que o desempenho aritmético da placa e seu suporte aos formatos numéricos mais recentes se tornam evidentes.
A geração da resposta é limitada pela largura de banda da memória. Cada token requer a leitura dos pesos, portanto, para uma única solicitação, o limite é aproximadamente a velocidade com que a placa consegue transmitir sua própria memória. É por isso que uma placa com memória mais lenta, porém em maior quantidade, pode perder em latência para uma placa menor e mais rápida, embora tenha vantagem em termos de adequação do modelo.
O processamento em lotes é o que torna tudo econômico. Atender a várias solicitações simultaneamente dilui o custo de leitura entre todas elas, e é por isso que a taxa de transferência total aumenta consideravelmente com a concorrência, enquanto a latência por solicitação praticamente não se altera — até que o cache de chave-valor fique sem espaço, momento em que tudo se degrada de uma vez. Mais uma vez, há espaço de sobra.

Peça uma resposta sincera.

Informe-nos o modelo, a quantização pretendida, o comprimento do contexto e aproximadamente quantas requisições simultâneas você espera. Se tivermos executado algo semelhante, diremos o que observamos e em qual plataforma. Caso contrário, também informaremos.

É uma base melhor para uma compra do que uma tabela de referência, e leva cerca de um minuto.

O atendimento normal funciona em todos os horários — telefone, chat e tickets, todos os dias do ano. O suporte tem os tempos de resposta informados por escrito.

Além de servir

O ajuste fino requer consideravelmente mais espaço do que o serviço.

Tudo o que foi mencionado acima dimensiona um modelo para inferência: pesos de entrada, tokens de saída. Treinar ou ajustar o mesmo modelo é um problema de memória diferente, e a diferença não é pequena.

Por que isso consome mais memória?

Para servir, são necessários os pesos. Para treinar, são necessários os pesos, os gradientes e o estado do próprio otimizador para cada parâmetro que ele atualiza, tudo residente ao mesmo tempo, além das ativações que ele precisa manter para percorrer a rede de trás para frente. Um modelo que serve confortavelmente em uma carta pode ser várias vezes grande demais para ser totalmente ajustado na mesma carta.

É por isso que a maioria das pessoas não o faz completamente.

Métodos com uso eficiente de parâmetros — adaptadores, atualizações de baixa classificação e suas variantes quantizadas — atualizam uma pequena fração dos parâmetros e, consequentemente, necessitam de uma fração igualmente pequena da memória adicional. Para a maioria das tarefas que chamamos de ajuste fino, essa é a escolha prática e a que cabe no hardware que você pode manter.

O que nos dizer

O modelo, o método, o comprimento da sequência e o tamanho do conjunto de dados. Não publicaremos um multiplicador aqui porque o valor correto depende dos quatro fatores, e um número inventado que subestime o desempenho da sua máquina é pior para nós dois do que uma conversa. Se a resposta for mais de uma placa de vídeo, a configuração com múltiplas GPUs e múltiplos nós explica como será essa configuração.

O ônibus é importante aqui de uma forma que não é para servir.

Um loop de treinamento transmite lotes continuamente pela conexão entre o processador e a placa, portanto, a geração PCIe da máquina subjacente é uma restrição real, e não uma especificação. A inferência em um modelo residente praticamente não a afeta. A informação sobre qual plataforma fornece qual conexão para uma placa é publicada em servidores dedicados a GPUs e comparada entre plataformas em ambientes com múltiplas GPUs e múltiplos nós .

Para onde ir a seguir?

As páginas de cada lado desta.

Esta página aborda uma única questão: o que é necessário para executar um modelo. Tudo o que está relacionado a isso tem sua própria página, e esta reúne todas elas.

Perguntado antes

As oito perguntas que esta página se propõe a responder.

Extraído das perguntas que as pessoas realmente nos fazem no chat e nos tickets, aproximadamente na ordem em que são feitas. As duas primeiras são as que determinam se uma compra será bem-sucedida.

Quanta memória de GPU um modelo de linguagem grande precisa?: Os pesos são a contagem de parâmetros multiplicada pelos bytes por parâmetro: dois bytes em 16 bits, um em 8 bits e metade em 4 bits. Um modelo com 7 a 8 bilhões de parâmetros requer 16 GB de pesos em 16 bits, 8 GB em 8 bits e 5 GB em 4 bits; um modelo com 70 bilhões de parâmetros requer 140 GB, 70 GB e 38 GB, respectivamente. Esses valores referem-se apenas aos pesos e são um limite mínimo, não um requisito — considere um adicional de 25% a 50% para o tempo de execução, as ativações e o cache de chave-valor.
Por que meu modelo carrega, mas não funciona?: Porque os pesos não são a única coisa na memória do cartão. O ambiente de execução e seus buffers residem na memória, e cada token em uma conversa deixa uma entrada no cache de chave-valor para que não precise ser recalculado. Esse cache cresce com o comprimento do contexto e novamente a cada solicitação atendida simultaneamente, portanto, um modelo cujos pesos se encaixam no limite comportará aproximadamente uma conversa curta. Dimensione o cartão para um tamanho entre uma vez e um quarto e uma vez e meia o número de pesos.
Qual ambiente de execução de inferência posso instalar?: Qualquer uma delas. A máquina chega com um sistema operacional e root limpos, e não há nenhum serviço de inferência de fornecedor instalado. O vLLM é a resposta usual para lidar com tráfego real, pois o processamento em lote contínuo permite que uma placa responda a várias solicitações simultaneamente. O llama.cpp é a resposta usual quando a memória é limitada ou a placa é mais antiga. TGI e SGLang funcionam sem alterações. O Ollama é o caminho mais curto de uma máquina vazia para um modelo respondendo em uma porta. Você define o driver, a versão do CUDA ou ROCm e o framework para as versões com as quais seu código foi testado.
Quantos tokens por segundo eu vou receber?: Não divulgamos um valor de tokens por segundo, pois cada número desse tipo depende do modelo, da quantização, do ambiente de execução e sua versão, do tamanho do lote, do comprimento da solicitação, do comprimento da resposta e da concorrência, e alterar qualquer um desses fatores o altera significativamente. O que o rege: a leitura da solicitação é limitada pelo poder computacional e ocorre uma vez por requisição; a geração da resposta é limitada pela largura de banda da memória, pois cada token requer a leitura dos pesos; e o processamento em lotes dilui essa leitura entre as requisições simultâneas, o que torna o serviço econômico até que o cache de chave-valor fique sem espaço. Para obter uma resposta baseada em nossas observações, consulte o modelo, a quantização e a concorrência esperada.
A placa de vídeo é compartilhada com mais alguém?: Não. Um único locatário por máquina física, e a placa é repassada para o seu próprio sistema operacional. Não há hipervisor, partição MIG, perfil vGPU ou agendador de fatiamento de tempo, portanto, nada mais é executado na placa e a latência de inferência não é afetada por um trabalho em lote de outra pessoa.
E se o modelo não couber em um único cartão?: Nesse caso, trata-se de uma configuração com várias placas de vídeo, cujo valor é cotado em vez de ser encomendado diretamente no caixa: a quantidade de placas que cabem depende da largura física da placa específica e da capacidade de energia do gabinete. Duas placas só oferecem a soma da memória delas se o sistema operacional puder dividir o modelo entre ambas, o que todo sistema operacional robusto suporta, embora com alguma perda de desempenho. Mais de uma placa ou máquina definem essa configuração.
O ajuste fino requer mais memória do que o serviço?: Consideravelmente mais. O saque precisa dos pesos; o treinamento precisa dos pesos, dos gradientes e do estado do otimizador para cada parâmetro que está sendo atualizado, todos residentes simultaneamente, além das ativações mantidas para a retropropagação. Um modelo que saca confortavelmente em uma única carta pode ser várias vezes grande demais para ser totalmente ajustado nela. Métodos com uso eficiente de parâmetros atualizam uma pequena fração dos parâmetros e precisam de uma fração correspondentemente pequena da memória extra, razão pela qual a maior parte do ajuste fino aqui utiliza apenas uma carta.
Posso usar uma placa de vídeo AMD? E o ROCm funciona?: Sim. As placas AMD Instinct estão entre as que possuem maior capacidade de memória e geralmente oferecem o melhor custo-benefício por gigabyte, mas seu sistema precisa ser compatível com ROCm em vez de CUDA. A maioria dos runtimes de inferência atuais é compatível; algumas ferramentas complementares ainda não. Consulte-nos antes de fazer o pedido e verificaremos a compatibilidade com seu runtime específico, em vez de responder de forma genérica.

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.