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 机制的作用

URL

https://arxiv.org/pdf/2104.13371.pdf

TL;DR

• 对 BasicVSR 的 Propagation 和 Alignment 组件进行了加强，达到了新的 SOTA
• 对 Propagation 的加强主要是把 BasicVSR 使用的单层双向传播结构改成了 多层 + 双向 + 二阶传播
• 对 Alignment 的加强主要是把 BasicVSR 使用的基于光流估计的对齐方式改成了基于光流估计指导的可变形卷积对齐，光流估计 + warp 的对齐方式似乎比可变形卷积要弱，可变形卷积单独训练容易崩，二者结合效果更好

Dataset/Algorithm/Model/Experiment Detail

Propagation

• 加入了二阶（跳帧）传播
  

Alignment

使用一个比较复杂的对齐结构（论文中对齐过程的数学表达式写的很清楚），通过 光流估计 + Warp + 残差 生成 DCN 的 offset 和 mask，再通过 DCN 对齐

最终结果

Thoughts

• 目前还没有开源代码，但是从结构上看 BasicVSR++ 集成了 BasicVSR 的大部分结构 + IConVSR 的 Propagation 级联结构 + EDVR 的可变形卷积特征对齐
• mmediting repo 中还是有不少可以借鉴的结构，比如 DCN bloack 这些对齐结构就很 make sense

URL

https://arxiv.org/pdf/2012.02181.pdf

TL;DR

• 将 VSR 任务所需的网络结构拆分成四个部分，分别是 Propagation、Alignment、Aggregation、Upsampling，并对常见的 VSR 模型进行了总结
• 只使用常见结构没有使用奇怪操作建立了 BasicVSR 结构和针对 BasicVSR 的改进版 IconVSR，达到了当时的 SOTA
• 代码开源在：mmediting

BasicVSR

对常见的 VSR 模型结构的总结

BasicVSR 总体结构

Propagation

• 从重建后 PSNR 角度证明了 双向传播结构比单向传播结构和局部不传播结构更好

Alignment

• 同样从重建后 PSNR 角度证明了 VSR 任务中，特征对齐比图像对齐和不对齐效果更好，相较于特征对齐，图像对齐重建后平均 PSNR 降低 0.17dB，不对齐重建后平均 PSNR 降低 1.19dB
• 本文的对齐模块使用基于光流对齐的方式，即： 双向视频光流估计 + Warp feature + 残差，光流估计网络用的 SPyNet

Aggregation

• 双向传播 + 双向对齐后的 feature 直接 concat

Upsampling

• PixelShuffle

IconVSR

在 BasicVSR 的基础上增强了 Propagation 和 Aggregation 两个部分：

• Aggregation 部分加入了一个 Information-Refill 结构，对关键帧额外做一次图像级的前后帧信息融合，从代码上看是用 EDVR 做前后帧信息融合
• Propagation 是将之前的 Bidirectional Propagation 变成 Coupled Bidirectional Propagation，具体来说就是将 BasicVSR 中的独立的双向传播变成了串联的双向传播

最终结果

Thoughts

• 将 VSR 任务的模型结构解耦，每个部分单独做 Ablation experiment，感觉作为一个 VSR 任务的 baseline 是不错的

URL

https://arxiv.org/pdf/2004.02803.pdf

TL;DR

1. Deformable 3D 简称 D3D，是 C3D 的 Deformable 版
2. 在视频超分中引入了可变形3D卷积，看上去很合理
3. 使用的超分网络结构很简单，与 VDSR 有一点相似

Dataset/Algorithm/Model/Experiment Detail

Algorithm

1. D3D：3D 卷积的可变形版本（或者说可变性卷积的3D版）

可变形2D卷积全过程（图来自论文Deformable Convolutional Networks）

可变形3D卷积全过程 （图来自本论文）您这也太像了吧

C3D计算过程：

URL

https://arxiv.org/pdf/2007.00649.pdf

TL;DR

• 传统的集成学习能提高算法效果，但是深度学习多 model 集成学习实在是太慢了
• 所以作者提出一种深度学习多 group 集成学习，本质是在网络的末尾处使用 分组卷积，分成多路，每一路独立监督，监督得到的 loss 加权求和 作为总 loss，然后反向传播、优化，优点是：理论上不产生额外计算量
• 加权求和的方式一共有三种，分别是 Group Averaging、Group Wagging、Group Boosting

Algorithm

Group Ensemble 与 Model Ensemble 的区别

网络结构

加权方式

• $Loss = \frac{1}{\sum_{i=1}^m}W_i*L_i$ ， $L_i$ 表示第 i 个分支上的损失， $W_i$ 表示对应权重
• Group Averaging
  • $W_i = 1, \ \ \ \ \ i = 1, 2, ..., m$
• Group Wagging
  • $W_i \sim N(1, \delta^2), \ \ \ \ \ i = 1, 2, ..., m$
• Group Boosting
  • $W_i = -log(\frac{P_{i-1}}{T}), \ \ \ \ \ i = 2, 3, ..., m$
    • 其中 T 表示 温度，类似于模型蒸馏时的蒸馏温度
    • $P_{i-1}$ 表示上一个分支算对的概率
    • 即上一个分支预测的越正确，本分支的权重就越小，这与 boosting 还真的有点像
      

最终效果

• ImageNet 数据集上，top-1 error 比 ResNeXt-50 降低了 1.83%
• 几乎不改变 Flops 和 params，在几乎所有网络上使用都会有明显提升
• 在多种任务中都能提高成绩，包括：
  • 目标检测
  • 动作识别
  • 图像识别
    
    

Thoughts

• Group Boosting 这种串行计算 loss 权重的方法确定在 inference 阶段不会影响速度？
• 为什么在 CIFAR 数据集上，Group Wagging 这种随机方法反而效果好

对比表格

URL

https://arxiv.org/pdf/1606.06160.pdf

TL;DR

• DoReFa-Net是一种神经网络量化方法，包括对weights、activations和gradients进行量化
• 量化模型的位宽重要性：gradient_bits > activation_bits > weight_bits

Algorithm

算法与实现角度理解：

总体流程

quantization of weights （v1） (上图 $f_\omega^W$ )

• STE (straight-through estimator)
  一种对本身不可微函数（例如四舍五入函数round()、符号函数sign()等）的手动指定微分的方法，量化网络离不开STE

• 当1 == w_bits时：
  $Forward: r_o = sign(r_i) \times E_F(|r_i|)$
  $Backward: \frac{\partial c}{\partial r_i} = \frac{\partial c}{\partial r_o}$
  其中 $E_F(|r_i|)$ 表示weight每层通道的绝对值均值

• 当1 < w_bits 时：
  $Forward\_v1: r_o = 2 quantize_k(\frac{tanh(r_i)}{2max(|tanh(r_i)|)} + \frac{1}{2}) - 1$

  $Backward: \frac{\partial c}{\partial r_i} = \frac{\partial c}{\partial r_o} \frac{\partial r_o}{\partial r_i}$
  其中 quantize_k()函数是一个量化函数，使用类似四舍五入的方法，将 $[0, 1, 2^{32}]$ 之间离散的数聚类到 $[0, 1, 2^{w\_bits}]$

  • quantize_k()：
    $ Forward: r_o = \frac{1}{2^k-1}round((2k-1)r_i)$

    $Backward: \frac{\partial c}{\partial r_i} = \frac{\partial c}{\partial r_o}$

• quantization of weights 源码

  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

  def uniform_quantize(k): class qfn(torch.autograd.Function): @staticmethod def forward(ctx, input): if k == 32: out = input elif k == 1: out = torch.sign(input) else: n = float(2 ** k - 1) out = torch.round(input * n) / n return out @staticmethod def backward(ctx, grad_output): # STE (do nothing in backward) grad_input = grad_output.clone() return grad_input return qfn().apply class weight_quantize_fn(nn.Module): def __init__(self, w_bit): super(weight_quantize_fn, self).__init__() assert w_bit <= 8 or w_bit == 32 self.w_bit = w_bit self.uniform_q = uniform_quantize(k=w_bit) def forward(self, x): if self.w_bit == 32: weight_q = x elif self.w_bit == 1: E = torch.mean(torch.abs(x)).detach() weight_q = self.uniform_q(x / E) * E else: weight = torch.tanh(x) max_w = torch.max(torch.abs(weight)).detach() weight = weight / 2 / max_w + 0.5 weight_q = max_w * (2 * self.uniform_q(weight) - 1) return weight_q

quantization of activations (上图 $f_\alpha^A$ )

• 对每层输出量化
  $ f^A_\alpha = quantize_k®$

quantization of gradients (上图 $f_\gamma^G$ )

• 对梯度量化
  $f^k_\gamma(dr)=2max_0(|dr|)[quantize_k[\frac{dr}{2max_0(|dr|)} + \frac{1}{2} + N(k)] - \frac{1}{2}]$
  其中：$ dr $ 表示backward上游回传的梯度， $k$ 表示 gradient_bits， $N(k)$ 表示随机均匀噪声$N(k) = \frac{\sigma}{2^k-1},\ \ \ \sigma \sim Uniform(-0.5, 0.5)$
• 由于模型端上inference阶段不需要梯度信息，而大多数模型也不会在端上训练，再加上低比特梯度训练会影响模型精度，所以对梯度的量化大多数情况下并不会使用

其他方面

• 由于最后一层的输出分布与模型中输出的分布不同，所以为了保证精度，不对模型输出层output做量化（上图step 5， 6）
• 由于模型第一层的输入与中间层输入分布不同，而且输入通道数较小，weight不量化代价小，所以 第一层的weight做量化
• 使用多步融合，不保存中间结果会降低模型运行是所需内存

Paper Reading Note

URL

https://arxiv.org/pdf/1912.13200.pdf

TL;DR

1. 使用-L1距离代替了Conv
2. 因为-L1距离永远<=0，所以还是保留了bn，另外在梯度回传的时候加了HardTanh
3. 实际训练很慢，收敛需要的epoch很多

Algorithm

模式匹配方式

• 卷积本质上是一种模式匹配方式，但是模式匹配方式不是只有卷积，L1距离同样可以衡量模式的相似程度
• L1距离只使用加法，理论速度比卷积快

卷积的数学表达（输入h*w*c）

• $Y(m, n, t) = \sum_{i=0}^d\sum_{j=0}^d\sum_{k=0}^{c_{in}} S(X(m+i,n+j,k) , F(i,j,k,t))$
  其中: $S(x, y) = x \times y$

-L1距离的数学表达

• $Y(m, n, t) = -\sum_{i=0}^d\sum_{j=0}d\sum_{k=0}^{c_{in}} |X(m+i,n+j,k) - F(i,j,k,t) | $

求导

• 卷积是乘法和加法，乘法是交换门，也就是说输出对卷积核的梯度可以表示为：
  • $\frac{\partial Y(m,n,t)}{\partial F(i,j,k,t)} = X(m+i,n+j,k)$
  • $\frac{\partial Y(m,n,t)}{\partial X(m+i,n+j,k)} = F(i,j,k,t)$
• -L1距离求导，由于绝对值函数梯度是分段函数，所以:
  • $ \frac{\partial Y(m,n,t)}{\partial F(i,j,k,t)} = sng(X(m+i,n+j,k) - F(i,j,k,t))$
  • $ \frac{\partial Y(m,n,t)}{\partial X(m+i,n+j,k)} = sng(F(i,j,k,t) - X(m+i,n+j,k))$
    其中: $sng(x) = \left\{\begin{matrix} -1, & x < 0\\ 0, & x = 0\\ 1, & x > 0 \end{matrix}\right.$

优化

• 分段函数求导麻烦，所以输出对卷积核的梯度，直接去掉符号函数，
  $ \frac{\partial Y(m,n,t)}{\partial F(i,j,k,t)} = X(m+i,n+j,k) - F(i,j,k,t)$ ，简单粗暴
• 对于输出对feature的导数，论文中没有直接去掉符号函数，而是将符号函数换成了HardTanh函数，这个函数用在梯度上的时候还有一个大家熟悉的名字——梯度截断
  $HardTanh(x) = \left\{\begin{matrix} 1, & x > 1\\ x, & -1 < x < 1\\ -1, & x < -1 \end{matrix}\right.$
  $x$ 表示梯度
• 自此：反向传播时用到的梯度已经变形为：
  $ \frac{\partial Y(m,n,t)}{\partial F(i,j,k,t)} = X(m+i,n+j,k) - F(i,j,k,t)$
  $ \frac{\partial Y(m,n,t)}{\partial X(m+i,n+j,k)} = HardTanh(F(i,j,k,t) - X(m+i,n+j,k))$
• 学习率：论文中详细的讲解了这个自适应学习率是如何推导出来的，如果想了解建议去看原文，这里直接说结论：
  $\alpha_l = \frac{\eta \sqrt K}{||\Delta(F_l)||_2}$
  (论文第二版中这个 $\sqrt K$ 在分母位置，看了源码，还是以第三版为准)
  其中， $K$ 表示卷积核滤波器中元素的个数， $||...||_2$ 表示矩阵的F范数

优化部分一堆公式不够直观，直接上源码

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

class adder(Function):
    @staticmethod
    def forward(ctx, W_col, X_col):
        ctx.save_for_backward(W_col, X_col)
        # -L1距离，其中x_col是使用img2col处理过的
        output = -(W_col.unsqueeze(2) - X_col.unsqueeze(0)).abs().sum(1)
        return output
    @staticmethod
    def backward(ctx, grad_output):
        W_col, X_col = ctx.saved_tensors
        # 对卷积核的梯度，直接去掉了符号函数sgn
        grad_W_col = (
            (X_col.unsqueeze(0) - W_col.unsqueeze(2)) * grad_output.unsqueeze(1)
        ).sum(2)
        # 这里是乘上推导出的自适应学习率，\eta=0.2
        grad_W_col = (
            grad_W_col
            / grad_W_col.norm(p=2).clamp(min=1e-12)
            * math.sqrt(W_col.size(1) * W_col.size(0))
            / 5
        )
        # 梯度截断，也就是所谓的HardTanh
        grad_X_col = (
            -(X_col.unsqueeze(0) - W_col.unsqueeze(2)).clamp(-1, 1)
            * grad_output.unsqueeze(1)
        ).sum(0)
        return grad_W_col, grad_X_col

实际运行

• 真的慢，可能是由于img2col还有求L1距离都是在python中做的，所以训练速度真的好慢啊!
• 真的难收敛，官方源码中，使用resnet20（conv -> L1）训练CIFAR10，设置的默认epoch次数为400，训练CIFAR10都需要400 epoch…
• 真的不稳定，不像传统Conv网络随着训练次数，网络准确率逐步提高，或者在极小范围内抖动，AdderNet训练过程中，epoch 23结束后在val上准确率可能55%，第epoch 24结束后，val上的准确率直接到了28%，而且不是因为学习率太大导致的，抖动范围真的大…
• 最终结果：AdderNet-ResNet20 在 CIFAR-10 上 epoch-400 最高正确率：91.67%

Thoughts

• 虽然这个网络目前问题还很多，而且作者的理论很糙，有些地方简单粗暴，但是这也许是神经网络加速的一种思路

与CNN的对比

URL

https://arxiv.org/pdf/1611.10176

TL;DR

• 提出一种基于DoReFa-Net的RNN量化方式

Algorithm

Dropout

• 由于 RNN 本质是由多个 FC 组成，所以需要使用 Dropout 将一部分元素随机置0，但在量化神经网络中，0不在 $Q_k(X + 0.5)-0.5$ ，所以需要将原始 DoReFa-Net 的量化范围： $[-0.5, 0.5]\to [0, 1]$

quantization of word embedding weights

• 初始化
  $W\in Uniform(0, 1)$
• quantization
  $W = Clip(W, 0, 1)$

quantization of GRU

• standard GRU
  $z_t = \sigma(W_z \cdot [h_{t-1},x_t])$

  $r_t = \sigma(W_r \cdot [h_{t-1},x_t])$

  $\tilde h_{t}=tanh(W\cdot [r_t \times h_{t-1},x_t])$

  $ h_t = (1-z_t)\times h_{t-1}+z_t\times \tilde{h_t}$
  其中：” $\cdot$ “ 表示 matmul，” $\times$ “ 表示 hadamard product， $\sigma$ 表示 sigmoid

• quantization of GRU
  $z_t = \sigma(W_z \cdot [h_{t-1},x_t])$

  $r_t = \sigma(W_r \cdot [h_{t-1},x_t])$

  $\tilde h_{t}=\sigma(W\cdot [Q_k(r_t \times h_{t-1}), x_t])$

  $ h_t = Q_k((1-z_t)\times h_{t-1}+z_t\times \tilde{h_t})$

  • 改进：
    • tanh 变 sigmoid
    • 将 $W, W_z, W_r$ quantize 到 [-1, 1]
    • 将 $x_t$ quantize 到 [0, 1]
    • 量化函数 $Q_k()$

quantization of LSTM

• standard LSTM
  $f_t = \sigma(W_f\cdot [h_{t-1},x_t]+b_f)$

  $i_t = \sigma(W_i\cdot [h_{t-1},x_t]+b_i)$

  $\tilde{C_t} = tanh(W_C\cdot [h_{t-1},x_t]+b_i)$

  $C_t=f_t\times C_{t-1}+i_t\times \tilde{C_t}$

  $o_t = \sigma(W_o\cdot [h_{t-1},x_t]+b_o)$

  $h_t=o_t \times tanh(C_t)$

• quantization of LSTM
  $f_t = \sigma(W_f\cdot [h_{t-1},x_t]+b_f)$

  $i_t = \sigma(W_i\cdot [h_{t-1},x_t]+b_i)$

  $\tilde{C_t} = tanh(W_C\cdot [h_{t-1},x_t]+b_i)$

  $C_t=f_t\times C_{t-1}+i_t\times \tilde{C_t}$

  $o_t = \sigma(W_o\cdot [h_{t-1},x_t]+b_o)$

  $h_t=Q_k(o_t \times \sigma(C_t))$

  • 改进：
    • tanh 变 sigmoid
    • 将 $W, W_z, W_r$ quantize 到 [-1, 1]
    • 将 $x_t$ quantize 到 [0, 1]
    • 量化函数 $Q_k()$

Thoughts

• 目前芯片上都是将所有的线性操作吸到卷积的 affine_k 和 affine_b，所以需要解决 tanh 和 sigmoid，一种最简单暴力的方式是分别 clip 到 [-1, 1] 和 [0, 1]