中文 on 1zeryu's blog

DeepSeek-V4：算法架构

Fri, 24 Apr 2026 10:00:00 +0800

4 月 24 日，DeepSeek 发布其最新版本 DeepSeek-V4¹ 技术报告，并同步开源代码与模型权重。DeepSeek-V4 在多项评测中达到 SOTA 水平；在效率方面，相较于 DeepSeek-V3.2，DeepSeek-V4-Pro 的单 token 推理 FLOPs 降至 27%，KV 缓存缩减至 10%，从而稳定支持百万级 token 的长上下文处理。

DeepSeek-V4 技术报告包含四部分内容：算法架构、基础设施（infra）、预训练、后训练。本文结合公开的技术报告与代码，聚焦算法架构部分；其余内容可参考完整技术报告。

算法架构概述

DeepSeek-V4 算法架构（由 Image-2 生成）

DeepSeek-V4 的算法架构整体延续 DeepSeek-V3² 的设计，主要在以下几个方面进行了优化：

将 Transformer block 中的残差连接（Residual Connection）替换为 mHC（Manifold-Constrained Hyper-Connections）
将 V3 的 MLA（Multi-Head Latent Attention）替换为混合注意力架构（Hybrid Attention Architecture）
使用 Muon 作为优化器

其他模块（如前馈网络 MoE 与多 Token 预测（MTP））基本与 V3 保持一致。

Transformer Block

DeepSeek-V4 Transformer block 结构

前两项优化点都发生在 Transformer block 内部。如上图所示：DeepSeek-V4 在注意力层混合使用 CSA（Compressed Sparse Attention）与 HCA（Heavily Compressed Attention），在前馈层使用 DeepSeekMoE，并通过 mHC 强化传统残差连接。

mHC（Manifold-Constrained Hyper-Connections）

DeepSeek-V4 系列引入 mHC 用以强化相邻 Transformer block 之间的信号传播。与传统残差连接相比，可以把 mHC 理解为：把“一个残差流”升级成“多条并行残差流”。具体实现时，通过 repeat 将单个残差流扩展为多条并行残差流。

1

h = h.unsqueeze(2).repeat(1, 1, self.hc_mult, 1) # 在进入 Transformer block 之前，先将残差流扩展为多条并行残差流

每一层会动态决定：（1）从哪些流里读出主表示去做子层计算；（2）把子层输出写回到哪些流里；（3）让这些流之间按一个受约束的“混合矩阵”交换信息。以下给出 mHC 和传统残差连接的代码对比：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


def forward(self, x: torch.Tensor, start_pos: int, input_ids: Optional[torch.Tensor]) -> torch.Tensor:
 residual = x # [batch_size, seq_len, hc, hidden_size]
+ x, post, comb = self.hc_pre(x, self.hc_attn_fn, self.hc_attn_scale, self.hc_attn_base)
 x = self.attn_norm(x)
 x = self.attn(x, start_pos)
- x = residual + x # 传统残差连接，直接通过加法操作实现
+ x = self.hc_post(x, residual, post, comb)

 residual = x
+ x, post, comb = self.hc_pre(x, self.hc_ffn_fn, self.hc_ffn_scale, self.hc_ffn_base)
 x = self.ffn_norm(x)
 x = self.ffn(x, input_ids)
- x = residual + x
+ x = self.hc_post(x, residual, post, comb)
 return x

mHC 实现里，输入的 x 是一个 [batch_size, seq_len, hc, hidden_size] 的张量，其中 hc 与 hc_mult 对应同一超参数，用于控制并行残差流的数量。

函数 hc_pre 决定“这一层该从哪几份副本读信息”，即从多流中计算主表示用于后续子层计算。下面给出一个实现片段：其中 hc_fn 可理解为线性映射的参数，用于将输入映射到 mix_hc 个维度；hc_scale 是 3 维张量，用于控制混合矩阵的约束；hc_base 是 mix_hc 维张量，用于初始化混合矩阵。

hc_split_sinkhorn 是一个函数，用于将混合矩阵拆分成 pre、post 和 comb 三部分，分别对应了“从哪些流里读取信息”、“写哪些流里”和“混合矩阵”。

1
2
3
4
5
6
7
8
9


def hc_pre(self, x: torch.Tensor, hc_fn: torch.Tensor, hc_scale: torch.Tensor, hc_base: torch.Tensor):
 # x: [b,s,hc,d], hc_fn: [mix_hc,hc*d], hc_scale: [3], hc_base: [mix_hc], y: [b,s,hc,d]
 shape, dtype = x.size(), x.dtype
 x = x.flatten(2).float()
 rsqrt = torch.rsqrt(x.square().mean(-1, keepdim=True) + self.norm_eps)
 mixes = F.linear(x, hc_fn) * rsqrt
 pre, post, comb = hc_split_sinkhorn(mixes, hc_scale, hc_base, self.hc_mult, self.hc_sinkhorn_iters, self.hc_eps)
 y = torch.sum(pre.unsqueeze(-1) * x.view(shape), dim=2)
 return y.to(dtype), post, comb

hc_post 决定“子层的新信息写到哪些副本里，以及旧副本之间怎么混合”，即将子层的新信息写回到多流中，同时根据混合矩阵计算出新的主表示。这里用到 post 和 comb 两个张量，就是 hc_pre 中计算得到的分流矩阵和混合矩阵。

1
2
3
4


def hc_post(self, x: torch.Tensor, residual: torch.Tensor, post: torch.Tensor, comb: torch.Tensor):
 # x: [b,s,d], residual: [b,s,hc,d], post: [b,s,hc], comb: [b,s,hc,hc], y: [b,s,hc,d]
 y = post.unsqueeze(-1) * x.unsqueeze(-2) + torch.sum(comb.unsqueeze(-1) * residual.unsqueeze(-2), dim=2)
 return y.type_as(x)

混合矩阵的约束：在 mHC 中，每个 token / 层都会生成一个流间混合矩阵（代码里的 comb），用于在多条“残差流”之间搬运与重组旧状态。如果不加约束，混合矩阵可能出现尺度放大、信息坍缩到少数通道等问题，导致训练与深层信息传播不稳定。Sinkhorn 迭代通过交替进行行/列归一化，把混合矩阵投影到近似“双随机矩阵”（非负、行和列都约为 1）的集合附近，从而实现“质量守恒”的稳定混合：信息在通道间可交换，但不易无界放大或被单通道吸走。

hc_sinkhorn_iters 控制该投影的迭代次数，次数越多约束越严格但计算开销更大。

mHC 通过多流、可路由且受约束的残差机制，提升了表示的可分解性与信息传递灵活性，同时改善深层训练与长程依赖建模的稳定性。

混合注意力（Hybrid Attention）

尽管目前出现了各种注意力机制（Linear Attention、Sparse Attention、Heavily Compressed Attention 等），它们的核心目标大多是在尽量不损失效果的前提下提升计算效率。从实现形式上看，这些机制仍遵循自注意力的通用框架。下面给出一个简化的伪代码：

1
2
3
4
5
6
7
8


def attention(self, x):
 q = x_to_q(x)
 k = x_to_k(x)
 v = x_to_v(x)
 q, k, v = insert_position_embedding(q, k, v) # 注入位置编码
 o = apply_attention_mix(q, k, v) # 注意力计算，矩阵计算
 new_x = o_to_x(o)
 return new_x

Q, K, V 映射与位置编码注入

首先介绍 x_to_q、x_to_k、x_to_v 这三个函数，它们将输入的 x 分别转换为查询、键值张量。insert_position_embedding 函数用于将位置编码注入到查询、键值张量中。以下是 DeepSeek-V4 中的实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# module
self.wq_a = Linear(self.dim, self.q_lora_rank)
self.wq_b = ColumnParallelLinear(self.q_lora_rank, self.n_heads * self.head_dim)
self.wkv = Linear(self.dim, self.head_dim)
self.q_norm = RMSNorm(self.q_lora_rank, self.eps)
self.kv_norm = RMSNorm(self.head_dim, self.eps)

# forward
qr = q = self.q_norm(self.wq_a(x))
q = self.wq_b(q).unflatten(-1, (self.n_local_heads, self.head_dim))
q *= torch.rsqrt(q.square().mean(-1, keepdim=True) + self.eps)
apply_rotary_emb(q[..., -rd:], freqs_cis)
kv = self.wkv(x)
kv = self.kv_norm(kv)
apply_rotary_emb(kv[..., -rd:], freqs_cis)
act_quant(kv[..., :-rd], 64, scale_fmt, scale_dtype, True)

使用线性层映射将输入映射到对应的维度空间，并使用相对位置编码注入位置信息；可以注意到多头的设置主要在 q 上。其中 act_quant 的作用是量化，把 KV 向量里“非 RoPE 的维度”做 QAT 对齐量化为 FP8 精度，而 RoPE 相关维度保持原精度，以兼顾“与训练时量化分布一致”和“位置编码精度”。

Sparse Attention

在完成 $q$、$k$、$v$ 以及位置编码注入后，Hybrid Attention 的关键不在于对所有历史 token 计算完整的注意力矩阵，而是先为每个 query token 构造一个候选 KV 索引集合 topk_idxs，然后只在这些候选位置上做注意力计算（Sparse Attention）。这样复杂度从 $O(L^2)$ 下降到近似 $O(L \cdot K)$，其中 $K$ 是每个 query 对应的候选集合大小。

在 DeepSeek-V4 中，候选集合由两部分组成：

Window tokens（局部高保真）：滑动窗口内的最近历史 token，保证局部依赖的精细建模。
Compressed tokens（全局低成本）：对远程历史做压缩后得到的 KV 记忆，用少量 token 覆盖长上下文。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


topk_idxs = get_window_topk_idxs(win, bsz, seqlen, start_pos)

if self.compress_ratio:
 offset = kv.size(1) if start_pos == 0 else win
 if self.indexer is not None:
 compress_topk_idxs = self.indexer(x, qr, start_pos, offset)
 else:
 compress_topk_idxs = get_compress_topk_idxs(ratio, bsz, seqlen, start_pos, offset)
 topk_idxs = torch.cat([topk_idxs, compress_topk_idxs], dim=-1)

topk_idxs = topk_idxs.int()

其中：

win = window_size：窗口大小（如 128）。
ratio = compress_ratio：压缩比，ratio>0 表示该层启用压缩记忆。
offset：将窗口索引与压缩索引映射到统一的 KV 缓存坐标系（prefill 与 decode 阶段略有不同）。关于 KV cache 的背景可参考 Qwen3-Omni 博客的附加内容。

CSA 与 HCA：两种压缩策略的对应关系

在开源模型 DeepSeek-V4-Pro 中，模型一共有 61 层，对于每一层注意力机制的压缩率列表如下：

1

compress_ratios = [128, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 128, 4, 0]

除了最后一层，其余层都对历史窗口做了不同程度的压缩，压缩比的选择分别是 $4$ 和 $128$ 两种，分别对应 CSA（Compressed Self Attention, compress_ratio=4）和 HCA（Heavy Compressed Attention, compress_ratio=128）两种压缩注意力机制。

两种压缩注意力机制在筛选候选 KV 索引时，分别采用不同的策略。CSA 更强调“相关性选择”，HCA 更强调“极致压缩”。

CSA（Compressed Sparse Attention）：轻度压缩 + 稀疏检索。该模式下会启用 Indexer：对压缩 KV 做学习型相关性打分，并为每个 query 选择 top-k 压缩位置，从而实现“压缩 + 稀疏检索”的长程注意力。

CSA 选择器层代码实现（可跳过，本篇暂不展开讨论实现细节）

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155


class Compressor(nn.Module):
 """Compresses KV cache via learned gated pooling over `compress_ratio` consecutive tokens.
 When overlap=True (ratio==4), uses overlapping windows for smoother compression boundaries."""

 def __init__(self, args: ModelArgs, compress_ratio: int = 4, head_dim: int = 512, rotate: bool = False):
 super().__init__()
 self.dim = args.dim
 self.head_dim = head_dim
 self.rope_head_dim = args.rope_head_dim
 self.nope_head_dim = head_dim - args.rope_head_dim
 self.compress_ratio = compress_ratio
 self.overlap = compress_ratio == 4
 self.rotate = rotate
 coff = 1 + self.overlap

 self.ape = nn.Parameter(torch.empty(compress_ratio, coff * self.head_dim, dtype=torch.float32))
 # wkv and wgate in the checkpoint is stored in bf16, while the parameter here is stored in fp32 for convenient.
 # When overlap, the first half of dims is for overlapping compression, second half for normal.
 self.wkv = Linear(self.dim, coff * self.head_dim, dtype=torch.float32)
 self.wgate = Linear(self.dim, coff * self.head_dim, dtype=torch.float32)
 self.norm = RMSNorm(self.head_dim, args.norm_eps)
 self.kv_cache: torch.Tensor = None # assigned lazily from Attention.kv_cache
 # State buffers for decode-phase incremental compression.
 # With overlap: state[:, :ratio] = overlapping window, state[:, ratio:] = current window.
 self.register_buffer("kv_state", torch.zeros(args.max_batch_size, coff * compress_ratio, coff * self.head_dim, dtype=torch.float32), persistent=False)
 self.register_buffer("score_state", torch.full((args.max_batch_size, coff * compress_ratio, coff * self.head_dim), float("-inf"), dtype=torch.float32), persistent=False)
 self.freqs_cis: torch.Tensor = None

 def overlap_transform(self, tensor: torch.Tensor, value=0):
 # tensor: [b,s,r,2d]
 b, s, _, _ = tensor.size()
 ratio, d = self.compress_ratio, self.head_dim
 new_tensor = tensor.new_full((b, s, 2 * ratio, d), value)
 new_tensor[:, :, ratio:] = tensor[:, :, :, d:]
 new_tensor[:, 1:, :ratio] = tensor[:, :-1, :, :d]
 return new_tensor

 def forward(self, x: torch.Tensor, start_pos: int):
 assert self.kv_cache is not None
 bsz, seqlen, _ = x.size()
 ratio, overlap, d, rd = self.compress_ratio, self.overlap, self.head_dim, self.rope_head_dim
 dtype = x.dtype
 # compression need fp32
 x = x.float()
 kv = self.wkv(x)
 score = self.wgate(x)
 if start_pos == 0:
 should_compress = seqlen >= ratio
 remainder = seqlen % ratio
 cutoff = seqlen - remainder
 offset = ratio if overlap else 0
 if overlap and cutoff >= ratio:
 self.kv_state[:bsz, :ratio] = kv[:, cutoff-ratio : cutoff]
 self.score_state[:bsz, :ratio] = score[:, cutoff-ratio : cutoff] + self.ape
 if remainder > 0:
 kv, self.kv_state[:bsz, offset : offset+remainder] = kv.split([cutoff, remainder], dim=1)
 self.score_state[:bsz, offset : offset+remainder] = score[:, cutoff:] + self.ape[:remainder]
 score = score[:, :cutoff]
 kv = kv.unflatten(1, (-1, ratio))
 score = score.unflatten(1, (-1, ratio)) + self.ape
 if overlap:
 kv = self.overlap_transform(kv, 0)
 score = self.overlap_transform(score, float("-inf"))
 kv = (kv * score.softmax(dim=2)).sum(dim=2)
 else:
 should_compress = (start_pos + 1) % self.compress_ratio == 0
 score += self.ape[start_pos % ratio]
 if overlap:
 self.kv_state[:bsz, ratio + start_pos % ratio] = kv.squeeze(1)
 self.score_state[:bsz, ratio + start_pos % ratio] = score.squeeze(1)
 if should_compress:
 kv_state = torch.cat([self.kv_state[:bsz, :ratio, :d], self.kv_state[:bsz, ratio:, d:]], dim=1)
 score_state = torch.cat([self.score_state[:bsz, :ratio, :d], self.score_state[:bsz, ratio:, d:]], dim=1)
 kv = (kv_state * score_state.softmax(dim=1)).sum(dim=1, keepdim=True)
 self.kv_state[:bsz, :ratio] = self.kv_state[:bsz, ratio:]
 self.score_state[:bsz, :ratio] = self.score_state[:bsz, ratio:]
 else:
 self.kv_state[:bsz, start_pos % ratio] = kv.squeeze(1)
 self.score_state[:bsz, start_pos % ratio] = score.squeeze(1)
 if should_compress:
 kv = (self.kv_state[:bsz] * self.score_state[:bsz].softmax(dim=1)).sum(dim=1, keepdim=True)
 if not should_compress:
 return
 kv = self.norm(kv.to(dtype))
 if start_pos == 0:
 freqs_cis = self.freqs_cis[:cutoff:ratio]
 else:
 freqs_cis = self.freqs_cis[start_pos + 1 - self.compress_ratio].unsqueeze(0)
 apply_rotary_emb(kv[..., -rd:], freqs_cis)
 if self.rotate:
 kv = rotate_activation(kv)
 fp4_act_quant(kv, fp4_block_size, True)
 else:
 act_quant(kv[..., :-rd], 64, scale_fmt, scale_dtype, True)
 if start_pos == 0:
 self.kv_cache[:bsz, :seqlen // ratio] = kv
 else:
 self.kv_cache[:bsz, start_pos // ratio] = kv.squeeze(1)
 return kv


class Indexer(torch.nn.Module):
 """Selects top-k compressed KV positions for sparse attention via learned scoring.
 Has its own Compressor (with Hadamard rotation) to build compressed KV for scoring."""

 def __init__(self, args: ModelArgs, compress_ratio: int = 4):
 super().__init__()
 self.dim = args.dim
 self.n_heads = args.index_n_heads
 self.n_local_heads = args.index_n_heads // world_size
 self.head_dim = args.index_head_dim
 self.rope_head_dim = args.rope_head_dim
 self.index_topk = args.index_topk
 self.q_lora_rank = args.q_lora_rank
 self.wq_b = ColumnParallelLinear(self.q_lora_rank, self.n_heads * self.head_dim)
 self.weights_proj = ColumnParallelLinear(self.dim, self.n_heads, dtype=torch.bfloat16)
 self.softmax_scale = self.head_dim ** -0.5
 self.compress_ratio = compress_ratio

 self.compressor = Compressor(args, compress_ratio, self.head_dim, True)
 self.register_buffer("kv_cache", torch.zeros(args.max_batch_size, args.max_seq_len // compress_ratio, self.head_dim), persistent=False)
 self.freqs_cis = None

 def forward(self, x: torch.Tensor, qr: torch.Tensor, start_pos: int, offset: int):
 bsz, seqlen, _ = x.size()
 freqs_cis = self.freqs_cis[start_pos:start_pos+seqlen]
 ratio = self.compress_ratio
 rd = self.rope_head_dim
 end_pos = start_pos + seqlen
 if self.compressor.kv_cache is None:
 self.compressor.kv_cache = self.kv_cache
 self.compressor.freqs_cis = self.freqs_cis
 q = self.wq_b(qr)
 q = q.unflatten(-1, (self.n_local_heads, self.head_dim))
 apply_rotary_emb(q[..., -rd:], freqs_cis)
 q = rotate_activation(q)
 # use fp4 simulation for q and kv in indexer
 fp4_act_quant(q, fp4_block_size, True)
 self.compressor(x, start_pos)
 weights = self.weights_proj(x) * (self.softmax_scale * self.n_heads ** -0.5)
 # We performed QAT here, kv could also use fp8 format, though current implementation uses bf16
 index_score = torch.einsum("bshd,btd->bsht", q, self.kv_cache[:bsz, :end_pos // ratio])
 index_score = (index_score.relu_() * weights.unsqueeze(-1)).sum(dim=2)
 if world_size > 1:
 dist.all_reduce(index_score)
 if start_pos == 0:
 mask = torch.arange(seqlen // ratio).repeat(seqlen, 1) >= torch.arange(1, seqlen + 1).unsqueeze(1) // ratio
 index_score += torch.where(mask, float("-inf"), 0)
 topk_idxs = index_score.topk(min(self.index_topk, end_pos // ratio), dim=-1)[1]
 if start_pos == 0:
 mask = topk_idxs >= torch.arange(1, seqlen + 1).unsqueeze(1) // ratio
 topk_idxs = torch.where(mask, -1, topk_idxs + offset)
 else:
 topk_idxs += offset
 return topk_idxs

HCA（Heavily Compressed Attention）：重度压缩。此时压缩 token 数量极少，更偏向全局摘要记忆；实现上一般不启用学习检索，而是使用规则映射生成压缩候选索引，以获得极低成本的长上下文覆盖。

HCA 选择函数代码实现

1
2
3
4
5
6
7
8


def get_compress_topk_idxs(ratio: int, bsz: int, seqlen: int, start_pos: int, offset: int):
 if start_pos > 0:
 matrix = torch.arange(0, (start_pos + 1) // ratio) + offset
 else:
 matrix = torch.arange(seqlen // ratio).repeat(seqlen, 1)
 mask = matrix >= torch.arange(1, seqlen + 1).unsqueeze(1) // ratio
 matrix = torch.where(mask, -1, matrix + offset)
 return matrix.unsqueeze(0).expand(bsz, -1, -1)

在获取到候选索引 topk_idxs 后，模型调用 sparse_attn(q, kv_cache, ...) 仅对候选位置执行注意力计算。模型只需关注候选集合中的有效 token，而无需处理所有历史 token，从而实现高效计算。

输出投影

注意力输出 o 会先对 RoPE 维做逆变换（inverse），再通过分组的低秩输出投影映射回原始维度空间，得到该注意力层的最终输出：

查看代码：输出投影

1
2
3
4
5


apply_rotary_emb(o[..., -rd:], freqs_cis, inverse=True)
o = o.view(bsz, seqlen, self.n_local_groups, -1)
wo_a = self.wo_a.weight.view(self.n_local_groups, self.o_lora_rank, -1)
o = torch.einsum("bsgd,grd->bsgr", o, wo_a)
new_x = self.wo_b(o.flatten(2))

至此，Hybrid Attention 在保持窗口注意力高保真建模能力的同时，引入压缩记忆与稀疏计算，实现长上下文场景下的高效注意力计算。

Muon

本节不展开 Muon 的细节，可参考 Moonshot Muon。

DeepSeek-V4 优化器配置细节

DeepSeek-V4 对优化器采用精细化分工：

优化器	覆盖参数
AdamW（Loshchilov & Hutter, 2017）	嵌入层、预测头、mHC 静态偏置与门控、全部 RMSNorm 权重
Muon	除上述外的所有可训练参数

Muon 实现沿用 Moonshot 版三项核心技巧：

对 Muon 参数施加 权重衰减
引入 Nesterov 动量 提升收敛稳定性
对更新矩阵做 RMS 重缩放，直接复用 AdamW 超参数，无需二次调参

与原版差异：

正交化步骤改用 混合 Newton-Schulz 迭代，兼顾数值精度与低延迟
移除 QK-Clip 技巧

如有错误或遗漏，欢迎指正！

DeepSeek-AI, DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence. https://huggingface.co/collections/deepseek-ai/deepseek-v4 ↩︎
DeepSeek-AI, DeepSeek-V3 Technical Report. https://github.com/deepseek-ai/DeepSeek-V3 ↩︎

从 HunyuanWorld-Mirror 初探 3D 重建

Thu, 23 Apr 2026 10:00:00 +0800

什么是3D重建？

在数字世界里，2D 信息就是一张张图像：它们由像素排成的平面画布组成，每个像素只携带 (x, y) 坐标和颜色、亮度等属性，像一幅挂在墙上的画。而 3D 信息则像把画撕下来、折成立体纸雕——点不再只是平面上的像素，而是拥有了 (x, y, z) 三维坐标的“点云”；它们可以描述凹凸、距离与体积。

3D 重建是从一组 2D 图像恢复场景三维几何与外观的过程：用相机从多个角度采集同一场景的图像，通过特征匹配、三角测量或神经网络推理，把不同视角下的像素或特征“拼回”三维空间，最终输出点云、网格、深度图或 3D 高斯等表示，供测量、渲染或编辑使用。根据算法设计，输入可少至单张图像，也可多达数百帧视频；输出亦不限于点云，而是涵盖任何可描述 3D 结构的数据格式。

Feed-Forward 3D 重建

Feed-Forward 3D 重建是 3D 重建（3D Reconstruction）领域中一种新兴的范式。

传统的 3D 重建（如 SfM/MVS、早期 NeRF）像是一位严谨的“雕塑家”。你必须让模特站好，雕塑家要围着模特走一圈，仔细观察每个角度（多视角输入），然后对着这个特定的模特一点点凿刻、反复修改，耗费数小时甚至数天才能完成作品（单场景迭代优化 Per-scene Optimization）。

Feed-Forward 3D 重建则像是一位阅历无数、极其敏捷的“速写大师 + 3D 打印机”。你只需要给他看一张模特正面的照片（单图 / 稀疏视角输入），他凭借过去看过成千上万个人的经验（大规模数据集预训练的先验知识），瞬间就能在脑海里“脑补”出模特背面的样子，并在几秒钟内直接“打印”出 3D 模型。他不需要对着这张照片重新学习或反复打磨，只需看一眼就直接出结果（神经网络一次前向传播 Single Forward Pass）。

特性	传统的 3D 重建（基于优化）	Feed-Forward 3D（基于前馈网络）
代表技术	SfM、MVS、基础 NeRF、基础 3D Gaussian Splatting	VGGT、WorldMirror 等“大重建模型”
输入要求	高：通常需要几十到上百张覆盖全视角的图片，并且往往需要（或需要先估计）较准确的相机参数	低：通常只需要单张图片，或极少量几张图片（稀疏视角）；可把相机/深度等信息当作可选条件输入
计算过程	慢：针对当前场景做迭代优化，通过大量循环计算逐步收敛	快：数据一次通过预训练网络，直接输出 3D 表示（如三平面、点云、3D 高斯）
耗时	十几分钟到数天（取决于场景规模与优化设置）	几百毫秒到几秒（取决于模型与分辨率）
对未知区域	弱：未观测区域容易破洞、模糊或不稳定，需要更多视角或更强先验	强：依赖训练先验做“补全/猜测”，结果往往更完整，但不保证严格物理真实
精度与细节	高：慢工出细活，几何一致性强	中等到较高：受模型容量与数据分布影响，细节可能更“平均化”；常用后期优化精修

HunyuanWorld-Mirror

HunyuanWorld-Mirror¹ 是“前馈式（feed-forward）3D 重建”模型：给定单张或多张图像序列，并可选地提供几何先验（相机位姿 / 相机内参 / 深度），模型在一次前向传播中同时输出多种 3D 表示（点图，相机参数，多视角深度图，表面法线估计，3D 高斯），从而把传统的“估位姿→算深度→建模→渲染/导出”的链条压缩成更短的数据流。

数据流

本章根据 WorldMirror 的结构图，介绍重建模型从输入到输出的数据流过程。下图展示了 WorldMirror 的结构

模型的输入包括单张或多张不同视角的图像序列，以及可选的 3D 先验作为辅助信息。给定输入后，模型内部会先把每种可选先验分别编码为 token，与图像 token 融合；随后通过视觉 Transformer 主干网络聚合多视角特征；最后将聚合后的表征送入多头预测器，一次前向输出点图、相机参数、多视角深度图、表面法线与 3D 高斯。

输入与输出

模型输入包括：多视角图像序列，以及可选的几何先验（相机位姿、相机内参、深度图）。一次前向传播后，模型直接输出以下 3D 表示：

相机参数：模型矫正后的相机内外参
多视角深度图：模型矫正后的深度图
表面法线：以 RGB 表示方向向量的 2D 图像，使 3D 模型在光照下呈现正确阴影与高光
点图：3D 空间中离散点的集合，每个点包含 $(x, y, z)$ 坐标与颜色
3D 高斯：用数以万计至百万计的“3D 椭球体”组成场景，每个高斯球含中心位置、大小、旋转、不透明度与颜色（球谐函数）

Token处理与聚合

考虑到输入之间的模态差异，各类 token 的处理方式有所不同。在实际实现中，有 6 种不同来源的 token 被聚合成一个长序列，下表给出每种 token 的处理方式和来源：

Token 类型	形状（每帧）	来源	职责
patch_tokens	$[P, D]$	图像经 PatchEmbed	承载像素级外观信息，序列主体
cam_tokens	$[1, D]$	可学习参数	全局查询：“相机参数是什么？”
reg_tokens	$[4, D]$	可学习参数	吸收全局噪声 / 汇聚跨帧信息（DINOv2 register 思想）
pose_tokens	$[1, D]$	相机位姿先验 → MLP	注入已知外参（条件）
ray_tokens	$[1, D]$	内参先验 → MLP	注入焦距 / 光心（条件）
depth_tokens	$[P, D]$	深度先验经 PatchEmbed	注入已知深度（与 patch_tokens 相加，而非拼接）

其中深度信息（depth_tokens）与图像 patch_tokens 相对齐，depth_tokens 会被残差连接到对应的 patch_tokens 中。

1
2
3
4


depth_flat = depth_maps.reshape(B*S, 1, H, W)
depth_emb = self.depth_embed(depth_flat)
depth_tokens = depth_emb.reshape(B*S, P, D)
patch_tokens = patch_tokens + depth_tokens

其余 token 通过拼接聚合成最终长 token 序列，

1

all_tokens = concat([cam_tokens, reg_tokens, pose_tokens, ray_tokens, patch_tokens], dim=1)

注意力交互与中间层特征提取

每层 Transformer 包含两个串行的注意力阶段，包括 frame attention 和 global attention。在不同的 attention 阶段，token 的形状会变化：

1
2


frame attention： [B, S, N, D] → 在 N 上做 self-attention（每帧独立）
global attention：[B, S*N, D] → 在 S*N 上做 self-attention（所有帧全部交互）

这样做的目的是实现信息之间的阶段式交互：frame attention 会保持帧的独立性，token 只和同一帧内的其他 token 交互，相当于“先看清每帧里有什么”；global attention 把帧维展平，所有帧的 token 打成一片做 self-attention，相当于“再建立跨帧的对应关系”。

每一层结束后，判断当前层是否在 intermediate_idxs 列表中；如果在，则把特征保留到列表中用于后续处理。这些多层次的 outputs 会被传给 DPTHead，分别做不同分辨率的上采样与多尺度融合，最终生成稠密预测图（深度/法线/点等）。

1
2
3
4
5
6
7


for idx in range(depth): # depth = 24（large模型）
 local_tokens = frame_block(...)
 global_tokens = global_block(...)

 if idx in intermediate_idxs: # e.g. [4, 11, 17, 23]
 combined = concat([local_tokens, global_tokens], dim=-1)
 outputs.append(combined) # 沿通道维度拼接 → [B*S, N, 2D]

预测和解码

模型从主干提取的 token_list（多层 local + global 拼接特征）出发，通过四条并行的解码头从同一表征空间“投影”出不同任务：

相机（cam_head）：cam_head 直接消费 token_list（不经过 DPT 解码），输出相机参数向量（7D/14D 等），再经 transform_camera_vector 转成 c2w 外参矩阵和内参 K。
稠密预测（depth/pts/normals）：三者共享 DPTHead 架构，均经过 _extract_fused_features（多尺度特征融合 + 上采样），然后用各自专属的激活函数映射到物理量（参考 VGGT²）。
3DGS（gs_head + gs_renderer）：gs_head 从 transformer 的多尺度 token 融合出场景特征图和对应的深度图；特征图再经过一个小型 CNN 直接回归出每个像素对应的高斯参数（形状、旋转、不透明度、颜色），深度图结合相机参数将每个高斯投影到三维空间位置，最终所有高斯及其属性被打包输出为 splats ——这是一种可渲染的显式三维表示。

附加训练信息

WorldMirror 采用端到端联合训练，模型通过最小化一个多任务复合损失函数实现所有预测头的同步学习：

\[ \mathcal{L} = \mathcal{L}_{\text{points}} + \mathcal{L}_{\text{depth}} + \mathcal{L}_{\text{cam}} + \mathcal{L}_{\text{normal}} + \mathcal{L}_{\text{3dgs}} \]

在训练阶段，WorldMirror 的训练数据来自 15 个不同来源的数据集，涵盖多种场景类型与采集条件。这些数据集覆盖室内 / 室外环境、真实 / 合成场景、静态 / 动态物体，为模型提供了丰富的监督信号，使其能够学习到泛化能力较强的几何表征。

如有错误或遗漏，欢迎指正！

Liu Y, Min Z, Wang Z, et al. Worldmirror: Universal 3d world reconstruction with any-prior prompting[J]. https://github.com/Tencent-Hunyuan/HunyuanWorld-Mirror ↩︎
Wang J, Chen M, Karaev N, et al. Vggt: Visual geometry grounded transformer. https://github.com/facebookresearch/vggt ↩︎

从理论到实践，解析JEPA

Fri, 17 Apr 2026 10:15:00 +0800

引言

JEPA¹（Joint Embedding Predictive Architecture）是由 LeCun 等人提出的一类预测学习框架。本篇笔记分四个部分：先介绍 JEPA 的核心直觉（无数学推导），再解释 JEPA 的技术架构，然后以开源实现为例说明其推理与训练细节，最后补充一些问题与个人理解。

World Models

在介绍 JEPA 之前，先用 World Models（世界模型）做一个铺垫。世界模型可以理解为“环境的内部模拟器”，常见组件包括：

状态（State）：对当前世界状况的表征，通常由传感器或特征提取器给出。
动作（Action）：智能体可执行的操作集合，用于干预世界。
记忆（Memory）：对过去状态与动作的长期存储，用于推断未来。
预测（Prediction）：基于当前状态与动作对未来状态的估计。
规划（Planning）：利用预测结果选择最优动作序列以达成目标。

世界模型架构示意图

补充：在强化学习语境下，世界模型还常包含“转移（transition）”与“奖励（reward）”等概念；这里为了贴合 JEPA 的讨论，只保留与“表征—预测—规划”最相关的部分。

简言之，世界模型让智能体能在“脑内”展开未来，从而在不实际试错的情况下评估策略、降低探索成本。JEPA 可以被视为在表征学习与预测这条链路上提供了一种更稳健的建模方式：把原始输入映射到潜空间，并在潜空间里预测下一步的表征。

JEPA的核心理论

人在记忆或回想一个场景时，并不会逐像素保存所有细节，而是把“关键对象的属性与关系”压缩成一段“摘要”。在机器学习里，这种摘要通常对应嵌入（embedding）：用一个低维向量保留对下游任务最有用的信息。

JEPA 的核心思路是：先把输入的图像、视频、文本等原始数据编码成嵌入，再基于已经发生的上下文去预测“下一步嵌入”。换句话说，它用潜空间的“摘要”去推演“下一幕”，而不是直接在像素或 token 级别做逐点预测。

JEPA的技术架构

JEPA 的技术架构并不复杂，如下图所示。它的主要组件包括：将原始数据压缩进表征空间的 Encoder（编码器），以及在条件信息（例如动作、历史上下文）下预测未来表征的 Predictor（预测器）。

JEPA架构示意图

其中，$x$ 与 $y$ 都表示原始输入，并且两者在数据集中存在配对关系：例如时序关系（$y$ 是 $x$ 的下一时刻观测），或空间/视角关系（$y$ 与 $x$ 在同一场景中具有对应关系）。$z$ 表示预测器依赖的控制条件：可以是 $x\rightarrow y$ 的动作，也可以是掩码/可见区域等结构化条件（例如 I-JEPA²、V-JEPA³）。

训练时，JEPA 通过共享编码器或参数绑定等方式，把 $x$ 与 $y$ 的编码器输出 $S_x$、$S_y$ 对齐到同一向量空间，并学习让预测表征 $\hat{S}_y$ 逼近 $S_y$。这样编码器与预测器就在同一个“联合向量空间”里工作。

联合向量空间（Joint Embedding Space）是指将不同输入数据的压缩表示（embedding）映射到一个共同的向量空间中，从而能够将不同模态的输入数据进行统一的表示和处理；这也是JEPA的关键所在。

实际应用中，JEPA 往往还需要配合额外的稳定性设计，例如在表征上引入正则（如 SIGReg，参考 LeWorldModel⁴），或使用 EMA（Exponential Moving Average）等技巧来缓解表征坍缩与训练不稳定。

JEPA的代码实现

本章将介绍 JEPA 的代码实现，参考的开源项目包括 LeWorldModel、I-JEPA。对每个实现，主要关注其下游任务设定，以及推理与训练的关键细节。

LeWorldModel

下游任务与推理：LeWorldModel⁴ 选择的下游任务是规划（planning），可参考上文的世界模型架构示意图。直观上，JEPA 负责在潜空间里“滚动预测”，从而让规划算法能够在内部模拟器中评估动作序列的好坏。

具体地说，给定初始观测 $o_1$ 与目标观测 $o_g$，希望在规划时域 $H$ 内求解动作序列 $\{a_1, a_2, \ldots, a_H\}$，使系统从 $o_1$ 出发尽可能“靠近”目标 $o_g$。

官方给出的做法是：先把观测编码到潜空间。给定 $o_1$，得到初始潜变量 $\hat{z}_1=\mathrm{enc}_{\theta}(o_1)$。然后对候选动作序列做 rollout，在规划时域 $H$ 内按动作展开潜状态：

\[ \hat{z}_{t+1}=\mathrm{pred}_{\phi}(\hat{z}_t,a_t). \]

最终的目标是让末端预测潜状态 $\hat{z}_H$ 接近目标观测 $o_g$ 的潜表示 $z_g=\mathrm{enc}_{\theta}(o_g)$，即最小化终端代价

\[ \mathcal{C}(\hat{z}_H)=\|\hat{z}_H-z_g\|_2^2, \]

因此规划问题等价于在 JEPA 的联合向量空间中搜索/优化动作序列，从而得到从 $o_1$ 朝向目标的最优控制序列 $\{a_1,a_2,\ldots,a_H\}$：

\[ a_{1:H}^{*}=\arg\min_{a_{1:H}}\mathcal{C}(\hat{z}_H), \]

在优化时，编码器与预测器参数保持固定；动作序列通常随机初始化，并用 CEM（Cross-Entropy Method）这类采样式优化方法迭代更新动作分布：采样一批候选序列 → rollout 得到 $\hat{z}_H$ → 计算代价 $\mathcal{C}(\hat{z}_H)$ → 选取精英样本并更新采样分布，直到收敛或达到迭代上限。

训练：由于需要编码的输入是图像，LeWorldModel 使用 ViT 作为图像编码器：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


encoder = spt.backbone.utils.vit_hf(cfg.encoder_cfg) # 编码器backbone
projector = MLP(input_dim=hidden_dim, output_dim=embed_dim, **kwargs)

def encode(self, info):
 # 处理原始数据到对应格式
 pixels = info['pixels'].float()
 b = pixels.size(0)
 pixels = rearrange(pixels, "b t ... -> (b t) ...") # flatten for encoding

 # 编码器编码，并提取ViT输出的cls token作为图像表示
 output = self.encoder(pixels, interpolate_pos_encoding=True)
 pixels_emb = output.last_hidden_state[:, 0] # cls token

 # 映射到对应的维度
 emb = self.projector(pixels_emb)
 info["emb"] = rearrange(emb, "(b t) d -> b t d", b=b)
 return info

预测器的核心部分是一个 Transformer 架构，其作用是基于历史的图像 token 预测未来的图像 token：

1
2
3
4
5
6
7
8
9


predictor = ARPredictor(cfg.predictor_cfg) # 内部主要是一个Transformer架构
predictor_proj = MLP(input_dim=hidden_dim, output_dim=embed_dim, **kwargs)

def predict(self, emb, act_emb):
 # 预测未来状态的潜变量，并映射到对应的维度
 preds = self.predictor(emb, act_emb)
 preds = self.pred_proj(rearrange(preds, "b t d -> (b t) d"))
 preds = rearrange(preds, "(b t) d -> b t d", b=emb.size(0))
 return preds

LeWorldModel 的训练目标由两部分组成：预测损失与正则化损失。预测损失计算连续时间步上预测潜变量与目标潜变量的均方误差，以对齐预测器输出与编码器表征。其训练 forward 伪代码如下：

1
2
3
4
5
6
7
8
9


def lejepa_forward(self, batch, stage, lambd):
 emb, act_emb, tgt_emb = self.model.encode(batch)
 pred_emb = self.model.predict(emb, act_emb) # pred
 # 计算预测损失
 output["pred_loss"] = (pred_emb - tgt_emb).pow(2).mean()
 # 计算正则化损失
 output["sigreg_loss"]= self.sigreg(emb.transpose(0, 1))
 output["loss"] = output["pred_loss"] + lambd * output["sigreg_loss"]
 return output

只学习预测损失容易带来收敛不稳定（表征坍缩）。LeWorldModel 通过引入 SIGReg⁵ 正则化缓解这一问题。

I-JEPA

WIP（有空再更新）

FAQ

JEPA 是比 NTP 或 Diffusion 模型更好的建模方式？

就目前看到的工作而言，JEPA 更强调规划与自监督表征学习，而 NTP/Diffusion 更常用于生成与条件生成，两者关注点并不完全相同。JEPA 是否能在更广泛的生成任务上形成显著优势，还需要更多证据与系统性对比。

JEPA有哪些优势？

优势比较直观：潜空间压缩使推理更高效；自监督学习减少对人工标注的依赖。

个人吐槽

目前不少 AI 媒体喜欢用“技术革命”“主流架构”等词去描述一些相对朴素的想法。实际看下来，JEPA 仍处在较早期阶段，仍需要在训练稳定性、可扩展性与任务覆盖面上继续验证。

如有错误或遗漏，欢迎指正！

LeCun Y. A path towards autonomous machine intelligence. https://openreview.net/pdf?id=BZ5a1r-kVsf&utm_source=pocket_mylist ↩︎
Assran, Mahmoud, et al. “Self-supervised learning from images with a joint-embedding predictive architecture.” https://arxiv.org/pdf/2301.08243 ↩︎
Assran, Mido, et al. “V-jepa 2: Self-supervised video models enable understanding, prediction and planning.” https://arxiv.org/pdf/2506.09985 ↩︎
Maes, Lucas, et al. “Leworldmodel: Stable end-to-end joint-embedding predictive architecture from pixels.” https://le-wm.github.io/ ↩︎ ↩︎
Randall Balestriero and Yann LeCun. Lejepa: Provable and scalable self-supervised learning without the heuristics, 2025. URL https://arxiv.org/abs/2511.08544. ↩︎

Qwen3-Omni的数据流与模态融合

Mon, 13 Apr 2026 10:00:00 +0800

引言：大一统多模态大模型

过去几年，尽管 GPT 系列在问答、编程、创作上不断刷新纪录，但它们都只能处理文本输入，无法直接感知视觉和听觉信息。与仅聚焦文本、对声画“关门”的单模态 GPT 大模型不同，人类天然是多模态智能体，能同步感知视觉与听觉并借文字、语音或动作完成信息交流。

Omni-Model（大一统多模态模型）试图刻画不同模态信息之间的互补与协同关系，将文本、图像、音频乃至视频信号映射到统一的语义空间，从而实现跨模态的联合推理与生成。其目标不仅是“能看会听”，更在于让模型像人一样，在复杂场景下灵活调用多模态线索，做出一致且可解释的决策。

Qwen3-Omni 概览

Qwen3-Omni ¹ 模型架构采用“Thinker（语义模块）+ Talker（表述模块）”的双塔结构：Thinker 专注文本理解与生成，Talker 则依据 Thinker 输出的语义表征实时合成自然语音。下面的架构图还包含以下模块：

Vision Encoder：将视觉信息转化为 token 序列
AuT（Audio Transformer）：将音频信息转化为 token 序列
MTP（Multi-Token Prediction）：预测后续输出语音的离散编码
Streaming Codec Decoder：将 MTP 输出的离散编码转换为自然语音（声波）

Qwen3-Omni 总体架构（Thinker-Talker + MTP + 流式 Codec 解码）

数据流全链路：从输入到输出发生了什么

与纯文本大语言模型类似，模型在推理时会构造 messages 列表，其中每条 message 承载当前轮次交互所携带的模态信息；在 Qwen3-Omni 中，单条 message 可同时包含语音、图像、视频与文本。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


messages = [
 {
 "role": "user",
 "content": [
 {"type": "audio", "audio": "/path/to/audio.wav"},
 {"type": "image", "image": "/path/to/image.png"},
 {"type": "video", "video": "/path/to/video.mp4"},
 {"type": "text", "text": "Describe the audio, image and video."},
 ],
 },
]

经过预处理和模型推理后，最终会生成文本序列和语音序列。以下展示模型推理的源代码流程：

1
2
3
4
5


text = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
audios, images, videos = process_mm_info(messages, use_audio_in_video=use_audio_in_video)
inputs = processor(text=text, audio=audios, images=images, videos=videos, return_tensors="pt", padding=True, use_audio_in_video=use_audio_in_video)
inputs = inputs.to(model.device).to(model.dtype)
text_ids, audio = model.generate(**inputs, xxx) # xxx 为其他参数，如 max_new_tokens、do_sample、speaker 等

数据预处理

apply_chat_template 负责把用户传来的多轮对话 messages 按照模型预定义的 prompt 模板拼接成一段纯文本，为后续 tokenizer 提供统一的文本入口；拼接时会通过特殊字符串标明对话角色和模态信息的边界。例如下面的例子：

1
2
3
4


prompt = """<|im_start|>user
<|audio_start|><|audio_pad|><|audio_end|><|vision_start|><|image_pad|><|vision_end|><|vision_start|><|video_pad|><|vision_end|>Describe the audio, image and video.<|im_end|>
<|im_start|>assistant
"""

process_mm_info() 则在拼接前扫描 messages，把其中 audio/image/video 字段的文件路径或字节流提取出来，返回可供后续编码器读取的原始模态数据列表。

processor 再把“已模板化的文本”与“已提取的音频、图像、视频”一起送入各自的子编码器（文本 tokenizer、音频 AuT、视觉 Vision Encoder 等），最终打包成 PyTorch 张量，供模型 forward 阶段一次性并行计算。下面列出部分关键张量及其形状：

1
2
3
4
5


# 文本序列的token表示，每个数字表示token的索引
input_ids: torch.Size([1, text_token_length])
pixel_values: torch.Size([image_token_length, 1536])
pixel_values_videos: torch.Size([video_token_length, 1536])
input_features: torch.Size([B, feature_size, T])

Tokenize

基于 Transformer 的模型设计中，核心问题之一是如何把不同形态的输入转化为 token 序列（可理解为一个 N×D 的矩阵，N 为序列长度，D 为 token 维度）。在预处理阶段，各模态会被转化为长度不同的 token 序列，常见做法包括：

文本：将字符串分词为 token，得到 token id 序列；随后通过 Embedding 层映射为向量序列
图像：Vision Encoder 将每张图像切分为 patch（如 16×16），再经线性投影得到视觉 token；多图/多帧可按顺序拼接，对应张量 pixel_values
音频：使用 AuT（Audio Transformer）等声学编码器，将波形转为特征序列并进一步编码为音频 token（可类比 Whisper² 的前端与编码流程）
视频：通常先抽帧后按“图像”方式编码；若包含音轨，则音频轨道按“音频”方式编码，最终共同形成 pixel_values_videos

最终 processor 会把三种模态的 token 按 prompt 模板中的出现顺序插到文本 token 流里，组成一条统一的“多模态长序列”，再整体送进 Transformer。

Thinker-Talker 分层推理

前文提到，Qwen3-Omni 采用双塔结构：Thinker 负责文本理解与生成，Talker 则根据 Thinker 输出的语义表征实时合成自然语音，二者在推理阶段依次执行。在 model.generate 中，核心流程的伪代码如下：

1
2
3
4
5
6
7
8
9


# 1. 文本生成 (Text Generation)
thinker_result = thinker.generate(input_ids, output_hidden_states=True)
# 2. 模态对齐与特征桥接 (Modality Alignment & Bridging)
talker_inputs, trailing_text = align_and_project_features(thinker_result.hidden_states)
# 3. 声学特征预测 (Acoustic Feature Prediction)
talker_result = talker.generate(inputs_embeds=talker_inputs, trailing_text=trailing_text)
audio_codes = extract_codes(talker_result)
# 4. 波形重建 (Waveform Decoding)
wavs = code2wav.chunked_decode(audio_codes, chunk_size=300)

整个端到端推理过程可分为四个阶段：

文本生成：核心模型（Thinker）处理多模态输入并自回归生成文本回复，同时输出每步的隐层状态；
特征桥接：提取 Thinker 的浅层和深层特征，将文本与多模态信息投影到声学语义空间，作为语音合成的条件；
声学预测：语音生成模型（Talker）接收桥接特征，自回归地预测离散音频编码（Audio Codes）；
波形重建：流式解码器（Code2Wav）通过分块解码策略，将离散编码实时转换为最终的音频波形。

NTP 推理过程: 上述“文本生成”属于标准的 NTP（Next Token Prediction）任务：模型依据当前输入序列，逐轮自回归地预测下一个 token。更具体地说，在 generate 内部，每轮都会调用 Thinker/Talker 输出概率分布，再经 Top-p/Top-k 等采样确定下一个 token；随后将其追加到序列末尾，循环直至生成完整的文本序列。

KV Cache: 为了避免对已生成 token 重复计算 Key/Value 向量，系统会维护 KV cache：每步只计算新增 token 的 K/V，并与缓存拼接。这样，序列变长时 Thinker/Talker 的推理延迟通常保持近似线性增长，而不至于出现二次级别的计算开销。

不同模态间的交互与融合

为了实现不同模态之间的交互与融合，Qwen3-Omni 会将来自文本、图像、音频、视频等模态的 token 按照 prompt 中的出现顺序拼接成一条统一的长序列，并将其整体输入 Transformer。在自注意力机制作用下，不同模态 token 可以相互建立关联，从而得到融合后的表征与输出序列。

而要实现这一点，Qwen3-Omni 会进行以下步骤：

统一不同模态的 token 维度：将不同模态的 token 序列（如文本 token、图像 token、音频 token、视频 token）映射到统一的特征维度（如 768、1024 等），一般通过映射层（如 Linear）实现。
合并不同模态的 token 序列：将不同模态的 token 序列按 prompt 中的出现顺序拼接成一条统一的长序列，作为 Transformer 的输入。如上文（见：prompt 模板示例），其中的 <|audio_start|><|audio_pad|><|audio_end|> 用于标记音频 token 的起始与结束位置；图像与视频 token 同理。

小结

本篇笔记主要想解释 Qwen3-Omni 的“推理期数据流”与“融合方式”。但是还有其他Qwen3-Omni的其他设计未提及，包括但不限于：

Transformer 模型设计细节（如注意力结构、位置编码、长上下文策略等）
Omni-modal 的训练工程与数据科学（数据构造、对齐信号、损失与混训策略等）
语音后处理模块（MTP 与 Code2Wav）：语音生成链路与文本生成链路在目标与解码细节上并不完全一致，建议结合论文与代码对照理解

如有错误或遗漏，欢迎指正！

Jin Xu et al., Qwen3-Omni Technical Report, arXiv:2509.17765. https://arxiv.org/abs/2509.17765 ↩︎
Radford, Alec, et al. “Robust Speech Recognition via Large-Scale Weak Supervision.” https://github.com/openai/whisper ↩︎