8GB Mac 高效运行 Gemma 4 26B

8GB Mac 高效运行 Gemma 4 26B | 前端进阶之旅

Full translation

完整中文译文

TurboFieldfare 可以在配备 8GB 内存的 Apple Silicon Mac 上运行纯文本版 Gemma 4 26B A4B 模型，进程占用大约为 1.9–2.1GB。它实现这一点的方式是：将 4K FP16 KV cache 和共享核心常驻内存，同时从占用 14.3GB SSD 空间的安装目录中流式加载被路由选中的 experts。本指南将介绍如何配置该 runtime，并如实测量这套配置的表现。

下面的命令和 API contract 来自 TurboFieldfare 项目文档。由于当前写作环境并非 Apple Silicon，本稿中的命令尚未实际执行。请在目标 Mac 上运行验证步骤，并在发布前补充真实输出。

2GB 这个数字意味着什么

Gemma 4 26B A4B 总共有大约 25.2B 参数，每个 token 会激活大约 3.8B 参数。由于每个 token 会使用 128 个 routed experts 中的 8 个，再加上一个 shared expert，因此 TurboFieldfare 可以维持一个容量有限的 expert cache，并从 SSD 流式加载缺失的 experts。

参考配置如下：

项目报告的性能数据是：在配备 8GB 内存的 M2 MacBook Air 上，decode 速度为 5.10–6.30 tok/s；在配备 24GB 内存的 M5 Pro 上，速度为 31–35 tok/s。这些是项目方的测量结果，并非 Google benchmark，而且不包含安装、模型加载和 prompt prefill 所需的时间。

第 1 步：检查 Mac

确认处理器架构、macOS 版本、Swift toolchain、可用存储空间和内存压力：

uname -m
sw_vers
swift --version
df -h .
memory_pressure -Q

预期的前置条件：

uname -m 返回 arm64。

macOS 版本为 26 或更高版本。

Swift 版本为 6.2 或更高版本。

首次安装至少需要 16GB 可用存储空间；此外还应为构建过程和系统正常运行预留额外空间。

加载模型之前，内存压力应处于健康状态。

关闭其他本地模型 runtime 和占用大量内存的应用程序。TurboFieldfare 文档建议同一时间只运行一个持有模型的进程。

第 2 步：构建 TurboFieldfare

克隆仓库并构建 release package：

git clone https://github.com/drumih/turbo-fieldfare.git
cd turbo-fieldfare
swift build -c release

启动原生 Mac 应用：

.build/release/TurboFieldfareMac

等待大约 15GB 的数据传输和重新打包过程完成。

确认安装完成后的模型占用大约 14.3GB 空间。

先使用默认的 4K context 和 16 个 expert-cache slots。

输入一个简短的 prompt 并生成响应。

安装程序会把远程 byte ranges 流式写入 .gturbo 布局，并验证最终生成的 manifest 和文件哈希。它不需要额外落盘一份完整的 checkpoint。

第 3 步：通过 CLI 验证安装

如果你更喜欢使用命令行，可以通过以下命令安装或继续安装模型：

swift run -c release TurboFieldfareRepack \
  --output scratch/gemma4.gturbo \
  --overwrite \
  --resume

在不加载模型的情况下验证已完成的安装：

swift run -c release TurboFieldfareRepack \
  --verify-install \
  --input-gturbo scratch/gemma4.gturbo

不要把不完整的目录当作模型安装目录。runtime 只接受包含最终 manifest.json 的完整 .gturbo 目录。

第 4 步：运行确定性的 CLI 冒烟测试

使用 greedy decoding 运行一次简短的原始 completion：

swift run -c release TurboFieldfareCLI \
  --model scratch/gemma4.gturbo \
  --prompt "The capital of France is" \
  --max-new 64 \
  --temperature 0

生成的文本会写入 standard output，计时统计则会写入 standard error。记录 commit、硬件型号、操作系统、Swift 版本、prompt 长度、生成的 token 数、context 设置、expert-cache slots、TTFT、decode rate 和 peak memory。

一次简短的 completion 只能算冒烟测试，不能算 benchmark。

第 5 步：启动本地 Chat Completions server

首先确认没有其他持有模型的进程正在运行：

pgrep -fl 'TurboFieldfareServer|TurboFieldfareMac|TurboFieldfareDecodeService|TurboFieldfareCLI|mlx_lm|mlx-lm'

如果该命令输出了仍在运行的模型进程，请先以正常方式停止该进程，再启动 server。

构建并启动 loopback server：

swift build -c release --product TurboFieldfareServer
.build/release/TurboFieldfareServer \
  --model scratch/gemma4.gturbo \
  --port 8080 \
  --max-context 4096

使用 --max-context 4096，可以让本教程与“约 2GB”这一结论所依据的 4K context 保持一致。项目文档中的 server 示例使用 16K，但更大的 FP16 KV cache 会消耗更多内存。

等待出现 TurboFieldfareServer ready，然后在另一个终端中执行客户端检查。

第 6 步：检查健康状态和 model ID

curl --silent --show-error http://127.0.0.1:8080/health
curl --silent --show-error http://127.0.0.1:8080/v1/models

发送一个确定性请求：

curl --silent --show-error http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemma-4-26b-a4b-it",
    "messages": [
      {"role": "user", "content": "Reply with exactly READY."}
    ],
    "temperature": 0,
    "max_completion_tokens": 16
  }'

本地 model ID 与官方托管模型的 ID 相同，但两者提供的接口能力并不等价。TurboFieldfare 的 server 支持 Chat Completions、streaming、function-tool declarations 和 single-prefix reuse。它不支持 Responses API、embeddings、multimodal input、structured output、batching、log probabilities 或远程模型切换。

第 7 步：测量 TTFT 和 decode throughput

创建一个独立的 Python 环境并安装 OpenAI client：

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip 'openai>=1.60,<3'

将以下内容保存为 measure_local_gemma.py：

from __future__ import annotations

import json
import time
from dataclasses import asdict, dataclass

from openai import OpenAI

@dataclass
class Result:
    time_to_first_text_seconds: float | None
    total_seconds: float
    completion_tokens: int | None
    measured_decode_tokens_per_second: float | None
    text: str

client = OpenAI(
    base_url="http://127.0.0.1:8080/v1",
    api_key="local",
)

started = time.perf_counter()
first_text_at: float | None = None
parts: list[str] = []
completion_tokens: int | None = None

stream = client.chat.completions.create(
    model="gemma-4-26b-a4b-it",
    messages=[
        {
            "role": "user",
            "content": (
                "Explain mixture-of-experts routing in 150 to 200 words. "
                "Use plain language and no bullet points."
            ),
        }
    ],
    temperature=0,
    max_completion_tokens=256,
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    now = time.perf_counter()
    if chunk.choices:
        content = chunk.choices[0].delta.content or ""
        if content:
            if first_text_at is None:
                first_text_at = now
            parts.append(content)

    if chunk.usage is not None:
        completion_tokens = chunk.usage.completion_tokens

finished = time.perf_counter()
text = "".join(parts)
ttft = None if first_text_at is None else first_text_at - started
decode_seconds = None if first_text_at is None else finished - first_text_at
decode_rate = (
    None
    if not completion_tokens or not decode_seconds or decode_seconds <= 0
    else completion_tokens / decode_seconds
)

result = Result(
    time_to_first_text_seconds=ttft,
    total_seconds=finished - started,
    completion_tokens=completion_tokens,
    measured_decode_tokens_per_second=decode_rate,
    text=text,
)

print(json.dumps(asdict(result), indent=2, ensure_ascii=False))

在本地 server 运行期间执行：

python measure_local_gemma.py | tee local-gemma-result.json

客户端侧的 decode 计算只是近似值，因为最终的 usage chunk 和网络缓冲都会影响计时。应将 server 输出的计时结果作为主要 decode 指标，而该脚本的数据则作为端到端的客户端观测结果。

第 8 步：创建可复现的结果表格

不要把单次运行结果当作硬件性能保证来发布。先进行一次 warmup，然后在新的进程中使用固定 prompts 重复测试，并记录所有测试条件。

项目自己的 benchmark protocol 使用固定 prompts，并要求输出内容连贯、没有重复。在将某项结果描述为可比较数据之前，请遵循这一方法。

将 server 保持在 loopback 上

本地 server 绑定到 127.0.0.1，并且不提供 authentication 或 TLS。项目明确说明，不要通过 proxy 或 tunnel 暴露它。

对于本地工具，应让 client 与 server 运行在同一台 Mac 上。如果需要提供远程或多用户的生产访问，不要只是简单修改 bind address。你应该设计一个独立的 serving layer，其中包含 authentication、authorization、TLS、request limits、queueing、process supervision、readiness checks、memory-pressure 和 SSD metrics、privacy-aware logging、overload handling 以及 failover。

模型生成的 tool calls 同样需要客户端批准。server 返回的只是一个执行建议；是否允许该工具执行，由应用程序决定。

本地 API 与官方 API

Google 官方托管模型的 ID 同样是 gemma-4-26b-a4b-it。Gemini API 提供文本和图像输入、托管基础设施、function calling，以及最高 256K 的 model context。

Google 目前将 Gemma 4 列在其 API free tier 中，但没有列出 Gemma 4 的付费 tier。在用于生产环境之前，请重新检查 pricing page 和 data-use terms。free-tier content 可能会被用于改进 Google 产品。

截至 2026 年 7 月 30 日，CometAPI 尚未列出 Gemma 4 26B。不要把本教程中的 model ID 指向 CometAPI。若要使用托管版 Gemma 4，请使用 Google 官方 API，除非其他 provider 明确列出了完全相同的模型。

应该比较哪些指标？

本地和托管两种调用方式应使用相同的 prompts 和 acceptance criteria。记录以下指标：

peak memory 和 SSD reads；
queue 和 concurrency behavior；
structured-output validity；
retries 和 human correction；
total operating cost。

Resident RAM 只是其中一个指标，不能单独决定部署方案。

如需采取进一步措施，你可以考虑屏蔽此人和／或举报滥用行为。