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.

基于裸机的语言模型 · Primcast LLC · 自 2004 年起

内存容量由型号决定，订单上的其他任何选项均不影响内存容量。

人们来到这个页面时，以为要做的就是选择速度最快的加速卡。其实不然。模型权重要么能装进显卡内存，要么装不下——少了2GB内存的显卡运行速度不会变慢，而是根本无法加载。所以，这个页面的顺序才是真正做决定的顺序：模型有多大，运行精度是多少，计算需要多少空间，最后才确定哪张显卡符合要求。价格信息特意放在下一页。

我的模型运行在哪张显卡上？我在上面安装了什么

每台机器仅限一个租户。该卡会直接传递给您的操作系统，您可以自行选择并固定运行时、驱动程序和框架版本。

第一步

这些砝码的实际重量是多少？

参数数量乘以每个参数占用的字节数，这就是全部计算结果。16 位权重每个占两个字节，8 位权重每个占一个字节，4 位权重每个占半个字节。一个 70 亿参数的 16 位模型需要 14 GB 的权重；同样的 4 位模型则需要 3 到 4 GB 的权重。

量化可以将原本无法存储模型的机器变成可以存储模型的机器。它会降低精度，而精度降低的程度远取决于模型和量化方法，而不仅仅是位数——一个量化良好的四位模型通常比人们预期的更接近其全精度状态，而一个量化不良的八位模型则可能更差。如果精度是关键，那么在投入硬件之前，应该对两种方法都进行测试；现在发现差异的成本远低于交付后发现差异的成本。

这些数字只是权重，仅此而已。它们是底线，而非要求。下一部分才是最容易让人困惑的地方。

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

第二步

为什么合适的模型仍然无法发挥作用。

这是购买 GPU 时最常见的出错方式，而且每次出错的方式都一样：有人看到自己想要的型号是 38 GB，就买了一张 40 GB 的显卡，安装成功后，却发现它只能勉强进行一次简短的对话。

运行时也包含在内。
加载模型并不是占用内存卡的唯一内容。运行时本身、其缓冲区以及正在计算的任何内容的激活值都与权重一起驻留在同一内存中。
对话就在那里，而且还在不断发展。
对话中已存在的每个令牌都会在键值缓存中留下一些信息，这样就无需重新计算。缓存会随着上下文长度的增长而增长，也会随着同时处理的请求数量而增长。较长的上下文或繁忙的端点可能需要与小型模型一样多的内存。
所以：又过了四分之一到一半。
卡片内存的预算至少要比权重多四分之一，如果上下文时间较长或端点繁忙，则至少要多预留一半。下一节表格中的规则就是如此——表格中列出的每张卡片都存储着权重的1.5倍。
如果价格接近，请在购买前说明。
请告诉我们您需要的模型、量化级别、上下文长度以及大致的请求数量。我们宁愿现在就说服您选择容量更大的卡片或更小的模型，也不愿接受一个第一周就令人失望并导致退款的订单。

第三步

哪张卡运行哪个模型。

向下读取至您的型号尺寸，横向读取至您计划使用的精度。每个单元格都列出了我们能容纳这些重量且仍有剩余空间的最小卡片，并链接到相应的机器。如果目录中没有可单独使用的产品，则该单元格会注明，而不是留空。

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

表格无法告诉你的三件事

尺寸最小的显卡未必是你最理想的选择。内存决定了模型能否运行；显卡的其他所有特性决定了运行速度和同时服务的用户数量。表格主要针对内存进行优化，因为内存是硬性限制，而同时服务的用户数量则取决于个人偏好。如果吞吐量比预算更重要，请参考下方列表中更高一级的显卡。
老款显卡不支持新的浮点数格式。我们产品目录中的一些显卡早于 FP8 和 bfloat16 格式，因此需要这些格式的运行时会回退到速度较慢的版本，甚至拒绝执行。这是一个值得在订购前咨询的问题，我们会针对具体的显卡和特定的运行时给出解答，而不是一概而论。
AMD显卡运行的是ROCm，而不是CUDA。Instinct系列显卡每GB的性价比很高，符合上述多个条件，但前提是你的操作系统必须支持ROCm。目前大多数运行时都支持ROCm，但一些相关的工具仍然不支持。请检查你的操作系统，或者联系我们，我们会帮你确认。

如果答案是“多张显卡”，我们会提供相应的配置报价，而不是直接下单购买。多GPU和多节点页面会详细解释这种配置的具体情况和限制。每张显卡的月租金以及其所在服务器的费用都属于GPU专用服务器的范畴——所有费用都与它所属的特定服务器相关，因此本页面不会重复列出。

凭记忆，最大的排在第一位

我们安装的每一张卡片都会公布内存数据。

同样的目录，GPU页面的价格排序方式正好相反：GPU页面从最便宜的整机开始，因为它回答的是“这台机器多少钱”，而这个页面从性能最强的显卡开始，因为它回答的是“我能运行的最大配置是什么”。如果显卡的显存容量没有厂商公布，那么这个页面会将其省略，而不是显示空白，因为无法比较的行对比较毫无意义。

这些显卡有好几种，其中一些出现在不止一种机箱上，价格有时也不同，而且底层机器的总线代数也会影响现代显卡的实际性能——这些都与GPU专用服务器有关。至于哪些显卡已经安装完毕并随时可用，则是另一个问题，答案是即时服务器。

你在上面安装什么

运行时完全由你掌控，这就是裸机的意义所在。

这台机器出厂时已预装干净的操作系统并拥有 root 权限。您无需使用任何厂商推断服务，无需担心托管运行时会在截止日期前一周自动升级，也无需访问您自己的模型 API。您可以根据需要安装所需的软件，并将其锁定到代码测试所用的版本。

vLLM

通常情况下，向真实流量展示模型需要采用连续批处理和分页式注意力机制。这使得一张卡片可以同时响应多个请求，而不是一次只能响应一个，这通常是演示和服务之间的区别。需要一张比较现代的卡片。

llama.cpp

当内存不足或存储卡较旧时，这通常是最佳解决方案。它的量化格式使得大型模型能够装入小容量存储卡，而且当权重数据无法完全匹配时，它也能很好地利用处理器和存储卡的协同工作。虽然每次请求速度较慢，但容错率更高。

TGI 和 SGLang

生产服务器与 vLLM 属于同一系列，但在结构化输出、前缀重用和多模型服务方面各有优势。如果您的技术栈中已经部署了此类服务器，则无需任何修改即可直接运行。

奥拉玛

从一台空机到一台正在接听电话的机型的最短路径。即使最终你选择了其他机型，也值得从这里开始，因为它会在大约十分钟内告诉你你的选择是否正确。

无论您选择哪种方案，驱动程序、CUDA 或 ROCm 版本以及框架构建都由您决定，不会在您未指定的情况下进行任何升级。如果您希望在交付前安装驱动程序，请在订单中注明并指定版本。

速度会有多快？

我们不公布每秒令牌数，原因如下。

每个这样的数字都取决于模型、量化方式、运行时及其版本、批处理大小、提示符长度、回复长度以及正在进行的请求数量。任何一个因素的改变都会导致该数字成倍变化。如果一个数字没有包含所有这些信息，那么它就只是为了好看而刻意挑选出来的，而我们却会被媒体引用。

我们将告诉你相关的规则，以便你可以自行判断：

读取提示符是计算密集型操作。每次请求只执行一次，在整个提示符范围内并行执行，这正是卡片算术吞吐量及其对新型数字格式支持能力的体现。
生成响应的速度受限于内存带宽。每个令牌都需要读取权重，因此对于单个请求而言，其上限大致取决于显卡自身内存的读写速度。这就是为什么内存速度较慢但容量更大的显卡在延迟方面可能不如内存容量较小但速度更快的显卡，但在模型拟合效果方面却更胜一筹。
批量处理是其经济高效的关键。同时处理多个请求可以分摊读取操作的开销，因此总吞吐量会随着并发量的增加而迅速提升，而单个请求的延迟几乎不变——直到键值缓存空间耗尽，此时所有性能都会同时下降。这又是一个性能提升空间不足的问题。

应该要求得到一个真实的答案。

请告诉我们您使用的模型、量化级别、上下文长度以及预计的并发请求数。如果我们之前运行过类似的测试，我们会说明测试结果以及测试平台。如果没有，我们也会说明。

它比基准图表更适合作为购买依据，而且只需大约一分钟即可完成。

常规支持服务涵盖所有渠道——电话、在线聊天和工单，全年无休。支持团队会以书面形式告知响应时间。

超越服务

微调需要的空间比服务需要的空间要大得多。

以上所有内容都涉及推理模型的规模调整：输入权重，输出标记。训练或微调同一个模型则涉及不同的内存问题，而且差异不容小觑。

为什么需要更多内存

模型运行需要权重。训练则需要权重、梯度以及优化器自身针对每个更新参数的状态，所有这些都必须同时存在，此外还需要保留激活值以便反向遍历网络。一个能在单卡上流畅运行的模型，其规模可能大到无法在同一张卡上进行完全微调。

这就是为什么大多数人没有完全做到这一点的原因。

参数高效的方法——例如适配器算法、低秩更新及其量化变体——只需更新一小部分参数，因此所需的额外内存也相应较少。对于大多数人们所说的微调任务而言，这既是切实可行的选择，也是在您可承受的硬件资源范围内的最佳方案。

告诉我们什么

模型、方法、序列长度和数据集大小都会影响性能。我们不会在此公布具体的倍数，因为准确的倍数取决于这四个因素，而随意编造一个低估你机器性能的数字，对我们双方都比沟通更糟糕。如果答案是多显卡，那么多GPU和多节点架构就能解释这种配置的具体情况。

在这里，公交车的重要性与它服务乘客的方式有所不同。

训练循环会持续不断地通过处理器和显卡之间的链路传输数据批次，因此底层机器的 PCIe 版本是一个实际的限制因素，而非规格参数。对驻留模型进行推理几乎不会受到 PCIe 版本的影响。哪个平台对应哪个显卡，哪个链路的信息会发布在GPU 专用服务器上，并在多 GPU 和多节点环境下进行跨平台比较。

接下来该去哪里？

这一页的两侧。

本页面仅包含一个问题：运行模型需要哪些条件。所有相关内容都有各自的页面，本页面即为所有相关页面。

之前问过

本页旨在解答以下八个问题。

这些问题取材于用户在聊天和工单中实际提出的问题，大致按提问顺序排列。前两个问题决定了购买是否成功。

大型语言模型需要多少GPU内存？: 权重是参数数量乘以每个参数的字节数：16 位参数每个参数占用 2 个字节，8 位参数占用 1 个字节，4 位参数占用一半字节。一个 70 亿到 80 亿参数的模型需要 16 GB 的 16 位权重、8 GB 的 8 位权重和 5 GB 的 4 位权重；一个 700 亿参数的模型则分别需要 140 GB、70 GB 和 38 GB 的权重。这些数字仅指权重本身，只是最低要求，并非硬性规定——运行时间、激活函数和键值缓存还需要额外预留四分之一到一半的空间。
为什么我的模型可以加载但却无法提供服务？: 因为卡片内存中不仅包含权重信息。运行时及其缓冲区也驻留在卡片内存中，对话中的每个标记都会在键值缓存中留下一个条目，因此无需重新计算。该缓存会随着上下文长度的增长以及并发请求数量的增加而增长，因此权重刚好合适的模型大约只能容纳一次较短的对话。卡片大小应设置为权重的 1.25 到 1.5 倍。
我可以安装哪个推理运行时？: 任何一种都可以。机器出厂时已安装干净的操作系统并获取了 root 权限，并且前端没有任何厂商推断服务。vLLM 是处理实际流量的常用方案，因为连续批处理允许一张卡同时响应多个请求。llama.cpp 是内存紧张或卡较旧时的常用方案。TGI 和 SGLang 无需修改即可运行。Ollama 是从一台空机器到在端口上响应的模型的最短路径。您需要将驱动程序、CUDA 或 ROCm 版本以及框架锁定到代码测试所用的版本。
我每秒能获得多少个代币？: 我们不公布每秒令牌数，因为每个此类数字都取决于模型、量化、运行时及其版本、批处理大小、提示长度、回复长度和并发度，任何一项的改变都会导致该数字成倍变化。其影响因素包括：读取提示受计算资源限制，且每个请求仅需读取一次；生成回复受内存带宽限制，因为每个令牌都需要读取权重；批处理可以将读取操作分摊到并发请求中，这使得服务在键值缓存耗尽之前保持经济高效。请提供模型、量化和预期并发度，以便我们根据实际观察结果给出答案。
这块GPU是和其他用户共用的吗？: 不。每台物理机仅限一个租户，显卡直接传递给您自己的操作系统。没有虚拟机管理程序、MIG 分区、vGPU 配置和时间片轮转调度器，因此显卡上不会运行其他任何程序，推理延迟也不会因为其他人的批处理作业而发生变化。
如果模型无法在一张卡片上显示怎么办？: 那么，这就是多卡配置方案，这种方案是按需报价而非直接下单：能装下多少张卡取决于特定卡的物理宽度和机箱的功耗预算。两张卡才能发挥它们的总内存，前提是运行时环境能够将模型分配到两张卡上，而几乎所有主流的运行时环境都支持这种做法，但会牺牲一定的吞吐量。多张卡或多台机器就能满足这种配置需求。
微调操作比服务操作需要更多内存吗？: 远不止如此。运行模型需要权重；训练模型则需要同时存储权重、梯度以及每个待更新参数的优化器状态，此外还需要保留用于反向传播的激活值。一个能在单卡上运行的模型，其规模可能远超单卡进行完全微调所需的内存。参数高效的方法只需更新一小部分参数，因此所需的额外内存也相应较少，这也是为什么大多数微调方法都只使用单卡的原因。
我可以使用AMD显卡吗？ROCm能用吗？: 是的。AMD Instinct 系列内存是我们能安装的容量最大的内存条之一，而且通常每 GB 的性价比最高，但您的系统必须支持 ROCm 而不是 CUDA。目前大多数推理运行时都支持 ROCm，但一些相关的工具仍然不支持。请在订购前咨询我们，我们会根据您的具体运行时进行检查，而不是给出笼统的答案。

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.