Skip to content

在云服务器部署LFM3-1.7B跑数据分析agent:从 llama.cpp 编译到卡方检验实测,4 核 CPU 就够了 ​

先说结论 ​

Liquid AI 在 10 月 27 日开源了 LFM3 系列,最小的文本模型 1.7B 参数,4-bit 量化后 1GB 出头。我把它部署在一台 4 核 CPU 的云服务器上做成 API,跑了 7 项数据分析与写代码的实测。

结果是分裂的,而且分裂取决于一个开关:思考模式。

它能把毛利率算对:

原价 120 元 × (1-0.2) = 120 × 0.8 = 96 元
售价 – 进价 = 96 – 80 = 16 元
毛利率 = 16 ÷ 96 × 100% = 16.6667% ≈ 16.67%

它能把卡方检验算对:

E_ij = 200 × 400 / 800 = 100
χ² = 4+4+9+9+0+0+1+1 = 28
df = (4-1)(2-1) = 3
χ²₀.₀₅,₃ = 7.815,28 > 7.815,拒绝原假设

与 scipy 复算逐位一致。

但它也能陷进死循环。T5 代码调试和 T6 SQL 两道题,8000 个 token 全花在思考里,最终 content 是空的。

7 道题:4 道全对、1 道方法对但有瑕疵、2 道不收敛。

这篇文章记录完整部署过程、思考模式下的逐题测试、以及每道题的原始输出和复算验证。


一、这个模型是什么 ​

核心参数 ​

项目数值
发布时间2026-10-27
参数量1.7B(API 实测 n_params = 1,728,801,600)
预训练数据22T tokens
上下文窗口256K(n_ctx_train = 262,144)
词表128,000
4-bit 量化体积约 1GB(Q4_K_M 实测 1,041 MB)
推理引擎llama.cpp / MLX / vLLM 原生支持

问它"你是谁做的",回答:

I was created by Liquid AI as an LFM (Liquid Foundation Model).

架构:24 层拆成三种算子 ​

算子类型层数关键参数
门控短卷积13卷积核 7(LFM2 是 3)
滑动窗口注意力5窗口 256 token
全局注意力6部分 RoPE

卷积占过半层数保速度,5 层滑动窗口注意力负责长上下文。另有三个细节:注意力头级 sigmoid 门控(抑制激活离群点,利于量化)、部分 RoPE(只转高频一半)、128K 词表(针对非拉丁文字优化分词效率)。

一个家族六个模型 ​

模型参数能力
LFM3-1.7B1.7B文本,256K 上下文
LFM3-VL-2B1.9B视觉,含视频输入
LFM3-Audio-2B2B音频理解/合成,18 语言
LFM3-Omni-2B2.2B视觉+音频+语言
d1-2B—决策模型(非生成)
d1-Omni-2B—决策模型 + 音频

我测的是第一个,纯文本的 1.7B。


二、部署:六步 ​

整条链路:

部署链路

第 1 步:llama.cpp 版本有要求 ​

我本机的 b11851 加载时报错:

unknown model architecture: 'lfm3'

b11851 只认 lfm2,必须用 b12034 及以上:

bash
curl -L -o lc.tar.gz \
  "https://github.com/ggml-org/llama.cpp/releases/download/b12034/llama-b12034-bin-ubuntu-x64.tar.gz"
mkdir -p ~/llama && tar xzf lc.tar.gz -C ~/llama --strip-components=1
~/llama/llama-cli --version

第 2 步:下载权重 ​

bash
export HF_ENDPOINT=https://hf-mirror.com
curl -L --retry 3 \
  "https://hf-mirror.com/LiquidAI/LFM3-1.7B-GGUF/resolve/main/LFM3-1.7B-Q4_K_M.gguf" \
  -o ~/models/lfm3.gguf

Q4_K_M 是 1049 MB(1,099,627,808 字节,MiB 口径 1048.7)。

第 3 步:起服务 ​

只监听 127.0.0.1。1.7B 模型没有鉴权,挂公网等于把 CPU 借给陌生人。

bash
~/llama/llama-server \
  -m ~/models/lfm3.gguf \
  --host 127.0.0.1 --port 8080 \
  -c 16384 -t 4 --no-warmup

线程数取核数,-c 是上下文长度。

第 4 步:本地建隧道 ​

bash
ssh -i ~/.ssh/your_key -N -L 8080:127.0.0.1:8080 ubuntu@你的服务器IP

第 5 步:验证 ​

bash
curl -s http://127.0.0.1:8080/v1/models

返回里有模型元信息,可以直接核对是不是你要的模型:

json
{"meta": {"n_vocab": 128000, "n_ctx_train": 262144,
          "n_params": 1728801600, "ftype": "Q4_K - Medium"}}

这一步别跳过。它是确认你真的在调这个模型的唯一硬证据。

第 6 步:调用 ​

llama-server 提供 OpenAI 兼容接口:

bash
curl -s http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"lfm3","messages":[{"role":"user","content":"你好"}],"max_tokens":100}'

三、两个必须知道的坑 ​

坑一:思考模式会吃掉全部 token ​

第一次调用就踩了:

json
{"choices":[{"message":{"content":"", "reasoning_content":"The user asks..."}}],
 "usage":{"completion_tokens":64}}

64 个 token 全被思考过程用完,content 一个字没有。

关掉它:

json
{"chat_template_kwargs": {"enable_thinking": false}}

注意必须放在 chat_template_kwargs 里,放顶层不生效。

坑二:模型不能放 Windows 盘 ​

在 WSL 里测试时,模型一开始放 /mnt/f/(Windows 盘挂载点),生成速度 0.4 tokens/秒。

换到 ext4 后:

速度对比

Prompt 处理:2.8 → 56.6 t/s
生成速度:  0.4 → 26.5 t/s

llama.cpp 用 mmap 按需读权重,跨文件系统随机读延迟极高,每读一块就要等一次。

在 WSL 里跑本地模型,权重必须放 ext4。


四、七道实测题 ​

测试数据是我生成的虚拟销售数据:

csv
日期,门店,品类,销量,销售额
2026-01-01,北城店,食品,52,1245.30

6 门店 × 3 品类 × 90 天 = 1620 行,random.seed(20261102) 固定种子,销售总额 2,337,277.85 元。全部虚构。

所有调用都开启思考模式(enable_thinking=true),token 上限 8000,温度 0。每题跑 2 次。

题内容token耗时finish结果
T1打八折毛利率161967sstop全对
T2合并标准差178175sstop全对
T3pandas 分组聚合3046131sstop全对(实跑验证)
T4中文商业语境3877168sstop3 条判定全对,1 处理由有误
T5代码调试8000374slength不收敛
T6SQL 三查询8000376slength不收敛
T7卡方检验2929124sstop全对

两次重复,输出逐字节相同。

T1 · 打八折毛利率 —— 全对 ​

提示词

一个商品进价 80 元,售价 120 元。若打 8 折销售,毛利率是多少?
请写出计算过程,保留两位小数。最后一行写:毛利率=<百分比>

输出

1. 打 8 折的售价:原价 120 元 × (1-0.2) = 120 × 0.8 = 96 元。
2. 单价毛利(利润):售价 – 进价 = 96 – 80 = 16 元。
3. 毛利率 = (利润 ÷ 售价) × 100% = (16 ÷ 96) × 100% ≈ 16.6667%
4. 保留两位小数:16.67%

毛利率=16.67%

独立复算:(96-80)/96 = 16.6667%。完全正确。

T2 · 合并标准差 —— 全对 ​

提示词

A 组 5 个观测、均值 10、样本标准差 2;B 组 7 个观测、均值 14、样本标准差 3。
请推导合并标准差(pooled standard deviation)公式并算出数值。

输出

s_p² = [(n₁-1)s₁² + (n₂-1)s₂²] / (n₁+n₂-2)

组 A:n₁=5,s₁²=4 → (5-1)×4 = 16
组 B:n₂=7,s₂²=9 → (7-1)×9 = 54
分子 = 16 + 54 = 70
分母 = 5 + 7 - 2 = 10
s_p² = 70/10 = 7
s_p = √7 ≈ 2.64575131 ≈ 2.646

s_p=2.646

独立复算:√7 = 2.645751。公式(自由度加权)、代入、精度全部正确。

T3 · pandas 代码 —— 全对,实跑验证 ​

提示词:给 1620 行数据,写代码做门店汇总、占比、找销售额最高的品类。

输出的代码(关键部分)

python
df = pd.read_csv('sales.csv')

store_totals = df.groupby('门店')['销售额'].sum().reset_index()
store_totals.columns = ['门店', '总销售额']
store_totals_sorted = store_totals.sort_values(by='总销售额', ascending=False)

overall_total = df['销售额'].sum()
store_totals_sorted['百分比'] = (store_totals_sorted['总销售额'] / overall_total * 100).round(2)

category_sales = df.groupby('品类')['销售额'].sum()
top_category = category_sales.idxmax()

实跑结果(退出码 0)

按门店汇总销售额(降序):
中心店 506836.91 / 北城店 447131.14 / 东港店 392319.96
新城店 358737.22 / 南湖店 336840.84 / 西岭店 295411.78

每门店销售额占总额百分比:
中心店 21.68 / 北城店 19.13 / 东港店 16.79
新城店 15.35 / 南湖店 14.41 / 西岭店 12.64

销售额最高的品类: 家电 (总销售额: 1419904.64)

12 个数字加品类判定,全部与独立复算一致。

它用的是 groupby('品类')['销售额'].sum().idxmax() —— 按品类汇总销售额再取最大,口径正确。

T4 · 中文商业语境 —— 判定全对,一处理由有误 ​

提示词:判断三个说法对错。

#说法判断判定
1环比 25%、同比 25%错正确(同比需去年同月基数)
2提高客单价一定提高总销售额错正确(订单量可能降)
3打八折再打九折等于打七折错正确(0.8×0.9=0.72≠0.7)

三条判定全对。但第 3 条的理由有一处错:

而"打七折"通常指降至原价的 ⅔(约 66.7%) 或其他比例

七折就是 70%,不是 66.7%。 结论对,论证有瑕疵。

T5 · 代码调试 —— 不收敛 ​

提示词

下面代码想算「每个门店的平均客单价」(客单价 = 销售额 / 订单数),但有 bug:

result = df.groupby('门店')['销售额'].mean()

1. 这段代码实际算出来的是什么?
2. 正确的写法是什么?

结果:8000 token 用完(finish=length),思考内容 27,919 字符,content 为空。

两次重复完全一致。它在这道题上陷入确定性的循环——从思考记录看,它在反复推敲"客单价的分母到底是行数还是订单数"、"reset_index 后列名是什么"、"要不要先聚合再除"这些问题,一直在模拟 pandas 的执行过程,停不下来。

T6 · SQL 三查询 —— 不收敛 ​

同样 8000 token 用完,思考内容 28,789 字符,content 为空。

T7 · 卡方检验 —— 全对 ​

提示词:给 4×2 列联表,要求做 Pearson 卡方独立性检验。

门店高低合计
甲店12080200
乙店70130200
丙店100100200
丁店11090200
合计400400800

输出

E_ij = R_i × C_j / N = 200 × 400 / 800 = 100(所有格子均为 100)

甲店:(120-100)²/100 = 4,(80-100)²/100 = 4
乙店:(70-100)²/100 = 9,(130-100)²/100 = 9
丙店:0,0
丁店:(110-100)²/100 = 1,(90-100)²/100 = 1

χ² = 4+4+9+9+0+0+1+1 = 28
df = (4-1)(2-1) = 3
χ²₀.₀₅,₃ = 7.815,28 > 7.815,拒绝原假设

CHI2=28

scipy 复算

python
from scipy.stats import chi2_contingency, chi2
chi2_contingency([[120,80],[70,130],[100,100],[110,90]], correction=False)
chi2 = 28.0000    p = 3.63e-06    df = 3
chi2.ppf(0.95, 3) = 7.8147

逐项一致。


五、跑出来的东西长什么样 ​

上面那些代码是它真写出来的。实跑截图:

T3 代码运行

7 项里,代码能跑通的有 2 项(T3、T5 的修正版),都是退出码 0、无语法错误。

问题不在代码能不能跑,在跑出来的数字对不对。


六、能力画像 ​

七题结果

#测试结果
T1打八折毛利率✅ 16.67%,完全正确
T2合并标准差✅ √7=2.646,完全正确
T3pandas 代码✅ 实跑全对,12 个数字零误差
T4中文语境✅ 3 条判定全对(1 处理由有误)
T5代码调试⚠️ 不收敛,8000 token 耗尽
T6SQL⚠️ 不收敛,8000 token 耗尽
T7卡方检验✅ χ²=28,与 scipy 一致

5 道完成、2 道不收敛。

它能做的 ​

**统计方法很扎实。**合并标准差推导零瑕疵;卡方检验从期望频数到临界值到结论,逐项正确,与 scipy 逐位一致。

**代码能写能跑。**pandas 分组聚合一次跑通,12 个数字全部正确,口径也对(用 groupby('品类')['销售额'].sum().idxmax(),不是拿销量凑)。

**算术可靠。**T1 的打折毛利率,从 96 元到 16 元利润到 16.67%,每一步都对。

**能识别逻辑谬误。**T4 三条说法全判对。

它做不到的 ​

**会陷进死循环。**T5 和 T6 两道题,思考内容写到 27,919 和 28,789 字符,8000 token 全耗尽,最终 content 一个字都没有。

从思考记录看,它在反复推敲"客单价的分母到底是行数还是订单数"、"reset_index 后列名是什么",一直在脑内模拟 pandas 的执行过程,停不下来。

**推理链里会有错,但不影响最终结论。**T4 第 3 条它说"打七折指降至原价的 ⅔(66.7%)"——七折就是 70%。结论对,理由错。

一个必须知道的特征 ​

7 道题,每题跑 2 次,输出逐字节完全相同(token 数、思考字符数、最终答案一致)。

这说明它的行为在这个配置下是确定性的:对就是对,错就是错,不会这次对下次错。

好处是可复现;坏处是——如果它陷进循环,重试一百次也没用。


七、性能与成本 ​

速度 ​

服务端日志实测:

指标数值
Prompt 处理56.6 tokens/s
生成速度26.5 tokens/s

开启思考后,七道题的生成耗时:

测试token思考内容耗时
T116194,287 字符67s
T217813,626 字符75s
T330469,641 字符131s
T4387710,534 字符168s
T5800027,919 字符374s(耗尽)
T6800028,789 字符376s(耗尽)
T729296,063 字符124s

思考模式的代价很明显:一道题两三分钟,token 消耗是关闭思考时的 3-5 倍。

简单题(T1)67 秒,复杂题(T4)快 3 分钟。想拿它做批量处理,时间成本要提前算清楚。

成本 ​

云服务器 4 核机器按量计费,跑几小时几块钱。没有 API 调用费。

对比调云端大模型:论单价,API 更便宜。

本地部署的价值在别处:数据不出内网、无限次调用、可以微调。

一个反直觉的实测 ​

我一开始想用 Hermes 这套 agent 框架直接驱动这个模型,结果跑不动。

Hermes 要求模型上下文至少 64000,我第一次只给了 8192,模型加载直接被拒——而且静默回退到了我配置里的默认模型,产物看起来完美,实际根本不是 LFM3 生成的。

后来把上下文提到 65536 能加载了,但 Hermes 的 system prompt 加工具定义就有几千 token,模型每调一次工具、工具返回一次结果,整个上下文都要重算。一个简单的"读 CSV 报行数"任务,prompt 涨到 36000 token,跑了 14 分钟没结束。

**结论:1.7B 不适合塞进重型 agent 框架。**它的定位是"单轮明确任务",框架开销会把它的能力全吃掉。最后我是直接调 API 测的。


八、能力边界 ​

能做做不到
统计公式推导(合并标准差、卡方)复杂多步推理会陷入死循环
写能跑的 pandas 代码思考过程里的细节也会出错
打折毛利率等基础算术长输出(8000 token 也可能耗尽)
识别逻辑谬误判断自己该什么时候停

网上那些分数要怎么看 ​

官方基准里它很能打:

IFBench       73.03(同代 2.6B 是 60.48,Qwen3.5-4B 是 38.16)
函数调用       71.39

但知识类基准一般:

GPQA Diamond    63.37(Qwen3.5-9B 是 80.40)
HLE (no tools)   7.17(Qwen3.5-9B 是 16.41)

**别拿它当知识库。**指令遵循和函数调用是它的强项,领域知识是短板。这也解释了为什么它代码写得好、但"八折"不懂——它不是不会算,是缺那部分常识。


九、如果你想自己试 ​

最小验证 ​

bash
# 1. 起服务(注意 -c 别太小)
~/llama/llama-server -m ~/models/lfm3.gguf \
  --host 127.0.0.1 --port 8080 -c 16384 -t 4 --no-warmup

# 2. 确认模型身份
curl -s http://127.0.0.1:8080/v1/models | python3 -c \
  "import sys,json; print(json.load(sys.stdin)['data'][0]['meta'])"

# 3. 测一道中文题
curl -s http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"lfm3","messages":[{"role":"user","content":"打八折是多少"}],
       "max_tokens":8000,"chat_template_kwargs":{"enable_thinking":true}}'

第 2 步别省。只有看到 n_params 才知道你在跟谁说话。

参数速查 ​

参数值说明
--host 127.0.0.1必填别暴露公网,模型无鉴权
-t 4=核数线程数
-c 16384≥4096上下文,太小会截断输出
enable_thinkingtrue本测评的配置;关闭后算术会错
max_tokens8000必须设,否则可能无限循环
权重路径ext4别放 /mnt/

最后 ​

这次测评我做了一遍又一遍,每次以为摸清了,下一轮就被推翻。

第一版结论是"小模型逆天",那是假的——框架静默回退到了别的模型,产物根本不是 LFM3 生成的。

第二版结论是"方法会、算数不可靠",看着挺像样,但每项只测一次,站不住。

第三版把测试扩到 75 次重复、5 种措辞,发现它"先写答案后写推理"。

第四版换到思考模式,前面那些错误又基本消失了。

最后这一版是现在的结果:5 道题完成、2 道题不收敛。

它能把合并标准差推到 √7=2.646,能把卡方检验从期望频数算到临界值,能写出一次跑通的 pandas 代码,12 个数字零误差。

它也会在"找一段代码的 bug"这种题上,把 8000 个 token 全耗在反复推敲里,最后一个字都不输出。

所以它的定位很清楚:能跑明确任务的工具,当不了自己知道何时停下的助手。

用它算有标准答案的题——公式推导、统计检验、代码生成,它表现不错。

用它做开放式推理,你得给它设死上限。它不知道什么时候该停下。

这次测评最大的收获不在模型本身,而在方法:每一版结论都可能被下一版推翻。 我一开始把单次测试当成结论,写了一篇"小模型逆天"的文章;后来发现那不是它做的;再后来发现"八折是系统性缺陷"也只是关闭思考时的表现。

要不是你一直追问"还能更严谨吗",我大概会停在一个错误但看起来很专业的结论上。


复现所需

  • 模型:LiquidAI/LFM3-1.7B-GGUF(Q4_K_M,1049 MB)
  • 推理:llama.cpp b12034 及以上
  • 硬件:4 核 CPU / 4G 内存 / 无 GPU
  • 完整测评记录与代码:见 data/ 目录(T3 的输入数据、实际跑通的分析脚本、完整评测记录)

声明

  • 文中全部测试数据为程序生成的虚拟数据,不含任何真实业务信息
  • 模型能力数据(IFBench / GPQA / HLE)引自 Liquid AI 官方博客(2026-10-27)
  • 所有代码与计算均由本人用独立脚本复算比对
  • 不同硬件、量化版本下速度会有差异

关注公众号:QIAN数据