YOLOv7: Eğitilebilir Ücretsiz Avantajlar Paketi#

Temmuz 2022'de yayımlanan YOLOv7, o dönemde gerçek zamanlı nesne algılama alanında önemli bir ilerlemeydi. GPU V100 üzerinde 56.8% AP elde ederek tanıtıldığı sırada yeni kıyaslama ölçütleri belirledi. YOLOv7, hız ve doğruluk açısından YOLOR, YOLOX, Scaled-YOLOv4 ve YOLOv5 gibi dönemin nesne algılayıcılarını geride bıraktı. Model, başka hiçbir veri kümesi veya önceden eğitilmiş ağırlık kullanılmadan MS COCO veri kümesi üzerinde sıfırdan eğitilir. YOLOv7'nin kaynak kodu GitHub'da mevcuttur. Unutma ki YOLO11 ve YOLO26 gibi daha yeni modeller, o zamandan beri daha verimli çalışarak daha yüksek doğruluk elde etti.

Son teknoloji nesne algılama modellerinin karşılaştırması#

YOLO karşılaştırma tablosundaki sonuçlardan, önerilen yöntemin hız-doğruluk dengesinde genel olarak en iyi sonucu verdiğini biliyoruz. YOLOv7-tiny-SiLU ile YOLOv5-N (r6.1) modelini karşılaştırırsak yöntemimiz 127 fps daha hızlıdır ve AP bakımından %10.7 daha doğrudur. Ayrıca YOLOv7, 161 fps kare hızında %51.4 AP elde ederken aynı AP değerine sahip PPYOLOE-L yalnızca 78 fps kare hızına ulaşır. Parametre kullanımı açısından YOLOv7, PPYOLOE-L'den %41 daha az parametre kullanır.

YOLOv7-X'in 114 fps çıkarım hızını, 99 fps çıkarım hızına sahip YOLOv5-L (r6.1) ile karşılaştırırsak YOLOv7-X, AP değerini %3.9 artırabilir. YOLOv7-X'i benzer ölçekteki YOLOv5-X (r6.1) ile karşılaştırırsak YOLOv7-X'in çıkarım hızı 31 fps daha yüksektir. Ayrıca YOLOv7-X, parametre ve hesaplama miktarı açısından YOLOv5-X'e (r6.1) kıyasla parametreleri %22, hesaplama miktarını %8 azaltırken AP değerini %2.2 artırır (Kaynak).

Genel Bakış#

Gerçek zamanlı nesne algılama; çoklu bilgisayarlı görü sistemleri, çoklu nesne takibi, otonom sürüş, robotik ve tıbbi görüntü analizi dahil olmak üzere birçok sistemin önemli bir bileşenidir. Son yıllarda gerçek zamanlı nesne algılama geliştirme çalışmaları, verimli mimariler tasarlamaya ve çeşitli CPU'ların, GPU'ların ve sinirsel işlem birimlerinin (NPU) çıkarım hızını artırmaya odaklanmıştır. YOLOv7, uçtan buluta kadar hem mobil GPU'ları hem de GPU cihazlarını destekler.

Mimari optimizasyonuna odaklanan geleneksel gerçek zamanlı nesne algılayıcılarının aksine YOLOv7, eğitim sürecini optimize etmeye odaklanır. Buna, çıkarım maliyetini artırmadan nesne algılama doğruluğunu iyileştirmek için tasarlanmış modüller ve optimizasyon yöntemleri dahildir; bu kavram "eğitilebilir ücretsiz avantajlar paketi" olarak bilinir.

Temel Özellikler#

YOLOv7 birkaç temel özellik sunar:

1. Modelin Yeniden Parametrelendirilmesi: YOLOv7, gradyan yayılım yolu kavramını temel alan ve farklı ağlardaki katmanlara uygulanabilen planlı bir yeniden parametrelendirilmiş model önerir.

2. Dinamik Etiket Atama: Birden fazla çıktı katmanına sahip modelin eğitimi yeni bir sorunu gündeme getirir: "Farklı dalların çıktıları için dinamik hedefler nasıl atanır?" Bu sorunu çözmek için YOLOv7, kabadan inceye yönlendirmeli etiket ataması adı verilen yeni bir etiket atama yöntemi sunar.

3. Genişletilmiş ve Bileşik Ölçeklendirme: YOLOv7, gerçek zamanlı nesne algılayıcısının parametreleri ve hesaplama kaynaklarını etkili biçimde kullanabilmesi için "genişletme" ve "bileşik ölçeklendirme" yöntemlerini önerir.

4. Verimlilik: YOLOv7'nin önerdiği yöntem, son teknoloji gerçek zamanlı nesne algılayıcılarına kıyasla parametre sayısını yaklaşık %40, hesaplama miktarını ise %50 azaltabilir; ayrıca daha hızlı çıkarım ve daha yüksek algılama doğruluğu sunar.

Kullanım Örnekleri#

Ultralytics, yolov7.pt önceden eğitilmiş ağırlıklarını veya ultralytics/cfg/models/v7/ YAML dosyalarını yayımlamaz ve YOLOv7 için yerel PyTorch eğitimi ile çıkarımı Ultralytics Python paketi tarafından desteklenmez. Ancak aşağıda gösterildiği gibi, YOLOv7 kaynak deposunda eğitilmiş bir YOLOv7 kontrol noktasını ONNX veya TensorRT'ye aktararak Ultralytics'e getirebilirsin.

ONNX Dışa Aktarımı#

YOLOv7 ONNX modelini Ultralytics ile kullanmak için:

1. (İsteğe bağlı) Ultralytics'i kur ve gerekli bağımlılıkların otomatik olarak yüklenmesi için bir ONNX modelini dışa aktar:

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

2. İstediğin YOLOv7 modelini YOLOv7 deposundaki dışa aktarıcıyı kullanarak dışa aktar:

   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. Aşağıdaki betiği kullanarak ONNX model grafiğini Ultralytics ile uyumlu olacak şekilde değiştir:

   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. Daha sonra değiştirilmiş ONNX modelini yükleyebilir ve Ultralytics'te normal şekilde çıkarım yapabilirsin:

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

TensorRT Dışa Aktarımı#

1. ONNX Dışa Aktarımı bölümündeki 1-2. adımları izle.

2. TensorRT Python paketini kur:

   pip install tensorrt

3. Değiştirilmiş ONNX modelini TensorRT motoruna dönüştürmek için aşağıdaki betiği çalıştır:

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

4. Modeli Ultralytics'te yükle ve çalıştır:

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

Atıflar ve Teşekkürler#

Gerçek zamanlı nesne algılama alanına önemli katkılarından dolayı YOLOv7 yazarlarına teşekkür ederiz:

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

Resmî YOLOv7 makalesi CVF 2023 Açık Erişim'de yayımlandı; ön baskısı arXiv'de yer alıyor. Yazarlar çalışmalarını herkese açık hâle getirdi ve kod tabanına GitHub üzerinden erişilebilir. Alanı ileriye taşımak ve çalışmalarını daha geniş topluluğun erişimine sunmak için gösterdikleri çabaları takdir ediyoruz.

Sık Sorulan Sorular#