不确定度 Uncertainty

对之前看的不确定度·做一个总结。
首先是第一篇文章：Sparse and noisy LiDAR completion with RGB guidance and uncertainty

作者在3.2说：在全局和局部分支都用到了不确定性，框架的两个部分都预测了一个置信度图，而置信度图对最终的融合就像是一个权重，因此这个权重是对图片中每一个像素都加权，并且通过无监督学习，基于学习到的置信度权重，不确定度就会对确定的输入类型更多的注意力。对于准确的lidar图像，局部网络将会产生带有高置信度的深度预测，对于不正确或者缺少的lidar数据，全局信息将会被使用，比如物体的边界。
在代码中表现为：1：如何产生的？2：如何使用的？
置信图一般由softmax产生。
global产生的置信图是由ERFNet产生的结果图按维度取切片。

**local产生的置信图：**是由沙漏结构产生的结果在维度方向上进行切分。
最终产生的置信图经过softmax拼接之后再进过softmax，产生的权重分别对两个框架产生的输出图进行加权。

---

第二篇是：UACANet: Uncertainty Augmented Context Attention for Polyp Segmentation

根据框架我们可以看到：encoder最后一层输出，输入到decoder中，大小并没有发生变化，且会产生一个初始的分割图，然后对分割图者不进行完善，最后上采样四倍。本文将分割图进行阈值处理，Mu作为不确定区域，然后将三个区域concat与原始的图进行注意力计算。

作者在3.3提到物体的边界区域有一个很低的saliency分数，反注意力是一个有效的方法去进行边界引导。我们专注于特征图和反特征图发现，边界区域的分数输一个模糊的分数为0.5，作者认为特征图和反特征图具有相等的边界信息，因为1减去特征图就是反特征图。即公式2，m=0.5，我们就把他判为不确定区域。这是不确定区域的来源。
那么他将起到什么作用呢？

由图可以看到，我们将他concat起来，刚才求三个区域，为了就是把他分开，现在concat一起有作用吗？
其实是有的，因为concat之后我们和原始图片相乘，每一个区域还是取出来的。然后再对x做注意力。

---

第三篇：Rectifying Pseudo Label Learning via Uncertainty Estimation for Domain Semantic Segmentation

来源：作者通过预测方差量化不确定度。预测是两个分类器的输出预测

通过kl散度实现的：

去处：通过与交叉熵损失函数相乘，作为loss，给每一个像素分配一个权重。

在代码中实现：

class ResNetMulti(nn.Module):
    def __init__(self, block, layers, num_classes, use_se = False, train_bn = False, norm_style = 'bn', droprate = 0.1):
        self.inplanes = 64
        self.train_bn = train_bn
        super(ResNetMulti, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(64, affine=affine_par)
        for i in self.bn1.parameters():
            i.requires_grad = self.train_bn
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, ceil_mode=True)  # change
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4)
        self.layer5 = self._make_pred_layer(Classifier_Module, 1024, [6, 12, 18, 24], [6, 12, 18, 24], num_classes, norm_style, droprate, use_se)
        self.layer6 = self._make_pred_layer(Classifier_Module, 1024 + 2048, [6, 12, 18, 24], [6, 12, 18, 24], num_classes, norm_style, droprate, use_se)

        #for m in self.modules():
        #    if isinstance(m, nn.Conv2d):
        #        n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
        #        m.weight.data.normal_(0, 0.01)
        #    elif isinstance(m, nn.BatchNorm2d):
        #        m.weight.data.fill_(1)
        #        m.bias.data.zero_()
                #        for i in m.parameters():
                #            i.requires_grad = False

    def _make_layer(self, block, planes, blocks, stride=1, dilation=1):
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion or dilation == 2 or dilation == 4:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * block.expansion, affine=affine_par))
        for i in downsample._modules['1'].parameters():
            i.requires_grad = self.train_bn
        layers = []
        layers.append(block(self.inplanes, planes, stride, dilation=dilation, downsample=downsample, train_bn = self.train_bn))
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes, dilation=dilation, downsample = None, train_bn = self.train_bn))

        return nn.Sequential(*layers)

    def _make_pred_layer(self, block, inplanes, dilation_series, padding_series, num_classes, norm_style, droprate, use_se):
        return block(inplanes, dilation_series, padding_series, num_classes, norm_style, droprate, use_se)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)
        x = self.layer1(x)
        x = self.layer2(x)

        x = self.layer3(x)
        x1 = self.layer5(x)

        x2 = torch.cat((self.layer4(x),x), 1)
        x2 = self.layer6(x2)

        return x1, x2
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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

首先输入经过网络会产生两个输出。对应于两个classifier。即trainer_ms.py的：self.G

将模型送入cuda中，然后上采样到原图大小：

 pred_target1, pred_target2 = self.G(images_t)
 pred_target1 = self.interp_target(pred_target1)
 pred_target2 = self.interp_target(pred_target2)
1
2
3

接着：将他们相加进行softmax，然后将两个分类器的预测值分别和他们相加的softmax值进行kl计算。

 loss_kl = 0.0
            if self.lambda_kl_target_copy>0:
                n, c, h, w = pred_target1.shape
                with torch.no_grad():
                    #pred_target1_flip, pred_target2_flip = self.G(fliplr(images_t))
                    #pred_target1_flip = self.interp_target(pred_target1_flip)
                    #pred_target2_flip = self.interp_target(pred_target2_flip)
                    mean_pred = self.sm(0.5*pred_target1 + pred_target2) #+ self.sm(fliplr(0.5*pred_target1_flip + pred_target2_flip)) ) /2
                loss_kl = ( self.kl_loss(self.log_sm(pred_target2) , mean_pred)  + self.kl_loss(self.log_sm(pred_target1) , mean_pred))/(n*h*w)
                #loss_kl = (self.kl_loss(self.log_sm(pred_target2) , self.sm(pred_target1) ) ) / (n*h*w) + (self.kl_loss(self.log_sm(pred_target1) , self.sm(pred_target2)) ) / (n*h*w)
                print(loss_kl)
                loss += self.lambda_kl_target * loss_kl
1
2
3
4
5
6
7
8
9
10
11
12

最后进行损失反向计算。