【Transformer+OD】DETR-End-to-End Object Detection with Transformers w/ my advice

  • 논문 : End-to-End Object Detection with Transformers
    필기 완료된 파일은 OneDrive\21.1학기\논문읽기 에 있다.
  • 분류 : Transformer + Object Detection
  • 저자 : Nicolas Carion, Francisco Massa, Gabriel Synnaeve
  • 읽는 배경 : Visoin Transformers 를 사용한 Object Detection
  • 느낀점 :
    • 연산이 좀 더 구체적으로 어떻게 이뤄지는 건지 궁금하면, Deformable DETR 부분의 내용정리를 참고하면 좋다
    • Conclution -> Method -> Introduction -> Abstract 순서로 논문을 공부하자!
    • 실제 공부 순서
      1. Conclusion, Abstract
      2. Introduction : Fig 1 과 Fig 1을 설명하는 논문의 부분. 1문단만 읽음
      3. Introduction : 거의 마지막 부분
      4. Related work : 큰 제목이 의미하는 것이 무엇인지만, 알아봤다.
      5. The DETR model
      6. 나머지
      7. 아직 이해가 안 되는 것 : auxiliary losses
    • 논문이 정말 깔끔하다. 이전의 ViT (16x16 vision transfomer) 논문을 보다가, 이 논문을 보니까 문장도 정말 잘 써놨고 이해도 정말 잘되게 써놨다. 일부러 어렵게 써놓지도 않아서 너무 좋다. 이렇게 아주아주 유명하고 유용한 논문도 이렇게 쉽게 써 놓을 수 있고, 쉽게 이해가 될 수 있는데…. 내가 논문을 읽으면서 “어렵고, 이해가 안되고, 논문 읽기 싫다” 라는 생각이 들때면, 이 DERT 논문을 떠올리자. 논문을 개같이 써놔서 이해가 안되고, 어려운거지, 코드를 보고 실제를 확인하면 정말 별거 없다. 내가 부족해서 어려운거 라고 생각하며 우울해하지말고, “논문을 개같이 써서 어려운거다! 이 논문만 그런거다! 또 다른 논문은 쉽게 이해되고 재미있을 수 있다!” 라고 생각하자. 왜 우울해 해. 모르면 배우면 되지. 생각하지 말고 그냥 하자.
  • 목차 :
    1. Paper Review
    2. Code
      • https://github.com/facebookresearch/detr


End-to-End Object Detection with Transformers

image-20210303203616333


1. Conclusion, Abstract, Introduction

  • 이 논문의 핵심 2가지
    1. Transformers(encoder-decoder architectures)를 기반으로 한, object detection systems.
    2. Direct set prediction (NMS 따위 안쓰고, Class, BB 한방에 예측해버림) : bipartite(Predicted BB and GT) matching을 수행하는, set-based global loss 를 정의해 사용했다.
    3. Fixed small set of learned object queries 를 사용한다 : DERT가 ‘객체와 Global Image context’ 와의 관계를 추론하여, Parallel하게 (N개의 Query에 대해서 N개의 예측 결과를 출력한다. Figure2에서 빨,초,노,파 박스) final predictions을 하게 만든다.
  • 특장점
    1. Powerful : optimized Faster R-CNN 와 유사한 성능 결과를 가진다. (하지만 Small object에 대해서는 성능이 매우 낮다)
    2. straightforward, simple :
      • detection pipeline을 간소화했다. 코드가 단순하다.
      • Task에 필요한 prior knowledge(사전적 지식 = 인간의 지식 = Heuristics Network)을 정확히 Encoding 해야하는, 많은 hand-designed components (= NMS, anchor generation) 를 제거했다.
      • any customized layers (heuristic한 접근법들) 을 사용하지 않았다.
      • 한방에 모든 객체를 예측한다. (Direct set prediction)
    3. flexible : 원래의 DERT 모델에서, simple segmentation head 를 추가함으로써, 쉽게 panoptic segmentation 구현했다.
    4. large objects : self-attention을 활용해서, global information을 이용해서, 큰 객체 아주 예측을 잘한다.
    5. 추가 특징
      • extra-long training schedule 이 필요하다.
      • auxiliary/parallel decoding losses 으로 부터 오는 이익이 있다.
  • 해결해야 할 도전과제들(challenge)
    • small objects

2. Related work

  • 2.1 Set Prediction (한방에 예측 세트를 찾아내는 것 = directly predict sets)
  • 2.2 Transformers and Parallel Decoding
  • 2.3 Object detection
    • Set-based loss
    • Recurrent detectors.

3. The DETR model

3.1 Object detection set prediction loss

  • DERT에서는 Single pass through the decoder를 통해서 N개의 고정된 크기 Predictions을 추출한다. 여기서 N은 평균 이미지 내부의 객체 수 보다 훨씬 크다.
  • (1) optimal bipartite matching
    • image-20210304153546840
    • 위 이미지에서 Hungarian algorithm 노동자와 일이 있을 때, 노동자에게 일을 할당하는 방법을 고르는 알고리즘이란다. (O(n!)의 경우의 수 시간을, O(n^3)으로 바꾸는 방법) 정말 필요하면, [43] 논문을 보면 될 것 같다. (내가 예측한 결과 N개와 GT N개에 대해서 1대1 대칭을 만들어 줄 때, 그 경우의 수는 n! 이다. 100! = 9.332622e+157. 100^3 = 1e+9.)
    • (문제점 발견!) 여기서 1대1 대응을 할 때, 문제가 발생할 수 있는게, 예측한 N개의 결과에서 Bounding box 위치와 Class confident만 조금 다르고 거의 같은 예측을 했다면, 하나만 정답 GT에 대응되고 나머지는 버려진다. 하지만 다르게 생각하면, N개의 예측 결과 중에서 딱 Instance의 갯수만 객체라고 예측하고 나머지는 no object라고 예측하도록 만드는 것 이기도 하다.
    • 위 이미지, 맨 아래의 수식처럼, P_i (c_i) 즉 just probabilities 값을 사용한게 아니라 log-probabilities 값을 사용했다. 경험적으로 더 좋은 성능일 보여서 log-probabilities를 최종 Loss 수식으로 정했다.
    • Class imbalance를 해결하기 위해서, no object라고 나오는 결과들의 log-probabilities는 10배 감소시켰다.
  • (2) object-specific (bounding box) losses = Bounding box loss
    • L1을 사용하면, relative scaling of the loss 문제점이 발생한다. : 만약 각각 2개의 GT BB와 Predicted BB가 있다고 하나. 하나는 박스가 Large하고 하나는 Small 하다. 만약 L1 loss를 사용하면, 2개의 BB pair에 따른 IOU가 비슷하다고 하더라도, Large Box에 대한 Loss가 더 크기 마련이다.
    • 그래서 linear combination of the L1 loss & the generalized IoU loss 를 사용한다.
    • normalization에 대해서는 4개이미지. 400개의 prediction. 의 Total loss를 400으로 나눠서 사용했다는 건가? 이건 코드를 봐야겠다.
    • image-20210304154317185

3.2 DETR architecture

  • surprisingly simple
    • transformer architecture implementation with just a few hundred lines (코드 몇줄에 네트워크 완성 가능)
    • Inference code for DETR can be implemented in less than 50 lines (코드 몇줄에 Inference 가능)
  • Transformer encoder.
    • transformer architecture는 permutation-invariant 치환불변 하기 때문에(순서에 대한 정보가 없이 Input이 들어가기 때문에), fixed positional encoding을 추가해 준다.
  • Transformer decoder.
    • 그림의 Encoder 부분에는 x N이라고 적혀있다. 이게 누적적으로 이뤄지는게 아니라, 이미지의 인풋이 계속들어가며 독립적으로 N개의 dxWH feature를 만들어 내고, 각각의 dxWH가 Decoder에 들어가는 건가? 코드를 보면서 확인해야 할 듯하다. 코드를 보니, 누적되어 결과가 나온다. 예를 들어서 Feature map input이 dxHW이면, Encoder를 계속 반복해서 최종 Encoding 값으로 (차원은 모르겠고) N개가 나온다. 그리고 이게 Decoder로 들어가서 (NLP는 Sequencail하게 결과값이 Decoder의 맨아래 outpus로 들어가지만 여기서는 그런거 없고) 한방에 N개의 Prediction 결과가 나온다.
    • (youtube) Object query : N 명의 사람들 각각이, 자기가 하고 싶은 질문은 한다. 고 상상하라. 예를 들어서 첫번째 query가 묻는다. ‘헤이 이미지! 아래 왼쪽에 있는 객체는 뭐야?’ 이런한 질문을 N번 받고, 그 결과가 N번 출력된다. 그게 Prediction set 이다. 또한 N명의 사람들은 Multi-Head Self-Attention을 통과하면서 서로서로 Communication 한다. 그래서 나오는 최종 질문이 Decoder의 Multi-Head Attention으로 들어간다.
      image-20210304181917273
    • 따라서 아래의 그림을 보면, 하나의 query에서 하나의 결과가 나오는 것을 알 수 있다. 1사람이 물어본 것에 대해서 1가지 답변을 해주니까!
    • 위에 Query 이미지 figure 7 참조 (Decoder output slot analysis) : 각각의 query는 자신만의 질문 ‘특별함’을 가진다. 각각 다른 box size와 box center position 에 집중하는 것을 확인할 수 있다.
  • Prediction feed-forward networks (FFNs).
    • 3-layer perceptron with ReLU activation function
    • ∅ is used to represent that no object 이것은 다른 OD 모델에서 the “background” class라고 예측하는 것과 비슷하다.
  • Auxiliary decoding losses.
    • use auxiliary losses [1] in decoder during training. (?)
    • 아래의 필기에서, 핫핑크 영어단어는 코드에 있는 변수이름을 그대로 적어놓은 것이다.

T6


4. Experiments

image-20210304211644160

  • DERT = ResNet50 을 backbone으로 가짐. R101 = ResNet101. DC5 = 마지막 Feature map의 Resolution을 높혀서 Small object에서도 강한 성능을 보이게 만들기 위해서, dilation 을 마지막 Layer에 추가하고( (dilated C5 stage)), 초반 conv에 stride를 적용하지 않는다.

4.2 Ablations

  • ResNet-50-based DETR model 에 대해서 최종적으로 6 encoder, 6 decoder layers and width 256를 골랐다.
  • Number of encoder layers
    1. 위의 Table2 이미지 보기. Encoder의 사용 갯수를 다르게 해봄으로써, “global image level self-attention”이 얼마나 중요한지 확인할 수 있었다.
    2. encoder 과정에서 global scene reasoning (전체 장면 추론)이 이뤄지고, objects들끼리 disentangling (서로 풀림) 이 이뤄진다고 추론했다.
    3. 아래 이미지는, 마지막 encoder layer에서 출력되는 attention maps을 시각화한 것이다. (아래 이미지를 어떤 방식으로 시각홰 했는지 모르겠다.)
      image-20210304224435901
  • Number of decoder layers
    1. 6개의 decoder layer 각각을 한 후에 auxiliary losses (?) 를 수행했다. (위에 설명 및 논문 참조)
    2. 위의 Table4 이미지 보기. Decoder를 통해서 Encoding 결과와 Object query간의 소통(communication)이 이뤄지고, cross-correlations를 서로서로 파악해가며, 성능이 좋아진다.
    3. NMS를 사용하면, 초반에는 중복 예측 중 좋은 예측을 골라주므로 성능이 좋아지지만, Decoder layer(Depth)가 증가하면 NMS에 의한 성능 증가가 작아지는 것을 확인했다. 마지막에는 NMS가 성능을 더 낮추는 일이 발생해서 NMS를 쓰지 않는 것으로 결정했다.
    4. Decoder에서도 어떻게 attention이 이뤄지는지 시각화를 해 놓았다. 객체의 머리 팔다리 사지(extremities) 에 집중하는 것을 확인할 수 있다.
      image-20210304225511150
    5. 저자의 추론을 정리하자면, Encoder에서 global attention을 이용해, Instance의 분리가 이뤄지고, decoder에서는 class and object boundaries를 검출하기 위해서, 객체의 팔, 다리, 머리 (extremities)에 집중한다.
  • Importance of FFN
    • tranformers안의 FFN은 attention module에서 1x1 conv를 하는 작업과 비슷하고 생각할 수 있다.
    • tranformers안의 FFN을 제거했을 때, parameters는 25프로가 줄었지만, AP 성능이 2.3% 감소했다. 따라서 tranformers안의 FFN는 중요하다
  • Importance of positional encodings / Loss ablations
    • image-20210305111316215

4.4 DETR for panoptic segmentation

  1. We also add a mask head which predicts a binary mask for each of the predicted boxes.
  2. 아래의 이미지처럼, transformer decoder에서 나오는 ouput과 the output of the encoder 또한 input으로 받는다.
  3. N개의 box embeding 결과로 부터, M개의 attention heatmaps를 생성한다. 여기까지는 small resolution 이다. resolution을 증가시키기 위해서, FPN-like 아래의 architecture를 사용하고, 이것에 대해서는 부록에 추가설명이 있다.
    image-20210305112536771


DETR Code Review


1. DETR_demo.ipynb

  • https://colab.research.google.com/github/facebookresearch/detr/blob/colab/notebooks/detr_demo.ipynb#scrollTo=GJhCp8y0-b-H

  • 아주 짦은 코랩 파일이다. 이해하기도 아주 쉽다. Dert Github 내용을 전혀 사용하지 않았다. nn.Transformer 만을 사용한게 전부이다.

  • ## Network 설정
    class DETRdemo(nn.Module):
        def __init__(self, num_classes, hidden_dim=256, nheads=8,
                     num_encoder_layers=6, num_decoder_layers=6):
            super().__init__()
      
            # create ResNet-50 backbone
            self.backbone = resnet50()
            del self.backbone.fc
      
            # create conversion layer
            self.conv = nn.Conv2d(2048, hidden_dim, 1)
      
            # create a default PyTorch transformer
            self.transformer = nn.Transformer(hidden_dim, nheads, num_encoder_layers, num_decoder_layers)
      
            # prediction heads, one extra class for predicting non-empty slots
            # note that in baseline DETR linear_bbox layer is 3-layer MLP
            self.linear_class = nn.Linear(hidden_dim, num_classes + 1)
            self.linear_bbox = nn.Linear(hidden_dim, 4)
      
            # output positional encodings (object queries)
            self.query_pos = nn.Parameter(torch.rand(100, hidden_dim))
      
            # spatial positional encodings
            # note that in baseline DETR we use sine positional encodings
            self.row_embed = nn.Parameter(torch.rand(50, hidden_dim // 2))
            self.col_embed = nn.Parameter(torch.rand(50, hidden_dim // 2))
              
    	def forward(self, inputs):
            # propagate inputs through ResNet-50 up to avg-pool layer
            x = self.backbone.conv1(inputs)
            x = self.backbone.bn1(x)
            x = self.backbone.relu(x)
            x = self.backbone.maxpool(x)
      
            x = self.backbone.layer1(x)
            x = self.backbone.layer2(x)
            x = self.backbone.layer3(x)
            x = self.backbone.layer4(x)
      
            # convert from 2048 to 256 feature planes for the transformer
            h = self.conv(x)
      
            # construct positional encodings
            H, W = h.shape[-2:]
            pos = torch.cat([
                self.col_embed[:W].unsqueeze(0).repeat(H, 1, 1),
                self.row_embed[:H].unsqueeze(1).repeat(1, W, 1),
            ], dim=-1).flatten(0, 1).unsqueeze(1)
      
            # propagate through the transformer
            h = self.transformer(pos + 0.1 * h.flatten(2).permute(2, 0, 1),
                                 self.query_pos.unsqueeze(1)).transpose(0, 1)
              
            # finally project transformer outputs to class labels and bounding boxes
            return {'pred_logits': self.linear_class(h), 
                    'pred_boxes': self.linear_bbox(h).sigmoid()}
          
    ## 과거 학습된 Parameter 가져옴. 
    detr = DETRdemo(num_classes=91)
    state_dict = torch.hub.load_state_dict_from_url(
        url='https://dl.fbaipublicfiles.com/detr/detr_demo-da2a99e9.pth',
        map_location='cpu', check_hash=True)
    detr.load_state_dict(state_dict)
    detr.eval();
      
    ## 예측 및 결과 추출
    outputs = model(img)
    

2. Evaluation 을 통해서 debugging 수행하기

  1. Dataset 다운받기

    detr/cocodata
      annotations/  # annotation json files
      train2017/    # train images
      val2017/      # val images
    
  2. eval 수행하기

    !python main.py --batch_size 1 --no_aux_loss --eval --resume https://dl.fbaipublicfiles.com/detr/detr-r50-e632da11.pth --coco_path ./cocodata
    
  3. 참고사항

    • engine.py -> def evaluate -> outputs = model(samples)

    • 아래의 코드 설명은, 내가 코드의 흐름을 파악하기 위해서 하나하나 함수와 클래스를 따라가면서, 필심부분만 적어놓은 것이다.

    • import main.py
      test_stats, coco_evaluator = evaluate(model, ...)
           
      import engine.py
      def evaluate(..) :
      	outputs = model(samples)
                                                 
      # ----------------------------------------------------------------------- #
           
      import main.py 
      model, criterion, postprocessors = build_model(args) 
           
      import model.detr.py 
      def build(args):
          transformer = build_transformer(args)
               
           model = DETR(
              backbone,
              transformer,
              num_classes=num_classes,
              num_queries=args.num_queries,
              aux_loss=args.aux_loss,
          )
               
      import models.transformer.py 
      def build_transformer(args): 
          return Transformer(...)
           
      import models.detr.py
      class DETR(nn.Module):
          features, pos = self.backbone(samples)
          src, mask = features[-1].decompose()
               
          hs = self.transformer(self.input_proj(src), mask, self.query_embed.weight, pos[-1])[0]
               
          outputs_class = self.class_embed(hs)
          outputs_coord = self.bbox_embed(hs).sigmoid()
          out = {'pred_logits': outputs_class[-1], 'pred_boxes': outputs_coord[-1]}
          return out
          
      
    • 그래서 아래와 같이 models.detr.py에 class DETR(nn.Module): 를 디버깅 해보았다. (디버깅 중 에러 해결. NestedTensor’ object has no attribute ‘shape)

    • 처음의 sample에는 이미지 1개가 딱 들어가는 shape를 확인할 수 있었다. 하지만 아래의 작업을 수행하기에는, 보고 싶은 변수의 type이 tensor도 아니고, 그래서 shape도 한방에 볼 수 없고, 복잡해서 디버깅은 나중에 VScode에서 진행하기로 마음먹었다.
      image-20210305132022905

【Transformer】An Image is worth 16x16 words - Image Transformers

visionTransformer

(gif 출처 : https://github.com/lucidrains/vit-pytorch)

<Vision Transformer paper>

0. Conclusion, Abstract

  1. Transformers to image recognition 을 수행해보았다.
    • 지금까지 다른 논문들은, Computer vision에서 self-attention을 사용했다. self-attention을 하기 위해서 다른 논문들은 inductive biases into the architecture (전체 Network에 attention module을 따로 설치한 행위를 의미하는 듯) 을 적용했지만, 우리는 그러지 않았다.
    • CNN에 의존하는 방식이 아니라, Pure transformer 방식을 적용했다. classification을 잘 수행하는 것을 확인했고, CNN이 필수적이 아니라는 것도 확인했다.
    • Image sequence of Patches 를 NLP에서 사용하는 Transformer encoder에 넣었다.
    • classification 과제 (ImageNet, CIFAR-100, VTAB, etc.) 에서 SOTA를 달성했고, 다른 모델에 비해 가볍다.
  2. many challenges 남아있다.
    • detection and segmentation 으로 나아가야한다. “End-to-end object detection with transformers” 를 거론하고 있다.
    • self-supervised training methods 에 대한 탐구가 더 이뤄져야한다. - Our initial 실험에는 self-supervised pre-training을 사용해서 성능 향상을 이루었다. 하지만 self-supervised 만으로는 supervised 를 이길 수 없었다.

2. Method

  • original Transformer (Vaswani et al., 2017) 를 최대한 따르려고 노력했다. (그래서 이 논문에서는 original Transformer “Attention is all you need.” 에 나오는 내용은 추가로 설명하지 않는다. 그래서 이 논문이 어렵다. “Attention is all you need.”논문의 내용은 대강 아는데, (논문을 훑어 봐도 이전 Post 내용 이외에 특별한 내용은 없다. 결국에 코드를 봐서 이해하는게 필요하다.) )

  • 논문에 나오는 내용을 아래와 같이 최종 정리 해놓았다. 이해가 안되는 건, 논문에도 안 써 있다. 결국엔 코드를 봐야한다. 코드를 보자.

  • (코드 내용 추가) 아래 이미지 사이즈에서, h = w = image_size 이며, h=w는 p로 나누어 떨어져야한다.

  • (코드 내용 추가) 특히 아래 Position Embeding은 sin을 사용하지 않고, nn.parameter를 사용해 그냥 learnable 변수로 정의했다. Class embeding 또한 nn.parameter를 사용해 그냥 learnable 변수로 정의했다.

  • image-20210302180259210

  • Hybrid Architecture

    1. 위에서는 원본 이미지를 patch로 나눈 후, 1차원 백터로 Embeding을 해서 Transformer에 그대로 넣는 방식를 취했었다.
    2. (PS) Positional embeding 값도 똑같이 1차원이여야한다. 이 값은 original Transformer 논문 처럼 sin함수를 사용해도 되고, learnable parameter를 사용해도 된다. 아래의 코드에서는 learnable parameter를 사용했다.
    3. 하지만! CNN으로 Feature Map을 일부 뽑아내고, 그렇게 뽑아낸 Feature를 Transformer에 넣는 방식은 어떨까? 이 방식을 사용한 것이 Hybrid Architecture 이다.
    4. 아래에 실험결과가 나와있지만, 결과는 학습초반에는 좀 더 좋은 성능을 보이다가, 후반에 많은 데이터로 학습 시키고 나서는 1번의 일반 Transformer를 사용한 것이 더 좋은 성능을 보여주었다.

3. Experiments and Results

  • 읽지는 않겠다.
  • 필요하면 그때 찾아 읽자.
  • Youtube 발표자료 부분에 간략히 정리되어 있기도 하다.


<Vision Transformer - Pytorch code>

  • 원래 논문의 code 는 이 사이트(google-research/vision_transformer) 이다.
  • Pytorch vit 코드 링크 https://github.com/lucidrains/vit-pytorch
  • 하지만 이 코드는 flax, vit_jax 라는 새로은 딥러닝 프레임워크를 사용한다. 이 프레임워크는 tensorflow2.0이 망할 것 같아서 구글이 새로 내놓은 프레임워크 같다. 옛날에 Raddit을 통해서, pytorch vs tensorflow vs falx+vit_jax 에 대해서 검색해 본 결과, 대충 결론은 이랬다. “tensorflow 1.3으로 나왔던 코드들은 tensorflow 2.0으로 다시 만들어 지지않는다. 최근 논문들도 대부분 pytorch를 사용한다. 구글에서 만든 것이 항상 최고는 아니다. falx+vit_jax 를 구글에서 새로 만들어 발표하기는 했지만, 이게 어떻게 될지는 아무도 모른다”
  • 앞으로 내가 살면서 Pytorch는 영원하지 않다. 개발자는 개발 언어에 큰 비중을 두어서는 안된다. 영원할 것만 같은 개발 언어도 언젠간 망하기 마련이고, 개발자는 그 변화에 빠르고 신속하게 적응해야한다. 개발자는 코딩의 전반적 지식과, 알고리즘, 그리고 논문 지식을 통해서 능력을 발휘할 수 있다.
  • 아이러니 하게도, flax, vit_jax 로 만들어진 vit (vision transformer) 코드는 1.8k stars를 가지고 있고, pytorch로 만들어진 vit 코드는 2.8k이다. 원래 것 보다 더 높은 star를 가지고 있다.

Colab 환경세팅

from google.colab import drive
drive.mount('/content/drive')
%cd /content/drive/MyDrive/GCPcode/torch_package
!ls

# !git clone https://github.com/lucidrains/vit-pytorch.git
%cd vit-pytorch
!python setup.py install

# no module einops 문제 해결방법
!pip install einops==0.2.0
!pip install einops==0.3.0
  • vision transformer 에는 몇가지 사용방법이 존재한다.
  • 16x16 Image recognition 논문에서 사용한 방법이 아래 1번의 방법이다.
  • 나머지 2번 ~ 5번의 방법은, 다른 논문에서 소개된 방법론이다. 이것까지 코드로 어떻게 사용하는지 소개해 놓았다.
    1. from vit_pytorch import ViT
    2. from vit_pytorch.t2t import T2TViT
    3. SOTA self-supervised learning technique : from vit_pytorch import ViT + from byol_pytorch import BYOL
    4. Efficient Attention : Nystromformer (computer vision cost(메모리,시간)를 낮춰주는 새로운 방법)
    5. x-transformers : used the most vanilla of attention networks
  • 따라서, 일단 나는, 16x16 Image recognition 논문을 먼저 이해하고 싶으므로, 위의 1번의 방법만 잘 이해하면 된다.
  • 위 1번 방법의 코드는 vit-pytorch/vit_pytorch/vit_pytorch.py 여기있는게 전부이다.

코드 리뷰

  • 핵심 코드 https://github.com/lucidrains/vit-pytorch/blob/main/vit_pytorch/vit_pytorch.py
  • 아래의 코드 내부 주석에 소중한 내용들이 많이 들어갔으니 꼭 참고하기!!
  • from einops import rearrange, repeat 이라는 마법의 이미지 변환 모듈을 사용했다.
  • from torch import einsum 이라는 마법의 텐서 변환 모듈을 사용했다.
    • 위의 2 모듈은 string을 입력하면 그 문자에 맞추어, 배열을 변환해 준다.
    • 예를 들어 이렇게 Rearrange("b c (h p1) (w p2) -> b (h w) (p1 p2 c)", p1 = patch_size, p2 = patch_size)
  • 실행 코드
import torch
from vit_pytorch import ViT

v = ViT(
    image_size = 256, 
    patch_size = 32,
    num_classes = 1000,
    dim = 1024, # A image patch가 변환되어, 1차원 백터가 됐을 때, 백터 원소의 갯수
    depth = 6, # Transformer blocks 갯수 ( Transformer Encoder 그림에서 x L )
    heads = 16, # heads in Multi-head Attention layer 의 갯수
    mlp_dim = 2048, # Multi Layer perceptron 에서 0층 1층 2층에서 1층의 백터 갯수
    dropout = 0.1, # [0,1] 사이의 수. default = 0 
    emb_dropout = 0.1
)

img = torch.randn(1, 3, 256, 256)
mask = torch.ones(1, 8, 8).bool() # optional mask, designating which patch to attend to

preds = v(img, mask = mask) # (1, 1000)
  • class ViT(nn.Module)
class ViT(nn.Module):
    def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, pool = 'cls', channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0.):
        super().__init__()
        assert image_size % patch_size == 0, 'Image dimensions must be divisible by the patch size.'
        num_patches = (image_size // patch_size) ** 2 # ( 224/32 = 16 ) ** 2 = 256의 Patchs
        patch_dim = channels * patch_size ** 2  # patch 하나가 가진 pixel의 총 갯수 = 32*32*3 = 3072
        assert pool in {'cls', 'mean'}, 'pool type must be either cls (cls token) or mean (mean pooling)'
        
        # from einops import rearrange, repeat 이라는 마법의 이미지 변환 모듈 사용
        # 아래의 과정을 통해서 이미지를 1차원 dim
        self.to_patch_embedding = nn.Sequential(
            Rearrange('b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = patch_size, p2 = patch_size),
            nn.Linear(patch_dim, dim), # 3072 -> 1024
        )

        # sin 함수를 이용한 embedding을 하는 줄 알았는데... 
        # randn 은 그냥 원하는 크기의 Tensor를 설정해줄 뿐, Parameter로 세팅해놓음으로써, Learnable이 된다.
        # 즉 pos_embedding 그리고 cls_token 는 Just Tensor가 아니라 Learnable 이다.
        self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))
        self.cls_token = nn.Parameter(torch.randn(1, 1, dim))
        self.dropout = nn.Dropout(emb_dropout)

        # Transformer Encoder layer 정의
        self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)

        self.pool = pool  # string in {'cls', 'mean'}
        self.to_latent = nn.Identity()

        # layerNorm 이라는게 있나보다. 그냥 mlp_head는 nn.Linear 라고 생각하면 편하다.
        self.mlp_head = nn.Sequential(
            nn.LayerNorm(dim),
            nn.Linear(dim, num_classes) # 1024 -> 1000
        )

    def forward(self, img, mask = None):
        x = self.to_patch_embedding(img)
        b, n, _ = x.shape

        cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)
        x = torch.cat((cls_tokens, x), dim=1)
        x += self.pos_embedding[:, :(n + 1)]
        x = self.dropout(x)

        x = self.transformer(x, mask)
        # print(x.shape) # torch.Size([1, 65, 1024])

        x = x.mean(dim = 1) if self.pool == 'mean' else x[:, 0]
        # print(x.shape) # torch.Size([1, 1024])

        x = self.to_latent(x)
        out = self.mlp_head(x)
        # print(out.shape) # torch.Size([1, 1000])
        return out
    
"""
여기서 알아야 하는 것.
nn.LayerNorm(dim)
nn.Identity()
class Transformer(nn.Module):
"""
  • class Transformer(nn.Module):
  • 논문 그림에서 “Transformer Encoder” 를 그대로 코드 구현을 해 놓은 것이다.
class Transformer(nn.Module):
    def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):
        super().__init__()
        self.layers = nn.ModuleList([])
        for _ in range(depth):
            self.layers.append(nn.ModuleList([
                Residual(PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout))),
                Residual(PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout)))
            ]))
    def forward(self, x, mask = None):
        for attn, ff in self.layers:
            x = attn(x, mask = mask)  # LayerNorm + Attention   + Residual 	
            x = ff(x)			      # LayerNorm + FeedForward + Residual 
        return x

"""
여기서 알아야 하는 것.
Residual
PreNorm
FeedForward
Attention
"""
  • class Residual : Skip connection 구현
  • class PreNorm : LayerNorm + [FeedForward or Attention]
  • class FeedForward : Multi Layer perceptron = 2층 nn.Linear
class Residual(nn.Module):
    # Skip connection 구현
    def __init__(self, fn):
        super().__init__()
        self.fn = fn # 무조건 class PreNorm 
    def forward(self, x, **kwargs):
        return self.fn(x, **kwargs) + x

    
class PreNorm(nn.Module):
    # LayerNorm + [FeedForward or Attention]
    def __init__(self, dim, fn):
        super().__init__()
        self.norm = nn.LayerNorm(dim)
        self.fn = fn  # class FeedForward 혹은 class Attention 둘 중 하나
    def forward(self, x, **kwargs):
        x = self.norm(x)
        return self.fn(x, **kwargs)

    
class FeedForward(nn.Module):
    # Multi Layer perceptron = 2층 nn.Linear
    def __init__(self, dim, hidden_dim, dropout = 0.):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(dim, hidden_dim),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, dim),
            nn.Dropout(dropout)
        )
    def forward(self, x):
        return self.net(x)

  • class Attention(nn.Module) : Multi Head Attention 모듈 구현
  • 아래에서 Keys, Querys, Values가 의미하는게 뭘까? 이전Post 내용에 따르면, 1차원 백터에서 어떤 부분에 더 집중해야 하는지? 를 나타낸다고 한다.
  • 아래의 qkv = self.to_qkv(x).chunk(3, dim = -1) 에서 x는 이미지 전체를 1차원 백터(1024개)로 embeding한 값들이 8*8 (64개 patchs)가 모두 모여 있는 백터이다. 즉, 1024 x 64의 x.shape를 가지고 있을 것이다.
  • 자, 그렇다면 64개의 patch 하나하나를 하나의 단어라고 생각하자.
  • 이전Post 내용에 따르면 “Hello I love you”에서 Love는 I와 you에 더 attention해야하고, 따라서 더 큰 weight를 줘야한다.
  • 같은 원리로 64개의 patch 각각에 대해서, 1개의 Patch는 다른 patch 중 어느 것에 더 집중해서 attention해야하는지를 weight값으로 알려주는 것이 Keys, Querys, Values이고, 이 처리를 모두 하고 나온 백터가 qkv이다.
class Attention(nn.Module):
    def __init__(self, dim, heads = 16, dim_head = 64, dropout = 0.):
        '''
        dim = patch를 1차원화 백터 원소의 갯수 = 1024 개
        heads = 1, 2, 3 ... ~ h (Multi-head Attention)에서 h 갯수
        
        처음 들어가는 1개 image patch의 차원 [1, 1024]
        [x1 ~ x65] = [1, 65, 64] # 원래 patch갯수는 64개 + extra class embedding 1개 = 65개
        하나의 Head에 의해 나오는 y_i의 차원 [1, 64]
        [y1 ~ y65] = [1, 65, 64] 
        '''
        super().__init__()
        inner_dim = dim_head *  heads # 64*16 = 1024
        project_out = not (heads == 1 and dim_head == dim)

        self.heads = heads
        self.scale = dim_head ** -0.5 # 0.125
		"""
        # qkv의 nn.linear 를 그림처럼 따로 하는게 아니라, 한꺼번에 해버린다.
        # 아래의 *3 이 의미하는 것은 qkv 3개를 말하는 건가?
        # inner_dim 은 qkv 중 하나의 linear를 통과했을 때 나오는 총 원소의 갯수
        # 즉 dim_head는 위 Transformer 이미지에서, 하나의 작은 linear를 통과했을 때 나오는 원소의 갯수 이다. 
        
        # input은  queries, keys, values와 연산되어 (nn.linear), forward 코드와 같이 각각 q, k, v 변수가 된다. 
        # by queries : (input)1024 vectors -> 64 vectors * 16개 head 
        # by keys : 1024 vectors -> 64 vectors * 16개 head 
        # by values : 1024 vectors -> 64 vectors * 16개 head 
        """
        self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)

        self.to_out = nn.Sequential(
            nn.Linear(inner_dim, dim), # (64*16 = 1024) -> 1024개
            nn.Dropout(dropout)
        ) if project_out else nn.Identity()

    def forward(self, x, mask = None):
        """
        # heads의 갯수 설정으로 내부에서 다수의 head가 알아서 돌아간다. 
        # 주의! heads는 Transformer Encoder의 Lx에서 L이 아니다! 맨 위 사진의 1~h에서 h 이다!
        # 따로 분류해서 연산하지 않고, 한꺼번에 묶어서 연산해 버린다. 
        # 그래서 이 코드로는 위 그림의 이해가 한방에 되지 않을 수 있다.
        
        # 따라서 아래 내용이 복잡하지만... "이거 다 통과하면 하나의 Multi Head Attention 을 통과하는 구나! 라고 알아두자."
        """
        
        b, n, _, h = *x.shape, self.heads
        # print(x.shape) # torch.Size([1, 65, 1024])
        qkv = self.to_qkv(x).chunk(3, dim = -1) 
        # print(qkv.shape, qkv[0].shape) # (3,) torch.Size([1, 65, 1024])
        # torch.chunk Tensor를 자른다.
        # q, k, v 각각, input에서 by queries, keys, values 처리를 하고 나오는 '결과'
        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), qkv) 
        # print(q.shape,k.shape,v.shape) # torch.Size([1, 16, 65, 64]) torch.Size([1, 16, 65, 64]) torch.Size([1, 16, 65, 64])

        # torch.einsum (https://pytorch.org/docs/stable/generated/torch.einsum.html)
        # tensor를 원하는 형태로 변환해줘!
        dots = einsum('b h i d, b h j d -> b h i j', q, k) * self.scale
        mask_value = -torch.finfo(dots.dtype).max

        if mask is not None:
            mask = F.pad(mask.flatten(1), (1, 0), value = True)
            assert mask.shape[-1] == dots.shape[-1], 'mask has incorrect dimensions'
            mask = rearrange(mask, 'b i -> b () i ()') * rearrange(mask, 'b j -> b () () j')
            dots.masked_fill_(~mask, mask_value)
            del mask

        attn = dots.softmax(dim=-1)

        out = einsum('b h i j, b h j d -> b h i d', attn, v)
        """
        여기까지 out = torch.Size([1, 16, 65, 64])
        <맨 위의 Transformer 최종 정리 사진과 꼭 함께 보기>
        이 말은 하나의 Head에 의해 나오는 y_i는 64개의 백터를 가진다. 총 [y1 ~ y65] = [1, 65, 64] 차원을 가지게 된다. 
        """
        out = rearrange(out, 'b h n d -> b n (h d)')
        out =  self.to_out(out)
        # print(out.shape) # torch.Size([1, 65, 1024])
        return out

Youtube 발표자료

p1

P2

![PR-281_ An Image is Worth 16x16 Words_ Transformers for Image Recognition at Scale_210303110807-10.png](https://github.com/junha1125/Imgaes_For_GitBlog/blob/master/2021-1/16x16_Transformers_for_Image_Recognition/PR-281%20An%20Image%20is%20Worth%2016x16%20Words_%20Transformers%20for%20Image%20Recognition%20at%20Scale_210303_110807-10.png?raw=true)

  • Method는 내가 한 정리가 더 좋다.
  • Experiments and Results

P3

P3

P4

P5

P5

P5

P5

P5

P5

【MOT】MOTS - Multi-Object Tracking and Segmentation

  • 논문 : MOTS: Multi-Object Tracking and Segmentation
    필기 완료된 파일은 OneDrive\21.겨울방학\RCV_lab\논문읽기 에 있다.
  • 분류 : MOT
  • 저자 : Paul Voigtlaender, Michael Krause, Aljosa sep, Jonathon Luiten
  • 읽는 배경 : 연구실 과제 참여를 위한 선행 학습
  • 느낀점 :
    • 코드를 많이 보고 싶은데, Tensorflow….
    • 솔직히, 결과들을 보면 이 모델이 정말 좋은 모델인가..? 라는 생각이 든다. Conv3D 그리고 Association head에서 다른 것들에 비해서 좋은 성능이 나왔다는 생각이 많이 들지 않는다.
    • 그들의 성능평가 matrix 자체 점수를, 원래 조금이라도 올리기가 매우 힘든건가? 확실히 아직은 MOTS 에 대해서 더 많은 연구가 이뤄져야 할 듯 하다.
    • 이 논문보다는 다른 (bounding box) MOT 논문을 찾아 다시 공부하자. 그렇게 신박한 방법은 없다. 아래의 내용정리만으로 이해가 어려우니, 필요하면 논문을 다시 보고 + 코드를 다시보고 공부해야한다. 아니면 MOT 논문을 공부해보고 이 논문을 다시 보자.


0. Abstract, Conclusion

  • (문제점) 지금까지 MOT + Segmentation을 같이 수행하는 benchmark model과 dataset이 존재하지 않았다.
  • (해결) 우리가 semi-automatic annotation procedure을 사용해서 만든 2개의 MOT dataset을 소개했다. 이미 존재하는 MOT 데이터(Bounding Box detection only) 에서 Segmentation 정보를 직접 추출해서, 그거를 Training data로 사용했다.
  • 기존의 MOTA matrics(평가지표)을 기반으로 새로 만들어낸 MOTSA, sMOTSA를 소개했다.
  • baseline model을 개발했다. detection + tracking + segmentation 을 모두 동시에 하는 single convolutional network 이다.

1. Introduction

  • (현재) bounding box level tracking 성능이 Saturation 되었다.
  • (문제점) 하지만 bounding box level tracking 에는 문제점이 있다. 겹처진 객체에 대해서 too coarse 한 BB를 가진다는 점이다. 또한 BB는 object에 대한 roughly fit 이기 때문에, overlapping BB(서로 겹치게 예측된 BB)와 그 GT를 비교하면, ambiguities 존재하는 것을 알 수 있다. (predicted BB가 맞는것(Positive)… 같기도 하면서 아니기도 한 그런…)
    image-20210219193943400
  • (해결책) BB와 다르게 Segmentation 정보는 non-overlapping 하므로 GT와 비교할 때 아주 단순한 방법으로 비교 가능하다.
  • (그래서 우리는) Mask R-CNN에 3D convolution을 사용한 TrackR-CNN을 만들어 냈다.
  • 논문 전체 contributions(summary)
    1. KITTI [13] and MOTChallenge [38] datasets 를 기반으로 MOTS를 위한 dataset 생성
    2. soft Multi-Object Tracking and Segmentation Accuracy (sMOTSA) measure(평가지표) 소개
    3. TrackR-CNN
    4. 우리 모델의 유용함 증명한다. 그 뿐만 아니라, 우리의 데이터 셋과, segmentation + tracking single network가 충분히 있음직하고 좋은 성능을 발휘한다는 것을 증명할 것이다.

2. Related work

  1. Multi-Object Tracking Datasets : a known set of classes로부터 unknown number of targets을 추적한다. Bounding box를 기반으로 한다. + 논문에 데이터셋 몇가지가 소개되어 있다.
  2. Video Object Segmentation Datasets : instance segmentations을 수행하기는 하나, 일렬의 비디오에 only few objects 만이 존재한다. 우리의 MOTS 모델은 미리 정의된 classes들과 crowded objects를 고려한다. + 논문에 데이터셋 몇가지가 소개되어 있다.
  3. Video Instance Segmentation Datasets : Cityscapes처럼 automotive scenario를 사용하는 3개의 데이터 소개한다. 하지만 이들은 동영상이 아주 작은 subset(짧은 frame 수)으로 구성되어 있거나, 특히 ApollloScape 데이터는 객체의 identities 정보가 없다. (tracking dataset으로 사용 불가)
  4. Methods
    • MOTS와 비슷한 작업을 하는 다른 논문들 몇가지 소개. 필요하면 찾아보기. 다른 논문들과 달리 MOTS는 많은 객체들이 동영상에서 들어가고 나간다. 또한 다른 논문들은 segmentation tracking 정보를 추출할 수는 있지만, MOTS annotation dataset이 없었기 때문에, 그들의 performance를 평가할 수 없었다.
    • LSTM을 사용해서 Tracking을 수행하는 2개의 논문 소개한다. [34, 2017], [51, 2017] 하지만 이들은 detection을 수행한 Frame들에 대해서 Hungarian matching procedure라는 전통적인 후처리 방법을 사용한다. MOTS에서는 그런 후처리 작업 수행하지 않는다.
  5. Semi-Automatic Annotation (반 자동 instance segmentation 주석 처리 방법)
    • deep learning을 사용하지 않는 전통적 컴퓨터 비전 방식의 annotation 기술들 몇가지가 소개 된다.
    • MOTS에서는 Polygon-RNN 이라는 방법을 사용한다. 다각형의 꼭지점을 정의하는 모델이다.
    • Fluid Annotation(사진 전체 mask-rcnn) 방법은, Tracking을 고려하지 않고, base dataset의 bounding box annotation 정보도 사용하지 않기 때문에, MOTS에서 사용하지 않는다.

3. Datasets

  1. Semi-automatic Annotation Procedure
    1. DeepLabV3+ 모델을 사용한다. Input에는 BB에 의해 crop된 + 아주 작은 region added(BB보다 조금 크게) 가 이뤄진 이미지를 사용한다.
    2. COCO, Mapillary dataset으로 pre-train 된 DeepLabV3+모델이라 할지라도, [KITTI MOTS, MOTSChallenge] dataset을 1번과 같은 방법으로 inference를 수행하면 성능이 poor하다고 한다. (아마 domain change 때문에) 그래서 초반에는 all manually created masks 를 가지고 학습시켜준다. 그러다 보면 상대적으로 괜찮은 Mask predict 값을 추출하게 되는데, 이때도 아직은 완벽하지는 않다.
    3. 위 과정 이후, DeepLabV3+을 이용해서 우선 predict segmentation를 하고, 그렇게 나오는 결과값(flawed generated masks)을 직접 manually 수정한다. 이렇게 수정한 이미지를 사용해 training을 다시 수행한다.
    4. 일정수준의 pixel-level accuracy이 나올때까지 위의 작업을 계속 반복하며 수행한다.
  2. KITTI MOTS dataset
    • 원래 이 데이터는 21개의 training sequences를 가지고 있다. 이것을 MOTS를 하기 위해 적절히 나눈다. car, pedstrian의 전제 숫자가 비슷하도록 데이터를 최대한 잘 분배했다. training set : validation set = 12 : 9
    • 특히나, 이 데이터를 pre-train 된 DeepLabV3+에서 inference를 하면 poorly 성능을 보인다. 이것은 “instance segmentation model들이 temporal reasoning을 사용(결합)해야만 한다는” 주요한 동기부여가 된다. (뭔소린지 정확히 모르겠다. instance segmentation을 하기 위해 temporal 정보를 어떻게든 사용한다면 성능이 훨씬 좋아질 수 있다는 건가? 이 방법을 사용해서 연구를 해도 좋을 것 같다.)
  3. MOTS Challenge dataset
    • 이 데이터 셋은 특히나 pedestrians in crowded scenes으로 이루어져 있다. 따라서 많은 occlusion(겹침) 문제가 발생한다. 따라서 pixel-wise description(mask 정보) 를 사용함으로써 특별히 이득을 볼것으로 예상된다고 한다.

image-20210219203814793


4. Evaluation Measures

  1. 변수 정의
    • M은 Ground True Segmentation 정보 ( 1 instance -> 1 channel bool 형식 )
    • H가 Predicted Segmentation hypothesis (예측 Instance Segmentation 값)
    • image-20210220180053696
  2. Establishing Correspondences (Predict를 얼마나 Correct하게 했는지 수치화)
    • image-20210220180940631
    • 위 그림에 숫자 동그리마 필기 찾기.
    • 0번째 수식 : c(h) = IOU 값을 이용해선 correctness 수치화량 값. 보통 Segmentation에서는 IOU(h,m) > at most 0.5 를 겨우 넘는 수준이라고 한다. 즉 BB보다 IOU값이 높게 나오기 힘들다.
    • 1번째 수식 ~ 3번째 수식 : h (prediced mask instance 집합의 원소), m (ground ture mask instance 집합의 원소) 를 활용한 TP, FP, FN 정의
    • 4번째 수식 : mask 뿐만 아니라, id까지 동일해야 한다. t에 관한 수식은 GT dataset에서 (논문의 주석5) does not count id switches if the target was lost by the tracker 이기 때문에 저런 수식이 나오는 듯 하다. 그리고 같은 ID인지 판단하는 알고리즘은 정확하게 적혀있지 않아있다. 따라서 필요하면 직접 코드를 보고 공부를 해야할 듯 하다.
    • 5번째 수식은 (IDS 수식은 정확히 이해되지 않는다. 필요하면 다시 공부하자.) m들 중에서, h들과 고려해봤을때 (같은 mask를 가르키고 있다고 판명할 만한 h가 있기는 하지만) ID까지 일치하는 객체가 없는 m의 갯수이다. 이것도 높으면 안 좋은 것.
  3. Mask-based Evaluation Measures
    • 아래의 수식들은 CLEAR MOT metrics [4, 2008]의 내용들을 기반으로 한다. 따라서 완벽한 이해가 안되면, CLEAR MOT 수식에 대해서 먼저 공부해야할 듯 하다.
    • image-20210220181902975
    • 얼마나 MOTS를 잘 수행하고 있는지 계산하는 matrix들이다.
    • 6번째 ~ 9번째 수식들을 사용하면 되고, 이 값이 높을 수록 MOTS가 잘 수행되고 있다고 판단할 수 있다.

5. Method

image-20210220182108558

  1. 아래의 내용들이 그렇게 구체적이지 않다. 따라서 이용하고 싶다면, 코드를 꼭 봐야할 필요가 있다. (Tensorflow 1.13 코드)
  2. Integrating temporal context
    • depthwise separable 3D convolution layers with 3×3 (spatial) ×3 (time) filter kernels. 즉 위의 필기에서 (3x3x256)은 filter 는 필터 차원이고, x128은 filter 의 갯수이고, 3x는 3D conv를 필요한 추가 차원이다.
    • ResNet-101
    • 위의 사진에서는 3D conv가 들어가지만, 대체신경망으로 (일반 LSTM과 다르게 the spatial structure 를 유지하고 있는) Convolutional LSTM (+ skip connection) 을 사용하는 것도 고려해 보았다고 한다. 논문에서 Convolutional LSTM를 검색하면, 이것을 사용할 때의 장점, 효과, 실험과정, 에 대해서 간단히 살펴볼 수 있다.
  3. Association Head
    • Association Head를 사용한 Inference
      • fully connected layer
      • Association Vectors 를 생성한다. 두 백터 사이의 유사도 판별은 단순하게 Euclidean distance 방법을 사용한다.
      • image-20210220182250679
    • Association Head 학습시키기
      • the batch hard triplet loss (proposed by Hermans et al. [18] adapted for video sequences) 의 방법을 사용하여 학습시킨다.
      • D denote the set of detections for a video (비디오에서 검출되는 모든 객체의 갯수)
      • d ∈ D consists of a mask mask_d and an association vector a_d
      • 아래 수식에서 margin alpha = 0.2가 가장 좋았다.
      • image-20210220182453584
  4. Mask Propagatio
    • image-20210220182551872
    • PWC-Net [55, 2018] 모델을 사용해서 Optical flow 계산
  5. Tracking
    • 이 내용은 논문에서 수식과 디테일 없이 간단하게 적어놓았다. 논문을 봐도 이해가 잘 안된다.
    • their association vector similarity (Euclidean distance)를 기반으로 Tracking을 수행한다. γ threshold 이상을 가지는 detections를 찾는다.
    • the Hungarian Algorithm을 사용햐서 Matching을 수행한다. threshold of β 이상을 가지는 detection을 찾는다.
    • 적절한 tracking hyper-parameter (δ, β, γ)를 찾기 위해 random search(이것저것으로 다 실험해봄)를 사용했다고 한다.
    • The resulting tracks (tracking하기 위해 찾아낸 detections) 들 서로서로가 겹칠 수 있다. (다중으로 뽑힐 수 있다.) 여기서는 MNS와 같은 방식으로 a higher confidence를 가지는 mask detections들을 선택한다.

6. Experiments

  • 40 epochs
  • a learning rate of 5 · 10^(−7) using the Adam optimizer
  • mini-batches which consist of 8 adjacent frames
  • Titan X
  • a speed of around 2 frames per second (아마 1번 mini-batch 결과가 나오는데, 4초 정도 걸리나 보다)
  • Main Results
    • image-20210220230519597
    • 맨위의 TrackR-CNN(box orig)는 mask head 가 없는 TracR-CNN이다. (PS. CAMOT [43] : stereo 정보를 사용)
    • +MG : segmentation masks as a post-processing step. 즉 Mask R-CNN의 the mask head 이라고 한다.

    • 코드 사용이 가능한 Segmentation-based tracker 가 없다. 대신 the bounding box-based tracker인 CIWT [42] and BeyondPixels [53]에 fine-tunning된 Mask R-CNN의 the mask head를 결합한 모델을 사용해 보았다.
  • Temporal Component
    • backbone feature map과 RPN 사이의 2개의 Conv3D (two depthwise separable 3D convolutional layers)를 넣었을 때의 장점
    • image-20210220233713166
  • Association Mechanism
    • image-20210220233436415
    • Association head를 사용하지 않고, 다른 기본적인 방법을 사용했을 때 성능의 증가율
  • Results on MOTS Challenge
    • image-20210220233927803
    • four methods that perform well on the MOT17 benchmark + Mask R-CNN fine-tuned on MOTSChallenge 이 모델들에 비해서는 좋은 성능을 보이고 있다.
    • 마지막 결과을 보면 확실히 segmenting all pedestrians 이 매우 어려운 문제로 남아있다는 것을 확인할 수 있다.

【Re-ID】Person Re-identification A Survey and Outlook w/ my advice

  • 논문 : Deep Learning for Person Re-identification: A Survey and Outlook
    필기 완료된 파일은 OneDrive\21.겨울방학\RCV_lab\논문읽기 에 있다.
  • 분류 : Re-identification
  • 저자 : Mang Ye, Jianbing Shen
  • 읽는 배경 : 연구실 과제 참여를 위한 선행 학습
  • 느낀점 :
    • 이 논문의 특징은, reference가 200개가 넘는다. 정말 자세하고 많은 것을 담고 있는 논문이다. 어차피 이 것을 다 이해하려면 1년이 더 걸린다. 따라서 지금 하나하나 이해해서 다 기록해 두려고 하지말고, 전체 그림만 그릴 수 있도록 스키밍을 하면서 빠르게 읽어나간다. 그리고 정리는 핵심과 큰 윤곽만 정리해 나간다.
    • 이 논문의 Reference의 핵심 논문이 너무 너무 많아서, 뭐 읽어야 겠다.. 라는 생각이 드는 논문이 거의 없다. 결국에는 나중에 SOTA 찍는 모델과 논문을 다시 보면서 공부해야한다. 여기서는 아주아주 큰 그림만 잡는다.
    • 이 논문을 읽다보니, 나는 우주 속 먼지보다 작은 존재로 느껴졌다. 정말 보고 읽어야 할게 산더미다!! 근데 차라리 이래서 더 안심이다. 차라리 이렇게 산더미니까 다 읽지는 못한다. 따라서 그냥 하루하루 하나씩 꾸준히 읽어가는 것에 목표를 둬야 겠다. 논문은 “다 읽어버리겠다!가 아니다. 꾸준히 매일 읽겠다! 이다.” 라는 마음을 가지자!


0. Abstract

  1. Person re-ID란? 겹치지 않는 다중 카메라들 사이에 person of interest를 검색(retrieving)하는 것
  2. 쉽게 설명해 보겠다. 3개의 카메라가 있다. 각 카메라는 구도와 공간이 다르다. 3개 이미지에는 많은 사람이 들어가 있고, 공통적으로 query person이 들어가 있다. 만약, 첫번째 이미지안의 query person이 query로 주어졌을 때, 나머지 2개의 이미지에서 다른 사람(boudning box는 이미 제공됨)이 아닌, 같은 query를 찾는 것이 Re-ID 과제 이다.
  3. 3개의 다른 perscpecitve를 가지는 closed world Person-Re-ID (상용화를 위한 것이 아닌 연구 단계의 연구들 = research-oriented scenarios)에 대한 종합적 개요가 있다. with (1) in-depth analysis (2) deep feature representation learning (3) deep metric learning (4) ranking optimization. 이 연구는 이미 거의 포화 상태다.
  4. 그래서 5개의 다른 perscpective를 가지는 Open-world setting으로 넘어가고 있다. (상용화를 위한 연구 단계의 연구 = practical applications)
  5. 이번 논문에서 새로 소개하는 것은 이런 것이 있다.
    1. a powerful AGW baseline
    2. 12개의 Dataset
    3. 4개의 다른 Re-ID task
    4. e a new evaluation metric (mINP)


1. Introduction

<Introduction 서론>

  1. 초기에는 a! specific person를 찾기 위함이었다. 시대의 발전과 공공 안전 중요도의 증가, 지능형 감시 시스템 need에 의한 기술 발전이 이뤄지고 있다.
  2. Person Re-ID의 Challenging task (방해요소들) : [the presence of different viewpoints [11], [12], varying low-image resolutions [13], [14], illumination changes [15], unconstrained poses [16], [17], [18], occlusions [19], [20], heterogeneous modalities [10], [21], complex camera environments, background clutter [22], unreliable bounding box generations, etc. the dynamic updated camera network [23], [24], large scale gallery with efficient retrieval [25], group uncertainty [26], significant domain shift [27], unseen testing scenarios [28], incremental model updating [29] and changing cloths [30] also greatly increase the difficulties.] 이런 요소들이 있기 때문에 연구들은 더욱 더 이뤄져야 한다.
  3. 딥러닝 이전에는 이런 기술들을 사용했다. the handcrafted feature construction with body structures [31], [32], [33], [34], [35] or distance metric learning [36], [37], [38]
  4. 딥러니 이후에는 [5], [42], [43], [44] 이 논문이 놀라운 성능을 내었다
  5. 이 Survey 논문의 특별한 차별점
    1. powerful baseline (AGW: Attention Generalized mean pooling with Weighted triplet loss) 제시한다.
    2. new evaluation metric (mINP: mean Inverse Negative Penalty) 제시한다. mINP는 현재 존재하는 지표인 CMC/mAP를 보충하는 것으로써, 정확한 matches를 발견하는 cost를 측정한다.

<Introduction 본론>

image-20210217132329680

일반적인 Re-ID 시스템은 아래의 5 절차를 거친다.

  1. Raw Data Collection : 감시 카메라로 부터 영상 받아오기
  2. Bounding Box Generation : Detecting, Tracking Algorithms 이용하기
  3. Training Data Annotation : Close world에서는 Classification 수행하기. Open world에서는 unlabel classification 수행하기
  4. Model Training : Re-ID 수행하기 (다른 카메라, 같은 Label data를 묶고, 전체를 Gallery에 저장하기.
  5. Pedestrian Retrieval : Query person 검색하기(찾기). 여기서 query-to-gallery similarity를 비교해서 내림차순으로 나열하는 A retrieved ranking를 수행한다. 이 작업을 위해 retrieval performance를 향상시키기 위한, the ranking optimization을 수행해야 한다.

image-20210217132347553

Closed-world 에서 Open-world Person Re-ID 으로의 필요한 핵심 포인트(또는 closed-world 연구에서의 핵심 가정 - 미리 위와 같은 5개의 과정을 해놓고 연구를 진행했던 것이다. 하지만 Open World에서의 저 가정은 옳지 않을 것이다.)

  1. ingle-modality vs. Heterogeneous Data : 지금은 카메라 영상 만을 이용하는데, infrared images [21], [60], sketches [61], depth images [62] 등을 활용한 Re-ID연구와 사용이 필수적이다.
  2. Bounding Box Generation vs. Raw Images/Videos : close world에서는 “Search + Predict + Bouning Box는 이미 되었다” 라고 가정하고 Re-ID를 수행한다. 하지만 이제는 이 모두를 수행하는 end-to-end person search가 필요하다.
  3. Sufficient Annotated Data vs. Unavailable/Limited Labels : label classification은 실생활에서 불가능하다. limited labels이기 때문이다. 따라서 unsupervised and semi-supervised Re-ID 연구가 필요하다.
  4. Correct Annotation vs. Noisy Annotation : close world에서는 정확한 Bounding Box가 주어진다. 하지만 실제 Detection 결과는 부정확하고 Noise가 있다. noise-robust person Re-ID를 만드는 연구가 필요하다.
  5. Query Exists in Gallery vs. Open-set : close world에서는 Gallery에 query person이 무조건 존재한다고 가정한다. 하지만 없을 수도 있는거다. 검색(retrieval)보다는 the verification(존재 유무 확인 및 검색)이 필요하다.

<Introduction 결론>

논문 전체 목차

  • § 2 : closed-world person Re-ID
  • § 2.4 : datasets and the state-of-the-arts
  • § 3 : the open-world person Re-ID
  • § 4 : outlook(견해) for future Re-ID
  • § 4.1 : new evaluation metric
  • § 4.2 : new powerful AGW baseline
  • § 4.2 : under-investigated open issues (아직 연구가 덜 된 분야)


2. Closed-world Person Re-ID

2-1 Feature Representation Learning

  • 이미 Detected 된 사람의 Bounding box에 대해, 이 Feature Representation(이하, Feature)을 어떻게 추출할 것인가? 사람의 포즈가 변해도, 바라보는 방향이 변해도, 카메라의 조도 등이 변해도 같은 Feature(descriptor)가 나오도록 하는 방법이 무엇일까? 크게 아래와 같이 4가지 방법이 있다.
  • image-20210217171528393
  1. Global Feature Representation Learning
    • Box 전체를 이용해서 Feature를 뽑아 낸다.
    • 대표적인 논문 : (1) ID-discriminative Embedding (IDE) model [55, 2017] (2) a multi-scale deep representation learning [84, 2017]
    • Attention Information는 feature 향상을 위해서(좀더 의미있는 정보추출) 사용된다. 아래 2개 논문이 핵심.
    1. pixel level attention : [90, 2019], robustness를 향상시켜주었다.
    2. A context-aware attentive feature learning : multiple images 사용 [95, 2019], the feature learning 향상시켜줌.
  2. Local Feature Representation Learning
    • 과거에는 human parsing/pose detector를 이용해 human parsing/pose을 먼저 추출하고, 각 부분에 대해서 Feature를 뽑아냈다. 이렇게 하면 성능은 좋지만 추가적인 detector가 필요하고, 이 detector 또한 완벽하지 않으므로 추가의 Noisy를 만들어 냈다.
    • 위와 같은 단점 때문에 horizontal-divided region features 를 사용한다. Fig2(b) 처럼. 가장 기초 논문은 Part-based Convolutional Baseline (PCB) [77]이고, 이것으로 SOTA를 찍은 논문은 [28], [105], [106]이다. 이 방법은 more flexible하다는 장점이 있지만, occlusions and background clutter(box내부 사람이 차지하는 공간이 아닌 다른 공간)에는 약한 단점이 있다.
  3. Auxiliary Feature Representation Learning = 추가 데이터를 활용한 Feature Learning = 아래의 방법으로 모두 좀 더 좋은 성능의 the feature representation를 추출할 수 있었다.
    • Semantic Attributes : male, short hair, red hat 과 같은 추가 정보를 이용하는 것이다.
    • Viewpoint Information
    • Domain Information : 다른 카메라 이미지를 다른 도메인이라고 여기고, 최종적으로 globally optimal Feature를 얻는다.
    • GAN Generation : the cross camera variations를 해결하고 robustness를 추가하기 위해서, the GAN generated images를 사용한다.
    • Data Augmentation
  4. Video Feature Representation Learning
    • a video sequence with multiple frames를 사용함으로써, 더 강력한 feature와 temporal information를 추출한다.
    • Challenge1 : the unavoidable outlier tracking frames(?뭔지 모름) 그리고 이것을 해결하려는 논문들 소개. 특히 매우 흥미로운 논문인 [20] [Vrstc: Occlusion-free video person re-identification in CVPR, 2019] 에서는 auto-complete occluded region를 수행하기 위해서, the multiple video frames를 사용한다.
    • Challenge2 : handle the varying lengths of video sequences. 그리고 이것을 해결하려는 논문들 소개.
  5. Architecture Design
    • Re-ID features를 더 잘 추출하기 위해서, Backbone을 수정하는 논문들
      1. the last convolutional stripe/size to 1 [77]
      2. adaptive average pooling in the last pooling layer [77], [82]
    • Re-ID 전체 과정 수행 논문 추천 : [112], [137], An efficient small scale network [138]
    • Auto-ReID [139] model : NAS를 사용하여, 효율적이고 효과적인 model architecture 추출.

2.2 Deep Metric Learning

image-20210217203628110

(a) Identity Loss.

  • an image classification problem 사용함. 이 Loss를 바꿔서 만든 다른 Loss 수식 또한 이와 같이 있다. (1) the softmax variants (2) the sphere loss (3) AM softmax (4) label smoothing(overfitting을 피하는데 효과적인 Loss) 과 같은 방법이 있다.
  • image-20210217203922526

(b) Verification Loss :

  1. The contrastive loss :
    • image-20210217204205277
  2. The verification loss with cross-entropy
    • image-20210217204439714
    • 사실 이 수식의 p 가 무슨 함수를 사용한 건지 모르겠다. 논문을 몇번이나 다시 읽고, reference paper도 확인해 봤는데, 어떤 곳에서도 p는 그냥 probability of an input pair (xi and xj) being recognized as δij (0 or 1) 이라고만 적혀 있다. 나중에 코드를 통해서 확인해 봐야겠다.

(c) Online Instance Matching (OIM) loss

  • unlabelled identities들이 존재할 때 = unsupervised domain adaptive Re-ID에서 사용하는 방법
  • 아래의 memory bank가 unlabeled classes에 대해서, 각각의 class를 표현하는 feature(representation)의 정보를 저장하고 있는 memery가 되겠다. labeled class라면, 저 memory bank의 v값들이 one-hot-encoding으로 되어있을 텐데…
  • image-20210217204706380

2.2.2 Training strategy

  • 핵심 문제점 : the severely imbalanced positive and negative sample pairs 그리고, 이것을 해결하는 방법들.
    1. The batch sampling strategy (the informative positive and negative minings)
    2. adaptive sampling (adjust(조정하기) the contribution(기여도) of positive and negative samples)
  • 위의 Loss들을 하나만 쓰는게 아니라, , a multiloss dynamic training strategy를 사용한다.
    • adaptively reweights the identity loss and triplet loss. 두 loss에 적절한 알파, 배타 값을 곱하고 이 알파, 배타 값을 이리저리 바꿔가면서, 학습을 진행하는 방법.
    • consistent performance gain 을 얻을 수 있다.

2.3 Ranking Optimization

  • testing stage에서 검색 성능(retrieval performance)를 증가시키기 위해서(=ranking list의 순서를 다시 정렬하는 방법들) 필요한 작업을 아래에 소개한다. 그냥 저런 방법과 이미지가 있다 정도로만 알아두자. 정확하게 이해는 안된다.

image-20210217212027970

  1. optimizes the ranking order [58], [157]
    1. by automatic gallery-to-gallery similarity mining : 위의 이미지 (b) 처럼 초기의 주어진 ranking list를 기준으로 Gallery안에서 계속 기준 Query를 바꿔가며 Search를 진행해 나간다. 그렇게 list를 다시 획득하는 방법. (?? 정확히 모르겠다.)
    2. human interaction : using human feedback을 계속 받으므로써, supervised-learning을 진행하며 Re-ID ranking performance를 높힌다.
  2. Rank/Metric fusion [160], [161] (??)

2.4.1 Datasets and Evaluation Metrics

image-20210217213136301

  • Evaluation Metrics : (1) Cumulative Matching Characteristics (CMC) (2) mean Average Precision (mAP)
    • CMC-k (a.k.a, Rank-k matching accuracy) : ranked된 retrieved results에서 top-k안에 정확한 match가 몇퍼센트로 일지하는가? 예를 들어서 ranked된 retrieved results에 100장의 BB가 있고, 그 중 query를 정확하게 맞춘 BB가 80장이라면 0.8 이다.
    • CMC = CMC-1 , the first match 만을 고려한다. 하지만 the gallery set에는 다수의 GT bounding box in image가 존재하기 때문에 이것으로는 multiple camera setting에서 정확한 지표라고 할 수 있다.

2.4.2 In-depth Analysis on State-of-The-Arts

image-20210217214213113

  • 빨간색 줄은 데이터셋 종류, 보라색 줄은 데이터셋 이름.
  • image-based(위 사진) and video-based(아래 사진) 이렇게 2개의 관점에서 SOTA 모델이 무엇인지 확인해 본다.
  • 이 논문의 8 Page를 살표보면, 각 그래프에 대해서, 왜 SOTA 빨간색점의 모델이 최고의 성능을 낼 수 있었던 이유에 대해서 짧게 설명하는 부분도 있다. 따라서 필요하면 참고하기.
  • 이 성능 비교는, 저자가 직접, 많은 데이터셋 중, 가장 핵심이 되는 4개의 데이터셋을 이미지와 비디오에서 각각 선별하고, 모델을 돌려 성능을 확인하고 나온 결과를 기록한 것이다.


3. Open World Person Re-ID

  • 윗 내용 중 Closed-world 에서 Open-world Person Re-ID 으로의 필요한 핵심 포인트 꼭꼭 다시 읽고 아래 내용 공부하기

3.1 Heterogeneous Re-ID

  1. [3.1.1] Depth-based Re-ID
    • Depth images 를 활용한 몇가지 논문들 소개
    • RGB and depth info.를 결합합으로써, Re-ID 성능을 높이고 the clothes-changing challenge 를 해결했다.
    • 몇가지 논문이 제시되어 있는데, 직접 찾아 확인을 해보니, 6m정도 이내에서 사람을 검출한다. 작은 복도 구석에 카메라를 설치해서 사용하는 방법이다. 확실히 Depth 카메라의 Range를 고려한 것 같다.
  2. [3.1.2] Text-to-Image Re-ID
    • visual image of query를 얻을 수 없고, only a text description만이 주워질 때 필수적으로 사용해야하는 방법이다.
    • the shared features (between the text description and the person images)를 학습한다.
  3. [3.1.3] Visible-Infrared Re-ID (적외선)
    • the cross-modality matching(= modality sharable features) between the daytime visible and night-time infrared images 를 다루는 방법이다.
    • GAN을 사용해서 cross-modality person images 를 생성해서, the cross-modality discrepancy 를 제거하는 방법도 있다.
    • 2019 ~ 2020 논문들이 많다. 이 쪽 연구가 활발히 이뤄지는 것 같다. 필요하면 참고할 것.
  4. [3.1.4] Cross-Resolution Re-ID
    • 높고 낮은 해상도 이미지 사이의, the large resolution variations 를 해결하기 위한 목적의 논문들 소개

3.2 End-to-End Re-ID

  1. Re-ID in Raw Images/Videos
    • the person detection and reidentification 을 모두 수행하애 한다.
    • 2017 년도에 나온 [55], [64] 논문이 기초 논문
    • [196, 2019] a graph learning framework
    • [197, 2019] squeeze-and-excitation network to capture the global context info
    • [198, 2019] generate more reliable bounding boxes
  2. Multi-camera Tracking
    • 1개 query가 아니라 multi-person, multi-camera tracking [52, 2018] 에 대한 고려 논문.
    • 이 외 다른 논문 소개 A graph-based formulation [201, 2017], a locality aware appearance metric [202, 2019]

3.3 Semi-supervised and Unsupervised Re-ID

  1. [3.3.1] Unsupervised Re-ID
    • invariant components(각 Label에 대해서 변함없는 feature 저장 구성) (i.e., dictionary [203], metric [204] or saliency [66]) 를 학습하는데 목적이 있다.
    • (1) deeply unsupervised methods 들에 대해서, 1문단으로 논문들 소개
    • (2) end-to-end unsupervised Re-ID 들에 대해서, 1문단으로 논문들 소개
    • 이런 많은 논문들과 연구들에도 불구하고, newly arriving unlabelled data를 model updating하는데 아직도 어려움이 많다.
    • (3) 일부 end-to-end unsupervised Re-ID 방법들 중에서, 특히 learn a part level representation ( local parts than that of a whole imag ) 를 학습하려고 하는 모델들이 있다. [153, 212]
    • Semi-/Weakly supervised Re-ID : (1) With limited label information, a one-shot metric learning [213] (2) A stepwise one-shot learning method [144] (3) A multiple instance attention learning framework uses the video-level labels [214]
  2. [3.3.2] Unsupervised Domain Adaptation
    • a labeled source dataset의 지식(Feature Extractor)을 the unlabeled target dataset에게 넘겨주는데 목적을 가지고 있는 모델들이다. = unsupervised Re-ID without target dataset labels
    • Target Image Generation : GAN을 사용해서, source-domain 이미지를 target-domain style이미지로 transfer generation한다. 이러한 방식을 사용하는 9가지 논문 소개
    • Target Domain Supervision Mining : source dataset을 이용해서 아주 잘 학습된 model을 사용해서 target dataset의 supervision(annotation정보)룰 직접적으로 mining(추출하는) 하는 방법이다. 이러한 방식을 사용하는 7가지 논문 소개
  3. [3.3.3] State-of-The-Arts for Unsupervised Re-ID
    • 우선 아래의 전체 모델 성능 비교 참조.
    • image-20210219152053230
    • 최근, He et al. [229, 2020] 논문을 보면 large-scale unlabeled training data를 사용하여 unsupervied learning을 적용하면, 다수의 tasks에서 supervised learning을 이용한 것보다 훨씬 더 좋은 성능이 나올 수 있다고 증명한다. 따라서 앞으로도 미래의 breakthroughs가 될 것으로 기대된다.

3.4 Noise-Robust Re-ID

  • 여기서는 3가지 관점으로 noise-robust Re-ID 논문들에 대해서 소개한다.
  • 논문에서는, 여러 다른 기술이 들어간 논문들을 아주 짧게 소개한다. 그러니 내가 이해못하는게 너무 당연하다. 정독을 하던, 스키밍을 하던 이해 안되는 것은 똑같았고, 그래서 큰 그림만을 아래에 적어 놓았다.
  1. the Re-ID problem with heavy occlusions (Partial Re-ID) : Deep Spatial feature Reconstruction (DSR) [232], Visibility-aware Part Model (VPM) [67], A foreground-aware pyramid reconstruction scheme [233]
  2. the problem caused by poor detection/inaccurate tracking results : Detected BB에서 noisy regions이 기여하는 정도를 suppress 하는것이 Basic Idea 이다. 특히 [20]에서는 multiple video frames to auto-complete occluded regions(비디오 이미지를 사용해서, 한 프레임에서는 보이지 않는 occulded 부분을, 여러 프레임을 사용해서 자동 복원하는 방법이다.)
  3. the problem due to annotation error : [42], [235], [236] 위에 처럼 각 논문에 따른 이름을 적어 놓는게 무슨 의미가 있나… 안 적었다. 필요하면 알아서 참고.

3.5 Open-set Re-ID and Beyond

  • Open-set Re-ID를 처리하는 가장 기본적인 방법은, a learned condition τ를 사용해서, similarity(query, gallery) > τ (τ보다 크면, matching시키고, τ보다 작으면 gallery에 query가 없다고 판단.)를 이용하는 것이다.
  • 위와 같은 방법을 handcrafted systems이라고 하며 [26], [69], [70] 이런 논문들이 있다.
  • handcrafted 가 아닌, deep learning methods를 사용한 Adversarial PersonNet (APN) [237] 이라는 방법도 있다. GAN module and the Re-ID feature extractor를 사용해서, similarity를 판별하고, gallery에 query가 있는지 없는지 판단한다.
  • Group Re-ID : associating the persons in groups rather than individuals. Group을 associationg(?) 하는 방법으로는, (1) sparse dictionary learning 기반, (2) the group as a graph 기반. 2개이다. 각 기반 방법에 해당하는 논문들이 소개 되어 있다.
  • Dynamic Multi-Camera Network : new cameras or probes(데이터 분포&유사도)에 대한 adaptation challenging를 고려하는 몇가지 논문들 소개되어 있음.


4. An Outlook Re-ID (new metric, baseline)

4.1 - mINP: A New Evaluation Metric for Re-ID

  • computationally efficient metric 를 표현하는 metric
  • image-20210228162554605
  • 여기서 R은 Rank position of the hardest match, G는 correct matches for query의 총 갯수이다. 아래의 예시를 참고하자.
    image-20210228162701915
  • 이런 성능 지표가 필요한 이유는 다음과 같다. 위 그림의 Rank List 1은 Rank List 2에 비해서 AP가 높다. (AP수식은 논문의 초반부분에서 참고) 하지만 NP를 계산해보면, Rank List 1이 더 높다. (NP는 낮아야 좋은것)이 말은 즉, “hardest true matching를 찾기 이전까지, too many false matchings 이 포함되었다.”를 의미한다. 따라서 Rank List 1의 computing 효울은 낮다고 판단할 수 있다.

4.2 - A New Baseline(AGW) - Single-/Cross-Modality Re-ID

  • three major improved components 를 포함하는 새로운 Baseline 모델이다. github code - pytorch

  • 여기 있는 아이디어를 나중에 착안해 사용해도 좋을 것 같다.

  • image-20210228154131446

    1. Non-local Attention (Att) Block : nonlocal attention block [246, 2019] 사용

    2. Generalized-mean (GeM) Pooling

      • a learnable pooling layer이다.
      • generalized-mean (GeM) pooling [247, 2018] 를 참고했다.
      • image-20210228163156640
      • 여기서 Xk는 feature map의 각 channel들이다. pk는 training 중에 학습되는 pooling hyper-parameter이다. 만약 Pk가 무한하게 크면, Max pooling이 이뤄지는 것이고, Pk가 1이면, average pooing이 이뤄지는 것이다.
    3. Weighted Regularization Triplet (WRT) loss

      • weighted regularized triplet loss.
      • image-20210228163422167
      • 위의 수식을 사용한다. (i, j, k)가 의미하는 것은 a hard triplet within each training batch 이다.
      • 3개의 이미지 중, 서로 2개가 같은 ID의 이미지이면 positive, 다르면 Negative이다. 위의 수식을 사용해서 positive인 weight 끼리는 거리가 가깝도록, negative인 weight 끼리는 거리가 멀더록 만든다.
  • 좀 더 확실한 이해는, 논문을 통해서도 힘들다. 나중에 코드도 함께 봐야겠다.

image-20210228154018475

4.2.a - Results

image-20210228163541917



4.3 Under-Investigated Open Issues (challenge)

  • 4.3.1 Uncontrollable Data Collection - 자동 데이터 수집기 필요
  • 4.3.2 Human Annotation Minimization - 비용 절감을 위해 사람의 라벨링 작업 최소화 필요
  • 4.3.3 Domain-Specific/Generalizable Architecture Design - Domain 변화에도 일정한 성능을 가지는 NN
  • 4.3.4 Dynamic Model Updating - online learning 필요
  • 4.3.5 Efficient Model Deployment - fast and efficient 한 모델. 작고 강한 모델.

자세한 내용은 논문 참조

【Detection】FSAF Module for Single-Shot Object Detection w/ code + my advice

  • 논문 : Feature Selective Anchor-Free Module for Single-Shot Object Detection
    필기 완료된 파일은 OneDrive\21.겨울방학\RCV_lab\논문읽기에 있다.
  • 분류 : Object Detection
  • 저자 : Chenchen Zhu, Yihui He, Marios Savvides
  • 읽는 배경 : Anchor Free 라는 개념의 시작이 되는 논문이므로.
  • 느낀점 + Advice :
    • 이 논문은 전체를 다~ 봐야지. 라는 마음으로 보지 않았다. 아래의 순서로 핵심만 찾아보앗다.
      1. Conclution -> Introduction -> Abstract 순서대로 읽으면서, 에서 핵심이 뭐지? - 이 논문이 해결하려는 문제점이 뭐지? 이 방식의 목표는 뭐지?
      2. Related Work에서 거의 무시. 거의 마지막 문단과 문장만 읽음.
      3. Figure1, Figure2 주석 읽기. 본문에서 Firgure2에 대한 추가 설명 찾아 읽기
      4. Method 읽기 시작! 이 논문의 method는 3페이지 이내이다.
      5. Ablation, Result에서 위에서 말한 문제점 해결이 잘 해결되었고, 목표를 잘 달성했는지 확인한다. 다시 말해서, 이 논문에서 제안한 각각의 몇가지 새로운 모듈에 대해서 결과론적으로 각각 좋은 결과를 얻었는지 확인.
    • 저번의 정리해놓은 논문 정리방법 과는 추가로, “같은 문장, 같은 문단에서도 비슷한 영어단어를 써가며 같은 말을 반복한다. 이걸 다 다른거라고 생각하지 말고 하나의 단어로 통일해서 정리해 두자” 예를 들어서 Extracted Feature = representation = Feature maps 뭐 이런 동의어를 반복해서 사용한다. 예전의 나는 이것들을 모두 따로따로 분리해서 생각했는데, 결국에는 같은 동의어이다. 아래 Conclution에서도 heuristic feature selection 고안하여~라는 말이 나오고 2문장 이후에 online feature selection 만들었다~라는 말이 나온다. 내가 이걸 따로 정리할 필요 없이 heuristic/online feature selection를 만들었다 라고만 적으면 끝이다.
    • 항상 논문을 끝까지 다 읽어봐야 한다. Conclution -> Introduction -> Abstract 은이 순서대로 다 읽고 나서, ‘논문 정리 문서 작성’을 해야한다. Abstract에서는 절대 이해가 안되던게, Introduction을 읽고 이해가 되기 시작한다. 그리고 Method를 읽으면 또 다시 이해가 되기 시작한다. 그니까 Conclution, Abstract, Introduction 여기서 이해 안되면, 안되는데로 읽거나 아니면 아에 읽지말고 넘어가라. 그리고 Method 읽고 다시 와서 읽어라. 그렇게 하면 “와… Abstract, Introduction에서 말만 삐까번쩍하게 해놨네… 쓸데없는 소리 엄청했네… 이렇게 써놓으면 처음보는 사람은 절대 이해 못하지… Method부터 읽길 잘했다…” 라는 생각이 엄청든다.
    • Conclution -> Method -> Introduction -> Abstract 순서대로 보았다면, Introduction, Abstract 에서 충분히 시간을 절약할 수 있었을 것 같다. Method 를 읽는데, Introduction, Abstract 부분의 지식은 하나도 필요없었다. 물론 알고 보면 좋은 건 있지만, 시간 절약으로 Method 공부 다~ 하고 Introduction, Abstract를 봤다면 좀더 정확한 Introduction, Abstract 부분의 이해와 정확한 정리가 가능하지 않았나.. 싶다. 좀 내가 아는 Object Detecion, Instance Segmentation 에서는 Conclution -> Method -> Introduction -> Abstract 순서로 논문을 공부하자!

Feature Selective Anchor-Free Module

image-20210301124902376


0. conclution

  • (PS. 이 논문에 계속 나오는 feature selection은 사실 feature level (in Pyramid = P_l)selection이라고 계속 이해하자 )
  • heuristic feature selection의 문제점,한계를 찾아내고, 이 문제 해결을 위해 online feature selection을 고안하며, FSAF 모듈을 만들어 냈다.
  • (1) Tiny inference overhead (2) SOTA / Strong baselines 얻었다.

1. Introduction, Abstract

  • 우리의 해결하려는 문제점이자 목표는, scale variation이다. 즉 scale invariability (객체의 크기가 커지더라도, 작아지더라도 객체를 안정되게 잘 탐지할 수 있는 능력) 성능을 가지는 모델을 만들어내고자 한다.
  • 최근 기법들의 한계점 (two limitations) (아래 그림의 (4)에서 발생하는 문제점이 핵심이다)
    1. inherently heuristic-guided feature selection : anchor의 size, rate는 이미 정해져있다. 때문에, 각각의 instance에 대해서 선택되는 (selected) feature level [PFN에서 upper(small, smentic), lower(large, deteail) 이 다른 feature map을 의미함] 이 최적의 level이 아닐 수 있다.
    2. overlap(IOU)-based anchor sampling : 각각의 instacne 들은 가장 가깝고 IOU가 높은 anchor box에 의해 detect / match 된다.
      image-202103011259079549
  • Feature selective anchor-free (FSAF)
    1. 이 모듈을 통해서, 각각의 instance가 the best feature level을 선택하도록 돕는다.
    2. FSAF 모듈은 classification subnet 과 regression subnet 으로 구성되어 있다.
    3. During training, 각 instance에 대해서 the most suitable feature level을 찾는다 Dynamically, Non-heuristically. 단순하게 instance box size를 기반으로 하는게 아니라, the instacne content (instance에 해당하는 feature 내용들) 를 기반으로 feature level을 찾는다.
    4. Durring Inference, anchorbased branches와 독립적이면서 공동으로 평행하게 run 된다.
      image-20210301130356467
  • FSAF의 장점과 특징 (Abstract 참조)
    1. simple and effective building block for single-shot object detectors.
    2. FPN를 가지는 Network에는 모두 적용가능하다.
    3. Feature Level Selection에서 online feature selection 을 수행한다. (Dynamically, Non-heuristically)
    4. state-of-the-art 44.6% mAP, SOTA in single-shot detectors on COCO.

2. Related work

  • 초반 내용 안 읽음
  • The idea of anchor-free detection는 새로운게 아니다. DenseBox [15, 2015]에 처음 나온 방식이다. Anchor Box를 사용하지 않고, directly predicted bounding boxes를 사용한다.
  • 위의 방법이 발전되어서 2개의 논문이 나왔다. 하지만 아래 2 논문은 여전히 heuristic feature level selection strategies을 취하고 있다. 우리는 heuristic 에 의해 발생하는 문제점을 최소화 하도록, heuristic 을 최소화 하는 것을 목표로 한다.
    1. CornerNet [17, 2018] : detect an object bounding box as a pair of corners. SOTA in single-shot detectors.
    2. SFace [32, 2018] : the anchor-based method and anchor-free method 를 모두 융합하기 시작.

3. Feature Selective Anchor-Free Module

3.1 Network Architecture

  • how to create the anchor-free branches in the network
  • surprisingly simple
  • FPN에서 나오는 feature map P_3 부터 P_7 까지. 3~7을 ‘l (small L)‘이라고 하자. P_l은 the input image에 대해서 1 / (2^l) resolution 을 가진다.
  • 아래 그림에, Class subnet, Box subnet 의 1x1 공간의 의미는 잘 적어두었으니 참조하기.
  • 아래 그림에 왼쪽 하단 질문 기준이 뭐야?의 해답은 : “[instance GT BB’를 1 / (2^l) 비율로 나눈, BB]가 Anchor역할을 한다.” 이다.

image-20210301152734581


3.2 Ground-truth and Loss

  • how to generate supervision signals for anchor-free branches

image-20210301153022171

  • 아래 그림에서 중앙의 검은색 곡선 라인을 기준으로,
    (1) 위 왼쪽은 Classification 에 해당하는 P_l의 GT가 무엇이 되어야 하는지.
    (2) 아래 오른쪽은 Box Regression에 해당하는 P_l의 GT가 무엇이 되어야 하는지. 를 나타낸다.
  • Classification Output : 아래 그림의 설명에서 추가적으로 Focal Loss에서 α = 0.25 and γ = 2.0 를 사용했다. 하나의 instance에 의해서 생성되는, 최종적 loss는 the summation of the focal loss over all non-ignoring regions(빨간색 내부 중, 보라색 부분 제외 모든 곳) 이다.
  • Box Regression Output : 아래 그림의 설명에서 추가적으로, S는 a normalization constant 이다. S는 경험적으로 4라고 찾아냈다고 한다. S를 왜 사용했는지는 구체적으로 나와있지 않는다. (대략 최종으로 나오는 d_t, d_l .. 값들이, objectness score와 비슷한 값 분포를 가지게 하려는 건가?)

image-20210301153605871

  • inference 를 수행하는 동안에는…
    • straightforward to decode the predicted boxes (위에서 했던 방식을, 그대로 반대로 해주면 된다. 마치 조립은 분해의 역순처럼!)
    • Box Regression 예측값 찾기
      • image-20210301154336984
    • Classification Score : 각 1x1 공간에 대해서 the maximum score 를 사용한다.

3.3. Online Feature Selection

  • how to dynamically select feature level for each instance

image-20210301163122322

image-20210301163346962

  • 위 그림에서 보라색 필기를 추가 설명하자면, online-feature-selection 방법이 효과적이다. 라는 것을 증명하기 위해서, 자체적으로 heuristic feature selection을 만들어 실험해 보았다. 두 방법을 비교한 결과는 아래의 Result에서 소개될 예정이다.
  • Supervision siginal을 보내는 방법은, 이렇다. 최소 Loss를 가지는 Lavel을 l* 라고 하자. 그렇다면 P_l*의 effective region의 결과에 대해서만 Loss를 계산하고 nn.optimize(Loss) 를 적용해주면 된다.

3.4. Joint Inference and Training

  • how to jointly train and test anchor-free and anchor-based branches
  • Inference
    1. each pyramid level에 대해서 top-score를 가지는 1k를 선출한다.
    2. 그것들에 대해서, (0.05 confidence score) thresholding을 수행한다.
    3. anchor-based branches에서도 위의 1번2번 과정과 같은, “top predictions”을 수행한다.
    4. 이렇게 찾아낸, 모든 BB들에 대해서, non-maximum suppression을 수행한다.
  • Initialization
    • (정확히 뭔소린지 모르겠다. 이걸 코드로 확인해 보아야 하나?)
    • classification 에 대해서, bias = log((1 − π)/π) and a Gaussian weight filled with σ = 0.01. 여기서 π는 학습 초기에 모든 픽셀에 대한 objectness score output을 π라고 했단다.
    • box regression 에 대해서, bias = b, and a Gaussian weight filled with σ = 0.01.
    • initialization을 정확하게 하는 것은, 학습 초기에 large loss를 막음으로써, network learning을 안정화시키는데 도움을 준다.
  • Optimization:
    • Loss는 Total Loss로써 아래의 수식을 사용한다.
    • 아래에서, Iterations 가 의미하는게 정확하게 뭔지는 모르겠지만, epoch는 아닌것 같고, 1 mini-batch 학습을, 1 iterations라고 보면 될 듯 하다.
    • image-20210301164305796

4. Experiments

image-20210301164807225

  • COCO dataset 을 사용해서, 성능을 비교하였다.
  • Ablation studies 를 통해서 내린 결론 (맨 위 표)
    1. Anchor-free branches are necessary.
    2. Online feature selection is essential.
  • How fast? : 위 표 중, 아래 오른쪽 표를 살펴보면 RetinaNet(AB) 와 Ours(AB + FSAP) 의 Runtime 차이가 그리 크지 않은 것을 확인할 수 있다.
  • How is optimal feature selected?
    1. 아래의 그림을 참고하자.
    2. the optimal pyramid level selected for instances 을 선택하는 것이 과연 얼마나 중요할까? 물론 왼쪽아래 표를 참고하면 이해할 수도 있기도 하지만, 아래의 사진을 통해서 이해해보자.
    3. 아래의 그림의 Bounding box annotation에서 Class 이름 옆에 있는 숫자는 P_l에서 l (feature level)을 의미한다.
    4. 아래의 그림을 통해서, 대체적으로 online feature selection 또한 [ 크기가 큰 객체는 높은 l 에서 검출이 되고, 크기가 작은 객체는 낮은 l 에서 검출되는, 아주 기본적인 원리 ] 를 만족하는 것을 확인할 수 있다.
    5. 하지만 빨간색 박스는, anchor-based branch에서 선택된 l (feature level) 과 FSAF module에서 선택된 l 이 다른 경우에 빨간색 박스를 처 놓았다. 이런 것을 봤을 때, 그리고 FSAF를 사용해 성능향상이 되는 것을 보았을 때, heuristic 뿐만아니라, online feature level selection 도 Object Detection에 필요하다는 것을 확인할 수 있다.
    6. image-20210301170937743
  • Comparison to State of the Art
    1. scale jitter over scales {640, 672, 704, 736, 768, 800} and for 1.5× longer than the models 이라는 방법을 사용해서 모델을 학습시켰다. 라고 논문에 나와있다.
    2. 내 추축으로 생각해봤을 때, 우선 네트워크는 an image scale of 800 pixels for both training and testing에 특화되게 학습시킨다.
    3. 그리고 원본이미지를 좀 더 작은 {640, 672, 704, 736, 768, 800} 사이즈를 가지는 이미지로 바꿔서 학습시킨 후. 나중에 원래 이미지 크기인 {400, 500, 600, 700, 900, 1000, 1100, 1200} 사이즈를 가지는 이미지를 가지는 이미지를 학습시킴으로써, 좀 더 small scale instance 를 검출하는데 효과적인 Network로 학습시키지 않았나 싶다.
    4. 여기서도 single-scale testing (800 pixels) 그리고 multi-scale testing ({400, 500, 600, 700, 900, 1000, 1100, 1200}) 를 적용했을때의 성능비교가 위의 (왼쪽 아래) 표에 잘 적혀있다.


PyTorch code of FSAF

【27살】나만의 연구분야 일기

1학년 1학기 시작하기 전, 나만의 연구분야에 관한 생각나는데로 써보는 일기…

2021년 2월 13일

2월 22일~26일에 현대 모비스 마북연구소로 현장실무연수를 다녀오기로 배정이 났다. 5일 동안 연구할 주제를 정해야 한다고 이야기를 들었다. 원래는 Object Detection(이미 거의 다 봤고), Image Segmentation을 이번달 까지 계속 보고, 다음달 부터 내가 하고 싶은 분야를 딱 정해서 공부할 예정이었으나, 예정보다 빠르게 연구주제를 정해야할 듯 하다. 내가 해야야 할 것들을 아래와 같이 정리해보았다.


  1. Object Detection 계보 다 읽기

    • (계보는 어느정도 다 읽음) YoloV4에 있던, 추가로 읽어야 하는 논문 찾아 읽기 (AnchorFree)
  2. 연구실

    • 연구실 과제

      • 내가 맡을 과제 or 나중에 하고 싶은 과제 알아보기
      • 과제와 관련된 논문 미리 읽고 공부하기
    • 연구실 선배님들 연구주제 알아두기

    • 
      $ 메모 
      - depth 라는 표현은 좋지 않다. 우리 연구실에서 거의 아무도 하지 않는다. 
      - 3D로 접급해보자.3D도 indoor area(3D reconstruction)가 있고 outdoor area(self-driving)이 있다. 
      - 3D를 하시는 분도 너무 제한적이다.(reconstruction하시는 분들이 대부분이다.) 같은 주제로 가져가려고 하기보다는, 비슷하면서도 내가 정말 하고 싶은 분야로 선택해서, 원하는 분야의 다른 논문들을 찾아보는것도 좋겠다. 
      - 라고 생각하면서도, 석사 과정 동안은 꼭 내가 원하는 분야를 해야하나?? 라는 생각이 든다. 현명한 선택은 최대한선배님들과 유사한 연구방향으로 선택하는 것 같다. 하고 싶은건 나중에 하면 되는 거다.
      - 어차피 과제가 정해진다 하더라도, 꼭 과제랑 내 분야가 일치할 수는 없다. 꼭 원하는 과제만 할 수 있는 것도 아니다.
      - RGB-Depth camera가 쓸모가 없다. 최대 거리가 겨우 4~9m ...
      
      - 그렇담.. 내가 정말 하고 싶은게 뭐냐?
      - Google Scholar -> 3d object detection survey driving
      - paper : A Survey on 3D Object Detection Methods for Autonomous Driving Applications
      - https://paperswithcode.com/task/3d-object-detection-from-stereo-images
      
      
  3. 3D-Object Detection 논문 읽기 찾아 읽기

  4. Vision Transformer 논문 읽기

    • vision transform
  5. Domain adaptation / Active Learning 논문 읽기

    • Domain Adaptive Semantic Segmentation Using Weak Labels
    • ViewAL: Active Learning With Viewpoint Entropy for Semantic Segmentation
  6. Object Tracking + 추천 받은 논문 읽기

    • bert
    • rethinking sementic segmentation
    • Trackformer - multi object tracking
    • re-ID
  7. Image Segmentation 논문 다 읽기

    • Instance Segmentation 계보 다 읽기
    • 혹은 the devil in boundary 논문에 있던, 추가로 읽어야 하는 논문 찾아 읽기

이렇게 정리를 하고 나서, 이런 결론을 내릴 수 있었다. [일단 2번의 ‘내가 맡을 과제 or 나중에 하고 싶은 과제 알아보기’ 를 하는게 가장 시급하다. 월.15, 화.16, 수.17 이내에 이것이 확정되면 그 이후에 다시 생각해 보자.] 그 전에는 그냥 그날 읽고 싶은 논문 순서대로 읽자 어차피 다~ 읽을 건데, 뭘 먼저 읽고 뭘 나중에 읽고는 의미가 없는 것 같다. 그냥 읽자. 계획 짜고 순서 짠다고 시간 버리지 말고. 그냥 하자.

그리고 교수님과의 면담과 1학기 수업에서 개인 프로젝트 및 과제를 하기 위해서는, 일단 연구 주제 확정해서 지금부터 한달 동안은 확정한 연구 주제만 미친 듯이 공부해야겠다.

Basic한 기초 내용 (선형대수, Basic Segmentation)는 나중에 시간날 때마다 틈틈히 공부하면 된다.


“나 자신을 위해 살지 말아라. 이미 놀거 다 놀고, 잘거 다 잤다. 사랑하는 사람을 위해 누구보다 독하게 살아라. 너의 부족함으로 인해 생기는 ‘이별의 고통’ 또는 ‘사랑하는 사람의 피눈물을 바라봐야 하는 고통’은 이 세상 그 어떤 고통보다 힘들고 아픈 고통이니까.”

“그냥 해라. 그냥 시작해라. 아무 생각도 하지 말아라. 그냥 읽어라. 그리고 조금만 더 해라.”

- 이충권 선생님-

정신차리고 하자.



2021년 2월 16일

(선배님과의 상담 내용 정리 - Private 공간에 정리 해둠)

【3D-Detect】A Survey on 3D object-detection for self-driving

  • 논문 : (Oct. 2019) A Survey on 3D Object Detection Methods for Autonomous Driving Applications
  • 분류 : 3D Object Detection for self-driving
  • 저자 : Eduardo Arnold, Omar Y. Al-Jarrah, Mehrdad Dianati, Saber Fallah
  • 읽는 배경 : 연구 주제 정하기 첫걸음
  • 느낀점 :
    • 막연하게 3D detection이라는 분야가 있는 줄 알았는데, 생각보다 많은 분류가 존재했다. 그리고 상용화까지는 힘든 성능의 모델들이 대부분이었다. 이 분야도 거의 다 완성된게 아니라.. 아직도 연구할게 많구나. 라는 생각이 들었다.
    • 만약 3D를 하고 싶다면, 그냥 가장 최신 논문 먼저 읽고 하나하나 따라 내려가는게 나을듯 하다. 여기 있는 논문 계보는 배경지식으로만 가지고 있자.
  • PS : 필기된 논문은 [21.겨울방학\RCV_lab\논문읽기] 참조

A Survey on 3D Object Detection for Autonomous Driving

1. Conclusion, Abstract, Introduction

  • 논문 전체 과정 : sensors들의 장단점, datasets에 대해서 알아보고, (1) monocular (2) point cloud based (3) fusion methods 기반으로 Relative Work를 소개한다.
  • 3D object Detection에서 나오는 depth information 정보를 통해서 만이, path planning, collision avoidance 를 정확히 구현할 수 있다. 자율주행을 하려면 (1) identification=classification (2) recognition of road agents positions (e.g., vehicles, pedestrians, cyclists, etc.) (3) velocity and class 들을 정확히 알아야 한다.
  • failure in the perception(인식 실패)는 sensors limitations 그리고 environment(domain) variations에 의해서, 또는”objects’ sizes”, “close or far away from the object” 등과 같은 요인에 의해서 발생한다.

2. Sensors and Dataset

  • Sensors
    1. 각 센서의 장단점 비교.
      image-20210214143901740
    2. Calibration 추천 논문 : “LiDAR and camera calibration using motion estimated by sensor fusion odometry”
  • Dataset
    1. KITTI
      • Sensor calibration, Annotated 3D bounding box 를 제공한다.
      • Categrized in easy, moderate, hard (객체 크기, 겹칩, 가려짐의 정도에 따라서).
      • 거의 대부분 주간 주행. Class unbalance가 심각하다. Predominant orientation 이다. (대부분의 객체가 같은 방향을 바라보고 있다.)
    2. Virtual KITTI
      • 직접 게임 엔진을사용해서 KITTI의 이미지와 똑같은 가상 사진을 만들었다.
      • 이 사진에서 Lighting, 날씨 조건, 차의 색 등을 바꿀 수 있다.
      • 두개 데이터에 대해서 Transferability를 측정해본 결과, 학습과 테스트를 서로에게 적용했을때 성능 감소가 크게 있지 않았다.
      • Virtual KITTI로 학습시키고, KITTI로 fine-tunning을 해서 나온 모델로 test해서 가장 좋은 성능을 얻었다.
    3. Simulation tool
      • game-engines GTA5 (SqueezeSeg [34])
      • Multi Object Tracking Simulator : “Virtual worlds as proxy for multi-object tracking analysis,”
      • autonomous driving simulator : CARLA-“CARLA: An open urban driving simulator-2017”, Sim4CV-“Sim4CV: A photo-realistic simulator for computer vision applications-2018”

3. 3D Object Detection Methods

  • 아래의 전체 분류 Table 참조

image-20210214171654498

3-A Monocular Image Based Methods

  • 우선 아래의 Table 참조
  • 대부분의 탐지 방식 : Region Proposal(2D) -> 3D model matching(3D detection) -> Reprojection to obtain 3D bounding boxes
  • 문제점(이것을 해결하기 위해 아이디어를 계속 생각해 봐야겠다) : 이미지에 Depth 단서가 부족해서, 먼 객체, 멀어서 작은 객체, 겹치는 객체, 잘리는 객체 탐지에 힘듬. Lighting과 Weather condition에 매우 제한적임. 오직 Front facing camera만을 사용해서 얻는 정보가 제한적이다. (Lidar와 달리)

image-20210214171814828

  1. 3DOP [43, 2015] : 원본 이미지에서 3D 정보를 추출하는 가장 기본적인 방법. 필기에서는 이 방법을 0번이라고 칭함.
  2. Mono3D [39, 2016] : 3DOP를 사용한다. Key Sentence-“simple region proposal algorithm using context, semantics, hand engineered shape features and location priors.”
  3. Pham and Jeon [44, 2017] : Keypoint-“class-independent proposals, then re-ranks the proposals using both monocular images and depth maps.” 위의 1번 2번보다 좋은 성능 얻음.
  4. 3D Voxel Pattern = 3DVP [41, 2015] : 3D detection의 가장 큰 Challenge는 severe occlusion(객체의 겹침, 잘림이다) 이것을 문제점을 해결하기 위한 논문. 객체가 가려진 부분을 recover하기 위해 노력했다. 2D detect결과에 3D BB결과를 project할 때의 the reprojection error를 최소화함으로써 성능을 높였다.
  5. SubCNN [45, 2017] : 3DVP의 저자가 만든 방법으로, Class를 예측하는 RPN을 사용한다. 그리고 3DVP를 사용해서 똑같은 3D OD를 거친다.([45]논문에 의하면, 2D Image와 Detection결과에서 Camera Parameter를 사용해서 3D 정보를 복원한다고 한다.)
  6. Deep MANTA [42, 2017] : a many task network to estimate vehicle position, part localization and shape. 다음의 과정을 순서대로 한다고 한다. 2D bounding regression -> Localization -> 3D model matching (Imbalance한 vehicle pose(데이터에서 vehicle pose가 거의 비슷)의 문제점을 해결하기 위해서)
  7. Mousavian et al. [40, 2017] : standard 2D object detect 결과에다가 추가로 3D orientation (yaw) and bounding box sizes regression (the network prediction Branch)만을 추가해서 3D bounding box결과를 추론한다. orientation을 예측하는데, L2 regression 보다는 a Multi-bin method 라는 것을 제안해서 사용했다고 한다.
  8. 360 Panoramic [46, 2018] : 옆, 뒤 객체도 탐지하기 위해서, 360 degrees panoramic image 사용한다. 데이터 셋 부족 문제를 해결하기 위해서 KITTI 데이터를 Transformation한다.

3-B. Point Cloud Based Methods

  • 우선 아래 테이블 참조
  • Projection 방법은 Bird-eye view를 사용하거나, 이전에 공부했던 SqueezeSeg와 같은 방법으로 3D는 2D로 투영하여 Point Clouds를 사용한다. 이러한 변환 과정에서 정보의 손실이 일어난다. 그리고 trade-off between time complexity and detection performance를 맞추는 것이 중요하다.
  • Volumetric methods는 sparse representation(빈곳들이 대부분이다)이므로 비효율적이고 3D-convolutions를 사용해야한다. 그래서 computational cost가 매우 크다. 3D grid representation. shape information를 정확하게 encode하는게 장점이다.
  • PointNet과 같은 방법은 using a whole scene point cloud as input 이므로, 정보 손실을 줄인다. 아주 많은 3D points를 다뤄야 하고 그 수가 가변적이다. 정해진 이미지 크기가 들어가는 2D-conv와는 다르다. 즉 points irregularities를 다뤄야 한다 [61]. 최대한 Input information loss를 줄이면서.

image-20210214202515874

  1. Projection via plane [47, 2017]
  2. Projection via cylindrical [48, 2016] : bird-eye view 이미지를 FCN하여 3D detection을 수행한다. 자동차만 탐지한다. channel은 Point의 hight(높이)에 맞춰서 encoding된다. (예를 들어 3개의 채널을 만들고, 높은 points, 중간 높이 points, 낮은 높이 points) FCN을 통해서 나오는 결과는 BB estimates이고 NMS를 거쳐서 objectness and bounding box를 추론한다.
  3. Projection via spherical [49, 2017]
  4. 3D-Yolo [30, 2018] : Encoding minimum, median and maximum height as channels. 그리고 추가로 2개의 channels은 intensity and density(해당 bird-eye view구역에 겹쳐지는 point의 객수 인듯). yolo에서 the extra dimension and yaw angle를 추가적으로 더 예측하는 inference 속도를 중요시하는 모델.
  5. BirdNet [51, 2018] : [50, project이미지를 Faster RCNN처리]을 기반(기초논문)으로 해서, Normalizes the density channel를 해서 성능 향상을 얻음.
  6. TowardsSafe [53, 2018] : Noise와 같은 불확실성을 보완할 수 있는 dropout을 적극적으로 사용하는 Bayesian Neural Network을 사용. 이러한 ‘확률적 랜덤 불확실성 모델’을 사용함으로써 noisy sample에 대해서 성능 향상을 얻을 수 있었다. [여기까지가 Projection Methods]
  7. 3DFCN [54, 2017] : 이미 가공된 a binary volumetric input를 사용한다. 해당 voxel에 vehicle이 ‘있고 없고’를 판단하는 binary 값을 사용해서, vehicle 밖에 검출하지 못한다. objectness and BB vertices predictions를 예측한다.
  8. Vote3Deep [55, 2017] : one-stage FCN. class는 차, 보행자, 자전거 끝. 각각의 Class에 대해서 고정된 크기의 BB만을 사용한다. 그리고 하나의 class만을 감지하는 모델을 각각 학습시킨다. 복잡성을 감소시키고 효율성을 증가시키기 위해 sparse convolution algorithm라는 것을 사용한다. Inference할때는 위의 각각의 모델을 parallel networks로써 추론을 한다. data augmentation, hard negative mining을 사용한다. [여기까지가 Volumetric Methods]
  9. PointNet[56, 2017], PointNet++ [59, 2017]. 더 발전된 것 [60, 2018] convolutional neural networks for irregular domains [61, 2017] : Segmented 3D PCL(전통적인 기법의 Point cloud library를 사용한) 기법을 사하여 classification(not detection) and part-segmentation을 수행한다. 그리고 Fully-Connnected layer를 통과시키고, max-pooling layer를 통과시킨다.
  10. VoxelNet [62, 2017] : classification(PointNet)이 아니라, detection을 수행. raw point subsets사용한다. each voxel에서 랜덤으로 하나의 point를 설정한다. 그리고 3D convolutional layer를 통과시킨다. cars and pedestrians/cyclists 탐지를 위해서 Different voxel size를 가지는 3개의 model을 각각 학습시킨다. 그리고 Inference에서는 3개의 model을 simultaneously 사용한다.
  11. Frustum PointNet [63, 2018] : imaged에서 추론한 결과를 기준으로 sets of 3D points를 선별해 사용하기 때문에 Fusion method로 나중에 다룰 예정이다. [여기까지가 PointNet Methods]

3-C. Fusion Based Methods

  • 우선 아래 테이블 참조
  • Points는 texture 정보를 주지 않는다. 즉 classification하기엔 힘들다. 또한 먼 곳에 있는 객체는 point density가 떨어져서, 객체라고 탐지하지 않는다. 이러한 판단은 Image에서의 detect도 방해될 수 있다.
  • fusion방식에는 아래와 같은 3가지 방법이 있다.(3 strategies and fusion schemes)
    1. Early fusion : 초기에 데이터를 융합하는 방법. 모든 센서데이터에 의존되는 representation 만들고 그것으로 detect를 수행한다.
    2. Late fusion : 각각 predictions을 수행하고 나중에 융합하는 방법. 이 방법의 장점은 ‘꼭 모든 센서 데이터가 있어야만 detect가 가능한 것은 아니다’라는 것이다.
    3. Deep fusion : 계층(hierarchically)적으로 각 센서데이터로 부터 나오는 Feature들을 융합하는 방식이다. Interact over layers라고도 표현한다.
  • 이런 3가지 strategies and fusion schemes에 대해서 [65, 2016]에서 무엇이 좋은지 테스트 해봤다. 2번 late fusion에서 가장 좋은 성능, early fusion에서 가장 안 좋은 성능을 얻었다고 한다.
  • 어찌 됐든, Fusion 방식은 SOTA 성능 결과를 도출해 준다. 라이더와 카메라가 각각 상호보완이 역할을 하기 때문이다.
  • image-20210214225942795
  1. MV3D [64, 2017] : 아래 그림 참조. 아래와 같은 3가지 종류의 input과 3가지 Branch를 가진다. 이 방법은 대표적인 deep fusion 방법이다. 후반의 작업을 보면, 계층적으로 서로서로 상호작용을 하면서 Feature를 얻어가는 것을 볼 수 있다. 이 방법을 통해서 저자는 ‘deep fusion을 통해서 the best performance를 얻었다. 다른 센서로 부터 얻은 정보를 융합하여, more flexible mean을 제공받기 때문이다.’라고 말한다.
    image-20210215133126397
  2. AVOD [6, 2018] : 아래 그림 참조. 대표적인 Early fusion방식이다. 중간에 한번 3D RPN과정을 위해 각 센서의 Feature map을 융합하여 the highest scoring region proposals을 얻는다. 이것을 사용해서 최종 Detection 결과를 얻는다. 저자는 small scale 객체 탐지를 위해서 FPN의 upsampling된 feature maps을 사용한다. 또한 이 방법을 통해서 악 조건의 날씨에서도 robustness한 결과를 얻을 수 있다고 한다.
    image-20210215133738617
  3. F-PointNet [63, 2018] : 2D 이미지로 부터 region proposals을 뽑아낸다. detected 2D box에 대해서, Camera calibration parameters를 사용해서 3D box ROI를 얻어낸다. 그리고 2번의 PointNet instance를 수행하여, Classification과 3D BB regression 정보를 추출한다.
    image-20210215134121819
  4. General Pipeline 3D [67, 2018] (상대적으로 인용수 적음) : 이 모델도 위의 F-PointNet과 같이 Image로 부터 Region proposals을 받는다. 이것과 F-PointNet은 Image로 부터 ROI를 받기 때문에 Lighting conditions 요인에 큰 영향을 받는다는 단점이 있다.
    image-20210215141144743

4. Evaluation Matrix and Results

  1. Recall과 Precision 그리고 AP = AP2D
    image-20210215151527145

  2. Average Orientation Similarity (AOS) : AP2D에서 Orientation performance까지 추가하는 방법. (weighting the AP2D score with the cosine similarity between the estimated and ground-truth orientations.)

  3. 3D localization metric (APBV) : localization and bounding box sizes 까지 고려하기 위한 Matrix. bird-eye view로부터 결과를 얻는다.

  4. AP3D : 3D box에 대해서 3D IOU를 계산해서 AP2D와 같은 공식을 적용한다. 하지만 이 방법은 IOU만 고려하고, GT와 predict box의 Orientation estimation을 고려하지 않는다. (Orientation이 많이 달라도 IOU만 크면 Positive라고 판단하는 문제점)

  5. AHS : 4.AP3D와 2.AOS를 융합한 방법이다. (AP3D metric weighted by the cosine similarity of regressed and ground-truth orientations)

    image-20210215152009589

[Ps. 논문에서 그림 수식을 제공하는 Matrix만 그림 첨부]

  • 성능 비교를 여기서 보지말고, 최신 3D-Detection 논문을 찾고 거기서 나오는 Results와 Matrix를 공부하자. (일단 아래와 같이 표만 정리해 두었다)
  • image-20210215152426868

5. Research Challenges

  1. 자율주행에 사용할 수 있을 정도로의 Detection performance levels를 획득해야 한다. 따라서 주행의 안정성과 Detection performance를 연관시켜서 정량화 할 것 인지? 에 대한 연구도 필요하다. (how detection performance relates to the safety of driving)
  2. Points에 대한 the geometrical relationships가 탐구되어야 한다. Point clouds를 살펴보면, missing points and occulsion, truncation이 많기 때문이다.
  3. Sensor fusion 뿐만 아니라, V2X 와 같은 multi-agent fusion scheme이 수행되어야 한다.
  4. KITTI는 거의 daylight에 대한 데이터 뿐이다. 일반적이고 전체적인 Conditions에서의 안정적은 성능을 달성하기 위해서 노력해야 한다. 시뮬레이션 툴을 사용하거나, Compound Domain Adaptation 등을 이용한다.
  5. Real time operation을 위해서는 적어도 10fps 이상의 속도 능력이 필요하다. real time operation을 유지해야한다.
  6. uncertainty in detection models을 정확히 정량화해야한다. calibrated confidence Score on predictions와 실제 주행 인지에서의 Uncertainty와의 gap은 분명히 존재한다.

【LightWeight】Understanding EfficientNet+EfficientDet paper w/ code

1. EfficientNet from youtube

img01 img02 img03 img04 img05 img06 img07 img08 img09 img10 img11 img12 img13 img14 img15 img16 img17 img18 img19 img20 img21 img22 img23 img24 img25 img26 img27 img28 img29 img30 img31 img32

2. lukemelas/EfficientNet-PyTorch

  • Github-Link : EfficientNet-PyTorch

  • EfficientNet은 a family of image classification models 이다. Based on MnasNet in term of AutoML, Compound Scaling.

  • Simply, Model 불러와 Classification 수행하기

    • import json
      from PIL import Image
      import torch
      from torchvision import transforms
          
      from efficientnet_pytorch import EfficientNet
      model = EfficientNet.from_pretrained('efficientnet-b0')
          
      # 0. Preprocess image
      tfms = transforms.Compose([transforms.Resize(224), transforms.ToTensor(),
          transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),])
      img = tfms(Image.open('img.jpg')).unsqueeze(0)
      print(img.shape) # torch.Size([1, 3, 224, 224])
          
      # 0. Load ImageNet class names
      labels_map = json.load(open('labels_map.txt'))  # 이미 EfficientNet-Pytorch/examples/simple/labels_map.txt 있다.
      labels_map = [labels_map[str(i)] for i in range(1000)]
          
      # 1. For Classify
      model.eval()
      with torch.no_grad():
          outputs = model(img)
          
      # 2. For Feature Extractor
      features = model.extract_features(img)
      print(features.shape) # torch.Size([1, 1280, 7, 7])
      
  • Pytorch Efficient-Net model Code



3. EfficientDet from youtube

img01 img02 img03 img04 img05 img06 img07 img08 img09 img10 img11 img12 img13 img14 img15 img16 img17 img18 img19 img20 img21 img22 img23 img24 img25 img26 img27 img28 img29 img30 img31 img32

4. zylo117/Yet-Another-EfficientDet-Pytorch

【LightWeight】Understanding MnasNet+NAS-FPN from youtube w/ code

1. MnasNet from youtube

  • 논문에 나오는 최종 모델 Architecture
    image-20210210145223586
  • 발표자분들끼리 하는 이야기로, 이런 NAS 작업을 우리같은 일반인이 하기는 쉽지 않다. 구글의 목표는 “너네가 원하는 신경망을 최적으로 찾고 싶다면, 너네 스스로 하지말고 돈 좀 내고 우리가 만든 플랫폼을 사용해서 최적의 신경망을 찾아” 라는 것을 목표로 한다고 한다. 따라서 NAS를 일반인이 하기에는 더욱 어려운 것 같다.
  • 그럼에도 불구하고 이 논문이 나오기 전, EnasNet은 [기존에 800개의 GPU로 21일을 학습시켜서 최적의 모델을 찾은 NAS]에 비해서 학습 효율이 더 좋게 만들기 위한 목적을 가지고 있다. 1개의 GPU로 8시간을 학습했다고 한다. 나중에 정말 NAS를 공부해야한다면 EnasNet 또한 읽어보는 것도 좋겠다.
  • 강의 필기 자료

img01 img02 img03 img04 img05 img06 img07 img08 img09 img10 img11 img12 img13 img14 img15 img16 img17 img18 img19 img20 img21 img22 img23 img24 img25 img26 img27 img28 img29 img30



2. NAS-FPN from youtube

  • 논문에 나오는 최종 모델 (아래 그림에서 (a) -> (f)는 모델의 발전 과정이다.) image-20210210145039802
  • 강의 필기 자료

img01 img02 img03 img04 img05 img06 img07 img08 img09 img10 img11 img12 img13 img14 img15 img16 img17 img18

3. code - MnasNet-PyTorch

  • Github1 - AnjieCheng/MnasNet-PyTorch <- MnasNet.py 파일 1개만 있다.
  • Github2- Cadene/pretrained-models.pytorch <- NASNet 뿐만 아니라, Backbone으로 사용하기 좋은 pretrained-model들이 다앙햐게 있다.
# MnasNet.py 
class MnasNet(nn.Module):
    def __init__(self, n_class=1000, input_size=224, width_mult=1.):
        super(MnasNet, self).__init__()

        # setting of inverted residual blocks
        self.interverted_residual_setting = [
            # t, c, n, s, k
            [3, 24,  3, 2, 3],  # -> 56x56
            [3, 40,  3, 2, 5],  # -> 28x28
            [6, 80,  3, 2, 5],  # -> 14x14
            [6, 96,  2, 1, 3],  # -> 14x14
            [6, 192, 4, 2, 5],  # -> 7x7
            [6, 320, 1, 1, 3],  # -> 7x7
            """
            t : expand_ratio(Channel 몇 배로 확장 후 축소) 
            c : output_channel 
            n : 같은 block 몇번 반복? 
            s : stride 
            k : kernel
            """
        ]

        assert input_size % 32 == 0
        input_channel = int(32 * width_mult)
        self.last_channel = int(1280 * width_mult) if width_mult > 1.0 else 1280

        # building first two layer
        # 여기서 Conv_3x3, SepConv_3x3 함수는 nn.Sequential( ... )를 return 하는 함수이다.
        self.features = [Conv_3x3(3, input_channel, 2), SepConv_3x3(input_channel, 16)]
        input_channel = 16

        # building inverted residual blocks (MBConv)
        for t, c, n, s, k in self.interverted_residual_setting:
            output_channel = int(c * width_mult)
            for i in range(n):
                if i == 0:
                    self.features.append(InvertedResidual(input_channel, output_channel, s, t, k))
                else:
                    self.features.append(InvertedResidual(input_channel, output_channel, 1, t, k))
                input_channel = output_channel

        # building last several layers
        self.features.append(Conv_1x1(input_channel, self.last_channel))
        self.features.append(nn.AdaptiveAvgPool2d(1))

        # make it nn.Sequential
        self.features = nn.Sequential(*self.features)

        # building classifier
        self.classifier = nn.Sequential(
            nn.Dropout(),
            nn.Linear(self.last_channel, n_class),
        )

        self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        x = x.view(-1, self.last_channel)
        x = self.classifier(x)
        return x

【Detection】Understanding YOLOv4 paper w/ code, my advice

  • 논문 : YOLOv4: Optimal Speed and Accuracy of Object Detection

  • 분류 : Object Detection

  • 저자 : Alexey Bochkovskiy, Chien-Yao Wang, Hong-Yuan Mark Liao

  • 읽는 배경 : Recognition Basic. Understand confusing and ambiguous things.

  • 읽으면서 생각할 포인트 : 코드와 함께 최대한 완벽히 이해하기. 이해한 것 정확히 기록해두기.

  • 느낀점 :

    • 논문 리뷰 정리를 할 때. 자꾸 같은 내용은 여기저기 쓰지 말아라. 한 곳에 몰아 정리하자.

      • 예를 들어 A,B라는 Key Idae가 있다고 치자. 그럼 아래 처럼 실제 논문에는 “같은 내용 반복하거나, 어디 다른 곳에서 추가 특징을 적어 놓는다” 그렇다고 나도 따로따로 분산해서 정리해 두면 안된다. “깔끔하게 정말 핵심만 한곳에 모아 정리해야 한다” 즉. 굳이 논문과 같은 목차로 정리해야한다는 강박증을 가지지 말아라. 어차피 핵심만 모으면 별거 없고, 한곳에 모인다.

      •       
        $ 실제 논문에는 이렇게 적혀 있다.
        1. Conclusion ,abstract
          - A idea
          - A의 장점1
          - A의 장점2
          - B idea
          - B의 장점1
        2. introduction
          - A의 장점1
          - A의 장점2
          - B의 장점1
          - B의 장점2
        3. Relative Work
          - A의 장점3
          - B의 장점2
          - B의 장점3
                
        $ ** 내가 정리해야 하는 방법 **
        1. Conclusion ,abstract
          - A idea
          - A의 장점1
          - A의 장점2
          - A의 장점3
          - B idea
          - B의 장점1
          - B의 장점2
          - B의 장점3
        
        
      • YoloV4 는 새로운 기법을 공부하기 위해서 읽는 논문이 아니로, 그냥 Object Detection Survey 논문이다.
  • 목차

    1. YoloV4 from youtube (바로가기)
    2. YoloV4 Paper (바로가기)
    3. Code - Tianxiaomo/pytorch-YOLOv4 (바로가기)
    4. About YoloV5 (바로가기)
  • PS

  • 추가로 읽어야겠다고 생각되는 논문

    1. PAN - path aggregation network
    2. ATSS : Bridging the Gap Between Anchor-based and Anchor-free Detection via Adaptive Training Sample Selection (citation : 74)
    3. RFB : Receptive Field Block Net for Accurate and Fast Object Detection (ASPP의 발전된 형태)
    4. Cross stage partial connections (DenseNet의 경량화 버전)
    5. Batch Normalization 블로그 & 동영상, CBN (Cross Batch Normalization)
    6. Soft-NMS -> DIoU-NMS
    7. CIoU-loss
    8. Mish Activation
    9. DropBlock regularization
    10. Class label smoothing

1. YoloV4 from youtube

  • youtube 논문 발표 링크 - 설명과 정리를 잘해주셨다.
  • 이 정도 논문이면, 내가 직접 읽어보는게 좋을 것 같아서 발표자료 보고 블로그는 안 찾아보기로 함
  • 강의 필기 PDF는 “OneDrive\21.겨울방학\RCV_lab\논문읽기”

img01 img02 img03 img04 img05 img06 img07 img08 img09 img10 img11 img12 img13 img14 img15 img16 img17 img18 img19 img20 img21 img22 img23 img24 img25 img26 img27

2. YoloV4 Paper Review

1. Conclustion, Abstract, Introduction

  • Faster / more Accurate(AP_(50…95) and AP_(50)) / best-practice with only one conventional GPU (1080 Ti or 2080 Ti GPU)
  • batch-normalization and residual-connections 과 같은 통념적으로 사용되는 Feature(여기서는 특정기술,특정방법론 이라고 해석해야함. Feature Map의 Feature 아님)뿐만 아니라, 아래와 같이 YoloV4에서 많은 성능향상을 준 Feature들이 있다.
    1. 무시가능한 특정기술 : Self-adversarial-training (SAT) (-> 좋다는 결과 없음. 일단 무시)
    2. 중간 중요도의 특정기술 : CmBN, DropBlock regularization, and CIoU loss. 기법들
    3. 중상 중요도 특정기술 : Weighted-Residual-Connections (WRC), Cross-Stage-Partial-connections (CSP), Cross mini-Batch Normalization (CmBN), Mish-activation
    4. 자신들이 Modified한 특정기술 : Cross Batch Normalization (CBN), Path aggregation network(APN), CBAM(SelfAttentionModul)
    5. 자신들이 추가하거나 수정한 특정기술: Mosaic data augmentation
    6. (1) Bag-ofFreebies and (2) Bag-of-Specials methods : 아래 목차에서 차근히 다룰 예정
  • 최종 성능 : 43.5% AP (65.7% AP50) for the MS COCO / speed of ∼65 FPS on Tesla V100.
  • image-20210208163946588
    1. ASFF : Learning Spatial Fusion for Single-Shot Object Detection (citation : 14)
    2. ATSS : Bridging the Gap Between Anchor-based and Anchor-free Detection via Adaptive Training Sample Selection (citation : 74)
  1. Object detection models
    • image-20210208184736493
    • 최근에 핫한 기술에 이런 것들이 있다.
    • 특히 Neck 이란? different stages로부터 Feature Maps 정보를 Collect한다.
  2. Bag of freebies
    • change the training strategy or increase the training cost 하는 방법들
    • data augmentation
      1. pixel-wise adjustments
      • photometric distortions : the brightness, contrast, hue, saturation, and noise of an image.
      • geometric distortions : random scaling, cropping, flipping, and rotating 2. simulating object occlusion issues
      • random erase(칼라 구멍), CutOut(검정 구멍)
      • hide-and-seek, grid mask : 일부 사각형 구역 검정
      • DropOut, DropConnect, and DropBlock 위 기법과 비슷한 컨셉
      • MixUp(두 이미지 blending), CutMix(구멍 - 다른 사진+Label) : multiple images together 사용하기
      • style transfer GAN : 현재 내가 가진 the texture bias 줄인다.
    • the problem of semantic distribution bias (예를들어, data imbalance)
    • Only two-stage : hard negative example mining & online hard example mining
    • one-stage : focal loss
    • label smoothing [73] , label refinement network [33]
    • the objective function of Bounding Box (BBox) regression
    • MSE : corresponding offset를 예측하는 것은, 온전체 객체 그 자체의 정보를 이용하는 것이 아니다.
    • IoU loss : IOU가 커지도록 유도됨. offset Loss는 (GT 박스가) 큰 객체에서는 상대적으로 loss가 커지는 경향이 있었는데, IOU loss에서는 이런 문제가 없음.
    • G_IOU : 객체의 모양이나 회전 정보를 포함
    • DIoU : GT와 BB의 center간의 distance 고려
    • CIoU : overlapping area, center distacne, the aspect ratio 모두 고려 (GOOD)
  3. Bag of specials
    • increase the inference cost 하는 방법들
    • enhance receptive field
      • SPP [25], ASPP(dilated ratio) [5] -> RFB(가장 종합적 이해와 낮은 Cost 좋은 성능 향상)[47]
    • attention module
      • channel-wise attention(channel 기준 pooling) and pointwise-wise attention(1x1xdepth의 cell 기준 pooling)
      • Squeeze-and-Excitation (SE) -> Spatial Attention Module (SAM=CBAM) (extra calculation 적음. GPU 연산 속도에 영향 없음)
    • feature integration
      • skip connection, hyper-column [22], FPN
      • 새로운 관점의 FPN : SFAM(SE module to execute channelwise level) [98] , ASFF(point-wise level reweighting) [48], and BiFPN(scale-wise level re-weighting and Adding feature maps of different scales) [77].
    • activation function
      • LReLU [54], PReLU [24] : zero gradient problem 해결
      • ReLU6 [28], Scaled Exponential Linear Unit (SELU) [35], hard-Swish [27]
      • Swish and Mish : continuously differentiable activation function.
    • post-processing
      • greedy(origin) NMS : optimizing & objective function 두개가 일관(일치)되게 만든다. by Confidence score
      • soft NMS : greedy NMS가 Confidence score의 저하 문제를 고려함
      • DIoU NMS : soft NMS에서 the center point distance개념을 추가
      • 하지만 anchor-free method 에서는 더 이상 post-processing을 필요로 하지 않는다.
    • Normalization
      • Batch Normalization에 대해서는 나중에 다시 진지하게 공부해 봐야겠다.
      • Batch Normalization (BN) [32], Cross-GPU Batch Normalization (CGBN or SyncBN) [93], Filter Response Normalization (FRN) [70], or Cross-Iteration Batch Normalization (CBN) [89]
    • Skip-connections
      • Residual connections, Weighted residual connections, Multi-input weighted residual connections, or Cross stage partial connections (CSP)

3. Methodology

  1. Backbone 선택
    • 아래의 조건을 만족하는 Cross-Stage-Partial-connections (CSP) (DenseNet의 경량화 버전) 과 DarkNet을 접목시켜서 사용. or CSPResNext50
    • Higher input Resolution For Small-objects
    • More Layers For Higher receptive field
    • More parameters For more accurate
  2. 많은 실험을 통한 Selection of BoF and BoS (주의할점 : 여기에서 좋은 결과를 내어야만 좋은 Method인 것은 아니다. 저자가 코드를 잘 못 이해하고 코드 적용이 잘못 됐을 수도 있는 거니까. By PPT발표자)
  3. Additional improvements
    1. data augmentation Mosaic : 4개의 이미지 합치기, batch normalization에 효과적
    2. CmBN collects statistics only between mini-batches within a single batch. Batch No
      image-20210208210015808
    3. SAM(CBAM) 그리고 PAN을 아래와 같이 수정했다. (그림만 나오지 구체적인 방법 없다.)
      • image-20210208210419416
  4. 최종적으로 YoloV4에서 사용한 방법론
    • image-20210208204847617
    • 시간이 날 때마다, 위의 방법론들에 대해서 찾아 공부하는 것도 좋을 것 같다.
  5. 실험결과는 윗 목차의 PPT 내용 참조

3. Tianxiaomo/pytorch-YOLOv4

  1. Github Link : Tianxiaomo/pytorch-YOLOv4 (중국어 Issue가 많아서 아쉬웠지만, 이거말고 1.1k star를 가지고 있는 YoloV4-pytorch repo도 대만사람이여서 그냥 둘다 비슷하다고 판단. 2.6k star인 이 repo보는게 낫다)
  2. ONNX : Open Neural Network Exchange
    • machine learning frameworks(Pytorch, Caffe, TF)들 사이의 Switching을 돕기 위해 만들어진 툴 by Facebook, Microsoft
    • onnx라는 파일 형식이 있다. Convert Pytorch into ONNX Tutorial
    • 그래서 아래와 같은 파일이, 이 깃허브 파일에 존재한다.
      • demo_pytorch2onnx.py : tool to convert into onnx
      • demo_darknet2onnx.py : tool to convert into onnx
  3. 이렇게 정리 되어 있어서 너무 좋다. 우리가 여기서 집중해야 할 파일은 models.py image-20210208143148246
  4. 2021.02.08 : ONNX와 YoloV4에 대한 코드 공부는 지금 당장 필요 없다. 위에서 사용된 Method들 중 모르는 것은 일단 논문을 읽어야 한다. 그리고 각 Method에 따른 코드를 Github에서 다시 찾던지, 혹은 이 YoloV4 repo에서 찾아서 공부하면 된다.

4. About YoloV5

  • YoloV5 Git issue : Where is paper? // The project should not be named yolov5
  • 위의 Issues를 읽어보면, 다음과 같은 것을 알 수 있다.
    1. 논문은 아직 나오지 않았다.
    2. yoloV5에 대한, 사람들의 불만이 있다. yoloV4에서 특별히 새로울게 없다.
  • 그럼에도 불구하고, YoloV5 github는 8500k의 star를 가지고 있다. YoloV4가 2600개의 star인것에 비해서.
  • 우선은 YoloV4 까지만 공부하자. 나중에 모델 사용에 있어서는 YoloV5를 사용하는게 맞는 듯 하다.
  • 어차피 YoloV4, YoloV5 모두, YoloV1,2,3의 저자인 Joseph Redmon에 의해서 만들어진 모델은 아니다.

Pagination


© All rights reserved By Junha Song.