Ultralytics를 사용한 K-Fold 교차 검증#

소개#

이 종합 가이드에서는 Ultralytics 생태계에서 객체 탐지 데이터셋에 K-Fold 교차 검증을 구현하는 방법을 설명합니다. YOLO 탐지 형식과 sklearn, pandas, PyYAML 등의 주요 Python 라이브러리를 활용하여 필요한 설정, feature vector 생성 과정, K-Fold 데이터셋 분할 실행 방법을 안내합니다.

프로젝트에서 Fruit Detection 데이터셋을 사용하든 사용자 지정 데이터 소스를 사용하든, 이 튜토리얼은 K-Fold 교차 검증을 이해하고 적용하여 머신러닝 모델의 신뢰성과 견고성을 높이는 데 도움을 드립니다. 이 튜토리얼에서는 k=5개 fold를 사용하지만, 최적의 fold 수는 데이터셋과 프로젝트의 구체적인 조건에 따라 달라질 수 있습니다. K-Fold 교차 검증은 데이터셋이 작거나 노이즈가 많거나 변동성이 큰 경우 가장 큰 효과를 발휘합니다. 크고 다양한 데이터셋에는 잘 구성된 train/val/test 분할만으로도 대체로 충분합니다.

시작해 보겠습니다.

설정#

• 어노테이션은 YOLO 탐지 형식이어야 합니다.

• 이 가이드에서는 어노테이션 파일을 로컬에서 사용할 수 있다고 가정합니다.

• 시연에는 Fruit Detection 데이터셋을 사용합니다.

  • 이 데이터셋에는 총 8479개의 이미지가 포함되어 있습니다.
  • 이 데이터셋에는 6개의 클래스 레이블이 있으며, 각 클래스의 전체 인스턴스 수는 아래에 나와 있습니다.

• 필요한 Python 패키지는 다음과 같습니다:

  • ultralytics
  • sklearn
  • pandas
  • pyyaml

• 이 튜토리얼에서는 k=5개의 fold를 사용합니다. 하지만 사용자의 데이터셋에 가장 적합한 fold 수를 직접 결정해야 합니다.

1. 프로젝트용 Python 가상 환경(venv)을 새로 만들고 활성화합니다. pip(또는 선호하는 패키지 관리자)을 사용해 다음 패키지를 설치합니다:

   • Ultralytics 라이브러리: pip install -U ultralytics. 또는 공식 저장소를 clone할 수 있습니다.
   • Scikit-learn, pandas, PyYAML: pip install -U scikit-learn pandas pyyaml.

2. 어노테이션이 YOLO 탐지 형식인지 확인합니다.

   • 이 튜토리얼에서는 모든 어노테이션 파일이 Fruit-Detection/labels 디렉터리에 있다고 가정합니다.

객체 탐지 데이터셋의 feature vector 생성#

1. 먼저 아래 단계를 위한 새 Python 파일 example.py을 만듭니다.

2. 패키지 데이터셋 소유자를 통해 설정된 학습 이미지와 검증 이미지를 불러오고, 테스트 분할은 그대로 둡니다.

   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. 이제 데이터셋 YAML 파일의 내용을 읽고 클래스 레이블의 인덱스를 추출합니다.

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

4. 빈 pandas DataFrame을 초기화합니다.

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

5. 어노테이션 파일에서 각 클래스 레이블의 인스턴스 수를 셉니다.

   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. 값을 채운 DataFrame의 예시는 다음과 같습니다:

                                                          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

행에는 절대 이미지 경로를 사용하고, 열은 클래스 레이블 인덱스에 해당합니다. 누락된 레이블은 모두 0인 배경 행으로 남습니다. 이 데이터 구조를 사용하면 객체 탐지 데이터셋에 K-Fold 교차 검증을 적용할 수 있습니다.

K-Fold 데이터셋 분할#

1. 이제 sklearn.model_selection의 KFold 클래스를 사용하여 데이터셋을 k개로 분할하겠습니다.

   • 중요:
     • shuffle=True을 설정하면 분할별 클래스 분포를 무작위로 구성할 수 있습니다.
     • M이 선택한 정수인 상태에서 random_state=M을 설정하면 반복 가능한 결과를 얻을 수 있습니다.

   from sklearn.model_selection import KFold
   
   ksplit = 5
   kf = KFold(n_splits=ksplit, shuffle=True, random_state=20)  # 반복 가능한 결과를 위해 random_state 설정
   
   kfolds = list(kf.split(labels_df))

2. 이제 데이터셋이 k개의 fold로 분할되었으며, 각 fold에는 train 및 val 인덱스 목록이 있습니다. 이 결과를 더 명확하게 표시하기 위해 DataFrame을 구성하겠습니다.

   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. 이제 각 fold의 클래스 레이블 분포를 val에 포함된 클래스 수와 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

   이상적인 상황은 각 분할과 클래스에서 모든 클래스 비율이 대체로 비슷한 것입니다. 다만 이는 데이터셋의 구체적인 특성에 따라 달라집니다.

4. 각 분할의 이미지 목록과 데이터셋 YAML을 작성합니다. 텍스트 목록을 사용하면 데이터셋을 k회 복사하지 않아도 됩니다.

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

레코드 저장(선택 사항)#

선택적으로 K-Fold 분할 및 레이블 분포 DataFrame의 레코드를 CSV 파일로 저장해 나중에 참고할 수 있습니다.

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

K-Fold 데이터 분할을 사용한 YOLO 학습#

1. 먼저 YOLO 모델을 불러옵니다.

   from ultralytics import YOLO
   
   weights_path = "path/to/weights.pt"  # 작은 모델에는 yolo26n.pt를 사용합니다
   model = YOLO(weights_path, task="detect")

2. 그다음 데이터셋 YAML 파일을 순회하며 학습을 실행합니다. 결과는 project 및 name 인수로 지정된 디렉터리에 저장됩니다. 기본 디렉터리는 'runs/detect/train#'이며, #은 정수 인덱스입니다.

   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. 데이터셋을 자동으로 분할하려면 Ultralytics data.split.autosplit 함수도 사용할 수 있습니다:

   from ultralytics.data.split import autosplit
   
   # 데이터셋을 train/val/test로 자동 분할
   autosplit(path="path/to/images", weights=(0.8, 0.2, 0.0), annotated_only=True)

결론#

이 가이드에서는 YOLO 객체 탐지 모델을 학습할 때 K-Fold 교차 검증을 사용하는 방법을 살펴보았습니다. 학습 및 검증 데이터 풀을 K개의 파티션으로 나누고, 무작위 분할 후 생성된 비율 표를 사용해 클래스 균형을 확인하는 방법을 알아보았습니다.

또한 분할된 데이터와 각 분할의 레이블 분포를 시각화하는 보고서 DataFrame을 만드는 절차를 살펴보았습니다. 이를 통해 학습 및 검증 세트의 구조를 명확하게 파악할 수 있습니다.

선택적으로 나중에 참고할 수 있도록 레코드를 저장했습니다. 이는 대규모 프로젝트나 모델 성능 문제를 해결할 때 특히 유용할 수 있습니다.

마지막으로 각 분할을 반복해 실제 모델 학습을 수행하고, 추가 분석과 비교를 위해 학습 결과를 저장했습니다.

K-Fold 교차 검증은 사용 가능한 데이터를 최대한 활용하는 견고한 방법이며, 서로 다른 데이터 하위 집합에서도 모델 성능의 신뢰성과 일관성을 확보하는 데 도움이 됩니다. 이를 통해 특정 데이터 패턴에 과적합할 가능성이 낮고 일반화 성능과 신뢰성이 더 높은 모델을 얻을 수 있습니다.

이 가이드에서는 YOLO를 사용했지만, 이러한 단계는 대부분 다른 머신러닝 모델에도 적용할 수 있습니다. 각 단계를 이해하면 자체 머신러닝 프로젝트에서 교차 검증을 효과적으로 적용할 수 있습니다.

자주 묻는 질문#