Model YAML Yapılandırma Rehberi

Model yaml yapılandırma dosyası, Ultralytics sinir ağları için mimari bir taslak görevi görür. Katmanların nasıl bağlandığını, her modülün hangi parametreleri kullandığını ve tüm ağın farklı model boyutlarında nasıl ölçeklendiğini tanımlar.

Yapılandırma Yapısı

Model yaml dosyaları, mimariyi tanımlamak için birlikte çalışan üç ana bölüme ayrılmıştır.

Parametreler Bölümü

Parametreler bölümü, modelin genel özelliklerini ve ölçekleme davranışını belirtir:

# Parameters
nc: 80 # number of classes
scales: # compound scaling constants [depth, width, max_channels]
    n: [0.50, 0.25, 1024] # nano: shallow layers, narrow channels
    s: [0.50, 0.50, 1024] # small: shallow depth, standard width
    m: [0.50, 1.00, 512] # medium: moderate depth, full width
    l: [1.00, 1.00, 512] # large: full depth and width
    x: [1.00, 1.50, 512] # extra-large: maximum performance
kpt_shape: [17, 3] # pose models only

• nc modelin tahmin ettiği sınıf sayısını belirler.
• scales model derinliğini, genişliğini ve maksimum kanal sayısını ayarlayarak farklı boyut varyantları (nano'dan ekstra büyüğe) üretmek için bileşik ölçekleme faktörlerini tanımlar.
• kpt_shape poz modelleri için geçerlidir. Bu, [N, 2] için (x, y) anahtar noktalar veya [N, 3] için (x, y, visibility).

Backbone ve Head Mimarisi

Model mimarisi, backbone (özellik çıkarımı) ve head (göreve özel) bölümlerinden oluşur:

backbone:
    # [from, repeats, module, args]
    - [-1, 1, Conv, [64, 3, 2]] # 0: Initial convolution
    - [-1, 1, Conv, [128, 3, 2]] # 1: Downsample
    - [-1, 3, C2f, [128, True]] # 2: Feature processing

head:
    - [-1, 1, nn.Upsample, [None, 2, nearest]] # 6: Upsample
    - [[-1, 2], 1, Concat, [1]] # 7: Skip connection
    - [-1, 3, C2f, [256]] # 8: Process features
    - [[8], 1, Detect, [nc]] # 9: Detection layer

Katman Belirtim Formatı

Her katman tutarlı bir deseni takip eder: [from, repeats, module, args]

Bağlantı Desenleri

from alanı, ağınız boyunca esnek veri akışı modelleri oluşturur:

- [-1, 1, Conv, [64, 3, 2]]    # Takes input from previous layer

- [[-1, 6], 1, Concat, [1]]    # Combines current layer with layer 6

- [[4, 6, 8], 1, Detect, [nc]] # Detection head using 3 feature scales

Modül Tekrarı

repeats parametresi daha derin ağ bölümleri oluşturur:

- [-1, 3, C2f, [128, True]] # Creates 3 consecutive C2f blocks
- [-1, 1, Conv, [64, 3, 2]] # Single convolution layer

Gerçek tekrar sayısı, model boyutu yapılandırmanızdaki derinlik ölçeklendirme faktörü ile çarpılır.

Mevcut Modüller

Modüller işlevselliğe göre düzenlenir ve Ultralytics modül dizininde tanımlanır. Aşağıdaki tablolar, kategoriye göre yaygın olarak kullanılan modülleri göstermektedir; kaynak kodunda çok daha fazlası mevcuttur:

Temel İşlemler

Bileşik Bloklar

Uzmanlaşmış Modüller

Gelişmiş Özellikler

TorchVision Entegrasyonu

TorchVision modülü, herhangi bir TorchVision modelinin bir backbone olarak sorunsuz entegrasyonunu sağlar:

from ultralytics import YOLO

# Model with ConvNeXt backbone
model = YOLO("convnext_backbone.yaml")
results = model.train(data="coco8.yaml", epochs=100)

backbone:
  - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, False]]
head:
  - [-1, 1, Classify, [nc]]

Özellik Seçimi için Dizin Modülü

Birden fazla özellik haritası çıkaran modeller kullanıldığında, Index modülü belirli çıktıları seçer:

backbone:
    - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, True]] # Multi-output
head:
    - [0, 1, Index, [192, 4]] # Select 4th feature map (192 channels)
    - [0, 1, Index, [384, 6]] # Select 6th feature map (384 channels)
    - [0, 1, Index, [768, 8]] # Select 8th feature map (768 channels)
    - [[1, 2, 3], 1, Detect, [nc]] # Multi-scale detection

Modül Çözümleme Sistemi

Ultralytics'ın modülleri nasıl bulduğunu ve içe aktardığını anlamak, özelleştirme için çok önemlidir:

Modül Arama Süreci

Ultralytics, üç katmanlı bir sistem kullanır parse_model:

# Core resolution logic
m = getattr(torch.nn, m[3:]) if "nn." in m else getattr(torchvision.ops, m[4:]) if "ops." in m else globals()[m]

1. PyTorch modülleri: Şununla başlayan isimler 'nn.' → torch.nn ad alanı
2. TorchVision işlemleri: Şununla başlayan isimler 'ops.' → torchvision.ops ad alanı
3. Ultralytics modülleri: Diğer tüm isimler → içe aktarmalar aracılığıyla genel ad alanı

Modül İçe Aktarma Zinciri

Standart modüller, içe aktarmalar aracılığıyla şurada kullanılabilir hale gelir: tasks.py:

from ultralytics.nn.modules import (  # noqa: F401
    SPPF,
    C2f,
    Conv,
    Detect,
    # ... many more modules
    Index,
    TorchVision,
)

Özel Modül Entegrasyonu

Kaynak Kodu Değişikliği

Kaynak kodunu değiştirmek, özel modüllerinizi entegre etmenin en çok yönlü yoludur, ancak zorlayıcı olabilir. Özel bir modül tanımlamak ve kullanmak için şu adımları izleyin:

1. Ultralytics'i geliştirme modunda kurun, Hızlı başlangıç kılavuzu'ndaki Git klonlama yöntemini kullanarak.

2. Modülünüzü tanımlayın içinde ultralytics/nn/modules/block.py:

   class CustomBlock(nn.Module):
       """Custom block with Conv-BatchNorm-ReLU sequence."""
   
       def __init__(self, c1, c2):
           """Initialize CustomBlock with input and output channels."""
           super().__init__()
           self.layers = nn.Sequential(nn.Conv2d(c1, c2, 3, 1, 1), nn.BatchNorm2d(c2), nn.ReLU())
   
       def forward(self, x):
           """Forward pass through the block."""
           return self.layers(x)
   

3. Modülünüzü paket düzeyinde kullanıma açın içinde ultralytics/nn/modules/__init__.py:

   from .block import CustomBlock  # noqa makes CustomBlock available as ultralytics.nn.modules.CustomBlock
   

4. İçe aktarmalara ekleyin içinde ultralytics/nn/tasks.py:

   from ultralytics.nn.modules import CustomBlock  # noqa
   

5. Özel argümanları ele alın (gerekirse) içinde parse_model() içinde ultralytics/nn/tasks.py:

   # Add this condition in the parse_model() function
   if m is CustomBlock:
       c1, c2 = ch[f], args[0]  # input channels, output channels
       args = [c1, c2, *args[1:]]
   

6. Modülü kullanın model yaml dosyanızda:

   # custom_model.yaml
   nc: 1
   backbone:
       - [-1, 1, CustomBlock, [64]]
   head:
       - [-1, 1, Classify, [nc]]
   

7. FLOPs'u kontrol edin ileri geçişin çalıştığından emin olmak için:

   from ultralytics import YOLO
   
   model = YOLO("custom_model.yaml", task="classify")
   model.info()  # should print non-zero FLOPs if working
   

Örnek Yapılandırmalar

Temel detect Modeli

# Simple YOLO detection model
nc: 80
scales:
    n: [0.33, 0.25, 1024]

backbone:
    - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
    - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
    - [-1, 3, C2f, [128, True]] # 2
    - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
    - [-1, 6, C2f, [256, True]] # 4
    - [-1, 1, SPPF, [256, 5]] # 5

head:
    - [-1, 1, Conv, [256, 3, 1]] # 6
    - [[6], 1, Detect, [nc]] # 7

TorchVision backbone Modeli

# ConvNeXt backbone with YOLO head
nc: 80

backbone:
    - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, True]]

head:
    - [0, 1, Index, [192, 4]] # P3 features
    - [0, 1, Index, [384, 6]] # P4 features
    - [0, 1, Index, [768, 8]] # P5 features
    - [[1, 2, 3], 1, Detect, [nc]] # Multi-scale detection

Sınıflandırma Modeli

# Simple classification model
nc: 1000

backbone:
    - [-1, 1, Conv, [64, 7, 2, 3]]
    - [-1, 1, nn.MaxPool2d, [3, 2, 1]]
    - [-1, 4, C2f, [64, True]]
    - [-1, 1, Conv, [128, 3, 2]]
    - [-1, 8, C2f, [128, True]]
    - [-1, 1, nn.AdaptiveAvgPool2d, [1]]

head:
    - [-1, 1, Classify, [nc]]

En İyi Uygulamalar

Mimari Tasarım İpuçları

Basit Başlayın: Özelleştirmeden önce kanıtlanmış mimarilerle başlayın. Mevcut YOLO konfigürasyonlarını şablon olarak kullanın ve sıfırdan oluşturmak yerine kademeli olarak değiştirin.

Kademeli Test Edin: Her değişikliği adım adım doğrulayın. Her seferinde bir özel modül ekleyin ve bir sonraki değişikliğe geçmeden önce çalıştığını doğrulayın.

Kanalları İzleyin: Bağlı katmanlar arasında kanal boyutlarının eşleştiğinden emin olun. Bir katmanın çıkış kanalları (c2) bir sonraki katmanın giriş kanallarıyla (c1) dizideki bir sonraki katmanınkilerle eşleşmelidir.

Atlama Bağlantılarını Kullanın: Özellik yeniden kullanımını şununla değerlendirin: [[-1, N], 1, Concat, [1]] desenleri. Bu bağlantılar, gradyan akışına yardımcı olur ve modelin farklı ölçeklerden gelen özellikleri birleştirmesine olanak tanır.

Uygun Şekilde Ölçeklendirin: Hesaplama kısıtlamalarınıza göre model ölçeklerini seçin. Kenar cihazlar için nano (n) kullanın, küçük (sdengeli performans için) ve daha büyük ölçekler (m, l, xmaksimum doğruluk için).

Performans Değerlendirmeleri

Derinlik ve Genişlik: Derin ağlar, birden fazla dönüşüm katmanı aracılığıyla karmaşık hiyerarşik özellikleri yakalarken, geniş ağlar her katmanda daha fazla bilgiyi paralel olarak işler. Bunları görev karmaşıklığınıza göre dengeleyin.

Atlama Bağlantıları: Eğitim sırasında gradyan akışını iyileştirir ve ağ boyunca özelliklerin yeniden kullanımını sağlar. Özellikle daha derin mimarilerde kaybolan gradyanları önlemek için önemlidirler.

Bottleneck Blokları: Modelin ifade gücünü korurken hesaplama maliyetini azaltır. Gibi modüller C2f özellik öğrenme kapasitesini korurken standart evrişimlerden daha az parametre kullanır.

Çok Ölçekli Özellikler: Aynı görüntüdeki farklı boyutlardaki nesneleri detect etmek için gereklidir. Farklı ölçeklerde birden fazla detect başlığına sahip Özellik Piramit Ağı (FPN) kalıplarını kullanın.

Sorun Giderme

Sık Karşılaşılan Sorunlar

Hata Ayıklama İpuçları

Özel mimariler geliştirirken, sistematik hata ayıklama sorunları erken tespit etmeye yardımcı olur:

Test için Identity Head Kullanın

Karmaşık başlıkları şunlarla değiştirin: nn.Identity backbone sorunlarını izole etmek için:

nc: 1
backbone:
    - [-1, 1, CustomBlock, [64]]
head:
    - [-1, 1, nn.Identity, []] # Pass-through for debugging

Bu, backbone çıktılarının doğrudan incelenmesine olanak tanır:

import torch

from ultralytics import YOLO

model = YOLO("debug_model.yaml")
output = model.model(torch.randn(1, 3, 640, 640))
print(f"Output shape: {output.shape}")  # Should match expected dimensions

Model Mimarisinin İncelenmesi

FLOP sayısını kontrol etmek ve her katmanı yazdırmak, özel model yapılandırmanızla ilgili sorunları ayıklamanıza da yardımcı olabilir. FLOP sayısı, geçerli bir model için sıfır olmamalıdır. Sıfırsa, büyük olasılıkla ileri geçişle ilgili bir sorun vardır. Basit bir ileri geçiş çalıştırmak, karşılaşılan hatayı tam olarak göstermelidir.

from ultralytics import YOLO

# Build model with verbose output to see layer details
model = YOLO("debug_model.yaml", verbose=True)

# Check model FLOPs. Failed forward pass causes 0 FLOPs.
model.info()

# Inspect individual layers
for i, layer in enumerate(model.model.model):
    print(f"Layer {i}: {layer}")

Adım Adım Doğrulama

1. Minimum ile başlayın: Önce mümkün olan en basit mimariyle test edin
2. Aşamalı olarak ekle: Karmaşıklığı katman katman oluşturun
3. Boyutları kontrol edin: Kanal ve uzamsal boyut uyumluluğunu doğrulayın
4. Ölçeklendirmeyi doğrula: Farklı model ölçekleriyle test edin (n, s, m)

SSS

Modelimdeki sınıf sayısını nasıl değiştiririm?

Şunu ayarla: nc YAML dosyanızın en üstündeki parametreyi, veri kümenizin sınıf sayısıyla eşleşecek şekilde ayarlayın.

nc: 5 # 5 classes

Model yaml dosyamda özel bir backbone kullanabilir miyim?

Evet. TorchVision backboneları da dahil olmak üzere desteklenen herhangi bir modülü kullanabilir veya Özel Modül Entegrasyonu'nda açıklandığı gibi kendi özel modülünüzü tanımlayıp içe aktarabilirsiniz.

Modelimi farklı boyutlar (nano, küçük, orta vb.) için nasıl ölçeklendiririm?

Şunu kullanın: scales bölüm derinlik, genişlik ve maksimum kanallar için ölçekleme faktörlerini tanımlamak üzere YAML dosyanızda. Model, temel YAML dosyasını dosya adına eklenmiş ölçekle yüklediğinizde bunları otomatik olarak uygulayacaktır (örn. yolo11n.yaml).

Ne yapar [from, repeats, module, args] ortalama biçim?

Bu format, her katmanın nasıl oluşturulduğunu belirtir:

• from: girdi kaynağı(ları)
• repeats: modülün kaç kez tekrar edileceği
• module: katman türü
• args: modül için argümanlar

Kanal uyumsuzluğu hatalarını nasıl gideririm?

Bir katmanın çıktı kanallarının, bir sonraki katmanın beklenen girdi kanallarıyla eşleştiğini kontrol edin. Şunu kullanın: print(model.model.model) modelinizin mimarisini incelemek için.

Mevcut modüllerin ve argümanlarının listesini nerede bulabilirim?

Kaynak kodunu şurada kontrol edin: ultralytics/nn/modules dizin mevcut tüm modüller ve argümanları için.

yaml yapılandırmama özel bir modül nasıl eklerim?

Modülünüzü kaynak kodunda tanımlayın, Kaynak Kodu Değişikliği'nde gösterildiği gibi içe aktarın ve YAML dosyanızda adıyla başvurun.

Özel bir yaml ile önceden eğitilmiş ağırlıkları kullanabilir miyim?

Evet, kullanabilirsiniz model.load("path/to/weights") ağırlıkları önceden eğitilmiş bir kontrol noktasından yüklemek için. Ancak, yalnızca eşleşen katmanların ağırlıkları başarıyla yüklenecektir.

Model yapılandırmamı nasıl doğrularım?

Kullanım model.info() FLOP sayısının sıfır olup olmadığını kontrol etmek için. Geçerli bir model sıfır olmayan FLOP sayısı göstermelidir. Sıfır ise, içindeki önerileri izleyin Hata Ayıklama İpuçları sorunu bulmak için.

📅 3 ay önce oluşturuldu ✏️ 1 ay önce güncellendi

Yorumlar