안녕하세요 Web of Think 입니다.

몇 년만에 작성하는 포스트인지 모르겠네요.

 

대략 5년여 전부터 web technology 기반으로 사물인터넷 세상(IoT world)이 구현될 것이라는 상상을 블로그에 적어 내려가기 시작했습니다. 이후로 많은 시간이 지나 관심사도 많이 변했지만, 컨넥티드 사물들(connected things)를 실생활에서 만날 기회가 생길 때마다 이렇게 다시 글을 쓰게 되네요.  

 

오늘은 제 인생의 첫 차와 예약 구매로 아직 제품이 도착하지 않은 블랙박스, 그리고 NB-IoT 모듈에 관한 이야기를 적어 보려고 합니다.

 

 

가장 먼저 필요한 준비물은 흔하게 볼 수 있는 연결끊긴 이동형 기기(unconnected mobile device) 입니다. (아래 사진은 관련이 있습니다) 

내가 처음 산 반자동으로 움직이는 쓸데없이 비싼 기기 -  My first (semi-)automobile (K5 Lpi 모델)

테슬라조차 아직까지 완전하 자동으로 움직이지 않지만 자동차라는 별명으로 알려진 이 기기는 놀랍게도 이미 백 년 전에 1.5시간 만에 완성시킬 수 있는 생산 최적화(e.g., 모델-T)를 이뤄 냈습니다. Oh My Ford! 그럼에도 불구하고, 원더키디 2020년 현재 코로나19와 같은 소소한(?) 이유로 배송하는 데만 일주일이 넘게 걸리는 마법(?)을 보여줍니다. 

대중교통 운행에 확실히 영향을 받은 것 같습니다. (참고: 구글맵)

 

사족이지만 더욱 놀라운 사실(!)은 이 기기를 구매하는 대부분의 사람들은 몇 가지에 불과한(?) 옵션 만을 선택할 수 있음에도 불구하고, 제품을 받기까지 길게는 7주까지 기다리는 인내력을 발휘한다고 하더군요. 전 어떻게든 빠르고 싸게 사겠다는 욕망에 영맨의 제고 관리 프로그램에서 우연히 발견한 하나뿐인 재고(?) 신차를 줍줍하였습니다. 이 기기의 추가 옵션에 블랙박스나 네비처럼 커넥티드 서비스(connected service)를 끼워팔기(bundling)하지만, 제가 7주의 인내력을 가질 수 없는 상황이기도 하고 비싸기도 해서 과감히 제외하고 요즘 신차 기본 옵션이라 불리는 슬기 운전(드라이브 와이즈) 구성만을 장착해 둔 것을 장바구니에 넣었습니다.     

 

오랫만에 글을 쓰니 (사실은 차를 처음 사보니) 사설이 길었네요. 양해 바랍니다;; 

 

두 번째 준비물은 어쩌다 찾은 할인 예약 구매한 제품인 아이나비 FXD5000 입니다.  (아래 광고 사진 및 야간 촬영 영상)

 

선택의 배경은 이렇습니다. 장기렌트로 빌려 타던 차량에는 (영맨이 서비스로 부착해 준) 어떤 블랙박스가 있었는데 촬영 품질이나 사용성 모두 너무 나빠서 차를 구매하면 절대 번들링하지 않겠다고 생각했습니다. 그래서, 서비스를 마다하고 직접 알아보았는데 블랙박스 제품들의 촬영 품질과 사용성을 검토해보니 품질이 조금 좋아질 수록 가격이 많이 오르더군요. (귀차니즘과 후회의 연속) 그래서 아직 변변한 사용기조차 없지만 제작사가 공개한 주행 영상이 보여주는 품질만 보고 예약 구매에 낚길 수 밖에 없었습니다. 

 

사실 블랙박스의 품질보다도 개인적인 바램이 자동차가 여전히 스스로 움직이지 못하더라도, 스마트폰으로 간접적인 대화라도 할 수 있었으면 했습니다. 특히 스마트 앱의 핵심은 유지보수라는 점에 착안해서 소프트웨어(도) 직접 만드는 금방 망하지 않을 것 같은 브랜드의 블랙박스를 선택하게 된 거죠.

 

FXD5000 언박싱입니다. 예약 주문 배송 건이라 출발 메시지는 늦었지만 정말 신속하게 배송되었네요.

예약 구매라서 GPS 안테나와 무료 설치 쿠폰이 딸려 옵니다.
패키지 전면 샷입니다. 파검 듀얼 톤인 패키지 디자인은 밋밋하고 작은 글자은 잘 안 보입니다. 아이나비 connected 라는 우측 상단의 브랜드(?)에 맞지 않게 실제 connected 는 옵션입니다 (connectable?). 잘 안보이지만 스펙을 적은 문단을 마지막을 보면 별매라고 적혀 있네요.
박스를 열면 정말 카메라처럼 생긴 블랙박스가 한켠에 자리 잡고 있습니다. 

 

마지막 준비물로 이번 포스트의 가장 핵심 모듈이지만 의외로 별매인 '커넥티드 PKG' 입니다.

앞서 블랙박스 예약 구매 할인 혜택으로 아낀 비용을 투자해서 2년 간 NB-IoT 통신 요금을 포함한 핵심 장치를 위메프에서 다나외 최적가인 6만원 미만으로 구매하였습니다. 이 장치를 달아야만 '아이나비 커넥티드'라는 모바일 앱으로 원격 접속이 가능해 진다네요. 

이 놀라운 물건은 LG U+에서 제공하는 통신망에 연결할 수 있는 유심을 포함한 일종의 모뎀에 불과한데 무료 기간인 2년이 지나고 계속 사용하면 매년 2만원 정도의 통신료가 청구됩니다. (아니면 그냥 GPS로 동작) 통신망의 빠른 발전으로 스마트폰 구매 주기가 2년 여에 불과했었는데 이런 통신 장치 역시 이런 방식으로 빠르게 발전해 갈지가 제 관전 포인트입니다.

이 장치와 연동되는 소물인터넷 통신망의 대역폭에 맞춰 가격과 앱이 제공하는 기능 - 고속(Pro)과 저속(Standard) -이 꽤 다릅니다. 자세한 내용은 판매자의 블로그 링크에 잘 정리되어 있네요.

역시 곁다리이지만 여기에 쓰인 NB-IoT 기술과 M2M 네트워크 기술들에 대한 내용은 이 블로그에서 잘 정리하고 있습니다. 

 

이것이 바로 NB-IoT 통신 동글 standard 버전 입니다.

 

이제 본격적으로 조립기를 작성해야 할 시점이지만 블랙박스 설치는 관심사가 아니므로(?) 윈도우 틴팅을 하면서 겸사 겸사 설치를 위탁했네요..;;;

거의 루마 버텍스 900에만 있는 투명도 80 필름으로 전면 틴팅을 했는데도 지하 주차장 때문인지 잘 보이지 않네요. 가운데 흰 빛이 블랙박스가 동작하고 있음을 나타냅니다.

 

가까이서 찍으니 다행히(?) 잘 보입니다. 

이제 본격적인 설치를 해봅니다.

패키지에는 통신용 유심과 통신 모듈이 포함되어 있습니다.

NANO USIM 칩을 통신 모듈 후면에 장착하고 GPS 연결 단자와 연결하면 끝인 줄 알았습니다.

이제 등록 절차를 통해 단말기와 스마트폰을 연동시켜야 합니다.

블랙박스 설명서에서 커넥티드 모듈에 대한 설명이 부족하여 몇 가지 의구심이 생기는 문제 단계에 진입했습니다.

  • 검색 결과에 따르면, 이전 제품들에서는 GPS 신호 픽토그램(pictogram)과 네트워크 연결 픽토그램이 각각 표시되는 것 같은데 이 제품은 GPS 신호로 보이는 픽토그램만 계속 점멸됩니다. 네트워크 연결 픽토그램이 나타나지 않으니 커넥티드 모듈 혹은 유심칩 연결에 문제가 있는 건지 모르겠네요.
  • 설명서에 따르면 몇 분 내에 네트워크에 연결된다고 하는데 생각보다 꽤 걸리더군요. 아마 지하 주차장에서의 통신 상황이 여의치 않아 그럴 수 있겠다는 생각이 듭니다.
  • 등록하라는 팝업 창이 나타났는데 확인을 누르니 다시 이전 상태로 돌아 갑니다. 여전히 네트워크 연결 픽토그램이 보이지 않아서 네트워크에 연결된 건지 알기 어렵습니다. 

등록은 아이나비 커넥티드 앱에서 진행해야 합니다.

아이나비 커넥티드 앱을 스마트폰에 설치하고 로그인하면 위와 같이 등록할 수 있는 메뉴가 나타납니다. 블랙박스 등록 버튼을 누르면 유심칩에 기재된 전화번호(?)를 입력해 등록을 진행할 수 있습니다. 등록 절차는 스마트 폰에서 요청하고 블랙박스 디스플레이에서 확인하는 블루투스 같은 프로세스입니다.

블루투스와 확실히 다른 점(?)은 근거리가 아닌 원거리 통신 프로토콜(NB-IoT)을 쓴다는 점이죠.  

 

여기서 블랙박스의 다양한 사용사례(?)에 대한 의문점들이 떠오릅니다.

  • 블랙박스 등록 시, 앱에서 로그인한 계정만 블랙박스에 연결할 수 있는가? 다시 말하면 여러 계정이 하나의 블랙박스를 공유할 수 없나?
  • 블랙박스 등록 계정을 해지하고 다시 등록할 수 있는가?
  • 블랙박스의 촬영 데이터 사용자 구분 및 개인정보 보호가 가능한가?  

첫 번째, 패밀리 카처럼 운전자가 두 명 이상일 경우, 가족 계정이라는 개념이 필요합니다. 즉, 사건 사고  발생 시 알람을 공유할 수 있으면 보다 빠른 조치가 가능할 것으로 보입니다.

반면 두 번째는 사용 중인 블랙박스를 재판매하거나 이전하는 경우입니다. 스마트폰이 그러하듯 여기에도 초기화라는 개념이 필요합니다.

세 번째는 앞서 든 두 가지의 사례의 확장인데 운전정보보호 개념입니다. 운전 중에 블랙박스로 촬영된 영상이 동선을 노출하기 때문에 프라이버시에 민감한 분들을 위해 이를 보호할 방법이 필요합니다. 더불어 앞서 다중 운전자의 사례처럼 기존의 영상 구분 방법 외에도 운전자에 따라 촬영 데이터가 분리될 필요성도 있습니다. 

쓰다보니 많이 엇나간 듯 하지만 한줄 정리하면, 커넥티드 기기가 되면, 기존에 없던 사용 사례들이 가능해지고 이에 따른 고려사항들이 생긴다는 것입니다. 유선 전화기와 데스크톱 PC에서 진화하여 스스로는 못 움직이지만 움직이게 된 스마트폰 역시 그런 과정을 통해 오늘에 이른 것입니다.

 

스마트폰, 블랙박스와 통하다.

 

다시 사용기로 돌아와서, standard 버전에서는 위와 같이 블랙박스 전원 on/off 버튼, 차량 배터리 전압 표시, 그리고 현재 날씨 정보가  제공됩니다. '나의 주행'이나 '실시간' 감시와 같은 고급(?) 기능은 pro 버전을 쓰라고 되어 있고요. 그리고 standard 버전은 충격이나 충돌 이벤트 시 전면 카메라의 스틸샷(still shot)이 핸드폰에 전송됩니다. 문을 닫았을 뿐인데도 충격 이벤트가 오네요. 정밀도(precision)보다 재현율(recall)에 맞춰 셋팅된 것으로 보입니다. 아무래도 블랙 박스를 달았는데 사건 사고 발생 시에도 기록이 없다면 소송감(?)일테니 말이죠. 

 

스마트 폰 앱은 pro 버전 사용자의 사용자 경험에 최적화한 것 같습니다. 차라리 standard 버전을 기준으로 설계하고 pro 버전은 별도 앱 혹은 옵션에서 확장할 수 있도록 하는게 낮지 않을까 싶네요. 나를 기준으로 맞춰주세요.  

차량에 설치된 블랙박스의 기능과 UI는 크게 도드라지지도 떨어지지도 않는 것 같습니다. full HD 영상이지만 디스플레이의 터치 반응 속도도 빨라서 블랙박스에서도 빠르게 촬영된 이벤트들을 검토해볼 수 있었습니다.

 

지금까지 긴 글 읽어 주셔서 감사합니다. 총평은 자잘한 아쉬움(?)이 있긴 하지만 오래된 아이나비 브랜드에 걸맞는 완성도를 보여준다고 할 수 있을 것 같네요. 더욱 진화되어 connectable이 connnected one에서 connected all이 되면 좋겠네요.  

역설적이게도 보험처럼 돈 낭비(?)가 되겠지만 부디 아무런 사건 사고 없이 블랙박스를 뒤질 일 없이 안전 운행하길 기원해 봅니다.  

     

  

p.s. 앞서 밝힌 것과 다르게 글을 쓰는 동기가 순수하지만은 않아 늦었지만 양심 고백(?)합니다. 사실 예약구매 사은품 조건으로 후기 작성 시 주유권(충전도 가능) 제공 이벤트가 있길래 이렇게 후기도 아닌데 서둘러 글을 썼네요. 놀랍게도!! 이벤트 담당자 분께서 업데이트 약속을 믿고 미리 모바일 상품권을 보내 주셨습니다!!! ㅠ.ㅠ 따라서, 전 아니지만 다른 유명 블로그들처럼 이 포스트는 아이나비의 사은품 후원을 받았음을 밝힙니다.         

  1. 노란콩 2020.06.25 14:34

    너무 잘 봤습니다. 차가 너무 멋지네요 ㅎㅎ

피아노를 하나 산 김에 구매 후기를 남기려 블로그에 글을 쓰기 시작합니다.

(로그인을 하니 휴먼계정이라고 나와서 일년 넘게 로그인조차 안한 방치 블로거였음을 깨닫습니다. ^^;)

 

저는 어릴 적 부모님 등쌀에 못이겨 피아노를 배우긴 했으나 숙련을 위해 반복하는 것을 힘들어서 서둘러 포기했었습니다.

음악을 매우 좋아하지만 잘 하지 못해서 "연주는 하는 것이 아니라 듣는 것"으로 여기며 살아왔습니다.

그래서 피아노라는 물건은 정작 제겐 필요없었습니다. 

 

시간이 흘러 마냥 어릴 것 같았던 제 아이들도 커서 피아노를 배우기 시작했습니다.   

첫째인 딸 아이가 피아노 학원을 다니면서 익힌 자신의 연주(?) 실력을 보여주며 집에서도 더 연습하고 싶다는 의지를 피력하길래 몇차례 아내의 요구에도 미뤄두었던 피아노를 저질렀습니다.

 

가격, 방음 및 공간의 문제 등으로 피아노보다 디지털 피아노를 우선적으로 고려했지만, 그럼에도 불구하고 피아노의 감성(생김새, 울림, 키 감 등)은 갖추길 원했습니다. 아이가 원하는 깔끔한 색깔을 제공하는 모델인 것도 중요한 요소였습니다. 따라서, 가격대가 조금 비싸더라도 계속 치고 싶은 피아노를 구매하려고 했습니다.

 

이번에 구매한 KAWAI CN-27 디지털 피아노(Premium Satin White 모델)는 입문용 수준이지만 피아노의 감성을 충분히 표현하는 제품으로 보였습니다. 특히 피아노 키감을 흉내내기 위해 적용한 RH-III 건반 구조는 역학적으로도 매우 흥미로웠습니다. 실제 눌러보았을 때 느껴지는 감성은 "진정한 터치, 아름다운 사운드, 감동적인 기능, 뛰어난 품질"이라는 선전문구 같이 진정 피아노처럼 동작하는 피아노이길 바라는 마음이 구현된 디지털 피아노가 아닌가 싶습니다.

 

처음 살펴본 100만원 이하 모델들은 가격을 낮추기 위해 피아노라기 보다 키보드의 느낌이 나는 구성이지만 이 제품은 피아노의 외관과 의자, 키 터치감 및 페달까지 피아노의 감성을 완벽하게 구현하고 있습니다.

 

 

 

제가 피아노를 칠 수 없기 때문에 내장된 체르니 악보를 자동 연주 시킨 것을 핸드폰으로 촬영해 보았습니다.

영상의 소리가 좋지 않아서 음성 녹음으로 저장한 파일도 첨부해 봅니다. 궁금하신 분은 들어보세요.       

cn-27_auto_play.m4a
0.26MB

 

마지막으로 딸 아이가  연습하는 장면입니다.

 

딸아이가 아빠와는 다르게 스스로 원하는 연주하면서 소소한 행복함을 느끼기를 희망합니다.

제게 그랬듯 음악이 인생의 좋은 동반자가 되어주길 소망합니다.   

 

자세한 구매 관련 정보는 http://peacemusic.kr/product/detail.html?product_no=4392&cate_no=832&display_group=1 를 참고하시기 바랍니다.

 

자녀에게 혹은 스스로에게 음악을 선물해주고픈 분들에게 조금이나마 도움이 되는 후기가 되었기를 바랍니다.

읽어주셔서 감사합니다. 

안녕하세요.

정말 오랫만에 블로그를 업데이트하네요. 


이번에 소개하는 논문인 조건부 뉴럴 프로세스(CNP)는 구글 딥마인드 팀에서 ICML 2018에 제출한 논문으로써 기존 Gaussian Processes 가 kernel engineering이 필요한 반면 CNP는 이 제약이 없이 데이터셋에 내재된 특성을 학습하여 확률 모델링(probabilistic modeling)을 수행할 수 있어 베이지안 최적화 (Bayesian Optimization)을 위한 방법으로 사용할 수 있을 것이라는 기대를 가지고 읽은 논문입니다.


읽고 보니 이 방법은 요즘 관심이 집중되고 있는 연구주제인 '메타러닝 (meta-learning)'과 일맥상통하며 논문의 실험에도 메타러닝에 사용된 데이터셋이 벤치마크로 사용되었더군요.  

아래 튜토리얼 코드는 논문을 쉽게 이해할 수 있도록 제공한 노트북으로 코드를 자세히 이해하는 차원에서 한글로 번역해 보았습니다.

관심있는 분들에게 도움이 되길 바랍니다.   





Copyright 2018 Google LLC

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


1차원 회귀 문제를 위한 조건부 뉴럴 프로세스 (CNP)

Conditional Neural Processes (CNPs)는 Generative Query Networks (GQN) 의 일환으로 장면 표현방식(scene rendering)을 넘어서 자체의 훈련 방식을 확장한 문제들 (예, 회귀/분류 문제)에 적용하기 위해 등장했습니다.

단 하나의 함수를 근사(approximate)하는 일반적인 뉴럴넷과 다르게 CNP는 함수들의 분포를 근사하기 위해 학습합니다. 그 결과, 평가 시에 CNP는 적은 수의 관찰 결과들을 제공했을 때 학습된 분포에서 어떤 함수나 근사할 수 있게 됩니다. 더불어, CNP는 데이터셋에서부터 이런 예측이 가지는 불확실성을 평가할 수 있도록 학습하고 관찰 수가 증가하게 되면 이 불확실성은 줄어들고 예측력이 향상됩니다.

여기서는 CNP가 어떻게 다른지를 설명하고 결과 모델을 랜덤 함수들로 생성한 데이터셋으로 학습한 1차원 회귀 문제에 적용해 봅니다.

CNP에 대한 궁금한 점이 있거나 이 문서에 대한 피드백이 있다면 garnelo@google.com 으로 연락주시기 바랍니다..

CNP 구현

먼저 이 코드를 수행하기 위해 필요한 패키지들(numpy, tensorflow, mathplotlib 등)을 임포트합니다.

In [0]:
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import collections

학습 데이터

CNP의 가장 핵심 요소는 테스트 시점에서의 유연성입니다. 이 알고리즘은 모든 범위의 함수들을 모델링할 수 있고 관찰 데이터 수가 증가하면 알고리즘의 예측 범위를 줄여 갑니다.이 데이터셋으로 CNP 학습 방식의 결과로써 이런 행태가 나타날 것입니다.

보편적인 기계학습에서 그렇듯 한 함수에서 얻은 관찰 값들을 사용해서 학습하기 보다는 내재된 특성을 공유하는 서로 다른 함수들을 구성해서 만든 데이터를 사용할 예정입니다. 위의 그림은 이를 도식화한 것입니다. 왼쪽 그림은 전통적인 학습 방식에 관련된 그림인데, 회색 선은 한 개의 내재된 정답 함수(a single underlying ground truth function)을 나타내고, 여러 다른 색으로 표시한 점들은 매번 학습할 때마다 이 함수에서 나온 적은 수의 샘플들을 표현한 것입니다.

오른쪽 그림은 뉴럴넷을 학습할 때 사용할 수 있는 데이터셋의 예시를 보여줍니다. 이 데이터셋에는 함수 하나 대신에 모델링하기를 원하는 함수 클래스에 속한 많은 수의 함수들로 구성되어 있습니다. 매 반복(iteration)마다, 데이터셋에서 임의로 하나의 함수를 선택하고, 학습하기 위해 그 함수에서 관찰 값 몇 개를 뽑습니다. 그리고 다음 반복 시점에는 이 함수를 되돌려 놓고 데이터셋에서 새로운 함수 하나를 뽑은 후 학습 데이터를 선택하기 위한 새로운 함수로 사용합니다. 이런 데이터셋의 형태는 모델이 특정 함수에 과적합(overfit)되지 않도록 막고, 그 대신 함수들의 분포를 학습하게 됩니다. 또한 이런 계층적인 데이터셋 아이디어가 현재의 메타러닝 방법들의 핵심에 맞닿아 있습니다.

다음과 같은 데이터셋들이 예시가 될 수 있습니다:

  • 세계 여러 도시들의 시간에 따른 온도 변화를 표현하는 함수들
  • 다양한 인간의 걸음 걸이에 대해 모션 캡쳐로 생성한 데이터셋
  • 이 예시처럼 어떤 한 커널을 이용해 가우시안 프로세스(GP)로 생성한 여러 함수들

이 예시에서는 GP를 선택해서 데이터를 만들었는데 이 방식은 어떤 내재적인 특성들(여기에서는 커널 함수)을 공유하는 부드러운 곡선들을 샘플링하기 쉬운 방식으로 구성되어 있기 때문입니다. 덧붙여 이 예제를 위한 데이터 생성 이외에 뉴럴넷으로 구현되는 뉴럴 프로세스는 커널 또는 GP를 이용하지 않습니다.

데이터 생성기

다음 장에는 함수들의 데이터셋을 생성하기 위해 GP로 학습 및 평가 데이터셋을 생성하기 위한 코드를 제공합니다. 다음에 설명하겠지만, CNP는 매 반복마다 두 가지의 부분집합을 사용하는데 하나는 문맥(context)을 제공하기 위함이고 남은 하나는 목표(target)를 위함입니다. 우리는 새로운 추가적인 데이터 값들로써 문맥 정보 값을 목표 값과 함께 포함시키는 것이 실질적으로 훈련에 도움이 되는 것을 발견했습니다. 이 데이터 생성기는 이렇게 생성 데이터를 두 집단으로 나누고 올바른 포멧으로 제공합니다.

In [0]:
# The CNP takes as input a `CNPRegressionDescription` namedtuple with fields:
#   `query`: a tuple containing ((context_x, context_y), target_x)
#   `target_y`: a tesor containing the ground truth for the targets to be
#     predicted
#   `num_total_points`: A vector containing a scalar that describes the total
#     number of datapoints used (context + target)
#   `num_context_points`: A vector containing a scalar that describes the number
#     of datapoints used as context
# The GPCurvesReader returns the newly sampled data in this format at each
# iteration

CNPRegressionDescription = collections.namedtuple(
    "CNPRegressionDescription",
    ("query", "target_y", "num_total_points", "num_context_points"))


class GPCurvesReader(object):
  """Generates curves using a Gaussian Process (GP).

  Supports vector inputs (x) and vector outputs (y). Kernel is
  mean-squared exponential, using the x-value l2 coordinate distance scaled by
  some factor chosen randomly in a range. Outputs are independent gaussian
  processes.
  """

  def __init__(self,
               batch_size,
               max_num_context,
               x_size=1,
               y_size=1,
               l1_scale=0.4,
               sigma_scale=1.0,
               testing=False):
    """Creates a regression dataset of functions sampled from a GP.

    Args:
      batch_size: An integer.
      max_num_context: The max number of observations in the context.
      x_size: Integer >= 1 for length of "x values" vector.
      y_size: Integer >= 1 for length of "y values" vector.
      l1_scale: Float; typical scale for kernel distance function.
      sigma_scale: Float; typical scale for variance.
      testing: Boolean that indicates whether we are testing. If so there are
          more targets for visualization.
    """
    self._batch_size = batch_size
    self._max_num_context = max_num_context
    self._x_size = x_size
    self._y_size = y_size
    self._l1_scale = l1_scale
    self._sigma_scale = sigma_scale
    self._testing = testing

  def _gaussian_kernel(self, xdata, l1, sigma_f, sigma_noise=2e-2):
    """Applies the Gaussian kernel to generate curve data.

    Args:
      xdata: Tensor with shape `[batch_size, num_total_points, x_size]` with
          the values of the x-axis data.
      l1: Tensor with shape `[batch_size, y_size, x_size]`, the scale
          parameter of the Gaussian kernel.
      sigma_f: Float tensor with shape `[batch_size, y_size]`; the magnitude
          of the std.
      sigma_noise: Float, std of the noise that we add for stability.

    Returns:
      The kernel, a float tensor with shape
      `[batch_size, y_size, num_total_points, num_total_points]`.
    """
    num_total_points = tf.shape(xdata)[1]

    # Expand and take the difference
    xdata1 = tf.expand_dims(xdata, axis=1)  # [B, 1, num_total_points, x_size]
    xdata2 = tf.expand_dims(xdata, axis=2)  # [B, num_total_points, 1, x_size]
    diff = xdata1 - xdata2  # [B, num_total_points, num_total_points, x_size]

    # [B, y_size, num_total_points, num_total_points, x_size]
    norm = tf.square(diff[:, None, :, :, :] / l1[:, :, None, None, :])

    norm = tf.reduce_sum(
        norm, -1)  # [B, data_size, num_total_points, num_total_points]

    # [B, y_size, num_total_points, num_total_points]
    kernel = tf.square(sigma_f)[:, :, None, None] * tf.exp(-0.5 * norm)

    # Add some noise to the diagonal to make the cholesky work.
    kernel += (sigma_noise**2) * tf.eye(num_total_points)

    return kernel

  def generate_curves(self):
    """Builds the op delivering the data.

    Generated functions are `float32` with x values between -2 and 2.
    
    Returns:
      A `CNPRegressionDescription` namedtuple.
    """
    num_context = tf.random_uniform(
        shape=[], minval=3, maxval=self._max_num_context, dtype=tf.int32)

    # If we are testing we want to have more targets and have them evenly
    # distributed in order to plot the function.
    if self._testing:
      num_target = 400
      num_total_points = num_target
      x_values = tf.tile(
          tf.expand_dims(tf.range(-2., 2., 1. / 100, dtype=tf.float32), axis=0),
          [self._batch_size, 1])
      x_values = tf.expand_dims(x_values, axis=-1)
    # During training the number of target points and their x-positions are
    # selected at random
    else:
      num_target = tf.random_uniform(
          shape=(), minval=2, maxval=self._max_num_context, dtype=tf.int32)
      num_total_points = num_context + num_target
      x_values = tf.random_uniform(
          [self._batch_size, num_total_points, self._x_size], -2, 2)

    # Set kernel parameters
    l1 = (
        tf.ones(shape=[self._batch_size, self._y_size, self._x_size]) *
        self._l1_scale)
    sigma_f = tf.ones(
        shape=[self._batch_size, self._y_size]) * self._sigma_scale

    # Pass the x_values through the Gaussian kernel
    # [batch_size, y_size, num_total_points, num_total_points]
    kernel = self._gaussian_kernel(x_values, l1, sigma_f)

    # Calculate Cholesky, using double precision for better stability:
    cholesky = tf.cast(tf.cholesky(tf.cast(kernel, tf.float64)), tf.float32)

    # Sample a curve
    # [batch_size, y_size, num_total_points, 1]
    y_values = tf.matmul(
        cholesky,
        tf.random_normal([self._batch_size, self._y_size, num_total_points, 1]))

    # [batch_size, num_total_points, y_size]
    y_values = tf.transpose(tf.squeeze(y_values, 3), [0, 2, 1])

    if self._testing:
      # Select the targets
      target_x = x_values
      target_y = y_values

      # Select the observations
      idx = tf.random_shuffle(tf.range(num_target))
      context_x = tf.gather(x_values, idx[:num_context], axis=1)
      context_y = tf.gather(y_values, idx[:num_context], axis=1)

    else:
      # Select the targets which will consist of the context points as well as
      # some new target points
      target_x = x_values[:, :num_target + num_context, :]
      target_y = y_values[:, :num_target + num_context, :]

      # Select the observations
      context_x = x_values[:, :num_context, :]
      context_y = y_values[:, :num_context, :]

    query = ((context_x, context_y), target_x)

    return CNPRegressionDescription(
        query=query,
        target_y=target_y,
        num_total_points=tf.shape(target_x)[1],
        num_context_points=num_context)

조건부 뉴럴 프로세스

CNP에서의 전방 학습 경로(forward pass)를 다음과 같이 표현할 수 있습니다:

drawing

위의 도식에서 표현된 것처럼 CNP는 문맥 데이터 값인 (x, y)i 쌍을 인코더(encoder) 를 통과시키고 통합기(aggregator)를 이용해 결합시킨 후, 독립적인 표현 값(representations) ri를 얻습니다. 결과적으로 표현된 r에는 목표 값 xT 의 위치가 섞여서 목표 위치에서 현재 예측치에 대한 불확실성에 대한 측정치로써 y의 평균 예측 값을 함께 반환하는 디코더(decoder) 를 지납니다.

따라서 CNP를 구현하는 것은 크게 세 가지 구성요소를 개발하는 것입니다:

  • 인코더
  • 통합기
  • 디코더

이 세 부분에 대한 상세한 설명은 아래의 코드와 함께 있습니다.

인코더

모든 맥락 데이터들 사이에 인코더 e 가 공유되어 있고 이 인코더는 작은 층 수를 지닌 다층 퍼셉트론(MLP)으로 구성되어 있습니다. 이 예제에서는 4층으로도 충분하지만, 코드에서는 나중을 위해 encoder_output_sizes 변수를 통해 그래프를 만드는 시점에서 계층의 수를 바꿀 수도 있습니다. 각각의 문맥 쌍 (x, y)i 은 인코딩 이후 개개의 표현 값 ri의 결과로 나타납니다. 이 표현 값들을 통합기 a를 이용해 모든 문맥 값들을 아울러 하나의 표현 값 r으로 결합됩니다.

여기에서는 통합기 a 를 인코더에 포함시켜서 구현했는데, 모든 데이터들의 평균을 취하는 것만 고려했기 때문입니다. 통합기가 생성한 표현 값 r에는 모든 문맥 데이터 값들에 의해 제공되어진 숨겨진 익명함수 f 에 관한 정보를 가지고 있습니다.

In [0]:
class DeterministicEncoder(object):
  """The Encoder."""

  def __init__(self, output_sizes):
    """CNP encoder.

    Args:
      output_sizes: An iterable containing the output sizes of the encoding MLP.
    """
    self._output_sizes = output_sizes

  def __call__(self, context_x, context_y, num_context_points):
    """Encodes the inputs into one representation.

    Args:
      context_x: Tensor of size bs x observations x m_ch. For this 1D regression
          task this corresponds to the x-values.
      context_y: Tensor of size bs x observations x d_ch. For this 1D regression
          task this corresponds to the y-values.
      num_context_points: A tensor containing a single scalar that indicates the
          number of context_points provided in this iteration.

    Returns:
      representation: The encoded representation averaged over all context 
          points.
    """

    # Concatenate x and y along the filter axes
    encoder_input = tf.concat([context_x, context_y], axis=-1)

    # Get the shapes of the input and reshape to parallelise across observations
    batch_size, _, filter_size = encoder_input.shape.as_list()
    hidden = tf.reshape(encoder_input, (batch_size * num_context_points, -1))
    hidden.set_shape((None, filter_size))

    # Pass through MLP
    with tf.variable_scope("encoder", reuse=tf.AUTO_REUSE):
      for i, size in enumerate(self._output_sizes[:-1]):
        hidden = tf.nn.relu(
            tf.layers.dense(hidden, size, name="Encoder_layer_{}".format(i)))

      # Last layer without a ReLu
      hidden = tf.layers.dense(
          hidden, self._output_sizes[-1], name="Encoder_layer_{}".format(i + 1))

    # Bring back into original shape
    hidden = tf.reshape(hidden, (batch_size, num_context_points, size))

    # Aggregator: take the mean over all points
    representation = tf.reduce_mean(hidden, axis=1)

    return representation

디코더

표현 값 r 를 학습을 통해 얻은 후 각각의 목표 값 xt 를 합쳐서 디코더 d를 통해 전달합니다. 인코더 e 처럼 모든 목표 데이터 값들 사이에 디코더 d가 공유되어 있고 이 디코더는 decoder_output_sizes 변수로 계층 수가 결정되는 작은 MLP로 구성되어 있습니다. 디코더는 모든 목표 값들 xt에 대한 평균 μt 과 분산 σt을 출력합니다. 예측된 평균 μt과 분산 σt으로 결정되는 가우시안 (Gaussian)에서의 정답 값 yt의 로그 우도 (log likelihood)를 사용해 CNP를 학습합니다. 여기 구현된 버전은 붕괴 현상(collapsing)를 막기 위해 분산 σt 를 0.1에서 잘라 버립니다.

In [0]:
class DeterministicDecoder(object):
  """The Decoder."""

  def __init__(self, output_sizes):
    """CNP decoder.

    Args:
      output_sizes: An iterable containing the output sizes of the decoder MLP 
          as defined in `basic.Linear`.
    """
    self._output_sizes = output_sizes

  def __call__(self, representation, target_x, num_total_points):
    """Decodes the individual targets.

    Args:
      representation: The encoded representation of the context
      target_x: The x locations for the target query
      num_total_points: The number of target points.

    Returns:
      dist: A multivariate Gaussian over the target points.
      mu: The mean of the multivariate Gaussian.
      sigma: The standard deviation of the multivariate Gaussian.
    """

    # Concatenate the representation and the target_x
    representation = tf.tile(
        tf.expand_dims(representation, axis=1), [1, num_total_points, 1])
    input = tf.concat([representation, target_x], axis=-1)

    # Get the shapes of the input and reshape to parallelise across observations
    batch_size, _, filter_size = input.shape.as_list()
    hidden = tf.reshape(input, (batch_size * num_total_points, -1))
    hidden.set_shape((None, filter_size))

    # Pass through MLP
    with tf.variable_scope("decoder", reuse=tf.AUTO_REUSE):
      for i, size in enumerate(self._output_sizes[:-1]):
        hidden = tf.nn.relu(
            tf.layers.dense(hidden, size, name="Decoder_layer_{}".format(i)))

      # Last layer without a ReLu
      hidden = tf.layers.dense(
          hidden, self._output_sizes[-1], name="Decoder_layer_{}".format(i + 1))

    # Bring back into original shape
    hidden = tf.reshape(hidden, (batch_size, num_total_points, -1))

    # Get the mean an the variance
    mu, log_sigma = tf.split(hidden, 2, axis=-1)

    # Bound the variance
    sigma = 0.1 + 0.9 * tf.nn.softplus(log_sigma)

    # Get the distribution
    dist = tf.contrib.distributions.MultivariateNormalDiag(
        loc=mu, scale_diag=sigma)

    return dist, mu, sigma

모델

이제 지금까지 정의한 CNP의 세 가지 구성요소(인코더, 디코더, 통합기)를 하나의 모델로 조립해 봅시다. 근본적으로 이 모델은 오직 두 가지 주된 방법만 포함하면 됩니다:

  1. 목표의 예측 모델 내의 숨은 진리(ground truth) 값의 로그 우도를 반환하는 방법인데 이 방법을 훈련 과정에서 손실 함수(loss function)으로 취급할 것입니다.
  2. 테스트 시점(test time)에서 CNP를 질의하거나 평가하기 위해서 목표 지점에서의 예측 평균과 분산을 반환하는 방법입니다. 이 방법은 앞서 언급한 방법과 다르게 숨은 진리 목표 값에 의존하지 않아야 해서 따로 정의될 필요가 있습니다.
In [0]:
class DeterministicModel(object):
  """The CNP model."""

  def __init__(self, encoder_output_sizes, decoder_output_sizes):
    """Initialises the model.

    Args:
      encoder_output_sizes: An iterable containing the sizes of hidden layers of
          the encoder. The last one is the size of the representation r.
      decoder_output_sizes: An iterable containing the sizes of hidden layers of
          the decoder. The last element should correspond to the dimension of
          the y * 2 (it encodes both mean and variance concatenated)
    """
    self._encoder = DeterministicEncoder(encoder_output_sizes)
    self._decoder = DeterministicDecoder(decoder_output_sizes)

  def __call__(self, query, num_total_points, num_contexts, target_y=None):
    """Returns the predicted mean and variance at the target points.

    Args:
      query: Array containing ((context_x, context_y), target_x) where:
          context_x: Array of shape batch_size x num_context x 1 contains the 
              x values of the context points.
          context_y: Array of shape batch_size x num_context x 1 contains the 
              y values of the context points.
          target_x: Array of shape batch_size x num_target x 1 contains the
              x values of the target points.
      target_y: The ground truth y values of the target y. An array of 
          shape batchsize x num_targets x 1.
      num_total_points: Number of target points.

    Returns:
      log_p: The log_probability of the target_y given the predicted
      distribution.
      mu: The mean of the predicted distribution.
      sigma: The variance of the predicted distribution.
    """

    (context_x, context_y), target_x = query

    # Pass query through the encoder and the decoder
    representation = self._encoder(context_x, context_y, num_contexts)
    dist, mu, sigma = self._decoder(representation, target_x, num_total_points)

    # If we want to calculate the log_prob for training we will make use of the
    # target_y. At test time the target_y is not available so we return None
    if target_y is not None:
      log_p = dist.log_prob(target_y)
    else:
      log_p = None

    return log_p, mu, sigma

그림 함수 (Plotting function)

PLOT_AFTER 반복 시마다 중간 예측치를 그리는 함수를 정의합니다. 숨은 진리 곡선은 검은 점선으로 표시되고 모델에 투입되는 문맥 값들은 이 곡선 상의 검은 점들처럼 표현됩니다. 모델의 예측 평균과 분산은 -2와 2 간격 사이의 목표 값들의 범위를 위해 파란색으로 표시됩니다.

In [0]:
def plot_functions(target_x, target_y, context_x, context_y, pred_y, var):
  """Plots the predicted mean and variance and the context points.
  
  Args: 
    target_x: An array of shape batchsize x number_targets x 1 that contains the
        x values of the target points.
    target_y: An array of shape batchsize x number_targets x 1 that contains the
        y values of the target points.
    context_x: An array of shape batchsize x number_context x 1 that contains 
        the x values of the context points.
    context_y: An array of shape batchsize x number_context x 1 that contains 
        the y values of the context points.
    pred_y: An array of shape batchsize x number_targets x 1  that contains the
        predicted means of the y values at the target points in target_x.
    pred_y: An array of shape batchsize x number_targets x 1  that contains the
        predicted variance of the y values at the target points in target_x.
  """
  # Plot everything
  plt.plot(target_x[0], pred_y[0], 'b', linewidth=2)
  plt.plot(target_x[0], target_y[0], 'k:', linewidth=2)
  plt.plot(context_x[0], context_y[0], 'ko', markersize=10)
  plt.fill_between(
      target_x[0, :, 0],
      pred_y[0, :, 0] - var[0, :, 0],
      pred_y[0, :, 0] + var[0, :, 0],
      alpha=0.2,
      facecolor='#65c9f7',
      interpolate=True)

  # Make the plot pretty
  plt.yticks([-2, 0, 2], fontsize=16)
  plt.xticks([-2, 0, 2], fontsize=16)
  plt.ylim([-2, 2])
  plt.grid('off')
  ax = plt.gca()
  ax.set_axis_bgcolor('white')
  plt.show()

조건부 뉴럴 프로세스 수행

지금까지의 과정을 통해 데이터셋 뿐 아니라 모델 및 그 구성요소들로 그래프를 만들 수 있는 모든 것이 준비되었습니다. 하지만, 학습을 시작하기 전에 몇 가지 변수들을 더 설정해야 합니다:

  • TRAINING_ITERATIONS - 학습 과정에서 얼마나 많은 횟수의 반복을 할 지를 결정. 매 반복마다 GP를 통해 함수들의 새로운 한 묶음(batch)를 샘플링해서 곡선의 일부 값들을 문맥 값 (x, y)C으로 선정하고 또 다른 일부는 목표 값 (x, y)T 으로 선정합니다. 주어진 문맥 하에서 목표 값들의 평균과 분산을 예측하고 모델을 개선하기 위해 손실 값으로 진리 값의 로그 우도를 이용합니다.
  • MAX_CONTEXT_POINTS - 훈련 과정에서 사용할 문맥 값들의 최대 갯수를 결정 . 문맥 값들의 갯수는 매 반복마다 3과 MAX_CONTEXT_POINTS 사이의 임의의 값을 고르게 됩니다.
  • PLOT_AFTER - 중간 결과 값을 얼마나 자주 그릴지를 결정.
In [0]:
TRAINING_ITERATIONS = int(2e5)
MAX_CONTEXT_POINTS = 10
PLOT_AFTER = int(2e4)
tf.reset_default_graph()

훈련 데이터와 테스트 데이터 모두를 위해 데이터셋 리더(dataset reader)를 그래프에 포함시켰습니다. 앞서 언급한 것처럼 데이터셋은 이 실험을 위해 매 반복마다 GP에서 새로 추출한 함수 값들로 구성되어 있습니다. 이 경우에 훈련 데이터와 테스트 데이터의 주된 차이는 실험 셋에는 예측을 위해 적은 수의 목표 값들만을 포함시켰으나 테스트 셋에는 모든 곡선을 그릴 수 있도록 더 많은 목표 값들을 포함시켰다는 것입니다.

In [0]:
# Train dataset
dataset_train = GPCurvesReader(
    batch_size=64, max_num_context=MAX_CONTEXT_POINTS)
data_train = dataset_train.generate_curves()

# Test dataset
dataset_test = GPCurvesReader(
    batch_size=1, max_num_context=MAX_CONTEXT_POINTS, testing=True)
data_test = dataset_test.generate_curves()

이제 그래프에 모델을 추가하고 초기화 루틴(initializer)과 훈련 반복 횟수 (train step)를 정해서 마무리 합니다.

In [0]:
# Sizes of the layers of the MLPs for the encoder and decoder
# The final output layer of the decoder outputs two values, one for the mean and
# one for the variance of the prediction at the target location
encoder_output_sizes = [128, 128, 128, 128]
decoder_output_sizes = [128, 128, 2]

# Define the model
model = DeterministicModel(encoder_output_sizes, decoder_output_sizes)

# Define the loss
log_prob, _, _ = model(data_train.query, data_train.num_total_points,
                       data_train.num_context_points, data_train.target_y)
loss = -tf.reduce_mean(log_prob)

# Get the predicted mean and variance at the target points for the testing set
_, mu, sigma = model(data_test.query, data_test.num_total_points,
                     data_test.num_context_points)

# Set up the optimizer and train step
optimizer = tf.train.AdamOptimizer(1e-4)
train_step = optimizer.minimize(loss)
init = tf.initialize_all_variables()

이제 모델을 훈련시킬 모든 준비가 끝났습니다! 아래 코드는 훈련 과정 중에 중간 예측 값들의 일부를 출력해서 어떻게 모델이 변해 가는지 볼 수 있게 했습니다.

PLOT_AFTER 반복 시마다 예측 분포 하에서 진리 목표 값의 로그 우도에 해당하는 손실 값을 출력하였습니다. 모델이 학습된다면 이 손실 값은 줄어들어야 합니다. 더불어, 진리 곡선에 비교하여 이 반복 지점에서의 CNP가 만들어낸 맥락 데이터 값들과 모델의 예측력을 도식화하게 됩니다.

In [0]:
with tf.Session() as sess:
  sess.run(init)

  for it in range(TRAINING_ITERATIONS):
    sess.run([train_step])

    # Plot the predictions in `PLOT_AFTER` intervals
    if it % PLOT_AFTER == 0:
      loss_value, pred_y, var, target_y, whole_query = sess.run(
          [loss, mu, sigma, data_test.target_y, data_test.query])

      (context_x, context_y), target_x = whole_query
      print('Iteration: {}, loss: {}'.format(it, loss_value))

      # Plot the prediction and the context
      plot_functions(target_x, target_y, context_x, context_y, pred_y, var)
Iteration: 0, loss: 1.58132648468
Iteration: 20000, loss: 0.670665860176
Iteration: 40000, loss: 0.211461827159
Iteration: 60000, loss: 0.109301753342
Iteration: 80000, loss: 0.259903162718
Iteration: 100000, loss: 0.342098742723
Iteration: 120000, loss: -0.0120964311063
Iteration: 140000, loss: 0.0102357501164
Iteration: 160000, loss: 0.538827002048
Iteration: 180000, loss: 0.111666142941


  1. guest 2020.06.25 13:59

    큰 도움이 되었습니다.
    감사합니다 ㅎㅎ

  2. guest 2020.06.25 14:00

    우와 너무 설명이 잘 되어 있네요 ㅎㅎ
    감사합니다!!

+ Recent posts