1. Anaconda 다운로드

• Anaconda 홈페이지에서 installer 다운로드 : Linux -> 64-bit installer의 링크 주소 복사

• 터미널에서 wget 파일로 다운로드

  $ wget https://repo.anaconda.com/archive/Anaconda3-2024.10-1-Linux-x86_64.sh

2. sh 파일 권한 설정

• ll을 입력하여 권한을 확인하였을 때 x 즉, 실행 권한이 없으면 권한을 실행 권한을 추가해줘야 한다

• sudo chmod +x Anaconda3-2024.10-1-Linux-x86_64.sh 로 실행 권한 추가

3. sh 파일 실행

$ ./Anaconda3-2024.10-1-Linux-x86_64.sh

• please review the license라는 문구가 나오고 ENTER를 입력하라고 하면 ENER를 치면 된다

• license accept를 물어보면 yes 입력하면 된다

• shell과 관련된 문구가 나오면 yes 또는 no를 입력하면 된다

  • yes를 선택하면 conda 명령어가 셸에서 제대로 작동하도록 셸 설정 파일(.bashrc, .zshrc 등)을 수정해준다
  • 보통 yes를 선택하는 것이 좋고 나도 yes를 선택했다

• yes를 선택했을 경우 vi ~/.bashrc로 해당 파일을 확인해보면 아래의 내용이 추가된 것을 확인할 수 있다

4. conda 명령어 설정

• 하지만 아직 conda 명령어가 실행이 안된다

• 위에서 수정된 .bashrc 를 적용해야 conda 명령어를 인식한다

  $ source ~/.bashrc

• conda 버전을 확인했을 때 버전이 뜨면 성공!

  conda -V

  

리눅스 ssh 설치 및 실행

1. ssh 설치

• 먼저 ssh가 설치되어 있는지 확인

  $ dpkg -l | grep openssh-server

• 설치가 안되어 있다면 ssh 설치

  $ sudo apt update
  $ sudo apt install openssh-server

• 다시 설치 확인

  $ dpkg -l | grep openssh-server

  

2. ssh 실행

• ssh가 실행되고 있는지 확인

  $ sudo systemctl status ssh

  

• 만약 ssh 확인 결과 Active: inactive (dead)가 표시된다면 ssh가 실행되고 있지 않다는 것
• 따라서 ssh 서비스를 시작해준다

  $ sudo systemctl start ssh

방법 1. MobaXterm 사용

1-1. 윈도우에 MobaXterm 설치

• MobaXterm 다운로드 홈페이지
• Installer 버전으로 설치 후 압축 해제
• MobaXterm_installer_24.2 실행하여 설치

1-2. MobaXterm 한글 설정

• 한글 파일명이 깨지지 않도록 한글 설정을 해준다
• Settings -> Terminal -> Default terminal font settings -> eucKR 설정

1-3. MobaXterm으로 리눅스(ubuntu) 접속

• ssh를 사용하여 리눅스에 연결
• Session -> SSH 클릭 후 접속할 pc의 정보 입력
  • Remote host : 리눅스 주소 (ip)
    • 리눅스에서 $ ifconfig 명령어를 통해 ip 주소를 확인할 수 있다
  • Specify username : 접속할 계정 (username)
    • 리눅스에서 $ whoami 명령어를 통해 username을 확인할 수 있다
  • Port : ssh 접속 포트
    • 기본 22
    • 만약 다른 포트로 설정하였다면 포트 번호 수정
  • 만약 보안키가 있다면 Advanced SSH settings -> Use private key에 보안키를 넣어준다

• 처음 접속하였다면 아래와 같은 창이 뜬다
• Accept 선택

• 그 후 리눅스 계정 비밀번호를 입력하면 된다
• 이 때 최초로 로그인하는 상황이라면 패스워드 저장 여부를 물어보는 창이 뜬다
  • Yes를 누르면 차후 같은 session에 접근할 때 패스워트 입력없이 자동 로그인이 된다
  • 원하지 않는다면 No를 선택하면 된다

• 만약 위에서 Yes를 선택했다면 보안을 위해 마스터 패스워크를 등록하라는 창이 뜬다
  • 원하는 패스워드를 입력하고 OK를 누르면 된다

• 접속 성공!

1-4. 파일 복사

• 리눅스에 접속하게 되면 왼쪽 사이드바에서 리눅스의 파일들을 확인할 수 있다
• 원하는 곳으로 드래그한 후 드롭하면 윈도우로 파일을 복사할 수 있다

방법 2. scp 사용

• scp는 Secure Copy Protocol의 약자
• 네트워크를 통해 파일과 디렉터리를 안전하게 복사하기 위한 프로토콜
• scp는 ssh 프로토콜을 사용하여 데이터를 암호화하고 안전하게 전송

• 윈도우에서 아래의 명령어를 통해 리눅스의 파일을 가지고 올 수 있다 (윈도우의 cmd 창에서 실행)
  • 리눅스 username : 리눅스 pc의 username
  • 리눅스 ip주소 : 리눅스 pc의 ip 주소
  • 리눅스 파일 경로 : 복사하고 싶은 파일의 경로
    • 예시) /home/quokka/test.c
  • 윈도우 파일 경로 : 복사할 파일을 저장할 윈도우 pc의 경로

scp [리눅스 username]@[리눅스 ip주소]:[리눅스 파일 경로] [윈도우 파일 경로]

예시) scp quokka@192.168.0.1:/home/quokka/test.c ./

1-1. driver version 확인

• $ nvidia-smi를 통해 자신의 driver version 확인

1-2. CUDA Version 확인

• driver version이 460.91.03이다. 그 옆에 CUDA Version을 추천해주는데 이게 뜬다고 해서 CUDA가 설치되어 있는 것은 아니다 (왜냐면... 난 nvcc -V이 안되기 때문..)
• 이와 맞는 CUDA version을 정확히 확인하기 위해서 구글에 driver version 460.91 cuda version이라고 검색한다

• 검색해서 나온 사이트에 들어가면 CUDA version을 확인할 수 있다
• 나의 경우에는 11.2.2 라고 뜬다

2. CUDA toolkit 설치

• https://developer.nvidia.com/cuda-toolkit-archive 여기 사이트에 들어가서 자신에게 맞는 버전을 설치하면 된다
• 이때 본인의 운영체제에 맞게 선택해야하기 때문에 운영체제를 확인을 먼저 해야한다

2-1. 운영체제 확인 방법

• 커널 아키텍처 확인 방법
  • $ uname -m
• 리눅스 os 종류, 버전 확인
  • $ cat /etc/*-release

2-2. CUDA toolkit 다운로드

• 확인한 운영체제에 맞게 선택해주면 된다

• 그러면 아래와 같이 설치 명령어를 볼 수 있다

• CUDA Toolkit 설치용 파일 다운로드 $ wget https://developer.download.nvidia.com/compute/cuda/11.2.2/local_installers/cuda_11.2.2_460.32.03_linux.run

2-3. 설치 파일 실행

$ sudo sh cuda_11.2.2_460.32.03_linux.run

• accept 입력

• install 선택

  • 이때 이미 Driver가 설치되어 있는 상황이라면 X 선택을 해제해야한다
  • 나의 경우 이미 NVIDIA driver를 설치한 상황이기 때문에 선택을 해제하였다

• 설치 완료

2-4. 환경 변수 설정

• 하지만 아직 환경 변수 설정을 안했기 때문에 nvcc -V은 되지 않는다.

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

• 위의 환경 변수 설정을 하고 유지하기 위해서는 위의 내용을 ~/.bashrc에 추가한 후 적용한다

  $ sudo vim ~/.bashrc
  환경 변수 추가
  $ source ~/.bashrc

  

2-5. 최종 확인

• nvcc 버전을 확인했을 때 버전이 나오면 잘 설치된 것이다!!!!!!!

  $ nvcc -V

  

0. Abstract

• ceymo dataset
  • 11 class
  • 4706개의 road marking이 포함된 2887 image
  • 1920 x 1080 해상도
  • polygon, bounding box, segmentation 3가지의 annotation

1. introduction

기존 연구

후보 영역 생성 → 머신러닝 기반 알고리즘 사용

최근 연구

• end-to-end 딥러닝 기반 instance segmentation, semantic segmentation 네트워크 사용
• 빠르고 효율적 but! 연구 부족

  본 연구

  instance segmentation 및 객체 감지 기반 접근 방법 사용
• instance segmentation → mask RCNN
• object detection → SSD
• inverse perspective transform (IPT) 함께 사용

2. related work

기존 공개 road marking detection dataset + detection 알고리즘 분석

2.1 Datasets

• A Practical System for Road Marking Detection and Recognition의 dataset
  • 11 class
  • 1443개의 annotation
  • 800 x 600 해상도
  • bounding box에 대한 정보
  • 이미지 처리 기반 접근 방식, 별도의 train, test set 제공x, 평가 기준 명확x

• TRoM (Tsinghua Road Marking Dataset)
  • 19 class (차선 + road marking)
  • 712개의 이미지
  • 픽셀 수준의 sementic segmentation annotation이 PNG로 제공
  • 데이터셋의 수 적음, annotation과 평가가 sementic segmentation 기반이라 다양한 mark 감지에 제한적

• VPGNet
  • 2만개의 이미지
  • 17 class (but! road marking 관련은 8개 class, 5만개의 instance가 other road marking으로 라벨링)
  • 차선의 소실점을 포함한 차선, road marking의 픽셀 수준 및 grid 수준 annotation이 MAT 파일 형식으로 제공
  • 평가 : IoU
  • 차선 위주

2.2 알고리즘

고전적인 방법

• 대부분 고전적인 이미지 처리 기술 + 간단한 머신러닝
• 일반적인 detection pipeline : 이미지 전처리 → ROI 생성 → 특징 추출 및 머신러닝 알고리즘
• 원본 이미지를 IPT하여 보정하는 것은 일반적으로 사용되는 전처리 기술
• IPT 대신 차선 정보를 사용하여 검색 영역을 축소할 수 있다고 제안 (Fast symbolic road marking and stop-line detection for vehicle localization 논문) → but! 차선 탐지 정확도에 직접적으로 의존하기 때문에 성능 제한될 수 있음

• A practical system for road marking detection and recognition 논문
  • Maximally stable extremal regions (MSER)은 가능한 후보 영역으로 사용됨
  • histogram of oriented gradients (HOG) feature descriptor가 각 클래스에 대한 template pool을 구축하는데 사용됨
  • 추론 시에 각 이미지는 모든 템플릿 이미지와 비교되어 클래스가 할당됨
  • 그러나 복잡한 시나리오에서는 일반적으로 supervised 학습 방법이 템플릿 매칭 방법보다 더 잘 수행됨
  • MSER 영역과 HOG 특징은 SVM 분류기와 함께 사용되어 symbol 기반 road marking 인지에 사용됨
  • 별도의 OCR 알고리즘은 텍스트 기반 도로 표지판을 인식하는데 사용됨
  • 그러나 서로 다른 road marking에 대해 다른 접근 방식을 가지로 있는 것은 계산 중복성을 초래할 수 있음
  • 이러한 두가지 방법 모두 HOG 특징 추출을 포함하며 이는 시간이 많이 소요됨

• Road marking detection and classification using machine learning algorithms 논문
  • Binarized normed gradients (BING) objectiveness 추정 알고리즘은 가능한 road marking 영역 제안을 생성하는데 사용
  • PCANet 및 SVM integrated classifier는 road marking을 인지하는데 사용
  • 이 방법의 단점은 BING이 일반적으로 더 큰 영역을 제안하기 때문에 위치 정확도가 낮음
  • 로지스틱 회귀를 PCANet과 함께 사용되어 분류 정확도 향상
  • 얕은 CNN도 road marking인식을 위한 분류기로 소개됨
  • MSER 영역을 식별한 후에는 밀도 기반 클러스터링 알고리즘을 사용하여 제안된 road marking 영역을 병합하여 분류기를 위한 road marking 영역을 얻음
  • 영역 제안을 얻기 위해 많은 전처리 기술 사용하고 PCANet 또는 얕은 CNN 분류기는 인식 부분에만 사용됨

딥러닝 기반 방법

• road marking detection 분야에서 딥러닝 기반 네트워크가 널리 사용되지는 않았다

• Benchmark for road marking detection: Dataset specification and performance baseline 논문
  • ResNet-101와 피라미드 pooling 앙상블을 결합한 합성곱 신경망 모델을 사용하여 차선, road marking을 semantic segmentation으로 얻음
  • 이는 TRoM dataset에서 평균 결과 달성

• VPGNet
  • 차선, road marking을 동시에 감지하기 위한 CNN 기반 아키텍처
  • road marking 탐지를 grid 최귀 작업으로 다루고 grid sampling 및 box clustering을 후처리 기술로 사용하여 grid cell 병합
  • 그러나 이는 주로 차선 탐지 및 소실점 예측 작업에 더 많이 집중

3. benchmark dataset

3.1 data annotation

• 11 class
• polygon 좌표 JSON
• bounding box XML
• 픽셀 수준의 segmentation mask PNG

3.2 dataset 통계

• 2887장의 이미지 (2099개, 788개 → train, test)
• 클래스 불균형이 있음

• test set 이미지는 6가지 시나리오로 구성
• 정상, 혼잡, 눈부심, 야간, 비, 그림자 (normal, crowded, dazzle light, night, rain and shadow)

3.3 평가 martix

• F1 score와 Macro F1 score 사용
• 예측과 실제 사이의 교차 영역 값이 계산되며 IoU가 0.3보다 크면 해당 예측이 true로 간주됨
• F1 score
  • $precision = \frac{TP}{TP + FP}$
  • $recall = \frac{TP}{TP + FN}$
  • $F1 = \frac{2 \times precision \times recall}{precision + recall}$
• macro F1 score는 11 class의 F1 score의 평균
  • $macro F1 = \frac{1}{C}\sum_{i=1}^CF1_i$
  • macro F1 score는 dataset에 나타나는 빈도에 관계없이 모든 class에 동일한 중요도 부여

4. 방법

• 2가지 접근 방법
  • object detection 방법
  • instance segmentation 방법

4.1 Object detection approach

1. BEV 변환
   • 먼저 inverse perspective transform(IPT)를 사용하여 bird eye view로 변환
   • IPT는 캡쳐된 이미지의 투시 왜곡을 줄이고 더 넓은 영역의 배경을 제거하여 road marking이 더 두드려지게 만듦
   • IPT는 관련 homography matirx인 M이 주어진 homography transformation
     • $Destination[\hat{x}, \hat{y}, :] = Source[x, y, :]$
     • $\hat{x} = \frac{M_{11}x + M_{12}y + M_{13}}{M_{31}x+M_{32}y + M_{33}}$
     • $\hat{y} = \frac{M_{21}x + M_{22}y + M_{23}}{M_{31}x+M_{32}y + M_{33}}$
     • 즉, $\begin{bmatrix} x' \newline y' \newline z' \end{bmatrix} = M \begin{bmatrix} x \newline y \newline 1 \end{bmatrix}$ 한 후 $\hat {x} = \frac{x'}{z'} , \hat{y} = \frac{y'}{z'}$ 하는 계산 과정

2. 모델
   • BEV 이미지에서 road marking을 감지하기 위해 end-to-end object detector 모델이 사용됨
   • MobileNet-v1 backbone을 사용하는 SSD와 Inception-v2 backbone을 사용하는 SSD의 성능 평가
   • 500 x 500 해상도의 이미지가 입력됨
   • bounding box로 road marking 감지 결과 출력

3. 최종 단계에서 bounding box는 M의 역행렬을 사용하여 원래 이미지 도메인으로 변환됨

4.2 Instance Segmentation Approach

• instance segmentation의 목표는 객체 instance와 그 객체의 픽셀 단위 segmentation mask를 예측하는 것
• Mask R-CNN 네트워크 아키텍처를 inception-V2와 Resnet-50 두 가지 backbone과 함께 사용
  • Mask R-CNN은 Faster R-CNN 아키텍처를 확장하여 각 ROI마다 bounding box와 segment mask 예측함
  • instance segmentation 네트워크는 일반적으로 추론 속도가 낮기 때문에 추가 전처리 단계 없이 입력 이미지를 낮은 해상도인 500 x 500으로 resize한 후 모델에 직접 입력함
  • 네트워크는 road marking에 대한 bounding box와 segmentation mask를 출력함
  • 본 논문은 convex hull을 얻을 수 있는 segmentation mask만 평가

5. experiment

5.1 data augmentation

• 클래스 불균형 문제의 영향을 줄이기 위한 단계
• 훈련 중에 부족한 instance 수를 증가시키기 위해 간단한 data augmentation 방법을 사용
• 왼쪽 화살표, 직진-우회전 화살표 클래스가 오른쪽 화살표, 직진-좌회전 화살표 클래스에 비해 상대적으로 적은 instance를 가지고 있음
• 따라서 화살표가 포함된 이미지를 수평으로 뒤집어 (horizontally flip) 대칭된 표지판을 얻음
• 그러나 cycle lane, bus lane, slow road marking 클래스의 instance를 뒤집으면 의미를 잃기 때문에 이러한 instance를 포함한 이미지는 피함
• 또한 탐지 모델을 훈련하는 동안 이미지의 밝기, 채도, 대비, 색조를 무작위로 변경함

  5.2 implementation details

• Intel Core i9-9900K CPU & Nvidia RTX-2080 Ti GPU
• TensorFlow로 모델 학습
• SSD-MoblieNet-v1 & SSD-Inception 모델
  • RMSProp optimization : 초기 learning rate 0.004, momentum 0.9, batch size 24
  • Mask-RCNN-Inception 모델
• momentum 포함한 SGD : 초기 lr 0.0001, momentum 0.9, batch size 4
  • Mask-RCNN-ResNet50 모델
• momentum 포함한 SGD : 초기 lr 0.0003, momentum 0.9, batch size 2

6. Result

• 표 4a
  • 각 모델의 F1 score, 추론 속도(FPS)
  • instance segmentation 방식이 object detection 보다 더 나음
  • Mask-RCNN-ResNet50 모델이 전체적으로 가장 높은 F1 score를 기록했지만 FPS가 가장 낮음
  • Mask-RCNN-Inception-v2 모델을 정확도와 속도 사이의 균형 제공
  • SSD 모델은 IPT와 함께 사용될 때 중간 정도의 정확도와 더 높은 추론 속도 보임
  • 모든 모델이 normal에서 더 나은 성능을 보이고, 도전 시나리오에서는 F1 score가 비교적 낮음

• 표 4b
  • macro F1 score
  • 모든 모델의 macro F1 score가 전체 F1 score 보다 약 2%정도 낮다는 것을 알 수 있음 → 모델이 특정 클래스에서 더 잘 작동하는 경향이 있음을 의미
  • dataset에서 자주 발견되고 도로의 큰 영역을 차지하는 횡단보도는 모든 모델에서 잘 감지됨
  • slow, bus lane, cycle lane 클래스는 dataset에서 비교적 수가 적음 → 하지만 독특한 형태와 특징이 있기 때문에 잘 감지함
  • 화살표의 경우 data augmentation을 통해 수를 증가시켰음에도 다른 sign에 비해 정확도가 낮음 → 화살표 클래스들 간의 유사성뿐만 아니라 도로 표면의 차선과도 유사성이 있기 때문일 수도 있음

• Mask R-CNN 모델이 특히 도전적인 시나리오에서 나은 성능을 보임
• segmentation mask는 객체 탐지 방법보다 road marking의 위치를 더 정밀하게 지정함

• 특정 class의 데이터 수가 다른 class의 데이터 수에 비해 적을 때
• 데이터의 수가 많은 class를 majority class라고 하고 적은 class를 minority class라고 한다
• 이런 경우 평가지표로 단순히 accuracy를 사용하는 것은 좋지 않다 : 만약 개와 고양이를 분류하는 문제에서 개의 데이터가 95%, 고양이의 데이터가 5%인 경우, 전체 데이터를 개로 분류하여도 95%의 accuracy가 나오기 때문이다
• 이런 경우에는 precision, recall의 조화평균인 F1 score 지표를 보는 것이 좋다
  • 일반적으로 precision은 높고 recall은 매우 낮은 경항이 있다

class imbalance의 문제

• 학습을 할 때 불균형이 크다면 majority class로 편향되어 학습된다
• 즉, minority class에 대한 정확도와 예측력이 낮아질 수 있다

class imbalance 해결 방법

1. 데이터 수집

• 테이터의 수가 minority class의 데이터를 더 수집한다
• 하지만 이 방법은 현실적으로 어려운 경우가 많아서 주로 아래의 방법들을 사용한다

2. weight balancing

train 과정에서 각 class의 loss를 계산할 때 특정 class(주로 minority class)의 loss에 가중치를 부여하여 해당 class를 더 잘 학습할 수 있도록 유도하는 방법

2-1. Balanced Cross-Entropy Loss

• 모든 클래스의 손실에 가중치 $\alpha$를 부여하여 클래스 간의 불균형을 조정하는 방법
• 주로 minority class에 높은 가중치를 부여하여 minority class에 대한 손실을 증가시키고, majority class에 대한 손실을 감소
  • 예를 들어, class frequency의 역수를 사용할 수 있다
  • class 불균형이 1:10이라면 minority에는 $1$을 곱하고 majority에는 $\frac{1}{10}$을 곱해준다
• 아래와 같은 식으로 표현할 수 있다
  • $\alpha$ : 가중치
  • $p_t$ : 모델이 예측한 class의 확률

$$BCE(p_t) = -\alpha_t log(p_t) $$

• 단점 : 단순히 class 샘플의 수를 고려한 것이기 때문에 easy sample과 herd sample을 구분하기 어렵다

2-2. Focal Loss

• 잘 분류되는 샘플(easy sample)에는 작은 가중치를 부여하고, 분류가 어려운 샘플(hard sample)에는 큰 가중치를 부여하는 방법

$$FL(p_t) = -(1-p_t)^\gamma log(p_t) $$

• easy sample의 $p_t$는 1에 가까운 값이고, hard sample의 $p_t$는 0에 가까운 값이다
• 즉, loss로 보면 easy sample의 loss를 작게 하고 hard sample의 loss를 강조하여 모델이 잘 학습할 수 있도록 도와준다
• 이때 $\gamma$의 값이 클수록 잘못 분류되는 경우의 값들이 강조되어 해당 값을 잘 학습할 수 있도록 유도된다

2-3. Balanced Focal Loss

• Balanced Cross-Entropy Loss와 Focal Loss를 결합한 방법이다 $$ FL(p_t) = -\alpha_t(1-p_t)^\gamma log(p_t) $$

• Balanced Cross-Entropy Loss에서 사용되는 $\alpha$ 값을 통해 class 간의 가중치를 조절한다
• Focal Loss에서 사용되는 $\gamma$ 값을 통해 hard sample을 잘 학습할 수 있도록 한다

3. resampling

데이터 샘플을 수를 조절하는 방법으로 under-sampling과 over-sampling 방법이 있다

3-1. under-sampling

• majority class 샘플의 일부를 삭제하여 개수를 맞추는 방법
• 데이터가 많은 경우에 사용할 수 있다
• 단점 : 데이터의 수가 줄어들기 때문에 정보 손실이 발생한다

3-2. over-sampling

• minority class 샘플을 복사하여 majority class 수 만큼 늘려주는 방법
• 단점 : 중복된 샘플이 많아 훈련 속도를 느리게하고 모델 과적합 문제가 발생할 수 있다

reference

• https://medium.com/data-science-ecom-express/focal-loss-for-handling-the-issue-of-class-imbalance-be7addebd856

• point cloud data로 부르며 3차원 공간에 존재하는 특정한 점이다
• 일반적인 경우 LiDAR 센서는 이더넷 TCP/IP (대부부은 UDP)를 통해 데이터를 수신하고 데이터의 포맷은 packet 형태를 가진다
• LiDAR가 ethernet protocol을 통해 local로 data를 보내준다

• ethernet 통신의 데이터를 packet이라고 한다
• ethernet 통신을 하는 이유?
  • LiDAR 데이터가 크기 때문이다
  • 만약 충분이 적은 데이터를 가진 센서라면 다른 인터페이스를 사용하는 경우도 있다

1-1. Packet 구조

• 많은 LiDAR 센서는 Ethernet Packer 구조를 사용하기 때문에 라이브러리 또는 SDK를 제공하지 않는다면 직접 packet을 un-pack(parsing)하는 과정이 필요하다
• 이때는 LiDAR 회사의 공식 문서를 참고해야한다
• 시중의 대부분의 센서는 라이브러리나 SDK를 제공한다

• Ethernet packet의 파일 확장자는 *.pcap 을 사용하고 packet stream Ehsms PCAP file을 point cloud format으로 변환하여 사용한다

Velodyne VLP-16 LiDAR 데이터 구조

• 한 packet의 크기는 1248bytes
• packet의 시작과 끝을 찾고 그 안에 있는 데이터를 가지고 온다
  • header : 42bytes
  • tail : 6bytes -> 시간, factory(끝을 의미)하는 내용이 담겨있다
• header와 tail을 제외한 데이터 : 1200 bytes
  • 12개의 data block (0 ~ 11 block)
  • Flag : data block의 시작을 확인할 수 있다, 16진수이기 때문에 2 bytes를 차지한다
  • Azimuth : Lidar의 각도
  • sequence : VLP-16은 16채널이기 때문에 채널에 대한 데이터가 각각 16개씩 들어있다

1-2. data format

• 일반적으로 point cloud data는 다음과 같은 데이터를 의미한다
• X, Y, Z : point의 3차원 위치를 표현
• (optional) intensity : 반사된 laser의 세기
• point cloud data는 *.pcd, *.las, *.xyz 등을 사용한다

2. PCL (PointCloudLibrary)

• point cloud를 다루는 라이브러리
• github : https://github.com/PointCloudLibrary/pcl
• site : https://pointclouds.org/

• open3D와 같은 유용한 라이브러리도 존재한다
• 또한 OUSTER처럼 자체 SDK를 제공하는 경우도 있다

• ROS를 사용한다면 PCL 라이브러리는 자동으로 설치된다
• ROS 환경이 아니라면 sudo apt install libpcl-dev 명령어로 설치한다
• PCL은 의존 라이브러리가 많이 때문에 직접 컴파일한다면, 반드시 공식 홈페이지를 참고하여 설치한다
• Mandatory, Optional 모두 설치해야한다

2-1. container, data type

container

• 데이터를 담아두는 그릇
• pcl::PointCloud<T>
• pcl::PCLPointCloud2 : PCL 1.x 버전 이상

data type

• 데이터를 표현하는 이름
• pcl::PointXYZ : 3D scanner를 사용하는 경우
• pcl::PointXYZI : 3D scanner에서 intensity를 같이 사용하는 경우
• pcl::PointXYZRGB : RGB-D camera 또는 LiDAR & Camera calibration을 통해 point cloud에 RGB값을 부여한 경우
• pcl::PointXYZRGBA : pcl::PointXYZRGB에 투명도가 추가된 것
• pcl::PointXY : 2D scanner를 사용하는 경우

2-2. CMakeLists.txt 작성 방법

• c++로 PCL을 사용할 경우 CMakeLists를 사용해야한다

cmake_minimum_required(VERSION 3.10)

project(project_name)
add_executable(project_name main.cpp)

find_package(PCL 1.12 REQUIRED)

if(PCL_FOUND)
  include_directories(${PCL_INCLUDE_DIRS})
  add_definitions(${PCL_DEFINITIONS})
  link_directoried(${PCL_LIBRAry_DIRS})
  target_link_libraries(project_name ${PCL_LIBRARIES})
endif()

2-3. PointCloud Container 작성 방법

• 1960년대 루돌프 칼만이 개발한 알고리즘
• 칼만 필터는 시스템의 상태에 대한 확률적인 정보를 가지고 노이즈가 섞인 측정값과 예측값을 효과적으로 결합하여 상태를 추정
• 칼만 필터는 센서를 통해 측정한 값에 노이즈가 포함되어도 이 노이즈를 제거
• 연산 과정이 빠르기 때문에 실시간, 임베디드 시스템에 적합

Kalman Filter 사용 조건

• motion model과 observation model이 linear한 경우
• motion model과 observation model이 가우시안 분포를 따를 경우

• motion model
  • 로봇이 현재 위치에서 control input을 받아서 이동했을 때의 확률 모델
• observation model
  • 로봇이 현재 위치에서 센서를 통해 자신의 위치를 측정했을 때의 확률 모델

Kalman Filter의 전체 과정

• 칼만 필터는 상태 예측 (state prediction)과 측정 업데이트 (measurement update)를 반복적으로 수행하며 현재 상태를 계산
  • 상태 예측 (state prediction): 이전 상태의 추정값과 모델을 이용하여 다음 상태 예측
  • 측정 업데이트 (measurement update): 예측값과 실제 측정값을 비교하여 상태를 업데이트

• 로봇의 경우 로봇이 이동하기 위해서 어디에 있는지 위치를 정확하게 알아야하는데 이때 칼만 필터를 사용
  • 상태 예측: 이전 로봇의 파라미터(위치) + 로봇 모션 입력 -> 현재 로봇 파라미터 예측
  • 측정 업데이트: 예측한 로봇의 파라미터 + 센서(GPS 등)를 통해 얻은 로봇의 위치 -> 로봇 파라미터 값 업데이트

간단 과정

정규 분포로 본 과정

1. state predict
   • 이전 위치에서 motion input을 받아 이동한 현재 위치를 예측하는 과정
   • 위치에 대한 정규분포와 이동에 대한 정규분포의 합성곱(convolution) 계산을 통해 이루어진다
2. measure
   • 센서를 사용하여 현재 위치를 측정하는 과정
   • 측정한 값도 정규분포로 나타난다
3. update
   • predict를 통해 예측한 값과 센서를 통해 측정한 값을 통해 최적의 값을 계산한다 (예측된 값 갱신)
   • 예측값의 정규분포와 측정값의 정규분포의 곱(product) 계산을 통해 이루어진다
4. time + 1
   • 최적의 값을 사용하여 다시 1번부터 수행한다

Kalman Filter 세부 과정

kalman filter를 사용하여 이동하는 로봇의 위치를 추정하는 과정에 대해 자세히 설명한다

0. 로봇의 위치, 이동량 정규분포

• 칼만 필터에서는 현재 위치와 이동량을 정규분포로 표현할 수 있다
• 정규분포로 표현하는 이유는 불확실도(uncertainty)를 포함하여 위치, 이동량을 표현하기 위해서이다

로봇의 위치

• 로봇이 $x=0$ 위치에 있을 가능성이 가장 높다고 가정한다
• 로봇이 정확하게 $x=0$ 위치에 있을지에 대해 불확실도가 있기 때문에 아래와 같은 정규분포로 표현할 수 있다

로봇의 이동량

• 로봇이 $x=3$ 만큼 오른쪽으로 이동한다고 가정한다
• 이동량 역시 정확하게 $x=3$만큼 이동하는지에 대해 불확실도가 있기 때문에 정규분포로 표현할 수 있다

1. State Predict

• 로봇이 $x=0$인 상태에서 $x=3$만큼 이동하였을 때 상태를 예측한다
  • 로봇이 $x=0$인 상태 = 이전 로봇의 파라미터
  • $x=3$만큼 이동 = motion control input
• 위치에 대한 정규분포와 이동에 관한 정규분포의 합성곱(convolution) 계산을 통해 예측값을 구한다
  • 합성곱을 하는 이유: 물체가 실제로 −∞ 부터 ∞까지 존재할 가능성이 있기 때문에 이 모든 경우에 대해서 이동량의 분포를 곱하고 더해주어야한다 (곱하고 더하는것 = 합성곱)

• 로봇이 $x=0$에서 $x=3$만큼 이동했다면 아래와 같은 분포로 표현할 수 있다

정규분포의 합성곱(convolution) 계산

• 합성곱은 임의의 두 함수 $f(t)$와 $g(t)$에 대해 다음과 같이 정의되는 연산이다
• (1) $f(t) * g(t) = \int_{-\infty}^\infty f(\tau)g(t-\tau)d\tau$

• $f(t), g(t)$를 정규분포로 표현하면 다음과 같다 (여기에서 $\mathcal{N}$은 정규분포, $\mu$는 평균, $\sigma$는 분산을 의미한다)
  • $f(t)$는 $\mathcal{N}_1(x; \mu_1, \sigma_1^2)$
  • $g(t)$는 $\mathcal{N}_2(x; \mu_2, \sigma_2^2)$

• 두 함수의 합성곱 결과는 다음과 같다
  • (2) $f(t) * g(t) = \mathcal{N}(x; \mu_1 + \mu_2, \sigma_1^2 + \sigma_2^2)$

• 위의 예시로 보면 $f(t)$가 로봇의 위치에 관한 함수, $g(t)$가 로봇의 이동량에 관한 함수이고 합성곱 결과는 예측값에 관한 함수이다
• 예측값 평균은 (2)에 이전 위치 평균인 $\mu_1$에 0을 대입하고, 이동량 평균인 $\mu_2$에 3을 대입하면 구할 수 있다
  • $\mu_1 + \mu_2=0+3=3$
• 예측값 분산은 (2)에 이전 위치 분산을 $\sigma_1$에 대입하고, 이동량 분산을 $\sigma_2$에 대입하면 구할 수 있다

• 여기에서 합성곱 결과 함수도 정규분포를 따르고, 합성곱 결과 함수의 분산은 두 입력 정규분포의 분산보다 항상 크다는 것을 알 수 있다
• 즉, 합성곱을 수행할 때마다 분산이 증가한다 (=불확실도가 증가한다)

2. Measure

• 센서를 사용하여 현재 위치를 측정하는 단계이다
• 센서를 사용하여 측정한 측정값에도 noise, 즉 불확실도가 있기 때문에 정규분포로 표현할 수 있다

• 센서에서 측정한 로봇의 현재 위치가 $x=4$라고 가정하면 아래와 같은 정규분포로 표현할 수 있다

3. Update

• 예측값과 측정값을 사용하여 최적값을 구하는 단계이다. 즉, 이전값을 갱신(update)하는 단계이다
• 이때 베이즈 정리(Bayes' theorem)를 사용하여 예측값 정규분포와 측정값 정규분포의 곱(product) 계산을 통해 최적값을 구한다

• 최적값 역시 정규분포로 표현할 수 있다
  • 두 정규분포(측정값, 예측값)의 곱은 정규분포 모양이지만 정규분포는 아니다
  • 하지만 아래의 베이즈 수식에서 볼 수 있듯이 $P(E)$를 나누어 정규화를 해주기 때문에 최적값도 정규분포가 된다

• 그 후 이 최적값이 1번의 predict 과정에서 로봇의 상태(위치)로 사용되고 1번부터 3번이 반복된다

베이즈 정리(Bayes' theorem)

• 베이즈 정리는 사전 정보(prior)와 관측(likelihood)를 사용하여 사후 확률(posterior)를 계산하는 것으로 이전 정보를 갱신하고 새로운 정보를 통합할 수 있다
• 베이즈 정리는 불확실성이 있는 상황에서 신뢰도 있는 값을 추정하기 위해 사용된다

• 칼만 필터는 상태를 확률 분포로 표현하고, 센서로 측정한 측정값도 오차가 있을 수 있다
• 이런 상황에서 확률 기반으로 값을 추정하는 베이즈 정리를 사용하면 현재 상태 추정에 대한 신뢰도를 표현할 수 있고 기존의 상태 추정과 통합하여 값을 갱신할 수 있다

• 베이즈 정리 수식

• 위의 예시(로봇의 위치 추정)에서의 의미
  • $P(H|E)$ : 최적값
  • $P(E|H)$ : 센서를 통해 측정한 측정값
  • $P(H)$ : 예측값 (state predict 과정에서 예측한 예측값)

• 즉, 최적값을 구하려면 측정값과 예측값의 곱을 계산해야한다

정규분포의 곱(product) 계산

• $f(t), g(t)$를 정규분포로 표현하면 다음과 같다 (여기에서 $\mathcal{N}$은 정규분포, $\mu$는 평균, $\sigma$는 분산을 의미한다)
  • $f(t)$는 $\mathcal{N}_1(x; \mu_1, \sigma_1^2)$
  • $g(t)$는 $\mathcal{N}_2(x; \mu_2, \sigma_2^2)$

• 정규분포의 곱 결과 분포를 $\mathcal{N}{new}(x; \mu{new}, \sigma_{new}^2)$라고 하면 그 계산 과정은 다음과 같다
  • $\mu_{new} = \frac{\mu_1 \sigma_2^2 + \mu_2 \sigma_2^2}{\sigma_1^2+\sigma_2^2}$
  • $\sigma_{new}^2 = \frac{1}{1/\sigma_1^2 + 1/\sigma_2^2} = \frac{\sigma_1^2\sigma_2^2}{\sigma_1^2 + \sigma_2^2}$

• 위의 예시로 보면 $f(t)$가 예측값에 관한 함수, $g(t)$가 측정값에 관한 함수이고 곱 결과는 최적값에 관한 함수이다

reference

• https://angeloyeo.github.io/2021/04/07/Kalman_filter.html
• https://medium.com/@celinachild/kalman-filter-%EC%86%8C%EA%B0%9C-395c2016b4d6

딥러닝 프로젝트 발표일!!

주말 동안 centerpoint 모델 학습을 진행하였다. 학습 epoch을 조절하고, pretrained weight를 사용해보는 등 여러 방법으로 학습을 진행하였다. 코드를 직접 구현한 것이 아니라 코드를 파악하기 어려웠다. epoch은 어디서 조절해야하는지, class를 바꾸려면 어디를 수정해야하는지 찾는데 시간이 오래걸렸다. 그리고 환경 변수 에러, gpu, docker 관련 에러 등 평소에 자주 보지 못했던 에러들이 많이 발생해서 이를 해결하는 과정도 오래걸렸다.

또한 AWS를 다같이 사용해서 모델을 학습시키다보니 용량이 부족한 문제가 자주 발생했다. 결국 docker container를 하나만 사용하는 방법으로 용량 문제를 해결했다. 사실 완전히 해결한 것은 아니지만 일단 다른 container를 제거해서 용량을 확보했다.

🧬 딥러닝 프로젝트 결과

같은 dataset으로 epoch를 조절하여 학습을 진행해보았다. 또한 mini dataset은 데이터 수가 부족하여 학습이 잘 되지 않는 것 같다고 판단하여 train dataset을 사용하여 학습을 진행해보았다.

그 결과 v1.0-trainval-1의 경우 데이터의 수가 훨씬 많기 때문에 mini의 경우보다 성능이 좋았다.

Dataset (nuScenes Dataset)

• v1.0 mini 와 v1.0 part 1 dataset 사용
• object detection은 10개의 class로 구분되어 있다

Object Detection 성능 평가 지표

• AP (Mean Average Precision) : Precision-Recall 곡선의 면적, 높은 mAP 값은 모델이 다양한 클래스에 대해 높은 precision과 recall을 가진다
• ATE (Mean Absolute Trajectory Error) : 2D 상에서의 Euclidean center distance (meters) 즉, 모델이 추정한 위치와 실제 위치 간의 차이를 의미한다
• ASE (Mean Absolute Scale Error) : orientation과 translation을 align 해 준 뒤의 3D IOU (1 - IOU)
• AOE (Average Orientation Error)
  • 예측 값과 GT 사이의 가장 작은 yaw angle 차이 값 (radians)
  • yaw angle은 차량의 주향 방향에 대한 각도를 의미한다
• AVE (Average Velocity Error) : velocity 차이의 L2 norm으로 velocity error의 절댓값 (m/s)
• AAE (Average Attribute Error) : 1에서 attribute classification accuracy를 빼준 값 (1 - acc)
• NDS (nuScenes Detection Score)
  • mAP, mATE, mASE, mAOE, mAVE, mAAE에 가중치를 부여하여 합산한 값
  • TP 오류를 TP 점수로 변환한다
  • $TP_score=max⁡(1−TP_error,0.0)$
  • mAP에는 가중치 5를 할당하고 나머지에는 가중치 1을 할당하여 계산한다

결과 비교

• 같은 dataset에서 epoch를 늘린 경우가 그렇지 않은 경우보다 성능이 좋다
• 하지만 mini dataset은 데이터의 수가 적기 때문에 성능이 좋은 편은 아니다
• v1.0-trainval-1의 경우 데이터의 수가 훨씬 많기 때문에 mini의 경우보다 성능이 좋다
• 딥러닝을 학습할 때는 epoch도 중요하지만 데이터의 절대적인 수가 매우 중요하다

dataset : v1.0 mini / epoch : 20

epoch 50

epoch 80

Tracking 결과

tracking 결과

AMOTA AMOTP RECALL MOTAR GT MOTA MOTP MT ML FAF TP FP FN IDS FRAG TID LGD bicycle 0.000 1.603 0.345 0.000 58 0.000 0.262 0 5 530.6 17 833 38 3 1 0.62 1.88 bus 0.117 1.515 0.453 0.444 86 0.186 0.655 1 2 30.8 36 20 47 3 5 3.25 3.62 car 0.609 0.856 0.647 0.856 2729 0.541 0.356 60 48 153.1 1725 248 963 41 25 1.71 2.30 motorcy 0.047 1.445 0.261 0.328 238 0.084 0.357 1 5 59.4 61 41 176 1 3 2.00 4.21 pedestr 0.668 0.540 0.786 0.791 1470 0.591 0.362 53 17 173.5 1098 229 314 58 18 0.76 1.17 trailer 0.000 2.000 0.000 0.000 41 0.000 2.000 0 1 500.0 0 nan 41 nan nan 20.00 20.00 truck 0.176 1.344 0.226 0.725 177 0.164 0.284 0 6 9.1 40 11 137 0 0 1.00 3.83

Aggregated results: AMOTA 0.231 AMOTP 1.329 RECALL 0.388 MOTAR 0.449 GT 685 MOTA 0.224 MOTP 0.611 MT 115 ML 84 FAF 208.1 TP 2977 FP 1382 FN 1716 IDS 106 FRAG 52 TID 4.19 LGD 5.29 Eval time: 46.8s

• flask가 사용될 때 발생할 수 있는 오류라고 한다
• werkzeug 라이브러리 버전이 맞지 않아서 발생한다

ImportError: cannot import name 'url_quote' from 'werkzeug.urls' (/opt/conda/lib/python3.8/site-packages/werkzeug/urls.py)

해결

pip uninstall -y Werkzeug
pip install Werkzeug==2.3.6

1. data 형식

1-1. LiDAR data

• velodyne HDL-64E
• LiDAR data 파일 형식 : *.bin
• data format : x, y, z, intensity로 구성되어있다
• 수평 시야각 : 360도, 수직 시야각 26.8도
• 맨 위쪽부터 반시계 방향 순서로 데이터가 기록되어 있다

• LiDAR 좌표계
  • LiDAR 센서 중심 (0,0,0)
  • x축 : 전방
  • y축 : 왼쪽
  • z축 : 높이, 하늘 방향

1-2. calibration data

• KITTI에서는 camera calibration과 관련된 데이터을 제공해준다 (camera calibration matrices of object data set)

calib 파일 (.txt) 내용

• P0, P1, P2, P3 : projection 행렬
  • world 좌표를 image 좌표로 projection 해주는 행렬
  • 12개의 값 -> 3x4 행렬
  • 아래와 같이 KITTI 데이터는 4대의 카메라(cam 0, cam1, cam2, cam3)을 사용한다
  • 다운받은 데이터셋이 cam2이기 때문에 P2만 사용하면 된다
  • 
• R0_rect : rectification
  • world 평면으로 회전시켜주는 회전 변환 행렬
  • 9개의 값 -> 3x3 행렬
  • KITTI는 사용하는 카메라가 4대이기 때문에 이들 간의 world 좌표를 맞춰주기 위해서 이 행렬을 사용한다
• Tr_velo_to_cam : LiDAR 좌표 -> camera 좌표
  • LiDAR 좌표를 camera 좌표 (정확히는 cam0)으로 변환해주는 변환 행렬
  • 9개의 값 -> 3x3 행렬

2. LiDAR와 camera mapping

$s(x, y, 1) = P2 * R0_rect * Tr_velo_to_cam * (X, Y, Z, 1)$

1. LiDAR 좌표 $(X, Y, Z, 1)$을 camera 기준 좌표계로 변환
   • $Tr_velo_to_cam * (X, Y, Z, 1)$
2. world 좌표로 변환
   • $R0_rect * Tr_velo_to_cam * (X, Y, Z, 1)$
   • cam0의 좌표를 최종적인 world 평면으로 회전시켜주는 과정
   • KITTI의 카메라 4대가 스테레오 카메라처럼 일렬로 배치되어 있는데 스테레오 연산을 위해서는 이 카메라들이 동일한 world 평면에서 정렬되어 있어야하기 때문이다
3. 카메라의 이미지 좌표로 변환
   • $P2 * R0_rect * Tr_velo_to_cam * (X, Y, Z, 1)$
4. 결과 $(x, y, 1)$
   • 결과 이미지 좌표로 (x, y, z)가 나오는데 이때 z는 1이기 때문에 $x = x/z, y = y/z$ 계산을 수행한다

• 계산을 수행할 때 행렬의 크기를 고려해야한다. 3x4 행렬의 경우 (0,0,0,1)을 추가하여 4x4 행렬로 변환한 후 사용하여도 되고 아니면 3x1 좌표를 4x1로 변환하여 계산해도 된다

3. LiDAR data 시각화하기

3-1. Open3D 라이브러리

def visualization_open3d(data):
    pcd = open3d.geometry.PointCloud()
    pcd.points = open3d.utility.Vector3dVector(data[:, :3])
    open3d.visualization.draw_geometries([pcd])

file_name = '000000'
velo_file = f'./data_object_velodyne/training/velodyne/{file_name}.bin'

with open(velo_file, 'rb') as f:
    data = np.fromfile(f, dtype=np.float32).reshape(-1,4)

visualization_open3d(data)

3-2. Mayavi 라이브러리

def visualization_mayavi(data):
    x = data[:, 0]
    y = data[:, 1]
    z = data[:, 2]

    mlab.figure(bgcolor=(0, 0, 0))
    mlab.points3d(x, y, z, color=(0, 1, 0), mode='point') 
    # mlab.axes() 
    mlab.show()
file_name = '000000'
velo_file = f'./data_object_velodyne/training/velodyne/{file_name}.bin'

with open(velo_file, 'rb') as f:
    data = np.fromfile(f, dtype=np.float32).reshape(-1,4)

visualization_mayavi(data)

4. projection 구현

4-1. calib 파일 불러오기

• projection 행렬들 중에서는 P2만 필요하기 때문에 4개의 projection 행렬 중에 P2만 가져온다

def read_calib_file(file_path):
    with open(file_path, 'r') as f:
        lines = f.readlines()

    P2 = np.array([float(i) for i in lines[2].split(' ')[1:]]).reshape(3,4)
    R0_rect = np.array([float(i) for i in lines[4].split(' ')[1:]]).reshape(3,3)
    Tr_velo_to_cam = np.array([float(i) for i in lines[5].split(' ')[1:]]).reshape(3,4)

    return P2, R0_rect, Tr_velo_to_cam

4-2. projection한 좌표 구하기

• [z>0] 을 하는 이유는 depth가 양수인 것만 투영하도록 하기 위해서이다. depth가 음수인 경우는 뒷쪽 lidar 데이터이기 때문이다

file_name = '000000'
calib_file = f'./calib/training/calib/{file_name}.txt'
image_file = f'./data_object_image_2/training/image_2/{file_name}.png'
velo_file = f'./data_object_velodyne/training/velodyne/{file_name}.bin' #lidar 파일

P2, R0_rect, Tr_velo_to_cam = read_calib_file(calib_file)

R0 = np.eye(4)
R0[:3, :3] = R0_rect #3x3 행렬인 R0_rect을 4x4 행렬로 변환
Tr = np.vstack([Tr_velo_to_cam, [0,0,0,1]]) #3x4 행렬인 Tr_velo_to_cam를 4x4 행렬로 변환

#lidar 데이터 불러오기
with open(velo_file, 'rb') as f:
    data = np.fromfile(f, dtype=np.float32).reshape(-1,4)

XYZ1 = np.vstack([data[:,:3].T, np.ones((1, data.shape[0]))])

xyz = np.dot(P2,np.dot(R0,np.dot(Tr, XYZ1))) 
z = xyz[2, :]
x = (xyz[0, :] / z).astype(np.int32)[z>0] 
y = (xyz[1, :] / z).astype(np.int32)[z>0]

4-3. 시각화하기

image, LiDAR

def visualization_plt(image_file, data, x, y):
    img = cv2.imread(image_file)
    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    aspect_ratio = float(img.shape[1]) / img.shape[0]

    fig, axs = plt.subplots(1, 2, figsize=(20, 25 ))

    axs[0].imshow(img_rgb)
    axs[0].axis('off') 

    x_values = data[:, 0]

    x_min, x_max = np.percentile(x_values, 1), np.percentile(x_values, 99) 

    scatter = axs[1].scatter(x, img.shape[0] - y, c=x_values, cmap='jet', marker='.', s=15, vmin=x_min, vmax=x_max)
    axs[1].set_xlim([0, img.shape[1]])
    axs[1].set_ylim([0, img.shape[0]])
    axs[1].axis('off')

    for ax in axs:
        ax.set_aspect(aspect_ratio)

    plt.tight_layout()
    plt.show()

LiDAR 데이터를 이미지 위로 시각화하였다

def visualization_projection(image_file, data, x, y):
    img = cv2.imread(image_file)
    img_mapped = img.copy()
    img_h, img_w = img.shape[:2]

    # 거리에 따라 color값을 다르게 주기 위한 부분
    x_normalized = (data[:, 0] - np.min(data[:, 0])) / (np.max(data[:, 0]) - np.min(data[:, 0]))
    colors = plt.cm.magma(x_normalized)

    for i, (ix, iy) in enumerate(zip(x, y)):
        if 0 <= ix < img_w and 0 <= iy < img_h:
            color = (colors[i] * 255).astype(np.uint8)[:3]
            color = (int(color[2]), int(color[1]), int(color[0]))
            cv2.circle(img_mapped, (ix, iy), radius=1, color=color, thickness=2)

    img_mapped_rgb = cv2.cvtColor(img_mapped, cv2.COLOR_BGR2RGB)

    plt.imshow(img_mapped_rgb)
    plt.show()

reference

https://www.cvlibs.net/datasets/kitti/setup.php https://darkpgmr.tistory.com/190

docker 환경에서 open3d를 시각화하려고 하면 아래와 같은 에러가 발생한다

GLFWError: X11: Failed to open display :0
Fail to initialize GLFW
Failed creating OpenGL window.

해결

• docker container를 만들 때 -e DISPLAY=$DISPLAY 와 -v /tmp/.X11-unix:/tmp/.X11-unix 옵션을 추가해야한다
  • e DISPLAY=$DISPLAY : display 환경 설정
  • v /tmp/.X11-unix:/tmp/.X11-unix : host의 x window 연결
• 그리고 container를 시작하기 전에 xhost + 를 해주어야한다
• 만약 위의 옵션을 다 추가해서 container를 생성하였는데도 에러가 발생하였다면 xhost + 를 다시 해보면 된다

$ xhost +
$ docker run -it --net=host --ipc=host -v /home/nahye/dev_practice/:/workspace -v /tmp/.X11-unix:/tmp/.X11-unix --device=/dev/video0:/dev/video0 -e DISPLAY=$DISPLAY --env QT_X11_NO_MITSHM=1 --name "torch_gui" pytorch/pytorch /bin/bash

• 해결되면 아래와 같이 시각화를 할 수 있다!!

용량 증설 전 상태

• $ df -h로 용량을 확인해보면 dev/nvme0n1p1의 avail 용량이 얼마남지 않은 것을 확인할 수 있다

용량 증설 방법

1. AWS 콘솔에서 볼륨 증설

• EC2 > 인스턴스 > 스토리지 에서 볼륨 크기를 확인 후 볼륨 ID 클릭

• 원하는 볼륨 선택 후 오른쪽 위의 작업에서 볼륨 수정 클릭

• 원하는 크기를 입력 후 수정 클릭

2. 인스턴스 접속 후 증설 적용

• AWS 콘솔에서 볼륨을 증설하여도 바로 적용되지 않는다
• 아래와 같이 증설이 되었지만 dev/nvme0n1p1는 여전히 45G로 늘지 않은 것을 확인할 수 있다

• 아래의 두 명령어를 통해 원하는 파티션에 연결하면 된다

  $ sudo growpart 용량_늘어난_파티션 1
  $ sudo resize2fs 적용할_파티션

용량 증설 후

dev/nvme0n1p1가 200G로 증가된 것을 확인할 수 있다

• KITTI dataset을 사용한다 (KITTI homepage)
• KITTI > object > 3d object 에서 아래 3개를 다운받는다
  • left color images of object data set (12 GB) : 2d 이미지 데이터
  • Velodyne point clouds (29 GB) : 3d LiDAR 데이터
  • training labels of object data set (5 MB) : 데이터 라벨링 값
  • camera calibration matrices of object data set (16 MB) : 카메라 calibraion 정보

2. Object Detection 모델

2-1. 2D Object Detection (YOLO v7)

• yolov7 github
• 2D 이미지에서 객체를 인식하기 위해 yolo v7 모델을 사용한다
• yolo v7 모델도 다양한 버전이 있는데 기존 버전을 사용하기로 결정했다
• 실시간 FPS와 성능을 고려하여 선택하였다

2-2. 3D Object Detection (CenterPoint)

• centerpoint-kitti github
• LiDAR의 3D 데이터 즉, point cloud 에서 객체를 인식하기 위해 centerpoint 모델을 사용한다

• class : ['Car', 'Pedestrian', 'Cyclist'] 3종류
• centerpoint.yaml 모델, pv_rcnn.yaml 모델 2종류로 각각 학습을 진행하였다
  • 결과를 확인할 때 해당 파일의 POST_PROCESSING > SCORE_THRESH 값을 바꿔주며 결과 이미지를 확인했다 (해당 부분이

3. KITTI format을 YOLO format으로 변환하기

KITTI format

• (class_type, truncated, occluded, alpha, bbox_xmin, bbox_ymin, bbox_xmax, bbox_ymax, dimension_height, dimension_width, dimension_length, location_x, location_y, location_z, rotation) 형식으로 되어 있다

• 예시

  Car 0.00 0 -1.59 553.89 184.63 598.47 220.55 1.26 1.60 3.56 -1.39 1.73 27.81 -1.64
  Car 0.00 0 -1.49 502.27 183.99 537.52 210.78 1.37 1.63 3.57 -4.95 2.00 39.72 -1.61
  Car 0.00 0 2.52 837.66 190.04 921.14 223.55 1.38 1.35 3.30 11.95 2.18 32.11 2.87
  Car 0.00 0 2.24 955.63 189.82 1046.94 226.08 1.59 1.73 4.02 18.79 2.44 34.70 2.73
  Van 0.00 2 -1.61 560.17 165.84 585.44 198.47 2.26 1.64 5.20 -2.79 1.81 52.88 -1.66
  DontCare -1 -1 -10 486.65 171.90 546.07 186.53 -1 -1 -1 -1000 -1000 -1000 -10

YOLO format

• (class_id, center_x, center_y, width, height) 형식으로 되어있다
• bounding box를 의미하는 center_x, center_y, width, height는 0 ~ 1 사이의 값으로 normalized 되어있다
• normalized는 이미지의 width, height로 나누어 수행한다

변환하기

• KITTI의 class_type, bbox 정보 4개만 가지고 와서 YOLO 형식으로 변환한다
• string으로 되어 있는 class_type을 int 형식으로 변환하고 bbox도 YOLO에 맞게 변환한다

def xyxy2xywh_np(bbox, img_width, img_height):
    min_x, min_y, max_x, max_y = np.array(bbox, dtype=np.float32)

    center_x = round((max_x + min_x) / 2,2)
    center_y = round((max_y + min_y) / 2,2)
    bbox_width = round(max_x - min_x,2)
    bbox_height = round(max_y - min_y,2)

    yolo_x = center_x / img_width
    yolo_y = center_y / img_height
    yolo_width = bbox_width / img_width
    yolo_height = bbox_height / img_height

    bbox = (yolo_x, yolo_y, yolo_width, yolo_height)

    return bbox

class convert2yolo():
    def __init__(self):
        self.label_dir = "./kitti_labels/val/"
        self.img_dir = "./images/"
        self.img_train_dir = self.img_dir + "val/"
        # self.img_valid_dir = self.img_dir + "valid/"
        self.output_dir = "./labels/val/"

        self.class_names = {
                        'Car' : 0, 
                        'Van' : 1, 
                        'Truck' : 2,
                        'Pedestrian' : 3, 
                        'Person_sitting' : 4, 
                        'Cyclist' : 5, 
                        'Tram' : 6,
                        'Misc' : 7,
                        'DontCare' : 8
                    }

        self.label_dir_list = glob(self.label_dir + "/*")
        os.makedirs(self.output_dir, exist_ok=True)

    def save(self):
        for file in self.label_dir_list:
            img_path = file.split('/')[-1].split('.')[0]
            img_name = self.img_train_dir + img_path + ".png"
            img = cv2.imread(img_name, cv2.IMREAD_ANYCOLOR)
            img_width = img.shape[1]
            img_height = img.shape[0]

            yolo_file = open(self.output_dir + file.split("/")[-1],"w+")
            with open(file, 'r', encoding='UTF-8') as f:
                lines = f.readlines()
                for line in lines:
                    line = line.split(' ')
                    class_id = self.class_names[line[0]]
                    cx, cy, w, h = xyxy2xywh_np(line[4:8], img_width, img_height)
                    yolo_file.write(f"{class_id} {cx} {cy} {w} {h}\n")
            f.close()
            yolo_file.close()


if __name__ == "__main__":
    convert = convert2yolo()
    convert.save()

4. YOLO v7 학습하기

4-0. 프로젝트 환경

• AWS EC2 G5
  • GPU 1, 24GB memory
  • 용량 : 45GB
• ubuntu 18.04
• pytorch

4-1. yolo v7 다운 받기

$ https://github.com/WongKinYiu/yolov7.git

4-2. docker container 생성

$ docker run -it --ipc=host --gpus all -v /home/ubuntu/yolov7/:/workspace/yolov7 -v /home/ubuntu/KITTI/:/workspace/KITTI -p 8888:8888 --name yolov7 nvcr.io/nvidia/pytorch:21.12-py3

4-3. dataset 구조 설정

📦KITTI ┣ 📂images ┃ ┣ 📂train ┃ ┣ 📂val ┃ ┗ 📂test ┣ 📂labels ┃ ┣ 📂train ┃ ┗ 📂val ┣ 📜train.txt : 전체 경로를 포함한 이미지 경로 리스트 ┣ 📜val.txt ┗ 📜test.txt

• 이미지 경로 리스트 만드는 방법

  # ls | while read file; do echo "$(pwd)/$file"; done > ../train.txt

4-4. 환경 설정

• container 내부에 yolo v7을 위한 환경을 설정한다

  # apt update
  # apt install -y zip htop screen libgl1-mesa-glx
  

pip install seaborn thop

cd /yolov7

pip install -r requirements.txt

### 4-5. 코드 수정 
- coco.yaml 파일에서 경로, class 관련 내용 변경
```yaml
train : /workspace/KITTI/train.txt
val : /workspace/KITTI/val.txt
test : /workspace/KITTI/test.txt

# number of classes
nc: 9

# class names
names: ['Car', 'Van', 'Truck', 'Pedestrian', 'Person_sitting', 'Cyclist', 'Tram', 'Misc', 'DontCare']

• yolov7.yaml 파일에도 class 수 변경
• train.py 파일에서도 class 수와 관련된 내용 변경

4-6. train

• 아래의 명령어로 학습 시작!

  python train.py --workers 8 --device 0 --batch-size 16 --data data/coco.yaml --img 640 640 --cfg cfg/training/yolov7.yaml --weights '' --name yolov7 --hyp data/hyp.scratch.p5.yaml

max_split_size_mb 에러

• gpu out of memory 에러가 발생했다
• 원래 batch-size가 32였는데 이를 16으로 줄이니까 해결되었다

4-7. inference

# python detect.py --weight ./runs/train/yolov7/weights/best.pt --conf 0.25 --img-size 640 --source /workspace/KITTI/images/test/000002.png

5. Object Detection 결과

5-1. camera image 2D Object Detection

5-2. LiDAR cloud point 3D Object Detection

• threshold를 0.4로 설정
• 아래의 이미지는 2D 이미지와 매칭을 해보았다

오류

cannot connect to the docker daemon at unix:///var/run/docker.sock. is the docker daemon running?

• docker ps -a 또는 docker image ls 등 docker를 확인하려고 하자 docker를 실행할 수 없다는 에러가 발생했다

원인

• docker service가 꺼져있기 때문이다
• $ sudo systemctl status docker를 실행하면 fail 상태인 것을 확인할 수 있다

해결

• 아래의 명령어로 다시 실행시켜주면 해결된다

  $ sudo systemctl start docker
  $ sudo systemctl enable docker

AWS에서 center point 환경설정을 드디어 성공했다!! 환경 설정이 이렇게 어렵고 오래 걸릴줄 몰랐다... 지나고보면 간단한 거였지만 그 당시에는 에러를 찾아보고 원인이 무엇인지 찾는 과정에 시간이 오래 걸린 것 같다. 환경 설정을 마무리 했으니 train 학습을 돌릴때도 용량 에러가 발생해서 해결하는에 오래걸렸다. 알고보니 container를 생성할 때 옵션을 주었어야했다.

인스턴스를 팀원들과 공유해서 같이 사용하는데 인스턴스의 용량이 부족해서 설치가 안된다는 에러가 계속 발생했다... 사실 이런 문제들은 local에서 각자 진행할 때는 발생하지 않는 문제인데 AWS로 동시에 사용하니 발생하는 것 같다. 이런 문제들도 해결해가는 과정에서 많은 경험이 쌓이는 것 같긴하다. 결국 용량 문제는 제대로 해결하지 못했다.. 내일 다시 찾아서 해결해봐야할 것 같다.

일단 train을 실행해놓고 자러가야겠다. 밤새 학습이 잘 되기를!!

🧬딥러닝 프로젝트 과정 및 어려웠던 점

환경 변수 설정

• center point와 nuscenes-devkit과 관련한 환경변수를 설정해주지 않았었다
• 그랬더니 에러가 발생하여 환경변수를 설정해주었다
• bashrc에 내용들을 저장하여 다시 접속했을 때도 적용이 되도록 설정했다

spconv 에러

• center point의 github에서 알려준 spconv 설치 방법대로 spconv 설치를 수행했었다
• 이때 cmake 에러, torch::jit::RegisterOperators 에러, cout 에러 등 많은 에러가 발생했다
• 이 에러들은 코드를 수정하고 git clone을 받아오는 등의 해결 방법으로 해결하였다
• 하지만 !!more than one operator "==",">" matches these operands 에러가 발생했고... 여러 방법들을 다 적용해보았지만 해결이 안되었다

• 결국 spconv에 관해 찾아보다가 단순히 # pip install spconv-cu114 명령어로 spconv를 설치할 수 있다는 것을 알게 되었고 이 방법으로 간단히 spconv를 설치할 수 있었다

• 앞으로 어떤 라이브러리를 설치할 때에는 단순히 다른 사람이 알려주는 설치 방법을 따르는 것보다 그 라이브러리를 먼저 찾아보는 습관을 들여야겠다

용량 부족 에러

shared memory (shm) 에러

• 모델 학습을 시작할 때 shared memory (shm) 에러가 발생하였다
• 이는 host와 IPC 네임스페이스를 공유하도록 설정하면 된다
• 하지만 이 방법은 container를 생성할 때 옵션으로 지정해줘야 하기 때문에 container를 다시 생성하고 환경 설정도 다시 해주어야 했다

no space left on device

• no space left on device라는 에러가 발생했다
• 인스턴스의 용량이 부족하다는 에러였다
• 팀원들이 같이 사용하고 있고 데이터셋도 용량이 커서 발생하는 문제 같았다

• 용량을 확인해 보았고 overlay가 가장 많은 용량을 차지하고 있었다
• overlay를 찾아보니 이걸 삭제하면 쓸데없는 container를 지울 수 있다고 해서 삭제를 진행하였다
• 그런데! up 상태인 container는 사라지지 않았지만 종료된 container는 다 사라졌다..!
• 결국 다시 container를 만드니 용량이 부족하다는 에러가 다시 발생하였다

• opt/conda 폴더를 제거하였다
• 이 폴더에는 conda 등의 여러 파일들이 있는데 현재 인스턴스에서는 필요하지 않기 때문에 삭제해도 아무런 문제가 없었다

• 하지만... 그 이후에도 용량 에러가 계속 발생했다
• 환경상 인스턴스의 용량을 늘릴 수 없어서 문제를 해결할 수 없었다...
• 결국 팀원과 같은 container를 사용하여 하나의 container만 남기고 다 삭제한 후 프로젝트를 진행해야했다

딥러닝 프로젝트를 시작했다!! 이번주는 온라인으로 진행하고 다음주부터 오프라인으로 진행한다. 딥러닝보다 AWS를 사용해보는게 기대가 되었다. 객체 인식 딥러닝을 진행하는데 nuScene 데이터로 center point 모델을 사용하여 학습하는 프로젝트이다.

처음에는 local에서 모델을 사용해보려고 했다. 하지만 환경 설정하는 중에 에러가 났다. 알고 보니 CUDA가 필수인데 local 환경에는 GPU가 없어서 발생하는 에러였다. 그래서 팀원들과 AWS 인스턴스를 만들고 docker로 환경설정을 진행했다. 오늘 환경설정을 다 하지는 못했다ㅠㅠ 에러가 너무 많이 나고 그 이유를 찾기 힘들어서 오래걸렸다... AWS를 처음 사용해봐서 인스턴스 만들고 사용하는 것부터 쉽지 않았다. docker 환경설정을 오늘 다 끝내기 못했다ㅠㅠ 내일 이어서 해야겠다!!

🧬 딥러닝 프로젝트 과정 및 어려웠던 점

Center Point 환경 설정하기

• 결국... local은 GPU가 없어서 환경을 설정하지 못하였다. AWS에서 docker로 환경 설정을 해야한다
• 발생하는 에러들을 하나씩 해결하며 환경 설정을 하려고 시도하였다
• 하지만 CUDA가 없어서 발생하는 에러였고 AWS로 진행해야한다는 것을 알게 되었다

AWS 인스턴스 만들기

• AWS를 처음 사용해봐서 인스턴스를 만드는 것부터 생소했다

1. IAM에서 MFA 인증하기
2. 원하는 Image 선택하기 : GPU + pytorch + ubuntu 18.04를 선택했다
3. 인스턴스 유형 선택 : g5.xlarge
4. key pair 설정
5. 인스턴스 시작

• 그 후에는 ssh로 연결하면 된다

docker container 생성 & 환경 설정

docker run -it --gpus all -v [host 경로]:[container 경로] -p 8888:8888 --name [container명] [image명] /bin/bash

• 위의 명령어로 docker container를 생성했다
• --gpus all 이 옵션을 넣어야 gpu를 사용할 수 있다
• center point를 설치하고 필요한 라이브러리도 설치했다
• nuscenes-devkit 설치를 진행했다
• APEX 설치를 진행하면서 에러가 많이 발생했는데 알고보니 docker image에 포함되어 있어서 설치할 필요가 없었다

• Light Detection And Ranging
• 빛을 탐지하고 범위를 측정하는 센서
• RADAR(RAdio Detection And Ranging)에서 사용하는 전파 (radio)를 빛(light)로 변경한 센서
• point cloud : LiDAR data

1-1. LiDAR 종류

1. single point distance sensor -> 레이저 포인터와 같은 점
2. 2D Scanners -> 강의장에서 사용하는 LiDAR (x, y)
3. 3D Scanners
4. Non-Repeating Pattern Scanners -> 원이 아닌 복잡하고 비반복적인 패턴을 사용한다

2D LiDAR와 3D LiDAR의 차이

• 센서의 채널 수가 다르다
• 2D LiDAR : 1개의 채널, (N, 2)
• 3D LiDAR : N개의 채널, (N, 3), 채널 수에 따라 객체의 입체적인 데이터를 가진다

1-2. LiDAR 센서의 측정 원리

• 빛이 반사된 거리를 측정한다
• 빛의 속도와 반사된 시간을 곱하여 거리를 측정할 수 있다

1-3. LiDAR Parsing

• LiDAR는 반사된 객체와의 직선 거리를 반환하기 때문에 반사된 포인트의 위치를 파악하기 위해서는 별도의 계산이 필요하다
• 거리($d$)와 빛의 각도($\alpha, \beta, \gamma$)를 알 수 있기 때문에 이를 활용하여 위치를 계산한다

• LiDAR 센서마다 방법이 다르다
• 센서마다 제공하는 데이터가 다르기 때문에 반드시 공식 문서를 참고한다
• 센서의 SDK를 제공하는 경우도 있다

Velodyne VLP-16 LiDAR

• 16 채널(layer)를 가지고 있다
• Laser ID를 layer라고 한다
• R값(거리)값들을 받을 후 $\omega$와 $\alpha$를 계산한다
• 그 후 공식을 사용하여 위치를 추정한다

2. LiDAR 종류

2-1. 3D LiDAR

• N개의 채널을 만드는 방법에 따라 다양한 구조를 가지고 있다

Mechanical 3D Spinning LiDAR

• 발광부와 수신부가 직접 회전하는 방식

• 장점 : 360도 회전이 가능하다
• 단점
  • 발광부와 수신부의 개수에 따라 채널이 제한되고 크기가 커진다
  • 진동에 의한 내구성이 약하다

• 오른쪽 이미지는 128 채널의 LiDAR

Solid-State LiDAR

• 특정한 반사물질을 이용한다
• 주로 거울이 사용된다
• 두번째 반사물질이 여러 각도로 빛을 퍼지게 만들어주어 여러 채널을 갖는 효과를 만들어준다

• 장점
  • single-Laser로도 N개의 채널을 표현할 수 있다
  • 따라서 가격이 비교적 저렴
• 단점
  • 복잡한 동작 방식
  • 매우 높은 Hz (~160Hz)
  • 그에 따른 내구성 문제가 존재한다

MEMS LiDAR

• 반사물질이 상/하, 좌/우 반복운동을 하고 N개의 Laser를 사용할 수 있어 데이터 취득에 더욱 용이하다
• Solid-state LiDAR와 비슷하지만 두번째 반사물질을 제거한 형태이다
• 따라서 반사물질을 개수를 줄일 수 있었다

• 장점 : single-laser로도 N개의 채널을 표현할 수 있다
• 단점
  • 높은 제작 난이도
  • 매우 높은 Hz(~800Hz) : 하나의 laser로 여러 채널을 표현해야하기 때문에 그만큼 빨리 움직여야한다
  • 그에 따른 내구성 문제가 존재한다

그 외의 LiDAR

• 복합적인 요소를 사용하는 LiDAR도 존재한다
• 왼쪽 LiDAR (L)
  • 고정형 발광 & 수신부 : 이전까지는 한줄로 이루어져있었지만 이 방법은 2D array에 해당하는 형식으로 이루어져있다
  • mirror 회전 방식
  • 낮은 Hz (빛이 면으로 발광하기 때문에)로도 넓은 FoV 확보 가능
• 오른쪽 LiDAR (R)
  • non-repeating pattern scanners 방식
  • 비반복적인 패턴을 사용해서 낮은 laser로도 매우 높은 채널을 만들어내는 방법이다
  • 최근에는 이 방법이 많이 사용되는 것 같다
  • 반복적 방법의 문제점 : layer들이 고정되어 있기 때문에 먼 거리에서 레이저 사이에 있는 물체는 검출하지 못하는 경우가 발생할 수 있었다

3. LiDAR와 RADAR의 차이

	LiDAR	RADAR
활용 소재	레이저 (light)	전자파 (radio)
형체 인식 정도	가능	정확한 인식 불가능
외부 환경에 대한 영향 (눈, 비)	있음	없음
가격	고가	저가

주행 코스

목표

• 목표1 : 객체를 인식하여 자율주행
  • 모든 차량은 출발지점의 정지선에서 신호 대기 -> 정지선 인식
  • 신호등의 출발 신호에 맞춰 출발 -> 신호등 인식
  • 제시되는 표지판의 내용대로 정지, 좌, 우 조향 제어 -> 표지판 인식
  • 동적 장애물은 갑작스레 등장할 예정 -> LiDAR를 사용하여 장애물 인식

• 목표2 : 차량주변의 객체 위치정보를 Bird’s Eye View로 표현
  • 트랙을 주행하며 주변 객체의 정보를 인식 -> object detection
  • BEV에 객체 정보 표현
  • 객체는 2D로 X,Y 좌표만 표현 (Point로 표현) -> depth 추정

점수 산정 기준

• 합산한 과태료가 가장 적은 팀이 우승이다

전체 알고리즘

1. LiDAR로 장애물 인식

• 갑자기 튀어나오는 장애물이나 차선 안에 주차되어 있는 차량 장애물을 인식하는 것은 다른 것들에 비해 가장 우선으로 인식되어야 한다
• 2가지 상황에 따른 대처
  • 갑자기 튀어나오는 장애물 -> 정지
  • 차선 안에 주차되어 있는 차량 -> 회피 주행

LiDAR 알고리즘

• LiDAR의 앞쪽 60도를 인식하여 차량 장애물과 돌발 장애물 인식
• 차량 장애물의 경우
  • 오른쪽 30도의 LiDAR 값이 0.4보다 작은 값의 개수가 10개 이상이면 물체가 있다고 판단하여 회피 주행
  • 왼쪽 30도의 LiDAR 값이 0.4보다 작은 값의 개수가 10개 이상이면 물체가 있다고 판단하여 회피 주행
• 돌발 장애물의 경우
  • 왼쪽, 오른쪽의 총 60도의 l값이 0.4보다 작은 값의 개수가 40개 이상이면 앞쪽에 물체가 있다고 판단하여 정지

2. 정지선 인식

• 정지선을 인식하면 3초 정지하였다가 출발
• 강제로 0.5초 동안 주행하도록 설정하였다. 이렇게 하지 않으면 그 다음 프레임에서도 정지선이 인식되어 계속 멈춰있기 때문이다

• 표지판이 감지되지 않을 경우에만 정지선 인식으로 판단한다
• 표지판이 있을 경우, 해당 표지판에 따라 행동해야하기 때문이다

정지선 인식 방법

• 차선을 인식하는 ROI 부분에서 검출된 직선이 평행에 가까울 때 정지선이라고 판단
• 기울기가 0.02보다 작고 그 선의 길이가 160보다 클 때 정지선이라고 판단

3. Object(표지판, 신호등, 차) 인식

• YOLO v7 모델로 예측한 object의 id와 bounding box 정보를 메세지로 받는다
• 추가로 계산한 depth도 메세지로 같이 받는다
• 이 메세지를 활용하여 어떤 object인지 자이카와의 거리가 어떤지를 파악하여 object에 맞는 알고리즘을 지정해주었다

• 신호등 (red light, green light, yellow light)
  • 초록불 : 전진
  • 빨간불 : 정지 (초록불이 들어올 때까지 정지)
• 정지 표지판 (stop)
  • 3초 정지 후 전진
• 횡단보도 표지판 (crosswalk)
  • 3초 정지 후 전진
• 오른쪽 표지판 (right)
  • 2초 동안 오른쪽으로 회전 후 전진
• 왼쪽 표지판 (left)
  • 2초 동안 왼쪽으로 회전 후 전진

4. default

• 기본적으로 위와 같은 상황이 아니라면 차선을 인식하여 주행

결과 성적

• 최종 2등을 하였다!!
• 차선을 한번 이탈하고, 돌발 장애물과 충돌하여 최종 과태료가 6만원이 나왔다

어려웠던 점

교차로 구간

차선이 안보이는 문제

• 교차로 구간에는 차선이 없는 부분이 많고 회전시 차선이 안보이는 문제도 같이 발생하기 때문에 어려웠다
• 2초 또는 3초 동안 회전하도록 지정해주었다
• 추후에 칼만 필터를 적용하여 현재 자신의 위치를 파악하고 그에 맞도록 주행하도록 개선하고 싶다
• 또한 시간 문제를 해결하면서 지속적으로 프레임을 받아 올 수 있기 때문에 차선이 보일 때까지 강제로 회전하고 차선이 보인다면 차선 주행을 하는 방법으로도 수정하고 싶다

표지판의 위치

• 표지판의 위치가 차선의 오른쪽 또는 왼쪽에 위치하는 경우도 있고 차선 앞쪽에 위치하는 경우도 있었다
• 이 경우에는 depth가 다르게 추정되기 때문에 depth에 조건을 주는 것이 어려웠다
• 따라서 표지판이 앞에 있는 경우로 판단되면 depth을 조금 늘려주는 방법을 통해 해결하였다

시간 관련 문제

• 몇 초 동안 회전하고 주행하도록 설정하였는데 이때 시간을 계산하는 함수를 처음에 ctime의 time()을 사용하였다
• 하지만 time() 함수는 1초 단위로밖에 조절할 수가 없고 그 사이에 sleep(1)을 사용하였더니 sleep되는 동안 다른 알고리즘은 멈춰버리는 문제가 있었다
• 이를 ctime의 clock()으로 바꾸니 문제가 해결되었다

하드웨어 문제

자이카 바퀴

• 오른쪽으로 회전할 때 바퀴가 최대로 꺾이지 않는 문제가 있어서 우회전을 할 때 제대로 회전하지 못하였다
• 또한 좌회전과 우회전의 정도가 달랐기 때문에 이를 맞추는 과정이 어려웠다
• 하드웨어 문제는 바로 해결할 수 없었기 때문에 좌회전의 각도를 최대 50이 아닌 조금 더 낮은 값으로 설정하여 양쪽의 비율을 맞춰주었다

라이다

• 라이다에서 앞의 오른쪽 값이 제대로 들어오지 않았다
• 이는 더 확인을 해봐야하는 문제지만 반대인 왼쪽은 값이 잘 들어오는데 오른쪽은 잘 들어오지 않아서 돌발 장애물과 차량 장애물을 회피하는 부분이 아쉬웠다

향후 하고 싶은 작업

• 칼만 필터를 적용하여 차선이 보이지 않을 때 발생하는 문제를 해결하고 싶다
• 표지판의 위치에 따라 depth를 다르게 계산하여 더 정확한 depth를 구하고 싶다
• 전체적인 코드를 깔끔하게 작성하고 싶다
• 라이다의 정확도를 높이고 싶다

• object와 자이카와의 depth를 추정하여 즉, 거리를 추정하여 추후에 자이카를 제어한다
• depth를 추정하는 방법에는 크게 3가지가 있는데 여기에서는 homography를 사용하는 방법을 선택했다
• 그 이유은 homography 방법은 간단하지만 지면이 평평한 경우에만 사용할 수 있는데 프로젝트 환경은 평평한 바닥이기 때문에 이 방법을 선택하였다

homography

• 간단하게 정리를 하자면 homography는 두 평면 간의 변환 관계를 의미한다
• 최소 4짱의 좌표값을 알면 homography matrix를 구할 수 있다

• 이 경우에는 바닥 평면과 카메라 이미지 평면 간의 관계를 구하는 것이다

Depth 추정 과정

1. world 좌표와 image 좌표쌍 구하기

• 최소 4쌍 이상의 좌표쌍이 필요한데 많을수록 정확한 homography matrix를 구할 수 있기 때문에 많은 좌표쌍을 구했다
• 최대한 멀리, 넓게 좌표쌍을 정해야 정확한 값을 얻을 수 있다

• 바닥 평면의 원하는 지점에 블록을 놓고 이미지를 촬영한다
• 이렇게 하는 이유는 바닥 평면의 grid 선이 이미지 상에서 뚜렷하게 보이지 않기 때문에 원하는 좌표쌍을 얻기 위해 잘 보이는 블록을 놓아서 이미지를 획득하였다
• 이때 자이카를 원하는 지점에 놓고 그 지점부터 블록까지의 거리를 알고 있어야한다
• 이 경우에서는 자이카의 가장 앞 부분을 (270, 540) 좌표에 맞춰서 놓고 이미지를 획득하였다

• 바닥 평면의 한 grid의 실제 크기는 45cm이다
• 하지만 조금 더 넓은 평면으로 변환을 하고 싶었기 때문에 90으로 조정하였다
• 아래 오른쪽 이미지를 보면 검은색 grid는 바닥 평면을 의미하고 빨간색 좌표는 카메라에서 획득한 이미지 상에서의 좌표를 의미한다

• world 좌표는 (x, y, 1) 과 같이 homography 좌표로 표현해야하고, image 좌표는 (x, y) 로 표현해야한다

  # x, y, 1
  homo_3d_points = numpy.array([
    [270, 0, 1],
    [180, 90, 1],
    [270, 90, 1],
    [360, 90, 1],
    [180, 180, 1],
    [270, 180, 1],
    [360, 180, 1],
    [180, 270, 1],
    [270, 270, 1],
    [360, 270, 1],
    [180, 360, 1],
    [270, 360, 1],
    [360, 360, 1],
    [180, 450, 1],
    [270, 450, 1],
    [360, 450, 1],
    [90,180, 1],
    [450,180, 1]
  ], dtype=numpy.float32)
  

x, y

homo_points = numpy.array([ [319, 256], [255, 260], [319,260], [386,260], [241, 265], [321, 265], [401,265], [217, 274], [321, 274], [423, 273], [174, 289], [320,289], [469,289], [70,327], [322,325], [571,325], [160,265], [479,265] ], dtype=numpy.float32)

### 2. homography matrix 구하기
- opencv의 `findHomography` 함수를 사용하여 계산한다
- 이때 method 옵션으로 **RANSAC**을 사용하면 outlier로 인한 오차를 줄여줄 수 있다고 한다

homography, _ = cv2.findHomography(homo_points, homo_3d_points, method=cv2.RANSAC)

homography matrix

[[-1.36650485e-01, -1.13733437e+00, 3.12113770e+02], [ 6.53381187e-04, -2.45035619e+00, 6.27102327e+02], [ 3.93808370e-06, -4.24034141e-03, 1.00000000e+00]]

### 3. depth 구하기
#### 3-1. 원하는 object의 좌표 구하기
- 예측한 object의 **bounding box에서의 밑변의 중심 좌표**를 구한다
- 밑변으로 해야하는 이유는 object가 **바닥과 붙어있는 지점**으로 해야지 거리를 구할 수 있기 때문이다
- 여기에서 x0, x1은 bounding box의 min_x, max_x를 의미한다
- y0, y1은 bounding box의 min_y, max_y를 의미한다

```python 
x0 = int(box[0])
y0 = int(box[1])
x1 = int(box[2])
y1 = int(box[3])

center_x = (x0 + x1)/2

3-2. image 좌표를 world 좌표로 변환하기

• 앞에서 구한 homography matrix를 사용하면 image 좌표값을 world 좌표값으로 변환할 수 있다
• image 좌표값을 homography 좌표로 변환하고 내적을 수행하면 x, y, z값이 나온다
• 이때 z값은 1이여야하기 때문에 x, y, z를 z로 나누면 원하는 world 좌표상의 x, y 값을 구할 수 있다

bbox_point = np.array([center_x, box[3], 1])
estimate = np.dot(self.homo_mat, bbox_point)
x, y, z = estimate[0], estimate[1], estimate[2]

depth_x = x/z
depth_y = y/z

3-2. depth 계산하기

• depth는 자이카와 원하는 object와의 거리를 의미한다
• 자이카가 (270,540) 좌표에 위치해 있기 때문에 이 좌표와의 거리를 계산하면 된다
• 방법 1은 두 점 간의 거리를 계산한 것으로 x, y 좌표를 모두 고려한 것이다. 프로젝트 때는 이 방법을 사용하였다
• 방법 2은 y 좌표만 고려한 것이다

# 방법 1
distance = int(np.sqrt(((270 - depth_x)/2)**2 + ((540-depth_y)/2)**2))

# 방법 2
distance = int((540 - depth_y)/2)

Bird-Eye View (BEV) 표현

• Bird-Eye view는 위에서 바라본 것을 의미한다
• 자이카와 그 주변의 object들이 어떻에 위치해있는지 보기 위해 Bird-Eye view로 그 좌표값들을 변환하였다

• 방법 1의 경우 카메라 이미지를 BEV로 변환한 것이다
• 하지만 이 결과는 깔끔해보이지 않기 때문에 방법 2를 선택하였다
• 방법 2의 경우 그냥 검은 이미지를 의미하고 추후에 world 좌표로 표현한 object의 위치를 여기에 나타내 주었다

# 방법 1
bev_img = cv2.warpPerspective(bev_img, self.homo_mat, (540,540))

# 방법 2
bev_img = np.zeros((540, 540, 3), dtype=np.uint8)

# 시각화 
depth_text = '{}:{}'.format(class_names[cls_id], distance)
cv2.circle(bev_img, (int(depth_x), int(depth_y)), 10, color, -1)
cv2.putText(bev_img, depth_text, (int(depth_x), int(depth_y) - 20), font, 1, color, thickness=1)

결과

• 아래쪽 가운데에 자이카가 위치해있다
• object의 위치와 자이카로부터 object 간의 거리를 나타내 주었다