Ultralytics ile K-Fold Çapraz Doğrulama#

Giriş#

Bu kapsamlı kılavuz, Ultralytics ekosisteminde nesne tespiti veri kümeleri için K-Katlı Çapraz Doğrulama (K-Fold Cross Validation) uygulamasını göstermektedir. Gerekli kurulum, özellik vektörleri oluşturma süreci ve K-Katlı veri kümesi bölümünün yürütülmesi boyunca sana rehberlik etmek için YOLO algılama formatından ve sklearn, pandas ve PyYAML gibi temel Python kütüphanelerinden yararlanacağız.

Projen ister Meyve Tespiti veri kümesini ister özel bir veri kaynağını içersin, bu eğitim makine öğrenimi modellerinin güvenilirliğini ve sağlamlığını artırmak için K Katlı Çapraz Doğrulamayı kavramana ve uygulamana yardımcı olmayı amaçlar. Bu eğitim için k=5 kat kullanıyor olsak da optimum kat sayısının veri kümene ve projenin özelliklerine bağlı olarak değişebileceğini unutma. K Katlı Çapraz Doğrulama, veri kümen küçük, gürültülü veya son derece değişken olduğunda en yüksek değeri sağlar; büyük, çeşitli veri kümeleri için iyi yapılandırılmış bir eğitim/doğrulama/test bölünmesi genellikle yeterlidir.

Haydi başlayalım.

Kurulum#

• Etiketlerin YOLO algılama formatında olmalıdır.

• Bu rehber, açıklama dosyalarının yerel olarak mevcut olduğunu varsayar.

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

  • Bu veri seti toplam 8479 görsel içermektedir.
  • Her birinin toplam örnek sayıları aşağıda listelenen 6 sınıf etiketi içerir.

• Gerekli Python paketleri şunlardır:

  • ultralytics
  • sklearn
  • pandas
  • pyyaml

• Bu eğitim k=5 kat ile çalışır. Ancak, özel veri kümen için en iyi kat sayısını belirlemelisin.

1. Projen için yeni bir Python sanal ortamı (venv) başlat ve bunu etkinleştir. Kurulum için pip (veya tercih ettiğin paket yöneticisini) kullan:

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

2. Etiketlerinin YOLO algılama formatında olduğunu doğrula.

   • Bu eğitim için tüm etiket dosyaları Fruit-Detection/labels dizininde bulunabilir.

Nesne Tespiti Veri Seti için Özellik Vektörleri Oluşturma#

1. Aşağıdaki adımlar için yeni bir example.py Python dosyası oluşturarak başla.

2. Yapılandırılmış eğitim ve doğrulama görsellerini paket veri seti sahibi aracılığıyla yükle, test bölünmesini ise olduğu gibi bırak.

   from pathlib import Path
   
   from ultralytics.data.dataset import YOLODataset
   from ultralytics.data.utils import check_det_dataset
   
   yaml_file = "path/to/data.yaml"
   data = check_det_dataset(yaml_file)
   dataset_path = Path(data["path"])
   sources = []
   for split in ("train", "val"):
       source = data.get(split)
       if source:
           sources.extend(source if isinstance(source, list) else [source])
   dataset = YOLODataset(sources, data=data, augment=False)
   images = [Path(p) for p in dataset.im_files]

3. Şimdi, veri seti YAML dosyasının içeriğini oku ve sınıf etiketi indekslerini çıkar.

   classes = data["names"]
   cls_idx = sorted(classes.keys())

4. Boş bir pandas DataFrame başlat.

   import pandas as pd
   
   labels_df = pd.DataFrame(0.0, columns=cls_idx, index=images)

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

   from collections import Counter
   
   for image, label in zip(images, dataset.labels):
       lbl_counter = Counter(label["cls"].flatten().astype(int))
       labels_df.loc[image, list(lbl_counter)] = list(lbl_counter.values())

6. Aşağıdakiler, doldurulmuş DataFrame'in örnek bir görünümüdü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 mutlak görsel yollarını kullanır ve sütunlar sınıf etiketi indekslerine karşılık gelir. Eksik etiketler tamamen sıfır arka plan satırları olarak kalır. Bu veri yapısı, bir nesne tespiti veri setine K-Fold Cross Validation uygulanmasını sağlar.

K-Fold Veri Seti Bölme#

1. Şimdi veri kümesinin k bölünmelerini oluşturmak için sklearn.model_selection içindeki KFold sınıfını kullanacağız.

   • Önemli:
     • shuffle=True ayarlanması, bölümlerinizde sınıfların rastgele bir dağılımını sağlar.
     • M seçilen bir tamsayı olduğunda random_state=M değerini ayarlayarak tekrarlanabilir sonuçlar elde edebilirsin.

   from sklearn.model_selection import KFold
   
   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 artık her biri bir train ve val indeksleri listesine sahip olan k katmana bölünmüştür. Bu sonuçları daha net göstermek için bir DataFrame oluşturacağız.

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

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

   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ölme için ve sınıflar arasında makul ölçüde benzer olmasıdır. Ancak bu, veri setinin özelliklerine bağlı olacaktır.

4. Her bölünme için görsel listeleri ve bir veri seti YAML dosyası yaz. Metin listeleri, veri setinin k kez kopyalanmasını önler.

   import yaml
   
   save_path = dataset_path.parent / f"{ksplit}-Fold_Cross-val"
   save_path.mkdir(parents=True, exist_ok=True)
   ds_yamls = []
   
   for split in folds_df.columns:
       for partition in ("train", "val"):
           split_images = folds_df.index[folds_df[split] == partition]
           paths = "\n".join(map(str, split_images))
           (save_path / f"{split}_{partition}.txt").write_text(f"{paths}\n")
   
       dataset_yaml = save_path / f"{split}.yaml"
       ds_yamls.append(dataset_yaml)
       with open(dataset_yaml, "w") as ds_y:
           yaml.safe_dump(
               {
                   "path": save_path.as_posix(),
                   "train": f"{split}_train.txt",
                   "val": f"{split}_val.txt",
                   "names": classes,
               },
               ds_y,
           )

Kayıtları Kaydet (İsteğe bağlı)#

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

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

K-Fold Veri Bölmelerini kullanarak YOLO Eğitimi#

1. İlk olarak, YOLO modelini yükle.

   from ultralytics import YOLO
   
   weights_path = "path/to/weights.pt"  # use yolo26n.pt for a small model
   model = YOLO(weights_path, task="detect")

2. Ardından, eğitimi çalıştırmak için veri kümesi YAML dosyaları üzerinde gezinin. Sonuçlar, project ve name argümanları tarafından belirtilen bir dizine kaydedilecektir. Varsayılan olarak bu dizin, # bir tamsayı indeksi olmak üzere 'runs/detect/train#' şeklindedir.

   results = {}
   
   # Define your additional arguments here
   batch = 16
   project = "kfold_demo"
   epochs = 100
   
   for k, dataset_yaml in enumerate(ds_yamls):
       model = YOLO(weights_path, task="detect")
       results[k] = model.train(
           data=dataset_yaml, epochs=epochs, batch=batch, project=project, name=f"fold_{k + 1}"
       )  # include any additional train arguments

3. Otomatik veri kümesi bölme için Ultralytics data.split.autosplit fonksiyonunu da kullanabilirsin:

   from ultralytics.data.split import autosplit
   
   # Automatically split dataset into train/val/test
   autosplit(path="path/to/images", weights=(0.8, 0.2, 0.0), annotated_only=True)

Sonuç#

Bu kılavuzda, YOLO nesne tespiti modelini eğitmek için K-Fold çapraz doğrulama kullanma sürecini inceledik. Eğitim ve doğrulama havuzunu K bölüme ayırmayı ve rastgele bölme sonrasında sınıf dengesini incelemek için oluşturulan oran tablosunu kullanmayı öğrendik.

Ayrıca veri bölmelerini ve bu bölmelerdeki etiket dağılımlarını görselleştirmek için rapor DataFrame'leri oluşturma prosedürünü inceledik, bu bize eğitim ve doğrulama setlerimizin yapısı hakkında net bir içgörü sağladı.

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

Son olarak, her bir bölmeyi 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-Katlı çapraz doğrulama tekniği, mevcut verilerinden en iyi şekilde yararlanmanın sağlam bir yoludur ve model performansının farklı veri alt kümelerinde güvenilir ve tutarlı olmasını sağlamaya yardımcı olur. Bu, belirli veri modellerine aşırı uyum (overfit) sağlama olasılığı daha düşük olan, daha genelleştirilebilir ve güvenilir bir modelle sonuçlanır.

Bu rehberde YOLO kullansak da, bu adımların çoğunun diğer makine öğrenimi modellerine aktarılabilir olduğunu unutma. Bu adımları anlamak, kendi makine öğrenimi projelerinde çapraz doğrulamayı etkili bir şekilde uygulamanı sağlar.

SSS#