论文阅读：Robust High-Resolution Video Matting with Temporal Guidance

发表时间：2021年8月25日
项目地址：https://peterl1n.github.io/RobustVideoMatting/
论文地址：https://arxiv.org/pdf/2108.11515.pdf

我们介绍了一种鲁棒的，实时的，高分辨率的人体视频匹配方法，以实现了新的最先进的性能。我们的方法比以前的方法要轻得多，可以在Nvidia GTX 1080Ti GPU上以76 FPS处理4K和104 FPS处理HD。与大多数现有的将视频匹配逐帧作为独立图像的方法不同，我们的方法使用了一个循环架构来利用视频中的时间信息，并在时间相干性和匹配质量方面取得了显著的改进。此外，我们提出了一种新的训练策略，以加强我们的网络在匹配和分割目标。这大大提高了我们的模型的鲁棒性。我们的方法不需要任何辅助输入，如trimap或预先捕获的背景图像，因此它可以广泛应用于现有的人体匹配应用。
在这里插入图片描述

本文主要讲述了一个先进的抠图算法，其与语义分割存在细微差异，抠图算法还要多预测一个α参数，其实质上可以视为视频的实时语义分割。其所设计的网络结构支持时序数据训练，也支持单图训练。其训练流程比较繁琐，先基于短时序进行训练，然后再基于长时序进行训练。最终所设计的网络模型可以输出单个图片进行预测，也可以输入图片序列进行预测（这主要源于其网络结构的设计特点，针对不同的数据走不同的forword形式）。这种设计思路可以应用到视频分割中。
在这里插入图片描述

1. Introduction

Matting（抠图）是从输入帧预测前景目标和前景颜色的过程。在形式上，一帧图像I可以通过α系数被视为前景F和背景B的线性组合，通过提取α和F，我们可以将前景对象复合到一个新的背景中，实现背景替换效果。
$I = α F + (1 - α) B$

背景替换有许多实际应用。许多不断上升的用例，如视频会议和娱乐视频创作，都需要在没有绿屏道具的人体主题上进行实时的背景替换。神经模型用于解决这个具有挑战性的问题，但目前的解决方案并不总是健壮的，而且经常产生伪影。我们的研究重点是提高此类应用的匹配质量和鲁棒性。

大多数现有的方法[18,22,34]，尽管是为视频应用程序设计的，但都将单个帧处理为独立的图像。这些方法忽略了视频中最广泛使用的功能：时间信息。时间信息可以提高视频匹配性能。首先，它允许预测更连贯的结果，因为模型可以看到多个帧和它自己的预测。这显著地减少了闪烁，并提高了感知质量。其次，时间信息可以提高匹配的鲁棒性。在单个帧可能是模糊的情况下，例如前景的颜色类似于背景中经过的物体，模型可以通过参考前面的帧来更好地猜测边界。第三，时间信息允许模型随着时间的推移了解更多的背景信息。当相机移动时，由于视角的变化，被试者背后的背景就会被显示出来。即使相机是固定的，由于受试者的运动，被遮挡的背景仍然经常显示出来。更好地理解背景可以简化配对任务。因此，我们提出了一种循环架构来利用时间信息。我们的方法显著提高了抠图的质量和时间的相干性。它可以应用于所有的视频，而不需要任何辅助输入，如手动标注的trimap或预先捕获的背景图像。

此外，我们提出了一种新的训练策略，使我们的模型同时实现匹配和语义分割目标。大多数现有的方法都是在合成配对数据集上进行训练。这些样本通常看起来是假的，并不利于网络推广到真实的图像。[18,22]之前的工作曾尝试用在分割任务上训练的权值来初始化模型，但在拟合训练过程中，模型仍然过度拟合合成分布。其他人尝试对未标记的真实图像进行对抗性训练[34]或半监督学习[18]作为额外的适应步骤。我们认为，人类的交配任务与人类的分割任务密切相关。同时训练与分割目标可以有效地调节我们的模型，而不需要额外的自适应步骤。

我们的方法优于以前的最先进的方法，同时是更轻和更快的。我们的模型只使用了58%的参数，可以在Nvidia GTX 1080Ti GPU上处理4K 76 FPS和HD 104 FPS的实时高分辨率视频。

1、介绍了现有抠图算法的不足，主要指出对时序信息利用的不够完善。
2、基于语义分割与所提出的循环架构，提出一种方法，只使用了58%的参数，可以在Nvidia GTX 1080Ti GPU上处理4K 76 FPS和HD 104 FPS的实时高分辨率视频
3、指出大部分深度抠图算法，都是基于仿真数据进行训练的。

2. Related Works

介绍了现有的7类可用于抠图的算法

Trimap-based matting. 经典的（非学习的）算法[1,5,7,10,20,21,38]需要一个手动的Trimap注释来解决Trimap的未知区域。Wang和Cohen [43]在调查中回顾了这些方法。Xu等人[45]首先使用深度网络进行Trimap配对，最近的许多研究继续采用这种方法。FBA [9]是最新的产品之一。基于Trimap的方法通常是对象不可知的（不限于人类）。它们适用于交互式照片编辑应用程序，用户可以选择目标对象并提供手动指导。为了将其扩展到视频中，Sun等人提出了DVM [39]，它只需要在第一帧上进行Trimap标注，并可以将其传播到视频的其余部分。

Background-based matting. Soumyadip等人提出了背景匹配（BGM）[34]，它需要一个额外的预先捕获的背景图像作为输入。这些信息作为前景选择的一种隐含方式，并提高了交配的准确性。Lin和Ryabtsev等人进一步提出了BGMv2 [22]，提高了性能，注重实时高分辨率。然而，该方法不能处理动态背景和大的相机运动。

Segmentation 语义分割是为每个像素预测一个类标签，通常没有辅助输入。它的二值分割掩模可以用于定位目标，但直接使用它进行背景替换会产生强烈的伪影。尽管如此，分割任务类似于在无辅助环境下的匹配任务，而分割方面的研究启发了我们的网络设计。DeepLabV3 [3]提出了ASPP（空间空间金字塔池）模块，并在其编码器中使用扩展卷积来提高性能。这种设计已被许多作品采用，包括MobileNetV3 [15]，它将ASPP简化为LR-ASPP。

Auxiliary-free matting 没有任何辅助输入的全自动matting也被研究过。像[29,46]这样的方法可以用于任何前景物体，但不是那么健壮，而像[18,35,47]这样的方法则是专门为人类肖像而训练的。MODNet [18]是最新的肖像贴片方法。相比之下，我们的方法被训练成整个人体。

Video matting. 很少有神经匹配方法被设计用于视频原生。MODNet [18]提出了一种后处理技巧，通过比较相邻帧的预测来抑制闪烁，但它不能处理快速移动的身体部位，模型本身仍然对作为独立图像的帧进行操作。BGM [34]探索了将一些相邻的帧作为额外的输入通道，但这只提供了短期的时间线索，其影响并不是本研究的重点。DVM [45]是视频原生的，但专注于利用时间信息来传播三位映射注释。相反，我们的方法侧重于利用时间信息来提高席接质量在一个无辅助的设置。

Recurrent architecture. 递归神经网络已被广泛应用于序列任务中。其中两个最流行的架构是LSTM（长短期记忆）[13]和GRU（门控循环单元）[6]，它们也被用于视觉任务，如ConvLSTM [36]和ConvGRU [2]。先前的工作已经探索了在各种视频视觉任务中使用循环架构，并显示出比基于图像的对应的[42,28,41]更好的性能。我们的工作采用了循环架构来完成匹配任务。

High-resolution matting. PointRend [19]探索了基于patch的细分，BGMv2 [22]用于细分的细分。它只在选择性的patch上进行卷积。另一种方法是使用引导滤波器[11]，这是一种后处理滤波器，在高分辨率帧的指导下联合上采样低分辨率预测。深度引导滤波器（DGF）[44]是一种可学习的模块，可以用网络端到端进行训练，无需手动超参数。尽管基于过滤器的上采样功能较弱，但我们选择它是因为它更快，而且所有推理框架都有很好的支持。

3. Model Architecture

我们的架构包括一个提取单个帧特征的编码器，一个聚合时间信息的循环解码器，以及一个用于高分辨率上采样的深度引导滤波器模块。图2显示了我们的模型架构。
在这里插入图片描述

3.1. Feature-Extraction Encoder

我们的编码器模块遵循了最先进的语义分割网络[3,4,15]的设计，因为准确定位人类主体的能力是基本的 matting 任务。我们采用MobileNetV3-Large [15]作为我们的高效骨干，然后采用MobileNetV3提出的用于语义分割任务的LR-ASPP模块。值得注意的是，MobileNetV3的最后一块使用了扩展卷积，而没有下采样步幅。编码器模块在单个帧上进行操作，并在循环解码器的1/2 、1/4 、1/8 和1/16个尺度上提取特征。
在这里插入图片描述

3.2. Recurrent Decoder

出于几个原因，我们决定使用循环架构而不是注意力，或者简单地转发多个帧作为额外的输入通道。循环机制可以自己学习在连续的视频流中需要保留和忘记的信息，而其他两种方法必须依赖一个固定的规则来删除旧信息，并将每个设置间隔上的新信息插入到有限的内存池中。自适应地保持长期和短期时间信息的能力使循环机制更适合我们的任务。

我们的解码器采用多尺度的ConvGRU来聚合时间信息。我们选择ConvGRU是因为它的门比ConvLSTM更有参数效率。在形式上，ConvGRU的定义为：
$\begin{aligned} & z_{t}=\sigma(w_{zx}*x_{t}+w_{zh}*h_{t-1}+b_{z}) \\ &r_{t}=\sigma(w_{rx}*x_{t}+w_{rh}*h_{t-1}+b_{r}) &&(2) \\ &o_{t}=tanh(w_{ox}*x_{t}+w_{oh}*(r_{t}\odot h_{t-1})+b_{o}) \\ &h_{t}=z_{t}\odot h_{t-1}+(1-z_{t})\odot o_{t} \end{aligned}$

class ConvGRU(nn.Module):
    def __init__(self,
                 channels: int,
                 kernel_size: int = 3,
                 padding: int = 1):
        super().__init__()
        self.channels = channels
        self.ih = nn.Sequential(
            nn.Conv2d(channels * 2, channels * 2, kernel_size, padding=padding),
            nn.Sigmoid()
        )
        self.hh = nn.Sequential(
            nn.Conv2d(channels * 2, channels, kernel_size, padding=padding),
            nn.Tanh()
        )
        
    def forward_single_frame(self, x, h):
        r, z = self.ih(torch.cat([x, h], dim=1)).split(self.channels, dim=1)
        c = self.hh(torch.cat([x, r * h], dim=1))
        h = (1 - z) * h + z * c
        return h, h
    
    def forward_time_series(self, x, h):
        o = []
        for xt in x.unbind(dim=1):
            ot, h = self.forward_single_frame(xt, h)
            o.append(ot)
        o = torch.stack(o, dim=1)
        return o, h
        
    def forward(self, x, h: Optional[Tensor]):
        if h is None:
            h = torch.zeros((x.size(0), x.size(-3), x.size(-2), x.size(-1)),
                            device=x.device, dtype=x.dtype)
        
        if x.ndim == 5:
            return self.forward_time_series(x, h)
        else:
            return self.forward_single_frame(x, h)

其中符号∗和 $\odot$ 分别表示卷积和元素级积；tanh和σ分别表示双曲切函数和s型函数。w和b是卷积核和偏差项。隐藏状态ht被用作下一个时间步的输出和循环状态，即ht−1。初始循环状态h0是一个全零张量。
在这里插入图片描述

如图2所示，我们的解码器由瓶颈块、上采样块和输出块组成.
Bottleneck block 在LR-ASPP模块之后进行1/16下采样操作。ConvGRU层通过分裂和连接只在一半的通道上操作。这大大减少了参数和计算，因为ConvGRU在计算上是可扩展的。

class BottleneckBlock(nn.Module):
    def __init__(self, channels):
        super().__init__()
        self.channels = channels
        self.gru = ConvGRU(channels // 2)
        
    def forward(self, x, r: Optional[Tensor]):
        a, b = x.split(self.channels // 2, dim=-3)
        b, r = self.gru(b, r)
        x = torch.cat([a, b], dim=-3)
        return x, r

Upsampling block 在1/8 、1/4 和1/2 的尺度上重复。首先，连接前一个块的双早期上采样输出、编码器对应尺度的特征图和重复2×2平均池化下采样的输入图像。然后，采用卷积后的批量归一化[16]和ReLU [26]激活来进行特征合并和信道缩减。最后，通过分割和连接，将ConvGRU应用于一半的通道。

class UpsamplingBlock(nn.Module):
    def __init__(self, in_channels, skip_channels, src_channels, out_channels):
        super().__init__()
        self.out_channels = out_channels
        self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels + skip_channels + src_channels, out_channels, 3, 1, 1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(True),
        )
        self.gru = ConvGRU(out_channels // 2)

    def forward_single_frame(self, x, f, s, r: Optional[Tensor]):
        x = self.upsample(x)
        x = x[:, :, :s.size(2), :s.size(3)]
        x = torch.cat([x, f, s], dim=1)
        x = self.conv(x)
        a, b = x.split(self.out_channels // 2, dim=1)
        b, r = self.gru(b, r)
        x = torch.cat([a, b], dim=1)
        return x, r
    
    def forward_time_series(self, x, f, s, r: Optional[Tensor]):
        B, T, _, H, W = s.shape
        x = x.flatten(0, 1)
        f = f.flatten(0, 1)
        s = s.flatten(0, 1)
        x = self.upsample(x)
        x = x[:, :, :H, :W]
        x = torch.cat([x, f, s], dim=1)
        x = self.conv(x)
        x = x.unflatten(0, (B, T))
        a, b = x.split(self.out_channels // 2, dim=2)
        b, r = self.gru(b, r)
        x = torch.cat([a, b], dim=2)
        return x, r
    
    def forward(self, x, f, s, r: Optional[Tensor]):
        if x.ndim == 5:
            return self.forward_time_series(x, f, s, r)
        else:
            return self.forward_single_frame(x, f, s, r)

Output block 不使用ConvGRU，因为我们发现它在这个规模上很广泛，没有影响。该块只使用规则的卷积来细化结果。它首先连接输入图像和前一个块的双上采样输出。然后使用2个重复卷积、批处理归一化和ReLU堆栈来生成最终的隐藏特征。最后，将这些特征投影到输出中，包括1通道alpha预测、3通道前景预测和1通道分割预测。分割输出用于分割训练目标，如后面的第4节所述。

class OutputBlock(nn.Module):
    def __init__(self, in_channels, src_channels, out_channels):
        super().__init__()
        self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
        self.conv = nn.Sequential(
            nn.Conv2d(in_channels + src_channels, out_channels, 3, 1, 1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(True),
            nn.Conv2d(out_channels, out_channels, 3, 1, 1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(True),
        )
        
    def forward_single_frame(self, x, s):
        x = self.upsample(x)
        x = x[:, :, :s.size(2), :s.size(3)]
        x = torch.cat([x, s], dim=1)
        x = self.conv(x)
        return x
    
    def forward_time_series(self, x, s):
        B, T, _, H, W = s.shape
        x = x.flatten(0, 1)
        s = s.flatten(0, 1)
        x = self.upsample(x)
        x = x[:, :, :H, :W]
        x = torch.cat([x, s], dim=1)
        x = self.conv(x)
        x = x.unflatten(0, (B, T))
        return x
    
    def forward(self, x, s):
        if x.ndim == 5:
            return self.forward_time_series(x, s)
        else:
            return self.forward_single_frame(x, s)

我们发现应用ConvGRU是有效的。这种设计有助于ConvGRU专注于聚合时间信息，而另一个分割分支则转发特定于当前帧的空间特征。所有的卷积都使用3个×3内核，除了最后一个投影使用1×1的内核。

我们修改了我们的网络，使它可以立即给出T帧作为输入，每一层在传递到下一层之前处理所有的T帧。在训练过程中，这允许批处理标准化跨批处理和时间计算统计信息，以确保标准化是一致的。在推理过程中，T=1可以用于处理实时视频，而T>1可以用于利用来自非循环层的更多GPU并行性，作为一种批处理形式。我们的循环译码器是单向的，所以它可以用于实时流媒体和后处理。

3.3. Deep Guided Filter Module

我们采用[44]中提出的深度引导滤波器（DGF）来进行高分辨率预测。当处理4K和HD等高分辨率视频时，我们在通过编码器-解码器网络之前，将输入帧降采样s倍。然后将低分辨率的alpha、前景、最终的隐藏特征以及高分辨率的输入帧提供给DGF模块，以产生高分辨率的alpha和前景。如第4节所述，对整个网络进行端到端训练。请注意，DGF模块是可选的，如果要处理的视频的分辨率较低，编码器解码器网络可以独立操作。

我们的整个网络不使用任何特殊的操作符，并且可以部署到大多数现有的推理框架中。更多的构建细节在补充资料中。

4. Training

我们建议同时用匹配和语义分割目标来训练我们的网络，原因有几个：

首先，人类匹配任务与人类分割任务密切相关。与基于trimap和基于背景的交配方法不同，后者被给予额外的线索作为输入，我们的网络必须学习从语义上理解场景，并在定位人类受试者时具有鲁棒性。
其次，大多数现有的匹配数据集只提供地面真实的阿尔法和前景，必须综合合成到背景图像。由于前景和背景有不同的灯光，这些作品有时看起来是假的。另一方面，语义分割数据集以真实图像为特征，其中人体主体被包含在所有类型的复杂场景中。使用语义分割数据集进行训练可以防止我们的模型对合成分布的过拟合。
第三，有更多的训练数据可用用于语义分割任务。我们收集了各种公共可用的数据集，包括基于视频的和基于图像的，以训练一个稳健的模型。

4.1. Matting Datasets

我们的模型在VideoMatte240K（VM）[22]、646646（D646）[30]和Adobe图像匹配（AIM）[45]数据集上进行训练。VM提供484 4K/高清视频剪辑。我们将数据集划分为475/4/5个片段进行train/val/test分割。D646和AIM是图像匹配数据集。我们只使用人类的图像，并将它们组合成420/15的train/val分割来进行训练。对于评估，D646和AIM分别分别提供11张和10张测试图像。

对于背景，[39]的数据集提供了适合拼接组合的高清背景视频。这些视频包括各种动作，比如汽车经过、树叶摇晃和摄像机的动作。我们选择了3118个不包含人类的剪辑，并从每个剪辑中提取前100帧。我们还按照[22]的方法获取了8000个图像背景。这些图片有更多的室内场景，如办公室和客厅。

我们在前景和背景上应用运动和时间增强来增加数据的多样性。运动增强包括仿射平移、缩放、旋转、透明、亮度、饱和度、对比度、色调、噪声和模糊，这些都随时间不断变化。该运动采用了不同的放松函数，这样的变化并不总是线性的。增强还为图像数据集增加了人工运动。此外，我们在视频上应用时间增强，包括剪辑反转、速度变化、随机暂停和帧跳跃。其他离散的增强，即水平翻转、灰度和锐化，都一致地应用于所有帧。

4.2. Segmentation Datasets

我们使用视频分割数据集YouTubeVIS，并选择了2985个包含人类的剪辑。我们还使用了图像分割数据集COCO [23]和SPD [40]。COCO提供了64,111张包含人类的图像，而SPD提供了额外的5711个样本。我们应用了类似的增强，但没有运动，因为YouTubeVIS已经包含了大的相机运动，而图像分割数据集不需要运动增强。

4.3. Procedures

我们的训练训练流水线分为四个阶段。它们的设计是为了让我们的网络逐步看到更长的序列和更高的分辨率，以节省训练时间。我们使用Adam优化器来进行训练。所有阶段使用批大小B = 4，跨越4个Nvidia V100 32Ggpu。

阶段一 我们首先在没有DGF模块的情况下，在低分辨率的VM上训练了15个时代。我们设置了一个短序列长度T = 15帧，以便网络可以更快地更新。MobileNetV3主干使用预先训练的ImageNet [32]权重初始化，并使用1e−4的学习率，而网络的其余部分使用2e−4。我们在256到512像素之间独立采样输入分辨率高度h和宽度w。这使得我们的网络对不同的分辨率和纵横比具有鲁棒性。

阶段二 我们将T增加到50帧，将学习率降低一半，并保留第1阶段的其他设置，并多训练2个epoch。这使得我们的网络可以看到更长的序列，并学习长期的依赖关系。T = 50是我们能训练的最长的版本。

阶段三 我们附加了DGF模块，并在VM上用高分辨率样本进行了1次的训练。由于高分辨率消耗了更多的GPU内存，因此序列长度必须设置为非常短。为了避免我们的循环网络对非常短序列的过拟合，我们在低分辨率长序列和高分辨率短序列上训练我们的网络。具体来说，低分辨率通道不采用DGF，并具有T = 40和h，w∼（256,512）。高分辨率通道需要低分辨率通道，并采用DGF与下采样因子s=0.25，Tˆ=6和ˆh，ˆw∼（1024,2048）。我们将DGF的学习速率设置为2e−4，将网络的其余部分设置为1e−5。

阶段四 我们在D646和AIM的组合数据集上进行了5个epoch的训练。我们将解码器学习率提高到5e−5，以让我们的网络适应并保持阶段3的其他设置

Segmentation 我们的分割训练是交错在每一次matting训练迭代之间的。我们对网络进行每次奇次迭代后的图像分割数据训练，以及每次偶次迭代后的视频分割数据进行训练。分割训练适用于所有阶段。对于视频分割数据，我们在每个匹配阶段之后使用相同的B，T，h，w设置。对于图像分割数据，我们将它们视为只有1帧的视频序列，所以T= 1。这给了我们空间来应用一个更大的批量尺寸B0 = B×T。由于图像作为第一帧被转发，即使在没有循环信息的情况下，它也迫使分割是鲁棒的。

4.4. Losses

我们对所有的t∈[1，T]帧应用损失。学习alpha $α_t$ 地面真相 $α_t∗$ ，我们使用L1损失 $L^α_{l1}$ 和金字塔拉普拉斯损失 $L^α_{lap}$ ，如[9,14]报道的，以产生最好的结果。我们还应用了[39]所使用的时间相干损失 $L^α_{tc}$ 来减少闪烁：
$\mathcal{L}_{l1}^{\alpha}=\|\alpha_{t}-\alpha_{t}^{*}\|_{1} \\ \mathcal{L}_{lap}^{\alpha}=\sum_{s=1}^{5}\frac{2^{s-1}}{5}\|L_{pyr}^{s}(\alpha_{t})-L_{pyr}^{s}(\alpha_{t}^{*})||_{1} \\\ \mathcal{L}_{tc}^{\alpha}=||\frac{\mathrm{d}\alpha_{t}}{\mathrm{d}t}-\frac{\mathrm{d}\alpha_{t}^{*}}{\mathrm{d}t}||_{2}$

学习前景Ft,地面真相Ft∗，我们计算L1损失 $L^F_{l1}$ 和时间相干损失 $L^F_{tc}$ ，其中 $α_t^∗$ >0遵循[22]的方法
$\begin{aligned}\mathcal{L}_{l1}^F&=\|(a_t^*>0)*(F_t-F_t^*)\|_1\\\\\mathcal{L}_{tc}^F&=\|(a_t^*>0)*(\frac{\mathrm{d}F_t}{\mathrm{d}t}-\frac{\mathrm{d}F_t^*}{\mathrm{d}t})\|_2\end{aligned}$

总体的loss如下所示：
$\mathcal{L}^{M}=\mathcal{L}_{l1}^{\alpha}+\mathcal{L}_{lap}^{\alpha}+5\mathcal{L}_{tc}^{\alpha}+\mathcal{L}_{l1}^{F}+5\mathcal{L}_{tc}^{F}$
对于语义分割，我们的网络只在人类类别上进行训练。来学习分割概率St地面真二进制标签St∗，我们计算二进制交叉熵损失如下：
$\begin{aligned}\mathcal{L}^S=S_t^*(-\log(S_t))+(1-S_t^*)(-\log(1-S_t))\end{aligned}$

5. Experimental Evaluation

5.1. Evaluation on Composition Datasets

我们通过将来自VM、D646和AIM数据集中的每个测试样本组合到5个视频和5个图像背景上来构建我们的基准测试。每个测试剪辑都有100帧。对图像样本进行了运动增强处理。

我们将我们的方法与最先进的基于trimap的方法（FBA [9]）、基于背景的方法（BGMv2 [22] with MobileNetV2 [33]主干）和无辅助的方法（MODNet [18]）进行了比较。为了公平地比较它们的全自动匹配，FBA使用了由语义分割方法DeepLabV3 [3]与ResNet101 [12]骨干生成的合成三分图；BGMv2只看到第一帧的地面真实背景；MODNet应用它的邻居帧平滑技巧。我们试图用我们的数据重新训练MODNet，但得到了更糟糕的结果，可能是由于训练过程中的问题，所以MODNet使用了它的官方权重；BGMv2已经在所有三个数据集上进行了训练；FBA还没有发布训练代码。

我们使用MAD（平均绝对差值）、MSE（均方误差）、Grad（空间梯度）[31]和Conn（连通性）[31]对α和地面真实α∗进行质量分析，并采用dtSSD [8]进行时间相干性分析。对于F，我们只通过MSE测量α∗>0中的像素。MAD和MSE按1e-3缩放，dtSSD按1e-2缩放，以获得更好的可读性。F不在VM上测量，因为它包含有噪声的地面真相。MODNet不预测F，所以我们评估输入帧作为其前景预测。这模拟了直接在输入上应用alpha哑光。

表1比较了使用低分辨率输入的方法。在这个场景中，我们的方法不使用DGF。我们在所有数据集上预测了更准确和一致的alpha。特别是，FBA受到不准确的合成trimap的限制。BGMv2在动态背景下表现较差。MODNet产生的结果不如我们的准确和一致。在前景预测方面，我们的预测落后于BGMv2，但表现优于FBA和MODNet。
在这里插入图片描述

表2进一步比较了我们的方法与MODNet在高分辨率上的方法。由于DGF必须通过网络端到端训练，因此我们修改了MODNet，使用非学习的快速引导滤波器（FGF）来对预测进行上采样。两种方法都使用降采样尺度的= 0.25作为编码解码器网络。我们删除了Conn度量，因为它在高分辨率上计算量扩展较多。我们的方法在所有指标上都优于MODNet。
在这里插入图片描述

5.2. Evaluation on Real Videos

图3显示了对真实视频的定性比较。在图3a中，我们比较了所有方法的alpha预测，发现我们的预测的细粒度细节，比如头发线更准确。在图3b中，我们在随机的YouTube视频上进行了实验。我们从比较中删除了BGMv2，因为这些视频没有预先捕获的背景。我们发现我们的方法对语义错误更有鲁棒性。在图3c和图3d中，我们进一步比较了在手机和网络摄像头视频上的实时匹配和MODNet。我们的方法比MODNet能更好地处理快速移动的身体部位。
在这里插入图片描述

5.3. Size and Speed Comparison

表3和表4显示，与MODNet相比，我们的方法明显更轻，只有58%的参数。我们的版本是高清版本上最快的（1920×1080），但比512×288上的BGMv2和4K上的FGF的MODNet（3840×2160）稍慢。我们的检查发现，DGF和FGF在性能上有非常小的差异。我们的方法在4K中比MODNet慢，因为我们除了预测alpha之外还预测前景，所以在高分辨率下处理3个额外的通道更慢。我们使用[37]来测量GMACs（乘法累积运算），但它只测量卷积，忽略了DGF和FGF中最常用的调整大小和许多张量运算，所以GMACs只是一个粗略的近似。我们的方法实现了HD 104 FPS和4K 76 FPS，这被许多应用认为是实时的。
在这里插入图片描述

6. Ablation Studies

6.1. Role of Temporal Information

图4显示了所有VM测试剪辑的平均alpha MAD度量随时间的变化。我们的模型的误差在前15帧显著下降，然后度量保持稳定。MODNet，即使是它的邻居frame平滑技巧，在度量中有很大的波动。我们还通过传递零张量作为递归状态来实验禁用网络中的递归。质量和一致性如预期的那样恶化。这证明了时间信息提高了质量和一致性。
在这里插入图片描述

图5比较了在一个视频样本上与MODNet的时间相干性。我们的方法在扶手区域产生一致的结果，而MODNet产生闪烁，这显著降低了感知质量。有关更多的结果，请参阅我们的补充资料。
在这里插入图片描述

我们进一步研究了循环隐藏状态。在图6中，我们发现我们的网络已经自动学会了重建随着时间的推移而显示的背景，并将这些信息保存在其循环通道中，以帮助未来的预测。它还使用其他循环通道来跟踪运动历史。我们的方法甚至试图重建背景，当视频包含摄像机的运动时，并且能够在镜头切割时忘记无用的记忆。更多的例子在补充部分中。
在这里插入图片描述

6.2. Role of Segmentation Training Objective

表5显示，当在包含人类的COCO验证图像子集上和仅在人类类别上进行评估时，我们的方法与语义分割方法一样具有鲁棒性。我们的方法达到了61.50 mIOU，考虑到模型大小的差异，这在MobileNetV3和COCO训练的DeepLabV3的性能之间。我们还试图通过阈值化α > 0.5作为二进制掩模来评估我们的alpha输出的稳健性，我们的方法仍然达到60.88 mIOU，表明alpha预测也是稳健的。为了进行比较，我们通过初始化我们的MobileNetV3编码器和LR-ASPP模块，对COCO预权重并去除分割目标。该模型与合成拟合数据过拟合，对COCO性能有显著回归，仅达到38.24 mIOU。
在这里插入图片描述

6.3. Role of Deep Guided Filter

表6显示，与FGF相比，DGF在大小和速度上只有很小的开销。DGF有一个更好的Grad度量，这表明它的高分辨率细节更准确。DGF也产生了由dtSSD度量显示的更一致的结果，可能是因为它考虑了循环解码器的隐藏特征。MAD和MSE指标是不确定的，因为它们是由分段级错误，没有被DGF或FGF纠正。
在这里插入图片描述

6.4. Static vs. Dynamic Backgrounds

表7比较了在静态背景和动态背景下的性能。动态背景包括背景对象运动和照相机运动。我们的方法可以处理这两种情况，并且在静态背景上表现得稍好一些，这可能是因为它更容易重建像素对齐的背景，如图6所示。另一方面，BGMv2在动态背景下表现不佳，而MODNet也没有表现出任何偏好。在度量方面，BGMv2在静态背景上的表现优于我们的背景，但当预先捕获的背景出现错位时，它预计会表现得更糟。
在这里插入图片描述