MVSFormer论文阅读和代码分析

最新推荐文章于 2025-04-22 12:33:08 发布

陈同学_alex

最新推荐文章于 2025-04-22 12:33:08 发布

阅读量1.4k

点赞数 3

文章标签：论文阅读 MVS 深度估计 pytorch 深度学习

本文链接：https://blog.csdn.net/qq_37394634/article/details/133971622

版权

MVSFormer

论文：MVSFormer: Multi-View Stereo by Learning Robust Image Features and Temperature-based Depth

2022

https://github.com/ewrfcas/MVSFormer

摘要

Feature representation learning is the key recipe for learning-based Multi-View Stereo (MVS). As the common feature extractor of learning-based MVS, vanilla Feature Pyramid Networks (FPNs) suffer from discouraged feature representations for reflection and texture-less areas, which limits the generalization of MVS. Even FPNs worked with pre-trained Convolutional Neural Networks (CNNs) fail to tackle these issues. On the other hand, Vision Transformers (ViTs) have achieved prominent success in many 2D vision tasks. Thus we ask whether ViTs can facilitate feature learning in MVS? In this paper, we propose a pre-trained ViT enhanced MVS network called MVSFormer, which can learn more reliable feature representations benefited by informative priors from ViT. The finetuned MVSFormer with hierarchical ViTs of efficient attention mechanisms can achieve prominent improvement based on FPNs. Besides, the alternative MVSFormer with frozen ViT weights is further proposed. This largely alleviates the training cost with competitive performance strengthened by the attention map from the self-distillation pre-training. MVSFormer can be generalized to various input resolutions with efficient multi-scale training strengthened by gradient accumulation. Moreover, we discuss the merits and drawbacks of classification and regression-based MVS methods, and further propose to unify them with a temperature-based strategy. MVSFormer achieves state-of-the-art performance on the DTU dataset. Particularly, MVSFormer ranks as Top-1 on both intermediate and advanced sets of the highly competitive Tanks-and-Temples leaderboard.

特征表示学习是实现基于学习的多视点立体视觉的关键。作为基于学习的MVS的通用特征提取器，普通特征金字塔网络(FPNs)在反射和无纹理区域存在特征表示不理想的问题，限制了MVS的泛化。即使FPNs与预训练的卷积神经网络(CNN)一起工作，也无法解决这些问题。另一方面，视觉Transformers(ViTs)在许多2D视觉任务中取得了显著的成功。那么，ViTs是否能够促进MVS中的特征学习呢?

本文提出一种预训练的ViT增强MVS网络，称为MVSFormer，它可以从ViT中受益于信息先验学习更可靠的特征表示。基于高效注意力机制的层级ViT的微调MVSFormer可以在FPNs的基础上实现显著的改进。此外，还进一步提出了具有冻结ViT权值的替代MVSFormer。这在很大程度上降低了训练成本，并且通过自蒸馏预训练得到的注意图增强了训练的竞争性。MVSFormer可以泛化到各种输入分辨率，并通过梯度积累加强有效的多尺度训练。此外，我们还讨论了基于分类和回归的MVS方法的优缺点，并进一步提出将它们与基于温度的策略统一起来。MVSFormer在DTU数据集上实现了最先进的性能。特别是，在竞争激烈的Tanks-and-Temples排行榜中，MVSFormer在中级和高级组中都排名第一。

引言

多视图立体(MVS)旨在用多视图图像重建高度详细的3D表示，关键步骤是估计已知相机位姿的深度图。许多传统方法成功地利用了图像的低层级特征匹配，但它们可能受到各种遮挡和不同光照条件的负面影响。最近出现了基于深度神经网络(DNNs)的学习方法。基于学习的MVS方法有3个步骤：特征提取、代价体（cost volume）构建和代价体正则化。

许多工作致力于通过高效的多阶段模型和visibility information构造更好的代价体（cost volumes）。同时，使用混合3D U-Net结构或递归神经网络(RNNs)学习更好的cost volume正则化也被证明可以提高性能。代价体正则化的目的是将non-Lambertian曲面或物体遮挡的、噪声污染的代价体细化为平滑特征相关（ smooth feature correlations），如图1©(e)所示。这种正则化不能完全纠正来自反射或具有不可靠二维图像特征的无纹理区域的模糊特征匹配。因此，在特征提取过程中学习好的代表性特征对于提高MVS的泛化性仍然具有重要意义。

在这里插入图片描述

在大多数MVS网络中，特征金字塔网络(feature Pyramid Network, FPN)是常用的特征提取方法。一些工作利用可变形卷积、注意力机制和法向曲率来学习FPNs更可靠的特征。然而，这些工作在建模反射和无纹理区域时仍然存在较差的泛化性，如图1©(d)所示。另一方面，之前很少有人明确地探索在额外图像数据上预训练的卷积神经网络(CNNs)的特征，例如ResNet，因为这种预训练的CNNs在MVS中可能存在一些问题:

CNNs的底层特征只考虑有限的感受野，缺乏对图像的整体理解，无法处理反射和无纹理区域;
CNNs的高级特征具有高度的语义抽象，最适合分类，而不是细粒度的视觉特征匹配。

通过经验验证，预训练的CNN模型在MVS方面并没有取得显著的改善，如表4所示。

近年来，Vision Transformers(ViTs)在各种图像理解任务中取得了令人印象深刻的成绩。因此，一个自然的问题是，是否可以通过外部2D图像数据集预训练的transformers来显著加强MVS的特征表示学习? 对于MVS中反射和无纹理区域的问题，配备长距离注意力模块的ViTs可以为MVS模型提供全局理解（而不是底层纹理）。此外，ViTs的patch-wise特征编码在特征匹配方面工作相当好（比如LoFTR，COTR）。由于深度预测本质上是沿极线的一维特征匹配问题，因此ViTs应该可以提高基于学习的MVS的精度。据我们所知，还没有其它工作明确地利用预训练的ViTs进行MVS。

为此，本文深入探讨了如何利用预训练的ViTs来提高MVS的性能。如图1(e)(f)所示，预训练ViT的特征与FPN的特征是互补的，可以更好地建模MVS中的反射和无纹理区域。

本文提出使用预训练的ViTs来增强FPN用于MVS的特征提取，并进一步设计了一种新的MVS Transformer (MVSFormer)。具体来说，采用 hierarchical ViT Twins作为MVSFormer的主干。得益于金字塔结构和高效的注意力机制，MVSFormer可以在高分辨率下进行训练，比普通FPNs获得更好的结果。此外，还将MVSFormer扩展为plain-ViT，称为MVSFormer-P。与使用hierarchical ViTs相比，在训练过程中冻结了MVSFormer-P1中自蒸馏方法（DINO）预训练的现成ViT主干，以减少计算量，如图2(A)所示。与其他最先进的MVS方法相比，MVSFormer-P仍然具有更好的性能。

其次，本文提出了一种有效的多尺度策略来训练MVSFormer，因为直接训练MVS的ViTs是很重要的。在MVS任务中，模型需要在各种高分辨率图像上进行测试，而为了节省训练计算量，模型必须在低分辨率图像上进行训练。因此，不适合直接将没有尺度不变性的预训练ViTs扩展到MVS任务。在4.1节中的经验实验表明，与训练期间最大的分辨率(1280)相比，所提出的多尺度策略足以将MVSFormer推广到具有更高分辨率(1536或1920)的图像。

此外，本文在技术上统一了MVSFormer的回归深度(regression)和argmax深度(classification)的优点。本文发现优化具有交叉熵损失的MVS网络可以获得更可靠的置信图，但深度预测略差。因为argmax操作不能提供精确的深度结果，这会降低深度估计性能。为了解决这个问题，MVSFormer在推理过程中预测基于温度的深度期望，而不是argmax，实现了平滑的深度预测和更好的最终点云。

本文的贡献可以突出如下:

这是第一个系统地探讨预训练ViTs对MVS的影响的工作。通过特征提取器学习更好的特征表示对于在2D视觉和3D MVS任务之间建立桥梁至关重要。
提出一种新型的ViT增强MVS网络—MVSFormer，并利用有效的多尺度训练策略对其进行进一步训练。本文提出的Twins-small预训练MVSFormer，与CNN-based预训练ResNet相比，在其他所有模型设置不变的情况下，DTU点云重建的整体误差从0.312显著降低到0.289，见表4。
分析了基于回归和基于分类的MVS的优点和局限性，提出了一种简单有效的方法将两者统一起来。图4和图6的经验定性证据表明，基于分类的置信度可以过滤真实世界重建的外点。表6中的定量结果表明，基于温度的深度预测也享有优越的点云指标。
所提出的方法在DTU数据集和Tanks-and-Temples数据集中都能达到最先进的性能。

方法

图2概述了MVSFormer的架构，类似[MVSNet](MVSNet: Depth Inference for Unstructured Multi-view Stereo,https://arxiv.org/abs/1804.02505) 的pipeline。给定一组N张不同视图的图像，其中包含参考图像 $\mathbf{I}_{0} \in \mathbb{R}^{H \times W \times 3}$ 和源图像 $\left\{\mathbf{I}_{i}\right\}_{i=1}^{N-1} \in \mathbb{R}^{H \times W \times 3}$ ，以及它们的相机内参和外参，MVSFormer在特征提取中学习特征表示，并通过 hierarchical ViT-Twins 或plain ViT-DINO 通过几种新的训练策略进行增强。然后提出了多阶段代价体构造和正则化来计算coarse-to-fine深度假设的概率。最后，利用交叉熵损失对MVSFormer进行优化，同时对深度期望进行推理。

在这里插入图片描述

Preliminaries.

Twins 通过 hierarchical-ViT以监督方式进行预训练，如图2(a)所示。为了进一步降低复杂性，Twins采用了可分离的 locally-grouped

self-attention和 global sub-sampled attention来构建每个注意力块。这种全局的和局部的设计优于经典的[金字塔ViT]( Pyramid vision transformer: A versatile backbone for dense prediction without convolutions)。Twins还利用了2D深度卷积的[CPE](Conditional positional encodings for vision transformers) （条件位置编码），而不是其他ViTs中的 [绝对位置编码](An image is worth 16x16 words: Transformers for image recognition at scale) 。
DINO 通过图2(b)所示的plain-ViT的自蒸馏，以自监督的方式进行预训练。DINO的突出特点是其最后一层的注意图可以学习特定于类的特征，从而实现无监督的对象分割，Caron等人(2021)对此进行了讨论，如图3所示。由于无监督训练和multi-crop策略，DINO的特征表示可以很好地推广到各种环境、光照和分辨率。

特征提取

类似常见的MVS工作，本文也使用FPN作为主要的特征提取器，并使用预训练的ViTs来增强特征提取。在MVSFormer中，ViTs致力于构造全局特征相关，而FPN致力于学习精细的特征相关性。

在将参考图像和源图像放入ViT之前，首先将其下采样为 $\left(\frac{H}{2}, \frac{W}{2}\right)$ ，以节省计算和内存成本。用双三次插值调整预训练ViTs的绝对位置编码大小，以适应不同的图像尺度。然后将hierarchical-ViT输出的 $\mathbf{F}^{(h)}$ 或plain-ViT输出的 $\mathbf{F}^{(p)}$ 直接添加到FPN编码器的最高层特征中。因此，可以从原始分辨率的 $\left(\frac{H}{8}, \frac{W}{8}\right)$ 缩放到 $(H, W)$ 的FPN解码器得到coarse-to-fine的特征 $\left\{\mathbf{F}^{(l)}\right\}_{l=1}^{L=4}$ ，如图2(A)所示。这些特征包含了ViT和CNN的先验，并将被用来构造更可靠的代价体。在附录C.2节中尝试了其他特征融合策略，但差异可以忽略不计。因此在MVSFormer中采用了简单有效的特征添加方法。

MVSFormer with trainable Twins.

Twins是默认的MVSFormer骨干，因为它具有最好的重建性能。为了在不同分辨率下对MVSFormer进行微调，ViT骨干需要满足两个条件，即有效的注意力机制和不同尺度的鲁棒位置编码，Twins很好地解决了这两个问题。

除了使用金字塔结构，Twins中的CPE可以从零填充中学习[位置线索](How much position information do convolutional neural networks encode?)，并通过适当的CNN归纳偏置（inductive biases）打破ViTs的permutation-equivalent。如图2(b)所示，MVSFormer分别编码了4个多尺度特征 $\left\{\mathbf{F}^{(h, s)}\right\}_{s=1}^{S=4}$ ，分别是原始分辨率的 $\left(\frac{1}{8}, \frac{1}{16}, \frac{1}{32}, \frac{1}{64}\right)$ 。使用另一个FPN对这些多尺度特征进行上采样：
$\mathbf{F}^{(h)}=\operatorname{FPN}\left(\mathbf{F}^{(h, 1)}, \mathbf{F}^{(h, 2)}, \mathbf{F}^{(h, 3)}, \mathbf{F}^{(h, 4)}\right) \in \mathbb{R}^{\frac{H}{8} \times \frac{W}{8} \times C} \tag{1}$
得益于高效的注意力设计，可以在训练阶段对预训练的Twins进行微调，在各种分辨率下的学习率相对较低。更多细节将在第4节讨论。

MVSFormer-P with frozen DINO.

本文还探索了基于plain-ViT的MVSFormer，即MVSFormer-P。尽管 plain ViTs在高分辨率的MVS学习中需要大量的计算，但我们发现自监督的ViT-DINO在ViT主干均匀冻结的情况下具有很好的改善特征表示的性能。特别地，利用DINO最后一层的[CLS] token的注意力图(如图3所示)来加强特征学习。

由于MVS本质上是一项特征匹配任务，因此物体或场景分割的先验性有助于避免前景和背景的深度预测混淆。由于ViT的输入大小已经减半，在kernel和步长为16的patch-wise嵌入之后，DINO对分辨率为( $\left(\frac{H}{32}, \frac{W}{32}\right)$ 的特征图执行基于注意力的学习。为了更好地利用DINO良好的分割特性，我们使用可训练门控线性单元(GLU)对DINO特征 $\mathbf{F}_{\text {dino }}$ 进行降维。假设 $\mathbf{A} \in \mathbb{R}^{\frac{H}{32} \times \frac{W}{32} \times h}$ 表示具有来自DINO最后一层的 $h$ 个注意头的[CLS]令牌的注意力图。 $\hat{\mathbf{A}} \in \mathbb{R}^{\frac{H}{32}} \times \frac{W}{32} \times 1$ 从 $\mathbf{A}$ 开始沿 $h$ 个头取平均值，因此GLU可以写成:
$\tilde{\mathbf{F}}^{(p)}=\operatorname{Swish}\left(\operatorname{ConvBN}_{l}\left(\left[\mathbf{F}_{\text {dino }} ; \mathbf{A}\right]\right) \odot \operatorname{Swish}\left(\operatorname{ConvBN}_{r}\left(\left[\mathbf{F}_{\text {dino }} \odot \hat{\mathbf{A}}\right]\right)\right) \in \mathbb{R}^{\frac{H}{32} \times \frac{W}{32} \times C_{p}},\right.$
其中 $\operatorname{Swish}(x)=x \cdot \operatorname{sigmoid}(x)$ ； $\odot$ means the element-wise multiplication; [ $\cdot ; \cdot]$ indicates the concat operation; $C_{p}$ is the reduced channel of DINO。GLU有助于在降维过程中保护从分割注意图中受益的重要特征，从而有效地提高MVS性能。然后使用两个转置卷积将特征添加到具有通道C的FPN编码器的 $\tilde{\mathbf{F}}^{(p)}$ 上采样到 $\mathbf{F}^{(p)} \in \mathbb{R}^{\frac{H}{8} \times \frac{W}{8} \times C}$ 。

尽管基于plain-ViT的DINO存在大量内存和计算成本的问题，但我们发现，当DINO冻结时，MVSFormer-P仍然可以很好地使用可训练的GLU和上样本卷积。与传统的MVS FPN训练相比，替代的MVSFormer-P只需要多一点的内存开销;作为完全可训练的MVSFormer，取得了有竞争力的成绩。

在这里插入图片描述

多尺度训练

虽然ViTs具有很大的模型容量，但由于缺乏翻译 translation equivalence and locality，使得它难以处理各种输入分辨率。大多数MVS任务应该以不同的高分辨率(HR) (从1200×1600 到1080×1920)进行测试。CNN-based方法可以通过动态核和随机裁剪在很大程度上解决这一问题。最重要的是，CNNs可以处理任意大小的输入，这得益于它们的归纳偏置，即 translation equivalence, and locality。对于MVSFormer中的可训练的Twins ，相同分辨率的训练容易过拟合单个输入大小，而不能推广到HR（高分辨率） cases。

因此，本文通过多尺度训练来重新定义学习特征，该训练源自基于视觉特征的检测任务。对于高效的多尺度训练，必须确保

1)每批图像的大小应该相同;
2)根据图像大小动态改变批处理大小，目的是充分利用有限的内存。

具体来说，用512到1280的动态分辨率训练模型，而宽高比在0.8到0.67之间随机采样。在梯度累积(gradient accumulation)的辅助下，使用了大batch size的多尺度训练。梯度累积将一个batch划分为几个sub batch，并累积它们的梯度来更新模型。在每个epoch开始时，所有实例随机分组为不同的分辨率和sub batch size对。较大的图像应该具有较小的sub batch size，反之亦然。使用更大的batch size的训练有助于更快的收敛，更低的方差和更好的BatchNorm层性能。因此，梯度积累显著提高了MVSFormer的多尺度训练效率。

与表16和图11相比，512到1280的动态训练大小足以将MVSFormer推广到至少2K分辨率的Tanks-and-Temples。关于多尺度训练的更多细节见附录A.1节。

Correlation Volume Construction

本节详细阐述代价体构造和正则化的经典组成部分，这些组件与本文的关键贡献是正交的，因为本文的主要重点是更好地提取MVS的特征。

为了实现多级代价体，首先为每一级初始化一组逆深度范围 $\left\{d_{j}\right\}_{j=1}^{D}$ 。这里为了简化，省略了第 $l$ 阶段的上标。源视图的特征被变换到参考视图。给定参考图像 $\mathbf{I}_{0}$ 的像素 $\mathbf{p}$ ，已知参考视图和源视图的相机内参 $\mathbf{K}_{0}, \mathbf{K}_{i}$ ，以及它们的旋转 $\mathbf{R}_{0 \rightarrow i}$ 和平移 $\mathbf{t}_{0 \rightarrow i}$ ，第 $j$ 个深度假设对应的、变换到源图像 $\mathbf{I}_{i}$ 中的点 $\mathbf{p}_{j}^{\prime}$ 可以表示为：
$\mathbf{p}_{j}^{\prime}=\mathbf{K}_{i} \cdot\left(\mathbf{R}_{0 \rightarrow i} \cdot \mathbf{K}_{0}^{-1} \cdot \mathbf{p} \cdot d_{j}+\mathbf{t}_{0 \rightarrow i}\right)$
利用分组池化将特征沿着通道维度划分为G组。特征相关（feature correlation） $\mathbf{C}_{i}$ 可由 group-wise 参考特征 $\mathbf{F}_{0}^{g}$ 和变换到参考图像坐标系后的源特征 $\mathbf{F}_{i}^{g}$ 的内积表示为
$\mathbf{C}_{i}\left(d_{j}, \mathbf{p}, g\right)=\left\langle\mathbf{F}_{0}^{g}(\mathbf{p}), \mathbf{F}_{i}^{g}\left(\mathbf{p}_{j}^{\prime}\right)\right\rangle \in \mathbb{R}^{\hat{C}} \tag{4}$
where $\hat{C}$ is the channel of $\mathbf{F}_{0}^{g}$ and $\mathbf{F}_{i}^{g}$ 。

然后，将Eq.(4)中的特征相关进一步平均到每组的 $\mathbf{C}_{i}\left(d_{j}, \mathbf{p}\right) \in \mathbb{R}^{G}$ ，以获得高效的代价体。本文训练了一个2D CNN，通过归一化相关的熵来学习每个源视图的pixel-wise weight visibility $\left\{\mathbf{W}_{i}\right\}_{i=1}^{N-1}$ 。因此， $N - 1$ 个源视图feature correlations可以与它们的visibility融合为
$\mathbf{C}\left(d_{j}\right)=\frac{\sum_{i=1}^{N-1} \mathbf{W}_{i} \mathbf{C}_{i}\left(d_{j}\right)}{\sum_{i=1}^{N-1} \mathbf{W}_{i}} \tag{5}$
这是3D U-Net 代价体正则化的输入。经过3D U-Net的正则化后，可以实现每个阶段逐像素输出的3D代价体 $\hat{\mathbf{C}} \in \mathbb{R}^{D \times H_{l} \times W_{l}}$ 。

Temperature-based Depth Prediction

给定3D U-Net的代价体 $\hat{\mathbf{C}}$ ，深度假设的概率体可以通过沿深度维度的softmax作为 $\mathbf{P}=\operatorname{softmax}(\hat{\mathbf{C}})$ 来实现。基于回归的深度(REG)利用soft-argmin对每个深度假设进行软加权，即 $\left\{d_{j}\right\}_{j=1}^{D}$ 与概率 $\mathbf{P}\left(d_{j}\right)$ 的期望。

对于基于分类的深度(CLA)，直接从所有深度假设中选取概率最大的预测深度 $\mathbf{D}_{c l a}$ ，即argmax深度假设。从而得到回归深度 $\mathbf{D}_{\text {reg }}$ 和分类深度 $\mathbf{D}_{c l a}$ :
$\mathbf{D}_{r e g}=\sum_{j=1}^{D} d_{j} \cdot \mathbf{P}\left(d_{j}\right), \quad \mathbf{D}_{c l a}=\underset{d_{j} \in\left\{d_{j}\right\}_{j=1}^{D}}{\arg \max } \mathbf{P}\left(d_{j}\right) \tag{6}$
$\mathbf{D}_{r e g}$ 采用ground truth深度的L1损失进行优化， $\mathbf{D}_{c l a}$ 采用one-hot ground truth深度体积的交叉熵(CE)进行优化。

Remark.

[Peng等人](Rethinking depth estimation for multi-view stereo: A unified representation and focal loss) 认为REGs存在过拟合问题，导致深度预测模糊，而CLAs更鲁棒，但无法获得精确的深度结果。相比之下，本文认为，CLAs的置信度图优于REGs; 这一点不应被忽视，特别是对于广泛使用的多阶段MVS模型(比如CasMVSNet )。特别是，由于反射、遮挡或缺少可靠的源视图，MVS网络不能确保所有预测的深度图都是正确的。因此，提供可靠的深度置信图(不确定性)对于MVS重建良好的点云也很重要，如图6和图13中经验评估的那样。获得REGs和CLAs置信度图的方法在第A.4节中进行了总结。然而，如图4(a)所示，即使对于阶段2,3,4的 out-of-range深度假设，REG也保持高置信度值。REGs很难在不损害其他正确深度点的情况下过滤外点，如图4(b)所示。

由于CE不能处理超出范围的深度标签，我们提出在训练中masked所有深度外点，如 [Mi等人(2021)](Generalized Binary Search Network for Highly-Efficient Multi-View Stereo) 。我们也试图优化具有masked L1 loss的MVS，但其性能不如普通的回归。

在这里插入图片描述

虽然CLA在MVS中有很多很好的性能，但在我们早期的实验中，REGs在深度和点云方面的性能优于CLAs。因此，聚焦到 [Peng等人](Rethinking depth estimation for multi-view stereo: A unified representation and focal loss) 提到的问题，即深度预测不准确。[UniMVSNet](Rethinking depth estimation for multi-view stereo: A unified representation and focal loss) 设计了Unified Focal Loss(UFL)算法来解决这一问题，该算法将CE视为多重二元交叉熵(Binary Cross-Entropy, BCE)。利用多个超参数控制的focal loss来解决BCE中的不平衡问题。与UFL不同的是，本文提出了一种简单的方法来统一REGs和CLAs，它只调整推理过程，而不需要重新训练模型。

首先将温度 $t$ 乘以softmax之前的cost volume $\hat{\mathbf{C}}$ ，并将 $\mathbf{D}_{r e g}$ 重写为基于温度的深度期望 $\mathbf{D}_{t m p}$ 为
$\mathbf{D}_{t m p}=\sum_{j=1}^{D} d_{j} \cdot \hat{\mathbf{P}}\left(d_{j}\right), \quad \hat{\mathbf{P}}=\operatorname{softmax}(\hat{\mathbf{C}} \cdot t) \tag{7}$
显然，当 $t=\infty$ or $t = 1$ 时， $\mathbf{D}_{t m p}$ 分别等价于 $\mathbf{D}_{c l a}$ , or $\mathbf{D}_{r e g}$ 。其核心思想是在推理过程中调整温度 $t$ 以统一CLAs和REGs。对于低分辨率的早期阶段，设置更大的 $t$ ，使模型作为CLA工作，以获得更好的全局区分能力。对于高分辨率的后期阶段，模型倾向于使用较低的 $t$ 作为REG来平滑局部细节。在实践中，我们设置 $\left\{t^{1}, t^{2}, t^{3}, t^{4}\right\}=\{5,2.5,1.5,1\}^{3}$ 并获得比分类 $(t=\infty)$ ，回归 $(t = 1)$ 和其他在4.2节中评估的 $t$ 的一致设置更好的性能。

注意， $\mathbf{D}_{t m p}$ 仅在测试期间使用，因为使用CE优化的masked CLA对于MVS学习具有足够的鲁棒。因此，MVSFormer在训练阶段采用 $\mathbf{D}_{c l a}$ 。虽然在测试过程中调整温度可能会受到训练和测试阶段之间差异的一些影响，但我们只是倾向于在只有几个附近深度假设的后一阶段回归。因此，这种差距在很大程度上缩小了。而且我们的温度设置对于各种数据集都是通用的和有效的。更多细节将在C.6节讨论。

实验

设置

本文的方法在DTU, Tanks-and-Temples和ETH3D上进行了评估。由于DTU数据是在固定相机位姿的室内环境中收集的，因此本文的模型在BlendedMVS数据集上进行了微调，其中包含各种场景和目标，以泛化到Tanks-and-Temples和ETH3D中更复杂的环境，类似Giang et al. (2021); Ding et al. (2021) 的标准做法。

MVSFormer设置 32-16-8-4 个深度假设、4个coarse-to-fine阶段、视图数 $N = 5$ 。MVSFormer中的CNN部件由Adam训练，学习率为1e-3。MVSFormer中Twins-Small部分以学习率3e-5和0.01权值衰减进行训练，而MVSFormer-P中DINO-small部分被冻结。

模型在DTU上训练了10个epoch，并在BlendedMVS上进行了另外10个epoch的微调。学习率用500步预热，然后用余弦调度器衰减。对于多尺度训练，我们根据512到1280的尺度动态地将sub batch从8改为2，最大batch size为8。更多细节见附录章节A。

定量结果

DTU

MVSFormer在DTU上用点云的官方评估指标进行了评估，即准确性、完整性和整体误差。测试分辨率固定为1152 × 1536，视图数N = 5。使用Gipuma的深度融合，对点云使用一致的置信阈值0.5。DTU的定量结果见表1，定性结果见附录图9和图10。

对于基于学习的方法，所有扫描的后处理超参数都是固定的。传统的方法不能得到很好的完整性，这意味着它们在稀疏的结果中遗漏了很多点。对于基于学习的方法，MVSFormer可以达到最好的完整性和整体误差。MVSFormer-P是整体误差第二好的，具有更快的效率。因此，与其他竞争对手相比，我们的方法可以获得更完整的点云。请注意，在GBiNet中报告的结果需要使用不同的超参数进行后处理。我们的方法可以在所有扫描中使用固定的超参数设置来优于GBiNet。由于MVSFormer取得了令人印象深刻的改进，我们认为预训练的ViTs有潜力突破MVS的极限。

在这里插入图片描述

Tanks-and-Temples

自2022年5月以来，MVSFormer与其他已发布的工作相比，在官方Tanks-and-Temples排行榜的中级和高级组中均排名第一。在表16中显示了中级集和高级集的定量结果。所有实例都是用原始的 $1088 \times 1920$ 图像大小来推断的，更详细的设置在附录中。

该指标由基于提交点云的精度和召回率的f分数正式评估。MVSFormer在中级组和高级组的平均f分数分别为66.37和40.87，优于所有其他最先进的方法。如表16所示，我们的方法在除“Auditorium”之外的几乎所有情况下都能获得最佳或次优结果，可见其泛化性好，性能令人印象深刻。此外，CLA的置信度图可以过滤外点，得到更精确的点云，如附录所示。此外，本文提出的多尺度策略可以将MVSFormer泛化到更大的分辨率，如2K。更多的定性结果见附录的图11和图12。

在这里插入图片描述

ETH3D

为了证明该方法在场景数据中的鲁棒性，在不重新训练的高分辨率ETH3D的训练集和测试集上对MVSFormer进行了评估。ETH3D包含13个训练场景和12个测试场景，包括室内和室外挑战场景。我们使用在DTU上训练并在BlendedMVS上微调的模型来评估ETH3D。输入图像被调整为 $1088 \times 1920$ 作为Tanks-and-Temples，视图数为7。其他设置与Wang et al. (2022a)相同。表3对MVSFormer与传统方法和其他基于学习的最新方法进行了定量比较。MVSFormer在ETH3D的训练集和测试集上都获得了最好的f1分数，这表明我们的方法在场景数据集上具有良好的鲁棒性和泛化性。

在这里插入图片描述

消融研究

Different pre-trained models.

本文在表4中测试了不同的MVS预训练模型，包括ResNet50, DINO, MAE和Twins。ResNet50和Twins都是可训练的，而DINO和MAE是冻结的。基线方法是一个带有visibility modules和随机裁剪的4阶段级联MVS模型。

从表4可以看出，row2中的ResNet50提高了深度，但未能降低点云的整体误差。因为CNN-based预训练不能从反射和无纹理的区域中学习到适当的特征，这导致这些scan的指标不理想，导致点云的结果更差，如图5所示。MVSFormer(表4的row4和row9)即使没有多尺度训练也可以提高基线。对于冻结预训练ViTs与多尺度训练策略的比较，DINO-small与MAE-base相比，在参数较少的情况下获得了更好的性能，这得益于multi-crop和提出的基于注意力的GLU。尽管基于REG的方法具有稍好的深度，但它们无法以适当的置信度重建适当的点云。基于Twins和DINO的MVSFormers分别在点云和深度方面取得了最好的结果，而基于预训练的ResNet50模型与所有其他技巧(表4中的第3行)未能产生具有竞争力的结果。mvsformer和ResNet的详细比较将在C.5节中讨论。第二节讨论了不同预训练MVS方法的计算量和GPU内存开销。

在这里插入图片描述

多尺度训练

从表4中可以看出，Twins和基于DINO的mvsformer都从多尺度训练中获得了相当大的改进。特别是，可训练的Twins享有更多的好处(0.19的总误差)。由于空间不变性，CNN-based ResNet50基本上无法从多尺度训练中获益(row3)。此外，还比较了多尺度策略与高分辨率微调(HR-FT)，即使用固定的 $1024 \times 1280$ 图像对模型进行另外5个epoch的微调。但HR-FT与多尺度方法相比效果较差。我们认为，在特定分辨率上的微调仍然存在对注意力块的空间过拟合，这限制了ViTs在各种图像尺度上的泛化。

The effect of pre-training for ViTs.

虽然训练一个transformer (with CNN) 进行MVS是可行的，但是我们认为预训练对于MVS的学习还是很重要的，特别是对于特征学习。特别是，用Twins-small从头开始训练MVSFormer，如表5(左)所示。将未预训练Twins-small的学习率从3e-5提高到1e-4，而其他设置不变。表5(左)的结果表明，预训练对于MVSFormer至关重要。没有经过预训练的Twins-small不如经过预训练的。在不进行预训练的情况下，我们的方法接近于除了基于温度的深度外，只考虑视图内注意的基于注意力的MVS方法。实际上，没有任何预训练的MVSFormer的性能与TransMVSNet相似(Ding et al.， 2021)。因此，预训练对于ViTs建模合适的特征表示来解决MVS中基本的特征匹配问题是非常重要的。

在这里插入图片描述

Effects of DINO attention maps from [CLS] and GLU.

在表5(右)中，评估了使用和不使用[CLS]注意图时MVSFormer-P的性能。此外，将基于GLU的注意图融合与简单的连接和×2卷积进行比较，以平衡参数。从表5(右)可以看出，两种注意融合策略与没有注意图的基线相比都有改善。在相同的计算量下，GLU块可以获得更好的深度。

REG vs CLA in MVS.

为了说明CLA模型的效果置信度图在点云重建中的重要性。在图6中进一步展示了REG和CLA在真实世界Tanks-and-Temples重建中的差异。注意CLA可以生成更可靠的置信度图来区分某些前景和不确定背景(例如，天空)。因此，基于CLA的方法可以用更少的外点重建更多的有效点，这对于现实世界的MVS实践至关重要。更多真实案例见附录图13。

在这里插入图片描述

Temperature-based depth prediction.

在这里插入图片描述

MVSFormer的REG和CLA的定量消融见表6。与使用REG训练的模型相比，基于CLA (t =∞)的原始模型无法获得更好的结果。随着温度 $t$ 的降低，深度被平滑，模型倾向于重建更精确的点云。由于精度距离的减小和完备距离的增大。由于准确性和完整性的权衡， $t = 0.75$ 得到的总体结果更差。在早期阶段简单地减少 $t$ 会导致过度平滑结果，从而损害点云的完整性。 ${t1, t2, t3, t4} ={5,2.5, 1.5, 1}$ 设置可以在深度和点云上得到很好的权衡，这比任何一致的t都好;与REG相比，它也具有更好的精度，这表明CLA提供了更好的置信度图来过滤外点。因此，让早期阶段作为CLA工作，后期阶段作为REG工作的想法是合理的。更多关于温度的定性(第C.3节)和定量(第C.6节)分析将在附录中讨论。

结论

在本文中讨论了预训练模型对MVS学习的影响，并提出了一种ViT增强的MVS架构，称为MVSFormer。MVSFormer通过预训练的hierarchical-ViT Twins增强了更好的特征编码，实现了显著的改进。此外，提出了一种替代MVSFormer-P与plain-ViT DINO，它也可以达到与冻结骨干竞争的结果。利用高效的多尺度训练将MVSFormer泛化到各种分辨率。此外，提出了一种有效的基于温度的深度预测方法，统一了REG和CLA在MVS学习中的应用，得到了平滑的深度图和清晰的无外点点云。方法在DTU中可以达到最先进的效果，在Tanks-and-Temples中排名第一。

A 更多实现细节和讨论

A.1 Multi-scale Training

在这里插入图片描述

图1总结了多尺度训练的PyTorch伪代码。训练尺度从25个模式中随机选择，其高度范围为512 ~ 1024，宽度范围为640 ~ 1280。我们还从原始尺度的[0.83,1.0]处随机裁剪图像。全局batch size为8，子批大小与分辨率的关系如表7所示。由于混合精度，MVSFormer在DTU和BlendedMVS中分别使用两个V100 32GB NVIDIA Tesla gpu进行10个epoch的训练只需要大约22和15个小时。

在这里插入图片描述

A.2 数据增强

在MVSFormer中对所有参考视图和源视图使用相同的参数来增强ViT的输入图像，这可以略微提高深度性能，如表8所示。具体来说，数据增强是通过随机伽马、亮度、对比度、饱和度和色调的颜色抖动来执行的。增强参数从均匀分布中采样，gamma、对比度和饱和度范围为[0.9,1.1]，亮度范围为[0.8,1.2]，色相范围为[0.95,1.05]。

在这里插入图片描述

A.3 后处理

对于DTU，使用Gipuma的深度融合工具得到最终的点云，这些点云具有一致的超参数，即视差阈值0.1，数量一致性2，概率阈值0.5。对于Tanks-and-Temples，为了避免为每种情况调整超参数，使用 Yan等人(2020) 提出的动态一致性检查。

A.4 Confidence Maps

获得了每个阶段的REGs和CLAs的置信度图：
$\mathbf{P}_{r e g}=\operatorname{AvgPool}(\mathbf{P}, k)\left(\mathbf{D}_{r e g}\right), \quad \mathbf{P}_{c l a}=\mathbf{P}\left(\mathbf{D}_{c l a}\right)$
其中， $\mathbf{D}_{r e g}$ 和 $\mathbf{D}_{c l a}$ 由式6预测深度; $\mathbf{P}$ 是沿深度假设softmax后的概率; $k$ 表示深度池化的核大小。对于CLAs，简单地使用所有深度假设的最大概率作为置信度图。REGs遵循MVSNet，在gathering置信度之前，沿深度将概率平均。对于级联深度假设，将4个阶段的池化核大小 $k$ 设置为 ${4,3,2,1}$ 到 32-16-8-4 个假设，而不是使用MVSNet的4，以获得稍好的重建结果。然后，在nearest resizing到原始图像大小后，对所有阶段的置信度图进行平均，以获得最终置信度输出。

A.5 额外讨论

为什么在MVSFormer中完全分离了FPN和ViT

在MVS中使用的FPN可以有效地整合来自不同输入尺度的信息。FPN对于MVSFormer中的ViT来说并不是冗余的，原因有3：

1)：对ViT使用1/2输入尺度，而FPN采用全分辨率输入。因此FPN可以学习到更细节的信息。在C.1节中讨论了没有FPNs和预训练ResNet的ViTs的性能。在MVS中，ViTs可以与FPNs互补，以获得全局理解和局部细节。
2)：由于ViT的输入被下采样到1/2以减小计算，因此hierarchical-ViT的有效最大特征尺度为1/8，而Plain ViT的有效最大特征尺度较小(1/32)。FPN特征尺度分别为1、1/2、1/4、1/8。所以只有一个特征层(1/8)可以被ViT特征完全取代。出于模型完整性的考虑，我们保留了FPN的所有层。
3)：由于FPN的输入比ViT的输入大2倍，FPN的最高层级特征 (1/8) 还包含从ViTs中未包含的高分辨率输入学习到的信息特征。

Why using DINO attention maps from [CLS] rather than other tokens?

使用从[CLS] token附带的注意力图有两个原因。

DINO 使用自蒸馏进行预训练。在预训练期间直接监督[CLS] token。因此，[CLS] token需要理解图像中的全局语义。因此，[CLS] token的注意图对于决定最终的预测更为重要。
此外，所有token ( $H W \times H W$ )的注意图比[CLS] token ( $H \times W$ )的注意图大得多，因此从 $H W \times H W$ 关系中选择或获得合理的注意图也是一个难题。

Relation of CLA/REG confidence and aleatoric/epistemic uncertainty.

正如 [Kendall & Gal(2017)](What uncertainties do we need in bayesian deep learning for computer vision?) 中提到的，任意不确定性捕获了观测中固有的噪声，而认知不确定性表示模型参数中的不确定性。根据Kendall & Gal(2017)的定义，CLA和REG都应该被归类为任意不确定性，而不是认知不确定性。因为我们还没有测试这些方法与模型不确定性(例如，辍学推理)。更重要的是，CLA和REG都只显示了训练分布中噪声的不确定性，而不是Out-of-data样例。例如，大多数基于学习的MVS方法(CLA和REG)在预测前需要一定的深度范围;在错误的深度范围内，它们无法提供正确的结果。然而，如第3.4节所述，在给定一定深度范围的情况下，基于CLA的级联MVS具有更合理的置信度。此外，MVS的不确定性估计是一个值得关注的问题。

B 推理内存和时间成本

在表9中测试了输入分辨率为 $1152 \times 1536$ 的推理内存和时间成本，并与CNN-based预训练、纯FPN和其他MVS方法进行了比较。所有的比较都是基于V100 NVIDIA Tesla GPU。从表9可以看出，虽然参数规模增加了，但与基线方法相比，ViT增强的MVSFormers只会多消耗一点GPU内存和时间。除了ViT本身包含的参数外，大多数其他可训练参数都用于MVSFormer中的降维。与MVSFormer-P相比，MVSFormer可以更快地进行推断，这得益于Twins中高效的多尺度关注设计。请注意，预训练的CNN模型-ResNet50在GPU内存和推理时间上也花费了很多。对于其他MVS算法，它们都是一次转发一个视图。CasMVSNet在没有为cost volume使用 group-wise pooling 的情况下消耗了大部分内存。复杂的TransMVSNet存在推理速度慢和内存成本大的问题。CDS-MVSNet比MVSFormer效率稍高，但性能不高。

在这里插入图片描述

C 更多实验结果

C.1 Pre-trained ViTs without FPNs

为了探索ViTs的学习能力，表10显示了一些不经过FPNs训练的ViTs (DINO-small, MAE-base, Twins-small)对MVS的量化结果，并将其与基于CNN-based的预训练ResNet34和ResNet50以及vanilla FPN进行了比较。请注意，这些实验仅基于256×320 DTU中的低分辨率情况，因为希望节省所有可训练ViT权重的计算。MAE和DINO的学习率为1e-5;Twins的学习率为3e-5，所有CNNs的学习率为1e-3。从表10中可以看出，ViTs无法获得与CNNs (2mm, 4mm)一样好的细节，但ViTs的结果在大深度误差指标(8mm, 14mm)中更具鲁棒。因此，我们认为ViTs可以解决主要论文中提到的一些由反射和无纹理区域引起的严重错误。与其他预训练的CNNs相比，从头开始训练的FPN在低分辨率情况下获得了更好的深度结果，这再次证明了在MVS中使用预训练的CNNs的困境。除了金字塔结构带来的2mm误差外，Twins-small可以获得比FPN更好的深度。因此，ViTs可以与CNN-based FPNs互补，以获得MVS的全局理解和局部细节。

在这里插入图片描述

C.2 MVSFormer的不同特征融合策略

在本文中更关注从预训练的ViTs中获得的本质改进。因此倾向于在MVSFormer中使用简单的特征融合策略。表11考虑了直接特征加法(DFA)(在主论文中使用)和多尺度特征加法(MFA)。对于多尺度加法，使用额外的卷积块将ViT特征进一步上采样到1/4和1/2，并将其添加到FPN中的相关特征图中。由于ViTs的输入减半，我们不尝试将ViT特征上采样到1/1。从表11可以看出，MFA可以实现更好的深度预测，但更差的点云指标。我们认为ViT特征不适合高分辨率特征，采用DFA作为我们的解决方案。

在这里插入图片描述

C.3 基于温度的深度预测的定性结果

在图7中显示了不同温度 $t$ 下CLA的其他定性结果。 $t = 100$ 倾向于输出具有锯齿边界的深度图，而 $t = 1$ 和基于回归的深度图遭受不确定和模糊的预测。虽然图7(e)和图7(f)之间的视觉差异不明显，但设置 ${t1, t2, t3, t4 = 5,2.5, 1.5, 1\}$ 可以得到比 $t = 100$ 或 $t = \infty$ 更精确的深度预测。如果仔细比较图7(i)和图7(j)，我们的深度在表面上的误差较小(<2mm)。另一方面，我们的温度设置带来的“副作用”比 $t = 1$ 的设置要小得多。因此，“CLA在早期阶段，REG在后期” 的想法是合理的，并得到更好的深度细节和点云结果。

在这里插入图片描述

C.4 不同ViT容量的比较

在表12中进一步评估了具有较大ViT骨干(base model)的MVSFormer-P和MVSFormer的性能。与DINO-small相比，DINO-base的性能更差。我们认为MVSFormer-P中使用的较小的DINO具有更好的泛化效果，因为DINO骨干在MVSFormer-P中由于昂贵的plain-ViT设计而固定。

另一方面，Twins-base相对于Twins-small可以实现全面的深度提升，但是对于点云的提升可以忽略不计。显然，点云度量更难改进。但是仍然可以期望从更大的可训练的预训练ViTs中获得良好的性能。此外，DINO-base和Twins-base都使训练收敛速度比small更快。

在这里插入图片描述

C.5 预训练的ResNet50与所有其他技术的性能

为了进一步确保预训练ViTs对MVS的有效性，在表13中提供了关于预训练ResNet50与MVSFormer中使用的所有其他技术(包括多尺度训练)的更多结果。由于CNNs具有良好的空间不变性，ResNet50的多尺度训练不如基于ViT的mvsformer的多尺度训练重要。表13的实验表明，多尺度训练并不能很大程度上提高ResNet50。

在这里插入图片描述

C.6 REG、CLA和基于温度的CLA的更详细的定量分析

Quantitative analysis.

首先从表6中重新列出表14中的这些重要结果，以便清晰具体地说明。点云的精度(Acc)表示与ground truth点距离最近的重构点的平均值。因此“Acc”可以看作是模型中重构点的精度。另一方面，“Cop”显示了所建议的方法重建的完整程度。从表14中可以看出，与REG相比，基于温度的CLA深度可以获得更好的Acc和Ovl, Cop相似，这意味着CLA具有更好的置信度图，可以用更精确的点云成功过滤边界附近的外点。

vanilla CLA无法获得良好的Acc (0.349 vs 0.336)与类似的Cop (0.248 vs 0.249)。这意味着用不精确的argmax从vanilla CLA重建的点是不精确的(vanilla CLA不会产生更多的点，因为Cop是相似的)，这可以通过我们基于温度的深度来很大程度上解决。

在这里插入图片描述

More ablations about temperatures.

为了更深入地讨论REG和CLA，在表15中提供了更多关于温度设置的消融。在表15中，进一步对比了1mm的深度误差，可以看出，降低最后阶段的温度可以有效地得到精确的深度，误差小于1.2 mm，而最后阶段的训练和推理差异可以忽略不计。此外， ${∞，∞，∞，1\}$ 的设置获得了最佳的深度度量和整体点云重建，但精度和完整性的差距大于{5,2.5,1.5,1}。因此，在早期阶段进行轻微的回归对于更高精度的重建仍然是有用的。除了完整性之外，{5,5,5,1}在大多数指标上都优于{5,2.5,1.5,1}，但改进并不明显。这一现象表明我们将早期阶段作为CLA而后期阶段作为REG的关键理念得到了验证;与其他阶段相比，最后一级调整深度预测具有更大的效益和更低的成本。

在这里插入图片描述

C.7 Ablations about More Source Views

在对Tanks-and-Temples的测试中，我们发现来自高级集的相机位姿非常具有挑战性。因此，我们尝试使用根据Yao等人(2018)的视图选择未包含的选定源视图的候选视图来扩展源视图。发现增加源视图的数量可以有效地提高Tanks-and-Temples复杂场景下的性能。由于MVSFormer中使用了可见性归一化，我们的方法可以推广到N = 15,20，并且在Tanks-and-Temples上取得了更好的结果。如图8所示，20视图输入预测的深度图比10视图输入预测的深度图更可靠。表16的定量结果表明，我们主要论文中关于Tanks-and-Temples的最新结果可以通过更多的源视图进一步改进。

在这里插入图片描述

C.8 DTU定性结果

将DTU与CDS-MVSNet和GBiNet进行了定性比较。定性深度和置信度对比如图9所示，点云对比如图10所示。从图9可以看出，MVSFormer可以实现比其他深度图更鲁棒的深度图。值得注意的是，MVSFormer的深度图与CDS-MVSNet的回归深度图一样平滑。此外，GBiNet中使用的argmax操作无法实现稳定的深度预测，并且严重依赖置信度图来过滤无效深度。但是我们的MVSFormer不仅可以得到很好的深度预测，而且可以得到可靠的置信图，这得益于我们提出的基于温度的深度预测。从图10中，我们的方法可以忠实地重建一些具有挑战性的点云，而这些点云通常被其他竞争者所忽略。

在这里插入图片描述

C.9 Tanks-and-Temples的定性结果

Tanks-and-Temples深度定性结果如图11所示。得益于所提出的基于温度的深度预测，MVSFormer不仅可以获得良好的深度预测，还可以获得可靠的置信度图，从而获得图11(d)中高质量的过滤深度。

我们还提供了与TransMVSNet和UniMVSNet比较的Tanks-and-Temples的定性结果。图12显示了“马”和“灯塔”在Tanks-and-Temples中间集的定性结果。从图12中可以看出，我们的MVSFormer可以重建更多的细节(更好的Recall)，生成位置更准确的点云(更好的Precision)。但TransMVSnet漏掉了“马”中的一些结构，并预测了“灯塔”中的偏差点。另一方面，UniMVSNet在’ Horse '中受到许多外点的影响，无法重建正确的灯塔。

在这里插入图片描述

F 限制及未来工作

我们讨论了局限性和潜在的未来工作。特别地，

1)利用了最近用自监督(MAE, DINO)和监督(Twins)任务预训练的ViTs，而探索不同预训练任务对MVS的影响是一个有趣的未来工作。所涉及的方法MAE、DINO和Twins比较有代表性。具体来说，MAE和DINO基于香草plain-ViT，而Twins基于hierarchical-ViT。此外，请注意，由于内存成本限制，必须冻结MVSFormer-P中的ViT权重，这与另一种变体(基于Twins的MVSFormer)相比失去了一些优势。因此，在本文中，这些ViTs不能保证使用相同的体系结构和训练设置进行预训练。因此，对于不同的预训练任务使用相同的ViT架构，并进一步探索这些预训练任务(监督和自监督)如何影响MVS是很有趣的。然而，用不同的预训练任务重新训练所有这些ViTs是非常重要的，并且需要大量的计算资源。因此，我们把它作为未来的工作。关键是，提出的模型的性能已经优于所有现有的方法;这证明了我们模型的有效性。

2)本文使用的融合方法虽然简单，但足以使我们的模型具有竞争力。在这里，我们只考虑单尺度和多尺度的特征相加。另一方面，更有技术和信息的融合策略将是非常可取的，例如 cross-attention (Vaswani等人，2017)和GRU模块(Cho等人，2014)。然而，这也将是一个非常有趣的未来工作，可能会激励社区。

G 广泛影响

我们的方法可以在二维图像的基础上进行三维重建。由于基于学习的MVS方法可以推广到各种现实世界的数据集，因此所提出的方法可能会对有争议的2D图像造成一些社会影响。请注意，我们在本文中只提供了技术方法，但现实世界的实践可能会产生负面的社会影响，需要进一步考虑。

代码实现

MVSFormer特征提取

Twins-MVSFormer的特征提取代码:

imgs = imgs.reshape(B * V, 3, H, W)

# FPN特征提取
conv01, conv11, conv21, conv31 = self.encoder(imgs)
# conv01:[B*V,8,H,W] conv11:[B*V,16,H/2,W/2]  conv21:[B*V,32,H/4,W/4]  conv31:[B*V,64,H/8,W/8]

# 为了减少内存消耗，将输入到VIT的图像大小减少
vit_h, vit_w = int(H * self.vit_args['rescale']), int(W * self.vit_args['rescale'])  
# [B*V,3,H/2,W/2]
vit_imgs = F.interpolate(imgs, (vit_h, vit_w), mode='bicubic', align_corners=Align_Corners_Range)  

# VIT特征提取
if self.args['fix']:  # 是否固定VIT的参数
    with torch.no_grad():
        [vit1, vit2, vit3, vit4] = self.vit.forward_features(vit_imgs)
else:
    [vit1, vit2, vit3, vit4] = self.vit.forward_features(vit_imgs)
# vit1:[B*V,64,H/8,W/8]  vit2:[B*V,128,H/16,W/16] vit3:[B*V,128,H/32,W/32] vit4:[B*V,512,H/64,W/64]

#特征融合网络
if self.multi_scale:
    vit_out, vit_out2, vit_out3 = self.decoder_vit.forward(vit1, vit2, vit3, vit4)
    feat1, feat2, feat3, feat4 = self.decoder.forward(conv01, conv11, conv21, conv31, vit_out, vit_out2,
                                                      vit_out3)
else:
    #先将VIT输出的特征融合成单个特征图
    vit_out = self.decoder_vit.forward(vit1, vit2, vit3, vit4)  # [B*V,64,H/8,W/8]
    conv31 = conv31 + vit_out
    # 再对FPN输出的特征进行特征融合
    feat1, feat2, feat3, feat4 = self.decoder.forward(conv01, conv11, conv21, conv31)
# feat1:[B*V,64,H/8,W/8] feat2:[B*V,32,H/4,W/4] feat1:[B*V,16,H/2,W/2] feat1:[B*V,8,H,W]
    
features = {'stage1': feat1.reshape(B, V, feat1.shape[1], feat1.shape[2], feat1.shape[3]),
            'stage2': feat2.reshape(B, V, feat2.shape[1], feat2.shape[2], feat2.shape[3]),
            'stage3': feat3.reshape(B, V, feat3.shape[1], feat3.shape[2], feat3.shape[3]),
            'stage4': feat4.reshape(B, V, feat4.shape[1], feat4.shape[2], feat4.shape[3])}

FPN特征提取网络：

class FPNEncoder(nn.Module):
    def __init__(self, feat_chs, norm_type='BN'):
        super(FPNEncoder, self).__init__()
        self.conv00 = Conv2d(3, feat_chs[0], 7, 1, padding=3, norm_type=norm_type)
        self.conv01 = Conv2d(feat_chs[0], feat_chs[0], 5, 1, padding=2, norm_type=norm_type)

        self.downsample1 = Conv2d(feat_chs[0], feat_chs[1], 5, stride=2, padding=2, norm_type=norm_type)
        self.conv10 = Conv2d(feat_chs[1], feat_chs[1], 3, 1, padding=1, norm_type=norm_type)
        self.conv11 = Conv2d(feat_chs[1], feat_chs[1], 3, 1, padding=1, norm_type=norm_type)

        self.downsample2 = Conv2d(feat_chs[1], feat_chs[2], 5, stride=2, padding=2, norm_type=norm_type)
        self.conv20 = Conv2d(feat_chs[2], feat_chs[2], 3, 1, padding=1, norm_type=norm_type)
        self.conv21 = Conv2d(feat_chs[2], feat_chs[2], 3, 1, padding=1, norm_type=norm_type)

        self.downsample3 = Conv2d(feat_chs[2], feat_chs[3], 3, stride=2, padding=1, norm_type=norm_type)
        self.conv30 = Conv2d(feat_chs[3], feat_chs[3], 3, 1, padding=1, norm_type=norm_type)
        self.conv31 = Conv2d(feat_chs[3], feat_chs[3], 3, 1, padding=1, norm_type=norm_type)

    def forward(self, x):
        conv00 = self.conv00(x)
        conv01 = self.conv01(conv00)
        down_conv0 = self.downsample1(conv01)
        conv10 = self.conv10(down_conv0)
        conv11 = self.conv11(conv10)
        down_conv1 = self.downsample2(conv11)
        conv20 = self.conv20(down_conv1)
        conv21 = self.conv21(conv20)
        down_conv2 = self.downsample3(conv21)
        conv30 = self.conv30(down_conv2)
        conv31 = self.conv31(conv30)

        return [conv01, conv11, conv21, conv31]

VIT 非多尺度的特征融合网络如下：

class TwinDecoderStage4(nn.Module):
    def __init__(self, args):
        super(TwinDecoderStage4, self).__init__()
        ch, vit_chs = args['out_ch'], args['vit_ch']  #"vit_ch": [64,128,256,512],  "out_ch": 64,
        ch = ch * 4  # 256
        self.upsampler0 = nn.Sequential(nn.ConvTranspose2d(vit_chs[-1], ch, 4, stride=2, padding=1),
                                        nn.BatchNorm2d(ch), nn.GELU())  # 256
        self.inner1 = nn.Conv2d(vit_chs[-2], ch, kernel_size=1, stride=1, padding=0)
        self.smooth1 = nn.Sequential(nn.Conv2d(ch, ch // 2, kernel_size=3, stride=1, padding=1),
                                     nn.BatchNorm2d(ch // 2), nn.ReLU(True))  # 256->128

        self.inner2 = nn.Conv2d(vit_chs[-3], ch // 2, kernel_size=1, stride=1, padding=0)
        self.smooth2 = nn.Sequential(nn.Conv2d(ch // 2, ch // 4, kernel_size=3, stride=1, padding=1),
                                     nn.BatchNorm2d(ch // 4), nn.ReLU(True))  # 128->64

        self.inner3 = nn.Conv2d(vit_chs[-4], ch // 4, kernel_size=1, stride=1, padding=0)
        self.smooth3 = nn.Sequential(nn.Conv2d(ch // 4, ch // 4, kernel_size=3, stride=1, padding=1),
                                     nn.BatchNorm2d(ch // 4), Swish())  # 64->64

    def forward(self, x1, x2, x3, x4):  # in:[1/8 ~ 1/64] out:[1/2,1/4,1/8]
        x = self.smooth1(self.upsampler0(x4) + self.inner1(x3))  # 1/64->1/32
        x = self.smooth2(F.upsample(x, scale_factor=2, mode='bilinear', align_corners=False) + self.inner2(x2))  # 1/32->1/16
        x = self.smooth3(F.upsample(x, scale_factor=2, mode='bilinear', align_corners=False) + self.inner3(x1))  # 1/16->1/8

        return x

VIT 多尺度的特征融合网络如下：

class TwinDecoderStage4V2(nn.Module):
    def __init__(self, args):
        super(TwinDecoderStage4V2, self).__init__()
        ch, vit_chs = args['out_ch'], args['vit_ch']
        ch = ch * 4  # 256
        self.upsampler0 = nn.Sequential(nn.ConvTranspose2d(vit_chs[-1], ch, 4, stride=2, padding=1),
                                        nn.BatchNorm2d(ch), nn.GELU())  # 256
        self.inner1 = nn.Conv2d(vit_chs[-2], ch, kernel_size=1, stride=1, padding=0)
        self.smooth1 = nn.Sequential(nn.Conv2d(ch, ch // 2, kernel_size=3, stride=1, padding=1),
                                     nn.BatchNorm2d(ch // 2), nn.GELU())  # 256->128

        self.inner2 = nn.Conv2d(vit_chs[-3], ch // 2, kernel_size=1, stride=1, padding=0)
        self.smooth2 = nn.Sequential(nn.Conv2d(ch // 2, ch // 4, kernel_size=3, stride=1, padding=1),
                                     nn.BatchNorm2d(ch // 4), nn.GELU())  # 128->64

        self.inner3 = nn.Conv2d(vit_chs[-4], ch // 4, kernel_size=1, stride=1, padding=0)
        self.smooth3 = nn.Sequential(nn.Conv2d(ch // 4, ch // 4, kernel_size=3, stride=1, padding=1),
                                     nn.BatchNorm2d(ch // 4), nn.GELU())  # 64->64

        self.decoder1 = nn.Sequential(nn.ConvTranspose2d(ch // 4, ch // 8, 4, stride=2, padding=1),
                                      nn.BatchNorm2d(ch // 8), nn.GELU())
        self.decoder2 = nn.Sequential(nn.ConvTranspose2d(ch // 8, ch // 16, 4, stride=2, padding=1),
                                      nn.BatchNorm2d(ch // 16), nn.GELU())

    def forward(self, x1, x2, x3, x4):  # in:[1/8 ~ 1/64] out:[1/2,1/4,1/8]
        x = self.smooth1(self.upsampler0(x4) + self.inner1(x3))  # 1/64->1/32
        x = self.smooth2(F.upsample(x, scale_factor=2, mode='bilinear', align_corners=False) + self.inner2(x2))  # 1/32->1/16
        out1 = self.smooth3(F.upsample(x, scale_factor=2, mode='bilinear', align_corners=False) + self.inner3(x1))  # 1/16->1/8
        out2 = self.decoder1(out1)
        out3 = self.decoder2(out2)

        return out1, out2, out3

FPN非多尺度特征融合网络：

class FPNDecoder(nn.Module):
    def __init__(self, feat_chs):
        super(FPNDecoder, self).__init__()
        final_ch = feat_chs[-1]
        self.out0 = nn.Sequential(nn.Conv2d(final_ch, feat_chs[3], kernel_size=1), nn.BatchNorm2d(feat_chs[3]), Swish())

        self.inner1 = nn.Conv2d(feat_chs[2], final_ch, 1)
        self.out1 = nn.Sequential(nn.Conv2d(final_ch, feat_chs[2], kernel_size=3, padding=1), nn.BatchNorm2d(feat_chs[2]), Swish())

        self.inner2 = nn.Conv2d(feat_chs[1], final_ch, 1)
        self.out2 = nn.Sequential(nn.Conv2d(final_ch, feat_chs[1], kernel_size=3, padding=1), nn.BatchNorm2d(feat_chs[1]), Swish())

        self.inner3 = nn.Conv2d(feat_chs[0], final_ch, 1)
        self.out3 = nn.Sequential(nn.Conv2d(final_ch, feat_chs[0], kernel_size=3, padding=1), nn.BatchNorm2d(feat_chs[0]), Swish())

    def forward(self, conv01, conv11, conv21, conv31):
        intra_feat = conv31
        out0 = self.out0(intra_feat)

        intra_feat = F.interpolate(intra_feat, scale_factor=2, mode="bilinear", align_corners=True) + self.inner1(conv21)
        out1 = self.out1(intra_feat)

        intra_feat = F.interpolate(intra_feat, scale_factor=2, mode="bilinear", align_corners=True) + self.inner2(conv11)
        out2 = self.out2(intra_feat)

        intra_feat = F.interpolate(intra_feat, scale_factor=2, mode="bilinear", align_corners=True) + self.inner3(conv01)
        out3 = self.out3(intra_feat)

        return [out0, out1, out2, out3]

多尺度特征融合网络：

class FPNDecoderV2(nn.Module):
    def __init__(self, feat_chs):
        super(FPNDecoderV2, self).__init__()
        self.out1 = nn.Sequential(nn.Conv2d(feat_chs[3] * 2, feat_chs[3], kernel_size=3, padding=1), nn.BatchNorm2d(feat_chs[3]), Swish())
        self.upsample1 = nn.Sequential(nn.ConvTranspose2d(feat_chs[3], feat_chs[2], kernel_size=4, stride=2, padding=1),
                                       nn.BatchNorm2d(feat_chs[2]), nn.ReLU(True))

        self.out2 = nn.Sequential(nn.Conv2d(feat_chs[2] * 2, feat_chs[2], kernel_size=3, padding=1), nn.BatchNorm2d(feat_chs[2]), Swish())
        self.upsample2 = nn.Sequential(nn.ConvTranspose2d(feat_chs[2], feat_chs[1], kernel_size=4, stride=2, padding=1),
                                       nn.BatchNorm2d(feat_chs[1]), nn.ReLU(True))

        self.out3 = nn.Sequential(nn.Conv2d(feat_chs[1] * 2, feat_chs[1], kernel_size=3, padding=1), nn.BatchNorm2d(feat_chs[1]), Swish())
        self.upsample3 = nn.Sequential(nn.ConvTranspose2d(feat_chs[1], feat_chs[0], kernel_size=4, stride=2, padding=1),
                                       nn.BatchNorm2d(feat_chs[0]), nn.ReLU(True))

        self.out4 = nn.Sequential(nn.Conv2d(feat_chs[0], feat_chs[0], kernel_size=3, padding=1), nn.BatchNorm2d(feat_chs[0]), Swish())

    def forward(self, conv01, conv11, conv21, conv31, vit1, vit2, vit3):
        out1 = self.out1(torch.cat([conv31, vit1], dim=1))  # [B,64,H/8,W/8]

        out2 = self.upsample1(out1) + conv21
        out2 = self.out2(torch.cat([out2, vit2], dim=1))  # [B,32,H/4,W/4]

        out3 = self.upsample2(out2) + conv11
        out3 = self.out3(torch.cat([out3, vit3], dim=1))  # [B,16,H/2,W/2]

        out4 = self.upsample3(out3) + conv01
        out4 = self.out4(out4)  # [B,8,H,W]

        return [out1, out2, out3, out4]

TwinsVit

PyramidVisionTransformer

class PyramidVisionTransformer(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256, 512],
                 num_heads=[1, 2, 4, 8], mlp_ratios=[4, 4, 4, 4], qkv_bias=False, qk_scale=None, drop_rate=0.,
                 attn_drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm,
                 depths=[3, 4, 6, 3], sr_ratios=[8, 4, 2, 1], block_cls=Block):
        super().__init__()
        print('drop_path_rate: --- ', drop_path_rate)
        self.num_classes = num_classes
        self.depths = depths

        # patch_embed
        self.patch_embeds = nn.ModuleList()
        self.pos_embeds = nn.ParameterList()
        self.pos_drops = nn.ModuleList()
        self.blocks = nn.ModuleList()

        for i in range(len(depths)):
            if i == 0:
                self.patch_embeds.append(PatchEmbed(img_size, patch_size, in_chans, embed_dims[i]))
            else:
                self.patch_embeds.append(PatchEmbed(img_size // patch_size // 2 ** (i - 1), 2, embed_dims[i - 1], embed_dims[i]))
            patch_num = self.patch_embeds[-1].num_patches + 1 if i == len(embed_dims) - 1 else self.patch_embeds[-1].num_patches
            self.pos_embeds.append(nn.Parameter(torch.zeros(1, patch_num, embed_dims[i])))
            self.pos_drops.append(nn.Dropout(p=drop_rate))

        # transformer encoder
        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
        print('dpr:',dpr)

        cur = 0
        for k in range(len(depths)):
            _block = nn.ModuleList([block_cls(
                dim=embed_dims[k], num_heads=num_heads[k], mlp_ratio=mlp_ratios[k], qkv_bias=qkv_bias, qk_scale=qk_scale,
                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer,
                sr_ratio=sr_ratios[k])
                for i in range(depths[k])])
            self.blocks.append(_block)
            cur += depths[k]

        self.norm = norm_layer(embed_dims[-1])

        # cls_token
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dims[-1]))

        # classification head
        self.head = nn.Linear(embed_dims[-1], num_classes) if num_classes > 0 else nn.Identity()

        # init weights
        for pos_emb in self.pos_embeds:
            trunc_normal_(pos_emb, std=.02)
        self.apply(self._init_weights)

    def reset_drop_path(self, drop_path_rate):
        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(self.depths))]
        cur = 0
        for k in range(len(self.depths)):
            for i in range(self.depths[k]):
                self.blocks[k][i].drop_path.drop_prob = dpr[cur + i]
            cur += self.depths[k]

    def _init_weights(self, m):
        if isinstance(m, nn.Linear):
            trunc_normal_(m.weight, std=.02)
            if isinstance(m, nn.Linear) and m.bias is not None:
                nn.init.constant_(m.bias, 0)
        elif isinstance(m, nn.LayerNorm):
            nn.init.constant_(m.bias, 0)
            nn.init.constant_(m.weight, 1.0)

    def init_weights(self, pretrained=None):
        if isinstance(pretrained, str):
            self.apply(self._init_weights)
            load_checkpoint(self, pretrained, map_location='cpu', strict=False, logger=None)
        elif pretrained is None:
            self.apply(self._init_weights)
        else:
            raise TypeError('pretrained must be a str or None')

    @torch.jit.ignore
    def no_weight_decay(self):
        # return {'pos_embed', 'cls_token'} # has pos_embed may be better
        return {'cls_token'}

    def get_classifier(self):
        return self.head

    def reset_classifier(self, num_classes, global_pool=''):
        self.num_classes = num_classes
        self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()

    def forward_features(self, x):
        B = x.shape[0]
        for i in range(len(self.depths)):
            x, (H, W) = self.patch_embeds[i](x)
            if i == len(self.depths) - 1:
                cls_tokens = self.cls_token.expand(B, -1, -1)
                x = torch.cat((cls_tokens, x), dim=1)
            x = x + self.pos_embeds[i]
            x = self.pos_drops[i](x)
            for blk in self.blocks[i]:
                x = blk(x, H, W)
            if i < len(self.depths) - 1:
                x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()

        x = self.norm(x)

        return x[:, 0]

    def forward(self, x):
        x = self.forward_features(x)
        x = self.head(x)

        return x

CPVTV2

class CPVTV2(PyramidVisionTransformer):
    def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256, 512],
                 num_heads=[1, 2, 4, 8], mlp_ratios=[4, 4, 4, 4], qkv_bias=False, qk_scale=None, drop_rate=0.,
                 attn_drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm,
                 depths=[3, 4, 6, 3], sr_ratios=[8, 4, 2, 1], block_cls=Block, F4=False, extra_norm=False):
        super(CPVTV2, self).__init__(img_size, patch_size, in_chans, num_classes, embed_dims, num_heads, mlp_ratios,
                                     qkv_bias, qk_scale, drop_rate, attn_drop_rate, drop_path_rate, norm_layer, depths,
                                     sr_ratios, block_cls)
        self.F4 = F4
        self.extra_norm = extra_norm
        if self.extra_norm:
            self.norm_list = nn.ModuleList()
            for dim in embed_dims:
                self.norm_list.append(norm_layer(dim))
        del self.pos_embeds
        del self.cls_token
        self.pos_block = nn.ModuleList(
            [PosCNN(embed_dim, embed_dim) for embed_dim in embed_dims]
        )
        self.apply(self._init_weights)

    def _init_weights(self, m):
        import math
        if isinstance(m, nn.Linear):
            trunc_normal_(m.weight, std=.02)
            if isinstance(m, nn.Linear) and m.bias is not None:
                nn.init.constant_(m.bias, 0)
        elif isinstance(m, nn.LayerNorm):
            nn.init.constant_(m.bias, 0)
            nn.init.constant_(m.weight, 1.0)
        elif isinstance(m, nn.Conv2d):
            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
            fan_out //= m.groups
            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
            if m.bias is not None:
                m.bias.data.zero_()
        elif isinstance(m, nn.BatchNorm2d):
            m.weight.data.fill_(1.0)
            m.bias.data.zero_()

    def no_weight_decay(self):
        return set(['cls_token'] + ['pos_block.' + n for n, p in self.pos_block.named_parameters()])

    def forward_features(self, x):
        outputs = list()

        B = x.shape[0]

        for i in range(len(self.depths)):
            x, (H, W) = self.patch_embeds[i](x)
            x = self.pos_drops[i](x)
            for j, blk in enumerate(self.blocks[i]):
                x = blk(x, H, W)
                if j == 0:
                    x = self.pos_block[i](x, H, W)
            if self.extra_norm:
                x = self.norm_list[i](x)
            x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()

            outputs.append(x)

        return outputs

    def forward(self, x):
        # 特征提取（这里调用ALTGVT的实现）
        x = self.forward_features(x)

        if self.F4:
            x = x[3:4]

        return x

PCPVT

class PCPVT(CPVTV2):
    def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256],
                 num_heads=[1, 2, 4], mlp_ratios=[4, 4, 4], qkv_bias=False, qk_scale=None, drop_rate=0.,
                 attn_drop_rate=0., drop_path_rate=0., norm_layer=nn.LayerNorm,
                 depths=[4, 4, 4], sr_ratios=[4, 2, 1], block_cls=SBlock, F4=False, extra_norm=False):
        super(PCPVT, self).__init__(img_size, patch_size, in_chans, num_classes, embed_dims, num_heads,
                                    mlp_ratios, qkv_bias, qk_scale, drop_rate, attn_drop_rate, drop_path_rate,
                                    norm_layer, depths, sr_ratios, block_cls, F4, extra_norm)

ALTGVT

class ALTGVT(PCPVT):
    def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256],
                 num_heads=[1, 2, 4], mlp_ratios=[4, 4, 4], qkv_bias=False, qk_scale=None, drop_rate=0.,
                 attn_drop_rate=0., drop_path_rate=0.2, norm_layer=nn.LayerNorm,
                 depths=[4, 4, 4], sr_ratios=[4, 2, 1], block_cls=GroupBlock, wss=[7, 7, 7],
                 F4=False, extra_norm=False, strides=(2, 2, 2)):
        super(ALTGVT, self).__init__(img_size, patch_size, in_chans, num_classes, embed_dims, num_heads,
                                     mlp_ratios, qkv_bias, qk_scale, drop_rate, attn_drop_rate, drop_path_rate,
                                     norm_layer, depths, sr_ratios, block_cls, F4)
        del self.blocks
        self.wss = wss
        self.extra_norm = extra_norm
        self.strides = strides
        if self.extra_norm:
            self.norm_list = nn.ModuleList()
            for dim in embed_dims:
                self.norm_list.append(norm_layer(dim))
        # transformer encoder
        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
        cur = 0
        self.blocks = nn.ModuleList()
        for k in range(len(depths)):
            _block = nn.ModuleList([block_cls(
                dim=embed_dims[k], num_heads=num_heads[k], mlp_ratio=mlp_ratios[k], qkv_bias=qkv_bias, qk_scale=qk_scale,
                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + i], norm_layer=norm_layer,
                sr_ratio=sr_ratios[k], ws=1 if i % 2 == 1 else wss[k]) for i in range(depths[k])])
            self.blocks.append(_block)
            cur += depths[k]

        if strides != (2, 2, 2):
            del self.patch_embeds
            self.patch_embeds = nn.ModuleList()
            s = 1
            for i in range(len(depths)):
                if i == 0:
                    self.patch_embeds.append(PatchEmbed(img_size, patch_size, in_chans, embed_dims[i]))
                else:
                    self.patch_embeds.append(
                        PatchEmbed(img_size // patch_size // s, strides[i - 1], embed_dims[i - 1], embed_dims[i]))
                s = s * strides[i - 1]

        self.apply(self._init_weights)

    def forward_features(self, x):
        outputs = list()

        B = x.shape[0]

        for i in range(len(self.depths)): #[2, 2, 10, 4]
            x, (H, W) = self.patch_embeds[i](x)
            x = self.pos_drops[i](x)
            for j, blk in enumerate(self.blocks[i]):
                x = blk(x, H, W)
                if j == 0:
                    x = self.pos_block[i](x, H, W)
            if self.extra_norm:
                x = self.norm_list[i](x)
            x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
            outputs.append(x)

        return outputs

Vit参数设置

class alt_gvt_small(ALTGVT):
    def __init__(self, **kwargs):
        super(alt_gvt_small, self).__init__(
            patch_size=4, embed_dims=[64, 128, 256, 512], num_heads=[2, 4, 8, 16], mlp_ratios=[4, 4, 4, 4], qkv_bias=True,
            norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[2, 2, 10, 4], wss=[7, 7, 7, 7], sr_ratios=[8, 4, 2, 1],
            extra_norm=True, drop_path_rate=0.2)


class alt_gvt_base(ALTGVT):
    def __init__(self, **kwargs):
        super(alt_gvt_base, self).__init__(
            patch_size=4, embed_dims=[96, 192, 384, 768], num_heads=[3, 6, 12, 24], mlp_ratios=[4, 4, 4, 4], qkv_bias=True,
            norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[2, 2, 18, 2], wss=[7, 7, 7, 7], sr_ratios=[8, 4, 2, 1],
            extra_norm=True, drop_path_rate=0.2)


class alt_gvt_large(ALTGVT):
    def __init__(self, **kwargs):
        super(alt_gvt_large, self).__init__(
            patch_size=4, embed_dims=[128, 256, 512, 1024], num_heads=[4, 8, 16, 32], mlp_ratios=[4, 4, 4, 4], qkv_bias=True,
            norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[2, 2, 18, 2], wss=[7, 7, 7, 7], sr_ratios=[8, 4, 2, 1],
            extra_norm=True, drop_path_rate=0.3)

MVS

入口函数

outputs = {}
outputs_stage = {}

if self.args['depth_type'] in ['ce', 'mixup_ce']:
    prob_maps = torch.zeros([B, H, W], dtype=torch.float32, device=imgs.device)
else:
    prob_maps = torch.empty(0)

######################### 深度估计 #########################

for stage_idx in range(len(self.ndepths)):  # ndepths=[32,16,8,4]
    # 内参和外参
    proj_matrices_stage = proj_matrices["stage{}".format(stage_idx + 1)]
    features_stage = features['stage{}'.format(stage_idx + 1)]
    B, V, C, H, W = features_stage.shape

    if stage_idx == 0:
        # 初始化深度平面
        if self.inverse_depth:
            # [B ndepth H W]
            depth_samples = init_inverse_range(depth_values, self.ndepths[stage_idx], imgs.device, imgs.dtype,
                                               H, W)
        else:
            depth_samples = init_range(depth_values, self.ndepths[stage_idx], imgs.device, imgs.dtype, H, W)
    else:
        # 更新深度初始化
        if self.inverse_depth:
            depth_samples = schedule_inverse_range(outputs_stage['depth'].detach(),
                                                   outputs_stage['depth_values'],  # 上一次的深度假设
                                                   self.ndepths[stage_idx],  # 如各阶段的深度样本数量为[32,16,8,4]
                                                   self.depth_interals_ratio[stage_idx], # [4.0,2.67,1.5,1.0]
                                                   H, W)  # B D H W
        else:
            depth_samples = schedule_range(outputs_stage['depth'].detach(), self.ndepths[stage_idx],
                                           self.depth_interals_ratio[stage_idx] * depth_interval, H, W)
    # depth_samples:[B,32,65,96]

    # 主要步骤：估计深度
    outputs_stage = self.fusions[stage_idx].forward(features_stage, proj_matrices_stage, depth_samples, tmp=tmp)
    outputs["stage{}".format(stage_idx + 1)] = outputs_stage

    if self.args['depth_type'] in ['ce', 'mixup_ce']:
        if (outputs_stage['photometric_confidence'].shape[1] != prob_maps.shape[1] or
                outputs_stage['photometric_confidence'].shape[2] != prob_maps.shape[2]):
            outputs_stage['photometric_confidence'] = F.interpolate(
                outputs_stage['photometric_confidence'].unsqueeze(1),
                [prob_maps.shape[1], prob_maps.shape[2]], mode="nearest").squeeze(1)
        prob_maps += outputs_stage['photometric_confidence']
    outputs.update(outputs_stage)

outputs['refined_depth'] = outputs_stage['depth']
if self.args['depth_type'] in ['ce', 'mixup_ce']:
    outputs['photometric_confidence'] = prob_maps / len(self.ndepths)

return outputs

MVS

class StageNet(nn.Module):
    def __init__(self, args, ndepth, stage_idx):
        super(StageNet, self).__init__()
        self.args = args
        self.fusion_type = args.get('fusion_type', 'cnn')
        self.ndepth = ndepth
        self.stage_idx = stage_idx

        in_channels = args['base_ch']
        if self.fusion_type == 'cnn':
            model_th = args.get('model_th', 8)
            self.vis = nn.Sequential(
                ConvBnReLU(1, 16),
                ConvBnReLU(16, 16),
                ConvBnReLU(16, 8),
                nn.Conv2d(8, 1, 1),
                nn.Sigmoid())
            if ndepth <= model_th:
                self.cost_reg = CostRegNet3D(in_channels, args['base_ch'])
            else:
                self.cost_reg = CostRegNet(in_channels, args['base_ch'])
        elif self.fusion_type == 'epipole':
            self.attn_temp = args.get('attn_temp', 2.0)
            self.cost_reg = CostRegNet2D(in_channels, args['base_ch'])
        elif self.fusion_type == 'epipoleV2':
            self.attn_temp = nn.Parameter(torch.tensor(1.0, dtype=torch.float32), requires_grad=True)
            self.cost_reg = CostRegNet3D(in_channels, args['base_ch'])
        else:
            raise NotImplementedError

    def forward(self, features, proj_matrices, depth_values, tmp=2.0):
        ref_feat = features[:, 0]  # [B,C,H,W]
        src_feats = features[:, 1:]  # [B,V,C,H,W]
        src_feats = torch.unbind(src_feats, dim=1)  # ([B,C,H,W],...)
        proj_matrices = torch.unbind(proj_matrices, 1)   # ([B,2,4,4],...)
        assert len(src_feats) == len(proj_matrices) - 1, "Different number of images and projection matrices"

        # step 1. feature extraction
        ref_proj, src_projs = proj_matrices[0], proj_matrices[1:]

        # step 2. differentiable homograph, build cost volume
        volume_sum = 0.0
        vis_sum = 0.0
        similarities = []
        with autocast(enabled=False):
            for src_feat, src_proj in zip(src_feats, src_projs):
                # warpped features
                src_feat = src_feat.to(torch.float32) #[B,C,H,W]
                # 投影矩阵的计算
                src_proj_new = src_proj[:, 0].clone() #[B,4,4]
                src_proj_new[:, :3, :4] = torch.matmul(src_proj[:, 1, :3, :3], src_proj[:, 0, :3, :4])
                ref_proj_new = ref_proj[:, 0].clone() #[B,4,4]
                ref_proj_new[:, :3, :4] = torch.matmul(ref_proj[:, 1, :3, :3], ref_proj[:, 0, :3, :4])
                # 特征的单应变换
                # depth_values:[B,32,H,W]
                warped_volume, proj_mask = homo_warping_3D_with_mask(src_feat, src_proj_new, ref_proj_new, depth_values)
                B, C, D, H, W = warped_volume.shape
                G = self.args['base_ch'] #8
                warped_volume = warped_volume.view(B, G, C // G, D, H, W) # 将src特征分成8组
                # 将ref特征也分成8组
                ref_volume = ref_feat.view(B, G, C // G, 1, H, W).repeat(1, 1, 1, D, 1, 1).to(torch.float32) #[B,G,8,32,H,W]
                # 计算特征相关，两个组的特征相关等于内积均值
                in_prod_vol = (ref_volume * warped_volume).mean(dim=2)  # [B,G,D,H,W]

                if not self.training:
                    similarity = F.normalize(ref_volume, dim=1) * F.normalize(warped_volume, dim=1) #[B,G,8,D,H,W]
                    similarity = similarity.mean(dim=2) #[B,G,D,H,W]
                    similarity = similarity.sum(dim=1) #[B,D,H,W]
                    similarities.append(similarity.unsqueeze(1))

                if self.fusion_type == 'cnn':
                    # 推理归一化的内积权重
                    sim_vol = in_prod_vol.sum(dim=1)  # [B,D,H,W]，特征相关求和
                    sim_vol_norm = F.softmax(sim_vol.detach(), dim=1) #[B,D,H,W]
                    # 通过归一化相关的熵来学习每个源视图的pixel-wise weight visibility
                    entropy = (- sim_vol_norm * torch.log(sim_vol_norm + 1e-7)).sum(dim=1, keepdim=True) #[B,1,H,W]
                    vis_weight = self.vis(entropy) #[B,1,H,W]
                elif self.fusion_type == 'epipole':
                    vis_weight = torch.softmax(in_prod_vol.sum(1) / self.attn_temp, dim=1) / math.sqrt(C)  # B D H W
                elif self.fusion_type == 'epipoleV2':
                    attn_score = in_prod_vol.sum(1) / torch.clamp(self.attn_temp, 0.1, 10.)  # [B,D,H,W]
                    attn_score = attn_score + (-10000.0 * proj_mask)
                    vis_weight = torch.softmax(attn_score, dim=1) / math.sqrt(G)  # B D H W
                else:
                    raise NotImplementedError
				
                volume_sum = volume_sum + in_prod_vol * vis_weight.unsqueeze(1) #[B,8,D,H,W]
                vis_sum = vis_sum + vis_weight

            # aggregate multiple feature volumes by variance
            volume_mean = volume_sum / (vis_sum.unsqueeze(1) + 1e-6)  # volume_sum / (num_views - 1)

        # step 3. cost volume regularization
        cost_reg = self.cost_reg(volume_mean)
        # volume_mean:[B,8,D,H,W] cost_reg:[B,1,D,H,W]
        prob_volume_pre = cost_reg.squeeze(1) #[B,D,H,W]
        prob_volume = F.softmax(prob_volume_pre, dim=1)

        # 下面执行深度回归
        if self.args['depth_type'] == 'ce' or self.args['depth_type'] == 'was':
            if type(tmp) == list:
                tmp = tmp[self.stage_idx]
            if self.training:
                _, idx = torch.max(prob_volume, dim=1)
                # vanilla argmax
                depth = torch.gather(depth_values, dim=1, index=idx.unsqueeze(1)).squeeze(1)
            else: # prob_volume_pre:[B,C,H,W], depth_values:[B,C,H,W]
                # regression (t) #[B,H,W]
                depth = depth_regression(F.softmax(prob_volume_pre * tmp, dim=1), depth_values=depth_values)
            # conf
            photometric_confidence = prob_volume.max(1)[0]  # [B,H,W]
        elif self.args['depth_type'] == 'mixup_ce':
            prob_left = prob_volume[:, :-1]  # [B,D-1,H,W]
            prob_right = prob_volume[:, 1:]  # [B,D-1,H,W]
            mixup_prob = prob_left + prob_right  # [B,D-1,H,W]
            photometric_confidence, idx = torch.max(mixup_prob, dim=1)  # [B,H,W]
            # 假设inverse depth range中间是线性的, 重归一化
            prob_left_right_sum = prob_left + prob_right + 1e-7
            prob_left_normed = prob_left / prob_left_right_sum
            prob_right_normed = prob_right / prob_left_right_sum
            mixup_depth = depth_values[:, :-1] * prob_left_normed + depth_values[:,
                                                                    1:] * prob_right_normed  # [B,D-1,H,W]
            depth = torch.gather(mixup_depth, dim=1, index=idx.unsqueeze(1)).squeeze(1)
        else:
            depth = depth_regression(prob_volume, depth_values=depth_values)
            if self.ndepth >= 32:
                photometric_confidence = conf_regression(prob_volume, n=4)
            elif self.ndepth == 16:
                photometric_confidence = conf_regression(prob_volume, n=3)
            elif self.ndepth == 8:
                photometric_confidence = conf_regression(prob_volume, n=2)
            else:
                photometric_confidence = prob_volume.max(1)[0]  # [B,H,W]

        outputs = {'depth': depth, 'prob_volume': prob_volume,
                   "photometric_confidence": photometric_confidence.detach(),
                   'depth_values': depth_values, 'prob_volume_pre': prob_volume_pre}

        if not self.training:
            try:
                similarities = torch.sum(torch.cat(similarities, dim=1), dim=1)
                sim_idx = torch.argmax(similarities, dim=1).unsqueeze(1)
                sim_depth = torch.gather(depth_values, index=sim_idx, dim=1).squeeze(1)
                outputs['sim_depth'] = sim_depth
            except:
                outputs['sim_depth'] = torch.zeros_like(depth)

        return outputs

特征的单应变换

def homo_warping_3D_with_mask(src_fea, src_proj, ref_proj, depth_values):
    # src_fea: [B, C, H, W]
    # src_proj: [B, 4, 4]
    # ref_proj: [B, 4, 4]
    # depth_values: [B, Ndepth] o [B, Ndepth, H, W]
    # out: [B, C, Ndepth, H, W]
    batch, channels = src_fea.shape[0], src_fea.shape[1]
    num_depth = depth_values.shape[1]
    height, width = src_fea.shape[2], src_fea.shape[3]

    with torch.no_grad():
        proj = torch.matmul(src_proj, torch.inverse(ref_proj)) # 用于将点从ref系变换到src系，Tsr = Tsw * (Trw)^(-1)
        rot = proj[:, :3, :3]  # [B,3,3]
        trans = proj[:, :3, 3:4]  # [B,3,1]
        # 参考视图像素点
        y, x = torch.meshgrid([torch.arange(0, height, dtype=torch.float32, device=src_fea.device),
                               torch.arange(0, width, dtype=torch.float32, device=src_fea.device)])
        y, x = y.contiguous(), x.contiguous()
        y, x = y.view(height * width), x.view(height * width)
        xyz = torch.stack((x, y, torch.ones_like(x)))  # [3, H*W]
        xyz = torch.unsqueeze(xyz, 0).repeat(batch, 1, 1)  # [B, 3, H*W]
        
        # 以下是单应变换的过程 https://zhuanlan.zhihu.com/p/363830541
        # 先旋转
        rot_xyz = torch.matmul(rot, xyz)  # [B, 3, H*W]，得到源视图下的像素坐标（未平移）
        # 再乘以深度，得到源视图下像素和深度xyd点（未平移），这里的旋转不会改变点的尺度。因为深度是单个数值，所以可以放在变换前或变换后
        rot_depth_xyz = rot_xyz.unsqueeze(2).repeat(1, 1, num_depth, 1) * depth_values.view(batch, 1, num_depth, -1)  # [B, 3, Ndepth, H*W]
        # 再把平移加上
        proj_xyz = rot_depth_xyz + trans.view(batch, 3, 1, 1)  # [B, 3, Ndepth, H*W]
        # 得到像素坐标
        proj_xy = proj_xyz[:, :2, :, :] / (proj_xyz[:, 2:3, :, :] + 1e-6)  # [B, 2, Ndepth, H*W]
        # 将像素坐标用做采样网格
        proj_x_normalized = proj_xy[:, 0, :, :] / ((width - 1) / 2) - 1
        proj_y_normalized = proj_xy[:, 1, :, :] / ((height - 1) / 2) - 1
        proj_xy = torch.stack((proj_x_normalized, proj_y_normalized), dim=3)  # [B, Ndepth, H*W, 2]
        grid = proj_xy

    # 计算mask
    X_mask = ((proj_x_normalized > 1) + (proj_x_normalized < -1)).detach()
    Y_mask = ((proj_y_normalized > 1) + (proj_y_normalized < -1)).detach()
    proj_mask = ((X_mask + Y_mask) > 0).view(batch, num_depth, height, width)
    z = proj_xyz[:, 2:3, :, :].view(batch, num_depth, height, width)
    proj_mask = (proj_mask + (z <= 0)) > 0
	
    # 进行采样，得到源视图的特征
    warped_src_fea = F.grid_sample(src_fea, grid.view(batch, num_depth * height, width, 2), mode='bilinear',
                                   padding_mode='zeros', align_corners=True)
    warped_src_fea = warped_src_fea.view(batch, channels, num_depth, height, width)

    return warped_src_fea, proj_mask