目標檢測mAP計算方法-簡單易懂

本次將整理一份map計算方法，主要分為三部分，第一部分簡單了解原理，第二部分理解如何調用coco等相關庫得到map，第三部分教會讀者如何結合模型(任何可計算map的網絡模型)調用而生成map，而本博客希望讀者能掌握使用模型預測map，其重點也為第三部分:

 

第一部分介紹map原理，主要引用部分他人結果，

 

第二部分說明如何整理真實標簽的數據及預測數據，調用pycocotools庫實現map的計算，以下便是本博客的整理(附帶轉換coco json代碼)

 

第三部分說明如何在模型中直接預測map，即結合模型預測+本博客代碼樣列，便可預測map，樣列如下：

 

以下是根據模型運用Computer_map類主代碼，詳細，我將在第三部分展示細節代碼。

def computer_main(data_root, model):
    '''
    data_root:任何文件夾，但必須保證每個圖片與對應xml必須放在同一個文件夾中
    model:模型，用於預測
    '''
    C = Computer_map()
    img_root_lst = C.get_img_root_lst(data_root)  # 獲得圖片絕對路徑與圖片產生image_id映射關系

    # 在self.coco_json中保存categories，便於產生coco_json和predetect_json
    categories = model.CLASSES  # 可以給txt路徑讀取，或直接給列表  #*********************得到classes,需要更改的地方***********##
    C.get_categories(categories)

    # 產生coco_json格式
    xml_root_lst = [name[:-3] + 'xml' for name in img_root_lst]
    for xml_root in xml_root_lst: C.xml2cocojson(xml_root)  # 產生coco json 並保存到self.coco_json中

    # 產生預測的json
    for img_path in img_root_lst:

        parse_result = predict(model, img_path)  ####**********************需要更改的地方***********************####


        result, classes = parse_result['result'], parse_result['classes']
        # restult 格式為列表[x1,y1,x2,y2,score,label],若無結果為空
        img_name = C.get_strfile(img_path)
        C.detect2json(result, img_name)
    C.computer_map()  # 計算map

 

 

 

 

 

 

一.map原理：

定義內容均來自此網址：https://zhuanlan.zhihu.com/p/70667071

Accuracy：准確率

✔️ 准確率=預測正確的樣本數/所有樣本數，即預測正確的樣本比例（包括預測正確的正樣本和預測正確的負樣本，不過在目標檢測領域，沒有預測正確的負樣本這一說法，所以目標檢測里面沒有用Accuracy的）。

Precision：查准率

✔️ recision表示某一類樣本預測有多准。

✔️ Precision針對的是某一類樣本，如果沒有說明類別，那么Precision是毫無意義的（有些地方不說明類別，直接說Precision，是因為二分類問題通常說的Precision都是正樣本的Precision）。

Recall：召回率

✔️ Recall和Precision一樣，脫離類別是沒有意義的。說道Recall，一定指的是某個類別的Recall。Recall表示某一類樣本，預測正確的與所有Ground Truth的比例。

✍️ Recall計算的時候，分母是Ground Truth中某一類樣本的數量，而Precision計算的時候，是預測出來的某一類樣本數。

F1 Score：平衡F分數

F1分數，它被定義為查准率和召回率的調和平均數

更加廣泛的會定義  分數，其中  和  分數在統計學在常用，並且，  分數中，召回率的權重大於查准率，而  分數中，則相反。

AP: Average Precision

以Recall為橫軸，Precision為縱軸，就可以畫出一條PR曲線，PR曲線下的面積就定義為AP，即：

PR曲線

由於計算積分相對困難，因此引入插值法，計算AP公式如下：

計算面積：

原理：

 

 

 

 

 

二.代碼-用於實現map：

 

本部分才是本博客重要內容，我將介紹2部分，第一部分如何使用有標記的真實數據產生coco json格式與如何使用模型預測結果產生預測json格式，第二部分如何使用代碼計算map。

①.json格式

真實數據json格式實際是coco json 格式，主要是如下圖：

 

 其中images格式如下圖：

 

 

annotations格式如下：

 

 categories格式為：

 

 以上為真實數據轉換為json的格式。

預測結果數據json格式轉換，主要是如下圖：

                                   

 

 以上右圖是整體結構，實際為列表，左圖是預測信息，保存為字典，其詳細內容如下：

 

 特別注意：image id 對應真實coco json圖像的image-id，類別id也是對應真實coco json中的類別id。

 ②.實際代碼，借助pycocotools 庫中評估類別，具體代碼如下圖：

from pycocotools.coco import COCO
from pycocotools.cocoeval import COCOeval

if __name__ == "__main__":
    cocoGt = COCO('coco_json_format.json')        #標注文件的路徑及文件名，json文件形式
    cocoDt = cocoGt.loadRes('predect_format.json')  #自己的生成的結果的路徑及文件名，json文件形式
    cocoEval = COCOeval(cocoGt, cocoDt, "bbox")
    cocoEval.evaluate()
    cocoEval.accumulate()
    cocoEval.summarize()

 

 

③結果展示：

 

 

 

二.代碼-模型預測map：

 

使用模型實現代碼的類：

 

模型預測map：

 

class Computer_map():
    '''
    主代碼樣列
    def computer_main(data_root, model):#data_root:任何文件夾，但必須保證每個圖片與對應xml必須放在同一個文件夾中，model:模型，用於預測
        C = Computer_map()
        img_root_lst = C.get_img_root_lst(data_root)  # 獲得圖片絕對路徑與圖片產生image_id映射關系

        # 在self.coco_json中保存categories，便於產生coco_json和predetect_json
        categories = model.CLASSES  # 可以給txt路徑讀取，或直接給列表  #*********************得到classes,需要更改的地方***********##
        C.get_categories(categories)

        # 產生coco_json格式
        xml_root_lst = [name[:-3] + 'xml' for name in img_root_lst]
        for xml_root in xml_root_lst: C.xml2cocojson(xml_root)  # 產生coco json 並保存到self.coco_json中

        # 產生預測的json
        for img_path in img_root_lst:

            parse_result = predict(model, img_path)  ####**********************需要更改的地方***********************####

            result, classes = parse_result['result'], parse_result['classes']
            # restult 格式為列表[x1,y1,x2,y2,score,label],若無結果為空
            img_name = C.get_strfile(img_path)
            C.detect2json(result, img_name)
        C.computer_map()  # 計算map

    '''

    def __init__(self):
        self.img_format = ['png', 'jpg', 'JPG', 'PNG', 'bmp', 'jpeg']
        self.coco_json = {'images': [], 'type': 'instances', 'annotations': [], 'categories': []}
        self.predetect_json = []  # 保存字典
        self.image_id = 10000000  # 圖像的id，每增加一張圖片便+1
        self.anation_id = 10000000
        self.imgname_map_id = {}  # 圖片名字映射id

    def read_txt(self, file_path):
        with open(file_path, 'r') as f:
            content = f.read().splitlines()
        return content

    def get_categories(self, categories):
        '''
        categories:為字符串，指絕對路徑；為列表，指類本身
        return:將categories存入coco json中
        '''
        if isinstance(categories, str):
            categories = self.read_txt(categories)
        elif isinstance(categories, list or tuple):
            categories = list(categories)

        category_json = [{"supercategory": cat, "id": i + 1, "name": cat} for i, cat in enumerate(categories)]
        self.coco_json['categories'] = category_json

    def computer_map(self, coco_json_path=None, predetect_json_path=None):
        from pycocotools.coco import COCO
        from pycocotools.cocoeval import COCOeval
        from collections import defaultdict
        import time
        import json
        from pycocotools import mask as maskUtils
        import numpy as np
        # 繼承修改coco json文件
        class COCO_modify(COCO):
            def __init__(self, coco_json_data=None):
                """
                Constructor of Microsoft COCO helper class for reading and visualizing annotations.
                :param annotation_file (str): location of annotation file
                :param image_folder (str): location to the folder that hosts images.
                :return:
                """
                # load dataset
                self.dataset, self.anns, self.cats, self.imgs = dict(), dict(), dict(), dict()
                self.imgToAnns, self.catToImgs = defaultdict(list), defaultdict(list)
                if coco_json_data is not None:
                    print('loading annotations into memory...')
                    tic = time.time()
                    if isinstance(coco_json_data, str):
                        with open(coco_json_data, 'r') as f:
                            dataset = json.load(f)
                        assert type(dataset) == dict, 'annotation file format {} not supported'.format(type(dataset))
                        print('Done (t={:0.2f}s)'.format(time.time() - tic))
                    else:
                        dataset = coco_json_data
                    self.dataset = dataset
                    self.createIndex()

            def loadRes(self, predetect_json_data):
                import copy
                """
                Load result file and return a result api object.
                :param   resFile (str)     : file name of result file
                :return: res (obj)         : result api object
                """
                res = COCO_modify()
                res.dataset['images'] = [img for img in self.dataset['images']]

                print('Loading and preparing results...')
                tic = time.time()

                if isinstance(predetect_json_data, str):
                    with open(predetect_json_data, 'r') as f:
                        anns = json.load(f)

                    print('Done (t={:0.2f}s)'.format(time.time() - tic))
                else:
                    anns = predetect_json_data

                assert type(anns) == list, 'results in not an array of objects'
                annsImgIds = [ann['image_id'] for ann in anns]
                assert set(annsImgIds) == (set(annsImgIds) & set(self.getImgIds())), \
                    'Results do not correspond to current coco set'
                if 'caption' in anns[0]:
                    imgIds = set([img['id'] for img in res.dataset['images']]) & set([ann['image_id'] for ann in anns])
                    res.dataset['images'] = [img for img in res.dataset['images'] if img['id'] in imgIds]
                    for id, ann in enumerate(anns):
                        ann['id'] = id + 1
                elif 'bbox' in anns[0] and not anns[0]['bbox'] == []:
                    res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])
                    for id, ann in enumerate(anns):
                        bb = ann['bbox']
                        x1, x2, y1, y2 = [bb[0], bb[0] + bb[2], bb[1], bb[1] + bb[3]]
                        if not 'segmentation' in ann:
                            ann['segmentation'] = [[x1, y1, x1, y2, x2, y2, x2, y1]]
                        ann['area'] = bb[2] * bb[3]
                        ann['id'] = id + 1
                        ann['iscrowd'] = 0
                elif 'segmentation' in anns[0]:
                    res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])
                    for id, ann in enumerate(anns):
                        # now only support compressed RLE format as segmentation results
                        ann['area'] = maskUtils.area(ann['segmentation'])
                        if not 'bbox' in ann:
                            ann['bbox'] = maskUtils.toBbox(ann['segmentation'])
                        ann['id'] = id + 1
                        ann['iscrowd'] = 0
                elif 'keypoints' in anns[0]:
                    res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])
                    for id, ann in enumerate(anns):
                        s = ann['keypoints']
                        x = s[0::3]
                        y = s[1::3]
                        x0, x1, y0, y1 = np.min(x), np.max(x), np.min(y), np.max(y)
                        ann['area'] = (x1 - x0) * (y1 - y0)
                        ann['id'] = id + 1
                        ann['bbox'] = [x0, y0, x1 - x0, y1 - y0]
                print('DONE (t={:0.2f}s)'.format(time.time() - tic))

                res.dataset['annotations'] = anns
                res.createIndex()
                return res

        coco_json_data = coco_json_path if coco_json_path is not None else self.coco_json
        cocoGt = COCO_modify(coco_json_data)  # 標注文件的路徑及文件名，json文件形式
        predetect_json_data = predetect_json_path if predetect_json_path is not None else self.predetect_json
        cocoDt = cocoGt.loadRes(predetect_json_data)  # 自己的生成的結果的路徑及文件名，json文件形式

        cocoEval = COCOeval(cocoGt, cocoDt, "bbox")
        cocoEval.evaluate()
        cocoEval.accumulate()
        cocoEval.summarize()

    def get_img_root_lst(self, root_data):
        import os
        img_root_lst = []
        for dir, file, names in os.walk(root_data):
            img_lst = [os.path.join(dir, name) for name in names if name[-3:] in self.img_format]
            img_root_lst = img_root_lst + img_lst
            for na in img_lst:  # 圖片名字映射image_id
                self.image_id += 1
                self.imgname_map_id[self.get_strfile(na)] = self.image_id
        return img_root_lst  # 得到圖片絕對路徑

    def get_strfile(self, file_str, pos=-1):
        '''
        得到file_str / or \\ 的最后一個名稱
        '''
        endstr_f_filestr = file_str.split('\\')[pos] if '\\' in file_str else file_str.split('/')[pos]
        return endstr_f_filestr

    def read_xml(self, xml_root):
        '''
        :param xml_root: .xml文件
        :return: dict('cat':['cat1',...],'bboxes':[[x1,y1,x2,y2],...],'whd':[w ,h,d])
        '''

        import xml.etree.ElementTree as ET
        import os

        dict_info = {'cat': [], 'bboxes': [], 'box_wh': [], 'whd': []}
        if os.path.splitext(xml_root)[-1] == '.xml':
            tree = ET.parse(xml_root)  # ET是一個xml文件解析庫，ET.parse（）打開xml文件。parse--"解析"
            root = tree.getroot()  # 獲取根節點
            whd = root.find('size')
            whd = [int(whd.find('width').text), int(whd.find('height').text), int(whd.find('depth').text)]
            xml_filename = root.find('filename').text
            dict_info['whd'] = whd
            dict_info['xml_filename'] = xml_filename
            for obj in root.findall('object'):  # 找到根節點下所有“object”節點
                cat = str(obj.find('name').text)  # 找到object節點下name子節點的值（字符串）
                bbox = obj.find('bndbox')
                x1, y1, x2, y2 = [int(bbox.find('xmin').text),
                                  int(bbox.find('ymin').text),
                                  int(bbox.find('xmax').text),
                                  int(bbox.find('ymax').text)]
                b_w = x2 - x1 + 1
                b_h = y2 - y1 + 1

                dict_info['cat'].append(cat)
                dict_info['bboxes'].append([x1, y1, x2, y2])
                dict_info['box_wh'].append([b_w, b_h])

        else:
            print('[inexistence]:{} suffix is not xml '.format(xml_root))
        return dict_info

    def xml2cocojson(self, xml_root):
        '''
        處理1個xml，將其真實json保存到self.coco_json中
        '''
        assert len(self.coco_json['categories']) > 0, 'self.coco_json[categories] must exist v'
        categories = [cat_info['name'] for cat_info in  self.coco_json['categories']]
        xml_info = self.read_xml(xml_root)
        if len(xml_info['cat']) > 0:
            xml_filename = xml_info['xml_filename']
            xml_name = self.get_strfile(xml_root)
            img_name = xml_name[:-3] + xml_filename[-3:]
            # 轉為coco json時候，若add_file為True則在coco json文件的file_name增加文件夾名稱+圖片名字

            image_id = self.imgname_map_id[img_name]
            w, h, d = xml_info['whd']
            # 構建json文件字典
            image_json = {'file_name': img_name, 'height': h, 'width': w, 'id': image_id}
            ann_json = []
            for i, category in enumerate(xml_info['cat']):
                # 表示有box存在，可以添加images信息

                category_id = categories.index(category) + 1  # 給出box對應標簽索引為類
                self.anation_id = self.anation_id + 1
                xmin, ymin, xmax, ymax = xml_info['bboxes'][i]

                o_width, o_height = xml_info['box_wh'][i]

                if (xmax <= xmin) or (ymax <= ymin):
                    print('code:[{}] will be abandon due to  {} min of box w or h more than max '.format(category,
                                                                                                         xml_root))  # 打印錯誤的box
                else:
                    ann = {'area': o_width * o_height, 'iscrowd': 0, 'image_id': image_id,
                           'bbox': [xmin, ymin, o_width, o_height],
                           'category_id': category_id, 'id': self.anation_id, 'ignore': 0,
                           'segmentation': []}
                    ann_json.append(ann)

            if len(ann_json) > 0:  # 證明存在 annotation
                for ann in ann_json:  self.coco_json['annotations'].append(ann)
                self.coco_json['images'].append(image_json)

    def detect2json(self, predetect_result, img_name,score_thr=-1):
        '''
        predetect_result:為列表，每個列表中包含[x1, y1, x2, y2, score, label]
        img_name: 圖片的名字
        '''
        if len(predetect_result) > 0:
            categories = [cat_info['name'] for cat_info in  self.coco_json['categories']]
            for result in predetect_result:
                x1, y1, x2, y2, score, label = result
                if score>score_thr:
                    w, h = int(x2 - x1), int(y2 - y1)
                    x1, y1 = int(x1), int(y1)
                    img_name_new = self.get_strfile(img_name)
                    image_id = self.imgname_map_id[img_name_new]
                    category_id = list(categories).index(label) + 1
                    detect_json = {
                        "area": w * h,
                        "iscrowd": 0,
                        "image_id": image_id,
                        "bbox": [
                            x1,
                            y1,
                            w,
                            h
                        ],
                        "category_id": category_id,
                        "id": image_id,
                        "ignore": 0,
                        "segmentation": [],
                        "score": score
                    }
                    self.predetect_json.append(detect_json)

    def write_json(self,out_dir):
        import os
        import json
        coco_json_path=os.path.join(out_dir,'coco_json_data.json')
        with open(coco_json_path, 'w') as f:
            json.dump(self.coco_json, f, indent=4)  # indent表示間隔長度
        predetect_json_path=os.path.join(out_dir,'predetect_json_data.json')
        with open(predetect_json_path, 'w') as f:
            json.dump(self.predetect_json, f, indent=4)  # indent表示間隔長度

 

結果展示：左圖為mmdet2.19模型結果，右圖為yolov5模型結果

 

 

 

 

 

 

 

 

 

 

 

 

 

附帶xml轉換coco json代碼：

 

import os
import json
import xml.etree.ElementTree as ET
import cv2  # 無xml時候需要讀取圖片高與寬
# from cope_data.cope_utils import *
from tqdm import tqdm








def read_xml(xml_root):
    '''
    :param xml_root: .xml文件
    :return: dict('cat':['cat1',...],'bboxes':[[x1,y1,x2,y2],...],'whd':[w ,h,d])
    '''
    dict_info = {'cat': [], 'bboxes': [], 'box_wh': [], 'whd': []}
    if os.path.splitext(xml_root)[-1] == '.xml':
        tree = ET.parse(xml_root)  # ET是一個xml文件解析庫，ET.parse（）打開xml文件。parse--"解析"
        root = tree.getroot()  # 獲取根節點
        whd = root.find('size')
        whd = [int(whd.find('width').text), int(whd.find('height').text), int(whd.find('depth').text)]
        xml_filename = root.find('filename').text
        dict_info['whd']=whd
        dict_info['xml_filename']=xml_filename
        for obj in root.findall('object'):  # 找到根節點下所有“object”節點
            cat = str(obj.find('name').text)  # 找到object節點下name子節點的值（字符串）
            bbox = obj.find('bndbox')
            x1, y1, x2, y2 = [int(bbox.find('xmin').text),
                              int(bbox.find('ymin').text),
                              int(bbox.find('xmax').text),
                              int(bbox.find('ymax').text)]
            b_w = x2 - x1 + 1
            b_h = y2 - y1 + 1

            dict_info['cat'].append(cat)
            dict_info['bboxes'].append([x1, y1, x2, y2])
            dict_info['box_wh'].append([b_w, b_h])

    else:
        print('[inexistence]:{} suffix is not xml '.format(xml_root))
    return dict_info







# xml轉換為訓練集
def train_multifiles(root_data, json_name='train.json', categories=None, out_dir=None, add_file=False,refuse_category=[],category_path=None):
    '''
    json文件中的file_name包含文件夾/名字
    :param json_name: 保存json文件名字,最終結果在out_dir+json_name(若out_dir有路徑情況)，否則在root_data下面
    :param categories: 類別信息，為None則將self.root文件夾的名字作為類別信息
    add_file :True表示cocojson中添加文件名，否則不添加
    refuse_category:拒絕裝換為cocojson的類的列表
    :return:
    '''



    def read_txt(file_path):
        with open(file_path, 'r') as f:
            content = f.read().splitlines()
        return content
    def write_txt(text_lst, out_dir):
        '''
        每行內容為列表，將其寫入text中
        '''
        file_write_obj = open(out_dir, 'w')  # 以寫的方式打開文件，如果文件不存在，就會自動創建
        for text in text_lst:
            file_write_obj.writelines(text)
            file_write_obj.write('\n')
        file_write_obj.close()
        return out_dir

    def get_strfile(file_str, pos=-1):
        '''
        得到file_str / or \\ 的最后一個名稱
        '''
        endstr_f_filestr = file_str.split('\\')[pos] if '\\' in file_str else file_str.split('/')[pos]
        return endstr_f_filestr

    # coco json文件格式
    json_dict = {"images": [], "type": "instances", "annotations": [], "categories": []}
    image_id = 10000000
    anation_id = 10000000
    xml_root_lst = []
    for dir, dir_file, dir_names in os.walk(root_data):
        name_lst = [os.path.join(dir, name) for name in dir_names if name[-3:] == 'xml']
        xml_root_lst = xml_root_lst + name_lst
    if category_path is None:
        if categories is None:
            categories = []
        elif isinstance(categories, list):
            categories = categories
        else:
            raise IOError('categories must be list or None')
    else:
        categories=read_txt(category_path)


    count_categories = {}
    for xml_root in tqdm(xml_root_lst):
        try:
            xml_info=read_xml(xml_root)
            if len(xml_info['cat'])>0:
                xml_filename = xml_info['xml_filename']
                xml_name = get_strfile(xml_root)
                img_name = xml_name[:-3] + xml_filename[-3:]
                # 轉為cocojson時候，若add_file為True則在cocojson文件的file_name增加文件夾名稱+圖片名字
                file_name = get_strfile(xml_root, pos=-2) + '/' + img_name  if add_file else img_name  # 只記錄圖片名字

                image_id = image_id + 1

                w,h,d=xml_info['whd']
                # 構建json文件字典
                image = {'file_name': file_name, 'height': h, 'width': w, 'id': image_id}
                for i, category in enumerate(xml_info['cat']):

                    if category  in refuse_category:
                        print('refuse {} code will not convert coojson format '.format(category))
                        continue
                    # 若categories列表不包含該code則增加該code到列表中
                    if category not in categories and category_path is None:
                        categories.append(category)
                    # 計數每個cat的數量
                    count_categories[category]=1  if category not in count_categories else count_categories[category]+1


                    # 表示有box存在，可以添加images信息
                    if image not in json_dict['images']:
                        json_dict['images'].append(image)  # 將圖像信息添加到json中
                    category_id = categories.index(category) + 1  # 給出box對應標簽索引為類
                    anation_id = anation_id + 1
                    xmin,ymin,xmax,ymax=xml_info['bboxes'][i]

                    o_width,o_height=xml_info['box_wh'][i]

                    if (xmax <= xmin) or (ymax <= ymin):
                        print('code:[{}] will be abandon due to  {} min of box w or h more than max '.format(category,xml_root))  # 打印錯誤的box

                    else:
                        ann = {'area': o_width * o_height, 'iscrowd': 0, 'image_id': image_id,
                               'bbox': [xmin, ymin, o_width, o_height],
                               'category_id': category_id, 'id': anation_id, 'ignore': 0,
                               'segmentation': []}
                        json_dict['annotations'].append(ann)
        except:
            print('xml file: {} not read error!'.format(xml_root))


    for cid, cate in enumerate(categories):
        cat = {'supercategory': cate, 'id': cid + 1, 'name': cate}
        json_dict['categories'].append(cat)
    if out_dir is not None:
        build_dir(self.out_dir)
        out_dir = os.path.join(out_dir, json_name)
        out_dir_txt=os.path.join(out_dir, 'classes.txt')
    else:
        out_dir = os.path.join(root_data, json_name)
        out_dir_txt = os.path.join(root_data, 'classes.txt')
    with open(out_dir, 'w') as f:
        json.dump(json_dict, f, indent=4)  # indent表示間隔長度

    write_txt(categories,out_dir_txt)


    print('categories count : \n',count_categories)




if __name__ == '__main__':
    root_path = r'D:\DATA\coco2017_train_val\data_coco_clear_2017\val'
    category_path=r'D:\DATA\coco2017_train_val\data_coco_clear_2017\classes.txt'
    train_multifiles(root_path,category_path=category_path)

 

 

 

 

 

 

 

 

 

借鑒博客：https://blog.csdn.net/qq_35916487/article/details/89076570