LFM2液态基础模型
1. 背景与动机
大语言模型（LLM）在各领域取得突破性进展，但高效设备端部署仍是核心挑战。传统Transformer架构在移动端面临三大瓶颈：
| 瓶颈类型 | 具体问题 | 影响 |
|---|---|---|
| 内存占用 | 全参数激活，KV缓存随序列长度线性增长 | 设备存储不足 |
| 计算延迟 | 注意力复杂度 | 响应时间长 |
| 功耗效率 | 密集矩阵运算不适合嵌入式CPU | 续航焦虑 |
Liquid AI提出的LFM2（Liquid Foundation Models 2）采用了硬件在环架构搜索（Hardware-in-the-loop architecture search）策略，让模型设计直接针对目标硬件进行优化。1
2. 核心架构设计
2.1 硬件感知架构搜索
传统模型设计流程是”先设计架构，后优化部署”，而LFM2采用逆向思维：
# 硬件在环搜索的核心思想
def hardware_aware_search(target_device):
"""针对目标设备联合优化模型架构"""
# 1. 在目标硬件上建立性能模型
perf_model = ProfileHardware(target_device)
# 2. 定义搜索空间
search_space = {
'backbone_type': ['transformer', 'convolution', 'state_space'],
'attention_type': ['full', 'linear', 'grouped'],
'moe_config': {'num_experts': [8, 16, 32], 'top_k': [2, 4]},
'hidden_dim': [256, 512, 1024, 2048]
}
# 3. 联合优化（架构参数 + 部署配置）
# 4. 在真实硬件上验证性能
return optimized_model关键创新点：
- 联合优化：同时考虑模型质量与硬件效率
- 真实测量：在Snapdragon等真实芯片上测量延迟和内存
- 帕累托前沿：找到质量-效率的最优权衡
2.2 混合主干架构
LFM2的核心设计是**门控短卷积 + 分组查询注意力（GQA）**的混合架构：
┌─────────────────────────────────────────────────────────────┐
│ LFM2 混合主干 │
├─────────────────────────────────────────────────────────────┤
│ Input Token Sequence │
│ ↓ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Gated Conv │ │ Gated Conv │ │ GQA Layer │ │
│ │ (3×1, k=3) │ → │ (3×1, k=3) │ → │ (h heads) │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ ↓ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ SiLU激活 │ │ SiLU激活 │ │ SwiGLU │ │
│ │ +残差连接 │ │ +残差连接 │ │ +残差连接 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ ↓ │
│ Output Representations │
└─────────────────────────────────────────────────────────────┘
门控短卷积模块
门控短卷积是LFM2区别于标准Transformer的关键组件：
// 门控短卷积的前向传播
template <typename T>
void gated_conv_forward(
const T* input, // [batch, seq_len, hidden_dim]
T* output,
const T* conv_w, // 卷积权重 [kernel_size, hidden_dim, hidden_dim]
const T* gate_w, // 门控权重 [hidden_dim, hidden_dim]
int batch, int seq_len, int hidden_dim, int kernel_size
) {
// 1. 深度可分离卷积：捕获局部模式
for (int b = 0; b < batch; ++b) {
for (int i = kernel_size - 1; i < seq_len; ++i) {
T conv_out = 0;
for (int k = 0; k < kernel_size; ++k) {
int idx = i - k;
for (int d = 0; d < hidden_dim; ++d) {
conv_out += input[b*seq_len*hidden_dim + idx*hidden_dim + d]
* conv_w[k*hidden_dim + d];
}
}
// 2. 门控机制：控制信息流
T gate = sigmoid(compute_gate(input, gate_w, i, hidden_dim));
output[b*seq_len*hidden_dim + i*hidden_dim :
(b+1)*seq_len*hidden_dim] = conv_out * gate;
}
}
}设计优势：
- 局部建模能力强：适合处理连续 token 序列中的局部依赖
- 计算效率高：相比全连接层，参数量大幅减少
- 与注意力互补：注意力捕获全局关系，卷积捕获局部模式
2.3 分组查询注意力（GQA）
LFM2采用GQA来平衡表达能力和计算效率：
| 注意力变体 | Key头数 | Value头数 | 表达能力 | 计算成本 |
|---|---|---|---|---|
| Multi-Head (MHA) | 最强 | |||
| Multi-Query (MQA) | 1 | 1 | 中等 | |
| Grouped-Query (GQA) | 平衡 |
LFM2-2.6B使用配置：
- Query头数：
- Key/Value头数：
- 压缩比：4倍
3. MoE变体：LFM2-8B-A1B
3.1 架构概述
LFM2-8B-A1B是LFM2系列的稀疏MoE变体，采用”密集+稀疏”混合模式：
┌─────────────────────────────────────────────────────────────┐
│ LFM2-8B-A1B 架构 │
├─────────────────────────────────────────────────────────────┤
│ Layer 1-N（前2层）：全专家激活（Dense） │
│ ┌─────────────────────────────────────────────────┐ │
│ │ Input → GatedConv → GQA → Output (N=2层) │ │
│ └─────────────────────────────────────────────────┘ │
│ ↓ │
│ Layer 3-N（剩余层）：稀疏MoE │
│ ┌─────────────────────────────────────────────────┐ │
│ │ Router → Top-4 Expert Selection │ │
│ │ ↓ ↓ ↓ ↓ │ │
│ │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │
│ │ │Exp 1│ │Exp 2│ │Exp 3│ │Exp 4│ (32 experts)│ │
│ │ └─────┘ └─────┘ └─────┘ └─────┘ │ │
│ │ ↓ │ │
│ │ Weighted Sum → Output │ │
│ └─────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
3.2 规范化Sigmoid门控机制
LFM2的专家路由采用规范化sigmoid门控（Normalized Sigmoid Gating）：
class NormalizedSigmoidGating(nn.Module):
"""LFM2 MoE的门控机制"""
def __init__(self, hidden_dim, num_experts, top_k):
super().__init__()
self.hidden_dim = hidden_dim
self.num_experts = num_experts
self.top_k = top_k
# 门控投影
self.gate = nn.Linear(hidden_dim, num_experts, bias=False)
# 自适应路由偏置（可学习）
self.routing_bias = nn.Parameter(torch.zeros(num_experts))
def forward(self, x):
"""
x: [batch, seq_len, hidden_dim]
"""
batch_size, seq_len, _ = x.shape
# 1. 计算原始门控分数
raw_logits = self.gate(x) # [B, S, E]
# 2. 添加可学习路由偏置（平衡专家负载）
logits = raw_logits + self.routing_bias
# 3. 规范化Sigmoid门控（核心创新）
# 相比softmax，更适合稀疏激活
probs = torch.sigmoid(logits) # [B, S, E]
# 4. Top-K选择 + 负载均衡正则化
topk_probs, topk_indices = torch.topk(probs, self.top_k, dim=-1)
# 5. 归一化
topk_probs = topk_probs / topk_probs.sum(dim=-1, keepdim=True)
return topk_probs, topk_indices规范化Sigmoid门控的优势：
| 特性 | Softmax门控 | Sigmoid门控 |
|---|---|---|
| 输出分布 | 竞争性（和为1） | 非竞争性（可多激活） |
| 专家利用率 | 可能不均衡 | 更易平衡 |
| 梯度特性 | 赢家通吃 | 更平滑 |
| 稀疏性 | 隐式稀疏 | 显式稀疏 |
3.3 温度化解耦Top-K知识蒸馏
训练LFM2-8B-A1B采用温度化解耦Top-K知识蒸馏策略：
class TemperedDecoupledKD(nn.Module):
"""温度化解耦知识蒸馏"""
def __init__(self, temperature=2.0, alpha=0.5):
self.temp = temperature
self.alpha = alpha
def compute_loss(self, student_logits, teacher_logits,
student_router, teacher_router):
# 1. 响应蒸馏损失
soft_loss = F.kl_div(
F.log_softmax(student_logits / self.temp),
F.log_softmax(teacher_logits / self.temp),
reduction='batchmean'
) * (self.temp ** 2)
# 2. 解耦路由器损失
# 路由器预测与实际激活解耦
hard_loss = F.cross_entropy(student_router, teacher_router)
# 3. 温度化组合
total_loss = self.alpha * soft_loss + (1 - self.alpha) * hard_loss
return total_loss4. 训练策略
4.1 数据规模与配比
| 阶段 | 数据规模 | 配比策略 |
|---|---|---|
| 预训练 | 10-12T tokens | 多领域均衡采样 |
| 课程学习 | 渐进式难度提升 | 短文本→长文本，简单→复杂 |
| 后训练 | 精选高质量数据 | SFT + 偏好优化 |
4.2 三阶段后训练流程
┌─────────────────────────────────────────────────────────────┐
│ LFM2 三阶段后训练流程 │
├─────────────────────────────────────────────────────────────┤
│ Stage 1: SFT (Supervised Fine-Tuning) │
│ ───────────────────────────────────────────────────── │
│ 目标: 基础指令跟随能力 │
│ 数据: 100K-1M 指令-响应对 │
│ loss = -Σ y log P(y|x) │
│ │
│ Stage 2: Length-Normalized Preference Optimization │
│ ───────────────────────────────────────────────────── │
│ 目标: 对齐人类偏好 │
│ 方法: 长度归一化防止长度作弊 │
│ loss = -log σ( (r_+/L_+ - r_-/L_-) / τ ) │
│ │
│ Stage 3: Model Merging (不确定时使用) │
│ ───────────────────────────────────────────────────── │
│ 目标: 结合多个模型的优点 │
│ 方法: 任务向量平均 / RegMean / TIES │
└─────────────────────────────────────────────────────────────┘
4.3 上下文长度
全系列LFM2模型支持32K上下文长度，采用：
- 位置编码：RoPE（Rotary Position Embedding）
- 注意力窗口：滑动窗口 + 全局注意力混合
- 长度外推：YaRN或类似技术
5. 性能分析
5.1 推理效率对比
在Snapdragon X Elite CPU上的基准测试结果：
| 模型 | 参数量 | Prefill速度 | Decode速度 | 内存占用 |
|---|---|---|---|---|
| LFM2-1.2B | 1.2B | 45 tokens/s | 28 tokens/s | 2.4GB |
| LFM2-2.6B | 2.6B | 32 tokens/s | 18 tokens/s | 5.2GB |
| LFM2-8B-A1B | 8.3B total / 1.5B active | 28 tokens/s | 15 tokens/s | 3.8GB |
| Llama-3.2-3B | 3B (dense) | 22 tokens/s | 12 tokens/s | 6.2GB |
| Qwen2.5-3B | 3B (dense) | 20 tokens/s | 11 tokens/s | 6.0GB |
关键发现：LFM2-8B-A1B在仅3.8GB内存下达到与6GB+ dense模型相当的性能。
5.2 质量基准
| 基准 | LFM2-2.6B | LFM2-8B-A1B | Llama-3.2-3B | Qwen2.5-3B |
|---|---|---|---|---|
| IFEval (指令遵循) | 79.56% | 86.2% | 81.4% | 83.7% |
| GSM8K (数学) | 82.41% | 89.3% | 85.2% | 87.1% |
| MMLU | 72.3% | 78.9% | 75.1% | 76.8% |
5.3 CPU效率提升
LFM2相比同等规模基线的CPU推理加速：
- Prefill阶段：1.8-2.0× speedup
- Decode阶段：1.6-1.9× speedup
- 内存带宽利用率：提升约40%
6. 多模态扩展
6.1 LFM2-VL（视觉-语言）
架构：LFM2 backbone + 视觉编码器（SigLIP或CLIP）
输入：图像 + 文本
处理：
1. 图像 → 分块 → SigLIP编码 → 视觉特征
2. 文本 → LFM2 Tokenizer → 文本特征
3. 跨模态注意力融合
4. LLM生成响应
6.2 LFM2-Audio（语音）
支持：
- 语音识别（ASR）
- 语音合成（TTS）
- 语音到语音对话
6.3 LFM2-ColBERT（检索）
基于ColBERT的延迟交互检索范式，适合RAG场景。
7. 设备端Fine-Tuning
7.1 Nanos系列
LFM2-Nanos是针对特定领域fine-tuned的轻量版本：
| 变体 | 领域 | 典型用例 |
|---|---|---|
| LFM2-Nano-Tool | 工具调用 | 代码助手、RAG |
| LFM2-Nano-Math | 数学推理 | tutoring |
| LFM2-Nano-Code | 代码生成 | IDE集成 |
7.2 LoRA支持
LFM2原生支持LoRA适配：
from peft import LoraConfig, get_peft_model
lora_config = LoraConfig(
r=16,
lora_alpha=32,
target_modules=["gate", "attn"], # 针对LFM2模块
lora_dropout=0.05,
bias="none"
)
lfm2_lora = get_peft_model(lfm2_base, lora_config)8. 部署支持
8.1 ExecuTorch部署
# ExecuTorch导出示例
from executorch.exir import EdgeCompileConfig, to_edge
# 1. 量化
quantized_model = quantize_dynamic(lfm2_model)
# 2. 导出
exported_program = to_edge(
compile(quantized_model)
)
# 3. 保存
exported_program.dump("lfm2-mobile.pte")8.2 llama.cpp支持
LFM2已集成到llama.cpp，支持：
- Metal GPU加速（macOS）
- Vulkan加速（Android）
- CPU原生推理
8.3 vLLM支持
# vLLM推理
from vllm import LLM, SamplingParams
llm = LLM(
model="LiquidAI/LFM2-2.6B",
tensor_parallel_size=1, # 单卡部署
gpu_memory_utilization=0.8
)
sampling_params = SamplingParams(temperature=0.7, max_tokens=512)
outputs = llm.generate(["Explain quantum computing:"], sampling_params)9. 与其他高效LLM的对比
| 特性 | LFM2 | MobileLLM | Mamba | RWKV |
|---|---|---|---|---|
| 注意力机制 | GQA | GQA | SSM | 线性注意力 |
| 局部建模 | 门控卷积 | 深度卷积 | SSM | RNN |
| MoE支持 | ✅ | ❌ | ❌ | ❌ |
| 硬件感知设计 | ✅ | ❌ | ❌ | ❌ |
| 开源程度 | 完全开源 | 部分开源 | 开源 | 开源 |
10. 总结
LFM2代表了设备端LLM设计的新范式：
- 硬件在环：真正面向目标硬件的联合优化
- 混合架构：卷积+注意力+MoE的协同
- 效率革命：在CPU上实现2倍加速
- 开源生态：完整的部署工具链
这些设计思想对于未来端侧AI的发展具有重要参考价值。
参考资料
Footnotes
-
Liquid AI, “LFM2: Liquid Foundation Models 2 Technical Report”, arXiv:2511.23404, 2025. https://arxiv.org/abs/2511.23404 ↩