YOLOv7: Bag-of-Freebies có thể huấn luyện#

YOLOv7, được phát hành vào tháng 7 năm 2022, là một bước tiến đáng kể trong lĩnh vực phát hiện đối tượng theo thời gian thực tại thời điểm ra mắt. Model đạt 56.8% AP trên GPU V100, thiết lập các chuẩn mực 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 đương thời như YOLOR, YOLOX, Scaled-YOLOv4 và YOLOv5 về tốc độ và độ chính xác. Model được huấn luyện trên dataset MS COCO từ đầu mà không sử dụng bất kỳ dataset nào khác hoặc pretrained weights. Mã nguồn của YOLOv7 có sẵn 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 với hiệu quả được cải thiện.

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

Từ các kết quả trong bảng so sánh YOLO, chúng ta biết rằng phương pháp được đề xuất có sự đánh đổi toàn diện tốt nhất giữa tốc độ và độ chính xác. Nếu 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à chính xác hơn 10.7% về AP. Ngoài ra, YOLOv7 đạt 51.4% AP ở tốc độ khung hình 161 fps, trong khi PPYOLOE-L có cùng AP chỉ đạt tốc độ khung hình 78 fps. Về mức sử dụng tham số, YOLOv7 ít hơn PPYOLOE-L 41%.

Nếu 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ó thể cải thiện AP thêm 3.9%. Nếu so sánh YOLOv7-X với YOLOv5-X (r6.1) có quy mô tương đương, tốc độ inference của YOLOv7-X nhanh hơn 31 fps. Ngoài ra, về số lượng tham số và lượng tính toán, YOLOv7-X giảm 22% tham số và 8% phép tính so với YOLOv5-X (r6.1), nhưng 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à một 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 nhiều đối tượng, lái xe tự hành, robotics và phân tích ảnh y tế. Trong những năm gần đây, việc phát triển các hệ thống phát hiện đối tượng theo thời gian thực tập trung vào thiết kế các kiến trúc hiệu quả và cải thiện tốc độ inference trên nhiều CPU, GPU và đơn vị xử lý thần kinh (NPUs). YOLOv7 hỗ trợ cả thiết bị GPU di động và GPU, từ edge đến cloud.

Khác với các bộ phát hiện đối tượng theo thời gian thực truyền thống tập trung vào tối ưu hóa kiến trúc, YOLOv7 chú trọng vào việc tối ưu hóa quy trình huấn luyện. Điều này bao gồm các module và phương pháp 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í inference, một khái niệm được gọi là "bag-of-freebies có thể huấn luyện".

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, đây là một chiến lược có thể áp dụng cho các layer trong những network khác nhau dựa trên khái niệm đường truyền gradient.

2. Gán Label Độ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 các target động cho đầu ra của những 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 label mới có tên là gán label dẫn hướng từ thô đến tinh.

3. Mở rộng và Scaling Hợp nhất: YOLOv7 đề xuất các phương pháp "mở rộng" và "scaling hợp nhất" cho bộ phát hiện đối tượng theo thời gian thực, có thể tận dụng hiệu quả các tham số và phép tính.

4. Hiệu quả: Phương pháp được YOLOv7 đề xuất có thể giảm hiệu quả khoảng 40% số tham số và 50% lượng tính toán của bộ phát hiện đối tượng theo thời gian thực SOTA, đồng thời có tốc độ inference 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 pretrained weights yolov7.pt hoặc YAML ultralytics/cfg/models/v7/, và việc huấn luyện cũng như inference YOLOv7 native bằng PyTorch không được Python package Ultralytics hỗ trợ. 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 export sang ONNX hoặc TensorRT, như minh họa bên dưới.

Export ONNX#

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

1. (Tùy chọn) Cài đặt Ultralytics và export một model ONNX để các dependency bắt buộc được tự động cài đặt:

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

2. Export 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. Sửa đổi graph của 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ể load model ONNX đã sửa đổi và chạy inference với model này trong Ultralytics như bình thường:

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

Export TensorRT#

1. Thực hiện các bước 1-2 trong phần Export ONNX.

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

   pip install tensorrt

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

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

4. Load 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à ghi nhận đóng góp#

Chúng tôi xin ghi nhận những đóng góp đáng kể 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 công bố trong CVF 2023 Open Access, cùng với bản preprint trên arXiv. Các tác giả đã công khai công trình của mình và có thể truy cập codebase trên GitHub. Chúng tôi trân trọng nhữ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.

FAQ#