YOLOv7: Tập hợp các thủ thuật miễn phí có thể huấn luyện#

Ra mắt vào tháng 7 năm 2022, YOLOv7 là bước tiến đáng kể trong lĩnh vực phát hiện đối tượng theo thời gian thực vào thời điểm đó. Model đạt 56.8% AP trên GPU V100, thiết lập các chuẩn benchmark mới khi được giới thiệu. YOLOv7 vượt trội hơn các bộ phát hiện đối tượng cùng thời như YOLOR, YOLOX, Scaled-YOLOv4 và YOLOv5 về tốc độ và độ chính xác. Model được huấn luyện từ đầu trên bộ dữ liệu MS COCO mà không sử dụng bộ dữ liệu hay trọng số pretrained nào khác. Mã nguồn YOLOv7 có trên GitHub. Lưu ý rằng các model mới hơn như YOLO11 và YOLO26 đã đạt độ chính xác cao hơn cùng hiệu quả được cải thiện.

So sánh các bộ phát hiện đối tượng SOTA#

Từ kết quả trong bảng so sánh YOLO, chúng ta có thể thấy phương pháp được đề xuất có sự cân bằng tổng thể tốt nhất giữa tốc độ và độ chính xác. Khi so sánh YOLOv7-tiny-SiLU với YOLOv5-N (r6.1), phương pháp của chúng tôi nhanh hơn 127 fps và có AP cao hơn 10.7%. Ngoài ra, YOLOv7 đạt 51.4% AP ở tốc độ 161 fps, trong khi PPYOLOE-L có cùng AP nhưng chỉ đạt 78 fps. Xét về số lượng tham số, YOLOv7 ít hơn PPYOLOE-L 41%.

Khi so sánh YOLOv7-X với tốc độ inference 114 fps và YOLOv5-L (r6.1) với tốc độ inference 99 fps, YOLOv7-X cải thiện AP thêm 3.9%. So với YOLOv5-X (r6.1) có quy mô tương đương, YOLOv7-X có tốc độ inference nhanh hơn 31 fps. Ngoài ra, xét về số lượng tham số và phép tính, YOLOv7-X giảm 22% số tham số và 8% lượng tính toán so với YOLOv5-X (r6.1), đồng thời cải thiện AP thêm 2.2% (Nguồn).

Tổng quan#

Phát hiện đối tượng theo thời gian thực là thành phần quan trọng trong nhiều hệ thống thị giác máy tính, bao gồm theo dõi đối tượng đa đối tượng, xe tự hành, robotics và phân tích hình ảnh y tế. Trong những năm gần đây, việc phát triển khả năng phát hiện đối tượng theo thời gian thực tập trung vào thiết kế kiến trúc hiệu quả và cải thiện tốc độ suy luận trên nhiều CPU, GPU và bộ xử lý thần kinh (NPUs). YOLOv7 hỗ trợ cả thiết bị GPU di động và GPU, từ biên đến đám mây.

Không giống các bộ phát hiện đối tượng theo thời gian thực truyền thống vốn tập trung vào tối ưu hóa kiến trúc, YOLOv7 chú trọng tối ưu hóa quy trình huấn luyện. Phương pháp này bao gồm các module và kỹ thuật tối ưu hóa được thiết kế để cải thiện độ chính xác phát hiện đối tượng mà không làm tăng chi phí suy luận; khái niệm này được gọi là "trainable bag-of-freebies".

Tính năng chính#

YOLOv7 giới thiệu một số tính năng chính:

1. Tái tham số hóa model: YOLOv7 đề xuất một model được tái tham số hóa có chủ đích, một chiến lược có thể áp dụng cho các layer trong những mạng khác nhau dựa trên khái niệm đường truyền gradient.

2. Gán nhãn động: Việc huấn luyện model với nhiều layer đầu ra đặt ra một vấn đề mới: "Làm thế nào để gán mục tiêu động cho đầu ra của các nhánh khác nhau?" Để giải quyết vấn đề này, YOLOv7 giới thiệu một phương pháp gán nhãn mới gọi là gán nhãn hướng dẫn từ thô đến tinh.

3. Mở rộng và scaling kết hợp: YOLOv7 đề xuất các phương pháp "mở rộng" và "scaling kết hợp" cho bộ phát hiện đối tượng thời gian thực, giúp tận dụng hiệu quả tham số và năng lực tính toán.

4. Hiệu quả: Phương pháp YOLOv7 đề xuất có thể giảm hiệu quả khoảng 40% số lượng tham số và 50% năng lực tính toán so với bộ phát hiện đối tượng thời gian thực hiện đại nhất, đồng thời đạt tốc độ suy luận nhanh hơn và độ chính xác phát hiện cao hơn.

Ví dụ sử dụng#

Ultralytics không phát hành trọng số pretrained yolov7.pt hoặc các tệp YAML ultralytics/cfg/models/v7/, và gói Python Ultralytics không hỗ trợ huấn luyện cũng như suy luận YOLOv7 trực tiếp bằng PyTorch. Tuy nhiên, bạn có thể đưa checkpoint YOLOv7 được huấn luyện trong repository YOLOv7 upstream vào Ultralytics bằng cách xuất sang ONNX hoặc TensorRT, như minh họa bên dưới.

Xuất ONNX#

Để sử dụng model YOLOv7 ONNX với Ultralytics:

1. (Tùy chọn) Cài đặt Ultralytics và xuất model ONNX để tự động cài đặt các dependency cần thiết:

   pip install ultralytics
   yolo export model=yolo26n.pt format=onnx

2. Xuất model YOLOv7 mong muốn bằng exporter trong repo YOLOv7:

   git clone https://github.com/WongKinYiu/yolov7
   cd yolov7
   python export.py --weights yolov7-tiny.pt --grid --end2end --simplify --topk-all 100 --iou-thres 0.65 --conf-thres 0.35 --img-size 640 640 --max-wh 640

3. Chỉnh sửa graph model ONNX để tương thích với Ultralytics bằng script sau:

   import numpy as np
   import onnx
   from onnx import helper, numpy_helper
   
   # Load the ONNX model
   model_path = "yolov7/yolov7-tiny.onnx"  # Replace with your model path
   model = onnx.load(model_path)
   graph = model.graph
   
   # Fix input shape to batch size 1
   input_shape = graph.input[0].type.tensor_type.shape
   input_shape.dim[0].dim_value = 1
   
   # Define the output of the original model
   original_output_name = graph.output[0].name
   
   # Create slicing nodes
   sliced_output_name = f"{original_output_name}_sliced"
   
   # Define initializers for slicing (remove the first value)
   start = numpy_helper.from_array(np.array([1], dtype=np.int64), name="slice_start")
   end = numpy_helper.from_array(np.array([7], dtype=np.int64), name="slice_end")
   axes = numpy_helper.from_array(np.array([1], dtype=np.int64), name="slice_axes")
   steps = numpy_helper.from_array(np.array([1], dtype=np.int64), name="slice_steps")
   
   graph.initializer.extend([start, end, axes, steps])
   
   slice_node = helper.make_node(
       "Slice",
       inputs=[original_output_name, "slice_start", "slice_end", "slice_axes", "slice_steps"],
       outputs=[sliced_output_name],
       name="SliceNode",
   )
   graph.node.append(slice_node)
   
   # Define segment slicing
   seg1_start = numpy_helper.from_array(np.array([0], dtype=np.int64), name="seg1_start")
   seg1_end = numpy_helper.from_array(np.array([4], dtype=np.int64), name="seg1_end")
   seg2_start = numpy_helper.from_array(np.array([4], dtype=np.int64), name="seg2_start")
   seg2_end = numpy_helper.from_array(np.array([5], dtype=np.int64), name="seg2_end")
   seg3_start = numpy_helper.from_array(np.array([5], dtype=np.int64), name="seg3_start")
   seg3_end = numpy_helper.from_array(np.array([6], dtype=np.int64), name="seg3_end")
   
   graph.initializer.extend([seg1_start, seg1_end, seg2_start, seg2_end, seg3_start, seg3_end])
   
   # Create intermediate tensors for segments
   segment_1_name = f"{sliced_output_name}_segment1"
   segment_2_name = f"{sliced_output_name}_segment2"
   segment_3_name = f"{sliced_output_name}_segment3"
   
   # Add segment slicing nodes
   graph.node.extend(
       [
           helper.make_node(
               "Slice",
               inputs=[sliced_output_name, "seg1_start", "seg1_end", "slice_axes", "slice_steps"],
               outputs=[segment_1_name],
               name="SliceSegment1",
           ),
           helper.make_node(
               "Slice",
               inputs=[sliced_output_name, "seg2_start", "seg2_end", "slice_axes", "slice_steps"],
               outputs=[segment_2_name],
               name="SliceSegment2",
           ),
           helper.make_node(
               "Slice",
               inputs=[sliced_output_name, "seg3_start", "seg3_end", "slice_axes", "slice_steps"],
               outputs=[segment_3_name],
               name="SliceSegment3",
           ),
       ]
   )
   
   # Concatenate the segments
   concat_output_name = f"{sliced_output_name}_concat"
   concat_node = helper.make_node(
       "Concat",
       inputs=[segment_1_name, segment_3_name, segment_2_name],
       outputs=[concat_output_name],
       axis=1,
       name="ConcatSwapped",
   )
   graph.node.append(concat_node)
   
   # Reshape to [1, -1, 6]
   reshape_shape = numpy_helper.from_array(np.array([1, -1, 6], dtype=np.int64), name="reshape_shape")
   graph.initializer.append(reshape_shape)
   
   final_output_name = f"{concat_output_name}_batched"
   reshape_node = helper.make_node(
       "Reshape",
       inputs=[concat_output_name, "reshape_shape"],
       outputs=[final_output_name],
       name="AddBatchDimension",
   )
   graph.node.append(reshape_node)
   
   # Get the shape of the reshaped tensor
   shape_node_name = f"{final_output_name}_shape"
   shape_node = helper.make_node(
       "Shape",
       inputs=[final_output_name],
       outputs=[shape_node_name],
       name="GetShapeDim",
   )
   graph.node.append(shape_node)
   
   # Extract the second dimension
   dim_1_index = numpy_helper.from_array(np.array([1], dtype=np.int64), name="dim_1_index")
   graph.initializer.append(dim_1_index)
   
   second_dim_name = f"{final_output_name}_dim1"
   gather_node = helper.make_node(
       "Gather",
       inputs=[shape_node_name, "dim_1_index"],
       outputs=[second_dim_name],
       name="GatherSecondDim",
   )
   graph.node.append(gather_node)
   
   # Subtract from 100 to determine how many values to pad
   target_size = numpy_helper.from_array(np.array([100], dtype=np.int64), name="target_size")
   graph.initializer.append(target_size)
   
   pad_size_name = f"{second_dim_name}_padsize"
   sub_node = helper.make_node(
       "Sub",
       inputs=["target_size", second_dim_name],
       outputs=[pad_size_name],
       name="CalculatePadSize",
   )
   graph.node.append(sub_node)
   
   # Build the [2, 3] pad array:
   # 1st row -> [0, 0, 0] (no padding at the start of any dim)
   # 2nd row -> [0, pad_size, 0] (pad only at the end of the second dim)
   pad_starts = numpy_helper.from_array(np.array([0, 0, 0], dtype=np.int64), name="pad_starts")
   graph.initializer.append(pad_starts)
   
   zero_scalar = numpy_helper.from_array(np.array([0], dtype=np.int64), name="zero_scalar")
   graph.initializer.append(zero_scalar)
   
   pad_ends_name = "pad_ends"
   concat_pad_ends_node = helper.make_node(
       "Concat",
       inputs=["zero_scalar", pad_size_name, "zero_scalar"],
       outputs=[pad_ends_name],
       axis=0,
       name="ConcatPadEnds",
   )
   graph.node.append(concat_pad_ends_node)
   
   pad_values_name = "pad_values"
   concat_pad_node = helper.make_node(
       "Concat",
       inputs=["pad_starts", pad_ends_name],
       outputs=[pad_values_name],
       axis=0,
       name="ConcatPadStartsEnds",
   )
   graph.node.append(concat_pad_node)
   
   # Create Pad operator to pad with zeros
   pad_output_name = f"{final_output_name}_padded"
   pad_constant_value = numpy_helper.from_array(
       np.array([0.0], dtype=np.float32),
       name="pad_constant_value",
   )
   graph.initializer.append(pad_constant_value)
   
   pad_node = helper.make_node(
       "Pad",
       inputs=[final_output_name, pad_values_name, "pad_constant_value"],
       outputs=[pad_output_name],
       mode="constant",
       name="PadToFixedSize",
   )
   graph.node.append(pad_node)
   
   # Update the graph's final output to [1, 100, 6]
   new_output_type = onnx.helper.make_tensor_type_proto(
       elem_type=graph.output[0].type.tensor_type.elem_type, shape=[1, 100, 6]
   )
   new_output = onnx.helper.make_value_info(name=pad_output_name, type_proto=new_output_type)
   
   # Replace the old output with the new one
   graph.output.pop()
   graph.output.extend([new_output])
   
   # Save the modified model
   onnx.save(model, "yolov7-ultralytics.onnx")

4. Sau đó, bạn có thể tải model ONNX đã chỉnh sửa và chạy suy luận với model đó như bình thường trong Ultralytics:

   from ultralytics import ASSETS, YOLO
   
   model = YOLO("yolov7-ultralytics.onnx", task="detect")
   
   results = model(ASSETS / "bus.jpg")

Xuất TensorRT#

1. Thực hiện các bước 1–2 trong mục Xuất ONNX.

2. Cài đặt package Python TensorRT:

   pip install tensorrt

3. Chạy script sau để chuyển model ONNX đã chỉnh sửa thành TensorRT engine:

   from ultralytics.utils.export import onnx2engine
   
   onnx2engine("yolov7-ultralytics.onnx", quantize=16)

4. Tải và chạy model trong Ultralytics:

   from ultralytics import ASSETS, YOLO
   
   model = YOLO("yolov7-ultralytics.engine", task="detect")
   
   results = model(ASSETS / "bus.jpg")

Trích dẫn và lời cảm ơn#

Chúng tôi xin ghi nhận những đóng góp quan trọng của các tác giả YOLOv7 trong lĩnh vực phát hiện đối tượng theo thời gian thực:

@inproceedings{wang2023yolov7,
  title={YOLOv7: Trainable Bag-of-Freebies Sets New State-of-the-Art for Real-Time Object Detectors},
  author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
  booktitle={Proceedings of the IEEE/CVF conference on Computer Vision and Pattern Recognition (CVPR)},
  pages={7464--7475},
  year={2023}
}

Bài báo YOLOv7 chính thức được xuất bản trên CVF 2023 Open Access, cùng với bản tiền xuất bản trên arXiv. Các tác giả đã công khai công trình của mình và mã nguồn có thể truy cập trên GitHub. Chúng tôi trân trọng nỗ lực của họ trong việc thúc đẩy lĩnh vực này và giúp cộng đồng rộng lớn hơn tiếp cận công trình.

Câu hỏi thường gặp#