YOLOv7: Trainable Bag-of-Freebies

YOLOv7, ra mắt vào tháng 7 năm 2022, là một bước tiến đáng kể trong detect vật thể thời gian thực tại thời điểm ra mắt. Nó đạt 56.8% AP trên GPU V100, thiết lập các tiêu chuẩn mới khi được giới thiệu. YOLOv7 vượt trội hơn các bộ detect vật thể cùng thời như YOLOR, YOLOX, Scaled-YOLOv4 và YOLOv5 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ố tiền huấn luyện nào khác. Mã nguồn của YOLOv7 có sẵn trên GitHub. Lưu ý rằng các mô hình mới hơn như YOLO11 và YOLO26 đã đạt được độ chính xác cao hơn với hiệu quả được cải thiện.

So sánh các công cụ phát hiện đối tượng SOTA

Từ kết quả trong bảng so sánh YOLO, chúng ta biết rằng phương pháp đề xuất đạt được sự đánh đổi tốt nhất giữa tốc độ và độ chính xác một cách toàn diện. 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 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ề lượng tham số sử dụng, 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) có 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ề 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

Detect đối tượng 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 track đa đối tượng, lái xe tự hành, ngành robot 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 detect đối tượng 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 nhiều CPU, GPU và đơn vị xử lý thần kinh (NPU). YOLOv7 hỗ trợ cả thiết bị GPU di động và GPU, từ biên đến đám mây.

Không như các bộ detect object 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 trọng tâm 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 của việc detect object mà không làm tăng chi phí suy luận, một khái niệm được gọi là "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: 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: 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 đầ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 được gọi là gán nhãn dẫn hướng từ thô đến tinh.

3. Mở rộng và Điều chỉnh kết hợp (Compound Scaling): YOLOv7 đề xuất các phương pháp "mở rộng" và "điều chỉnh kết hợp" cho bộ detect object thời gian thực có thể tận dụng hiệu quả các tham số và tính toán.

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

Ví dụ sử dụng

Tại thời điểm viết bài này, 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=yolo26n.pt format=onnx
   

2. Xuất mô hình YOLOv7 mong muốn bằng cách sử dụng bộ xuất 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 đồ 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à Lời cảm ơ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 detect object 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 gốc về YOLOv7 có thể tìm thấy trên arXiv. Các tác giả đã công khai công trình của họ, và mã nguồn có thể được truy cập 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à giúp cộng đồng rộng lớn hơn tiếp cận được công trình của họ.

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 detect object thời gian thực?

YOLOv7, ra mắt vào tháng 7 năm 2022, là một mô hình detect vật thể thời gian thực quan trọng đạt được tốc độ và độ chính xác xuất sắc tại thời điểm ra mắt. Nó vượt trội hơn các mô hình cùng thời như YOLOX, YOLOv5 và PPYOLOE cả về việc sử dụng tham số và tốc độ suy luận. Các tính năng nổi bậ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 chỉ số so sánh của nó với các bộ detect vật thể tiên tiến khác, hãy tham khảo bài báo YOLOv7.

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

YOLOv7 giới thiệu một số đổi mới, 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 2.2% và giảm 22% tham số so với YOLOv5-X. Các so sánh chi tiết có thể tìm thấy trong bảng hiệu suất So sánh YOLOv7 với các bộ detect object SOTA.

Tôi có thể sử dụng YOLOv7 với các công cụ và nền tảng của 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 kiểm tra 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 cách sử dụng tập dữ liệu của tôi?

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

1. Clone 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ị tập dữ liệu của bạn và 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ữ GitHub của YOLOv7 để 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 cách mạng hóa detect object 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.

📅 Được tạo 2 năm trước ✏️ Cập nhật 5 ngày trước

Bình luận