Paperreading之五 Stacked Hourglass Networks(SHN)和源码阅读（PyTorch版本）

1.前言

这篇文章是ECCV2016的论文，Jia Deng组的工作，是top-down算法，非常经典，当时也是在各种公开数据集上霸榜。在FLIC和MPII上都是第一名（在当时），是sota算法。现在很多关于姿态估计的论文都有参考SHN或者会拿他作对比，可以说是比较典型的姿态估计算法。

 

2. 网络结构

SHN网络名字起的很不错，级联的沙漏网络，顾名思义，沙漏网络就表示该网络具有高度对称性，多个沙漏网络进行级联，其实不级联也是可以检测的，只是检测效果会差一些，作者认为人体关节点之间有较强的相关性，前面沙漏检测出的关键点对后面的检测有帮助，所以前面的输出可以作为后面的输入的一部分，见下图的虚线部分，这个后面再讨论。

级联的沙漏网络

 

2.1单个沙漏网络

单个沙漏网络如上图所示，这是一个4阶版本的沙漏网络，表示有四次下采样和四次下采样。方块大小表示feature maps大小，方块变小方式下采样，方块变大是上采样，加号表示按元素相加。其他全部都是残差模块，上方的连线方式也是一些残差模块，但是没有改变feature maps的大小，只是改变通道数，变成与下面相同，然后才可以按元素相加。

看一下更加具体的版本

该图来自https://blog.csdn.net/shenxiaolu1984/article/details/51428392。浅绿色部分是一些残差模块。看上去很明朗，就是一些残差模块，先下采样然后上采样，这样的网络结构提取特征很充分，在不同的分辨率有进行卷积，然后还有特征融合。但是也有一些弊端，不能使用pretrained model，因为它不像cpn那样，GlobalNet是resnet50或者resnet101，可以直接使用在ImageNet上预训练的模型进行初始化。没有预训练模型用来初始化，一般需要训练更久然后效果会更差一些，但是没有预训练的情况下，当数据很充分，训练也很充分，合理使用BN或者GN，炼丹能力较好的情况下，是可以达到预训练的效果（Kaiming He的最新论文的结论，Rethinking）。

2.2看一下Pytorch版本实现

class HourglassNet(nn.Module):
    '''Hourglass model from Newell et al ECCV 2016'''
    def __init__(self, block, num_stacks=2, num_blocks=4, num_classes=16):
        """
        参数解释
        :param block: hg块元素
        :param num_stacks: 有几个hg
        :param num_blocks: 在两个hg之间有几个block块
        :param num_classes: keypoint个数,也就是最后的heatmap个数
        """
        super(HourglassNet, self).__init__()

        self.inplanes = 64
        self.num_feats = 128
        self.num_stacks = num_stacks
        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,
                               bias=True)   # 第一次下采样
        self.bn1 = nn.BatchNorm2d(self.inplanes) 
        self.relu = nn.ReLU(inplace=True)
        self.layer1 = self._make_residual(block, self.inplanes, 1)  #self.planes = 64，有downsample（只是改变channel数）
        self.layer2 = self._make_residual(block, self.inplanes, 1)  #有downsample（只是改变channel数）
        # 这一次的bottleneck没有downsample，因为self.planes == planes(self.num_feats=128)*2 = 256
        self.layer3 = self._make_residual(block, self.num_feats, 1)
        self.maxpool = nn.MaxPool2d(2, stride=2)   #第二次下采样
        # build hourglass modules
        ch = self.num_feats*block.expansion   #128*2=256
        hg, res, fc, score, fc_, score_ = [], [], [], [], [], []
        for i in range(num_stacks):
            hg.append(Hourglass(block, num_blocks, self.num_feats, 4))  #block, num_blocks, planes, depth=4
            res.append(self._make_residual(block, self.num_feats, num_blocks))
            fc.append(self._make_fc(ch, ch))
            score.append(nn.Conv2d(ch, num_classes, kernel_size=1, bias=True))
            if i < num_stacks-1:
                fc_.append(nn.Conv2d(ch, ch, kernel_size=1, bias=True))
                score_.append(nn.Conv2d(num_classes, ch, kernel_size=1, bias=True))
        self.hg = nn.ModuleList(hg)
        self.res = nn.ModuleList(res)
        self.fc = nn.ModuleList(fc)
        self.score = nn.ModuleList(score)
        self.fc_ = nn.ModuleList(fc_) 
        self.score_ = nn.ModuleList(score_)

    def _make_residual(self, block, planes, blocks, stride=1):  #planes = 64,blocks=4
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            # 这里的downsample只有改变通道数的功能，并没有下采样的功能，因为调用时stride固定为1
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=True),
            )

        layers = []
        # 只在每个block的第一个bottleneck做downsample，因为channel数不相同
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion  #self.planes是改变的,从最开始的64，128,256
        for i in range(1, blocks):   #因为blocks=1 ，后面都不会执行
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def _make_fc(self, inplanes, outplanes):
        bn = nn.BatchNorm2d(inplanes)
        conv = nn.Conv2d(inplanes, outplanes, kernel_size=1, bias=True)
        return nn.Sequential(
                conv,
                bn,
                self.relu,
            )

    def forward(self, x):
        out = []
        x = self.conv1(x)  #下采样
        x = self.bn1(x)
        x = self.relu(x) 

        x = self.layer1(x)  
        x = self.maxpool(x)  #下采样
        x = self.layer2(x)  
        x = self.layer3(x)  

        for i in range(self.num_stacks):
            y = self.hg[i](x)
            y = self.res[i](y)
            y = self.fc[i](y)
            score = self.score[i](y)
            out.append(score)
            if i < self.num_stacks-1:
                fc_ = self.fc_[i](y)
                score_ = self.score_[i](score)
                x = x + fc_ + score_

        return out

在上面，Bottleneck是使用expansion=2的版本的残差Bottleneck，通常是是使用4阶版本的沙漏网络，结构就跟上图一样，很多残差模块加下采样和上采样。这个实现使用了递归实现，这么短的代码就实现了那么长的网络结构，PyTorch真香，呵呵~

 

2.3完整网络结构

看了上面的单个Hourglass结构，下面看下完整的网络结构。很简单，前面加了几层卷积，后面就是Hourglass的级联模式，Hourglass之间的级联稍微有一些特殊处理。

网络的从一个7*7的卷积开始，然后接着3个残差模块，这一共会经过两次下采样，如果输入是256*256的，那么经过这个前端网络处理feature maps变为64*64的尺寸。后面就开始级联多个Hourglass部分接口，只与多少个可能要根据实际情况确定。作者实验试过2,4,8，好像是越多越好，然后越到后面输出预测越准，符合直觉预期，说明经过级联是有效的，前面的输出对后面的训练是有帮助的。

下面是Hourglass之间的连接结构图，有一些特征融合在里面。

 

图来自https://blog.csdn.net/wangzi371312/article/details/81174452

如上图，N1代表第一个沙漏网络，提取出的混合特征经过1个1x1全卷积网络后，分成上下两个分支，上部分支继续经过1x1卷积后，进入下一个沙漏网络。下部分支先经过1x1卷积后，生成heat map，就是图中蓝色部分.

上图中蓝色方块比其他三个方块要窄一些，这是因为heat map矩阵的depth与训练数据里的节点数一致，比如 [1x64x64x16]，其他几个则具有较高的depth，如 [1x64x64x256]

heat_map继续经过1x1卷积，将depth调整到与上部分支一致，如256，最后与上部分支合并，一起作为下一个沙漏网络的输入。

前面提到过，由于人体关节点之间的较强相关性，作者认为前面检测出的heat maps对后面的预测是有帮助的，最初的输入，heatmaps经过1*1卷积调整channels数，以及上一级Hourglass的输出三个做按元素相加，作为下一级Hourglass的输入。

2.4 完整网络结构PyTorch实现

class HourglassNet(nn.Module):
    '''Hourglass model from Newell et al ECCV 2016'''
    def __init__(self, block, num_stacks=2, num_blocks=4, num_classes=16):
        """
        参数解释
        :param block: hg块元素
        :param num_stacks: 有几个hg
        :param num_blocks: 在两个hg之间有几个block块
        :param num_classes: keypoint个数,也就是最后的heatmap个数
        """
        super(HourglassNet, self).__init__()

        self.inplanes = 64
        self.num_feats = 128
        self.num_stacks = num_stacks
        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,
                               bias=True)
        self.bn1 = nn.BatchNorm2d(self.inplanes) 
        self.relu = nn.ReLU(inplace=True)
        self.layer1 = self._make_residual(block, self.inplanes, 1)  #self.planes = 64
        self.layer2 = self._make_residual(block, self.inplanes, 1)
        self.layer3 = self._make_residual(block, self.num_feats, 1)  #这一次的bottleneck没有downsample，因为self.planes == planes(self.num_feats=128)*2 = 256
        self.maxpool = nn.MaxPool2d(2, stride=2)   #TODO 这个maxpool需不需要。论文里是有2次下采样，从256降到64，

        # build hourglass modules
        ch = self.num_feats*block.expansion   #128*2=256
        hg, res, fc, score, fc_, score_ = [], [], [], [], [], []
        for i in range(num_stacks):
            hg.append(Hourglass(block, num_blocks, self.num_feats, 4))  #block, num_blocks, planes, depth=4
            res.append(self._make_residual(block, self.num_feats, num_blocks))
            fc.append(self._make_fc(ch, ch))
            score.append(nn.Conv2d(ch, num_classes, kernel_size=1, bias=True))
            if i < num_stacks-1:
                fc_.append(nn.Conv2d(ch, ch, kernel_size=1, bias=True))
                score_.append(nn.Conv2d(num_classes, ch, kernel_size=1, bias=True))
        self.hg = nn.ModuleList(hg)
        self.res = nn.ModuleList(res)
        self.fc = nn.ModuleList(fc)
        self.score = nn.ModuleList(score)
        self.fc_ = nn.ModuleList(fc_) 
        self.score_ = nn.ModuleList(score_)

    def _make_residual(self, block, planes, blocks, stride=1):  #planes = 64,blocks=4
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=True),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))  #只在每个block的第一个bottleneck做下采样，因为channel数不相同
        self.inplanes = planes * block.expansion  #self.planes是改变的,从最开始的64，128,256
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def _make_fc(self, inplanes, outplanes):
        bn = nn.BatchNorm2d(inplanes)
        conv = nn.Conv2d(inplanes, outplanes, kernel_size=1, bias=True)
        return nn.Sequential(
                conv,
                bn,
                self.relu,
            )

    def forward(self, x):
        out = []
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x) 

        x = self.layer1(x)  
        x = self.maxpool(x)
        x = self.layer2(x)  
        x = self.layer3(x)  

        for i in range(self.num_stacks):
            y = self.hg[i](x)
            y = self.res[i](y)
            y = self.fc[i](y)
            score = self.score[i](y)
            out.append(score)
            if i < self.num_stacks-1:
                fc_ = self.fc_[i](y)
                score_ = self.score_[i](score)
                x = x + fc_ + score_

        return out

fc和score分别表示hourglass的输出两个支路，score是得到heatmaps，经过的卷积的channel 数好keypoints个数相同。fc_和score_分别表示当后面还需要级联Hourglass时，需要做一些1*1的卷积改变featuremaps的通道数，这样后面才能做按元素相加，然后作为后面的输入。

 

3. 中继监督

通过端到端地堆叠多个沙漏，我们将网络架构进一步细化，将一个沙漏的输出作为输入提供给下一个沙漏，但是每个Hourglass都会输出heatmaps，然后也会计算loss。这提供了具有用于重复自底向上、自顶向下的推理的机制的网络，允许在整个图像上重新评估初始估计和特征。这种方法的关键是预测我们可以应用损失的中间群体。预测是在通过每个沙漏之后生成的，其中网络有机会在本地和全局上下文中处理特性。随后的沙漏模块允许再次处理这些高级特征，以进一步评估和重新评估高阶空间关系。这与其他姿态估计方法类似，这些姿态估计方法在多个迭代阶段和中间监督下表现出很强的性能。

下面这个图挺有意思的，这个Ablation实验部分。作者实验了不同的级联方式对准确率的影响，和中间Hourglass输出heatmaps的准确率规律，在参数量几乎相同的情况下，每个残差模块有不同的个数，这样网络的总层数几乎相同。可以看到，小的Hourglass多级联几次有利于准确率提升，后面层的输出比前面的输出效果好非常多，在小的Hourglass上看的尤其明显，级联了8次，前面2级的效果很差。

作者还做了一些有趣的实验，loss计算位置，在网络结构相似的情况下，loss影响不是特别大，在每个Hourglass的单独输出上计算loss效果是最好的。

 

4. 训练设置

5. 结论与结果

1. 设计了一个新的单人姿态估计网络Hourglass，效果也是棒棒的，如果用于多人需要单独的行人检测作为前端预处理。
2. 中继监督的作用很大，
3. 级联的Hourglass效果非常好，当时sota方法
4. 但对一些遮挡问题难以处理，这是绝大部分算法的难题

 

参考文献：

[1] Newell A , Yang K , Deng J . Stacked Hourglass Networks for Human Pose Estimation[J]. 2016.

[2] https://github.com/bearpaw/pytorch-pose

[3]https://blog.csdn.net/wangzi371312/article/details/81174452

[4] https://blog.csdn.net/shenxiaolu1984/article/details/51428392