[딥러닝] 10. 객체검출

[신민서]

실습 과제

• faster r-cnn 모델의 구조와 원리를 조사하라
  • https://frogbam07.tistory.com/28   < RoI Pooling 설명
  • https://medium.com/@parkie0517/r-cnn-%EA%B3%84%EC%97%B4%EC%9D%98-%EB%B0%9C%EC%A0%84-%EB%8F%99%ED%96%A5%EA%B3%BC-faster-r-cnn-%EB%85%BC%EB%AC%B8-%EB%A6%AC%EB%B7%B0-155f46cca6ad < faster r-cnn 설명
  • Fast R-CNN?
    • Region Proposal > 물체가 속할 수 있는 후보군을 제안하는 일
    • 입력(이미지, pixel)이 한 번만 CNN을 거침
      • 특성맵 하나만 생김
  • 구조
    • Backbone 네트워크
      • 입력 이미지를 특성 맵으로 변형 시켜줌
    • RPN(Region Proposal Network) 모듈
      • 특성 맵으로부터 region proposal 수행함
      • 어디 부분을 객체로 인식해야 하는지 알려줌
    • Detection 모듈

>   RoI Pooling 수행 > Region of Interest Pooling

>   제안된 영역에 대해 classification(분류)와 regression(회귀) 수행

• 훈련 결과를 실시간으로 시각화하시오.
  • accuracy > mAP(50:95)
  • loss
  • VcXsrv 사용
  • engine.py 내에 있는 함수에서 값을 반환, 에폭을 돌 때 변수에 저장하고 liveplot 클래스 내 함수에 넣어
    실시간 업데이트가 가능하도록 작성 

> train.py의 에폭 도는 부분 수정 > 클래스 추가

print("Start training")     start_time = time.time()          lp = LivePlot() # 객체 생성               for epoch in range(args.start_epoch, args.epochs):         if args.distributed:             train_sampler.set_epoch(epoch)                           train_loss, train_acc = train_one_epoch(model, optimizer, data_loader, device, epoch, args.print_freq, scaler)                  lr_scheduler.step()         if args.output_dir:             checkpoint = {                 "model": model_without_ddp.state_dict(),                 "optimizer": optimizer.state_dict(),                 "lr_scheduler": lr_scheduler.state_dict(),                 "args": args,                 "epoch": epoch,             }             if args.amp:                 checkpoint["scaler"] = scaler.state_dict()             utils.save_on_master(checkpoint, os.path.join(args.output_dir, f"model_{epoch}.pth"))             utils.save_on_master(checkpoint, os.path.join(args.output_dir, "checkpoint.pth"))             # added by 2sungryul, save the full model with its structure and weight               torch.save(model_without_ddp, os.path.join(args.output_dir, "model.pth"))           # eval‎uate after every epoch         val_loss, val_acc = eval‎uate(model, data_loader_test, device=device)         lp.update_all(epoch, train_loss, val_loss, train_acc, val_acc)         lp.show()     total_time = time.time() - start_time     total_time_str = str(datetime.timedelta(seconds=int(total_time)))     print(f"Training time {total_time_str}") Colored by Color Scripter

cs

> engine.py 함수 수정

def train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq, scaler=None):     model.train()  # 모델을 학습 모드로 설정     metric_logger = utils.MetricLogger(delimiter="  ")     header = f"Epoch: [{epoch}]"       running_loss = 0.0     total_samples = 0       coco_eval‎uator = CocoEval‎uator(get_coco_api_from_dataset(data_loader.dataset), iou_types=["bbox"])       for images, targets in metric_logger.log_every(data_loader, print_freq, header):         images = list(image.to(device) for image in images)         targets = [{k: (v.to(device) if isinstance(v, torch.Tensor) else v) for k, v in t.items()} for t in targets]           # 모델에 이미지와 타겟을 전달하여 손실 계산 (학습 모드)         with torch.autocast(device_type='cpu',enabled=scaler is not None):             loss_dict = model(images, targets)               losses = sum(loss for loss in loss_dict.values())           optimizer.zero_grad()         if scaler is not None:             scaler.scale(losses).backward()             scaler.step(optimizer)             scaler.update()         else:             losses.backward()             optimizer.step()           batch_size = len(images)         running_loss += losses.item() * batch_size         total_samples += batch_size                  model.eval‎()         outputs = model(images)         model.train()                  res = {}         for i, output in enumerate(outputs):             image_id = targets[i]["image_id"]                          # image_id가 문자열이면 정수로 변환             if isinstance(image_id, torch.Tensor):                 image_id = image_id.item()             elif isinstance(image_id, str):                 try:                     image_id = int(image_id)  # 문자열이면 정수로 변환                 except ValueError:                     raise ValueError(f"Invalid image_id: {image_id}. Expected int or convertible string.")               res[image_id] = {                 "boxes": output["boxes"].detach().cpu(),                 "scores": output["scores"].detach().cpu(),                 "labels": output["labels"].detach().cpu()             }           coco_eval‎uator.update(res)         metric_logger.update(loss=losses.item())       # 에포크별 손실 계산     epoch_loss = running_loss / total_samples       # COCO eval‎uator 처리     coco_eval‎uator.synchronize_between_processes()     coco_eval‎uator.accumulate()     coco_eval‎uator.summarize()          # mAP 계산     coco_stats = coco_eval‎uator.coco_eval‎['bbox'].stats     train_mAP = coco_stats[0]  # mAP (IoU=0.50:0.95)     print(f"epcoh_loss: {epoch_loss}")     print(f"train_mAP: {train_mAP}")     return epoch_loss, train_mAP  # 훈련 손실 및 mAP 반환       def _get_iou_types(model):     model_without_ddp = model     if isinstance(model, torch.nn.parallel.DistributedDataParallel):         model_without_ddp = model.module     iou_types = ["bbox"]     if isinstance(model_without_ddp, torchvision.models.detection.MaskRCNN):         iou_types.append("segm")     if isinstance(model_without_ddp, torchvision.models.detection.KeypointRCNN):         iou_types.append("keypoints")     return iou_types     @torch.inference_mode() def eval‎uate(model, data_loader_test, device):     model.eval‎()     coco = get_coco_api_from_dataset(data_loader_test.dataset)     coco_eval‎uator = CocoEval‎uator(coco, iou_types=["bbox"])       running_loss = 0.0     total_samples = 0       with torch.no_grad():         for images, targets in data_loader_test:             images = list(image.to(device) for image in images)             targets = [{k: (v.to(device) if isinstance(v, torch.Tensor) else v) for k, v in t.items()} for t in targets]               model.train()             loss_dict = model(images, targets)             losses = sum(loss for loss in loss_dict.values())             model.eval‎()               batch_size = len(images)             running_loss += losses.item() * batch_size             total_samples += batch_size               # 모델의 예측을 coco eval‎uator로 업데이트             outputs = model(images)             #res = {target["image_id"].item(): output for target, output in zip(targets, outputs)}                          res = {}             for i, output in enumerate(outputs):                 image_id = targets[i]["image_id"]                              # image_id가 문자열이면 정수로 변환                 if isinstance(image_id, torch.Tensor):                     image_id = image_id.item()                 elif isinstance(image_id, str):                     try:                         image_id = int(image_id)  # 문자열이면 정수로 변환                     except ValueError:                         raise ValueError(f"Invalid image_id: {image_id}. Expected int or convertible string.")                   res[image_id] = {                     "boxes": output["boxes"].detach().cpu(),                     "scores": output["scores"].detach().cpu(),                     "labels": output["labels"].detach().cpu()                 }                 coco_eval‎uator.update(res)       epoch_loss = running_loss / total_samples     coco_eval‎uator.synchronize_between_processes()     coco_eval‎uator.accumulate()     coco_eval‎uator.summarize()       # mAP 값 추출     coco_stats = coco_eval‎uator.coco_eval‎['bbox'].stats     val_mAP = coco_stats[0]  # mAP (IoU=0.50:0.95)     print(f"epcoh_loss: {epoch_loss}")     print(f"val_mAP: {val_mAP}")     return epoch_loss, val_mAP  # 검증 손실 및 mAP 반환     Colored by Color Scripter

cs

• 최종 모델파일을 이용하여 테스트하는 파이토치 코드 my_test.py를 작성하시오
  • 10장씩 새로 찍어서 모두 불러와 테스트
  • 한 장씩 볼 수 있는 코드와 10장을 한 번에 볼 수 있는 코드
  • https://kind-slip-86b.notion.site/10-1a18a2c2bfdb8059ac55e121e848150c?pvs=4

딥러닝 10 | Notion

• 훈련 성능을 평가하는 아래의 지표들의 의미를 설명하시오
  • loss
    • 손실 
    • 모델의 예측값과 실제값 간의 차이를 측정
  • loss_classifier
    • 분류 손실 
    • 객체 검출 모델에서 각 객체가 특정 클래스에 속할 확률을 예측할 때 사용
    • 예를 들면 객체가 고양이인지 강아지인지 구별할 때의 손실값임
  • loss_box_reg
    • 박스 회귀 손실 
    • 예측된 바운딩 박스(객체를 둘러싸는 사각형)와 실제 바운딩 박스 간의 차이를 계산
  • loss_objectness
    • 객체 존재 여부 손실 
    • 모델이 해당 영역에 객체가 있는지 없는지를 예측하는데 사용
    • RPN에서 사용
    • 이진 분류 문제
  • loss_rpn_box_reg
    • RPN 박스 회귀 손실 
    • RPN이 예측한 바운딩 박스가 실제 바운딩 박스와 얼마나 차이가 나는지 측정
  • AP
    • 평균 정밀도
    • 객체 검출 성능을 평가하는 지표 > 모델이 얼마나 정확하게 객체를 검출하는지를 측정함
    • 보통 mAP가 사용되며, 여러 클래스에 대한 AP의 평균을 의미
    • https://ctkim.tistory.com/79
    • AP > 여러 임계값에서의 정밀도와 재현율(Recall)을 종합하여 계산함
  • IOU
    • 교집합 비율
    • 예측된 바운딩 박스와 실제 바운딩 박스 간의 겹치는 영역의 비율을 측정하는 지표
    • 예측된 박스와 실제 박스의 교집합 / 예측된 박스와 실제 박스의 합집합
  • maxDets
    • 최대 검출 수
    • 객체 검출 모델이 한 이미지에서 얼마나 많은 객체를 검출할 수 있는지에 대한 제한

• 표의 의미를 설명하라

• Average Precision(AP)
  • 평균 정밀도
  • 모델이 양성으로 예측한 값 중 실제로 양성인 비율
  • 해당 값이 높다면 오검출이 낮음
• Average Recall(AR)
  • 평균 재현율
  • 실제 양성 중에서 모델이 정확하게 감지한 비율
  • 해당 값이 높다면 미검출한 객체가 낮음
• IoU
  • 지정해준 정답의 라운딩 박스와 모델이 추측한 객체의 라운딩 박스가 일치하는 비율을 나타낸 값
  • IoU=0.50 > 50% 이상 겹치는 객체에 대해 정답으로 인식
  • IoU=0.50:0.95 > 50% 이상 95% 미만 겹치는 영역에 위치했을 때 정답으로 인식
• area
  • 라운딩 박스의 크기를 의미

• 전이학습에서 훈련하는 웨이트는 컨벌루션레이어와 완전연결레이어 중 어느 것인가?
  • 컨벌루션 레이어: 은닉층에서 사용되는 레이어
  • 완전 연결 레이어: 은닉층의 가중치와 편향값의 수행 결과를 토대로 모델의 최종 출력을 결정하는 역할을 하는 레이어
  • 전이학습에서 재학습하는 레이어들은 컨벌루션 레이어임

• 훈련결과를 이용하여 과적합을 판단하는 방법을 설명하라
  • 작은 객체와 중간 크기 객체에서의 AP와 AR이 현저히 낮거나 -1로 표시되는 경우
  • 모델이 특정 객체 크기나 특정 데이터 범주에 대해 잘 작동하지 않는다면,
    해당 범주에서 과적합이 발생했거나 데이터가 부족한 경우임

• 파이토치 예제에서 사용한 증식 적용에 대해서 설명하라.
  • preset.py에서 증식 확인 가능

from collections import defaultdict   import torch import transforms as reference_transforms     def get_modules(use_v2):     # We need a protected import to avoid the V2 warning in case just V1 is used     if use_v2:         import torchvision.transforms.v2         import torchvision.tv_tensors           return torchvision.transforms.v2, torchvision.tv_tensors     else:         return reference_transforms, None     class DetectionPresetTrain:     # Note: this transform assumes that the input to forward() are always PIL     # images, regardless of the backend parameter.     def __init__(         self,         *,         data_augmentation,         hflip_prob=0.5,         mean=(123.0, 117.0, 104.0),         backend="pil",         use_v2=False,     ):           T, tv_tensors = get_modules(use_v2)           transforms = []         backend = backend.lower()         if backend == "tv_tensor":             transforms.append(T.ToImage())         elif backend == "tensor":             transforms.append(T.PILToTensor())         elif backend != "pil":             raise ValueError(f"backend can be 'tv_tensor', 'tensor' or 'pil', but got {backend}")           if data_augmentation == "hflip":             transforms += [T.RandomHorizontalFlip(p=hflip_prob)]         elif data_augmentation == "lsj":             transforms += [                 T.ScaleJitter(target_size=(1024, 1024), antialias=True),                 # TODO: FixedSizeCrop below doesn't work on tensors!                 reference_transforms.FixedSizeCrop(size=(1024, 1024), fill=mean),                 T.RandomHorizontalFlip(p=hflip_prob),             ]         elif data_augmentation == "multiscale":             transforms += [                 T.RandomShortestSize(min_size=(480, 512, 544, 576, 608, 640, 672, 704, 736, 768, 800), max_size=1333),                 T.RandomHorizontalFlip(p=hflip_prob),             ]         elif data_augmentation == "ssd":             fill = defaultdict(lambda: mean, {tv_tensors.Mask: 0}) if use_v2 else list(mean)             transforms += [                 T.RandomPhotometricDistort(),                 T.RandomZoomOut(fill=fill),                 T.RandomIoUCrop(),                 T.RandomHorizontalFlip(p=hflip_prob),             ]         elif data_augmentation == "ssdlite":             transforms += [                 T.RandomIoUCrop(),                 T.RandomHorizontalFlip(p=hflip_prob),             ]         else:             raise ValueError(f'Unknown data augmentation policy "{data_augmentation}"')           if backend == "pil":             # Note: we could just convert to pure tensors even in v2.             transforms += [T.ToImage() if use_v2 else T.PILToTensor()]           transforms += [T.ToDtype(torch.float, scale=True)]           if use_v2:             transforms += [                 T.ConvertBoundingBoxFormat(tv_tensors.BoundingBoxFormat.XYXY),                 T.SanitizeBoundingBoxes(),                 T.ToPureTensor(),             ]           self.transforms = T.Compose(transforms)       def __call__(self, img, target):         return self.transforms(img, target)     class DetectionPresetEval‎:     def __init__(self, backend="pil", use_v2=False):         T, _ = get_modules(use_v2)         transforms = []         backend = backend.lower()         if backend == "pil":             # Note: we could just convert to pure tensors even in v2?             transforms += [T.ToImage() if use_v2 else T.PILToTensor()]         elif backend == "tensor":             transforms += [T.PILToTensor()]         elif backend == "tv_tensor":             transforms += [T.ToImage()]         else:             raise ValueError(f"backend can be 'tv_tensor', 'tensor' or 'pil', but got {backend}")           transforms += [T.ToDtype(torch.float, scale=True)]           if use_v2:             transforms += [T.ToPureTensor()]           self.transforms = T.Compose(transforms)       def __call__(self, img, target):         return self.transforms(img, target)   Colored by Color Scripter

cs

사용한 증식 목록

• https://pytorch.org/vision/main/transforms.html
• RandomHorizontalFlip  <  랜덤하게 수평으로 뒤집음
• ScaleJitter  <  이미지 무작위로 붙여넣기 수행
• RandomShorttestSize  <  입력의 크기를 무작위로 조절
• RandomPhotometricDistort   < 이미지 랜덤 왜곡 ( 밝기, 대비, 채도 등)
• RandomZoomOut  <  이미지 축소 변형 (이미지 및 바운딩 박스 및 마스크를 무작위로 패딩함)
• RandomIoUCrop  < IoU 크롭, 랜덤하게 변환함

• 증식 확인 시 참고
• https://cafe.daum.net/SmartRobot/W2or/159 

• Yolo 모델을 이용하여 객체 검출을 수행
• yolo_detection.py

from ultralytics import YOLO import torch import time  # 시간 측정을 위한 모듈 추가   def train_yolo(data_yaml, epochs=50, imgsz=640, save_path="/home/jetson/work/Pytorch/dataset2/output_yolo/yolo_custom.pt"):     """ YOLO 모델 학습 및 저장 """     model = YOLO("yolov8n.pt")  # YOLOv8n 모델 로드          start_time = time.time()  # 학습 시작 시간 기록     model.train(data=data_yaml, epochs=epochs, imgsz=imgsz)     end_time = time.time()  # 학습 종료 시간 기록          total_time = end_time - start_time  # 훈련 시간 계산     print(f"Total training time: {total_time:.2f} seconds")  # 훈련 시간 출력          model.save(save_path)  # 학습된 모델 저장     print(f"Model saved at: {save_path}")          return save_path   def main():     device = 'cuda' if torch.cuda.is_available() else 'cpu'     print(f"Using device: {device}")          # YOLO 학습 데이터 설정     data_yaml = "/home/jetson/work/Pytorch/vision/references/detection/data.yaml"          # YOLO 커스텀 학습 진행     trained_model = train_yolo(data_yaml)   if __name__ == "__main__":     main()   Colored by Color Scripter

cs

• yaml 파일 작성 필요함

• label 파일이 따로 있어야 함  > yolo 학습을 위한 데이터셋 구조가 다름

import os import json import shutil   # 클래스 정의 (labels.txt 기반) class_names = ['big robot', 'small robot']   # JSON에서 YOLO TXT로 변환하는 함수 def convert_json_to_yolo(json_path, output_txt_path, img_width, img_height):     with open(json_path, 'r') as f:         data = json.load(f)       if img_width == 0 or img_height == 0:         print(f"Warning: Image size not found in {json_path}")         return       with open(output_txt_path, 'w') as f:         for shape in data.get('shapes', []):             label = shape.get('label')             if label not in class_names:                 continue  # 정의되지 않은 클래스는 무시             class_id = class_names.index(label)               # bounding box 좌표 (예: [[x1, y1], [x2, y2]])             points = shape.get('points', [])             if len(points) != 2:                 continue               x1, y1 = points[0]             x2, y2 = points[1]               # YOLO 형식으로 변환 (중심 좌표와 너비/높이 정규화)             x_center = (x1 + x2) / 2 / img_width             y_center = (y1 + y2) / 2 / img_height             width = abs(x2 - x1) / img_width             height = abs(y2 - y1) / img_height               # YOLO TXT 형식으로 기록             f.write(f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}\n")   # 디렉토리 처리 및 파일 이동 함수 def process_directory(input_dir, output_img_dir, output_label_dir):     if not os.path.exists(output_img_dir):         os.makedirs(output_img_dir)     if not os.path.exists(output_label_dir):         os.makedirs(output_label_dir)       for file in os.listdir(input_dir):         if file.endswith('.json'):             json_path = os.path.join(input_dir, file)             with open(json_path, 'r') as f:                 data = json.load(f)             img_width = data.get('imageWidth', 0)             img_height = data.get('imageHeight', 0)               # 이미지 파일 이름 추출             img_name = os.path.splitext(file)[0] + '.jpg'             img_path = os.path.join(input_dir, img_name)               # TXT 파일 이름             txt_name = os.path.splitext(file)[0] + '.txt'             txt_path = os.path.join(output_label_dir, txt_name)               # 이미지 파일이 존재하면 이동             if os.path.exists(img_path):                 shutil.move(img_path, os.path.join(output_img_dir, img_name))                 print(f"Moved image: {img_name} to {output_img_dir}")             else:                 print(f"Warning: Image {img_name} not found in {input_dir}")                 continue               # JSON을 TXT로 변환             convert_json_to_yolo(json_path, txt_path, img_width, img_height)             print(f"Converted: {file} to {txt_name}")   # 실행 base_dir = '/home/jetson/work/Pytorch/dataset2' output_base_dir = os.path.join(base_dir, 'dataset') image_base_dir = os.path.join(output_base_dir, 'images') label_base_dir = os.path.join(output_base_dir, 'labels')   for folder in ['train', 'val']:     input_dir = os.path.join(base_dir, folder)     output_img_dir = os.path.join(image_base_dir, folder)     output_label_dir = os.path.join(label_base_dir, folder)       print(f"Processing {folder}...")     process_directory(input_dir, output_img_dir, output_label_dir)   print("Dataset restructuring and conversion completed!") Colored by Color Scripter

cs

• yolo 훈련 수행 시간

• 기존 코드 훈련 수행 시간

# 추가 작성

백본 가중치 고정 후 훈련

freeze로 가중치 고정을 할 수 있음

앞서 사용한 YOLOv8의 구조

백본 층이 0-9층인 걸로 보아 총 10개가 모델의 앞 구조에 있음을 확인

from ultralytics import YOLO import torch import time   def train_yolo(data_yaml, epochs=50, imgsz=640, freeze_layers=10,                 save_path="/home/jetson/work/Pytorch/dataset2/output_yolo/yolo_custom.pt"):     """ YOLO 모델 학습 및 저장 (백본 가중치 고정) """     model = YOLO("yolov8n.pt")  # YOLOv8n 모델 로드          print(model.model)  # 모델 구조 출력          start_time = time.time()  # 학습 시작 시간 기록     model.train(data=data_yaml, epochs=epochs, imgsz=imgsz, freeze=freeze_layers, device="cuda")       end_time = time.time()  # 학습 종료 시간 기록          total_time = end_time - start_time  # 훈련 시간 계산     print(f"Total training time: {total_time:.2f} seconds")  # 훈련 시간 출력          model.save(save_path)  # 학습된 모델 저장     print(f"Model saved at: {save_path}")          return save_path   def main():     device = 'cuda' if torch.cuda.is_available() else 'cpu'     print(f"Using device: {device}")          # YOLO 학습 데이터 설정     data_yaml = "/home/jetson/work/Pytorch/vision/references/detection/data.yaml"          # YOLO 커스텀 학습 진행 (백본 고정)     trained_model = train_yolo(data_yaml, freeze_layers=10)   if __name__ == "__main__":     main()   Colored by Color Scripter

cs

freeze할 층을 10개로 잡아 가중치 고정시켜서 학습

훈련 시작 시 아래 사진과 같이 Freezing layer 문구가 뜨면 됨

결과

[Sungryul Lee]

Yolo훈련시 백본의 가중치는 고정하고 나머지만 훈련한건요?
로스,정확도 그래프 추가할것, Yolo에서 저장해준는 것도 첨부할것
훈련검증에 사용하지 않은 테스트 영상 10장 이상으로 테스트 결과 추가할 것