本地跑大模型前，先算清这台电脑够不够

30 秒速查

• 先看内存：8GB 选 3B，16GB 选 7B，32GB 再上 14B
• 跑 node resources/ollama-hardware/check.mjs
• 有 NVIDIA 显卡会快很多，但不是必需
• 模型选 4-bit 量化，别一上来跑全精度

这篇教程解决什么问题

想在本机跑大模型，第一步通常不是装 Ollama，而是下载一个 5GB 的模型，跑到一半发现内存不够，或者慢到没法用。

这篇先不下载任何模型。用一个脚本读本机的内存、CPU 和 NVIDIA 显卡，按 4-bit 量化给出建议：能跑 3B、7B、14B 还是 32B，大概占多少空间。

先算清楚，再决定要不要下。

先看这张表

4-bit 量化是本地运行的常用档位，画质（效果）和占用比较平衡：

模型	大约占用	适合的机器
3B	2 GB	8 GB 内存，短文本
7B	4.5 GB	16 GB 内存，摘要/分类
14B	9 GB	32 GB 内存，长一点的文档
32B	20 GB	64 GB 内存或大显存

除了模型本身，还要给系统、上下文和软件留约 4 GB。16 GB 内存跑 14B，余量就很小了。

写脚本

保存为 resources/ollama-hardware/check.mjs：

import os from "node:os";
import path from "node:path";
import { spawnSync } from "node:child_process";
import { pathToFileURL } from "node:url";

// 看这台电脑适合跑多大的本地模型。只看内存和显卡，不启动模型。
// 4-bit 量化模型的大小是估算值，实际会因模型和量化方式略有差异。

const MODEL_SIZE = {
  "3B": "约 2 GB",
  "7B": "约 4.5 GB",
  "14B": "约 9 GB",
  "32B": "约 20 GB",
};

export function recommend({ totalMemGB, gpuGB = 0 }) {
  let models;

  if (totalMemGB < 8) {
    models = ["3B"];
  } else if (totalMemGB < 16) {
    models = ["7B"];
  } else if (totalMemGB < 32) {
    models = ["7B", "14B"];
  } else {
    models = ["14B", "32B"];
  }

  const sizes = models.map((name) => MODEL_SIZE[name]);
  const size = sizes.length === 1
    ? sizes[0]
    : `${sizes[0].replace(/^约 /, "").replace(" GB", "")}–${sizes[1].replace(/^约 /, "")}`;
  const hasGpu = gpuGB > 0;

  return {
    models,
    size,
    hasGpu,
    note:
      totalMemGB < 8
        ? "内存偏小，只适合短文本；长文档或批量任务建议用云端。"
        : hasGpu
          ? "有独立显卡，同样的模型会快很多。"
          : "没有独立显卡也能跑，只是速度慢一些。",
  };
}

export function detectGpu() {
  const result = spawnSync(
    "nvidia-smi",
    ["--query-gpu=name,memory.total", "--format=csv,noheader,nounits"],
    { encoding: "utf8" },
  );

  if (result.error || result.status !== 0) return null;

  const [name, memory] = result.stdout.trim().split("\n")[0].split(",");
  if (!name || !memory) return null;

  return { name: name.trim(), memoryMB: Number(memory.trim()) };
}

export function inspect() {
  const gpu = detectGpu();
  return {
    platform: os.platform(),
    arch: os.arch(),
    totalMemGB: os.totalmem() / 1024 ** 3,
    cores: os.cpus().length,
    cpu: os.cpus()[0]?.model ?? "未知",
    gpu,
  };
}

const isDirectRun =
  process.argv[1] &&
  pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url;

if (isDirectRun) {
  const system = inspect();
  const plan = recommend({
    totalMemGB: system.totalMemGB,
    gpuGB: system.gpu ? system.gpu.memoryMB / 1024 : 0,
  });

  console.log(`系统：${system.platform} ${system.arch}`);
  console.log(`内存：${system.totalMemGB.toFixed(1)} GB`);
  console.log(`CPU：${system.cores} 核（${system.cpu}）`);
  console.log(
    system.gpu
      ? `显卡：${system.gpu.name}（${Math.round(system.gpu.memoryMB / 1024)} GB）`
      : "显卡：未检测到 NVIDIA 显卡",
  );
  console.log(`建议：${plan.models.join(" 或 ")} 的 4-bit 量化模型`);
  console.log(`占用：${plan.size}，另留 4 GB 给系统和上下文`);
  console.log(`说明：${plan.note}`);
}

脚本只做三件事：

• 读 os.totalmem() 和 CPU 核数；
• 尝试调用 nvidia-smi，没有就跳过；
• 按内存分档，给出模型建议和占用估算。

不会启动 Ollama，也不会联网。

真实输出

在一台 23.3 GB 内存、8 核 CPU、没有 NVIDIA 显卡的 Linux 机器上跑：

node resources/ollama-hardware/check.mjs

系统：linux x64
内存：23.3 GB
CPU：8 核（11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz）
显卡：未检测到 NVIDIA 显卡
建议：7B 或 14B 的 4-bit 量化模型
占用：4.5–9 GB，另留 4 GB 给系统和上下文
说明：没有独立显卡也能跑，只是速度慢一些。

你的内存、CPU 和显卡会不同，看「建议」和「占用」两行就够。

怎么读结果

• 内存 8 GB 以下：只建议 3B，或者直接用云端。硬跑 7B 会频繁换页，体验很差。
• 16 GB 左右：7B 是甜点区，摘要、分类、打标签都能做；14B 会很紧。
• 32 GB 以上：可以试 14B；有 24 GB 以上显存再考虑 32B。
• 有 NVIDIA 显卡：同样的模型快很多，但显存不够时仍会退回内存，别只看显卡型号。

常见坑

1. 只看内存，不看显存

模型优先放显存。8 GB 显存跑 7B 的 4-bit 模型刚好；跑 14B 会 offload 到内存，速度掉一大截。

2. 一上来跑全精度

全精度 7B 要 28 GB 左右，不是普通笔记本能承受的。先跑 4-bit，够用再谈更大的模型。

3. 同时开很多任务

本地模型吃满内存和显存，并发设 1 到 2 就够。开两个批量任务，不如跑完一个再跑下一个。

4. 忽略上下文长度

上下文越长，占用越高。把上下文从 2K 拉到 32K，内存可能多吃几个 GB；先按默认值跑通。

下一步读什么

确认机器能跑，再去看断网也能批量处理：怎么用 Ollama 做摘要、分类、打标签，以及什么时候该换回云端。

模型和安装信息在 Ollama 工具页；这条路线收在本地 AI 工具箱。