전체적으로 짧게 요약하자면, few-shot으로부터 학습하기 위해 meta적인 파라미터를 학습시켜놓는 것이며, 이를 알고리즘으로 표현한 것이다.
본 논문의 Fig.1
즉 위 그림처럼 Distribution of Task T에 대하여 메타적인 파라미터 세타가 있으면, 특정 Task Ti에 대해서 몇 개의 데이터(supervised) 혹은 탐험(강화학습)으로부터 얻어낸 로스를 활용하여 Task Ti에 맞는 파라미터 세타i가 될 수 있게끔 하는 것이다.
이를 대략적인 알고리즘으로 나타내면 아래와 같다.
본 논문의 Alg.1
대략적으로 단계를 표현하면,
1) 특정 Task에 맞게끔 로스를 이용하여 세타i 를 구해낸다.
2) 세타i가 정말 특정 Task에 맞는지 로스를 구해 세타를 수정한다.
이를 supervised나 강화학습에 구체화시키면 아래와 같다.
본 논문의 Alg.2본 논문의 Alg.3
이 논문에서 실험한 내용 중 인상깊은 내용은 Supervised 관련 부분이다.
간단한 Regression 메타 러닝에 대한 실험이었다.
sinusoid 모양의 함수를 모델이 파악할 수 있으면 된다.
비교 대상은 1) MAML로 학습한 모델 2) 하나의 sinusoid에 대해 pretrain된 모델 이다.
두 모델이 얼만큼 빨리 특정 모델로 변할 수 있는가를 테스트한다.
본 논문의 Fig.2
MAML 모델의 pre-update 모양은 정확한 sinusoid 모양은 아니지만, 특정 모양으로 굉장히 빠르게 변하는 것을 확인할 수 있다.
이는 meta적으로 sinusoid 모양을 학습한 것이라고 볼 수 있다.
반면 pretrain 모델은 GT 모양에 맞게끔 fine-tuning 되는 것이 쉽지 않아보인다.
결론적으로 든 생각은 MAML 알고리즘을 활용하여 다양한 부분의 메타 러닝에 접목할 수 있겠다는 것이다.
Model-Agnostic Meta-Learning, 본 논문은 위 모델을 기반으로 하여 사용했다고 합니다.
MAML을 간단히 설명드리면 하나의 뉴럴 네트워크가 있고, 가중치가 있습니다.
이 가중치를 특정 task에 쓸 수 있게끔 조금씩 바꿔서 다양한 도메인에 적용할 수 있게끔 하는 개념입니다.
대략적인 이해를 도울 수 있는 그림, MAML 논문의 Fig.1
그림은 대략적인 흐름을 보여주는 것으로 각각의 task 1, 2, 3에 대해 코어 가중치인 세타가 각각의 로스로 인해 세타* 1, 2, 3으로 변하는 것을 볼 수 있습니다.
MAML 논문의 Alg.1
알고리즘으로 표현을 해보자면, 각각의 task에 대해 로스를 이용하여 특화된 세타를 만들어내고 이렇게 만들어낸 세타에 대해 로스를 계산하여 코어 가중치를 다시 한번 수정합니다(meta update). 대략적인 개념이 이해되면 어떤 식으로 이 논문이 MAML을 적용하였는지 파악해보겠습니다.
MAML을 접목한 imitation learning, 본 논문의 Alg.1
imitation learning, 즉 데모를 보고 따라하게끔 코어 가중치를 수정해야 합니다.
1) 가중치를 얼마나 수정할지에 대해 로스 함수를 통해 구하고, 이를 이용하여 가중치를 수정합니다.
2) 수정된 가중치에 대해 로스를 구하고, 이를 이용하여 코어 가중치를 수정합니다.(meta-update)
이를 살펴보면 코어 가중치가 각 task들에 대한 가중치에 대하여 접근할 수 있는 pretrain 가중치라고 볼 수 있을 것 같습니다.
그렇다면, 로스는 어떤 식으로 설정하였는지 알아보겠습니다.
* Pretrain이 되어있으면 학습이 좀 더 빠르듯이, MAML 개념은 모든 task에 접근할 수 있는 pretrain 가중치를 미리 설정해두는 느낌입니다.
4. Meta-Imitation Learning with MAML
코어 가중치의 목표, 본 논문의 수식.1
코어 가중치가 향하는 방향은 각각 만들어낸 가중치들에 대한 로스를 더했을때 최소가 되게끔 하는 것입니다.
로스 함수, 본 논문의 수식.2
로스 함수는 Observation o가 나올 때 예측한 Action a와 ground-truth를 비교한 mean squared error를 사용합니다.
여기서의 a는 로봇 환경이므로 각 joint에 가하는 힘이라고 생각하시면 됩니다.
학습을 위해서는 각 task별로 두 개의 demo를 이용합니다.
첫 번째 데모를 이용하여 특정 가중치로 코어 가중치를 업데이트합니다.
두 번째 데모를 이용하여 특정 가중치와의 로스를 계산하고, 이를 이용하여 코어 가중치를 업데이트합니다.
테스트 단계에서는 각 task별로 하나의 demo가 존재하며 이를 이용해 특정 가중치로 업데이트하고, 테스트합니다.
<Two-Head Architecture : Meta-Learning a Loss for Fast Adaptation>
코어 가중치로부터 나오는 폴리시를 최종적인 출력 레이어 직전에서 두 개로 구분합니다.
pre-updated, post-updated : 이를 Two-Head라고 이 논문에서는 말하고 있습니다.
pre-updated는 최종적인 가중치에 영향을 끼치지 않습니다.
post-updated는 데모를 이용하여 업데이트되지 않습니다.
알고리즘에서도 살펴보았듯이 코어 가중치를 이용해서 특정 가중치를 만들고, 특정 가중치를 이용해서 코어 가중치를 수정하는 2단계로 이루어져 있습니다.
이렇게 구분하는 이유는 각 단계별 로스를 조금 더 명확히 구분함으로써 학습에 도움을 주기 위함으로 보입니다.
이 개념으로 접근하여 로스 함수를 다시 정의할 수 있습니다.
본 논문의 수식.3
y는 가장 마지막의 hidden layer의 출력이며, W는 output layer의 가중치, b는 bias입니다.
사실 로스함수까지만 보면 이전의 로스 함수를 풀어썼다고 볼 수 있습니다.
이를 통해 모델의 목적 함수도 새로이 정의될 수 있습니다.
본 논문의 수식.4
눈여겨 볼 점은 목적 함수가 코어 가중치 세타만을 찾는 것이 아니라 로스를 줄여줄 최종 레이어의 적절한 W, b 값 또한 찾습니다.
<Learning to Imitate without Expert Actions>
위의 로스함수를 보시면 데모는 지금까지 액션과 스테이트의 페어가 저장되어 있는 것으로 했었습니다.
하지만 visual demo를 통해 task를 배우기 위해서는 위 사항들이 없다고 봐야합니다.
학습 과정에서는 액션이 있다고 해서 그대로 사용할 수 있습니다.
그렇다면 test 시에 1단계, 특정 가중치를 로스를 이용해 찾을 때 어떻게 로스를 계산할 수 있을까요?
본 논문의 수식.
본 논문에서는 위 식, 단순히 기존 로스 함수에서 액션 a를 식에서 제거한 식을 사용합니다.
이렇게 할 수 있는 이유는 위에서 W, b가 포함된 마지막 레이어가 로스 함수를 meta-learn하기 때문이라고 합니다.
* pre-updated post-updated 의미를 정확히 파악하지 못했습니다.
5. Model Architectures for Meta-Imitation Learning
Two-Head Architecture에 대한 그림, 본 논문의 Fig.2
policy network로 CNN 구조를 사용했습니다.
모델에게 들어오는 입력은 카메라로부터의 영상과 로봇의 현재 configuration입니다.
아래는 대략적인 순서도입니다.
1) 영상으로부터 feature를 추출합니다.
2) image feature와 robot configuration을 concat합니다.
3) FC layer를 통해 결과(액션)를 출력합니다.
이 모델은 추가적으로 bias transformation이라는 입력과 상관없는 상수 벡터를 사용합니다.
이는 간단히 소개하면, bias 역할을 해 줄 벡터를 입력에 concat하는 것입니다.
이를 통해서 좀 더 gradient의 표현력을 높일 수 있다고 합니다. (제 생각에는 Z로 인해 파라미터의 갯수가 늘어난 것 때문으로 보입니다.)
* 편향을 적극적으로 활용할 수 있다는 점은 좋은 아이디어인 거 같습니다.
6. Experiments
위 논문은 세 가지 환경에서 실험을 진행합니다.
각각의 환경에서 비교 대상이 될 모델은 아래와 같습니다.
1) random policy : 정규 분포에 따른 랜덤한 액션을 사용합니다.
2) contextual policy : feedforward policy로 task의 골을 가리키기 위한 데모의 최종 이미지와 현재의 이미지를 입력으로 주어 액션을 출력합니다.
3) LSTM : RNN으로, 데모와 현재의 observation을 주면 액션을 출력합니다.
4) LSTM+attention : attention 구조가 추가되었습니다.
<Simulated Reaching>
시뮬레이터 환경에서 3가지 색깔 중 특정 색깔에 닿아야 하는 task입니다.
<Simulated Pushing>
시뮬레이터 환경에서 특정 물체를 타겟 위치에 놓아야 하는 task입니다.
본 논문의 Fig.4
MIL은 본 논문에서 제안한 Meta Imitation Learning을 의미합니다.
전체적인 성공률이 MIL이 높은 것을 확인할 수 있습니다.
본 논문의 Table.1
데모가 어떠한 정보를 포함하는가에 따른 성능 비교 실험입니다.
LSTM은 순차적인 모델이기에 순차적인 액션 나열이 주어질 때는 나름 강력한 능력을 보여주지만, 액션이 데모 정보에서 빠져버리면 contextual보다도 낮은 성능을 보이는 점이 인상깊습니다.
이 실험 또한 MIL의 학습 능력을 보여줍니다.
<Real-World Placing>
현 세계에서의 작업입니다.
특정한 물체를 특정한 받침대 위에 놓아야 합니다.
로봇이 테스트 시에 학습 시 나오지 않았던 unseen object에 대해서도 잘 작업을 수행할 수 있는지도 테스트할 수 있습니다.
본 논문의 Table.2
LSTM과 contextual 모델은 unseen 물체에 대해 굉장히 약한 모습을 보여주는 것에 반해 MIL은 90%라는 놀라운 성공률을 보여줍니다.
이는 어쩌면 1300개의 데모 훈련 데이터가 부족하여 그런 것일수도 있습니다.
이는 one-shot demo learning을 하기 위해 MIL이 필요한 데이터도 더 적다는 점을 보여줍니다.
* 실험 자체는 딱히 평범해보입니다. MIL의 성능이 굉장히 좋은 것 같습니다. 원리를 좀 더 이해하면 좋았을 거 같은데 아쉽네요.. 특히 Visual demo가 어떤식으로 반영이 되는건지에 대한 설명이 없는 것 같아 의문이네요..
Program Synthesis는 specification에 맞는 프로그램을 자동적으로 생성하는 작업입니다.
보통 이를 위해 LSTM을 이용하여 프로그램 토큰들을 순차적으로 출력하게끔 학습시키는 Seq2Seq 모델을 많이 사용하며, 학습을 위해서는 Maximum Likelihood Estimation(MLE)을 사용합니다.
하지만 이런 방법에는 두 가지 한계점이 있습니다.
1) Program Aliasing - 이루어진 토큰은 다르지만, 같은 내용을 의미하는 프로그램이 큰 로스로 다가올 수 있습니다.
같은 일을 하는 프로그램이지만 코드 구성은 다릅니다. 본 논문의 Fig.1
MLE를 사용한 supervised 학습은 이런 의미적인 부분을 무시하게 됩니다.
2) Strict Program Syntax - 프로그램 토큰을 차례로 나열하는 Seq2Seq 모델은 프로그램의 문법적인 부분에 대해 캐치하지 못한 채로 잘못된 문법의 프로그램을 만들어낼 수 있습니다.
문법이 맞지 않는 프로그램은 실행시킬 수도 없고, 의미가 없기 때문에 이 점을 모델에게 어떤 식으로라도 도와줄 수 있다면 좋을 것입니다.
이 논문에서는 이 문제들에 대한 해결을 위해
1) 순수한 Supervised Learning이 아닌 강화 학습을 추가로 적용하여 학습시킵니다.
강화 학습의 리워드는 의미적으로 맞는 프로그램을 생성하였는가가 됩니다.
2) 모델에 Syntax Check를 도와주는 추가적인 작업을 적용시킵니다.
LSTM의 Output으로 나오는 다음으로 나올 토큰들의 확률들에 대하여 Syntax가 맞지 않는 토큰의 확률은 없애서 올바른 문법의 프로그램을 출력할 수 있게 도와줍니다.
Introduction
Program Synthesis는 Input-Output 예시라던지 하는 어떠한 specification에 대하여 그에 맞는 프로그램을 자동적으로 생성해내는 작업입니다.
이와 비슷한 작업인 Neural Program Induction 분야는 최근 굉장한 발전이 있었지만, 이는 명시적으로 해석이 가능한 프로그램을 생성하지 않습니다. (프로그램의 형식으로 작업을 하긴 하는데, 프로그램을 처음부터 끝까지 쫙 만드는 게 아니라 그때그때 환경에 필요한 프로그램을 호출하는 형식입니다. NPI가 이 분야에 속합니다.)
그 외에도 각각의 프로그램을 배우기 위해 많은 예시가 필요한다던지 하는 문제들이 있습니다.
이런 문제들에 대해 해결하기 위해 나온 방식이 Neural Program Synthesis입니다.
이는 5개 정도 되는 몇 개 안되는 예시(few examples)에 대해서도 Domain-Specific Language(DSL)를 통해 프로그램으로 표현을 해내는 것이 가능합니다.
하지만 이 모델도 두 가지의 한계점들이 있었습니다.
1) Program Aliasing
몇 개 안되는 예시로부터 프로그램을 만들기에 만들 수 있는 프로그램의 수는 굉장히 많습니다. 하지만 supervised 학습은 ground-truth 프로그램을 출력하게끔 하기 때문에 다른 가능한 프로그램들에 대해서는 높은 loss를 내게 됩니다.
가능한 어떤 프로그램이라도 만들 수 있게끔 하는 본래의 Program Synthesis 목적에 맞게끔 이 문제를 해결하기 위해 MLE를 대신하여 강화 학습을 접목할 것입니다.
2) Strict Program Syntax
프로그램은 엄격한 문법 구조를 지켜야 합니다. 하지만 단순한 seq2seq 모델로는 이 문법 구조를 알게 하기가 쉽지 않습니다.
이를 위해 본 모델을 도와줄 syntax checker를 추가적으로 사용하고, 이를 통해 pruning이 가능하게 합니다.
위 방법들에 대한 효과를 검증하기 위해 Karel 환경에서 실험을 진행합니다.
Karel은 교육용 프로그래밍 언어로써 if 구절 같은 control flow를 포함하고 있고, 이는 program synthesis 작업을 좀 더 어렵게 합니다.
이 논문이 기여하는 바를 다시 한번 정리하면,
1) 순수한 supervised 학습에 비해 일반화된 프로그램 생성에서 좋은 성능을 보이는 강화 학습 방법을 제시합니다.
2) syntax checker를 통한 탐색 공간의 축소화 방법을 제시합니다.
3) syntax checker가 없을 수 있기 때문에, 이를 위해 프로그램 생성과 더불어 자체적으로 syntax를 학습하는 모델 또한 소개합니다.
Problem Overview
<Program Synthesis Formulation>
본 논문의 exp.1
데이터셋은 위 수식으로 표현이 가능합니다. IO는 input/output 쌍을 나타냅니다. input과 output은 상태로 표현할 수 있습니다.
Karel example, 구글 검색
예를 들어 Karel에서는 각각의 격자 칸의 상태를 상태로 표현이 가능합니다.
람다는 프로그램을 나타냅니다.
즉, 프로그램 i에 대해서 k개의 Input/output 쌍이 존재한다고 설명이 가능합니다.
본 논문의 exp.2
위 논문에서 Program Synthesis 모델이 세타입니다.
k개의 IO가 주어질 때 그에 맞는 프로그램을 생성해내는 일을 하게 됩니다.
본 논문의 exp.3
테스트 셋은 spec과 test로 나누어지는데, spec은 모델의 입력으로 주어지는 IO이며, test는 모델이 출력한 프로그램을 실행하여 맞게 만들어졌는지 테스트하기 위한 IO입니다.
본 논문의 exp.4
즉 이 모델의 목표는 위 식으로 표현이 가능합니다.
테스트 데이터셋에 대하여 모델이 만들어낸 프로그램에게 input 상태에서 시작할 때 최종적으로 정답 output 상태가 나오게끔 만들면 됩니다.
<Neural Program Synthesis Architecture>
가장 기본적인 LSTM 기반의 seq2seq 모델로,
Input : Embedding(IO) + Embedding(이전의 토큰)
Output : 다음으로 나오게 될 토큰들의 확률 (출력값이 추가적으로 softmax layer를 거칩니다)
표현이 가능합니다. Karel의 상태에 대한 임베딩은 CNN을 활용하였습니다.
모델을 식으로 표현하면 아래와 같습니다.
본 논문의 exp.5
s는 토큰을 의미하고 L은 토큰의 길이를 의미합니다.
K개의 IO가 주어질 때 올바른 프로그램 세타를 예측하게 될 확률을 높이는 과정은 위 수식의 오른쪽으로 표현이 가능합니다.
테스트시에는 Beam Search를 활용하여 프로그램을 얻습니다.
program synthesis의 장점으로는 실행할 수 있는 프로그램을 만들어낸다는 점입니다.
실행을 통해 문법적으로 오류가 있거나 예시와 일치하지 않는 프로그램을 제거하며, 남아있는 프로그램들 중 가장 높은 확률의 프로그램을 모델에게 전달합니다.
모델 아키텍쳐, 본 논문의 Fig.2
Syntax checker까지 존재하는 모델의 전체적인 구조와 흐름을 설명드리겠습니다.
Input>
IO는 concat, CNN과 FC 레이어를 통해 임베딩 됩니다.
위 임베딩 벡터에 이전에 나온 토큰의 임베딩 값이 concat 되어 LSTM의 입력값으로 들어가게 됩니다.
IO는 변함이 없지만, 토큰 임베딩 값은 상황마다 변하게 됩니다.
각 프로그램마다 K개의 IO쌍이 있습니다.
각각의 IO쌍에 대해 각각의 LSTM을 입력으로 주게 됩니다.
Output>
K개의 LSTM으로부터 나온 값에 MaxPooling을 적용합니다.
이와 별개로 이전의 토큰을 Syntax checker에게 넣어 mask 벡터를 구합니다.
위 두 개의 벡터를 곱하고, 이에 softmax를 적용하여 최종적으로 다음에 나오게 될 토큰을 구하게 됩니다.
Objective Function
<Maximum Likelihood Optimization>
모델의 가중치(파라미터) 세타에 대해 supervised 학습을 적용한 기본적인 방법은 MLE입니다.
본 논문의 exp.6
MLE를 적용한 목적함수가 위 식이라고 할 수 있습니다.
하지만 위에서도 말했듯이, 위 식만을 이용하면 여러 문제가 생깁니다.
학습 과정에서 모델은 오로지 훈련 데이터에 대해서만 노출되지만, 테스트 과정에서는 자신이 출력한 토큰이 입력으로 들어오게 됩니다.
Natural Language Processing에서 이런 문제는 Exposure Bias라고 합니다.
게다가 이 loss는 program synthesis의 진정한 목적이라고 할 수 없습니다.
MLE 학습 과정에서는 Program Aliasing 문제가 발생할 수 있기 때문입니다.
이 문제를 해결하기 위해 ground-truth 프로그램과 일치하지는 않더라도 맞는 프로그램에 대해서 loss 함수가 페널티를 주는 것을 막을 것입니다.
<Optimizing Expected Correctness>
Program Synthesis의 진정한 목적에 맞게 하기 위한 목적 함수의 첫 번째 수정은 아래와 같습니다.
본 논문의 exp.7
R은 리워드 함수를 의미합니다.
리워드 함수는 여러 가지로 설정할 수 있습니다.
감마가 시그마 아래에 있는 건 만들어질 수 있는 프로그램이 강화 학습에서는 정말 다양하게 나올 수 있기 때문에 저렇게 표현한 것으로 보입니다.
하지만 위 식의 문제점은 너무 다양한 프로그램이 나올 수 있기 때문에 어떻게 기준을 잡아 계산하기 어렵다는 점입니다.
이 점을 해결하기 위해 몬테 카를로 방식을 사용하여 몇 개에 샘플에 대한 식으로 바꿀 수 있습니다.
본 논문의 exp.8
여기서 S는 샘플의 개수입니다.
하지만 위 방식 또한 문제점을 찾을 수 있는데, 기울기를 추정하며 샘플을 뽑아낼 때 반복적으로 같은 프로그램을 만들어낼 확률이 높다는 점입니다.
이는 특히나 supervised 학습을 통해 pre-train 된 경우 도드라집니다.
이를 위해 살짝 다른 변경을 통해 학습을 도와줄 수 있습니다.
Beam Search 적용 예시, 본 논문의 Fig.3
이 변화는 S 개의 샘플을 만들어낼 때 Beam Search에서 S개의 가장 높은 확률의 샘플을 뽑아내는 것입니다.
위 그림에서 S는 3이며, 각각의 타임 스텝마다 3개의 후보에 대해 Beam Search를 진행합니다.
BS(p세타, S)는 파라미터가 세타일 때 Beam Search를 통해 S개의 샘플을 뽑아낸 최종적인 결과를 의미하며, 초록색은 End Token을 의미합니다.
이렇게 나오게 된 S개의 프로그램은 확률 p를 가지고 있는데, 이 p를 softmax 비슷하게 적용하여 확률 q로 리스케일링 해줍니다.
이를 통해 중복적인 프로그램이 나오는 경우를 방지할 수 있습니다.
위 과정을 Exp.7과 비슷하게 표현이 가능합니다.
본 논문의 exp.9
전체 수식은 p가 q로 변경된 점뿐입니다.
하지만 Beam Search를 이용한 샘플링을 한다는 점이 추가되었습니다.
참고로 주의할 점은 S가 과도하게 커지게 되어 모든 생성될 만한 프로그램을 커버할 수 있게 되면 7번 수식과 다를 게 없다는 점입니다.
여기서 조금 더 다루기 쉽게 하기 위해 더 복잡한 목적 함수를 정의할 수 있습니다.
Program Synthesis에서 입력으로 들어온 Specification을 통해 몇몇 예측값들을 pruning 할 수 있습니다.
그러므로, 하나의 프로그램을 샘플링할 때 기대되는 reward 값을 최적화하는 것 이상으로 프로그램들의 묶음 C를 샘플링하고 최상의 프로그램을 유지할 때 기대되는 reward 값을 최적화하는 것을 선택할 수 있습니다.
본 논문의 exp.10
Reward 함수는 프로그램이 올바르냐에 따라 0, 1의 값을 줄 수 있고, 이를 이용해 식을 좀 더 쉽게 표현하면 아래와 같습니다.
본 논문의 exp.11
* 10번과 11번 수식은 자세히 이해되진 않습니다. 설명해주신다면 감사하겠습니다..
Model
<Conditioning On the Syntax>
Program Synthesis 작업은 문법적으로 맞지 않는 프로그램을 만들어낼 수 있다는 측면이 있는데, 예측하기 전에 선별해 줄 수 있습니다.
본 논문의 exp.12
stx는 문법적으로 맞는 프로그램이라는 걸 의미합니다.
이를 신경 써서 모델링한다는 점은 위 식처럼 표현할 수 있습니다.
이를 조금만 더 분해해서 생각하여, t번째 토큰을 예측하는 걸 식으로 표현하면 아래와 같습니다.
본 논문의 exp.13
실제 모델 구현에서는 일종의 Mask를 모델이 softmax를 통해 최종 아웃풋을 출력하기 전에 더해주게끔 하였습니다.
각각의 타임 스텝마다 토큰 벡터에 대해 Mask M= {-INF, 0}으로 표현할 수 있습니다.
-INF는 현재 문맥에서 문법적으로 불가능한 토큰에 부여됩니다.
이를 통해 문법적으로 정확한 프로그램만을 찾게 되므로, Beam Search에서 탐색 범위를 줄여 효율적인 탐색이 가능합니다.
이는 문제를 좀 더 단순하게 만들고 학습을 쉽게 만듭니다.
<Jointly Learned Syntax>
하지만 항상 Syntax Checker가 존재한다고 가정할 수는 없습니다.
또한 모델이 그저 학습만으로도 Syntax를 파악하게 된다면 일반적으로 쓰기 더 좋을 것입니다.
이를 위해 이 논문에서는 Syntax Checker를 뉴럴 네트워크 모듈(syntaxLSTM)로 만들고, 함께 학습을 시킵니다.
몇 가지 특징은 아래와 같습니다.
1) syntaxLSTM은 IO 쌍과 상관없이 오로지 프로그램 토큰들이 중요하기 때문에 IO는 입력으로 받지 않습니다.
이를 통해 문법의 학습에 집중할 수 있게 합니다.
2) syntaxLSTM으로부터 나오게 된 출력 값은 x -> -exp(x) 활성화 함수를 통과하여 decoder LSTM의 출력 값에 더해지게 됩니다.
위에서 설명한 Mask처럼 -exp 함수 또한 문법적으로 맞지 않는 토큰에 대해 페널티를 부과합니다.
syntaxLSTM의 추가는 모델 구조의 간단한 변경이기 때문에 학습의 절차를 바꿀 필요는 없습니다.
하지만, supervised 학습에서는 문법적으로 맞는 프로그램에게 갈 수 있게 해줘야 하기 때문에 MLE에 더해 추가적인 loss를 사용합니다.
본 논문의 exp.14
이 loss는 문법적으로 유효한 프로그램들을 통해 syntaxLSTM에게 올바른 문법을 학습시킬 수 있게 도와줍니다.
Experiments
<The Domain : KAREL>
KAREL은 그리드 월드에서 에이전트가 움직이거나(move, turn{Left, Right}), 환경을 바꾸면서({pick, put}Marker), 또한 환경으로부터 정보를 얻으며(markerPresent, noMarkerPresent, frontIsClear, leftIsClear, rightIsClear) 진행해나갈 수 있는 실험 환경입니다.
위 토큰들 말고도 control flow로 for, while, if를 지원합니다. 실험을 위해 서브루틴을 정의할 수 있는 기능은 사용하지 않았습니다.
DataSet>
실험을 위해 랜덤 DSL 프로그램 생성을 하였으며, 간단한 몇 가지 휴리스틱 체크를 통해 환경에 변화를 주지 않는 프로그램이나, 의미 없는 행동(turnLeft, turnRight를 이어서 하는 경우처럼)을 하는 프로그램은 사용하지 않았습니다.
각각의 프로그램에 대해 많은 IO쌍을 만들고, 적어도 프로그램에 존재하는 모든 IF를 한 번은 지나가도록 선별하여 6개의 IO 쌍을 가지게끔 하였습니다.
첫 5개의 샘플은 입력으로 주어지며, 6번째 샘플은 테스트를 위해 사용됩니다. 5000개의 프로그램을 나누어 validation set과 test set으로 사용되었습니다.
모델의 입출력>
KAREL의 상태는 각각의 그리드마다 16개로 나타내어질 수 있었습니다.
실험에서 그리드는 18 * 18 크기를 사용했고, 따라서 IO는 16 * 18 * 18의 형태를 띄었습니다.
IO는 각각 CNN에 들어가 feature를 추출한 후 Concatenation 한 뒤, 다시금 두 개의 CNN과 하나의 FC를 거쳐 512 크기의 벡터를 최종적으로 출력하게끔 하였습니다.
모델의 출력 값은 step마다 K개의 Decoder의 출력 값을 Maxpooling을 한 값을 이용하여 최종 출력에 사용하였습니다.
<Results>
Full Dataset : 100만 개의 프로그램 데이터셋입니다.
Small Dataset : 1만 개의 프로그램 데이터셋입니다.
데이터셋을 나눠서 실험하는 이유는 실 세계의 program synthesis domain에서는 수많은 데이터를 모으기 어렵기 때문입니다.
본 논문의 Table.1
첫 번째 실험은 학습 방법을 통한 결과 비교 실험입니다.
모델>
MLE : 수식 6을 이용하는 방법이며, 평범한 supervised 학습 방식 모델입니다.
아래의 RL은 모두 reward로 프로그램이 모든 샘플과 일치하면 1, 아니면 0을 사용합니다.
RL : 수식 7과 8을 loss로 이용하는 방법입니다. (샘플링 적용한 강화 학습)
RL_beam : 수식 9를 loss로 이용하는 방법입니다. (샘플링에서 같은 샘플 뽑히는 문제 해결한 방법)
RL_beam_div : 수식 10을 loss로 이용합니다. (output이 좀 더 다양하게 나올 수 있도록 개량한 방법)
RL_beam_div_opt : 수식 10을 loss로 이용하지만, time step에 따라 추가적으로 reward에 페널티를 주는 방법을 사용하였습니다.
RL 관련 모델은 supervised 학습을 통해 먼저 pretrain 되었습니다.
보통의 Neural Machine Traslation 방법에서 보편적으로 사용되는 방식이기도 하고, 아무래도 순수 RL만으로 하기에는 성능이 좋지 못했다고 합니다.
이는 DSL을 통한 탐색 공간이 너무 넓어서 그런 것으로 생각됩니다.
평가지표>
Generalization : 만들어진 프로그램이 모든 IO에 대하여 정확하게 매치되는지 확인합니다.
Exact Match : 만들어진 프로그램이 ground-truth 프로그램과 정확하게 매치되는지 확인합니다.
분석>
Full dataset : RL을 이용하였을 때, Exact Match는 줄어들지만, Generalization은 좋아지고 있습니다.
이를 통해 RL을 이용하면 supervised의 한계였던 기존의 ground-truth 프로그램과 정확하게 일치하는 프로그램을 생성하던 비율이 줄어든다는 의미로 볼 수 있습니다.
즉, Program Aliasing 문제를 해결한다고 볼 수 있습니다. 이는 특히 RL_beam에서 두드러집니다.
Small dataset : MLE로만 학습을 진행시켰을 때보다 강화 학습을 추후에 추가로 진행하였을 때 성능이 두 가지 지표에서 모두 올라가는 것을 확인할 수 있습니다.
이를 통해 데이터가 적을 때 강화학습을 이용하여 데이터의 효율성을 높일 수 있다는 점을 확인할 수 있습니다.
본 논문의 Table.2
두 번째 실험은 Full dataset에서 각각의 모델로부터 생성된 Top-k개의 프로그램에 대한 Generalization 비교 실험입니다.
분석 >
위 실험을 통해 알아낼 수 있는 점은 같은 일을 하더라도 다른 코드로 표현할 수 있는 능력을 본다고 생각합니다.
특히 이런 능력은 Program Synthesis에서 중요한 부분이라고 생각합니다.
Top-1과 Top-5에서 RL_beam_div_opt 모델의 성능이 가장 좋은 점을 확인할 수 있는데, 이는 Beam Search의 다양성을 높이면서, time step에 따른 reward의 조정으로 의미 없는 액션의 반복을 피했기 때문이라고 생각합니다.
개인적으로 의미 없는 액션의 반복을 계속하다, 이상한 길로 빠질 수도 있다고 생각합니다.
Top-50에 대해서는 MLE가 성능이 가장 좋은 점을 확인할 수 있는데, 이 부분에 대해서는 강화 학습은 MLE에 비해 넓은 범위를 탐색하기 때문에 최적의 프로그램은 더 잘 만들 수 있지만, 그런 만큼 넓은 범위에 대해 탐색하기 때문에 50개를 뽑을 때는 전체 성능은 낮을 수밖에 없다고 생각합니다.
본 논문의 Table.3
세 번째 실험은 Syntax Checker 방식에 따른 성능의 차이 유무입니다.
모델>
MLE_learned : syntaxLSTM을 학습시키는 모델입니다.
MLE_handwritten : syntax 규칙을 알고 있는 syntax checker를 사용하는 모델입니다.
MLE_large : 추가적인 syntaxLSTM을 사용하지는 않지만 그만큼 파라미터 수를 추가해서 학습하는 모델입니다.
분석>
Full dataset : MLE가 MLE-learned보다 성능이 높은 점을 알 수 있습니다.
이는 충분한 데이터가 주어지면 모델이 따로 명시되어 있지 않아도 syntax에 대해 학습을 한다는 것으로 보입니다. 이에 대한 것은 MLE_large가 성능이 가장 좋은 점을 통해서도 알 수 있습니다.
Small dataset : 하지만 데이터셋이 충분하지 않을 때는 문법을 명시적으로 학습시키려 하는 MLE_learned 성능이 가장 좋았습니다.
특히 handwritten보다 성능이 좋은 점은 눈여겨볼 만 한데, 이 이유는 syntaxLSTM이 문법적으로 올바르지 못한 토큰을 거르는 것을 포함하여, 의미적으로 이상한 토큰마저도 거르는 걸 도와줄 수 있기 때문이라고 생각합니다.
다른 모델은 syntax를 자체적으로 학습하기에는 데이터가 충분하지 않은 점이 비교적 낮은 성능의 원인이라고 생각합니다.
본 논문의 Table.4
네 번째 실험은 MLE_learned 모델이 full dataset에 대해 학습하였을 때 Top-k개에 대하여 문법적으로 맞는 프로그램을 만들어내는가를 확인하는 실험입니다.
모델>
Joint Model : syntaxLSTM을 사용하여 프로그램을 생성하는 모델입니다.
Without Learned Syntax : syntaxLSTM으로부터 나온 mask를 사용하지 않는 모델입니다.
분석>
syntaxLSTM을 사용하지 않은 모델의 정확도가 급격하게 떨어진 점은 학습을 함에 있어서 syntaxLSTM에 의존하게 되었기 때문이라고 보입니다.
Joint Model을 보면 문법적으로는 거의 완벽한 프로그램들만을 생성하는 점을 볼 수 있습니다.
handWritten과 learned의 Mask 비교, 본 논문의 Fig.3
위 그림은 Fig1.a에 대해 handwritten model(Manual)과 learned model의 syntax mask에 대한 비교입니다.
하얀색은 문법적으로 가능한 토큰을 의미합니다.
(c)는 두 mask의 차이를 나타낸 것이며, 하얀색은 같고, 파란색은 learn이 문법적으로 틀린 토큰에 대해 가능하다고 판단한 부분이며, 빨간색은 문법적으로 가능한 토큰에 대해 불가능하다고 판단한 부분입니다.
빨간색이 세 번째 실험과 어느 정도 연관성이 있는, 가능하지만 의미적으로 이상하다고 학습된 부분으로 보입니다.
즉 syntaxLSTM이 문법 자체만 학습하는 것이 아닌 전체적인 토큰의 분포 또한 학습을 하는 것으로 이해할 수 있습니다.
Conclusion
이 논문은 현재의 최신 neural program synthesis에 있어 성능을 향상시킬 수 있는 두 가지의 새로운 기여를 하였습니다.
1) 출력되는 프로그램의 일반화를 위해 강화 학습을 사용하였습니다.
2) 추가적인 메커니즘으로 syntax check를 통해 탐색 공간을 줄였습니다. 이는 부족한 데이터셋에 대해서 눈에 띄는 성능 향상을 가져올 것입니다. (실험 3)
이미지나 자연어 처리에 있어 뉴럴 네트워크는 강력하고 유연한 모델들입니다. 그럼에도 불구하고, 여전히 뉴럴 네트워크를 디자인하기란 여전히 어렵습니다. 이 논문에서는 뉴럴 네트워크의 모델을 만들어내는 RNN을 사용할 것이며, 이 RNN을 통해 만들어진 뉴럴 네트워크가 validation set에 예상되는 accuracy를 최대화하는 방향으로 강화학습을 진행할 것입니다.
이 논문에서는 CIFAR-10 데이터에 대해 모델이 테스트를 진행하였을 때 3.65%의 에러율이 나왔는데, 이는 비슷한 구조를 사용했던 기존의 최신 모델보다 0.09퍼센트 나은 성능입니다. 거기에 1.05배 더 빠르다고 합니다.
Pen Treebank(PTB) 데이터셋에 대해서, 이 모델은 다른 기존의 베이스라인들이나 널리 사용되는 LSTM cell을 능가하는 새로운 rnn cell을 만들어냈습니다.
이 rnn cell은 PTB 테스트 셋에 대해 62.4의 perplexity를 이루어냈습니다. 이는 이전의 최신 모델들보다 3.6 perplexity 나은 성능입니다. 이 cell은 또한 PTB에 대해 character language modeling task를 전달할 수 있으며, 1.214의 perplexity를 이루어냈습니다.
Introduction
최근의 몇 년동안의 딥 뉴럴 네트워크의 발전으로 음성 인식이나 이미지 인식 등 많은 챌린지들이 성공하는 것은 기존의 feature design에서 architecuture design으로 패러다임을 변경시켰습니다. 비록 이전의 feature design보다는 쉬워졌지만, architecture design 또한 많은 지식과 시간이 요구되는 일입니다.
간단히 표현한 NAS 구조, 본 논문의 Fig.1
이 논문은 좋은 architecture를 찾아주는 Neural Architecture Search(NAS)를 제시합니다. 이 논문은 뉴럴 네트워크의 구조를 가변 길이의 문자열로 표현할 수 있다는 관점에서 시작되었습니다. 이를 위해 NAS의 controller는 가변 길이의 문자열을 생성하기 위해 RNN 구조를 이용합니다. 문자열로부터 나오게 된 네트워크(child network)를 학습하면, validation set에 대해 accuracy가 나오게 됩니다. 이 accuracy를 강화학습에서의 reward의 관점으로 보아 controller의 policy를 업데이트하게 됩니다. 이를 통해 다음에 나오게 될 문자열로 표현된 네트워크가 높은 accuracy를 받을 확률을 높이게 됩니다.
Methods
아래에선 순서대로 다음에 대해 설명할 것입니다.
1) cnn architecture를 rnn(controller)으로 생성하기 위한 방법
2) rnn(controller)을 강화학습으로 훈련시키는 방법
3) 모델의 복잡도와 훈련 시간을 줄이기 위한 몇몇 방법
4) rnn architecture를 생성하기 위한 방법
<Generate model descriptions with a controller RNN>
NAS에서는 controller가 뉴럴 네트워크의 구조적인 하이퍼 파라미터들을 생성하게끔 합니다. 유연성을 추가하기 위해 이는 RNN을 이용하여 구현되었습니다. 만약 convolutional layer로만 이루어진 뉴럴 네트워크를 생성한다고 가정해보면, 아래 그림과 같이 하이퍼 파라미터가 토큰들의 시퀀스로 생성되게끔 controller를 사용할 수 있습니다.
Controller의 출력 하나 하나가 architecture의 하이퍼 파라미터입니다. 본 논문의 Fig.2
각각의 출력값들은 softmax를 통해 값을 정하게 되고, 이렇게 정해진 값은 다음 step에서의 input으로 들어가게 됩니다. 실험에서는 layer의 수가 특정 값을 초과하면 architecture 생성을 멈추게끔 하였습니다. 이 특정 값은 훈련이 진행됨에 따라 점차 늘려갑니다. RNN controller가 architecture 생성을 마쳤을 때, 이 architecture 기반의 child 모델이 생성되고 훈련을 실시합니다. 훈련이 끝나가 child 모델이 수렴하게 되었을 때 validation set에 대한 accuracy 값이 기록됩니다. RNN controller의 가중치는 생성한 architecture에게 기대되는 accuracy 값이 최대가 되도록 가중치를 업데이트합니다. 이 방법에 대해서는 아래 더 자세히 설명드리겠습니다.
<Training with reinforce>
chile network의 하이퍼 파라미터를 하나하나 예측하는 것 자체를 action이라고 볼 수 있습니다. 그러면 action들이 연속하여 나오게 된 것이 child network의 architecture이며, child가 최종적으로 내게 된 accuracy R이 데이터셋으로부터 나오게 됩니다. 이 R 값을 일종의 reward로 생각해서 RNN controller에 강화학습을 진행하게 됩니다. 좀 더 구체적으로, 최적의 architecture를 찾기 위해 controller에게 기대되는 reward를 최대화하게끔 합니다.
본 논문에서는 현재의 가중치에서 1부터 T까지의 액션 시퀀스 a가 주어졌을 때의 기대값 R을 왼쪽과 같이 표현합니다.
이렇게 표현되는 R은 미분이 불가능하기 때문에, 지속적으로 가중치를 업데이트할 수 있는 policy gradient method가 필요합니다. 이 논문에서는 아래와 같은 식을 사용합니다.
이는 아래의 식으로 추정될 수 있습니다.
m : 한 번의 batch에서 controller가 만들어낸 architecture의 갯수
T : architecture를 디자인하기 위해 controller가 생성한 하이퍼파라미터의 갯수
Rk : k번째 architecture의 accuracy
하지만 위의 식은 분산이 굉장히 높습니다. 따라서 baseline을 추가한 아래의 식을 적용합니다.
이 논문에서 baseline b 는 이전의 architecture들의 평균 accuracy를 이용하여 결정합니다.
추가적으로 학습을 빠르게 진행시키기 위하여 아래 방법을 사용했습니다.
NAS에서 하나의 child network를 만든 뒤, accuracy 측정을 위해 이를 학습시키는 과정은 여러 시간이 소모됩니다. 따라서 controller의 학습 시간을 빠르게 하기 위해 분산 학습을 이용합니다. controller의 파라미터를 저장하는 파라미터 서버가 S개 존재하며, 이 서버들은 K개의 controller에게 파라미터를 보냅니다. 이를 통해 controller들은 m개의 architecture를 생성하고, 이를 병렬적으로 학습시켜 최종 gradient를 계산합니다. 그 뒤 이를 다시, 파라미터 서버에 보내며 업데이트 시킵니다. 이 과정을 정해진 값만큼의 epoch동안 반복합니다.
분산 학습의 구조, 본 논문의 Fig.3
<Increase architecture complexity with skip connections and other layer types>
위에서 보았지만, controller의 탐색 공간은 skip connection 등의 최신 architecture에서 사용되는 기법들을 탐색하지는 못합니다. 이를 위해 탐색 공간을 넓힘으로써, controller가 이런 기법들에 대해서도 제안할 수 있게끔 하는 방법에 대해 소개하겠습니다.
skip connection 적용 방법 관련 그림, 본 논문의 Fig.4
connection을 가능하게끔 하기 위해 set-selection attention을 사용합니다. 추가적으로 각 레이어에는 Anchor point가 생기게 됩니다. 현재의 레이어가 N일 때 1 ~ N-1 까지 이전의 레이어에서 연결할지 말지를 계산합니다. 계산식은 아래와 같습니다.
v와 W는 학습해야 하는 벡터입니다.
j의 범위는 1 ~ i - 1입니다.
위 식을 통해 j레이어가 i레이어에 연결이 될지 말지를 결정할 수 있습니다. 이를 적용해도 강화학습 방법은 별다른 수정 없이 그대로 사용이 가능합니다. 기존에는 무조건 순차적으로 연결되있던 모델만을 생성했다면, 이번엔 Anchor를 통해서만 레이어들이 연결되는 것으로 바뀌게 됩니다.
다만 이런 connection을 추가하면 문제가 생길 수 있습니다. 예를 들어 하나의 레이어에 많은 레이어가 input으로 들어오게 될 때, 많은 레이어를 concatenation 하여 input으로 사용하게 되는데 이럴 때 차원 관련 문제가 생길 수 있습니다. 혹은 한 레이어에 input이 없는 경우가 있을 수도 있습니다. 이런 경우 컴파일 에러를 낼 수 있습니다. 따라서 이 논문에서는 세 가지 간단한 기술을 추가로 적용합니다.
1) 레이어에 input이 없는 경우 이미지를 input으로 넣습니다.
2) 최종 레이어는 output 레이어가 없는 모든 레이어를 연결합니다.
3) 만약 인풋 레이어들끼리 다른 사이즈를 가지고 있다면, 작은 레이어는 제로 패딩을 적용하여 같은 사이즈로 만듭니다.
위와는 다른 기술적 적용으로 learning rate 같은 파라미터에 대해서는 controller가 예측하지 못하는 제한적인 CNN 구조만 만들 수가 있었는데, 이런 것 또한 가능하게끔 할 수 있습니다. 그에 더해 pooling, normalization, batchnorm 등등을 추가하는 것 또한 가능하다고 합니다. 이를 위해서는 필요한 작업은 controller가 layer type을 출력하게끔 하면 됩니다.
<Generate recurrent cell architectures>
위의 방식을 수정하여 RNN cell을 만들수도 있습니다. 기본적인 rnn 모델은 hidden state Ht를 입력값 X와 이전의 출력값 H(t-1)을 이용하여 계산합니다. 이를 수식으로 나타내면 아래와 같습니다.
조금 더 복잡한 모델인 LSTM이 요즘엔 많이 쓰이기 때문에 이런 복잡한 모델을 생성하기 위해 어떻게 NAS를 사용해야 하는지 설명해드리겠습니다.
NAS의 RNN Cell 생성 과정 예시, 본 논문의 Fig.5
하이퍼 파라미터들을 출력하는 점은 이전의 NAS와 비슷합니다만, 레이어별로 하이퍼파라미터를 출력하는 것이 아니라 필요한 연산들을 트리 구조로 나타내어 하이퍼 파라미터를 출력합니다. 위 그림에서 왼쪽의 트리는 기본적인 RNN의 틀을 만들어 준 트리입니다.
각 트리의 노드마다 1)계산 방법과 2)활성화 함수를 NAS 모델이 출력하게 됩니다. 그런데 이 정도로는 복잡한 RNN 모델을 표현하기에 부족할 수 있기 때문에(LSTM 같은 경우에는 추가적으로 cell state를 활용) 추가적으로 cell inject와 cell indices 부분을 받습니다.
cell inject는 cell state가 사용할 계산 방법과 활성화 함수를 출력하는 부분이며, cell indices는 각기의 cell state가 기존의 트리 노드에 끼어들 부분을 선택하는 부분입니다. 이를 통해 만들어진 rnn cell을 트리로 나타내면 왼쪽 그림이 됩니다. 이를 추가적으로 응용하면 좀 더 복잡한 모델 또한 만들 수 있을 것으로 보입니다.
Experiments and Results
실험은 두 가지 데이터셋에서 진행됩니다. 첫 번째로는 CIFAR-10 데이터셋으로 이미지 인식에 대해 좋은 성능의 CNN 아키텍쳐를 찾기를 원하고, 두 번째로는 Penn Treebank 데이터셋으로 language modeling에 대해 좋은 성능의 RNN cell을 찾기를 원합니다.
<Convolutional Architectures for CIFAR-10>
데이터셋 : CIFAR-10 데이터셋에 전처리 과정과 augmentation 과정을 걸쳤습니다. 먼저 이미지들에 대해 whitening 과정을 걸치고 추가적으로 각각의 이미지들을 upsample 후 랜덤하게 32x32 크기로 잘랐습니다. 마지막으로, 이렇게 잘려진 32x32 이미지에 대해 랜덤한 horizontal flips를 사용했습니다.
Search space : 비선형 함수로 Relu를 사용하며 각 레이어마다 batch normalization과 skip connection이 존재합니다. 모든 convolutional 레이어에 대해, RNN controller는 filter의 height[1, 3, 5, 7]과 width[1, 3, 5, 7], 그리고 필터의 수[24, 36, 48, 64]를 선택합니다.
stride에 대해서는 두 가지의 실험을 했습니다. 한 가지는 1로 고정시킨 것이며, 다른 건 controller가 [1, 2, 3]의 값 중 하나를 선택하게끔 하는 것입니다.
Training details : RNN controller는 35개의 hidden unit을 가진 LSTM 레이어 두 개로 이루어집니다. 학습률은 0.0006으로 ADAM optimizer를 사용했으며, 균등하게 가중치를 -0.08과 0.08 사이의 값으로 초기화시켰습니다.
학습은 위에서 설명드린 파라미터 서버를 이용하여 분산 환경에서 진행을 하였습니다. 파라미터 서버의 갯수는 20개이며, 컨트롤러의 갯수는 100개, 각 컨트롤러마다 child architecture는 8개를 만들었습니다. 즉 800개의 네트워크가 800개의 GPU를 통해 동시에 학습이 되는 방식이었습니다.
각각의 child architecture는 만들어지면 50번의 epoch을 통해 학습을 진행하였습니다. 그 중 마지막 5 epoch 동안의 accuracy를 최대화하게끔 reward를 이용하여 파라미터를 업데이트했습니다.
validation set은 랜덤하게 5000개를 뽑았으며, 나머지 45000개는 훈련 데이터로 사용되었습니다.
controller를 훈련시키는 동안, 점차 child network의 레이어 수를 늘려갔습니다. 이 실험에서는 6개의 레이어에서 시작하여 1600개의 child network마다 두 개의 레이어를 늘리게끔 진행되었습니다.
Results : controller가 12800개의 아키텍쳐에 대해 학습을 마친 후, 아키텍쳐가 가장 좋은 accuracy를 가지게 된다는 것을 발견했습니다. 그 뒤, 학습률, weight decay, batchnorm epsilon, epoch에 따른 학습률 감소 분야에 걸쳐 작은 범위에서 grid search를 진행하였고, 이를 통해 찾아낸 best model을 학습시킨 결과는 아래와 같습니다.
CIFAR-10 데이터셋에 대한 결과, 본 논문의 Table.1
다른 기존 모델들과의 성능 비교가 함께 되어있는데, Error rate를 살펴보시면 기존에 가장 좋은 성능을 내던 Dense-Net과 어느 정도 비슷한 성능을 내는 것을 볼 수 있습니다. 이를 통해 NAS가 dataset에 대해서 잘 작동할 수 있는 아키텍쳐를 구축할 수 있다는 점이 증명되었다고 할 수 있습니다.
표를 좀 더 살펴보시면 NAS에서도 추가적인 하이퍼파라미터나 레이어를 통해 성능을 높일 수 있다는 점이 눈에 띕니다. 그리고 v1의 경우에는 깊이가 15로 낮은 모델임에도 좋은 성능을 내고 있습니다. 그리고 또한 흥미로운 점은 v2와의 비교인데, strides를 예측하게 했더니 오히려성능이 drop되었습니다. 이는 search space가 커지게 되어 controller 성능에 악영향을 끼친 것으로 파악이 됩니다.
v3의 경우는 13레이어와 24 레이어에 pooling layer를 추가하게끔 하는 모델로 controller는 39개의 레이어로 이루어진 모델을 만들었습니다. 성능 또한 4.47로 좀 더 좋아졌습니다. 여기서 search space를 줄이기 위해 controller가 만드는 레이어의 갯수를 13개로 줄이고, 그 대신 각 레이어마다 3개의 dense 레이어를 추가했습니다. 추가적으로 여기서 controller가 예측하는 필터의 갯수 범위를 [24, 36, 48, 64]에서 [6, 12, 24, 36] 로 변경하였습니다. 그 대신 각 레이어마다 40개의 필터를 추가하였고 이를 통해 error rate가 3.65로 기존 Dense Net 모델을 뛰어넘는 결과가 나왔습니다. Dense-Net의 가장 좋은 모델인 3.46은 1x1 convolution을 사용해서 정확한 경쟁 대상이 아니라고 합니다. 따라서 기존에 성능이 가장 좋던 모델보다 더 좋은 모델을 NAS가 만들어낸 것입니다.
NAS가 찾은 CNN 아키텍쳐, 본 논문의 Appendix.1
위 그림은 NAS가 찾아낸 CNN 아키텍쳐 중 하나입니다. skip connection이 다양하게 불규칙적으로 이루어지는 것을 확인할 수 있습니다.
<Learning recurrent cells for penn treebank>
Dataset : Language modeling에서 벤치마크로 잘 알려진 Penn Treebank(PTB) 데이터셋을 이용합니다. 이 데이터셋에 대해서는 LSTM 모델이 뛰어난 경향을 보이며, 이를 향상시키는 것은 어렵습니다. PTB는 작은 데이터셋이기 때문에, 오버피팅을 피하기 위해 regularization 방법들이 필요하기에, Embedding dropout과 Recurrent dropout를 사용합니다. 이 방법을 input과 output Embedding에도 공유합니다.
Search space : 위에서 설명했듯이 RNN 모델을 만들기 위해 차례로 각 트리의 노드별로 계산 방법과 활성화 함수를 순차적으로 출력하게 됩니다. 계산 방법은 [Add, Elem_mult(곱)], 활성화 함수는 [identity, tanh, sigmoid, relu] 중 하나를 선택합니다.
Training details: 위 CIFAR-10 학습 과정과 몇 개의 수정사항을 제외하곤 거의 비슷합니다.
1) RNN controller의 학습률은 0.0005로 CIFAR-10보다 조금 높습니다.
2) 파라미터 서버의 갯수는 20, 컨트롤러의 갯수는 400개이며, child 아키텍쳐는 단 1개입니다. 즉 400개의 모델이 동시에 학습됩니다.
3) 파라미터 서버의 파라미터의 업데이트는 10개의 기울기가 컨트롤러에 축적되었을 때 실행됩니다.
각각의 만들어진 child 모델은 35 epoch를 통해 훈련되었습니다. child 모델은 두 개의 레이어를 가지고 있습니다. 이 실험에서 controller는 오로지 RNN cell 구조를 예측하기 위해 다른 하이퍼 파라미터들은 고정한 상태입니다. reward 함수는 c / (validation perplexity)^2 이며, c는 상수로 80으로 설정했습니다.
위 실험과 마찬가지로 가장 좋은 성능의 RNN cell이 발견되었을 때, 학습률이나 weight 초기화, dropout rate, decay epoch에 대해서 그리드 서치를 진행하였습니다.
Results : 아래의 표는 PTB 데이터셋에 대한 각 모델들의 성능을 비교한 것입니다. 표에서 확인할 수 있는 NAS로 생성된 모델이 기존의 모델을 능가하는 것을 확인할 수 있습니다. perplexity 지표만으로도 좋은 것이 확인되지만, 속도 면에서도 기존 모델보다 빠르다는 점도 주목할 만 합니다. (Zilly 모델에 비해 NAS의 모델이 2배의 속도를 가진다고 합니다.)
Penn Treebank에 관한 실험 결과, 본 논문의 Table.2NAS가 찾은 RNN cell 구조, 본 논문의 appendix.2
<Transfer learning results>
이번에는 같은 데이터셋에 대해 다른 task인 character language modeling을 해보면서 모델의 일반화 능력에 대해서 알아보겠습니다. 실험 환경은 Ha et al. 논문과 비슷하게 구성을 하였고, 이 모델과 비교를 합니다.
비교 결과가 아래의 테이블에 나와 있습니다.
PTB character modeling 에 대한 비교, 본 논문의 Table.3
이 부분에 대해선 아직 이해가 부족해서 정리를 못하겠습니다..
Conclusion
이 논문은 RNN을 활용한 뉴럴 네트워크 아키텍쳐를 찾아내는 아이디어, NAS에 대해 소개합니다.
RNN을 사용함으로써 아키텍쳐 구조에 대해 유연하게 대응할 수 있습니다.
이 방법을 통해 여러 분야의 챌린저에서 가장 좋은 성능의 모델들보다 좋은 성능을 내는 아키텍쳐를 구해냈습니다.
이를 통해 다양한 분야에서 좋은 아키텍쳐 구조를 찾는 데 도움이 될 것으로 보입니다.
개인 의견
사실 요즘 인공지능 딥러닝 분야는 여러 다양한 복합적인 모듈들이 섞여서 하나의 지능적인 task를 해내는 걸 주로 하는 듯 한데, 위 NAS를 이용하려면 꽤 많은 변경과 아이디어가 필요할 것으로 보입니다. 그래도 RNN을 강화학습으로 학습시키는 부분이나, 신경망의 파라미터들의 시퀀스를 출력하게끔 한다는 점은 훌륭한 아이디어로 보입니다.
이 논문은 새로운 로봇 학습 프레임워크인 Neural Task Programming(NTP)를 제안합니다.
Neural Program Induction과 few-shot demo learning 두 가지 분야를 합쳤습니다.
NTP의 핵심 흐름은 아래와 같습니다.
본 논문의 Fig.1 (top)
NTP는 입력으로 task specification(예를 들어 비디오 데모)을 받습니다. 이 task specification을 재귀적으로 분해하면서 sub-task의 task specification으로 나눕니다. 재귀적이라고 말했듯이 이는 반복됩니다.
즉 비디오 데모라고 한다면, 전체 비디오를 부분부분 잘라서 sub task가 언젠가 최소의 Action이 될때까지 계속해서 분해하는 방식입니다. NTP 모델은 task specification을 보고 다음으로 실행해야 될 프로그램이 무엇인지 파악하고 호출합니다. 이 모델은 NPI와 닮았습니다. Compositional한 모델로 다음 프로그램을 호출할 때 새로운 NTP와 새로이 분해된 task specification을 입력으로 줍니다. 이 말은 아래에서 다시 설명드리겠습니다.
NTP는 순차적인 task에서 강력한 일반화 능력을 가지고 있다고 합니다. 이 논문에서는 이를 증명하기 위해 3가지의 로봇 조작 task에서 실험을 진행합니다.
본 논문의 Fig.1 (C)
위 그림은 로봇 조작 task 중 하나인 Object Sorting task의 예시입니다. NTP는 이 환경에서 변화가 일어나 옮겨야 될 블록의 갯수가 많아지거나, 블록마다 할당된 바구니가 달라지거나 하는 unseen task에서도 강력한 일반화로 인해 잘 동작한다고 합니다.
4) Core Network : 코어 네트워크로 LSTM 기반이 아닌, Reactive 기반의 네트워크를 사용한다고 합니다. 다음 프로그램과, 프로그램의 종료 확률을 출력으로 내게 됩니다.
5) API Decoder : 다음에 실행할 프로그램이 Primitive한 API일 경우에 API를 위한 매개변수를 생성하는 Decoder입니다.
6) Task Specification Selection : 다음 하위 프로그램에게 줄 task specification을 적절하게 선택하는 과정입니다. 여기서 나온 task specification이 다음 프로그램에게 주어지게 됩니다.
전체적인 흐름은 NPI와 많이 유사합니다. 차이점은 아래와 같습니다.
1) NPI의 Primitive Action을 NTP는 Robot API를 사용합니다. 이는 task의 적용을 실제 환경같은 더 넓은 범위에 할 수 있게 합니다.
2) NPI는 LSTM 기반의 코어 네트워크를 가졌습니다만, NTP은 Reactive 코어 네트워크를 사용한다고 합니다. 자세한 내용은 나와있지 않아 알 수가 없지만, 이를 통해 Error로부터의 회복에 더 강하다고 합니다. 이는 예외 상황이 발생하기 쉬운 로봇 환경에서 이점이 됩니다.
3) NPI는 다음 프로그램을 생성할 때 input으로 기존의 h state를 사용했지만, NTP는 적절한 task specification을 받습니다. 이를 통해 다양한 Task variation들에 대해서도 적절한 프로그램을 뽑을 수 있다고 합니다.
실제 NTP가 돌아가는 Flow, 본 논문의 Fig..3
위 그림은 NTP가 돌아가는 흐름이라고 보실 수 있습니다. 맨 위의 영상들의 Sequence는 task specification을 의미하고 있습니다. 맨 처음 프로그램을 호출할 때는 빨간 색의 범위에 있는 task specification을 입력으로 넣습니다. 그 뒤 호출하게 될 프로그램에 대해서는 주황 색 범위의 task specification이 입력으로 들어가게 됩니다. 이런 식으로 하위 프로그램에게는 그 프로그램이 필요한 task specification을 제공하여, 필요한 정보만을 입력으로 줄 수 있습니다.
<Task Specification Scoping>
그렇다면 과연 task specification을 적절하게 자르는 과정은 어떤 방식으로 이루어지는 걸까요?
task specification은 time step마다의 값이라고 볼 수 있습니다.
이렇게 나온 값마다 {'Start', 'End', 'Inside', 'Outside'} 확률을 구하기 위해 softmax를 적용합니다. inside와 outside 확률도 구하지만, 실전에서는 가장 높은 확률의 start와 end를 기준으로 자르는 것이 좋은 성능을 보여주었다고 합니다.
논문은 Neural Programmer-interpreter(NPI) 모델을 제안합니다. 이 모델은 프로그램을 표현하고 실행하는 법을 배우는 recurrent하고 compositional한 뉴럴 네트워크입니다.
NPI는 세 가지 요소를 가지고 있습니다.
1) Task와 상관없는 코어 RNN
2) key-value 프로그램 메모리
3) Task 도메인마다의 특정 인코더 - 이를 통해 다양하고 다른 여러가지 환경에서 NPI가 작동할 수 있게 해줍니다.
하위 레벨의 프로그램들을 조합하여 상위 레벨의 프로그램을 표현하는 법을 배우기 위해, NPI는 기존 Seq2Seq LSTM 모델과 비교하였을 때 학습과정에서의 샘플 필요 수를 줄이고, 일반화 능력을 높였습니다.
프로그램 메모리는 이미 존재하는 프로그램들과 함께 추가적인 task에 대한 효율적인 학습을 할 수 있게 합니다.
NPI는 또한 RNN의 hidden state에 대한 장기적인 기억에 대한 부담을 감소시킬 수 있게끔 환경을 이용할 수 있습니다. 예를 들어 환경에 패드(메모장)가 존재한다면, 그 패드에 계산의 중간값을 저장할 수 있습니다.
NPI는 완전지도학습으로 학습됩니다. 각각의 프로그램은 Input에 따라 중간중간 서브프로그램을 실행하는 예시 순서들을 가지고 있습니다. 많은 수의, 하지만 상대적으로 빈약한 training 데이터보다, 풍부하지만 적은 수의 training 데이터를 이용해 학습한다고 합니다.
이 논문은 NPI가 여러 타입의 프로그램들(덧셈, 정렬, 3D 모델 회전시키기)을 학습할 수 있다는 것을 증명하려 합니다.
더 나아가서, 단 하나의 NPI가 이 프로그램들과 21가지의 연관된 서브프로그램을 실행할 수 있게 학습시킬 수 있습니다.
Introduction & Model
Recurrent와 Compositional, 이 두 말의 의미는 논문에서 대략 이렇게 사용됩니다.
1) Recurrent는 말 그대로 반복적인 모델이라는 뜻인데, 보통 RNN이라고 표현합니다.
2) Compositional은 여러 개의 모델이 합쳐져 사용된다는 뜻으로 보입니다.
이 두가지를 그림으로 표현하면 아래와 같습니다.
본 논문의 Fig.1
h 가 써져있는 네모난 블록이 하나하나의 신경망이라고 보시면 됩니다. 그림을 보시면 h 블록으로부터 다른 h 블록으로 화살표가 이어져있는 것을 볼 수 있는데, 이전에 나왔던 출력값이 다시 입력값으로 들어가는 Recurrent한 모습을 보여줍니다. 하지만 모든 블록들이 이렇게 이어져있지 않고 여러 그룹이 존재합니다. 이렇게 여러 그룹들이 존재하는 모습이 Compositional 하다라고 볼 수 있습니다.
이 논문의 모델을 잘 표현한 그림이라 조금만 더 설명드리겠습니다. h 는 신경망이라고 했는데, 아래에 위치한 블록들이 입력값, 위에 위치한 블록들이 출력값입니다. 모델의 입력으로는 현재 실행하는 프로그램과 현재의 State 값이 들어가게 됩니다.
<Input>
1) 현재 실행되는 프로그램을 나타내는 임베딩 값
2) 현재의 State는 두 개의 값으로 구성됩니다. 프로그램을 실행할 때 같이 들어온 매개변수와 환경의 상태입니다.
- 환경의 상태는 task를 수행할 환경마다 다르기 때문에 환경마다 특정한 Encoder를 사용합니다. 위의 그림에서는 이미지로 받아들이기 때문에 CNN 기반의 Encoder가 사용될 것입니다.
- 매개변수 또한 환경마다 다를 수 있기 때문에 특정 Encoder에 같이 들어가게 됩니다.
2)에서 사용되는 Encoder를 통해 NPI 모델이 받아들일 수 있는 Input의 사이즈에 맞게 항상 환경의 특징들이 추출된다고 볼 수 있습니다.
<Output>
1) KEY 는 다음에 실행할 프로그램을 찾을 수 있는 키값입니다. 이를 이용해 프로그램 메모리에서 적절한 프로그램을 찾습니다.
2) END 는 현재 실행되고 있는 프로그램을 종료할 확률입니다. 특정 쓰레쉬홀드값을 넘어가게끔 하면 이 프로그램은 끝을 맺습니다.
3) ARG 는 다음에 실행할 프로그램의 매개변수입니다.
전체적인 동작의 과정은 알고리즘을 보시면 좀 더 이해하시기 편할 것 같습니다.
본 논문의 Alg.1
* 반복문 while의 조건은 END 확률이 쓰레쉬홀드값을 넘어가기 전까지 계속해서 반복됩니다.
1) 매개변수와 환경을 Encoder에 넣어서 나온 출력값 s 와 현재의 프로그램 p, 그리고 RNN이기 때문에 이전 출력값h도 함께 모델에 입력값으로 넣습니다.
2) 모델로부터 나온 출력값 h 를 이용하여 KEY, END, ARG를 구해냅니다.
3) KEY를 이용하여 어떤 프로그램을 실행할지 알아내는 과정은 프로그램 메모리에 저장되어 있는 키값들 중에서 가장 유사한 값을 찾는 방식입니다.
4) 만약 이번에 실행할 프로그램이 ACT(가장 원자단위의 행동 프로그램이라는 뜻입니다) 라면 환경에 대해서 실행하고, 아니라면 재귀적으로 RUN 함수를 호출하면서 또 다른 모델구조를 만듭니다.(Compositional)
위 알고리즘과 그림을 함께 보시면, 대략적인 구조가 이해되실 것 같습니다.
Training
이 모델의 학습은 아래의 식을 이용합니다.
본 논문의 수식.7
즉, 이전의 Input history가 주어질 때 output으로 나와야하는 Ground-truth output의 확률을 높이는 방식으로 되어있습니다. 이는 아래와 같이 표현할 수 있습니다.
본 논문의 수식.8
Experiments
이 논문에서의 실험 환경은 3가지입니다.
1) Addition
본 논문의 Fig.3 (a)
input1, input2, carry, output 4개의 row로 이루어져 있으며, 각각의 row마다 포인터가 존재합니다. 두 개의 인풋이 들어오면 덧셈 연산을 합니다.
Addition의 Encoder ,본 논문의 수식.9
환경마다의 특정한 Encoder가 필요하다고 했었는데, Addition 환경에서의 Encoder는 위와 같습니다. Q는 각각의 포인터가 가리키는 숫자가 원핫 인코딩으로 표현되어있습니다. 즉, 이 환경에서는 4개의 포인터가 가리키는 4개의 숫자와 함께 매개변수 3개를 합쳐서 MLP에 입력하여 나온 출력값을 S 값으로 사용합니다.
2) Sorting
본 논문의 Fig.4 (a)
Bubble-sort를 이용하여, 정렬을 하는 환경입니다. 하나의 row에 두 개의 포인터로 이루어져 있습니다.
Sorting의 Encoder, 본 논문의 수식.10
Encoder는 위 Addition과 비슷하게 이루어져 있습니다.
3) Canonicalizing 3D Models
본 논문의 Fig.7
3D 환경에서 주어진 차의 모습을 target 각도로 돌리는 것이 목표인 환경입니다.
본 논문의 수식.11
Encoder가 위 두 개의 환경이랑 조금 다르게 되어있습니다. 이 환경에서 target은 각도와 고도가 각각의 숫자로 나타내어져 있고, 그것을 Q를 통해 읽게 됩니다. 또한 3D 환경이므로 현재의 상태를 CNN을 통해 파악하게 됩니다.
첫번째 실험과 두번째 실험은 bubble-sort task에 대하여 평범한 Seq2Seq LSTM과의 비교실험입니다. Bubble-sort는 시간복잡도가 O(N^2)이기에, 정렬해야할 숫자가 길어질수록 급격하게 상태정보가 커지게 되고, 이는 LSTM의 hidden state에 전부 담기에 불가능해집니다. 하지만 NPI는 Compositional 하기 때문에 평범한 LSTM에 비해 더 많은 상태저장이 가능합니다.
훈련 데이터는 2개에서부터 20개까지의 숫자 리스트들에 대한 64개의 예시와 1216개의 trace 과정들을 통해 이루어집니다.
트레이닝 데이터의 갯수에 따른 Acc, 본 논문의 Fig.5
길이가 20인 배열의 정렬을 가능하게끔 하기 위해 필요한 훈련 데이터의 갯수를 그래프로 나타낸 것입니다. 한 눈에 보기에도 NPI가 2개부터 학습을 시작하여, 8개에서 이미 학습을 완료한 점이 눈에 띕니다. 그에 반해 Seq2Seq 모델은 64개부터 시작하여, 250개에 이르러서야 어느정도 학습이 되는 모습입니다.
학습 후 일반화 능력에 대한 테스트, 본 논문의 Fig.6
이번에는 길이가 20을 넘어서는 배열에 대해서도 정렬이 가능한지에 대한 실험입니다. 이것이 가능하다는 것은 배우는 것에 대해 일반화를 했다고 볼 수 있는데, NPI가 Seq2Seq 모델에 비해 훨씬 강력한 일반화 능력을 보여주고 있습니다.
NPI는 추가적인 프로그램을 학습시키는 것이 가능합니다. 이것에 대해 먼저 걱정되는 점은 새로운 학습이 기존의 task에 대한 성능을 떨어뜨릴 수 있지 않을까 하는 점입니다. 이를 극복하기 위해 NPI core 모델의 가중치는 고정을 시키고, 오로지 프로그램 메모리를 업데이트하는 식으로 프로그램을 추가합니다. 하지만 이렇게 되면 실수로 기존의 프로그램이 새로운 프로그램을 불러버리는 일도 있을 수 있습니다. 이점을 극복하기 위해서는 이 논문에서는 새로운 프로그램의 trace들 뿐만 아니라, 기존에 존재하던 trace들 또한 학습에 사용했습니다.
본 논문의 표.1
위 실험은 하나의 task에 대해서 학습시킨 Single 모델과, 한번에 여러가지의 task를 학습시킨 Multi모델, 그리고 Multi에 추가로 Max 프로그램을 학습시킨 모델 세 가지의 Acc를 비교합니다. 이를 통해
1) 새로운 프로그램을 학습시키는 것은 기존의 다른 task들의 성능에 영향을 주지 않는다는 것
2) 하나의 NPI 코어만으로 여러 task에 접목하는 것이 가능하다는 것
두 가지를 증명했습니다.
Conclusion
오로지 하나의 NPI만으로 비슷하지 않은 여러 환경들의 프로그램들에 대해 배우는 것이 가능한 모델입니다.
그리고 NPI는 LSTM과 비교하여 강력한 일반화 능력을 가지고 있습니다.
또한 NPI는 여러 새로운 프로그램들을 기존 프로그램을 잊지 않으면서 학습하게끔 할 수 있습니다.
데모 비디오들로부터 행동 결정 로직을 해석하는 일은 사람을 사람을 흉내 내고 협력하는 데 있어서 키 포인트라고 말하며, 이 로직을 시각적으로 복잡한 여러 데모 비디오들로부터 DSL*을 이용하여 프로그램 포맷으로 생성해내는 Neural Program Synthesizer 모델을 이 논문은 제안합니다.
이 모델의 핵심 요소 두 가지는 아래와 같습니다.
1) Summarizer module - 여러 개의 데모 비디오를 Compact 하게 통합하여 주는 모듈
2) Multi-task objective - end-to-end 학습에서 모델의 학습 능력을 높이기 위한 부가적인 목적함수들
* DSL(Domain Specific Language) - 특정 도메인에 특화된 언어로써 이 논문의 모듈이 프로그램을 생성할 때 이를 이용해 생성합니다. 프로그램은 연속된 각각의 토큰들로 생각할 수 있습니다. 이 논문에서는 크게 3가지(Action, Perception, Control flow)로 토큰들을 분류합니다.
[Approach]
전체적인 모듈의 구조가 나타난 본 논문의 Fig.3
위의 그림은 전체적인 모델의 구조를 보여줍니다.
모델은 크게 3가지 모듈로 나눌 수 있습니다.
1) Demonstration Encoder - 데모 비디오 입력을 통해, 에이전트의 Action과 Perception을 Embedding 합니다.
2) Summarizer Module - 각각의 데모 비디오들로부터 나온 Embedding을 통합하는 역할을 합니다.
3) Program Decoder - Summarizer로부터 나온 Vector를 코드의 Sequence로 decode 합니다.
각 모듈에 대한 추가 설명은 아래에 이어서 하겠습니다.
Demonstration Encoder와 Summarizer Module의 구조가 나타난 본 논문의 Fig.4
<Demonstration Encoder>
어떠한 프로그램으로부터 생성된 데모 비디오가 k개까지 있다고 할 때, 각각의 데모 비디오들은 일정한 time step을 구분으로 하는 state의 연속된 sequence라고 표현할 수 있습니다. state를 encoder(CNN)에 입력으로 얻은 feature 값을 S로 위 그림에서 표현합니다.
Demo Encoder는 LSTM을 사용하며, S를 차례대로 입력으로 넣고 최종적으로 나오게 되는 cell state c, hidden state h가 데모의 전체적인 내용을 함축한다고 생각할 수 있게 됩니다. Average Pooling 과정에서는 각각의 c와 h를 더해 평균을 낸 Z 를 만들게 됩니다.
<Summarizer Module>
위에서 만들어진 Z를 활용하여 데모들을 Review하는 과정을 거치게 됩니다. 이때의 LSTM은 Z로 Initialized되며, 각 step마다의 입력은 Demo Encoder 과정에서 step마다의 hidden state h 를 이용하게 됩니다. 이는 데모들의 전체적인 관점에서 다시 한번 각각의 데모들을 리뷰하는 과정이라고 보실 수 있겠습니다. 이를 이용해 최종적으로 데모마다 벡터를 뽑게 되고, 이를 Relation Network를 이용하여 최종적으로 모든 데모들이 요약된 벡터 Vsummary 를 만들게 됩니다. Relation Network 관련 부분은 단순하게 생각하면 각각의 데모마다의 관계를 계산하는 모듈이라고 생각할 수 있을 것 같습니다.
Relation Network 관련된 본 논문의 수식 (4)
<Program Decoder>
프로그램을 생성하는 모듈입니다. Vsummary 로 initialized된 LSTM을 사용하며 각각의 step마다 이전 step에서의 토큰Embedding을 입력으로 받고, 출력으로 다음으로 나오게 될 토큰들의 확률을 계산합니다.
<Learning>
Training 과정에서의 Loss, 본 논문의 수식 (5)
M : training example의 총 개수
N : 토큰의 총 개수
W : 이전 토큰들의 sequence
D : 데모
데모 D와 이전 토큰들의 시퀀스가 주어질 때 다음 토큰으로 ground-truth 토큰이 되게끔 합니다.
<Multi-task Objective>
위 모델은 End-to-End로 학습을 진행합니다. 하지만 데모들로부터 각각의 time step에서 Action들과 Perception을 잘 인식하여 뽑아냈는지 확인하기가 어렵습니다. 만약 환경이 시각적으로 좀 더 복잡하다면 이는 모델에게 있어 더 어려운 일이 될 것입니다. 이를 해결하기 위해 두 가지의 Loss 함수를 추가적으로 이용합니다.
본 논문의 수식 (6)
첫 번째로 Action Loss 입니다. Summarizer Module에서 Relation Network에 들어가기 전 review 과정에서 나왔던
V와 이전까지의 액션들의 시퀀스 A가 주어질 때 다음 action이 ground-truth action이 되게끔 합니다. 즉, 각각의 데모 비디오로부터 올바른 action sequence를 뽑아내게끔 도와주는 역할을 하는 것으로 보입니다.
본 논문의 수식 (7)
두 번째로 Perception Loss 입니다. perception은 각각의 perception에 대해서 {0, 1} 바이너리로 표현된 L차원 벡터로 이루어져 있습니다. 이번에도 review 과정에서 나왔던 V와 이전까지의 perception sequence가 주어질 때 L개의 perception에 대해서 올바른 ground-trueth perception이 나오도록 합니다. 이 또한 위의 Action Loss와 비슷하게 올바른 perception을 뽑아낼 수 있도록 도와주는 역할을 하는 것으로 보입니다.
지금까지 나온 세 가지 Loss를 각각에 가중치를 곱해 더한 값을 Loss 함수로 위 모델은 사용하게 됩니다.
[Experiments]
위 논문은 Karel과 VizDoom 두 가지 환경을 사용하여 실험을 진행합니다.
평가 척도로는 3가지를 제시하였습니다.
1) Sequence Accuracy - 코드가 정확하게 일치하는지를 평가하는 척도
2) Program Accuracy - 같은 의미의 코드라도 다르게 쓰일 수가 있는데 이 점을 감안하여 코드 일치를 평가하는 척도
3) Execution Accuracy - ground-truth 프로그램과 실행 결과를 비교해서 평가하는 척도
<Karel Environment>
Karel 환경은 8x8 Grid 2D 환경으로, 5가지의 Action 및 5가지의 Perception 토큰이 존재하는 간단한 환경입니다. 랜덤으로 35000개의 프로그램을 생성하여, 25000개의 train, 5000개의 valid, 5000개의 test 집합으로 나누었다고 합니다. 각각의 프로그램마다 10개의 seen demo와 5개의 unseen demo를 생성했습니다. (unseen demo는 execution accuracy를 평가할 때 사용됩니다.)
Karel 환경에서의 모델 비교, 본 논문의 Table.1
첫 번째 실험은 아까의 세 가지 척도를 활용하여 모델들을 비교하는 실험입니다. Induction 모델은 프로그램을 생성하지 않고, 단순히 Action들의 Sequence를 만들어내는 모델입니다. 비교할 때 공평성을 위해 Perception 정보를 매 step마다 입력으로 넣어주었다고 하며, 그 결과가 괄호 안의 값이라고 보시면 됩니다. 위 논문에서 제안한 두 가지 요소들이 더해짐으로써 성능이 좋아지는 것을 확인할 수 있습니다.
데모 갯수에 따른 summarizer 성능 증가 비교, 본 논문의 Table.2
두 번째 실험은 summarizer module의 힘을 보여주는 실험입니다. seen demo의 개수를 k라고 할 때, k가 늘어날수록 Summarizer module을 통한 Execution Accuracy가 증가하는 것을 확인할 수 있습니다.
<VizDoom Environment>
Doom은 플레이어가 연속된 상태 공간에서 몬스터, 아이템 및 무기로 상호작용을 하는 3인칭 슈팅 게임입니다. VizDoom은 Doom을 베이스로 한 AI platform입니다. 120x160x3 pixel로 표현되는 7개의 Action, 6개의 Perception 토큰이 존재하는 좀 더 복잡한 환경입니다. 이번에는 80000개의 train, 8000개의 test 집합을 생성하였고, 각각의 프로그램마다 25개의 seen demo와 10개의 unseen demo를 생성했습니다.
VizDoom 환경에서의 모델 비교, 본 논문의 Table.3
첫 번째 실험은 모델 비교 실험입니다. 환경이 좀 더 복잡해지자 Induction 모델의 성능이 확연히 떨어지는 것을 확인할 수 있습니다. 이는 명시적으로 프로그램을 생성해내는 Synthesis 모델의 장점이 드러난다고 볼 수 있습니다. 그리고 한 가지 더 눈여겨볼 점으로 생성된 프로그램들의 구문이 99.9% 정확했습니다. 이는 DSL의 구문 또한 모델이 학습한다고 볼 수 있습니다.
if-else로 이루어진 프로그램에서의 모델 비교, 본 논문의 Table.4
두 번째 실험은 condition에 따른 행동 변화의 추론에 대한 중요성을 입증하기 위한 실험입니다. 이를 위해 if-else 구문으로 이루어진 간단한 프로그램들로 모델을 비교하며 실험했습니다. Induction model은 condition에 따른 행동 변화를 추론하는 데 있어서 어려움을 가지고 있는 것이 성능으로 드러납니다. 그에 반해 모든 모듈이 포함된 Synthesis 모델은 높은 성능이 보입니다.
K개의 seen demo가 주어질 때의 Execution Accuracy, 본 논문의 Fig.7
위 그림은 k개의 seen demo가 있을 때 나타나는 execution accuracy 성능을 보여줍니다. Induction model은 demo가 많이 주어지더라도 그에 맞는 성능을 이끌어내지 못하는 점을 확인할 수 있습니다. 그리고 summaraizer module은 demo의 개수가 늘어날수록 급격하게 유무의 차이가 나타나는 점을 확인할 수 있습니다. 이를 통해 summarizer module이 중요한 역할을 한다는 점을 다시 확인할 수 있습니다.
[Conclusion]
이 논문은 여러 데모 비디오로부터 프로그램을 생성해내는 모델을 제안했으며, 이에 추가로 성능을 높이기 위한 summarizer module과 multi-task objective를 제안했습니다. 평가를 위해 fully-observable의 Karel 환경과 partially-observable의 VizDoom 환경에서 실험을 진행했으며, 실험을 통해 제안된 모델이 좋은 성능을 낸다는 것을 증명했습니다.
