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

YOLOv7 là một trình phát hiện đối tượng theo thời gian thực hiện đại, vượt trội hơn tất cả các trình phát hiện đối tượng đã biết về cả tốc độ và độ chính xác trong phạm vi từ 5 FPS đến 160 FPS. Nó có độ chính xác cao nhất (56,8% AP) trong số tất cả các trình phát hiện đối tượng theo thời gian thực đã biết với 30 FPS trở lên trên GPU V100. Hơn nữa, YOLOv7 vượt trội hơn các trình phát hiện đối tượng khác như YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 và nhiều trình khác về tốc độ và độ chính xác. Mô hình được huấn luyện trên tập dữ liệu MS COCO từ đầu mà không sử dụng bất kỳ tập dữ liệu hoặc trọng số được huấn luyện trước nào khác. Mã nguồn cho YOLOv7 có sẵn trên GitHub.

So sánh các công cụ 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ự cân bằng tốc độ-độ chính xác tốt nhất một cách toàn diện. Nếu chúng ta so sánh YOLOv7-tiny-SiLU với YOLOv5-N (r6.1), phương pháp của chúng ta nhanh hơn 127 fps và chính xác hơn 10,7% trên AP. Ngoài ra, YOLOv7 có 51,4% AP ở tốc độ khung hình 161 fps, trong khi PPYOLOE-L với cùng AP chỉ có tốc độ khung hình 78 fps. Về mức sử dụng tham số, YOLOv7 ít hơn 41% so với PPYOLOE-L.

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

Không giống như các trình dò tìm đố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 giới thiệu sự tập trung vào tối ưu hóa quy trình huấn luyện. Điều này bao gồm các mô-đun và phương pháp tối ưu hóa được thiết kế để cải thiện độ chính xác của việc dò tìm đối tượng mà không làm tăng chi phí suy luận, một khái niệm được gọi là "túi quà tặng có thể huấn luyện" (trainable bag-of-freebies).

Các 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 Mô Hình (Model Re-parameterization): YOLOv7 đề xuất một mô hình tái tham số hóa có kế hoạch, đây là một chiến lược có thể áp dụng cho các lớp trong các mạng khác nhau với khái niệm về đường dẫn lan truyền gradient.

2. Gán Nhãn Động (Dynamic Label Assignment): Việc huấn luyện mô hình với nhiều lớp đầu ra đặt ra một vấn đề mới: "Làm thế nào để gán các mục tiêu động cho các đầ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 dẫn dắt từ thô đến tinh.

3. Mở Rộng và Tỉ Lệ Hợp Chất (Extended and Compound Scaling): YOLOv7 đề xuất các phương pháp "mở rộng" và "tỉ lệ hợp chất" cho trình dò tìm đối tượng theo thời gian thực, có thể sử dụng hiệu quả các tham số và tính toán.

4. Hiệu Quả (Efficiency): Phương pháp được đề xuất bởi YOLOv7 có thể giảm hiệu quả khoảng 40% tham số và 50% tính toán của trình dò tìm đối tượng theo thời gian thực hiện đại, đồng thời có tốc độ suy luận nhanh hơn và độ chính xác dò tìm cao hơn.

Ví dụ sử dụng

Tại thời điểm viết bài, Ultralytics chỉ hỗ trợ suy luận ONNX và TensorRT cho YOLOv7.

Xuất ONNX

Để sử dụng mô hình YOLOv7 ONNX với Ultralytics:

1. (Tùy chọn) Cài đặt Ultralytics và xuất một mô hình ONNX để tự động cài đặt các phụ thuộc cần thiết:

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

2. Xuất mô hình YOLOv7 mong muốn bằng cách sử dụng trình xuất trong kho lưu trữ 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 đồ thị mô hình 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 mô hình ONNX đã sửa đổi và chạy suy luận với nó trong Ultralytics một cách bình thường:

   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 theo các bước 1-2 trong phần Xuất ONNX.

2. Cài đặt TensorRT Gói Python:

   pip install tensorrt
   

3. Chạy script sau để chuyển đổi mô hình ONNX đã sửa đổi sang TensorRT engine:

   from ultralytics.utils.export import export_engine
   
   export_engine("yolov7-ultralytics.onnx", half=True)
   

4. Tải và chạy mô hình 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

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 dò tìm đối tượng theo thời gian thực:

@article{wang2022yolov7,
  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},
  journal={arXiv preprint arXiv:2207.02696},
  year={2022}
}

Bài báo YOLOv7 gốc có thể được tìm thấy trên arXiv. Các tác giả đã công khai công trình của họ và có thể truy cập codebase trên GitHub. Chúng tôi đánh giá cao những nỗ lực của họ trong việc thúc đẩy lĩnh vực này và làm cho công trình của họ có thể tiếp cận được với cộng đồng rộng lớn hơn.

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

YOLOv7 là gì và tại sao nó được coi là một bước đột phá trong dò tìm đối tượng theo thời gian thực?

YOLOv7 là một mô hình dò tìm đối tượng theo thời gian thực tiên tiến, đạt được tốc độ và độ chính xác vô song. Nó vượt trội so với các mô hình khác, chẳng hạn như YOLOX, YOLOv5 và PPYOLOE, cả về mức sử dụng tham số và tốc độ suy luận. Các tính năng phân biệt của YOLOv7 bao gồm tái tham số hóa mô hình và gán nhãn động, giúp tối ưu hóa hiệu suất của nó mà không làm tăng chi phí suy luận. Để biết thêm chi tiết kỹ thuật về kiến trúc và các số liệu so sánh với các trình dò tìm đối tượng hiện đại khác, hãy tham khảo bài báo YOLOv7.

YOLOv7 cải tiến so với các mô hình YOLO trước đây như YOLOv4 và YOLOv5 như thế nào?

YOLOv7 giới thiệu một số cải tiến, bao gồm tái tham số hóa mô hình và gán nhãn động, giúp tăng cường quy trình huấn luyện và cải thiện độ chính xác suy luận. So với YOLOv5, YOLOv7 tăng đáng kể tốc độ và độ chính xác. Ví dụ: YOLOv7-X cải thiện độ chính xác lên 2,2% và giảm 22% tham số so với YOLOv5-X. Có thể tìm thấy các so sánh chi tiết trong bảng hiệu suất so sánh YOLOv7 với các trình dò tìm đối tượng SOTA.

Tôi có thể sử dụng YOLOv7 với các công cụ và nền tảng Ultralytics không?

Hiện tại, Ultralytics chỉ hỗ trợ suy luận YOLOv7 ONNX và TensorRT. Để chạy phiên bản YOLOv7 đã xuất ONNX và TensorRT với Ultralytics, hãy xem phần Ví dụ sử dụng.

Làm cách nào để huấn luyện một mô hình YOLOv7 tùy chỉnh bằng bộ dữ liệu của riêng tôi?

Để cài đặt và huấn luyện mô hình YOLOv7 tùy chỉnh, hãy làm theo các bước sau:

1. Sao chép kho lưu trữ YOLOv7:

   git clone https://github.com/WongKinYiu/yolov7
   

2. Điều hướng đến thư mục đã sao chép và cài đặt các зависимость:

   cd yolov7
   pip install -r requirements.txt
   

3. Chuẩn bị bộ dữ liệu của bạn và định cấu hình các tham số mô hình theo hướng dẫn sử dụng được cung cấp trong kho lưu trữ. Để được hướng dẫn thêm, hãy truy cập kho lưu trữ YOLOv7 GitHub để biết thông tin và cập nhật mới nhất.

4. Sau khi huấn luyện, bạn có thể xuất mô hình sang ONNX hoặc TensorRT để sử dụng trong Ultralytics như được hiển thị trong Ví dụ Sử dụng.

Các tính năng và tối ưu hóa chính được giới thiệu trong YOLOv7 là gì?

YOLOv7 cung cấp một số tính năng chính mang tính cách mạng trong việc phát hiện đối tượng theo thời gian thực:

• Tái Tham Số Hóa Mô Hình (Model Re-parameterization): Nâng cao hiệu suất của mô hình bằng cách tối ưu hóa các đường dẫn lan truyền gradient.
• Gán Nhãn Động (Dynamic Label Assignment): Sử dụng phương pháp dẫn dắt từ thô đến tinh để gán các mục tiêu động cho các đầu ra trên các nhánh khác nhau, cải thiện độ chính xác.
• Mở Rộng và Tỉ Lệ Hợp Chất (Extended and Compound Scaling): Sử dụng hiệu quả các tham số và tính toán để масштабирование mô hình cho các ứng dụng thời gian thực khác nhau.
• Hiệu quả: Giảm 40% số lượng tham số và 50% tính toán so với các mô hình hiện đại khác đồng thời đạt được tốc độ suy luận nhanh hơn.

Để biết thêm chi tiết về các tính năng này, hãy xem phần Tổng quan về YOLOv7.

📅 Đã tạo 1 năm trước ✏️ Cập nhật 3 tháng trước

Bình luận