Başla

Ultralytics ile K-Katlı Çapraz Doğrulama

Giriş#

Bu kılavuz, Ultralytics ekosistemindeki nesne algılama veri kümeleri için K-Katlı Çapraz Doğrulamayı nasıl uygulayacağını gösterir. YOLO algılama biçimini ve scikit-learn, pandas ve PyYAML gibi Python kütüphanelerini kullanarak kurulum, özellik vektörleri oluşturma ve veri kümesini K katına bölme adımlarını açıklar.

K-fold cross validation data splitting

Projen ister Meyve Algılama veri kümesini ister özel bir veri kaynağını kullansın, bu eğitim makine öğrenmesi modellerinin güvenilirliğini ve dayanıklılığını artırmak için K-Katlı Çapraz Doğrulamayı anlamana ve uygulamana yardımcı olur. Bu eğitimde k=5 kat kullansak 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; küçük, gürültülü veya değişkenliği yüksek veri kümelerinde en fazla faydayı sağlar. Büyük ve çeşitli veri kümeleri için iyi oluşturulmuş bir eğitim/doğrulama/test bölmesi genellikle yeterlidir.

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.
Sınıf EtiketiÖrnek Sayısı
Elma7049
Üzüm7202
Ananas1613
Portakal15549
Muz3536
Karpuz1976
  • 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. Kurulum yapmak için pip (veya tercih ettiğin paket yöneticisi) aracını 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. Test bölmesini değiştirmeden bırakıp, veri kümesi YAML dosyanda listelenen eğitim ve doğrulama görüntülerini Ultralytics YOLODataset sınıfıyla yükle.

    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. Etiket dosyalarında bulunan her sınıf etiketinin örnek sayısını hesapla.

    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 uygulamayı 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ğitim çalıştırmak için veri kümesi YAML dosyaları arasında döngü kur. Sonuçlar, project ve name bağımsız değişkenleriyle belirtilen dizine kaydedilir. Varsayılan olarak bu dizin runs/detect/train# olur; # ise bir tamsayı indeksidir.

    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 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ştiren rapor DataFrame'leri oluşturma yöntemini de inceledik. Böylece eğitim ve doğrulama kümelerimizin yapısını net biçimde görebildik.

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#

  • K-Katlı Çapraz Doğrulama, model performansını daha güvenilir biçimde değerlendirmek için veri kümesinin 'k' alt kümeye (kata) bölündüğü bir tekniktir. Her kat hem eğitim hem de doğrulama verisi olarak kullanılır. Nesne algılama bağlamında K-Katlı Çapraz Doğrulama, Ultralytics YOLO modelinin farklı veri bölmelerindeki performansının sağlam ve genellenebilir olmasını sağlayarak güvenilirliğini artırmaya yardımcı olur. Ultralytics YOLO ile K-Katlı Çapraz Doğrulamayı ayarlama konusunda ayrıntılı talimatlar için Ultralytics ile K-Katlı Çapraz Doğrulama başlıklı kaynağa bak.

  • Ultralytics YOLO ile K-Katlı Çapraz Doğrulamayı uygulamak için şu adımları izle:

    1. Ek açıklamaların YOLO algılama biçiminde olduğunu doğrula.
    2. sklearn, pandas ve pyyaml gibi Python kütüphanelerini kullan.
    3. Veri kümen üzerinden özellik vektörleri oluştur.
    4. Veri kümeni sklearn.model_selection içindeki KFold öğesini kullanarak böl.
    5. YOLO modelini her bölmede eğit.

    Kapsamlı bir kılavuz için belgelerimizdeki K-Katlı Veri Kümesi Bölmesi bölümüne bak.

  • Bu kılavuzdaki iş akışı YOLO algılama biçimini hedefler, ancak aynı yaklaşım tüm YOLO görevlerine uyarlanabilir: görev, çapraz doğrulamanın faydalı olup olmadığını değil, katları nasıl oluşturacağını değiştirir:

    GörevKat tasarımı
    detectNesne ve sınıf dağılımlarını katlar arasında dengeleyerek görüntü düzeyinde böl. İlişkili görüntüleri (aynı hasta, video dizisi, kamera veya konum) tek bir katta tut.
    segmentAlgılamayla aynı görüntü düzeyindeki stratejiyi kullan ve buna ek olarak her kattaki maske ve sınıf kapsamını koru.
    classifySınıf sıklıklarının eğitim ve doğrulama arasında dengeli kalması için katmanlı katları tercih et.
    poseAynı kişi veya hayvanın bir katın iki tarafında da yer almaması için denek ya da dizi bazında böl.
    obbGörüntü düzeyinde bölme yap ve aynı sahneden gelen döşemeleri veya kırpmaları bir arada tut; bu, özellikle hava görüntüleri için önemlidir.

    Görev ne olursa olsun, birbirine çok benzeyen örnekleri ve ilişkili örnekleri karşıt katlara koyma. Bu tür bir sızıntı, doğrulama metriklerini modelin üretimde elde edeceği düzeyin çok üzerine çıkarır.

  • Ultralytics YOLO, yüksek doğruluk ve verimlilikle son teknoloji ürünü, gerçek zamanlı nesne tespiti sunar. Tespit, örnek segmentasyonu, anlamsal segmentasyon ve sınıflandırma gibi çeşitli bilgisayarlı görü görevlerini destekleyen çok yönlü bir çözümdür. Ayrıca kod yazmadan model eğitimi ve dağıtımı için Ultralytics Platform gibi araçlarla entegre olur.

  • Ek açıklamaların YOLO algılama biçimine uygun olmalıdır. Her ek açıklama dosyası, nesne sınıfını ve görüntüdeki sınırlayıcı kutu koordinatlarını listelemelidir. YOLO biçimi, nesne algılama modellerini eğitmek için veri işlemenin verimli ve standartlaştırılmış olmasını sağlar. Ek açıklamaları doğru biçimlendirme hakkında daha fazla bilgi için YOLO algılama biçimi kılavuzunu ziyaret et.

  • Evet, ek açıklamalar YOLO algılama biçimindeyse herhangi bir özel veri kümesiyle K-Katlı Çapraz Doğrulama kullanabilirsin. Veri kümesi yollarını ve sınıf etiketlerini kendi veri kümene özgü olanlarla değiştir. Bu esneklik, her nesne algılama projesinin K-Katlı Çapraz Doğrulama ile sağlam model değerlendirmesinden yararlanmasını sağlar. Uygulamalı bir örnek için Özellik Vektörleri Oluşturma bölümümüzü incele.

Yorumlar21

Bir soru sor, sonuçlarını paylaş veya başka birine yardım et.

  1. jingieboyGitHub

    does this work with yolov8-cls? if so how would the folder structure look like? how are the data splits

    1. Glenn JocherUltralytics(düzenlendi)

      Yes—K‑Fold works the same for classification; use the standard ImageNet-style layout per fold, and train each fold separately (YOLO infers classes from folder names). For YOLO26 (recommended) you can do:

      dataset/
        split_1/
          train/
            class_a/ ...
            class_b/ ...
          val/
            class_a/ ...
            class_b/ ...
        split_2/
          train/...
          val/...
        ...
      from ultralytics import YOLO
      
      weights = "yolo26n-cls.pt"  # swap to 'yolov8n-cls.pt' if you prefer YOLOv8
      splits = ["dataset/split_1", "dataset/split_2", "dataset/split_3"]
      
      for d in splits:
          model = YOLO(weights)
          model.train(data=d, epochs=20, batch=16)  # d must contain 'train/' and 'val/' subfolders

      For building folds, use StratifiedKFold on image-level labels derived from parent folder names to keep class balance, or use the random splitter shown in the autosplit reference if stratification isn’t required. Classification usage details are in the classification task docs.

    2. jingieboyGitHub

      thank you for this! I have also notice that everytime I run model.val(), the accuracies and confusion matrix values are slightly different this time. Is this normal or during evaluation, there is a small randomness when calling the function.

    3. Glenn JocherUltralytics

      @jingieboy minor variations can occur from non-deterministic CUDA ops or multi-threading; validation itself doesn’t add randomness by default—set seeds and force deterministic ops to lock results:

      import random, numpy as np, torch
      
      seed = 0
      random.seed(seed); np.random.seed(seed); torch.manual_seed(seed)
      torch.backends.cudnn.deterministic = True
      torch.backends.cudnn.benchmark = False
      
      model.val()  # run evaluation

      If differences are still large, double-check your eval args in the validation mode docs.

  2. NehasqGitHub

    Hi, I am applying K-fold validation using the leave-one-out technique. My dataset consists of a single class and includes 21 images in total. For each split, I use 20 images for training and 1 image for testing. I am implementing the leave-one-out technique with the code above, setting ksplit=21.

    I am not using a separate validation dataset, only training and testing data. Here is the code I am using:

    results = {}

    Define additional arguments here

    batch = 16 project = "kfold_demo" epochs = 100

    for k in range(ksplit): dataset_yaml = ds_yamls[k] model = YOLO(weights_path, task="detect") 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

    In my data.yaml file, I have provided the validation path as the test set. When it trains and validates on the "1 test data," does this mean the model is being tested on data it has never seen during training? This is my first point of confusion.

    my data.yaml file for each split looks like this: names:

    • pothole path: ../ 2024-12-10_21-Fold_Cross-val/split_1 train: train val: test

    My second question is about calculating the final performance. When I ran the above code, it calculated scores for each individual split. Do I need to calculate the final performance metrics manually, or is there any functionality in YOLOv8 to compute the aggregated performance automatically?

    1. Glenn JocherUltralytics

      @Nehasq to address your first question, yes, the model is being tested on unseen data during each split, as the test set (1 image) is excluded from training and only used for validation. Regarding your second question, YOLO does not automatically aggregate metrics across splits. You need to compute the final performance metrics manually by averaging the results from all splits. For reference, you can review the K-Fold Cross Validation guide.

    2. NehasqGitHub

      Thanks for your reply. I understand your point. So, are you saying that, for example, in my case, where I have 21 scores (precision, recall, etc.), I should simply add all the precision values together and divide the sum by 21 to get the final precision of the model? Is that correct?

      Also, in y case of 20 images( training) and 1 images for test, what batch size would you suggest?

    3. Glenn JocherUltralytics

      Yes, to calculate the final precision (or any metric), you average the values across all splits, i.e., sum all precision scores and divide by the number of splits (21 in your case). As for the batch size, given your small dataset, you could keep it low (e.g., 1 or 2) to ensure efficient utilization of the data while avoiding overfitting.

    4. NehasqGitHub

      Thanks, that really helps! With a batch size of 1, I am keeping the epochs at 10. Should it be fewer? Also, to check for overfitting, I need to review the result graphs for each split. However, I can't definitively determine if it is overfitting since each split is separate, right?

    5. Glenn JocherUltralytics

      Keeping epochs at 10 with a batch size of 1 is reasonable given your small dataset size. To check for overfitting, reviewing result graphs from each split can help, but overfitting may be harder to detect since each split involves different training and test data. Consider comparing trends across splits for consistent insights. For further details, you can reference the K-Fold Cross Validation guide.

  3. semyon-v-dotGitHub

    After the loop:

    for ext in supported_extensions:
        images.extend(sorted((dataset_path / "images").rglob(f"*{ext}")))

    Should be this line of code: images = sorted(images)

    For images matching with labels list: labels = sorted(dataset_path.rglob("*labels/*.txt"))

    Otherwise the script creates background images because some images missing their labels.

    1. Glenn JocherUltralytics

      @semyon-v-dot thank you for your suggestion. Sorting the images list after extending it with supported extensions is a good practice to ensure alignment with the labels list. This helps prevent issues with missing labels.

      1
  4. sangeun jo

    K-폴드 데이터 세트 분할 4번에서 images.extend(sorted((dataset_path / "images").rglob(f"*{ext}"))) 이 코드를 images.extend(sorted(dataset_path.rglob(f"*images/*{ext}"))) 로 변환해야 작동했습니다.

    1. Glenn JocherUltralytics

      @sangeun-jo thank you for pointing that out. Your modification to images.extend(sorted(dataset_path.rglob(f"*images/*{ext}"))) is indeed correct and ensures the code works as intended. If you have any further questions or need additional assistance, feel free to ask!

  5. kh-diabGitHub

    is it usefult to use this k fold approach when I just have one class only but my issue is the class is detected as background or vice versa as per the attached Confusion matrix

    1. Glenn JocherUltralytics

      @kh-diab using K-Fold Cross Validation can still be beneficial even with a single class. It helps ensure that your model's performance is robust and not overly dependent on a particular subset of the data. This can be particularly useful if you're experiencing issues with class detection accuracy, as it allows you to validate the model's performance across multiple splits and identify any inconsistencies. If your class is being detected as background or vice versa, K-Fold Cross Validation can help diagnose whether this issue is consistent across different data splits or specific to certain subsets. For more details, you can refer to our guide on K-Fold Cross Validation: https://docs.ultralytics.com/guides/kfold-cross-validation/.

  6. alexander-sonyGitHub

    Good guide, consider adding it in a colab notebook.

    In section "Train YOLO using K-Fold Data Splits", model should be re-initialized foe every k, i.e. it should be inside the for-loop: for k in range(ksplit).

    1. Glenn JocherUltralytics

      @alexander-sony thank you for your feedback and suggestion! 😊

      You're absolutely right about re-initializing the model within the loop for each fold to ensure a fresh start for every training iteration. This can help avoid any potential carryover effects from previous folds. Here's the corrected code snippet for the training section:

      from ultralytics import YOLO
      
      weights_path = "path/to/weights.pt"
      results = {}
      
      # Define your additional arguments here
      batch = 16
      project = "kfold_demo"
      epochs = 100
      
      for k in range(ksplit):
          model = YOLO(weights_path, task="detect")  # Re-initialize the model inside the loop
          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

      Regarding your suggestion to add this guide to a Colab notebook, that's a fantastic idea! It would make the process more interactive and accessible for users. We'll consider creating a Colab version of this guide in the future.

      For more details on K-Fold Cross Validation, you can refer to our comprehensive guide.

      Thanks again for your valuable input! If you have any more suggestions or questions, feel free to share. Happy coding! 🚀

    2. Likhith-SugganahalliGitHub

      @alexander-sony

      woudnt that be a new model trained on each split, giving us n different models trained on 1/nth of the dataset?

    1. Paula DerrengerUltralytics

      Yes, you can implement Stratified K-Fold Cross Validation with YOLOv8! Stratified K-Fold ensures that each fold has a similar distribution of class labels, which can be particularly useful for imbalanced datasets.

      To achieve this, you can use StratifiedKFold from sklearn.model_selection instead of KFold. Here's a brief example of how to modify the K-Fold implementation:

      from sklearn.model_selection import StratifiedKFold
      
      # Assuming labels_df is your DataFrame with class counts
      ksplit = 5
      skf = StratifiedKFold(n_splits=ksplit, shuffle=True, random_state=20)
      
      # Generate stratified splits
      kfolds = list(skf.split(labels_df, labels_df.idxmax(axis=1)))
      
      # The rest of the process remains the same

      For a detailed guide on K-Fold Cross Validation, please refer to the Ultralytics documentation. If you have any more questions, feel free to ask! 😊

      1