(原)人体姿态识别alphapose

转载请注明出处:

https://www.cnblogs.com/darkknightzh/p/12150171.html

论文

RMPE: Regional Multi-Person Pose Estimation

https://arxiv.org/abs/1612.00137

官方代码:

https://github.com/MVIG-SJTU/AlphaPose

官方pytorch代码:

https://github.com/MVIG-SJTU/AlphaPose/tree/pytorch

1. 简介

该论文指出,定位和识别中不可避免的会出现错误,这些错误会引起单人姿态估计(single-person pose estimator,SPPE)的错误,特别是完全依赖人体检测的姿态估计算法。因而该论文提出了区域姿态估计(Regional Multi-Person Pose Estimation,RMPE)框架。主要包括symmetric spatial transformer network (SSTN)、Parametric Pose Non- Maximum-Suppression (NMS), 和Pose-Guided Proposals Generator (PGPG)。并且使用symmetric spatial transformer network (SSTN)、deep proposals generator (DPG) 、parametric pose nonmaximum suppression (p-NMS) 三个技术来解决野外场景下多人姿态估计问题。

2. 之前算法的问题

2.1检测框定位错误

如下图所示。红框为真实框,黄框为检测到的框(IoU>0.5)。由于定位错误,黄框得到的热图无法检测到关节点

解决方法:增大训练时的框(框增大0.2-0.3倍)

2.2 检测框冗余

如下图所示。同一个人可能检测到多个框。

解决方法:使用p-NMS来解决人体检测框不准确时的姿态估计问题。

3. 网络结构

3.1 总体结构

总体网络结构如下图:

Symmetric STN=STN+SPPE+SDTN

STN:空间变换网络,对于不准确的输入,得到准确的人的框。输入候选区域,用于获取高质量的候选区域。

SPPE:得到估计的姿态。

SDTN:空间逆变换网络,将估计的姿态映射回原始的图像坐标。

Pose-NMS:消除额外的估计到的姿态

Parallel SPPE:训练阶段作为额外的正则项,避免陷入局部最优,并进一步提升SSTN的效果。包含相同的STN及SPPE(所有参数均被冻结),无SDTN。测试阶段无此模块。

PGPG(Pose-guided Proposals Generator):通过PGPG网络得到训练图像,用来训练SSTN+SPPE模块。

3.2 SSTN

SSTN如下图所示。不准确的输入(下图左侧input)经过STN+SPPE+SDTN,先姿态估计,把估计结果映射到原图,以此来调整原本的框,使框变的精准。其中中间黑色虚线的框认为是准确的输入(即中心化的输入,将姿态对齐到图像中心)。

3.3 STN和SDTN

STN为2D的仿射变换,定义如下:

SDTN定义如下:

其中为变换后坐标,为变换前坐标。${{\theta }_{1}}$,${{\theta }_{2}}$,${{\theta }_{3}}$,${{\gamma }_{1}}$,${{\gamma }_{2}}$,${{\gamma }_{3}}$为变换参数关系如下:

(使用SDTN进行反向传播的公式请见论文)

3.4 Parallel SPPE(PSPPE)

PSPPE模块和原始的SPPE共享相同的STN参数,但是无SDTN模块。此分支的人体姿态已经中心化,和中心化后的真知标签直接比较。训练阶段,PSPPE所有层的参数均被冻结,目的是反传中心化的姿态误差到STN模块。因而若STN得到的姿态未中心化,会产生较大的误差,使得STN集中于正确的区域。

可以讲PSPPE作为训练阶段额外的正则项。

3.5 P-NMS

定义:令第i个姿态由m个关节点组成,定义为$\left\{ \left\langle k_{i}^{1},c_{i}^{1} \right\rangle ,\cdots ,\left\langle k_{i}^{m},c_{i}^{m} \right\rangle  \right\}$,其中k为location,c为socre。

消除过程:score最高的姿态作为基准,重复消除接近基准姿态的姿态,直到剩下单一的姿态。

消除准则:消除标准用于重复消除剩余姿态,为:

$f({{P}_{i}},{{P}_{j}}|\Lambda ,\eta )=\mathbf{1}(d({{P}_{i}},{{P}_{j}}|\Lambda ,\lambda )\le \eta )$

其中,距离函数$d(\centerdot )$包括姿态距离和空间距离,若$d(\centerdot )$不大于$\eta $,则上面$f(\centerdot )$的输出为1,表明由于${{P}_{i}}$和基准姿态${{P}_{j}}$过于相似,因而${{P}_{i}}$需要被消除。其定义如下:

$d({{P}_{i}},{{P}_{j}}|\Lambda )\text{=}{{K}_{Sim}}({{P}_{i}},{{P}_{j}}|{{\sigma }_{1}})+\lambda {{H}_{sim}}({{P}_{i}},{{P}_{j}}|{{\sigma }_{2}})$

其中,$\Lambda =\{{{\sigma }_{1}},{{\sigma }_{2}},\lambda \}$。

姿态距离用于消除和其他姿态太近且太相似的姿态,假定${{P}_{i}}$的bbox是${{B}_{i}}$,其定义为如下的soft matching公式(不同特征之间score的相似度):

其中$B(k_{i}^{n})$为中心在$k_{i}^{n}$的box,并且每个坐标$B(k_{i}^{n})$为原始坐标${{B}_{i}}$的1/10。

如下图所示。其中蓝框为关节点${{P}_{i}}$的框,各黑点为蓝框${{P}_{i}}$各个关节点位置$k_{i}^{n}$(为了方便,只显示了4个),各红框为宽高为蓝框1/10的子框,其中心为相应的关节点$k_{i}^{n}$,三角为姿态${{P}_{j}}$在红框内的关节点$k_{j}^{n}$,五星为姿态${{P}_{j}}$在红框外关节点$k_{j}^{n}$。进行消除时,对三角使用上式的if进行消除,因该点在子框内;对五星使用otherwise,因该点在子框外(左上角既有三角,又有五星。实际上对于一个检测到的姿态${{P}_{j}}$,是不会出现这种情况的,因为一个姿态的某个特定关节点只有一个,不会出现三角和五星两个关节点。此处只是显示使用)。

空间距离用于衡量不同特征之间空间距离的相似度,令$k_{i}^{n}$和$k_{j}^{n}$为不同特征中心,其定义如下:

${{H}_{sim}}({{P}_{i}},{{P}_{j}}|{{\sigma }_{2}})=\sum\limits_{n}{\exp [-\frac{{{(k_{i}^{n}-k_{j}^{n})}^{2}}}{{{\sigma }_{2}}}]}$

$\lambda $为平衡姿态距离和空间距离的权重。$\eta $为阈值。上式共四个参数${{\sigma }_{1}}$,${{\sigma }_{2}}$,$\lambda $,$\eta $,论文中说交替固定2个,训练另外两个。但是pytorch代码中全部固定了。

3.6 PGPG

步骤:

1 归一化姿态,使得所有躯干有归一化长度。

2 使用kmeans聚类对齐的姿态,并且聚类得到的中心形成atomic poses。

3 对有相同atomic poses的人,计算gt bbox和detected bbox的偏移。

4 偏移使用gt bbox进行归一化。

5 此时,偏移作为频率的分布,且固定数据为高斯混合分布。对于不同的atomic poses,有不同的高斯混合分布的参数。

注:没看此部分对应的代码

4. 代码

4.1 前向推断

网络前向推断使用InferenNet_fast函数,其中输入图像x为通过yolo V3检测到的单张人体。

输出为热图。out.narrow原因是,训练时使用了COCO和MPII,因而特征维数维33,前17层为COCO特征。代码中只测试COCO上性能,因而只取前17层热图。

 1 class InferenNet_fast(nn.Module):
 2     def __init__(self, kernel_size, dataset):
 3         super(InferenNet_fast, self).__init__()
 4 
 5         model = createModel().cuda()
 6         print('Loading pose model from {}'.format('./models/sppe/duc_se.pth'))
 7         model.load_state_dict(torch.load('./models/sppe/duc_se.pth'))
 8         model.eval()
 9         self.pyranet = model   # 图像得到33维热图
10         self.dataset = dataset
11 
12     def forward(self, x):
13         out = self.pyranet(x)   # 得到b*33*h*w的矩阵
14         # https://github.com/MVIG-SJTU/AlphaPose/issues/187#issuecomment-441416429 指出,代码联合训练COCO和MPII,前17个为COCO,后16个为MPII,故此处取前17层
15         out = out.narrow(1, 0, 17)  # data = tensor:narrow(dim, index, size)取出tensor中第dim维上索引从index开始到index+size-1的所有元素存放在data中
16 
17         return out   # 图像得到33维热图,取出channel上0—16维特征
18 
19 
20 def createModel():
21     return FastPose()
22 
23 
24 class FastPose(nn.Module):
25     DIM = 128
26 
27     def __init__(self):
28         super(FastPose, self).__init__()
29         self.preact = SEResnet('resnet101')   # 101层SE_ResNet
30         self.suffle1 = nn.PixelShuffle(2) #将Input: (N, C∗upscale_factor * upscale_factor2, H, W)转换成输出Output: (N, C, H∗upscale_factor, W∗upscale_factor),此处upscale_factor=2
31         self.duc1 = DUC(512, 1024, upscale_factor=2)   # conv+BN+ReLU+PixelShuffle, PixelShuffle将1024维降低到256维
32         self.duc2 = DUC(256, 512, upscale_factor=2)    # conv+BN+ReLU+PixelShuffle, PixelShuffle将512维降低到128维
33         self.conv_out = nn.Conv2d(self.DIM, opt.nClasses, kernel_size=3, stride=1, padding=1) # 128维降低到33维
34 
35     def forward(self, x: Variable):
36         out = self.preact(x)
37         out = self.suffle1(out)
38         out = self.duc1(out)
39         out = self.duc2(out)
40 
41         out = self.conv_out(out)
42         return out
43 
44 
45 class DUC(nn.Module):
46     '''
47     INPUT: inplanes, planes, upscale_factor
48     OUTPUT: (planes // 4)* ht * wd
49     '''
50     def __init__(self, inplanes, planes, upscale_factor=2):
51         super(DUC, self).__init__()
52         self.conv = nn.Conv2d(inplanes, planes, kernel_size=3, padding=1, bias=False)
53         self.bn = nn.BatchNorm2d(planes)
54         self.relu = nn.ReLU()
55 
56         self.pixel_shuffle = nn.PixelShuffle(upscale_factor)  #将Input: (N, C∗upscale_factor * upscale_factor2, H, W)转换成输出Output: (N, C, H∗upscale_factor, W∗upscale_factor)
57 
58     def forward(self, x):
59         x = self.conv(x)
60         x = self.bn(x)
61         x = self.relu(x)
62         x = self.pixel_shuffle(x)
63         return x
View Code

4.2 预测

预测代码如下:

 1 def getPrediction(hms, pt1, pt2, inpH, inpW, resH, resW):  # 由于对人体检测后裁剪的图像进行预测,后6个参数为裁剪图像的相关信息
 2     '''Get keypoint location from heatmaps'''
 3     assert hms.dim() == 4, 'Score maps should be 4-dim'
 4     # 每个通道最大值作为关节点,因为是自顶向下,前提就是每张图只有一个人,因而每个通道只有一个关节点
 5     maxval, idx = torch.max(hms.view(hms.size(0), hms.size(1), -1), 2)  # hms.size(0)为batchsize,hms.size(1)为channels,热图中h*w变成一维后的最大值及索引
 6 
 7     maxval = maxval.view(hms.size(0), hms.size(1), 1)  # b*c*1的矩阵
 8     idx = idx.view(hms.size(0), hms.size(1), 1) + 1    # b*c*1的矩阵,+1是用于防止计算xy坐标时错误
 9 
10     preds = idx.repeat(1, 1, 2).float()  # b*c*2的矩阵,将第2维重复一遍
11 
12     preds[:, :, 0] = (preds[:, :, 0] - 1) % hms.size(3)                 # 得到x坐标
13     preds[:, :, 1] = torch.floor((preds[:, :, 1] - 1) / hms.size(3))    # 得到y坐标
14 
15     pred_mask = maxval.gt(0).repeat(1, 1, 2).float()   # 最大值中大于0的第2维重复一遍
16     preds *= pred_mask   # 去掉maxval小于0对应的坐标
17 
18     # Very simple post-processing step to improve performance at tight PCK thresholds
19     for i in range(preds.size(0)):        # 遍历batchsize中每个输入的预测
20         for j in range(preds.size(1)):    # 遍历每个channels
21             hm = hms[i][j]                # 当前热图
22             pX, pY = int(round(float(preds[i][j][0]))), int(round(float(preds[i][j][1])))    # 当前坐标
23             # 得到热图每个关节点的坐标后,进一步结合上下左右四个点,优化坐标(论文中没有提到)
24             if 0 < pX < opt.outputResW - 1 and 0 < pY < opt.outputResH - 1:                  # 当前坐标在特征图内
25                 diff = torch.Tensor((hm[pY][pX + 1] - hm[pY][pX - 1], hm[pY + 1][pX] - hm[pY - 1][pX]))  # 当前热图点右侧减左侧值,当前点热图下边减上边值
26                 preds[i][j] += diff.sign() * 0.25  # diff.sign()得到diff每个元素的正负;此处将preds进行偏移
27     preds += 0.2   # preds进一步偏移??
28 
29     preds_tf = torch.zeros(preds.size())
30     preds_tf = transformBoxInvert_batch(preds, pt1, pt2, inpH, inpW, resH, resW)  # 热图中关节点坐标映射回原始图像上的坐标
31 
32     return preds, preds_tf, maxval   # 返回关节点在原始图像裁剪后图像上的坐标,在原始图像上的坐标,热图最大值
View Code

4.3 P-NMS

p _poseNMS.py配置参数如下(固定的参数,并未体现出通过训练得到):

  1 delta1 = 1
  2 mu = 1.7
  3 delta2 = 2.65
  4 gamma = 22.48
  5 scoreThreds = 0.3
  6 matchThreds = 5
  7 areaThres = 0#40 * 40.5
  8 alpha = 0.1
  9 
 10 pose_nms如下:
 11 def pose_nms(bboxes, bbox_scores, pose_preds, pose_scores):
 12     '''
 13     Parametric Pose NMS algorithm
 14     bboxes:         bbox locations list (n, 4)
 15     bbox_scores:    bbox scores list (n,)    #       各个框为人的score
 16     pose_preds:     pose locations list (n, 17, 2)   各关节点的坐标
 17     pose_scores:    pose scores list    (n, 17, 1)   各个关节点的score
 18     '''
 19     #global ori_pose_preds, ori_pose_scores, ref_dists
 20 
 21     pose_scores[pose_scores == 0] = 1e-5
 22     final_result = []
 23 
 24     ori_bbox_scores = bbox_scores.clone()   # 各个框为人的score,下面要删除,此处先备份
 25     ori_pose_preds = pose_preds.clone()     # 各关节点的坐标,下面要删除,此处先备份
 26     ori_pose_scores = pose_scores.clone()   # 各个关节点的score,下面要删除,此处先备份 [n, 17, 1]
 27 
 28     xmax = bboxes[:, 2]   # 检测到的人在原始图像上的坐标
 29     xmin = bboxes[:, 0]
 30     ymax = bboxes[:, 3]
 31     ymin = bboxes[:, 1]
 32 
 33     widths = xmax - xmin   # 检测到的人的宽高
 34     heights = ymax - ymin
 35     ref_dists = alpha * np.maximum(widths, heights)   # alpha=0.1,为论文中的1/10,此处为NMS中当前batch各个人子框的阈值[n,]
 36 
 37     nsamples = bboxes.shape[0]
 38     human_scores = pose_scores.mean(dim=1)  # 当前batch各个人姿态的均值 [n, 1]
 39     human_ids = np.arange(nsamples)
 40     pick = []            # Do pPose-NMS
 41     merge_ids = []
 42     while(human_scores.shape[0] != 0):
 43         pick_id = torch.argmax(human_scores)     # Pick the one with highest score   找出分值最高的姿态的索引
 44         pick.append(human_ids[pick_id])          # 由于后面要delete array的部分值,因而此处保存索引
 45         # num_visPart = torch.sum(pose_scores[pick_id] > 0.2)
 46 
 47         ref_dist = ref_dists[human_ids[pick_id]]  # Get numbers of match keypoints by calling PCK_match  当前人NMS子框的阈值
 48         simi = get_parametric_distance(pick_id, pose_preds, pose_scores, ref_dist)   # 公式(10)的距离,[n],由于每次均会删除id,因而n递减
 49         num_match_keypoints = PCK_match(pose_preds[pick_id], pose_preds, ref_dist)   # 返回满足条件的点的数量,[n],由于每次均会删除id,因而n递减
 50 
 51         # Delete humans who have more than matchThreds keypoints overlap and high similarity   # gamma = 22.48,matchThreds = 5,
 52         delete_ids = torch.from_numpy(np.arange(human_scores.shape[0]))[(simi > gamma) | (num_match_keypoints >= matchThreds)]  # 迭代删除的索引
 53 
 54         if delete_ids.shape[0] == 0:
 55             delete_ids = pick_id
 56         #else:
 57         #    delete_ids = torch.from_numpy(delete_ids)
 58 
 59         merge_ids.append(human_ids[delete_ids])    # 每次筛选出来的人的索引,如果没有近距离的人,merge_ids==pick
 60         pose_preds = np.delete(pose_preds, delete_ids, axis=0)
 61         pose_scores = np.delete(pose_scores, delete_ids, axis=0)
 62         human_ids = np.delete(human_ids, delete_ids)
 63         human_scores = np.delete(human_scores, delete_ids, axis=0)
 64         bbox_scores = np.delete(bbox_scores, delete_ids, axis=0)
 65 
 66     assert len(merge_ids) == len(pick)
 67     preds_pick = ori_pose_preds[pick]            # 根据pick重新映射后的不同人各关节点的坐标
 68     scores_pick = ori_pose_scores[pick]
 69     bbox_scores_pick = ori_bbox_scores[pick]
 70     #final_result = pool.map(filter_result, zip(scores_pick, merge_ids, preds_pick, pick, bbox_scores_pick))
 71     #final_result = [item for item in final_result if item is not None]
 72 
 73     for j in range(len(pick)):   # 人的数量。此处是当人体检测器检测的不好,同一个人检测到了2个以上的框,这些框比较接近的情况
 74         ids = np.arange(17)
 75         max_score = torch.max(scores_pick[j, ids, 0])
 76 
 77         if max_score < scoreThreds:
 78             continue
 79 
 80         merge_id = merge_ids[j]  # Merge poses
 81         # 返回冗余关节点位置和这些关节点对应的score。无冗余姿态的情况下,merge_pose==preds_pick[j]==ori_pose_preds[merge_id],merge_score==ori_pose_scores[merge_id]
 82         merge_pose, merge_score = p_merge_fast(preds_pick[j], ori_pose_preds[merge_id], ori_pose_scores[merge_id], ref_dists[pick[j]])
 83 
 84         max_score = torch.max(merge_score[ids])
 85         if max_score < scoreThreds:
 86             continue
 87 
 88         xmax = max(merge_pose[:, 0])
 89         xmin = min(merge_pose[:, 0])
 90         ymax = max(merge_pose[:, 1])
 91         ymin = min(merge_pose[:, 1])
 92 
 93         if (1.5 ** 2 * (xmax - xmin) * (ymax - ymin) < areaThres):
 94             continue
 95 
 96         final_result.append({
 97             'keypoints': merge_pose - 0.3,
 98             'kp_score': merge_score,
 99             'proposal_score': torch.mean(merge_score) + bbox_scores_pick[j] + 1.25 * max(merge_score)
100         })
101 
102     return final_result
103 
104 
105 
106 def PCK_match(pick_pred, all_preds, ref_dist):
107     dist = torch.sqrt(torch.sum(torch.pow(pick_pred[np.newaxis, :] - all_preds, 2), dim=2 ))   # 当前点和其他所有点的距离 [n, 17]
108     ref_dist = min(ref_dist, 7)
109     num_match_keypoints = torch.sum(dist / ref_dist <= 1, dim=1)   # 得到满足条件的点的数量   [n]
110     return num_match_keypoints    # 返回满足条件的点的数量
111 
112 
113 
114 def get_parametric_distance(i, all_preds, keypoint_scores, ref_dist):
115     pick_preds = all_preds[i]   # 当前预测关节点的坐标
116     pred_scores = keypoint_scores[i]    # 当前预测关节点的分值
117     dist = torch.sqrt(torch.sum(torch.pow(pick_preds[np.newaxis, :] - all_preds, 2), dim=2))  # 当前人关节点和所有人关节点的距离 [n, 17]
118     mask = (dist <= 1)    # 当前人关节点和所有人关节点的mask,此处指如果两套关节点距离太小(因是二维矩阵,不会出现某人部分关节点mask=1),则mask=1,一般来说,只是本人关节点mask=1 [n, 17]
119 
120     score_dists = torch.zeros(all_preds.shape[0], 17)  # Define a keypoints distance
121     keypoint_scores.squeeze_()
122     if keypoint_scores.dim() == 1:
123         keypoint_scores.unsqueeze_(0)  # 增加维度
124     if pred_scores.dim() == 1:
125         pred_scores.unsqueeze_(1)      # 增加维度
126     pred_scores = pred_scores.repeat(1, all_preds.shape[0]).transpose(0, 1)  # The predicted scores are repeated up to do broadcast。 [n, 1]
127 
128     # 由于broadcast,pred_scores!=keypoint_scores,但是pred_scores[mask] == keypoint_scores[mask]
129     score_dists[mask] = torch.tanh(pred_scores[mask] / delta1) * torch.tanh(keypoint_scores[mask] / delta1)   # delta1 = 1,当前点和近距离点的score的相似度,公式(8)
130 
131     point_dist = torch.exp((-1) * dist / delta2)    # delta2 = 2.65,当前点和近距离点的距离的相似度,公式(9)
132     final_dist = torch.sum(score_dists, dim=1) + mu * torch.sum(point_dist, dim=1)  # mu = 1.7,最终的距离  [n]
133 
134     return final_dist   # 返回最终的距离
135 
136 
137 # 如果人体检测器效果很好,无冗余检测,则此函数无效
138 def p_merge_fast(ref_pose, cluster_preds, cluster_scores, ref_dist):
139     '''
140     Score-weighted pose merging
141     INPUT:
142         ref_pose:       reference pose          -- [17, 2]       ref_pose  # 根据pick重新映射后的当前人各关节点的坐标
143         cluster_preds:  redundant poses         -- [n, 17, 2]    cluster_preds  # 筛选出来的当前人各关节点的坐标
144         cluster_scores: redundant poses score   -- [n, 17, 1]    cluster_scores  # 筛选出来的当前人各个关节点的score
145         ref_dist:       reference scale         -- Constant      ref_dist  # 根据pick重新映射后当前人NMS子框的阈值
146     OUTPUT:
147         final_pose:     merged pose             -- [17, 2]
148         final_score:    merged score            -- [17]
149     '''
150     # 无冗余姿态的情况下,ref_pose==cluster_preds==final_pose,dist=[[0....0]]  17个
151     dist = torch.sqrt(torch.sum(torch.pow(ref_pose[np.newaxis, :] - cluster_preds, 2), dim=2))
152 
153     kp_num = 17
154     ref_dist = min(ref_dist, 15)
155 
156     mask = (dist <= ref_dist)
157     final_pose = torch.zeros(kp_num, 2)
158     final_score = torch.zeros(kp_num)
159 
160     if cluster_preds.dim() == 2:
161         cluster_preds.unsqueeze_(0)    # [17,2] ==> [1, 17, 2]
162         cluster_scores.unsqueeze_(0)   # [17,1] ==> [1, 17, 1]
163     if mask.dim() == 1:
164         mask.unsqueeze_(0)             # [1,17] ==> [1, 17]  不变
165 
166     # Weighted Merge
167     masked_scores = cluster_scores.mul(mask.float().unsqueeze(-1))    # [1, 17, 1]   冗余score乘以mask,并进行归一化
168     normed_scores = masked_scores / torch.sum(masked_scores, dim=0)    # [1, 17, 1]  的全1矩阵
169 
170     # 冗余关节点位置乘归一化分数,得到冗余关节点位置。无冗余姿态的情况下,无冗余姿态的情况下,ref_pose==cluster_preds==final_pose
171     final_pose = torch.mul(cluster_preds, normed_scores.repeat(1, 1, 2)).sum(dim=0)
172     # 归一化之前的冗余关节点分数  final_score==cluster_scores==masked_scores
173     final_score = torch.mul(masked_scores, normed_scores).sum(dim=0)
174 
175     return final_pose, final_score   # 返回冗余关节点位置和这些关节点对应的score
View Code

 

posted on 2020-01-04 19:51  darkknightzh  阅读(23095)  评论(2编辑  收藏  举报

导航