四种 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

URL

https://arxiv.org/pdf/2109.09310.pdf

TL；DR

• 本文提出一种多功能的卷积核，可以有效提高算法效果，降低计算量与存储空间
• 具体做法是：将 一个 主卷积核与 多个 二值 mask 点积生成 多个次级卷积核，用次级卷积核进行计算
• 二值 mask 包括 H、W、C 方向，即每个次级卷积核的 H、W、C 都可能不同

Algorithm

思路

• 神经网络轻量化（参数量与计算量）常用方法：
  • 模型压缩，主要包括：
    • 权重分解
    • 网络剪枝
    • 权重量化
    • 知识蒸馏
  • 网络结构轻量化，主要包括：
    • Xception
    • MobileNet series
    • ShuffleNet series
    • OctConv
    • MixConv
• 本论文思路：
  • 将 一个 主卷积核与 多个 二值 mask 点积生成 多个次级卷积核
  • 二值 mask 作用在 H、W、C 上，所以每 个次级卷积核的感受野可能不同，关注的 channel 可能不同

网络设计

在空间方向设计多功能卷积

• 空间方向就是指 H、W 方向

• 图中用一个极端例子演示，实际上二值 mask 不是由人手工设计的，而是神经网络自动学习得到

• 普通卷积计算过程：

  • $input:\ x\in\mathbb{R}^{H\times W\times c}$
  • $filter:\ f \in\mathbb{R}^{d\times d\times c}$
  • $output:\ y = f @ x\ \ ,\ \ \ y\in\mathbb{R}^{H'\times W'}$ （“@” means convolution operation）

• 多功能卷积计算过程（在空间方向上）：

  • $filter:\ f \in\mathbb{R}^{d\times d}$
  • $binery\ mask:\ M_i(p,q,c) = \begin{cases} 1,\ if\ p,q \ge i \mid p,q \le d+1-i\\ 0,\ otherwise \end{cases}$
  • $secondary\ filter:\ \{\hat{f}_1,\ \hat{f}_2,\ ...\ ,\hat{f}_s\}\ \ ,\ \ \ \ s=\lceil \frac{d}{2} \rceil\ ,\ \ \ \hat{f}_i = M_i \circ f$
  • $output: \ y = [(M_i\circ f)\ @\ x + b_1, ...\ , (M_s\circ f)\ @\ x + b_s],$
    $s.t.\ s = \lceil \frac{d}{2} \lceil,\ { M_i }^{s_{i=1}\in{0, 1}}{d\times d\times c}\ $

  “[]” means concat，$b_i$ means bias

  • naive version：$output:\ y = \sum_{i=1}^s(M_i\circ f)\ @\ x + b = [\sum_{i=1}^s(M_i)\circ f]\ @\ x + b,$

  $ s.t.\ s = \lceil \frac{d}{2} \lceil,\ { M_i }^{s_{i=1}\in{0, 1}}{d\times d\times c}\ $

在 Channel 方向设计多功能卷积

• 在卷积神经网络中 C >> H、W，所以在 Channel 方向设计多功能卷积非常必要

• 数学表示：

  • $y = [\hat{f}_1\ @\ x_1,\ ...\ ,\hat{f}_n\ @\ x_n]$

  $ s.t.\ \ \forall i, \hat{f}_i \in \mathbb{R}^{d\times d\times c},\ \ n = (c - \hat{c})/g+1$

  • 其中：
    • 省略 bias
    • g means channel-wise stride
    • $\hat{c}$ means non-zeros channels
    • n means 一个 filter 用几次
    • [] means concat

学习策略

mask 具体如何设计

• mask 两种设计策略：
  • 方案 a：每个主卷积核共享一套二值 mask
  • 方案 b：每个二值 mask 只用一次
• 实验证明，方案 b 效果更好，原因是：方案 b 中二值 mask 的假设空间更大

如何让主卷积核对应的多个二值 mask 相似性

• 极端情况：如果一个主卷积核对应的所有二值 mask 都相同，那理论上模型效果与只是用主卷积核运算表现基本相同

• 所以需要加入一种使得 同一个主卷积核对应的多个每个二值 mask 更倾向不同 的损失函数

• 损失函数数学表示：

  • $\min_{F,M}\mathcal L = \mathcal L_0(F,M) + \lambda\mathcal L_{ortho}(M)$
  • $M = [vec(M_1),\ ...\ ,vec(M_s)]$

  $ \mathcal{L}_{ortho} = \frac{1}{2} \lVert \frac{1}{d^2c}MTM-I\rVert_F^2$

  • 其中：
    • $\mathcal{L}_{ortho}$ means loss of Orthogonal（正交损失）
    • $\mathcal{L}_0$ means 任务相关 loss
    • $M_i$ 表示一个主卷积核的一个二值 mask
    • 正交矩阵的性质：
      • 假设 M 是一个正交矩阵，则 $M^TM=I$
      • 正交矩阵的列向量线性无关

对主卷积核的优化方法

• 总 loss 包括 任务相关 loss 和 mask 正交 loss
• 只有 任务相关 loss 与主卷积核相关
• $\frac{\partial\mathcal L}{\partial f_i} = \frac{\partial\mathcal L_0}{\partial f_i} = \sum_{j=1}^{s}\frac{\partial\mathcal L_0}{\partial \hat f_{ij}}\circ M_j$
• $\frac{\partial\mathcal L}{\partial F} = [\frac{\partial\mathcal L_0}{\partial f_1},\ ....\ ,\frac{\partial\mathcal L_0}{\partial f_k}]$
  • 其中 k 表示主卷积核的个数
• $F \leftarrow F - \eta \frac{\mathcal L}{F}$

对二值 mask 的优化方法

• 先将 $\mathcal L_{ortho}$ 展开：
  • $\mathcal L_{ortho} = \frac{1}{2}Tr[(\frac{1}{d^2c}M^TM-I)(\frac{1}{d^2c}M^TM-I)^T] = \frac{1}{2}Tr[\frac{1}{d^4c^2}M^TMM^TM - 2\frac{1}{d^2c}M^TM+I]$
• 所以：
  • $\frac{\partial\mathcal L_{ortho}}{\partial M} = \frac{1}{2}(\frac{4}{d^4c^2}MM^TM - \frac{4}{d^2c}M) = \frac{2}{d^4c^2}MM^TM - \frac{2}{d^2c}M$
• $\because$ 交换门，$\therefore \frac{\partial\mathcal L_{0}}{\partial M_j} = \sum_{i=1}^k\frac{\partial\mathcal L_{0}}{\partial\hat f_{ij}}\circ f_i$
• $\frac{\partial\mathcal L}{\partial M} = [\frac{\partial\mathcal L_0}{\partial M_1},\ ...\ , \frac{\partial\mathcal L_0}{\partial M_s}] + \lambda \frac{\partial\mathcal L_{ortho}}{\partial M}$
• 因为 M 是 binary 的离散值，所以需要一个代理的连续变量 H，实现 直通估计器 STE 的作用
• $M = sign(H),\ \ \ H = clip(H,0,1)$
• $\frac{\partial\mathcal L}{\partial M}=\frac{\partial\mathcal L}{\partial H}$
• $\begin{cases} H\leftarrow M\\ H\leftarrow clip(H-\eta \frac{\partial\mathcal L}{\partial H},0,1) \end{cases}$
  

Thought

• 这篇文章在 2018 年就已经发表在 nips 上了，最近做了一些详细实验后重新挂在了 arxiv 上了
• 本文实验非常详细，虽然没有开源，前向计算和反向计算的数学推导很精彩~~（敲 latex 敲的想哭）~~，像一篇 survey
• 这篇文章 inference 阶段有点重参数化的感觉，RepMLP 思想和本文有点相似
• STE 部分让我想起了 DoReFa-Net 😂

URL

https://arxiv.org/pdf/2110.07641.pdf

TL;DR

• 本文提出一种浅层神经网络 ParNet，12层深度可以在 ImageNet 上达到 80.72% 准确率的效果
• 将网络变宽，因为多个横向 Branch 可以并行计算，而纵向深度只能顺序计算
• 将 RepVGG 和 SENet 的结构合并成了 RepVGG-SSE 结构
• ParNet 表示 parallel substructure network

Algorithm

整体结构

• 使用 SENet 结构的原因：网络深度过浅，下采样次数太少，只能通过 SE 结构获得全局信息
• 使用 RepVGG 结构的原因：结构重参数化白给的涨点，不要白不要
• 使用三个分支的原因：
  • 三个分支分别处理不同分辨率级别的 feature，最终 fusion
  • 选 “三” 是效果和速度的 tradeoff
• 如何做 model scale:
  • 传统网络（例如 ResNet）做 model scale 的方法：
    • 缩放 H、W：减少下采样次数
    • 增加 C：增加卷积核数量
    • 增加深度：堆叠 block
  • ParNet 做 model scale 的方法：
    • 增大 H、W：减少下采样次数
    • 增加 C：增加卷积核数量
    • 增加 Stream：增加横向 Branch 数量
• SSE 是指 Skip-Squeeze-and-Excitation：为降低网络层数，将 SE 结构中 GAP 后的 feature 做一层 Conv 而不是两层 MLP
• $SiLU(x) = x * sigmoid(x)$
• 本网络除了 SSE 结构之外，没有跳边连接

效果

这个图有点不公平，因为横坐标表示层数而不是参数量

• 和 ResNet 对比
  
• 对下游任务也有涨点加速的作用
  

URL

https://arxiv.org/pdf/2103.16788.pdf

TL;DR

• 本文提出一种 动态可扩展表征增量学习方法，目前是增量学习的 SOTA
• 提出一种两阶段（表征学习阶段 和 分类学习阶段）的增量学习方法，更好的平衡 stability-plasticity （稳定性与可塑性）

Algorithm

问题定义

• $\mathcal{D}_t$ 表是第 t 次增量学习的数据集，$\mathcal{M}_t$ 表示第 t 次增量学习前的模型（已隐含前 t-1 次增量学习的所有数据），现可获得的所有数据 $\tilde{\mathcal{D}}_t=\mathcal{D}_t\cup\mathcal{M}_t$，用 $\tilde{\mathcal{D}}_t$ 去训练一个新的模型（表征器 + 分类器）

整体结构

表征学习阶段

• 目的：为 $\tilde{\mathcal{D}}_t$ 训练一个表征器（特征提取器）
• 具体做法：冻结（eval 模式）已有的表征器；为新的增量数据训练一个表征器；两个表征器结果 concat 作为新的表征结果
• $u=\Phi_t(x)=[\Phi_{t-1}(x),\mathcal{F}_t(x)]$，其中，$x \in \mathcal{D}_t$，$\Phi_{t-1}$ 表示已有的（前 t-1 次增量数据训练的）表征器，$\mathcal{F}_t$ 表示为第 t 次增量数据训练的表征器，二者结果 concat 即为新的表征结果 $u$

分类器学习阶段

• 由于新加入数据 $\mathcal{D}_t$ 后，特征 $u$ 的维度和数据分布都发生了变化，所以需要重新训练一个分类器
• $\hat{y} = argmax_{P_{\mathcal{H}_t}} P_{\mathcal{H}_t}(y|x)=softmax(\mathcal{H}_t(u))$，其中 $\mathcal{H}_t$ 表示第 t 次增量学习训练的分类器

算法细节

Training Loss

• $\mathcal{L}_{\mathcal{H}_t} = -\frac{1}{|\tilde{D}_t|}\sum_{i=1}^{|\tilde{D}_t|}log(P_{\mathcal{H}_t}(y=y_i|x_i))$，根据新的表征 $u$ 训练
• 辅助 loss：$\mathcal{L}_{\mathcal{H}_t^a} = -\frac{1}{|\tilde{D}_t|}\sum_{i=1}^{|\tilde{D}_t|}log(P_{\mathcal{H}_t^a}(y=y_i|x_i))$，只训练新表征器 $\mathcal{F}_t$
• 二者加权相加即为可扩展表征损失函数： $\mathcal{L}_{ER}=\mathcal{L}_{\mathcal{H}_t}+\lambda_{\alpha}\mathcal{L}_{\mathcal{H}_t^a}$

动态扩展

• 加入了 Channel-level Masks
• 加入了稀疏正则化：Sparsity Loss
• 可扩展表征损失函数加上稀疏正则化即为最终损失函数： $\mathcal{L}_{ER}=\mathcal{L}_{\mathcal{H}_t}+\lambda_{\alpha}\mathcal{L}_{\mathcal{H}_t^a}+\lambda_s\mathcal{L}_S$

表现

Thought

• 正如题目所说，这种增量学习只适用于类别增量，不适用于数据增量，对于类别固定，数据为流式数据（例如：每日回流的数据）并不适用
• 不适用于流式数据的原因是：这种方法随着增量次数变大，模型会变得越来越大，不适合流式数据这种频繁更新的数据

URL

https://arxiv.org/pdf/2108.13341.pdf

TL;DR

• 本文提出一种 分级重排 (Hierarchical Rearrangement) 的视觉 MLP 网络结构用于图像分类，效果优于 MLP-mixer
• MLP-mixer 存在的问题：
  • 输入尺寸和模型结构强耦合，所以不能将分类模型作为下游任务的预训练
  • flatten 之后，空间的局部信息丢失，只能提取全局信息
• 该论文的优点：
  • 输入尺寸 flexible
  • inference 速度快

Algorithm

• 网络结构
  
  其中，inner-region rearrange 过程为：
  
  cross-region rearrange 过程为：
  
• 数学表示
  $Y = Hire-Module(LN(X)) + X $
  $ Z = Channel-MLP(LN(Y )) + Y$
• 效果
  

URL

https://arxiv.org/pdf/1901.05555.pdf

TL;DR

• 本文提出一种在 不平衡数据分类 场景使用的 Loss —— Class-Balanced Loss
• 提出一个理论模型，对每类的 有效样本数量 进行估计，从而对每类设计损失权重
• 理论可概括为：对某一类的所有样本（样本容量为 n）进行采样，每一次采样，有 p 的概率和之前采样过的样本 重复，有 1-p 的概率不重复，n 越大，冲突可能越大，所以 p 越大
• 该理论模型简化后可用数学归纳法证明，Class-Balanced Loss 最终化简为包含一个超参 $\beta$ 的权重系数

Algorithm

常用的不平衡数据处理方法

• 重采样
  • 对大类欠采样
    • 缺点：学习能力变差
  • 对小类过采样
    • 缺点：过拟合
    • 缺点：训练变慢
  • both
• 重赋权
  • 以类间样本容量比例直接作为权重
    • 缺点：虽然最为常用，但不科学，因为样本容量的比值不能代替样本中有效样本的比值

有效样本

• 本文提出一种类中有效样本的计算方式，类中样本容量用 $n \in \mathbb Z_{>0}$ 表示，有效样本量用 $N \in \mathbb Z_{>0}$ 表示，有效样本的期望用 $E_n \in \mathbb Z_{>0}$ 表示
  $E_n = \frac{1-\beta^n}{1-\beta},\ \ \ \ \beta=\frac{N-1}{N}$
  
• 实际使用时，$\beta$ 为一个超参，取值范围：{0.9, 0.99, 0.999, 0.9999}

实际使用时的损失函数

• 理论模型只提供一个权重，实际使用时还需要结合其他的分类损失函数，例如 [Softmax Loss（交叉熵）, Sigmoid Loss, Focal Loss]

  $CB(p, y) = \frac{1}{E_{n_y}} L(p, y)=\frac{1-\beta}{1-\beta^{n_y}}L(p, y)$

  其中，$p \in [0, 1]$ 表示输入样本 x 后模型输出的各类的概率分布，$y$ 表示样本 x 的 label，$\beta$ 是一个超参数，$L(p, y)$ 是分类常用损失函数

• class-balanced softmax cross-entropy loss
  $CB_{softmax}(z, y) = -\frac{1-\beta}{1-\beta^{n_y}}log(\frac{exp(z_y)}{\sum_{j=1}^C exp(z_j)})$

• class-balanced sigmoid cross-entropy loss
  $CB_{sigmoid}(z, y) = -\frac{1-\beta}{1-\beta^{n_y}}\sum_{i=1}^C log(\frac{1}{1+exp(-z_i^t)})$

• class-balanced focal loss
  $CB_{focal}(z, y) = -\frac{1-\beta}{1-\beta^{n_y}}\sum_{i=1}^C (1-p_i^t)^\gamma log(p_i^t)$
  $\gamma \in \{0.5, 1, 2\}$

Thought

• 理论被不停简化，条件过于理想化，最后变成一个很简单的公式
• 和其他损失函数结合后，准确率比较随机

效果

• 其中 $Imbalanced\ factor = \frac{Sample\ size\ for\ largest\ class}{Sample\ size\ for\ least\ class}$
  
  
  
  

URL

https://arxiv.org/pdf/2007.11301.pdf

TL;DR

• 深度学习在光栅图上取得了极大的成功，但在矢量图上的表示和应用未被探索，矢量图相较于光栅图有无损缩放能力
• 本文给出一种便于深度学习使用的矢量图表示方法，且将 SVG 的最小表示集合缩小为 {<path>}
• 本文提出一个 SVG 数据集 SVG-Icons8

Dataset/Algorithm/Model/Experiment Detail

SVG 图像的结构化表示

• 一个 SVG 由 $N_p$ 个 path 组成，即 $V = \{P_1, ..., P_{N_p}\}$
• 一个 path 由一个三元组表示，即 $P_i = \{S_i, f_i,v_i\},\ \ S_i:shape,\ \ f_i:fill\ property,\ \ v_i: visibility$
• 一个 shape 由 $N_c$ 个 command 组成，即 $S_i = \{N_i^1,...,N_i^{N_c}\}$
• $f_i\in\{0,1,2\}, \ \ v_i\in\{0,1\}$
• 一个 command 由一个二元组表示，即 $C_i^j = (c_i^j,X_i^j)$ ，分别表示 command type 和 argument
• command type $\in$ {<SOS>, <M>, <L>, <C>, <Z>, <EOS>}
• 一个 command argument 由一个六元组表示，即 $X_i^j = (q^j_{x_1,i},q^j_{y_1,i},q^j_{x_2,i},q^j_{y_2,i},x^j_{2,i},y^j_{2,i})$ ，默认值为 -1，使用六元组的原因是对齐 <C> 的参数长度
• 为了简化 $N_c, \ N_p$ 都采用确定值

SVG Embedding

每个 command $C_i$ 被映射到一个 $d_E$ 维的向量 $e_i^j$ ， $e_i^j = e_{cmd,i}^j + e_{coord,i}^j + e_{ind,i}^j$

• command embedding
  $e_{cmd,i}^j = W_{cmd}\ \delta_{c_i^j}\in\mathbb{R}^{d_E}$ ，其中 $W_{cmd} \in \mathbb{R}^{d_E\times 6},\ \ \delta_{c_i^j}\in\mathbb{R}^6,\ \ \delta_{c_i^j}\ is \ one \ hot \ vector$
• coordinate embedding
  $e_{coord,i}^j = W_{coord}\ vector(W_X\ X_i^j)\in \mathbb{R}^{d_E}, \ \ \ X_i^j = [q^j_{x_1,i},q^j_{y_1,i},q^j_{x_2,i},q^j_{y_2,i},x^j_{2,i},y^j_{2,i}] \in \mathbb{R} ^{257 \times 6}$
• index embeding
  $e_{ind,i}^j =W_{ind}\ \delta_j \in \mathbb{R}^{d_E}, \ \ W_{ind}\in\mathbb{R}^{d_E\times N_s},\ \ \ \delta_j\ is \ one\ hot \ vector$

path 标签使用方式

SVG-Icon8 数据集样例

DeepSVG 网络结构

• 一个 VAE 结构，由两层 Encoder 和 两层 Decoder 构成
  

Thoughts

• 本文提出的 SVG 结构化表示有利于应用矢量图作为神经网络的输入
• 本文的 SVG 数据集都是矢量 Icon，只包含 path 标签且无填充无透明度，对于真实光栅图应该用 path 标签 + 填充 + 透明度来表示，即拓展上述的 SVG 表示

URL

https://arxiv.org/pdf/1809.02966.pdf

TL;DR

• 提出一种端到端的可训练的优化方法，通过近似 Hessian 优化方法，解决非线性最小二乘法问题
• 从训练数据中隐式的学习正则化与先验信息
• 第一个将可学习的优化器用于单目视觉光度误差估计任务中

Algorithm

背景知识

非线性最小二乘法求解

• 最小二乘法问题： $E = \frac{1}{2}\sum_{j} r_j^2(x),\ \ \ \ \ r_j(x)$ 表示 x 第 j 项的 L1 误差
• 常用方法： Gauss-Newton (GN)、Levenberg-Marquadt (LM)
• 求解过程：
  • 对误差进行一阶估计： $r(x_i+\Delta x_i)=r(x_i)+J_i\Delta x_i,\ \ \ J_i = \frac{dr}{dx}|_{x=x_i}$ ，J 是雅各比矩阵
  • 最优变化量： $\Delta x_i=\arg_{\Delta x_i}\min \frac{1}{2}||r_i+J_i\Delta x_i||^2$
  • GN 法获得最优变化量： $J_i^TJ_i\Delta x_i = - J_i^Tr_i$ ，如果 $J_i^TJ_i$ 可逆，则最优变化量 $\Delta x_i=-(J_i^TJ_i)^{-1}J_i^Tr_i$
  • LM 法获得最优变化量（在 GN 的基础上加入超参数—— 阻尼系数 $\lambda$）： $\Delta x_i=-(J_i^TJ_i + \lambda \ diag(J_i^TJ_i))^{-1}J_i^Tr_i$
  • 本方法：基于 GN 加入了更多的可学习参数，使用梯度下降优化

任务描述

• 输入一段图像序列，输出深度估计（depth）与姿态估计（pose），为了估计较大范围的深度，所以网络实际估计深度的倒数： $z = \frac{1}{d}$
• 所以本任务优化目标函数： $E(x) = \frac{1}{2}||r(x)||^2,\ \ \ x=(z, p)$

网络结构

网络结构包含 bootstrap network、iterative network、refinement network

• bootstrap network： 生成低分辨率（ $\frac{H}{4}, \frac{W}{4}$ ）的粗糙估计（一个简单的包含下采样的CNN）
• iterative network：重复迭代与细化，本文使用 LSTM （非线性最小二乘法优化也用于此处）
• refinement network：上采样（双线性插值法）
  

iterative network 优化过程

• 其中 $f_{\theta_0}$ 表示 bootstrap network， $f_{\theta}$ 表示 Convolutional LSTM Cell

• 由于 J 具体空间局部性，所以这里使用的 LSTM 是 Convolutional LSTM
• $\begin{bmatrix} \Delta x_i\\ h_{i+1} \end{bmatrix} = LSTM_{cell}(\Phi(J_i,r_i),h_i,x_i;\theta),\ \ \ x_{i+1} = x_i + \Delta x_i$ ，这里的 $x_i$ 并不是真的输入到 LSTM 中，如 Algorithm 1 所示， $x_i$ 用来产生 $J_i$ 从而产生 $\Phi(J_i, r_i)$
• 其中雅各比矩阵的变形 $\Phi(J_i,r_i) = [J^TJ,r]$
  • 理论上 $\Phi(J_i,r_i) = [(J^TJ)^{-1}J,r]$ ，但由于求逆会引入较大的计算量，并且不会产生额外的信息量，所以简化 $\Phi(J_i,r_i) = [J^TJ,r]$
  • 由于雅各比矩阵是稀疏的，所以使用了下图的方法对 $J^TJ$ 进行了压缩
    

损失函数

• depth 与 pose 的 L1 误差的加权和

Thoughts

• 本文的创新点在于 Convolutional LSTM 中输入的不是 $x_i$ ，而是压缩后的二阶雅各比矩阵，用来拟合 $\Delta x_i$ ，可以通过近似 GN 法，产生超一阶优化的效果
• GN ： $\Delta x_i=-(J_i^TJ_i)^{-1}J_i^Tr_i$ ，本文： $\Delta x_i=LSTM(J_i^TJ_i,r_i)$ ，即把 $[(J_i^TJ_i)^{-1}J_i,r_i] --> [J_i^TJ_i,r_i]$ 并加入了 LSTM 梯度下降优化
• 本文的网络没有官方开源，也找不到民间实现，所以对网络的细节不是特别明白

URL

https://dl.acm.org/doi/pdf/10.1145/3219819.3220007

TL;DR

• 本文提出一种多任务神经网络结构，称为 Multi-gate Mixture-of-Experts 简称 MMOE
• 与传统多任务网络共享 bottom 相比，该结构可以在 任务相关性较弱 的情况下有较好的鲁棒性
• MMOE 中的 Multi-gate 本质就是一种 Softmax Attention，针对不同的任务给出不同的专家组合

Algorithm

总体网络结构

其中 A 和 B 分别表示两个 任务，Tower 表示与任务相关的金字塔头部，Expert 表示专家 bottom network，Gate 表示任务相关的权重生成网络

• 上图 a 表示 Bottom Shared Architecture: 传统共享 bottom network 的多任务结构，共享 bottom network (Backbone) 进行特征提取，将提取到的特征分别送入任务相关头部，缺点是如果任务 A 和 B 之间的相关性较弱，那么共用一个 Backbone 是危险的
• 上图 b 表示 One-gate Mixture-of-Experts Architecture，有多个 Expert 做 Backbone 进行不同维度的特征提取，只有一个 Gate network 用于给每个任务生成 Expert 权重
• 上图 c 表示 Multi-gate Mixture-of-Experts Architecture，有多个 Expert 做 Backbone 进行不同维度的特征提取，每个任务有单独的 Gate network 生成唯一的 Expert 权重

数学定义

• Bottom Shared
  $y_k = h^k(f(x))$

  其中 $k$ 表示 任务数，$f()$ 表示 shared bottom，$h^k$ 表示 第 k 个任务的 Tower

• OMOE
  $y_k=h^k(\sum_{i=1}^n g(x)_i f_i(x))$， where $\sum_{i=1}^n g(x)_i=1,\ \ g(x) \in \mathbb R^n$
  其中 $n$ 表示 专家数，$g$ 表示 Gate network（由于 $g(x)$ 要经过 Softmax，使得 logits -> prob，所以 $\sum_{i=1}^n g(x)_i=1$）

• MMOE
  $y_k=h^k(\sum_{i=1}^n g^k(x)_i f_i(x))$， where $\sum_{i=1}^n g^k(x)_i=1$
  $g^k(x)=softmax(W_{gk}x)$，其中 $x \in \mathbb R^d,\ \ W_{gk} \in \mathbb R^{n\times d}, \ so \ \ g^k(x) \in \mathbb R^n$
  与 OMOE 不同之处在于： 每个任务有单独的 Gate network，不共享

Thoughts

• 是有效的优化，针对任务相关性差的多任务场景，确实能有效涨点
• 本质是一种参数的堆砌，没看到很创新的点
• 除了堆参数之外，还有一个很致命的问题，每个 Gate 以及 Expert 都是独立的，实际实现过程中只能使用 for loop 依次计算，效率很低，速度很慢

Experiments

URL

https://arxiv.org/pdf/2009.04759.pdf

TL;DR

• 本文将常见的激活函数分为两大类，基于 Maxout 和基于 Smooth maximum
• 基于 Maxout 的主要是 XXXReLU 家族
• 基于 smooth maximum 的本文命名为 activate or not 家族，著名的 Swish 在 $\beta=1$ 时就是 ACON-A

Dataset/Algorithm/Model/Experiment Detail

Smooth maximumn

• $S_{\beta}(x_1,...,x_n) = \frac{\sum_{i=1}^nx_i \times e^{\beta x}}{\sum_{i=1}^n e^{\beta x}}$ ，当 $\beta \rightarrow \infty, S_\beta \rightarrow max$ ，当 $\beta \rightarrow 0, S_\beta \rightarrow mean$
• 当 n = 2 时， $S_\beta(\eta_a(x),\eta_b(x)) = (\eta_a(x)-\eta_b(x))\times\sigma[\beta(\eta_a(x)-\eta_b(x))]+\eta_b(x)$ ，其中： $\sigma$ 表示 Sigmoid， $\eta$ 表示 per channle 的线性函数
  

Meta-ACON

• 当 ACON 中的 $\beta$ 从一个 learnable parameter 变成一个 network，ACON -> Meta-ACON，这里的 network 与 SENet 中的 channel-scale 用到的两层 fc 结构相同

代码 （ACON-C 和 Meta-ACON-C）

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

import torch
from torch import nn
class AconC(nn.Module):
    r"""ACON activation (activate or not).
    # AconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is a learnable parameter
    # according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
    """
    def __init__(self, width):
        super().__init__()
        self.p1 = nn.Parameter(torch.randn(1, width, 1, 1))
        self.p2 = nn.Parameter(torch.randn(1, width, 1, 1))
        self.beta = nn.Parameter(torch.ones(1, width, 1, 1))
    def forward(self, x):
        return (self.p1 * x - self.p2 * x) * torch.sigmoid(
            self.beta * (self.p1 * x - self.p2 * x)
        ) + self.p2 * x
class MetaAconC(nn.Module):
    r"""ACON activation (activate or not).
    # MetaAconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is generated by a small network
    # according to "Activate or Not: Learning Customized Activation" <https://arxiv.org/pdf/2009.04759.pdf>.
    """
    def __init__(self, width, r=16):
        super().__init__()
        self.fc1 = nn.Conv2d(
            width, max(r, width // r), kernel_size=1, stride=1, bias=True
        )
        self.bn1 = nn.BatchNorm2d(max(r, width // r))
        self.fc2 = nn.Conv2d(
            max(r, width // r), width, kernel_size=1, stride=1, bias=True
        )
        self.bn2 = nn.BatchNorm2d(width)
        self.p1 = nn.Parameter(torch.randn(1, width, 1, 1))
        self.p2 = nn.Parameter(torch.randn(1, width, 1, 1))
    def forward(self, x):
        beta = torch.sigmoid(
            self.bn2(
                self.fc2(
                    self.bn1(
                        self.fc1(
                            x.mean(dim=2, keepdims=True).mean(dim=3, keepdims=True)
                        )
                    )
                )
            )
        )
        return (self.p1 * x - self.p2 * x) * torch.sigmoid(
            beta * (self.p1 * x - self.p2 * x)
        ) + self.p2 * x

效果

Thoughts

• 是一种动态上下界的几乎函数，并很 general 的解释了 Smooth maximum 机制的作用