CVAD

3. CARLA 0.9.12 버전으로 재설치

_DK_Kim — Mon, 27 May 2024 15:54:18 +0900

이전 포스팅 : 2023.08.12 - [CARLA] - 1. Ubuntu 20.04 CARLA install

집 컴퓨터로 CARLA를 돌리는데 너무 렉도 심하게 걸리고, 무엇보다 headless로 돌리는 방법이 굉장히 복잡한 것 같아서

0.9.12버전으로 다시 설치했다. 이전 포스팅도 리마인드할 겸 다시 절차를 기록해보자.

먼저, Software requirements에 있는 항목들을 설치해준다. 아래의 명령어를 수행해주자.

sudo apt-get update &&
sudo apt-get install wget software-properties-common &&
sudo add-apt-repository ppa:ubuntu-toolchain-r/test &&
wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add

그리고, 자신의 운영체제 버전에 맞는 명령어를 수행해준다.나는 20.04 이므로 아래와 같다.

sudo apt-add-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main"
sudo apt-get update
sudo apt-get install build-essential clang-10 lld-10 g++-7 cmake ninja-build libvulkan1 python python-dev python3-dev python3-pip libpng-dev libtiff5-dev libjpeg-dev tzdata sed curl unzip autoconf libtool rsync libxml2-dev git
sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/lib/llvm-10/bin/clang++ 180 &&
sudo update-alternatives --install /usr/bin/clang clang /usr/lib/llvm-10/bin/clang 180

다음은 python dependency를 설정해준다.

pip install --user setuptools &&
pip3 install --user -Iv setuptools==47.3.1 &&
pip install --user distro &&
pip3 install --user distro &&
pip install --user wheel &&
pip3 install --user wheel auditwheel

다음으로는 Unreal Engine 4.26을 다운받아준다. 아래의 명령어를 입력해주고, Github ID랑 token값을 입력해주자.

UnrealEngine과 Github 계정을 연결하는 방법은 이전 포스팅의 notion 페이지를 참고하면 된다.

git clone --depth 1 -b carla https://github.com/CarlaUnreal/UnrealEngine.git ~/UnrealEngine_4.26

설치가 완료되면 build해준다. 아래의 명령어를 입력하자

cd ~/UnrealEngine_4.26
./Setup.sh && ./GenerateProjectFiles.sh && make

Build가 완료되면 UnrealEngine을 실행하여 제대로 돌아가는지 확인해준다.

cd ~/UnrealEngine_4.26/Engine/Binaries/Linux && ./UE4Editor

위의 사진과 같이 UnrealEngine이 실행된다.

마지막으로, .bashrc에 UnrealEngine을 환경변수로 저장해주자.

gedit ~/.bashrc

# .bashrc 하단에 아래를 넣은 뒤 저장
export UE4_ROOT=~/UnrealEngine_4.26

source ~/.bashrc

다음은 CARLA 0.9.12버전을 다운받아야한다.

https://github.com/carla-simulator/carla/releases

Releases · carla-simulator/carla

Open-source simulator for autonomous driving research. - carla-simulator/carla

github.com

여기서 CARLA_0.9.12.tar.gz 파일을 다운받아주면 된다.

압축을 해제해주고 설치 경로에서 아래의 명령어를 실행했을 때, carla가 실행되면 된다.

./CarlaUE4.sh

만약 python 스크립트로 carla를 사용한다면, 가상환경 하나를 따로 만들어주고 사용해주면 된다.

0.9.12 버전 기준으로 python은 3.8로 설정해주고 해당 환경에 아래 명령어를 써주자.

pip install carla==0.9.12

Isaac sim 설치 및 라이브러리 자동완성 적용하기

_DK_Kim — Mon, 27 May 2024 13:06:03 +0900

Isaac sim은 NVIDIA에서 개발한 시뮬레이션 플랫폼으로, 고품질 렌더링과 다양한 물리 시뮬레이션을 제공한다.

나도 연구실에서 로봇을 시뮬레이션하기위해 사용한게 처음이었고, 그 당시 잘 정리된 내용이나 국내 자료가 없다보니까 사용에 많은 문제를 겪었다. (이건 지금도 마찬가지다)

이번 포스팅을 시작으로 Issac sim의 사용법과 코드를 일부 다뤄보려고 한다.

1. Isaac sim 설치

Isaac sim을 설치하기 위해 "Omniverse launcher" 라는 것을 다운받아야한다. 아래의 링크로 들어가준다.

https://www.nvidia.com/en-us/omniverse/

NVIDIA Omniverse

Design, Develop, Deploy Next Era of 3D Applications and Services.

www.nvidia.com

그러면 연결된 홈페이지에서 Download SDK Now를 클릭하고 양식을 제출해주면 된다.

이제 자신의 운영체제에 맞는 것을 클릭해주면 자동으로 다운받아진다.

나는 Linux 운영체제이므로 다운받으면 AppImage 파일이 설치된다.

파일이 설치된 경로로 가서 권한을 수정해주자.

sudo chmod +x omniverse-launcher-linux.AppImage

그리고 다시 AppImage 파일을 더블클릭해주면 아래와 같은 창을 볼 수 있다. 계정이 있다면, 로그인해주고 없다면 회원가입을 진행해주자.

로그인까지 완료되면 omniverse launcher를 사용할 수 있다. EXCHANGE를 눌러주면 Isacc sim을 비롯한 다양한 app과 extension 프로그램들을 볼 수 있다.

여기서 isaac sim을 검색해주면 된다. App 카테고리에서 확인할 수 있을 것이다.

기본적으로 가장 최신버전으로 옵션이 올라가 있지만, 저기 2023.1.1을 누르면 이전 버전의 isacc sim도 다운받을 수 있다.

다운이 완료되면 LIBRARY에서 Isacc sim을 확인할 수 있다.

이렇게되면 설치가 모두 끝난다.

2. Issac sim 라이브러리 자동완성 적용하기

나는 VScode로 isaac sim을 주로 사용하는데 관련 라이브러리가 자동완성이 되지 않거나, 어떤 입력값을 받는지 설명이 뜨지 않아서 불편했던 기억이 있다.

예를 들면, omni.isaac.core.robot 이라고 칠때 자동완성이 하나도 되지 않아서 손수 다 쳐줘야하는 불편함이 있었다.

그러던 중 이걸 해결할 수 있는 방법을 찾았다.

먼저, isacc sim이 설치된 위치에서 ctrl+F 를해서 .vscode 파일을 찾아주자. 만일 안보인다면, 숨김 파일 보기(ctrl+h)를 활성화 시켜주고 다시 검색해보자.

isaac sim의 설치 위치는 Simulation App을 시작할 때도 확인할 수 있지만, 기본적으로 아래와 같다.

이제 .vscode 파일로 들어가면 총 3개의 파일이 보일 것이다.

여기서 settings.json파일을 열어준다.

그러면 python.analysis.extraPaths 항목이 보일 것이고, 여기 있는 상대 경로들을 복사해서 전부 절대 경로로 수정하여

VScode의 settings.json에 옮겨주면 된다.

VScode의 settings.json을 여는 방법은 간단하다. VScode를 켜고 ctrl + , 를 입력해준다. 그러면 아래와 같이 뜬다.

여기서 스크롤을 내리다보면, 아래와 같은 항목이 보일 것이다. 여기서 Edit in settings.json을 눌러주면 된다.

한 가지 팁을 주자면, 위의 사진에서처럼 한번에 바꿀 수 있는 경로들이 존재하는데 VScode 기준으로 바꿀 부분을 드래그 해준뒤 ctrl+L을 눌러주면 해당 부분이 들어간 것이 모두 선택된다. 이때 바꾸면 전부 바뀌게된다.

여기서 주의할 점이 있는데, 밑에 경로를 보다보면 kit/exts/omni.~ 이런식으로 된 부분도 같이 바뀐다는 것이다. 따라서 kit 경로는 따로 옮겨뒀다가 따로 바꿔주고 나중에 합쳐주는게 좋다.

모든 과정이 마무리되면 라이브러리가 잘 불러와지는 것을 확인할 수 있다.

[24.05.19] Isacc Sim project 시작 및 근황

_DK_Kim — Sun, 19 May 2024 22:15:59 +0900

요즘 다시 Isaac sim을 쓰기 시작했다. 얼마 전에 연구실 사람과 연락이 닿아서 프로젝트를 진행하게 되었는데,

그 때부터 Issac sim project를 시작하게 되었다.

너무 오랜만에 시작하려고하니, python 스크립트 작성법이나 명령어, simulation app에서 기능등 까먹은게

많아서 document 보면서 공부하고 있다.

지금은 가장 급한 문제인 robot importing를 해결하고 있댜. 일부 로봇을 불러오는데, 스크립트

자체가 실행되지 않거나 로봇이 보이지 않는 경우 등의 문제가 발생해서 스크립트를 고쳐보고있다.

다행히 현재는 어느정도 문제가 해결되었고, 코드 정리 및 controller 적용해서 테스트해보면 될 것 같다.

아래는 현재 importing하려고 하는 robot들의 모습이다.

QCar 원본이 너무 작긴하지만, 이건 scale값을 조정하면 되니 빨리 controller를 만들어봐야겠다.

다만, QCar가 ackermann system이라 커스텀으로 controller 정의해줘야할 것 같은데 이게 문제다.

일단...그렇다!

[24.05.03] 환경 세팅-그래픽 드라이버/CUDA&cuDNN

_DK_Kim — Fri, 3 May 2024 16:55:59 +0900

컴퓨터 세팅 기록 2번째 글이다. 사실 필요한 작업은 5월전에 끝냈지만, 글은 지금 쓰고있다.

앞으로는 미리미리 좀 써놔야겠다.

1. 그래픽 드라이브 설치

터미널에 아래의 명령어를 입력하면, 현재 설치 가능한 그래픽 드라이버가 나온다.

ubuntu-drivers devices

현재 설치 가능한 드라이버

보통은 recommended 표시된 것을 설치하면된다. 나의 경우 사진처럼 nvidia-driver-535를 설치했다.

설치는 아래의 명령어를 입력하면 된다.

sudo apt install nvidia-driver-535

이 과정이 귀찮다면 처음부터 권장 드라이버를 자동으로 설치하는 방법도 있다. 아래의 명령어를 사용하면 된다.

sudo ubuntu-drivers autoinstall

설치가 완료되면 재부팅해준다.

2. CUDA 설치

사실 CUDA 설치하려면 호환성 표?도 보고 그래픽 카드랑 드라이버 버전도 보고 그랬던 것 같은데

기억도 가물가물하고 어디서 듣기로 그냥 nvidia-smi 에 나와있는 CUDA 버전따라 설치하면

된다고 들어서 그냥 나도 그렇게 했다.

내 생각에 CUDA를 여러 버전을 사용하는 경우에는 전자의 방식을 통해 호환성을 봐야하는 것 같다.

호환표는 아래의 홈페이지에서 알 수 있다.

https://docs.nvidia.com/deploy/cuda-compatibility/index.html#binary-compatibility__table-toolkit-driver

CUDA Compatibility :: NVIDIA GPU Management and Deployment Documentation

The NVIDIA® CUDA® Toolkit enables developers to build NVIDIA GPU accelerated compute applications for desktop computers, enterprise, and data centers to hyperscalers. It consists of the CUDA compiler toolchain including the CUDA runtime (cudart) and vari

docs.nvidia.com

아무튼 터미널에 nvidia-smi를 쳐주면 아래와 같이 나온다.

그러면 저렇게 CUDA version으로 호환되는 CUDA 버전이 나온다.

이제 CUDA 설치를 위해 아래 홈페이지로 이동해보자.

https://developer.nvidia.com/cuda-toolkit-archive

CUDA Toolkit Archive

Previous releases of the CUDA Toolkit, GPU Computing SDK, documentation and developer drivers can be found using the links below. Please select the release you want from the list below, and be sure to check www.nvidia.com/drivers for more recent production

developer.nvidia.com

나는 여기서 제일하단의 12.2.0 버전으로 진행했다.

위와 같이 자신의 환경에 맞게 잘 골라주고 runfile을 클릭하면 설치를 위한 명령어가 나온다.

저대로 진행해주면 한 터미널 창이 뜨는데, Continue $\rightarrow$ 'Driver' 꼭 체크 해제해주고 CUDA Toolkit만 다운 받아주자.

설치가 진행되면 이렇게 뜬다. Warning이 거슬리긴해도 정상적으로 받아진 것이니 그냥 무시하면 된다.

설치가 끝나면 환경변수에 CUDA를 추가해준다. 이걸 해줘야 nvcc -V가 제대로 동작한다.

gedit으로 .bashrc 창을 열어주자

gedit ~/.bashrc

그리고 하단에 아래의 코드를 추가해주자

export PATH=$PATH:/usr/local/cuda/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64
export CUDADIR=/usr/local/cuda

변경사항을 저장하고 .bashrc를 source 해주자.

source ~/.bashrc

잘 설치된 경우 터미널에 nvcc -v를 입력해주면 아래와 같이 나온다.

3. cuDNN 설치

설치에 앞서서 먼저, nvidia 계정을 만들어야한다. 로그인 후 아래의 사이트로 이동해준다.

https://developer.nvidia.com/cudnn

CUDA Deep Neural Network

cuDNN provides researchers and developers with high-performance GPU acceleration.

developer.nvidia.com

여기서 Download cuDNN Library를 눌러주면 최신 버전의 cuDNN 설치로 자동으로 연결되는 것 같다.

세팅 당시에는 9.0.0 다운로드되었는데 지금 포스팅(24.05.03)기준으로는 9.1.1로 연결된다.

CUDA 설치와 마찬가지로 자신의 환경에 맞게 옵션을 골라주면 설치 가이드가 밑에 뜬다.

Installation instructions의 명령어들을 진행해주었고, 혹시몰라서 CUDA 12 버전 관련 명령어도 실행해줬다.

설치가 잘 마무리되면 아래의 명령어를 통해 설치 여부를 확인할 수 있다.

cat /usr/include/x86_64-linux-gnu/cudnn_v*.h | grep CUDNN_MAJOR -A 2

이렇게 그래픽드라이버부터 CUDA/cuDNN 설치까지 진행하였다.

사실, 컴퓨터가 먹통된건 Vision Mamba 라는 모델 돌려볼려고 github 참고해서 환경만드는데

cuda 버전 여러 개 써볼려고하다가 망했다.

관련 내용은 좀 알아보고 진행해야할 것 같고, 당분간은 github에 올렸던 프로젝트들 다운받고 좀 수정하면서 지낼 것 같다.

이번 달에 어학도 새로 갱신해야하고, 토이 프로젝트도 간단한거 진행해보고 싶은데 의욕이 너무 없어서 큰일이다.

[Mask 착용] YOLOv8로 마스크 착용 유무 판별하기-1

_DK_Kim — Wed, 1 May 2024 16:16:00 +0900

이번 포스팅은 YOLO-v8로 마스크 착용 유무를 판별하도록 해보겠다.

이번 포스팅에서는 전과 달리 ultralytics라는 라이브러리를 사용해서 모델정의, 학습, 검증 등을

진행할 것이기 때문에 다른 예제 포스팅에 비해 간단하다.

절차는 다음과 같다

데이터셋 준비
모델 학습
검증
결과 분석

1. 데이터셋 준비

마스크 데이터셋은 아래의 깃허브의 링크에서 다운받을 수 있다.

https://github.com/VictorLin000/YOLOv3_mask_detect

GitHub - VictorLin000/YOLOv3_mask_detect: Face mask detection using YOLOv3 on GoogleColab

Face mask detection using YOLOv3 on GoogleColab. Contribute to VictorLin000/YOLOv3_mask_detect development by creating an account on GitHub.

github.com

데이터셋은 이미지와 각 이미지에 대한 txt 형식의 라벨링 데이터로 이루어져 있고, 총 678 쌍이다.

그리고 클래스는 총 3개로 마스크를 잘 쓴 경우(0), 이상하게 쓴 경우(1), 안 쓴 경우(2)로 정의되었다.

데이터가 그렇게 많지 않으므로 학습과 검증 데이터셋의 비율을 9:1 정도로 하는 것이 좋을 것 같다.

이제 학습 및 검증 데이터셋으로 분할해보자. 먼저, 데이터들을 저장할 경로를 생성해준다.

import random
import shutil
import os

raw_file_path = '../../Data/Masks/raw'
file_list = [file for file in os.listdir(raw_file_path) if file.endswith(".txt")]


# Make train/valid folders
train_img_path = '../../Data/Masks/train/images'
train_lbl_path = '../../Data/Masks/train/labels'
valid_img_path = '../../Data/Masks/valid/images'
valid_lbl_path = '../../Data/Masks/valid/labels'

folder_list = [train_img_path, train_lbl_path, valid_img_path, valid_lbl_path]

for folder in folder_list:
    if not os.path.exists(folder):
        os.makedirs(folder)

그 후, 데이터셋 리스트를 랜덤으로 정렬한 후 미리 설정한 비율에 따라 지정된 경로로 복사해준다.

random.shuffle(file_list)

ratio = .1
crit = int(len(file_list)*ratio)
valid_list = file_list[:crit]
train_list = file_list[crit:]

modes = ['train', 'valid']

for mode in modes:
    if mode == 'train':
        data_list = train_list
        img_path = train_img_path
        lbl_path = train_lbl_path
    else:
        data_list = valid_list
        img_path = valid_img_path
        lbl_path = valid_lbl_path

    for data in data_list:
        file_name = os.path.splitext(data)[0]
        # Copy image file
        shutil.copy(os.path.join(raw_file_path, file_name+f'.jpg'), os.path.join(img_path, file_name+f'.jpg'))
        # Copy label file
        shutil.copy(os.path.join(raw_file_path, data), os.path.join(lbl_path, data))

마지막으로 yolo v8 모델을 학습시키기 위한 yaml 파일을 만들어줘야 한다.

yaml 파일은 학습에 필요한 정보를 담고있는데, 딕셔너리 형태로 데이터 경로 및 클래스 수 등을 기록해주면 된다.

아래와 같이 코드를 실행해주자.

import yaml
data = dict()

data['train'] = '학습 데이터 파일 경로'
data['val'] = '검증 데이터 파일 경로'
data['test'] = '검증 데이터 파일 경로'

data['nc'] = 3
data['names'] = ['Yes', 'Improperly', 'No']

with open('mask_detection.yaml', 'w') as f:
    yaml.dump(data, f)

train과 val, test의 value에는 적힌 것처럼 해당하는 데이터 파일의 경로를 적어주면 된다.

나는 각 class를 마스크를 잘 쓴 경우(Yes), 이상하게 쓴 경우(Improperly) 그리고 안 쓴경우(No)로 정의해줬다.

이러면 데이터셋과 관련된 준비는 모두 끝났다.

사실, 데이터 증강 기법같은 것도 적용해보고 싶었는데 저 라이브러리를 써본 적이 없어서 못했다.

나중에 이 라이브러리에 익숙해지면 사용법을 따로 포스팅해봐야겠다.

2. 모델 학습

학습 코드는 엄청 간단하다. 뭐 따로 정의해줄 필요도 없이 ultralytics가 다 해준다.

먼저 필요한 라이브러리를 불러오고 모델을 정의해준다.

import os
import cv2
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

from ultralytics.utils.plotting import Annotator
from ultralytics import YOLO

model = YOLO('yolov8n.yaml')

다음은 모델 학습 코드다. 아래의 코드만 실행해주면 된다.

results = model.train(data='mask_detection.yaml', epochs=200, batch=32, device=0,
                      patience=30, name='mask_detection')

학습에는 대략 7~8분정도 시간이 소요됐다. 학습 정보와 best 모델은 위 코드를 실행한 경로에 runs라는 파일에 있다.

학습이 잘 마무리되면 검증을 수행해보자.

# Validation
model = YOLO('runs/detect/mask_detection3/weights/best.pt')

# validation
metrics = model.val()

왠지는 모르겠지만, 전체 클래스에 대한 mAP를 보면 mAP50이 0.76으로 그렇게 높지 않은 것을 확인할 수 있다.

이제, 모델의 출력을 시각화해보자.

검증 데이터셋에서 이미지 한 개를 불러와서 결과를 살펴보자.

valid_img_path = '../../Data/Masks/valid/images'
test_img_list = os.listdir(valid_img_path)
color_dict = [(0, 255, 0), (255, 0, 0), (0, 0, 255)]

# Load sample images
test_img = cv2.imread(os.path.join(valid_img_path, test_img_list[0]))
img_src = cv2.cvtColor(test_img, cv2.COLOR_BGR2RGB)
result = model(test_img)

# Visualization
for res in result:
    annotator = Annotator(img_src)
    boxes = res.boxes
    for box in boxes:
        b = box.xyxy[0]
        cls = box.cls
        annotator.box_label(b, model.names[int(cls)], color_dict[int(cls)])
img_src = annotator.result()
plt.imshow(img_src)

위와 같이 대체로 잘 동작하지만, 몇몇 경우 손을 얼굴로 인식하는 등 잘 동작하지 않는 경우도 존재했다.

이번 포스팅에서는 YOLO v8을 사용하여 마스크 착용여부를 탐지하는 모델을 구성했다.

Object detection을 기반으로 동작하는 테스크였고, 기존의 포스팅들과 달리 라이브러리를 사용하여 편하게

수행할 수 있었다.

다음 포스팅은 이전에 cam으로 실시간 object detection을 수행했던 것을 바탕으로 실시간

마스크 검출을 수행하는 포스팅을 해보고자 한다.

포스팅에 대한 질문이나 잘못된 사항 댓글 달아주시면 감사하겠습니다 ! :)

[24.04.29] 환경 다시 셋팅-우분투 20.04 설정

_DK_Kim — Mon, 29 Apr 2024 17:43:22 +0900

요새하도 많은 일이 있어서 정신이 없었다. 그러다보니 공부나 블로그 포스팅을 전혀 하지 못했다.

티스토리도 나름 포토폴리오를 목적으로 사용해보려고 시작했는데, 이게 리뷰나 코드 가이드 같은 글을 작성하는데 시간이 너무 소요되는 것 같았다.

그래서 든 생각이 일단 일상 기록용으로 티스토리를 적고, 혹시나 더 기록하고 싶은 내용이 있다면 따로 적어야할 것 같다. 그래서 오늘부터는 일상 기록을 위해 일기장(?)처럼 쓸것 같다.

최근에 그래픽드라이버를 잘못 건드렸다가 컴퓨터가 먹통이 되서 다시 싹다 지우고, 셋팅을 하고있다...

연구실에 있었을 때도 꽤 많이 해봤는데 오랜만에 다시 하려니 순서나 방법이 헷갈렸다.

그래서 내가 다시 보려고 순서를 기록해 놓으려고 한다.

VGA : Nvidia GTX 4060 Ti
램 : 32 GB

셋팅은 듀얼부팅으로 HDD에 우분투 20.04 LTS 버전을 사용하였다. 이 두 가지는 워낙 인터넷에 잘

설명된 글이 많아서 생략.

1. Ubuntu 한글 설정

sudo apt update
sudo apt upgrade ibus-hangul
reboot

터미널에서 위 코드를 차례로 실행 후 Setting $\rightarrow$ Input source $\rightarrow$ '+' 버튼에서 Hangul 추가.

그 후, 다른 키보드는 삭제하고 한글 옆의 톱니바퀴 눌러서 한/영전환키를 추가 .

여기까지하면 정상적으로 한/영 변환이 되는걸 확인할 수 있다.

(참고 : https://freeablelab.tistory.com/138 )

2. 화면 해상도 변경

나의 경우 처음 ubuntu를 시작했을 때 해상도가 1024$\times$768로 고정되어 있었다.

실제 모니터는 1920$\times$1080 해상도를 지원해서 불편했는데 Setting에서도 크기 변경이 불가능했다.

이 문제는 아래의 방법을 통해서 해결할 수 있었다.

먼저 gedit을 통해 아래 경로에 있는 파일을 열어준다. vim이나 nano 같은 다른 editor를 써도 된다.

나는 gedit이 편해서 이걸로 했다.

sudo gedit /etc/default/grub

그러면 텍스트창이 하나 열린텐데 여기서 아래 사진에 해당하는 부분을 찾아준다.

원래는 #으로 주석처리가 되어있고 640$\times$480으로 적혀있을텐데 우리는 이걸 바꿔줘야 한다.

해당 부분을 사진처럼 'GRUB_GFXMODE=1920x1080' 으로 변경.

그 후, 텍스트를 저장 후 닫은 후 터미널을 통해 grub 파일을 업데이트 해줌. 아래의 코드를 사용.

sudo update-grub

마지막으로 컴퓨터를 재부팅해줌.

sudo reboot

그러면 입력된 해상도로 변한 것을 확인할 수 있다.

(참고 : https://askubuntu.com/questions/441040/failed-to-get-size-of-gamma-for-output-default-when-trying-to-add-new-screen-res )

3. 우분투 미러 서버 변경

이번에는 우분투의 apt 서버를 변경해줘야한다. 기본 설정된 서버는 굉장히 느려서 update 및 패키지를

다운받는데 불편해서 그렇다고 한다.

서버 변경을 위해서 아래의 절차를 진행해주자.

sudo gedit /etc/apt/sources.list

이러면 텍스트 창이 하나 뜬다.

여기서 ' /kr.archive.ubutu.com ' 이 부분을 모두 ' /mirror.kakao.com ' 으로 바꿔주면 된다.

나는 멍청하게 이 부분을 수작업으로 바꿔줬는데 나중에 찾아보니 vim을 통해 손쉽게 바꿀 수 있었다...

아래의 참고 링크에서 이 방법이 있으므로 아래 포스팅을 보는게 더 나을 것 같다.

마지막으로 변경 사항을 업데이트 해주자.

sudo apt-get update

( vim 통해서 바꾸기 : https://lonaru-burnout.tistory.com/5 )

4. 윈도우와 우분투 시간 동기화 시켜주기

보통 인터넷에서 동기화 방법을 찾아보면 크게 2가지 방법으로 소개된 글들을 볼 수 있다.

1. Windows에서 UTC 시간을 저장하게 하기

2. Ubuntu 에서 로컬 타임을 저장하게 하기

근데 보통 대부분 2번째 방법을 많이 사용해서 나도 2번째 방법으로 동기화를 진행해줬다.

터미널을 열고 아래의 코드를 입력해주자.

timedatectl set-local-rtc 1 --adjust-system-clock

이러면 사실상 적용은 끝났다. 코드가 잘 입력되었는지 확인하려면 아래의 코드를 입력했을 때

RTC in local TZ : yes 로 나온다.

timedatectl

이러고 재부팅해주면 적용된다.

나의 경우 바로 적용되진 않았고, 우분투와 윈도우에서 각각 1번씩 재부팅 해줬더니 그때부터 잘 적용되었다.

(참고 : https://mesnotes.tistory.com/11 )

# 추가 프로그램 설치

화면 캡쳐 프로그램 Flameshot 설치

sudo apt-get install falmeshot 으로 설치

configuration 'Launch at startup' 설정

Setting의 Key board shortcut에 가서 기존에 print 검색. 그 후 기존에 등록된 단축키 삭제

Key board shortcut의 최하단에 '+' 버튼 누른 후 아래처럼 flameshot 을 단축키로 등록

++) window, ubuntu 부팅 순서 변경

https://webnautes.tistory.com/2117

정말 오랜만에 셋팅도 진행해보고 블로그 포스팅도 하다보니 별로 한 것도 없는데 오늘 하루가 삭제됐다.

연구실에서부터 꽤 많이 포맷해봐서 그때는 기계적으로 셋팅했었는게, 이게 또 3-4 개월 지나니까 다 까먹었다.

포맷할 일이 없는게 제일 좋지만, 그래도 이제 새로 셋팅을 진행할 일이 생기면 내 셋팅 루틴이 정리되어있어서

편하게 할 수 있을 것 같다.

아직 cuda랑 그래픽드라이버부터해서 ros, carla, isaac sim 등등 설치해야할 것이 한 가득 이지만 오늘은

여기쯤에서 마무리해야할 것 같다.

다음 글은 아마 저것들 설치하는 과정을 기록할 것 같다.

아직 6월도 아닌데 벌써부터 너무 덥다.

올해 여름은 좀 덜 덥고 비나 좀 내리면 좋을 것 같다.

전이학습(Transfer learning)이란? - 2

_DK_Kim — Sun, 24 Mar 2024 18:18:13 +0900

이전 포스팅 내용이 궁금하시다면 아래의 링크를 참고하시면 감사하겠습니다!
- 전이학습(Transfer learning)이란? - 1

저번 포스팅에서는 전이 학습의 개념과 원리, 적용 방법론에 대해서 알아보았다. 이번에는 실제 모델을 사용해서 전이 학습을 적용해 보자.

두 가지 방법론 중 이번에 구현할 것은 feature extractor로 사용하는 방법이다. 사전 학습된 VGG16 모델을 사용해서 간단한 classifcation task를 해결하도록 classifier 부분만 새로 교체하여 학습할 것이다.

이번 포스팅의 절차는 아래와 같다.

데이터셋 준비
Classifier 제거 후 학습
결과 확인

1. 데이터셋 준비

데이터셋은 'Dogs vs Cats'을 사용할 것이다. 이 데이터셋은 아래의 Kaggle 링크를 통해 다운로드할 수 있다.

https://www.kaggle.com/competitions/dogs-vs-cats/data

Dogs vs. Cats | Kaggle

www.kaggle.com

여기서 train 데이터를 다운로드하여서 확인해 보면, 25000장의 개와 고양이 사진을 확인할 수 있다.

그리고 파일명에 개 사진인지 고양이 사진인지 표시되어 있다.

이제 각 class 이미지 수를 알아보자.

import os

data_path = '../../Data/DogsandCats/train'
img_list = os.listdir(data_path)

cat = 0
dog = 0

for img in img_list:
    if img[:3] == 'cat':
        cat +=1
    elif img[:3] == 'dog':
        dog +=1

print(f'cat : {cat} || dog : {dog}')
========================================================================================
cat : 12500 || dog : 12500

위의 코드를 실행하면 결과를 알 수 있다. 개와 고양이가 딱 절반이다.

나는 train 파일의 이미지들을 두 클래스 균일하도록 나누어서 검증 데이터셋으로 분할하였다.

전체 데이터의 80%만 학습으로 사용하고, 나머지는 검증용으로 valid 폴더를 생성해서 저장해 보자.

import shutil

dogs_list = [imgs for imgs in img_list if imgs[:3] == 'dog']
cats_list = [imgs for imgs in img_list if imgs[:3] == 'cat']

valid_path = '../../Data/DogsandCats/valid'

if not os.path.exists(valid_path):
    os.makedirs(valid_path)

num_imgs = int(len(dogs_list)*0.2)
for i in range(num_imgs):
    shutil.move(os.path.join(data_path, dogs_list[i]), os.path.join(valid_path, dogs_list[i]))
    shutil.move(os.path.join(data_path, cats_list[i]), os.path.join(valid_path, cats_list[i]))

그러면 개와 고양이 사진이 각각 2500장씩, 총 5000장의 검증 데이터셋을 만들 수 있다. 이제, 데이터셋 파일을 정의해 보자.

import os
from torch.utils.data import Dataset
from torchvision.io import read_image

data_path = '../../Data/DogsandCats'

class DogsandCats(Dataset):
    def __init__(self, mode, transform=None):
        '''
        mode = 'train' or 'valid' | call train dataset or validation dataset
        transform : None(default)
        '''

        self.mode = mode
        if self.mode == 'train':
            self.img_path = data_path + '/train'
        else:
            self.img_path = data_path + '/valid'
        
        self.img_list = os.listdir(self.img_path)
        self.transform = transform

    def __len__(self):
        return len(self.img_list)
    
    def __getitem__(self, idx):
        name = self.img_list[idx][:3]
        if name == 'dog':
            lbl = 0
        elif name == 'cat':
            lbl = 1
        img = read_image(os.path.join(self.img_path, self.img_list[idx]))/255.0

        if self.transform:
            img = self.transform(img)

        return img, lbl

개 사진일 경우 label값을 0으로 주었고, 반대의 경우는 1을 주었다. 그 외의 dataset 구성 코드는 다른 예제 포스팅에서 다뤘던 형식을 사용하였다.

2. Classifier를 제거 후 학습

먼저 우리가 확인해 볼 것은 classifier 부분을 제거한 후 사전학습된 VGG16 모델의 출력층만 바꿔서 볼 것이다.

모델 구현 코드를 작성해 보자.

import torch
import torchvision.models as models
import torch.nn as nn
from torchinfo import summary

class VGG16_new_classifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1)

        for param in self.model.parameters():
            param.requires_grad = False
        
        self.classifier = nn.Sequential(
            nn.Linear(25088, 4096), 
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, 2)  
        )

        # Replace the classifier in the pre-trained model with the new one
        self.model.classifier = self.classifier

    def forward(self, x):
        x = self.model(x)
        return x

model = VGG16_new_classifier().to(config.device)
# summary(model, (1,3,224,224))

위의 코드를 잠시 살펴보면, torchvision에서 제공하는 vgg16 모델을 불러온 뒤 classifier를 제외한 나머지 layer의 가중치를 고정시켜 준다.

그리고, 원래 classifier를 학습되지 않은 새로운 classifier로 바꿔주면 된다.

이제 학습에 필요한 코드들을 작성해 보자

import torch.optim as optim
import torch.nn as nn
import matplotlib.pyplot as plt
import torch
import os

from torch.utils.data import DataLoader
from Dataset import DogsandCats
from torchvision.transforms import v2 as T
from tqdm.auto import tqdm


def my_transforms():
    transforms = T.Compose([
        T.Resize([224, 224], interpolation=T.InterpolationMode.NEAREST_EXACT),
        T.Normalize(mean=[.4885, .4553, .4172], std=[.2293, .2249, .2252]),
        T.ToDtype(torch.float, scale=True),
        T.ToPureTensor(),
    ]
    )
    return transforms

ds_train = DogsandCats(mode='train', transform=my_transforms())
ds_valid = DogsandCats(mode='valid', transform=my_transforms())

dl_train = DataLoader(ds_train, batch_size=64, shuffle=True, num_workers=4)
dl_valid = DataLoader(ds_valid, batch_size=32, shuffle=False)

class config():
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    model_name = 'VGG16_new_classifier'
    max_epoch = 5

전처리는 위와 같이 이미지 크기를 $224\times224$로 맞춰주고 정규화만 적용해 주었다. 데이터 증강의 경우 별도로 진행하지 않았는데, 예측 클래스 수가 적고, 학습 데이터셋의 크기가 충분히 크기 때문이다.

이미 대부분의 layer가 학습되어 있으니, 5 epoch만 학습을 해보자. 아마 충분히 학습될 것이다.

오차 함수로는 Corssentrpy를 사용해 주고, 최적화기법은 Adam을 사용하였다.

loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3, weight_decay=.1)

log_path = f'Model/{config.model_name}/log'
best_model_path = log_path + '/best_model'

# Check log & best model path
if os.path.exists(best_model_path):
    pass
else:
    os.makedirs(best_model_path)


class engine():
    def model_train(model, data, optimizer, loss_fn):
        imgs, lbls = data['image'], data['label']
        imgs, lbls = imgs.to(config.device), lbls.to(config.device)

        model.train()

        preds = model(imgs)
        loss = loss_fn(preds, lbls)

        optimizer.zero_grad()

        loss.backward()
        optimizer.step()

        return loss.item()
    
    @ torch.no_grad()
    def model_valid(mdoel, data, loss_fn):
        imgs, lbls = data['image'], data['label']
        imgs, lbls = imgs.to(config.device), lbls.to(config.device)

        model.eval()

        preds = model(imgs)
        loss = loss_fn(preds, lbls)

        return loss.item()


def run():
    best_val_loss = 1e9
    
    for epoch in range(config.max_epoch):

        for _, data in tqdm(enumerate(dl_train), total=len(dl_train)):
            train_loss = engine.model_train(model, data, optimizer, loss_fn)

        for _, data in tqdm(enumerate(dl_valid), total=len(dl_valid)):
            valid_loss = engine.model_valid(model, data, loss_fn)


        torch.save(model.state_dict(), os.path.join(log_path, f'epoch_{epoch}.pth'))

        if valid_loss < best_val_loss:
            torch.save(model.state_dict(), os.path.join(best_model_path, 'best_model.pth'))

        print(f'[Epoch : {epoch}/{config.max_epoch}] Train loss : {train_loss} || Validation loss : {valid_loss}')
        print()
run()

3. 결과 확인

아래는 5 epoch 학습의 결과다.

100%|██████████| 313/313 [01:11<00:00,  4.35it/s]
100%|██████████| 157/157 [01:21<00:00,  1.92it/s]
[Epoch : 0/5] Train loss : 0.14762777090072632 || Validation loss : 0.0013951573055237532

100%|██████████| 313/313 [01:10<00:00,  4.42it/s]
100%|██████████| 157/157 [00:17<00:00,  8.89it/s]
[Epoch : 1/5] Train loss : 0.015938522294163704 || Validation loss : 0.0007364111370407045

100%|██████████| 313/313 [01:10<00:00,  4.42it/s]
100%|██████████| 157/157 [00:17<00:00,  8.81it/s]
[Epoch : 2/5] Train loss : 0.05040908232331276 || Validation loss : 0.002780304057523608

100%|██████████| 313/313 [01:10<00:00,  4.42it/s]
100%|██████████| 157/157 [00:17<00:00,  8.87it/s]
[Epoch : 3/5] Train loss : 0.06553690880537033 || Validation loss : 0.0857008844614029

100%|██████████| 313/313 [01:10<00:00,  4.42it/s]
100%|██████████| 157/157 [00:17<00:00,  8.89it/s]
[Epoch : 4/5] Train loss : 0.2567245662212372 || Validation loss : 0.013202370144426823

이미 대부분 학습되어 있는 모델이라 그런지, 2번째 epoch에 best에 도달하고 그 이후에는 아마 over fitting이 난 것 같다.

가장 validation loss가 낮은 모델로 학습 결과를 살펴보자.

from torchvision.io import read_image

test_img_1 = '../../Data/DogsandCats/valid/cat.0.jpg'
test_img_2 = '../../Data/DogsandCats/valid/dog.7.jpg'

img1 = read_image(test_img_1)
img2 = read_image(test_img_2)
imgs = [img1, img2]

get_transforms = my_transforms()
model = VGG16_new_classifier().to(config.device)
best_state = torch.load(os.path.join(best_model_path, 'best_model.pth'))
model.load_state_dict(best_state)

for img in imgs:
    img = get_transforms(img/255.0).unsqueeze(dim=0)
    with torch.no_grad():
        model.eval()
        img = img.to(config.device)
        pred = model(img)

        real_label = torch.argmax(pred).item()

    if real_label == 1:
        print('Cat')
    elif real_label == 0:
        print('Dog')
========================================================================================
Cat
Dog

처음 예상처럼 예측이 잘 이루어지는 것을 확인할 수 있다.

이번 포스팅에서 우리는 전이 학습의 2가지 방법론 중 feature extractor로 사용하는 예제를 다루었다. 위의 예제처럼 유사한 task에 대해 진행할 수도 있지만, 완전히 다른 task에서 활용할 수 있다. Backbone으로 사용하는 것이 이러한 경우에 속한다.

만약에 Backbone으로 사용하는 경우에 대해 더 알고 싶다면, VOC PASCAL segmentation 예제의 두 모델코드를 참고하면 좋을 것 같다. 다음 포스팅에서는 나머지 한 개의 방법론 예제를 다루겠다.

포스팅에 대한 질문이나 잘못된 사항 댓글 달아주시면 감사하겠습니다! :)

전이학습(Transfer learning)이란 - 1

_DK_Kim — Mon, 18 Mar 2024 17:24:20 +0900

어떤 모델을 학습시키는 상황을 생각해 보자. 우리에게 충분한 양질의 데이터, 시간, 하드웨어 그리고 심적인 여유가 있다면 신경망을 처음부터 구성해서 학습시킬 수도 있을 것이다.

하지만, 대부분의 경우 위의 조건들을 모두 만족시키기는 어렵다. 밤새 이미지에 수백만 장의 이미지에 레이블링을 수작업한다고생각해 보자. 수 백만까지가 아니라 백 장 언저리만 해도 현타가 올 것 같다.

그렇다면, 우리의 시간과 노력을 아낄 수 있는 방법은 무엇일까? 바로 전이학습(Transfer learning)을 사용하는 것이다!

이번 포스팅에서 우리는 전이학습에 대한 아래의 내용을 다룰 것이다.

전이학습(Transfer learning)이란?
전이학습의 원리
컴퓨터 비전에서 전이학습의 적용

1. 전이학습(Transfer learning)이란?

전이학습은 어떤 데이터셋에서 '이미 학습된 모델'을 새로운 데이터셋에서 활용하는 것을 의미한다.

대부분의 경우 ImageNet, MS COCO처럼 대규모 데이터셋에서 학습된 모델을 사용해서, 가지고 있는 소규모 데이터셋에

대해 학습하는 방식을 사용한다.

학습에 필요한 데이터 셋이 있다면, 그냥 처음부터 학습하면 되는 거 아닌가?

아마 이런 의문을 가진 사람도 있을 것이다.

결론부터 말하자면, 전이학습을 사용하는 것이 더 효율적이고 좋은 결과를 얻을 수 있기 때문이다.

그 이유는 처음부터 모델을 학습시킬 때 발생하는 문제점에서 찾을 수 있다.

데이터의 부족 :
만일 학습의 필요한 데이터를 준비하는 상황을 가정해보자.
일반화되고 높은 성능을 얻고 싶다면, 많은 이미지와 그에 해당하는 라벨링 데이터가 필요할 것이다.
물론, 준비야할 수 있겠지만 전이학습을 사용한다면 이러한 시간 및 노력을 효율적으로 줄일 수 있다.

이미 충분히 많은 데이터를 통해 학습이 수행된 모델을 사용하기 때문에, 적은 데이터만 사용해도
일반화되고 좋은 성능의 모델을 얻을 가능성이 높기 때문이다.
학습 시간 및 노력:
만약, 학습에 필요한 대규모 데이터를 준비하는 데 성공했다고 치자. 그럼에도, 이 데이터를 모델에 충분히
학습시키려면 많은 시간과 노력이 필요할 것이다.

내 경험을 비춰보자면, MobileViT 모델으로 ImageNet-1K을 학습시켰을 때, 8개의 GPU가 달린 서버를
사용했음에도 3일이 넘게 걸렸던 기억이 있다. GPU Memory 문제도 있어서 작은 batch size를 선택한
영향도 있지만, 그러한 요소를 차치해두더라도 개인 컴퓨터의 단일 gpu로 학습한다 하면 더 오래걸릴 것이다.
만일, 학습 하이퍼 파라미터를 바꿔가며 더 학습한다면? 필요한 시간과 노력은 배가될 것이다.

전이학습은 다른 사람이 이미 이런 데이터셋에 다른 사람이 시간과 노력을 쏟아부어서 잘 학습시킨 모델을
우리가 사용하는 것이므로 우리의 시간과 노력을 많은 부분 절약해 준다.

즉, 전이학습은 많은 시간과 비용을 절약시켜 주고 모델의 성능을 더 높여준다고 말할 수 있다!

때문에, 대부분의 경우 충분한 데이터셋이 있더라도 전이학습을 사용하는 경우가 많다.

2. 전이학습의 원리

앞서, 전이학습의 효과를 알아보았다. 그러면 전이학습은 어떤 원리로 이런 효과를 보이는 것일까?

이를 이해하기 위해, 모델이 입력된 이미지를 어떻게 처리하는지 살펴보자.

아래의 사진은 분류 문제를 수행하는 모델의 동작 과정을 나타낸다.

https://medium.com/@chriskevin_80184/feature-maps-ee8e11a71f9e

위 사진에서 볼 수 있듯이, 모델은 입력된 이미지를 layer 통과시킨 후, 유효한 feature를 추출한다.

또, 추출된 feature를 다음 layer로 전달하여 다시 유효한 feature를 추출한다.

이런 과정을 반복하여 최종 추출된 feature를 통해 분류를 진행한다.

우리는 feature를 추출하기 위해 어떠한 weight로 구성된 kernel을 사용한다는 것과 학습은 kernel의 가중치를 업데이트

하는 과정이라는 것을 이미 알고 있다.

즉, 전이학습은 이미 특정 task와 데이터셋에서 잘 훈련된 모델과 그 가중치를 가져와서 사용한다는 것이다.

더군다나, 그 데이터셋은 일반화를 위해 다양한 class가 정의된 대규모의 데이터셋을 사용하였다.

또한, 모델의 얕은 layer에서는 일반적으로 저수준의 feature(ex) 점, 선, 모서리)이 포착되며, layer가 깊어짐에 따라 점점

복잡하고 해당 데이터셋의 고유한 feature들이 추출되기 시작한다.

요약하자면, 얕은 layer에서는 어떤 이미지에서든 뽑힐 수 있는 일반적인 feature들이 추출되는 반면, 깊은 layer로
들어갈수록 학습된 데이터셋에서만 포착할 수 있는 feature들이 뽑힌다는 것이다.

때문에, 얕은 layer의 학습 결과는 어떤 이미지에서든 활용할 수 있고 깊은 layer에서의 학습 결과는 이미 특정 task와

데이터셋에 특화되어 일반적인 경우라면 활용하기 어려울 것이다.

정리하자면, 전이학습은 잘 훈련된 weight와 모델 구조를 사용해서 좋은 feature들을 잘 추출할 수 있게 도와줌으로써

모델의 성능과 학습 효율을 높여준다는 것이다.

728x90

3. 컴퓨터 비전에서 전이학습의 적용

전이학습을 적용하는 방식은 정말 많다. 그 중 데이터셋간의 유사성을 기준으로 아래와 같이 2가지 방법론으로 구분할 수 있다.

사전학습된 모델을 feature extractor로 사용:
만약 사전 학습된 데이터셋이 새로 학습할 데이터셋과의 유사성이 높고, task가 유사할 경우 사용할 수 있다.
ImageNet으로 학습된 VGG16 모델을 사전학습 모델로 사용해서 견종을 분류하는 task를 수행한다고 생각해보자.

이때, VGG16 모델의 분류기를 제외한 나머지 부분의 weight를 고정시키고 새로운 분류기로 교체하여 학습함으로써
전이학습을 수행할 수 있다.

ImageNet 데이터셋에는 개의 이미지가 다수 포함되어있기 때문에, 견종을 구분하는 데이터셋과의 유사성이 높고
동일한 classification task이므로 고수준의 feature를 재사용할 수 있기 때문에 높은 성능을 보일 것이다.
Fine-tuning:
앞선 경우와 달리 데이터셋간의 유사성이 낮을 때 적용할 수 있는 방법이다.
예를들어, 견종을 분류하는 모델을 사용하여 다양한 오브젝트가 포함된 이미지를 분류하는 테스트로 학습시키는 경우가
이에 해당한다.

앞선 방식과의 차이점은 weight를 일부만 고정시키거나, 전체 weight를 다시 학습시킬 수 있다는 것이다.
예를 들어, feature map을 추출하는 layer가 깊이에따라 4개 존재하는 모델을 미세조정한다고 가정해보자.

사용자는 모델의 학습 결과를 분석하며 weight가 고정된 layer를 4부터 1까지 혹은 전부 고정되지 않게 바꿀 수 있을 것이다.

여기서 아까 언급한 내용을 고려하자면, 얕은 layer일수록 일반화된 feature를 추출함으로, 깊은 layer부터 weight 고정을 풀며
학습하는 방식을 통해 새로운 task에도 고수준의 feature를 잘 뽑아내도록 학습할 수 있다.

미세 조정이 모델을 처음부터 학습시키는 방법보다 좋은 이유는 바로 이미 사전학습된 모델의 weight가 최적값에
맞춰져있기 때문이다.

새로운 모델을 학습시키는 경우, 무작위 weight로 시작하게된다.
하지만, 사전학습된 모델은 학습된 데이터셋에 최적화된 weight를 갖고있기 때문에 새로운 데이터셋과 task에서도
최적화된 weight로 수렴하는 속도가 훨씬 빠르다. 특히, 얕은 layer의 가중치는 이러한 이점을 더욱 받을 것이다.

때문에, 미세 조정에서는 처음부터 모델을 학습하는 경우보다 더 낮은 학습률을 사용한다.
(이미 weight가 최적값 근처에 있으므로)

위와 같은 2가지 방식을 기준으로 상황에 따라 적절하게 전이학습을 적용하는 것이 중요하다.
간단한 가이드라인을 정리하자면 아래와 같다.

학습할 데이터셋 크기	사전학습 데이터셋과의 유사성	전이학습 방법
작음(데이터셋이 적음)	유사	feature extractor로서 활용
큼(데이터셋이 많음)	유사	깊은 layer를 하나 정도 포함하여 미세조정
작음	많이 다름	깊은 layer 중 일부를 포함하여 미세조정
큼	많이 다름	얕은 layer 일부 혹은 하나 빼고 미세조정

이번 포스팅은 전이학습의 개념과 원리, 컴퓨터 비전 분야에서의 적용 방식에 대해 알아보았다.

처음부터 모델을 학습시켜서 적용해보는 것도 분명 모델의 구조 및 경험을 쌓는데 큰 의미가 있다.

하지만, 주어진 조건에 따라 유연하게 전이학습을 적용해서 더 빠르게 높은 성능을 얻을 수도 있다.

때문에, 상황과 목적을 고려하여 학습을 진행하면 컴퓨터 비전 분야를 이해하는데 큰 도움이 될 것 같다.

포스팅에 대한 질문이나 잘못된 사항 댓글 달아주시면 감사하겠습니다! :)

[Penn-Fudan] Object detection 학습하기 - 3

_DK_Kim — Wed, 13 Mar 2024 19:07:35 +0900

이전 포스팅 내용이 궁금하시다면 아래의 링크를 참고하시면 감사하겠습니다 !
- [Penn-Fudan] Object detection 학습하기 - 1
- [Penn-Fudan] Object detection 학습하기 - 2

저번에 모델 구현까지 완료했으니, 이번 포스티에서는 학습 코드를 작성하고 학습 시킨 뒤 결과를 분석해보자.

이번 포스팅의 내용은 아래와 같다.

모델 학습 코드 구현
학습 결과 분석
요약

3. 모델 성능 검증

3.1 학습 코드 구현

학습 코드는 Pytorch 예제에 나와있는 실행 코드를 사용할 것이다.

나의 경우, 일부 python 파일에서 모듈 인식에 문제가 생겨서 코드를 일부 수정해주었다.

우선 예제에 나와있듯, 학습을 진행할 경로에 'reference/detection'으로 파일을 만들어주고 파일을 다운받아주자.

github에 들어가도 좋지만, Linux를 사용한다면 wget을 사용하면 훨씬 편할 수도 있다.

코드는 다음과 같다.

wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/engine.py&&
wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/utils.py&&
wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/coco_utils.py&&
wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/coco_eval.py&&
wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/transforms.py

정상적으로 다운받아졌다면, 아래와 같이 5개의 python 파일이 다운받아졌을 것이다.

이제 코드를 수정해야한다. 수정해야할 파일은 'coco_utils', 'coco_eval', 'engine' 이렇게 3가지 파일이다.

먼저 coco_utils.py 부터 살펴보자.

import copy
import io
from contextlib import redirect_stdout

import numpy as np
import pycocotools.mask as mask_util
import torch

# import utils
from .utils import all_gather

from pycocotools.coco import COCO
from pycocotools.cocoeval import COCOeval


================================================
================================================

def merge(img_ids, eval_imgs):
    # all_img_ids = utils.all_gather(img_ids)
    all_img_ids = all_gather(img_ids)

    # all_eval_imgs = utils.all_gather(eval_imgs)
    all_eval_imgs = all_gather(eval_imgs)

=================================================
=================================================

utils.py를 import하는 부분을 utils에서 all_gather class를 직접 불러오도록 수정하고, 이에 따라 def 함수에

all_img_ids와 all_eval_imgs를 수정해준다. 위의 코드를 참고하자.

다음은 coco_eval.py 을 살펴보자.

import os

import torch
import torch.utils.data
import torchvision

# import transforms as T
from .transforms import Compose
from pycocotools import mask as coco_mask
from pycocotools.coco import COCO


def get_coco(root, image_set, transforms, mode="instances", use_v2=False, with_masks=False):
==================================================
==================================================
        # TODO: handle with_masks for V1?
        t = [ConvertCocoPolysToMask()]
        if transforms is not None:
            t.append(transforms)
        # transforms = T.Compose(t)
        transforms = Compose(t)

        dataset = CocoDetection(img_folder, ann_file, transforms=transforms)

    if image_set == "train":
        dataset = _coco_remove_images_without_annotations(dataset)

    # dataset = torch.utils.data.Subset(dataset, [i for i in range(500)])

    return dataset
==================================================
==================================================

마찬가지로, transform.py를 import하는 코드를 transform.py에서 Compose를 직접 가져오도록 바꿔준다.

get_coco 함수의 transforms도 이에 맞춰서 바꿔준다. 위의 코드를 참고하자.

마지막으로 engine.py를 살펴보자.

import math
import sys
import time

import torch
import torchvision.models.detection.mask_rcnn
# import utils

from .utils import MetricLogger, SmoothedValue, reduce_dict
from .coco_eval import CocoEvaluator
from .coco_utils import get_coco_api_from_dataset


def train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq, scaler=None):
    model.train()
    # metric_logger = utils.MetricLogger(delimiter="  ")
    metric_logger = MetricLogger(delimiter="  ")

    # metric_logger.add_meter("lr", utils.SmoothedValue(window_size=1, fmt="{value:.6f}"))
    metric_logger.add_meter("lr", SmoothedValue(window_size=1, fmt="{value:.6f}"))

==============================================================
==============================================================

        # reduce losses over all GPUs for logging purposes
        # loss_dict_reduced = utils.reduce_dict(loss_dict)
        loss_dict_reduced = reduce_dict(loss_dict)
        losses_reduced = sum(loss for loss in loss_dict_reduced.values())
        
==============================================================
==============================================================

@torch.inference_mode()
def evaluate(model, data_loader, device):
    n_threads = torch.get_num_threads()
    # FIXME remove this and make paste_masks_in_image run on the GPU
    torch.set_num_threads(1)
    cpu_device = torch.device("cpu")
    model.eval()
    # metric_logger = utils.MetricLogger(delimiter="  ")
    metric_logger = MetricLogger(delimiter="  ")

==============================================================
==============================================================

utils 파일에서 MetricLogger, SmoothedValue, reduce_dict 를 import 하도록 바꿔준 뒤 위의 코드를 참고하여

수정을 진행해준다.

이제 필요한 수정은 전부 끝났다. 본격적으로 학습 코드를 구현해보자.

우선, 필요한 라이브러리와 적용할 augmentation을 정의해보자.

import torch
import torchvision
import torch.optim as optim
import matplotlib.pyplot as plt

from torchvision.transforms import v2 as T
from torch.utils.data import DataLoader

from Model.MaskRCNN import PreMaskRCNN, MaskRCNN_MobileNet_v2_bn
from Dataset import PennFudanDataset
from reference.detection import utils

from reference.detection.engine import train_one_epoch, evaluate

from torchvision.utils import draw_bounding_boxes, draw_segmentation_masks
from torchvision.io import read_image

torch.manual_seed(123)

def get_transform(train):
    transforms = []
    if train:
        transforms.append(T.RandomHorizontalFlip(0.5))
    transforms.append(T.ToDtype(torch.float, scale=True))
    transforms.append(T.ToPureTensor())
    return T.Compose(transforms)

augmentation은 간단하게 Horizontalflip을 적용해준다.

다음은 학습 코드를 확인해보자.

# Main train code
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

num_classes = 2

ds_train = PennFudanDataset(get_transform(train=True))
ds_valid = PennFudanDataset(get_transform(train=False))

# Split the dataset in train and valid set

indices = torch.randperm(len(ds_train)).tolist()

ds_train = torch.utils.data.Subset(ds_train, indices[:-50])
ds_valid = torch.utils.data.Subset(ds_valid, indices[-50:])

dl_train= DataLoader(ds_train, batch_size=2, shuffle=True, num_workers=4, collate_fn=utils.collate_fn)
dl_valid= DataLoader(ds_valid, batch_size=1, shuffle=False, num_workers=4, collate_fn=utils.collate_fn)

# model = PreMaskRCNN().to(device)
model = MaskRCNN_MobileNet_v2_bn().to(device)

params = [p for p in model.parameters() if p.requires_grad]
optimizer = optim.SGD(params, lr=5e-3, momentum=0.9, weight_decay=5e-4)

lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1)

num_epochs = 10

for epoch in range(num_epochs):
    train_one_epoch(model, optimizer, dl_train, device, epoch, print_freq=10)

    lr_scheduler.step()

    evaluate(model, dl_valid, device=device)

학습은 GPU로 돌릴 것이고 train데이터셋과 valid dataset은 위와 같이 정의했다.

학습과 검증 데이터셋은 랜덤하게 나열된 이미지와 마스크쌍을 리스트로 나열한 뒤, 뒤에서 50번째 데이터를 기준으로 나누었다.

예제와 동일하게 SGD를 사용하여 최적화를 진행하였고, 초기 학습률은 0.005로 두었다.

그리고 scheduler를 사용하여 3번의 epoch마다 학습률을 0.1배 하도록 설정하였다.

( 원래 예제에서는 epoch가 2였는데, 이러면 lr_scheduler를 둔 의미가 있나 싶어. 10으로 수정했다. )

코드가 정상적으로 실행된다면, 아래와 같이 학습 로그를 볼 수 있다.

나의 경우 Mask R-CNN의 마지막 Layer와 head를 바꾼 모델은 한 epoch당 17초 정도 걸렸고 MobileNet backbone 모델은 의외로 한 epoch당 13초 정도 걸렸다. 처음 예상과 달리 MobileNet backbone이 한 epoch당 계산 속도는 더 빨랐다.

이제 모델의 출력을 시각화해보자.

아래의 코드를 실행해준다.

view_img = read_image('../../Data/PennFudanPed/PNGImages/FudanPed00046.png')
eval_transform = get_transform(train=False)

model.eval()

with torch.no_grad():
    images = eval_transform(view_img)
    images = images[:3, ...].to(device)
    preds = model([images,])

pred = preds[0]
view_img = (255.0*(view_img - view_img.min()) / (view_img.max() - view_img.min())).to(torch.uint8)
view_img = view_img[:3, ...]

pred_labels = [f"pedestrian: {score:.3f}" for label, score in zip(pred["labels"], pred["scores"])]
pred_boxes = pred["boxes"].long()

output_image = draw_bounding_boxes(view_img, pred_boxes, pred_labels, colors="red")

masks = (pred["masks"] > 0.7).squeeze(1)
output_image = draw_segmentation_masks(output_image, masks, alpha=0.5, colors="blue")

plt.figure(figsize=(12, 12))
plt.imshow(output_image.permute(1, 2, 0))
plt.axis('off')

코드를 실행하면 아래와 같이 모델이 추정한 segmentation과 object detection 결과를 확인할 수 있다.

PreMaskRCNN 모델의 결과

728x90

2. 학습 결과 분석

결과부터 말하자면, Mask R-CNN의 마지막 layer와 head만 바꾸는 방식이 훨씬 더 좋은 결과를 보였다.

간편한 표기를 위해 2 모델을 아래와 같이 표기했다.

A : Mask R-CNN의 head를 Faster R-CNN으로 바꾼 뒤 마지막 layer를 변경
B: Mobilenet v2를 backbone으로 사용

아래는 각 모델의 출력을 시각화 한 것이다.

사진에서 보이듯,B는 모델은 bounding box를 이상한 곳에도 잡아놓은것을 확인할 수 있다. 다음은 마지막 epcoch에서의 coco_evaluate에서 제공하는 Metric을 가져와서 비교해봤다.

정량적 비교에서도 B의 결과는 처참하다.

우선, B는 AP가 AR이 저렇게 둘 다 낮은걸 보면 학습자체가 아예 안된것이라고 보는게 맞다. 반면 A는 AP, AR 둘다 균형좋게 높은 것을 확인할 수 있다.

B는 왜 이런 결과가 생겼을까? 아쉽게도 정확한 원인은 아직 찾지 못했다.

처음에는 이유는 데이터셋이 충분치 않아서 그런 것 같았다. 정확히는 모델의 복잡도에 비해 데이터셋이 너무 적은게 아닐까 싶었다.

총 170장의 이미지 중 학습 데이터셋에 사용된 이미지는 120장밖에 안된다. 심지어 augmentation은 한 가지만
사용했기에 충분히 증강되었다고 생각하기도 어렵다.

이전 포스팅에 언급하였듯, B의 학습 가능한 파라미터는 A보다 훨씬 많다. 즉, 더 복잡한 모델이라고 생각할 수 있다.

그래서 쉽게 overfitting되는 문제가 생긴 것일 수도 있다.

그런데 loss를 살펴보니, epoch이 증가해도 train loss가 감소하지 않는 것을 볼 수 있었다.

overfitting이면, train loss는 낮고 validation loss 높아야하는데, 아쉽게도 validation loss는 coco_evalate에서

따로 log에 기록하지 않아 확인이 어려웠다.

혹시, epoch이 너무 짧아서 그런 문제인가 싶어서 20 epoch으로 학습해보아도, 역시 loss가 감소하다가 오히려 상승하는

문제가 발생했다.

현재는 모델 구조에 문제가 있는게 아닌가 생각해보고있지만, 시간이 난다면 해당 문제를 해결해서 포스팅해보겠다.

이번 포스팅은 Mask R-CNN을 활용하여 Penn-Fudan 데이터셋을 학습시켜서 결과를 분석해보는 내용을 다루었다.

2가지 방법을 사용하여 Mask R-CNN을 구현하였고, coco_evaluate를 사용하여 두 모델의 성능을 비교하였다.

기존의 예측과 달리 Mobilenet backbone을 사용한 모델이 너무 성능이 안좋아서 이유를 찾아보고자 했지만, 아쉽게도

정확한 이유를 찾지 못했다. 정확한 이유를 찾는다면 추후 포스팅해보겠다.

포스팅에 대한 질문이나 잘못된 사항 댓글 달아주시면 감사하겠습니다 ! :)

[Penn-Fudan] Object detection 학습하기 - 2

_DK_Kim — Tue, 12 Mar 2024 13:35:39 +0900

이전 포스팅 내용이 궁금하시다면 아래의 링크 참고하시면 감사하겠습니다 !
- [Penn-Fudan] Object detection 학습하기 - 1

저번 포스팅에 이어 이번 포스팅은 Pen-Fudan 데이터셋을 학습할 모델을 정의하고 코드로 작성해볼 것이다.

모델은 Mask R-CNN을 사용하되, 2가지 방법으로 구현해 볼 것이다.

Pretrain된 Mask R-CNN 모델을 불러온 뒤, head를 Faster R-CNN으로 변경하고 마지막 layer만 학습
Backbone을 MobileNet v2로 변경한 뒤 학습

2. 학습 모델 정의

2.1 Pretrain된 모델을 불러온 뒤, head를 변경 후 마지막 Layer만 학습

해당 코드는 다음과 같다.

import torchvision
import torch.nn as nn

from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
from torchvision.models.detection.mask_rcnn import MaskRCNNPredictor

class PreMaskRCNN(nn.Module):
    def __init__(self, num_classes=2):
        super().__init__()

        # load a Pre-trained Mask R-CNN model on  COCO dataset
        self.model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights="DEFAULT")
        
        # For replacing the classifier (last layer) => 2 (background + pedestrian)
        self.num_classes = num_classes

        # get number of input features for the classifier
        in_features = self.model.roi_heads.box_predictor.cls_score.in_features

        # Replace the pre-trained head with new one
        self.model.roi_heads.box_predictor = FastRCNNPredictor(in_features, self.num_classes)

        in_features_mask = self.model.roi_heads.mask_predictor.conv5_mask.in_channels
        hidden_layer = 256

        # and replace the mask predictor with a new one
        self.model.roi_heads.mask_predictor = MaskRCNNPredictor(
            in_features_mask,
            hidden_layer,
            self.num_classes
            )

    def forward(self, imgs, targets=None):
        if targets:
            return self.model(imgs, targets)
        else:
            return self.model(imgs)

먼저, COCO 데이터셋으로 pretrain된 Mask R-CNN 모델을 불러와준다.

여기서 resnet50은 backbone을 resnet 50을 사용했다는 것을 의미하고, fpn은 head로 FPN(Featuer Pyramid

Network)를 사용했다는 것이다.

그리고 head를 Fast R-CNN의 box predictor로 바꿔준다.

그 후, 256개의 hidden layer를 추가하고 수정된 head와 classifer 파라미터를 업데이트해준다.

2.2 Backbone을 MobileNet V2로 변경하여 학습

이번에는 backbone을 바꿔서 학습할 것이다. 코드는 아래와 같다.

import torchvision
import torch.nn as nn

from torchvision.models.detection import MaskRCNN
from torchvision.models.detection.anchor_utils import AnchorGenerator

class MaskRCNN_MobileNet_v2_bn(nn.Module):
    def __init__(self, num_classes=2):
        super().__init__()

        self.num_classes = num_classes
        # Load pretrained mobilenet_v2 and extract features
        backbone = torchvision.models.mobilenet_v2(weights="DEFAULT").features
        backbone.out_channels = 1280

        # Make RPN generate 5 x 3
        anchor_generator = AnchorGenerator(
            sizes=((32, 64, 128, 256, 512),),
            aspect_ratios=((0.5, 1.0, 2.0),)
        )

        # Define the feature maps that we will use to perform the roi cropping
        roi_pooler = torchvision.ops.MultiScaleRoIAlign(
            featmap_names=['0'],
            output_size=7,
            sampling_ratio=2
        )

        # Put the pieces together
        self.model = MaskRCNN(
            backbone,
            num_classes=self.num_classes,
            rpn_anchor_generator=anchor_generator,
            box_roi_pool=roi_pooler
        )

    def forward(self, imgs, targets=None):
        if targets:
            return self.model(imgs, targets)
        else:
            return self.model(imgs)

여기서 우리는 빈 Mask R-CNN의 구조를 가져와서 필요한 모듈을 우리가 넣어줄 것이다. 우리가 채워야할 모듈은

"backbone", "rpn_anchor_generator" 그리고 "box_roi_pool"이다.

각 값들에 대한 설명을 간략히 적어보면 다음과 같다.

backbone : 입력된 이미지로부터 고차원 feature를 추출. 위의 코드에서는 MobileNet v2를 사용
rpn_anchor_generator : RPN(Region Proposal Network)에 사용할 Anchor 파라미터를 정의.
위의 코드에서는 총 5개의 Size와 3개의 비율값을 통해 object detection을 진행
box_roi_pool : 객체의 bounding box를 정밀하게 추정하기 위해, feature map에서 RoI를 pooling하는
방식을 정의. 위 코드에서는 MultiScaleAlign을 통해 다양한 크기의 featuremap에서 효과적으로 RoI를 pooling

나는 이 두 개의 모델 코드를 한 개의 Python 파일에 작성하여 저장해줬다.

728x90

이제 정의된 두 모델에 대해 살펴보자.

먼저, 첫 번째 방법에서 구현된 모델의 정보를 보자.

Pretrained Mask R-CNN, Head : Fast R-CNN, Classifier : Custom

위의 사진에서 알 수 있듯 모델의 학습 가능한 파라미터 수는 대략 43.7M(Milion) 정도다. 모델의 크기는 3794.11 MB다.

Mask R-CNN with MobileNet v2 backbone

반면, 두 번째는 87.3M 정도의 학습 가능한 파라미터 수를 갖고 있지만, 모델의 크기는 3760.88 MB로 앞선 경우와

비슷하다.

데이터양의 충분하다면, MobileNet v2 bakcbone을 사용한 모델이 학습은 느리더라도 더 높은 정확도를 보여주겠지만,

데이터셋이 적어서 결과가 어떨지 모르겠다. 실제 예제에서도 데이터가 너무 적어서 첫 번째 모델로 진행했다고

적혀있긴하다.

그래도 pretrain된 backbone을 사용하는데 두 번째 방식도 잘되지 않을까 생각이 들었다.

이번 포스팅에서는 Mask R-CNN을 정의하는 2가지 방법에 대해서 다뤄보았다. 다음 포스팅에서는 정의된 모델을 학습하는

코드를 다루겠다.

내용에 대한 질문이나 오류에 대해 답글 달아주시면 감사하겠습니다! :)