Ultralytics를 활용한 K-겹 교차 검증#

소개#

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

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

시작하겠습니다.

설정#

• 주석은 YOLO 탐지 형식이어야 합니다.

• 이 가이드에서는 주석 파일을 로컬에서 사용할 수 있다고 가정합니다.

• 이 예제에서는 Fruit Detection 데이터셋을 사용합니다.

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

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

  • ultralytics
  • sklearn
  • pandas
  • pyyaml

• 이 튜토리얼에서는 k=5개의 겹을 사용합니다. 그러나 사용 중인 데이터셋에 가장 적합한 겹 수를 직접 결정해야 합니다.

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

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

2. 주석이 YOLO 탐지 형식인지 확인합니다.

   • 이 튜토리얼에서는 모든 주석 파일이 Fruit-Detection/labels 디렉터리에 있습니다.

객체 탐지 데이터셋의 특징 벡터 생성#

1. 먼저 아래 단계에 사용할 새 example.py Python 파일을 만듭니다.

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-겹 교차 검증을 적용할 수 있습니다.

K-겹 데이터셋 분할#

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)  # setting random_state for repeatable results
   
   kfolds = list(kf.split(labels_df))

2. 이제 데이터셋이 k개의 겹으로 분할되었으며, 각 겹에는 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. 이제 각 겹에 대한 클래스 레이블 분포를 계산합니다. 이는 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-겹 분할 및 레이블 분포 DataFrame의 레코드를 CSV 파일로 저장하여 나중에 참조할 수 있습니다.

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

K-겹 데이터 분할을 사용하여 YOLO 학습#

1. 먼저 YOLO 모델을 로드합니다.

   from ultralytics import YOLO
   
   weights_path = "path/to/weights.pt"  # use yolo26n.pt for a small model
   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
   
   # Automatically split dataset into train/val/test
   autosplit(path="path/to/images", weights=(0.8, 0.2, 0.0), annotated_only=True)

결론#

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

또한 데이터 분할과 이러한 분할 전반의 레이블 분포를 시각화하기 위한 보고서 DataFrame 생성 절차를 살펴보았으며, 이를 통해 학습 및 검증 세트의 구조를 명확하게 파악할 수 있었습니다.

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

마지막으로 각 분할을 루프에서 사용하여 실제 모델 학습을 구현하고, 추가 분석 및 비교를 위해 학습 결과를 저장했습니다.

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

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

FAQ#