论文解读：On the Detection of Digital Face Manipulation（2020 CVPR)

一.创新点

1. 制作了一个综合的fakeface数据集，包括0.8M真实人脸和1.8M由不同方法生成的伪人脸。
2. 提出一种新颖的基于注意力的层，用于提高分类性能并产生指示被操纵的面部区域的注意力图。
3. 提出一种新的度量，称为IINC(Inverse Intersection Non-containment )，用于评估注意力图，产生比现有度量更一致的评估。

二.注意力机制

1.特点

1. 并行计算
2. 考虑了序列的前后关系
3. 参数共享

更多参考：综述—图像处理中的注意力机制_xys430381_1的专栏-CSDN博客_图像注意力机制

2.方法

1. 空间域（在H*W方向上）（本文采用）
2. 通道域（在Channel方向上）
3. 混合域

三、论文结构

1.主干网络：Xception

Xception是一种主干网络(Backbone)，在许多模型中放置在网络前端，用来提取特征图F。Xception包含三个主要模块：Entry flow, Middle flow 和 Exit flow。

1. Entry flow：这一模块包括最开始的两层普通卷积和三个可分离卷积块，其中每个可分离卷积块又包括两次可分离卷积，且第一次可分离卷积需要对Channel数调整，第二次可分离卷积后需要残差块处理。
2. Middle flow：这一模块为一个可分离卷积块重复八次，每个卷积快包括三次可分离卷积。
3. Exit flow：这一模块包括一个可分离卷积块和后续收尾操作：2*可分离卷积，全局平均池化，全连接等。
4. 注意力层：论文中提到：“We convert Xception-Net into our model by inserting the attention-based layer between Block 4 and Block 5 of the middle flow, and then fine-tune on DFFD training set.”即注意力层在Middle flow中第4个模块和第5个模块之间。

代码实现：

class SeparableConv2d(nn.Module):		#可分离卷积(整合了depthwise和pointwose卷积)
    def __init__(self, c_in, c_out, ks, stride=1, padding=0, dilation=1, bias=False):
        super(SeparableConv2d, self).__init__()
        self.c = nn.Conv2d(c_in, c_in, ks, stride, padding, dilation, groups=c_in, bias=bias)
        self.pointwise = nn.Conv2d(c_in, c_out, 1, 1, 0, 1, 1, bias=bias)

    def forward(self, x):
        x = self.c(x)
        x = self.pointwise(x)
        return x
    
class Block(nn.Module):				#基本块
    def __init__(self, c_in, c_out, reps, stride=1, start_with_relu=True, grow_first=True):
        """
        c_in:输入层channel数
        c_out:输出层channel数
        reps:一个Block中SeparableConv2d块的数量
        stride:卷积步长
        start_with_relu:是否为网络中的第一个Block
        grow_first：是否为网络中的最后一个Block
        """
        super(Block, self).__init__()

        self.skip = None
        self.skip_bn = None
        if c_out != c_in or stride != 1:	# 是否加入残差模块的条件判断
            self.skip = nn.Conv2d(c_in, c_out, 1, stride=stride, bias=False)
            self.skip_bn = nn.BatchNorm2d(c_out)

        self.relu = nn.ReLU(inplace=True)

        rep = []
        c = c_in
        # 如果是Block中的第一次卷积，就需要调整Channel数
        if grow_first:
            rep.append(self.relu)
            rep.append(SeparableConv2d(c_in, c_out, 3, stride=1, padding=1, bias=False))
            rep.append(nn.BatchNorm2d(c_out))
            c = c_out

        # 中间过程的卷积Channel数不变
        for i in range(reps - 1):
            rep.append(self.relu)
            rep.append(SeparableConv2d(c, c, 3, stride=1, padding=1, bias=False))
            rep.append(nn.BatchNorm2d(c))
		# 只有Exit flow中卷积块的最后一次卷积，Channel数扩充
        if not grow_first:
            rep.append(self.relu)
            rep.append(SeparableConv2d(c_in, c_out, 3, stride=1, padding=1, bias=False))
            rep.append(nn.BatchNorm2d(c_out))

        # 如果是第一个Block中的第一个卷积块,就需要去掉最开始的relu层，因为已经做过了
        if not start_with_relu:
            rep = rep[1:]
        else:
            rep[0] = nn.ReLU(inplace=False)

        if stride != 1:
            rep.append(nn.MaxPool2d(3, stride, 1))
        self.rep = nn.Sequential(*rep)

    def forward(self, inp):
        x = self.rep(inp)

        if self.skip is not None:
            y = self.skip(inp)
            y = self.skip_bn(y)
        else:
            y = inp

        x += y
        return x
    
# 主干网络(注意力层也夹在其中)
class Xception(nn.Module):
    """
  Xception optimized for the ImageNet dataset, as specified in
  https://arxiv.org/pdf/1610.02357.pdf
  """

    def __init__(self, maptype, templates, num_classes=1000):
        super(Xception, self).__init__()
        self.num_classes = num_classes
        
        
		# Entry flow
        self.conv1 = nn.Conv2d(3, 32, 3, 2, 0, bias=False)
        self.bn1 = nn.BatchNorm2d(32)
        self.relu = nn.ReLU(inplace=True)

        self.conv2 = nn.Conv2d(32, 64, 3, bias=False)
        self.bn2 = nn.BatchNorm2d(64)

        self.block1 = Block(64, 128, 2, 2, start_with_relu=False, grow_first=True)
        self.block2 = Block(128, 256, 2, 2, start_with_relu=True, grow_first=True)
        self.block3 = Block(256, 728, 2, 2, start_with_relu=True, grow_first=True)
        
        # Middle flow
        self.block4 = Block(728, 728, 3, 1, start_with_relu=True, grow_first=True)
        self.block5 = Block(728, 728, 3, 1, start_with_relu=True, grow_first=True)
        self.block6 = Block(728, 728, 3, 1, start_with_relu=True, grow_first=True)
        self.block7 = Block(728, 728, 3, 1, start_with_relu=True, grow_first=True)
        self.block8 = Block(728, 728, 3, 1, start_with_relu=True, grow_first=True)
        self.block9 = Block(728, 728, 3, 1, start_with_relu=True, grow_first=True)
        self.block10 = Block(728, 728, 3, 1, start_with_relu=True, grow_first=True)
        self.block11 = Block(728, 728, 3, 1, start_with_relu=True, grow_first=True)
        
        # Exit flow
        self.block12 = Block(728, 1024, 2, 2, start_with_relu=True, grow_first=False)

        self.conv3 = SeparableConv2d(1024, 1536, 3, 1, 1)
        self.bn3 = nn.BatchNorm2d(1536)

        self.conv4 = SeparableConv2d(1536, 2048, 3, 1, 1)
        self.bn4 = nn.BatchNorm2d(2048)

        self.last_linear = nn.Linear(2048, num_classes)

        if maptype == 'none':
            self.map = [1, None]
        elif maptype == 'reg':
            self.map = RegressionMap(728)
        elif maptype == 'tmp':
            self.map = TemplateMap(728, templates)
        elif maptype == 'pca_tmp':
            self.map = PCATemplateMap(728)
        else:
            print('Unknown map type: `{0}`'.format(maptype))
            sys.exit()

    def features(self, input):
        # Entry flow
        x = self.conv1(input)
        x = self.bn1(x)
        x = self.relu(x)

        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu(x)

        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        
        # Middle flow
        x = self.block4(x)
        x = self.block5(x)
        x = self.block6(x)
        x = self.block7(x)
        # attention-based layer
        mask, vec = self.map(x)
        x = x * mask
        x = self.block8(x)
        x = self.block9(x)
        x = self.block10(x)
        x = self.block11(x)
        
        # Exit flow
        x = self.block12(x)
        x = self.conv3(x)
        x = self.bn3(x)
        x = self.relu(x)

        x = self.conv4(x)
        x = self.bn4(x)
        return x, mask, vec

    def logits(self, features):
        x = self.relu(features)
        x = F.adaptive_avg_pool2d(x, (1, 1))
        x = x.view(x.size(0), -1)
        x = self.last_linear(x)
        return x

    def forward(self, input):
        x, mask, vec = self.features(input)
        x = self.logits(x)
        return x, mask, vec

2.注意力层

论文中给出了两种计算注意力层的方法，用于相互比较：1. MAM Map 2.Reg.Map。

1. MAM Map

全称Manipulation Appearance Model，是作者自己提出的一个结构。该结构包括一个可分离卷积块和一个全连接，以此来估计各个区域的权重$\alpha$。此时，$M_{att}=\overline{M}+A\cdot \alpha$，其中$\overline{M}$和$A$通过主成分分析(PCA)提取，将在后文介绍。

# MAM Map
class TemplateMap(nn.Module):
    def __init__(self, c_in, templates):
        super(TemplateMap, self).__init__()
        self.c = Block(c_in, 364, 2, 2, start_with_relu=True, grow_first=False)
        self.l = nn.Linear(364, 10)
        self.relu = nn.ReLU(inplace=True)

        self.templates = templates

    def forward(self, x):
        # 可分离卷积
        v = self.c(x)
        v = self.relu(v)
        # 适应性平均池化
        v = F.adaptive_avg_pool2d(v, (1, 1))
        v = v.view(v.size(0), -1)
        # 全连接
        v = self.l(v)
        mask = torch.mm(v, self.templates.reshape(10, 361))
        mask = mask.reshape(x.shape[0], 1, 19, 19)

        return mask, v

2.Reg. Map

这里采用Direct regression，通过一个可分离卷积和$Sigmoid$函数可以得到。

# Reg. Map
class RegressionMap(nn.Module):
    def __init__(self, c_in):
        super(RegressionMap, self).__init__()
        self.c = SeparableConv2d(c_in, 1, 3, stride=1, padding=1, bias=False)
        self.s = nn.Sigmoid()

    def forward(self, x):
        # 可分离卷积
        mask = self.c(x)
        # sigmoid
        mask = self.s(mask)
        return mask, None

3.PCA

在上文中，$M_{att}=\overline{M}+A\cdot \alpha$，其中$\overline{M}$和$A$通过主成分分析(PCA)提取。其数据来源于FaceApp计算的100个真实的manipulation masks。其提取结果如下(10个主成分)：

# PCA
class PCATemplateMap(nn.Module):
    def __init__(self, templates):
        super(PCATemplateMap, self).__init__()
        self.templates = templates

    def forward(self, x):
        fe = x.view(x.shape[0], x.shape[1], x.shape[2] * x.shape[3])
        fe = torch.transpose(fe, 1, 2)
        # 均值
        mu = torch.mean(fe, 2, keepdim=True)
        fea_diff = fe - mu

        cov_fea = torch.bmm(fea_diff, torch.transpose(fea_diff, 1, 2))
        B = self.templates.reshape(1, 10, 361).repeat(x.shape[0], 1, 1)
        D = torch.bmm(torch.bmm(B, cov_fea), torch.transpose(B, 1, 2))
        # 特征值和特征向量
        eigen_value, eigen_vector = D.symeig(eigenvectors=True)
        index = torch.tensor([9]).cuda()
        eigen = torch.index_select(eigen_vector, 2, index)

        v = eigen.squeeze(-1)
        mask = torch.mm(v, self.templates.reshape(10, 361))
        mask = mask.reshape(x.shape[0], 1, 19, 19)
        return mask, v

3.损失函数

样本共分为三种场景：supervised, weakly supervised 和 unsupervised。

但总的损失函数始终为：$\mathfrak{L}={\mathfrak{L}}_{\mathrm{c}\mathrm{l}\mathrm{a}\mathrm{s}\mathrm{s}\mathrm{i}\mathrm{f}\mathrm{i}\mathrm{e}\mathrm{r}}+\lambda \ast {\mathfrak{L}}_{\mathrm{m}\mathrm{a}\mathrm{p}}$
因此，损失函数也分三种情况讨论。

supervised: ${\mathfrak{L}}_{\mathrm{m}\mathrm{a}\mathrm{p}}=||{\mathrm{M}}_{att}-{\mathrm{M}}_{gt}||$

${\mathrm{M}}_{gt}$是真实图像，用全0矩阵表示。对于完全伪造的图像，则用全1矩阵表示。

weakly supervised:${\mathfrak{L}}_{\mathrm{m}\mathrm{a}\mathrm{p}}=\{\begin{array}{ll}|\mathrm{S}\mathrm{i}\mathrm{g}\mathrm{m}\mathrm{o}\mathrm{i}\mathrm{d}({\mathrm{M}}_{att})-0|,& \mathrm{i}\mathrm{f}\mathrm{r}\mathrm{e}\mathrm{a}\mathrm{l}\\ |\mathrm{m}\mathrm{a}\mathrm{x}(\mathrm{S}\mathrm{i}\mathrm{g}\mathrm{m}\mathrm{o}\mathrm{i}\mathrm{d}({\mathrm{M}}_{att}))-0.75|& \mathrm{i}\mathrm{f}\mathrm{f}\mathrm{a}\mathrm{k}\mathrm{e}\end{array}$

对于真实图像，这种损失可以使注意力机制对其不产生激活。对于伪造图像，其损失会保持足够大。

unsupervised：${\lambda }_m=0$

此时总损失仅通过分类损失得到。

四、其他细节

1.数据集

论文构造了一个数据集，包括真实图像和虚假图像。

真实图像主要通过FFHQ和CelebA数据集获得。

虚假图像的来源有以下几种：

1. 身份交换和表情修改：FaceBook++
2. 属性操作：通过StarGAN训练FaceApp的图像得到
3. 全脸合成：通过与预训练的PGGAN和StyleGAN得到

2.新的度量标准IINC

"IINC improves upon other metrics by measuring the non-overlap ratio of both maps, rather than their combined overlap, as in IoU. "即IINC相比于传统的IoU,除了考虑重叠的部分之外，还考虑了非重叠的部分。
$$IINC=\frac{1}{3-|\mathrm{U}|}\ast \{\begin{array}{ll}0& \mathrm{i}\mathrm{f}\overline{{\mathrm{M}}_{gt}}=0\mathrm{a}\mathrm{n}\mathrm{d}\overline{{\mathrm{M}}_{att}}=0\\ 1& \mathrm{i}\mathrm{f}\overline{{\mathrm{M}}_{gt}}=0\mathrm{x}\mathrm{o}\mathrm{r}\overline{{\mathrm{M}}_{gt}}=0\\ 2-\frac{|\mathrm{I}|}{{\mathrm{M}}_{att}}-\frac{|\mathrm{I}|}{{\mathrm{M}}_{gt}}& otherwise\end{array}$$
其中，U和I的含义与IoU中的定义相同，即Union和Intersection。

五、论文链接

pdf

code

dataset

2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)

最后

以上就是感动楼房为你收集整理的论文解读：On the Detection of Digital Face Manipulation（2020 CVPR)论文解读：On the Detection of Digital Face Manipulation（2020 CVPR)的全部内容，希望文章能够帮你解决论文解读：On the Detection of Digital Face Manipulation（2020 CVPR)论文解读：On the Detection of Digital Face Manipulation（2020 CVPR)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。