所以，这篇文章就是拼接的

一. 解决问题和贡献

1.1. 解决问题

- ` bottom-up`方案（`OpenPose`）在地低分辨率上表现差，文章在[《Towards Accurate Multi-person Pose Estimation in the Wild》](https://arxiv.org/abs/1701.01779)文章的基础上，添加$p_b^{i,j}$和$p_\sigma^{i,j}$，将特征图的定位转换到原图上做处理
- `up-bottom`（`Mask RCNN`）方案在多人有遮挡的场景上表现差，已经错检

红圈中是错检测，黑框中的是漏检的

Mask RCNN在拥挤的场景漏检

1.2. 贡献

- `bottom-up`, `box-free`, `end-to-end cnn architecture`

• 提出Part Intensity Field (PIF) 用来定位人体关节点位置
• 提出Part Association Field (PAF)用来确定关节点之间的连接

1.3. 整体结构

二. 关节点定义

过早时期，谷歌提出直接对关键点做回归，通过多次迭代校准关键点的定位（x,y）,这样定位还是不是很准确，后来的方法都是基于关键点热力图，将一个关键点Ground True坐标周围半径R内区域都设为1，之外的区域设为0，转化为分类问题。

三. PIF（Part Intensity Fields）

Pif label是confidence map和regression map的结合

• Pif输出的是[b, 17, 5,h, w]纬度
  • b：batch
  • 17：代表预测的关键点个数
  • h,w:特征图的长宽
  • 5：表示{$p_c^{i,j}$，$p_x^{i,j}$，$p_y^{i,j}$，$p_b^{i,j}$，$p_\sigma^{i,j}$}
    • （i，j）是输出特征图上的坐标，$p_c^{i,j}$表示输出的
    • （x,y）表示（i，j）指向周围关键点真值的方向向量
    • $p_c^{i,j}:$是经过Pif的特征图上（i，j）位置的confidence预测值
    • $p_x^{i,j}$、$p_y^{i,j}$:是经过Pif的特征图上（i，j）位置的x,y方向上offset（偏置）向量
    • $p_b^{i,j}$:是laplace loss上的系数,控制关键点热力图的大小
    • $p_\sigma^{i,j}$:不是高斯的$\sigma$，是用来将特征图还原到原图的比例

$p_c^{i,j}$在PIF中代表点（i,j）是否是关键点的置信度，用来判断关键点，在PAF里面用来衡量两点的关联性大小

有个这个Pif label,就可以根据$p_c^{i,j}$，$p_x^{i,j}$，$p_y^{i,j}$得到位置精度更高的confidence map,公式如下：

公式展开就是$\displaystyle\sum_{i,j}e^{-\frac{(x-p_x^{i,j})^2+(y-p_y^{i,j})^2}{2*(p_\sigma^{i,j})^2}}$

同样的，本篇论文的公式也是表示越近的点权重越大，只不过距离是offset与（x,y）的距离。所以这就是为什么相近的offset（图像种的箭头）方向很接近，远的相差远，呈现渐变的感觉：

• 图(a)是Pif label里的$p_c^{i,j}$
• 图(b)是Pif预测的结果offset：$p_x^{i,j}$，$p_y^{i,j}$ ，放大后可以看出方向是渐变的，相近的向量方向相近，不仔细分析注意不到这点
• 图©是三者融合之后的结果. 可以看出来点的位置更精确, 中心处的响应值更强, 边缘处更弱

用来控制同一张图片上不同大小的目标物的关键点热力图（Heatmap）大小（大的物体，关键点热力图区域就应该大），文章中半径为$3\sigma$，loss函数如下：

• $｜x - \mu|/b$作为指数函数的幂次，就是$e^{-\frac{(x-\mu)}{2*(b\sigma)^2}}$，所以$p_b^{i,j}$相当于是对$\sigma$值加权

$p_\sigma^{i,j}$:不是高斯的$\sigma$，是用来将特征图还原到原图进行处理的比例系数，论文里没有详细说明，但是代码（openpifpaf-main/src/openpifpaf/csrc/src/cif_hr.cpp）中可以看出：

void CifHr::accumulate(const torch::Tensor& cif_field, int64_t stride, double min_scale, double factor) {
    if (ablation_skip) return;

    auto cif_field_a = cif_field.accessor<float, 4>();
    float min_scale_f = min_scale / stride;

    float v, x, y, scale, sigma;
    for (int64_t f=0; f < cif_field_a.size(0); f++) {
        for (int64_t j=0; j < cif_field_a.size(2); j++) {
            for (int64_t i=0; i < cif_field_a.size(3); i++) {
                v = cif_field_a[f][1][j][i];
                if (v < threshold) continue;

                scale = cif_field_a[f][4][j][i]; // 每个点（j,i）的scale不一样，相当于权重
                if (scale < min_scale_f) continue;

                x = cif_field_a[f][2][j][i] * stride;
                y = cif_field_a[f][3][j][i] * stride;
                sigma = fmaxf(1.0, 0.5 * scale * stride);   // 通过stride还原到原图尺寸,scale可以学习的参数

                // Occupancy covers 2sigma.
                // Restrict this accumulation to 1sigma so that seeds for the same joint
                // are properly suppressed.
                add_gauss(f, v / neighbors * factor, x, y, sigma, 1.0);
            }
        }
    }
}


void CifHr::add_gauss(int64_t f, float v, float x, float y, float sigma, float truncate) {
    auto accumulated_a = accumulated.accessor<float, 3>();

    auto minx = std::clamp(int64_t(x - truncate * sigma), int64_t(0), accumulated_a.size(2) - 1); //x < truncate * sigma,等于0
    auto miny = std::clamp(int64_t(y - truncate * sigma), int64_t(0), accumulated_a.size(1) - 1);
    // -siga < x < sigma -> minx=0 -> x + sigma + 1 > 0 + 1 -> maxx = x + sigma + 1  (0, x + sigma + 1)
    //  x < -sigma -> minx=0 -> x + sigma + 1 < 0 + 1 -> maxx = min + 1 = 1 (0, 1)
    // x > sigma -> minx= x - sigma  -> x + sigma + 1 > x - sigma + 1 -> maxx = x + sigma + 1  (x - sigma, x + sigma + 1 || accumulated_a.size(1) - 1)
    auto maxx = std::clamp(int64_t(x + truncate * sigma + 1), minx + 1, accumulated_a.size(2));  
    auto maxy = std::clamp(int64_t(y + truncate * sigma + 1), miny + 1, accumulated_a.size(1));

    float sigma2 = sigma * sigma;
    float truncate2_sigma2 = truncate * truncate * sigma2;
    float deltax2, deltay2;
    float vv;
    for (int64_t xx=minx; xx < maxx; xx++) {
        // x < -sigma -> xx = x = 0  -> deltax2 = 0
        deltax2 = (xx - x) * (xx - x);     
                                            
        for (int64_t yy=miny; yy < maxy; yy++) {
            deltay2 = (yy - y) * (yy - y);

            if (deltax2 + deltay2 > truncate2_sigma2) continue;

            if (deltax2 < 0.25 && deltay2 < 0.25) {
                // this is the closest pixel
                vv = v;
            } else {
                vv = v * approx_exp(-0.5 * (deltax2 + deltay2) / sigma2);
            }

            auto& entry = accumulated_a[f][yy][xx];
            entry = fmaxf(entry, revision) + vv;
            entry = fminf(entry, revision + 1.0);
        }
    }
}

• cif_field_a[f][1][j][i] ：$p_c^{i,j}$
• cif_field_a[f][2][j][i] 、cif_field_a[f][3][j][i]：$p_x^{i,j}$，$p_y^{i,j}$
• cif_field_a[f][4][j][i]$:p_\sigma^{i,j}$

• Paf label的输出是[b, 17, 7,h, w]纬度
  • 7:表示{$a_c^{i,j}$，$a_{x1}^{i,j}$，$a_{y1}^{i,j}$，$p_{b1}^{i,j}$，$a_{x2}^{i,j}$，$a_{y2}^{i,j}$，$p_{b2}^{i,j}$}
    • $a_c^{i,j}:代表（i，j）的confidence
    • {$a_{y1}^{i,j}$，$p_{b1}^{i,j}$}和{$a_{x2}^{i,j}$，$a_{y2}^{i,j}$}：分别代表（i，j）该点到真正的两个groundtruth 关键点的（x_offset, y_offset）
    • $p_{b1}^{i,j}$、$p_{b2}^{i,j}$：是相对应的两个用来计算loss的系数

不同的是，不是直接连线预测的关键点作为连接线，而是通过：对特征图中所有（i，j）点，首先找到离它最近的预测的关键点，如图（b）的短箭头：

然后通过先验知识知道第一个关键点和其他channel的关键点有连接关系，获取第二个关键点，通过如下关系计算得到通过（i，j）连接的两个预测的关键点之间的关联度PAF：

• x：（i，j）到关键点1的连线
• $a_c$:paf输出的confidence $a_c^{i,j}$
• a1:PAF输出的$a_{x1}^{i,j}$，$a_{y1}^{i,j}$
• $b_1$:代表$p_{b1}^{i,j}$
• $f_2(a_{x2},a_{y2})$:利用PIF的公式更新得到的关键点2的新confidence
  -

得到PIF和PAF后，为了确保根据paf找到的两个点确实是应该连到一起的, 程序会执行reverse操作, 即如果通过point a找到了point b, 那么就会从point b找到point c, 如果point a和point c之间的距离小于设定好的阈值, 那么就说明这两个点应该被连在一起. 计算出来哪些点需要连在一起之后, 然后通过NMS方式将多连接的线去除掉，直到完整的pose被找到。

六.其他

文章对smoth L1和Laplace Loss做了对比实验，Laplace加上尺度因子b效果更好

参考文章：
【1】CSDN：PifPaf: Composite Fields for Human Pose Estimation