AlphaPose Pytorch 代码详解(一):predict

2023-10-11 21:21

本文主要是介绍AlphaPose Pytorch 代码详解(一):predict,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

前言

代码地址:AlphaPose-Pytorch版

本文以图像 1.jpg(854x480)为例对整个预测过程的各个细节进行解读并记录

python demo.py --indir examples/demo --outdir examples/res --save_img

在这里插入图片描述

1. YOLO

1.1 图像预处理

  • cv2读取BGR图像 img [480,854,3] (h,w,c)
  • 按参数 inp_dim=608,将图像保持长宽比缩放至 [341,608,3],并以数值为128做padding至 [608,608,3]
  • BGR转RGB、维度处理、转tensor、数据类型转float、数值除以255做归一化,[1,3,608,608] (b,c,h,w)

输出:

img:		[1,3,608,608]	(yolo输入图像)
orig_img:	[480,854,3]		(原始BGR图像)
im_name:	'examples/demo/1.jpg'
im_dim_list:[854,480,854,480](原图尺寸, 用于把yolo的输出坐标转换到原图坐标系)

1.2 yolo 模型推理

输入:img[1,3,608,608]
输出:pred[1,22743,85]

1 = b a t c h s i z e \mathrm{1=batchsize} 1=batchsize

22743 = [ ( 608 / 32 ) 2 + ( 608 / 16 ) 2 + ( 608 / 8 ) 2 ] × 3 22743=[(608/32)^2+(608/16)^2+(608/8)^2]\times3 22743=[(608/32)2+(608/16)2+(608/8)2]×3

85 = [ x , y , w , h , c o n f , 80 c l a s s e s ] \mathrm{85=[x,y,w,h,conf,80classes]} 85=[x,y,w,h,conf,80classes]

1.3 输出后处理

(1)第一阶段

  • 坐标 xywhxyxy
  • batchsize 循环,[22743,85][22743,7] 7 = [ x , y , x , y , c o n f , c l a s s s c o r e , c l a s s ] \mathrm{7=[x,y,x,y,conf,class\ score,class]} 7=[x,y,x,y,conf,class score,class],即80类得分转换为得分最高的类别索引及其得分
  • 去除 c o n f ≤ 0.05 \mathrm{conf\le0.05} conf0.05 的项 [37,7]
  • 保留类别为人的项,并且按 conf 从高到低排序,得到结果 img_pred[19,7]
  • nms去除重复目标 [19,7]->[6,7]
  • 添加 batch_idx 这里batchsize为1所以都是0,[6,7]->[6,8] 8 = [ b a t c h i d x , x , y , x , y , c o n f , c l a s s s c o r e , c l a s s ] \mathrm{8=[batch\ idx, x,y,x,y,conf,class\ score,class]} 8=[batch idx,x,y,x,y,conf,class score,class]
  • 坐标数值转换,从 [608,608] 转到原图坐标 [854,480],并把坐标 clamp[0,w] [0,h] 之间

输出:

orig_img:[480,854,3]	(原始BGR图像)
im_name:'examples/demo/1.jpg'
boxes:	[6,4]	(x,y,x,y)(原图坐标系)
scores:	[6,1]	(conf)

NMS 细节

  • nms_conf=0.6
  • img_pred 中的第一项放到结果中
  • 剩余所有项与结果中的最后一项计算iou,保留 iou<nms_conf 的项作为新的 img_pred
  • 循环直到 img_pred 中没有目标
  • 当经过nms后的目标数量大于100个,会把 nms_conf-0.05,从最初的 img_pred 开始重新进行nms

(2)第二阶段

  • 原始图像 orig_img [480,854,3] BGR转RGB、维度处理、转tensor、数据类型转float、数值除以255做归一化,得到 inp [3,480,854]
  • 对三通道做处理 inp[0].add_(-0.406), inp[1].add_(-0.457), inp[2].add_(-0.480)
  • 扩大 boxes 中目标框的范围,并把左上角坐标存入 pt1,右下角坐标存入 pt2
  • 根据 boxes 把每个目标从图中抠出来,通过保比例缩放+zero padding,统一成 [3,320,256] 大小的图像存入 inps

输出:

inps:	[6,3,320,256]	(检测目标的子图像,作为Alphapose的输入)
orig_img:[480,854,3]	(原始BGR图像)
im_name:'examples/demo/1.jpg'
boxes:	[6,4]	(x1,y1,x2,y2)(yolo原始输出,原图坐标系)
scores:	[6,1]	(yolo输出conf)
pt1:	[6,2]	(x1,y1)(yolo输出扩大后坐标,原图坐标系)
pt2:	[6,2]	(x2,y2)(yolo输出扩大后坐标,原图坐标系)

2. POSE

2.1 pose 模型推理

输入:inps[6,3,320,256]
输出:hm[6,17,80,64],即6个目标,每个目标17个关键点对应的热力图

2.2 输出后处理

(1)第一阶段:热力图转坐标

  • 获取 hm[6,17,80,64] 中每个关键点的热力图中最大值的索引 preds[6,17,2]
  • 由于 opt.matching=False,此处使用简单的后处理,源码如下
    preds 中某个索引 [x,y] 为例,取出其热力图中相邻的上下左右四个位置的值,并且分别在 x x x y y y 轴上往较高的方向偏移 0.25 0.25 0.25
    x x x 轴为例: p l e f t = h m [ y ] [ x − 1 ] p_\mathrm{left}=\mathrm{hm}[y][x-1] pleft=hm[y][x1] p r i g h t = h m [ y ] [ x + 1 ] p_\mathrm{right}=\mathrm{hm}[y][x+1] pright=hm[y][x+1],若 p l e f t > p r i g h t p_\mathrm{left}>p_\mathrm{right} pleft>pright x + 0.25 x+0.25 x+0.25,若 p l e f t = p r i g h t p_\mathrm{left}=p_\mathrm{right} pleft=pright x x x 保持不变
    最后会在所有的坐标值上 + 0.2 +0.2 +0.2
for i in range(preds.size(0)):for j in range(preds.size(1)):hm = hms[i][j]pX, pY = int(round(float(preds[i][j][0]))), int(round(float(preds[i][j][1])))if 0 < pX < opt.outputResW - 1 and 0 < pY < opt.outputResH - 1:diff = torch.Tensor((hm[pY][pX + 1] - hm[pY][pX - 1], hm[pY + 1][pX] - hm[pY - 1][pX]))preds[i][j] += diff.sign() * 0.25
preds += 0.2
  • 目前得到的坐标 preds[6,17,2] 是相对于输出分辨率 [80,64] 坐标系下的,转换到原图分辨率 [480,854] 坐标系下,得到 preds_tf[6,17,2]

输出:

preds:		[6,17,2]	(经过第二步偏移处理后的坐标,相对于热力图坐标系)
preds_tf:	[6,17,2]	(最终坐标,相对于原图坐标系)
maxval:		[6,17,1]	(热力图最大值)

(2)第二阶段:pose nms

输入:

ori_bboxs:		[6,4]		(yolo原始输出,原图坐标系)
ori_bbox_scores:[6,1]		(yolo输出conf)
ori_pose_preds:	[6,17,2]	(对应preds_tf,关键点坐标,原图坐标系)
ori_pose_scores:[6,17,1]	(对应maxval,热力图最大值)
  • 根据 bboxs 计算每个目标框的 w,h,选择每个目标框中的最大值 max(w,h) 并乘上 alpha=0.1 构成 ref_dists[6]
  • 根据 pose_scores 计算每个目标17个关键点得分的均值,得到 human_scores[6]
  • 开始循环,直到 human_scores 无目标
    1. 选择 human_scores 最高的目标,坐标和得分分别记为 pick_preds[17,2], pick_scores[17,1]
      全部的坐标和得分记为 all_preds[6,17,2], all_scores[6,17,1](此处命名方式与源码略有不同,以便于区分)
    2. 计算距离:final_dist[6] 目标的同类别关键点的距离,距离越近数值越大
      score_dists 计算位置距离非常近的同类别关键点的得分距离
      point_dist = e − d / 2.65 =e^{-d/2.65} =ed/2.65,因为 d ≥ 0 d\ge0 d0,所以 0 < p o i n t _ d i s t ≤ 1 0<\mathrm{point\_dist}\le1 0<point_dist1 d d d 越小, p o i n t _ d i s t \mathrm{point\_dist} point_dist 越大,目标本身则最大全为1
    3. 计算关键点匹配数量:num_match_keypoints[6] 目标之间同类别关键点中距离较近的数量
    4. 去除多余目标:目标之间的距离超过阈值 or 目标之间距离相近的关键点数量超过阈值 → 判定为多余的目标。
      由于选出的目标本身也在其中,因此目标自身必然在去除的队伍中,如果除了自身还有目标被去除,那么会把额外的目标与自身的索引放在一起得到 merge_ids,这些目标相互之间距离很近,用于后续融合目标。
对应第2def get_parametric_distance(i, all_preds, all_scores):pick_preds, pick_scores = all_preds[i], all_scores[i]'计算坐标位置的欧氏距离 dist[6,17](同类别关键点之间的距离)'dist = torch.sqrt(torch.sum(torch.pow(pick_preds[np.newaxis, :] - all_preds, 2), dim=2))'计算dist<=1的点之间的得分距离 score_dists[6,17]'mask = (dist <= 1)score_dists = torch.zeros(all_preds.shape[0], 17)score_dists[mask] = torch.tanh(pick_scores[mask]/delta1) * torch.tanh(all_scores[mask]/delta1)  'delta1=1''final_dist[6]'point_dist = torch.exp((-1) * dist / delta2)  'delta2=2.65'final_dist = torch.sum(score_dists, dim=1) + mu * torch.sum(point_dist, dim=1)  'mu=1.7'return final_dist
对应第3def PCK_match(pick_pred, all_preds, ref_dist):dist = torch.sqrt(torch.sum(torch.pow(pick_preds[np.newaxis, :] - all_preds, 2), dim=2))ref_dist = min(ref_dist, 7)num_match_keypoints = torch.sum(dist / ref_dist <= 1, dim=1)return num_match_keypoints
对应第4'gamma=22.48, matchThreds=5'
delete_ids = torch.from_numpy(np.arange(human_scores.shape[0]))[(final_dist > gamma) | (num_match_keypoints >= matchThreds)]

输出:

merge_ids:			[6,x]
preds_pick:			[6,17,2]
scores_pick:		[6,17,1]
bbox_scores_pick:	[6,1]
'''
这里的输出是从各个输入 orig_xxxx, 例如 ori_bbox_scores 中挑选出来的(nms后的目标)
只是在这个例子中, nms判断并没有重复的目标, 因此和原始输入保持一致merge_ids 是一个列表, x代表每一项的长度, 本例中x都=1
如果nms判断存在重复目标, 那么会把这些目标在原始输入中的索引记录在 merge_ids 中, 此时x>1
在第三阶段中会把这些目标进行融合
'''

(3)第三阶段:融合与过滤

  • 去除17个关键点中最高得分 m a x _ s c o r e < s c o r e T h r e d s = 0.3 \mathrm{max\_score < scoreThreds = 0.3} max_score<scoreThreds=0.3 的目标
  • 融合目标,具体看下面代码,简单来说就是把距离比较近的关键点根据得分的高低作为权重,把坐标位置和得分进行加权求和作为融合后的目标
  • 去除融合后,17个关键点中最高得分 m a x _ s c o r e < s c o r e T h r e d s = 0.3 \mathrm{max\_score < scoreThreds = 0.3} max_score<scoreThreds=0.3 的目标
  • 根据能包含目标所有关键点的矩形框面积来过滤目标,1.5**2 * (xmax-xmin) * (ymax-ymin) < areaThres=0,具体为外接矩形长宽都乘1.5后计算面积,由于这里阈值为0,过滤基本无效
  • 最后会把所有关键点坐标数值 − 0.3 -0.3 0.3,并且根据关键点得分和目标框得分生成 proposal_score,具体见下面代码

此阶段过滤掉了一个目标,最终得到5个目标。

merge_pose, merge_score = p_merge_fast(preds_pick[j], ori_pose_preds[merge_id], ori_pose_scores[merge_id], ref_dists[pick[j]])def p_merge_fast(ref_pose, cluster_preds, cluster_scores, ref_dist):'''Score-weighted pose mergingINPUT:															本博客中文别称ref_pose:       reference pose          -- [17, 2]			挑选目标关键点cluster_preds:  redundant poses         -- [n, 17, 2]		多余目标关键点(挑选目标本身包含在多余目标中)cluster_scores: redundant poses score   -- [n, 17, 1]ref_dist:       reference scale         -- ConstantOUTPUT:final_pose:     merged pose             -- [17, 2]final_score:    merged score            -- [17]''''计算与多余目标关键点距离 dist[n,17]'dist = torch.sqrt(torch.sum(torch.pow(ref_pose[np.newaxis, :] - cluster_preds, 2),dim=2))kp_num = 17'回顾一下, ref_dist是挑选目标的目标框的 max(h,w)*0.1'ref_dist = min(ref_dist, 15)mask = (dist <= ref_dist)final_pose = torch.zeros(kp_num, 2)final_score = torch.zeros(kp_num)if cluster_preds.dim() == 2:cluster_preds.unsqueeze_(0)cluster_scores.unsqueeze_(0)if mask.dim() == 1:mask.unsqueeze_(0)# Weighted Merge'根据pose的得分来决定每个目标所占的比例, 具体为该得分占总得分的比例'masked_scores = cluster_scores.mul(mask.float().unsqueeze(-1))normed_scores = masked_scores / torch.sum(masked_scores, dim=0)'根据计算得到的比例做加权和, 得到最终的pose及其得分'final_pose = torch.mul(cluster_preds, normed_scores.repeat(1, 1, 2)).sum(dim=0)final_score = torch.mul(masked_scores, normed_scores).sum(dim=0)return final_pose, final_score
final_result.append({'keypoints': merge_pose - 0.3,'kp_score': merge_score,'proposal_score': torch.mean(merge_score) + bbox_scores_pick[j] + 1.25 * max(merge_score)
})keypoints 	[17,2]
kp_score	[17,1]
proposal_score [1]

3. Alphapose 网络结构

3.1 总流程

在这里插入图片描述

  1. SEResnet 作为 backbone 提取特征
  2. nn.PixelShuffle(2) 提升分辨率
  3. 经过两个 DUC 模块进一步提升分辨率
  4. 通过一个卷积得到输出
  5. 此时获得的输出如图所示 out[6,33,80,64] 有33个关键点,通过 out.narrow(1, 0, 17) 获取前17个关键点作为最终的输出 hm[6,17,80,64]

3.2 DUC 模块

  1. 2个DUC模块结构相同,都是先用卷积升维,再用一个 nn.PixelShuffle(2) 提升分辨率
  2. 图中以 DUC1 模块的参数为例进行绘制

3.3 PixelShuffle 操作

import torch
import torch.nn as nninput_tensor = torch.arange(1, 17).view(1, 16, 1, 1).float()
pixel_shuffle = nn.PixelShuffle(2)
output_tensor = pixel_shuffle(input_tensor)print(output_tensor)>>>
tensor([[[[ 1.,  2.],[ 3.,  4.]],[[ 5.,  6.],[ 7.,  8.]],[[ 9., 10.],[11., 12.]],[[13., 14.],[15., 16.]]]])

3.4 SEResnet 框架

在这里插入图片描述
  图中省略了 batchsize 维度,主要分为4层,分别相对原图下采样4、8、16、32倍

3.5 SEResnet 细节

在这里插入图片描述
  仿照代码,把这4个由 Bottleneck_SEBottleneck 构成的层级记作 l a y e r 1 ∼ 4 \mathrm{layer1\sim4} layer14,图中为 l a y e r 1 \mathrm{layer1} layer1 的数据。

  每个层中两种 Bottleneck 都会通过三个卷积层,先把特征维度控制为输出特征维度的 1/4,第二个保持不变,第三个达到输出特征维度,再以第二层为例:
l a y e r 2 : \mathrm{layer2:} layer2:
   B o t t l e n e c k _ S E : 256 → 128 → 128 → 512 \mathrm{Bottleneck\_ SE:256\to128\to128\to512} Bottleneck_SE:256128128512
   B o t t l e n e c k : 512 → 128 → 128 → 512 \mathrm{Bottleneck:512\to128\to128\to512} Bottleneck:512128128512

这篇关于AlphaPose Pytorch 代码详解(一):predict的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/190912

相关文章

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明(认真看哦) AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证,则会调用 #attemptAuthentica

OpenHarmony鸿蒙开发( Beta5.0)无感配网详解

1、简介 无感配网是指在设备联网过程中无需输入热点相关账号信息,即可快速实现设备配网,是一种兼顾高效性、可靠性和安全性的配网方式。 2、配网原理 2.1 通信原理 手机和智能设备之间的信息传递,利用特有的NAN协议实现。利用手机和智能设备之间的WiFi 感知订阅、发布能力,实现了数字管家应用和设备之间的发现。在完成设备间的认证和响应后,即可发送相关配网数据。同时还支持与常规Sof

活用c4d官方开发文档查询代码

当你问AI助手比如豆包,如何用python禁止掉xpresso标签时候,它会提示到 这时候要用到两个东西。https://developers.maxon.net/论坛搜索和开发文档 比如这里我就在官方找到正确的id描述 然后我就把参数标签换过来

poj 1258 Agri-Net(最小生成树模板代码)

感觉用这题来当模板更适合。 题意就是给你邻接矩阵求最小生成树啦。~ prim代码:效率很高。172k...0ms。 #include<stdio.h>#include<algorithm>using namespace std;const int MaxN = 101;const int INF = 0x3f3f3f3f;int g[MaxN][MaxN];int n

6.1.数据结构-c/c++堆详解下篇(堆排序,TopK问题)

上篇:6.1.数据结构-c/c++模拟实现堆上篇(向下,上调整算法,建堆,增删数据)-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小): 2.2 C语言代码(手写堆) 2.3 C++代码(使用优先级队列 priority_queue)

计算机毕业设计 大学志愿填报系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试

🍊作者:计算机编程-吉哥 🍊简介:专业从事JavaWeb程序开发,微信小程序开发,定制化项目、 源码、代码讲解、文档撰写、ppt制作。做自己喜欢的事,生活就是快乐的。 🍊心愿:点赞 👍 收藏 ⭐评论 📝 🍅 文末获取源码联系 👇🏻 精彩专栏推荐订阅 👇🏻 不然下次找不到哟~Java毕业设计项目~热门选题推荐《1000套》 目录 1.技术选型 2.开发工具 3.功能

K8S(Kubernetes)开源的容器编排平台安装步骤详解

K8S(Kubernetes)是一个开源的容器编排平台,用于自动化部署、扩展和管理容器化应用程序。以下是K8S容器编排平台的安装步骤、使用方式及特点的概述: 安装步骤: 安装Docker:K8S需要基于Docker来运行容器化应用程序。首先要在所有节点上安装Docker引擎。 安装Kubernetes Master:在集群中选择一台主机作为Master节点,安装K8S的控制平面组件,如AP

代码随想录冲冲冲 Day39 动态规划Part7

198. 打家劫舍 dp数组的意义是在第i位的时候偷的最大钱数是多少 如果nums的size为0 总价值当然就是0 如果nums的size为1 总价值是nums[0] 遍历顺序就是从小到大遍历 之后是递推公式 对于dp[i]的最大价值来说有两种可能 1.偷第i个 那么最大价值就是dp[i-2]+nums[i] 2.不偷第i个 那么价值就是dp[i-1] 之后取这两个的最大值就是d

pip-tools:打造可重复、可控的 Python 开发环境,解决依赖关系,让代码更稳定

在 Python 开发中,管理依赖关系是一项繁琐且容易出错的任务。手动更新依赖版本、处理冲突、确保一致性等等,都可能让开发者感到头疼。而 pip-tools 为开发者提供了一套稳定可靠的解决方案。 什么是 pip-tools? pip-tools 是一组命令行工具,旨在简化 Python 依赖关系的管理,确保项目环境的稳定性和可重复性。它主要包含两个核心工具:pip-compile 和 pip

D4代码AC集

贪心问题解决的步骤: (局部贪心能导致全局贪心)    1.确定贪心策略    2.验证贪心策略是否正确 排队接水 #include<bits/stdc++.h>using namespace std;int main(){int w,n,a[32000];cin>>w>>n;for(int i=1;i<=n;i++){cin>>a[i];}sort(a+1,a+n+1);int i=1