안경쓴 코린이

Object Tracking이란?

• object detection + tracking

MOT의 목적은 연속적인 프레임에서 여러 관심 객체의 궤적을 추정하는 것이다.

Object Detection Model

• 영상에서 관심있는 경계 상자(Bounding Box) 영역의 위치를 추정

Association Model

• 각 경계 상자에 대한 Re-identification(이하 Re-ID) 특징을 추출하여 정의된 특정 메트릭에 따라 기존에 존재하는 트랙 중 하나에 연결시킴
• 장점

      모델이 발전함에 따라 추적 성능이 향상됨

• 단점

      각 모델의 두 단계 끼리 특징을 공유하지 않기 때문에 실시간 성능을 보장할 수 없다는 문제가 있음

• 결론

태스킹 학습 방식이 떠오름에 따라 객체를 탐지하고, Re-ID 특징까지 학습하는 One-Shot 방법을 사용.이러한 One-Shot 방법의 정확도는 Two-step 방법에 비해 현저히 떨어진다는 단점을 갖는다. 그래서 이 두 작업을 결합할 때, "어떠한 트릭"을 사용하여 정확도를 높이는 방식으로 학습해야한다.

• MOT 정확도에 영향을 미치는 세 가지 중요한 요소

     (1) Anchors don't fit Re-ID

현재 one-shot tracker 는 모두 객체 탐지기 기반이기 때문에 anchor 를 기반으로 하고있다. 그러나 anchor 는 Re-ID 특징을 학습하는데 적합하지 않다. 왜냐하면 서로 다른 이미지 패치에 해당하는 multiple anchors 가 동일한 객체의 identity 를 추정할 필요가 있는데, 이로 인해 신경망에 심각한 ambiguity 가 발생 하기 때문이다. 즉, 주변에 다른 객체를 나타내는 여러 anchor 들은 학습 시 모호성을 줄 수 있다. 또한 feature map은 일반적으로 정확도와 속도의 trade off 를 위해 8번씩 down-sampling 된다. 이는 객체 중심이 객체의 identity 를 예측하기 위해 coarse anchor 위치에서 추출된 특징과 align 되지 않을 수 있기 때문에 탐지에는 적합하지만, Re-ID 에는 너무 coarse 하다는 문제점을 가진다. 따라서 high-resolution feature map 의 top 에서 픽셀 방식의 keypoint estimation (object center) 추정 및 identity classification 를 통해 이러한 문제를 해결한다.

    (2) Multi-Layer Feature Aggregation

Re-ID 특징은 small 및 large 객체들을 모두 accommodate 하기 위해 low-level 및 high-level 특징들을 모두 활용해야한다. 본 논문에서는 스케일 변화를 처리하는 능력을 향상 시켜 one-shot 방법 기반으로 identity high-resolution 를 줄였다. two-step 방법의 경우 cropping 및 resizing 작업 후 물체의 스케일이 비슷해진 채로 적용되기 때문에 스케일 문제를 개선 시킬 필요가 없다.

    (3) Dimensionality of the ReID Features

이전의 Re-ID 방법들은 일반적으로 high dimensional feature 들을 학습하고, 벤치마크에서 좋은 결과를 얻어왔다. 하지만 본 논문에서는 Re-ID 보다 학습 이미지가 적기 때문에(Re-ID 데이터 세트는 잘린 이미지 만 제공하기 때문) lower-dimensional feature 가 MOT에 실제로 더 좋다는 사실을 발견하였다. 이러한 lower-dimensional feature 를 사용하면 small data 에 대한 overfitting 을 줄이고, tracking robustness 를 향상 시킬 수 있다.

Model Approach

• Backbone Network

정확도와 속도의 trade-off 를 위하여 ResNet-34 를 백본으로 설정하였다. 다양한 스케일의 객체를 수용하기 위해 Deep Layer Aggregation(DLA)이 백본에 적용된다. original DLA와는 달리, Feature Pyramid Network(FPN) 와 유사한 low-level 및 high-level feature 간에 더 많은 skip connection 이 존재한다. 또한 up-sampling 모듈의 모든 컨볼루션 레이어는 deformable convolution layer 로 대체되어 객체 스케일 및 포즈에 따라 receptive field 를 동적으로 조정할 수 있다. 이러한 변경 사항은 align 문제를 완화 하는데 도움을 줄 수 있다. 이 모델의 이름은 DLA-34 로 정한다. 입력 이미지의 크기를 H x W 라고 하면 output feature map 의 모양은 C x H' x W' 이며, 이 때 H' 는 H/4 이며, W'는 W/4 이다.

• Object Detection Branch

객체 탐지는 high-resolution feature map 에서 center-based 의 bounding box regression task 를 수행한다. 특히 3개의 parallel regression head 가 백본 신경망에 추가되어 각각 heatmap, object center offset, bounding box size 를 추정한다. 각 head 는 3x3 conv(256 channel) 을 백본 신경망의 output feature map에 적용한 다음, final target 을 생성하는 1x1 conv 를 적용하여 구현된다.

• 1. Heatmap Head
  • 이 head 는 객체 중심의 위치를 추정한다. landmark point estimation task 의 표준인 heatmap 기반 representation 이 여기서 사용된다. 특히 heatmap 의 dimension 은 1 x H x W 이다. heatmap 의 위치에 대한 response 는 ground-truth object center 로 붕괴될 경우의 반응으로 예상된다. heatmap 의 위치와 object center 사이의 거리에 따라 response 는 기하 급수적으로 감소한다.

        2. Center Offset

• • head 는 객체를 보다 정확하게 localization 한다. feature map 의 stride 는 non-negligible quantization error 를 유발할 수 있다. 객체 탐지의 성능의 이점은 미미할 수 있으나, Re-ID 의 특징은 정확하게 object center 에 따라 추출되어야 함으로 tracking 에서는 중요하다는 특징을 가진다. 실험에서 Re-ID 의 특징을 object center 와 carefull alignment 하는 것이 성능에 중요하다는 것을 발견하였다.

        3. Box Size Head

• • 이는 각 anchor 위치에서 target bounding box 의 높이와 너비를 추정한다. 이 head 는 Re-ID 특징과는 직접적인 관련이 없지만, localization 정확도는 객체 탐지 성능 평가에 영향을 미친다 ****
• Identity Embedding Branch

identity embedding branch 의 목표는 다른 객체와 구별할 수 있는 특징을 생성하는 것이다. 이상적으로는 서로 다른 객체 사이의 거리가 같은 객체 사이의 거리보다 커야한다. 즉, 같은 객체는 다른 프레임 상에서의 위치가 가까이 붙어있는 편이 이상적이다. 다른 객체와 구별할 수 있는 특징을 생성하기 위해 백본 특징 위에 128개의 커널이 포함된 conv layer 를 적용하여 각 위치에 대한 identity embedding feature 를 추출한다. output feature map 인 E 는 128 x W x H 영역에 포함되며, Re-ID feature 인 x, y 에서의 E 는 128에 속하고, 객체의 x, y 는 feature map 으로부터 추출된다.

• Tracking Algorithm
  1. 칼만필터
     • 칼만은 기존 추적하던 물체의 속도를 반영해서 다음 상황을 예측한다고 생각하면 쉽다.

1. 과거의 값을 이용하여 현재값을 예측하고

2. 예측값과 측정값에 각각 노이즈를 반영한 뒤, 실제값을 예측한다.

3. 이 실제값을 다시 다음 측정에 사용한다.

( p.s 측정값을 그냥 쓰면 되는거 아니냐고 생각할 수 있지만 노이즈라는 개념이 들어가면 (원래 센서퓨전에 쓰려고 만든 알고리즘이므로) 측정값도 100% 신뢰할 수 없다는 것을 알 수 있다. )

• 1. 헝가리안 알고리즘
  • 최소값을 찾아준다
  • pose_dla_dcn.py
  • 
  • demo_track.py

    

    

    • tracker.update(blob, img0) ## 여기서 결과값 반환
    • img0 : frame 이미지
    • blob :  img0에서의 윤관값을 결정한 이후에 메모리의 연속 배열을 반환값을(C 순서) 255.0으로 나눈 값
    • STrack형태로 각각의 detection된 값들과 tracking 결과값이 반환됨

  • 

    • 여기서 숫자 30이 frame 몇 개까지 비교할지 결정 (default buffer size값 30 )
    • embedding_distance 비교

  1. 이전에 나온 track_features와 현 frame의 det_features가지고 cost_matrix를 구현
        2. cost_matrix에서 칼만필터를 적용 후에 자기 자신과의 거리가 먼 박스들의 값을 무한대로 보내버림
        3. 이후에 새로운 id인지 그 이전 id인지 판단하는 과정을 거침



- FairMOT 설치과정

    $ git clone [https://github.com/ifzhang/FairMOT](https://github.com/ifzhang/FairMOT)

    $ conda create -n FairMOT python=3.6.9

    $ pip3 install torch==1.8.1+cu111 torchvision==0.9.1+cu111 torchaudio==0.8.1 -f [https://download.pytorch.org/whl/torch_stable.html](https://download.pytorch.org/whl/torch_stable.html)

    $ cd ${FAIRMOT_ROOT}

    $ pip install cython

    $ pip install -r requirements.txt

    $ git clone [https://github.com/jinfagang/DCNv2_latest](https://github.com/jinfagang/DCNv2_latest)

    $ cd DCNv2_latest

    $ ./make.sh

    ![https://s3-us-west-2.amazonaws.com/secure.notion-static.com/1872adea-92e7-4744-9180-1d661f05349b/Untitled.png](https://s3-us-west-2.amazonaws.com/secure.notion-static.com/1872adea-92e7-4744-9180-1d661f05349b/Untitled.png)

    나머지는 필요한 가중치를 다운받고 터미널이 아닌 파이참에서 돌리려면

    Run>Run/Debug Configurations - Parmeters에서 터미널에서 줘야하는 파라미터들을 직접 적어주면 된다. 그렇게 하지 않으려면 paser에 직접 default값을 수정해주면 됨

Paper : https://arxiv.org/pdf/2004.01888v4.pdf

Github : https://github.com/ifzhang/FairMOT3

1. Introduction

MOT(Multi-Object Tracking)는 컴퓨터 비전 분야에서 longstanding goal 이다. MOT의 목적은 연속적인 프레임에서 여러 관심 객체의 궤적을 추정하는 것이다. 객체의 궤적을 잘 추적하게 되면 Action Recognition, Sport Videos Analysis, Elderly Care, Human Computer Interaction 와 같은 분야에서 널리 응용 될 수 있다.

Object Detection Model

• 영상에서 관심있는 경계 상자(Bounding Box) 영역의 위치를 추정

Association Model

• 각 경계 상자에 대한 Re-identification(이하 Re-ID) 특징을 추출하여 정의된 특정 메트릭에 따라 기존에 존재하는 트랙 중 하나에 연결시킴

이러한 최근의 Object Detection 및 Re-ID 기술들이 발전함에 따라 추적 성능이 향상되고 있지만 이러한 두 단계 끼리 특징을 공유하지 않기 때문에 실시간 성능을 보장할 수 없다는 문제를 가진다. 최근 멀티 태스킹 학습 방식이 떠오름에 따라 객체를 탐지하고, Re-ID 특징까지 학습하는 One-Shot 방법이 나타나기 시작했다. 대부분의 특징이 두 모델에 공유되기 때문에 추론 시간을 크게 줄일 수 있다. 그러나 이러한 One-Shot 방법의 정확도는 Two-step 방법에 비해 현저히 떨어진다는 단점을 갖는다. 그래서 이 두 작업을 결합할 때, "어떠한 트릭"을 사용하여 정확도를 높이는 방식으로 학습해야한다.

MOT 정확도에 영향을 미치는 세 가지 중요한 요소는 다음과 같다.

(1) Anchors don't fit Re-ID

현재 one-shot tracker 는 모두 객체 탐지기 기반이기 때문에 anchor 를 기반으로 하고있다. 그러나 anchor 는 Re-ID 특징을 학습하는데 적합하지 않다. 왜냐하면 서로 다른 이미지 패치에 해당하는 multiple anchors 가 동일한 객체의 identity 를 추정할 필요가 있는데, 이로 인해 신경망에 심각한 ambiguity 가 발생 하기 때문이다. 즉, 주변에 다른 객체를 나타내는 여러 anchor 들은 학습 시 모호성을 줄 수 있다. 또한 feature map은 일반적으로 정확도와 속도의 trade off 를 위해 8번씩 down-sampling 된다. 이는 객체 중심이 객체의 identity 를 예측하기 위해 coarse anchor 위치에서 추출된 특징과 align 되지 않을 수 있기 때문에 탐지에는 적합하지만, Re-ID 에는 너무 coarse 하다는 문제점을 가진다. 따라서 high-resolution feature map 의 top 에서 픽셀 방식의 keypoint estimation (object center) 추정 및 identity classification 를 통해 이러한 문제를 해결한다.

(2) Multi-Layer Feature Aggregation

Re-ID 특징은 small 및 large 객체들을 모두 accommodate 하기 위해 low-level 및 high-level 특징들을 모두 활용해야한다. 본 논문에서는 스케일 변화를 처리하는 능력을 향상 시켜 one-shot 방법 기반으로 identity switch 를 줄였다. two-step 방법의 경우 cropping 및 resizing 작업 후 물체의 스케일이 비슷해진 채로 적용되기 때문에 스케일 문제를 개선 시킬 필요가 없다.

(3) Dimensionality of the ReID Features

이전의 Re-ID 방법들은 일반적으로 high dimensional feature 들을 학습하고, 벤치마크에서 좋은 결과를 얻어왔다. 하지만 본 논문에서는 Re-ID 보다 학습 이미지가 적기 때문에(Re-ID 데이터 세트는 잘린 이미지 만 제공하기 때문) lower-dimensional feature 가 MOT에 실제로 더 좋다는 사실을 발견하였다. 이러한 lower-dimensional feature 를 사용하면 small data 에 대한 overfitting 을 줄이고, tracking robustness 를 향상 시킬 수 있다.

먼저, anchor-free obejct detection 방법을 통해 high-resolution feature map에서 object center 를 추정한다. anchor 를 제거하게 되면 ambiguity 문제가 완화되고, high-resolution feature map 을 사용하여 Re-ID 특징을 object center 에 더 잘 align 시킬 수 있다. 그 다음 객체의 identity 를 예측하는데 사용되는 픽셀 단위의 Re-ID 특징을 추정하기 위해 parallel branch 를 추가한다. 특히 계산 시간을 단축할 뿐만 아니라 feature matching 의 robustness 를 향상시키는 low-dimensional Re-ID 특징을 학습하게 된다. 본 논문에서는 backbone 에 Deep Layer Aggregation operator 를 사용하여 다양한 스케일의 객체를 처리하기 위해 여러 레이어의 특징들을 통합한다.

MOT Chanllenge 벤치 마크에 대해 평가 한 결과 2DMOT15, MOT16, MOT17, MOT20 데이터 세트에서 all online tracker 중에서 1위를 차지하였다. 또한, offline tracker 보다 성능이 뛰어나다. 이러한 접근 방식은 매우 simple 하며, 30 FPS 로 동작한다.

2. Approach

2.1 Backbone Network

정확도와 속도의 trade-off 를 위하여 ResNet-34 를 백본으로 설정하였다. 다양한 스케일의 객체를 수용하기 위해 Deep Layer Aggregation(DLA)이 백본에 적용된다. original DLA와는 달리, Feature Pyramid Network(FPN) 와 유사한 low-level 및 high-level feature 간에 더 많은 skip connection 이 존재한다. 또한 up-sampling 모듈의 모든 컨볼루션 레이어는 deformable convolution layer 로 대체되어 객체 스케일 및 포즈에 따라 receptive field 를 동적으로 조정할 수 있다. 이러한 변경 사항은 align 문제를 완화 하는데 도움을 줄 수 있다. 이 모델의 이름은 DLA-34 로 정한다. 입력 이미지의 크기를 H x W 라고 하면 output feature map 의 모양은 C x H' x W' 이며, 이 때 H' 는 H/4 이며, W'는 W/4 이다.

2.2 Object Detection Branch

객체 탐지는 high-resolution feature map 에서 center-based 의 bounding box regression task 를 수행한다. 특히 3개의 parallel regression head 가 백본 신경망에 추가되어 각각 heatmap, object center offset, bounding box size 를 추정한다. 각 head 는 3x3 conv(256 channel) 을 백본 신경망의 output feature map에 적용한 다음, final target 을 생성하는 1x1 conv 를 적용하여 구현된다.

Heatmap Head

• 이 head 는 객체 중심의 위치를 추정한다. landmark point estimation task 의 표준인 heatmap 기반 representation 이 여기서 사용된다. 특히 heatmap 의 dimension 은 1 x H x W 이다. heatmap 의 위치에 대한 response 는 ground-truth object center 로 붕괴될 경우의 반응으로 예상된다. heatmap 의 위치와 object center 사이의 거리에 따라 response 는 기하 급수적으로 감소한다.

Center Offset

• head 는 객체를 보다 정확하게 localization 한다. feature map 의 stride 는 non-negligible quantization error 를 유발할 수 있다. 객체 탐지의 성능의 이점은 미미할 수 있으나, Re-ID 의 특징은 정확하게 object center 에 따라 추출되어야 함으로 tracking 에서는 중요하다는 특징을 가진다. 실험에서 Re-ID 의 특징을 object center 와 carefull alignment 하는 것이 성능에 중요하다는 것을 발견하였다.

Box Size Head

• 이는 각 anchor 위치에서 target bounding box 의 높이와 너비를 추정한다. 이 head 는 Re-ID 특징과는 직접적인 관련이 없지만, localization 정확도는 객체 탐지 성능 평가에 영향을 미친다.

2.3 dentity Embedding Branch

identity embedding branch 의 목표는 다른 객체와 구별할 수 있는 특징을 생성하는 것이다. 이상적으로는 서로 다른 객체 사이의 거리가 같은 객체 사이의 거리보다 커야한다. 즉, 같은 객체는 다른 프레임 상에서의 위치가 가까이 붙어있는 편이 이상적이다. 다른 객체와 구별할 수 있는 특징을 생성하기 위해 백본 특징 위에 128개의 커널이 포함된 conv layer 를 적용하여 각 위치에 대한 identity embedding feature 를 추출한다. output feature map 인 E 는 128 x W x H 영역에 포함되며, Re-ID feature 인 x, y 에서의 E 는 128에 속하고, 객체의 x, y 는 feature map 으로부터 추출된다.

2.4 Loss Function

Heatmap Loss

• heatmap 의 손실함수는 이미지에서 GT box 인 b 에 대하여 object center 를 구한다. 그 다음 각각의 위치는 feature map 에서 stride 를 divide 함으로써 구한다. 그 다음 x, y에서 heatmap response 는 Mxy 에 의해 구해지는데, 여기서 N은 객체 수를 뜻하며, σ 은 standard deviation 을 뜻한다. 손실 함수는 pixel-wise logistic regression with focal loss 를 사용한다. 말로 설명하니까 힘들다. 영어와 수식을 보는게 낫겠다. .. .... . 여기서의 M은 추정된 heatmap 을 뜻하며, 알파와 베타는 파라미터이다...

Offset and Size Loss

• 본 논문에서는 출력의 size 를 S 라 표현하였고, offset 을 O 라고 표현하였다. 이미지에서 각 GT box 인 b 를 통해 size 를 계산 할 수 있다. 또한 GT offset 도 계산 할 수 있다. two head 에 대한 손실 함수는 l1 을 사용하였으며, 아래와 같다.

Identity embedding Loss

• 본 논문에서는 object identity embedding 을 classification task 로 둔다. 특히 학습 데이터 세트에서 same identity 의 모든 instance 는 하나의 클래스로 취급된다. 이미지의 각 GT box b 에 대해 heatmap 에서 객체 중심 좌표를 얻는다. 그러면 그 위치에서 identity feature vector 를 추출하여 class distribution vector p(k) 에 매핑하는 방법을 학습할 수 있다.
• GT class label 인 one-hot representation 를 Li(k) 로 표시한다. 그 다음 softmax loss 를 다음과 같이 계산한다. 여기서 K는 클래스의 갯수이다.

2.5 Online Tracking

Network Inference

• 신경망은 이전 "Towards real-time multi-o- bject tracking." 논문에서와 같이 1088 x 608 크기의 이미지를 입력으로 넣는다. 예측된 heatmap 이외에도 heatmap score 를 기반으로 NMS(Non-Maximum Suppression)를 수행하여 peak keypoint 를 추출한다. heatmap score 가 임계 값 보다 큰 경우 keypoint 의 위치를 유지한다. 그 다음 추정된 offset 과 box 의 크기를 기반으로 bounding box 를 계산한다. 또한 추정된 object center 에서 identity embedding 을 추출한다.

Online Box Linking

• 본 논문에서는 표준 온라인 추적 알고리즘을 사용하여 box linking 을 수행한다. 첫번째 프레임의 estimated box 를 기반으로 여러 tracklet 을 초기화 한다. 다음 프레임에서는 Re-ID 특징 및 IoU 로 측정한 거리에 따라 box 를 기존 tracklet 에 연결한다. 또한 Kalman Filter 를 사용하여 현재 프레임에서 tracklet 의 위치를 예측한다. linked detection 에서 너무 멀면 해당 cost 를 무한대로 설정하여 탐지를 큰 움직임으로 연결되는 현상을 효과적으로 방지한다. apperance variation 을 처리하기 위하여 각 time step 에서 추적기의 appearance feature 를 업데이트 한다.

3. Experiments

3.1 Implementation Details

Zhou, Xingyi, Dequan Wang, and Philipp Krähenbühl. "Objects as points." arXiv preprint arXiv:1904.07850 (2019).

위 논문에서 제안한 DLA-34 의 변형을 기본 백본 신경망으로 사용한다. COCO detection dataset 에서 사전 학습 된 모델 파라미터는 모델을 초기화 하는데 사용된다. 또한 Adam optimizer 를 통해 모델을 30 epoch 에 대해 learning rate 1e-4 로 설정하여 학습시켰다. 학습 속도는 20 and 27 epoch 에서 1e-5 및 1e-6 으로 감소한다. 배치 크기는 12로 설정되며, rotation, scaling 및 color jittering 을 포함한 augmentation 을 적용하였다. 입력 이미지의 크기가 1088 x 608 로 조정되고 feature map resolution 은 272 x 152 이다. 두 개의 RTX 2080 GPU를 이용한 학습은 약 30 시간이 소요된다.

3.2 Ablative Study

Anchor-based vs. Anchor-free

• 이 전의 one-shot tracker 는 mis-alignment 로 고통받는 anchor 를 사용하였다. 본 논문에서는 detection branch 를 Towards real-time multi-object tracking 에서 사용된 anchor 기반 방법으로 대체함으로써 수치를 검증하기로 하였다. 공정한 비교를 위하여 두 가지 접근 방식의 나머지 요소는 동일하게 구성되며, anchor 기반 방법은 작은 데이터 세트를 사용할 때 매우 나쁜 결과를 얻었으며 표 1과 같다.
  

  

Evaluation of the anchor-based and anchor-free methods on the validation videos of the MOT15 dataset. The large training dataset is used and all models are trained for 10 epochs. ↑ means the larger the better and ↓ means the smaller the better. The best results are in bold.

• 위 표에서와 같이 anchor-based 방법이 anchor-free 방법보다 일관되게 낮은 MOTA 점수를 얻는 것을 볼 수 있다. 예를 들어 stride 가 8인 경우 anchor-free 방법은 TPR(True Positive Rate) 이 85.5% 으로 훨씬 더 나은 TPR 점수를 달성한다. 이에 주된 요인은 anchor 와 obejct center 사이의 alignment 가 잘못 되면, 신경망 학습에 심각한 모호성이 생기기 때문이다. anchor-based 방법에 대해 feature map resolution 을 높이면 MOTA 점수도 저하된다. high-resolution feature map 을 사용하면 더 많은 양의 anchor unalign 되기 때문에 신경망 학습이 더욱 어려워진다. anchor 수가 크게 증가하면 GPU 메모리 용량을 초과하기 때문에 stride 2 의 대한 결과는 표시하지 않았다고 한다.
• anchor-free 접근법은 mis-alignment issue 를 덜 겪고, anchor-based 방법 보다 현저히 더 나은 MOTA 점수를 달성한다. 특히 stride 4 로 인해 ID switch 수가 137개에서 93 개로 줄어든다. stride 8에서 4로 줄이면 더 많은 이점이 있다는 것이다. stride 를 2로 줄이면 더 낮은 수준의 feature 가 유입되어 representation 이 appearance variation 에 less robust 해지므로 결과가 저하된다.
• 또한 아래 그림 3에서 다양한 모델로 학습한 Re-ID 특징을 시각화 하였다. 특히 stride 4인 경우의 anchor-based 접근 방식은 서로 다른 ID의 특징이 혼합되어있음을 볼 수 있다.

Multi-Layer Feature Aggregation

• 백본 신경망에서 multi-layer feature aggregation 의 영향을 평가한다. 특히 vanilla ResNet, FPN, HRNet, DLA-34 와 같은 다수의 백본을 평가하였으며, 접근법의 나머지 요소들은 동일하게 구성되었다. final feature map 의 stride 는 4 로 설정되었으며, vanilla ResNet 에 3개의 up-sampling 작업을 추가하여 stride-4 feature map 을 얻는다. 본 논문에서는 2DMOT15 데이터 세트의 학습 부분을 5개의 학습 비디오와 6개의 검증 비디오로 나누었다. cost computation 을 줄이기 위하여 대규모 훈련 데이터 세트는 사용되지 않는다.

• 위와 같이 ResNet-34 보다는 ResNet-50이 더 좋은 MOTA 점수를 나타낸다. 그러나 자세한 메트릭을 살펴보면 Re-ID 특징에서는 더 큰 사이즈의 신경망에서 얻는 이점을 얻지는 못한다. 결론적으로 multi-layer fusion 이 identity embedding 개선 측면에서 더 깊은 신경망을 사용하는 것 보다 확실한 이점을 가지고 있다는 것을 보여준다. ResNet-34를 기반으로 구축된 DLA-34는 훨씬 더 나은 MOTA 점수를 나타낸다. 특히 TPR 은 35.0% 에서 67.3%로 증가하여였으며, IDs 가 크게 감소한 것을 볼 수 있다. 그런데 HRNetV1 뿐만 아니라 V2 모델도 매우 강력한 탐지 결과를 내놓는다.
• 하지만 DLA-34에는 이에 비해 더 차별화된 Re-ID 특징이 있다. DLA-34 모델에서 deformable convolution 을 사용하는 이유는 작은 객체에 대한 down-sampling 으로 인한 mis-alignment 문제를 완화 시킬 수 있다. 아래 표3 에서 볼 수 있듯 DLA-34가 small and middle 객체에서 HRNetV2 보다 성능이 뛰어남을 알 수 있다.

The Re-ID Feature Dimension

• 이전 연구에서는 보통 ablation study 없이 512 dimensional feature 를 학습한다. 그러나 실험에서 feature dimension 이 중요한 역할을 한다는 것을 찾아냈다. 일반적으로 overfitting 을 피하기 위하여 high-dimensional Re-ID feature 를 학습하려면 대량의 학습 이미지가 필요하다. 이전의 two-step 접근 방식은 crop 된 이미지로 이루어진 대규모의 데이터 세트를 활용할 수 있기 때문에 이러한 문제가 덜 발생했으나, one-shot 방식은 자르지 않은 원본 이미지를 필요로 하기 때문에 이와 같은 데이터를 사용할 수 없다. 이를 위한 솔루션으로는 Re-ID 특징의 dimension 을 줄여 데이터에 대한 의존성을 줄일 수 있다.
• 

• 위와 같이 dim 이 512 에서 128 로 감소하였을 때 모든 요소들이 일관적으로 개선되었다. 64 로 더 줄이게 되면 Re-ID 특징의 representative ability 이 손상되기 때문에 TPR 이 감소한다. MOTA 점수의 변화는 미미하지만, 실제로 IDs 의 수는 크게 줄어든다. 이는 실제로 사용자가 tracker 를 사용할 때 직관적으로 느낄 수 있는 척도라고 보면 된다. Re-ID feature dimension 을 줄임으로써 inference speed 도 약간 개선된다. lower-dimensional Re-ID feature 를 사용하는 것은 소수의 학습 데이터를 사용할 경우에만 적용된다. 데이터 수가 증가하게 되면 이러한 효과는 감소된다.

3.3 The State-of-the-arts

One-Shot MOT Methods

One-shot MOT 방법인 JDE 및 TrackRCNN 의 방법과 비교한 결과는 아래와 같다. 추론 속도는 모두 실시간 성능을 보장한다.

1. Wang, Zhongdao, et al. "Towards real-time multi-object tracking." arXiv preprint arXiv:1909.12605 (2019).
2. Voigtlaender, Paul, et al. "MOTS: Multi-object tracking and segmentation." Proceedings of the IEEE conference on computer vision and pattern recognition. 2019.

Two-Step MOT Methods

two-step 기반 방법들과 비교한 결과는 다음과 같다. public detection result 를 사용하지 않기 때문에 "private detector" protocol 을 사용한다. 테스트 하기 전에 각 데이터 세트에서 10 epoch 에 대한 모델을 fine-tuning 한다. 모든 결과는 MOT challenge evaluation server 에서 얻고, 본 논문의 접근 방식은 2DMOT15, MOT16, MOT17, MOT20 데이터 세트에서 1위를 차지한다. 본 논문의 접근 방식이 매우 간단한 점을 고려해봤을 때 매우 좋은 결과를 나타낸다. 또한 RAR15 및 POI 와 같은 고성능 tracker 는 본 논문의 방법보다 느리다.

4. Conclusion

one-shot multiple object tracking 을 위한 simple baseline 을 제시하였다. 본 논문에서는 이전의 one-shot 방식에서 two-step 방식과 비교할만한 결과를 못얻는지에 대한 연구부터 시작하였으며, object detection 및 Re-ID 에 anchor 를 사용하는 것이 성능을 저하시킨다는 것을 발견하였다. 특히 객체의 다른 부분에 해당하는 여러개의 주변 anchor 들은 신경망 훈련에 모호성을 유발한다. 또한 본 논문의 tracker 는 30 fps 를 달성하며, anchor-free 방식의 SOTA tracker 를 제시하였다.

출처: https://eehoeskrap.tistory.com/447 [Enough is not enough]

• 공부하기 위해서 출처와 똑같이 작성하였습니다.

Yolov4-tiny를 쓰기 위해 코드
git hub : https://github.com/AlexeyAB/darknet

패키지는 yolov5 requirement.txt 와 같은 패키지를 사용하고 있음

gpu : RTX 3090(24GB)
CUDA : 11.1
nvidia-driver : 455.55
cudnn : 8.0.4
tensorRT : 7.2.3.4
os : Ubuntu 18.04
( 만약 cmake 없다면 설치해줘야 함)

Yolov4-tiny를 사용하기 위해서 {darknet(yolov4)}/cfg/yolov4-tiny.cfg 를 수정해서 사용(복사하고 나서 원하는 이름으로 변경후에 사용하는걸 추천) config 파일에서 배치들을 수정해서 사용하면 됨 (모델구조는 costum layer를 사용하지 않으면 바꾸지 않고 진행 혹시나 변경하게 되면 pretrained weight를 사용할 수 없음)

그리고 yolov4-tiny pretrained weight : https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v4_pre/yolov4-tiny.weights

• hange line batch to batch=64
• change line subdivisions to subdivisions=16
  change line max_batches to (classes*2000, but not less than number of training images and not less than 6000), f.e. max_batches=6000 if you train for 3 classes
• change line steps to 80% and 90% of max_batches, f.e. steps=4800,5400
• set network size width=416 height=416 or any value multiple of 32:
  https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L8-L9
• change line classes=80 to your number of objects in each of 3 [yolo]-layers:
  https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L610
• change [filters=255] to filters=(classes + 5)x3 in the 3 [convolutional] before each [yolo] layer, keep in mind that it only has to be the last [convolutional] before each of the [yolo] layers.
  https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L603
• when using [Gaussian_yolo] layers, change [filters=57] filters=(classes + 9)x3 in the 3 [convolutional] before each [Gaussian_yolo] layer
  https://github.com/AlexeyAB/darknet/blob/6e5bdf1282ad6b06ed0e962c3f5be67cf63d96dc/cfg/Gaussian_yolov3_BDD.cfg#L604

바꿔야하는 기준에 대해서 github에 작성되어 있다

{darknet(yolov4)}/data/fire.data
{darknet(yolov4)}/data/fire.name
를 수정해야하는데 fire.data에는 데이터 경로와 class 이름들이 들어가 있는 fire.name의 경로 클래스 갯수등이 들어가고 train 결과가 backup/ 밑으로 가도록 경로를 설정해준다
fire.name에는 라벨링 class의 이름들을 적어준다

$ vi ./data/fire.data
classes= 2
train  = data/fire_train.txt
valid  = data/fire_val.txt
#difficult = data/fire_test.txt
names = data/fire.names
backup = backup/

$ vi ./data/fire.name
fire
smoke

라벨링 데이터의 경우
[object-class][x_center] [y_center][width] [height] 순으로 적혀 있다.

train 실행
$ ./darknet detector train data/fire.data cfg/yolov4-tiny.cfg yolov4-tiny.conv.29

demo 실행
$ ./darknet detector demo data/fire.data cfg/yolov4-tiny.cfg /backup/yolov4-tiny_best.weights /{data_path}/fire.mp4

git hub : https://github.com/ultralytics/yolov5

코드를 다운받고

$ pip install -r requirements.txt

를 통해서 필요한 패키지를 다운 받습니다.

환경구성
gpu : RTX 3090
ram : 64gb
nvidia driver : 455.32
cuda toolkit : 11.1
cudnn : 8.0.4
tensorRT : 7.2.3.4
pytorch : 1.8.1 + cu11

위의 환경구성은 따로 작성을 진행하도록 하겠습니다.

custom dataset으로 yolov5를 진행하려면 원하는 data.yaml파일이 필요로 합니다.
cocodataset 예시

# COCO 2017 dataset http://cocodataset.org - first 128 training images
# Train command: python train.py --data coco128.yaml
# Default dataset location is next to /yolov5:
#   /parent_folder
#     /coco128
#     /yolov5


# download command/URL (optional)
download: https://github.com/ultralytics/yolov5/releases/download/v1.0/coco128.zip

# train and val data as 1) directory: path/images/, 2) file: path/images.txt, or 3) list: [path1/images/, path2/images/]
train: ../coco128/images/train2017/  # 128 images
val: ../coco128/images/train2017/  # 128 images

# number of classes
nc: 80

# class names
names: [ 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light',
         'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
         'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
         'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard',
         'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
         'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
         'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
         'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear',
         'hair drier', 'toothbrush' ]

위와 같이 비슷한 구조로 패스와 클래스의 갯수 그리고 클래스의 이름들을 정해주면 된다.

from utils.autoanchor import *;_=kmean_anchors(path='/{path}/data/fire_data.yaml', n=9, img_size=480, thr=4.0, gen=1000, verbose=True)

위의 코드를 추가해서 사용하는 yaml를 넣어주면 먼저 앵커값들의 최적화를 진행후에 train을 진행한다.

사실 github에 정리가 너무 잘 되어 있어서 참고로만 보면 될 거 같습니다.
그리고 원하는 파라미터를 넣고 싶으시다면 data/hyp.scratch.yaml 파일을 수정해서 사용하면 됩니다.

그렇게 train을 돌리고 나서 mAP를 확인하려면 run/train/exp* 폴더를 확인하면 됨

exp폴더의 경우 train코드상에서 수정을 하지 않았다면 그저 순서대로 epx1 exp2 순으로 train한 순서대로 저장됨

이 경로에서 tensorboard를 통해서 확인할 수 있는데

$ tensorboard --logdir=./

을 통해서 확인할 수 있다

이제 여기서 제공하는 결과는 아래의 그림과 같다

여기서 사용한 데이터는 화재 데이터인데 클래스는 2개 smoke와 fire라벨을 이용했다
아래는 Yolov5 학습에 사용된 라벨 데이터이다.

1 0.642969 0.406944 0.164062 0.175000

기본적인 학습이 끝났으니 Yolov5에서 제공해주고 있는 TensorRT를 이용해보자.

그리고 TensorRT를 사용하기 위해
github : https://github.com/wang-xinyu/tensorrtx 를 다운 받습니다.

그리고 tensorRT/yolov5 디렉토리로 들어가서 gen_wts.py을 yolov5 폴더로 옮겨서 weight파일을 가지고 weight파일의 모델구조 및 파라미터를 뽑는 과정이다

1. generate .wts from pytorch with .pt, or download .wts from model zoo

$ cp {tensorrtx}/yolov5/gen_wts.py {ultralytics}/yolov5
$ cd {ultralytics}/yolov5
$ python gen_wts.py yolov5s.pt
// a file 'yolov5s.wts' will be generated. {yolov5s}는 weight파일 이름에 귀속

   2. build tensorrtx/yolov5 and run

cd {tensorrtx}/yolov5/
// update CLASS_NUM in yololayer.h if your model is trained on custom dataset
// yoloayer.h파일에서 class 갯수를 사용한 weight파일에 맞춰줘야함 본인은 2개로 수정함
mkdir build
cd build
cp {ultralytics}/yolov5/yolov5s.wts {tensorrtx}/yolov5/build
cmake ..
make
sudo ./yolov5 -s [.wts] [.engine] [s/m/l/x/s6/m6/l6/x6 or c/c6 gd gw]  // serialize model to plan file
// [s/m/l/x/s6/m6/l6/x6 or c/c6 gd gw] 의 경우 사용한 모델을 적어주면 된다.
sudo ./yolov5 -d [.engine] [image folder]  // deserialize and run inference, the images in [image folder] will be processed.
// For example yolov5s
sudo ./yolov5 -s yolov5s.wts yolov5s.engine s
sudo ./yolov5 -d yolov5s.engine ../samples
// For example Custom model with depth_multiple=0.17, width_multiple=0.25 in yolov5.yaml
sudo ./yolov5 -s yolov5_custom.wts yolov5.engine c 0.17 0.25
sudo ./yolov5 -d yolov5.engine ../samples

Yolov5m모델을 TensorRT로 변환해서 영상을 실행한 결과인데 FPS 396.4로 굉장히 높게 나옴... 하지만 메모리가
대략 4GB를 사용한다

Yolov4-tiny를 window에서 실행하기 위해 환경구성을 하던중 vcpkg를 통해 c++ 패키지 및 라이브러리를 관리할 수 있도록 설치가 github에 안내되어 있길래 그대로 진행

https://vcpkg.io/en/getting-started.html

위의 주소를 들어가서 진행하면 되는데
cmd창을 열고

Step 1: Clone the vcpkg repo

git clone https://github.com/Microsoft/vcpkg.git

Make sure you are in the directory you want the tool installed to before doing this.

Step 2: Run the bootstrap script to build vcpkg

.\vcpkg\bootstrap-vcpkg.bat

Install libraries for your project
vcpkg install [packages to install]

위의 step별로 진행하고 원하는 패키지를 설치하면 된다.

기능 맵을 시각화하는 방법

기능 맵이라고하는 활성화 맵은 입력 이미지 또는 다른 기능 맵과 같은 입력에 필터를 적용한 결과를 캡처합니다.

특정 입력 이미지에 대한 특성 맵을 시각화하는 아이디어는 특성 맵에서 감지되거나 보존되는 입력 특성을 이해하는 것입니다. 입력에 가까운 기능 맵은 작거나 세분화 된 세부 사항을 감지하는 반면 모델 출력에 가까운 기능 맵은보다 일반적인 기능을 캡처합니다.
(1pixel이 의미하는 바가 layer를 거치기 전에는 부리의 일부분 깃털의 일부분이라면 layer가 진행되면 진행될수록 부리, 깃털, 날개, 몸톰, 새, 이미지천체 한 픽셀에 담기는 데이터 정보가 점점 커져간다. 이것 때문에 피라미드 구조가 나오게 됨)

기능 맵의 시각화를 탐색하려면 활성화를 만드는 데 사용할 수있는 VGG16 모델에 대한 입력이 필요합니다. 간단한 새 사진을 사용합니다. 특히, Chris Heald가 촬영 한 Robin 은 허용 라이센스에 따라 릴리스되었습니다.

사진을 다운로드하고 파일 이름이 ' bird.jpg '인 현재 작업 디렉토리에 배치합니다

STEP1. - 먼저 이미지를 VGG16에서 사용하는 input size로 가져옵니다

데이터 불러오기 -> 데이터 전처리 -> 모델 train&val -> 모델 test -> inference(service)
[학습에서는 데이터의 dependency가 강력하기 때문에 데이터의 일관성이 굉장이 중요함. 본 이미지 데이터 분석은 나중에 이미지 프로젝트 진행시 이미지 데이터를 분석을 하기 위한 초석으로 보면 될 듯 싶다.

import cv2
from tensorflow.keras.models import Model
import numpy as np
from keras.applications.vgg16 import VGG16
from matplotlib import pyplot

#load the image with the required shape
img = cv2.imread('bird.jpg',cv2.COLOR_BGR2RGB)
img = cv2.resize(img,(224,224))
print(img.__class__)
print(img.shape)

STEP2. - 데이터 차원 확장 및 전처리

데이터 차원확장은 이번에 사용하는 데이터가 하나이기 때문에 따로 차원확장을 진행해줬다. [ N, H, W, C], [ N, C, H, W] C,H,W의 순서는 opencv냐 아니냐에 달라질 수는 있으나 (tensorflow, pytorch의 차이도 존재) 기본적으로 4차원으로 들어가야한다.

img = np.expand_dims(img, axis=0) # 차원확대

img = img/255.0 # 이미지 scaling

STEP3. - 모델을 불러오기

# load the model
model = VGG16()
# summarize featu

model = Model(inputs=model.inputs, outputs=model.layers[1].output)

STEP4. - 예측하기

feature_maps = model.predict(img)

STEP5. - 결과확인

# plot all 64 maps in an 8x8 squares
square = 8
ix = 1
for _ in range(square):
	for _ in range(square):
		# specify subplot and turn of axis
		ax = pyplot.subplot(square, square, ix)
		ax.set_xticks([])
		ax.set_yticks([])
		# plot filter channel in grayscale
		pyplot.imshow(feature_maps[0, :, :, ix-1], cmap='gray')
		ix += 1
# show the figure
pyplot.show()

각 레이어에 대한 이미지 feature값들도 확인해보자

input에서 output으로 나오는 각각의 layer의 이미지들을 출력값으로 뽑은 이미지들이다.

# visualize feature maps output from each block in the vgg model
from keras.applications.vgg16 import VGG16
from keras.applications.vgg16 import preprocess_input
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.models import Model
from matplotlib import pyplot
from numpy import expand_dims
# load the model
model = VGG16()
# redefine model to output right after the first hidden layer
ixs = [2, 5, 9, 13, 17]
outputs = [model.layers[i].output for i in ixs]
model = Model(inputs=model.inputs, outputs=outputs)
# load the image with the required shape
img = load_img('bird.jpg', target_size=(224, 224))
# convert the image to an array
img = img_to_array(img)
# expand dimensions so that it represents a single 'sample'
img = expand_dims(img, axis=0)
# prepare the image (e.g. scale pixel values for the vgg)
img = preprocess_input(img)
# get feature map for first hidden layer
feature_maps = model.predict(img)
# plot the output from each block
square = 8
for fmap in feature_maps:
	# plot all 64 maps in an 8x8 squares
	ix = 1
	for _ in range(square):
		for _ in range(square):
			# specify subplot and turn of axis
			ax = pyplot.subplot(square, square, ix)
			ax.set_xticks([])
			ax.set_yticks([])
			# plot filter channel in grayscale
			pyplot.imshow(fmap[0, :, :, ix-1], cmap='gray')
			ix += 1
	# show the figure
	pyplot.show()

이건 convolution을 각 레이어 및 필터 마다 나오는 이미지 혹은 필터값을 특정하기 위해서 찾은 강의를 따라한 것이다.

아래는 그 주소이다
https://machinelearningmastery.com/how-to-visualize-filters-and-feature-maps-in-convolutional-neural-networks/

This tutorial is divided into four parts; they are:

1. Visualizing Convolutional Layers
2. Pre-fit VGG Model
3. How to Visualize Filters
4. How to Visualize Feature Maps

환경 변수

tensorflow = 2.4.0
kereas = 2.4.3

1. Visualizing Convolutional Layers

신경망 모델은 일반적으로 불투명하다고합니다. 이것은 특정 결정이나 예측을 한 이유를 설명하는 데 부족하다는 것을 의미합니다.

컨볼 루션 신경망은 이미지 데이터와 함께 작동하도록 설계되었으며 그 구조와 기능은 다른 유형의 신경망보다 이해하기 어려운 측면이 있습니다.

특히, 모델은 작은 선형 필터와 활성화 맵 또는보다 일반적으로 기능 맵이라는 필터를 적용한 결과로 구성됩니다.

필터와 기능 맵을 모두 시각화 할 수 있습니다.

예를 들어, 라인 감지기와 같은 작은 필터를 설계하고 이해할 수 있습니다. 학습 된 컨볼 루션 신경망 내에서 필터를 시각화하면 모델 작동 방식에 대한 통찰력을 얻을 수 있습니다.

입력 이미지에 필터를 적용하고 이전 계층에서 출력 한 기능 맵에 생성 된 기능 맵은 모델의 특정 입력 지점에서 모델이 갖는 내부 표현에 대한 통찰력을 제공 할 수 있습니다.

이 튜토리얼에서는 컨볼 루션 신경망을 시각화하는 두 가지 접근 방식을 모두 살펴볼 것입니다.

2. Pre-fit VGG Model

시각화 해볼 모델은 VGG16입니다. keras에서 불러오기도 쉽고 사용하기도 쉬운데 성능이 좋기 때문입니다.

# load vgg model
from keras.applications.vgg16 import VGG16
# load the model
model = VGG16()
# summarize the model
model.summary()

# load vgg model
from keras.applications.vgg16 import VGG16
# load the model
model = VGG16()
# summarize the model
model.summary()

예제를 실행하면 모델 가중치가 메모리에로드되고로드 된 모델구조가 인쇄됩니다.

Model: "vgg16"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         [(None, 224, 224, 3)]     0         
_________________________________________________________________
block1_conv1 (Conv2D)        (None, 224, 224, 64)      1792      
_________________________________________________________________
block1_conv2 (Conv2D)        (None, 224, 224, 64)      36928     
_________________________________________________________________
block1_pool (MaxPooling2D)   (None, 112, 112, 64)      0         
_________________________________________________________________
block2_conv1 (Conv2D)        (None, 112, 112, 128)     73856     
_________________________________________________________________
block2_conv2 (Conv2D)        (None, 112, 112, 128)     147584    
_________________________________________________________________
block2_pool (MaxPooling2D)   (None, 56, 56, 128)       0         
_________________________________________________________________
block3_conv1 (Conv2D)        (None, 56, 56, 256)       295168    
_________________________________________________________________
block3_conv2 (Conv2D)        (None, 56, 56, 256)       590080    
_________________________________________________________________
block3_conv3 (Conv2D)        (None, 56, 56, 256)       590080    
_________________________________________________________________
block3_pool (MaxPooling2D)   (None, 28, 28, 256)       0         
_________________________________________________________________
block4_conv1 (Conv2D)        (None, 28, 28, 512)       1180160   
_________________________________________________________________
block4_conv2 (Conv2D)        (None, 28, 28, 512)       2359808   
_________________________________________________________________
block4_conv3 (Conv2D)        (None, 28, 28, 512)       2359808   
_________________________________________________________________
block4_pool (MaxPooling2D)   (None, 14, 14, 512)       0         
_________________________________________________________________
block5_conv1 (Conv2D)        (None, 14, 14, 512)       2359808   
_________________________________________________________________
block5_conv2 (Conv2D)        (None, 14, 14, 512)       2359808   
_________________________________________________________________
block5_conv3 (Conv2D)        (None, 14, 14, 512)       2359808   
_________________________________________________________________
block5_pool (MaxPooling2D)   (None, 7, 7, 512)         0         
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0         
_________________________________________________________________
fc1 (Dense)                  (None, 4096)              102764544 
_________________________________________________________________
fc2 (Dense)                  (None, 4096)              16781312  
_________________________________________________________________
predictions (Dense)          (None, 1000)              4097000   
=================================================================
Total params: 138,357,544
Trainable params: 138,357,544
Non-trainable params: 0
_________________________________________________________________

Process finished with exit code 0

3. How to Visualize Filters

수행 할 가장 간단한 시각화는 학습 된 필터를 직접 플로팅하는 것입니다.

신경망 용어에서 학습 된 필터는 단순히 가중치이지만 필터의 특수한 2 차원 구조로 인해 가중치 값은 서로 공간적 관계를 가지며 각 필터를 2 차원 이미지로 플로팅하는 것은 의미가 있습니다

첫 번째 단계는 모델의 필터를 검토하여 작업해야하는 사항을 확인하는 것입니다.

이전 섹션에서 인쇄 된 모델 요약은 각 레이어의 출력 모양 (예 : 결과 피쳐 맵의 모양)을 요약합니다. 네트워크에서 필터 (가중치)의 모양에 대한 아이디어는 제공하지 않으며 레이어 당 총 가중치 수만 제공합니다.

model.layers 속성을 통해 모델의 모든 계층에 액세스 할 수 있습니다 .

각 레이어에는 layer.name 속성이 있습니다. 여기서 컨볼 루션 레이어에는 block # _conv # 와 같은 명명 컨볼 루션이 있습니다. 여기서 ' # '는 정수입니다. 따라서 각 레이어의 이름을 확인하고 ' conv ' 문자열이 포함되지 않은 레이어는 건너 뛸 수 있습니다.

# summarize filter shapes
for layer in model.layers:
	# check for convolutional layer
	if 'conv' not in layer.name:
		continue

각 컨벌루션 계층에는 두 세트의 가중치가 있습니다.

하나는 필터 블록이고 다른 하나는 바이어스 값 블록입니다. layer.get_weights () 함수 를 통해 액세스 할 수 있습니다. 이러한 가중치를 검색 한 다음 그 모양을 요약 할 수 있습니다.

# get filter weights
filters, biases = layer.get_weights()
print(layer.name, filters.shape)

전체 코드 입니다.

# summarize filters in each convolutional layer
from keras.applications.vgg16 import VGG16
from matplotlib import pyplot
# load the model
model = VGG16()
# summarize filter shapes
for layer in model.layers:
	# check for convolutional layer
	if 'conv' not in layer.name:
		continue
	# get filter weights
	filters, biases = layer.get_weights()
	print(layer.name, filters.shape)

밑에는 그 결과 입니다.

     block1_conv1 (3, 3, 3, 64)
     block1_conv2 (3, 3, 64, 64)
     block2_conv1 (3, 3, 64, 128)
     block2_conv2 (3, 3, 128, 128)
     block3_conv1 (3, 3, 128, 256)
     block3_conv2 (3, 3, 256, 256)
     block3_conv3 (3, 3, 256, 256)
     block4_conv1 (3, 3, 256, 512)
     block4_conv2 (3, 3, 512, 512)
     block4_conv3 (3, 3, 512, 512)
     block5_conv1 (3, 3, 512, 512)
     block5_conv2 (3, 3, 512, 512)
     block5_conv3 (3, 3, 512, 512)

모든 컨벌루션 레이어는 작고 해석하기 쉬운 3x3 필터를 사용한다는 것을 알 수 있습니다.

컨벌루션 신경망의 구조적 문제는 필터의 깊이가 필터에 대한 입력 깊이 (예 : 채널 수)와 일치해야한다는 것입니다.

빨강, 녹색 및 파랑에 대해 3 개의 채널이있는 입력 이미지의 경우 각 필터의 깊이가 3임을 알 수 있습니다 (여기서는 채널-마지막 형식으로 작업 함). 하나의 필터를 각 채널에 대해 하나씩 세 개의 이미지가있는 플롯으로 시각화하거나 세 개를 모두 단일 색상 이미지로 압축하거나 첫 번째 채널을보고 다른 채널이 동일하게 보일 것이라고 가정 할 수도 있습니다. 문제는 시각화하고 싶은 63 개의 다른 필터가 있다는 것입니다.

다음과 같이 첫 번째 레이어에서 필터를 검색 할 수 있습니다.

# retrieve weights from the second hidden layer
filters, biases = model.layers[1].get_weights()

가중치 값은 0.0을 중심으로하는 작은 양수 및 음수 값일 수 있습니다.

값을 쉽게 시각화 할 수 있도록 0-1 범위로 정규화 할 수 있습니다.(정규화에 대한 자세한 이야기는 다른 페이지에서 자세히 다루도록 하겠습니다.)

# normalize filter values to 0-1 so we can visualize them
f_min, f_max = filters.min(), filters.max()
filters = (filters - f_min) / (f_max - f_min)

이제 블록의 64 개 중 처음 6 개 필터를 열거하고 각 필터의 3 개 채널을 각각 플로팅 할 수 있습니다.

matplotlib 라이브러리를 사용하고 각 필터를 새로운 서브 플롯 행으로 플로팅하고 각 필터 채널 또는 깊이를 새 열로 플로팅합니다.

# plot first few filters
n_filters, ix = 6, 1
for i in range(n_filters):
	# get the filter
	f = filters[:, :, :, i]
	# plot each channel separately
	for j in range(3):
		# specify subplot and turn of axis
		ax = pyplot.subplot(n_filters, 3, ix)
		ax.set_xticks([])
		ax.set_yticks([])
		# plot filter channel in grayscale
		pyplot.imshow(f[:, :, j], cmap='gray')
		ix += 1
# show the figure
pyplot.show()

아래는 전체 코드입니다

# cannot easily visualize filters lower down
from keras.applications.vgg16 import VGG16
from matplotlib import pyplot
# load the model
model = VGG16()
# retrieve weights from the second hidden layer
filters, biases = model.layers[1].get_weights()
# normalize filter values to 0-1 so we can visualize them
f_min, f_max = filters.min(), filters.max()
filters = (filters - f_min) / (f_max - f_min)
# plot first few filters
n_filters, ix = 6, 1
for i in range(n_filters):
	# get the filter
	f = filters[:, :, :, i]
	# plot each channel separately
	for j in range(3):
		# specify subplot and turn of axis
		ax = pyplot.subplot(n_filters, 3, ix)
		ax.set_xticks([])
		ax.set_yticks([])
		# plot filter channel in grayscale
		pyplot.imshow(f[:, :, j], cmap='gray')
		ix += 1
# show the figure
pyplot.show()

예제를 실행하면  각 필터에 대해 한 행, 각 채널에 대해 한 열에 대해 18개의 이미지가 출력된다.

어떤 경우에는 필터가 채널(첫 번째 행)에서 동일하고 다른 경우(마지막 행)필터가 다르다는 것을 알 수 있습니다.

어두운 사각형은 weight 부분이 작은 부분이고 밝은 사각형은 큰 weight를 나타내는데 이 직관을 활용하면 첫 번째 행의 필터가 왼쪽 상단의 빛에서 오른쪽 하단의 어두운 곳으로의 그라디언트를 감지하는다는 것을 알 수 있습니다.

시각화가 있지만 첫 번째 컨볼 루션 레이어의 64 개 필터 중 처음 6 개만 볼 수 있습니다. 64 개의 모든 필터를 하나의 이미지로 시각화하는 것이 가능합니다.

두 번째 컨벌루션 레이어에서 필터를 살펴 보려면 다시 64 개의 필터가 있지만 각 필터에는 입력 특성 맵과 일치하는 64 개의 채널이 있음을 알 수 있습니다. 64 개 필터 모두에 대해 한 행에있는 모든 64 개 채널을 보려면 (64x64) 4,096 개의 서브 플롯이 필요하므로 세부 정보를 확인하기 어려울 수 있습니다.

파이썬(Python) Multiprocessing - Pool

멀티 프로세싱을 활용하면 복잡하고 시간이 걸리는 작업을 별도의 프로세스를 생성 후 병렬처리해서
보다 빠른 응답처리 속도를 기대할 수 있는 장점이 있습니다.

최근들어 대용량의 빅데이터의 분석 및 예측 등의 머신러닝을 지원하는 다양한 패키지에서 대부분 멀티 프로세싱을 활용해서 멀티코어의 CPU의 장점을 극대화하고 빠른 처리를 지원하고 있습니다.

다만, 충분한 사전 지식 및 병렬 프로그래밍의 이해 없이 코드를 작성한다면, 싱글 프로세스의 응답속도보다 시간이 지연되고 별도로 예상치 못한 결과가 나타날 수 있으니 프로세스 및 쓰레드 등의 지식이 중요합니다.

또한, 멀티프로세싱은 오버헤드의 증가 및 메모리 사용률이 높아지는 단점도 존재합니다

파이썬(Python) MultiProcessing - 구조

보통 Multiprocessing 실행 흐름은 아래와 같이 나타낼 수 있으며, 관련 예제는 하단에서 설명합니다.

출처 : https://sebastianraschka.com/Articles/2014_multiprocessing.html

밑의 코드는 각각의 이미지들을 crop하고 저장하는것을 multiprocessing으로 구현했습니다. 서버에서는 cpu코어가 많아서 20~30로 줬었는데 process가 진행하다가 디렉토리에서 다른 디렉토리로 넘어갈 때 멈추는 현상이 있었습니다. python 정책에 의해서 인지 다른 프로세스가 끝나서 그런지 아니면 서버에서 다른 작업을 진행하느라 그것을 기다리느라 오래 걸린 것인지(프로세스의 경우 우선 순위에 따라서 진행되는걸로 알고 있습니다.) 정확한 이유는 알 수 없습니다. 추후 이 부분에 대해서는 추가로 작성하는걸로....(이걸로 대략 3.5TB의 이미지를 처리 했었다.)