Model YAML Yapılandırması

Model YAML yapılandırma dosyası, Ultralytics sinir ağları için mimari plan olarak hizmet eder. 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.

Konfigürasyon Yapısı

Model YAML dosyaları, mimariyi tanımlamak için birlikte çalışan üç ana bölüm halinde düzenlenmiştir.

Parametreler Bölümü

Parametreler bölümü modelin global ö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 Farklı boyut varyantları (nano ila ekstra büyük) üretmek için model derinliğini, genişliğini ve maksimum kanalları ayarlayan bileşik ölçeklendirme faktörlerini tanımlayın.
• kpt_shape poz modelleri için geçerlidir. Bu olabilir [N, 2] için (x, y) anahtar noktalar veya [N, 3] için (x, y, visibility).

Backbone ve Kafa Mimarisi

Model mimarisi backbone (özellik çıkarma) ve kafa (göreve özgü) bölümlerinden oluşmaktadır:

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 Spesifikasyon Formatı

Her katman tutarlı bir model izler: [from, repeats, module, args]

Bağlantı Kalıpları

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ülleri dizininde tanımlanır. Aşağıdaki tablolarda kategorilere göre yaygın olarak kullanılan modüller gösterilmektedir ve kaynak kodunda çok daha fazlası mevcuttur:

Temel İşlemler

Kompozit Bloklar

Özel Modüller

Gelişmiş Özellikler

TorchVision Entegrasyonu

TorchVision modülü, herhangi bir TorchVision modelinin backbone olarak sorunsuz bir şekilde entegre edilmesini 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ı çıktısı veren modeller kullanıldığında, Dizin 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 'in 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: ile başlayan isimler 'nn.' → torch.nn ad alanı
2. TorchVision operasyonları: ile başlayan isimler 'ops.' → torchvision.ops ad alanı
3. Ultralytics modülleri: Diğer tüm adlar → içe aktarmalar yoluyla küresel ad alanı

Modül İçe Aktarma Zinciri

Standart modüller şuradaki içe aktarmalar yoluyla kullanılabilir hale gelir tasks.py:

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

Özel Modül Entegrasyonu

Kaynak Kod Değişikliği

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

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

   class CustomBlock(nn.Module):
       def __init__(self, c1, c2):
           super().__init__()
           self.layers = nn.Sequential(nn.Conv2d(c1, c2, 3, 1, 1), nn.BatchNorm2d(c2), nn.ReLU())
   
       def forward(self, x):
           return self.layers(x)
   

2. Modülünüzü paket düzeyinde gösterin içinde ultralytics/nn/modules/__init__.py:

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

3. İthal ürünlere ekle içinde ultralytics/nn/tasks.py:

   from ultralytics.nn.modules import CustomBlock  # noqa
   

4. Özel argümanları işleme (gerekirse) içeride parse_model() içinde ultralytics/nn/tasks.py:

   elif m is CustomBlock:
       c1, c2 = ch[f], args[0]  # input channels, output channels
       args = [c1, c2, *args[1:]]
   

5. Modülü model YAML'nizde kullanın:

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

6. İleri geçişin çalıştığından emin olmak için FLOP'ları kontrol edin:

   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 Algılama 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 aşamalı olarak değiştirin.

Aşamalı olarak 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ı İzleme: Kanal boyutlarının bağlı katmanlar arasında eşleştiğinden emin olun. Çıkış kanalları (c2) bir katmanın giriş kanallarıyla (c1) sıradaki bir sonraki katmanın.

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

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

Performans Değerlendirmeleri

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

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

Darboğaz Blokları: Model ifadesini korurken hesaplama maliyetini azaltın. Gibi modüller C2f özellik öğrenme kapasitesini korurken standart konvolüsyonlardan daha az parametre kullanır.

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

Sorun Giderme

Sık Karşılaşılan Sorunlar

Hata Ayıklama İpuçları

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

Test için Identity Head kullanın

Karmaşık başlıkları aşağıdakilerle 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 çıkış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 Mimarisi Denetimi

FLOPs 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. FLOPs sayısı geçerli bir model için sıfırdan farklı olmalıdır. Sıfırsa, muhtemelen 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. Minimal başlayın: Önce mümkün olan en basit mimari ile test edin
2. Aşamalı olarak ekleyin: Karmaşıklığı katman katman oluşturun
3. Boyutları kontrol edin: Kanal ve uzamsal boyut uyumluluğunu doğrulayın
4. Ölçeklendirmeyi doğrulayın: Farklı model ölçekleri ile test edin (n, s, m)

SSS

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

Ayarlamak nc parametresini veri kümenizin sınıf sayısıyla eşleşecek şekilde YAML dosyanızın en üstüne ekleyin.

nc: 5 # 5 classes

YAML modelimde özel bir backbone kullanabilir miyim?

TorchVision omurgaları da dahil olmak üzere desteklenen herhangi bir modülü kullanabilir veya kendi özel modülünüzü tanımlayabilir ve Özel Modül Entegrasyonu bölümünde açıklandığı gibi içe aktarabilirsiniz.

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

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

Ne yapar [from, repeats, module, args] format ne demek?

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

• from: giriş kaynak(lar)ı
• repeats: modülün kaç kez tekrarlanacağı
• module: katman türü
• args: modül için argümanlar

Kanal uyuşmazlığı hatalarını nasıl gideririm?

Bir katmanın çıkış kanallarının bir sonrakinin beklenen giriş kanallarıyla eşleşip eşleşmediğini kontrol edin. Kullanım print(model.model.model) modelinizin mimarisini incelemek için.

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

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

YAML yapılandırmama nasıl özel bir modül ekleyebilirim?

Modülünüzü kaynak kodda tanımlayın, Kaynak Kod Değişikliği bölümünde gösterildiği gibi içe aktarın ve YAML dosyanızda adıyla referans verin.

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

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

Model yapılandırmamı nasıl doğrulayabilirim?

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

📅 0 gün önce oluşturuldu ✏️ 0 gün önce güncellendi