2021SC@SDUSC YOLO5源码分析 (6) 激活函数

2021SC@SDUSC

• 2021/10/27第一次修改

本文分析yolov5的uitls.activations.py

util包中的activation.py中定义了一些便于导出的激活函数,其中不少激活函数是近两年新出的,本文重点分析下这些激活函数.

SiLu

$$SiLu(x)=x\ast sigmoid(x)$$
于是有

return x * torch.sigmoid(x)

Hardswish

$$\begin{array}{r}hardswish(x)=\{\begin{array}{rlr}& 0,& x\le -3\\ & x,& x\ge 3\\ & \frac{x(x+3)}{6},& other\end{array}\end{array}$$
这里的实现使用的是torch.nn.functional的hardtanh,一般的hardtanh定义为
$$hardtanh(x)=\{\begin{array}{rlr}& -1,& x<-1\\ & 1,& x>1\\ & x,& other\end{array}$$
torch.nn.functional的hardtanh有额外的两个参数可以规定上下届,于是得到以下hardswish的定义

return x * F.hardtanh(x + 3, 0., 6.) / 6.

Mish

$$\begin{gathered} mish(x)=x\ast tanh(ln(1+e^x)), \\ softplus=ln(1+e^x) \end{gathered}$$
实现为

return x * F.softplus(x).tanh()

MemoryEfficientMish

一种内存高效的Mish实现~ 乍一看和上面的Mish似乎没什么区别~ 自己写循环测了下也看不出区别~

似乎普通Mish会消耗大量显存,github yolov3的1098 issue就是这个~

class MemoryEfficientMish(nn.Module):
    class F(torch.autograd.Function):
        @staticmethod
        def forward(ctx, x):
            ctx.save_for_backward(x)
            return x.mul(torch.tanh(F.softplus(x)))  # x * tanh(ln(1 + exp(x)))

        @staticmethod
        def backward(ctx, grad_output):
            x = ctx.saved_tensors[0]
            sx = torch.sigmoid(x)
            fx = F.softplus(x).tanh()
            return grad_output * (fx + x * sx * (1 - fx * fx))

    def forward(self, x):
        return self.F.apply(x)

issue是2020的,当时似乎解决方案是自己配置专门定制的mish的cuda实现.
现在是2021,torch.nn的mish跑得飞快,估计显存消耗也好得多.(需要更新最新版本torch)

FReLU

旷视2020年提出的,一种为卷积神经网络设计的,更好地提取图像特征的激活函数.FReLU为视觉任务设计,有更好的空间敏感性.

$$FReLU(x)=max(x,T(x))$$
T(x)是空间特征提取器,代码实现就是一次卷积套归一化~

这边插叙一些FReLU论文提到的术语以
及一些必要的前置.

scalar activation是一类简单的形如$y=f(x)$的激活函数,如ReLU, sigmoid之类的,前者非线性好非常好用就是负值差,后者计算复杂梯度消失.上面的SiLU,hardswish之类的也是scalar activation,不过效果好.

contextual conditional activation是基于语境的,多对一的,类似的有maxout.

ReLU使用$max(0,x)$的$max()$非线性并且使用人工设置的$0$作为条件.PReLU为$max(0,x)+p\ast min(x,0)$,其中p是可学习的,初始化为0.25.FReLU的作者将这个p描述为$1\ast 1$的无偏置卷积.

也就引出来FReLU的空间提取器的描述,一个预设的大小的,以输入像素为中心的滑动窗口,其中同一通道共享权重

class FReLU(nn.Module):
    def __init__(self, c1, k=3):  # ch_in, kernel
        super().__init__()
        self.conv = nn.Conv2d(c1, c1, k, 1, 1, groups=c1, bias=False)
        self.bn = nn.BatchNorm2d(c1)

    def forward(self, x):
        return torch.max(x, self.bn(self.conv(x)))

AconC

这个和底下的是2021的同篇论文(Activate or Not: Learning Customized Activation)里提出的,也就是2020年的yolov5版本没有这个.

Acon是论文提出的近似技巧,论文认为swish是ReLU的近似,并且有一堆smooth maximum的复杂推导.然后由这个smooth maximum对maxout类激活函数进行平滑得到acon类,分别有:

我们这里的Acon-C的效果相对最好,其中p1,p2和$\beta$都是可学习参数.

p1,p2控制一阶导数的上下界,$\beta$能控制激活函数的线性度

class AconC(nn.Module):

    def __init__(self, c1):
        super().__init__()
        self.p1 = nn.Parameter(torch.randn(1, c1, 1, 1))
        self.p2 = nn.Parameter(torch.randn(1, c1, 1, 1))
        self.beta = nn.Parameter(torch.ones(1, c1, 1, 1))

    def forward(self, x):
        dpx = (self.p1 - self.p2) * x
        return dpx * torch.sigmoid(self.beta * dpx) + self.p2 * x

MetaAconC

上面考虑了AconC的参数结构及含义,已知$\beta$控制函数的线性程度,所以提出一个模块$G(x)$由输入特征图来学习$\beta$

自适应函数有,层级,通道级,像素级的设计空间.

这边使用的是通道级的,首先分别对H, W维度求均值，然后通过两个卷积层，使得每一个通道所有像素共享一个权重， 最后由sigmoid激活函数求得β。为了减少参数我们在两个中间的channel加了个缩放参数r.

class MetaAconC(nn.Module):

    def __init__(self, c1, k=1, s=1, r=16):  # ch_in, kernel, stride, r
        super().__init__()
        c2 = max(r, c1 // r)
        self.p1 = nn.Parameter(torch.randn(1, c1, 1, 1))
        self.p2 = nn.Parameter(torch.randn(1, c1, 1, 1))
        self.fc1 = nn.Conv2d(c1, c2, k, s, bias=True)
        self.fc2 = nn.Conv2d(c2, c1, k, s, bias=True)
        # self.bn1 = nn.BatchNorm2d(c2)
        # self.bn2 = nn.BatchNorm2d(c1)

    def forward(self, x):
        y = x.mean(dim=2, keepdims=True).mean(dim=3, keepdims=True)
        # batch-size 1 bug/instabilities https://github.com/ultralytics/yolov5/issues/2891
        # beta = torch.sigmoid(self.bn2(self.fc2(self.bn1(self.fc1(y)))))  # bug/unstable
        beta = torch.sigmoid(self.fc2(self.fc1(y)))  # bug patch BN layers removed
        dpx = (self.p1 - self.p2) * x
        return dpx * torch.sigmoid(beta * dpx) + self.p2 * x

这边只是从代码上简单谈一下各个激活函数的实现,原理.实际上上述的每个激活函数,在理论和应用时,都有各自的非常复杂的特性,受限篇幅不赘述.

具体参考了各个激活函数提出的文献,里面有各种细节.