C++ 目标检测中的precision，recall，fscore的计算

最新推荐文章于 2024-06-07 01:53:59 发布
最新推荐文章于 2024-06-07 01:53:59 发布
阅读量1.5k 收藏 4
点赞数 2
分类专栏： C++学习 文章标签： XML读取 IOU计算 fscore precision recall
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22764813/article/details/82848476
版权

demo的作用是对目标检测到的目标位置进行precision，recall和fscore的计算;

demo功能就涉及：1）ground truth xml中的box的读取;

                              2）计算预测目标框和ground truth box的IOU区域（demo中IOU阈值为0.5）

                              3）IOU计算原理;

demo代码如下：

#include<iostream>
#include<QString>
#include<vector>
#include<QFile>
#include<QXmlStreamReader>

using namespace std;

typedef struct Bnd_Box_
{
    int xmin;
    int ymin;
    int xmax;
    int ymax;
}Bnd_Box;

typedef struct Obj_Box_
{
    int x;
    int y;
    int width;
    int height;
}Obj_Box;

typedef struct Xml_Image_Head_
{
    QString folder;
    QString filename;
    QString path;
    QString source;
    QString database;
    int image_width;
    int image_height;
    int image_depth;
    int image_size;
    int segmented;
}Xml_Image_Head;

typedef struct Xml_Box_
{
    QString class_name;
    QString pose;
    int truncated;
    int difficult;
    Bnd_Box box;
}Xml_Box;

void parseBlog( QXmlStreamReader &reader, Xml_Image_Head &image_head, vector< Xml_Box > &objs )
{
    bool ok;
    Xml_Box obj;
    QString strElementName;
    QString strCharacters;

    objs.clear();
    while( !reader.atEnd() )
    {
        reader.readNext();
        if (reader.isStartElement())
        {  // 开始元素
            strElementName = reader.name().toString();
            reader.readNext();
            if (reader.isCharacters())
            {
                strCharacters = reader.text().toString();
            //    qDebug() << QString("Characters : %1").arg(strCharacters);
            }
         //   QString strText = reader.text().toString();

           // qDebug() << QString::fromLocal8Bit("********** 开始元素<") << strElementName << QString::fromLocal8Bit("> ********** ") << strCharacters;
            if( QString( "folder" ) == strElementName )
            {
                image_head.folder = strCharacters;
            }
            else if( QString( "filename" ) == strElementName )
            {
                image_head.filename = strCharacters;
            }
            else if( QString( "path" ) == strElementName )
            {
                image_head.path = strCharacters;
            }
            else if( QString( "source" ) == strElementName )
            {
                image_head.source = strCharacters;
            }
            else if( QString( "database" ) == strElementName )
            {
                image_head.database = strCharacters;
            }
            else if( QString( "width" ) == strElementName )
            {
                image_head.image_width = strCharacters.toInt( &ok );
                if( false == ok )
                {
                    image_head.image_width = 0;
                }
            }
            else if( QString( "height" ) == strElementName )
            {
                image_head.image_height = strCharacters.toInt( &ok );
                if( false == ok )
                {
                    image_head.image_height = 0;
                }
            }
            else if( QString( "depth" ) == strElementName )
            {
                image_head.image_depth = strCharacters.toInt( &ok );
                if( false == ok )
                {
                    image_head.image_depth = 0;
                }
            }
            else if( QString( "segmented" ) == strElementName )
            {
                image_head.segmented = strCharacters.toInt( &ok );
                if( false == ok )
                {
                    image_head.segmented = 0;
                }
            }
            else if( QString( "object" ) == strElementName )
            {
                // TODO:: box
                bool is_do = true;
                while( is_do && !reader.atEnd() )
                {
                    reader.readNext();
                    if (reader.isStartElement())
                    {  // 开始元素
                        strElementName = reader.name().toString();
                        reader.readNext();
                        if (reader.isCharacters())
                        {
                            strCharacters = reader.text().toString();
                        }
                 //       qDebug() << QString::fromLocal8Bit("********** 开始元素<") << strElementName << QString::fromLocal8Bit("> ********** ") << strCharacters;
                        if( QString( "name" ) == strElementName )
                        {
                            obj.class_name = strCharacters;
                        }
                        else if( QString( "pose" ) == strElementName )
                        {
                            obj.pose = strCharacters;
                        }
                        else if( QString( "truncated" ) == strElementName )
                        {
                            obj.truncated = strCharacters.toInt( &ok );
                            if( false == ok )
                            {
                                obj.truncated = 0;
                            }
                        }
                        else if( QString( "difficult" ) == strElementName )
                        {
                            obj.difficult = strCharacters.toInt( &ok );
                            if( false == ok )
                            {
                                obj.difficult = 0;
                            }
                        }
                        else if( QString( "xmin" ) == strElementName )
                        {
                            obj.box.xmin = strCharacters.toInt( &ok );
                            if( false == ok )
                            {
                                obj.box.xmin = 0;
                            }
                        }
                        else if( QString( "ymin" ) == strElementName )
                        {
                            obj.box.ymin = strCharacters.toInt( &ok );
                            if( false == ok )
                            {
                                obj.box.ymin = 0;
                            }
                        }
                        else if( QString( "xmax" ) == strElementName )
                        {
                            obj.box.xmax = strCharacters.toInt( &ok );
                            if( false == ok )
                            {
                                obj.box.xmax = 0;
                            }
                        }
                        else if( QString( "ymax" ) == strElementName )
                        {
                            obj.box.ymax = strCharacters.toInt( &ok );
                            if( false == ok )
                            {
                                obj.box.ymax = 0;
                            }
                        }
                    }
                    else if ( reader.isEndElement() )
                    {  // 结束元素
                        QString strElementName = reader.name().toString();
                  //      qDebug() << QString::fromLocal8Bit("********** 结束元素<") << strElementName << QString::fromLocal8Bit("> ********** ");
                        if( 0 == strElementName.compare( "object" ) )
                        {
                            is_do = false;
                            objs.push_back( obj );
                        }
                    }
                }
            }
        }
        else if (reader.isEntityReference())
        {  // 实体引用
            QString strName = reader.name().toString();
            QString strText = reader.text().toString();
         //   qDebug() << QString("EntityReference : %1(%2)").arg(strName).arg(strText);
        }
        else if (reader.isCDATA())
        {  // CDATA
         //   QString strCDATA = reader.text().toString();
        //    qDebug() << QString("CDATA : %1").arg(strCDATA);

            reader.readNext();
            if (reader.isCharacters())
            {
                QString strCharacters = reader.text().toString();
        //        qDebug() << QString("Characters : %1").arg(strCharacters);
            }
        }
        else if (reader.isEndElement())
        {  // 结束元素
            QString strElementName = reader.name().toString();
       //     qDebug() << QString::fromLocal8Bit("********** 结束元素<") << strElementName << QString::fromLocal8Bit("> ********** ");
        }
        else if (reader.isDTD())
        {  // CDATA
            QString strDTD = reader.text().toString();
       //     qDebug() << QString("DTD : %1").arg(strDTD);

            reader.readNext();
            if (reader.isCharacters())
            {
                QString strCharacters = reader.text().toString();
        //        qDebug() << QString("Characters : %1").arg(strCharacters);
            }
        }
    }
}

void analysis_xml( QString xml_name, Xml_Image_Head &image_head, vector< Xml_Box > &box )
{

    QFile file_io( xml_name );
    file_io.open( QIODevice::ReadOnly );
    QXmlStreamReader xml_read( &file_io );

    if( file_io.isOpen() )
    {
        while( !xml_read.atEnd() )
        {
            QXmlStreamReader::TokenType nType = xml_read.readNext();
            switch( nType )
            {
                case QXmlStreamReader::StartDocument:
                {   // 开始文档
                //    qDebug() << QString::fromLocal8Bit( "********** 开始文档（XML 声明） ********** ");
                    // XML 声明
                    QString strVersion = xml_read.documentVersion().toString();
                    QString strEncoding = xml_read.documentEncoding().toString();
                    bool bAlone = xml_read.isStandaloneDocument();
                //    qDebug() << QString::fromLocal8Bit("版本：%1  编码：%2  Standalone：%3")
                 //               .arg(strVersion).arg(strEncoding).arg(bAlone) << "\r\n";
                    break;
                }
                case QXmlStreamReader::Comment:
                {   // 注释
              //      qDebug() << QString::fromLocal8Bit("********** 注释 ********** ");
                    QString strComment = xml_read.text().toString();
                //    qDebug() << strComment << "\r\n";
                    break;
                }
                case QXmlStreamReader::ProcessingInstruction:
                {   // 处理指令
               //     qDebug() << QString::fromLocal8Bit("********** 处理指令 ********** ");
                    QString strProcInstr = xml_read.processingInstructionData().toString();
               //     qDebug() << strProcInstr << "\r\n";
                    break;
                }
                case QXmlStreamReader::DTD:
                {   // DTD
                //    qDebug() << QString::fromLocal8Bit("********** DTD ********** ");
                    QString strDTD = xml_read.text().toString();
                //    QXmlStreamNotationDeclarations notationDeclarations = xml_read.notationDeclarations();  // 符号声明
                //    QXmlStreamEntityDeclarations entityDeclarations = xml_read.entityDeclarations();  // 实体声明
                    // DTD 声明
                    QString strDTDName = xml_read.dtdName().toString();
                    QString strDTDPublicId = xml_read.dtdPublicId().toString();  // DTD 公开标识符
                    QString strDTDSystemId = xml_read.dtdSystemId().toString();  // DTD 系统标识符
               //     qDebug() << QString::fromLocal8Bit("DTD : %1").arg(strDTD);
               //     qDebug() << QString::fromLocal8Bit("DTD 名称 : %1").arg(strDTDName);
               //     qDebug() << QString::fromLocal8Bit("DTD 公开标识符 : %1").arg(strDTDPublicId);
               //     qDebug() << QString::fromLocal8Bit("DTD 系统标识符 : %1").arg(strDTDSystemId);
               //     qDebug() << "\r\n";

                    break;
                }
                case QXmlStreamReader::StartElement:
                {   // 开始元素
                    QString strElementName = xml_read.name().toString();
                    if (QString::compare( strElementName, "annotation") == 0)
                    {   // 根元素
                   //     qDebug() << QString::fromLocal8Bit( "********** 开始元素<annotation> ********** " );
                        QXmlStreamAttributes attributes = xml_read.attributes();
                        if (attributes.hasAttribute("object"))
                        {
                            QString strVersion = attributes.value("Version").toString();
                //            qDebug() << QString::fromLocal8Bit("属性：Version(%1)").arg(strVersion);
                        }

                        parseBlog(xml_read, image_head, box );
                    }
                    break;
                }
                case QXmlStreamReader::EndDocument:
                {   // 结束文档
                //    qDebug() << QString::fromLocal8Bit("********** 结束文档 ********** ");
                    break;
                }

                default:
                    break;
            }
        }
    }
}
typedef struct Obj_Info_
{
    Obj_Box obj_box;
    float obj_prob;
    int obj_class;
}Obj_Info;

float calcIOU(int prediction_xmin,int prediction_ymin,int prediction_width,int prediction_height,
            int GT_xmin,        int GT_ymin,        int GT_width,        int GT_height)
{
    float IOU = 0.0;
    float eps = 1e-5;
    int center_point1_x = prediction_xmin + 0.5 * prediction_width;
    int center_point1_y = prediction_ymin + 0.5 * prediction_height;
    int center_point2_x = GT_xmin + 0.5 * GT_width;
    int center_point2_y = GT_ymin + 0.5 * GT_height;
    if (((abs(center_point1_x - center_point2_x) < ((prediction_width + GT_width) / 2.0)) and (
        abs(center_point1_y - center_point2_y) < ((prediction_height + GT_height) / 2.0))))
    {
        int lu_x_inter = max(prediction_xmin, GT_xmin);
        int lu_y_inter = max(prediction_ymin, GT_ymin);

        int rb_x_inter = min((prediction_xmin + prediction_width),
                             (GT_xmin + GT_width));
        int rb_y_inter = min((prediction_ymin + prediction_height),
                             (GT_ymin + GT_height));

        int inter_w = abs(rb_x_inter - lu_x_inter);
        int inter_h = abs(rb_y_inter - lu_y_inter);

        int inter_square = inter_w * inter_h;
        int union_square = (prediction_width * prediction_height) + (GT_width * GT_height) - inter_square;

        IOU = 1.0 * inter_square / union_square;
        cout<<"calcIOU:"<<IOU<<endl;
    }
    else
    {
        IOU = 0.0;
    }
    return IOU;
}
int main()
{
    Xml_Image_Head image_head;
    vector< Xml_Box > boxes;
    string img_file = "child_hug_vid1_cut_person_child_1_2_100000001.jpg";
    string root_path_xml ="/home/fuxueping/sdb/Caffe_Project/test_image_all_xml/" ;
    int i = img_file.find(".jpg");

    string xml_name(img_file.substr(0,i-1));

    string xml_file = root_path_xml+xml_name + ".xml";
    QString xml_dir = QString::fromStdString(xml_file);
    analysis_xml( xml_dir, image_head, boxes );
    int total = 0;
    int correct = 0;
    int proposal = 0;
    int out_obj_num;
    proposal += out_obj_num;
    total += boxes.size();
    Obj_Info obj_info[10];

    int num_box = 0;
    float iou_thresh = 0.5;
    float eps = 0.000000001;
    for(int i = 0; i < boxes.size();i++)
    {
        float best_iou = 0;
        for (int k=0; k < out_obj_num; k++ )
        {
            float w  = obj_info[ k ].obj_box.width;
            float h  = obj_info[ k ].obj_box.height;
            float xmin = obj_info[ k ].obj_box.x;
            float ymin = obj_info[ k ].obj_box.y;
            float iou = calcIOU(xmin,ymin,w,h,
                              boxes[i].box.xmin,
                              boxes[i].box.ymin,
                              boxes[i].box.xmax-boxes[i].box.xmin,
                              boxes[i].box.ymax - boxes[i].box.ymin);
            if(iou > best_iou)
            {
                best_iou = iou;
            }
        }
        if((best_iou > iou_thresh)&&(num_box < out_obj_num))
        {
            correct += 1;
            num_box += 1;
        }
    }
    float precision = 1.0 × correct/(proposal + eps);
    float recall = 1.0 * correct/(total + eps);
    float fscore = 2.0 * precision * recall /(precision + recall + eps);
    return 0;
}

xml类型如下：

<annotation>
  <folder>child_hug_vid1_cut</folder>
  <filename>2017-06-30_13-56-10_00686</filename>
  <path>/home/csh/Desktop/label/py/child_hug_vid1_cut/2017-06-30_13-56-10_00686.jpg</path>
  <source>
    <database>Unknown</database>
  </source>
  <size>
    <width>433</width>
    <height>229</height>
    <depth>3</depth>
  </size>
  <segmented>0</segmented>
  <object>
    <name>1</name>
    <pose>Unspecified</pose>
    <truncated>0</truncated>
    <difficult>0</difficult>
    <bndbox>
      <xmin>165</xmin>
      <ymin>46</ymin>
      <xmax>251</xmax>
      <ymax>193</ymax>
    </bndbox>
  </object>
  <object>
    <name>1</name>
    <pose>Unspecified</pose>
    <truncated>0</truncated>
    <difficult>0</difficult>
    <bndbox>
      <xmin>161</xmin>
      <ymin>22</ymin>
      <xmax>332</xmax>
      <ymax>202</ymax>
    </bndbox>
  </object>
</annotation>

这里是一个demo程序;

我在使用时，是通过图片的文件名然后获得xml的绝对路径，所以务必保证所有测试的图片是包含XML文件;

猫猫与橙子
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++手撕IOU和NMS，目标检测基础，面试高频
weixin_44850236的博客
01-01 604
【代码】C++手撕目标检测基础IOU和NMS。
windows下基于Tensorflow的深度学习目标检测算法的C++实现(不依赖于python环境)
qq_37562987的博客
09-21 927
之前一段时间，由于项目需求，将深度学习框架从Caffe切换到Tensorflow，从ubuntu下模型训练到模型移植到windows推理，即从 Caffe：Ubuntu下训练，windows端推理，采用C++调用python的方式工程化 切换为： Tensorflow：Ubuntu下训练，windows端推理，采用Tensorflow C++接口的方式工程化(不依赖于python环境) Tenso...
YOLOv3 深入解析：使用C++实现目标检测
最新发布
m0_57781768的博客
06-07 964
YOLO（You Only Look Once）系列算法是Redmon等人在2016年提出的一种新型目标检测方法。与传统的R-CNN系列方法相比，YOLO采用了全卷积神经网络（Fully Convolutional Neural Network），将目标检测问题转化为回归问题，只需一次前向传播即可完成对图像的检测和分类任务。YOLOv3是该系列的第三个版本，在精度和速度上都进行了优化和改进。
C++基础学习：简单加减法运算并统计准确率
Dycadrwy的博客
11-18 1020
#include <iostream> #include <stdio.h> #include <math.h> #include <time.h> using namespace std; int counter = 0; int main(int argc, char** argv) { int random_number, x, y, z; //避免每次产生相同的随机数 srand((unsigned)time(NULL).
检测到目标服务器启用了trace方法_目标检测中mAP的计算方法
weixin_39555415的博客
11-20 196
2020.3.10 更新：“计算过程”部分的伪代码更新了一下，“举例说明”增加了一些内容。2020.3.31 更新：“举例说明”增加Precision、Recall和PR曲线具体计算方法部分，新增“python代码”部分前言：基本上所有的中文文章都会告诉你什么是mAP，什么是Precision、Recall、TP、FP、FN，但就是不讲清楚到底该怎么计算，应该先算什么再算什么，在项目中应该怎么自...
目标检测中评估指标mAP详解和计算方式
左手coding，右手cooking
02-22 379
这文章写的很详细
目标检测基础——IOU计算
Guo_Python的博客
04-26 4807
IoU 作为目标检测算法性能 mAP 计算的一个非常重要的函数，IoU 计算的是 “预测的边框” 和 “真实的边框” 的交集和并集的比值。
计算目标检测IoU、Precision、Recall
05-15
计算目标检测IoU、Precision、Recall 计算目标检测IoU、Precision、Recall 计算目标检测IoU、Precision、Recall 计算目标检测IoU、Precision、Recall 计算目标检测IoU、Precision、Recall 计算目标检测IoU、...
计算目标检测二分类结果的Precision,Recall,TP,FP与FN(python)
11-04
输入标注txt文件与预测txt文件路径，计算P、R、TP、FP与FN。txt格式为class、归一化后的矩形框中点x y w h，可调整IOU阈值
从图像分类开始带你快速了解计算机视觉的目标检测任务 计算机视觉.pdf
04-21
在目标检测中，评估标准通常包括平均精度（Average Precision, AP）和平均召回率（Average Recall），以及它们的变体，如AP50、AP75等，用于衡量算法在不同IoU（Intersection over Union）阈值下的性能。 总的来说...
基于yolo5的目标检测人物动物识别，有代码，有数据，可以直接运行
05-14
7. **评估指标**：评估目标检测模型的常用指标包括精度（Precision）、召回率（Recall）、平均精度均值mAP（Mean Average Precision）等。理解这些指标有助于优化模型性能。 通过这个资源，初学者可以快速掌握YOLOv...
prec_rec.zip_Curves_Recall_precision recall_precision-recall_rec
09-23
在MATLAB中，通常会使用如`precision_recall_curve`这样的函数来计算并绘制PR曲线。这个函数会根据模型的预测概率和真实标签，生成一系列精确率和召回率对，然后用`plot`函数绘制曲线。通过分析这条曲线，我们可以...
IOU和NMS图解（附Python和C++代码）
weixin_44623662的博客
06-29 1058
IOU和NMS学习，代码和推导过程记录。
目标检测算法之常见评价指标的详细计算方法及代码解析
I good vegetable a!
01-07 4981
前言 之前简单介绍过目标检测算法的一些评价标准，地址为为目标检测算法之评价标准和常见数据集盘点。然而这篇文章仅仅只是从概念性的角度来阐述了常见的评价标准如Acc，Precision，Recall，AP等。并没有从源码的角度来分析具体的计算过程，这一篇推文的目的就是结合代码再次详细的解释目标检测算法中的常见评价标准如Precision，Recall，AP，mAP的具体计算过程。 评价指标 由于在上面...
推荐系统中召回率Recall计算方式附代码
CSDN 精品推荐
04-09 1073
Recall（召回率）是指在所有实际有交互的用户 - 物品对中，推荐系统成功预测出的比例。具体来说，设所有有交互的用户 - 物品对为S，推荐系统预测出的用户 - 物品对为T，则Recall的计算公式为：
召回率和精确率（recall and precision）
Rookie1012的博客
03-02 2650
#记性不好写博客以记之 召回率（recall） 公式：Recall = TP /TP+FN 定义：所有的正样本中，我们识别出来的比例。召回率又叫查全率、击中的概率。 精准率（precision） 公式：Precision = TP /TP+FP 定义：所有识别成正样本中，有多少是真正的正样本。精准率又叫查准率、误杀率。 #关于TP、TN、FP、FN中的T、F（True、False）意为样本预测正确...
准确率(Accuracy), 精确率(Precision), 召回率(Recall)和F1-Measure
weixin_34144450的博客
07-22 1万+
yu Code 15 Comments  机器学习(ML),自然语言处理(NLP),信息检索(IR)等领域,评估(Evaluation)是一个必要的 工作,而其评价指标往往有如下几点:准确率(Accuracy),精确率(Precision),召回率(Recall)和F1-Measure。(注： 相对来说，IR 的 ground truth 很多时候是一个 Ordered List, 而不是...
c++运用一维数组简单的统计用户答题的正确率
qq_41814721的博客
09-13 851
#include&lt;iostream&gt; using namespace std; int main (){ const char key[] = {'a','c','b','a','d'};// 定义一个常数组为正确答案 const int NUM_QUES = 5;// 定义问题个数为5 char c; int ques = 0,numCorrect = 0;//ques作为KE...
分类算法中准确率的一些问题
热门推荐
zhao_crystal的博客
07-28 3万+
1.混淆矩阵，精准率和召回率 1.1 为什么要引入混淆矩阵，精准率和召回率 在前面KNN，LogisticRegression等分类算法中，我们都是以分类准确度（预测正确的/总的样本数）来评判算法的好坏，但是对于有偏的数据,分类准确度就不是那么有效了。 比如案例1： 一个癌症预测系统，输入体检信息，可以判断是否有癌症 实际癌症产生的概率为0.1% 我们的系统预测所有的人都不患癌症，即可...
目标检测中的Precision和Recall的作用
06-11
在目标检测中，Precision和Recall是用来评估模型检测性能的两个重要指标。 Precision（精确率）指的是模型检测出来的正样本中，真正为正样本的比例。即： Precision = TP / (TP + FP) 其中，TP表示真正例（即模型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猫猫与橙子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值