https://arxiv.org/abs/2106.13230

 

Video Swin Transformer

The vision community is witnessing a modeling shift from CNNs to Transformers, where pure Transformer architectures have attained top accuracy on the major video recognition benchmarks. These video models are all built on Transformer layers that globally c

arxiv.org

Abstract

  • Pure Transformer Architecture가 Video Recognition Benchmark에서 좋은 Accuracy를 보임
  • 이런 Video Model Transformer Model은 Spatial, Temporal Dimension을 Global하게 연결
  • 해당 논문에서는 Video Transformer에서의 Locality Inductive Bias를 옹호
  • 이는 Global로 Attention을 하는 것에 비해서 더 나은 Speed-Accruacy의 Balance가 지켜짐
  • 저자들의 Video Architecture는 Image Domain을 해결하기 위해 설계된 Swin Transformer를 적용하는 동시에 Pretrain된 Image Model의 힘을 활용
  • 다양한 Test에서 SOTA에 달성, Less Pretraining, Smaller Model Size

Introduction

  • CNN Based Backbone 구조는 긴 기간동안에 Computer Vision분야에 지배적이였지만, ViT(globally models spatial relationships on non-overlapping image patches)의 등장으로 다양한 Task에서 Transformer를 이용, 이는 Video Recognition Task도 해당함
  • 이전 Video Task의 CNN Model은 단순히 Temporal Axis로 확장한 형태로 진행, 이런 Joint SpatioTemporal Modeling은 Computational Cost가 경제적이지 않고, Optimize가 쉽지 않음
  • 이를 해결하고자 Factorization(Spatio Temporal을 분리)해서 더 나은 Speed와 Accuracy를 달성함
  • Transformer Base의 Video Recognition의 첫 시도는 ViViT와 TimeSformer에서 나온 Factorized Encoder, Factorized Self-Attention -> 연산량을 낮추고, 모델의 크기를 줄임

  • 해당 논문에서는 Pure Transformer Backbone 구조를 이용하는 Video Recognition을 소개, Factorized Model보다 좋은 효율을 가짐
  • Spatio Temporal Locality(Spatiotemporal Distance가 가까운 Pixel이 더 관련있는)를 가지는 Video의 특성을 활용
  • 이 특성으로 인해 Full SpatioTemproal Attention은 Local에서 계산된 Self-Attention에 의해 근사 가능

  • 저자들의 구현은 Swin Tranformer의 접근 방식은 SpatioTemproal에 맞게 바꿈
  • Swin Transformer는 Spatial locality뿐만 아니라 Translation Invariance를 이
  • Video Swin Transformer라고 불리는 Model은 원래 Swin Transformer의 hierarchical structure를 이용하고, Local Attention의 범위를 Spatial에서 SpatioTemporal 영역까지 확장
  • Non-Overlapping Window에서 Local Attention이 계산됨에 따라 원래 Swin Transformer의 Shifted Window 메커니즘도 Temporal 영역까지 확장
  • Swin Transformer를 이용하기 때문에 ImageNet-21k으로 Pretrain하고, 이를 이용해 초기화 가능
  • Backbone의 Learning Rate는 Head에 비해 0.1배로 진행함
  • 결과적으로 Backbone은 새로운 Video Data에 맞추는 동안 Pretrain된 Parameter와 Data를 느리게 잊어 더 나은 일반화 방법으로 이어짐, 이런 Pretrain된 Parameter를 이용하는 방법을 찾음
  • 이런 방법으로 여러 Task에서 SOTA에 달성

Related Work

  • CNN and Variants
    - CNN은 긴 기간동안 Computer Vision 분야에 Standard
    - 3D Modeling을 하기 위해서는 단순히 Temporal 축으로 차원을 늘려서 진행하는 CNN방식을 이용
    - 하지만 Small Receptive Field를 가짐, 이를 넓히기 위에서는 Network Depth를 늘려야 함
    - 이는 Parameter증가, Computational Cost 증가라는 문제가 야기됨, 이로 인해 Self-Attention Mechanism이 Vision분야에 주목을 받음
  • Self-Attention / Transformers To Complement CNNs
    - NLNet는 Visual Recognition Task를 해결하기 위해 Self-Attention을 채택한 최초의 방식
    - GCNet, DNL등 다양한 Task에서 Long Range Dependencise를 Modeling하기 위해 CNN에 보완적인 방식
    - 저자들의 방식은 Self-Attention의 힘을 이용하여 우수한 성능으로 이어짐
  • Vision Transformers
    - ViT의 시작으로 Computer Vision분야의 Backbone으로 CNN에서 Transformer로 넘어감
    - DeiT는 Several Traning Strategies 를 통합하여 적은량의 Data로도 학습이 가능하도록 한 방식
    - Swin Transformer는 Locality, Hierarchy, Translation Invariance라는 Inductive Bias를 가짐
    - Swin은 이로인해 General Purpose Backbone으로서 Image Recognition Task에 주목을 받음
  • Image -> Video
    - Image Transformer의 큰 성공으로 Video Based Recognition Task에 대한 연구도 진행됨
    - VTN은 Pretrain된 ViT위에 Temporal Attention Encoder를 추가, 좋은 성능을 얻음
    - TimeSformer는 5가지의 다양한 Attention 방식을 연구
    - ViViT는 Pretrain 된 ViT Model에 대한 Space, Time Attention에 대해 다양한 Factorized Design을 보여줌
    - 여러 연구들은 모두 Global Self-Attention Module을 Base로 함
    - 이 논문은 Spatio Temporal Locality를 조사한 다음, spatiotemporalLocality bias를 가지는 Video Swin Transformer가 기존 Video Transformer의 성능을 능가 한다는것을 입증

Video Swin Transformer

Video Swin Transformer(Tiny Version)

  • 3.1 Overall Architecture
    - Tiny Version을 시각화 한 것
    - Input 으로 T x H x W x 3, T는 Frame, H x W x C는 Image
    - Video Swin Transformer는 3D Patch를 다루는데, Size는 2 x 4 x 4 x 3
    - 3D Patch Partitioning Layer에서는 T / 2 x H / 4 x W / 4 개의 3D Token을 얻을 수 있음, Channel은 2 x 4 x 4 x 3 = 96
    - 이를 Linear Embedding Layer를 적용하여 Arbitrary Dimension인 C로 투영
  • 해당 저자들은 Temporal Dimension을 따라 Down Sampling을 진행하지 않음
    - 4-Stage로 구성되고 각 Stage에서 Patch Merging Layer에서 2x Spatial Down Sampling을 진행하는 Original Swin Transformer와 비슷한 구조
    - Patch Merging Layer는 2x2 Spatially Neighboring Patch Group의 Feature를 연결하여, Linear Layer를 적용해서 4C가된 Channel Dim의 크기를 2C로 투영 

  • Video Swin Transformer Block의 Major Component는 W-MSA, SW-MSA는 3D로 바꾼 것
    - 다른 Component는 바꾸지 않음
  • 3.2 3D Shifted Window Based MSA Module
    - Image와 비교해서 Video는 Temporal Dimension이 존재해서 아주 많은 Input Token을 가지게됨
    - 그러므로 Global Self-Attention Module은 Video Task에 적합하지 않음(Video는 상당한 Computation, Memory Cost가 발생함)
    -  Swin Transformer의 Locality Inductive Bias가 Video에도 효과적

  • Multi-head self-attention on non-overlapping 3D windows
    - Non-Overlapping 2D Window MSA는 Image Recognition Task에서 effective and efficient가 뛰어남
    - 저자들은 Video Input에 이것을 단순하게 확장
    - Input으로 T' × H' × W' 3D Token이 들어오고 P x M x M 3D Window가 주어지면, Window는 Non-Overlapping 방식으로 Video Input을 균일하게 분할
    - 즉  Input token은 T' / P x H' / M x W' / M 으로 변함
    - Figure 3를 보면 Input Token가 8 x 8 x 8 이고, Window Size가 4 x 4 x 4 일 총 8개의 Window로 분할됨
  • 3D Shifted Windows
    - Self-Attention Mechanisim은 Non-Overlapping 3D Window에 적용됨
    - 하지만 Swin 에서 설명한 것처럼 다른 Window와의 Connections이 부족하고, 이는 Representation Power가 Limit
    - 이를 해결하기 위해 저자들도 Swin에서 이용된 것처럼 2D Shited Mechanism을 3D로 확대, 이런 방식은 Window간의 Connection을 이용하고, Non Overlapping Window Self-Attention의 효율적인 계산을 유지
    - T' x H' X W' 3D Token, 3D Window P x M x M, 연속된 두개의 Layer에서 각 Window내에는 [T'/P] x [H'/M] x ['W'/M]
    - 1-Layer에서 Self-Attention을 취하고 (P/2, M/2, M/2) 만큼 오른쪽 아래방향으로 Shift
    - Figure3을 보면 Input Size = 8 x 8 x 8, Window Size = 4 x 4 x 4, 그러면 Window의 개수는 2 x 2 x 2 = 8개가 된다.
    - 그 다음 Layer에서는 (2, 2, 2) 만큼 Shift 시키고, Window의 개수는 3 x 3 x3 = 27이 된다
    - 이런 방식은 Window의 개수가 늘어났다고 볼 수 이지만, Swin Transformer 의 방식처럼 Cyclic Shift를 이용해서 Masking Self-Attention으로 연산량을 유지 할 수 있다.(Window개수 8로 유지)
    - Image Recongnition과 유사하게 3D Shift접근은 Kinetics 400/600, SSv2 같은 Action Recognition Task에서 효과(Temporal Modeling 잘됨)
  • 3D Relative Position Bias
    -
  • Architecture Variant
    - 4개 Version의 Model Variant가 존재
    - C는 Channel Number, Model Size과 Computational Complexity는 Base Model의 0.25, 0.5, 1, 2배
    - Window size P = 8, M = 7, 각 Head의 Dimension은 d = 32가 되도록 조절, MLP Layer의 Expansion은 4

Model Variants

  • Initialization From Pre-Trained Model
    - Swin Transformer에서 구조를 가져오므로 Large Scale Dataset에서 Pretrain된 Image Model을 이용 가능
    - Swin과 비교하여 Embedding Layer, Relative Position Bias만 다른 모양
    - Relative Position Bias는 단순하게 2P-1번 복제하여 (2P-1, 2M-1, 2M-1)만듬
    - Swin Transformer에서는 48C -> 96C (48C x 96C)로 바뀌는 Linear Embedding, 하지만 Swin Video에서는
    96C -> 96C (96C x 96C)로 바뀜
    - 이를 해결하기 위해  단순하게 Swin TransformerWeight두번 복제하고, 전체에 0.5곱해 평균과 분산을 유지

Experiments

  • Dataset
    - Human Action Recognition Kinetics-400(400 Class, 240k Train Dataset, 20k Valid Dataset)
    - Human Action Recognition Kinetics-600(600 Class, 370k Train Dataset, 28.3k Valid Dataset)
    - Temporal Modeling SSv2(174 Class, 168.9k Train Dataset, 24.7k Valid Dataset)
  • 4.2 Comparison To SOTA

  • Kinetics-400
    - Convolution Based, Transformer Based, Swin Based Model을 비교
    - JFT로 Training ViViT보다 높은 성능을 보여줌(JFT는 ImageNet보다 훨씬 큰 Dataset)
    - ViViT는 JFT로 Training하고 Fine Tuning할 경우 FLOPs가 너무 높지만 Swin-L은 ImageNet으로 Training하여 낮은 FLOPs, 높은 Accuracy를 보여 SOTA
    - JFT로 Swin Transformer를 Training 하면 어떤 결과가 나올지 궁금

  • Kinetics-600
    - K600에서도 비슷한 결과를 얻음
    - ImageNet-21k로 Pre Training한 Swin-L이 JFT로 Pre Training한 ViViT 보다 높은 성능
    - 적은 FLOPs, Parameter가 장점
  • Something-Something V2
    - SSv2에서도 SOTA에 달성
    - MViT-B 모델은 K-600으로 Pretraining 했지만, K-400으로 Pretraining한 Swin-B가 더 높은 성능
    - 더 큰 Resolution 으로 시도하고 싶은데, 이것은 Future Work로 나둠
  • 4.3 Ablation Study
  • Different Designs for SpatioTemporal Attention
    - 3개의 Major Desing을 이용해 Test 진행(Joint, Split, Factorized)
    - Joint Version은 3D Window Based MSA Layer에서 Spatiotemporal Attention을 계산
    - Split Version은 Spatial Swin Transformer위에다가 두개의 Temporal Transformer Layer를 추가, 이 방법은 ViViT에서 효과적(ViViT Facotrized Encoder방식)
    - Factorized는 Swin Transformer의 각 Spatial Only MSA Layer 뒤에 Temporal 전용 MSA Layer 추가, 이는 TimeSformer에서 효과적인것으로 확인
    - Factorized Version은 Pretrain Weight로 Temporal Layer를 초기화 하면 안좋으므로 Temporal Only Layer는 0으로 초기화
    - Joint Version이 적절한 FLOPs, Parameter, Accuracy를 가짐
    - Joint Version은 원래 ViT DeiT에서는 높은 Computational Cost가 높지만, Spatial Domain의 Locality의 효율성을 유지하기 떄문에 계산 비용이 줄어듬(Window Base Attention)
    - Split Version은 잘 동작하지 않음, 해당 방식은 Pretrain에서 좋은 이점을 받기 어려움
    - Factorized Version은 좋은 성능을 가지지만 더 많은 Parameter가 필요

ViViT, TimeSformer

  • Temporal Dimension of 3D Tokens, Temporal Window Size
    - Temporal 정보를 취할때 Temporal 축의 Window크기에 대한 연구를 진행함
    - 일반적으로 Temproal Dimension이 클수록 Global하게 보는 것은 성능이 올라가지만, 느려짐(Window내의 3D Token이 증가)
    - Temporal Dimension을 16으로 유지하고 Window Size의 Temporal를 줄일수록 성능은 낮아지고 연산은 가벼워짐(Window내의 3D Token 감소)
    - 즉 Input Frame이 많을수록, Window의 사이즈가 클수록 성능은 좋아지지만, Token수가 늘어나므로 연산량이 무거워짐

  • 3D Shifted Windows
    - Temporal , Spatial 모두 Shift을 하는 것이 가장 좋게 나온것을 알 수 있다.

  • Ratio of backbone/head learning rate
    - Backbone, Head Learning Rate에 대한비율
    - Backbone의 Learning Rate가 0.1배인 것이 가장 좋은 결과를 얻음
    - 0.1로 설정하여 Backbone은 Pretrain된 Parameter를 천천히 잊고 Data가 새로운 Video Input에 Fitting되도록 함
    - 좀더 일반화 효과가 좋음

  • Initialization on linear embedding layer 
    - ViViT에서는 Center Initialization을 통해 큰 성능상승을 얻음
    - Video Swin에서 2가지 Test를 진행했는데, 표 8처럼 Swin-Transformer 를 이용한 Video Model에서는 동일한 효과
    - 그러므로 inflate 방식을 Default로 정함
  • 3D relative position bias matrix
    - 3D Relative Position Bias Matrix도 두개 방법을 선택함(Duplicate, Center)
    - Linear Embedding Layer의 Center 초기화 방법과는 다르게 여러 Frame에 거쳐 Relative Position BIas를 마스킹해서 3D Relative Position Bias Matrix를 초기화
    -비슷한 성능이 나와 Duplicate 방식을 선택하기로 결정

Conclusion

  • 저자들은 Spatio Temporal Locality Inductive Bias를 기반으로하는 Video Recognition을 위한 Pure Transformer를제안
  • 이 Model은 Image Recognition을 위해 만들어진 Swin Transformer를 기반으로 하였고, 강력한 Pretrain된 Image Model의 힘을 이용함
  • K400, K600, SSv2에서 SOTA에달성

https://arxiv.org/abs/2103.14030

 

Swin Transformer: Hierarchical Vision Transformer using Shifted Windows

This paper presents a new vision Transformer, called Swin Transformer, that capably serves as a general-purpose backbone for computer vision. Challenges in adapting Transformer from language to vision arise from differences between the two domains, such as

arxiv.org

Abstract

  • General Purpose Backbone으로 Computer Vision 분야에 이용가능한 Swin-Transformer를 제안
  • Transformer는 기존에 NLP에서 생겨낫는데 이를 Vision에 적용할때 Domain의 차이, Text에 비해 Token의 개수가 많아지는 고해상도 이미지라는 문제가 존재
  • 이런 문제를 해결하고자 Shifted Window로 계산되는 Transformer를 제안
  • Shfited Window는 Self-Attention을 Non-Overlapping Local Window로 제한하고, Cross-Window 연결을 허용하여 Efficiency를 향상시킴
  • 이런 계층구조는 다양한 규모로 Modeling 가능한 유연성을 가지고, Image Size에 관련해서 Linear Computatioanl을 가지게 됨
  • 이런 방식으로 Vision Backbone을 요구하는 Task에서 SOTA에 달성

Introduction

  • CNN은 Computer Vision 분야에 지배적이고, ImageNet 대회에서 훌륭한 성공을 얻었음
  • Great Scale, Extensive Connection, 정교한 구조까지 다양한 Field에서 발전함

  • 반면에 NLP 분야에서는 다른 방향으로 발전하였고, Transformer라는 아키텍처가 가장 유명함
  • Transduction Task에서는 Sequence Modeling이 필요하고, Transformer는 Long-Range Depedencies를 Attention을 이용해 잘 Capture
  • 이런 NLP에서 성공을 보고 Vision에서도 이를 적용하기 위해 노력

  • 본 논문에서는 Transformer가 NLP 및 CNN이 비전에서 하는 것 처럼 Computer Vision을 위한 General Purpose Backbone 역활을 할 수 있도록 가능성을 확장
  • 해당 저자들은 NLP영역에서 높은 성능을 Vision영역에 이식하는데 두가지 Modalities 차이가 존재
  • 하나는 Scale, NLP Transformer는 처리의 기본 요소로 Word Token을 이용하지만 Visual Element는 크기가 다양함
    이는 Object Detection(객체의 크기, 이를 극복하기 위해 FPN이라는 것이 CNN에 존재)에서 발생하는 문제임. Swin 이전에 Transformer는 모두 Fixed Scale이며 이는 Vision Application에서는 적합하지 않음
  • 두번째는 Text에 비해 Image의 해상도가 너무 높다는 문제, Pixel 수준의 Dense Prediction을 필요로 하는 Semantic Segmentation 같은 Task에서는 이용하기 어려움, Transformer의 Big-O는 Token의 개수의 Quadratic

Swin-Transformer, ViT

  • 이런 문제를 해결하기 위해 General Purpose Backbone인 Swin Transformer를 제안, Hierarchical Feature Map을 구성하고, Image Size에 대해서 Linear Complexity를 가짐
  • 그림의 (a)처럼 Swin Transformer는 Small Size Patch(회색 테두리)에서 시작, 깊어지는 Transformer에서 인접 Patch를 Merge하며 Hierarchical Feature Representation을 생성
  • 이런 Hierarchical Feature Map을 이용해서 FPN, U-Net과 같은 Dense Prediction Task를 위한 Advanced Techniques를 이용 가능
  • Linear Complexity은 빨간색 테두리로 표시된 Non-OverLapping 내에서 Local로 Self-Attention을 진행하므로 가능함
  • 각 창의 Patch의 수는 Fixed이므로 Complexity는 Image Size에 종속됨
  • 이러한 장점으로 다양한 Vision Task의 Backbone으로 이용 가능하고, 기존의 Single Resolution Feature Map을 만드는 ViT에 비해 유용

Figure2

  • Swin Transformer의 Key Design은 Shift of Window Partition Between Consecutive Self-Attention Layer
  • Window 내의 모든 Query Patch는 동일한 Key Set을 공유하므로 Memory Access에 용이함
  • Sliding Window기법글은 매번 서로 다른 Query Pixel에 대한 서로 다른 Key Set을 이용하므로 느
  • Shfited Window는 이전 Layer의 Window를 Bridge하여 Modeling 성능 향상
  • Sliding Window보다 빠른 속도, 낮은 지연시간을 가짐

Related Work

  • CNN은 Deeper, Effective Convolution 방식으로 진화, VGG, GoogleNet, ResNet Etc.. Backbone으로 유용함

  • Self-Attention Base의 NLP 성공으로 영감을 받은 Vision 연구자들은 ResNet을 대체하기 위해 노력, 하지만 기존 CNN에 비해 Memory Cost도 높음

  • CNN과 Transformer를 붙이는 DETR같은 Task도 존재

  • 여러 시도가 있었지만, Dense Prediction Task에서 이용하기 위해서는 여러 해상도의 Feature Map이 필요, 그러므로 Swin Transformer가 이를 해결

Method

  • Swin Transformer Tiny 시각화
  • 처음으로 Input RGB image가 들어오면 Non-OverLapping Patch로 Split(ViT 방식) 각 Patch는 Token
  • 저자들은 4 x 4 Patch를 이용하여 각 Patch의 Feature Dimension은 4 x 4 x 3 = 48이됨
  • 그 뒤에 Linear Embedding Layer를 통과시켜 차원 C로 Projection H / 4 x W / 4 x 48 -> H / 4 x W / 4 x C
  • 이후에 Transformer Block에서는 Token의 개수를 유지하며 진행됨(Stage 1 , H / 4 x W / 4 Token)
  • Hierarchical Representation을 위해 Patch Merging Layer를 이용해 병합, Token수 감소
  • 첫 Patch Merge에서는 인접한 2x2 Patch에 대해 각 Group의 Feature로 연결, 4C 차원으로 깊어진 Feature에 대해서 Linear Projection을 적용(2C)
  • 이 방식은 Token의 개수를 4배 줄임( H / 4 * W / 4 -> H / 8 * W / 8) 이것을 Stage 3, 4에 반복
  • VGGNet, ResNet 과 비슷한 동작방식으로 Backbone으로 이용 가능
  • Swin Transformer는 두개의 연속된 Swin Transformer구조는 W-MSA, MLP, SW-MSA, MLP 구조를 가지게 됨
  • Standard Transformer는 Global Self-Attention을 진행, Global Attention은 계산량이 Token의 개수에 대해 Quadratic, 이는 Token이 많은 Vision에 적합 x
  • Self-Attention in Non-Overlapped Window : 효율적인 Modeling을 위해 Local Window내에서 Self-Attention을 계산 할 것을 제안
  • Window들은 Non-Overlapping 되는 방식으로 Image를 균일하게 분할
  • 각 Window에 M x M Patch가 포함되어 있다고 가정하면, 계산량은 아래와 같고, W-MSA 방식이 훨씬 가벼운 것을 알 수 있음

M = 7 Default, hw에 비해 엄청 작은값

  • Shifted window partitioning in successive blocks : Window-Base Self-Attention Module에서는 다른 Window간의 Connection이 부족함
  • Non-Overlapping Window의 효율적인 계산을 유지하며, Cross-Window Connection을 도입하기 위해 Consecutive Swin Transformer Block에서 두개의 방법을 오가며 진행하는 것을 제안
  • Figure2 처럼 첫 Module은 일반적인 Window내의 8 x 8 Feature Map은 4 x 4의 , 즉 2x2개의 Window로 나누어져서 Window내에서 Self Attention을 취함
  • 그 뒤에 Window크기의 절반만큼 오른쪽 아래 방향으로 Shift하여 Self-Attention을 진행

  • Shifted Window Partitioning 접근법으로 다양한 Task에서 효과적

  • Efficient batch computation for shifted configuration : Window를 Shift시키면 기존 [h / M] X [w / M] 에서
    [h / M + 1] X [w / M + 1]이 됨, 그리고 몇몇 Window는 M x M보다 작게됨(Patch Size보다)
  • Navie Solution은 작은 창을 M x M 크기로 Padding하는것, 이런 방식은 2x2 -> 3x3 계산량이 2.25베 증가
  • Cyclic Shift 방식을 이용하여 다시 2x2 Window Self-Attention을 취함
  • 하지만 이때 Masking을 이용하여 같은 Partition내에 있는 Window에 대해서만 Attention이 진행되도록 함
  • 결국 4개의 Window에서 Attention Score Map을 구하고, 자기와 같은 구역에 있는 Patch들에 대해서만 Score를 살리고, Masking 하는 방법을 이용

  • Related Position Bias : Swin Transformer는 Self-Attention을 진행할 때 Relative Position Bias를 이용
  • 기존에는 Position Embedding을 절대좌표를 이용했지만 방법을 바꿈
  • B ∈ R(M^2×M^2), Q, K, V ∈ R(M^2×d), M^2은 Window 내의 Patch의 개수
  • Patch 들간의 상대위치를 넣어주며 절대 위치보다는 Object들의 Part를 파악하기 쉬움
  •  

 

  • Model Detail : 총 4개의 Version이 존재

Experiments

  • ImageNet 1k Classificaton, COCO, ADE20K, 3개에서 SOTA달성

  • Image Classification on ImageNet-1K
  • 첫번째는 Pretraining하지 않고 진행한 결과, ViT Base 보다 Parameter가 적고, EfficientNet가 비슷한 결과를 얻음
  • 두번째는 ImageNet 22k로 Pretraining, ImageNet-1k로 Fine Tuning, ViT Model과 비슷한 처리속도를 가진 Swin-B는 훨씬 높은 정확도를 얻음

  • Object Detection on COCO
  • (a) ImageNet 21k Pretraining, 비슷한 Parameter, FLOPs를 가지는 ResNet을 이용, FLOPs 상승, FPS는 감소 했지만 모든 경우에 좋은 성능을 얻음
  • (b) Csacade Mask R-CNN에서 다양한 Backbone을 이용하여 Instance Segmentation, 모든 경우에 Swin이 좋음
  • (c) HTC에서 비교한 결과 모든 SWIN Model이 좋은 결과를 얻음, ResNet은 고도로 최적화된 Cudnn을 이용하지만, 일반적인 Pytorch를 이용해 ResNet보다는 최적화가 덜 된 상태에서도 비슷한 연산, 더 높은 결과. SOTA달성

  • Semantic Segmentation on ADE20K
  • Swin Backbone이 좋은 결과를 얻음, 낮은 FLOPs & Parameter

Ablation Study

  • 각 Design Element를 조사함

app :  the first scaled dot-product term, Table4
Table 5
Table6

  • Table 4에서 Shfited Window방식이 좋은 결과를 얻음, Table5를 봐도 Shfited Window는 적은Overhead를 가짐
  • Relative Position Bias가 있는 경우 제일 좋은 결과, ViT/DeiT는 Visual Modeling에서 오랫동안 중요한 것으로 자리잡은 Translation Invariance를 포기 했지만, Translation Invariance를 장려하는 Inductive Bias가 여전히 Dense Prediction Task에서 선호되는 것을 확인(상대위치)
  • Self-Attention 기법에서 Shfited Window Cyclic이 효율적인 것을 알 수 있음, T, S, B에모두 빠른 속도를 보여줌
  • 또한 정확도 또한 Shifed Window방식이 좋음

 

https://arxiv.org/abs/2010.11929

 

An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale

While the Transformer architecture has become the de-facto standard for natural language processing tasks, its applications to computer vision remain limited. In vision, attention is either applied in conjunction with convolutional networks, or used to rep

arxiv.org

(Inductive Bias란 학습 시에는 만나보지 않았던 상황에 대하여 정확한 예측을 하기 위해 사용하는 추가적인 가정을 의미합니다.)

ViT_발표자료.pdf
1.81MB

 

약 1주일 전에 최종 신체검사 후에 합격 후에 최종 합격 통보를 받았다.자세한 내용은 보안으로 걸릴 수 있으니 분위기 위주로 작성할 예정이다.

 

지원공고 확인

지원 공고 확인은 에브리 타임에서 광고하는 것을 보고 지원하게 되었다.

채용공고
채용 프로세스

지원 가능한 대학 3곳을 1순위, 2순위, 3순위로 나눠서 쓰는 것이 가능했다.(대부분 최종 합격 시 1지망으로 보내는 것 같다)
분야는 원래부터 관심이 있던 그래픽스 및 컴퓨터 비전을 선택했다.

 

설명회

개인적으로 나는 학과 설명회를 안 들어갔다. 원래 들어가려고 생각을 하였으나, 그날에 까먹고 못 들어가 버렸다.
나중에 최종 합격을 하고 알게 된 사실인데 대략적인 인적성 면접에 대한 일정, 형식 등은 설명회에서 이야기해 주었다고 한다. 나는 이를 모르고 인적성 3일 전, 면접 1~2일 전에 급하게 준비한 것 같다. 나 같은 실수는 하지 않았으면 한다.

 

지원서 작성

지원서 항목은 무난 무난한 느낌이었다.(지원 동기, 지원 직무 협업경험, 지원 직무 대표적인 연구 및 프로젝트, 보유한 skill)  대체적으로 500자 제한이라, 나를 어필할 수 있는 내용을 최대한 압축하는 것이 좋은 것 같다. 지원 항목을 보면 느끼는 점이 AI와 관련된 경험이 없거나 비전공자인 경우에는 쓰기 어려운 것 같다는 느낌이 들었다. 직무관련된 경험을 쓰는 항목이 3개나 되고, 나는 각각의 항목마다 총 3개의 프로젝트를 정리해서 작성했다.
개인적으로 서류에서 합/불을 가릴 것 같다는 느낌은 들지 않았다. 실제로 대부분의 회사에서도 코딩 테스트와 인적성은 다 보게 해주는 느낌이기 때문이다. 

 

대략적으로 서류 합격 소식은 10일 정도 걸린 것 같다. 사실 학과 설명회를 들어가서 미리 일정을 알았다면 인적성과 코딩 테스트를 준비하겠지만, 나는 서류 합격 메일을 보고 준비해서 3일 정도밖에 시간이 없었다.

 

인적성/ 코딩 테스트

SD에듀

인적성은 SD 적성검사연구소에서 나온 것을 알라딘 E북으로 구매하였다. 나의 실수로 3일밖에 시간이 없어 최신 기출 유형을 하루 만에 다 풀고, 하루에 한 개씩 모의고사를 풀었다. 그리고 최대한 눈으로 푸는 연습을 했다. 온라인 인적성이니 필기구를 못쓰는 문제가 있기 때문이다.
개인적으로 나는 인적성을 정말 못 풀었다. 실제 시험에서 반타작을 한 것 같다. 그래서 당연히 떨어질 거라 생각했는데, 붙여주는 거 보니 KT도 절대평가 느낌으로 엄청 낮은 점수가 아니면 다 PASS를 주는 것 같다.

 

코딩 테스트는 프로그래머스 플랫폼을 이용했다. 기존에 나는 삼성전자 문제도 많이 풀었고, 백준에서 골드 1 정도 티어를 가지고 있어서 프로그래머스 플랫폼에 적응하는 훈련만을 했다. 근데 문제가 너무너무 쉽게 나와서(실버 5~3 정도 느낌) 3문제를 해결하는 데 약 20분 정도 걸린 것 같다. 남은 1시간 40분 동안에 검토만 했다.
기존에 연습할 때처럼 문제만 빠르게 풀고 코드를 이쁘게 정리 안 했는데, 시간 남으면 정리하는 것이 좋은 것 같다.

대충 합격 소식은 시험을 보고 1주일도 안 돼서 나왔다.

 

실무면접

실무면접은 현직에서 일하시는 분들과 진행하는 면접이다.
다대일로 온라인으로 진행했고, 줌으로 하다 보니 시선처리가 엄청 어려웠다.(시선처리가 가장 중요한 듯)
그리고 내가 바보같이 설명회에 안 들어가고, 인적성이 망해서 당연히 떨어질 줄 알고 준비를 안 했다.
그래서 면접 준비를 하루밖에 못했다.(정확히 8시간 정도, 정장도 없었다. ^^)
면접 내용은 보안이므로 자세히 말을 하지는 못하지만, 자기소개서에 작성한 내용 위주로 진행한 프로젝트에 대해서 질문하셨다.
분위기는 엄청 편안했고, 어려운 질문도 많이 하지 않으셨다.
나는 발음도 좋지 않고, 말도 못 하는 편이라 면접을 걱정했지만 다행히 그런 요소들보다 나의 실무능력 위주로 평가하는 느낌이 강했다.

실무면접도 1주일도 안되서 결과가 나왔다.

임원면접

임원면접은 실무면접보다 불편한 분위기? 였다.

다대일로 이또한 온라인으로 진행했고, 줌으로 하다 보니 시선처리가 어려운것을 당연했다.

그리고 실무는 테이블 배치도 엄청 편하게 되어있었지만, 임원면접은 말그대로 드라마에서 보던 대기업 회의장느낌..이였다. (아무래도 임원분들이다보니 그런것 같다.)

그래도 임원분들이 굉장히 친절하셨다. 긴장을 풀어줄려는 노력이 엄청 보였다..(감사하다)

면접 내용은 자소서 내용이 진짜인지 판단하는 느낌이 강했고, 다른 임원면접처럼 나의 성향을 파악하려는 노력을 많이 하셨다. 중간에 번아웃이 있다고 말실수를 했지만, 다행히 임기응변으로 잘 해결한 것도 있다.

그리고 인성질문이 강한 느낌이였다.
꼬리 질문이 상당히 많았고, 하나하나 캐치해서 질문하는 것이 조금 날카로웠지만 원만하게 잘 해결한 것 같다.
임원면접도 1주일도 안 돼서 결과가 나왔다.
결과가 나오면서 학교를 배치해 주고, 학업계획서를 작성해야 한다. 나는 1지망으로 작성한 한양대학교로 배정되었다.

대학원면접

사실 대학원 면접까지 오면 무조건 붙는다는 주변의 반응이 있어서 준비를 하루밖에 안 했다.
실제로 대학원 면접에 가서 느낀 점은 '무조건 붙는다'였다.
한양대학교 전체 면접날이었고, 대기할 때 KT와 LG 계약학과 인원들과 같이 봤다.
다대1면접으로 교수님들이 많이 바쁜 느낌이 강했다.
들어가서 자기소개 후에 성적 증명서만 보고 이 과목이 A+인데 기억나는 것이 있냐고 물어보셨다.
그렇게 질문 하나하나 하고 끝이었다. 대략 5분 정도?
아무래도 앞에서 힘들게 면접을 봐서 배려를 해준 느낌 같기도 했다.

이렇게 프로세스를 진행하고, 대학원 면접 합격을 받았다.
채용검진은 .. 그냥 떨어지면 병원에 가서 입원해야 하는 느낌이 강할 정도로 단조로웠다.
최종 합격하고 나서 느낀 것이지만, 솔직하게 대답하고 나의 역량을 어필하는 것이 중요한 것 같다.
그리고 나처럼 바보같이 채용설명회를 무시하지 말고 정보를 확보하는 것이 좋은 것 같다.

 

앞으로 2년간 열심히 노력해야겠다. ㅇㅅㅇ..

https://www.acmicpc.net/problem/23291

 

23291번: 어항 정리

마법사 상어는 그동안 배운 마법을 이용해 어항을 정리하려고 한다. 어항은 정육면체 모양이고, 한 변의 길이는 모두 1이다. 상어가 가지고 있는 어항은 N개이고, 가장 처음에 어항은 일렬로 바

www.acmicpc.net

내가 볼려고 쓰는글 가독성 0

 </p

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
import sys
from collections import deque
N, K = map(int, input().split())
fish_input = list(map(int, input().split()))
fishbowl = deque([deque([fish_input[i]]) for i in range(N)])
 
def push_least_fish():
    min_value = min(fishbowl)[0]
    for index in range(N):
        if min_value == fishbowl[index][0]:
            fishbowl[index][0+= 1
 
def left_fishbowl_push():
    fishbowl[1].extend(fishbowl[0])
    fishbowl[0].pop()
 
def fly_upper2():
    while True:
        left_pop_count = 0
        fly_count = 0
        stack_len = 0
        for i in range(len(fishbowl)):
            if len(fishbowl[i]) == 0:
                left_pop_count += 1
            elif len(fishbowl[i]) >= 2:
                stack_len = max(len(fishbowl[i]),stack_len)
                fly_count += 1
        fly = deque()
        for _ in range(left_pop_count):
            fishbowl.popleft()
        if stack_len > len(fishbowl) - fly_count:
            break
        for _ in range(fly_count):
            fly.append(fishbowl.popleft())
        while len(fly) != 0:
            pop_value = fly.pop()
            for _, value in enumerate(pop_value):
                fishbowl[_].append(value)
 
def fish_split():
    dx = [0,1,0,-1]
    dy = [1,0,-1,0]
    new_fish_bowl = deque()
    make_map = [[0 for i in range(len(fishbowl[0]))] for j in range(len(fishbowl))]
 
    for i in range(len(fishbowl)):
        for j in range(len(fishbowl[i])):
            make_map[i][j] = fishbowl[i][j]
    value_info = []
    # print(fishbowl)
    for i in range(len(fishbowl)):
        for j in range(len(fishbowl[i])):
            total_count = 0
            for dx_,dy_ in zip(dx,dy):
                new_x = i + dx_
                new_y = j + dy_
                if new_x >= 0 and new_y >= 0 and new_x < len(fishbowl) and new_y < len(fishbowl[0]) and make_map[new_x][new_y] != 0:
                    minus = abs(make_map[new_x][new_y] - make_map[i][j])
                    # print(i,j,new_x,new_y)
                    # print(make_map[i][j],minus,minus // 5)
                    if make_map[new_x][new_y] > make_map[i][j]:
                        total_count += minus // 5
                    else:
                        total_count -= minus // 5
            value_info.append(total_count)
    index = 0
    for i in range(len(fishbowl)):
        for j in range(len(fishbowl[i])):
            fishbowl[i][j] += value_info[index]
            index += 1
 
def make_line():
    global fishbowl
    new_fish_bowl = deque()
    for index in range(len(fishbowl)):
        for _ in fishbowl[index]:
            dq = deque()
            dq.append(_)
            new_fish_bowl.append(dq)
    fishbowl = new_fish_bowl
 
def repeat_upper():
    number = N
    number = number // 2
    for i in range(number):
        fishbowl[-1 - i].append(fishbowl.popleft()[0])
    number = number // 2
    for i in range(number):
        value = fishbowl.popleft()
        fishbowl[-1 - i].append(value[1])
        fishbowl[-1 - i].append(value[0])
 
answer = 0
while True:
    answer += 1
    push_least_fish()
    left_fishbowl_push()
    fly_upper2()
    fish_split()
    make_line()
    repeat_upper()
    fish_split()
    make_line()
    if max(fishbowl)[0- min(fishbowl)[0<= K:
        print(answer)
        break
cs

https://www.acmicpc.net/problem/23290

 

23290번: 마법사 상어와 복제

첫째 줄에 물고기의 수 M, 상어가 마법을 연습한 횟수 S가 주어진다. 둘째 줄부터 M개의 줄에는 물고기의 정보 fx, fy, d가 주어진다. (fx, fy)는 물고기의 위치를 의미하고, d는 방향을 의미한다. 방향

www.acmicpc.net

개인 기록용

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import sys
from collections import deque
import copy
# input 처리
sys.stdin = open("input.txt","rt")
# 물고기 수 M, 상어 마법 연습 S
M, S = map(int,input().split())
# 초기 입력 fish_pos
fish_pos = deque()
for _ in range(M):
    fish_pos.append(list(map(int,input().split())))
# 상어 위치
sx, sy = map(int,input().split())
 
# dx, dy
dx = [00-1,-1,-10111]
dy = [0,-1-101110,-1]
fish_map = [[[] for i in range(5)]for j in range(5)]
smell_map = [[0 for i in range(5)]for j in range(5)]
def check_range(new_x, new_y):
    if new_x >= 1 and new_x <= 4 and new_y >= 1 and new_y <= 4:
        return True
    else:
        return False
 
def rotete_direction(x,y,dire):
    first = dire
    while check_range(x+dx[dire], y + dy[dire]) == False or (sx == x + dx[dire] and sy == y + dy[dire]) or smell_map[x+dx[dire]][y+dy[dire]] < 0:
        dire -= 1
        if dire == 0:
            dire = 8
        if first == dire:
            return x, y , first
    x = x + dx[dire]
    y = y + dy[dire]
    return x, y, dire
 
def print_map(map_):
    for i in map_[1:5]:
        print(i[1:5])
    print("_"*20)
 
def move_fish():
    global  fish_map
    # print(fish_pos)
    fish_original = fish_map
    fish_map_after = [[[] for i in range(5)] for j in range(5)]
    for i in range(1,5):
        for j in range(1,5):
            arr = fish_map[i][j]
            for value in arr:
                x,y,dire = value[0] , value[1],value[2]
                x,y,dire = rotete_direction(x,y,dire)
                fish_map_after[x][y].append([x,y,dire])
    fish_map = fish_map_after
    return fish_original, fish_map
 
def move_shark(fish_map,fish_original):
    # 상1, 좌2, 하3, 우4
    global fish_pos
    global sx,sy
    shark_move = deque()
    dx_shark = [0,-1,0,1,0]
    dy_shark = [0,0,-1,0,1]
    x, y = [0*3, [0* 3
    for i in range(1,5):
        x[0= sx + dx_shark[i]
        y[0= sy + dy_shark[i]
        if check_range(x[0],y[0]) == False:
            continue
        for j in range(1,5):
            x[1= x[0+ dx_shark[j]
            y[1= y[0+ dy_shark[j]
            if check_range(x[1], y[1]) == False:
                continue
            for k in range(1,5):
                x[2= x[1+ dx_shark[k]
                y[2= y[1+ dy_shark[k]
                if check_range(x[2], y[2]) == False:
                    continue
                count = 0
                for move in set(zip(x,y)):
                    count = count + len(fish_map[move[0]][move[1]])
                x_ = x.copy()
                y_ = y.copy()
                if len(shark_move) == 0:
                    shark_move.append([x_,y_,count])
                elif shark_move[0][2< count:
                    shark_move.appendleft([x_,y_,count])
    sx = shark_move[0][0][2]
    sy = shark_move[0][1][2]
 
    for i in range(1,5):
        for j in range(1,5):
            if smell_map[i][j] < 0:
                smell_map[i][j] += 1
 
    for move in zip(shark_move[0][0],shark_move[0][1]):
        if len(fish_map[move[0]][move[1]]) > 0:
            smell_map[move[0]][move[1]] = -2
            fish_map[move[0]][move[1]].clear()
 
    for i in range(1,5):
        for j in range(1,5):
            fish_map[i][j].extend(fish_original[i][j])
 
 
for i in fish_pos:
    fish_map[i[0]][i[1]].append(i)
for i in range(S):
    fish_original, fish_map = move_fish()
    move_shark(fish_map,fish_original)
answer = 0
for i in range(1,5):
    for j in range(1,5):
       answer += len(fish_map[i][j])
print(answer)
cs

https://www.acmicpc.net/problem/23288

 

23288번: 주사위 굴리기 2

크기가 N×M인 지도가 존재한다. 지도의 오른쪽은 동쪽, 위쪽은 북쪽이다. 지도의 좌표는 (r, c)로 나타내며, r는 북쪽으로부터 떨어진 칸의 개수, c는 서쪽으로부터 떨어진 칸의 개수이다. 가장 왼

www.acmicpc.net

오랜만에 다시 공부하면서 Python으로 문제를 푸는데 흠.. 아직 코드 정리를 잘 못하겠네요.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import sys
from collections import deque
 
N, M, K = map(int,input().split())
graph = []
# 1번 윗면 2번 북족 3번 동쪽 4번 서쪽 5번 남쪽 6번 아래면
dice = [0,1,2,3,4,5,6]
# 0  1  2  3
# 북 동 남 서
direction = 1
# 전 후
change_dice = [
    [[6,5],[5,1],[1,2],[2,6]],
    [[4,1],[1,3],[6,4],[3,6]],
    [[2,1],[1,5],[5,6],[6,2]],
    [[1,4],[3,1],[4,6],[6,3]],
]
dx = [-1,0,1,0]
dy = [0,1,0,-1]
pos = [0,0]
score = 0
map_score = [[0 for i in range(M)] for j in range(N)]
#print(map_score)
def cal_score():
    for i in range(N):
        for j in range(M):
            dq_stack = deque()
            if map_score[i][j] == 0:
                value = graph[i][j]
                dq_set = set()
                dq_set.add(str(i)+" "+str(j))
                dq_stack.append([i,j])
                while len(dq_stack) != 0:
                    dq_pop = dq_stack.popleft()
                    x, y = dq_pop[0], dq_pop[1]
                    for dx_,dy_ in zip(dx,dy):
                        new_x = x + dx_
                        new_y = y + dy_
                        if new_x >= 0 and new_x < N and new_y >= 0 and new_y < M:
                            if graph[new_x][new_y] == value and map_score[new_x][new_y] == 0:
                                map_score[new_x][new_y] = 1
                                dq_set.add(str(new_x) + " " + str(new_y))
                                dq_stack.append([new_x,new_y])
 
                value = len(dq_set) * value
                for i_ in dq_set:
                    split_ = i_.split(" ")
                    map_score[int(split_[0])][int(split_[1])] = value
 
 
 
 
for _ in range(N):
    graph.append(list(map(int,input().split())))
 
cal_score()
answer = 0
for index,i in enumerate(range(K)):
    new_x = dx[direction] + pos[0]
    new_y = dy[direction] + pos[1]
    if new_x >= 0 and new_x < N and new_y >= 0 and new_y < M:
        pass
    else:
        direction = (direction + 2) % 4
        new_x = dx[direction] + pos[0]
        new_y = dy[direction] + pos[1]
    pos[0= new_x
    pos[1= new_y
 
    # 주사위 굴리기
    dict_prev = dice.copy()
    for i in change_dice[direction]:
        dice[i[1]] = dict_prev[i[0]]
 
    # A > B
    if dice[6> graph[pos[0]][pos[1]]:
        direction = (direction + 1) % 4
    elif dice[6< graph[pos[0]][pos[1]]:
        direction = direction - 1
        if direction == -1:
            direction = 3
    answer += map_score[pos[0]][pos[1]]
    #print(pos[0]+1,pos[1]+1,"방향",direction,"아래",dice[6])
print(answer)
cs

https://arxiv.org/abs/1706.03762

 

Attention Is All You Need

The dominant sequence transduction models are based on complex recurrent or convolutional neural networks in an encoder-decoder configuration. The best performing models also connect the encoder and decoder through an attention mechanism. We propose a new

arxiv.org

Abstract

기존의 Dominant Sequence Transduction Model들은 인코더 디코더를 포함하는 복잡한 Recurrent 또는 CNN 기반
가장 성능이 좋은 모델 또한 Attention 메커니즘을 통해 인코더와 디코더를 연결
저자들은 Recurrence와 Convolution을 완전히 배제한 새로운 Network인 Transformer를 제안
두 개의 Translation Task에서 모델이 우수하고 병렬화되어 훈련시간이 훨씬 적게 소요된다는 것을 보여줌
영어-독일어 번역 작업에서 최고 성능은 물론이고, 영어-프랑스어 번역에서도 8개의 GPU를 이용하여 3.5일간 학습 후 Sota에 달성(기존보다 작은 Training Cost)

1. Introdutction

RNN, LSTM, GRU Network는 Sequence Modeling, Machine Translation 등 분야에서 많이 이용

Recurrent Language Model과 Encoder-Decoder의 Boundary를 넓히기 위해 노력

Recurrent Model을 일반적으로 입력 및 출력 시퀀스에 따라 계산을 진행

단계 별로 계산을 진행하므로 이전 Hidden State Ht-1과 t 순서의 입력이 있어야 함

이런 방식은 순차적 특성으로 인해서 Training 시에 병렬처리에 한계가 존재하고, 메모리 제약으로 인해 더 긴 Sequence Length에서 중요해짐

최근 연구에서는 Factorization Trick,  Conditional Computation을 통해 계산 효율을 높이고, 모델 성능을 높임

하지만 Sequential Computation은 근본적인 제약이 있어 한계가 있음

 

Attention Mechanisms은 Sequence Modeling 및 Transduction Model의 다양한 부분에서 필수적인 부분이 되어고, Input Output Sequence Distance에 상관없이 Dependencies를 모델링 할 수 있음

몇 가지 특별한 경우를 제외하고 Attention은 Recurrent Network와 같이 사용됨

 

논문의 저자들은 Recurrence를 피하는 대신 Attention에 전적으로 의존하여 입력과 출력 사이에  Global Dependencies를 도출하는 모델인 Transformer를 제안

모델 병렬화에 큰 효과가 있어 P100 GPU를 이용하여 번역 품질을 개선

2. Background

Sequential Compuation을 줄이기 위해 ByteNet, ConvS2S는 Convolution Neural Network를 기본으로 이용하여 모든 입력과 출력 위치에 대해 hidden representation을 병렬화 (RNN을 CNN으로 표현한 연구)

CNN의 경우 n개의 단어를 문맥으로 파악하려면 드는 시간은 O(n/k)이다. RNN의 경우를 생각해보면 linear하기 때문에 시간은 O(n)

이런 모델들은 Input, Output 위치의 신호를 연관시키는데 필요한 작업수가 많이 늘어나 서로간의 Dependencies를 학습하는게 어려움

Transformer는 이러한 작업의 수를 Constant로 줄여주는 Multi Head Attention을 이용

 

Self-Attention은 Sequence의 Representation을 계산하기 위해서 Single Sequence내에서 다른 위치와 연관된 Attention

Self-Attention은 다양한 Task에서 성공적으로 이용

 

End-To-End Memory network는 Sequence-Aligned Recurrence 대신에 Recurrent Attenton Mechanism을 기반으로 하고, QA 및 모델링에서 우수한 성능을 발휘 (Recurrent방식이 Sequence방식보다 좋은성능을 보임)

 

Transformer는 Self-attention에만 의존한 최초의 Transduction Model

3. Model Architecture

가장 Competitive Neural Sequence Transduction Model은 Encoder-Decoder 형태

Encoder의 경우 Input으로 (x1, ..., xn)을 받아 representations z = (z1, ..., zn), 정보가 담겨있는 z를 생성

Decoder의 경우 z를 입력 받아  (y1, ..., ym)를 생성

각 Step마다 Model을 Auto-regressive하고 동작한다. 즉 Decoder의 출력이 다시 입력으로 들어감

 

Transformer는 figure1의 왼쪽 및 오른쪽 절반은 각각 Encoder와 Decoder가 쌓여있는 모양

self-attention과 point-wise fully connected layer를 이용하여 전체적인 아키텍처가 완성

3.1 Encoder and Decoder Stacks

Encoder

Encoder는 6개의 같은 Layer가 쌓여있는 모양

각 Layer는 2개의 Sub-Layer를 가짐(Multi-Head Self-Attention, Position-wise fc layer)

각각의 Sub-layer에 Residual-Connection을 추가

그 뒤에 Layer Normalization을 진행 그러므로 각각의 Sub-Layer는 LayerNorm(x + Sublayer(x))

Residual-Connection으로 인해 Input Output의 차원은 dmodel=512로 유지

Decoder

Decoder또한 6개의 같은 Layer가 쌓여있는 모양

각 Layer는 Encoder Layer와 유사하나 Masked-Multi Head Attention이 추가됨

Residual Connection을 추가하고, Layer Normalization을 진행

Masked-Multi Head Attention을 통해 i위치에 대한 Prediction이 i보다 앞에있는, 즉 이전의 출력에 대해 Attention을 구할 수 있음

3.2 Attention

Attention 함수는 Query, key, value, output들이 모두 Vector일 때 ,Query와 key-Value 쌍의 집합을 매핑하는 것으로 설명이 가능
Output은 Value Weight Sum로 게산되며, 여기서 각 Value 값에 할당된 Weight들은 key와 Query의 Compatibility function 에 의해 계산

3.2.1 Scaled Dot-Product Attention

'Scaled Dot-Product Attention'은 위와 같다

input으로 들어오는 Query와 Key의 dimension은 dk이고, Value의 Dimension은 dv

Attention이 궁금한 단어의 Query와 모든 단어의 Key와 Dot-Product를 취하고 루트dk로 나눠준 뒤에 Softmax를 통해 Value에 곱해지는 Weight를 생성, 그 뒤에 Weighted Sum으로 해당 단어와 모든 단어의 Attention을 생성

 

계산법에는 Additive Attention과 Dot-Product Attention이 존재

Additive Attention의 경우 Single Layer를 통해 Feed Forward로 compatibility function을 계산,

Dot-Product는 dk를 나눠주는것을 제외하면 동일

일반적으로 dk가 작으면 비슷한 성능을 보여주지만, dk가 커질 경우에 softmax에 의해 gradient가 작아지는 문제가 존재하므로 Additive가 좋지만, 해당 논문에서는 dk를 이용해 Scaling ( 기본적으로 Dot-Product는 연산이 매우 가벼움)

3.2.2 Multi-Head Attention

d-model dimension인 Query, Key, Value로 single attention을 취하는 것보다 h개의 다른 Linear Projection을 취하는 것이 효과적
Multi Head를 통해 모델은 서로 다른 위치에서 서로 다른 Subspace의 Attention을 취함

만약 h = 8 인 경우 dk = dv = dmodel / h = 64로 하여 Single Head Attention과 동일한 연산량을 유지

3.2.3 Applications of Attention in our Model

Transformer는 3가지의 다른 방식으로 Multi-Head Attention을 사용

 

'Encoder - Decoder Attention' 에서 Query는 이전 Decoder Layer의 출력, Key와 Value는  Encoder의 Output
이를 통해서 Decoder는 Input Sequence의 모든 Position에 대해 Attend가능

Sequence To Sequence Model에서 일반적인 Encoder-Decoder Attention을 모방

 

Encoder에는 Self-Attention Layer가 포함됨

Self-Attention Layer의 Query, Key, Value는 같은 장소에서 옴

이 경우 Encoder의 이전 Layer의 Output

Encoder의 각 Position은 Encoder의 이전 Layer의 모든 Position에 관여 가능

 

비슷하게 Decoder또한 Self-Attention Layer를 가짐

Decoder의 Self-Attention 또한 Decoder의 모든 Position에 Attention이 가능

이때 Auto-Regressive한 특성으로 인해 Decoder는 아직 예측하지 못한부분을 Attention하지 못하기 때문에 Masked Self-Attention 진행

3.3 Position-wise Feed-Forward Networks

Attention Sub-Layer이외에도 Encoder와 Decoder의 각 Layer는 Fully Connected Feed Forward Network가 포함

이 Network는 Activation Function으로 ReLU를 이용하며 W1, W2를 이용해 Linear Transformation을 진행

Input 및 Output Dimension은 dmodel = 512 이고, 내부 Dimension은 dff = 2048

3.4 Embeddings and Softmax

Embedding 같은 경우 다른 Sequence Transduction Model과 비슷하게진행

Input Token과 Output Token을 차원을 dmodel로 변환하기 위해 Training된 Embedding을 이용

그리고 일반적으로 Training된 Linear -Transfomation과 Softmax를 이용하여 구한 Decoder의 출력을 Token 확률로 변환

3.5 Positional Encoding

Transformer는 Recurrence와 Convolution도 이용하지 않음, Model이 Sequence를 사용하기 이해 Token의 상대적 또는 절대적 위치에 대한 정보가 필요

이를 위해 Encoder-Decoder Stack 하단 Input Embedding에 Positional Encoding을 추가

Positional Encoding과 Embedding은 같은 차원인 dmodel을 가짐(합치기 가능)

해당 작업에 서로 다른 freq를 가지 sin과 cos을 이용

 

Pos : Position

i: Token Vector의 차원

Transformer는 Sine을 이용하는데, Model이 더 긴 Sequence 길이를 추론 가능

4. Why Self-Attention

n is the sequence length, d is the representation dimension, k is the kernel size of convolutions and r the size of the neighborhood in restricted self-attention.

해당 Section 에서는 Self-Attention과 Convolution, Recurrent Layer와 비교

3가지를 고려하는데 Computational Complexity Per Layer, Computational Can Parallelized, Long-Range Dependencies 길이

 

3번째 같은 경우에는 Long-Range Dependencies 사이의 Path 길이
Long-Range Dependency 속성을 하는 것은 Sequence Transduction Task의 핵심

이런 Dependencies를 학습하는 능력에 가장 큰 영향을 미치는 것은 forward, backward path의 길이

input 및 output Sequence의 위치가 서로 가까울수록 Dependencies를 학습하기 쉬움

그러므로 Input과 Output Position을 비교

 

Table1을 보면 Self-Attention Layer는 모든 Position을 Constant Number로 연결함

하지만 Recurrent Layer 같은 경우 O(n)이 소요

Computational Complexity 관점에서 n이 d보다 작을 경우에  Self Attention 은 Recurrent보다 낮음, 일반적으로 n<d해당

만약 매우 긴 Sequence를 가진 작업에 대해서 성능을 향상시키기 위해 각 input Sequece의 neighborhood size를 r로 제한

이는 maximum path의 길이를 O(n/r)로 증가시킴, 저자들의 Future Work

 

k < n인 Single Conv Layer는 input과 output의 모든 Pair를 연결 x

Contiguous Kernel의 경우 O(n/k)의 Convolution Stack이 필요

Dilated Convolution의 경우 O(logk(n))이 필요, 계산랑 증가

Convolution Layer는 일반적으로 Recurrent Layer보다 k배 비쌈

근데 Seperable Convolution을 이용하면  

추가적으로 문장의 구조적, 의미적 구조를 잘 연관시킨다

또한 Model이 해석이 가능하고, Attention Map을 시각화하여 왜 이런 결과가 나오는지 해석 가능

+ Recent posts