Ultralytics ile K-Katlı Çapraz Doğrulama#

Giriş#

Bu kapsamlı kılavuz, Ultralytics ekosistemindeki nesne algılama veri kümeleri için K-Katlı Çapraz Doğrulamanın uygulanışını gösterir. Gerekli kurulumu, özellik vektörlerinin oluşturulmasını ve K-Katlı veri kümesi bölme işlemini adım adım açıklamak için YOLO algılama biçiminden ve sklearn, pandas ve PyYAML gibi temel Python kütüphanelerinden yararlanacağız.

Projen Fruit Detection veri kümesini ya da özel bir veri kaynağını içeriyor olsun, bu eğitim K-Katlı Çapraz Doğrulamayı anlamana ve uygulamana yardımcı olarak makine öğrenimi modellerinin güvenilirliğini ve sağlamlığını artırmayı amaçlar. Bu eğitimde k=5 kat kullanacak olsak da en uygun kat sayısının veri kümesine ve projenin özelliklerine göre değişebileceğini unutma. K-Katlı Çapraz Doğrulama; veri kümen küçük, gürültülü veya yüksek değişkenlik gösterdiğinde en çok faydayı sağlar; büyük ve çeşitli veri kümeleri için iyi tasarlanmış bir train/val/test bölmesi genellikle yeterlidir.

Başlayalım.

Kurulum#

• Ek açıklamaların YOLO algılama biçiminde olmalıdır.

• Bu kılavuzda ek açıklama dosyalarının yerel olarak erişilebilir olduğu varsayılır.

• Örneğimizde Fruit Detection veri kümesini kullanıyoruz.

  • Bu veri kümesinde toplam 8479 görüntü bulunur.
  • Veri kümesi 6 sınıf etiketi içerir ve her sınıfın toplam örnek sayısı aşağıda listelenmiştir.

• Gerekli Python paketleri:

  • ultralytics
  • sklearn
  • pandas
  • pyyaml

• Bu eğitimde k=5 kat kullanılır. Ancak kendi veri kümen için en uygun kat sayısını belirlemelisin.

1. Projen için yeni bir Python sanal ortamı (venv) oluşturup etkinleştir. Yüklemek için pip (veya tercih ettiğin paket yöneticisini) kullan:

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

2. Ek açıklamalarının YOLO algılama biçiminde olduğunu doğrula.

   • Bu eğitimde tüm ek açıklama dosyaları Fruit-Detection/labels dizininde bulunur.

Nesne Algılama Veri Kümesi 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örüntülerini paket veri kümesi sahibi aracılığıyla yükle; test bölümüne dokunma.

   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 kümesinin YAML dosyasını oku ve sınıf etiketlerinin indekslerini çıkar.

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

4. Boş bir pandas DataFrame'i başlat.

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

5. Ek açıklama dosyalarındaki her 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. Doldurulmuş DataFrame'in örnek görünümü aşağıdadı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ırlarda mutlak görüntü yolları, sütunlarda ise sınıf etiketi indeksleri yer alır. Eksik etiketler, tüm değerleri sıfır olan arka plan satırları olarak kalır. Bu veri yapısı, nesne algılama veri kümesine K-Katlı Çapraz Doğrulama uygulanmasını sağlar.

K-Katlı Veri Kümesi Bölmesi#

1. Şimdi veri kümesini k bölüme ayırmak için sklearn.model_selection içindeki KFold sınıfını kullanacağız.

   • Önemli:
     • shuffle=True ayarı, bölümlerde sınıfların rastgele dağıtılmasını sağlar.
     • M seçilen bir tam sayı olduğunda random_state=M ayarını yaparak tekrarlanabilir sonuçlar elde edebilirsin.

   from sklearn.model_selection import KFold
   
   ksplit = 5
   kf = KFold(n_splits=ksplit, shuffle=True, random_state=20)  # tekrarlanabilir sonuçlar için random_state ayarlanıyor
   
   kfolds = list(kf.split(labels_df))

2. Veri kümesi artık k kata bölündü; her katta train ve val indekslerinden oluşan bir liste bulunuyor. Sonuçları daha net 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=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 her kat için sınıf etiketlerinin dağılımını, val içindeki sınıfların train içindeki sınıflara oranı olarak 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 durumda tüm sınıf oranları her bölmede ve sınıflar arasında makul ölçüde benzer olmalıdır. Ancak bu, veri kümenin özelliklerine bağlıdır.

4. Her bölme için görüntü listelerini ve bir veri kümesi YAML dosyası yaz. Metin listeleri, veri kümesini k kez kopyalama ihtiyacını ortadan kaldırır.

   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ı Kaydetme (İsteğe Bağlı)#

İstersen K-Katlı 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-Katlı Veri Bölmeleriyle YOLO Eğitme#

1. Önce YOLO modelini yükle.

   from ultralytics import YOLO
   
   weights_path = "path/to/weights.pt"  # küçük bir model için yolo26n.pt kullan
   model = YOLO(weights_path, task="detect")

2. Ardından eğitimi çalıştırmak için veri kümesi YAML dosyalarını sırayla işle. Sonuçlar, project ve name bağımsız değişkenleriyle belirtilen dizine kaydedilir. Varsayılan olarak bu dizin, # işaretinin bir tam sayı indeksi olduğu 'runs/detect/train#' dizinidir.

   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 işlevini de kullanabilirsin:

   from ultralytics.data.split import autosplit
   
   # Veri kümesini otomatik olarak train/val/test bölümlerine ayır
   autosplit(path="path/to/images", weights=(0.8, 0.2, 0.0), annotated_only=True)

Sonuç#

Bu kılavuzda, YOLO nesne algılama modelini eğitmek için K-Katlı çapraz doğrulama kullanımını 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 yöntemini inceledik; böylece eğitim ve doğrulama kümelerimizin yapısı hakkında net bir fikir edindik.

Kayıtlarımızı isteğe bağlı olarak ileride başvurmak üzere kaydettik. Bu, büyük ölçekli projelerde veya model performansıyla ilgili sorunları giderirken özellikle yararlı olabilir.

Son olarak, her bölmeyi bir döngüde kullanarak model eğitimini uyguladık ve eğitim sonuçlarımızı daha sonra analiz ve karşılaştırma yapmak üzere kaydettik.

Bu K-Katlı çapraz doğrulama tekniği, elindeki verilerden en iyi şekilde yararlanmanın sağlam bir yoludur ve farklı veri alt kümelerinde model performansının güvenilir ve tutarlı olmasını sağlamaya yardımcı olur. Böylece belirli veri örüntülerine aşırı uyum gösterme olasılığı daha düşük, genelleme kabiliyeti ve güvenilirliği daha yüksek bir model elde edilir.

Bu kılavuzda YOLO kullanmış olsak da bu adımların çoğunun diğer makine öğrenimi modellerine de uygulanabileceğini unutma. Bu adımları anlamak, kendi makine öğrenimi projelerinde çapraz doğrulamayı etkili biçimde uygulamanı sağlar.

Sık Sorulan Sorular#