算法模型的评估与tensorflow版fasterrcnn模型评价代码解析
过拟合与欠拟合
在我们训练一个机器模型之后，往往需要对此模型进行评价，一些术语需要对此进行了解。
过拟合：在训练时我们往往不希望模型对所有的数据都能得到很好的拟合，因为一旦这样往往在新的样本上表现的不一定好。
常见的形式是：训练过程损失函数逐渐收敛的很好，而测试时损失函数很大，并且不易收敛。这也说明这个模型泛化能力很差。
打个比方：平时做题训练时答得都很好，一旦考试就不会，这说明它的泛化性不够好，我们往往希望得到一个泛化性能高的模型。
导致过拟合的常见情况为学习能力过于强大，即把学习率调低一些，或者设置成为动态的学习率。
欠拟合：与过拟合相对应的，训练样本的一般性质没有学到，可以考虑加大学习率。
模型的评估方法
留出法：分配训练集与测试集，比如在目标检测时，提前按照比例分配好训练集与测试集后，根据训练出的模型及进行测试，根据预测出来的框的位置与之前标注时框的位置做一个交并比（交集与并集面积之比）通常认为比值大于0.5认为检测出来，以此来进行检测有着不足，当样本较少时，仅仅0.2的测试集不足以评估出模型的准确率。因此往往需要用到交叉验证法
交叉验证法：把数据集分成10份，
123456789份训练1第0份验证
1234567910份训练第8份验证…以次类推做10折交叉法。
混淆矩阵
错误率：分类错误的样本数占样本总数的比例
精度：分类正确样本数占样本总数的比例
| 正 ------- ------------------------- 负 | |
|---|---|
| 真T | TP---------------------------------TN |
| 假F | FP(误报)--------------------------------FN（漏报） |
查准率（precision)=TP/(TP+FP)
查全率(recall)=TP/(TP+FN)
查准率和查全率是一对矛盾的度量.一般来说，查准率高时，查全率往往偏低;而查全率高时，查准率往往偏低.
几种评价曲线
很多情形我们可根据学习器的预测结果对样例进行排序，排在前面的是学习器认为"最可能 "是正例的样本，排在最后的则是学习器认为"最不可能"是正例的样本。按此顺序逐个把样本作为正例进行预测，则每次可以计算出当前的查全率、 查准率以查准率为纵轴、查全率为横轴作图 ，就得到了查准率- 查全率曲线，简称 P- R线
ROC曲线与AUC
与PR曲线类似，将预测出来的值与阈值比较，大于作为正类，小于阈值作为负类。ROC曲线是另外一种模型评价曲线，它的面积即为AUC。ROC 曲线则是研究学习器泛化性能的有力工具。
该曲线的横轴是‘假正例率FPR’，纵轴是真正例率（TPR）。
FPR=TP/(TN+FP)
TPR=TP/(TP+FN)
参考：周志华机器学习，
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import pickle
import xml.etree.ElementTree as ET
import numpy as np
def parse_rec(filename):####解析已经标注好的XML文件
""" Parse a PASCAL VOC xml file """
tree = ET.parse(filename)
objects = []#定义一个列表，将字典装入列表中
for obj in tree.findall('object'):#Element.findall(): 查找特定元素，并且这些元素是当前元素的直接子元素
obj_struct = {}
obj_struct['name'] = obj.find('name').text
obj_struct['pose'] = obj.find('pose').text
obj_struct['truncated'] = int(obj.find('truncated').text)
obj_struct['difficult'] = int(obj.find('difficult').text)
bbox = obj.find('bndbox')
obj_struct['bbox'] = [int(bbox.find('xmin').text),
int(bbox.find('ymin').text),
int(bbox.find('xmax').text),
int(bbox.find('ymax').text)]
objects.append(obj_struct)#添加相应的键值对即位置坐标
#####jia
#print(objects)##打印一下objects中存储的是标注文件的类别种类以及框的坐标
return objects
def voc_ap(rec, prec, use_07_metric=False):##计算某一类的AP值
""" ap = voc_ap(rec, prec, [use_07_metric])
Compute VOC AP given precision and recall.
If use_07_metric is true, uses the
VOC 07 11 point method (default:False).
计算AP值，若use_07_metric=true,则用11个点采样的方法，将rec从0-1分成11个点，这些点prec值求平均近似表示AP
若use_07_metric=false,则采用更为精确的逐点积分方法
"""
if use_07_metric:
# 11 point metric
ap = 0.
for t in np.arange(0., 1.1, 0.1):
if np.sum(rec >= t) == 0:
p = 0
else:
p = np.max(prec[rec >= t])
ap = ap + p / 11.
else:
# correct AP calculation
# first append sentinel values at the end
mrec = np.concatenate(([0.], rec, [1.]))
mpre = np.concatenate(([0.], prec, [0.]))
# compute the precision envelope
for i in range(mpre.size - 1, 0, -1):
mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
# to calculate area under PR curve, look for points
# where X axis (recall) changes value
i = np.where(mrec[1:] != mrec[:-1])[0]
# and sum (\Delta recall) * prec
ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
return ap
#####评价部分，也是核心部分计算模型的查准率和查全率
def voc_eval(detpath,##生成检测文件路径
annopath,###标注路径
imagesetfile,##train，test文本文件路径
classname,##类别名称
cachedir,####cachedir中存储的是test文本中的相对应的xml文件的内容只不过存储形式为pkl
ovthresh=0.5,
use_07_metric=False):
"""rec, prec, ap = voc_eval(detpath,
annopath,
imagesetfile,
classname,
[ovthresh],
[use_07_metric])
Top level function that does the PASCAL VOC evaluation.
detpath: Path to detections
detpath.format(classname) should produce the detection results file.
annopath: Path to annotations
annopath.format(imagename) should be the xml annotations file.
该文件格式：imagename1 confidence xmin ymin xmax ymax (图像1的第一个结果)
imagename1 confidence xmin ymin xmax ymax (图像1的第二个结果)
imagename1 confidence xmin ymin xmax ymax (图像2的第一个结果)
每个结果占一行，检测到多少个BBox就有多少行，这里假设有20000个检测结果
imagesetfile: Text file containing the list of images, one image per line.
classname: Category name (duh)
cachedir: Directory for caching the annotations
[ovthresh]: Overlap threshold (default = 0.5)
[use_07_metric]: Whether to use VOC07's 11 point AP computation
(default False)
"""
# assumes detections are in detpath.format(classname)
# assumes annotations are in annopath.format(imagename)
# assumes imagesetfile is a text file with each line an image name
# cachedir caches the annotations in a pickle file
# first load gt
#加
if not os.path.isdir(cachedir):
os.mkdir(cachedir)
#jia
filename=cachedir+'/annots.pkl'
os.remove(filename)####这里是每次运行前需要删除的前一次的pkl文件，不然每次需要手动删除如果第一次运行可以注释掉
####
cachefile = os.path.join(cachedir, 'annots.pkl')
# read list of images
with open(imagesetfile, 'r') as f:###打开测试文件
lines = f.readlines()
imagenames = [x.strip() for x in lines]#逐行读取列表
####加
#print(imagenames)#打印一下图片序号imagenames是一个列表中存储的是test文本文件中的图片序号
#####
if not os.path.isfile(cachefile):
# load annots
recs = {}
for i, imagename in enumerate(imagenames):
recs[imagename] = parse_rec(annopath.format(imagename))###将预测图片序号与之前objects列表分别作为键值加入到rec字典中
if i % 100 == 0:
print('Reading annotation for {:d}/{:d}'.format(
i + 1, len(imagenames)))
# save
####print(recs)###不明白就多打印，打印一下
print('Saving cached annotations to {:s}'.format(cachefile))
with open(cachefile, 'wb') as f:
pickle.dump(recs, f)####将recs字典存储pkl中
else:
# load
with open(cachefile, 'rb') as f:
try:
recs = pickle.load(f)
except:
recs = pickle.load(f, encoding='bytes')
# extract gt objects for this class按类别获取标注文件，recall和precision都是针对不同类别而言的，AP也是对各个类别分别算的
class_recs = {}#当前类别的标注
npos = 0#npos标记的目标数量
for imagename in imagenames:#####开始在列表中读取测试图片
R = [obj for obj in recs[imagename] if obj['name'] == classname]#如果rec中的类别为指定类别才进行抽取
print('R是：',R)####R代表存取的某一类坐标数据，形式为列表
bbox = np.array([x['bbox'] for x in R]) #在R中抽取bbox
difficult = np.array([x['difficult'] for x in R]).astype(np.bool)#如果数据集没有difficult,所有项都是0
det = [False] * len(R)#len(R)就是当前类别的得到目标个数，det表示是否检测到，初始化为false。
npos = npos + sum(~difficult) #自增，非difficult样本数量，如果数据集没有difficult，npos数量就是gt数量。
class_recs[imagename] = {'bbox': bbox,
'difficult': difficult,
'det': det}
print('class_recs是',class_recs)
# read dets
detfile = detpath.format(classname)#读取检测结果
print('detdile是：',detfile)
#detdile是： D:\research\ce_Faster-RCNN-TensorFlow-Python3-master\data\VOCdevkit2007\results\VOC2007\Main\comp4_det_test_(类).txt
with open(detfile, 'r') as f:
lines = f.readlines()
splitlines = [x.strip().split(' ') for x in lines] #假设检测结果有20000个，则splitlines长度20000
#print('splitlines是',splitlines)#经打印可得出splitlines是一个列表嵌入列表，里面的每一个列表元素为一个可能的结果名称+置信度+坐标
image_ids = [x[0] for x in splitlines]#将图片名称抽取出来
confidence = np.array([float(x[1]) for x in splitlines])#将置信度抽取出来
BB = np.array([[float(z) for z in x[2:]] for x in splitlines])#将位置坐标抽取出来
'''
sorted_ind = np.argsort(-confidence) # 对confidence的index根据值大小进行降序排列。
sorted_scores = np.sort(-confidence) # 降序排列。
BB = BB[sorted_ind, :] # 重排bbox，由大概率到小概率。
image_ids = [image_ids[x] for x in sorted_ind]
'''
nd = len(image_ids)#nd是某一类的图片名称的个数，一个图片有多个缺陷时重复计算。
tp = np.zeros(nd)###真正值,是个列表，且列表中元素的个数等于nd值
fp = np.zeros(nd)###假正值
print('nd是{},tp是{},fp是{}'.format(nd,tp,fp))
if BB.shape[0] > 0:
# sort by confidence
sorted_ind = np.argsort(-confidence)# 对confidence的index根据值大小进行降序排列。
sorted_scores = np.sort(-confidence)
BB = BB[sorted_ind, :]# 重排bbox，由大概率到小概率。
image_ids = [image_ids[x] for x in sorted_ind]
# go down dets and mark TPs and FPs
for d in range(nd):#遍历所有检测结果，因为已经排序，所以这里是从置信度最高到最低遍历
R = class_recs[image_ids[d]]#当前检测结果所在图像的所有同类别gt
bb = BB[d, :].astype(float) #当前检测结果bbox坐标
ovmax = -np.inf
BBGT = R['bbox'].astype(float) #当前检测结果所在图像的所有同类别gt的bbox坐标
if BBGT.size > 0:#计算当前检测结果，与该检测结果所在图像的标注重合率
# compute overlaps
# intersection
ixmin = np.maximum(BBGT[:, 0], bb[0])
iymin = np.maximum(BBGT[:, 1], bb[1])
ixmax = np.minimum(BBGT[:, 2], bb[2])
iymax = np.minimum(BBGT[:, 3], bb[3])
iw = np.maximum(ixmax - ixmin + 1., 0.)
ih = np.maximum(iymax - iymin + 1., 0.)
inters = iw * ih#标注框面积
# union
uni = ((bb[2] - bb[0] + 1.) * (bb[3] - bb[1] + 1.) +
(BBGT[:, 2] - BBGT[:, 0] + 1.) *
(BBGT[:, 3] - BBGT[:, 1] + 1.) - inters)#预测框面积
overlaps = inters / uni
ovmax = np.max(overlaps)
jmax = np.argmax(overlaps)
if ovmax > ovthresh:
if not R['difficult'][jmax]:
if not R['det'][jmax]:
tp[d] = 1.#正检数目+1
R['det'][jmax] = 1#该gt被置为已检测到，下一次若还有另一个检测结果与之重合率满足阈值，则不能认为多检测到一个目
else:
fp[d] = 1.#相反，认为检测到一个虚警
else:
fp[d] = 1.#相反，认为检测到一个虚警
# compute precision recall
fp = np.cumsum(fp)#积分图，在当前节点前的虚警数量，fp长度
tp = np.cumsum(tp)#在当前节点前的正检数量
print('tp:{},fp:{}'.format(tp,fp))
rec = tp / float(npos)
# avoid divide by zero in case the first detection matches a difficult
# ground truth
prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)
ap = voc_ap(rec, prec, use_07_metric)
return rec, prec, ap
参考：博客