0、解析xml文件中的标注信息转化为中心点及宽高并归一化
def load_dataset(path):
dataset = []
# print(path)
print(listdir(path))
for xml_file in glob.glob("{}/*xml".format(path)):
# print(xml_file)
tree = ET.parse(xml_file)
# print('tree')
height = int(tree.findtext("./size/height"))
width = int(tree.findtext("./size/width"))
# print(height)
# print(tree.iter("object"))
for obj in tree.iter("object"):
# print(obj.findtext("bndbox/xmin"))
xmin = int(obj.findtext("bndbox/xmin")) / width
ymin = int(obj.findtext("bndbox/ymin")) / height
xmax = int(obj.findtext("bndbox/xmax")) / width
ymax = int(obj.findtext("bndbox/ymax")) / height
dataset.append([xmax - xmin, ymax - ymin])
return np.array(dataset)
1、k-means
算法思想:
（1）随机选取k个聚类中心（一般在样本集中选取，也可以自己随机选取）;
（2）计算每个样本与k个聚类中心的距离，并将样本归到距离最小的那个类中;
（3）更新中心，计算属于k类的样本的均值作为新的中心。
（4）反复迭代（2）（3）,直到聚类中心不发生变化，后者中心位置误差在阈值范围内，或者达到一定的迭代次数。
import numpy as np
"""K-mean算法的函数"""
def iou(box, clusters):
"""
Calculates the Intersection over Union (IoU) between a box and k clusters.
:param box: tuple or array, shifted to the origin (i. e. width and height)
:param clusters: numpy array of shape (k, 2) where k is the number of clusters
:return: numpy array of shape (k, 0) where k is the number of clusters
"""
# print("box:",box,"cls",clusters)
x = np.minimum(clusters[:, 0], box[0])
y = np.minimum(clusters[:, 1], box[1])
# print(x)
# print(np.count_nonzero(x == 0))
# print(np.count_nonzero(y == 0))
if np.count_nonzero(x == 0) > 0 or np.count_nonzero(y == 0) > 0:
raise ValueError("Box has no area")
intersection = x * y
box_area = box[0] * box[1]
cluster_area = clusters[:, 0] * clusters[:, 1]
iou_ = intersection / (box_area + cluster_area - intersection)
return iou_
def avg_iou(boxes, clusters):
"""
Calculates the average Intersection over Union (IoU) between a numpy array of boxes and k clusters.
:param boxes: numpy array of shape (r, 2), where r is the number of rows
:param clusters: numpy array of shape (k, 2) where k is the number of clusters
:return: average IoU as a single float
"""
return np.mean([np.max(iou(boxes[i], clusters)) for i in range(boxes.shape[0])])
def translate_boxes(boxes):
"""
Translates all the boxes to the origin.
:param boxes: numpy array of shape (r, 4)
:return: numpy array of shape (r, 2)
"""
new_boxes = boxes.copy()
for row in range(new_boxes.shape[0]):
new_boxes[row][2] = np.abs(new_boxes[row][2] - new_boxes[row][0])
new_boxes[row][3] = np.abs(new_boxes[row][3] - new_boxes[row][1])
return np.delete(new_boxes, [0, 1], axis=1)
def kmeans(boxes, k, dist=np.median):
"""
Calculates k-means clustering with the Intersection over Union (IoU) metric.
:param boxes: numpy array of shape (r, 2), where r is the number of rows
:param k: number of clusters
:param dist: distance function
:return: numpy array of shape (k, 2)
"""
rows = boxes.shape[0]
distances = np.empty((rows, k))
last_clusters = np.zeros((rows,))
np.random.seed()
# the Forgy method will fail if the whole array contains the same rows
clusters = boxes[np.random.choice(rows, k, replace=False)]
while True:
for row in range(rows):
# print(row)
# print(boxes[row])
# if boxes[row][0]==0 :
# print('------',row)
# continue
distances[row] = 1 - iou(boxes[row], clusters)
nearest_clusters = np.argmin(distances, axis=1)
if (last_clusters == nearest_clusters).all():
break
for cluster in range(k):
clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)
last_clusters = nearest_clusters
return clusters, last_clusters
2、NMS
在测试和检测过程中经模型得出的所有box进行非极大值抑制：
若只有13*13和26*26两种尺度，N个类，预测共有13*13*3+26*26*3=2535个box
prediction的形式为（2535,5+N），5+N为中心坐标、宽高、置信度及每类预测的概率
①筛选出满足置信度阈值（conf_thres）条件的box
②在从①中筛选出每个box中概率最大的作为该box预测最有可能的类别
③坐标转换：bbox(x, y, w, h)->bbox(x1,y1,x2,y2)
④整理筛选后剩余box的信息（x1,y1,x2,y2,置信度，概率，类别（列号）），统计所有box中不重复的类别
⑤遍历类别，取出每次遍历类别的对应的box（即相同类别的box），
计算这些box的score=置信度*概率，然后对score进行排序，记录排序后原有的box位置（行号）
重新获取已排序后的box
⑥NMS处理（3种方式选择or）：首先以最大score对应的box进行保存，然后计算该box与之后所有box的iou（同一类别两个box）
⑦满足iou>nms_thres（即表明同一位置预测到多个box，我们要剔除，只保留一个），记录该box的序号，暂时剔除这些box（也包括自己），然后再对剩余的box进行⑥⑦操作，最后会获得不同位置（这些位置预测都是同一类）有唯一的box
⑧遍历下一个类即重复⑤⑥⑦即可，最终筛选出不同位置预测出同类或不同类的唯一box（类别可能相同但是位置绝对不能相同这就是非极大值抑制作用）
def non_max_suppression(prediction, conf_thres=0.5, nms_thres=0.4):
"""
非极大值抑制 NMS
Removes detections with lower object confidence score than 'conf_thres'
Non-Maximum Suppression to further filter detections.
Returns detections with shape:
(x1, y1, x2, y2, object_conf, class_score, class_pred)
"""
output = [None for _ in range(len(prediction))]
for image_i, pred in enumerate(prediction):
# Experiment: Prior class size rejection
# x, y, w, h = pred[:, 0], pred[:, 1], pred[:, 2], pred[:, 3]
# a = w * h # area
# ar = w / (h + 1e-16) # aspect ratio
# n = len(w)
# log_w, log_h, log_a, log_ar = torch.log(w), torch.log(h), torch.log(a), torch.log(ar)
# shape_likelihood = np.zeros((n, 60), dtype=np.float32)
# x = np.concatenate((log_w.reshape(-1, 1), log_h.reshape(-1, 1)), 1)
# from scipy.stats import multivariate_normal
# for c in range(60):
# shape_likelihood[:, c] =
# multivariate_normal.pdf(x, mean=mat['class_mu'][c, :2], cov=mat['class_cov'][c, :2, :2])
# Filter out confidence scores below threshold
#函数softmax输出的是所给矩阵的概率分布，获取每个box预测出的最大的概率及对应的列号（实际上是类别序号）
#class_prob 最大值的列号，class_pred最大值
class_prob, class_pred = torch.max(F.softmax(pred[:, 5:], 1), 1)
v = pred[:, 4] > conf_thres#筛选大于置信度阈值的box,并每个box是True或False组成的列表
v = v.nonzero().squeeze()#取出v中True对应的行
if len(v.shape) == 0:
v = v.unsqueeze(0)
pred = pred[v]
class_prob = class_prob[v]
class_pred = class_pred[v]
# If none are remaining => process next image
nP = pred.shape[0]
if not nP:
continue
# From (center x, center y, width, height) to (x1, y1, x2, y2)
pred[:, :4] = xywh2xyxy(pred[:, :4])
# Detections ordered as (x1, y1, x2, y2, obj_conf, class_prob, class_pred)
detections = torch.cat((pred[:, :5], class_prob.float().unsqueeze(1), class_pred.float().unsqueeze(1)), 1)
# Iterate through all predicted classes
unique_labels = detections[:, -1].cpu().unique().to(prediction.device)
nms_style = 'OR' # 'OR' (default), 'AND', 'MERGE' (experimental)
for c in unique_labels:
# Get the detections with class c
dc = detections[detections[:, -1] == c]
# Sort the detections by maximum object confidence
_, conf_sort_index = torch.sort(dc[:, 4] * dc[:, 5], descending=True)
dc = dc[conf_sort_index]#(x1,y1,x2,y2,score)
# Non-maximum suppression
det_max = []
ind = list(range(len(dc)))#
if nms_style == 'OR': # default
while len(ind):
j = ind[0]
det_max.append(dc[j:j + 1]) # save highest conf detection
reject = bbox_iou(dc[j], dc[ind]) > nms_thres #(T or F)
[ind.pop(i) for i in reversed(reject.nonzero())]#剔除相近的box序号包括（与自己的iou）
# while dc.shape[0]: # SLOWER METHOD
# det_max.append(dc[:1]) # save highest conf detection
# if len(dc) == 1: # Stop if we're at the last detection
# break
# iou = bbox_iou(dc[0], dc[1:]) # iou with other boxes
# dc = dc[1:][iou < nms_thres] # remove ious > threshold
# Image Total P R mAP
# 4964 5000 0.629 0.594 0.586
elif nms_style == 'AND': # requires overlap, single boxes erased
while len(dc) > 1:
iou = bbox_iou(dc[0], dc[1:]) # iou with other boxes
if iou.max() > 0.5:
det_max.append(dc[:1])
dc = dc[1:][iou < nms_thres] # remove ious > threshold
elif nms_style == 'MERGE': # weighted mixture box
while len(dc) > 0:
iou = bbox_iou(dc[0], dc[0:]) # iou with other boxes
i = iou > nms_thres
weights = dc[i, 4:5] * dc[i, 5:6]
dc[0, :4] = (weights * dc[i, :4]).sum(0) / weights.sum()
det_max.append(dc[:1])
dc = dc[iou < nms_thres]
# Image Total P R mAP
# 4964 5000 0.633 0.598 0.589 # normal
if len(det_max) > 0:
det_max = torch.cat(det_max)
# Add max detections to outputs
output[image_i] = det_max if output[image_i] is None else torch.cat((output[image_i], det_max))
return output
3、iou
iou=（box1与box2的交集）/(box1与box2的并集)
box1与box2的交集：矩形与矩形交集还是矩形只要获得该矩形的左上右下坐标即可，如下图
def bbox_iou(box1, box2, x1y1x2y2=True):
# Returns the IoU of box1 to box2. box1 is 4, box2 is nx4
box2 = box2.t()
# Get the coordinates of bounding boxes
if x1y1x2y2:
# x1, y1, x2, y2 = box1
b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]
b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]
else:
# x, y, w, h = box1
b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2
b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2
b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2
b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2
# Intersection area
inter_area = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \
(torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0)
# Union Area
union_area = ((b1_x2 - b1_x1) * (b1_y2 - b1_y1) + 1e-16) + \
(b2_x2 - b2_x1) * (b2_y2 - b2_y1) - inter_area
return inter_area / union_area # iou
4、xyxy2xywh
#bbox(x1,y1,x2,y2)->bbox(x, y, w, h)
def xyxy2xywh(x):
y = torch.zeros_like(x) if x.dtype is torch.float32 else np.zeros_like(x)
y[:, 0] = (x[:, 0] + x[:, 2]) / 2
y[:, 1] = (x[:, 1] + x[:, 3]) / 2
y[:, 2] = x[:, 2] - x[:, 0]
y[:, 3] = x[:, 3] - x[:, 1]
return y
5、xywh2xyxy
#bbox(x, y, w, h)->bbox(x1,y1,x2,y2)
def xywh2xyxy(x):
y = torch.zeros_like(x) if x.dtype is torch.float32 else np.zeros_like(x)
y[:, 0] = (x[:, 0] - x[:, 2] / 2)
y[:, 1] = (x[:, 1] - x[:, 3] / 2)
y[:, 2] = (x[:, 0] + x[:, 2] / 2)
y[:, 3] = (x[:, 1] + x[:, 3] / 2)
return y
6、padding-resize
def letterbox(img, height=416, color=(127.5, 127.5, 127.5)): # resize a rectangular image to a padded square
shape = img.shape[:2] # shape = [height, width]
ratio = float(height) / max(shape) # ratio = new/ old
new_shape = (round(shape[1] * ratio), round(shape[0] * ratio))#该方法返回 x 的小数点四舍五入到n个数字
#dw,dh二者有一个为0
dw = (height - new_shape[0]) / 2 # width padding
dh = (height - new_shape[1]) / 2 # height padding
#4个方向同时增广
top, bottom = round(dh - 0.1), round(dh + 0.1)
left, right = round(dw - 0.1), round(dw + 0.1)
img = cv2.resize(img, new_shape, interpolation=cv2.INTER_AREA) # resized, no border
img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # padded square
return img, ratio, dw, dh
7、数据预处理加载
class LoadImagesAndLabels: # for training
def __init__(self, path, batch_size=1, img_size=608, augment=False):
with open(path, 'r') as file:
self.img_files = file.readlines()
self.img_files = [x.replace('\n', '') for x in self.img_files]
#图片所有路径
self.img_files = list(filter(lambda x: len(x) > 0, self.img_files))
#存放标签
self.label_files = [x.replace('images', 'labels').replace('.png', '.txt').replace('.jpg', '.txt')
for x in self.img_files]
self.nF = len(self.img_files) # number of image files
self.nB = math.ceil(self.nF / batch_size) # number of batches
self.batch_size = batch_size
self.img_size = img_size
self.augment = augment
assert self.nF > 0, 'No images found in %s' % path
def __iter__(self):
self.count = -1
self.shuffled_vector = np.random.permutation(self.nF) if self.augment else np.arange(self.nF)
return self
def __next__(self):
self.count += 1
if self.count == self.nB:
raise StopIteration
ia = self.count * self.batch_size #以batch_size为步长的训练集位置
ib = min((self.count + 1) * self.batch_size, self.nF)#以batch_size为步长的标签位置
img_all, labels_all, img_paths, img_shapes = [], [], [], []
for index, files_index in enumerate(range(ia, ib)):
img_path = self.img_files[self.shuffled_vector[files_index]]
label_path = self.label_files[self.shuffled_vector[files_index]]
img = cv2.imread(img_path) # BGR
assert img is not None, 'File Not Found ' + img_path
augment_hsv = True
if self.augment and augment_hsv:
# SV augmentation by 50%
fraction = 0.50
#颜色转换hsv处理后再转换
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
S = img_hsv[:, :, 1].astype(np.float32)
V = img_hsv[:, :, 2].astype(np.float32)
a = (random.random() * 2 - 1) * fraction + 1
S *= a
if a > 1:
np.clip(S, a_min=0, a_max=255, out=S)
a = (random.random() * 2 - 1) * fraction + 1
V *= a
if a > 1:
np.clip(V, a_min=0, a_max=255, out=V)
img_hsv[:, :, 1] = S.astype(np.uint8)
img_hsv[:, :, 2] = V.astype(np.uint8)
cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img)
h, w, _ = img.shape
#调整图像尺寸——>416
img, ratio, padw, padh = letterbox(img, height=self.img_size)
# Load labels
if os.path.isfile(label_path):
labels0 = np.loadtxt(label_path, dtype=np.float32).reshape(-1, 5)
# Normalized xywh to pixel xyxy format
#已经归一化坐标的label中whxy转化为在新尺寸下的非归一化的左上右下坐标
labels = labels0.copy()
#新尺寸/原尺寸 *原尺寸*(归一化的中心坐标-宽高/2)+宽高的补偿
labels[:, 1] = ratio * w * (labels0[:, 1] - labels0[:, 3] / 2) + padw #x1-w/2
labels[:, 2] = ratio * h * (labels0[:, 2] - labels0[:, 4] / 2) + padh#y1-h/2
labels[:, 3] = ratio * w * (labels0[:, 1] + labels0[:, 3] / 2) + padw#x2-w/2
labels[:, 4] = ratio * h * (labels0[:, 2] + labels0[:, 4] / 2) + padh#y2-h/2
else:
labels = np.array([])
# Augment image and labels
if self.augment:
img, labels, M = random_affine(img, labels, degrees=(-5, 5), translate=(0.10, 0.10), scale=(0.90, 1.10))
plotFlag = False
if plotFlag:
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 10)) if index == 0 else None
plt.subplot(4, 4, index + 1).imshow(img[:, :, ::-1])
plt.plot(labels[:, [1, 3, 3, 1, 1]].T, labels[:, [2, 2, 4, 4, 2]].T, '.-')
plt.axis('off')
nL = len(labels)
if nL > 0:
# convert xyxy to xywh
#将新获得的xyxy坐标转化为中心坐标，在除以新图的尺寸 （归一化）
labels[:, 1:5] = xyxy2xywh(labels[:, 1:5].copy()) / self.img_size
if self.augment:
# random left-right flip
#左右旋转
lr_flip = True
if lr_flip & (random.random() > 0.5):
img = np.fliplr(img)
if nL > 0:
labels[:, 1] = 1 - labels[:, 1]
# random up-down flip
#上下旋转
ud_flip = False
if ud_flip & (random.random() > 0.5):
img = np.flipud(img)
if nL > 0:
labels[:, 2] = 1 - labels[:, 2]
if nL > 0:
labels = np.concatenate((np.zeros((nL, 1), dtype='float32') + index, labels), 1)#1维度连接
labels_all.append(labels)
img_all.append(img)
img_paths.append(img_path)
img_shapes.append((h, w))
# Normalize
img_all = np.stack(img_all)[:, :, :, ::-1].transpose(0, 3, 1, 2) # BGR to RGB and cv2 to pytorch
img_all = np.ascontiguousarray(img_all, dtype=np.float32)
img_all /= 255.0
labels_all = torch.from_numpy(np.concatenate(labels_all, 0))
#返回所有图像数据、标签、图像路径、图像尺寸
return torch.from_numpy(img_all), labels_all, img_paths, img_shapes
def __len__(self):
return self.nB # number of batches
8、cfg解析
class Darknet(nn.Module):
"""YOLOv3目标检测模型，实现前向传播"""
def __init__(self, cfg_path, img_size=416): # 模型和参数初始化
super(Darknet, self).__init__()
self.module_defs = parse_model_cfg(cfg_path)
self.module_defs[0]['cfg'] = cfg_path
self.module_defs[0]['height'] = img_size
#获取模型网络结构
self.hyperparams, self.module_list = create_modules(self.module_defs) # 模型构建
self.img_size = img_size
self.loss_names = ['loss', 'xy', 'wh', 'conf', 'cls', 'nT']
self.losses = []
def forward(self, x, var=None): # 前向传播
img_size = x.shape[-1] # 416
layer_outputs = []
output = []
for i, (module_def, module) in enumerate(zip(self.module_defs, self.module_list)):
mtype = module_def['type'] # module_def层信息：Conv、filter、pad... module:层结构
# 'convolutional', 'upsample', 'maxpool'层直接输入层结构
if mtype in ['convolutional', 'upsample', 'maxpool']:
x = module(x)
# 'route' 'shortcut' 'yolo'层单独写的运算
elif mtype == 'route':#路由层主要深度扩充
layer_i = [int(x) for x in module_def['layers'].split(',')]
if len(layer_i) == 1:
x = layer_outputs[layer_i[0]]
else:
x = torch.cat([layer_outputs[i] for i in layer_i], 1)
elif mtype == 'shortcut':#跨层连接：相同纬度相加
layer_i = int(module_def['from'])
x = layer_outputs[-1] + layer_outputs[layer_i]
elif mtype == 'yolo':
x = module[0](x, img_size) # 进入yolo层的前向传播，x:[1,507,85]每行一个bbox信息
output.append(x)
layer_outputs.append(x) # 储存中间层输出
if ONNX_EXPORT:
output = torch.cat(output, 1) # merge the 3 layers 85 x (507, 2028, 8112) to 85 x 10647
return output[5:].t(), output[:4].t() # ONNX scores, boxes
else:
return output if self.training else torch.cat(output, 1) # 整合3个尺度， 85 x (507, 2028, 8112) ——> 85 x 10647
10、损失函数
def compute_loss(p, targets): # predictions, targets
FT = torch.cuda.FloatTensor if p[0].is_cuda else torch.FloatTensor
loss, lxy, lwh, lcls, lconf = FT([0]), FT([0]), FT([0]), FT([0]), FT([0])
txy, twh, tcls, tconf, indices = targets
MSE = nn.MSELoss()#均方误差
CE = nn.CrossEntropyLoss()#二类交叉熵误差
BCE = nn.BCEWithLogitsLoss()#二类交叉熵误差
# Compute losses
# gp = [x.numel() for x in tconf] # grid points
for i, pi0 in enumerate(p): # layer i predictions, i P:两个元组：[4,3,13,13,85]、[4,3,26,26,85]
b, a, gj, gi = indices[i] # 目标第i个尺度的 image, anchor, gridx, gridy
# Compute losses
k = 1 # nT / bs
# 负责预测该物体的anchor的误差：
if len(b) > 0:
pi = pi0[b, a, gj, gi] # 找到perd中负责预测该物体的anchor，[目标数，85]，这个anchor和他的4个坐标+C+80类
lxy += k * MSE(torch.sigmoid(pi[..., 0:2]), txy[i]) # xy:方均根误差
lwh += k * MSE(pi[..., 2:4], twh[i]) # wh: 方均根误差
lcls += (k / 4) * CE(pi[..., 5:], tcls[i]) # 80类分类结果: 交叉熵误差 p*log(q) p:期望1, q:实际置信度
# pos_weight = FT([gp[i] / min(gp) * 4.])
# BCE = nn.BCEWithLogitsLoss(pos_weight=pos_weight)
# 所有的预测都要计算的误差C：pi0（看看tconf格式）
lconf += (k * 64) * BCE(pi0[..., 4], tconf[i]) # 二分类交叉熵，如置信度C=0.8，就计算[0.8,0.2]和[1,0]之间的交叉熵误差
loss = lxy + lwh + lconf + lcls
# Add to dictionary
d = defaultdict(float)
losses = [loss.item(), lxy.item(), lwh.item(), lconf.item(), lcls.item()]
for name, x in zip(['total', 'xy', 'wh', 'conf', 'cls'], losses):
d[name] = x
return loss, d
11、map
def ap_per_class(tp, conf, pred_cls, target_cls):
""" 计算平均精度，给出召回率和精度曲线。
Source: https://github.com/rafaelpadilla/Object-Detection-Metrics.
# Arguments
tp: True positives (list).分类为的正样本，且分对了的 个数
conf: Objectness value from 0-1 (list).边框置信度
pred_cls: Predicted object classes (list).预测类
target_cls: True object classes (list).实际类
# Returns
平均精度。
"""
# 按置信度降序排列
i = np.argsort(-conf)#返回排序原有的索引列表
tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]
# Find unique classes（np.unique：除去重复元素）
#统计出现所有不同类
unique_classes = np.unique(np.concatenate((pred_cls, target_cls), 0))#按维度进行连接
# Create Precision-Recall curve and compute AP for each class
ap, p, r = [], [], []
for c in unique_classes:#在类别为c的情况下
i = pred_cls == c#列表比较,结果为True/False的列表 [t,f,t,t,f,f,f]为True表示在预测中存在该类别有哪些
n_gt = sum(target_cls == c) # 实际对象数
n_p = sum(i) # 预测对象数
if (n_p == 0) and (n_gt == 0):
continue
elif (n_p == 0) or (n_gt == 0):
ap.append(0)
r.append(0)
p.append(0)
else:
# Accumulate FPs and TPs 假设这一类都是识别为人
# False Positives 窗户认作人
# True Positives 人认作了人
#转化为为一堆0,1来判断tp[i]表示预测为c类的实际也为c类 是哪些列：是为1，不是为0
#1-tp[i]表示预测为c类实际不是c类
fpc = np.cumsum(1 - tp[i])#按照列累加。
tpc = np.cumsum(tp[i])#列表
# Recall：分类器识别为人，且确实是人，占所有‘人’ 的比例
recall_curve = tpc / (n_gt + 1e-16)
r.append(tpc[-1] / (n_gt + 1e-16))
# Precision：分类器认为是人，且确实是人，占分类器认为是人的比例
precision_curve = tpc / (tpc + fpc)
p.append(tpc[-1] / (tpc[-1] + fpc[-1]))
# 从R-P曲线得到曲线下面积AP
ap.append(compute_ap(recall_curve, precision_curve))
return np.array(ap), unique_classes.astype('int32'), np.array(r), np.array(p)
![证券从业合格证书什么时候打印？有哪些注意事项？[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)