YOLOv7: Trainierbare Sammlung kostenloser Verbesserungen#

YOLOv7, veröffentlicht im Juli 2022, war zum Zeitpunkt seiner Veröffentlichung ein bedeutender Fortschritt bei der Objekterkennung in Echtzeit. Das Modell erreichte 56,8 % AP auf einer GPU V100 und setzte damit bei seiner Einführung neue Maßstäbe. YOLOv7 übertraf zeitgenössische Objektdetektoren wie YOLOR, YOLOX, Scaled-YOLOv4 und YOLOv5 bei Geschwindigkeit und Genauigkeit. Das Modell wird von Grund auf auf dem MS-COCO-Datensatz trainiert – ohne andere Datensätze oder vortrainierte Gewichte. Der Quellcode für YOLOv7 ist auf GitHub verfügbar. Beachte, dass neuere Modelle wie YOLO11 und YOLO26 inzwischen eine höhere Genauigkeit bei verbesserter Effizienz erzielen.

Vergleich führender Objektdetektoren#

Aus den Ergebnissen in der YOLO-Vergleichstabelle geht hervor, dass die vorgeschlagene Methode insgesamt das beste Verhältnis von Geschwindigkeit und Genauigkeit bietet. Vergleichen wir YOLOv7-tiny-SiLU mit YOLOv5-N (r6.1), ist unsere Methode 127 fps schneller und bei AP um 10,7 % genauer. Außerdem erreicht YOLOv7 bei einer Bildrate von 161 fps einen AP von 51,4 %, während PPYOLOE-L bei demselben AP nur eine Bildrate von 78 fps erzielt. Beim Parameterverbrauch benötigt YOLOv7 41 % weniger als PPYOLOE-L.

Vergleichen wir YOLOv7-X mit einer Inferenzgeschwindigkeit von 114 fps mit YOLOv5-L (r6.1) mit einer Inferenzgeschwindigkeit von 99 fps, kann YOLOv7-X den AP um 3,9 % verbessern. Wird YOLOv7-X mit dem ähnlich großen YOLOv5-X (r6.1) verglichen, ist YOLOv7-X bei der Inferenz um 31 fps schneller. Außerdem reduziert YOLOv7-X im Vergleich zu YOLOv5-X (r6.1) die Anzahl der Parameter um 22 % und den Rechenaufwand um 8 %, verbessert den AP aber um 2,2 % (Quelle).

Übersicht#

Echtzeit-Objekterkennung ist ein wichtiger Bestandteil vieler Computer-Vision-Systeme, darunter Multi-Objektverfolgung, autonomes Fahren, Robotik und medizinische Bildanalyse. In den letzten Jahren konzentrierte sich die Entwicklung der Echtzeit-Objekterkennung auf den Entwurf effizienter Architekturen und die Verbesserung der Inferenzgeschwindigkeit auf verschiedenen CPUs, GPUs und neuronalen Verarbeitungseinheiten (NPUs). YOLOv7 unterstützt sowohl mobile GPUs als auch GPU-Geräte – vom Edge bis zur Cloud.

Im Gegensatz zu herkömmlichen Echtzeit-Objektdetektoren, die sich auf die Optimierung der Architektur konzentrieren, setzt YOLOv7 auf die Optimierung des Trainingsprozesses. Dazu gehören Module und Optimierungsmethoden, die die Genauigkeit der Objekterkennung verbessern sollen, ohne die Inferenzkosten zu erhöhen – ein Konzept, das als „trainable bag-of-freebies“ bekannt ist.

Wichtige Funktionen#

YOLOv7 führt mehrere wichtige Funktionen ein:

1. Modell-Reparametrisierung: YOLOv7 schlägt ein gezielt reparametrisiertes Modell vor. Diese Strategie lässt sich auf Schichten in verschiedenen Netzwerken anwenden und basiert auf dem Konzept des Gradientenflusses.

2. Dynamische Labelzuweisung: Das Training eines Modells mit mehreren Ausgabeschichten wirft eine neue Frage auf: „Wie lassen sich dynamische Zielwerte den Ausgaben verschiedener Zweige zuweisen?“ Um dieses Problem zu lösen, führt YOLOv7 eine neue Methode zur Labelzuweisung ein, die als grob-zu-fein-geleitete Labelzuweisung bezeichnet wird.

3. Erweiterte und zusammengesetzte Skalierung: YOLOv7 schlägt Methoden zur „Erweiterung“ und „zusammengesetzten Skalierung“ für Echtzeit-Objektdetektoren vor, mit denen sich Parameter und Rechenleistung effektiv nutzen lassen.

4. Effizienz: Die von YOLOv7 vorgeschlagene Methode kann die Parameteranzahl des aktuell besten Echtzeit-Objektdetektors um etwa 40 % und den Rechenaufwand um 50 % reduzieren und erzielt zugleich eine höhere Inferenzgeschwindigkeit und Erkennungsgenauigkeit.

Anwendungsbeispiele#

Ultralytics veröffentlicht keine vortrainierten Gewichte yolov7.pt oder YAML-Dateien ultralytics/cfg/models/v7/. Natives Training und native Inferenz von YOLOv7 mit PyTorch werden vom Ultralytics-Python-Paket nicht unterstützt. Du kannst jedoch einen im YOLOv7-Repository des Originalprojekts trainierten YOLOv7-Checkpoint in Ultralytics einbinden, indem du ihn wie unten gezeigt nach ONNX oder TensorRT exportierst.

ONNX-Export#

So verwendest du ein YOLOv7-ONNX-Modell mit Ultralytics:

1. (Optional) Installiere Ultralytics und exportiere ein ONNX-Modell, damit die erforderlichen Abhängigkeiten automatisch installiert werden:

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

2. Exportiere das gewünschte YOLOv7-Modell mit dem Exporter im YOLOv7-Repository:

   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. Passe den ONNX-Modellgraphen mit dem folgenden Skript an, damit er mit Ultralytics kompatibel ist:

   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. Anschließend kannst du das angepasste ONNX-Modell laden und wie gewohnt damit in Ultralytics Inferenz ausführen:

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

TensorRT-Export#

1. Befolge die Schritte 1–2 im Abschnitt ONNX-Export.

2. Installiere das Python-Paket TensorRT:

   pip install tensorrt

3. Führe das folgende Skript aus, um das angepasste ONNX-Modell in eine TensorRT-Engine umzuwandeln:

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

4. Lade das Modell in Ultralytics und führe es aus:

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

Zitate und Danksagungen#

Wir möchten den YOLOv7-Autoren für ihre bedeutenden Beiträge im Bereich der Echtzeit-Objekterkennung danken:

@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}
}

Die offizielle YOLOv7-Arbeit wurde in CVF 2023 Open Access veröffentlicht; ein Vorabdruck ist auf arXiv verfügbar. Die Autoren haben ihre Arbeit öffentlich zugänglich gemacht, und der Quellcode ist auf GitHub verfügbar. Wir schätzen ihre Bemühungen, das Fachgebiet voranzubringen und ihre Arbeit einer breiteren Gemeinschaft zugänglich zu machen.

Häufig gestellte Fragen#