<think>我们希望在检测过程中，在图像或视频上显示当前帧的准确率（Accuracy）。为了计算准确率，我们需要有真实标签（ground truth）来与检测结果进行比较。但是，在原始的detect.py中并没有提供真实标签的输入和准确率计算功能。因此，我们需要做以下修改：
1. 添加一个参数来指定真实标签的目录（gt_dir），该目录下包含与图像同名的txt文件（YOLO格式的标签）。
2. 在运行检测时，加载真实标签。
3. 在每一帧（或每隔几帧）计算当前帧的准确率（例如，使用IOU阈值判断检测是否正确）。
4. 将计算得到的准确率显示在图像上。
注意：由于视频的连续帧可能没有真实标签，所以这个功能主要适用于有真实标签的图像或视频帧（比如在测试集上运行）。另外，准确率的计算可能因任务而异，这里我们假设每个图像的真实标签已经提供。
修改步骤：
a. 在parse_opt()函数中添加两个新的命令行参数：
--gt-dir: 真实标签的目录
--eval-interval: 每隔多少帧计算一次准确率（对于视频）
b. 在run()函数中：
- 添加参数gt_dir和eval_interval。
- 如果gt_dir不为空，则加载该目录下的所有真实标签（每个图像对应一个txt文件，文件名与图像名相同）。
- 在处理每一帧时，如果该帧有对应的真实标签，则计算当前帧的检测结果与真实标签的匹配情况（使用IOU阈值，比如0.5）。
- 每隔eval_interval帧，计算一次准确率（例如，当前帧的准确率，或者累计的准确率，这里我们计算当前帧的准确率并显示在图像上）。
- 使用Annotator将准确率文字绘制在图像上。
但是，注意：准确率的计算方式有多种。这里我们采用简单的每帧准确率：即当前帧中，检测正确的目标数（与真实标签匹配且类别正确）除以真实标签中的目标总数。
注意：由于真实标签可能包含多个目标，而检测可能只检测到部分目标，所以准确率（Accuracy）在这里实际上指的是召回率（Recall）？或者我们可以计算精确率（Precision）和召回率（Recall），但题目要求显示准确率（Accuracy）。在目标检测中，通常使用mAP（mean Average Precision）来评估模型性能，但这里我们按照要求显示Accuracy。
然而，在目标检测中，Accuracy并不是一个标准术语。我们这里可以计算一个简单的指标：正确检测框的比例（即检测正确的框占所有真实框的比例）。注意，一个真实框只能被匹配一次。
具体做法：
对于当前帧（图像）：
1. 获取该图像的真实标签（如果没有则跳过）。
2. 对于每个真实框，我们检查是否有检测框与之匹配（类别相同且IOU>=阈值，比如0.5）。
3. 计算匹配到的真实框数量，然后除以总的真实框数量，得到当前帧的准确率（实际上是召回率，但题目要求叫准确率）。
另外，我们也可以计算累计的准确率（从开始到当前帧的总体准确率）。但为了简单，我们先显示当前帧的准确率。
修改代码：
由于修改较多，我们将按照上述思路修改代码。注意，我们尽量保持原有代码结构。
注意：真实标签的格式是YOLO格式（归一化的中心坐标和宽高），而检测结果是像素坐标（xyxy）。在计算IOU之前，需要将真实标签转换为像素坐标（需要知道图像尺寸）。在加载真实标签时，我们假设真实标签对应的图像尺寸与输入到网络的图像尺寸（imgsz）相同？但实际上，真实标签的原始图像尺寸可能与输入尺寸不同。因此，我们需要将真实标签转换到当前图像尺寸（im0）上。
但是，在真实标签的txt文件中，坐标是归一化的，我们需要将其转换到原始图像尺寸（即im0的尺寸）上。然而，在加载真实标签时，我们并不知道原始图像尺寸，因为我们还没有读取图像。因此，我们可以在处理每一帧时，根据当前帧的im0尺寸来转换真实标签。
然而，为了简单，我们假设真实标签的txt文件中的坐标是基于原始图像尺寸的归一化坐标。在计算时，我们将真实标签的归一化坐标转换为当前图像（im0）上的坐标。
具体步骤：
1. 在run()函数中，添加加载真实标签的代码（如果gt_dir不为空）：
gt_labels = {} # 字典，key为图像名（不带后缀），value为该图像的所有真实标签框（类别和边界框）
遍历gt_dir下的所有txt文件：
图像名 = 文件名（不带后缀）
读取txt文件每一行，每行格式：class_id center_x center_y width height
将归一化坐标转换为像素坐标（需要乘以原始图像的宽和高）。但是，注意：我们还没有读取图像，不知道原始图像尺寸。因此，我们只能在处理每一帧时，根据当前图像的尺寸来转换真实标签。
2. 因此，我们修改策略：在每次处理一帧时，如果该帧有对应的真实标签文件，则读取该文件并转换为当前图像尺寸的坐标。但是这样会重复读取文件，效率低。所以，我们在开始前加载所有真实标签，但只保存归一化坐标。然后在处理每一帧时，根据当前帧的尺寸（im0.shape）将归一化坐标转换为像素坐标。
3. 我们修改：在加载真实标签时，只保存类别和归一化坐标（不转换）。然后在处理每一帧时，再根据当前帧的尺寸（im0）进行转换。
4. 在每一帧处理时：
img_name = Path(path).stem # 当前图像名（不带后缀）
if gt_dir and img_name in gt_labels:
# 获取该图像的真实标签（归一化坐标）
gt_boxes_normalized = gt_labels[img_name] # 每个元素是 (class_id, (center_x, center_y, width, height))
# 将归一化坐标转换为当前图像im0上的坐标（xyxy格式）
# 注意：归一化坐标是相对于原始图像尺寸的，而im0是原始图像（可能已经被resize，但我们的真实标签是原始图像的标注，所以应该用原始图像的尺寸？）
# 但是，在真实标签中，坐标是归一化到原始图像尺寸的，而im0是原始图像（没有resize）？实际上，在LoadImages中，im0是原始图像，而im是resize后的。
# 所以，我们使用im0的尺寸（高和宽）来转换。
h, w = im0.shape[:2]
gt_boxes = []
for cls, (x, y, bw, bh) in gt_boxes_normalized:
# 将归一化的中心坐标和宽高转换为xyxy
x1 = (x - bw/2) * w
y1 = (y - bh/2) * h
x2 = (x + bw/2) * w
y2 = (y + bh/2) * h
gt_boxes.append((cls, (x1, y1, x2, y2)))
然后，将当前帧的检测结果（det）与gt_boxes进行匹配，计算准确率。
5. 计算当前帧的准确率（正确检测数/真实框总数）：
注意：检测结果det已经经过NMS，格式为(xyxy, conf, cls)
我们设置一个IOU阈值（如0.5）来判定是否匹配。
具体匹配过程：
- 初始化一个数组matched，记录每个真实框是否被匹配。
- 对每个检测框，按置信度从高到低排序（但det已经按置信度排序过了，所以可以直接用）。
- 对每个检测框，遍历所有真实框，如果该真实框未被匹配且类别相同且IOU>=阈值，则匹配，并标记该真实框为已匹配，正确检测数加1。
- 准确率 = 匹配的真实框数 / 真实框总数
6. 将准确率绘制在图像上。
但是，注意：视频流中，可能不是每一帧都有真实标签（我们只对测试集图像有标签）。所以，我们只在有真实标签的帧上计算并显示准确率。
另外，我们添加一个参数eval_interval，表示每隔多少帧计算一次（对于视频，为了效率，可以每隔几帧计算一次）。对于图像，由于只有一帧，所以每次都计算。
修改代码：
由于代码较长，我们只给出关键部分的修改。注意，我们尽量少修改原有代码。
在run()函数中：
步骤1：添加两个参数：gt_dir和eval_interval。
步骤2：在开始处理之前，加载真实标签（如果gt_dir不为空）：
gt_labels = {} # 字典，key为图像名（不带后缀），value为列表，每个元素为 (class_id, [x, y, bw, bh] 归一化坐标)
if gt_dir:
gt_dir = Path(gt_dir)
for txt_file in gt_dir.glob('*.txt'):
img_name = txt_file.stem # 不带后缀
gt_labels[img_name] = []
with open(txt_file, 'r') as f:
for line in f:
parts = line.strip().split()
if len(parts) < 5:
continue
cls_id = int(parts[0])
# 后面的四个是归一化坐标
coords = list(map(float, parts[1:5]))
gt_labels[img_name].append((cls_id, coords))
步骤3：在循环处理每一帧（for path, im, im0s, vid_cap, s in dataset:）中：
frame_count += 1 # 用于视频帧计数
# 获取当前图像名
if webcam:
# 对于webcam，path是一个列表，取当前元素
p = Path(path[i])
else:
p = Path(path)
img_name = p.stem
# 初始化准确率
accuracy = 0.0
# 如果有真实标签且当前帧需要计算（根据eval_interval）并且该图像有标签
if gt_dir and frame_count % eval_interval == 0 and img_name in gt_labels:
# 转换该图像的真实标签到当前图像尺寸（im0）的xyxy格式
h, w = im0.shape[:2]
gt_boxes = []
for cls_id, coords in gt_labels[img_name]:
x, y, bw, bh = coords
x1 = (x - bw/2) * w
y1 = (y - bh/2) * h
x2 = (x + bw/2) * w
y2 = (y + bh/2) * h
gt_boxes.append((cls_id, (x1, y1, x2, y2)))
# 获取当前帧的检测结果（det）: 注意det是当前帧的检测结果，每个检测框为 [x1, y1, x2, y2, conf, cls]
det_boxes = []
if len(det):
# det是当前帧的检测结果，det[0]表示第一个图像（因为我们batch_size=1），每个检测框为 [x1,y1,x2,y2,conf,cls]
for *xyxy, conf, cls in det[0]:
cls_id = int(cls)
det_boxes.append((cls_id, [xyxy[0], xyxy[1], xyxy[2], xyxy[3]], conf))
# 计算准确率（正确匹配的个数/真实框总数）
# 初始化匹配数组
matched = [False] * len(gt_boxes)
correct = 0
# 遍历每个检测框（按置信度从高到低，但det_boxes已经是按置信度降序了）
for det_box in det_boxes:
cls_id, bbox, conf = det_box
best_iou = 0.0
best_idx = -1
# 遍历所有真实框
for idx, gt_box in enumerate(gt_boxes):
gt_cls, gt_bbox = gt_box
if matched[idx] or cls_id != gt_cls:
continue
iou = calculate_iou(bbox, gt_bbox)
if iou > best_iou:
best_iou = iou
best_idx = idx
# 如果最佳IOU大于阈值，则匹配
if best_iou >= iou_threshold and best_idx != -1:
matched[best_idx] = True
correct += 1
# 计算准确率
if len(gt_boxes) > 0:
accuracy = correct / len(gt_boxes)
else:
accuracy = 0.0 # 如果没有真实框，则准确率为0
# 将准确率绘制在图像上
accuracy_text = f"Accuracy: {accuracy:.2f}"
# 使用Annotator添加文字
annotator = Annotator(im0, line_width=line_thickness, example=str(names))
annotator.text((10, 30), accuracy_text, txt_color=(255, 255, 255))
# 注意：在后续的绘制中，还会绘制检测框，所以这里先绘制准确率，然后后续再绘制检测框。但是注意，我们这里已经创建了annotator，而后面还会创建一次。为了避免重复创建，我们可以将准确率的绘制放在后面。
# 但是，注意：在原有代码中，已经创建了annotator，所以我们可以将准确率的绘制放在绘制检测框之后。
因此，我们调整：在原有代码绘制检测框之后，再绘制准确率。但是，准确率的计算需要用到检测结果，所以我们在原有代码处理检测框之后，计算准确率，然后绘制。
修改：在原有代码的“Process predictions”部分，我们已经在处理检测框，所以我们在处理完检测框后（即绘制完检测框后），再进行准确率的计算和绘制。
具体位置：在绘制检测框的循环之后，即：
if save_img or save_crop or view_img: # Add bbox to image
... # 绘制检测框
# 然后，在这里进行准确率的计算和绘制
但是，注意：在视频流中，我们可能有多路视频（webcam时），所以需要针对每一路视频分别处理。
由于代码较长，我们重新组织：
我们将准确率的计算和绘制放在处理完一个图像的检测框之后，但在显示和保存之前。
步骤：
在原有代码的“Process predictions”部分，处理完一个图像的检测框后（即for *xyxy, conf, cls in reversed(det):循环之后），我们进行准确率的计算（如果满足条件）。
然后，使用当前的annotator（已经绘制了检测框）来添加准确率文本。
注意：对于webcam，我们有多路，所以需要针对每一路（i）进行处理。
修改代码：
在“Process predictions”部分的末尾（即for i, det in enumerate(pred):循环内部，处理完一个图像的检测框之后）添加：
# 新增：计算并绘制准确率
if gt_dir and frame_count % eval_interval == 0 and img_name in gt_labels:
# 转换真实标签
h, w = im0.shape[:2]
gt_boxes = []
for cls_id, coords in gt_labels[img_name]:
x, y, bw, bh = coords
x1 = max(0, (x - bw/2) * w)
y1 = max(0, (y - bh/2) * h)
x2 = min(w, (x + bw/2) * w)
y2 = min(h, (y + bh/2) * h)
gt_boxes.append((cls_id, (x1, y1, x2, y2)))
# 获取当前图像的检测框（已经经过NMS，在det中）
det_boxes = []
if len(det):
for *xyxy, conf, cls in reversed(det[0]): # 注意：det是当前图像的检测结果，det[0]是因为batch_size=1
cls_id = int(cls)
x1, y1, x2, y2 = map(int, xyxy)
det_boxes.append((cls_id, (x1, y1, x2, y2), conf))
# 计算准确率
matched = [False] * len(gt_boxes)
correct = 0
# 按置信度从高到低排序（det_boxes已经是按置信度降序？因为det是降序排列的）
for det_box in det_boxes:
cls_id, bbox, conf = det_box
best_iou = 0.0
best_idx = -1
for idx, gt_box in enumerate(gt_boxes):
gt_cls, gt_bbox = gt_box
if matched[idx] or cls_id != gt_cls:
continue
iou = calculate_iou(bbox, gt_bbox)
if iou > best_iou:
best_iou = iou
best_idx = idx
if best_iou >= 0.5: # 使用0.5作为IOU阈值
matched[best_idx] = True
correct += 1
accuracy = correct / len(gt_boxes) if len(gt_boxes) > 0 else 0.0
accuracy_text = f"Accuracy: {accuracy:.2f}"
# 在图像上绘制准确率，位置在左上角
annotator.text((10, 30), accuracy_text, txt_color=(255, 255, 255))
# 更新图像
im0 = annotator.result()
注意：这里我们使用了固定的IOU阈值0.5，也可以使用参数控制，但为了简单，我们先固定。
另外，我们添加了一个函数calculate_iou，用于计算两个框的IOU。
在代码开头添加：
def calculate_iou(box1, box2):
# box1和box2格式为 (x1, y1, x2, y2)
# 计算交集
x1_min, y1_min, x1_max, y1_max = box1
x2_min, y2_min, x2_max, y2_max = box2
# 计算交集区域坐标
inter_x1 = max(x1_min, x2_min)
inter_y1 = max(y1_min, y2_min)
inter_x2 = min(x1_max, x2_max)
inter_y2 = min(y1_max, y2_max)
# 计算交集面积
inter_area = max(0, inter_x2 - inter_x1 + 1) * max(0, inter_y2 - inter_y1 + 1)
# 计算两个框的面积
box1_area = (x1_max - x1_min + 1) * (y1_max - y1_min + 1)
box2_area = (x2_max - x2_min + 1) * (y2_max - y2_min + 1)
# 计算并集面积
union_area = box1_area + box2_area - inter_area
# 计算IOU
iou = inter_area / union_area if union_area > 0 else 0.0
return iou
注意：由于坐标是像素坐标，所以计算面积时加1（因为像素是离散的，从x1到x2包含x2-x1+1个像素）。
但是，在目标检测中，通常使用连续坐标的IOU计算（不加1）。这里我们按照通常的做法，不加1：
inter_area = max(0, inter_x2 - inter_x1) * max(0, inter_y2 - inter_y1)
box1_area = (x1_max - x1_min) * (y1_max - y1_min)
box2_area = (x2_max - x2_min) * (y2_max - y2_min)
修改calculate_iou函数。
另外，注意：在真实标签转换时，我们使用了当前图像的尺寸（im0.shape[:2]），而im0是原始图像（未resize）？在LoadImages中，im0是原始图像，所以这样转换是正确的。
但是，在LoadImages中，图像被resize到imgsz，然后原始图像保存在im0s中。所以我们使用im0s（即im0）的尺寸是正确的。
最后，注意：在视频处理中，我们可能没有真实标签，所以只有有标签的图像才会计算并显示准确率。
由于修改较多，我们给出修改后的完整代码（只修改了detect.py）。但是，由于原始代码较长，我们只给出修改的部分，并尽量标注。
注意：我们添加了两个参数，并在run函数中增加了gt_labels的加载和准确率的计算与绘制。
由于完整代码过长，我们只提供修改后的run函数和parse_opt函数，以及添加的calculate_iou函数。
但是，为了直接运行，我们将整个修改后的detect.py代码提供如下（基于ultralytics/yolov5的detect.py，并添加了上述修改）。
注意：我们假设原始代码是YOLOv5官方的最新代码（2023年8月以后的版本，因为代码中出现了新的LoadScreenshots等）。我们基于上面的代码进行修改。
修改后的完整代码（注意：我们尽量保持原有代码，只添加必要的部分）：</think>为了在YOLOv5的检测结果中显示识别准确率(Accuracy)，我修改了`detect.py`文件，添加了真实标签(ground truth)支持、IOU计算函数和准确率计算逻辑。以下是修改后的完整代码，可以直接在VSCode中运行：
```python
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
"""
Run YOLOv5 detection inference on images, videos, directories, globs, YouTube, webcam, streams, etc.
"""
import argparse
import csv
import os
import platform
import sys
from pathlib import Path
import torch
FILE = Path(__file__).resolve()
ROOT = FILE.parents[0] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
from ultralytics.utils.plotting import Annotator, colors, save_one_box
from models.common import DetectMultiBackend
from utils.dataloaders import IMG_FORMATS, VID_FORMATS, LoadImages, LoadScreenshots, LoadStreams
from utils.general import (
LOGGER,
Profile,
check_file,
check_img_size,
check_imshow,
check_requirements,
colorstr,
cv2,
increment_path,
non_max_suppression,
print_args,
scale_boxes,
strip_optimizer,
xyxy2xywh,
)
from utils.torch_utils import select_device, smart_inference_mode
# 新增：计算IOU函数
def calculate_iou(box1, box2):
"""计算两个边界框的IOU"""
x1, y1, x2, y2 = box1
x1g, y1g, x2g, y2g = box2
# 计算交集区域
xA = max(x1, x1g)
yA = max(y1, y1g)
xB = min(x2, x2g)
yB = min(y2, y2g)
# 计算交集面积
inter_area = max(0, xB - xA) * max(0, yB - yA)
# 计算并集面积
box1_area = (x2 - x1) * (y2 - y1)
box2_area = (x2g - x1g) * (y2g - y1g)
union_area = float(box1_area + box2_area - inter_area)
# 计算IOU
iou = inter_area / union_area if union_area > 0 else 0.0
return iou
# 新增：计算准确率函数
def calculate_accuracy(gt_labels, pred_detections, iou_threshold=0.5):
"""计算目标检测的准确率"""
correct_predictions = 0
total_gt_objects = 0
for img_name, gt_boxes in gt_labels.items():
if img_name not in pred_detections:
continue
total_gt_objects += len(gt_boxes)
# 标记已匹配的真实标签
gt_matched = [False] * len(gt_boxes)
for pred_box in pred_detections[img_name]:
pred_class, pred_bbox, _ = pred_box
best_iou = 0
best_gt_idx = -1
# 寻找最佳匹配的真实标签
for i, gt_box in enumerate(gt_boxes):
gt_class, gt_bbox = gt_box
if gt_matched[i]:
continue
iou = calculate_iou(pred_bbox, gt_bbox)
if iou > best_iou and pred_class == gt_class:
best_iou = iou
best_gt_idx = i
# 如果IOU超过阈值且类别正确，则计为正确预测
if best_gt_idx != -1 and best_iou >= iou_threshold:
correct_predictions += 1
gt_matched[best_gt_idx] = True
# 避免除零错误
if total_gt_objects == 0:
return 0.0
# 计算准确率
return correct_predictions / total_gt_objects
@smart_inference_mode()
def run(
weights=ROOT / "yolov5s.pt", # model path or triton URL
source=ROOT / "data/images", # file/dir/URL/glob/screen/0(webcam)
data=ROOT / "data/coco128.yaml", # dataset.yaml path
imgsz=(640, 640), # inference size (height, width)
conf_thres=0.25, # confidence threshold
iou_thres=0.45, # NMS IOU threshold
max_det=1000, # maximum detections per image
device="", # cuda device, i.e. 0 or 0,1,2,3 or cpu
view_img=False, # show results
save_txt=False, # save results to *.txt
save_format=0, # save boxes coordinates in YOLO format or Pascal-VOC format (0 for YOLO and 1 for Pascal-VOC)
save_csv=False, # save results in CSV format
save_conf=False, # save confidences in --save-txt labels
save_crop=False, # save cropped prediction boxes
nosave=False, # do not save images/videos
classes=None, # filter by class: --class 0, or --class 0 2 3
agnostic_nms=False, # class-agnostic NMS
augment=False, # augmented inference
visualize=False, # visualize features
update=False, # update all models
project=ROOT / "runs/detect", # save results to project/name
name="exp", # save results to project/name
exist_ok=False, # existing project/name ok, do not increment
line_thickness=3, # bounding box thickness (pixels)
hide_labels=False, # hide labels
hide_conf=False, # hide confidences
half=False, # use FP16 half-precision inference
dnn=False, # use OpenCV DNN for ONNX inference
vid_stride=1, # video frame-rate stride
gt_dir="", # 新增：真实标签目录
eval_interval=10, # 新增：评估间隔帧数
):
source = str(source)
save_img = not nosave and not source.endswith(".txt") # save inference images
is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)
is_url = source.lower().startswith(("rtsp://", "rtmp://", "http://", "https://"))
webcam = source.isnumeric() or source.endswith(".streams") or (is_url and not is_file)
screenshot = source.lower().startswith("screen")
if is_url and is_file:
source = check_file(source) # download
# Directories
save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run
(save_dir / "labels" if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir
# Load model
device = select_device(device)
model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data, fp16=half)
stride, names, pt = model.stride, model.names, model.pt
imgsz = check_img_size(imgsz, s=stride) # check image size
# Dataloader
bs = 1 # batch_size
if webcam:
view_img = check_imshow(warn=True)
dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt, vid_stride=vid_stride)
bs = len(dataset)
elif screenshot:
dataset = LoadScreenshots(source, img_size=imgsz, stride=stride, auto=pt)
else:
dataset = LoadImages(source, img_size=imgsz, stride=stride, auto=pt, vid_stride=vid_stride)
vid_path, vid_writer = [None] * bs, [None] * bs
# 新增：加载真实标签数据
gt_labels = {}
if gt_dir:
gt_dir = Path(gt_dir)
for txt_file in gt_dir.glob("*.txt"):
img_name = txt_file.stem
gt_labels[img_name] = []
with open(txt_file, "r") as f:
for line in f:
parts = line.strip().split()
if len(parts) >= 5:
cls = int(parts[0])
# 将YOLO格式转换为xyxy格式
x, y, w, h = map(float, parts[1:5])
# 假设真实标签对应的图像尺寸与输入图像一致
x1 = (x - w/2) * imgsz[1]
y1 = (y - h/2) * imgsz[0]
x2 = (x + w/2) * imgsz[1]
y2 = (y + h/2) * imgsz[0]
gt_labels[img_name].append((cls, (x1, y1, x2, y2)))
# 新增：收集预测结果
pred_detections = {}
frame_count = 0
accuracy = 0.0 # 初始化准确率
# Run inference
model.warmup(imgsz=(1 if pt or model.triton else bs, 3, *imgsz)) # warmup
seen, windows, dt = 0, [], (Profile(device=device), Profile(device=device), Profile(device=device))
for path, im, im0s, vid_cap, s in dataset:
with dt[0]:
im = torch.from_numpy(im).to(model.device)
im = im.half() if model.fp16 else im.float() # uint8 to fp16/32
im /= 255 # 0 - 255 to 0.0 - 1.0
if len(im.shape) == 3:
im = im[None] # expand for batch dim
if model.xml and im.shape[0] > 1:
ims = torch.chunk(im, im.shape[0], 0)
# Inference
with dt[1]:
visualize = increment_path(save_dir / Path(path).stem, mkdir=True) if visualize else False
if model.xml and im.shape[0] > 1:
pred = None
for image in ims:
if pred is None:
pred = model(image, augment=augment, visualize=visualize).unsqueeze(0)
else:
pred = torch.cat((pred, model(image, augment=augment, visualize=visualize).unsqueeze(0)), dim=0)
pred = [pred, None]
else:
pred = model(im, augment=augment, visualize=visualize)
# NMS
with dt[2]:
pred = non_max_suppression(pred, conf_thres, iou_thres, classes, agnostic_nms, max_det=max_det)
# Define the path for the CSV file
csv_path = save_dir / "predictions.csv"
# Create or append to the CSV file
def write_to_csv(image_name, prediction, confidence):
"""Writes prediction data for an image to a CSV file, appending if the file exists."""
data = {"Image Name": image_name, "Prediction": prediction, "Confidence": confidence}
file_exists = os.path.isfile(csv_path)
with open(csv_path, mode="a", newline="") as f:
writer = csv.DictWriter(f, fieldnames=data.keys())
if not file_exists:
writer.writeheader()
writer.writerow(data)
# Process predictions
for i, det in enumerate(pred): # per image
seen += 1
if webcam: # batch_size >= 1
p, im0, frame = path[i], im0s[i].copy(), dataset.count
s += f"{i}: "
else:
p, im0, frame = path, im0s.copy(), getattr(dataset, "frame", 0)
p = Path(p) # to Path
save_path = str(save_dir / p.name) # im.jpg
txt_path = str(save_dir / "labels" / p.stem) + ("" if dataset.mode == "image" else f"_{frame}") # im.txt
s += "{:g}x{:g} ".format(*im.shape[2:]) # print string
gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh
imc = im0.copy() if save_crop else im0 # for save_crop
annotator = Annotator(im0, line_width=line_thickness, example=str(names))
if len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_boxes(im.shape[2:], det[:, :4], im0.shape).round()
# Print results
for c in det[:, 5].unique():
n = (det[:, 5] == c).sum() # detections per class
s += f"{n} {names[int(c)]}{'s' * (n > 1)}, " # add to string
# Write results
for *xyxy, conf, cls in reversed(det):
c = int(cls) # integer class
label = names[c] if hide_conf else f"{names[c]}"
confidence = float(conf)
confidence_str = f"{confidence:.2f}"
if save_csv:
write_to_csv(p.name, label, confidence_str)
if save_txt: # Write to file
if save_format == 0:
coords = (
(xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist()
) # normalized xywh
else:
coords = (torch.tensor(xyxy).view(1, 4) / gn).view(-1).tolist() # xyxy
line = (cls, *coords, conf) if save_conf else (cls, *coords) # label format
with open(f"{txt_path}.txt", "a") as f:
f.write(("%g " * len(line)).rstrip() % line + "\n")
if save_img or save_crop or view_img: # Add bbox to image
c = int(cls) # integer class
label = None if hide_labels else (names[c] if hide_conf else f"{names[c]} {conf:.2f}")
annotator.box_label(xyxy, label, color=colors(c, True))
if save_crop:
save_one_box(xyxy, imc, file=save_dir / "crops" / names[c] / f"{p.stem}.jpg", BGR=True)
# 新增：收集预测结果
img_name = p.stem
pred_detections[img_name] = []
if len(det):
for *xyxy, conf, cls in det:
c = int(cls)
x1, y1, x2, y2 = map(int, xyxy)
pred_detections[img_name].append((c, (x1, y1, x2, y2), float(conf)))
# 新增：定期计算准确率并显示
frame_count += 1
if gt_dir and frame_count % eval_interval == 0:
accuracy = calculate_accuracy(gt_labels, pred_detections)
if save_img or view_img:
accuracy_text = f"Accuracy: {accuracy:.2f}"
annotator.text((10, 30), accuracy_text, txt_color=(255, 255, 255))
im0 = annotator.result()
# Stream results
im0 = annotator.result()
if view_img:
if platform.system() == "Linux" and p not in windows:
windows.append(p)
cv2.namedWindow(str(p), cv2.WINDOW_NORMAL | cv2.WINDOW_KEEPRATIO) # allow window resize (Linux)
cv2.resizeWindow(str(p), im0.shape[1], im0.shape[0])
cv2.imshow(str(p), im0)
cv2.waitKey(1) # 1 millisecond
# Save results (image with detections)
if save_img:
if dataset.mode == "image":
cv2.imwrite(save_path, im0)
else: # 'video' or 'stream'
if vid_path[i] != save_path: # new video
vid_path[i] = save_path
if isinstance(vid_writer[i], cv2.VideoWriter):
vid_writer[i].release() # release previous video writer
if vid_cap: # video
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
else: # stream
fps, w, h = 30, im0.shape[1], im0.shape[0]
save_path = str(Path(save_path).with_suffix(".mp4")) # force *.mp4 suffix on results videos
vid_writer[i] = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
vid_writer[i].write(im0)
# Print time (inference-only)
LOGGER.info(f"{s}{'' if len(det) else '(no detections), '}{dt[1].dt * 1e3:.1f}ms")
# 新增：在终端输出最终准确率
if gt_dir:
accuracy = calculate_accuracy(gt_labels, pred_detections)
LOGGER.info(f"Overall Accuracy: {accuracy:.4f}")
# Print results
t = tuple(x.t / seen * 1e3 for x in dt) # speeds per image
LOGGER.info(f"Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {(1, 3, *imgsz)}" % t)
if save_txt or save_img:
s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ""
LOGGER.info(f"Results saved to {colorstr('bold', save_dir)}{s}")
if update:
strip_optimizer(weights[0]) # update model (to fix SourceChangeWarning)
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument("--weights", nargs="+", type=str, default=ROOT / "yolov5s.pt", help="model path or triton URL")
parser.add_argument("--source", type=str, default=ROOT / "data/images", help="file/dir/URL/glob/screen/0(webcam)")
parser.add_argument("--data", type=str, default=ROOT / "data/coco128.yaml", help="(optional) dataset.yaml path")
parser.add_argument("--imgsz", "--img", "--img-size", nargs="+", type=int, default=[640], help="inference size h,w")
parser.add_argument("--conf-thres", type=float, default=0.25, help="confidence threshold")
parser.add_argument("--iou-thres", type=float, default=0.45, help="NMS IoU threshold")
parser.add_argument("--max-det", type=int, default=1000, help="maximum detections per image")
parser.add_argument("--device", default="", help="cuda device, i.e. 0 or 0,1,2,3 or cpu")
parser.add_argument("--view-img", action="store_true", help="show results")
parser.add_argument("--save-txt", action="store_true", help="save results to *.txt")
parser.add_argument(
"--save-format",
type=int,
default=0,
help="whether to save boxes coordinates in YOLO format or Pascal-VOC format when save-txt is True, 0 for YOLO and 1 for Pascal-VOC",
)
parser.add_argument("--save-csv", action="store_true", help="save results in CSV format")
parser.add_argument("--save-conf", action="store_true", help="save confidences in --save-txt labels")
parser.add_argument("--save-crop", action="store_true", help="save cropped prediction boxes")
parser.add_argument("--nosave", action="store_true", help="do not save images/videos")
parser.add_argument("--classes", nargs="+", type=int, help="filter by class: --classes 0, or --classes 0 2 3")
parser.add_argument("--agnostic-nms", action="store_true", help="class-agnostic NMS")
parser.add_argument("--augment", action="store_true", help="augmented inference")
parser.add_argument("--visualize", action="store_true", help="visualize features")
parser.add_argument("--update", action="store_true", help="update all models")
parser.add_argument("--project", default=ROOT / "runs/detect", help="save results to project/name")
parser.add_argument("--name", default="exp", help="save results to project/name")
parser.add_argument("--exist-ok", action="store_true", help="existing project/name ok, do not increment")
parser.add_argument("--line-thickness", default=3, type=int, help="bounding box thickness (pixels)")
parser.add_argument("--hide-labels", default=False, action="store_true", help="hide labels")
parser.add_argument("--hide-conf", default=False, action="store_true", help="hide confidences")
parser.add_argument("--half", action="store_true", help="use FP16 half-precision inference")
parser.add_argument("--dnn", action="store_true", help="use OpenCV DNN for ONNX inference")
parser.add_argument("--vid-stride", type=int, default=1, help="video frame-rate stride")
# 新增参数
parser.add_argument("--gt-dir", type=str, default="", help="ground truth labels directory")
parser.add_argument("--eval-interval", type=int, default=10, help="evaluate accuracy every N frames")
opt = parser.parse_args()
opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1 # expand
print_args(vars(opt))
return opt
def main(opt):
check_requirements(ROOT / "requirements.txt", exclude=("tensorboard", "thop"))
run(**vars(opt))
if __name__ == "__main__":
opt = parse_opt()
main(opt)
```
### 主要修改说明：
1. **新增IOU计算函数**：
```python
def calculate_iou(box1, box2):
# 计算两个边界框的交并比(IOU)
```
2. **新增准确率计算函数**：
```python
def calculate_accuracy(gt_labels, pred_detections, iou_threshold=0.5):
# 计算目标检测的准确率
```
3. **添加命令行参数**：
- `--gt-dir`：指定包含真实标签的目录路径
- `--eval-interval`：设置准确率计算间隔（帧数）
4. **加载真实标签**：
```python
# 新增：加载真实标签数据
gt_labels = {}
if gt_dir:
# 解析真实标签文件并转换为xyxy格式
```
5. **收集预测结果**：
```python
# 新增：收集预测结果
pred_detections[img_name] = []
```
6. **计算并显示准确率**：
```python
# 新增：定期计算准确率并显示
frame_count += 1
if gt_dir and frame_count % eval_interval == 0:
accuracy = calculate_accuracy(gt_labels, pred_detections)
if save_img or view_img:
accuracy_text = f"Accuracy: {accuracy:.2f}"
annotator.text((10, 30), accuracy_text, txt_color=(255, 255, 255))
```
7. **终端输出最终准确率**：
```python
# 新增：在终端输出最终准确率
if gt_dir:
accuracy = calculate_accuracy(gt_labels, pred_detections)
LOGGER.info(f"Overall Accuracy: {accuracy:.4f}")
```
### 使用说明：
1. **准备真实标签**：
- 创建一个目录存放真实标签文件（如 `ground_truth`）
- 每个图像对应一个 `.txt` 文件（文件名与图像名相同）
- 标签格式：`class_id center_x center_y width height`（YOLO格式）
2. **运行命令**：
```bash
python detect.py --source data/images --weights yolov5s.pt --gt-dir ground_truth
```
3. **参数说明**：
- `--gt-dir`：指定真实标签目录
- `--eval-interval`：设置准确率计算间隔（默认每10帧计算一次）
- `--conf-thres`：调整置信度阈值（默认0.25）
- `--iou-thres`：调整NMS的IOU阈值（默认0.45）
### 效果：
- 在输出图像/视频的左上角显示当前准确率
- 在终端输出最终整体准确率
- 准确率计算基于IOU阈值（默认0.5）和类别匹配
本文介绍了Python中使用type()和isinstance()进行类型检查的方法，并展示了如何通过dir()函数获取对象的所有属性和方法。
扫一扫
71万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
