本地运行 Gemma 4 需要多少 RAM？

Gemma 4 E2B 和 E4B 在 4-bit 量化下仅需 5GB RAM 即可运行——任何现代笔记本电脑都符合要求。26B MoE 模型需要约 18GB RAM (适用于 RTX 4090 的 24GB VRAM)。31B Dense 模型需要约 20GB RAM。对于仅限 CPU 的执行，请在模型权重大小的基础上增加 20-30% 的 RAM。

我应该选择哪个 Gemma 4 模型进行本地使用？

对于没有独立 GPU 的笔记本电脑：E2B (最快、最轻量)。对于带有 GPU 的笔记本电脑或台式机：E4B (质量更好，依然轻量)。对于配备 RTX 4090 或同等配置的台式机：26B MoE (最佳质量计算比)。对于具有 24GB+ VRAM 的工作站：31B Dense (最高质量)。26B MoE 是大多数开发者的理想平衡点。

Gemma 4 本地使用是免费的吗？

是的。Gemma 4 在 Apache 2.0 协议下发布，允许包括商业应用在内的不受限使用。Ollama 也是免费且开源的。唯一的成本是您的硬件。没有 API 费用，没有使用限制，也没有许可限制。

与云端 API 相比，本地运行 Gemma 4 的速度如何？

在 RTX 4090 上，Gemma 4 E4B 每秒生成 80-120 tokens。26B MoE 每秒生成 30-50 tokens。31B Dense 每秒生成 20-35 tokens。像 Google AI Studio 这样的云端 API 在处理超大型模型时可能更快，但每次请求会增加 100-500ms 的网络延迟。对于交互式使用，在较小模型上的本地推理感觉是瞬时的。

我可以将本地运行的 Gemma 4 作为我应用程序的 API 使用吗？

是的。Ollama 在端口 11434 上公开了一个与 OpenAI API 格式兼容的本地 REST API。任何支持 OpenAI API 的应用程序、框架或工具都可以通过将 base URL 指向 http://localhost:11434/v1 来连接到本地 Gemma 4。这包括 Python, Node.js 和大多数 AI 框架。

Gemma 4 在 Ollama 中支持 GPU 加速吗？

是的。Ollama 自动检测并使用 NVIDIA GPU (CUDA)、Apple Silicon (Metal) 和 AMD GPU (ROCm)。无需额外配置——如果您的 GPU 有足够的 VRAM 来容纳模型，Ollama 将自动使用它。NVIDIA 还发布了针对 RTX 优化的 Gemma 4 版本，以获得额外的性能提升。

核心要点

使用 Ollama 在本地运行 Gemma 4 只需不到 5 分钟：安装 Ollama，运行一条命令，您就可以在自己的硬件上拥有一个功能齐全的 AI 模型，API 成本为零，数据不会离开您的机器，且在 Apache 2.0 协议下没有任何使用限制。E2B 模型可以在任何笔记本电脑上运行。26B MoE 模型可以适配单个 RTX 4090，并提供足以媲美活动参数量高出 10x 的模型的质量。

在本地运行 Gemma 4：完整指南

为什么要在本地运行 Gemma 4？

在深入了解设置之前，以下是 2026 年本地推理至关重要的原因：

隐私 — 您的数据永远不会离开您的机器。不会将提示词发送到外部服务器。这对于专有代码、法律文档、医疗数据或任何敏感信息都至关重要。
成本 — 在一次性硬件投资之后，每个 token 的成本为零。与 API 定价相比，重度用户每月可节省数百美元。
延迟 — 没有网络往返。E2B 和 E4B 模型在现代硬件上的响应时间以毫秒计。
可靠性 — 没有 API 速率限制，没有停机，没有供应商政策变更。您的模型始终可用。
自定义 — 在 Apache 2.0 协议下自由地微调、量化和修改模型。
离线访问 — 模型下载完成后，无需互联网连接即可工作。

Gemma 4 特别适合本地部署，因为 Google 专门为边缘和设备端使用设计了较小的模型。E2B 和 E4B 模型并非事后才想到的产物，而是针对本地硬件限制而优化的顶级模型。

前提条件

各模型的硬件要求

模型	最小 RAM	推荐 VRAM	仅 CPU 可行？	磁盘空间
E2B (4-bit)	5 GB	4 GB	是	~1.5 GB
E4B (4-bit)	5 GB	4 GB	是	~2.8 GB
E4B (FP16)	9 GB	9 GB	慢	~9 GB
26B MoE (4-bit)	18 GB	16 GB	非常慢	~15 GB
26B MoE (FP16)	52 GB	48 GB	否	~52 GB
31B Dense (4-bit)	20 GB	18 GB	非常慢	~18 GB
31B Dense (FP16)	62 GB	48 GB+	否	~62 GB

核心提示：如果您拥有一台 2022 年以后生产的笔记本电脑，就可以运行 E2B 或 E4B。如果您拥有 RTX 4090 (24GB VRAM) 或配备 32GB+ RAM 的 Apple M-series Mac，则可以运行 4-bit 量化版的 26B MoE 或 31B Dense。

软件要求

操作系统：macOS, Linux, 或 Windows
Ollama：版本 0.6+ (从 ollama.com 下载)
GPU 驱动程序（可选）：NVIDIA GPU 需要 NVIDIA CUDA 12+，Apple Silicon 不需要额外驱动程序

步骤 1：安装 Ollama

macOS

从 ollama.com/download 下载或使用 Homebrew：

brew install ollama

Linux

单行安装脚本：

curl -fsSL https://ollama.com/install.sh | sh

Windows

从 ollama.com/download 下载安装程序并运行。Ollama 在 Windows 上作为后台服务运行。

验证安装

ollama --version

您应该看到 ollama version 0.6.x 或更高版本。如果看到版本号，说明 Ollama 已正确安装。

来源：Ollama 安装指南

步骤 2：拉取 Gemma 4 模型

选择与您的硬件匹配的模型：

针对笔记本电脑和轻量级工作负载

# 最小的模型 — 可在任何现代笔记本电脑上运行 (5GB RAM)
ollama pull gemma4:e2b

# 具有更广泛能力的模型 (5-9GB RAM)
ollama pull gemma4:e4b

针对配有独立 GPU 的台式机

# 最佳效率 — 3.8B 活动参数即可提供旗舰级质量 (18GB RAM)
ollama pull gemma4:26b-moe

# 最高质量 — 完整的 31B 参数 (20GB RAM)
ollama pull gemma4:31b

指定量化版本

默认情况下，Ollama 会拉取每个模型的推荐量化版本（通常是 Q4_K_M，以获得良好的质量与大小平衡）。您可以指定不同的量化版本：

# 质量更高，体积更大
ollama pull gemma4:31b-q5_K_M

# 体积更小，质量稍低
ollama pull gemma4:31b-q3_K_M

# 全精度（需要更多 RAM）
ollama pull gemma4:31b-fp16

下载将根据您的互联网连接速度持续几分钟。模型大小从约 1.5GB (E2B 4-bit) 到约 62GB (31B FP16) 不等。

步骤 3：运行 Gemma 4

交互式对话

ollama run gemma4:e4b

这将打开一个交互式对话会话。输入您的提示词并按回车键：

>>> What are the key differences between REST and GraphQL APIs?

模型将直接在您的终端中响应。输入 /bye 退出。

单次提示（非交互式）

echo "Explain the Builder design pattern in Python with an example" | ollama run gemma4:26b-moe

使用思考模式

Gemma 4 支持为复杂任务配置思考模式。通过添加系统提示词来启用它：

ollama run gemma4:31b --system "Think step by step before answering. Show your reasoning process."

对于数学、逻辑和复杂的分析任务，思考模式能显著提高回答质量。模型在产生最终响应之前，会生成 4,000+ tokens 的内部推理。

步骤 4：使用本地 API

Ollama 在 localhost:11434 上暴露了一个与 OpenAI API 格式兼容的 REST API。这意味着任何支持 OpenAI API 的工具或库都可以通过更改 URL 连接到您的本地 Gemma 4。

使用 curl 测试 API

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:26b-moe",
  "prompt": "Write a Python function to parse CSV files with error handling",
  "stream": false
}'

OpenAI 兼容端点

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "gemma4:26b-moe",
  "messages": [
    {"role": "user", "content": "Explain async/await in JavaScript"}
  ]
}'

来源：Ollama API 文档

步骤 5：集成到您的应用程序中

Python

import requests

def ask_gemma(prompt, model="gemma4:26b-moe"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    return response.json()["response"]

# 使用示例
answer = ask_gemma("What is the time complexity of merge sort?")
print(answer)

使用 OpenAI SDK 的 Python 代码

from openai import OpenAI

# 指向本地 Ollama 而非 OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama 不需要真实的 API key
)

response = client.chat.completions.create(
    model="gemma4:26b-moe",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a React hook for debounced search"}
    ]
)
print(response.choices[0].message.content)

Node.js / TypeScript

const response = await fetch("http://localhost:11434/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:26b-moe",
    messages: [
      { role: "user", content: "Explain the Observer pattern with a TypeScript example" }
    ]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

配合 LangChain 使用

from langchain_community.llms import Ollama

llm = Ollama(model="gemma4:26b-moe")
response = llm.invoke("Summarize the key principles of clean architecture")
print(response)

配合 LlamaIndex 使用

from llama_index.llms.ollama import Ollama

llm = Ollama(model="gemma4:26b-moe", request_timeout=120.0)
response = llm.complete("What are the SOLID principles in software engineering?")
print(response)

量化选项说明

量化通过使用较低精度的数字来表示模型权重，从而减小模型大小和内存占用。这是质量与资源使用之间的权衡：

量化	每个权重的比特数	质量影响	内存节省	最适合
FP16	16 bits	无（全质量）	基准	拥有充足 VRAM 的服务器
Q8_0	8 bits	微乎其微	~50%	高质量本地推理
Q6_K	6 bits	极小	~62%	注重质量的本地使用
Q5_K_M	5 bits	较小	~69%	良好的平衡
Q4_K_M	4 bits	小	~75%	推荐的默认值
Q3_K_M	3 bits	中等	~81%	受限的硬件
Q2_K	2 bits	显著	~87%	极端受限的情况

Q4_K_M 是大多数用户的最佳平衡点。 与 FP16 的质量差异非常小，以至于大多数任务产生的结果难以分辨，而 75% 的内存节省则决定了模型是“需要服务器”还是“可以在我的笔记本电脑上运行”。

选择合适的量化

对于 Gemma 4 E2B/E4B：使用默认值 (Q4_K_M)。这些模型本身已经足够小，更高的量化不会显著改变用户体验。

对于 Gemma 4 26B MoE：Q4_K_M 占用 18GB RAM，这在 RTX 4090 的 24GB VRAM 范围内，且为 KV cache 留有空间。如果您拥有 48GB+ VRAM（A6000，双 GPU），可以考虑使用 Q8_0 以获得略微更好的质量。

对于 Gemma 4 31B Dense：20GB 的 Q4_K_M 勉强能挤进 RTX 4090。Q5_K_M 的效果稍好，但需要约 24GB，会消耗所有可用 VRAM。如果您拥有 32GB+ VRAM（RTX 5090, A6000），Q6_K 或 Q8_0 值得升级。

性能调优

GPU 卸载

当 VRAM 可用时，Ollama 会自动将模型层卸载到 GPU。如果只有部分模型能装入 VRAM，Ollama 会在 GPU 和 CPU 之间进行分配。您可以控制这一点：

# 强制所有层进入 GPU（如果 VRAM 不足则失败）
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# 强制仅使用 CPU（用于测试）
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

上下文窗口配置

为了效率，Ollama 默认使用 2048 tokens 的上下文窗口。要利用 Gemma 4 的完整上下文能力：

# 将上下文窗口设置为 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# 将上下文窗口设置为 128K tokens（需要更多 RAM）
ollama run gemma4:26b-moe --num-ctx 131072

重要提示：更大的上下文窗口会为 KV cache 消耗更多 RAM。在 31B 模型上开启 128K 上下文窗口可能需要在模型权重之外额外增加 8-16GB 的 RAM。请从 32K 开始，仅在用例需要时再增加。

并发请求

Ollama 支持同时处理多个请求：

# 允许最多 4 个并发请求
OLLAMA_NUM_PARALLEL=4 ollama serve

每个并发请求都会为其 KV cache 增加内存开销。在运行 Q4_K_M 量化 26B MoE (~18GB) 的 24GB GPU 上，您大约有 6GB 的余量 —— 足以支持 2-3 个短上下文的并发请求。

保持活跃设置

默认情况下，Ollama 会在最后一个请求后将模型保留在内存中 5 分钟。根据您的用例调整此设置：

# 将模型保持加载 1 小时
OLLAMA_KEEP_ALIVE=3600 ollama serve

# 永久保持模型加载
OLLAMA_KEEP_ALIVE=-1 ollama serve

# 每个请求后立即卸载（节省内存）
OLLAMA_KEEP_ALIVE=0 ollama serve

NVIDIA RTX 优化

NVIDIA 发布了针对 RTX GPU 优化过的 Gemma 4 构建版本。这些优化包括：

为 Gemma 4 的注意力机制定制的 CUDA kernels
集成 TensorRT-LLM 以实现更快的推理
支持 Flash Attention，以减少长上下文推理期间的内存使用
优化的 KV cache 管理，以获得更好的吞吐量

安装 NVIDIA 优化的 Gemma 4

如果您拥有 RTX 4000 或 5000 系列 GPU：

# 检查您的 GPU
nvidia-smi

# 拉取 NVIDIA 优化版本（如果在 Ollama 中可用）
ollama pull gemma4:31b-nvidia

或者，直接使用 NVIDIA AI Workbench 或 TensorRT-LLM 以获得最高性能。与标准的 Ollama 构建版本相比，NVIDIA 优化版在 RTX GPU 上的推理速度可提高 30-50%。

实际性能基准测试

在常见硬件配置上的测量结果：

每秒 Tokens 数（生成速度）

模型	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	仅 CPU (32GB)
E2B (Q4)	~150 tok/s	~120 tok/s	~100 tok/s	~30 tok/s
E4B (Q4)	~100 tok/s	~80 tok/s	~70 tok/s	~15 tok/s
26B MoE (Q4)	~40 tok/s	~30 tok/s	~25 tok/s	~3 tok/s
31B Dense (Q4)	~30 tok/s	~20 tok/s	~20 tok/s	~2 tok/s

背景参考：人类的阅读速度大约是每秒 4-5 个 tokens。任何生成速度超过 10 tok/s 的模型在交互使用时都会感觉是“即时”的。E2B 和 E4B 模型快到足以在几乎任何硬件上进行实时流式传输。

首个 Token 生成时间（延迟）

模型	RTX 4090	M3 Max	仅 CPU
E2B	<100ms	<200ms	<500ms
E4B	<200ms	<300ms	~1s
26B MoE	~500ms	~1s	~5s
31B Dense	~800ms	~1.5s	~8s

对于交互式应用，首个 token 的生成时间比生成速度更重要。E2B 和 E4B 模型即使在 CPU 上也能几乎瞬间开始生成，使其成为实时聊天界面的理想选择。

常见用例

本地代码助手

将 Gemma 4 用作私有代码助手，绝不会将您的代码发送到外部服务器：

ollama run gemma4:26b-moe --system "You are an expert software engineer. When given code, analyze it for bugs, suggest improvements, and explain your reasoning. Be concise and practical."

将其与支持 Ollama 作为后端的 VS Code 扩展（如 Continue 或 Twinny）配合使用。

文档分析

本地处理敏感文档：

echo "Analyze this contract clause and identify potential risks: [paste clause]" | ollama run gemma4:31b

凭借 256K 上下文，31B 模型可以处理长达约 750 页的文档 —— 足以应对大多数合同、研究论文和技术文档。

本地 RAG (检索增强生成)

将 Gemma 4 与本地向量数据库结合，构建一个完全私有的 RAG 系统：

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

# 使用 Gemma 4 进行嵌入和生成
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# 从您的文档创建向量存储
vectorstore = Chroma.from_documents(documents, embeddings)

# 通过 RAG 进行查询
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents("What is our refund policy?")
context = "\n".join([doc.page_content for doc in docs])
response = llm.invoke(f"Based on this context:\n{context}\n\nAnswer: What is our refund policy?")

在应用程序中构建 AI 功能

对于构建具有 AI 能力的应用程序的开发者来说，通过 Ollama 的 API 在本地运行 Gemma 4 是实现工作原型的最快途径。由于 API 与 OpenAI 兼容，这意味着您可以先使用本地 Gemma 4 进行开发，然后在准备扩展时切换到云端 API，而无需更改应用程序代码。

像 ZBuild 这样的平台可以处理应用程序基础设施 —— 前端、后端、身份验证、数据库 —— 而您只需专注于 AI 集成层。在开发过程中将应用程序的 AI 端点指向 localhost:11434，并在准备就绪时切换到云端端点。

故障排除

"Out of memory"（内存不足）错误

如果看到内存错误：

尝试更小的量化版本：ollama pull gemma4:31b-q3_K_M
减小上下文窗口：--num-ctx 4096
关闭其他占用 GPU 的应用程序
切换到更小的模型：26B MoE 以更低的内存成本提供接近 31B 的质量

生成速度慢

如果生成速度低于预期：

检查 GPU 利用率：nvidia-smi（应该显示高 GPU 使用率）
确保模型完全装入 VRAM —— 部分 CPU 卸载会显著变慢
减小 --num-ctx 以释放 VRAM 用于计算
检查是否有其他进程正在使用 GPU

模型未找到

如果 ollama run gemma4:26b-moe 失败：

# 列出可用模型
ollama list

# 搜索 Gemma 4 模型
ollama search gemma4

# 拉取特定模型
ollama pull gemma4:26b-moe

API 连接被拒绝

如果应用程序无法连接到 localhost:11434：

# 检查 Ollama 是否正在运行
ollama list

# 手动启动 Ollama 服务器
ollama serve

# 检查端口
curl http://localhost:11434/api/tags

模型选择决策树

使用此方法快速选择合适的模型：

您是否有 16GB+ VRAM 的独立 GPU？

是 → 您想要最高质量还是最高效率？
- 最高质量 → gemma4:31b (Q4_K_M, 需要 20GB)
- 最高效率 → gemma4:26b-moe (Q4_K_M, 需要 18GB)
否 → 您是否有 8GB+ RAM？
- 是 → gemma4:e4b (Q4_K_M, 质量更好)
- 否 → gemma4:e2b (Q4_K_M, 可在 5GB 上运行)

对于大多数拥有现代台式机或游戏电脑的开发者：从 gemma4:26b-moe 开始。它在整个 Gemma 4 家族中提供了最佳的质量资源比。

您可以构建什么

随着 Gemma 4 在本地运行，您拥有了一个零成本的 AI 后端，可用于：

具有完整对话隐私的聊天应用程序
针对专有代码库工作的代码分析工具
针对敏感数据的文档处理管道
离线工作的本地 AI 助手
在投入云端 API 成本之前的 AI 功能原型
针对特定领域任务的微调模型（Apache 2.0 允许自由进行此类操作）

Apache 2.0 许可证意味着您构建的一切都属于您 —— 没有使用限制，没有收入分成，无需批准。在本地运行它，在您的服务器上部署它，将其嵌入到您的产品中。这就是真正开放的 AI 该有的样子。

在 5 分钟内本地运行 Gemma 4：完整 Ollama 设置指南 (2026)