Xác thực chéo K-Fold với Ultralytics

Q: How do I implement K-Fold Cross Validation using Ultralytics YOLO?

Để thực hiện K-Fold Cross Validation với Ultralytics YOLO , bạn cần làm theo các bước sau: Để biết hướng dẫn toàn diện, hãy xem phần Phân tách tập dữ liệu K-Fold trong tài liệu của chúng tôi.

Giới thiệu

Hướng dẫn toàn diện này minh họa việc triển khai K-Fold Cross Validation cho các tập dữ liệu phát hiện đối tượng trong Ultralytics hệ sinh thái. Chúng tôi sẽ tận dụng YOLO định dạng phát hiện và khóa Python các thư viện như sklearn, pandas và PyYaml hướng dẫn bạn thiết lập cần thiết, quy trình tạo vectơ đặc trưng và thực hiện phân chia tập dữ liệu K-Fold.

Tổng quan về xác thực chéo K-Fold

Cho dù dự án của bạn liên quan đến tập dữ liệu Fruit Detection hay nguồn dữ liệu tùy chỉnh, hướng dẫn này nhằm mục đích giúp bạn hiểu và áp dụng K-Fold Cross Validation để tăng cường độ tin cậy và tính mạnh mẽ của dữ liệu của bạn. học máy mô hình. Trong khi chúng tôi đang áp dụng k=5 số lần gấp cho hướng dẫn này, hãy nhớ rằng số lần gấp tối ưu có thể thay đổi tùy thuộc vào tập dữ liệu và thông số cụ thể của dự án.

Không cần phải nói thêm nữa, chúng ta hãy cùng bắt đầu nhé!

Cài đặt

Chú thích của bạn phải theo định dạng phát hiện YOLO .
Hướng dẫn này giả định rằng các tệp chú thích có sẵn cục bộ.
Để chứng minh, chúng tôi sử dụng bộ dữ liệu Phát hiện trái cây .
- Bộ dữ liệu này chứa tổng cộng 8479 hình ảnh.
- Nó bao gồm 6 nhãn lớp, mỗi nhãn có tổng số lượng phiên bản được liệt kê bên dưới.

Nhãn lớp	Số lượng trường hợp
Quả táo	7049
Quả nho	7202
Quả dứa	1613
Quả cam	15549
Chuối	3536
Dưa hấu	1976

Cần thiết Python các gói bao gồm:
- ultralytics
- sklearn
- pandas
- pyyaml
Hướng dẫn này hoạt động với k=5 số lần gấp. Tuy nhiên, bạn nên xác định số lần gấp tốt nhất cho tập dữ liệu cụ thể của mình.
Bắt đầu một cái mới Python môi trường ảo (venv) cho dự án của bạn và kích hoạt nó. Sử dụng pip (hoặc trình quản lý gói bạn thích) để cài đặt:
- Các Ultralytics thư viện: pip install -U ultralytics. Ngoài ra, bạn có thể sao chép chính thức kho lưu trữ.
- Scikit-learn, pandas và PyYAML: pip install -U scikit-learn pandas pyyaml.
Xác minh rằng chú thích của bạn đang ở định dạng phát hiện YOLO .
- Đối với hướng dẫn này, tất cả các tệp chú thích đều được tìm thấy trong Fruit-Detection/labels thư mục.

Tạo vectơ đặc trưng cho tập dữ liệu phát hiện đối tượng

Bắt đầu bằng cách tạo một cái mới example.py Python tập tin để thực hiện các bước dưới đây.

Tiến hành lấy tất cả các tệp nhãn cho tập dữ liệu của bạn.

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'

Bây giờ, hãy đọc nội dung của tệp YAML trong bộ dữ liệu và trích xuất chỉ mục của nhãn lớp.

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

Khởi tạo một cái trống pandas Khung dữ liệu.

import pandas as pd

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

Đếm số trường hợp của từng nhãn lớp có trong các tệp chú thích.

from collections import Counter

for label in labels:
    lbl_counter = Counter()

    with open(label, "r") 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(" ")[0])] += 1

    labels_df.loc[label.stem] = lbl_counter

labels_df = labels_df.fillna(0.0)  # replace `nan` values with `0.0`

Sau đây là ví dụ về chế độ xem DataFrame đã được điền:

                                                       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

Các hàng lập chỉ mục các tệp nhãn, mỗi hàng tương ứng với một hình ảnh trong tập dữ liệu của bạn và các cột tương ứng với các chỉ mục nhãn lớp của bạn. Mỗi hàng biểu diễn một vectơ đặc trưng giả, với số lượng của mỗi nhãn lớp có trong tập dữ liệu của bạn. Cấu trúc dữ liệu này cho phép áp dụng Xác thực chéo K-Fold vào tập dữ liệu phát hiện đối tượng.

Phân chia tập dữ liệu K-Fold

Bây giờ chúng ta sẽ sử dụng KFold lớp từ sklearn.model_selection để tạo ra k sự phân chia của tập dữ liệu.
- Quan trọng:
  - Cài đặt shuffle=True đảm bảo phân phối ngẫu nhiên các lớp trong phần chia của bạn.
  - Bằng cách thiết lập random_state=M Ở đâu M là một số nguyên được chọn, bạn có thể thu được kết quả lặp lại.
```
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))
```

Bộ dữ liệu hiện đã được chia thành k nếp gấp, mỗi nếp gấp có một danh sách train Và val chỉ số. Chúng tôi sẽ xây dựng một DataFrame để hiển thị những kết quả này rõ ràng hơn.

folds = [f"split_{n}" for n in range(1, ksplit + 1)]
folds_df = pd.DataFrame(index=indx, columns=folds)

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

Bây giờ chúng ta sẽ tính toán sự phân bố của các nhãn lớp cho mỗi lần gấp theo tỷ lệ của các lớp có trong val cho những người có mặt trong 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

Kịch bản lý tưởng là tất cả các tỷ lệ lớp đều tương đối giống nhau cho mỗi lần chia và giữa các lớp. Tuy nhiên, điều này sẽ tùy thuộc vào thông số cụ thể của tập dữ liệu của bạn.

Tiếp theo, chúng tôi tạo các thư mục và tệp dữ liệu YAML cho mỗi phần tách.

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

Cuối cùng, sao chép hình ảnh và nhãn vào thư mục tương ứng ('train' hoặc 'val') cho mỗi phần tách.

LƯU Ý: Thời gian cần thiết cho phần mã này sẽ thay đổi tùy theo kích thước tập dữ liệu và phần cứng hệ thống của bạn.

import shutil

for image, label in zip(images, labels):
    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)

Lưu hồ sơ (Tùy chọn)

Tùy chọn, bạn có thể lưu các bản ghi về phân chia K-Fold và phân phối nhãn DataFrame dưới dạng tệp CSV để tham khảo sau này.

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

Xe lửa YOLO sử dụng Phân chia dữ liệu K-Fold

Đầu tiên, tải YOLO người mẫu.

from ultralytics import YOLO

weights_path = "path/to/weights.pt"
model = YOLO(weights_path, task="detect")

Tiếp theo, lặp lại các tệp YAML của tập dữ liệu để chạy đào tạo. Kết quả sẽ được lưu vào một thư mục được chỉ định bởi project Và name arguments. Theo mặc định, thư mục này là 'exp/runs#' trong đó # là chỉ số nguyên.

results = {}

# Define your 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

Phần kết luận

Trong hướng dẫn này, chúng tôi đã khám phá quy trình sử dụng xác thực chéo K-Fold để đào tạo YOLO mô hình phát hiện đối tượng. Chúng tôi đã học cách chia tập dữ liệu của mình thành K phân vùng, đảm bảo phân phối lớp cân bằng trên các phần khác nhau.

Chúng tôi cũng đã khám phá quy trình tạo DataFrame báo cáo để trực quan hóa các phân chia dữ liệu và phân phối nhãn trên các phân chia này, giúp chúng tôi hiểu rõ hơn về cấu trúc của bộ dữ liệu đào tạo và xác thực.

Tùy chọn, chúng tôi lưu hồ sơ của mình để tham khảo sau này, điều này có thể đặc biệt hữu ích trong các dự án quy mô lớn hoặc khi khắc phục sự cố hiệu suất mô hình.

Cuối cùng, chúng tôi triển khai mô hình đào tạo thực tế bằng cách sử dụng từng phần chia trong một vòng lặp, lưu kết quả đào tạo để phân tích và so sánh thêm.

Kỹ thuật xác thực chéo K-Fold này là một cách mạnh mẽ để tận dụng tối đa dữ liệu có sẵn của bạn và giúp đảm bảo hiệu suất mô hình của bạn đáng tin cậy và nhất quán trên các tập dữ liệu khác nhau. Điều này dẫn đến một mô hình tổng quát và đáng tin cậy hơn, ít có khả năng quá phù hợp với các mẫu dữ liệu cụ thể.

Hãy nhớ rằng mặc dù chúng ta đã sử dụng YOLO trong hướng dẫn này, các bước này chủ yếu có thể chuyển giao sang các mô hình học máy khác. Hiểu các bước này cho phép bạn áp dụng xác thực chéo hiệu quả trong các dự án học máy của riêng bạn. Chúc bạn viết mã vui vẻ!

CÂU HỎI THƯỜNG GẶP

Xác thực chéo K-Fold là gì và tại sao nó hữu ích trong việc phát hiện đối tượng?

Xác thực chéo K-Fold là một kỹ thuật trong đó tập dữ liệu được chia thành các tập con 'k' (fold) để đánh giá hiệu suất mô hình đáng tin cậy hơn. Mỗi fold đóng vai trò là dữ liệu đào tạo và xác thực . Trong bối cảnh phát hiện đối tượng, sử dụng Xác thực chéo K-Fold giúp đảm bảo Ultralytics YOLO hiệu suất của mô hình mạnh mẽ và có thể khái quát hóa trên các phân chia dữ liệu khác nhau, nâng cao độ tin cậy của nó. Để biết hướng dẫn chi tiết về cách thiết lập Xác thực chéo K-Fold với Ultralytics YOLO , tham khảo Xác thực chéo K-Fold với Ultralytics .

Làm thế nào để tôi triển khai K-Fold Cross Validation bằng cách sử dụng Ultralytics YOLO ?

Để thực hiện Xác thực chéo K-Fold với Ultralytics YOLO , bạn cần thực hiện theo các bước sau:

Xác minh chú thích có ở định dạng phát hiện YOLO .
Sử dụng Python thư viện như sklearn, pandas, Và pyyaml.
Tạo các vectơ đặc trưng từ tập dữ liệu của bạn.
Chia tách tập dữ liệu của bạn bằng cách sử dụng KFold từ sklearn.model_selection.
Đào tạo YOLO mô hình trên mỗi lần chia tách.

Để biết hướng dẫn toàn diện, hãy xem phần Phân chia tập dữ liệu K-Fold trong tài liệu của chúng tôi.

Tại sao tôi nên sử dụng Ultralytics YOLO để phát hiện vật thể?

Ultralytics YOLO cung cấp khả năng phát hiện đối tượng theo thời gian thực, hiện đại với độ chính xác và hiệu quả cao. Nó linh hoạt, hỗ trợ nhiều tác vụ thị giác máy tính như phát hiện, phân đoạn và phân loại. Ngoài ra, nó tích hợp liền mạch với các công cụ như Ultralytics HUB cho đào tạo và triển khai mô hình không cần mã. Để biết thêm chi tiết, hãy khám phá các lợi ích và tính năng trên trang Ultralytics YOLO của chúng tôi.

Làm thế nào tôi có thể đảm bảo chú thích của tôi có định dạng chính xác cho Ultralytics YOLO ?

Chú thích của bạn phải tuân theo YOLO định dạng phát hiện. Mỗi tệp chú thích phải liệt kê lớp đối tượng, cùng với tọa độ hộp giới hạn của nó trong hình ảnh. YOLO định dạng đảm bảo xử lý dữ liệu hợp lý và chuẩn hóa để đào tạo các mô hình phát hiện đối tượng. Để biết thêm thông tin về định dạng chú thích phù hợp, hãy truy cập hướng dẫn định dạng phát hiện YOLO .

Tôi có thể sử dụng K-Fold Cross Validation với các tập dữ liệu tùy chỉnh khác ngoài Fruit Detection không?

Có, bạn có thể sử dụng K-Fold Cross Validation với bất kỳ tập dữ liệu tùy chỉnh nào miễn là các chú thích nằm trong YOLO định dạng phát hiện. Thay thế các đường dẫn tập dữ liệu và nhãn lớp bằng những đường dẫn cụ thể cho tập dữ liệu tùy chỉnh của bạn. Tính linh hoạt này đảm bảo rằng bất kỳ dự án phát hiện đối tượng nào cũng có thể hưởng lợi từ việc đánh giá mô hình mạnh mẽ bằng cách sử dụng K-Fold Cross Validation. Để biết ví dụ thực tế, hãy xem phần Tạo vectơ tính năng của chúng tôi.

📅 Được tạo ra cách đây 1 năm ✏️ Đã cập nhật cách đây 1 tháng