Two and One

Posted Nov 25, 2025Updated Nov 25, 2025blog6 minutes read (About 846 words)

引言

在快要到 2026 年的今天, ViT 相比于当下的复杂的结构而言, 已经显得比较简单了, 我读论文的时候的最大感觉是, 它充满了 Transformer 在各领域蓬勃发展的野蛮生长的气息.
但是作为 Transformer 在 CV 领域的里程碑式的工作, 并且我作为这方面的初学者, 我觉着还是需要读一下这一篇论文An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale, 做一个简单的记录.

ViT 的整体结构

ViT 的整体结构如下图所示:

可以看到, 他的特殊处理是在于输入部分, 传统的 CNN 是通过 kernel 来滑动提取局部信息, 这样的一个 CNN 的输出很难直接送入 Transformer 中进行处理, 因为
Transformer 需要的是一个序列化的输入, 而 CNN 的输出是一个三维的 feature map.

因此, 相较于同期的其他处理, ViT 直接将输入图像划分为若干个小的 patch, 然后将每个 patch 展平并映射到一个固定维度的向量空间中, 形成一个序列化的输入, 这样就可以直接送入 Transformer 中进行处理.

具体来说, 假设输入图像的尺寸为 $H \times W \times C$ (高度, 宽度, 通道数), 我们将其划分为大小为 $P \times P$ 的若干个不重叠的 patch, 则总共会得到 $N = \frac{H W}{P ^{2}}$ 个 patch.
每个 patch 被展平为一个向量, 并通过一个线性投影映射到一个 $d$ 维的向量空间中, 形成一个序列化的输入矩阵 $X \in R^{N \times d}$ .
此外, 为了让模型能够捕捉到位置信息, ViT 还引入了可学习的位置编码, 将其与输入序列相加, 形成最终的输入表示.
接下来, 这个序列化的输入就可以直接送入标准的 Transformer Encoder 中进行处理, 经过多层的 Transformer Encoder Layer 的处理后, 得到最终的输出表示.

其具体的一个维数变换大概是这样: $X \in R^{224 \times 224 \times 3} \to 196 \times P a t c h s^{16 \times 16 \times 3} \to Fl a tt e n e d_{P} a t c h s^{196 \times 768} \to T r an s f or m er I n p u t^{197 \times 768} \to T r an s f or m er O u tp u t^{197 \times 768} \to Cl a ss i f i er O u tp u t^{1 \times 1000}$
为什么新加上的 class token work?

因为在 transformer 中, 两两 token 之间是可以相互 attention 的, 因此 class token 可以和所有的 patch token 进行 attention, 从而聚合全局的信息, 这样我们就可以在最终的输出中使用 class token 来进行分类任务.

一些其他的细节

相对于 CNN 而言, ViT 的先验信息很少, 因此在中小数据集上的表现并不理想, 论文中提到需要在大规模数据集上进行预训练, 然后再进行微调, 才能取得较好的效果.

此外, ViT 的 attention 机制也与 Transformer 类似, 主要包括 Multi-Head Self-Attention 和 Feed-Forward Neural Network (FFN) 两个部分, 具体的计算过程与 Transformer 中的 Self-Attention 类似, 这里就不再赘述.

总的来说, ViT 通过将图像划分为 patch 并使用 Transformer 进行处理, 提供了一种新的思路来解决计算机视觉中的图像分类问题, 并且在大规模数据集上取得了优异的表现, 成为计算机视觉领域的重要里程碑.

Posted Nov 24, 2025Updated Nov 24, 2025blog12 minutes read (About 1795 words)

回顾一下Transformer

引言

Transformer 在Attention is All You Need一文中被提出, 本来想读一下原文的, 但是时间并不太够, 因此我们这里就简单捋一下就行.

整体结构

Transformer 的整体结构如下图所示:
Transformer架构图
可以看到, 其主要由 Encoder 和 Decoder 两部分组成.

Transformer 的工作流程:
- 首先获取输入每一个词的表示向量 $X$ , $X$ 由单词的 embedding 和位置的 embedding 相加得到.
- 然后将 $X$ 输入到 Encoder 中, 经过多层的 Encoder Layer 的处理, 得到编码后的表示 $Z$ .
  - $Z$ 用 $X_{n \times d}$ 表示, 其中 $n$ 是序列长度, $d$ 是词向量的维度.
- 接着将目标序列的输入 $Y$ 输入到 Decoder 中, 经过多层的 Decoder Layer 的处理, 并结合 Encoder 的输出 $Z$ , 最终得到预测结果 $\hat{Y}$ .如下图:
  - 使用的过程中, 翻译到单词 $i + 1$ 时, 需要通过Mask操作掩盖住未来的信息, 以防止模型在预测时看到未来的词.

OK, 下面我们来具体看看 Encoder Layer 和 Decoder Layer 的结构.

Self-Attention 机制

Transformer 的核心是 Self-Attention 机制, 其结构如下图所示:

Self-Attention架构图

左侧为Encoder block
右侧为Decoder block
红圈中的部分为Multi-Head Attention机制, 是由多个 Self-Attention 组成的.

可以看到Encoder block包含一个Multi-Head Attention层.
Decoder block包含两个Multi-Head Attention层, 第一个用于处理目标序列的输入, 第二个用于结合 Encoder 的输出.
每个 Attention 层后面都跟着一个**Feed-Forward Neural Network (FFN)**层.

因为Self-Attention机制是 Transformer 的核心, 因此我们重点来看一下它的计算过程.

dsa

上图是Self-Attention的计算流程图, 计算时需要用到三个矩阵: Query ( $Q$ ), Key ( $K$ ), Value ( $V$ ), 实际过程中, 这三个矩阵都是通过输入的表示 $X$ 经过线性变换得到的.

Q, K, V 的计算

Self-Attention机制中, 对于输入的表示 $X \in R^{n \times d}$ , 可以使用线性变换矩阵 $W_{Q}, W_{K}, W_{V} \in R^{d \times d_{k}}$ 来计算 $Q, K, V$ : $Q = X W_{Q}, K = X W_{K}, V = X W_{V}$

实现

from math import sqrt


class SelfAttention(nn. Module): 
 def __init__(self, d_model, d_k, d_v): 
 " " " 
 input: X: (batch_size, n, d_model)
 q: (batch_size, n, d_k)
 k: (batch_size, n, d_k)
 v: (batch_size, n, d_v)
 " " " 
 super(SelfAttention, self).__init__()
 self.d_k = d_k
 self.W_Q = nn. Linear(d_model, d_k)
 self.W_K = nn. Linear(d_model, d_k)
 self.W_V = nn. Linear(d_model, d_v)
 self._norm_factor = sqrt(d_k)
 
 def forward(self, X): 
 Q = self.W_Q(X) # Q: (batch_size, n, d_k)
 K = self.W_K(X) # K: (batch_size, n, d_k)
 V = self.W_V(X) # V: (batch_size, n, d_v)
 
 scores = torch.matmul(Q, K.transpose(-2, -1)) / sqrt(self.d_k) # (batch_size, n, n)
 attn_weights = torch.softmax(scores, dim=-1) # (batch_size, n, n)
 output = torch.matmul(attn_weights, V) # (n_batch_size, n, d_v)
 
 return output

因此, 当我们得到了 $Q, K, V$ 后, 就可以计算 Attention 的输出了: $Attention (Q, K, V) = softmax (\frac{Q K ^{T}}{d _{k}}) V$

得到 $Q K^{T}$ 之后, 使用 Softmax 函数对每一行进行归一化, 即每一行的和都变为 1.

最后将归一化后的权重矩阵与 $V$ 相乘, 得到最终的 Attention 输出.

上图中softmax矩阵的第一行可以理解为单词 1 对其他单词的关注程度, 最终单词 1 的输出 $Z_{1}$ 等于所有单词的值 $V$ 加权求和.

Multi-Head Attention

上一步中, 我们已经知道怎么使用 Self-Attention 机制来计算 Attention 的输出了, 但是 Transformer 中使用的是Multi-Head Attention机制, 其结构如下图所示:

Multi-Head Attention架构图

从上图中可以看到Multi-Head Attention机制包含多个并行的 Self-Attention 头, 每个头都有自己的一组线性变换矩阵 $W_{Q}^{i}, W_{K}^{i}, W_{V}^{i}$ .

首先将输入 $X$ 分别传递到 h 个 Self-Attention 头中, 得到 h 个不同的 Attention 输出, 下面是 h = 8 的例子:

from math import sqrt

class MultiHeadAttention(nn. Module): 
 def __init__(self, d_model, d_k, d_v, h): 
 " " " 
 input: X: (batch_size, n, d_model)
 q: (batch_size, d_model, d_k)
 k: (batch_size, d_model, d_k)
 v: (batch_size, d_model, d_v)
 " " " 
 super(MultiHeadAttention, self).__init__()
 self.h = h
 self.d_k = d_k
 self.d_v = d_v
 
 self.W_Q = nn. ModuleList([nn. Linear(d_model, d_k) for _ in range(h)])
 self.W_K = nn. ModuleList([nn. Linear(d_model, d_k) for _ in range(h)])
 self.W_V = nn. ModuleList([nn. Linear(d_model, d_v) for _ in range(h)])
 self.linear = nn. Linear(h * d_v, d_model)
 
 def forward(self, X): 
 heads = []
 for i in range(self.h): 
 Q = self.W_Q[i](X)
 K = self.W_K[i](X)
 V = self.W_V[i](X)
 
 scores = torch.matmul(Q, K.transpose(-2, -1)) / sqrt(self.d_k)
 attn_weights = torch.softmax(scores, dim=-1)
 head = torch.matmul(attn_weights, V) # (batch_size, n, d_v)
 heads.append(head)
 
 concat_heads = torch.cat(heads, dim=-1) # (batch_size, n, h * d_v)
 output = self.linear(concat_heads) # (batch_size, n, d_model)
 
 return output

得到 8 个输出后, 将它们在最后一个维度上进行拼接, 得到一个新的表示, 然后通过一个线性变换矩阵 $W_{O}$ 将拼接后的表示映射回原始的维度 $d_{m o d e l}$ .

可见Multi-Head Attention输出的矩阵维度与输入矩阵的维度相同, 这样就可以方便地将其与后续的层进行连接.

Other components

剩余的层比较简单, 因此不再赘述.

Decoder Layer

Decoder Layer 的结构如下图红框内所示:

其与 Encoder Layer 的主要区别在于多了一个Masked Multi-Head Attention层, 该层用于处理目标序列的输入, 并且在计算 Attention 时会掩盖住未来的信息, 以防止模型在预测时看到未来的词.

第一个Multi-Head Attention

我们重点解释一下 Mask 操作.

第一步是 Decoder 的输入矩阵和 Mask 矩阵, Mask 矩阵是一个上三角矩阵, 用于掩盖未来的信息.
接下来的操作和之前的 Self-Attention 机制类似, 通过输入矩阵计算 $Q, K, V$ ., 之后计算 $Q K^{T}$ .
然后将 Mask 矩阵应用到 $Q K^{T}$ 上, 将被掩盖的位置设置为负无穷大, 这样在 Softmax 计算时, 这些位置的权重会变为 0.

最后进行 Softmax 归一化, 并与 $V$ 相乘, 得到最终的 Attention 输出.

第二个Multi-Head Attention

第二个 Multi-Head Attention 层与 Encoder Layer 中的 Multi-Head Attention 层类似, 只是这里的 $K$ 和 $V$ 来自于 Encoder 的输出 $Z$ , 而 $Q$ 来自于第一个 Attention 层的输出.

根据 Encoder 的输出 $C$ 计算得到 $K$ 和 $V$ , 根据上一个 Attention 的输出 $D$ 计算得到 $Q$ , 然后计算 Attention 的输出.

时间复杂度分析

Transformer 的时间复杂度主要来自于 Self-Attention 机制. 对于一个长度为 $n$ 的序列, Self-Attention 的时间复杂度为 $O (n^{2} \cdot d)$ , 其中 $d$ 是词向量的维度. 这是因为在计算 $Q K^{T}$ 时, 需要进行 $n \times n$ 的矩阵乘法, 每个元素的计算涉及到 $d$ 维的向量点积.
因此, 对于一个包含 $L$ 层 Encoder 和 Decoder 的 Transformer 模型, 总的时间复杂度为 $O (L \cdot n^{2} \cdot d)$ .

总结

Transformer 应该是这样的.

Posted Nov 01, 2025Updated Nov 01, 2025blog14 minutes read (About 2168 words)

SLAM Former 阅读

引言

最近几天读了SLAM-Former: Putting SLAM into One Transformer这篇很近很近的工作，本文笔记记录用于后续翻阅学习

首先， SLAM-Former 与之前读到的所有论文相似，都是致力于从 RGB 图像序列中恢复三维场景结构和相机位姿等属性的工作。但是与之前的工作（包含一个冗长复杂的 pipeline ）不同，
SLAM-Former 对已有的 transformer 架构进行了大胆的改进，使之更适合进行重建任务，并在实验中得到了 competitive 的结果。

模型结构

SLAM-Former架构图

据作者所述， SLAM-Former 的主要 pipeline 由 frontend 和 backend 两部分组成，至于模型的 backbone ， SLAM-Former 建立在一个 Transformer 架构之上，
而这个 Transformer aggregate 了 intraframe 和 interframe 的信息，并使用 task specific heads 预测不同的三维属性。
值得注意的是，这个 Transformer 的输入与 $π^{3}$ 类似，对所有的输入的 image token 共享一个相同的 register tokens
从而使模型不依赖于一个不稳定的 reference frame 。

模型的 backbone 包含了 $L$ 层组合了 intra-frame attention 和 inter-frame attention
来联合捕捉图像内容和图像之间的关系。

此外， Front end 部分负责增量式的逐帧重建， back end 负责全局的点云对齐和相机优化，他们共享一个
Transformer backbone 。

Front end

图中大部分内容都是 front end 的处理细节，当一个新的 frame 输入时， frontend 首先会
决定其是否为 keyframe ，如果是的话，则会进行进一步处理。

当给定一个 frame sequence 时， frontend 将每一个 frame 映射到一个 map token 集合中： $F < e m > t = f < / e m > f n (I < e m > t) < / e m > C_{k} < e m > K \in S$
这里, ${C_k}{K\in S}$表示之前 keyframe 的KV cache，
， $S$ 代表着 keyframe 的索引集合， $F_{t}$ 是当前 frame 的 map token, 作为该 frame 的
一个隐式神经表示。同时新的 KV cache 也通过$C_t = Cache(f(\mathbb{F}t))$产生，
也会视情况被扩充到${C_k}{K\in S}$中。

Keyframe detection

在上一步中我们已经对当前帧 generated 了 map token ，接下来我们需要决定是否为 keyframe.

作者采用了 pose head 来预测当前帧的 pose ： $g_{t} = h_{p ose} (F_{t})$

当当前 frame 的 relative pose 与最近的 keyframe 的 pose 之间的差异大于一个阈值时，
则将当前 frame 标记为 keyframe 。

但是作者在论文里又表明，在检测 frame 是否为 keyframe 时，他们并没有依赖 KV cache
, 而是直接应用了 $f_{f n} (I_{k_{p re v}}, T_{t})$ 来检测，就相当于之前的 KV cache 是将该图片
与所有的 keyframe 进行 attention 计算，而这里则是只与最近的 keyframe 进行 attention 计算。
这样增加了效率并且避免了选取一个特定的 reference frame 。（这里似乎我没怎么懂跟特定的 reference frame 有什么关系）

Front end tracking and mapping

接着上一步，如果一个新的 frame 已经被认为是一个 keyframe ，我们就可以重新利用全部的 KV cache 来重新
计算他的 map token, 并更新 M, S.

好了， front end 到这里差不多结束了，作者说 frontend 只依赖于过去的 keyframe ，
使得其适合于 online 的 tracking ，然而，这种处理顺序会导致误差累积和局部不一致，
为了解决这一问题，作者引入了一个 back end 模块来进行 global refinement.

Backend

Backend 的主要任务是 refine 所有的 frame 来达到全局的一致性。传统的
SLAM 系统通常会使用 loop closure 和 bundle adjustment 来实现这一点，
但是这些方法都非常的 costly, 作为对比，作者使用了一个 transformer-based 的
back end 来进行全局的优化。

作者认为这个设计的有效性在于 backend transformer 内部的 full attention 机制，
他的全局感受野使得模型能够完成误差纠正和结构一致性。

此外，为了继承 backend refinement 的优势， frontend 和 backend 共享了 KV cache ，
使得 frontend 能够受益于 backend 的全局优化。

Training Strategy

与以往的一些论文不同， SLAM-Former 的创新点不止在于模型架构，也在于一些训练策略。

作者的目标是使一个 transformer 同时胜任 frontend 和 backend 的任务，为了达到这个目标，
作者用三种模式联合训练，每一个模式都对应着不同的输入输出对。

训练模式图

Training Frontend

Frontend 用了一个 causal mask 来确保每一个 frame 只能访问之前的 keyframe 。

然而，纯净的使用 causal mask 会自动的将第一帧作为 reference frame ，
作者又注意到党对两帧或更多帧进行联合操作时，没有单一的 refernce frame,
这避免了后续帧需要与 reference frame pose 相似的要求。

因此，作者对前两帧使用了 full attention ，并同时对所有后续 frame 使用 causal mask,
在这种情况下， inference 时， keyframe detection 将最后一帧关键帧和当前的输入帧进行处理，
tracking and mapping 时，前两个 keyframe 则会联合处理决定全局坐标。

作者的原文是：

For tracking and mapping, the
first two keyframes are jointly processed to determine the
global coordinate.

取前两帧的做法与之前的 tracking and mapping 部分提到的 use full KV cache 不符，
我感觉不怎么理解。

Training Frontend with Backend Cooperation

为了在 frontend 和 backend 之间建立联系，作者使用 maxed attention 来模拟 backend 和
cache sharing 的过程。

具体来说，采用混合注意力在一个统一的正向传播中同时完成地图精炼（后端/全注意力）和新数据处理，
并且前端的 casual attention 并非独立工作，而是以 KV cache 为条件，实现了高效且信息流一致的前端-后端协作，确保前端的实时处理结果能够立即对齐到后端修正后的全局结构。

$F = f_{f n} (I) < e m > C < / e m > M$

woc 这什么花式操作啊

Training Backend

作者最后使用 full attention 来训练 backend transformer ，

Joint Training

在所有的三种模式中，三维属性均是由 task specific heads 预测的：

$P^{<} e m >, Σ^{<} / e m >, g^{*} = h (F) .$

但值得注意的是，并不像其他的工作一样， SLAM-Former 只预测每一帧的 local
pointmap 来避免设定一个特定的世界坐标系的需求，这倒是与 $π^{3}$ 非常相似。

剩下的 loss 函数都比较常规。
这三种模式都会在一个 batch 中共享权重依次训练。

Pipeline

在图片和叙述过程中， pipeline 已经是显而易见的，于是我便不再赘述。

Experimental Setup

本模型有 36 层 framewise 和 global attention 相结合的 transformer layer, 训了 10 个
epoch, 在 32 个 A100 上训练了 11 小时。可以可以。

Results

模型在 pose ， tracking 和 reconstruction 等任务上都达到了很好的指标。数据冗长不再多说。
值得一提的是作者对 Front end 和 back end 的联系的理解。

back end assist front end 无疑是显而易见的，但是作者还发现 back end 同样也
benefit from front end, 作者解释了是因为 back end 使用了来自于 frontend 的
implicit 的顺序信息，从而使得 back end 能够更好地理解 frame 之间的关系。（迷）

总结

总之， SLAM-Former 通过对 transformer 架构的改进和训练策略的设计，
成功地实现了一个统一的模型来处理 SLAM 任务。

但 SLAM-Former 仍然存在一些局限性，比如说作者用 full attention 来替代传统的 loop
closure 和 bundle adjustment ，受限于 full attention 的计算复杂度，模型难以处理非常长的序列，
其次， frontend 不支持一个 local 的 inference ，因为在 inference 之前需要将所有的 KV cache 输入到 frontend 中。

此外，文章中没有提到的是，我去看他们的 demo ，发现重建结果有很明显的分块化现象，目前不知是否与 transformer 的架构有关。

此文撰写的时候， SLAM-Former 的代码尚未开源，期待后续的代码发布。

Posted Oct 31, 2025Updated Oct 31, 2025blog12 minutes read (About 1868 words)

重返vggt

引言

这是本人在学了一些基础知识并做了一些实验之后, 察觉到之前对于一些经典论文的阅读并不充分, 于是决定重新阅读VGGT一文, 并写下这篇文章, 以供后续查阅.

首先, VGGT 是一个完全的前馈式神经网络用于多目重建任务, 通过 look into 他的代码, 可以看到基本上是没有什么 pipeline 的, 直接将图片输入网络, 然后输出各种三维属性, 并在作者的宣称下, 他们所预测的多个指标在存在 BA 的前提下
均达到
子领域的 SOTA 水平, 这一点非常厉害.

模型结构

VGGT 的 backbone 是一个标准的 transformer 结构, 首先接受大量图片作为输入, 首先通过一个 DINO 提取了分块的 feature, 然后将这些 feature 通过一个主体网络结构(包含了 Alternating frame-wise layer 和 global attention layer)
进行处理, 最后通过多个 task-specific heads 输出不同的三维属性.
VGGT架构图
接下来, 我们详细叙述各个细节部分:

Alternating attention frame-wise layer

据文章作者所述, 该 AA 机制与标准的 transformer attention 机制有所不同, 能够使 Transformer 以交替的方式聚焦每一帧和全局.

frame wise attention layer: 该层的 attention 仅在同一帧内进行, 也就是说, 每个 patch 只能与同一帧内的其他 patch 进行 attention 计算. 这样做的好处是能够更好地捕捉每一帧内部的局部特征.
global attention layer: 该层的 attention 在所有帧之间进行, 也就是说, 每个 patch 可以与所有帧内的其他 patch 进行 attention 计算. 这样做的好处是能够捕捉不同帧之间的全局特征.

另外值得一提的是, 作者采用了 $L = 24$ 层的 AA 机制, 并通过消融实验证明了 AA 机制的有效性, 此外, 作者声称他们的架构并没有采用 cross attention, 只采用 self attention.

任务特定的heads

将输入的图片通过 backbone 网络处理后, 会得到一个全局的 feature 表示, 然后通过多个 task-specific heads 输出不同的三维属性. 值得注意的是, DINO 编码的 feature 并非直接输入到 AA 中, 而是被添加了一个额外的相机 token
$t_{i}^{g} \in R^{1 \times C}$ 和四个 register tokens $t_{i}^{R} \in R^{4 \times C}$ 进行增强, 然后将 $(t_{i}^{L}, t_{i}^{g}, t_{i}^{R})$ 作为最终的输入.

此处值得注意的是, 第一帧的输入 token 是 $(t_{1}^{g} = t_{ini}^{g}, t_{1}^{R} = t_{ini}^{R})$ , 之后的帧的输入 token 是 $(t_{i}^{g} = t_{f o ll o w}^{g}, t_{i}^{R} = t_{f o ll o w}^{R})$ , 也就是说, 第一帧和之后的帧的 camera token 和 register token 是不同的.
但是作者说他们都是 learnable 的. 这使得模型能够将第一帧和其他帧区分开来, 并在第一个相机的坐标系下表示全局点云以及各种数据.但是, 经过 AA 层之后, 本来被赋予同一初值的 camera token 和 register
token 均会变为帧特定的, 这是因为 AA 层的 frame-wise attention layer 会使得每一帧的 token 在不同的计算中产生不同的表示.

最后遵循常规做法, register token 会被丢弃, camera token 和 image token 会被保留用于预测.

Camera parameter head

这个 head 从上图中的模型的 backbone 就可以看到, 他是将 camera token 通过 4 个 self-attention layers 进行处理, 然后通过一个 MLP 预测出每一帧的相机参数(包含内参和外参).

Dense Prediction

输出的 image token 在这里被使用, 用于预测 depth map $D_{i}$ , point map $P_{i}$ 和 tracking features $F_{i}$ . 更具体地来讲, $\hat{t}_{i}^{I}$ 首先会通过一个 DPT head 转化为一个 dense feature map
$F_{i} \in R^{C ’’ \times H \times W}$ , 之后每一个 $F_{i}$ 会通过一个 $3 \times 3$ 的卷积层解析出 corresponding depth 和 point map. 另外, DPT 头同样也会输出 dense feature map $T_{i}$ 用于后续的 tracking,
在此同时, vggt 同样也会输出 confidence map $Σ_{i}^{D} \in R^{C \times H \times W}$ 和 $Σ_{i}^{P} \in R^{C \times H \times W}$ 用于表示 depth 和 point 的置信度. 这个置信度用于后续的模型的 loss 计算和
真实预测时的 conf 输出.

Tracking

这一方面我并不打算去深入了解, 因此先跳过.

Training

Loss function

VGGT 的 loss function 包含多个部分, 主要包含以下几种:

Camera loss: 这个 loss 监管了相机参数$L_{camera} = \sum_{i=1}^{N} ||\hat{g}i - g_i||{\epsilon}$, 使用了 Huber loss.
Depth loss: 这个 loss 沿用了 dust3r 的 loss 设计$\mathcal{L}{\mathrm{depth}}=\sum{i=1}^N|\Sigma_i^D\odot(\hat{D}_i-D_i)|+|\Sigma_i^D\odot(\nabla\hat{D}_i-\nabla D_i)|-\alpha\log\Sigma_i^D$
Point loss: 这个 loss 同样沿用了 dust3r 的 loss 设计$\mathcal{L}{\mathrm{point}}=\sum{i=1}^N|\Sigma_i^P\odot(\hat{P}_i-P_i)|+|\Sigma_i^P\odot(\nabla\hat{P}_i-\nabla P_i)|-\beta\log\Sigma_i^P$
Tracking loss: 这个 loss 监管了 tracking feature 的质量, 具体细节我并不打算深入了解, 因此先跳过.

因此, 最终的 loss function 为: $L < e m > t o t a l = L < / e m > c am er a + L < e m > d e pt h + L < / e m > p o in t + λ_{t r a c kin g} L_{t r a c kin g}$

坐标Normalization

如果缩放的话, 重建结果应该同样也是正确的, 为了消除这种不确定性, 作者采用了归一化进行处理. 首先将所有量表示在第一个相机的坐标系中, 然后计算所有点的平均欧氏距离, 然后利用该尺度归一化相机平移, 点云坐标和深度值.

值得注意的是, 作者没有对预测结果施加任何归一化, 相反强制模型去学习预测归一化后的值, 这样做的好处是能够使得模型更好地适应不同尺度的场景.

Details

我难以想象训练的规模, 按照作者所述, 这一个 transformer 模型包含了 $1.2 B$ 的参数, 在 64 块 A100 上训练了 9 天, 属实是第一次见了.

另外, 训练的数据集之多也是难以想象:
dsfa
有点离谱了.

结论

vggt 的指标基本上达到 SOTA 水平, 但是值得注意的是, 直接的输出并没有达到, 作者加入了 BA 优化之后才达到了 SOTA, 因为 BA 是一个 costly 的优化过程, 因此我觉着这一方面或许还可以改进? 作者在论文中提到了
应用 diffentiable BA 的可行性, 但是也因为 BA 的计算量过大, 因此并没有进行进一步的尝试.

此外, VGGT 向我们展示了不需要一个复杂的 pipeline 也可以进行高质量的多目重建说你呢, SLAM3R, 我 TM 的快改吐了, 再结合最近发布的 SLAM Former, 我觉着这是一个很有意义的方向.

非常重要的是, vggt 证明了联合预测多个任务是有益的, 虽然并没有在 loss 阶段进行互相的监督, 但是通过多个任务的单独监督, 使得模型学到了更好的表示,

此外, vggt 另一个重要的发现是, 通过 depth 和 pose 反解出来的点云比直接预测的点云要好.

ok, 让我们把仓库链接抬出来:

另外, 这是真的可以的嘛?

iasdf

Posted Sep 06, 2025Updated Sep 06, 2025blog14 minutes read (About 2107 words)

论文阅读记录：reloc3r

引言

最近，我们在尝试将 SLAM3R 进行使之输出不限于点云，还有位姿估计、深度图、局部定位等结果的改造，大体上来讲，我对这个改造的感觉就是端了一个类似于 VGGT 的重建结构出来。于是，为了了解一下现在利用 transformer 做位姿估计的工作，我选择了组里的学长的论文：Reloc3r: Large-Scale Training of Relative Camera Pose Regression for
Generalizable, Fast, and Accurate Visual Localization来阅读，本文用来记录对这个模型的理解以及个人的感受。

首先，论文上来又是经典的针砭时弊环节🤣，论文指出了之前的工作分为APR和RPR两种方式，但是各有各的缺点：

APR: 绝对位姿回归，它主要是从图片中直接回归位姿，优点是有更高的推理速度和准确度，但是它的缺点也很明显：大多数这种方法都是针对场景有效，并且在训练时需要密集点图，这限制了他们在真实世界中投入应用。
RPR: 相对位姿回归：它是估计一对图片的相对位姿，相比于绝对位姿回归的好处在于它不需要密集点图的训练，但是，它的准确度表现非常差，远远不及 APR 。

为了解决这些问题，论文提出了一种新型的对称有效的网络，并在一个特大的数据集上进行训练，最终得到了state of the art的水平。

模型结构

模型主要由两个模块组成：相对位姿回归网络和运动平均模块

相对位姿回归网络

这个网络如图片左边所示，是由两个完全相同的 vit transformer 分支构成，并且两个分支共享权重，这有效的消除了输入顺序带来的不利影响，代表着训练得到了大幅简化，并且提高了计算速度和存储效率。

细节在于通过 ViT encoder 图片被编码成特征序列之后，他们之后通过的 decoder 是 Cross attention 的，这能够使模型同时理解两张图片之中的信息，最后， decoder 输出的信息会经过 Pose regression Head
这个 head 会将 decoder 的输出转化为相对旋转和相对位移，其中相对旋转一开始会以一个 9 维向量来表示，随后通过 SVD 分解完成得到旋转矩阵。

因此，我们这个网络最后的输出就是图 A 相对于图 B 的位姿变换和图 B 相对于图 A 的位姿变换。

运动平均模块

理论上来说，第一步网络的输出的精度应当已经达标，并且网络同时输出的两个相对位姿变换矩阵应该互你，从经验上来看，这两个位姿变换矩阵的精度相似，因此我们直接选择了一个非学习的模块用于转换两个输出的相对位姿。

其中有一些细节：

旋转平均的处理：模型将多个对于一张图片的相对旋转转换为绝对旋转处理，并使用四元数表示，最终选取中位数来作为绝对旋转，增强了模型的鲁棒性。
相机中心三角化的处理：因为几何点的平均/中位数化并不可解，因此我们转而通过最小二乘法寻找到所有平移方向距离之和最小的点，将这个点作为相机预测的光心。

损失函数

模型的损失包括两方面：旋转损失和位移损失。文章将他们都表示成了角度： $l_{R} = arccos (\frac{t r ( R ^ ^{- 1} R ) - 1}{2}), (l)_{T} = arccos (\frac{t ^ \cdot t}{∣∣ t ^ ∣∣∣∣ t ∣∣})$
然后将两者相加得到最后的总损失。显然这是一种无尺度的方法，解决了不同数据集之间度量尺度不统一的问题。

分析流程

该模型的处理流程大致如下：

输入：一个查询图像 $I_{q}$ 和一个带位姿数据的数据库 $I_{d_{n}}$ .
检索：使用 NetVLAD 在数据库中为 $I_{q}$ 检索出 Top-K 个最相似的图像 $I_{d_{K}}$ .
相对位姿预测：将 $K$ 个图像对 $(I_{q}, I_{d_{i}})$ 逐一送入相对位姿回归网络，得到 $K$ 个相对位姿估计（旋转矩阵和无尺度的平移方向）
绝对位姿聚合：
- 利用数据库图像已知的绝对位姿旋转和预测的相对旋转计算出 $K$ 个图像的绝对旋转统计，然后通过取中值得到最终的旋转 $\hat{R}_{q}$ 。
- 利用所有有效的图像对和估计的 $\hat{R}_{q}$ 进行相机中心的三角化，然后通过最小二乘法解出相机中心，从而得到所有的位姿估计。
输出

数据分析

第一次写数据分析模块🧐，有所不完善请原谅🥺。

性能评价指标

相对位姿

rra

RRA@15, RTA@15, mAA@30，分别是相对旋转、相对位移在 15°阈值内的准确度、以及 30°阈值下的平均准确率。

auc

AUC@5°/10°/20°: 位姿误差（旋转和平移角度误差的最小值）在 5°/10°/20°阈值下的精度曲线下面积。

绝对位姿

平移和旋转中位数误差（ m and degree ）：
abso

有效性验证

查看上面的图表便可看出，模型在个主流的公开数据集 (ScanNet1500, RealEstate 10K, ACID, CO3Dv2, 7 Scenes, Cambridge Landmarks) 上与当前最先进的方法（包括非回归和回归两大类）进行全面对比：

相对位姿估计: 在 ScanNet1500, RealEstate 10K 和 ACID 数据集上， Reloc3r 显著优于所有其他相对位姿回归(PR)方法，并且性能达到甚至超过了顶尖的非 PR 方法，同时速度快了几个数量级（例如，在 ScanNet 上比 NoPoSplat 快 50 倍以上）。在 CO3Dv2 数据集上， Reloc3r 在所有多视图评估指标上均达到 SOTA 。
视觉定位
- 在 7Scenes (室内) 数据集上， Reloc3r 的平均误差为 0.04m / 1.02°，超越了所有之前在新场景上评估的 RPR 方法，并达到了与需要场景专门训练的 APR 方法相媲美的精度。
- 在 Cambridge Landmarks (室外) 数据集上， Reloc3r 同样超越了所有 RPR 方法，与之前的 SOTA RPR 方法相比，平均位姿误差降低了约一半，其平均旋转误差甚至优于所有 APR 方法。

消融实验

lab

对称性
论文另外训练了一个使用了独立的两个 ViT 分支的相对位姿回归网络，显而易见性能是弱于 default 版本的
不含尺度信息
同样训练了一个同时输出尺度信息的模型，显而易见其准确性比不对称还差。

有趣的发现

论文在查看 decoder 的交叉熵注意力图时发现：模型在没有直接监督的情况下，自发地学会了在图像对之间建立有意义的块级别匹配。（如下图）
finding

局限性

作者发现当检索到的数据库图像与目标图像共线的时候，运动平均模块并不能恢复尺度。

总结

Reloc3r 使用了一个相当简洁的模型结构完成了 SOTA 水平，但其付出的代价是非常庞大的训练数据。这似乎在向我们说明只要数据够多够大，我们便可以训练出足够高性能的模型，这似乎在
告诉我们多造一下 SLAM3R V2 的数据🤣。

OK ，这篇论文的代码仓库如下：

Posted Sep 04, 2025Updated Sep 04, 2025blog15 minutes read (About 2176 words)

论文阅读记录：Fast3R

引言

OK, 本人昨天又读了一篇 3D reconstruction 方向的论文：Fast3R: Towards 3D Reconstruction of 1000+ Images in One Forward Pass，因此写下此篇 Blog 分享自己的理解与发现。

Fast3R 从本质上来说感觉和 SLAM3R 解决的是一类问题，都是对原本 DUst3R 存在的局限性：一次只能对两张图片进行处理，如果对多张图片进行处理的话， DUst3R 则是选择进行两两配对进行重建，最后进行全局坐标下的对齐，显然这将会是一个
$O (N^{2})$ 的过程。而 Fast3R 提出了对于打乱序列的多张图片（ 1000+）的处理方法， SLAM3R 则是解决了由视频进行重建的方法。感觉两者的本质上的区别就是 input 的图像集是否有序，后续两者的网络结构区别也正是在此。

从论文的 introduction 上来看，他们主要做了以下三方面的贡献：

创建了 Fast3R ，一个基于 Transformer 的对多目图片重建点图的端到端的模型，据论文所述，它在速度上取得显著提升，并且可以规模化计算。
展示了随着训练时视角增多，模型表现也会加强。另外，当推理时视角增多时，每张视角重建结果的精确度也会提升。并且模型可以处理比训练时多得多的模型。
在相机的位姿定位上达到了SOTA水平，另外也展现出了极快的速度。

好的，现在到了我们喜闻乐见的介绍模型环节啦！

模型

Fast3R 给出了一个看起来在推理环境就很庞大的结构图：
Fast3R

问题定义

从图中右边就可以看到， Fast3R 采用了两个头： Global Head 和 Local Head 来处理输出的 token ，因此可见， Fast3R 为每张图片预测了两个点图：本地坐标系下的点图 $X_{L}$ 和全局坐标系下的点图 $X_{G}$ ，可以用公式表示： $Fast3R : I \to (X < e m > L, Σ < / e m > L, X < e m > G, Σ < / e m > G)$
$Σ_{X}$ 指代的是 $X$ 点图的置信度。

值得注意的是，全局坐标系值得是第一张图片的坐标系，本地坐标系是每个对应图片的坐标系。（虽然 Fast3R 并没有次序的概念，但其也需要一个切入点，所以随机选取了一张图片作为第一张图片）

训练对象

类似于 Dust3R ， Fast3R 的损失函数分别采用了同样的处理方法处理本地点图和全局点图两部分： $L < e m > total = L < / e m > X_{G} + L_{X_{L}}$
阅读其论文，发现其与 Dust3R 的损失函数基本一致，因此不多赘述。

模型架构

Image Encoder

由上图所示，我们可以看到每一个输入的图片都会经过一个共享权重的 Vit Encoder 生成对应的 token 序列 $H_{i} = h_{i, j}_{j = 1}^{H W / P^{2}}$ ，即： $H_{i} = F (I_{i}), i \in 1, \dots, N$
论文中提到，他们使用了和 Dust3R 相同的 Encoder ： CroCo ViT ，但是他们提到了 DINOv2 的表现与之相似。

另外，在把 token 传入 fusion transformer 之前，作者为每一个 token 添加了一个一维的位置编码，目的是让模型知道哪些图像块来自于同一张图片，并且帮助模型认出上文标定的第一张图片。这同样也能让模型隐式地去理解这些图片里反映的相机位姿。

Fusion Transformer

模型中大多数计算都发生在 Fusion Transformer 里面，作者使用了一个类似于ViT-L的 24 层的 transformer 作为这一模块的主体。它将来自所有的视角的 token 作为输入，并且通过全连接的自注意力机制进行处理，使的模型能够理解所有视角的信息，远超 Dust3R 能理解的两个视角的信息。

Pointmap Decoding Heads

最后， Fast3R 使用了两个独立的 DPT 解码头将 Fusion Transformer 的输出解码为点图，即图片中右边部分。

位置编码

论文最后的目标是进行多图片处理，并且实现推理时的可以处理的图片数量远远多于训练时的图片数量，因此我们就要考虑推理时为 token 嵌入位置编码的手段。

一开始，文章尝试使用相同的球谐函数嵌入编码，文章中又提到：在 LLM 中，这种方法导致性能不佳。果不其然，在文章的初步实现中，他们同样发现当输入图像数量超过训练时使用图像的数量时，模型的效果并不好。
因此，文章借鉴了大预言模型中的位置插值方法：在训练时从一个集合 $1, \dots, N ’$ 中均匀随机抽取 $N$ 个索引，这样模型便被迫去学习处理更大范围的索引。

对于 transformer 来说，这种策略感觉和 masking 没什么区别，文章中也说：

This strategy enables Fast3R to handle N = 1000 images during inference, even if only trained with N = 20 images.

有效利用显存

从模型架构的图片来看，这看起来就是一个占用很大显存的模型。但是文章提出，由于模型的特点（ meta-architecture ），这个模型可以广泛使用各种并行化以及分片技术。
文章提出他们在训练和推理的时候利用了两种不同形式的并行化和 FlashAttention 技术，并认为随着未来的技术成熟他们的模型会持续受益（废话）。

具体采用的策略来实现高效训练。

首先，使用 FlashAttention 来提高时间和内存效率。即便如此，当 N>16 时，一个朴素的实现即使在批量大小为 1 的情况下也会耗尽内存（ 128 x A100-80GB 啊，离大谱）。
因此，后来使用了 DeepSpeed ZeRO stage 2 训练，将优化器状态、动量估计和梯度在不同的机器上进行分区。这样就能够以每个数据样本最多 N=28 个视角进行训练，同时每个 GPU 的批量大小为 1 。

模型效果：

miaomiao
就模型所给出的表格而言，确实是达到了 Sota 水平。

在推理速度上，由于所做的各种优化，它也得到了显著的提升。

但是，其实我更好奇的是它跟同期的 SLAM3R 的性能比较，阅读论文，发现两者并没有过同一个精度指标的比较，通过本人的本地测试，发现对于一个很小的数据集（ 82 张有序图片），两者速度上并没有太多差距，但是重建质量上来说
， SLAM3R 的质量远超 Fast3R 。这很好的符合了 SLAM3R 对有序图像序列进行针对性重建的特性，而 fast3R 是对一个随机图像重建的方法。

所以，当我看到 Fast3R 的 demo 里有对视频重建的选项时，我感觉并不适合。因为从直觉上来说，人们从一个没有次序的图像集中理解环境的过程也大致遵循一个先排序再重建的过程，也就是说人们对无次序的图片集中还原 3D 场景的难度远大于从视频中还原场景的难度。

论文中也提到了局限性的存在：

缺少包含大型场景的数据因而缺少在此类场景下的泛化能力。
没有更好的位置嵌入，不过论文提出可以参考那些能处理极长上下文序列的大语言模型。

ok ，关于 Fast3R 我就处理到这里，欸，我觉着或许我以后应该认真去看看训练细节和实验部分，总去看模型结构有种高屋建瓴的感觉，还是应该多看看代码（ x

Posted Sep 02, 2025Updated Sep 02, 2025blog15 minutes read (About 2245 words)

论文阅读记录：MAst3R

引言

经过一周的对SLAM3R进行 online 以及可视化 demo 改造的低效率劳作且工作完成，我终于有时间来补档我这篇早在近两个周之前就读完的论文Grounding Image Matching in 3D with MASt3R

读完这篇论文之后，我的第一感觉就是：这是一个 DUst3R 的修补模型，他并没有太多的像 DUst3R 那样的开创性地将 transformer 运用于双目三维重建那样的举动，而是在 DUst3R 模型上进行了
少许修补，并提出了少许修补中的一些独创性方法，感觉是一篇介绍 small trick 的论文。同时，我们似乎也可以这么说： MAst3R 发现本聚焦于三维重建任务的 DUst3R 在像素匹配问题上同样达到了 SOTA
于是， MAst3R 将 DUst3R 稍加改造，得到了一个在像素匹配上表现更强的模型 MAst3R.

模型介绍

MASt3R 的模型结构与 Dust3R 大致相同：
mast3r

Encoder

与 DUst3R 相同， MAst3R 的 encoder 部分同样是由 ViT 组成的，且与 DUst3R 相同的是， MAst3R 的 encoder 部分也是共享权重的。
就像这样： $H_{1} = E n co d er (I^{1}) H_{2} = E n co d er (I^{2})$

Decoder

MASt3R 的 Decoder 同样采用了 cross-attention 的机制，这能使得 MAst3R 能够理解同一像素在不同视角下的信息，有助于后续进行像素匹配。 $H ’^{1}, H ’^{2} = Deco d er (H^{1}, H^{2})$

Heads

对于 Dust3R 来说，他只有一个 head ，直接将 decoder 的输出转化为点图信息和置信度（上图灰色部分）

3D Heads

MASt3R 对这个 head 基本上与 DUst3R 的 head 相同，都是将 decoder 的输出转化为点图信息和置信度。

Matching Heads

MASt3R 在此基础上又增加了一个 head ，专门用于像素匹配任务(上图蓝色部分)，这个头部由一个简单的两层的 MLP 组成，使用了 GELU 作为激活函数，另外在处理完后进行归一化处理，负责输出两张密集的特征图： $D^{1} = He a d_{d esc}^{1} ([H ’_{1}, H ’ < e m > 2]) D^{2} = He a d < / e m > d esc^{2} ([H ’_{1}, H ’_{2}])$

Loss

Mast3R 的损失函数由两部分组成： $L < e m > t o t a l = L < / e m > co n f + β L_{ma t c h}$

3D Loss

MAst3R 的 3D Loss 与 DUst3R 的 3D Loss 基本相同，都是由点图的 L1 损失和置信度的交叉熵损失组成。
但是， MAst3R 在计算回归损失的时候，原本的 DUst3R 计算公式是这样的： $ℓ_{regr} (ν, i) = ∣ ∣ \frac{1}{z} X_{i}^{ν, 1} - \frac{1}{z ^} \hat{X} < e m > i^{ν, 1} ∣ ∣,$
MAst3R 认为在它的应用场景中，并不鼓励尺度不变性，而更多的是需要绝对的尺度一致性，因此 MAst3R 将上式改为了： $ℓ < / e m > regr (ν, i) = \frac{∣ ∣ X _{i}^{ν, 1} - X ^ < e m > i ^{ν, 1} ∣ ∣}{z ^}$
因此， MAst3R 的 3D Loss 计算公式为： $L < / e m > conf = ν \in 1, 2 \sum i \in V^{ν} \sum C_{i}^{ν} ℓ_{regr} (ν, i) - α lo g C_{i}^{ν} .$

Matching Loss

这个损失函数是对 Matching Head 输出的特征图进行监督的，基本思想是：我们鼓励一个图像中的一个特征匹配符，最多与另一张图像中代表同一个 3D 点的特征匹配符进行匹配，
需要注意的是，这个匹配本质上是一个交叉熵分类损失，当网络猜到正确的像素（而非邻近的像素）时，才会得到奖励。

具体实现上，我们利用了 InfoNCE loss 来实现这个想法，其作用于一组对应关系 $\hat{M} = (i, j) ∣ \hat{X_{i}}^{1, 1} = \hat{X_{j}}^{2, 1}$ ，具体公式如下： $L < e m > match = - \sum < / e m > (i, j) \in \hat{M} lo g \frac{s _{τ} ( i , j )}{\sum _{k \in P^{1}} s _{τ} ( k , j )} + lo g \frac{s _{τ} ( i , j )}{\sum _{k \in P^{2}} s _{τ} ( i , k )}$
其中， $s_{τ} (i, j) = exp (\frac{D _{i}^{1} \cdot D _{j}^{2}}{τ})$ ， $τ$ 是一个温度参数， $P^{1}$ 和 $P^{2}$ 分别是图像 1 和图像 2 中所有像素的集合。

这极大地鼓励了网络进行高精度匹配。

最后，两个损失函数被结合起来，形成了 MAst3R 的总损失函数： $L < e m > t o t a l = L < / e m > co n f + β L_{ma t c h}$
有了上述模型与 Loss 就可以训练了，但是网络的输出还需要经过一些处理，才能得到需要的匹配关系。注意，网络只输出了 PointMap 和每个像素的 LocalFeature ，而期望得到的是两个图像之间的像素点级别的匹配，匹配相关的部分就是图中新增的 NN 模块。

快速互惠匹配

当给定两张特定的预测图 $D D^{1}, D^{2} \in R^{H \times W \times d}$ 时，我们的目标是提取一组可靠的像素对应关系，即互惠最近邻。

数学定义：

互惠最近邻集合由公式定义： $̲$ </li> <li>这里的$…" style="color:#cc0000">\mathcal{M}={(i,j)|j=\mathrm{NN}_2(D_i^1)\mathrm{<del>and</del>}i=\mathrm{NN}_1(D_j^2)} $$</li> <li>这里的 $N N_{A} (D_{j}^{B})$ 表示在特征图 $D^{A}$ 中与特征 $D_{j}^{B}$ 距离最近的特征的索引。其数学定义为：
\mathrm{NN}_A(D_j^B)=\arg\min_i|D_i^A-D_j^B| $</li> </ul> <h3 id="传统方法"><a href="#传统方法" class="headerlink" title="传统方法"></a>传统方法</h3><p>传统上，计算互惠最近邻的方法是通过暴力搜索来实现的，这种方法的时间复杂度为 O ((H W)^{2}) ，这在高分辨率图像中是不可行的。</p> <p>虽然优化最近邻搜索是可能的，例如使用 <strong>K-d</strong> 树，但这种优化在高维特征空间中通常会变得非常低效，在某些情况下，其速度甚至比 MASt3R 输出 D_{1} 和 D_{2} 的推理时间慢几个数量级。</p> <h3 id="MASt3R的方法"><a href="#MASt3R的方法" class="headerlink" title="MASt3R的方法"></a>MASt3R的方法</h3><p>MASt3R 提出了一种基于<strong>子采样</strong>*的快速方法。</p> <p>这个方法是从一个稀疏的第一张图片的像素集合出发的，通过找到这个集合中每个像素在第二张图片上的最近邻得到最近邻集合，然后再从这个最近邻集合中找到每个像素在第一张图片上的最近邻，最后通过检查互惠性来得到最终的互惠最近邻集合。</p> <p>整个过程可以表示为：$
U^t\mapsto[\mathrm{NN}2(D_u^1)]{u\in U^t}=V^t\mapsto[\mathrm{NN}1(D_v^2)]{v\in V^t}=U^{t+1}
\mathcal{P}i^{(T\times d)}=E{pts}(\hat{X}_i^{(H\times W\times3)}),i=1,…,K+1. $然后，由于我们实际上不能只通过点图信息来进行建模（如纹理相同的两个不一样的平面或不同的一块地面），因此我们选择将特征与 I 2 P 网络中的特征融合：$
\mathcal{F}_i^{(T\times d)}=F_i^{(T\times d)}+\mathcal{P}_i^{(T\times d)},i=1,…,K+1. $̲K + 1$ 个点图输入到两个解…" style="color:#cc0000">在这之后，我们便生成了每张点图的位置外观特征序列。</p> <p>紧接着，我们会这 $K + 1$ 个点图输入到两个解码器中：</p> <h4 id="Registration-Decoder"><a href="#Registration-Decoder" class="headerlink" title="Registration Decoder"></a>Registration Decoder</h4><p>Registration Decoder 将所有 token 作为输入，然后目的是将 L2W 的关键帧重建转换到场景坐标系下，它与 $D_{k ey}$ 采用相同的架构。</p> <p>解码过程大概是：
\mathcal{G}{sce_i}=D{sce}(\mathcal{F}{sce_i},\mathcal{F}{key}),\quad i=1,…,K $</p> <h4 id="Scene-Decoder"><a href="#Scene-Decoder" class="headerlink" title="Scene Decoder"></a>Scene Decoder</h4><p>Scene Decoder 同样将所有 token 作为输入，但是它的目的是在不改变场景坐标系的情况下，精化坐标几何。他同样采用与 D_{k ey} 相同的架构，但是他是对每一个在已选中的关键帧点图进行优化：$
\mathcal{G}{sce_i}=D{sce}(\mathcal{F}{sce_i},\mathcal{F}{key}),\quad i=1,…,K $通过这样的方式将已生成的 p o in t ma p 进行优化 < / p >< p > 最后，我们采用类似于 I 2 P 模块中的方法对我们所有已经重建的关键帧 t o k e n 进行点图重建：$
\tilde{X}_i^{(H\times W\times3)},\tilde{C}_i^{(H\times W\times1)}=\mathrm{H}(\mathcal{G}_i^{(T\times d)}),i=1,…,K+1.
$$

得到一个实时的三维表示。

结论
本人目前涉猎不深，但是论文最后与其他系统做比较，其展现的效率确实令我印象深刻，感觉以上的这个系统的两大模块也令非常简洁舒适。等我再去阅读其他的 3R 文章来进一步理解这个 SOTA 的含金量吧😋

github 项目地址：

喵喵又是充实的一天🥳，本人可能理解有偏差（ bushi