Zhangzhe's Blog

URL

• https://arxiv.org/pdf/1705.08690.pdf

TL;DR

• 本文提出一种学者模型用于处理持续学习问题，依次训练每个任务，每个任务都有一个学者模型，每个学者模型包括一个生成器和一个求解器
• 生成器的作用是生成与 旧任务 真实样本同分布的样本
• 求解器的作用是求解任务
• 二者分开训练

Algorithm

网络结构

• 根据 task 顺序训练 学者模型。
• 训练新任务生成器时，新任务生成器负责 模仿新任务的真实数据和旧任务的生成器数据，这里的生成器实际上是指一整个 GAN，可以对抗学习来模拟样本分布。
• 训练新任务的求解器时，求解器会映射 x -> y，这里的 x 来自第 i 个任务的真实样本和第 i-1 个任务的生成样本，生成样本的 label 来自于第 i-1 个任务的求解器的输出。

Loss 设计

• loss
  $L_{train}(\theta_i) = r\mathbb{E}_{(x,y) \sim D_i}[L(S(x;\theta_i), y)] + (1-r)\mathbb{E}_{x' \sim G_{i-1}}[L(S(x';\theta_i), S(x';\theta_{i-1}))]$
  其中，$D_i$ 表示第 i 个任务的数据，$G_{i-1}$ 表示第 i-1 个任务的数据生成器。
  $L_{test}(\theta_i) = r\mathbb{E}_{(x,y) \sim D_i}[L(S(x;\theta_i), y)] + (1-r)\mathbb{E}_{(x,y) \sim D_{past}}[L(S(x;\theta_i), y)]$
  其中，$D_{past}$ 表示过去数据的积累分布

Thought

• 感谢 GAN，感恩 Ian Goodfellow

URL

• paper: https://arxiv.org/pdf/1606.09282.pdf

TL;DR

• 本文将一个增量学习任务的网络结构拆分成三个部分：
  • backbone
  • 旧任务相关参数
  • 新任务相关参数
• 所有增量学习都需要：
  • 使用原始 backbone（可微调）
  • 随机初始化新任务相关参数
• 在此基础上增量学习常用的解决灾难式遗忘的方法有：
  • Fine-tuning：在 新任务数据集 上 冻结旧任务相关参数，Fine-tuning backbone 以及新任务相关参数，如上图 b 所示
  • Feature Extraction：在 新任务数据集 上 冻结 backbone 以及旧任务相关参数，只训练新任务相关参数，（与 b 不同的地方在于 是否冻结 backbone），如上图 c 所示
  • Joint Training：在 所有任务数据集上 上 Fine-tuning 所有参数（backbone、新任务相关参数、旧任务相关参数），（与 b 不同的地方在于 是否使用所有任务数据，以及是否 fine-tuning 旧任务相关参数），如上图 d 所示
  • Learning without Forgetting：在 新任务数据集 上 Fine-tuning 所有参数（backbone、新任务相关参数、旧任务相关参数），如上图 e 所示，（与 d 不同的地方在于 使用的训练数据不同），这种方法使用的标签包括：
    • 硬标签：新任务数据的 原始标签
    • 软标签：新任务数据在旧模型上的 输出分布，目的是：使得网络在训练新任务时，尽可能保持旧任务上的分布
      Joint Training 因为用到所有数据同时训练，所以通常被认为是增量学习的算法效果上界

Algorithm

• LwF 算法会修改所有参数：
  • backbone
  • 新任务相关参数
  • 旧任务相关参数（这个很重要！）
• LwF 损失函数中各参数的含义：
  • $\theta_s,\theta_s^\star,\hat{\theta_s}$ 分别表示：backbone 原始参数、backbone 在所有任务上的最优参数、backbone 训练中的临时参数
  • $\theta_o,\theta_o^\star,\hat{\theta_o}$ 分别表示：旧任务相关参数原始参数、旧任务相关参数在所有任务上的最优参数、旧任务相关参数训练中的临时参数
  • $\theta_n,\theta_n^\star,\hat{\theta_n}$ 分别表示：新任务相关参数原始参数、新任务相关参数在所有任务上的最优参数、新任务相关参数训练中的临时参数
  • $\lambda_o$ 表示：旧任务重要程度权重

Experiment

比 Fine-tuning、Feature Extraction、Joint Training 都强

Thought

• 使用一种类似蒸馏的方法，使用新数据 + 旧模型的方法 replay 旧数据，看起来挺 make sense

URL

• paper: https://arxiv.org/pdf/1904.07734.pdf
• code: https://github.com/GMvandeVen/continual-learning

TL;DR

• 本文将增量学习细分为三种场景：
  • 训练阶段：所有场景在训练阶段都一样，Task 1、Task 2、… 、Task T 一个接一个训练
  • 预测阶段
    • task-incremental learning (Task-IL)：测试阶段会指明是哪个 task，常用的结构是 Multi-head 每个任务独占一个 head，所有任务共享 backbone，但 Multi-head 和 Single-head 网络结构不能决定增量学习场景，只是一种常用的结构。
    • domain-incremental learning (Domain-IL)：测试阶段不指明是哪个 task，网络也无需推测输入属于哪一个 task，常用的网络结构是 Single-head。
    • class-incremental learning (Class-IL)：网络需要推测输入属于哪个 task，并且输出这个任务中的哪一类。

Algorithm

• 本文的三种增量学习的对比实验所用实验策略有两个：
  • MNIST 数据分类：一共 5 个 task，每个 task 分类 2 种数字，细节如上图所示。
  • Permuted MNIST 数据分类：一共 10 个 task，每个 task 分类 一种固定 shuffle 方式 的 10 种 MNIST 数字数据，细节如下图所示：
    

增量学习常用策略

• 任务独占组件：在每个任务上训练单独的组件，在 inference 时根据给定的 task 选择组件。只适用于 Task-IL，例如 XdG 算法。
• 正则优化：在每个任务上训练单独的组件，但在 inference 时由于 task 不可知，所以使用整个网络 inference。训练时加入正则化项，使得网络在新任务中的参数与旧任务参数接近，常用的算法有：EWC、Online-EWC、SI 等。
• 修改训练数据：又被称为 replay 方法，即通过某种方法将之前任务的数据（或伪数据）补充到新的训练任务中，例如：
  • Learning without Forgetting 方法（LwF），这种方法将新任务输入数据在旧模型中的输出分布作为软标签伪数据，与新数据的数据一起在旧模型上 fine-tunning，最终得到新模型，利用了类似 知识蒸馏 的方法。
  • Deep Generative Replay 方法（DGR），这种方法和 LwF 都属于使用 数据重放（data replay） 来实现增量学习的算法，不同之处在于，DGR 使用的是使用样本生成的方法直接生成旧任务的样本，使用硬标签训练，而不是使用新任务数据在旧模型上的软标签进行蒸馏。
  • 或者使用 DGR + LwF 的方法，用 DGR 生成与旧任务数据同分布的数据并使用 LwF 方法蒸馏。
• 使用范例数据：例如 iCaRL 类别增量学习算法，保存一部分旧类别数据的典型样本，每次和新类别数据一起更新表征，再根据新表征更新旧任务典型样本。

增量学习的算法上下界

• 增量学习的算法上界（joint training）：所有任务的训练数据可以一次性拿到，同时训练所有任务。
• 增量学习的算法下界（fine-tuning）：不使用任何优化，每次新任务都只使用新任务的数据对旧模型进行训练。

Experiment

实验设置

• 输出单元设置：为了公平比较，所有方法都使用相同的输出单元。split MNIST 使用２个隐藏层实现，每层 400 节点。permuted MNIST 使用２个隐藏层实现，每层 1000 节点。激活函数使用 ReLU，除了 iCaRL 之外，其他模型最后一层都是 softmax 输出层。
• iCaRL 只能用于类增量学习，任务增量和域增量不可以。
• Task-IL 实验设置：所有算法都使用 Multi-head Output Layer 结构，每个任务都有一个指定的输出单元，对于任务 $T_a$，只有对应的输出单元 $O_a$ 被使用，其他任务对应的输出单元不被使用。
• Domain-IL 实验设置：所有算法都使用 Single-head Output Layer 结构，只有一个输出单元，所有任务共用一个输出单元。
• Class-IL 实验设置：目前已有多少类，就有多少个输出单元，每个类都有独立的输出单元。

实验结果

• 对于 split MNIST 任务
  
• 对于 permuted MNIST 任务
  

Through

• 文章逻辑挺清晰的，就是代码写的太拉胯了…

URL

• paper: https://arxiv.org/pdf/2010.11929.pdf
• code: https://github.com/lucidrains/vit-pytorch

TL；DR

• 本文提出一种应用于视觉任务的 Transformer

Algorithm

Architecture

code

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

import torch
from torch import nn
from einops import rearrange, repeat
from einops.layers.torch import Rearrange
# helpers
def pair(t):
    return t if isinstance(t, tuple) else (t, t)
# classes
class PreNorm(nn.Module):
    def __init__(self, dim, fn):
        super().__init__()
        self.norm = nn.LayerNorm(dim)
        self.fn = fn
    def forward(self, x, **kwargs):
        return self.fn(self.norm(x), **kwargs)
class FeedForward(nn.Module):
    def __init__(self, dim, hidden_dim, dropout=0.0):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(dim, hidden_dim),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, dim),
            nn.Dropout(dropout),
        )
    def forward(self, x):
        return self.net(x)
class Attention(nn.Module):
    def __init__(self, dim, heads=8, dim_head=64, dropout=0.0):
        super().__init__()
        inner_dim = dim_head * heads
        project_out = not (heads == 1 and dim_head == dim)
        self.heads = heads
        self.scale = dim_head**-0.5
        self.attend = nn.Softmax(dim=-1)
        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias=False)
        self.to_out = (
            nn.Sequential(nn.Linear(inner_dim, dim), nn.Dropout(dropout))
            if project_out
            else nn.Identity()
        )
    def forward(self, x):
        qkv = self.to_qkv(x).chunk(3, dim=-1)
        q, k, v = map(lambda t: rearrange(t, "b n (h d) -> b h n d", h=self.heads), qkv)
        dots = torch.matmul(q, k.transpose(-1, -2)) * self.scale
        attn = self.attend(dots)
        out = torch.matmul(attn, v)
        out = rearrange(out, "b h n d -> b n (h d)")
        return self.to_out(out)
class Transformer(nn.Module):
    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout=0.0):
        super().__init__()
        self.layers = nn.ModuleList([])
        for _ in range(depth):
            self.layers.append(
                nn.ModuleList(
                    [
                        PreNorm(
                            dim,
                            Attention(
                                dim, heads=heads, dim_head=dim_head, dropout=dropout
                            ),
                        ),
                        PreNorm(dim, FeedForward(dim, mlp_dim, dropout=dropout)),
                    ]
                )
            )
    def forward(self, x):
        for attn, ff in self.layers:
            x = attn(x) + x
            x = ff(x) + x
        return x
class ViT(nn.Module):
    def __init__(
        self,
        *,
        image_size,
        patch_size,
        num_classes,
        dim,
        depth,
        heads,
        mlp_dim,
        pool="cls",
        channels=3,
        dim_head=64,
        dropout=0.0,
        emb_dropout=0.0
    ):
        super().__init__()
        image_height, image_width = pair(image_size)
        patch_height, patch_width = pair(patch_size)
        assert (
            image_height % patch_height == 0 and image_width % patch_width == 0
        ), "Image dimensions must be divisible by the patch size."
        num_patches = (image_height // patch_height) * (image_width // patch_width)
        patch_dim = channels * patch_height * patch_width
        assert pool in {
            "cls",
            "mean",
        }, "pool type must be either cls (cls token) or mean (mean pooling)"
        self.to_patch_embedding = nn.Sequential(
            Rearrange(
                "b c (h p1) (w p2) -> b (h w) (p1 p2 c)",
                p1=patch_height,
                p2=patch_width,
            ),
            nn.Linear(patch_dim, dim),
        )
        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
        self.dropout = nn.Dropout(emb_dropout)
        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)
        self.pool = pool
        self.to_latent = nn.Identity()
        self.mlp_head = nn.Sequential(nn.LayerNorm(dim), nn.Linear(dim, num_classes))
    def forward(self, img):
        x = self.to_patch_embedding(img)
        b, n, _ = x.shape
        cls_tokens = repeat(self.cls_token, "() n d -> b n d", b=b)
        x = torch.cat((cls_tokens, x), dim=1)
        x += self.pos_embedding[:, : (n + 1)]
        x = self.dropout(x)
        x = self.transformer(x)
        x = x.mean(dim=1) if self.pool == "mean" else x[:, 0]
        x = self.to_latent(x)
        return self.mlp_head(x)
vit = ViT(
    image_size=100,
    patch_size=10,
    num_classes=10,
    dim=128,
    depth=12,
    heads=8,
    mlp_dim=256,
)
img = torch.randn(2, 3, 100, 100)
out = vit(img)
print(out.shape)  # [2, 10]

Thought

• 一个优雅的网络结构，就该像 ViT 这样，用一张动图 + 一段不长的代码完美表示。显然 Swin Transformer 不够优雅…

URL

• https://arxiv.org/pdf/2111.06377.pdf

TL;DR

• 本文提出一种图像自监督预训练方法: Masked Autoencoders (MAE)，通过 mask 很高比例的图像 patch，并使用非对称 encoder-decoder 结构重建整个图进行预训练
  • 随机 mask 很大的比例，例如：75% ，一方面提高自监督难度以达到自监督效果，另一方面减小 encoder 大小
  • 只将未 mask 的 patch 送入神经网络，重建整张图
• 与 BERT 非常相似，BERT 在自然语言中进行自监督预训练从而使得网络参数量可以达到惊人的一千亿；MAE 也希望通过图像自监督预训练提高网络参数和网络效果

Algorithm

视觉模型 masked autoencoder 与语言模型 masked autoencoder 有何差异

• 视觉模型通常使用 CNN，CNN 无法直接对 mask tokens 和 positional embeddings 等自监督标记进行有效整合；Vision Transformers (ViT) 提出了一种有效的解决方法
• 语言是人生成的经过高度信息聚合的，所以信息冗余较少，mask 很小比例后重建难度就较高；图像有大量信息冗余，所以需要 mask 很大比例才有重建难度，才能起到自监督效果
• 由于语言自监督模型重建的信息维度较高，所以 encoder-decoder 结构中的 decoder 可以非常简单（通常是一个 MLP）；但视觉自监督模型重建的信息维度是像素，所以 decoder 结构在网络中扮演一个关键角色

什么是 Autoencoder

• Autoencoder 是一种经典的表征学习方法，可以将输入通过 encoder 映射到表征空间，再通过 decoder 解码
• Denoising autoencoders (DAE) 是将输入破坏，再通过 decoder 重建出破坏前的原始输入，Masked Autoencoder 就是一种 DAE

Architecture

• MAE 的 encoder 部分与 ViT 的 encoder 相同，输入为 未 mask 的图像 patch
• MAE 的 decoder 部分输入包含两部分：
  • encoder 部分对 未 mask 的图像 patch encoder 后的表征（输入 decoder 的浅蓝色方块）
  • mask tokens（输入 decoder 的灰色方块）
• decoder 的结构更浅更窄，每个 token 的计算量只有 encoder 的 10%
• 只在 mask patch 上计算 loss，损失函数就是简单的 mean squared error（MSE）
  

自监督重建效果

不同 mask 比例下的自监督效果对比

寻找最合适的 mask 比例

Though

• 将 Masked Language Model 优雅地应用在图像自监督中，简单、有效、mask sense
• 使在图像上应用超大规模预训练模型成为可能

URL

• https://arxiv.org/pdf/1810.04805.pdf

TL;DR

• 一种 用于语义理解的预训练深层双向 transformer，任务相关的 fine-tuning 即可 SOTA
• BERT 全称：Bidirection Encoder Representation from Transformer
• 使用 无标签文本 进行预训练，自监督预训练的方法包括：
  • masked language model：预测被遮挡的词的 token（不需要重建整个句子）
  • next sentence prediction：预测两个句子是否是前后相连的关系（只需预测 是 或者 否）

Algorithm

自监督语义表征方法

• 自监督语义表征方法常用的监督方法有两种：
  • feature based：任务相关的预训练
  • fine-tuning：在预训练过程中增加任务相关参数，预训练结束后只需要替换这些任务相关参数，在任务数据上有监督 end-to-end fine-tuning 很少 step 即可
• 相较于 GPT 的 left -> right 单向语义结构，双向语义结构对下游任务更友好

BERT 模型结构

• BERT 参数含义：
  • L：transformer layers
  • H：hidden size
  • A：self-attention heads
• $BERT_{base}(L=12,H=768,A=12,Total\ Parameters=110M)$
• $BERT_{large}(L=24,H=1024,A=16,Total\ Parameters=340M)$

BERT 输入输出结构

输入

• BERT 输入可以是一个句子，也可以是多个句子的 concat（用特殊分隔符分隔），例如问答数据集中，输入的句子是 <question, answer> concat
  • [CLS] 为 Sequence 开始标志位
  • [SEP] 为 Sentence 结束标志位
• Token Embeddings 是将句子转化成词向量，英文版本 BERT 用的分词器是 WordPiece embeddings，词表容量 30,000
• Segment Embeddings 用于指明句子如何分割
• Position Embedding 用于记录原始位置信息（与 CNN 不同，Transformer 中没有位置信息）

输出

其中：$C\in \mathbb{R}^H,\ T_i \in \mathbb{R}^H,\ \ H\ means\ hidden\ size$

BERT 预训练细节

Masked Language Model

• mask 策略：
  • 训练数据随机 mask 15% 的位置
  • mask 数据的 80% 使用 [MASK] token 去 mask
  • mask 数据的 10% 使用随机 token 去 mask
  • mask 数据的 10% 什么都不改变
• 计算 loss
  • 假如第 $i$ 个 token 被 mask，那只计算输出 $T_i$ 映射到词表空间的 token 分布和真实 token 之间的交叉熵 Loss（本质就是分类）

Next Sentence Prediction

• 数据生成策略：
  • 每个样本由两个句子组成，50% 的可能两个句子是前后句的关系，50% 的可能两个句子不是前后句的关系，预测 IsNext OR NotNext
• 计算 loss
  • 只用输出 C 映射到二分类空间的结果和二分类 label，计算交叉熵损失
• 在 NSP 数据集中，无监督预训练即可达到 97% - 98% 的准确率

BERT fine-tuning

• 对于不同的任务，只需要替换 BERT 之后的网络结构，使用有监督数据 end-to-end fine-tuning 即可

消融实验

分析了 NSP、双向网络结构等对效果的影响

效果对比

URL

• https://pan.baidu.com/s/1O3dZeTgs1qcAy_GTNafmaQ?dp-logid=84667800628071820001#/doc/395565337776495/3115377

TL;DR

• 多任务模型共享网络结构，在一些弱关联或者负相关的任务上，可能出现 跷跷板效应（Seesaw Phenomenon），即一个任务的效果和另外一个任务的效果无法同时提升
• 针对跷跷板效应问题，本文提出一种 CGC（Customized Gate Control） 结构，任务之间部分共享底层网络
• 提出一种 CGC 的升级版本 - PLE（Progressive Layered Extraction）
• 单层网络结构 CGC 与多层网络结构 PLE 都优于 MMOE

Algorithm

不同多任务网络结构对比

Customized Gate Control（CGC）

• CGC 结构部分共享表征，部分独用表征，共享表征和独占表征的权重分配是通过门控制
  $y^k(x) = t^k(g^k(x))$，其中 $t^k$ 表示第 k 个任务的 tower
  $g^k(x) = w^k(x)S^k(x)$，其中 $w^k(x)$ 表示表征选择器 $w^k(x) \in\mathbb{R}^{m_k+m_s}$、$m_k$、$m_s$ 分别表示独占和共享表征的数量
  $w^k(x) = Softmax(w^k_gx),w^k_g\in\mathbb{R}^{(m_k+m_s)\times d}$，d 表示表征向量的长度
  $S^k(x) = [E^T_{(k,1)}, E^T_{(k,2)}, ... ,E^T_{(k,m_k)},E^T_{(s,1)}, E^T_{(s,2)}, ... ,E^T_{(s,m_s)}]$，E 表示表征，$S^k(x)\in\mathbb{R}^{d\times(m_k+m_s)}$ 表示表征集合

Progressive Layered Extractio（PLE）

• PLE 相当于 CGC 的多层网络结构
  $y^k(x) = t^k(g^{k,N}(x))$，N 表示网络总层数
  $g^{k,j}(x) = w^{k,j}(g^{k,j-1}(x))S^{k,j}(x)$

效果对比

Thought

• MMOE 的改进版，从效果来看，对于不正相关甚至互逆的任务，都可以有效解决跷跷板问题
• 但本质还是更 general 的 MMOE，没有跳出 MMOE 对多任务的定义

URL

https://arxiv.org/pdf/2105.02358.pdf

TL;DR

• 本文提出一种 Multi-Head External Attention 使用两层全连接层和两个 normalization 层替代 transformer 的 attention 层，以降低计算复杂度
• 提出一种 DoubleNorm 标准化层替代 attention 中的 softmax 层
• 在一些任务中没有超越 transformer 达到 SOTA，只是提出一种关于 attention 的思考

Algorithm

网络结构

• external attention 对比 self attention
  
• multi-head external attention 对比 multi-head self attention
  

数学表示与伪代码表示

• self attention
  $A = (\alpha)_{i,j} = softmax(QK^T),\ \ \ (\cdot)\ means\ matrix$
  $F_{out} = AV$
  其中:
  $F\in\mathbb{R}^{N\times d}$ 表示输入，$Q=FW_1,K=FW_1,V=F,W_1\in\mathbb{R}^{d\times d'}$
  $Q\in\mathbb{R}^{N\times d'},K\in\mathbb{R}^{N\times d'},A\in\mathbb{R}^{N\times N}$
  $F_{out}\in\mathbb{R}^{N\times d}$ 表示输出
• 简化 self attention
  $A = (\alpha)_{i,j} = softmax(FF^T)$
  $F_{out} = AV$
• external attention
  $A = (\alpha)_{i,j} = Norm(FM^T)$
  $F_{out} = AM$
  以上两步可以共享 MLP 权重，$M\in\mathbb{R}^{S\times d}$，也可以不共享，分成 $M_k$、$M_v$
  计算复杂度 O(dSN)
  伪代码表示：
  
• multi-head external attention
  $h_i = ExternalAttention(F_i,M_k,M_v)$
  $F_{out} = MultiHead(F,M_k,M_v) = Concat(h_1,...,h_H)W_o$
  伪代码表示：
  
• DoubleNorm
  本文提出一种 double-normalization 结构，先在第一维做 softmax，再在第二维做 average
  $(\tilde{\alpha})_{i,j} = FM_k^T$
  $\hat{\alpha}_{i,j}=exp(\tilde{\alpha}_{i,j})/\sum_k exp(\tilde{\alpha}_{k,j})$
  $\alpha_{i,j}=\hat{\alpha}_{i,j}/\sum_k \hat{\alpha}_{i,k}$

EA 结构用法示例

External Attention 和 DoubleNorm 的消融实验

算法表现

• 本文中对 EANet 与其他网络结构在不同任务上的对比实验做的非常详细，建议去看原文

Thought

• 在一些任务上超越了 self-attention 并不能说明 external attention 结构优于 self-attention 结构
• 在参数量较小的情况下，external attention 结构可带来较多增益
• 本文更像是对 《Attention is all you need》 的嘲讽之作

URL

• https://arxiv.org/pdf/1910.03151.pdf

TL;DR

• 本文提出一种高效的 Channel Attention 算法，与 SENet 相比，效果更好，参数量与计算量更低

Algorithm

网络结构

• 与 SENet 结构的区别:
  • 两层 FC 变成一层 FC
  • FC 权重稀疏（kernel_size = k 的 1D Conv）

对比实验

• 本文将 ECA-Net 与以下 Channel Attention Block 进行了对比，目的是：如何对 FC 稀疏可以使得模型最终效果最好
  • SENet：Squeeze and Excitation Network
  • SE-Var1：SE 变种 1
  • SE-Var2：SE 变种 2
  • SE-Var3：SE 变种 3
  • SE-GC1：SE 通道分组 1
  • SE-GC2：SE 通道分组 2
  • SE-GC3：SE 通道分组 3
  • ECA-NS：ECA-Net 的动态版
• 数学表示
  $x \in \mathbb{R}^{W\times H\times C}\ :\ input$
  $g\ :\ Global\ Average\ Pool$
  $\sigma\ :\ Sigmoid$
• SENet
  • Channel-wise Attention Weight：$w = \sigma(f_{\{W_1,W_2\}}(g(x)))$，记 $y = g(x)$
  • $f_{\{W_1,W_2\}}(y) = W_2 ReLU(W_1 y)$
  • $W_1\in \mathbb{R}^{C\times \frac{C}{r}}$
  • $W_2\in \mathbb{R}^{\frac{C}{r} \times C}$
  • 参数个数：$2\times \frac{C^2}{r}$
• SE-Var
  • Channel-wise Attention Weight：$w = \sigma (Wy)$
  • $W \in \mathbb{R}^{C\times C}$
  • SE-Var1：$W$ 是一个 单位矩阵，参数个数：1
  • SE-Var2：$W$ 是一个 对角矩阵，参数个数：$C$
  • SE-Var3：$W$ 是一个 普通矩阵，参数个数：$C^2$
• SE-GC
  • $W$ 是一个 分块对角矩阵，每个块边长 $\frac{C}{G}$，对角线包含 $G$ 个块，一共包含非零元素（参数个数）：$\frac{C}{G}\times \frac{C}{G}\times G = \frac{C^2}{G}$ 个
  • SE-GC1 和 SE-GC2 和 SE-GC3 的区别只是 $G$ 的取值不同
• ECA-NS
  • $W$ 是一个 阶梯状矩阵，每行连续 $K$ 个非零元素，阶梯状叠加 $C$ 行，参数个数：$K\times C$
• ECA-Net
  • ECA-NS 中每行元素都一样的特例，参数量：$K$
    

代码表示

对下游任务的提升

• ImageNet 分类
  
• COCO 目标检测
  
• COCO 实例分割
  

Thought

• SE-Net 的简化版，但参数量与计算量都更小
• 但是性能比 SE-Net 更好这个结论感觉不太 make sense

四种 Norm 对比

• BN：垂直于 C 维度归一化
• LN：垂直于 N 维度归一化
• IN：垂直于 N, C 维度归一化
• GN：$GN = \begin{cases} LN,\ \ \ g=1\\ IN,\ \ \ g=c \end{cases}$，g 表示每个 group 覆盖的 channel 数

四种 Norm 的 Affine 参数 Shape

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import torch
inp = torch.randn(3, 4, 5, 6)
# batch norm
batchnorm = torch.nn.BatchNorm2d(num_features=4)
batchnorm.weight.shape                              # torch.Size([4])
out = batchnorm(inp)
out.shape                                           # torch.Size([3, 4, 5, 6])
out.permute(1,0,2,3).reshape(4, -1).mean(1).data    # tensor([-5.9605e-09,  1.5895e-08, -5.2982e-09, -7.9473e-09])  几乎是 0
out.permute(1,0,2,3).reshape(4, -1).std(1).data     # tensor([1.0056, 1.0056, 1.0056, 1.0056])  几乎是 1
# layer norm
layernorm = torch.nn.LayerNorm(normalized_shape=(4, 5, 6))
layernorm.weight.shape              # torch.Size([4, 5, 6])
out = layernorm(inp)
out.shape                           # torch.Size([3, 4, 5, 6])
out.reshape(3, -1).mean(1).data     # tensor([ 3.9736e-09, -5.9605e-09,  2.7816e-08])  几乎是 0
out.reshape(3, -1).std(1).data      # tensor([1.0042, 1.0042, 1.0042])  几乎是 1
# instance norm
instancenorm = torch.nn.InstanceNorm2d(num_features=4)
out = instancenorm(inp)
out.shape                           # torch.Size([3, 4, 5, 6])
out.reshape(12, -1).mean(1).data    # tensor([ 1.7881e-08,  1.7881e-08, -2.3842e-08, -1.9868e-08,  0.0000e+00, -3.9736e-09,  0.0000e+00,  0.0000e+00,  0.0000e+00,  7.9473e-09, 1.9868e-08, -2.1855e-08])  几乎是 0
out.reshape(12, -1).std(1).data     # tensor([1.0171, 1.0171, 1.0171, 1.0171, 1.0171, 1.0171, 1.0171, 1.0171, 1.0171, 1.0171, 1.0171, 1.0171])  几乎是 1
# group norm
groupnorm = torch.nn.GroupNorm(num_groups=2, num_channels=4)
groupnorm.weight.shape              # torch.Size([4, 5, 6])
out = groupnorm(inp)
out.shape                           # torch.Size([3, 4, 5, 6])
out.reshape(6, -1).mean(1).data     # tensor([ 1.9868e-09,  3.1789e-08, -1.9868e-08,  0.0000e+00,  1.5895e-08, 5.9605e-08])  几乎是 0
out.reshape(6, -1).std(1).data      # tensor([1.0084, 1.0084, 1.0084, 1.0084, 1.0084, 1.0084])  几乎是 1