Fully Convolutional Networks for Panoptic Segmentation论文阅读笔记

Fully Convolutional Networks for Panoptic Segmentation论文阅读笔记

——第一篇真正意义上的图像端对端全景分割

一、 论文部分：

FCN Panoptic = ⑴ kernel Generator + ⑵ kernel Fusion + ⑶ Feature Encoder
•文章中的两个词不太懂Instance-aware和semantically consistent prosperties
•全景分割=实例分割+语义分割
全景分割要求对于每一个像素分配一个语义标签和独一的身份（identity）, 在全景分割中，有thing和stuff，thing看做是前景中的物体，stuff是背景。

⑴ kernel Generator

kernel Generator = ① position head + ② kernel head
①同时预测thing和stuff的位置（其中，thing通过预测center来定位和分类，stuff通过region来定位和分类）(对于有相同语义信息的背景我们看做一个实例instance)
②然后根据thing和stuff的位置，从kernel head中产生kernel weights。（从内核头中选取位置相同的内核权重来表示相应的实例）
这里有一个细节是，thing通过定位的点从kernel head对应的点抽取kernel weight，而stuff通过定位的区域mask和kernel head相乘得到kernel weight，这样thing和stuff的kernel weight 维度能够保持相同。

⑵ kernel Fusion

将不同stage对同一实体（identity）产生的kernel weights 进行合并，保证thing的实例感知和stuff的语义一致性。简单来说通过对不同stage的kernel weights 平均池化产生所有thing和stuff的kernel weights，然后通过阈值来去除相似的kernel weight，最后产生M 个thing的kernel weights和N 个stuff的kernel weights。（通过naive feature encoder，保留了带有细节的高分辨率特征，可以通过直接与生成的内核进行卷积来产生对事物和东西的每个预测。）

⑶ Feature Encoder

首先对高分辨率feature进行编码得到编码feature，然后用kernel fusion得到的M+N 个kernel weights对encoded feature 进行卷积，得到最终的预测结果，其中每个输出通道表示一个thing和stuff的mask预测。和SOLO类似，panoptic FCN 的kernel head 和feature encoder都引入了coord,有利于和position head 特征进行位置对齐，对精度的提升非常大。

图1 The framework of Panoptic FCN

总结：
Panoptic FCN 通过引入了kernel generator 来为thing和stuff 生成kernel weights，然后通过kernel fusion对多个stage的kernel weights 进行合并，feature encoder用来对高分辨率feature进行编码，最后将得到的kernels和编码的feature卷积得到最终预测结果。

二、代码部分

⑴Kernel Generator

在代码的panoptic/head.py中，Position head 同时预测thing和stuff的位置（其中，thing通过预测center来定位和分类，stuff通过region来定位和分类）。代码中在第55行，

class PositionHead(nn.Module):

补充代码细节知识：

1. 均匀分布

torch.nn.init.uniform_(tensor, a=0, b=1) 服从~U(a,b)
U(a,b)

2. 正态分布

torch.nn.init.normal_(tensor, mean=0, std=1) 服从~N(mean,std)
N(mean,std)从给定均值和标准差的正态分布N(mean, std)中生成值，填充输入的张量或变量
参数：tensor – n维的torch.Tensor；mean – 正态分布的均值；std – 正态分布的标准差

3. 初始化为常数

torch.nn.init.constant_(tensor, val) 初始化整个矩阵为常数val
其中，focal loss在loss.py文件中，第75行def sigmoid_focal_loss()

Kernel head

然后根据thing和stuff的位置，从kernel head中产生kernel weights。代码中在第92行。

class KernelHead(nn.Module):

⑵Kernel Fusion

对多个stage的kernel weights 进行合并。在代码中class ThingGenerator(nn.Module)里面的
kernel_fusion(self, meta_weight, pred_cate, pred_score)；
然后代码中class StuffGenerator(nn.Module)，里面也有对应的kernel_fusion（）方法。所以这里的kernel weights是分别对thing和stuff处理。

⑶Feature Encoder

用来对高分辨率feature进行编码，最后将得到的kernels和编码feature卷积得到最终预测结果。代码中在第123行。

class FeatureEncoder(nn.Module):

（4）loss

Position loss

在panoptic_seg.py文件中，第193行：loss_pos_th 和loss_pos_st的计算。这里loss[“loss_pos_th”]就是论文中的 λpos *Lpos

#position loss
loss["loss_pos_th"] = self.pos_weight * sum(loss_pos_ths) / max(thing_gt_num, 1)
loss["loss_pos_st"] = self.pos_weight * sum(loss_pos_sts) / max(feat_shape[0],1)

segmentation loss

loss["loss_seg_th"] = self.seg_weight * loss_thing / max(thing_gt_num, 1)
loss["loss_seg_st"] = self.seg_weight * loss_stuff / max(stuff_gt_num, 1)
其中，loss_thing ：
loss_thing = weighted_dice_loss(thing_pred, thing_gt, 
                                gt_num=thing_gt_num,
                                index_mask=thing_gt_idx,
                                instance_num=thing_num,
                                weighted_val=weighted_values,
                                weighted_num=self.weighted_num,
                                mode="thing",
                                reduction="sum")     

loss_stuff ：

loss_stuff = weighted_dice_loss(stuff_pred, stuff_gt, 
                                gt_num=stuff_gt_num,
                                index_mask=stuff_gt_idx,
                                instance_num=stuff_num,
                                weighted_val=1.0,
                                weighted_num=1,
                                mode="stuff",
                                reduction="sum")

loss_pos_th: 就是论文中的FL（L_i^th , Y_i^th）

position loss for things

loss_pos_th = sigmoid_focal_loss(pred_center, gt_center,
                                 mode="thing",
                                 alpha=self.focal_loss_alpha,
                                 gamma=self.focal_loss_gamma,
                                 reduction="sum")

Loss_pos_st:

#position loss for stuff
loss_pos_st = sigmoid_focal_loss(pred_region, gt_sem_scores,
                                 mode="stuff",
                                 alpha=self.focal_loss_alpha,
                                 gamma=self.focal_loss_gamma,
                                 reduction="sum")

Segmentation loss

在loss.py文件中，dice loss在第62行。

#calculate dice loss
loss_part = (prediction ** 2).sum(dim=-1) + (target_seg ** 2).sum(dim=-1)
loss = 1 - 2 * (target_seg * prediction).sum(dim=-1) / torch.clamp(loss_part, min=eps)# clamp 函数返回范围内的一个数值。可以使用 clamp 函数将不断增加、减小或随机变化的数值限制在一系列的值中。
#normalize the loss
loss = loss * weighted_val

代码中有一个

prediction = prediction.reshape(-1, weighted_num, h, w)[index_mask,...]
# a[…, :2]= a[:, :, :2] 所以这里[index_mask,...] = [index_mask : : ]？