CVPR2018 DGCNN、RSNet

DGCNN和RSNet与KCNet和PointwiseCNN一样，都着眼于对局部特征提取方面的工作。

CVPR2018 DGCNN

Dynamic Graph CNN for Learning on Point Clouds
（论文链接）（源码链接）
受到PointNet和graph CNN的启发，作者提出了EdgeConv和Dynamic Graph。
PointNet在提取点云局部特征时是逐点进行处理的，并没有考虑到点与点之间的关系，因此在局部特征的提取上有所欠缺，DGCNN是构建局部邻近图，然后在边上进行像卷积一样的操作。与graph CNN的不同之处在于，DGCNN每层的大小是在动态更新的，而不是固定的。

Edge Convolution

对于一个含有$n$个点的点云 X = { x 1 , . . . x n } ∈ R F , x i = ( x i , y i , z i ) X=\{\mathbf{x}_1,...\mathbf{x}_n\}\in\mathbb{R}^F,\mathbf{x}_i=(x_i,y_i,z_i) X={x1​,...xn​}∈RF,xi​=(xi​,yi​,zi​)，构建一个有向图$\mathcal{G}=(\mathcal{V},\mathcal{E})$来表示点云的局部结构，其中， V = { 1 , … , n } \mathcal{V}=\{1, \ldots, n\} V={1,…,n}， $\mathcal{E}\subseteq \mathcal{V}\times \mathcal{V}$分别是顶点和边。最简单的方法是构建一个点云的k最近邻图，图上包含自环，每条边的特征定义为$e_{ij}=h_{\Theta }\left({\mathrm{x}}_i,{\mathrm{x}}_j\right),$ 其中$h_{\Theta }:{\mathbb{R}}^F\times {\mathbb{R}}^F\to {\mathbb{R}}^{F^{\prime }}$是包含一组待学习参数$\Theta 的$非线性函数。最后用一个channelwise symmetric aggregation operation $\square$对每条边的特征进行操作，EdgeConv的输出可以表示为：$${\mathbf{x}}_i^{\prime }=\prod _{j:(i,j)\in \mathcal{E}}{h}_{\Theta }\left({\mathbf{x}}_i,{\mathbf{x}}_j\right)$$
其中，${\mathbf{x}}_i$是中心点， { x j : ( i , j ) ∈ E } \{\mathbf{x}_j:(i, j) \in \mathcal{E}\} {xj​:(i,j)∈E}是相邻的一些点。如下图。

非线性函数$h$和channelwise symmetric aggregation operation $\square$的选择可以有下列几种：

• $$x_{im}^{\prime }=\sum _{j:(i,j)\in \mathcal{E}}{\theta }_m\cdot {\mathbf{x}}_j$$当${\mathbf{x}}_1,...{\mathbf{x}}_n$表示规则网格上的图像像素时，$\mathcal{G}$可以表示像素点之间的连接情况，可以将${\theta }_m\cdot {\mathbf{x}}_j$作为$h$，求和运算作为channelwise symmetric aggregation。上式中$\mathbf{\Theta }=\left({\mathbf{\theta }}_1,\dots ,{\mathbf{\theta }}_M\right)$为$M$个不同filter的权值，每个${\theta }_M$的维度与$\mathbf{x}$都是相同的，$\cdot$指欧几里得内积。
• $$h_{\Theta }\left({\mathbf{x}}_i,{\mathbf{x}}_j\right)=h_{\Theta }\left({\mathbf{x}}_i\right)$$
  这一种只对全局形体特征进行了提取，而没有考虑到点与点之间相邻的关系结构，在PointNet中用的就是这一种。
• $$\begin{gathered} h_{\Theta }\left({\mathbf{x}}_i,{\mathbf{x}}_j\right)=h_{\Theta }\left({\mathbf{x}}_j\right)， \\ {x}_{im}^{\prime }=\sum _{j\in \mathcal{V}}\left(h_{\mathbf{\theta }\left({\mathrm{x}}_j\right)}\right)g\left(u\left({\mathrm{x}}_i,{\mathrm{x}}_j\right)\right) \end{gathered}$$
  上式中，$g$是高斯核，$u$计算的是点与点之间的欧氏距离。Atzmon et al.在[1]中使用过。
• $$h_{\Theta }\left({\mathbf{x}}_i,{\mathbf{x}}_j\right)=h_{\Theta }\left({\mathbf{x}}_j-{\mathbf{x}}_i\right)$$
  这一种只考虑了局部信息，而没有考虑全局信息。
• $$h_{\Theta }\left({\mathbf{x}}_i,{\mathbf{x}}_j\right)={\bar{h}}_{\Theta }\left({\mathbf{x}}_i,{\mathbf{x}}_j-{\mathbf{x}}_i\right)$$
  本文中使用的为上式，通过从${\mathbf{x}}_i$坐标中提取的全局信息和计算${\mathbf{x}}_j-{\mathbf{x}}_i$得到的局部信息相结合。具体的，本文用到的操作如下：
  $$\begin{gathered} e_{ijm}^{\prime }=\mathrm{ReLU}\left({\theta }_m\cdot \left({\mathrm{x}}_j-{\mathrm{x}}_i\right)+{\varphi }_m\cdot {\mathrm{x}}_i\right), \\ {x}_{im}^{\prime }=\underset{j:(i,j)\in \mathcal{E}}{\max }{e}_{ijm}^{\prime } \end{gathered}$$
  其中，$\Theta =\left({\theta }_1,\dots ,{\theta }_M,{\varphi }_1,\dots ,{\varphi }_M\right)$。
  论文里写的比较复杂，根据代码EdgeConv具体的操作大概：
• 对于每个点$x_i$，找到$k$个最近邻点。$k$个点按距离升序排列，得到$x_{j_{i1}},x_{j_{i2}},\dots ,x_{j_{ik}}$
• 依次计算出$x_{j_{i1}}-x_i,x_{j_{i2}}-x_i,\dots ,x_{j_{ik}}-x_i$
• 每个边里面加入上一步计算得到的，得到$\left(x_i,x_{j_{i1}}-x_i\right),\left(x_i,x_{j_{i2}}-x_i\right),\dots ,\left(x_i,x_{j_{ik}}-x_i\right)$
• 对于上面得到的每个特征用$h_{\theta }$来更新。代码中使用的是卷积核为1x1的Conv2d
• 用max pooling，将以上k的特征整合为一个特征，作为$x_i$的新特征。

Dynamic graph update

在每一层都有不同的图${\mathcal{G}}^{(l)}=\left({\mathcal{V}}^{(l)},{\mathcal{E}}^{(l)}\right)$，其中第$l$层的边是由$\left(i,j_{i1}\right),\dots ,\left(i,j_{i{k}_l}\right)$组成的，${\mathbf{x}}_{j_{i1}}^{(l)},\dots ,x_{j_{ik}}^{(l)}$是与$x_i^{(i)}$相离最近的$k_l$个点。也就是说，每一层图也都是不同的，DGCNN学习了如何构建每一层的图。
（大概就是由于${\mathbf{x}}_{j_{ik}}^{(l)}$在不断的变化，EdgeConv计算得到的特征也都在不断地变化，每一次计算都会得到新的特征，也就是整个图是在动态变化的）

Properties

Permutation Invariance 每一层使用的是对称函数max，因此对点的顺序不敏感。
Translation Invariance 对于变换$T$：
$$\begin{array}{rl}{e}_{ijm}^{\prime }& ={\mathbf{\theta }}_m\cdot \left({\mathbf{x}}_j+T-\left({\mathbf{x}}_i+T\right)\right)+{\varphi }_m\cdot \left({\mathbf{x}}_i+T\right)\\ & ={\mathbf{\theta }}_m\cdot \left({\mathbf{x}}_j-{\mathbf{x}}_i\right)+{\mathbf{\varphi }}_m\cdot \left({\mathbf{x}}_i+T\right)\end{array}$$
令${\varphi }_m=0$则操作是完全置换不变的。

Architecture

Classification

• 4个EdgeConv Layer每层后面各接了一层全连接层，各层神经元个数分别为$(64,64,128,256)$【论文里写的是The four EdgeConv layers use three shared fully-connected layers(64,64,128,256).代码里也是这么写的，然而跟图上好像不太一样hhhhh。emmmmm】，根据每个EdgeConv层的特征重新计算图并用于下一个EdgeConv层，计算k近邻图时$k=20$。
• 将各个全连接层的输出concat到一起得到一个$512$维的数据，使用一个全连接层（1024）来综合多尺度的特征（前4层Conv层的输出）
• 用max pooling和sum pooling来对上一层的输出进行处理，并concat到一起
• 然后通过两层全连接层（512，256）来处理全局特征（dropout=0.5）
• 每层都使用了LeakyReLU和batch normalization

Part Segmentation

• 在spatial transformer network后使用了3层EdgeConv Layer
• 使用一层全连接层来对此前的得到的特征进行处理，并参照pointnet的做法进行concat
• 然后将此前得到的特征concat到一起，然后使用3层全连接层（256，256，128）进行处理
• ReLU、batch normalization、dropout的用法与classification一致

Indoor Scene Segmentation

与part segmentation的网络结构差不多，但是没有 categorical vector

[1] Matan Atzmon,Haggai Maron,and Yaron Lipman.2018. Point Convolutional Neural Networks by Extension Operators. ACM Trans. Graph.37,4,Article71(July2018), 12pages. https://doi.org/10.1145/3197517.3201301

CVPR2018 RSNet

（论文链接）（pytorch源码链接）
不同于此前的一些网络在处理无序点云时，主要是采用对称函数进行处理，而得到一个具有排列不变性的网络，RSNet则是采用slice pooling layer将无序的点云进行处理得到有序的特征，然后用RNN处理（RNN的输入是有序序列），再用slice unpooling layer将特征传递到每一个点。作者在论文中对复杂度进行了分析，确识还蛮高效的。

Architecture

对于点云输入数据$X$，通过RSNet得到 Y = { y 1 , y 2 , . . . y i , . . . y n } , y i ∈ L Y=\{y_1,y_2,...y_i,...y_n\},y_i\in L Y={y1​,y2​,...yi​,...yn​},yi​∈L，即每一个点$x_i$得到一个相应的标签$y_i$。
根据源码net.py的内容：

• 输入点云数据首先经过了1个卷积核大小为$1\times 9$的Conv2d和2个卷积核大小为$1\times 1$的Conv2d，每一层后面都有用relu和batch normalization，输出通道大小均为64
• 紧接着是根据$x,y,z$三个方向进行切片的Slice pooling layer
• 得到的不同排序的切片集合通过6层双向RNN，输出通道大小分别为(64,512,256,128,128,256)
• 通过RNN得到的特征分别使用slice unpooling layer处理，并对三个分支的得到的特征进行加和
• 加和得到的数据通过三层卷积核大小为$1\times 1$的卷积层，输出通道大小为(512,256,13)，其中前两层的输出使用了relu，但没有使用batch normalization，最后一层之前使用了dropout。
  

Independent Feature Extraction

在RSNet中有两个特征提取模块，分别是输入特征模块和输出特征模块。输入特征模块对于输入$X\in {\mathbb{R}}^{n\times d^{in}}$得到特征$F^{in}\in {\mathbb{R}}^{n\times d^{in}}$，输出特征模块对于输入特征$F^{su}\in {\mathbb{R}}^{n\times d^{su}}$得到每个点的预测标签。

Local Dependency Module

Slice Pooling Layer

Slice pooling layer的输入为无序的点云数据 F i n = { f 1 i n , f 2 i n . . . f n i n } F^{in}=\{f_1^{in},f_2^{in}...f_n^{in}\} Fin={f1in​,f2in​...fnin​}，首先将点云数据分组到切片中，然后通过在切片中聚合点的特征来为每个切片生成全局表示。切片的方向有$x,y,z$三个，以$z$为例，具体的操做如下图(a)：

根据点云在$z$维度分布的范围$[z_{min},z_{max}]$和超参数$r$进行切片划分，点$x_i$将被划分到第$k$块，其中$k=\lfloor \frac{z_i-z_{min}}{r}\rfloor$，总共将被划分为$N=\lceil \frac{z_{max}-z_{min}}{r}\rceil$块，可以表示为 S = { S 1 , S 2 , . . . S N } S=\{S_1,S_2,...S_N\} S={S1​,S2​,...SN​}，$S_i$表示第$i$个切片的点云集合，然后对每个切片中的数据进行如下操作，最终得到特征向量 F s = { f s 1 , f s 2 , . . . f s N } F^s=\{f^{s1},f^{s2},...f^{sN}\} Fs={fs1,fs2,...fsN}
$$f^{si}=\underset{x_j\in S_i}{\max }\left\{f_j^{in}\right\}$$
Slice Pooling Layer有如下特点：
Oeder and Structure $F^s$是一个有序且具有一定结构特征的序列，$f^{s1}$到$f^{sN}$分别是点云从下到上的切片，$f^{si}$和$s^{s(i-1)}$是相邻的特征。
Efficiency slice pooling layer的复杂度是$O(n)$
Local context trade-off

RNN

RSNet中使用的是双向RNN units，RNNs得到的输出是 F r = { f r 1 , f r 2 , . . . f r N } F^r=\{f^{r1},f^{r2},...f^{rN}\} Fr={fr1,fr2,...frN}

Slice Unpooling Layer

将一个slice中多个点的特征映射成了一个全局的特征向量，因此这里需要完成映射的逆过程，如上图(b)所示，每个点的特征由其所在slice的全局特征向量表示

一些实验结果：