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 uygulanmasını gösterir. Gerekli kurulumu, özellik vektörlerinin oluşturulma sürecini ve K katlı veri kümesi bölme işleminin yürütülmesini açıklamak için YOLO algılama biçiminden ve sklearn, pandas ve PyYAML gibi temel Python kitaplıklarından yararlanacağız.

Projen Fruit Detection veri kümesini veya özel bir veri kaynağını içeriyor olsun, bu eğitim K Katlı Çapraz Doğrulamayı anlayıp uygulamana ve makine öğrenimi modellerinin güvenilirliğini ve sağlamlığını artırmana yardımcı olmayı amaçlar. Bu eğitimde k=5 kat kullanacak olsak da en uygun kat sayısının veri kümen 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 oldukça değişken olduğunda en fazla faydayı sağlar; büyük ve çeşitli veri kümeleri için iyi oluşturulmuş 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ılavuz, ek açıklama dosyalarının yerel olarak kullanılabilir olduğunu varsayar.

• Gösterimimizde Fruit Detection veri kümesini kullanıyoruz.

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

• Gerekli Python paketleri şunlardır:

  • ultralytics
  • sklearn
  • pandas
  • pyyaml

• Bu eğitim k=5 kat ile çalışı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ştur ve etkinleştir. Kurulum yapmak için pip (veya tercih ettiğin paket yöneticisini) kullan:

   • Ultralytics kitaplığı: pip install -U ultralytics. Alternatif olarak resmi 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 üzerinden yükle ve test bölmesini değiştirme.

   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ümesi YAML dosyasının içeriğini oku ve sınıf etiketlerinin dizinlerini çı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ında bulunan 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ı kullanılır ve sütunlar sınıf etiketi dizinlerine karşılık gelir. Eksik etiketler tamamen sıfırlardan oluşan arka plan satırları olarak kalır. Bu veri yapısı, bir nesne algılama veri kümesine K Katlı Çapraz Doğrulama uygulanmasını sağlar.

K Katlı Veri Kümesi Bölme#

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

   • Önemli:
     • shuffle=True değerini ayarlamak, bölmelerindeki sınıfların rastgele dağıtılmasını sağlar.
     • M seçilmiş bir tam sayı 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 k kata bölündü; her katta train ve val dizinlerinden oluşan bir liste bulunuyor. Bu sonuçları daha anlaşılır ş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=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çinde bulunan sınıfların train içinde bulunan 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 her bölmede ve sınıflar arasında tüm sınıf oranları makul ölçüde benzer olmalıdır. Ancak bu durum veri kümenin özelliklerine bağlı olacaktır.

4. Her bölme için görüntü listeleri ve bir veri kümesi YAML dosyası yaz. Metin listeleri, veri kümesini k kez kopyalamaktan kaçını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ı Kaydet (İsteğe Bağlı)#

İsteğe bağlı olarak 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ğitimi#

1. Öncelikle 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ğitim çalıştırmak için veri kümesi YAML dosyaları üzerinde yinele. Sonuçlar project ve name bağımsız değişkenleriyle belirtilen bir dizine kaydedilir. Varsayılan olarak bu dizin, # işaretinin bir tam sayı dizini 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. Veri kümesini otomatik olarak bölmek için Ultralytics data.split.autosplit işlevini de 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 algılama modelini eğitmek için K katlı ç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 sürecini inceledik; bu sayede eğitim ve doğrulama kümelerimizin yapısını net bir şekilde görebildik.

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

Son olarak, her bölmeyi bir döngüde kullanarak gerçek model eğitimini uyguladık ve eğitim sonuçlarımızı daha ayrıntılı 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. Bunun sonucunda, belirli veri örüntülerine aşırı uyum sağlama olasılığı daha düşük, genellenebilirliği 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 aktarılabileceğini unutma. Bu adımları anlaman, çapraz doğrulamayı kendi makine öğrenimi projelerinde etkili biçimde uygulamana olanak tanır.

SSS#