İçeriğe geç

YOLOv5'te Dondurulmuş Katmanlarla Transfer Öğrenimi

📚 Bu kılavuz, transfer öğrenimi uygularken YOLOv5 🚀 katmanlarını nasıl donduracağınızı açıklar. Transfer öğrenimi, tüm ağı sıfırdan yeniden eğitmeden yeni veriler üzerinde bir modeli hızla yeniden eğitmenize olanak tanıyan güçlü bir makine öğrenimi (ML) tekniğidir. İlk katmanların ağırlıklarını dondurarak ve yalnızca sonraki katmanların parametrelerini güncelleyerek, hesaplama kaynağı gereksinimlerini ve eğitim süresini önemli ölçüde azaltabilirsiniz. Ancak, bu yaklaşım nihai modelin doğruluğunu biraz etkileyebilir.

Başlamadan Önce

İlk olarak, YOLOv5 deposunu klonlayın ve içinde listelenen gerekli bağımlılıkları kurun requirements.txt. Bir tane olduğundan emin olun Python>=3.8.0 ortamı ile PyTorch>=1.8 kuruldu. Önceden eğitilmiş modeller ve gerekli veri kümeleri en son YOLOv5'ten otomatik olarak indirilecektir sürüm.

git clone https://github.com/ultralytics/yolov5 # clone repository
cd yolov5
pip install -r requirements.txt # install dependencies

Katman Dondurma Nasıl Çalışır

Bir katmanları dondurduğunuzda sinir ağı, parametrelerinin (ağırlıklar ve sapmalar) eğitim sürecinde güncellenmesini önlersiniz. PyTorch'de bu, şunu ayarlayarak elde edilir: requires_grad katman tensörlerinin özelliği False. Sonuç olarak, bu katmanlar için eğitim sırasında gradyanlar hesaplanmaz geri yayılım (backpropagation), hesaplama ve bellek tasarrufu sağlar.

İşte YOLOv5'in eğitim betiğinde katman dondurmayı nasıl uyguladığı:

# Freeze specified layers
freeze = [f"model.{x}." for x in range(freeze)]  # Define layers to freeze based on module index
for k, v in model.named_parameters():
    v.requires_grad = True  # Ensure all parameters are initially trainable
    if any(x in k for x in freeze):
        print(f"Freezing layer: {k}")
        v.requires_grad = False  # Disable gradient calculation for frozen layers

Model Mimarisi Keşfi

Hangi katmanların dondurulacağına karar vermek için YOLOv5 modelinin yapısını anlamak çok önemlidir. Aşağıdaki Python kod parçacığını kullanarak tüm modüllerin adlarını ve parametrelerini inceleyebilirsiniz:

# Assuming 'model' is your loaded YOLOv5 model instance
for name, param in model.named_parameters():
    print(name)

"""
Example Output:
model.0.conv.conv.weight
model.0.conv.bn.weight
model.0.conv.bn.bias
model.1.conv.weight
model.1.bn.weight
model.1.bn.bias
model.2.cv1.conv.weight
model.2.cv1.bn.weight
...
"""

YOLOv5 mimarisi tipik olarak özellik çıkarımından sorumlu bir backbone (YOLOv5s/m/l/x gibi standart konfigürasyonlarda 0-9 katmanları) ve nesne algılamayı gerçekleştiren bir başlıktan (kalan katmanlar) oluşur.

# Example YOLOv5 v6.0 backbone structure
backbone:
    # [from, number, module, args]
    - [-1, 1, Conv, [64, 6, 2, 2]]  # Layer 0: Initial convolution (P1/2 stride)
    - [-1, 1, Conv, [128, 3, 2]] # Layer 1: Downsampling convolution (P2/4 stride)
    - [-1, 3, C3, [128]]          # Layer 2: C3 module
    - [-1, 1, Conv, [256, 3, 2]] # Layer 3: Downsampling convolution (P3/8 stride)
    - [-1, 6, C3, [256]]          # Layer 4: C3 module
    - [-1, 1, Conv, [512, 3, 2]] # Layer 5: Downsampling convolution (P4/16 stride)
    - [-1, 9, C3, [512]]          # Layer 6: C3 module
    - [-1, 1, Conv, [1024, 3, 2]]# Layer 7: Downsampling convolution (P5/32 stride)
    - [-1, 3, C3, [1024]]         # Layer 8: C3 module
    - [-1, 1, SPPF, [1024, 5]]    # Layer 9: Spatial Pyramid Pooling Fast

# Example YOLOv5 v6.0 head structure
head:
    - [-1, 1, Conv, [512, 1, 1]] # Layer 10
    - [-1, 1, nn.Upsample, [None, 2, "nearest"]] # Layer 11
    - [[-1, 6], 1, Concat, [1]] # Layer 12: Concatenate with backbone P4 (from layer 6)
    - [-1, 3, C3, [512, False]] # Layer 13: C3 module
    # ... subsequent head layers for feature fusion and detection

Dondurma Seçenekleri

Hangi katmanların dondurulacağını kontrol etmek için şunu kullanabilirsiniz: --freeze eğitim komutundaki argümanı. Bu argüman, ilk dondurulmamış modül; bu dizinden önceki tüm modüllerin ağırlıkları dondurulacaktır.

Sadece Backbone'u Dondur

COCO gibi büyük bir veri kümesinden öğrenilen genel özellik çıkarma yeteneklerini korurken modeli yeni nesne sınıflarına uyarlarken yaygın olan tüm backbone'u (0'dan 9'a kadar olan katmanlar) dondurmak için:

python train.py --weights yolov5m.pt --data your_dataset.yaml --freeze 10

Bu strateji, hedef veri kümeniz orijinal eğitim verileriyle (örneğin, COCO) benzer düşük seviyeli görsel özellikler (kenarlar, dokular) paylaştığında ancak farklı nesne kategorileri içerdiğinde etkilidir.

Son Algılama Katmanları Hariç Tümünü Dondur

Ağın neredeyse tamamını dondurmak için, yalnızca son çıktı evrişim katmanlarını bırakarak (şunun bir parçası Detect modülü, tipik olarak son modül, örneğin YOLOv5s'de 24 numaralı modül) eğitilebilir:

python train.py --weights yolov5m.pt --data your_dataset.yaml --freeze 24

Bu yaklaşım, öğrenilmiş özelliklerin büyük çoğunluğunu sağlam tutarken modeli öncelikle farklı sayıda çıktı sınıfına göre ayarlamanız gerektiğinde kullanışlıdır. İnce ayar için en az işlem kaynağı gerektirir.

Performans Karşılaştırması

Katmanları dondurmanın etkilerini göstermek için, YOLOv5m'yi şunun üzerinde eğittik: Pascal VOC veri kümesi için 50 epok, resmi COCO önceden eğitilmiş modelinden başlayarak ağırlıklar (yolov5m.pt). Üç senaryoyu karşılaştırdık: tüm katmanları eğitme (--freeze 0), backbone'u dondurma (--freeze 10), ve son algılama katmanları dışındaki her şeyi dondurarak (--freeze 24).

# Example command for training with backbone frozen
python train.py --batch 48 --weights yolov5m.pt --data voc.yaml --epochs 50 --cache --img 512 --hyp hyp.finetune.yaml --freeze 10

Doğruluk Sonuçları

Sonuçlar, katmanları dondurmanın eğitimi önemli ölçüde hızlandırabileceğini, ancak nihai mAP (ortalama Ortalama Hassasiyet)'de hafif bir azalmaya yol açabileceğini göstermektedir. Tüm katmanları eğitmek genellikle en iyi doğruluğu sağlarken, daha fazla katmanı dondurmak potansiyel olarak daha düşük performans pahasına daha hızlı eğitim sunar.

Farklı dondurma stratejilerini karşılaştıran eğitim mAP50 sonuçları Eğitim sırasında mAP50 karşılaştırması

Farklı dondurma stratejilerini karşılaştıran eğitim mAP50-95 sonuçları Eğitim sırasında mAP50-95 karşılaştırması

Performans sonuçlarını özetleyen tablo Performans metriklerinin özet tablosu

Kaynak Kullanımı

Daha fazla katmanın dondurulması, GPU bellek gereksinimlerini ve genel kullanımı önemli ölçüde azaltır. Bu, dondurulmuş katmanlarla transfer öğrenimini, sınırlı donanım kaynaklarıyla çalışırken cazip bir seçenek haline getirir ve normalde mümkün olandan daha büyük modellerin eğitilmesine veya daha büyük görüntü boyutlarının kullanılmasına olanak tanır.

Eğitim sırasında ayrılan GPU bellek yüzdesi GPU Belleği Tahsis Edildi (%)

Eğitim sırasında GPU bellek kullanım yüzdesi GPU Kullanımı (%)

Katman Dondurmayı Ne Zaman Kullanmalı

Transfer öğrenimi sırasında katman dondurma, özellikle çeşitli durumlarda avantajlıdır:

  1. Sınırlı Hesaplama Kaynakları: GPU belleği veya işlem gücü konusunda kısıtlamalarınız varsa.
  2. Küçük Veri Kümeleri: Hedef veri kümeniz, orijinal ön eğitim veri kümesinden önemli ölçüde küçük olduğunda, dondurma aşırı uyumu önlemeye yardımcı olur.
  3. Hızlı Prototipleme: Mevcut bir modeli ilk değerlendirme için yeni bir göreve veya alana hızla uyarlamanız gerektiğinde.
  4. Benzer Özellik Alanları: Yeni veri kümenizdeki düşük seviyeli özellikler, modelin önceden eğitildiği veri kümesindekilere çok benziyorsa.

Sözlük girdimizde transfer öğreniminin nüansları hakkında daha fazla bilgi edinin ve performansı optimize etmek için hiperparametre ayarlama gibi teknikleri göz önünde bulundurun.

Desteklenen Ortamlar

Ultralytics, CUDA, CuDNN, Python ve PyTorch gibi temel bağımlılıkların önceden yüklü olduğu çeşitli kullanıma hazır ortamlar sunar.

Proje Durumu

YOLOv5, özellikle daha küçük varyantları (YOLOv5n, YOLOv5s) hem CPU hem de GPU (TensorRT) üzerinde mükemmel çıkarım hızı göstererek, gerçek zamanlı ve uç dağıtımı için oldukça uygundur. DAMO-YOLO, rekabetçi mAP puanları elde eder ve büyük varyantı mAP<sup wg-1="">val</sup> 50-95'te YOLOv5x'i hafifçe geride bırakır, ancak bildirilen CPU çıkarım hızlarından yoksundur, bu da potansiyel olarak GPU performansına odaklandığını gösterir. YOLOv5, hız, boyut ve doğruluğu dengeleme konusunda esneklik sağlayan daha geniş bir model yelpazesi sunar.

Bu rozet, tüm YOLOv5 GitHub Actions Sürekli Entegrasyon (CI) testlerinin başarıyla geçtiğini doğrular. Bu CI testleri, YOLOv5'in temel işlemler üzerindeki işlevselliğini ve performansını titizlikle değerlendirir: eğitim, doğrulama, çıkarım, dışa aktarma ve kıyaslamalar. macOS, Windows ve Ubuntu'da tutarlı ve güvenilir çalışma sağlarlar, her 24 saatte bir ve her yeni kod kaydında otomatik olarak çalışırlar.



📅 1 yıl önce oluşturuldu ✏️ 4 ay önce güncellendi

Yorumlar