仅70块钱的板子256M内存跑起了10亿参数大模型，这个项目让我惊掉下巴，这是真大佬，我服

推荐语

仅70块钱的板子跑10亿参数大模型？这个开源项目用逐层加载的黑科技颠覆了传统推理方式！

核心内容：
1. 传统大模型推理对内存的严苛需求与计算瓶颈
2. picolm项目突破性的逐层流式加载技术原理
3. 工程思维中"组合创新"的经典案例解析

杨芳贤

53AI创始人/腾讯云(TVP)最具价值专家

事情是这样的，我在 github 上刷到了一个直觉感受不可能的项目，他里面的一行描述让我停下来：

"Run a 1-billion parameter LLM on a $10 board with 256MB RAM"

我的第一反应是——这不可能。

不是不可能跑，是不可能用256MB RAM跑。我下意识地做了个估算：1B参数的模型，哪怕用最激进的INT4量化，也得……等等，我得认真算一下。

先把这道基础题做对

在看这个项目之前，我觉得有必要先把数字搞清楚。因为我发现很多人说"模型太大跑不了"，但从来没算过"到底有多大"。

一个参数，用不同精度存储：

• • FP32（全精度）：4 字节 → 1B 参数 = 4 GB
• • FP16（半精度）：2 字节 → 1B 参数 = 2 GB
• • INT8（8位量化）：1 字节 → 1B 参数 = 1 GB
• • INT4（4位量化）：0.5 字节 → 1B 参数 = ~500 MB

500MB。就算最激进的INT4量化，权重本身就要500MB。

然后 256MB 的设备要跑它？

这个时候我意识到，一定有什么东西不对——要么这 256MB 的说法有问题，要么这个推理方式根本不是我们平时理解的那种"全部加载进内存"。

等等，"运行"不等于"全部加载"

我重新去读了作者 Jaber 在 X 上发的那条推文 ： x^[1]

"model sits on the sd card, streams one layer at a time through 45mb of ram"

这句话让我停顿了一下。

"streams one layer at a time"——逐层流式推理。

好，这里有个关键认知需要建立：

Transformer 推理的本质，是把输入 token 依次经过每一层（Layer），最后输出下一个 token。而每一层在处理完之后，其权重在当前 token 的推理中就不再需要了。

所以，有没有可能——我们不把整个模型放进内存，而是每次只加载当前需要的那一层，用完就扔，再加载下一层？

答案是：可以。这就是 picolm 的核心设计。 真的是太妙了，但是想想，这不是和 skills 的实现方式类似吗，说他是渐渐式加载也不为过吧，只不过他用完就丢，做得更狠了，这似乎又和动态规划算法原理有点类似，用完前面的推导了就可以丢了，所以朋友们，你们看，有些原理其实就是这么美妙而直接，他会反复的被用到各种工程之处，并不是我们发明了多少，而是我们成功组合了多少。

推导一遍这个方案

我来把这个设计思路完整推一遍，因为光知道结论不够，要知道"为什么这样做"。

传统的推理流程是这样的：

[完整模型权重] → 全部加载进 RAM → 输入 Token → 逐层计算 → 输出 Token

这要求 RAM 足够装下整个模型。

picolm 的方案是：

[SD 卡上的量化模型] 
         ↓（逐层读取，每次只读一层）
[45MB RAM 缓冲区]
    ├── 当前层权重（从 SD 卡流入）
    ├── 激活值（当前 token 的中间状态）
    └── KV Cache（注意力机制的缓存）
         ↓
[CPU 计算当前层]
         ↓（计算完毕，当前层权重可以丢弃）
[读入下一层权重] → 重复...
         ↓
[最终输出 Token]

这样最关键的问题就变成：45MB 能不能装下一层的权重 + 激活值 + KV Cache？

对于一个标准的 1B 参数 Transformer（比如 Llama 架构），通常有 16-32 层，每层参数量大约是总参数的 1/层数。以 32 层为例，每层约 31M 参数，用 INT4 存储约 15-16MB。

加上激活值和 KV Cache 的开销，挤一挤，45MB 是可以装下的。

这里有个代价：每个 token 推理都需要从 SD 卡读取所有层的权重一遍。 这就是为什么速度是 10-21 tokens/秒，而不是 GPU 上的几百 tokens/秒。但在这个硬件条件下，这已经非常出色。

量化到底做了什么

讲完架构，再往下挖一层：模型怎么量化才能塞进 SD 卡，而且还能保持语言能力？

量化的基本原理是用低精度整数来近似浮点数。最常见的方式是 INT4 量化，也就是把每个权重从 FP32（4字节，约40亿个取值）压缩到 4bit（0.5字节，16个取值）。

这显然会有精度损失。关键在于：怎么把损失控制到"基本不影响语言理解"的程度？

目前主流的方案有几种思路：

• • 按层分组量化（Group Quantization）：不是整个权重矩阵用一个缩放因子，而是每 128 个或 64 个权重一组，各自有独立的缩放参数。这样可以大幅减少量化误差。
• • 异常值处理（Outlier handling）：某些权重值特别大，直接量化误差会很严重。现代量化方案（如 GPTQ、AWQ）会特别处理这些异常权重。 blog.4geeks^[2]

picolm 大概率使用了 GGUF 格式的量化模型（从配套的 PicoClaw 生态来看），这是 llama.cpp 生态里最成熟的量化格式，对 INT4/INT3/INT2 都有良好支持。 hackster^[3]

80KB 二进制，纯 C，零依赖——这是什么意思

作者特别强调了几个数字：80KB 二进制，pure C，zero dependencies。

我琢磨了一下，这三个约束其实互相解释：

首先，为什么要纯 C？

因为目标平台是嵌入式 Linux（Raspberry Pi）和 RISC-V 裸板（LicheeRV Nano）。这两类设备：

• • 没有 Python 运行时（或者有但很慢）
• • 没有 PyTorch/TensorFlow/ONNX Runtime
• • 内存本来就只有 256MB，运行时自身不能占太多

纯 C 是在嵌入式世界里的通用语言，编译出来的二进制小、启动快、内存可控。
为什么只有 80KB？

这是纯 C + 零依赖的直接结果。没有引入任何第三方库，整个推理引擎从头实现。80KB 的二进制意味着：

• • 启动速度极快
• • 可以在任何 Linux/RISC-V 设备上直接跑
• • 不需要 pip install 任何东西

这让我想到了 llama.cpp 早期的设计哲学——当时作者 Georgi Gerganov 也是用纯 C/C++ 从头实现推理引擎，正是因为这个才能跑在苹果 M1 上超越 GPU。picolm 把这个思路推到了更极端的硬件边界。

整个系统的数据流

现在把完整的系统流程画出来，从硬件到推理输出：

┌─────────────────────────────────────────────────┐
│              硬件层（LicheeRV Nano / Pi）          │
│                                                  │
│  ┌──────────┐    ┌─────────────────────────┐    │
│  │  SD 卡   │───>│   45MB RAM 工作缓冲区    │    │
│  │          │    │  ┌───────────────────┐  │    │
│  │ 量化模型  │    │  │ 当前层权重 ~15MB   │  │    │
│  │ (INT4)   │    │  │ 激活值 (中间状态)  │  │    │
│  │          │    │  │ KV Cache          │  │    │
│  │ ~500MB   │    │  └───────────────────┘  │    │
│  └──────────┘    └──────────┬──────────────┘    │
│                             │                    │
│                    ┌────────▼───────────┐        │
│                    │   CPU 推理引擎     │        │
│                    │  (80KB 纯C二进制)  │        │
│                    └────────┬───────────┘        │
│                             │                    │
└─────────────────────────────│────────────────────┘
                              │
                    ┌─────────▼──────────┐
                    │  Token 输出        │
                    │  ~10-21 tokens/s   │
                    └────────────────────┘
                              │
                    ┌─────────▼──────────┐
                    │  PicoClaw 接口     │
                    │  (完整离线AI助手)   │
                    └────────────────────┘

推理的每一个 token，都会触发一次"从 SD 卡按层读取 → RAM 计算 → 丢弃上一层"的循环。这个循环的瓶颈在 SD 卡的读取速度，而不是 CPU 算力。

性能数字怎么看

作者给出的性能数据是：

• • Raspberry Pi：约 21 tokens/秒
• • LicheeRV Nano（$10 RISC-V）：约 10 tokens/秒

10 tokens/秒是什么感觉？大概就是每秒出现10个字，比人类阅读速度快一点，但明显比 GPU 推理慢很多。

但换个角度想：这是在 $10 的板子 上，跑 1B 参数的语言模型，完全 离线，不需要任何云服务。

这个对比才是关键。如果你的应用场景是：

• • 不能联网的工业现场
• • 需要本地隐私保护的嵌入式设备
• • 开发低成本 AI 终端
• • 教育/实验室用的低成本 AI 节点

10 tokens/秒就完全够用了。

这件事背后有一个更重要的问题

我把这个项目反复看了几遍，有一个问题一直在脑子里转：

为什么是现在才出现这个？

技术上，逐层流式推理不是新思路，INT4量化也已经成熟，纯C推理引擎 llama.cpp 早就存在。但 picolm 把这些东西组合起来，特别针对 256MB 内存的嵌入式板子做了工程优化，并且把配套的 PicoClaw 整个生态也建起来了。

这里有一个技术密度极高但被低估的工程选择：内存 budget 的精确分配。

45MB 这个数字不是随便选的。作者需要在以下几项之间精确平衡：

1. 1. 当前层权重大小（由模型架构决定）
2. 2. 激活值缓存（由序列长度和 hidden dim 决定）
3. 3. KV Cache（由 context 长度决定，越长越占内存）
4. 4. 系统和进程本身的开销（Linux kernel + 进程 ≈ 50MB+）

总计需要在 256MB 里抠出 45MB 干净的工作内存，同时系统不崩溃。这需要对每一个字节的去向都了如指掌。这种程度的内存控制能力，在现代 AI 工程师里已经很少见了。

那它能干什么，不能干什么

说实话，1B 参数的语言模型，能力上限就摆在那里。

能做的：

• • 基本的问答和对话
• • 简单的文本分类/摘要
• • 代码补全（简单片段）
• • 作为本地 AI 助手核心引擎（配合 PicoClaw）

不能做的：

• • 复杂推理（数学、逻辑）
• • 长上下文理解（context 受 KV Cache 内存限制）

但这不是这个项目的目标。picolm 的价值不在于"打败 GPT-5"，而在于把 AI 推理的硬件门槛降到极限。

最后想说一件事

我做技术这些年，见过很多"用大力气做小事"的项目，也见过很多"用小力气做大事"的项目。

picolm 属于后者。

80KB 的二进制，一个人写的，解决了一个清晰而真实的问题：让最便宜的硬件也能跑语言模型。

这背后没有什么神奇的新技术，用的都是已有的东西——量化、逐层推理、纯C实现。但工程上的每一个选择都很克制，很扎实。

有时候，工程问题的答案不是"找到一个更好的算法"，而是"想清楚什么东西是真的必要的，把其他的全部扔掉"。

picolm 就是把"不必要的"扔干净之后，剩下的那 80KB。

项目地址：github.com/RightNow-AI/picolm
配套 AI 助手：github.com/sipeed/picoclaw

引用链接

[1] x: https://x.com/Akashi203/status/2024295010615661008
[2] blog.4geeks: https://blog.4geeks.io/deploying-a-small-language-model-slm-on-an-edge-device-a-practical-guide/
[3] hackster: https://www.hackster.io/news/creating-cross-platform-small-ai-with-picollm-3cf6076db9ec