차량파손 데이터셋

AI-Hub의 차량 파손 데이터가 크므로 샘플 데이터를 압축을 푼후 쓰세요

https://www.aihub.or.kr/aihubdata/data/view.do?currMenu=115&topMenu=100&aihubDataSe=data&dataSetSn=581

AI-Hub

 

예시 1)

%pwd
-->
/content

# 경로를 변경
%cd /content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/damage/data

 

예시 2)

# ./images/damage.zip 에 있는 압축 풀기
!unzip -oq ./images/damage.zip -d ./images/

 

예시 3)

#압축 풀기
!unzip -oq ./annotations/damage.zip -d ./annotations/

 

예시 4)

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

 

예시 5)

import os
import random
import shutil
import cv2
import glob
import json
import numpy as np
import matplotlib.pyplot as plt
import ultralytics
from tqdm import tqdm
from pycocotools import mask as maskUtils

 

예시 6)

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

 

예시 7)

# 파일 경로 설정
file_root = '/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전'
data_root = '/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/damage'
train_root = f'{data_root}/train'
valid_root = f'{data_root}/valid'
test_root = f'{data_root}/test'
cls_list = ['Scaratched', 'Crushed', 'Breakage', 'Separated']

 

예시 8)

# 학습(train), 검증(validation), 테스트(test) 데이터셋의 루트 폴더 리스트
for folder in [train_root, valid_root, test_root]:  
    # 만약 해당 폴더(train, valid, test)가 존재하지 않으면 생성
    if not os.path.exists(folder):  
        os.makedirs(folder)  # 디렉터리 생성
    
    # 각 폴더 안에 'images' 폴더와 'labels' 폴더를 생성
    for s in ['images', 'labels']:  
        s_folder = f'{folder}/{s}'  # 현재 폴더 내에 'images' 또는 'labels' 폴더 경로 생성
        if not os.path.exists(s_folder):  
            os.makedirs(s_folder)  # 폴더가 없으면 생성

 

예시 9)

# 이미지 폴더 갯수
data_list = glob.glob(f'{data_root}/data/images/*.jpg')
len(data_list)

 

예시 10)

# 데이터의 이미지 폴더 경로
data_list[0]
-->
/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/damage/data/images/0087613_sc-197073.jpg

 

예시 11)

import json  # JSON 파일을 읽기 위해 사용
import cv2  # OpenCV 라이브러리 (이미지 처리)
import numpy as np  # 배열 처리를 위한 NumPy
import os  # 파일 경로 처리를 위한 os 모듈
import matplotlib.pyplot as plt  # Matplotlib을 사용하여 이미지 출력

# 주어진 인덱스(idx)에 해당하는 이미지 파일을 불러와서
# JSON 어노테이션 파일에서 폴리곤 정보를 읽어 이미지 위에 그려주는 함수.
def draw_polygon_by_index(idx):
    
    # data_list에서 idx에 해당하는 이미지 파일 경로 가져오기
    image_path = data_list[idx]

    # OpenCV를 사용하여 이미지 로드
    image = cv2.imread(image_path)
    
    # 어노테이션 JSON 파일 경로 생성 (이미지 파일 경로에서 변환)
    json_path = image_path.replace('images', 'annotations').replace('.jpg', '.json')

    # OpenCV는 기본적으로 BGR 색상을 사용하므로 Matplotlib에서 올바르게 표시하려면 RGB로 변환
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    # JSON 파일 열기 및 데이터 로드
    with open(json_path, 'r') as f:
        data = json.load(f)  # JSON 데이터를 Python 딕셔너리로 변환

    # JSON의 'annotations' 키 안의 데이터 순회
    for ann in data['annotations']:
        # 'segmentation' 키가 존재하는 경우
        if 'segmentation' in ann:
            segmentation = ann['segmentation']

            # segmentation이 리스트 형식인지 확인
            if isinstance(segmentation, list):
                for seg in segmentation:
                    # 세그먼트(seg)가 리스트인지 확인 (좌표 리스트인지 체크)
                    if isinstance(seg, list):
                        # 좌표 데이터를 NumPy 배열로 변환 및 정수형(Int32)으로 변경
                        points = np.array(seg).reshape(-1, 2).astype(np.int32)

                        # OpenCV를 사용하여 폴리곤(다각형) 그리기
                        # - image: 이미지 배열
                        # - [points]: 다각형 좌표 리스트 (배열 형태로 감싸야 함)
                        # - isClosed=True: 다각형을 닫음
                        # - color=(255, 0, 0): 빨간색 (BGR 포맷이므로 (Blue, Green, Red))
                        # - thickness=2: 선 두께 2px
                        cv2.polylines(image, [points], isClosed=True, color=(255, 0, 0), thickness=2)

    # Matplotlib을 사용하여 이미지 출력
    plt.figure(figsize=(10, 8))  # 이미지 크기 설정
    plt.imshow(image)  # 이미지 출력
    plt.axis('off')  # 축 제거
    plt.title(f'Polygon Overlay: {os.path.basename(image_path)}')  # 이미지 제목 추가
    plt.show()  # 화면에 이미지 표시

 

예시 12)

#20번째 파일 출력
draw_polygon_by_index(20)

--->

 

예시 13)

# 자동차 손상 유형을 나타내는 클래스 딕셔너리
damage_classes = {
    "Scratched": 0,  # 긁힘
    "Crushed": 1,    # 찌그러짐
    "Breakage": 2,   # 파손
    "Separated": 3   # 분리됨
}

 

예시 14)

import json
import os

# JSON 어노테이션 데이터를 YOLO 형식으로 변환하여 저장하는 함수
def convert_json_to_yolo(json_path, save_dir):
 
    # JSON 파일 로드
    with open(json_path, 'r') as f:
        data = json.load(f)
    
    # 이미지 정보 가져오기 (너비, 높이)
    image_info = data['images']
    img_width, img_height = image_info['width'], image_info['height']

    # YOLO 어노테이션 리스트 초기화
    yolo_annotations = []

    # 어노테이션 데이터를 순회하며 YOLO 형식으로 변환
    for ann in data['annotations']:
        if 'segmentation' in ann and 'damage' in ann:
            segmentation = ann['segmentation'][0][0]  # 첫 번째 세그멘테이션 정보 가져오기
            
            # 세그먼트가 중첩된 리스트인지 확인 후 평탄화
            if isinstance(segmentation[0], list):
                segmentation = [coord for sublist in segmentation for coord in sublist]

            # 좌표 값을 YOLO 형식으로 정규화 (0~1 범위)
            normalized_coords = [
                segmentation[i] / img_width if i % 2 == 0 else segmentation[i] / img_height
                for i in range(len(segmentation))
            ]
            
            # 클래스 ID 가져오기 (없는 경우 -1)
            class_label = damage_classes.get(ann['damage'], -1)

            # YOLO 형식의 문자열 생성 (클래스 ID + 정규화된 좌표)
            yolo_annotations.append(f"{class_label} " + ' '.join(map(str, normalized_coords)))
    
    # 변환된 YOLO 라벨을 저장할 파일명 생성 (json → txt 변경)
    yolo_filename = os.path.basename(json_path).replace('.json', '.txt')
    save_path = os.path.join(save_dir, yolo_filename)

    # YOLO 라벨 파일 저장
    with open(save_path, 'w') as f:
        f.write('\n'.join(yolo_annotations))

 

예시 15)

import os
import glob
from tqdm import tqdm  # 진행 상태바를 표시하는 tqdm

# JSON 파일들을 YOLO 형식으로 변환
for json_path in tqdm(glob.glob(os.path.join(f'{data_root}/data/annotations', '*.json'))):
    """
    - `glob.glob(...)`:
        - `data_root/data/annotations/` 디렉터리에서 `.json` 파일 목록을 가져옴.
        - 즉, 모든 JSON 어노테이션 파일을 찾음.

    - `tqdm(...)`:
        - 파일 변환 진행 상황을 **프로그레스 바 형태로 시각적으로 표시**.

    - `convert_json_to_yolo(json_path, f'{data_root}/data/labels')`:
        - JSON 파일을 YOLO 형식으로 변환하여 `data_root/data/labels/`에 저장.
    """
    convert_json_to_yolo(json_path, f'{data_root}/data/labels')

# 변환 완료 메시지 출력
print(f'YOLO 변환 완료')
-->
100%|██████████| 1200/1200 [08:01<00:00,  2.49it/s]YOLO 변환완료

 

예시 16)

import random
import glob

# 랜덤 시드 설정 (재현 가능성을 위해 고정)
random.seed(2025)

# YOLO 형식의 라벨 파일 목록 가져오기
file_list = glob.glob(f'{data_root}/data/labels/*.txt')

# 파일 리스트를 랜덤하게 섞기
random.shuffle(file_list)

# 테스트 데이터 비율 설정
test_ratio = 0.1  # 10%를 테스트 데이터로 사용

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

# 데이터셋 분할 (테스트, 검증, 학습 데이터)
test_list = file_list[:int(num_file * test_ratio)]  # 첫 10% → 테스트 데이터
valid_list = file_list[int(num_file * test_ratio):int(num_file * test_ratio) * 2]  # 다음 10% → 검증 데이터
train_list = file_list[int(num_file * test_ratio) * 2:]  # 나머지 → 학습 데이터

 

예시 17)

import shutil
from tqdm import tqdm

# 테스트 데이터 이동
for i in tqdm(test_list):
    label_name = i.split('/')[-1]  # 파일명만 추출
    shutil.copyfile(i, f'{test_root}/labels/{label_name}')  # 라벨 파일 복사

    img_name = i.split('/')[-1].replace('txt', 'jpg')  # 파일 확장자 변경 (txt → jpg)
    img_path = f'{data_root}/data/images/{img_name}'  # 이미지 파일 경로 생성
    shutil.copyfile(img_path, f'{test_root}/images/{img_name}')  # 이미지 파일 복사

# 검증 데이터 이동
for i in tqdm(valid_list):
    label_name = i.split('/')[-1]
    shutil.copyfile(i, f'{valid_root}/labels/{label_name}')

    img_name = i.split('/')[-1].replace('txt', 'jpg')
    img_path = f'{data_root}/data/images/{img_name}'
    shutil.copyfile(img_path, f'{valid_root}/images/{img_name}')

# 학습 데이터 이동
for i in tqdm(train_list):
    label_name = i.split('/')[-1]
    shutil.copyfile(i, f'{train_root}/labels/{label_name}')

    img_name = i.split('/')[-1].replace('txt', 'jpg')
    img_path = f'{data_root}/data/images/{img_name}'
    shutil.copyfile(img_path, f'{train_root}/images/{img_name}')
-->
100%|██████████| 120/120 [00:20<00:00,  5.88it/s]
100%|██████████| 120/120 [00:14<00:00,  8.36it/s]
100%|██████████| 960/960 [09:39<00:00,  1.66it/s]

 

예시 18)

%pwd
-->
/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/damage/data

%cd /content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/damage
-->
/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/damage

 

예시 19)

import yaml  # YAML 파일을 생성하고 저장하기 위한 라이브러리

# YOLO 학습을 위한 데이터 설정을 저장할 딕셔너리 생성
data = dict()

# 학습(train), 검증(val), 테스트(test) 데이터셋 경로 설정
data['train'] = train_root  # 학습 데이터 경로
data['val'] = valid_root    # 검증 데이터 경로
data['test'] = test_root    # 테스트 데이터 경로

# 클래스 개수 (nc: number of classes)
data['nc'] = len(cls_list)  # 클래스 개수 저장

# 클래스 이름 리스트 (names: YOLO 학습을 위한 클래스 리스트)
data['names'] = cls_list  # 클래스명 리스트 저장

# YAML 파일 생성 및 저장
with open('car_damage.yaml', 'w') as f:
    yaml.dump(data, f)  # 데이터 딕셔너리를 YAML 형식으로 저장

 

예시 20)

from ultralytics import YOLO  # Ultralytics YOLO 라이브러리 임포트

# YOLO 모델 초기화 (Segmentation용)
model = YOLO('yolov8s-seg.yaml')  
"""
- 'yolov8s-seg.yaml': YOLOv8 **Segmentation** 모델을 설정하는 YAML 파일
- 모델 구조 및 기본 설정을 정의함.
"""

# YOLO 모델 학습 실행
results = model.train(
    data='car_damage.yaml',  # 학습 데이터셋 경로 (YAML 설정 파일)
    epochs=100,              # 학습 반복 횟수 (Epoch 수)
    imgsz=224,               # 입력 이미지 크기 (224x224)
    batch=16,                # 미니 배치 크기 (16개의 이미지씩 학습)
    device=0,                # GPU 사용 (0번 GPU 사용)
    name='damage_s'          # 저장될 실험 결과 폴더 이름 (runs/segment/damage_s/)
)

 

예시 21)

result_folder = '/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/damage/runs/segment/damage_s'
model = YOLO(f'{result_folder}/weights/best.pt')

--->

 

예시 22)

results = model.predict (
    source = '/content/drive/MyDrive/KDT 시즌 4/13. 컴퓨터 비전/resource/damage/test/images',
    imgsz = 224,
    conf = 0.15,
    device = 0,
    save = True,
    save_root = True
)

--->