前

最近在整理学习笔记时，我发现了一个尴尬的现象：去年收藏的 50+ 个技术教程，完整看完的不到 5 个；购买的 10+ 门在线课程，学完的只有 1 门；下载的几十本技术书籍，读完的寥寥无几。

更糟糕的是，当别人问我”你会 XXX 吗？”时，我的回答往往是”学过，但不太熟”。明明花了很多时间学习，为什么总觉得自己什么都没学会？

后来我意识到，自己掉进了一个我称之为 “123 陷阱” 的学习误区。

什么是 123 陷阱

现象描述

123 陷阱指的是这样一种学习模式：

学习 Go → 感觉没学会 → 学习 Rust → 感觉没学会 → 学习 Zig → 感觉没学会 → ...
       1                2                 3

你不断地学习新东西（1、2、3…），但每次都浅尝辄止：
– 看了几节课就觉得枯燥，转向下一个
– 跟着教程做了 Hello World，就以为学会了
– 遇到难点就放弃，去找”更简单”的替代品
– 总觉得自己学得不够深，要继续学更多

结果就是：看起来学了很多，实际上什么都没真正掌握。

我的真实案例

回顾我的学习历程，典型的 123 陷阱场景：

编程语言方面
– 学 Python：写了几个小脚本，遇到类和装饰器就卡住了
– 转学 Go：写了个 HTTP server，遇到 channel 和 goroutine 又懵了
– 再学 Rust：被所有权和生命周期劝退
– 又去看 TypeScript：发现类型系统也很复杂

一年过去了，结果是：Python 不熟练，Go 不会用，Rust 看不懂，TypeScript 只会基础语法。

前端框架方面
– React：学到 Hooks 就没继续
– Vue：看了文档没做项目
– Svelte：觉得新鲜，看了几个例子就没了
– Next.js、Nuxt.js：收藏了教程从未打开

问题很明显：我在收集知识，而不是掌握技能。

为什么会掉进这个陷阱

原因一：学习的即时满足感

学习新东西有一种天然的愉悦感：
– 打开一个新教程：充满期待
– 看懂前几章：感觉良好
– 了解新概念：觉得自己在进步

但这种满足感是廉价的，就像刷短视频一样：
– 你获得了”学习”的感觉
– 但没有真正的能力提升
– 只是在满足”我在学习”的心理需求

原因二：逃避深度思考

真正的学习是痛苦的：
– 需要反复练习
– 要面对自己的不足
– 必须克服理解上的障碍
– 要投入大量时间深挖

而切换到新主题可以让你：
– 回到舒适的”入门”阶段
– 避免面对当前主题的难点
– 用”学习新东西”来掩盖”学不会旧东西”的事实

切换学习主题是一种伪装成勤奋的逃避。

原因三：错误的学习目标

我发现自己经常陷入这样的思维误区：
– “我要学会所有流行的技术”
– “不懂 XXX 就落伍了”
– “多学一门语言就多一个选择”

但从来没问过自己：
– 学这个要解决什么问题？
– 这个技术对我的工作有什么帮助？
– 我有时间深入学习吗？

没有明确的目标，学习就变成了盲目的收集。

原因四：完美主义作祟

很多时候觉得”没学会”，其实是完美主义在作祟：
– 看了一本书，但没看完所有章节 → “还没学会”
– 会用基本功能，但不懂底层原理 → “还没学会”
– 能写代码，但写得不够优雅 → “还没学会”

这种心态导致：
– 永远觉得自己准备不足
– 不敢真正开始实践
– 陷入无休止的”学习准备期”

如何跳出 123 陷阱

策略一：项目驱动学习

不要为了学而学，而要为了用而学。

我的转变过程：

以前的学习路径

看 Docker 教程 → 学 K8s → 研究 Service Mesh → ...

现在的学习路径

需要部署个人博客 → 学习 Docker 基础 → 写 Dockerfile → 成功部署
               ↓
        遇到多容器管理问题 → 学习 docker-compose → 解决问题
               ↓
        需要自动扩缩容 → 学习 K8s 的相关概念 → 在项目中实践

关键区别
– 以前：漫无目的地学习概念
– 现在：为了解决具体问题而学习

实践方法
– 想学某个技术前，先找一个要做的项目
– 以项目需求为导向，只学必要的部分
– 遇到问题再深入学习，而不是预先学所有东西

策略二：20% 法则

20% 的知识可以解决 80% 的问题。

核心原则
– 先掌握最核心的 20%
– 用这 20% 去解决实际问题
– 在实践中遇到瓶颈时，再学习下一个 20%

以学 Python 为例

第一个 20%（优先掌握）
– 基本语法：变量、条件、循环
– 常用数据结构：列表、字典
– 函数定义和调用
– 基本文件操作

用这些知识就可以：
– 写数据处理脚本
– 做简单的自动化任务
– 解决日常工作中的小问题

不要一开始就学
– 装饰器
– 元类
– 协程
– 类型标注

这些是高级特性，等你真正需要时再学。

策略三：深度优先而非广度优先

广度优先（123 陷阱）

Python 基础 → Go 基础 → Rust 基础 → TypeScript 基础
    ↓
都学了一点，都不精通

深度优先（推荐）

Python 基础 → Python 项目 → Python 高级特性 → 生产环境实践
    ↓              ↓             ↓                ↓
 会写代码      能做东西      代码质量提升      解决真实问题

实践建议
– 选择一门语言/技术深入学习
– 至少做 3 个以上的项目
– 在生产环境中使用过
– 读过相关的源码或深度文章

只有真正掌握一门技术后，再去学第二门，才会发现：
– 学第二门时快很多（很多概念是相通的）
– 更容易理解底层原理
– 能主动对比不同技术的优劣

策略四：建立反馈循环

问题：学了没有反馈，不知道是否真的掌握

解决方案：建立多个反馈节点

即时反馈
– 跟着教程写代码时，每个例子都运行一遍
– 不要只是看，一定要自己敲一遍
– 尝试修改参数，观察结果变化

短期反馈
– 学完一个模块，用它做个小项目
– 不用复杂，能跑起来就行
– 用自己的话写一篇总结笔记

中期反馈
– 教别人你学到的东西
– 回答社区里的相关问题
– 给开源项目提 PR

长期反馈
– 在工作中应用学到的技术
– 承担相关的技术任务
– 成为团队里这个技术的 go-to person

策略五：允许自己”不完美”

转变心态

以前
– “还没学完全部章节，不能说自己会”
– “还没看源码，不敢说自己懂”
– “还有很多高级特性不会，不能用在项目里”

现在
– “能解决实际问题就够了”
– “遇到问题再深入学习也不迟”
– “先用起来，在实践中提升”

实践原则
– 会用 > 懂原理 > 精通（按顺序来）
– 能解决 80% 的问题就够格说”会”
– 精通是长期实践的结果，不是学完教程的结果

一些建立的实践

我的当前学习清单

以前我的学习列表是这样的：
– [ ] 学 Go
– [ ] 学 Rust
– [ ] 学 K8s
– [ ] 学 React
– [ ] 学机器学习
– [ ] …（还有 20+ 项）

现在我只保留 3 个：
– [x] 深入 Python（当前工作语言，90% 精力）
– 完成 3 个实际项目
– 阅读优秀开源项目源码
– 在生产环境中优化性能
– [ ] 学习 Go（10% 精力，只学基础）
– 只是为了能看懂公司的 Go 项目
– 不求精通，能改小 bug 就够
– [ ] K8s 基础（根据需要学习）
– 暂时不学，等部署需求出现时再学

我的项目列表

现在每学一个技术，都会同步创建至少一个项目：

学 Docker 时做的项目
1. 容器化个人博客
2. 搭建开发环境
3. 部署数据库和 Redis

学 Python 时做的项目
1. 数据分析脚本（处理工作中的 Excel）
2. API 服务（为前端提供接口）
3. 爬虫工具（收集资料）

每个项目都很小，但都是真实可用的。

我的学习笔记结构

以前的笔记：按教程章节记录，很少回看

现在的笔记：按问题和解决方案记录

# Python 学习笔记

## 问题：如何读取大文件不会内存溢出？
解决方案：使用生成器逐行读取
[代码示例]
[使用场景]
[踩过的坑]

## 问题：如何处理 JSON 中的日期格式？
[解决方案]
[代码示例]

## 项目：数据处理工具
[需求描述]
[技术选型]
[核心代码]
[遇到的问题和解决方案]

这样的笔记结构让知识更容易被检索和应用。

后

写完这篇文章，我翻了翻自己的学习记录。过去一年，我学了不少东西，但真正能用的只有那几个做过项目的技术。

123 陷阱的本质是：把学习当成了目的，而不是手段。

真正的学习应该是：
– 有明确的目标（解决什么问题）
– 聚焦核心知识（20% 法则）
– 立即实践（做项目）
– 深度优先（一个一个来）
– 持续反馈（在使用中提升）

如果你也觉得自己学了很多但什么都不会，不妨问自己几个问题：
– 我为什么要学这个？
– 我打算用它做什么？
– 我是否有时间深入学习？
– 我能否现在就开始做个小项目？

如果答案都是否定的，那这个技术可能只需要”了解”而不是”学习”。

最后，分享一句我很认同的话：

真正的学习不是收集知识，而是改变行为。

如果学了一个技术后，你的工作方式、解决问题的能力没有任何改变，那这次学习就是无效的。

停止无意义的 1、2、3，选一个真正需要的技术，深入进去，做几个项目，用它解决真实的问题。这才是跳出 123 陷阱的唯一方法。

希望这篇文章能够帮助你重新审视自己的学习方法，找到真正有效的学习路径。

最小二乘法的问题描述

数据拟合的问题

记录一下第一次认真参加Kaggle比赛 比赛链接：https://www.kaggle.com/competitions/rsna-2022-cervical-spine-fracture-detection

等待更新☺️

由于点云传统配准（ICP：迭代最近点算法）效果不佳，于是考虑使用深度学习的方法。 这里采用NgeNet。

Neighborhood-aware Geometric Encoding Network 邻域感知几何编码网络

论文链接：https://arxiv.org/abs/2201.12094

Introduction

点云配准深度学习方法的分类

作者将其分为了两种

1. end-to-end：将feature learning 和 transformation estimation 融合到了一个模型
   1. 其中有一些方法依赖相关性的建立来进行后续的Procrustes分析
   2. 而其他方法则更关注点云之间的全局特征
2. feature-learning：更加关注learning of discriminative point feature（学习辨别性的点的特征），而transformation则是由pose estimators来估计的

提出网络

NgeNet利用多尺度结构明确地生成具有多种邻域大小的点状特征，并利用几何指导的编码模块来最大限度地利用几何信息。具体来说，设计了一个投票机制，为每个点选择一个合适的邻域大小，并拒绝在无法区分的表面上出现虚假的特征。

主要贡献

• 多尺度结构与几何引导编码相结合，产生多层次的几何和语义信息编码的特征。
• 多层次的一致性投票，为每个点选择适当的邻域并拒绝虚假的邻域。
• 我们的方法中所提出的技术是与模型无关的，能够很容易地移植到其他骨干结构上并提高性能。

Preliminaries （引言）

点云配准问题的数学表达

\[arg\ \underset{T}{\mathrm{min}}\frac{1}{|\sigma|}\sum_{(i, j)\in \sigma}||T (x_i ) − y_j ||_2\]

Cardinal Number(基数)：集合论中刻画集合大小的数

邻域分析

在特征学习中常常用到encoder-decoder网络来提取特征； 模型的输入为\(X\in\mathbb{R}^3\) 维数从\(N\times 3\) -> $N C $意思是每个点输出C维的特征

有两种方式去影响领域的范围一个是依靠连续的卷积层，隐形的增加了领域的范围；另一个是在encoder-decoder网络中常常使用两倍大小的分层卷积层来模拟点云的down sample。

方法

网络

可以很清楚的看到NgeNet是一个encoder-decoder网络 - encoder模块由：residual-style KPConv/strided KPConv层、instance norm层和Leaky ReLU层（k=0.1）组成

KPConv 是用于三维点云中的一种卷积方式

• decoder模块由：decoder中的上采样块采用最近搜索来进行特征插值。 unary block由一个线性（MLP）层、一个实例范数层和一个 Leaky ReLU 层 (k=0.1) 组成，而last unary block仅由一个线性层（MLP）组成

Input是什么？

Input为the source point cloud \(X\) and its initial descriptor \(F_X\) , the target point cloud \(Y\) and its initial descriptor \(F_Y\)

• 其中\(F_X\) and \(F_Y\) 都被init为全部为\(1\)的矩阵

组成部分

SIAMESE MULTI - SCALE BACKBONE

连体式多级骨干（什么鬼翻译

用途：用于处理输入的点云

如何工作？

• Shared Encoder：可以在绿色的Encoder部分看到一共做了四次卷积；这样做是为了拓展领域特征。此时一共有四个输出，最后的输出得到Super points \(X'\) （\(X'\)集合会在下文经常提到其中包括他的点\(x'_i \in X '\)）和它的feature \(F^{en}_{X'}\)（我理解上标的en意思是end；最后一个输出）；前三步输出的feature作为中间变量也被保存了下来，为了decoder去生成multi-scale的feature。这三个中间变量被记为\(F^1_{X}, F^2_{X}, F^3_{X}\)。这里需要注意的是，每个点特征的邻接点的感知范围从\(F^1_X\)延伸到\(F^3_{X}\) （最后一句话是KPConv的知识）

  • 最后Shared Encoder输出的是\(X' \in \mathbb{R}^{N' \times 3}\) 和\(F^{en}_{X'} \in \mathbb{R}^{N' \times D_{en} }\) ，加起来是应该是\((X', F^{en}_{X'}) \in \mathbb{R}^{N' \times (3+D_en)}\)（有待考证）

• Parallel Decoder：上面说在decoder的时候需要用到我们刚才保存的\(F^1_{X}, F^2_{X}, F^3_{X}\)，同时还有之后会介绍的\(F^{inter}_{X'}\)，一共这四个输入。最后得到的output是关于\(X'\)的高、中、低级别的feature

• 现在我们定义一个函数（后面要用） \[\phi (F^1 , F^2 , g) = cat[Up(g(F^2 )), F^1 ]\] 其中\(F^1\)和\(F^2\)是输入的feature，\(g\)是一个代表MLP或者Identity Layer的函数， \(cat\)表示concatenation（拼接矩阵），\(Up\)是nearest upsampling

• 现在可以表示 \(F^l_X , F^m_X\) 和 \(F^h_X\) 的计算方式

\[\begin{split}F^l_X &= MLP_2(\phi(F^1_X, F^2_X, MLP_1), \\F^m_X &= MLP_5(\phi(F^1_X, \phi (F^2_X, F^3_X, MLP_3), MLP_4), \\F^h_X &= MLP_8(\phi(F^1_X, \phi (F^2_X, \phi (F^3_X, F^{inter}_X, Identity), MLP_6), MLP_7 ).\end{split}\]

• 同时给出overlap（重复性）分数\(O_X\)和saliency（显著性）分数\(S_X\)

GEOMETRIC - GUIDED ENCODING

几何学引导式编码

GGE模块是一个 一个输入一个输出的模块

用途：GGE将super points和潜在的feature(也就是Shared Encoder输出的\((X', F^{en}_{X'}) \in \mathbb{R}^{N' \times (3 + D_{en})}\))作为输入；然后输出几何增强后的feature

如何工作？

• Normal vectors smoothing：这里计算Normal vector的方式比较特别。这一步的目的是去获得super points的Normal vector，但是他没有直接去用open3d的库直接计算。而是将super points的点映射回原来的全部点集中。再通过全部点集中，super points周围点的normal vectors去平均得到super points的normal vector。

\[N_{X_i^{'}}=\frac{1}{|J_i^N|}\sum_{x_j \in J_i^N}{N_{X_j}}\]

公式里面\(J_i^N = \{x_j| \left|| x_j-x'_i \right|| < r^N \}\) 其中\(x_j\in X\)，\(r^N\)是\(x'_i\)的邻域。

• Geometric encoding：这里我们想要的是每个点的几何特征，记为\(G_{x'_i}\)，利用PPF(Point Pair feature)去计算几何特征

\[\begin{equation}\begin{split}PPF(x'_i, x'_j) &= (\angle(x'_j-x'_i, N_{x'_i}), \angle(x'_j-x'_i, N_{x'_j}), \angle(N_{x'_i}, N_{x'_j}), \left|| x'_i - x'_j\right||_2), \\G_{x'_j} &= f_1(x'_i, x'_j-x'_i, PPF(x'_i, x'_j)), \\G_{x'_i} &= max\{ G_{x'_j}|x'_j \in J^G_i \}.\end{split}\end{equation}\]

公式里面\(\angle(\cdot, \cdot)\in(0, \pi)\) 代表两个向量之间的夹角, \(f_1\)是pointnet里的一个函数, \(J^G_i = \{x'_j \left|| x'_j-x'_i\right||<r^G\}\)，\(r^G\)是\(x'_i\)邻域的半径，\(max(\cdot)\)意思是channel-wise max-pooling

这个公式也解释一下：

PPF我这里理解的就是一个四维向量包含了（按照NgeNet的顺序），一个法向量和{两个法向量之间的向量d}的夹角，另一个法向量和{两个法向量之间的向量d}的夹角，两个法向量的夹角，两点之间的距离。对应下图的\((F_2, F_3, F_4, F_1)\)

\(f_1\)函数：暂时不清楚什么意思 \(G_{x'_i}\)：找到\(G_{x'_j}\)中最大的；至于channel-wise再点云中代表什么几何含义，暂时不清楚

• Semantic encoding：需要更新

损失函数

这里我们将损失函数从两个方面来看：特征损失 和 重叠与显着性损失

特征损失

这里说的特征损失，就是我们之前提到的\(F^h_X, F^m_X, F^l_X, F^h_Y, F^m_Y, F^l_Y\) 两个点云三个类别的特征。

重叠与显着性损失

投票机制

为什么要投票

在Parallel Decoder我们强调了，在每一次计算特征的时候，我们都保存下来了那些中间变量；他们是\(F^l_X\) 和\(F^m_X\) ，最后的输出是\(F^h_X\) 。

此时它们三个分别可以决定哪些source的特征点和target的特征点可以一一对应。那么每一个特征点都会存在三种方案。所以需要通过投票决定使用哪一种。

如何投票

上一篇文章《计算机视觉中的Transformer》讲了计算机视觉中的Transformer结构^[1]，还有非常受欢迎的Vision Transformer(ViT)^[2]。本篇文章将补上上一篇掠过的《Attention Augmented Convolutional Networks》^[3]和《End-to-End Object Detection with Transformers》^[4]，同时也会介绍一下DeiT (Data-effieciency Image Transformer)^[5]。

Self-Attention回顾

Transformer的核心是Self-Attention。Self-Attention是基于特征向量对序列上token成对关系的表征学习(Representation Learning)。

Fig. 1. Self Attention.

计算方式大致如下:

• 序列: $X\in R^{n\times d}$
• Query向量: $Q$有相对应的可学习权重$W^Q\in R^{n\times dq}$
• Key向量: $K$也有相对应的可学习权重$W^K\in R^{n\times dk}$
• Value向量: $V$也有相对应的可学习权重$W^V\in R^{n\times dv}$
• $Q=XW^Q, K=XW^K, V=XW^V$
• Self-Attention层: $Z=softmax(\frac{QK^T}{\sqrt{d_q}})V$
• 若是Masked Self-Attention层，则需要增加一层mask: $softmax(\frac{QK^T}{\sqrt{d_q}}\circ M)$

Fig. 2. Self Attention运算过程. Adapted from ^[1]

这里展示的是一个简单的Self-Attention计算方式，对于^[1]同时提出的Multi-Head Self-Attention，可以将上述过程并行的执行多次来模拟不同的head。

在2021年，计算机视觉领域中的Transformer和Self-Attentio的相关技术已经发展了很多。我们可以使用以下这张图来理解今天的Self-Attention相关技术的不同类型。

Fig. 3. Self Attention不同类型. Adapted from ^[6]

在上图中能看到不同的Attention类型，比如Local Attention, Global Attention, Vectorized Attention。下图介绍了这些类型的大致计算流程。

Fig. 4. Self Attention的不同类型. Adapted from ^[6]

用Attention增强卷积

从之前我们可以了解到，Self-Attention可以很好的找到距离较远的token之间的关系，而普通的卷积层只能计算非常有限的范围。如果我们能够将这些距离较远的token之间的关系计算出来，那么就可以使用Self-Attention来弥补卷积层的这个缺陷，对图像分析是有帮助的。而且卷积层是等变的，在不同区域的卷积用的是同一个参数。所以在2019年的时候，这篇文章的作者看到Self-Attention已经被广泛运用于NLP领域，所以就想到了用Self-Attention来增强卷积，并且使用基于相对位置的Positional Encoding用于解决上述说的等变问题^[3]。

Flatten和Attention层

先介绍会在这个部分中使用的一些数学符号:

• $H, W, F_in$是指特征图中高度、宽度、输入feature map的数量
• $N_h, d_v, d_k$是指head的数量，value和key的维度。其中$N_h$是可以整除$d_v$和$d_k$的。
• $d^h_v, d^h_k$是指每一个head中value和key的维度。

Fig. 5. Attention Augmented Convolution的计算过程. Adapted from ^[3]

第一步是需要将输入的特征图进行flatten，从$(H,W,F_in)$变成一个新矩阵$X\in \mathbb{R}^{HW\times F_{in}}$。然后把它放进标准的Multi-head Attention(MHA)层中，于是输出它的输出则是，
$$O_h=Softmax(\frac{(XW_q)(XW_k)^T}{\sqrt{d^h_k}})(XW_v)$$

Positional Encoding

在这篇文章，作者使用了一个基于像素的相对位置的Positional Encoding，专门用于图像分析。其实这个相对位置的Positional Encoding之前已经提出，具体的可以参考这篇^[7]。

它的计算方式是

$$l_{i,j}=\frac{q_i^T}{\sqrt{d_k^h}}(k_j+r^W_{j_x-i_x}+r^H_{j_y-i_y})$$

其中$r$是Positional Encoding，$i$是当前token所代表的像素，$j$是计算Self-Attention时的目标像素，而$x$和$y$则是像素的位置。将这个计算向量化后，

$$O_h=Softmax(\frac{QK^T+S_H^{rel}+S_W^{rel}}{\sqrt{d^h_k}})V$$

这篇作者也提到，根据他们的实验，最好的效果是同时使用传统卷积层和Attention层的输出，所以以上的结果要通过一个简单的拼接层来获得。

$$AAConv(X)=Concat[Conv(X),MHA(X)]$$

实验结果

首先是每篇论文都会提到的自己的方法比别人强。

Fig. 6. Attention Augmented用于分类的实验结果. Adapted from ^[3]

可见，用于一些传统的CNN模型，用Attention增强卷积的方法可以得到更好的结果。对于COCO数据集的对象检测也是一样的，这里就不再赘述了。

不过其中最有趣的还是Positional Encoding的对比。

Fig. 7. Positional Encoding是否使用的对比结果. Adapted from ^[3]

能看到这个Positional Encoding真的是很有用，所以在Transformer中的Self-Attention层中基本人人都会用它。

E2E的Transformer对象检测

在2020年的时候，一篇论文^[4]提出了一个E2E的Transformer对象检测模型Detection Transformer (DETR)，它非常有开创性的使用Transformer结构实现了一个完全端到端的训练方式。这有什么好处呢？首先之前的对象检测模型很多都是需要Proposal，Anchor，或者Window之类的容易出错，而且还需要一些人工处理，比如说非最大值抑制等等。这些东西在一定程度上会影响模型的性能。如果能使用E2E的模式避免人工处理的情况下训练，那就能解决这个问题。

首先来看一下它的结构。

Fig. 8. DETR结构. Adapted from ^[4]

这个结构是由一个骨干网络，Positional Encoding，Transformer，以及一个FFN预测头组成的。让我们一个一个看。

骨干特征提取器

首先是第一步的backbone，这一部分在原文中是一个CNN的特征提取器，需要从图像中提取出高价值的特征图。在原文中对于一个图像为$x_{img}\in \mathbb{R}^{3\times H_0 \times W_0}$，在骨干网络后将会变成一个特征图$f\in \mathbb{R}^{C\times H\times W}$。他们设定的值是$C=2048$ $H,W=\frac{H_0}{32},\frac{W_0}{32}$ 。

Transformer部分

通过骨干网络得到的特征图会通过一个1x1卷积压缩通道数，得到$z_0\in\mathbb{R}^{d\times H\times W}$。因为这个Transformer编码器希望得到一个序列作为输入，所以不能用一个三维的矩阵，需要压平成二维。这个特征图将会被flatten到$(d\times HW)$。对于每一层Transformer编码器，都有一个Self-Attention层和FFN，就像原版Transformer一样。作者还特地说明了，对于每一层，都添加了一个固定的不可训练的Positional Encoding加到输入中去。对于Self-Attention层和Transformer编码器部分相信大家都很熟悉了，但是这个网络还使用了Transformer解码器部分，这需要好好看看。

Fig. 9. DETR中的Transformer部分. Adapted from ^[4]

这里我们可以看到，它并没使用原版Transformer中的Masked Multi-Head Self-Attention层，可能是因为原版的是对于时间序列的预测所以需要遮盖未来时间的序列元素，但是这里是图像分析，则不需要这些。然后是对于编码器的Attention层，和解码器的第二个Attention层，都使用了Positional Encoding，而且是每一层都会使用。

这里的Object queries其实是一个可学习的参数，原文中设定的长度是$N=100$。剩下的都是一些相加融合，根据这张图应该是很容易理解的。

FFN预测头

在解码器的输出得到嵌入序列之后，对于序列中的每一个元素都通过两个FFN网络，一个用于预测类型，一个用于预测Box。

这些FFN在原文中使用的是一个3层MLP和ReLU。对于一个91个类的多分类问题，这里的类型预测FFN会输出一个92长度的向量，多出来的一个代表”没有对象($\phi$)”。这个预测Box会被编码成中心坐标(x, y)和宽度高度(w, h)，也就是长度为4的向量。由于这个预测框的数量等于Object Queriesd的数量$N$且是固定且有限的，所以必须要远大于实际可能的预测框数量。

损失函数

因为预测出的是长度为$N$的一系列无序的box，而ground truth是一个长度远小于$N$的序列。所以在计算损失时，需要将预测的box和ground truth进行匹配。这里需要搜索到一个有最小损失值的box匹配，然后计算这个最小损失。这个匹配$\sigma$是:

$$\hat{\sigma}=\mathop{\arg\min}_{\sigma\in\mathfrak{S}_N}\sum^N_i \mathcal{L}_{match}(y_i,\hat{y}_{\sigma(i)})$$

对于这个问题，使用Hungarian算法可以有效的解决，找到ground truth和预测结果的最优匹配。这里的$\mathcal{L}_{match}$是一个二分图匹配的损失函数，其中$y_i$是ground truth的第i个box，$\hat{y}_{\sigma(i)}$是预测的第i个box。对于第i个预测$\sigma(i)$，定义类别$c_i$的概率是$\hat{p}_{\sigma(i)}(c_i)$，预测的box是$\hat{b}_{\sigma(i)}$。定义这个损失函数为：

$$\mathcal{L}_{match}=-\mathbb{1}_{\{c_i\neq\emptyset\}}\hat{p}_{\sigma(i)}(C_i)+\mathbb{1}_{\{c_i\neq\emptyset\}}\mathcal{L}_{box}(b_i,\hat{b}_{\sigma(i)})$$

与上面的等式结合，可以得到Hungarian损失函数，

$$\mathcal{L}_{Hungarian}(y,\hat{y})=\sum^N_{i=1}[-log\hat{p}_{\hat{\sigma}(i)}(C_i)+\mathbb{1}_{\{c_i\neq\emptyset\}}\mathcal{L}_{box}(b_i,\hat{b}_{\hat{\sigma}}(i))]$$

其中的$\hat{\sigma}$是上面找到的最佳匹配方式。

对于box损失，这里使用GIOU损失函数^[8]。

再对L1损失和IOU损失进行线性组合，得到最终的损失函数，

$$\mathcal{L}=\lambda_{iou}\mathcal{L}_{iou}(b_i,\hat{b}_{\sigma(i)})+\lambda_{L1}||b_i-\hat{b}_{\sigma(i)}||_1$$

其中的$\lambda_{iou}$和$\lambda_{L1}$是超参数。

然而除此之外，他们还使用了解码器辅助损失(Auxiliary decoding loss)。添加到每一个解码器层后面，预测class和box并计算上述损失$\mathcal{L}$。

推断代码

作者们另外提供了一个基于PyTorch的用于推断的代码，放在这里有助于理解。

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

import torch
from torch import nn
from torchvision import resnet50

class DETR(nn.Module):

  def __init__(self, num_classes, hidden_dim, nheads, num_encoder_layers, num_decoder_layers):
    super().__init__()
    # We take only convolutional layers from ResNet-50 model
    self.backbone = nn.Sequential(*list(resnet50(pretrained=True).children())[:-2])
    self.conv = nn.Conv2d(2048, hidden_dim, 1)
    self.transformer = Transformer(hidden_dim, nheads, num_encoder_layers, num_decoder_layers)
    self.linear_class = nn.Linear(hidden_dim, num_classes + 1)
    self.linear_bbox = nn.Linear(hidden_dim, 4)
    self.query_pos = nn.Parameter(torch.randn(100, hidden_dim))
    self.row_embed = nn.Parameter(torch.randn(50, hidden_dim // 2))
    self.col_embed = nn.Parameter(torch.randn(50, hidden_dim // 2))

  def forward(self, inputs):
    x = self.backbone(inputs)
    h = self.conv(x)
    H, W = h.shape[-2:]
    pos = torch.cat([
        self.col_embed[:W].unsqueeze(0).repeat(H, 1, 1),
        self.row_embed[:H].unsqueeze(1).repeat(1, W, 1)
    ], dim=-1).flatten(0, 1).unsqueeze(1)
    h = self.transformer(pos + h.flatten(2).permute(2, 0, 1), self.query_pos.unsqueeze(1))
    return self.linear_class(h), self.linear_bbox(h).sigmoid()

detr = DETR(num_classes=91, hidden_dim=256, nheads=8, num_encoder_layers=6, 
  num_decoder_layers=6
)
detr.eval()
inputs = torch.randn(1, 3, 800, 1200)
logits, bboxes = detr(inputs)

Listing 1: DETR PyTorch推断代码. Adapted from ^[4]

实验结果

他们使用了COCO数据集用于测试这个方法。

Fig. 10. DETR实验结果. Adapted from ^[4]

一言以蔽之，相比于FasterRCNN，DETR更好。

然后他们也测试了一下编码器层的数量，解码器层的数量，辅助损失，FFN，Positional Encoding的重要性，发现都很重要，都是需要的。

Fig. 11. $N$个Object Queries的预测可视化. Adapted from ^[4]

通过上图可以看出，这些预测插槽也已经学习到了box的预测模式，每一个插槽是专注于其中的少数几种box的样式。

Fig. 12. DETR用于图像分割. Adapted from ^[4]

如上图所示，DETR架构也可以用于图像分割，并且也在实验中取得了比其他方法更好的结果。

Transformer和知识蒸馏

在2020年底，ViT发布两个月后，这篇论文《Training data-efficient image transformers & distillation through attention》[5]介绍了他们的新方法Data-efficient image Transformers (DeiT)，这是一个用少量数据和时间训练，就可以达到SOTA水平的方法。对于一个差不多参数量的ViT，需要一个Cloud TPU v3训练83天。而对于DeiT，只需要4个GPU训练3天，可见效率提升很大。

此外，之前的ViT需要在谷歌未公开的数据集JFT-300M用3亿张图片进行训练，而这个只需要在公开的ImageNet上训练就已经能达到SOTA的水平，所以这个模型是data-efficient的。

它主要的方法是通过知识蒸馏(knowledge distillation)的方法，并且做了不少实验，对比了不同的实验设定有怎样的效果。

它的基本结构如下图所示。

Fig. 13. DeiT架构. Adapted from ^[5]

知识蒸馏

知识蒸馏是一种知识训练方法，其中知识是由一个预训练的教师模型和一个需要训练的学生模型组成。知识蒸馏除了能有效的压缩模型，还能有效的提升学生模型的性能。

由Fig. 13可以看出，相比于之前的ViT，它多了一个知识蒸馏的部分。首先是输入部分，除了左下角的class token之外，还增加了一个右下角的distillation token。这个distillation token经过Transformer会输出一个值用于计算蒸馏损失。

蒸馏损失

关于蒸馏损失，这篇文章给出了两种方法，分别是硬蒸馏和软蒸馏。

$$\mathcal{L}_{dis}^{hard}=\frac{1}{2}\mathcal{L}_{CE}(\psi(Z_s),y)+\frac{1}{2}\mathcal{L}_{CE}(\psi(Z_s),y_t)$$

$$\mathcal{L}_{dis}^{soft}=(1-\lambda)\mathcal{L}_{CE}(\psi(Z_s),y)+\lambda\tau^2KL(\psi(Z_s/\tau),\psi(Z_t/\tau))$$

其中，$Z_t$是教师模型的logits输出，$Z_s$是学生模型的logits输出，$y_t$是老师模型的label，$y$是ground truth。$\tau$是超参数蒸馏温度，$\lambda$是蒸馏损失和交叉熵损失的比例。另外，$\mathcal{L}_{CE}$指的是交叉熵损失，$\psi()$指的是sigmoid函数。

根据作者的实验结果，硬蒸馏的训练效果更好。

教师模型的选择

Fig. 14. 教师模型的实验结果对比. Adapted from ^[5]

作者对不同的教师模型进行了横向对比，根据上图的实验结果，可以看出使用CNN的效果要比Transformer更好。

其他超参数

作者对于训练用的很多参数都做了实验对比测试，其中包括学习率，参数初始化方法，weight decay，dropout，还有数据增强，优化器和正则化等等。对于详细的内容请参考原文，因为仅仅是实验结果而已，这里就不多做展示了。

这篇文章给Transformer使用知识蒸馏提供了很多意见和想法，如果在未来需要用一些比较高效的方法来训练Transformer，可以参考这篇文章。

参考文献

• [1] A. Vaswani et al., “Attention is all you need,” in Proceedings of the 31st International Conference on Neural Information Processing Systems, Red Hook, NY, USA, Dec. 2017, pp. 6000–6010.
• [2] A. Dosovitskiy et al., “An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale,” arXiv:2010.11929 [cs], Oct. 2020, [Online]. Available: http://arxiv.org/abs/2010.11929.
• [3] I. Bello, B. Zoph, A. Vaswani, J. Shlens, and Q. V. Le, “Attention Augmented Convolutional Networks,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, 2019, pp. 3286–3295, [Online]. Available: https://openaccess.thecvf.com/content_ICCV_2019/html/Bello_Attention_Augmented_Convolutional_Networks_ICCV_2019_paper.html.
• [4] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko, “End-to-End Object Detection with Transformers,” in Computer Vision – ECCV 2020, Cham, 2020, pp. 213–229, doi: 10.1007/978-3-030-58452-8_13.
• [5] H. Touvron, M. Cord, M. Douze, F. Massa, A. Sablayrolles, and H. Jegou, “Training data-efficient image transformers & distillation through attention,” in International Conference on Machine Learning, Jul. 2021, pp. 10347–10357. Accessed: Jul. 22, 2021. [Online]. Available: http://proceedings.mlr.press/v139/touvron21a.html
• [6] S. Khan, M. Naseer, M. Hayat, S. W. Zamir, F. S. Khan, and M. Shah, “Transformers in Vision: A Survey,” arXiv:2101.01169 [cs], Feb. 2021, Accessed: Apr. 23, 2021. [Online]. Available: http://arxiv.org/abs/2101.01169
• [7] P. Shaw, J. Uszkoreit, and A. Vaswani, “Self-Attention with Relative Position Representations,” arXiv:1803.02155 [cs], Apr. 2018, Accessed: Jul. 25, 2021. [Online]. Available: http://arxiv.org/abs/1803.02155
• [8] H. Rezatofighi, N. Tsoi, J. Gwak, A. Sadeghian, I. Reid, and S. Savarese, “Generalized Intersection Over Union: A Metric and a Loss for Bounding Box Regression,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2019, pp. 658–666. Accessed: Jul. 26, 2021. [Online]. Available: https://openaccess.thecvf.com/content_CVPR_2019/html/Rezatofighi_Generalized_Intersection_Over_Union_A_Metric_and_a_Loss_for_CVPR_2019_paper.html

深度学习中最一开始的Transformer是2017年推出的，非常强力^[1]。可能当时作者觉得这个东西很强，所以才会赋予”变形金刚”的名字吧。而后来，Transformer也广泛的推广到了计算机视觉(CV)领域，从2020年开始，就有对Transformer在CV中的大量新研究发表。

本文主要会讲最初的Transformer，Vision Transformer(ViT)和Multi-scale Vision Transformer(MViT)。

最初的Transformer

解决并行问题

最初的Transformer是来源于这篇，”Attention is all you need”，用于自然语言处理(NLP)的机器翻译任务的。以前的RNN(包括LSTM^[2], GRU^[3])层计算并不能并行，因为一个序列中的某一个元素的计算是要基于别的元素的。如下图所示。

Fig. 1. RNN layer. Adapted from ^[4]

其中$a^1$到$a^4$都是一个序列中的token，RNN层可以看到一个序列中的全部信息，包括位置信息。但是这里每一个token的计算需要其他token的计算结果，所以无法做到并行化提高效率。

Fig. 2. Convolutional layer. Adapted from ^[4]

如上图所示, 使用卷积层^[5]虽然可以并行计算，但是覆盖面积受到卷积核(kernel)的限制，无法在距离比较远的token中提取特征。

Fig. 3. Stacked convolutional layer. Adapted from ^[4]

如上图所示，很多人会通过将卷积层堆叠起来以达到提取更多特征的目的，但是这个覆盖范围其实依然并不是很宽，而且也需要更多的计算。

我们需要的是一个有长时记忆，并且可以并行处理的结构。所以这篇论文提出了Self-attention机制和Multi-Head Attention Layer。

Fig. 4. Calculation of $K^i$ and $Q^i$ in self-attention layer. Adapted from ^[4]

首先，我们有一个输入序列，从$x^1$到$x^4$。在Embedding之后，会将每一个token转换成1-D vector，$a^1$到$a^4$。使用3个线性层分别对应Q，K，V的权重，则可以把$z^i$转换成Q (Query)，K (Key)，V (Value)的向量。这个计算方式如下所示。
$$
\begin{split}
q^i &= W^qa^i \\
k^i &= W^ka^i \\
v^i &= W^va^i
\end{split}
$$
我们以第一个token作为例子，需要用$q^1$与所有token的$k$相乘，从而求得$\alpha_{1,1}$到$\alpha_{1,4}$。之后，通过一个softmax进行标准化使得它们的和为1，得到$\hat{\alpha}_{1,1}$到$\hat{\alpha}_{1,4}$。

Fig. 5. Calculation of $b^i$ in self-attention layer. Adapted from ^[4]

然后，再对计算出来的$\hat{\alpha}_{1,1}$到$\hat{\alpha}_{1,4}$和$v$相乘求和。以第一个token为例，它的attention层输出是，
$$
b^1 = \sum_i\hat{\alpha}_{1,i}v^i
$$

重复同样的步骤，则可以得到$b_1$到$b_4$。以上的步骤看起来计算相当的复杂，但是其实可以通过几个比较简单的矩阵运算即可完成，所以它是可以很容易通过GPU进行并行计算的。

Fig. 6. Matrix multiplication form in self-attention layer. Adapted from ^[4]

左上角的$O$代表output，$I$代表input。而这个$I$则是将所有的输入$a_i$叠起来变成一个2D矩阵。而以上的全部需要一个一个迭代计算的过程都可以用矩阵乘法的方式实现，总的计算其实很方便。正因为这个容易进行并行计算，所以在运算速度上是快于RNN的。

Transformer结构

Fig. 7. Scaled dot product attention. Adapted from ^[1]

$$Attention(Q,K,V)=softmax(\frac{QK^T}{\sqrt{d_K}})V$$

如上所示^[1]，这个过程被称为Scaled Dot-Product Attention。你会注意到这个公式里除以一个$\sqrt{d_K}$。根据原文的说明，这个的目的是为了把值重新缩放回 Mean = 0, Variance = 1 的状态。

Fig. 8. Multi-head attention. Adapted from ^[4]

除此之外，他们还提出了一个Multi-Head Attention Layer，相比于普通的attention层，这个多头attention层有多个attention层互相并行。最后把多个并行的attention层拼接，再通过一个全连接层进行映射，把维度保持在和输入相同的状态。

Fig. 9. Transformer structure. Adapted from ^[1]

如上图所示，整个Transformer是一个encoder-decoder结构。如果这个Transformer的任务是把英文翻译成中文，那在encoder的inputs这里输入中文句子，在decoder的输入端输入英文句子，decoder的输出则是概率。从encoder开始，输入的token序列会先送入embedding层转换成向量，然后再和positional encoding相加。因为在attention层中输入token并不会知道其中的位置信息，所以需要加一个positional encoding。因为矩阵相加可以视为拼接的一种特殊情况，所以通过embedding和positional encoding相加，attention层可以同时获取两者的信息，提取的特征更有效率。这个positional encoding可以是自己手动设定的，也可以是通过学习的。在这篇文章下用的是手动设定的。相加之后，会有4条路线，1条是类似于ResNet^[6]的恒等连接，而另外3条则是通过对应的全连接层得到Q,K,V，再输入进attention层。在结束了multi-head attention层的计算之后，接下来是一个Add & Norm层，这个层的过程就是将attention层的输入和输出相加，并且做一个layer normalization(LN)^[7]。

Fig. 10. Layer normalization. Adapted from ^[4]

如上图所示^[4]，和常用的batch normalization(BN)^[8]相比，主要是标准化的维度不同。LN是在一个输入中跨通道的标准化，BN是在一个batch中跨数据但是在同一个通道下进行标准化。在sequence数据中，一般使用LN而不是BN。

然后是decoder部分，这里的decoder的输入，也就是机器翻译的结果是需要右移一位的(shifted right)，因为第一位是<BOS>标签，作为一个句子的开头。对比encoder和decoder，主要区别在于decoder的第一层是一个Masked Multi-Head Attention。因为对于一个基于时间序列的预测来说，当然是不能通过未来的信息去预测的，所以在这个Masked Multi-Head Attention层中，所有的token输入只能看到前面的信息，而后面的信息都会被隐藏。

在这个Masked Multi-Head Attention层之后，会有一个普通的Multi-Head Attention，但是其中的Q和K是来源于encoder计算的结果，只有V是来自于上一层的输出。个人理解是Q和K可以寻找不同token在这个sequence之间的相关性，所以encoder的输出要拿来给decoder使用。

Fig. 11. Transformer inference. Adapted from ^[4]

如上图所示^[4]，在预测的时候，因为不知道翻译的结果，所以只能一个一个预测，将第一个预测出的词放到这个序列的第二个输入才能依次预测出整个句子。在训练的时候因为知道了全部内容，所以可以并行，但是在预测中是不行的。

尝试把Transformer用于CV

在Transformer发布之后，有很多研究在尝试把Transformer结果用于CV。

Fig. 12. Attention augmented convolutional network. Adapted from ^[9]

比如这一篇^[9]，同时使用传统的卷积和新的Self-Attention机制用于计算机视觉相关的任务。

Fig. 13. Object detection transformer. Adapted from ^[10]

而这一篇^[10]，则仅仅用CNN替代原始Transformer中的Embedding过程，剩下的都与原版^[1]很像。同样是完整的Transformer encoder和decoder，还有positional encoding，最后生成的结果也是一个个box用于对象检测(object detection)。这个过程已经和原版很像了。

关于这两篇的详解，已经在续篇中详细介绍。

Vision Transformer

之前的研究很少有讲Transformer直接用在CV上的，而且用上了速度也很慢。在2020年年底，有一篇论文，”An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale”，提出了Vision Transformer (ViT)^[11]，提供了另一种方法让本来用于NLP的Transformer可以直接用在CV上。在ViT中，每一个Transformer的token其实是一个图片的patch，这也是标题这么起的原因。在这篇论文中，这个ViT主要是用于最基础的图像分类任务。

Fig. 14. Vision transformer. Adapted from ^[11]

具体步骤

一开始我们有一个图片$x$，高度$H$，宽度$W$，通道数$C$。对于RGB图像来说$C=3$。
$$x\in H\times W\times C$$

正如之前所说，我们先需要讲这个图片分成一块一块patch，然后将一个patch中的所有数值全部暴力的压扁到一维向量。假设patch都是正方形，边长为$P$，一个图片中的patch数量为$N$。则,
$$x_p\in N \times (P^{2}C)$$
其中，
$$N=\frac{HW}{P^2}$$
所以我们是将一个patch本来为三维矩阵$(P\times P \times C)$直接摊平为一维向量，长度为$P^{2}C$。而因为有$N$个patch，所以最后的结果是$N \times (P^{2}C)$的二维矩阵。这个形状是符合Transformer输入的。

然而$P^{2}C$的长度可能太长了，于是我们可以使用一个线性映射将维度降低到$N\times D$，其中$D$是新的patch向量的长度。把降维之后的矩阵记为$z_p$。
$$z_p\in N\times D$$

然后，我们需要增加一个可训练的token，$z_{class}$，放到整个$Z$的第一位，并且加上一个可训练的positional encoding。
$$Z=[z_{class},z_p^1,z_p^2,z_p^3,\cdots,z_p^N]+E_{pos}$$
由这些新的向量组成的矩阵加上positional encoding $E_{pos}$，得到的结果的矩阵记为$Z$。

这些东西就可以直接放进一个Transformer encoder，得到的结果也是一个sequence，但是只取第一个，也就是$z_{class}$对应的输出。将这个向量放入一个MLP用于分类，得到分类结果$\hat{y}$，与label $y$一起计算loss并反向传播训练整个ViT。

Class Token

根据原文，这个是从BERT^[12]的结果中拿过来的，因为使用一个可训练的token，会比使用别的token的结果用于分类更加公平，因为不会受到原先包含信息的影响。

Fig. 15. BERT. Adapted from ^[12]

Positional Encoding

Fig. 16. Positional encoding in ViT. Adapted from ^[11]

然后是关于positional encoding的。这张图展示了positional encoding的相似度，越亮说明越相似。我们可以看到，对于每一个patch，在相似行和列的patch的相似度是较高的，而那些距离比较远的相似度则较低。这说明一个可训练的positional encoding是可以学到其中的位置关系的。

Fig. 17. Attention distance. Adapted from ^[11]

这张图展示了attention距离和网络深度的关系。x轴是网络深度，y轴是平均attention的patch之间的距离，不同的点代表不同的head找到的attention。很显然，在网络很浅的时候，attention层依然能找到距离较远的关系。如果这是一个CNN网络，那这个结果就应该会分布在这张图中一堆散点的下边缘。所以不用特别深的网络，ViT依然能学到这张图的全局特征。

Multiscale Vision Transformer

在之前的ViT^[11]中，实际上每一个attention层的输入输出维度都是一样的，所以attention层只是在一个scale上进行检测。这篇2021年的论文提出了Multiscale Vision Transformer (MViT)[13]。大家都知道，在CNN中经过了数层卷积层之后会有一个降采样层降低特征图的长宽，这样之后的卷积层将能提取到不同scale的特征。这篇论文想通过同样的方式来把这个multi-scale的想法用在ViT上。

Fig. 18. Multiscale vision transformer. Adapted from ^[13]

如上图所示^[13]，他们提出了Multi-Head Pooling Attention (MHPA)层。很显然，最大的区别就在于对于每一条路上都加了一个pooling层。在这些pooling层之后，那些向量的长度就会降低，这样后面的attention层就能检测到不同scale的特征了。

Fig. 19. MViT structures. Adapted from ^[13]

在这篇文章里，他们提出两个MViT的结构，分别是MViT-B和MViT-S，用于视频分析的。他们把一整个网络分成了多个stage。在第一个stage中是读取数据，因为视频是用3D矩阵表示，切分patch也是3D，所以patch在这里被成为cube。然后在后面的stage中，cube的长度和宽度都不断降低，而通道数则不断增加。在最终的实验结果中，MViT的表现要优于之前的ViT模型，而且参数数量也更少了，运行速度也更快了。

推荐一个GitHub Repository

这里推荐一个GitHub repo，叫Awesome Visual-Transformer，里面收录了许多用于CV的Transformer论文和官方实现的code链接^[14]。
https://github.com/dk-liang/Awesome-Visual-Transformer

参考文献

• [1] A. Vaswani et al., “Attention is all you need,” in Proceedings of the 31st International Conference on Neural Information Processing Systems, Red Hook, NY, USA, Dec. 2017, pp. 6000–6010.
• [2] S. Hochreiter and J. Schmidhuber, “Long Short-Term Memory,” Neural Computation, vol. 9, no. 8, pp. 1735–1780, Nov. 1997, doi: 10.1162/neco.1997.9.8.1735.
• [3] K. Cho et al., “Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation,” arXiv:1406.1078 [cs, stat], 2014.
• [4] "Transformer & BERT", Speech.ee.ntu.edu.tw, 2021.
• [5] Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner, ‘Gradient-based learning applied to document recognition’, Proceedings of the IEEE, vol. 86, no. 11, pp. 2278–2324, Nov. 1998, doi: 10.1109/5.726791.
• [6] K. He, X. Zhang, S. Ren, and J. Sun, “Deep Residual Learning for Image Recognition,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2016, pp. 770–778.
• [7] J. L. Ba, J. R. Kiros, and G. E. Hinton, “Layer Normalization,” arXiv:1607.06450 [cs, stat], 2016.
• [8] S. Ioffe and C. Szegedy, “Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift,” in International Conference on Machine Learning, Jun. 2015, pp. 448–456.
• [9] I. Bello, B. Zoph, A. Vaswani, J. Shlens, and Q. V. Le, “Attention Augmented Convolutional Networks,” in Proceedings of the IEEE/CVF International Conference on Computer Vision, 2019, pp. 3286–3295.
• [10] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko, “End-to-End Object Detection with Transformers,” in Computer Vision – ECCV 2020, Cham, 2020, pp. 213–229, doi: 10.1007/978-3-030-58452-8_13.
• [11] A. Dosovitskiy et al., “An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale,” arXiv:2010.11929 [cs], Oct. 2020.
• [12] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova, “BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding,” in Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), Minneapolis, Minnesota, Jun. 2019, pp. 4171–4186, doi: 10.18653/v1/N19-1423.
• [13] H. Fan et al., “Multiscale Vision Transformers,” arXiv:2104.11227 [cs], Apr. 2021.
• [14] "dk-liang/Awesome-Visual-Transformer", GitHub, 2021. [Online]. Available: https://github.com/dk-liang/Awesome-Visual-Transformer.