目标检测-mAP测试

红太狼 2022-10-24 01:42 225阅读 0赞

# 个人微信公众号 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70_pic_center]

#### keras-yolov3源码 ####

git clone https://github.com/qqwweee/keras-yolo3.git

### 目录 ###

1.  测试图片的准备
2.  数据标签文件的格式转换（XML转换为txt格式）
3.  模型对测试图片的检测以及检测结果坐标文件的生成
4.  MAP测试
5.  结果

**说明：**

1.  本次试验中，map的测试采用的是人脸图片数据；
2.  本试验中模型的训练/MAP测试只使用了部分试验数据，因此，最后的MAP值并不高，仅供参考；

### 一、测试图片准备 ###

1：首先，从GitHub上下载相关的代码，并保存到keras\_yolo项目文件夹内；

git clone https://github.com/Cartucho/mAP

2：进入mAP子目录，将需要测试的图片以及图片对应的XML文件放置对应的文件夹内；  
测试图片放入的目录为： mAP/input/images-optional  
图片对应的XML放入的目录为：mAP/input/ground-truth

### 二、 测试图片的标签格式转换(.txt) ###

本次测试中，数据格式是的VOC格式，查询文件中Readme发现，有现成的代码可用，无需做修改；  
打开终端，进入子目录、运行代码：

cd mAP/scripts/extra
    	python convert_gt_xml.py

代码运行完后，测试数据的GT坐标会保存在对应的txt文件内，XML文件会另存在目录中的backup文件夹内；

### 三、 模型对测试图片进行测试并生成结果坐标信息保存至txt文件 ###

1.测试代码如下，需放置在keras\_yolo/ 项目文件夹下，与yolo\_video.py在同级目录；

2.运行代码，将会生成对应的测试结果并保存在指定的目录中；  
python yolo\_detect.py

# -*- coding: utf-8 -*-
    """
    Class definition of YOLO_v3 style detection model on image and video
    """
    
    import colorsys
    import os
    import sys 
    from timeit import default_timer as timer
    
    import numpy as np
    from keras import backend as K
    from keras.models import load_model
    from keras.layers import Input
    from PIL import Image, ImageFont, ImageDraw
    
    from yolo3.model import yolo_eval, yolo_body, tiny_yolo_body
    from yolo3.utils import letterbox_image
    import os
    from keras.utils import multi_gpu_model
    
    class YOLO(object):
        _defaults = {
            "model_path": '/your/path/to/keras-yolo3/model_data/face_h5/face.h5', ##训练好的模型的路径
            "anchors_path": 'model_data/tiny_yolo_anchors.txt',
            "classes_path": 'model_data/face.txt',
            "score" : 0.3,
            "iou" : 0.45,
            "model_image_size" : (416, 416),
            "gpu_num" : 0
        }
    
        @classmethod
        def get_defaults(cls, n):
            if n in cls._defaults:
                return cls._defaults[n]
            else:
                return "Unrecognized attribute name '" + n + "'"
    
        def __init__(self, **kwargs):
            self.__dict__.update(self._defaults) # set up default values
            self.__dict__.update(kwargs) # and update with user overrides
            self.class_names = self._get_class()
            self.anchors = self._get_anchors()
            self.sess = K.get_session()
            self.boxes, self.scores, self.classes = self.generate()
    
        def _get_class(self):
            classes_path = os.path.expanduser(self.classes_path)
            with open(classes_path) as f:
                class_names = f.readlines()
            class_names = [c.strip() for c in class_names]
            return class_names
    
        def _get_anchors(self):
            anchors_path = os.path.expanduser(self.anchors_path)
            with open(anchors_path) as f:
                anchors = f.readline()
            anchors = [float(x) for x in anchors.split(',')]
            return np.array(anchors).reshape(-1, 2)
    
        def generate(self):
            model_path = os.path.expanduser(self.model_path)
            assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
    
            # Load model, or construct model and load weights.
            num_anchors = len(self.anchors)
            num_classes = len(self.class_names)
            is_tiny_version = num_anchors==6 # default setting
            try:
                self.yolo_model = load_model(model_path, compile=False)
            except:
                self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
                    if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
                self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
            else:
                assert self.yolo_model.layers[-1].output_shape[-1] == \
                    num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
                    'Mismatch between model and given anchor and class sizes'
    
            print('{} model, anchors, and classes loaded.'.format(model_path))
    
            # Generate colors for drawing bounding boxes.
            hsv_tuples = [(x / len(self.class_names), 1., 1.)
                          for x in range(len(self.class_names))]
            self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
            self.colors = list(
                map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
                    self.colors))
            np.random.seed(10101)  # Fixed seed for consistent colors across runs.
            np.random.shuffle(self.colors)  # Shuffle colors to decorrelate adjacent classes.
            np.random.seed(None)  # Reset seed to default.
    
            # Generate output tensor targets for filtered bounding boxes.
            self.input_image_shape = K.placeholder(shape=(2, ))
            if self.gpu_num>=2:
                self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
            boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
                    len(self.class_names), self.input_image_shape,
                    score_threshold=self.score, iou_threshold=self.iou)
            return boxes, scores, classes
    
        def detect_image(self, image):
            start = timer()
    
            if self.model_image_size != (None, None):
                assert self.model_image_size[0]%32 == 0, 'Multiples of 32 required'
                assert self.model_image_size[1]%32 == 0, 'Multiples of 32 required'
                boxed_image = letterbox_image(image, tuple(reversed(self.model_image_size)))
            else:
                new_image_size = (image.width - (image.width % 32),
                                  image.height - (image.height % 32))
                boxed_image = letterbox_image(image, new_image_size)
            image_data = np.array(boxed_image, dtype='float32')
    
            print(image_data.shape)
            image_data /= 255.
            image_data = np.expand_dims(image_data, 0)  # Add batch dimension.
    
            out_boxes, out_scores, out_classes = self.sess.run(
                [self.boxes, self.scores, self.classes],
                feed_dict={
                    self.yolo_model.input: image_data,
                    self.input_image_shape: [image.size[1], image.size[0]],
                    K.learning_phase(): 0
                })
    
            print('Found {} boxes for {}'.format(len(out_boxes), 'img'))
    
            font = ImageFont.truetype(font='font/FiraMono-Medium.otf',
                        size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))
            thickness = (image.size[0] + image.size[1]) // 300
    
            for i, c in reversed(list(enumerate(out_classes))):
                predicted_class = self.class_names[c]
                box = out_boxes[i]
                score = out_scores[i]
    
                label = '{} {:.2f}'.format(predicted_class, score)
                draw = ImageDraw.Draw(image)
                label_size = draw.textsize(label, font)
    
                top, left, bottom, right = box
                top = max(0, np.floor(top + 0.5).astype('int32'))
                left = max(0, np.floor(left + 0.5).astype('int32'))
                bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
                right = min(image.size[0], np.floor(right + 0.5).astype('int32'))
                print(label, (left, top), (right, bottom))
                #new_f=open("/home/shan/xws/pro/keras-yolo3/detection-results/"+tmp_file.replace(".jpg", ".txt"), "a")
                new_f.write("%s %s %s %s %s\n" %  (label, left, top, right, bottom))
                if top - label_size[1] >= 0:
                    text_origin = np.array([left, top - label_size[1]])
                else:
                    text_origin = np.array([left, top + 1])
    
                # My kingdom for a good redistributable image drawing library.
                for i in range(thickness):
                    draw.rectangle(
                        [left + i, top + i, right - i, bottom - i],
                        outline=self.colors[c])
                draw.rectangle(
                    [tuple(text_origin), tuple(text_origin + label_size)],
                    fill=self.colors[c])
                draw.text(text_origin, label, fill=(0, 0, 0), font=font)
                del draw
    
            end = timer()
            print(end - start)
            return image
    
        def close_session(self):
            self.sess.close()
    
    if __name__ == '__main__':
        # yolo=YOLO()
        # path = '1.jpg'
        # try:
        #     image = Image.open(path)
        # except:
        #     print('Open Error! Try again!')
        # else:
        #     r_image = yolo.detect_image(image)
        #     r_image.show()
        # yolo.close_session()
        #strat1=timer()
        dirname="/your/path/to/map/input/image-optional/" ##该目录为测试照片的存储路径，每次测试照片的数量可以自己设定
        path=os.path.join(dirname)
        pic_list=os.listdir(path) 
        count=0
        yolo=YOLO()
        for filename in pic_list:
            tmp_file=pic_list[count]
            new_f=open("/your/path/to/map/input/detection-results/"+tmp_file.replace(".jpg", ".txt"), "a")  #预测坐标生成txt文件保存的路径
            abs_path=path+pic_list[count]
            image = Image.open(abs_path)
            r_image = yolo.detect_image(image)
            count=count+1
        #end1=timer()
        print(count)
        yolo.close_session()

### 四、 MAP结果测试 ###

python main.py

### 五、 MAP结果（一类/部分少量数据测试结果） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70]

## 参考链接 ##

*  [YoloV3\_Keras模型MAP测试][YoloV3_Keras_MAP]
 *  [Keras\_Yolov3 实现人脸检测][Keras_Yolov3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/ab76efb42ce14268ace8ca07c7ae8354.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70]: /images/20221024/c1b8cfdd20f54a80b7bd50b83136840b.png
[YoloV3_Keras_MAP]: https://blog.csdn.net/weixin_38106878/article/details/89199961
[Keras_Yolov3]: https://blog.csdn.net/weixin_38106878/article/details/88970394