yolov8姿态检测，骨架提取实操步骤

最新推荐文章于 2024-04-21 18:02:12 发布

睡不醒的Michael

最新推荐文章于 2024-04-21 18:02:12 发布

阅读量1.8k

点赞数 28

文章标签： YOLO

本文链接：https://blog.csdn.net/2302_77816072/article/details/135411726

版权

之前写过一篇基于yolov8的实例分割，但是yolov8的功能不止如此，它集成了目标识别，实例分割以及关键点检测。目标识别已经有很多完整的教程了，在这里就不过多赘述了，但是在完成骨架提取的相应项目时，我发现找到的资源或者相应的案例比较少，于是想在这一篇中汇总一下我所找到的相应资源以及本人在实际操作中所遇到的问题。

1.使用相应的软件进行标注

在这里我推荐使用两种不同的标注工具，首先可以使用labelme，进行标注，关于labelme的安装等注意事项具体可以参见这篇博客：https://blog.csdn.net/qq_41931453/article/details/125757449

在安装好软件之后，我们就可以进行相应的标注了

在这里，我以小狗的图片为例，我们先在左上角的edit里面找到create rectangle,为我们需要标注关键点或者姿态检测的物体打一个框，（打完之后记得给出相应的标签）就像我们在目标识别中所做的那样，接下来，我们还是选择edit,选择其中的create Point,在我们标出的框中打上关键点，需要注意的是，这个关键点的个数是由你来决定的，你可以自由选择打点的个数，但是需要注意的是，每张图像的关键点都需要保持一致，意思就是如果你第一张标的第一个点是头，那么你后面每张图片的第一个点都应该是头，我们就按照这样的顺序依次对我们的数据集进行标注，在标注完之后，我们可以得到相应的json文件。

第二种我们还是可以使用之前推荐过的roboflow进行标注，我们按照步骤新建项目，然后选择其中的Keypoint Detection，按照官方给出的步骤一步一步进行标注即可。

2.json文件转成yolo需要的txt格式

这里我看过很多别人的文章，大体来说是分为两种方法，第一种就是简单粗暴的直接将json文件格式转化成txt格式，但是我试过相应的代码，效果并不好，而且转化完成后的结果并不满足yolo所需要的格式。还有一种就是先将json转化成coco格式，之后再借由coco格式转化成txt格式，这里参考https://blog.csdn.net/WYKB_Mr_Q/article/details/132035597

import os
import sys
import glob
import json
import argparse
import numpy as np
from tqdm import tqdm
from labelme import utils


class Labelme2coco_keypoints():
    def __init__(self, args):
        """
        Lableme 关键点数据集转 COCO 数据集的构造函数:

        Args
            args：命令行输入的参数
                - class_name 根类名字

        """

        self.classname_to_id = {args.class_name: 1}
        self.images = []
        self.annotations = []
        self.categories = []
        self.ann_id = 0
        self.img_id = 0

    def save_coco_json(self, instance, save_path):
        json.dump(instance, open(save_path, 'w', encoding='utf-8'), ensure_ascii=False, indent=1)

    def read_jsonfile(self, path):
        with open(path, "r", encoding='utf-8') as f:
            return json.load(f)

    def _get_box(self, points):
        min_x = min_y = np.inf
        max_x = max_y = 0
        for x, y in points:
            min_x = min(min_x, x)
            min_y = min(min_y, y)
            max_x = max(max_x, x)
            max_y = max(max_y, y)
        return [min_x, min_y, max_x - min_x, max_y - min_y]

    def _get_keypoints(self, points, keypoints, num_keypoints):
        """
        解析 labelme 的原始数据， 生成 coco 标注的 关键点对象

        例如：
            "keypoints": [
                67.06149888292556,  # x 的值
                122.5043507571318,  # y 的值
                1,                  # 相当于 Z 值，如果是2D关键点 0：不可见 1：表示可见。
                82.42582269256718,
                109.95672933232304,
                1,
                ...,
            ],

        """

        if points[0] == 0 and points[1] == 0:
            visable = 0
        else:
            visable = 1
            num_keypoints += 1
        keypoints.extend([points[0], points[1], visable])
        return keypoints, num_keypoints

    def _image(self, obj, path):
        """
        解析 labelme 的 obj 对象，生成 coco 的 image 对象

        生成包括：id，file_name，height，width 4个属性

        示例：
             {
                "file_name": "training/rgb/00031426.jpg",
                "height": 224,
                "width": 224,
                "id": 31426
            }

        """

        image = {}

        img_x = utils.img_b64_to_arr(obj['imageData'])  # 获得原始 labelme 标签的 imageData 属性，并通过 labelme 的工具方法转成 array
        image['height'], image['width'] = img_x.shape[:-1]  # 获得图片的宽高

        # self.img_id = int(os.path.basename(path).split(".json")[0])
        self.img_id = self.img_id + 1
        image['id'] = self.img_id

        image['file_name'] = os.path.basename(path).replace(".json", ".jpg")

        return image

    def _annotation(self, bboxes_list, keypoints_list, json_path):
        """
        生成coco标注

        Args：
            bboxes_list： 矩形标注框
            keypoints_list： 关键点
            json_path：json文件路径

        """

        if len(keypoints_list) != args.join_num * len(bboxes_list):
            print('you loss {} keypoint(s) with file {}'.format(args.join_num * len(bboxes_list) - len(keypoints_list), json_path))
            print('Please check ！！！')
            sys.exit()
        i = 0
        for object in bboxes_list:
            annotation = {}
            keypoints = []
            num_keypoints = 0

            label = object['label']
            bbox = object['points']
            annotation['id'] = self.ann_id
            annotation['image_id'] = self.img_id
            annotation['category_id'] = int(self.classname_to_id[label])
            annotation['iscrowd'] = 0
            annotation['area'] = 1.0
            annotation['segmentation'] = [np.asarray(bbox).flatten().tolist()]
            annotation['bbox'] = self._get_box(bbox)

            for keypoint in keypoints_list[i * args.join_num: (i + 1) * args.join_num]:
                point = keypoint['points']
                annotation['keypoints'], num_keypoints = self._get_keypoints(point[0], keypoints, num_keypoints)
            annotation['num_keypoints'] = num_keypoints

            i += 1
            self.ann_id += 1
            self.annotations.append(annotation)

    def _init_categories(self):
        """
        初始化 COCO 的 标注类别

        例如：
        "categories": [
            {
                "supercategory": "hand",
                "id": 1,
                "name": "hand",
                "keypoints": [
                    "wrist",
                    "thumb1",
                    "thumb2",
                    ...,
                ],
                "skeleton": [
                ]
            }
        ]
        """

        for name, id in self.classname_to_id.items():
            category = {}

            category['supercategory'] = name
            category['id'] = id
            category['name'] = name
            # 17 个关键点数据
            category['keypoint'] = [str(i + 1) for i in range(args.join_num)]

            self.categories.append(category)

    def to_coco(self, json_path_list):
        """
        Labelme 原始标签转换成 coco 数据集格式，生成的包括标签和图像

        Args：
            json_path_list：原始数据集的目录

        """

        self._init_categories()

        for json_path in tqdm(json_path_list):
            obj = self.read_jsonfile(json_path)  # 解析一个标注文件
            self.images.append(self._image(obj, json_path))  # 解析图片
            shapes = obj['shapes']  # 读取 labelme shape 标注

            bboxes_list, keypoints_list = [], []
            for shape in shapes:
                if shape['shape_type'] == 'rectangle':  # bboxs
                    bboxes_list.append(shape)           # keypoints
                elif shape['shape_type'] == 'point':
                    keypoints_list.append(shape)

            self._annotation(bboxes_list, keypoints_list, json_path)

        keypoints = {}
        keypoints['info'] = {'description': 'Lableme Dataset', 'version': 1.0, 'year': 2021}
        keypoints['license'] = ['BUAA']
        keypoints['images'] = self.images
        keypoints['annotations'] = self.annotations
        keypoints['categories'] = self.categories
        return keypoints


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("--class_name", default="pangolin", help="class name", type=str)
    parser.add_argument("--input",  default="./json", help="json file path (labelme)", type=str)
    parser.add_argument("--output", default="./coco", help="output file path (coco format)", type=str)
    parser.add_argument("--join_num",  default=7, help="number of join", type=int)
    # parser.add_argument("--ratio", help="train and test split ratio", type=float, default=0.5)
    args = parser.parse_args()

    labelme_path = args.input
    saved_coco_path = args.output

    json_list_path = glob.glob(labelme_path + "/*.json")

    print('{} for json files'.format(len(json_list_path)))
    print('Start transform please wait ...')

    l2c_json = Labelme2coco_keypoints(args)  # 构造数据集生成类

    # 生成coco类型数据
    keypoints = l2c_json.to_coco(json_list_path)
    l2c_json.save_coco_json(keypoints, os.path.join(saved_coco_path, "keypoints.json"))

这是第一步将json转化成coco格式的代码，这里有几点需要注意：

1.首先我们需要将labelme标注好的json文件放在一个名为json的文件夹，之后，我们新建一个名为coco的文件夹，代码运行后的结果将保存到我们新建的coco的文件夹

2.我们需要更改第209行-212行的内容，将default=“pangolin”中的pangolin改成你自己的类别，第212行的7改为你自己标注的关键点数量。

做完这两步之后，我们运行代码，就可以在我们命名的coco文件夹中找到类似这样的文件：

到这一步，我们第一步的转化就成功了。

接下来，我们将得到的coco文件夹中的文件转化成labelme所需要的txt格式，运行如下代码：

# COCO 格式的数据集转化为 YOLO 格式的数据集
# --json_path 输入的json文件路径
# --save_path 保存的文件夹名字，默认为当前目录下的labels。

import os
import json
from tqdm import tqdm
import argparse

parser = argparse.ArgumentParser()
# 这里根据自己的json文件位置，换成自己的就行
parser.add_argument('--json_path',
                    default='coco/keypoints.json', type=str,
                    help="input: coco format(json)")
# 这里设置.txt文件保存位置
parser.add_argument('--save_path', default='txt', type=str,
                    help="specify where to save the output dir of labels")
arg = parser.parse_args()


def convert(size, box):
    dw = 1. / (size[0])
    dh = 1. / (size[1])
    x = box[0] + box[2] / 2.0
    y = box[1] + box[3] / 2.0
    w = box[2]
    h = box[3]

    x = round(x * dw, 6)
    w = round(w * dw, 6)
    y = round(y * dh, 6)
    h = round(h * dh, 6)
    return (x, y, w, h)


if __name__ == '__main__':
    json_file = arg.json_path  # COCO Object Instance 类型的标注
    ana_txt_save_path = arg.save_path  # 保存的路径

    data = json.load(open(json_file, 'r'))
    if not os.path.exists(ana_txt_save_path):
        os.makedirs(ana_txt_save_path)

    id_map = {}  # coco数据集的id不连续！重新映射一下再输出！
    with open(os.path.join(ana_txt_save_path, 'classes.txt'), 'w') as f:
        # 写入classes.txt
        for i, category in enumerate(data['categories']):
            f.write(category['name']+"\n")
            id_map[category['id']] = i
    # print(id_map)
    # 这里需要根据自己的需要，更改写入图像相对路径的文件位置。
    # list_file = open(os.path.join(ana_txt_save_path, 'train2017.txt'), 'w')
    for img in tqdm(data['images']):
        filename = img["file_name"]
        img_width = img["width"]
        img_height = img["height"]
        img_id = img["id"]
        head, tail = os.path.splitext(filename)
        ana_txt_name = head + ".txt"  # 对应的txt名字，与jpg一致
        f_txt = open(os.path.join(ana_txt_save_path, ana_txt_name), 'w')
        for ann in data['annotations']:
            if ann['image_id'] == img_id:
                box = convert((img_width, img_height), ann["bbox"])
                f_txt.write("%s %s %s %s %s" % (id_map[ann["category_id"]], box[0], box[1], box[2], box[3]))
                counter=0
                for i in range(len(ann["keypoints"])):
                    if ann["keypoints"][i] == 2 or ann["keypoints"][i] == 1 or ann["keypoints"][i] == 0:
                        f_txt.write(" %s " % format(ann["keypoints"][i] + 1,'6f'))
                        counter=0
                    else:
                        if counter==0:
                            f_txt.write(" %s " % round((ann["keypoints"][i] / img_width),6))
                        else:
                            f_txt.write(" %s " % round((ann["keypoints"][i] / img_height),6))
                        counter+=1
        f_txt.write("\n")
        f_txt.close()

这里需要注意的是

1.需要新建一个 txt 文件夹，这个文件夹用来保存我们的输出结果。如果上面你的数据存放位置和我的一样，那就不用修改代码，如果有差异，就更改第12行-第17行的输入数据和输出位置即可，之后我们就可以得到相应符合格式要求的数据集。

3.训练阶段

在完成上述两步操作之后，我们就可以根据自己制作的数据集进行训练模型了，首先，我们需要将我们的数据集划分为训练集和验证集，在划分好了以后，我们找到yolov8中coco8-pose.yaml文件的位置，如图所示：

修改其中的path为包含训练集和验证集的目录，train为我们训练集的目录，val为我们验证集的目录，全部修改好了以后，在终端执行以下指令：

yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640

其中epochs为训练次数，可以根据我们的需求进行更改。

预测和导出的话，可以在终端执行以下命令：

yolo pose predict model=path/to/best.pt source='images/bus.jpg'  # 预测

yolo export model=path/to/best.pt format=onnx  # 导出

到此，我们关键点检测（姿态检测）就完成了。

睡不醒的Michael

关注

28
点赞
踩
27

收藏

觉得还不错? 一键收藏
2
评论
yolov8姿态检测，骨架提取实操步骤

之前写过一篇基于yolov8的实例分割，但是yolov8的功能不止如此，它集成了目标识别，实例分割以及关键点检测。目标识别已经有很多完整的教程了，在这里就不过多赘述了，但是在完成骨架提取的相应项目时，我发现找到的资源或者相应的案例比较少，于是想在这一篇中汇总一下我所找到的相应资源以及本人在实际操作中所遇到的问题。1.首先我们需要将labelme标注好的json文件放在一个名为json的文件夹，之后，我们新建一个名为coco的文件夹，代码运行后的结果将保存到我们新建的coco的文件夹。
复制链接

扫一扫