이안류 CCTV 데이터셋

1. 이안류 CCTV 데이터셋
* AI Hub의 '이안류 CCTV 데이터'는 우리나라 주요 해수욕장(해운대, 송정, 대천, 중문, 낙산)에서 이안류 발생 여부와 위치를 모니터링하기 위해 구축된 인공지능 학습용 데이터셋입니다. 
* 해수욕장 주변에 설치된 CCTV 영상을 이미지로 변환하여, 이안류 발생 여부와 위치를 가시화하는 모델 개발에 활용할 수 있습니다. 
* 이 데이터셋은 이안류 탐지 및 예측 시스템 개발에 필수적인 자료를 제공하며, 해수욕객의 안전을 위한 응용 서비스 구성에 활용될 수 있습니다. 
* ​이안류는 해안에서 먼 바다로 빠르게 이동하는 폭이 좁은 바닷물의 흐름으로, 기상 상태가 양호한 경우에도 나타나며, 얕은 곳에 있던 해수욕객을 순식간에 수심이 깊은 먼 바다로 이동시켜 인명사고를 유발할 수 있습니다. 
* 따라서 이러한 데이터셋은 해수욕장 안전 관리 및 이안류 예측 모델 개발에 중요한 역할을 합니다.

이안류 데이터 링크 주소 : https://www.aihub.or.kr/aihubdata/data/view.do?currMenu=115&topMenu=100&aihubDataSe=data&dataSetSn=71297

AI-Hub

 

여기 사이트에서 샘플데이터를 압축을 풀어줍니다.

풀어준 후, 

/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent/data/ 폴더에
labels와 images 폴더를 만듭니다.

 

예시 1)

# ultralytics 패키지를 설치해줌
!pip install -q ultralytics opencv-python

 

예시 2)

import os
import random
import shutil
import cv2
import glob
import json
import yaml
import ultralytics
import matplotlib.pyplot as plt
from torchvision import transforms
from tqdm import tqdm
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator

 

예시 3)

ultralytics.checks()
-->
Ultralytics 8.3.87 🚀 Python-3.11.11 torch-2.5.1+cu124 CUDA:0 (Tesla T4, 15095MiB)
Setup complete ✅ (2 CPUs, 12.7 GB RAM, 39.1/112.6 GB disk)

 

예시 4)

data_root = "/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전"
pjt_name = "resource/ripcurrent"
file_root = f"{data_root}/{pjt_name}/data"

 

예시 5)

train_root = f"{data_root}/{pjt_name}/train"
valid_root = f"{data_root}/{pjt_name}/valid"
test_root = f"{data_root}/{pjt_name}/test"

 

예시 6)

# train_root, valid_root, test_root 리스트에 담긴 폴더들에 대해 반복합니다.
for folder in [train_root, valid_root, test_root]:
    # 해당 폴더가 존재하지 않으면, 폴더를 생성합니다.
    if not os.path.exists(folder):
        os.makedirs(folder)
    
    # 각 폴더 안에 'images'와 'labels'라는 두 개의 하위 폴더를 생성하기 위한 반복문입니다.
    for s in ['images', 'labels']:
        # 하위 폴더의 경로를 지정합니다.
        s_folder = f"{folder}/{s}"
        # 해당 하위 폴더가 존재하지 않으면, 하위 폴더를 생성합니다.
        if not os.path.exists(s_folder):
            os.makedirs(s_folder)

 

예시 7)

# file_root 디렉토리의 "labels" 폴더 내에 있는 모든 .json 파일들의 경로를 검색합니다.
file_list = glob.glob(f"{file_root}/labels/*.json")
# 검색된 .json 파일 경로들의 리스트를 출력하거나 사용할 수 있습니다.
file_list

 

예시 8)

# coco dataset 형식
# [x_min, y_min] , [x_max, y_min] , [x_max, y_max] , [x_min, y_max]
#    좌상단               우상단             우하단           좌하단
# coco -> yolo : 클래스 x센터 y센터 너비 높이 (정규화)

# Bounding box 형태 변형하기
def json_to_yolo_bbox(bbox, w, h):
    # xcenter = xmin, xmax /2
    # ycenter = ymin, ymax /2
    x_center = ((bbox[0][0]+ bbox[1][0])/2)/w # 좌상단의 x 좌표, 우상단의 x 좌표
    y_center = ((bbox[0][1]+ bbox[3][1])/2)/h # 좌상단의 y 좌표, 좌하단의 y 좌표
    width = (bbox[1][0]- bbox[0][0])/w
    height = (bbox[3][1]- bbox[0][1])/h

    return [x_center, y_center, width, height]

 

예시 9)

file = file_list[100]
file
-->
/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent/data/labels/HD_GLORY_20190607_091006.json

 

예시 10)

# 결과를 저장할 빈 집합 생성 (중복된 바운딩 박스 정보를 방지하기 위해 set 사용)
result = set()

# JSON 파일을 읽기 모드로 열기
with open(file, 'r') as f:
    # JSON 데이터를 파싱하여 파이썬 딕셔너리로 변환
    json_data = json.load(f)

    # 이미지의 해상도 정보를 가져와 가로(width)와 세로(height) 크기로 변환
    width, height = list(map(int, json_data["image_info"]["resolution"].split(',')))

    # 클래스 번호 설정 (현재 모든 객체를 클래스 0으로 설정)
    cls = 0

    # "annotations"에서 "drawing" 항목이 존재하는지 확인
    if json_data["annotations"].get("drawing"):
        # "drawing" 리스트에 있는 모든 바운딩 박스를 반복 처리
        for b in json_data["annotations"]["drawing"]:
            # COCO 형식의 바운딩 박스를 YOLO 형식으로 변환
            yolo_bbox = json_to_yolo_bbox(b, width, height)

            # YOLO 바운딩 박스 좌표값을 문자열로 변환 (공백으로 구분)
            bbox_string = " ".join([str(x) for x in yolo_bbox])

            # 클래스 번호와 바운딩 박스 정보를 조합하여 결과 집합에 추가
            result.add(f"{cls} {bbox_string}")

    # 집합(set)을 리스트로 변환 (중복된 바운딩 박스를 제거한 상태)
    result = list(result)

    # 변환된 결과가 존재할 경우 YOLO 형식의 텍스트 파일로 저장
    if result:
        # JSON 파일과 동일한 이름을 가지되 확장자를 '.txt'로 변경하여 저장
        with open(file.replace('json', 'txt'), 'w', encoding='utf-8') as t:
            # 리스트의 각 항목을 줄바꿈 문자("\n")로 연결하여 파일에 기록
            t.write("\n".join(result))

            # 변환이 완료된 파일명을 출력 (진행 상태 확인용)
            print(file)
 --->
 /content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent/data/labels/HD_GLORY_20190607_091006.json

 

예시 11)

# 파일 목록(file_list)의 각 파일을 순차적으로 처리하면서 진행률 표시 (tqdm 사용)
for file in tqdm(file_list):
    # 중복된 바운딩 박스를 방지하기 위해 set()을 사용하여 결과 저장
    result = set()
    
    # JSON 파일을 읽기 모드로 열기
    with open(file, 'r') as f:
        # JSON 데이터를 파싱하여 파이썬 딕셔너리로 변환
        json_data = json.load(f)

        # 이미지의 가로(width)와 세로(height) 크기 가져오기
        # "image_info"에서 "resolution" 값을 가져와 쉼표(,)로 분리 후 정수형(int)으로 변환
        width, height = list(map(int, json_data["image_info"]["resolution"].split(',')))

        # 클래스 번호 설정 (현재 모든 객체를 동일한 클래스 0으로 설정)
        cls = 0

        # 바운딩 박스 개수 가져오기
        num_b = json_data["annotations"]["bounding_count"]

        # 바운딩 박스 개수가 1개 이상일 경우 처리
        if num_b > 0:
            # "drawing" 키 안에 있는 모든 바운딩 박스 정보를 순회
            for b in json_data["annotations"]["drawing"]:
                # COCO 형식의 바운딩 박스를 YOLO 형식으로 변환
                yolo_bbox = json_to_yolo_bbox(b, width, height)

                # YOLO 형식의 바운딩 박스 좌표값을 문자열로 변환 (공백으로 구분)
                bbox_string = " ".join([str(x) for x in yolo_bbox])

                # 클래스 번호와 변환된 바운딩 박스를 조합하여 결과 집합(result)에 추가
                result.add(f"{cls} {bbox_string}")

            # 중복을 제거한 후 리스트로 변환
            result = list(result)

            # 변환된 바운딩 박스 정보가 존재할 경우 YOLO 형식의 `.txt` 파일로 저장
            if result:
                # 원본 JSON 파일과 동일한 파일명을 가지되 확장자를 `.txt`로 변경하여 저장
                with open(file.replace('json', 'txt'), "w", encoding="utf-8") as f:
                    # YOLO 형식의 바운딩 박스 정보를 파일에 줄 단위로 저장
                    f.write("\n".join(result))
--->
100%|██████████| 360/360 [01:44<00:00,  3.45it/s]

 

예시 12)

# tqdm을 사용하여 파일 목록(file_list) 순회하며 진행률 표시
for file in tqdm(file_list):
    # 중복된 바운딩 박스를 방지하기 위해 결과를 저장할 빈 set 생성
    result = set()

    # JSON 파일을 읽기 모드로 열기
    with open(file, 'r') as f:
        # JSON 데이터를 로드하여 파이썬 딕셔너리로 변환
        json_data = json.load(f)

        # 이미지의 해상도를 가져와 width, height를 정수형으로 변환
        width, height = list(map(int, json_data["image_info"]["resolution"].split(',')))

        # 객체의 클래스 번호 (현재 모든 객체를 클래스 0으로 설정)
        cls = 0

        # JSON에서 바운딩 박스 개수 가져오기
        num_b = json_data["annotations"]["bounding_count"]

        # 바운딩 박스가 1개 이상이면 변환 작업 수행
        if num_b > 0:
            # "drawing" 항목에 포함된 모든 바운딩 박스를 반복 처리
            for b in json_data["annotations"]["drawing"]:
                # COCO 형식의 바운딩 박스를 YOLO 형식으로 변환
                yolo_bbox = json_to_yolo_bbox(b, width, height)

                # 변환된 바운딩 박스 좌표를 문자열로 변환 (공백으로 구분)
                bbox_string = " ".join([str(x) for x in yolo_bbox])

                # 클래스 번호와 변환된 바운딩 박스를 조합하여 결과 집합(result)에 추가
                result.add(f"{cls} {bbox_string}")

            # set을 list로 변환하여 중복 제거된 데이터 유지
            result = list(result)

            # 변환된 결과가 존재하면 YOLO 형식의 .txt 파일로 저장
            if result:
                # JSON 파일명에서 확장자를 'json' → 'txt'로 변경하여 저장
                with open(file.replace('json', 'txt'), "w", encoding="utf-8") as f:
                    # YOLO 형식의 바운딩 박스 정보를 파일에 줄 단위로 기록
                    f.write("\n".join(result))

 

예시 13)

import random
import glob

# 난수 생성기의 시드를 2025로 설정
# 이를 통해 이후 random 모듈을 사용한 작업(예: 셔플)이 실행될 때
# 동일한 결과가 나오도록 보장 (재현 가능성 확보)
random.seed(2025)

# file_root 경로 안의 'labels' 폴더에서 모든 '.txt' 파일을 찾음
# glob.glob()은 지정된 패턴과 일치하는 파일 목록을 리스트 형태로 반환
# 예를 들어, file_root가 "/dataset"이면 "/dataset/labels/" 폴더 내 모든 ".txt" 파일을 리스트로 저장
file_list = glob.glob(f"{file_root}/labels/*.txt")

 

예시 14)

import random

# file_list의 요소(파일 경로)를 무작위로 섞음 (랜덤 순서 변경)
random.shuffle(file_list)

# 테스트 데이터 비율 설정 (예: 10%)
test_ratio = 0.1

# 전체 파일 개수 계산
num_file = len(file_list)

# 파일 개수 출력 (num_file 변수에 저장됨)
num_file

 

예시 15)

# 전체 파일 중에서 test_ratio(10%)에 해당하는 파일 개수만큼 테스트 리스트 생성
test_list = file_list[:int(num_file * test_ratio)]

# 테스트 리스트(test_list)의 개수 출력
len(test_list)
-->
24

 

예시 16)

# 검증(valid) 데이터 리스트 생성
valid_list = file_list[int(num_file * test_ratio) : int(num_file * test_ratio) * 2]

# 검증 데이터 개수 출력
len(valid_list)
-->
24

 

예시 17)

# 훈련(train) 데이터 리스트 생성
train_list = file_list[int(num_file * test_ratio) * 2:]
-->
24

 

예시 18)

import shutil
from tqdm import tqdm

#  테스트 데이터셋 라벨 & 이미지 복사
for i in tqdm(test_list):  # test_list에 있는 각 라벨 파일(txt)을 순회
    txt_name = i.split('/')[-1]  # 파일명만 추출 (예: "image_01.txt")
    
    # 라벨 데이터(txt) 복사: test_root/labels 폴더로 이동
    shutil.copyfile(i, f"{test_root}/labels/{txt_name}")

    # 해당 라벨 파일에 대응하는 이미지 파일 경로 찾기
    img_path = i.replace('labels', 'images')  # "labels" → "images" 폴더로 변경
    img_path = img_path.replace('TL', 'TS').replace('JSON', '이미지').replace('txt', 'jpg')  # 경로 조정

    img_name = img_path.split('/')[-1]  # 이미지 파일명 추출 (예: "image_01.jpg")

    # 이미지 파일 복사: test_root/images 폴더로 이동
    shutil.copyfile(img_path, f"{test_root}/images/{img_name}")

# 검증 데이터셋 라벨 & 이미지 복사
for i in tqdm(valid_list):  # valid_list에 있는 각 라벨 파일(txt)을 순회
    txt_name = i.split('/')[-1]  # 파일명만 추출

    # 라벨 데이터(txt) 복사: valid_root/labels 폴더로 이동
    shutil.copyfile(i, f"{valid_root}/labels/{txt_name}")

    # 해당 라벨 파일에 대응하는 이미지 파일 경로 찾기
    img_path = i.replace('labels', 'images')  # "labels" → "images"
    img_path = img_path.replace('TL', 'TS').replace('JSON', '이미지').replace('txt', 'jpg')  # 경로 조정

    jpg_name = img_path.split('/')[-1]  # 이미지 파일명 추출

    # 이미지 파일 복사: valid_root/images 폴더로 이동
    shutil.copyfile(img_path, f"{valid_root}/images/{jpg_name}")

# 훈련 데이터셋 라벨 & 이미지 복사
for i in tqdm(train_list):  # train_list에 있는 각 라벨 파일(txt)을 순회
    txt_name = i.split('/')[-1]  # 파일명만 추출

    # 라벨 데이터(txt) 복사: train_root/labels 폴더로 이동
    shutil.copyfile(i, f"{train_root}/labels/{txt_name}")

    # 해당 라벨 파일에 대응하는 이미지 파일 경로 찾기
    img_path = i.replace('labels', 'images')  # "labels" → "images"
    img_path = img_path.replace('TL', 'TS').replace('JSON', '이미지').replace('txt', 'jpg')  # 경로 조정

    jpg_name = img_path.split('/')[-1]  # 이미지 파일명 추출

    # 이미지 파일 복사: train_root/images 폴더로 이동
    shutil.copyfile(img_path, f"{train_root}/images/{jpg_name}")

 

예시 19)

# Google Drive 내 프로젝트 루트 디렉토리 경로 설정
# '/content/drive/MyDrive/' → Google Drive의 "내 드라이브(My Drive)" 경로
# 'KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent' → 특정 프로젝트 폴더 경로
# 이 변수는 프로젝트 내 파일을 불러오거나 저장할 때 기본 경로로 사용됨
pjt_root = '/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent'

 

예시 20)

import yaml

# 빈 딕셔너리 생성 (YOLO 데이터셋 설정 정보를 저장할 딕셔너리)
data = dict()

# 학습(train), 검증(val), 테스트(test) 데이터의 경로 설정
# train_root, valid_root, test_root 변수는 각각의 데이터셋 루트 경로를 의미
data['train'] = train_root  # 훈련 데이터 경로
data['val'] = valid_root    # 검증 데이터 경로
data['test'] = test_root    # 테스트 데이터 경로

# 클래스 개수 (nc: number of classes)
data['nc'] = 1  # 객체 클래스 개수가 1개 (ripcurrent 클래스만 존재)

# 클래스 이름 (names: 클래스 리스트)
data['names'] = ['rip']  # 클래스 이름이 'rip' (이 프로젝트는 rip current 예측 관련)

# 딕셔너리 출력 (YOLO 데이터셋 설정 정보 확인)
data
-->
{'train': '/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent/train',
 'val': '/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent/valid',
 'test': '/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent/test',
 'nc': 1,
 'names': ['rip']}

 

예시 21)

# YOLO 학습을 위한 데이터셋 설정 파일(rip.yaml) 저장
with open(f'{pjt_root}/rip.yaml', 'w') as f:
    yaml.dump(data, f)  # data 딕셔너리를 YAML 형식으로 저장

 

예시 22)

# %pwd
/content
%cd /content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent

 

예시 23)

# YOLO v8 모델 불러오기
model = YOLO('yolov8s.pt')

# YOLO 모델 학습 실행
results = model.train(
                     data='rip.yaml',   # 데이터셋 경로 (YOLO 학습용 설정 파일)
                     epochs=10,         # 학습할 에포크 수 (10번 반복 학습)
                     batch=8,           # 배치 크기 (한 번에 처리할 이미지 개수)
                     imgsz=224,         # 입력 이미지 크기 (224x224)
                     device=0,          # GPU 사용 (0번 GPU)
                     workers=1,         # 데이터 로드에 사용할 CPU 코어 개수
                     amp=False,         # Automatic Mixed Precision 비활성화 (FP32 연산 사용)
                     patience=30,       # 성능 향상이 없을 경우 조기 종료 기준 (30 epoch)
                     name='rip_s'       # 저장될 실험 결과 디렉토리 이름
                     )

 

예시 24)

from IPython.display import display
from PIL import Image

# 학습 결과가 저장될 폴더 경로 설정
result_folder = f'{pjt_root}/runs/detect/rip_s'

# 저장된 모델 가중치를 로드하여 평가 수행
model = YOLO(f'{result_folder}/weights/best.pt')

# 'test' 데이터셋을 사용하여 모델 평가
metrics = model.val(split='test')

 

예시 25)

# 테스트 데이터셋 평가 결과에서 mAP 값 출력
print(metrics.box.map)    # mAP@[0.5:0.95] (COCO 기준 평균 정밀도)
print(metrics.box.map50)  # mAP@0.5 (IoU=0.5 기준 평균 정밀도)
-->
0.37370496779548373
0.686418152555679

 

예시 26)

# YOLO 모델 가중치 불러오기
model = YOLO(f'{result_folder}/weights/best.pt')

# 테스트 데이터 변환 설정 (이미지를 텐서 형식으로 변환)
test_data_transform = transforms.Compose([
    transforms.ToTensor()  # 이미지를 PyTorch Tensor로 변환
])

# 객체 감지 결과를 시각화할 때 사용할 색상 딕셔너리 (BGR 형식)
color_dict = [(0, 0, 255)]  # 빨간색 (Blue=0, Green=0, Red=255)

 

예시 27)

import glob
import random

# 테스트 데이터셋의 루트 디렉토리 설정
test_root = '/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/ripcurrent/test'

# 테스트 데이터셋에서 이미지 파일 리스트 가져오기
test_file_list = glob.glob(f'{test_root}/images/*')  # 'images/' 폴더 내 모든 파일 가져오기

# 파일 리스트를 랜덤하게 섞음 (테스트 데이터 순서를 무작위로 변경)
random.shuffle(test_file_list)

# 섞인 테스트 파일 리스트 출력
test_file_list

 

예시 28)

# OpenCV를 사용하여 테스트 이미지 불러오기
test_img = cv2.imread(test_file_list[0])  # 첫 번째 테스트 이미지 로드

# OpenCV의 기본 색상(BGR)을 RGB로 변환 (YOLO 모델 입력 형식에 맞추기)
img_src = cv2.cvtColor(test_img, cv2.COLOR_BGR2RGB)

# YOLO 모델을 사용하여 객체 감지 수행
results = model(img_src)[0]

# 감지 결과 출력
results
-->
0: 128x224 (no detections), 21.7ms
Speed: 1.5ms preprocess, 21.7ms inference, 1.1ms postprocess per image at shape (1, 3, 128, 224)
ultralytics.engine.results.Results object with attributes:

boxes: ultralytics.engine.results.Boxes object
keypoints: None
masks: None
names: {0: 'rip'}
obb: None
orig_img: array([[[ 72,  72,  72],
        [ 74,  74,  74],
        [ 74,  73,  78],
        ...,
        [114, 118, 130],
        [114, 118, 130],
        [114, 118, 130]],

       [[ 73,  73,  73],
        [ 75,  75,  75],
        [ 75,  74,  79],
        ...,
        [114, 118, 130],
        [114, 118, 130],
        [114, 118, 130]],

       [[ 74,  74,  74],
        [ 75,  75,  75],
        [ 75,  74,  79],
        ...,
        [114, 118, 130],
        [114, 118, 130],
        [114, 118, 130]],

       ...,

       [[ 36,  32,  29],
        [ 37,  33,  30],
        [ 38,  34,  31],
        ...,
        [ 77,  72,  52],
        [ 77,  72,  52],
        [ 77,  72,  52]],

       [[ 37,  33,  30],
        [ 38,  34,  31],
        [ 37,  33,  30],
        ...,
        [ 77,  72,  52],
        [ 77,  72,  52],
        [ 77,  72,  52]],

       [[ 38,  34,  31],
        [ 38,  34,  31],
        [ 37,  33,  30],
        ...,
        [ 77,  72,  52],
        [ 77,  72,  52],
        [ 77,  72,  52]]], dtype=uint8)
orig_shape: (1080, 1920)
path: 'image0.jpg'
probs: None
save_dir: 'runs/detect/predict'
speed: {'preprocess': 1.4616569999361673, 'inference': 21.718684999996185, 'postprocess': 1.058796000052098}

 

예시 29)

# 감지된 객체에 바운딩 박스 및 라벨을 추가하는 Annotator 생성
annotator = Annotator(img_src)

# 감지된 객체들의 바운딩 박스 정보 가져오기
boxes = results.boxes

# 감지된 각 객체에 대해 바운딩 박스를 그림
for box in boxes:
    b = box.xyxy[0]  # 바운딩 박스 좌표 (x1, y1, x2, y2)
    cls = box.cls  # 감지된 객체의 클래스 ID

    # 바운딩 박스에 클래스 라벨 및 색상 추가
    annotator.box_label(b, model.names[int(cls)], color_dict[int(cls)])

# 최종 결과 이미지 가져오기
img_src = annotator.result()

# 결과 이미지 출력
plt.imshow(img_src)
plt.axis("off")  # 축 제거
plt.show()

-->

 

예시 30)

import cv2
import matplotlib.pyplot as plt

# 출력 크기 설정 (12x6 크기의 그림 생성)
plt.figure(figsize=(12, 6))

# 상위 6개의 테스트 이미지에 대해 객체 감지 수행
for idx in range(6):
    # 테스트 이미지 로드 및 BGR → RGB 변환
    test_img = cv2.imread(test_file_list[idx])
    img_src = cv2.cvtColor(test_img, cv2.COLOR_BGR2RGB)

    # YOLO 모델을 사용하여 객체 감지 수행
    results = model(test_img)

    # 감지된 객체를 이미지에 표시
    for result in results:
        annotator = Annotator(img_src)  # Annotator 객체 생성
        boxes = result.boxes  # 감지된 바운딩 박스 정보 가져오기
        
        for box in boxes:
            b = box.xyxy[0]  # 바운딩 박스 좌표 (x1, y1, x2, y2)
            cls = box.cls  # 감지된 객체 클래스 ID

            # 바운딩 박스 및 클래스 라벨 추가
            annotator.box_label(b, model.names[int(cls)], color_dict[int(cls)])

    # 최종 객체 감지 결과 이미지 생성
    img_src = annotator.result()

    # 2행 3열 서브플롯의 idx번째 위치에 이미지 출력
    plt.subplot(2, 3, (idx + 1))
    plt.imshow(img_src)
    plt.axis("off")  # 축 제거

# 모든 서브플롯 표시
plt.show()
-->
0: 128x224 (no detections), 12.2ms
Speed: 1.1ms preprocess, 12.2ms inference, 0.8ms postprocess per image at shape (1, 3, 128, 224)

0: 128x224 1 rip, 9.0ms
Speed: 1.0ms preprocess, 9.0ms inference, 1.4ms postprocess per image at shape (1, 3, 128, 224)

0: 128x224 1 rip, 8.9ms
Speed: 0.9ms preprocess, 8.9ms inference, 1.3ms postprocess per image at shape (1, 3, 128, 224)

0: 128x224 2 rips, 8.6ms
Speed: 2.0ms preprocess, 8.6ms inference, 1.5ms postprocess per image at shape (1, 3, 128, 224)

0: 128x224 1 rip, 8.1ms
Speed: 1.5ms preprocess, 8.1ms inference, 1.3ms postprocess per image at shape (1, 3, 128, 224)

0: 128x224 (no detections), 8.9ms
Speed: 2.0ms preprocess, 8.9ms inference, 0.6ms postprocess per image at shape (1, 3, 128, 224)

-->