İçeriğe geç

Ultralytics ile K-Fold Çapraz Doğrulama

Giriş

Bu kapsamlı kılavuz, Ultralytics ekosistemi içinde nesne algılama veri kümeleri için K-Fold Çapraz Doğrulama uygulamasını göstermektedir. Gerekli kurulum, özellik vektörleri oluşturma süreci ve bir K-Fold veri kümesi bölümünün yürütülmesinde size rehberlik etmek için YOLO algılama formatını ve sklearn, pandas ve PyYaml gibi temel Python kitaplıklarını kullanacağız.

K-Fold Çapraz Doğrulama Genel Bakışı

Projeniz İster Meyve Algılama veri kümesini ister özel bir veri kaynağını içeriyor olsun, bu eğitim, K-Fold Çapraz Doğrulamayı güvenilirliğinizi ve sağlamlığınızı güçlendirmek için anlamanıza ve uygulamanıza yardımcı olmayı amaçlamaktadır. makine öğrenimi modeller. Uygularken k=5 Bu eğitim için katmanlar kullanıyorsanız, projenizin özelliklerine ve veri kümenize bağlı olarak en uygun katman sayısının değişebileceğini unutmayın.

Daha fazla uzatmadan, hadi dalalım!

Kurulum

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

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

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

    • Bu veri kümesi toplam 8479 resim içermektedir.
    • Her biri aşağıda listelenen toplam örnek sayılarıyla birlikte 6 sınıf etiketi içerir.
Sınıf Etiketi Örnek Sayısı
Apple 7049
Üzümler 7202
Ananas 1613
Turuncu 15549
Muz 3536
Karpuz 1976

  • Gerekli Python paketleri şunları içerir:

    • ultralytics
    • sklearn
    • pandas
    • pyyaml

  • Bu eğitim şunlarla çalışır: k=5 katmanlar. Ancak, kendi veri kümeniz için en iyi katman sayısını belirlemelisiniz.

  • Yeni bir Python sanal ortamı başlatın (venv) projeniz için ve etkinleştirin. Şunu kullanın: pip projeniz için (veya tercih ettiğiniz paket yöneticisi) kurmak için:

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

  • Açıklamalarınızın YOLO algılama formatında olduğundan emin olun.

    • Bu eğitim için, tüm açıklama dosyaları şurada bulunur: Fruit-Detection/labels dizininde.

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

  1. Yeni bir tane oluşturarak başlayın example.py Aşağıdaki adımlar için python dosyası.

  2. Veri kümeniz için tüm etiket dosyalarını almak üzere ilerleyin.

    from pathlib import Path

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.

    import yaml

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

  4. Boş bir tane başlat pandas DataFrame.

    import pandas as pd

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

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

    from collections import Counter

for label in labels:
    lbl_counter = Counter()

    with open(label) as lf:
        lines = lf.readlines()

    for line in lines:
        # classes for YOLO label uses integer at first position of each line
        lbl_counter[int(line.split(" ", 1)[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ü bulunmaktadı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, veri kümenizdeki bir görüntüye karşılık gelen etiket dosyalarını indeksler ve sütunlar, sınıf etiketi indekslerinize karşılık gelir. Her satır, veri kümenizde bulunan her sınıf etiketinin sayısıyla birlikte bir sözde özellik vektörünü temsil eder. Bu veri yapısı, bir nesne algılama veri kümesine K-Fold Çapraz Doğrulama uygulanmasını sağlar.

K-Fold Veri Kümesi Bölme

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

    • Önemli:
      • Ayar shuffle=True bölmelerinizde sınıfların rastgele dağılımını sağlar.
      • Ayarlanarak random_state=M nerede M seçilen bir tamsayıdır, tekrarlanabilir sonuçlar elde edebilirsiniz.
    import random

from sklearn.model_selection import KFold

random.seed(0)  # for reproducibility
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 şu şekilde ayrılmıştır: k katmanlar, her birinde bir liste bulunan train ve val indeksler. Bu 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=index, columns=folds)

for i, (train, val) in enumerate(kfolds, start=1):
    folds_df[f"split_{i}"].loc[labels_df.iloc[train].index] = "train"
    folds_df[f"split_{i}"].loc[labels_df.iloc[val].index] = "val"

  3. Şimdi, her katman için sınıf etiketlerinin dağılımını, mevcut sınıfların oranı olarak hesaplayacağız. val içinde 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 tabi olacaktır.

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

    import datetime

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
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,
        )

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

    • NOT: Kodun bu bölümü için gereken süre, veri kümenizin boyutuna ve sistem donanımınıza göre değişecektir.
    import shutil

from tqdm import tqdm

for image, label in tqdm(zip(images, labels), total=len(images), desc="Copying files"):
    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ölünmesinin ve etiket dağılımı DataFramelerinin kayıtlarını gelecekte 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-Fold Veri Bölmeleri Kullanarak YOLO Eğitimi

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

    from ultralytics import YOLO

weights_path = "path/to/weights.pt"  # use yolo11n.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 yineleme yapın. Sonuçlar, tarafından belirtilen bir dizine kaydedilecektir. project ve name argümanlar. Varsayılan olarak, bu dizin '#', bir tamsayı indeksi olmak üzere 'runs/detect/train#'dir.

    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.utils.autosplit fonksiyonunu da kullanabilirsiniz:

    from ultralytics.data.utils 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-Fold çapraz doğrulamasının nasıl kullanılacağını inceledik. Veri kümemizi K bölüme ayırmayı ve farklı katmanlar arasında dengeli bir sınıf dağılımı sağlamayı öğrendik.

Ayrıca, veri bölmelerini ve bu bölmelerdeki etiket dağılımlarını görselleştirmek için rapor DataFrameleri oluşturma prosedürünü inceledik ve bu da bize eğitim ve doğrulama kümelerimizin yapısı hakkında net bir fikir verdi.

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

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

K-Fold çapraz doğrulama tekniği, mevcut verilerinizden en iyi şekilde yararlanmanın güçlü bir yoludur ve model performansınızın farklı veri alt kümelerinde güvenilir ve tutarlı olmasını sağlamaya yardımcı olur. Bu, belirli veri kalıplarına aşırı uyum sağlama olasılığı daha düşük olan, daha genellenebilir ve güvenilir bir modelle sonuçlanır.

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

SSS

K-Fold Çapraz Doğrulama nedir ve nesne tespitinde neden faydalıdır?

K-Katlı Çapraz Doğrulama, model performansını daha güvenilir bir şekilde değerlendirmek için veri kümesinin 'k' alt kümeye (katmana) bölündüğü bir tekniktir. Her katman hem eğitim hem de doğrulama verisi olarak işlev görür. Nesne algılama bağlamında, K-Katlı Çapraz Doğrulama kullanmak, Ultralytics YOLO modelinizin performansının farklı veri bölümlerinde sağlam ve genellenebilir olmasını sağlamaya yardımcı olarak güvenilirliğini artırır. Ultralytics YOLO ile K-Katlı Çapraz Doğrulamayı ayarlama hakkında ayrıntılı talimatlar için, Ultralytics ile K-Katlı Çapraz Doğrulama'ya bakın.

Ultralytics YOLO kullanarak K-Fold Çapraz Doğrulamayı nasıl uygularım?

Ultralytics YOLO ile K-Fold Çapraz Doğrulamayı uygulamak için şu adımları izlemeniz gerekir:

  1. Açıklamaların YOLO algılama formatında olduğundan emin olun.
  2. Şunun gibi Python kütüphanelerini kullanın: sklearn, pandasve pyyaml.
  3. Veri kümenizden özellik vektörleri oluşturun.
  4. Veri kümenizi kullanarak bölün KFold kaynak: sklearn.model_selection.
  5. YOLO modelini her bir bölünme üzerinde eğitin.

Kapsamlı bir kılavuz için, belgelerimizdeki K-Fold Veri Kümesi Bölme bölümüne bakın.

Nesne algılama için neden Ultralytics YOLO kullanmalıyım?

Ultralytics YOLO, yüksek doğruluk ve verimlilikle son teknoloji ürünü, gerçek zamanlı nesne tespiti sunar. Algılama, segmentasyon ve sınıflandırma gibi çoklu bilgisayarla görme görevlerini destekleyen çok yönlü bir araçtır. Ek olarak, kodsuz model eğitimi ve dağıtımı için Ultralytics HUB gibi araçlarla sorunsuz bir şekilde entegre olur. Daha fazla ayrıntı için Ultralytics YOLO sayfamızdaki avantajları ve özellikleri inceleyin.

Etiketlerimin Ultralytics YOLO için doğru formatta olduğundan nasıl emin olabilirim?

Ek açıklamalarınız YOLO algılama formatını izlemelidir. Her ek açıklama dosyası, görüntüdeki sınırlayıcı kutu koordinatlarıyla birlikte nesne sınıfını listelemelidir. YOLO formatı, nesne algılama modellerini eğitmek için akıcı ve standartlaştırılmış veri işlemeyi sağlar. Doğru ek açıklama biçimlendirmesi hakkında daha fazla bilgi için YOLO algılama formatı kılavuzunu ziyaret edin.

Meyve Tespiti dışındaki özel veri kümeleriyle K-Fold Çapraz Doğrulamayı kullanabilir miyim?

Evet, etiketlemeler YOLO algılama formatında olduğu sürece herhangi bir özel veri kümesiyle K-Fold Çapraz Doğrulaması kullanabilirsiniz. Veri kümesi yollarını ve sınıf etiketlerini, özel veri kümenize özel olanlarla değiştirin. Bu esneklik, herhangi bir nesne algılama projesinin K-Fold Çapraz Doğrulaması kullanılarak sağlam model değerlendirmesinden yararlanabilmesini sağlar. Pratik bir örnek için, Özellik Vektörleri Oluşturma bölümümüzü inceleyin.



📅 1 yıl önce oluşturuldu ✏️ 19 gün önce güncellendi
glenn-jocher RizwanMunawar Y-T-G willie.maddox@gmail.com Burhan-Q M-Amrollahi IvorZhu331

Yorumlar