Laya 显存需求:三个模型、全部文件与运行方式

Laya 是基于 ModernBERT 的决策编码器,不是对话 LLM:输入文本和类型化问题,一次前向返回校准概率。选择模型、文件和输入长度,查看峰值内存和哪些显卡装得下。

– 估算峰值内存

权重: – 即文件大小;其余是一次前向的激活值,再加 0.5 GB 运行时开销。

显存4 GB6 GB8 GB12 GB16 GB24 GB
结果––––––

没有 GPU 时,同样的量从系统内存中占用: –.

“勉强”表示只有运行时使用融合注意力内核(不保存完整注意力分数矩阵)时才装得下。

16 GB、24 GB 显卡或纯 CPU 能跑 Laya 吗?

都能。已发布的最大文件是 850 MB,按默认输入长度,每个文件的峰值都在 0.76 GB–1.40 GB,所以 16 GB 或 24 GB 显卡只用到不到十分之一,4 GB 显卡也够。没有 GPU 时模型从系统内存运行,空闲 3 GB 就足够,连需要加载两份模型的 llama.cpp 方式也够用。硬件决定的是速度而不是能否运行:GPU 上每次请求几十毫秒,CPU 上几百毫秒(见下方实测)。

全部 Laya 文件:大小与内存

每个模型按默认输入长度计算(English 为 512 token,typed-decisions 和 multilingual 为 1,024),每次前向 1 行。大小是 Hugging Face 列出的已发布文件,单位 MB;内存单位为 GB(GiB)。

模型运行方式格式 文件大小峰值内存 16 GB24 GB纯 CPU(内存)
Laya (English) PyTorch(laya 包) F16 model.safetensors 843 MB 1.30 GB–1.30 GB 可以 可以 1.30 GB
Laya (English) ggmlc laya 程序 F16 laya_english_f16.gguf 846 MB 1.31 GB–1.33 GB 可以 可以 1.33 GB
Laya (English) ggmlc laya 程序 Q8_0 laya_english_q8_0.gguf 452 MB 0.95 GB–0.96 GB 可以 可以 0.96 GB
Laya (English) ggmlc laya 程序 UD_Q4_K_M laya_english_ud_q4_k_m.gguf 420 MB 0.92 GB–0.93 GB 可以 可以 0.93 GB
Laya (English) llama.cpp + 决策头 F16 laya-F16.gguf 791 MB
另加决策头 106 MB
1.26 GB–1.28 GB 可以 可以 2.66 GB
Laya (English) llama.cpp + 决策头 Q8_0 laya-Q8_0.gguf 421 MB
另加决策头 106 MB
0.92 GB–0.93 GB 可以 可以 2.32 GB
Laya (English) llama.cpp + 决策头 Q6_K laya-Q6_K.gguf 344 MB
另加决策头 106 MB
0.85 GB–0.86 GB 可以 可以 2.24 GB
Laya (English) llama.cpp + 决策头 Q4_K_M laya-Q4_K_M.gguf 272 MB
另加决策头 106 MB
0.78 GB–0.79 GB 可以 可以 2.18 GB
Laya typed-decisions PyTorch(laya 包) F16 model.safetensors 843 MB 1.31 GB–1.34 GB 可以 可以 1.34 GB
Laya typed-decisions ggmlc laya 程序 F16 laya_typed_decisions_f16.gguf 850 MB 1.34 GB–1.40 GB 可以 可以 1.40 GB
Laya typed-decisions ggmlc laya 程序 Q8_0 laya_typed_decisions_q8_0.gguf 455 MB 0.97 GB–1.04 GB 可以 可以 1.04 GB
Laya typed-decisions ggmlc laya 程序 UD_Q4_K_M laya_typed_decisions_ud_q4_k_m.gguf 424 MB 0.94 GB–1.01 GB 可以 可以 1.01 GB
Laya typed-decisions llama.cpp + 决策头 F16 laya-typed-decisions-F16.gguf 791 MB
另加决策头 106 MB
1.29 GB–1.35 GB 可以 可以 2.73 GB
Laya typed-decisions llama.cpp + 决策头 Q8_0 laya-typed-decisions-Q8_0.gguf 421 MB
另加决策头 106 MB
0.94 GB–1.00 GB 可以 可以 2.39 GB
Laya typed-decisions llama.cpp + 决策头 Q6_K laya-typed-decisions-Q6_K.gguf 344 MB
另加决策头 106 MB
0.87 GB–0.93 GB 可以 可以 2.32 GB
Laya typed-decisions llama.cpp + 决策头 Q4_K_M laya-typed-decisions-Q4_K_M.gguf 272 MB
另加决策头 106 MB
0.80 GB–0.87 GB 可以 可以 2.25 GB
Laya multilingual PyTorch(laya 包) F16 model.safetensors 644 MB 1.11 GB–1.14 GB 可以 可以 1.14 GB
Laya multilingual ggmlc laya 程序 F16 laya_multilingual_f16.gguf 663 MB 1.15 GB–1.19 GB 可以 可以 1.19 GB
Laya multilingual ggmlc laya 程序 Q8_0 laya_multilingual_q8_0.gguf 362 MB 0.86 GB–0.91 GB 可以 可以 0.91 GB
Laya multilingual ggmlc laya 程序 UD_Q4_K_M laya_multilingual_ud_q4_k_m.gguf 524 MB 1.02 GB–1.06 GB 可以 可以 1.06 GB
Laya multilingual llama.cpp + 决策头 F16 laya-multilingual-F16.gguf 629 MB
另加决策头 60 MB
1.11 GB–1.16 GB 可以 可以 2.32 GB
Laya multilingual llama.cpp + 决策头 Q8_0 laya-multilingual-Q8_0.gguf 341 MB
另加决策头 60 MB
0.85 GB–0.89 GB 可以 可以 2.05 GB
Laya multilingual llama.cpp + 决策头 Q6_K laya-multilingual-Q6_K.gguf 271 MB
另加决策头 60 MB
0.78 GB–0.83 GB 可以 可以 1.98 GB
Laya multilingual llama.cpp + 决策头 Q4_K_M laya-multilingual-Q4_K_M.gguf 249 MB
另加决策头 60 MB
0.76 GB–0.81 GB 可以 可以 1.96 GB

更长的输入和更大的批量

内存随“行数 × token 数”增长,注意力分数随长度的平方增长。即使是这里最重的情况,laya-multilingual 读取一篇 8,192 token 的文档,也不到 5 GB。

负载峰值内存4 GB6 GB8 GB16 GB24 GB
Laya English,PyTorch,32 行 × 512 token1.68 GB–1.93 GB可以可以可以可以可以
Laya English,PyTorch,64 行 × 512 token2.08 GB–2.58 GB可以可以可以可以可以
multilingual,PyTorch,1 篇文档 × 8,192 token1.21 GB–2.71 GB可以可以可以可以可以
multilingual,ggmlc F16,1 篇文档 × 8,192 token1.34 GB–4.34 GB勉强可以可以可以可以

在本地运行 Laya 的三种方式

1. PyTorch:laya Python 包

官方参考方式,也是唯一能运行全部三个模型并把每个请求自动路由到合适模型的方式。首次使用时下载 safetensors 文件,可在 CUDA、Apple GPU 或 CPU 上运行。PyPI、GitHub。

pip install laya
from laya import Router

router = Router()  # Router(preload=True) loads all three checkpoints up front
result = router.predict(
    "We were billed twice for March. Please refund the duplicate.",
    {"churn_risk": {"type": "noul", "instructions": "Does the user threaten to leave?"}},
)
print(result["answers"]["churn_risk"]["noul"])  # probability of yes

2. ggmlc:独立的 laya 程序

从 ggmlc 发布页下载一个程序即可运行 mys/laya-*-GGUF 文件,无需 Python:有 CUDA 或 Metal 时使用 GPU,否则用 CPU。它提供命令行、带网页的 HTTP 服务和 JSON-RPC 守护进程。这些 GGUF 是 ggmlc 自己的格式,llama.cpp 无法加载。

huggingface-cli download mys/laya-GGUF laya_english_f16.gguf --local-dir .
laya decide laya_english_f16.gguf --preset email --device auto

3. llama.cpp:编码器用 llama-server,决策头用 Python

fr0stbit3/laya-*-gguf 文件只包含 ModernBERT 编码器,由 llama-server 以逐 token 向量的形式提供。决策头在同目录的 -head.safetensors 文件中,需要用 laya 包在 Python 里运行,而 laya 包仍会下载一次原始权重。模型卡说明这些文件只做过少量测试,建议用 F16 或 Q8_0。

llama-server -m laya-F16.gguf --embeddings --pooling none -c 2048 -ub 2048 -b 2048 --port 8080

Ollama

Ollama 官方库里没有 Laya。社区上传的 s1gnature/laya 是一个嵌入模型:ollama embed 返回的是编码器向量,而不是 Laya 的答案,因为其中不包含决策头。ollama run 也无法和它对话:Laya 不生成文本。

Laya 不是 LLaVA

名字相近,模型完全不同。LLaVA 是视觉语言对话模型(7B–34B 的 LLM 加图像编码器),会针对图片生成文字,Ollama 默认下载就有 4.7–20 GB。Laya 是 0.3–0.4B 的文本编码器加决策头:输入一段文本或 JSON“状态”和类型化问题(选择、打分、是/否),一次前向就返回校准过的概率。它从不生成 token,不读图片,也没有 KV 缓存,所以本站的 LLM 计算器都不适用于它。

公开数据与 ModelVRAM 速度实测

硬件运行方式负载耗时来源
RTX PRO 6000 Blackwell Server Editionlaya 0.4.1, eager, FP32 weights / BF16 AMPModelVRAM 实测:英文,495 个输入 token,1 个问题12.48 ms median, 3 calls after warmup measurements/2026-10-09/laya-english.json
RTX PRO 6000 Blackwell Server Editionlaya 0.4.1, eager, FP32 weights / BF16 AMPModelVRAM 实测:typed-decisions,968 个输入 token,1 个问题14.46 ms median, 3 calls after warmup measurements/2026-10-09/laya-typed-decisions.json
RTX PRO 6000 Blackwell Server Editionlaya 0.4.1, eager, FP32 weights / BF16 AMPModelVRAM 实测:多语言,492 个输入 token,1 个问题10.63 ms median, 3 calls after warmup measurements/2026-10-09/laya-multilingual.json
Tesla T4(16 GB)PyTorch (laya package)Laya English,一次 1 个问题 / 一次 10 个问题39.5 ms / 158.6 ms convaiinnovations/laya
Tesla T4(16 GB)PyTorch (laya package)Laya multilingual,一次 1 个问题 / 一次 10 个问题32.8 ms / 72.3 ms convaiinnovations/laya
CPUPyTorch, Router(preload=True)一次请求,模型已预加载193–464 ms convaiinnovations/laya
RTX 4050 笔记本(6 GB)ggmlc laya, F16, --cuda-graph1 个是/否问题 / 7 个问题的 email 预设,一次 B=7 前向25 ms / 143 ms mys/laya-GGUF
Apple GPUPyTorch (laya package)Laya multilingual,一篇 4,000 token 文档,max_len=8192about 1.7 s convaiinnovations/laya

有多快:每次决策多少毫秒、每秒多少次

这类编码器很少受显存限制,真正要看的是速度。选模型、GPU、每行读多少 token、一次决策要几行,就能看到每次决策的耗时,以及这张卡每秒能处理多少次决策。

Laya:对同一段文本每问一个问题算一行。

– 每次决策

一次只处理一个请求: – 次/秒

许多请求合批处理: – 次/秒

Laya (English),每行 512 token,每次决策一行

GPU每次决策逐个处理合批处理
RTX 4070 12GB20–68 ms15–51 次/秒36–51 次/秒
RTX 5070 12GB15–66 ms15–68 次/秒38–68 次/秒
RTX 5070 Ti 16GB11–58 ms17–91 次/秒54–91 次/秒
RTX 5080 16GB10–54 ms18–97 次/秒70–97 次/秒
RTX 309011–63 ms16–95 次/秒44–95 次/秒
RTX 40909.8–50 ms20–102 次/秒102 次/秒
RTX 50905.5–48 ms21–182 次/秒130–182 次/秒
L40S4.5–51 ms19–224 次/秒88–224 次/秒
A100 80GB4.8–45 ms22–207 次/秒193–207 次/秒
H100 SXM1.6–43 ms23–612 次/秒339–612 次/秒
H2001.6–42 ms24–612 次/秒486–612 次/秒

不做估算:CPU、Apple Silicon、AMD 和 Intel 显卡,以及 NVIDIA 没有公布 BF16 张量算力的型号(RTX 3060、4060、4060 Ti、5060 Ti、4070 Ti Super、4080 Super、RTX PRO 6000、B200、DGX Spark)。

估算方法

  • 实测基准。ModernBERT 论文(表 2)在一张 RTX 4090 上实测了每秒处理的 token 数:ModernBERT-large 在 512 token 时 52,300、8,192 token 时 46,800;ModernBERT-base 为 148,100 和 123,700;DeBERTa-v3-large 在 512 token 时 24,600,输入长短不一、需要补齐时只有一半。Laya English 和 typed-decisions 是 ModernBERT-large;Laya multilingual 是 mmBERT-base,结构和非嵌入参数量与 ModernBERT-base 相同(mmBERT 论文第 3.1 节)。
  • 换算到其他 GPU。编码器的耗时一部分是矩阵运算,随张量算力变化;一部分是显存读写,随带宽变化。所以相对 RTX 4090 的速度落在两个比值之间,范围的两端分别按这两个比值算。张量算力用 NVIDIA 公布的 BF16 稠密值(RTX Blackwell 架构白皮书附录,L40S、A100、H100、H200 页面,稀疏值除以 2);带宽与LLM 速度计算器用的相同。
  • 每次决策。下限是 GPU 满负荷处理你这一个请求,且不低于把权重读一遍的时间。上限再加上每次调用 40 ms 的固定开销:laya 包公布的单问题耗时在 Tesla T4 上是 39.5 ms 和 32.8 ms,ggmlc 在 RTX 4050 笔记本上是 25 ms(模型卡);对短问题来说,这些时间大多花在分词、Python 和内核启动上,而不是计算。编译过模型、合批处理的服务接近下限;每个请求单独调用一次 laya 包接近上限。
  • 合批处理。请求足够多、每次前向都能把 GPU 占满时,每秒能完成的决策数:每秒 token 数除以一次决策的 token 数。在 RTX 4090 上就是论文的实测值,所以两端相同;在其他卡上,实际服务应落在这个范围内;如果把请求补齐到同一长度,会更低(ModernBERT 会去掉补齐,不受影响)。
  • 没有建模的情况:ggml 和 llama.cpp 运行时(F32 激活、不同的内核)、TensorRT 等 INT8/FP8 引擎、笔记本 GPU 和功耗限制。核对日期:2026-09-29。

ModelVRAM 于 2026-10-09 在单张 RTX PRO 6000 Blackwell Server Edition 上实测,每个版本使用独立进程:英文、typed-decisions、多语言的 CUDA 峰值已分配内存分别为 2.27、2.28、1.47 GiB;调用结束后 nvidia-smi 分别显示 3.14、3.15、2.18 GiB。运行环境为 PyTorch 2.8.0 / CUDA 12.8,FP32 权重、BF16 自动混合精度。输入分别为 495、968、492 token;每次一个问题。分配内存不含驱动开销和未使用的缓存;这组样例不代表一般准确率。 测量脚本.

文件大小于 从 Hugging Face API 读取;层数来自各模型的 encoder/config.json。权重大小是精确值;激活内存根据结构估算(每次只保留一层编码器的张量,PyTorch 为 BF16,ggml 为 F32),另加固定 0.5 GB 运行时开销。 仓库: convaiinnovations/laya、mys/laya-GGUF、fr0stbit3/laya-gguf、convaiinnovations/laya-typed-decisions、mys/laya-typed-decisions-GGUF、fr0stbit3/laya-typed-decisions-gguf、convaiinnovations/laya-multilingual、mys/laya-multilingual-GGUF、fr0stbit3/laya-multilingual-gguf

对话类 LLM 请用 LLM 显存计算器。

常见问题

Laya 需要多少显存?

不到 1.5 GB。最大的文件是 850 MB(typed-decisions 的 ggmlc F16),按默认输入长度一次前向的峰值为 0.76–1.40 GB,含 0.5 GB 运行时开销。批量 64 行 × 512 token 也只需约 2.1–2.6 GB。

没有 GPU 能跑 Laya 吗?

能。laya Python 包和 ggmlc 的 laya 程序都支持纯 CPU,内存占用与上表相同(约 1–1.5 GB)。官方模型卡给出的 CPU 耗时为每次请求 193–464 ms(模型已预加载)。

Laya 和 LLaVA 是同一个模型吗?

不是。LLaVA 是 7B–34B 的视觉语言对话模型;Laya 是 0.3–0.4B 的文本分类/决策编码器,不生成文字,也不读图片。

Ollama 能运行 Laya 吗?

Ollama 官方库没有 Laya。社区上传的 s1gnature/laya 只能用 ollama embed 输出编码器向量,不包含决策头,得不到 Laya 的答案。要完整运行,请用 laya Python 包或 ggmlc 的 laya 程序。

三个 Laya 模型有什么区别?

Laya English 和 typed-decisions 基于 ModernBERT-large(4.21 亿参数,28 层);multilingual 基于 mmBERT-base(3.22 亿参数,22 层),支持 100 多种语言,可读 8,192 token 的长文档。

Laya 有多快:每次决策多少毫秒、每秒多少次?

在 RTX 4090 上,Laya English 处理一个 512 token 的问题估计需要 9.8–50 ms:下限对应合批处理的服务,上限对应每个请求单独调用一次 laya 包。合批处理时,这张卡每秒约能完成 102 次这样的决策。估算由 ModernBERT 论文的 RTX 4090 实测换算而来;模型卡自己在 Tesla T4 上测得每个问题 39.5 ms。

更多计算器

更新于