이 글에서는 Pytorch Docker를 생성하고 실행하는 방법을 정리한다.

Ctrl + F로 원하는 명령어를 검색하면 좋다.

기본 설명

여러 개의 Python 프로젝트에 참여하다 보면 각 프로젝트에서 사용하는 Python과 라이브러리들의 버전이 다른 경우가 대부분이다. 그래서 많은 경우 가상환경(python venv 또는 conda 등)을 사용하여 각 프로젝트의 환경을 분리하고는 하는데, Python을 여러 버전을 설치하기 곤란한 경우나 환경을 완전히 분리하고 싶은 경우에는 Docker(도커)를 사용할 수 있다.

Docker는 간단히 Container 기반의 Open-Source 가상화 플랫폼 정도로 정의할 수 있다. Container는 외부와 격리된 공간(파일 통신이 가능하긴 하지만, 일단 넘어가자)이며 내부에서 프로세스를 수행할 수 있다.

Docker를 사용하는 것은 마치 윈도우에서 가상머신을 돌리는 것과 비슷하다. 사실상 완전히 분리된 환경으로 동작하며, 한 환경에 설치된 라이브러리나 프로그램이 다른 환경에 아무런 영향을 미치지 못한다. 두 환경 간의 통신은 지정된 명렁어를 통해서만 가능하다.
참고: 엄밀히 말해서 가상머신과는 다르다. 가상머신은 추가적인 OS를 설치하여 가상화하는 방법인데, 이러한 방식은 Docker에 비해 추가적인 비용이 더 들기 때문에 실제 프로젝트 환경에서 쓰기에는 부적절하다.

Docker의 기본 사용법은 다음과 같다.

1. 필요한 세팅이 되어 있는 Docker Image를 인터넷에서 다운로드한다. 예: Pytorch Docker Image List
2. 다운받은 Docker Image로 새 Container를 생성한다. (같은 이미지로 여러 Container를 생성할 수 있다.)
3. 생성한 Container를 구동시키고(띄우고) 접속한다.
4. 필요한 Python 라이브러리를 마저 설치하고 사용 가능!

즉, 이미지 다운 → Container 생성 → 사용 순서를 따른다. 참 쉽죠?

설치 및 다운로드

Docker 설치

최신 Ubuntu라면 기본으로 설치되어 있는 경우가 많은 것 같긴 한데… 아니더라도 걱정할 필요는 없다.

curl -fsSL https://get.docker.com/ | sudo sh

password를 입력하고 기다리면 설치가 완료될 것이다.

Ubuntu가 아니라면 Windows나 Mac을 참고해보자.

최소 19.03 이상의 버전으로 설치하면 된다.

TroubleShooting

이 부분은 위의 설치가 안 되는 환경에서 설치방법을 다룬다.
이전 버전의 docker가 존재해서 문제가 되는 경우가 있는데, 이것들을 삭제하고 재설치하는 방법을 알아본다.

참고로 이전 버전의 docker는 docker, docker.io, docker-engine, 최신 버전은 docker-ce라고 한다.

먼저 삭제를 진행하자.

sudo apt-get remove docker docker-engine docker.io containerd runc

다음 코드를 터미널에 순차적으로 입력하자.

sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common

sudo apt-get update
# Docker official GPG key 추가
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
# 결과: OK

sudo apt-key fingerprint 0EBFCD88

# 결과
pub   4096R/0EBFCD88 2017-02-22
      Key fingerprint = 9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid                  Docker Release (CE deb) <docker@docker.com>
sub   4096R/F273FCD8 2017-02-22

docker repository를 추가하자.

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

ModuleNotFoundError: No module named 'apt_pkg' 에러가 뜨면 Python 기본 버전을 잠시 바꿔줬다가 해보자.

update-alternatives  --set python3  /usr/bin/python3.5
# 결과: update-alternatives: using /usr/bin/python3.5 to provide /usr/bin/python3 (python3) in manual mode

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

root@vicman2:/home/ywjang# update-alternatives  --set python3  /usr/bin/python3.6
# 결과: update-alternatives: using /usr/bin/python3.6 to provide /usr/bin/python3 (python3) in manual mode

경우에 따라 3.5 대신 다른 버전일 수 있다. sudo update-alternatives --config python3로 버전을 확인해보거나 기본값을 바꿔보자.

이제 설치를 진행하자.

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

특정 버전 설치는 apt-cache madison docker-ce로 버전을 확인 후 sudo apt-get install docker-ce= docker-ce-cli= containerd.io와 같이 설치하자.

설치 확인은 다음 hello_world를 실행해서 확인해보자.

sudo docker run hello-world

Nvidia Toolkit 설치

Container에서 GPU를 정상적으로 잘 사용하려면 nvidia toolkit를 설정해 주어야 한다.
아래 다섯 줄만 터미널에서 실행해 주자.

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

2번째 줄에서 OK가 출력되고, 3번째 줄에서 deb 어쩌구 하는 메시지가 여러 줄 나온다. 4번째는 update와 설치가 진행되고, 5번째 줄은 docker를 재시작한다.

Docker 권한 설정

Docker를 사용하려고 하면 root 권한이 (거의) 항상 필요하다. 매번 sudo를 입력하는 것은 상당히 귀찮기 때문에 현재 접속한 user에게 권한을 주자.

sudo usermod -aG docker $USER # 현재 접속중인 사용자에게 권한주기
sudo usermod -aG docker gorio # gorio 사용자에게 권한주기

재부팅하면 권한 설정이 완료된다.

sudo reboot

이제부터 docker를 쓸 때는 sudo docker 대신 docker라고만 해도 된다.

Docker Image 다운로드

사용할 수 있는 Docker Image를 찾으려면 다음 사이트를 확인하면 된다. 이미 다운받을 곳을 알고 있다면, 해당 사이트에서 진행하자.

• Docker Hub : 웬만한 건 여기에 있다고 보면 된다.
• Pytorch : 사실 Docker Hub에 포함된다.
• Docker Registry : 직접 해 보자.

# Pytorch 최신 버전의 Docker를 받고 싶으면 아래과 같이 하자.
docker pull pytorch/pytorch:latest
# 사실 아래처럼 써도 똑같은 이미지를 받을 수 있다. 기본 tag가 latest이기 때문.
docker pull pytorch/pytorch

# Tags 탭을 누르면 여러 버전의 Docker Image를 볼 수 있다. 원하는 버전을 받아 보자.
docker pull pytorch/pytorch:1.9.0-cuda10.2-cudnn7-runtime

이미지의 이름은 <Repository> : <Tag> 의 형식을 갖는다. pytorch/pytorch가 repository 이름이고, tag는 latest가 하나의 예시이다.

참고로 CUDA 버전에 맞는 PyTorch 버전을 포함하는 Docker Image를 다운받아야 한다. 여기나 여기를 참고하면 된다.

다운받은 Image 확인

Image를 다운받았으면, 어떤 Image를 받았는지 확인해보자. 지금까지 다운받은 모든 Image들이 표시된다.

docker images

# 결과
REPOSITORY        TAG                             IMAGE ID       CREATED        SIZE
pytorch/pytorch   1.9.0-cuda10.2-cudnn7-runtime   3850639cdf7a   5 days ago     4.42GB
pytorch/pytorch   latest                          5ffed6c83695   2 months ago   7.25GB

Image 삭제

docker rmi <image_id>

이미 해당 이미지로 생성한 컨테이너가 있다면 다음과 비슷한 에러가 뜨면서 삭제가 되지 않는다.

Error response from daemon: conflict: unable to delete bd58e1ea5cd2 (must be forced) 
- image is being used by stopped container fc69401afaf6

컨테이너를 전부 제거하고 이미지를 삭제하거나, 아예 컨테이너까지 강제 삭제하려면 다음과 같이 쓰면 된다.

docker rmi -f <image_id>

모든 image를 삭제하는 방법도 있다. 물론 복구는 되지 않는다.

docker rmi $(docker images -q)

None(untagged) Image 조회 및 삭제

docker를 빌드할 때 오류 등으로 완전히 진행되지 않으면 <none> image가 생성되기도 한다. 이를 조회하고 삭제하는 방법은 다음과 같다.

docker images -f "dangling=true" -q

검색된 id를 위의 Image 삭제 명령어로 실행해도 되지만, 한 번에 삭제하는 방법이 있다.

docker rmi $(docker images -f "dangling=true" -q)
# 해당 이미지로 이미 컨테이너가 생성되었다면 -f 옵션을 쓰자.
docker rmi -f $(docker images -f "dangling=true" -q)

삭제에 관한 조금 더 자세한 내용은 여기를 참조해도 좋을 것 같다.

Container 생성 및 실행

Container 실행하는 걸 Container를 띄운다고 표현하기도 한다.

우선 Container를 Image로부터 생성해보자.

Container 생성 및 실행

docker run -it --gpus all --name prj_gorio pytorch/pytorch:1.6.0-cuda10.1-cudnn7-devel /bin/bash

# 결과
root@fcdd07478fdf:/workspace# 

위의 결과는 Container를 만들고, /bin/bash가 바로 실행되어 Container 내부에서 터미널이 열려 있는 상태라고 생각하면 된다.

옵션을 살펴보자. Ubuntu를 좀 다뤄봤으면 대충만 봐도 알 수는 있겠지만.

Container 생성 옵션

위에서 사용한 옵션을 대략 설명하면 아래와 같다.

옵션은 순서 변경이 가능하지만, Image와 실행 프로세스는 마지막에 두자.

참고 19.03 이하 버전에서는 nvidia-docker 버전에 따라 아래처럼 사용한다. nvidia-docker v2에서는 --gpus all 대신 --runtime=nvidia를 사용한다. nvidia-docker v1은 --runtime=nvidia 또는 --gpus all 명령줄 플래그 대신 nvidia-docker 별칭을 사용한다.

추가 옵션을 더 줄 수도 있다. 은근히 많으니 공식 문서를 참조하자.

Container 작동 확인

Python 라이브러리와 PyTorch GPU 사용이 가능한지 확인해 보자.

pip freeze
python -V
python

import torch

# GPU check
torch.cuda.is_available()

# GPU 정보 확인
torch.cuda.get_device_name(0)

# 사용 가능한 GPU 개수
torch.cuda.device_count()

# 현재 GPU 번호
torch.cuda.current_device()

# device 정보 반환
torch.cuda.device(0)

# 결과:
True
'TITAN Xp'
2
0
<torch.cuda.device object at 0x7f015b7f6610>

nvidia-smi는 잘 작동하는데 torch.cuda.is_available()이 안 된다면 CUDA 버전과 PyTorch 버전이 안 맞을 확률이 높다. 다른 Docker Image를 사용하자.

실행중인 Container 확인

docker ps

# 결과
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

실행 중인 Container가 없으면 위처럼 별다른 정보가 나오지 않는다.

모든 Container의 리스트 확인

실행중인 Container 말고도 종료된 것까지 모두 보여준다.

docker ps -a

같은 명령어에 -a 옵션만 주면 된다. --all과 같은 의미인 것은 아마도? 알 것이다.

Container 검색

생성된 모든 컨테이너 중 특정한 Container 종류만 검색하려면 필터 옵션을 쓰면 된다.
아래 예시는 최신 pytorch docker image로 생성한 container들을 검색한다.

docker ps -a --filter ancestor=pytorch/pytorch:latest

Container 생성 후 volume 추가하는 방법

원래 생성할 때 연결하는 것이 기본이고, 안타깝게도 현재로서는 이미 생성된 docker에 간단히 volume을 추가할 수는 없다.

실수로 volume을 추가하는 것을 docker 생성 시 까먹었다면 해결할 수 있는 방법은 2가지다.

1. 어차피 연결하기 전에 수정한 사항은 그리 많지 않을 가능성이 크므로 그냥 새로 만든다.
2. 다음 코드를 실행한다.

docker commit <container-id> <newname>
docker run -ti -v <dir_in_somewhere>:/<dir_in_container> <newname> /bin/bash

• <container-id>는 docker ps -a 명령을 통해 volume을 추가하고자 하는 container id를 확인한다.
• docker commit은 아래에서 설명하겠지만 container를 통째로 저장하는 명령이다.
• <newname>은 생성할 container 백업의 이름인데 대문자는 사용 불가능하다.
• 그리고 <dir_in_somewhere>, <dir_in_container>은 각각 원하는 docker 밖 directory, docker 안 directory 경로를 지정하면 된다.

Container 관리

Container 이름 변경

실수로 --name 옵션을 안 쓰고 생성해서 임의의 이름으로 생성되었거나 이름이 마음에 안 들면 Container 이름을 간단히 바꿀 수 있다.

docker rename <old-name> <new-name>

Container 띄우기

생성 시 실행하는 것 말고, 종료 상태의 Container를 시작하려면 docker start <docker-name>과 같이 쓴다.

docker start prj_gorio

Container 접속

위의 명령은 Container를 띄운 것(구동시킨 것)이다. 실제로 접속해서 사용하려면 attach를 사용해야 한다.

docker attach prj_gorio

Container 밖으로 탈출

이 항목은 Container 생성 시 -it 옵션을 주고 생성했을 때만 가능하다.

Ctrl + P를 누르고 Ctrl + Q를 누르면 Container를 죽이지 않고 탈출할 수 있다.

Container 종료

Container를 완전히 종료하려면(삭제가 아니다!) Ctrl + D를 누르거나 다음과 같이 쓴다.

exit

Container 삭제

docker rm <container-name> [<container-name2>]
# 예시
docker rm prj_gorio
docker rm 503d22a4c01d prj_gorio ...

참고로 모든 container를 삭제하려면 다음과 같이 쓰면 된다.

docker rm -f $(docker ps -aq)

container 필터 검색과 결합하여 사용할 수도 있다.

docker rm -f $(docker ps -aq --filter ancestor=pytorch/pytorch:latest)

Container 내부 설정

Docker Image에 따라 다르지만, 기본적인 App이 설치되어 있지 않은 경우가 있다.

그런 경우에는 다음과 같이 입력하자. sudo는 쓰지 않는다.

apt-get update
apt-get install git vim wget
...

Container $\leftrightarrow$ 외부 파일 복사

docker cp <filename> <container-name>:/<path>/
# 파일명을 바꾸면서 복사하려면
docker cp <filename> <container-name>:/<path>/<filename>
# 디렉토리는 추가 옵션 없이 그냥 쓸 수 있다.
docker cp <directory-name> <container-name>:/<path>/

# 예시
docker cp gorio.py prj_gorio:/run/
docker cp gorio.py prj_gorio:/run/gorio.py
docker cp gorio.py prj_gorio:/preprocess/morio.py
docker cp gorio_test/ prj_gorio:/

Image와 Container를 파일로 저장 & 복원

Image 저장: docker save

Docker image를 tar 파일로 저장하려면 다음과 같이 쓴다.

docker save [option] <filename> [image_name]

# -o 옵션은 파일명을 지정한다.
docker save -o pytorch_latest.tar pytorch/pytorch:latest

Image 로드: docker load

docker save 명령으로 저장한 파일을 다시 Image로 불러오려면 다음과 같이 쓴다.

docker export로 생성한 tar 파일을 docker load로 불러오려고 시도하면 에러가 뜬다.

docker load -i <tar filename>

# 예시
docker load -i pytorch_latest.tar

Container 백업: docker commit -p

현재 생성되어 있는 container를 그 상태 그대로 저장하는 방법은 다음과 같다.

우선 docker commit -p 명령을 이용하여 container를 image로 만든다.

docker commit -p <container-id> <new_image_name>

그리고 위의 docker save -o 명령으로 이미지를 *.tar 파일로 만든다.

만들어진 파일을 다른 곳으로 옮긴 후 docker load -i 명령으로 이미지를 불러오면 된다.

같은 설명을 여기에서도 볼 수 있다.

참고로 8GB 이상의 파일이 있으면 commit이 안되고 Error processing tar file(exit status 1): unexpected EOF 같은 에러가 뜨니 너무 큰 파일은 굳이 container 안에 집어넣지 말고 container 생성 시 공유 옵션(--volume)을 이용하는 편이 낫다.

Container 백업: docker export

생성된 컨테이너를 파일로 저장할 수 있다.

docker export <container_name or conainter_ID> > xxx.tar

# 예시
docker export prj_gorio > gorio.tar

Container 로드: docker import

export 커맨드를 통해 만들어진 tar 파일을 다시 docker image로 생성하는 명령어이다.

docker save로 생성한 tar 파일을 docker import로 불러오려고 시도하면 에러가 뜬다.

docker import <filename or URL> [image name[:tag name]]

# 예시
docker import gorio.tar
docker import gorio.tar pytorch/pytorch:1.6.0-cuda10.1-cudnn7-devel

에러 해결법

• docker: Error response from daemon: could not select device driver "" with capabilities: [[gpu]]. - nvidia-cuda-toolkit을 설치 또는 재설치한다.
• docker: Error response from daemon: failed to create shim task: nvidia-container-cli: requirement error: unsatisfied condition: cuda>=xx.x, please update your driver to a newer version - 설치된 cuda 버전이 docker image가 요구하는 cuda version보다 낮다. cuda 또는 nvidia-driver를 버전 업그레이드한다.

참고

• CUDA 재설치 등의 작업을 수행한 경우 nvidia toolkit 작업을 다시 해 주어야 한다. 여기를 참조하면 된다.

이 글에서는 Baidu에서 만든 모델 시리즈 ERNIE 중 첫 번째(ERNIE: Enhanced Representation through Knowledge Integration)를 살펴보고자 한다.

ERNIE 시리즈는 다음과 같다. 참고로 2번째는 Baidu가 아닌 Tshinghus University에서 발표한 논문이다.

• ERNIE: Enhanced Representation through Knowledge Integration, Yu sun el al., 2019년 4월
• ERNIE 2.0: A Continual Pre-training Framework for Language Understanding, Yu Sun et al., 2019년 6월
• ERNIE-ViL: Knowledge Enhanced Vision-Language Representations Through Scene Graph, Fei Yu et al., 2019년 6월
• ERNIE-Doc: A Retrospective Long-Document Modeling Transformer, Siyu Ding et al., 2020년 12월
• ERNIE 3.0: Large-Scale Knowledge Enhanced Pre-Training For Language Understanding And Generation, Yu Sun et al., 2021년 7월

중요한 부분만 적을 예정이므로 전체가 궁금하면 원 논문을 찾아 읽어보면 된다.

ERNIE: Enhanced Representation through Knowledge Integration

논문 링크: ERNIE: Enhanced Representation through Knowledge Integration

Official Code: Github

초록(Abstract)

Novel Language Representation Model인 ERNIE(Enhanced Representation through kNowledge IntEgration)을 제안한다. BERT가 masking 전략을 쓴 것처럼, ERNIE는 phrase-level masking과 entity-level masking을 포함한 여러 knowledge masking 표현을 학습하도록 설계되었다.

• Phrase-level masking은 conceptual unit으로서 여러 단어로 구성된 전체 phrase를 masking한다.
• Entity-level masking은 여러 단어로 이루어진 entity를 masking한다.

실험 결과는 ERNIE가 자연어 추론, 의미적 유사성, 명명 개체 인식, 감정분석, 질답 등 5개의 중국어 자연어처리 과제에서 SOTA를 능가하였다. 또 cloze test에서 더 강력한 지식 추론 능력을 가진다.

얘가 Ernie이다. ELMo 이후로 세서미 스트리트에 끼워맞추는 게 유행..

BERT가 강력한 파괴력을 가졌던 것처럼, 중국 바이두에서 만든 이 모델을 Ernie 시리즈로 밀고 나간다. GLEU benchmark 등 영어에서도 실험하지만, 만든 곳이 그 곳이니만큼 중국어에 상당 부분 초점이 맞춰져 있다.

1. 서론(Introduction)

이전까지 언어표현 사전학습 모델은 동시에 등장하는 단어들을 바탕으로(co-occurence) 학습을 진행해 왔다. Word2vec 등이 단어표현에서 대표적인 예시이고, ELMo, BERT 등의 연구에서는 여러 전략을 사용하여 단어표현을 발전시키고 downstream task에 더욱 효율적이게 만들었다.

이러한 모델들의 대부분은 단지 문맥 안에서 masking된 단어를 예측하는 방식으로 진행되는데 이는 문장에 대한 사전 지식을 고려하지 않는다. 예를 들어 “Harry Potter is a series of fantasy novels written by J. K. Rowling”이라는 문장에서, Harry Potter는 소설 이름, J.K. Rowling은 작가 이름이다. Harry Potter를 masking해서 지웠을 때 (사람은) 빠진 단어가 무엇인지 쉽게 유추할 수 있지만 모델은 Harry Potter와 J.K. Rowling의 관계를 알지 못하며 예측하지 못한다. 여기서 모델이 만약 사전지식을 더 잘 알 수 있다면, 언어표현을 더욱 유용하게 만들 수 있다고 생각할 수 있다.

이 논문에서, knowledge masking 전략을 사용한 ERNIE를 소개한다. 기본적인 masking 전략에 더해 entity-level masking과 phrase-level masking을 사용한다. Phrase를 하나의 entity로 취급하여 사용하는 방식으로 학습하며 학습 내내 하나의 entity처럼 사용된다. 이 방식으로, entity와 phrase에 대한 사전지식이 암묵적으로 학습된다. ERNIE는 knowledge를 명시적으로 입력받지 않고 암묵적으로 학습하고 더 긴 의미적 의존성을 파악함으로써 더 나은 일반화 및 적응 능력을 가질 수 있다.

학습 비용을 위해서 5가지 중국어 NLP task에서 사전학습을 진행하며, 대부분에서 SOTA 결과를 달성했다.

이 논문의 기여한 바는,

1. Entity와 Phrase를 하나의 unit으로 취급하여 masking하고 학습하는 방식으로 문맥적, 의미적 정보를 암묵적으로 학습하는 새로운 언어모델을 제시하였다.
2. ERNIE는 다양한 중국어 NLP task에서 SOTA 결과를 달성하였고,
3. ERNIE의 코드와 사전학습된 모델을 공개하였다.

2. 관련 연구(Related Work)

Context-independent Representation

단어표현을 연속적인 벡터로 표현하는 방식은 긴 역사를 가지고 있다. 2003년 NNLM에서는 MLP를 사용하여 단어 벡터표현을 학습하였다.
전통적인 방법은 문맥과 독립적으로 학습하는 방식으로 WordVec, Glove 등이 있다. 이들은 대규모 말뭉치를 입력으로 받고 수백 차원 정도의 단어표현을 학습하며 각 단어에 대해 하나의 embedding 표현을 생성한다.

Context-aware Representation

그러나, 문맥을 고려하지 않고서는 완전한 단어표현을 학습할 수 없다. 각 단어는 문맥에 따라서 다양한 의미를 갖기 때문이며 Cove, ELMo, BERT, GPT2 등에서는 문맥을 고려하여 단어표현을 생성하도록 했다.

Heterogeneous Data

다차원적 비지도 데이터에서 사전학습한 의미적 encoder는 전이학습 성능을 높일 수 있다. Universal sentence encoder(Cer et al., 2018), XLM(Lample and Conneau, 2019)이 Wikipedia 등에서 학습하여 여러 MT task에서 좋은 성능을 보였다.

3. Methods

모델의 Transformer encoder는 3.1절, Knowledge Integration은 3.2절, BERT와 ERNIE의 비교는 아래 그림을 참조한다.

BERT는 각 단어를 일정 확률로 masking하고 이를 예측하지만, ERNIE는 단어뿐 아니라 독립체(entity), 구(phrase) 전체를 하나의 unit으로 취급하여 masking한다.

3.1. Transformer Encoder

ERNIE는 GPT, BERT, XLM처럼 multi-layer Transformer를 기본 인코더로 사용한다. Transformer는 self-attention을 통해 각 token의 문맥 정보를 잡아낼 수 있고 문맥적 embedding의 sequence를 생성한다.

중국어 말뭉치를 위해, CJK Unicode range에 있는 모든 문자 주변에 공백을 추가하고 WordPiece tokenizer를 사용하였다. 주어진 token에 대해서 그 입력 표현은 주변 token, segment & position embedding(잘 모르겠으면 BERT 참고)의 embedding을 더하여 구성한다. 첫 번째 token은 [CLS]이다.

3.2. Knowledge Integration

사전지식을 사용하는데, 이를 직접 집어넣지는 않고, entity와 phrase 수준 지식을 통합하기 위해 다단계 knowledge masking 전략을 제안한다. 문장에서 여러 masking 수준은 Figure 2에서 볼 수 있다.

3.2.1. Basic-Level Masking

기본 단위(영어는 한 단어, 중국어는 한 글자)을 학습하는 단계로 15%의 기본 단위를 임의로 masking하고 Transformer는 이를 예측하도록 한다. 여기서는 고수준의 의미 정보를 얻기는 힘들다.

3.2.2. Phrase-Level Masking

여러 단어나 글자를 하나의 개념적 단위로 묶은 것으로 영어는 어휘분석과 chunking, 언어의존적 분할 도구를 사용하여 단어/phrase 정보를 얻는다. 이 단계에서는 한 phrase 안에 속하는 모든 단어(글자)를 한 번에 masking한다. 이를 통해 phrase 정보가 단어 임베딩에 포함된다.

3.2.3. Entity-Level Masking

Name Entity는 사람, 지역, 조직, 상품 등을 포함하며 적절한 “이름”으로 나타내어진다. 추상적이거나 물리적 실체를 가질 수도 있다. 보통 entity는 문장에서 중요한 정보를 갖는다. Phrase 단계와 비슷하게 named entity가 문장에서 어떤 것이 있는지 분석하고 masking할 때는 한 entity 안에 속하는 모든 단어/글자를 한 번에 masking하고 이를 예측하도록 학습한다.

4. Experiments

ERNIE는 비교를 위해 Bert-base와 같은 모델 크기를 갖는다. 12 Encoder layers, 768 hidden units, 12 attention heads를 포함한다.

4.1. Heterogeneous Corpus Pre-training

중국 Wikipedia, Baidu Baike/News/Tieba 말뭉치를 사용하였으며 각 문장 수는 21M~54M이다. 각각 언어모델링의 기초가 되는 백과사전 글과 영화/배우 이름 등에 대한 정보, Reddit과 같은 토론, DLM의 것과 같은 내용을 포함한다. 한자는 번체에서 간체로, 영어는 소문자로 변환하고 17,964개의 공유 유니코드 문자를 포함한다.

4.2. DLM

Dialogue Language Model의 약자로 BERT의 token-position-segment embedding과 비슷한 구조를 가지지만, segment embedding이 2개의 문장을 뜻하는 0, 1이 아닌 multi-turn 대화를 나타내도록 되어 있다(Question-Response-Question 등. QRQ, QRR, …)
이는 ERNIE가 대화에서 암묵적인 관계를 학습할 수 있게 한다.

4.3. Experiments on Chinese NLP Tasks

5가지 task에 대해 진행하였다.

1. 자연어추론: XNLI(Cross-lingual NLI) 말뭉치는 모순, 중립, 함의를 포함하며 중국어 포함 14개 언어 쌍이 있다.
2. Semantic Similarity: LCQMC 데이터셋 사용, 두 문장이 같은 내용(intention)을 포함하는지를 판별하는 task.
3. Name Entity Recognition: Microsoft Research Asia에서 배포한 MSRA-NER 데이터셋 사용. 사람/장소/조직 이름 등을 포함하는 entity를 갖고 있으며 sequence labeling task로도 볼 수 있다.
4. Sentiment Analysis: ChnSentiCorp 데이터셋 사용. 호텔, 책, 전자컴퓨터와 같은 여러 domain의 comment를 포함하며 어떤 문장의 긍정/부정을 평가한다.
5. Retrieval Question Answering: NLPCC-DBQA 데이터셋 사용. 질문에 맞는 답을 선택하는 것이다. 평가 방법은 MRR과 F1 score 사용.

4.4. Experiment results

ERNIE가 모든 task에서 BERT를 능가한다. 중국어 NLP task에서는 SOTA를 찍고, BERT에 비해서 절대오차 1% 이상으로 우세하다. 이러한 이득은 지식 통합 전략에 따른 것이다.

4.5. Ablation Studies

Knowledge Masking 전략의 효과를 알아보기 위해 전체의 10% 학습 데이터를 뽑고, 각 level(word/phrase/entity)의 masking 전략 중 어느 것을 적용하는지에 따라 성능 차이가 좀 난다. phrase와 entity 수준에서 masking을 하는 것이 성능이 더 좋은 것을 볼 수 있다. 전체 데이터셋을 사용하면 10%일 때에 비해 0.8%의 향상이 있다.

DLM을 학습에 포함시키는 경우 그렇지 않은 경우에 비해 0.7%/1.0%의 향상이 있다.

4.6. Cloze Test

Name Entity를 단락에서 제거하고 모델이 이를 추론하는 Cloze test를 진행하였다. BERT는 문장에서 복사하려고 한 반면에 ERNIE는 기사에서 언급된 지식 관계를 기억하고 있다거나(Case 1), BERT는 entity 종류는 맞췄지만 제대로 채우는 데에는 실패했다거나(Case 2,5), 빈 칸을 여러 글자로 채웠지만 의미는 맞추지 못했다거나(Case 3, 4, 6) 하는 예시가 있다. 중국어라서 봐도 잘은 모르겠지만..(ERNIE는 Case 4에서 맞추지는 못했지만 semantic type은 맞췄다고 한다.)

결론(Conclusion)

지식 통합 전략으로 지식을 사전학습 언어모델에 넣는 새로운 방법을 제시했다. 5가지의 중국어 NLP task에서 BERT보다 우수한 성능을 보였으며 지식통합과 사전학습이 언어표현 학습에 모두 도움이 되는 것을 확인하였다.
이후에는 다른 종류의 지식을 의미적 표현모델에 넣는 방법(구문 parsing, 약한 지도학습 등)과 다른 언어에 적용할 방법을 연구한다고 한다.

참고문헌(References)

논문 참조!

본 글에서는 2018년에 발표된 How Powerful are Graph Neural Networks라는 논문에 대한 Review를 진행할 것이다. 본 논문에서는 Graph Neural Network에서 거의 필수적으로 진행되는 Aggregation 과정에서의 문제점을 지적하고 이를 해결할 방법으로 Graph Isomorphism Network를 제시하고 있다.

앞으로 상세히 설명할 Aggregation 과정에서의 문제는 필자 역시 GraphSAGE 기반 알고리즘을 사용하면서 경험적으로 느껴왔던 부분이기에 본 논문에서 제시하고 있는 방법론과 연구 결과는 더욱 의미있게 다가왔다. 논의를 전개하면서 근간으로 사용되는 수학적 이론들은 깊이를 요구하지만, 전반적으로 이야기를 이끌어가는 핵심 아이디어는 굉장히 간단하다. 결국 Graph의 구조적인 특성을 GNN이 더 잘 표현하도록 만들고 싶다는 이야기인 것이다.

참고로 논문에서 직접적으로 언급하고 있는 GraphSAGE에 대해 궁금하다면, 이 글을 참조하면 좋을 것이다.

torch_geomectric을 이용하여 GIN를 사용하는 방법에 대해서 간단하게 Github에 올려두었으니 참고해도 좋을 것이다.

또한 Reddit Data를 이용하여 GIN을 적용하는 예시는 이 글을 참조하면 좋고, Pyspark와 Tensorflow를 이용하여 Bipartite Graph 구조에서 GIN을 적용하는 사례에 대해 참고하고 싶다면 이 곳을 확인해 보아도 좋다.

Graph Isomorphism Networks 리뷰

1. Introduction

GNN은 Neighborhood Aggregation 혹은 Message Passing이라는 반복적인 과정을 수행하여 각 Node의 새로운 Feature 벡터를 형성하기 위해 이웃 Node의 이웃을 통합하게 된다. 이러한 통합이 과정이 k번 수행되고 나면, 그 Node는 변형된 Feature 벡터로 표현될 것이고, 이는 그 Node의 k-hop Neighborhood 안에 존재하는 구조적인 정보를 포착하게 된다.

GNN이 괄목할 만한 성과를 거두어왔던 것은 사실이지만, GNN의 새로운 디자인은 대부분 경험적 직관, 휴리스틱, 혹은 실험에 기반한 것으로 GNN의 특징과 한계점에 대한 이론적인 연구가 부족했던 것을 사실이다. 또한 GNN의 Representional Capacity에 대한 이전의 연구도 제한적이었다.

따라서 본 논문에서는 GNN의 Representational Power에 대해 분석하는 이론적인 프레임워크를 제시할 것이다. 이 프레임워크는 GNN과 Weisfeiler-Lehman Graph Isomorphism Test 사이의 유사성에 기반하여 만들어졌는데, 이 WL Test는 여러 종류의 Graph를 구별할 수 있는 효과적인 테스트 방법으로 알려져 있다.

GNN과 비슷하게, WL Test도 Node가 주어졌을 때, 이 Node의 이웃들의 Feature 벡터를 통합하여 Node Feature 벡터를 반복적으로 업데이트한다. WL Test의 경우 다른 Node 이웃들을 다른 Feature 벡터로 매핑하는 Injective Aggregation Update의 존재로 인해 강력한 효과를 지니게 된다.

이 말이 무엇을 의미하는지 잘 생각해 보아야 하므로 예시를 들어 보겠다. (물론 논문 본문에서 잘 설명하고 있다.)

아래와 같은 Node와 Feature 벡터가 주어졌다고 해보자.

이 때 알라딘 서점과 스타벅스 커피는 사람 A의 이웃 Node이고, 이디야 커피는 사람 B의 이웃 Node라고 생각해보자. 그리고 사람 A와 사람 B의 Feature 벡터를 얻기 위해 GraphSAGE에서 제시한 Mean Aggregation 과정을 진행한다고 해보자.

그렇다면 사람 A의 이웃 Node의 Feature 벡터는 [0.5, 0.5, 0.5]가 될 것이고, 사람 B의 이웃 Node의 Feature 벡터 또한 [0.5, 0.5, 0.5]가 될 것이다. 물론 위 예시에 대해 애초에 Feature 값이 이들을 표현하기에 불충분하다고 생각할 수도 있지만, 충분히 실제 데이터 상에서 나타날 수 있는 예시일 것이다. 어쨌든 위 결과에 따르면 사람 A와 사람 B의 이웃 Feature 벡터는 똑같은 형상을 하게 될 것이고, 이는 학습에 있어서 데이터 소실 혹은 왜곡이라는 문제로 귀결되게 될 것이다.

본 논문에서는 GNN의 Aggregation Scheme이 굉장히 Expressive하고 Injective Function을 모델링할 수 있다면 GNN 또한 WL Test 처럼 굉장히 강력한 Disciminative Power를 지니게 될 것이라고 이야기 하고 있다.

수학적으로 위 인사이트를 공식화하기 위해, 본 논문의 Framework는 먼저 Node가 주어졌을 때, 이 Node의 이웃들의 Feature 벡터를 Multiset, 즉 repeating elements가 존재할 수 있는 집합으로 표현할 것이다. 그러면 GNN에 있는 Neighbor Aggregation이 Aggregation Function over the multiset으로 표현될 수 있을 것이다. 따라서 강력한 Representational Power를 가지기 위해서는 GNN은 다른 multiset을 다른 representation으로 표현할 수 있어야 한다.

본 논문에서는 몇몇 multiset function의 변형 버전과 그들의 discriminative power, 즉 aggregation function이 다른 multiset들을 얼마나 잘 구별할 수 있는지를 이론적으로 분석하였다. 더 disciminative 할 수록, GNN 속에 내재되어 있는 Representational Power는 더 강력할 것이다.

본 논문의 핵심적인 결과는 아래와 같다.

1) GNN은 Graph 구조를 판별하는데에 있어 WL Test 만큼이나 효과적이다.  
2) 위 문장이 성립하기 위해서는 Neighbor Aggregation이나 Graph Readout Function에 관하여 조건들이 필요한데, 본 논문에서는 이를 제시하였다.  
3) 본 논문에서는 GCN이나 GraphSAGE는 구분할 수 없는 Graph 구조에 대해 언급하고, GNN 기반의 모델들이 포착할 수 있는 Graph 구조들에 대해 정확하게 분석하였다.  
4) 본 논문에서는 GIN이라고 부르는 간단한 신경망 구조를 고안하였고, 이 알고리즘이 WL Test 만큼이나 discriminative/representational power를 갖고 있음을 증명하였다.  

2. Preliminaries

이 Section은 GNN의 기본에 관한 것이므로 간단히만 짚고 넘어가도록 하겠다. 자세한 내용은 논문 원본을 참고하면 좋을 것이다.

Graph Neural Networks
GNN은 Graph 구조와 Node Feature $X_v$ 를 활용하여 Node에 대한 Representation 벡터 $h_v$ 혹은 전체 Graph $h_G$ 를 학습하는 것을 목적으로 한다. 현대의 GNN은 이웃의 표현을 통합하여 Head Node의 Feature를 업데이트하기 위해 Neighborhood Aggregation이란 방법을 사용한다. GNN의 k번째 layer는 아래와 같이 표현할 수 있을 것이다.

[a_v^{k} = AGGREGATE^{k} ({ h_u^{k-1}: u \in \mathcal{N}(v) }]

[h_v^{k} = COMBINE^{k} (h_v^{k-1}, a_v^{k})]

$h_v^{(k)}$ 는 Node $v$ 의 $k$ 번째 반복 혹은 layer의 Feature 벡터를 의미하게 된다. 위에서 표기한 Aggregate 및 Combine 함수는 정말로 중요한 부분이다. 이를 어떻게 정의하느냐에 따라 GNN의 디자인과 효과는 굉장히 상이할 수 있다. GraphSAGE에서는 Aggregate 부분을 아래와 같이 정의하고 있다.

[a_v^{k} = MAX( ReLU(W \cdot h_u^{k-1}), \forall u \in \mathcal{N} (v) )]

Combine 부분은 아래와 같이 concatenation 방식으로 정의된다.

[W [h_v^{k-1}, a_v^k]]

GCN에서는 Aggregate 및 Combine 방식을 아래와 같이 통합하여 element-wise mean pooling을 사용하였다.

[h_v^k = ReLU( W \cdot MEAN { h_u^{k-1}, \forall u \in \mathcal{N} (v) \cup { v } } )]

Node Classification의 경우 최종 Layer의 Representation이 예측을 위해 사용되며, Graph Classification의 경우 Readout 함수가 아래와 같이 Node Feature들을 통합하게 된다.

[h_G = Readout ( { h_v^K \vert v \in G } )]

Weisfeiler-Lehman Test
Graph Isomorphism (동형 이성) 문제는 2개의 Graph가 위상적으로 동일한지 판단하는 문제를 의미한다. 이는 굉장히 큰 문제인데, 왜냐하면 아직까지 polynomial-time 알고리즘을 알려지지 않았기 때문이다. 몇몇 극단적인 예시를 제외하고는 WL Test의 경우 Graph의 broad class를 구별하는 효과적인 테스트로 평가받고 있다.

WL Test는 반복적으로 Node의 Label과 이웃을 통합한 후, 이렇게 통합된 label 혹은 이웃을 unique한 새로운 Label로 Hash한다. 이 알고리즘은 만약 일정 수준의 반복 이후 2개의 Graph에 존재하는 Node들의 Label이 달라지게 되면 2개의 Graph는 non-isomorphic 하다고 판단한다.

3. Theoretical Frameworks: Overview

GNN은 반복적으로 Node의 Feature 벡터를 업데이트하여 Network 구조와 다른 이웃 Node의 Feature들을 포착한다. 본 논문에서는 Node Input Feature는 countable universe에서 왔다고 가정할 것이다. 유한한 수의 Graph에 대해 어떠한 고정된 모델 하의 깊은 Layer에 있는 Node Feature 벡터 또한 countable universe에서 왔다. 단순하게 기호를 표현하기 위해, 본 논문에서는 각 Feature 벡터에 대해 고유한 Label을 $a, b, c …$ 와 같이 붙여줄 것이다. 그리고 나서 이들의 이웃 Node의 Feature 벡터로 multiset을 형성할 것이다. 이 때 다른 Node라 하더라도 같은 Feature 벡터를 가질 수 있으므로 같은 element도 여러 번 등장할 수 있다.

Multiset의 정의를 다시 짚고 넘어가기 위해 아래 논문 원본을 참조하면 좋을 것이다.

GNN의 Representational Power를 연구하기 위해, 본 논문에서는 GNN의 2개의 Node를 Embedding 공간 상에서 같은 위치에 매핑할 때를 분석하였다. 직관적으로 이러한 경우가 발생하기 위해서는, 각 Node가 존재하는 subtree 구조가 동일해야 할 것이다. 이 때 subtree 구조는 Node의 이웃에 의해 재귀적으로 정의되므로 이제 논의 주제는, 과연 GNN이 2개의 이웃 집합(Neighborhood)을 같은 Embedding 혹은 Representation으로 매핑할 것인가 하는 문제로 생각해 볼 수 있다.

Maximally Powerful GNN이라면 2개의 다른 이웃 집합(혹은 multisets of feature 벡터)을 같은 Representation에 매핑하지 않을 것이다. 이 때의 Aggregation Scheme은 반드시 Injective해야 한다. 따라서 본 논문에서는 GNN의 Aggregation Scheme을 이 신경망이 표현하는 multiset에 대한 함수의 class로 추상화하고, 이 신경망이 injective multiset function을 표현할 수 있는지 분석할 것이다.

다음 Section에서는 이러한 추론을 바탕으로 가장 강력한 GNN을 소개할 것이다. Section 5에서는 유명한 GNN 변형 버전들에 대해 이야기하고, 이들의 Aggregation Scheme이 내재적으로 injective하지 않고, 그렇기 때문에 덜 powerful하며 Graph의 흥미로운 특징들을 잘 담아내지 못한다는 것을 증명할 것이다.

4. Building Powerful Graph Neural Networks

우리는 Isomorphic Graph는 같은 Representation을 갖고, Non-isomorphic Graph는 다른 Representation을 갖길 원한다. 본 분석에서는 WL Test라는 다소 약한 기준을 통해 GNN의 Representational Capacity를 분석할 것이다.

모든 lemma와 theorem에 대한 증명은 본 논문의 부록에서 찾을 수 있다. 어쨌든, 어떠한 aggregation 기반의 GNN은 다른 Graph를 구별하는 데에 있어서는 WL Test만큼이나 강력해질 수 있다. 다음에 이어질 자연스러운 질문은 정말로 WL Test만큼이나 강력한 GNN이 존재할 것인가 하는 것이다. 아래 Theorem3에 따르면 답은 ‘그렇다’이다. 만약 Neighbor Aggregation 및 Graph-level readout 함수가 injective하다면, 이에 따른 GNN은 WL Test만큼이나 강력할 것이다.

위 이론은 중요하다. 이 부분에 대한 증명은 부록에서 찾아볼 수 있다.

좀 더 Simple하게 바꿔보자. 중요한 것은 Injective Multiset Function은 아래와 같이 표현된다는 것이다.

[\varphi ( \Sigma_{x \in S} f(x) )]

이 때 $\varphi, f$ 는 어떤 비선형 함수이고, $\Sigma$ 부분은 multiset에 대한 합 연산을 의미한다. 예시를 들면 쉽다. 아래 그림을 보면, One-hot 인코딩으로 이루어진 3개의 Node Feature 벡터가 합 연산으로 통합되었을 때, 모든 정보를 보존하고 있는 것을 알 수 있다.

이 때 위 Feature 벡터들이 One-hot 인코딩된 형태가 아니라 연속형 변수들로 구성되어 있다면 이들을 한 번 더 처리하기 위해 다른 과정이 필요할 것이다. 이 다른 과정을 본 논문에서는 MLP로 처리하고 있고, 이에 대해서는 아래 4.1에서 확인할 수 있다.

유한한 수의 집합에 대해, Injectiveness는 함수가 Input의 distinctness를 잘 보존하는지를 특징화한다. 셀 수 없는 집합에 대해서는, 만약 Node Feature가 연속형 변수라면 추가적인 조건이 더 필요하다. 더 나아가 학습된 Feature가 함수의 이미지 속에서 어떻게 가깝게 존재하는지 파악해보면 좋을 것이다. 이 부분에 대해서는 추후 연구로 남겨두고, 본 논문에서는 유한한 수의 집합에 대해서만 다루도록 하겠다.

다른 Graph를 구별하는 것을 넘어서 Graph의 구조적 유사성을 포착하는 GNN의 중요한 특징에 대해 논의해보는 것도 중요하다. WL Test에 존재한는 Node Feature 벡터들은 본질적으로 One-Hot 인코딩되었기 때문에 subtree 사이의 유사성을 잡아내지 못한다. Theorem3을 만족하는 GNN은 반대로 subtree를 저차원 공간에 embed하는 법에 대해 학습함으로써 WL Test를 일반화 할 수 있다. 이 점이 GNN으로 하여금 다른 구조를 판별할 뿐만 아니라 유사한 Graph 구조를 유사한 Embedding에 매핑하고 Graph 구조 간의 의존성을 포착하도록 해준다.

4.1. Graph Isomorphism Network (GIN)

Maximally Powerful GNN에 대한 조건을 수립한 이후, 본 논문에서는 Graph Isomorphism Network: GIN이라는 간단한 구조를 고안하였고, 이 알고리즘은 Theorem3을 만족한다. 이 모델은 WL Test를 일반화하며 따라서 현존하는 GNN 중에서 가장 강한 disciminative power를 지니고 있다.

Neighbor Aggregation을 위한 Injective Multiset Function을 모델링하기 위해, 본 논문에서는 Universal Multiset Function을 신경망과 함께 파라미터화 하는 Deep Multisets 이론을 제안한다. 아래 lemma가 aggregator를 더하는 것이 multiset에 대해 injective & universal한 함수를 표현한다는 것을 말해준다.

Deep Multiset과 Sets 사이의 중요한 구별점이라고 한다면, Mean Aggregator와 같은 특정한 유명 Injective Set Function의 경우 Injective Multiset Function은 되지 못한다는 것이다. lemma5의 Universal Multiset Function를 building block으로 모델링하기 위한 메커니즘으로 Node와 그 이웃의 multiset에 대한 Universal Function을 표현하는 Aggregation Scheme은 Theorem3에 있는 Injectiveness 조건을 만족한다고 생각할 수 있다. 아래 corollary는 이러한 여러 Aggregation Scheme 사이에 존재하는 간결하고 구체적인 formulation을 제공한다.

Universal Approximation Theorem 덕분에 위에서 제시되고 있는 함수 $f, \varphi$ 를 모델링하기 위해서 본 논문에서는 MLP를 사용할 것이다. 실제로 MLP는 여러 함수들의 Composition을 표현할 수 있기 때문에 본 논문에서는 $f^{k+1} \circ \varphi^k$ 를 하나의 MLP로 모델링할 것이다.

잠시 Universal Approximation Theorem에 대해서 짚고 넘어가자. 원본 논문은 이 곳에서 확인할 수 있다.

핵심 내용은 간단하다. 충분히 큰 Hidden Dimensionality와 적절한 비선형 함수를 갖는 1-hidden-layer MLP는 일정 수준의 정확도로 어떠한 연속형 함수도 근사할 수 있다는 것이 본 이론의 내용이다.

최초의 반복에서 만약 Input Feature가 One-hot 인코딩이면 그들의 합 또한 injective할 것이기 때문에 합 연산 이전에 MLP가 필요하지는 않다. 물론 One-hot 인코딩 되어 있지 않거나 연속형 변수가 중간에 끼어 있다면 MLP가 필요할 것이다. $\epsilon$ 의 경우 학습 가능한 파라미터 혹은 고정된 스칼라로 둘 수 있다. 최종적으로 GIN은 Node Representation을 아래와 같이 업데이트하게 될 것이다.

[h_v^k = MLP^k ( (1 + \epsilon^k) \cdot h_v^{k-1} + \Sigma_{u \in \mathcal{N} (v)} h_u^{k-1} )]

효과적인 GNN은 많이 존재하지만 GIN은 굉장히 간단하면서도 굉장히 효과적인 GNN의 대표적인 예라고 할 수 있다.

4.2. Graph-level Readout of GIN

Graph-level의 readout에서 중요한 측면은, 반복 횟수가 증가할 수록 subtree 구조에 따른 Node Representation이 더욱 정제되고 global해진다는 것이다. 충분한 반복이 지속되면 훌륭한 discriminative power를 얻을 수 있지만 때로는 반복을 적정 수준에서 멈췄을 때의 feature가 일반화 측면에서 더 나은 모습을 보이기도 한다.

사실 위 문제는 GNN에서 고질적으로 지적되는 Over-smoothing 문제라고 해석할 수 있다. 이 문제는 사용하는 이웃의 수가 많아지고, GNN의 Layer 깊이가 점점 더 깊어질 수록 Node 임베딩이 서로서로 비슷해지는 경향을 보이는 현상을 말한다.이 문제에 대해서는 추후에 다른 글에서 더욱 상세하게 다루도록 하겠다.

본 논문에서는 모든 구조적인 정보를 활용하기 위해 모델에 존재하는 모든 깊이 및 반복에서 생성된 정보를 활용하였다. 이를 위해서 본 논문에서는 Jumping Knowledge Network와 비슷한 구조를 차용하였다. 본 논문에서는 GIN에 존재하는 모든 반복/Layer 속에서 Readout 방식을 아래와 같이 변형하였다는 차이가 있다. 참고로 앞서 언급한 논문은 이 곳에서 전문을 확인할 수 있다.

[h_G = CONCAT ( READOUT ( { h_v^k \vert v \in G } ) \vert k=0, 1, …, K )]

5. Less Powerful but still interesting GNNs

GNN의 여러 변형 버전들의 경우 WL Test에 비해 단순한 Graph에도 쉽게 오류를 범하고 성능 측면에서도 다소 아쉬운 모습을 보이긴 하지만, GCN에서의 Mean Aggregator의 경우도 Node Classification Task 등에서는 굉장히 잘 작동한다. 이 부분에 대해 더욱 자세히 이해하기 위해 Graph를 학습하는 데에 있어 다른 GNN의 변형 버전들이 어떻게 Graph에 대해 학습하고 정보를 습득하는지 정확히 알아볼 것이다.

5.1. 1-Layer Perceptrons are not sufficient

현존하는 많은 GNN 구조는 1-layer MLP를 사용하고 있다. 그렇다면 이 구조는 Graph 학습에 있어 충분할까? 아래 lemma는 그렇지 않은 경우가 존재한다는 것을 알려준다.

위 내용을 증명할 핵심 아이디어는, 1-layer 퍼셉트론은 linear mapping과 유사하게 작동하기 때문에 GNN layer들이 이웃 Feature들을 단순히 합산하는 수준으로 퇴보할 수 있다는 것이다. 물론 이 때의 이야기는 bias term이 존재하지 않을 때를 가정한 것이고, 만약 bias term이 존재한다면 충분히 큰 output 차원이 전제될 때, 1-layer 퍼셉트론도 다른 multiset을 구분할 가능성이 꽤 높아진다.

그럼에도 불구하고 MLP를 이용한 모델에 비해 1-layer 퍼셉트론은 multiset 함수에 대한 Universal Approximator라고 할 수 없다. 결과적으로 1-layer 퍼셉트론을 이용한 GNN은 어느 수준까지는 다른 Graph를 다른 위치에 Embed 할 수 있지만, 충분히 그 특징을 잡아내지는 못할 수도 있다.

5.2. Structures that confuse mean and max-pooling

만약 $h(X) = \Sigma_{x \in X} f(x)$ 에 있는 합 연산을 GCN이나 GraphSAGE에 있는 Mean 혹은 Max-pooling으로 대체한다면 어떤 일이 발생할까?

Mean/Max-pooling Aggregator는 permutation invariant하기 때문에 여전히 잘 정의된 multiset 함수이지만 결정적으로 이들은 injective하지 않다.

위 그림을 보자. 3가지 방법이 존재할 때 이들의 표현력을 기준으로 순위를 매기면 위와 같은 결과를 얻을 수 있다. 이 때 같은 색의 Node는 같은 Node Feature를 갖는 것을 전제로 한다. 왜 이런 결과가 나오는지 아래 그림을 통해 알아보자.

a, b, c에 있는 Graph들은 모두 다른 구조를 갖고 있지만, 위와 같이 Mean/Max-pooling Aggregator는 다른 구조임을 인지하지 못한다. 이러한 사례가 바로 구조적인 정보를 포착하지 못하는 대표적인 사례가 된다. 반대로 Sum Aggregator는 차이를 인지할 수 있다.

(후략)

6. Other Related Work

(생략)

7. Experiments

본 논문에서는 GIN과 GNN의 여러 변형 버전들의 성능에 대해 평가해보았다. 이 실험의 목적은 모델이 단지 Input Node Feature에 의존하지 않고 Network 구조를 학습하도록 하는 것이다. 본 실험에서 사용한 bioinformatics graph에 대해서는 Node는 Categorical Input Feature를 가지며, Social Network 데이터에서는 feature가 없다. Reddit 데이터셋에서는 모든 feature를 같게 만들어 사실상 의미 없도록 만들었으며, 다른 데이터셋에 대해서는 node degree를 One-hot 인코딩으로 추가하여 Feature를 생성하였다.

참고로 GIN-0은 $\epsilon$ 을 0으로 고정한 모델을 의미한다. 모든 설정에서 Input Layer를 포함하여 총 5개의 layer가 사용되었고 모든 MLP는 2개의 layer를 갖게 하였다. Batch Normalization은 모든 Hidden Layer에 적용되었다. Adam Optimizer가 사용되었고 최초의 Learning Rate은 0.01이고, 50 Epoch이 진행될 때마다 0.5씩 Learning Rate에 decay를 적용하였다.

bioinformatics graph에서는 16, 32의 hidden unit을, social graph에서는 64개의 hidden unit을 사용하였다. Batch Size는 32와 128 중에 선택하였고 Dropout Rate은 0 혹은 0.5를 선택하였다. 그리고 이 Dropout layer는 Dense Layer 이후에 적용되었다.

Training Set Performance
높은 Representational Power를 갖고 있는 모델일수록 Training Set에서의 정확도도 높을 것이다. 아래 그림을 보면 그 결과가 나와 있다.

결과를 보면 GIN-$\epsilon$ 과 GIN-0이 가장 좋은 성과를 보임을 알 수 있다. 본 실험의 결과에 따르면 $\epsilon$ 을 명시적으로 학습하는 것에 있어서 큰 효과는 나타나지 않았다. GNN의 다른 변형 버전들은 상대적으로 낮은 성과를 보였다. 또한 MLP layer가 1-layer 퍼셉트론보다 더 나은 성능을 기록하였다. 그리고 Mean/Max-pooling Aggregator 보다는 Sum Aggregator가 더 나은 결과를 보여주었다.

모든 결과에서 GNN은 WL Test를 넘어서지는 못했는데, 이는 매우 당연한 것이 GNN은 WL Test에 비해 낮은 Discriminative Power를 갖고 있기 때문이다.

Test Set Performance

테스트 셋에서의 결과를 보면 꼭 GIN이 최고의 결과를 보여준 것은 아님을 알 수 있다. 본 논문에서는 분류 성능으로 GNN의 Expressive Power를 가늠해보는 정도라고 이야기하고 있는데, 이 설명은 조금은 아쉽긴 하다. 개인적으로는 추가적인 설명이 더 있었으면 좋았을 것이라는 생각이 든다.

어쨌든 이번 결과에서 보면 GIN-0이 눈에 띄는 성과를 지속적으로 보이고 있음을 알 수 있다. 물론 이는 데이터셋의 특성에 기인한 것일 수 있고, 만약 Head Node의 특성이 풀고자 하는 문제에서 가장 중요한 특성이라면 $\epsilon$ 을 활용하는 것이 더 나은 선택이 될 수 있을 것이다. 실제로 필자가 현실 데이터에서 본 알고리즘을 활용해본 경험에 의하면, User-Item 사이의 Link Prediction을 풀어내는 문제에서는 $\epsilon$ 을 학습하는 것이 분류 성능 자체에 있어서는 더욱 도움이 되었다. (다만 이것이 전반적인 Graph와 Node의 특성을 더욱 잘 학습했다는 결론으로 직접적으로 귀결되는 것은 아니다.) 어쨌든 GIN-0이 전반적으로 더 나은 성과를 보인 것은 흥미로운 부분이다.

8. Conclusion

본 논문에서는 GNN의 Expressive Power에 대한 추론을 위한 이론적인 근간을 마련하였고, 여러 유명한 GNN의 변형 버전들의 Representational Capacity에 대한 엄격한 한계를 증명하였다. 또한 Neighborhood Aggregation Framework 하에서의 가장 powerful한 GNN 구조를 고안하였다.

미래 연구로 흥미로운 방향이 있다면, 지금껏 전제로 삼아온 Neighborhood Aggregation 혹은 Message Passing을 넘어서면서 Graph를 학습하는 powerful한 구조를 만들어 보는 것을 생각해 볼 수 있다. 이를 위해서는 GNN의 최적화 뿐만 아니라 이 네트워크의 일반화 특성을 이해하고 더 개선하는 방향으로 연구가 실행되어야 할 것이다.

References

1) 논문 원본
2) Stanford University CS224W Lecture

본 글에서는 2017년에 발표된 Graph Attention Networks라는 논문에 대한 Review를 진행할 것이다. 다방면에서 적용되는 Attention 개념을 Graph 구조의 데이터에 적용하는 초석을 마련한 논문이라고 할 수 있겠다. 자세한 내용은 논문 원본에서 확인하길 바라며 본 글에서는 핵심적인 부분만 다루도록 하겠다.

torch_geomectric을 이용하여 GAT를 사용하는 방법에 대해서 간단하게 Github에 올려두었으니 참고해도 좋을 것이다.

Graph Attention Networks 리뷰

1. Introduction

CNN은 image classification, semantic segmentation, machine translation 등 많은 분야에 성공적으로 적용되었지만, 이 때 데이터는 grid 구조로 표현되어 있어야 했다. 그런데 많은 분야의 데이터는 이렇게 grid 구조로 표현하기에 난감한 경우가 많다. 3D mesh, social network, telecommunication network, biological network 등이 그 예시라고 할 수 있다. 이러한 데이터는 Graph 구조로 표현할 수 있다.

굉장히 다양한 구조의 Graph를 다루기 위해 신경망을 확장하려는 시도는 지속되어 왔고, 초기 연구는 RNN으로 Graph 구조의 데이터를 다루고자 하였다. Graph Neural Network는 RNN의 일반화된 버전으로 소개되기 시작하였고 이후에 지속적으로 발전을 이어나갔다. 이후의 발전은 크게 2가지로 구분할 수 있을 것이다.

첫 번째는 Graph를 Spectral Representation으로 표현하는 것이다. Graph Laplacian의 eigen decomposition을 계산하는 Fourier domain으로 정의되는 합성곱 연산을 수행하는 것이 대표적인 방법이라고 할 수 있을 것인데, 이 연산을 통해 intense한 연산과 non-spatially localized한 filter를 만들어 낼 수 있다. 이러한 구조의 방법은 좀 더 세부적인 구조와 Feature의 특성을 반영하는데 특화되어 있지만 그 연산의 특성으로 인해, 새로운 구조의 Graph나 새로운 Node에 대해 대응하기 어려운 단점이 있다.

두 번째는 Non-spectral 혹은 Spatial Representaion으로 정의할 수 있겠다. 이는 합성곱을 Graph에 직접적으로 적용하고, spatially close한 이웃 그룹에 대해 연산을 수행하는 방법을 의미한다. 이러한 방법의 대표적인 예시가 바로 GraphSAGE이다. 이 알고리즘에 대해 자세히 알고 싶다면 이 글을 참조하면 될 것이다. 이러한 접근은 굉장히 scale이 큰 데이터에 대해 효과적인 접근으로 평가받고 있다.

위와 같은 최근 연구의 연장선에서, 본 논문에서는 Graph 구조의 데이터에 대해 Node Classification을 수행하기 위해 Attention 기반의 구조를 소개할 것이다. 연산은 효율적이며, 이웃들에 대해 각기 다른 weight을 지정함으로써 다른 degree(Node가 갖는 이웃의 수)를 갖는 Graph Node에 적용될 수 있다는 장점을 지니고 있다. 또한 이 모델은 Inductive Learning Problem에 직접적으로 적용될 수 있기 때문에 이전에 본 적이 없는 Graph에 대해서도 일반화할 수 있다는 큰 강점을 지닌다.

2. GAT architecture

2.1. Graph Attentional Layer

single Graph Attention Layer에 대해 설명할 것인데, 사실 이 layer가 본 논문에 소개된 GAT 구조에서 범용적으로 쓰인다. 본격적인 설명에 앞서 언제나 그렇듯 기호에 대해 잠시 정리하고 진행하겠다.

아래와 같이 표현되는 Node Feature가 존재할 때,

[\mathbf{h} = { \vec{h}_1, \vec{h}_2, …, \vec{h}_N }]

위 $\mathbf{h}$ 행렬은 Layer를 통과한 후 $\mathbf{h}^{\prime}$ 의 형상을 취하게 될 것이며, 그 shape은 $N, F^{\prime}$ 이 될 것이다.

$W = (F^{\prime}, F), \mathbf{a} = (2F^{\prime}, 1)$ 의 shape을 갖고 있을 때 Attention Coeffieicient는 아래와 같이 정의된다.

[e_{ij} = a(\mathbf{W} \vec{h}_i, \mathbf{W} \vec{h}_j)]

위 식은 Node $i$ 에 대해 Node $j$ 의 Feature가 갖는 중요도를 의미한다. 이 때 $j$ 는 모든 Node를 의미하는 것은 아니고 $N_i$ 즉, Node $i$ 의 이웃에 대해서만 계산하게 된다. 최종적으로 softmax 함수를 통과하면 아래와 같은 Normalized Attention Score를 계산할 수 있다.

[\alpha_{ij} = {softmax}j (e{ij}) = \frac{exp(e_{ij})}{\Sigma_{k \in N_i} exp(e_{ik})}]

이전 식에서 $a$ 로 표기되었던 Attention Mechanism은 single-layer feedforward 신경망으로, 아래와 같이 학습 가능한 파라미터와 LeakyRELU activation 함수로 정의할 수 있다.

[\alpha_{ij} = \frac {exp (LeakyRELU ( \vec{a}^T [ \mathbf{W} \vec{h}i \vert \mathbf{W} \vec{h}_j ] )) } { \Sigma{k \in N_i} exp ( LeakyRELU ( \vec{a}^T [ \mathbf{W} \vec{h}_i \vert \mathbf{W} \vec{h}_k ] ) ) }]

이렇게 계산된 Attention Score는 아래와 같이 Node $i$의 이웃의 중요도를 결정하여 Input 데이터를 재정의하게 된다.

[\vec{h}^{\prime}i = \sigma( \Sigma{j \in N_i} \alpha_{ij} \mathbf{W} \vec{h}_j )]

이를 그림으로 나타내면 아래와 같다.

논문에서는 방금 설명한 Self Attention을 좀 더 안정화하기 위한 방법에 대해 상술하고 있는데 그 과정에 대해서는 아래 원문을 참조하길 바란다.

2.2 Comparison to related work

GCN과 달리 GAT는 같은 이웃 집단의 Node에 대해 다른 중요도를 배정하기 때문에 Model Capacity를 개선할 수 있으며 해석에 있어서도 도움을 주게 된다.

Attention Mechanism은 Graph의 모든 Edge에 공유되어 적용되기 때문에 전체 Graph에 대한 접근 없이도 학습이 진행될 수 있으며 이에 따라 Inductive Learning을 가능하게 한다.

GraphSAGE는 각 Node에 대해 고정된 수의 이웃을 추출하기 때문에 계산량을 일정하게 유지하게 되는데, 이는 추론을 행할 때 전체 이웃집단에 대해 접근할 수 없게 만드는 현상을 초래한다. 사실 본 논문에서는 LSTM Aggregator의 성능이 가장 좋았다고 기술하고 있는데, 이는 이웃 집단 내에서 각 이웃사이의 순서가 중요하다는 것을 암시하는 것과 다름이 없다. 만약 다른 Max Pooling Aggregator나 Mean Pooling Aggregator를 사용하였는데, 각 이웃 Node 사이의 순서 혹은 다른 개별적인 특징이 중요하다면, GraphSAGE는 이러한 부분까지는 커버하지 못하는 단점을 지니게 된다. 본 논문에서 제시하는 GAT는 이러한 한계에서 자유로우며 이웃 전체에 대해 접근하면서도 효율적으로 학습을 진행할 수 있다는 장점을 지닌다.

3. Evaluation

(중략)

3.4. Results

실험 결과에 대해서는 논문 원본을 참조하길 바란다.

4. Conclusion

본 논문에서는 Graph Neural Network (GAT)를 제시하였는데, 이 알고리즘은 masked self-attentional layer를 활용하여 Graph 구조의 데이터에 적용할 수 있는 새로운 Convolution-style의 신경망이다.

효율적인 연산과, 각기 다른 이웃 Node에 다른 중요도를 부과할 수 있다는 장점을 지니고 있으며 전체 Graph에 대한 접근 없이도 학습이 가능하기 때문에 Inductive Learning이 가능한 구조이다.

References

1) 논문 원본
2) 이분 그래프에 Attention 적용한 사례

이 글에서는 Python 라이브러리인 time과 datetime에 대해 알아본다. 가끔 쓰는데 막상 쓰려면 언제 봐도 헷갈리는 라이브러리 중 하나인 듯 하다.

추가로 numpy와 pandas에서 사용하는 datetime64에 대해서도 정리한다.

Import

import time
import datetime

공통적으로, strptime()은 str을 datetime 객체로, strftime()은 datetime을 str로 바꿔준다.

time

현재 시각: time.time()

1970년 1월 1일 0시 0분 0초 이후 경과한 시간을 초 단위로 반환한다. 2021년 기준 대략 16억의 값을 가진다.

print(time.time())
# 1620055042.444191

time 객체: time.localtime(secs)

float 형식의 seconds를 입력으로 주면 지역 시간대에 맞는 time 객체로 변환할 수 있다. 입력을 안 주면 현재 시간으로 계산한다.

반환된 값에서 .tm_year 등의 값을 그대로 가져올 수 있다. 연, 월, …, 초, 요일(tm_wday, 일요일=0, 토요일=6), 몇 번째 날짜(tm_yday, 1월 1일=0, 1월 2일=1), 일광 절약 시간(tm_isdst, 미적용=0, 적용=양수, 정보없음=음수)

print(time.localtime())
print(time.localtime(secs=time.time()))
print(time.localtime(time.time()).tm_year)

# result
time.struct_time(tm_year=2021, tm_mon=5, tm_mday=4, tm_hour=0, tm_min=19, 
                 tm_sec=51, tm_wday=1, tm_yday=124, tm_isdst=0)
time.struct_time(tm_year=2021, tm_mon=5, tm_mday=4, tm_hour=0, tm_min=19, 
                 tm_sec=51, tm_wday=1, tm_yday=124, tm_isdst=0)
2021

출력 포맷: time.strftime(format, time object)

datetime에도 비슷한 메서드가 있는데, string format time 정도라고 생각하면 된다.

time 객체가 주어지면 지정한 format으로 출력해준다.

now = time.localtime()
print(time.strftime('%Y%m%d', now))
print(time.strftime('%c', now))
print(time.strftime('%x', now))
print(time.strftime('%X', now))
print(time.strftime('%H%M%S', now))

# result
20210504
Tue May  4 00:41:07 2021
05/04/21
00:41:07
004107

출력 포맷 종류

출력 포맷은 다음과 같은 것이 있다.

datetime

datetime.time은 시간 기능(시, 분, 초, 마이크로초)을, datetime.date는 날짜 기능을(연, 월, 일), datetime.datetime은 날짜+시간을, datetime.timedelta는 시간의 차이를 구한다.

아래에서 소개하는 함수들은 datetime.date, datetime.time, datetime.datetime 모두에서 사용 가능하다.

현재 시각: datetime.datetime.today()

현재 시각 정보를 포함하는 datetime 객체를 반환한다. 연도부터 마이크로초까지 나온다.
물론 각 원소는 .year와 같이 접근할 수 있다.

print(datetime.datetime.today())
print(datetime.datetime.today().year)

# result
datetime.datetime(2021, 5, 4, 0, 44, 5, 707495)
2021

datetime.date.today()로는 현재 날짜를 구할 수 있다.

datetime.date.today() 

# result
datetime.date(2023, 4, 29)

원하는 시각으로 datetime 객체 생성하기

메서드는 다음과 같이 생겼다. 연, 월, 일 등을 지정하여 datetime 객체를 생성할 수 있다.

datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0)

print(datetime.datetime(2021, 12, 25))
print(datetime.date(2021,12,25))

# result
2021-12-25 00:00:00
2021-12-25

문자열로 datetime 객체 생성하기 - strptime

문자열과 그 문자열이 어떻게 생겼는지를 지정하는 format을 같이 주면 datetime 객체가 생성된다.

d = datetime.datetime.strptime('20211225', '%Y%m%d')
print(type(d))
print(d)

# result
<class 'datetime.datetime'>
2021-12-25 00:00:00

datetime을 문자열로 바꾸기 - strftime

today = datetime.datetime.today()
print(today.strftime('%Y-%m-%d %H'))

# result
2023-04-29 21

numpy datetime64

• 날짜 및 시간과 관련된 ISO 8601 국제표준 방식으로 str type의 값을 전달해 생성하거나
• 유닉스 시각(UTC 1970.1.1 자정)부터 경과 시간을 초 단위로 환산해 나타낼 수 있다.
• np의 datetime64는 마이크로초($10^{-6}$)가 아닌 아토초($10^{-18}$)까지 저장한다.
• 단위 코드는 Y, M, W, M, h, m, s, ms, us, ns, ps, fs이다.

str로 생성하기

import numpy as np
np.datetime64('2023-04-29')

# result
numpy.datetime64('2023-04-29')

경과한 시간으로 생성하기

아래는 각각 나노초(ns), 일(Day), 초(second)으로 생성한 결과이다.

np.datetime64(1000, 'ns')
np.datetime64(100000, 'D')
np.datetime64(123456789, 's')

# result
numpy.datetime64('1970-01-01T00:00:00.000001000')
numpy.datetime64('2243-10-17')
numpy.datetime64('1973-11-29T21:33:09')

일련의 날짜 객체 생성하기

np.arange로 범위를 줄 때는 [시작, 끝) 범위로 주고, Day, Month, Year 간격으로 생성할 수 있다.

np.array(['2021-01-01', '2022-01-01', '2023-01-01'], dtype='datetime64')
# np.arange('2010-01-01', '2010-01-03', dtype='datetime64[H]') # TypeError
np.arange('2010-01', '2010-02', dtype='datetime64[D]')
np.arange('2010-01', '2011-09', dtype='datetime64[M]')
np.arange('2010-01', '2012-09', dtype='datetime64[Y]')

# result
array(['2021-01-01', '2022-01-01', '2023-01-01'], dtype='datetime64[D]')

array(['2010-01-01', '2010-01-02', '2010-01-03', '2010-01-04',
       '2010-01-05', '2010-01-06', '2010-01-07', '2010-01-08',
       '2010-01-09', '2010-01-10', '2010-01-11', '2010-01-12',
       '2010-01-13', '2010-01-14', '2010-01-15', '2010-01-16',
       '2010-01-17', '2010-01-18', '2010-01-19', '2010-01-20',
       '2010-01-21', '2010-01-22', '2010-01-23', '2010-01-24',
       '2010-01-25', '2010-01-26', '2010-01-27', '2010-01-28',
       '2010-01-29', '2010-01-30', '2010-01-31'], dtype='datetime64[D]')

array(['2010-01', '2010-02', '2010-03', '2010-04', '2010-05', '2010-06',
       '2010-07', '2010-08', '2010-09', '2010-10', '2010-11', '2010-12',
       '2011-01', '2011-02', '2011-03', '2011-04', '2011-05', '2011-06',
       '2011-07', '2011-08'], dtype='datetime64[M]')

array(['2010', '2011'], dtype='datetime64[Y]')

datetime64 날짜 간격 계산

둘 중 최소 날짜 단위로 계산해준다.

np.datetime64('2023-04-29') - np.datetime64('2021-05-18')
np.datetime64('2023-04') - np.datetime64('2021')

# result
numpy.timedelta64(711,'D')
numpy.timedelta64(27,'M')

Pandas

Timestamp

• Datetimes는 python 표준 라이브러리인 datetime이다. 특정 시점 하나를 지칭한다. (Timestamp)
• 두 개 이상의 배열을 다룰 때는 DatetimeIndex를 사용한다.
• date_range() 함수(또는 ~Index)는 연 또는 월 단위로 인자를 주면 [시작 연/월의 시작일, 끝 연/월의 시작일]범위로 생성해 준다.

import pandas as pd
pd.Timestamp(2323.345689, unit='D')
pd.Timestamp('2023-04-29')

pd.to_datetime('2023-04-29 21')
pd.to_datetime(['2023-04-29', '2023-04-30'])

pd.date_range('2020-02-01', '2020-02-07')
pd.date_range('2020-01', '2020-09')
# pd.date_range('2020', '2023')

# result
Timestamp('1976-05-12 08:17:47.529600017')
Timestamp('2023-04-29 00:00:00')

Timestamp('2023-04-29 21:00:00')
DatetimeIndex(['2023-04-29', '2023-04-30'], dtype='datetime64[ns]', freq=None)

DatetimeIndex(['2020-02-01', '2020-02-02', '2020-02-03', '2020-02-04',
               '2020-02-05', '2020-02-06', '2020-02-07'],
              dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-04',
               '2020-01-05', '2020-01-06', '2020-01-07', '2020-01-08',
               '2020-01-09', '2020-01-10',
               ...
               '2020-08-23', '2020-08-24', '2020-08-25', '2020-08-26',
               '2020-08-27', '2020-08-28', '2020-08-29', '2020-08-30',
               '2020-08-31', '2020-09-01'],
              dtype='datetime64[ns]', length=245, freq='D')

Time spans

• Time spans는 특정 시점이 아닌 기간을 의미한다. 하루 데이터면 0시 0분 0초부터 23시 59분 59초까지이다. 하나면 Period, 두 개 이상이면 PeriodIndex를 사용한다.

pd.Period('2019-01')
pd.Period('2019-04', freq='D')
pd.period_range('2020-01', '2020-02', freq='D')

# result
Period('2019-01', 'M')
Period('2019-04-01', 'D')
PeriodIndex(['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-04',
             '2020-01-05', '2020-01-06', '2020-01-07', '2020-01-08',
             '2020-01-09', '2020-01-10', '2020-01-11', '2020-01-12',
             '2020-01-13', '2020-01-14', '2020-01-15', '2020-01-16',
             '2020-01-17', '2020-01-18', '2020-01-19', '2020-01-20',
             '2020-01-21', '2020-01-22', '2020-01-23', '2020-01-24',
             '2020-01-25', '2020-01-26', '2020-01-27', '2020-01-28',
             '2020-01-29', '2020-01-30', '2020-01-31', '2020-02-01'],
            dtype='period[D]')

Date times와 Time spans의 차이는 아래로 확인할 수 있다.

spans = pd.Period('2023-04-29')
stamp = pd.Timestamp('2023-04-29 12:34')
print(spans.start_time < stamp < spans.end_time)

# result
True

date_range(), period_range() 함수에 freq 인자를 다양하게 넣어줄 수 있다.

pd.date_range('2019-04', '2019-05', freq='B')
pd.date_range('2019-04', '2019-05', freq='W')
pd.date_range('2019-04', '2019-05', freq='W-MON')

# result
DatetimeIndex(['2019-04-01', '2019-04-02', '2019-04-03', '2019-04-04',
               '2019-04-05', '2019-04-08', '2019-04-09', '2019-04-10',
               '2019-04-11', '2019-04-12', '2019-04-15', '2019-04-16',
               '2019-04-17', '2019-04-18', '2019-04-19', '2019-04-22',
               '2019-04-23', '2019-04-24', '2019-04-25', '2019-04-26',
               '2019-04-29', '2019-04-30', '2019-05-01'],
              dtype='datetime64[ns]', freq='B')

DatetimeIndex(['2019-04-07', '2019-04-14', '2019-04-21', '2019-04-28'], dtype='datetime64[ns]', freq='W-SUN')

DatetimeIndex(['2019-04-01', '2019-04-08', '2019-04-15', '2019-04-22',
               '2019-04-29'],
              dtype='datetime64[ns]', freq='W-MON')

주기는 아래와 같은 것들이 있다.

# result

References

• 원문
• 번역본