百度飞桨顶会论文复现（5）：视频分类论文之《Representation Flow for Action Recognition》篇

自动驾驶小学生

已于 2022-03-13 22:50:21 修改

阅读量993

点赞数

分类专栏：百度顶会论文复现文章标签： 1024程序员节

于 2020-08-05 21:40:58 首次发布

本文链接：https://blog.csdn.net/cg129054036/article/details/107823903

版权

百度顶会论文复现专栏收录该内容

5 篇文章 11 订阅

订阅专栏

这次老师在课上总共领读了4篇分类论文，我这里分享其中的一篇论文，是关于使用神经网络对光流进行学习。
课程地址是：https://aistudio.baidu.com/aistudio/education/group/info/1340。
论文地址是：https://arxiv.org/abs/1810.01455。
Github地址是：https://github.com/piergiaj/representation-flow-cvpr19。
论文中文翻译地址：https://blog.csdn.net/qq_42037746/article/details/107411080。

文章目录

1.相关介绍

这里我将按照老师上课领读的顺序来进行介绍。
过去在对视频进行分类时，一般需要设计两个网络，一个网路输入静态图像得到图像特征；另一个网络输入两张图像之间的光流，学习运动特征；然后对两个特征进行融合，进行最终的视频分类。这里最主要的问题是光流的计算成本比较高，通常需要上百次的迭代优化；另一个是需要训练两个网络，这使得模型在推理时资源消耗较大，限制了其应用。因此本文作者设计了一种CNN层：表示光流层，对光流进行学习，并且表示光流层可以对任意一层特征图进行学习。
在这里插入图片描述

2.本文方法

2.1 光流法介绍

在介绍本文方法之前首先回顾下什么是光流？光流是用来描述像素随时间在图像之间运动的方法。
在光流法中一个基本假设是：同一个空间点的像素灰度值，在各个图像中是固定不变的，可以用 $I (x, y, t)$ 来表示像素灰度。
下图中， $t$ 时刻图像中像素位置为 $(x, y)$ ，在 $t + d t$ 时刻运动到 $(x + d x, y + d y)$ ，由于灰度不变可得：
$I (x, y, t) = I (x + d x, y + d y, t + d t)$
泰勒一阶展开，像素运动 $u_1,u_2)$ 即为光流矢量。
在这里插入图片描述

2.2 光流层细节

论文的整体网络结构如下，可以看到输入只有图片，与以往的分类网络不同的是多了一个Flow Layer，这也是整个网络的核心部分。
在这里插入图片描述
下图为光流层迭代计算过程，这里 $F_1，F_2$ 为两张图片的特征图。

初始时 $u=0,p=0,p_c=F_2-F_1$ ；然后进行 $n$ 次迭代计算；

计算特征图 $F_2$ 的梯度，这里的梯度是通过卷积操作计算的，下面的矩阵表示为卷积核。 $\nabla{F_{2x}}=\begin{bmatrix}1&0&-1\\2&0&-2\\1&0&-1\end{bmatrix}*F_2，\nabla{F_{2y}}=\begin{bmatrix}1&2&1\\0&0&0\\-1&-2&-1\end{bmatrix}*F_2$

然后是更新 $v$ 的值；

计算 $p$ 的散度： $divergence(p)=p_x*w_x+p_y*w_y$

然后是计算速度梯度，操作和求 $F_2$ 梯度类似： $\nabla{u_{x}}=\begin{bmatrix}1&0&-1\\2&0&-2\\1&0&-1\end{bmatrix}*u_x,\nabla{u_{y}}=\begin{bmatrix}1&2&1\\0&0&0\\-1&-2&-1\end{bmatrix}*u_y$

跟新p的值；

最终，经过 $n$ 次迭代即可得到最终的像素运动速度 $u$ 。
下面是原作者光流层实现代码，首先网络的定义：

class FlowLayer(nn.Module):
    def __init__(self, channels=1, bottleneck=32, params=[1,1,1,1,1], n_iter=10):
        super(FlowLayer, self).__init__()
        self.bottleneck = nn.Conv3d(channels, bottleneck, stride=1, padding=0, bias=False, kernel_size=1)
        self.unbottleneck = nn.Conv3d(bottleneck*2, channels, stride=1, padding=0, bias=False, kernel_size=1)
        self.bn = nn.BatchNorm3d(channels)
        channels = bottleneck
        
        self.n_iter = n_iter
        if params[0]:
            self.img_grad = nn.Parameter(torch.FloatTensor([[[[-0.5,0,0.5]]]]).repeat(channels,channels,1,1))
            self.img_grad2 = nn.Parameter(torch.FloatTensor([[[[-0.5,0,0.5]]]]).transpose(3,2).repeat(channels,channels,1,1))
        else:
            self.img_grad = nn.Parameter(torch.FloatTensor([[[[-0.5,0,0.5]]]]).repeat(channels,channels,1,1), requires_grad=False)
            self.img_grad2 = nn.Parameter(torch.FloatTensor([[[[-0.5,0,0.5]]]]).transpose(3,2).repeat(channels,channels,1,1), requires_grad=False)            

            
        if params[1]:
            self.f_grad = nn.Parameter(torch.FloatTensor([[[[-1],[1]]]]).repeat(channels,channels,1,1))
            self.f_grad2 = nn.Parameter(torch.FloatTensor([[[[-1],[1]]]]).repeat(channels,channels,1,1))
            self.div = nn.Parameter(torch.FloatTensor([[[[-1],[1]]]]).repeat(channels,channels,1,1))
            self.div2 = nn.Parameter(torch.FloatTensor([[[[-1],[1]]]]).repeat(channels,channels,1,1))            
        else:
            self.f_grad = nn.Parameter(torch.FloatTensor([[[[-1],[1]]]]).repeat(channels,channels,1,1), requires_grad=False)
            self.f_grad2 = nn.Parameter(torch.FloatTensor([[[[-1],[1]]]]).repeat(channels,channels,1,1), requires_grad=False)
            self.div = nn.Parameter(torch.FloatTensor([[[[-1],[1]]]]).repeat(channels,channels,1,1), requires_grad=False)
            self.div2 = nn.Parameter(torch.FloatTensor([[[[-1],[1]]]]).repeat(channels,channels,1,1), requires_grad=False)

            
        self.channels = channels
        
        self.t = 0.3  
        self.l = 0.15
        self.a = 0.25        

        if params[2]:
            self.t = nn.Parameter(torch.FloatTensor([self.t]))
        if params[3]:
            self.l = nn.Parameter(torch.FloatTensor([self.l]))
        if params[4]:
            self.a = nn.Parameter(torch.FloatTensor([self.a]))

前向传播：

def forward(self, x):
        residual = x[:,:,:-1]
        x = self.bottleneck(x)
        inp = self.norm_img(x)
        x = inp[:,:,:-1]
        y = inp[:,:,1:]
        b,c,t,h,w = x.size()
        x = x.permute(0,2,1,3,4).contiguous().view(b*t,c,h,w)
        y = y.permute(0,2,1,3,4).contiguous().view(b*t,c,h,w)
        
        u1 = torch.zeros_like(x)
        u2 = torch.zeros_like(x)
        l_t = self.l * self.t
        taut = self.a/self.t

        grad2_x = F.conv2d(F.pad(y,(1,1,0,0)), self.img_grad, padding=0, stride=1)#, groups=self.channels)
        grad2_x[:,:,:,0] = 0.5 * (x[:,:,:,1] - x[:,:,:,0])
        grad2_x[:,:,:,-1] = 0.5 * (x[:,:,:,-1] - x[:,:,:,-2])

        
        grad2_y = F.conv2d(F.pad(y, (0,0,1,1)), self.img_grad2, padding=0, stride=1)#, groups=self.channels)
        grad2_y[:,:,0,:] = 0.5 * (x[:,:,1,:] - x[:,:,0,:])
        grad2_y[:,:,-1,:] = 0.5 * (x[:,:,-1,:] - x[:,:,-2,:])
        
        p11 = torch.zeros_like(x.data)
        p12 = torch.zeros_like(x.data)
        p21 = torch.zeros_like(x.data)
        p22 = torch.zeros_like(x.data)

        gsqx = grad2_x**2
        gsqy = grad2_y**2
        grad = gsqx + gsqy + 1e-12

        rho_c = y - grad2_x * u1 - grad2_y * u2 - x
        
        for i in range(self.n_iter):
            rho = rho_c + grad2_x * u1 + grad2_y * u2 + 1e-12

            v1 = torch.zeros_like(x.data)
            v2 = torch.zeros_like(x.data)
            mask1 = (rho < -l_t*grad).detach()
            v1[mask1] = (l_t * grad2_x)[mask1]
            v2[mask1] = (l_t * grad2_y)[mask1]
            
            mask2 = (rho > l_t*grad).detach()
            v1[mask2] = (-l_t * grad2_x)[mask2]
            v2[mask2] = (-l_t * grad2_y)[mask2]

            mask3 = ((mask1^1) & (mask2^1) & (grad > 1e-12)).detach()
            v1[mask3] = ((-rho/grad) * grad2_x)[mask3]
            v2[mask3] = ((-rho/grad) * grad2_y)[mask3]
            del rho
            del mask1
            del mask2
            del mask3

            v1 += u1
            v2 += u2

            u1 = v1 + self.t * self.divergence(p11, p12)
            u2 = v2 + self.t * self.divergence(p21, p22)
            del v1
            del v2
            u1 = u1
            u2 = u2

            u1x, u1y = self.forward_grad(u1)
            u2x, u2y = self.forward_grad(u2)
            
            p11 = (p11 + taut * u1x) / (1. + taut * torch.sqrt(u1x**2 + u1y**2 + 1e-12))
            p12 = (p12 + taut * u1y) / (1. + taut * torch.sqrt(u1x**2 + u1y**2 + 1e-12))
            p21 = (p21 + taut * u2x) / (1. + taut * torch.sqrt(u2x**2 + u2y**2 + 1e-12))
            p22 = (p22 + taut * u2y) / (1. + taut * torch.sqrt(u2x**2 + u2y**2 + 1e-12))
            del u1x
            del u1y
            del u2x
            del u2y
            


        flow = torch.cat([u1,u2], dim=1)
        flow = flow.view(b,t,c*2,h,w).contiguous().permute(0,2,1,3,4)
        flow = self.unbottleneck(flow)
        flow = self.bn(flow)
        return F.relu(residual+flow)

3.结果展示

首先作者分析了对不同特征层使用光流层的分类结果：可以看出在第三个残差块后面使用光流层效果最好。在这里插入图片描述
然后作者讨论了不同结构光流层的分类结果，可看到Flow-Conv-Flow的分类效果是最好的。

最后作者与现有的SOTA模型进行了对比，可以看到，FCF+(2+1)D的效果是最好的。
这里简单对《Representation Flow for Action Recognition》论文进行了介绍，更多理解还需要反复阅读论文和阅读源码。

自动驾驶小学生

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
百度飞桨顶会论文复现（5）：视频分类论文之《Representation Flow for Action Recognition》篇

这次老师在课上总共领读了4篇分类论文，我这里分享其中的一篇论文，是关于使用神经网络对光流进行学习。课程地址是：https://aistudio.baidu.com/aistudio/education/group/info/1340。论文地址是：https://arxiv.org/abs/1810.01455。Github地址是：https://github.com/piergiaj/representation-flow-cvpr19。论文中文翻译地址：https://blog.csdn.net.
复制链接

扫一扫