Zhangzhe's Blog

关于孙剑博士意外离世的一点感想

Posted on 2022-06-17 Edited on 2025-12-11 In 随笔 Valine:

2022年6月14日中午，听闻了孙老师意外离世的消息，愕然！
在我的印象中，孙老师是一个高高壮壮、有些腼腆的学者。在旷视的一年和孙老师接触仅限于在电梯里的几次照面，我只是一个 nobody，所以没有打过招呼。
记得有一次，我同时和印奇老板、孙剑老师同时进入电梯，印奇老板询问孙老师一个事情的进度，态度和蔼，但孙老师瞬间脸就红了，然后尴尬的微笑着简单地汇报了进度，能看出非常的不自在。我事后给女友讲起此事，感叹人间真实，曾经的晚辈变成了自己的老板，尴尬自然是正常的。
对孙老师形成直观的印象来自于一封内部信，应该是 2021 新年伊始，孙老师发内部信总结公司的 2020 并展望 2021，关于公司的战略规划，我兴趣不大，只是隐约明白了我还有活干。我感兴趣的点在于孙老师对自己生活的分享，他说父母经常会有自己的小孩一定会和自己一样优秀的错误幻想，但实际上他自己作为一个名声响彻 ai 界的大牛，女儿小学数学竟然不及格，他每天都在辅导女儿打败数学大魔头。他还分享了自己练习长跑的心得，刚开始跑几百米就气喘吁吁，后面每天练习，日复一日，终于可以一口气跑 10 km，相信自己，贵在坚持，总能战胜自己。
谁能想到，才 45 岁的他就此陨落，从此女儿没有了父亲，妻子没有了丈夫，旷视研究院没有了孙院长，学界少了一位孙老师。
是的，朋友圈刷屏了，满眼都是对他的哀悼和纪念，甚至旷视 CEO 印奇也发文：“一定要完成孙老师未竟的事业”，但是又如何？怕不过一周之后，不会再有人感叹他的英年早逝、不会再有人感叹天妒英才，人总要向前看。尘归尘，土归土，只留给他的家人无尽的痛苦。
他无疑是成功的，拥有 100 多篇顶级学术论文，多少研究人员终其一生也难中一篇。我来自农村，能一步一步走到现在实属不易，受过的苦只有自己知道，也从未幻想过能有一天和巨人并肩。我只是一个小人物，赚着不多不少的钱，住着不大不小的房子，每天努力工作，少有人知道也少有人关心，我没有成功者该有自律，甚至已经三四个月没有读过论文了，健身事业也常常被各种各样的杂事搁置。累了就躺平，无聊了就找点事干，我知道我的一生很可能永远也不会有高光时刻，我是个平凡的普通人，我认了。
不过至少没有让我的父母和妻子失望，我活着，每天遇到各种各样的烦恼却依然相信总会变好的。人拼一辈子，拼到最后就是拼谁命长，把时间线拉的足够长，眼下的困难和失意又算的了什么？
在阿里的 11 个月，我太疲惫了，每个工作日在家的时间不会超过 9 个小时，不想继续下去了，到此为止吧。孙老师的意外给了我很深的启示，人生绝不是只有工作的，我要去寻找生活了，重新出发，去迎接新生命的到来。
孙老师的微博“孙剑_ai”，我一条一条仔细翻完了，除去他作为 AI 大牛的光环之外，他是一个非常 nice 的父亲、丈夫和儿子，是一个乐观又有点愤青的学者，一个和蔼又毒舌的朋友，一个慷慨又有点小骄傲的老师，斯人已逝，愿您在乎的人永远平安！

Continual Learning with Deep Generative Replay

Posted on 2022-02-15 Edited on 2025-12-11 In Incremental Learning Valine:

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

LwF: Learning without Forgetting

Posted on 2022-02-03 Edited on 2025-12-11 In Incremental Learning Valine:

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

Three scenarios for continual learning

Posted on 2022-01-25 Edited on 2025-12-11 In Incremental Learning Valine:

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 数字数据，细节如下图所示：

model name	task number	class number	image size	info
split mnist	5	2	28x28 pixel grey-scale images	总共 10 类数字，每个类别有 6000个图片用于训练，1000个用于测试
permuted mnist	10	10	zero-padded to 32x32 pixels	总共 100 类数字，每个类别有 6000个图片用于训练，1000个用于测试

增量学习常用策略

任务独占组件：在每个任务上训练单独的组件，在 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

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

An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale

Posted on 2022-01-20 Edited on 2025-12-11 In Transformer Valine:

URL

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

TL；DR

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

Algorithm

Architecture

code

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 不够优雅…~~

Masked Autoencoders Are Scalable Vision Learners

Posted on 2022-01-19 Edited on 2025-12-11 In Self-Supervised Learning Valine:

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
使在图像上应用超大规模预训练模型成为可能

BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding

Posted on 2021-12-30 Edited on 2025-12-11 In Self-Supervised Learning Valine:

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、双向网络结构等对效果的影响

效果对比

Progressive Layered Extraction (PLE): A Novel Multi-Task Learning (MTL) Model for Personalized Recommendations

Posted on 2021-12-15 Edited on 2025-12-11 In Multi-Task Valine:

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 对多任务的定义

Beyond Self-attention: External Attention using Two Linear Layers for Visual Tasks

Posted on 2021-12-06 Edited on 2025-12-11 In Transformer Valine:

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》的嘲讽之作~~

ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks

Posted on 2021-11-16 Edited on 2025-12-11 In CNN Architecture Design Valine:

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$

URL

TL;DR

Algorithm

网络结构

Loss 设计

Thought

URL

TL;DR

Algorithm

Experiment

Thought

URL

TL;DR

Algorithm

增量学习常用策略

增量学习的算法上下界

Experiment

实验设置

实验结果

Through

URL

TL；DR

Algorithm

Architecture

code

Thought

URL

TL;DR

Algorithm

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

什么是 Autoencoder

Architecture

自监督重建效果

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

寻找最合适的 mask 比例

Though

URL

TL;DR

Algorithm

自监督语义表征方法

BERT 模型结构

BERT 输入输出结构

输入

输出

BERT 预训练细节

Masked Language Model

Next Sentence Prediction

BERT fine-tuning

消融实验

效果对比

URL

TL;DR

Algorithm

不同多任务网络结构对比

Customized Gate Control（CGC）

Progressive Layered Extractio（PLE）

效果对比

Thought

URL

TL;DR

Algorithm

网络结构

数学表示与伪代码表示

EA 结构用法示例

External Attention 和 DoubleNorm 的消融实验

算法表现

Thought

URL

TL;DR

Algorithm

网络结构

对比实验

代码表示

对下游任务的提升

Thought