K-Katlı Çapraz Doğrulama ile Ultralytics

Giriş

Bu kapsamlı kılavuz, Ultralytics ekosistemindeki nesne algılama veri kümeleri için K-Kat Çapraz Doğrulama uygulamasını göstermektedir. Gerekli kurulum, özellik vektörleri oluşturma süreci ve K-Fold veri kümesi bölme işleminin yürütülmesinde size rehberlik etmek için YOLO algılama formatından ve sklearn, pandas ve PyYaml gibi temel Python kütüphanelerinden yararlanacağız.

Projeniz ister Fruit Detection veri setini ister özel bir veri kaynağını içersin, bu eğitim makine öğrenimi modellerinizin güvenilirliğini ve sağlamlığını artırmak için K-Kat Çapraz Doğrulamayı anlamanıza ve uygulamanıza yardımcı olmayı amaçlamaktadır. Biz uygularken k=5 Bu eğitim için katlama sayısını belirlerken, optimum katlama sayısının veri setinize ve projenizin özelliklerine bağlı olarak değişebileceğini unutmayın.

Lafı daha fazla uzatmadan içeri dalalım!

Kurulum

• Ek açıklamalarınız YOLO algılama formatında olmalıdır.

• Bu kılavuz ek açıklama dosyalarının yerel olarak mevcut olduğunu varsayar.

• Gösterimiz için Meyve Tespiti veri kümesini kullanıyoruz.

  • Bu veri kümesi toplam 8479 görüntü içermektedir.
  • Her biri aşağıda listelenen toplam örnek sayılarıyla birlikte 6 sınıf etiketi içerir.

• Gerekli Python paketleri şunları içerir:

  • ultralytics
  • sklearn
  • pandas
  • pyyaml

• Bu eğitim şu şekilde çalışır k=5 katlar. Ancak, kendi veri kümeniz için en iyi katlama sayısını belirlemelisiniz.

• Yeni bir Python sanal ortamı başlatın (venv) projeniz için seçin ve etkinleştirin. Kullanım pip (veya tercih ettiğiniz paket yöneticisi) ile yükleyebilirsiniz:

  • Ultralytics kütüphanesi: pip install -U ultralytics. Alternatif olarak, resmi repo.
  • Scikit-learn, pandas ve PyYAML: pip install -U scikit-learn pandas pyyaml.

• Ek açıklamalarınızın YOLO algılama biçiminde olduğunu doğrulayın.

  • Bu eğitim için, tüm ek açıklama dosyaları Fruit-Detection/labels dizin.

Nesne Algılama Veri Kümesi için Özellik Vektörleri Oluşturma

1. Yeni bir Python dosyası oluşturarak başlayın ve gerekli kütüphaneleri içe aktarın.

   import datetime
   import shutil
   from pathlib import Path
   from collections import Counter
   
   import yaml
   import numpy as np
   import pandas as pd
   from ultralytics import YOLO
   from sklearn.model_selection import KFold
   

2. Veri setiniz için tüm etiket dosyalarını almaya devam edin.

   dataset_path = Path('./Fruit-detection') # replace with 'path/to/dataset' for your custom data
   labels = sorted(dataset_path.rglob("*labels/*.txt")) # all data in 'labels'
   

3. Şimdi, veri kümesi YAML dosyasının içeriğini okuyun ve sınıf etiketlerinin indekslerini çıkarın.

   yaml_file = 'path/to/data.yaml'  # your data YAML with data directories and names dictionary
   with open(yaml_file, 'r', encoding="utf8") as y:
       classes = yaml.safe_load(y)['names']
   cls_idx = sorted(classes.keys())
   

4. Boş bir başlatma pandas DataFrame.

   indx = [l.stem for l in labels] # uses base filename as ID (no extension)
   labels_df = pd.DataFrame([], columns=cls_idx, index=indx)
   

5. Ek açıklama dosyalarında bulunan her sınıf etiketinin örneklerini sayın.

   for label in labels:
       lbl_counter = Counter()
   
       with open(label,'r') as lf:
           lines = lf.readlines()
   
       for l in lines:
           # classes for YOLO label uses integer at first position of each line
           lbl_counter[int(l.split(' ')[0])] += 1
   
       labels_df.loc[label.stem] = lbl_counter
   
   labels_df = labels_df.fillna(0.0) # replace `nan` values with `0.0`
   

6. Aşağıda, doldurulmuş DataFrame'in örnek bir görünümü yer almaktadır:

                                                          0    1    2    3    4    5
   '0000a16e4b057580_jpg.rf.00ab48988370f64f5ca8ea4...'  0.0  0.0  0.0  0.0  0.0  7.0
   '0000a16e4b057580_jpg.rf.7e6dce029fb67f01eb19aa7...'  0.0  0.0  0.0  0.0  0.0  7.0
   '0000a16e4b057580_jpg.rf.bc4d31cdcbe229dd022957a...'  0.0  0.0  0.0  0.0  0.0  7.0
   '00020ebf74c4881c_jpg.rf.508192a0a97aa6c4a3b6882...'  0.0  0.0  0.0  1.0  0.0  0.0
   '00020ebf74c4881c_jpg.rf.5af192a2254c8ecc4188a25...'  0.0  0.0  0.0  1.0  0.0  0.0
    ...                                                  ...  ...  ...  ...  ...  ...
   'ff4cd45896de38be_jpg.rf.c4b5e967ca10c7ced3b9e97...'  0.0  0.0  0.0  0.0  0.0  2.0
   'ff4cd45896de38be_jpg.rf.ea4c1d37d2884b3e3cbce08...'  0.0  0.0  0.0  0.0  0.0  2.0
   'ff5fd9c3c624b7dc_jpg.rf.bb519feaa36fc4bf630a033...'  1.0  0.0  0.0  0.0  0.0  0.0
   'ff5fd9c3c624b7dc_jpg.rf.f0751c9c3aa4519ea3c9d6a...'  1.0  0.0  0.0  0.0  0.0  0.0
   'fffe28b31f2a70d4_jpg.rf.7ea16bd637ba0711c53b540...'  0.0  6.0  0.0  0.0  0.0  0.0
   

Satırlar, her biri veri kümenizdeki bir görüntüye karşılık gelen etiket dosyalarını indeksler ve sütunlar sınıf-etiket indekslerinize karşılık gelir. Her satır, veri kümenizde bulunan her sınıf etiketinin sayısıyla birlikte sözde bir özellik vektörünü temsil eder. Bu veri yapısı, bir nesne algılama veri kümesine K-Kat Çapraz Doğrulama uygulanmasını sağlar.

K-Katlı Veri Kümesi Bölme

1. Şimdi kullanacağımız KFold sınıfından sklearn.model_selection üretmek için k veri kümesinin bölünmesi.

   • Önemli:
     • Ayar shuffle=True bölünmelerinizde sınıfların rastgele dağılımını sağlar.
     • Ayarlayarak random_state=M nerede M seçilen bir tamsayı ise, tekrarlanabilir sonuçlar elde edebilirsiniz.

   ksplit = 5
   kf = KFold(n_splits=ksplit, shuffle=True, random_state=20)   # setting random_state for repeatable results
   
   kfolds = list(kf.split(labels_df))
   

2. Veri kümesi şimdi şu bölümlere ayrılmıştır k katlar, her biri bir train ve val endeksler. Bu sonuçları daha net bir şekilde görüntülemek için bir DataFrame oluşturacağız.

   folds = [f'split_{n}' for n in range(1, ksplit + 1)]
   folds_df = pd.DataFrame(index=indx, columns=folds)
   
   for idx, (train, val) in enumerate(kfolds, start=1):
       folds_df[f'split_{idx}'].loc[labels_df.iloc[train].index] = 'train'
       folds_df[f'split_{idx}'].loc[labels_df.iloc[val].index] = 'val'
   

3. Şimdi her bir kat için sınıf etiketlerinin dağılımını, mevcut sınıfların bir oranı olarak hesaplayacağız. val orada bulunanlara train.

   fold_lbl_distrb = pd.DataFrame(index=folds, columns=cls_idx)
   
   for n, (train_indices, val_indices) in enumerate(kfolds, start=1):
       train_totals = labels_df.iloc[train_indices].sum()
       val_totals = labels_df.iloc[val_indices].sum()
   
       # To avoid division by zero, we add a small value (1E-7) to the denominator
       ratio = val_totals / (train_totals + 1E-7)
       fold_lbl_distrb.loc[f'split_{n}'] = ratio
   

İdeal senaryo, tüm sınıf oranlarının her bölünme için ve sınıflar arasında makul ölçüde benzer olmasıdır. Ancak bu, veri setinizin özelliklerine bağlı olacaktır.

1. Ardından, her bir bölünme için dizinleri ve veri kümesi YAML dosyalarını oluşturuyoruz.

   supported_extensions = ['.jpg', '.jpeg', '.png']
   
   # Initialize an empty list to store image file paths
   images = []
   
   # Loop through supported extensions and gather image files
   for ext in supported_extensions:
       images.extend(sorted((dataset_path / 'images').rglob(f"*{ext}")))
   
   # Create the necessary directories and dataset YAML files (unchanged)
   save_path = Path(dataset_path / f'{datetime.date.today().isoformat()}_{ksplit}-Fold_Cross-val')
   save_path.mkdir(parents=True, exist_ok=True)
   ds_yamls = []
   
   for split in folds_df.columns:
       # Create directories
       split_dir = save_path / split
       split_dir.mkdir(parents=True, exist_ok=True)
       (split_dir / 'train' / 'images').mkdir(parents=True, exist_ok=True)
       (split_dir / 'train' / 'labels').mkdir(parents=True, exist_ok=True)
       (split_dir / 'val' / 'images').mkdir(parents=True, exist_ok=True)
       (split_dir / 'val' / 'labels').mkdir(parents=True, exist_ok=True)
   
       # Create dataset YAML files
       dataset_yaml = split_dir / f'{split}_dataset.yaml'
       ds_yamls.append(dataset_yaml)
   
       with open(dataset_yaml, 'w') as ds_y:
           yaml.safe_dump({
               'path': split_dir.as_posix(),
               'train': 'train',
               'val': 'val',
               'names': classes
           }, ds_y)
   

2. Son olarak, görüntüleri ve etiketleri her bir bölünme için ilgili dizine ('train' veya 'val') kopyalayın.

   • NOT: Kodun bu kısmı için gereken süre, veri kümenizin boyutuna ve sistem donanımınıza bağlı olarak değişecektir.

   for image, label in zip(images, labels):
       for split, k_split in folds_df.loc[image.stem].items():
           # Destination directory
           img_to_path = save_path / split / k_split / 'images'
           lbl_to_path = save_path / split / k_split / 'labels'
   
           # Copy image and label files to new directory (SamefileError if file already exists)
           shutil.copy(image, img_to_path / image.name)
           shutil.copy(label, lbl_to_path / label.name)
   

Kayıtları Kaydet (İsteğe Bağlı)

İsteğe bağlı olarak, K-Fold bölme ve etiket dağıtım DataFrame'lerinin kayıtlarını ileride başvurmak üzere CSV dosyaları olarak kaydedebilirsiniz.

folds_df.to_csv(save_path / "kfold_datasplit.csv")
fold_lbl_distrb.to_csv(save_path / "kfold_label_distribution.csv")

K-Katlı Veri Bölmeleri kullanarak YOLO 'u eğitin

1. İlk olarak YOLO modelini yükleyin.

   weights_path = 'path/to/weights.pt'
   model = YOLO(weights_path, task='detect')
   

2. Ardından, eğitimi çalıştırmak için veri kümesi YAML dosyaları üzerinde yineleyin. Sonuçlar şu şekilde belirtilen bir dizine kaydedilecektir project ve name argümanlar. Varsayılan olarak bu dizin 'exp/runs#' şeklindedir ve burada # bir tamsayı dizinidir.

   results = {}
   
   # Define your additional arguments here
   batch = 16
   project = 'kfold_demo'
   epochs = 100
   
   for k in range(ksplit):
       dataset_yaml = ds_yamls[k]
       model.train(data=dataset_yaml,epochs=epochs, batch=batch, project=project)  # include any train arguments
       results[k] = model.metrics  # save output metrics for further analysis
   

Sonuç

Bu kılavuzda, YOLO nesne algılama modelini eğitmek için K-Kat çapraz doğrulama kullanma sürecini inceledik. Farklı katlar arasında dengeli bir sınıf dağılımı sağlayarak veri kümemizi K bölümlerine nasıl ayıracağımızı öğrendik.

Ayrıca, eğitim ve doğrulama setlerimizin yapısı hakkında net bir fikir edinmemizi sağlayan veri bölünmelerini ve bu bölünmelerdeki etiket dağılımlarını görselleştirmek için rapor DataFrames oluşturma prosedürünü de araştırdık.

İsteğe bağlı olarak, kayıtlarımızı ileride başvurmak üzere kaydettik; bu, özellikle büyük ölçekli projelerde veya model performansında sorun giderirken yararlı olabilir.

Son olarak, her bir bölünmeyi bir döngü içinde kullanarak gerçek model eğitimini uyguladık ve eğitim sonuçlarımızı daha fazla analiz ve karşılaştırma için kaydettik.

Bu K-Kat çapraz doğrulama tekniği, elinizdeki verilerden en iyi şekilde yararlanmanın sağlam bir yoludur ve model performansınızın farklı veri alt kümeleri arasında güvenilir ve tutarlı olmasını sağlamaya yardımcı olur. Bu, belirli veri modellerine aşırı uyum sağlama olasılığı daha düşük olan daha genelleştirilebilir ve güvenilir bir modelle sonuçlanır.

Bu kılavuzda YOLO adresini kullanmamıza rağmen, bu adımların çoğunlukla diğer makine öğrenimi modellerine de aktarılabileceğini unutmayın. Bu adımları anlamak, kendi makine öğrenimi projelerinizde çapraz doğrulamayı etkili bir şekilde uygulamanıza olanak tanır. Mutlu kodlamalar!

Yorumlar