사실, 비정형 데이터를 분석하는 게 더 재밌고 공부할 부분도 많지만, 내 기준으로 현업에서는 정형데이터를 다루는 경우가 많은 것 같다. 정형 데이터를 처리할 때, 처리 속도가 빠르고, 설명력이 좋은 머신러닝 알고리즘을 선호하는 경우가 많은데, 대표적인 것이 바로 의사결정나무이다.
의사결정나무란?
의사결정나무는 계층적으로 데이터를 분할하면서, 의사 결정 규칙을 학습하여, 데이터 분류와 회귀 분석에 사용할 수 있는 예측 모델이다.
의사결정나무의 가장 큰 장점은 해석력이다. 의사결정나무는 다른 머신러닝 기법들과는 다르게, 직관적으로 분할 규칙을 이해할 수 있다.
의사결정나무는 특성중요도(Feature Importance, 어떤 Feature가 예측에 큰 영향을 미치는지)를 쉽게 파악할 수 있다.
의사결정나무는 일반적으로 연산 cost가 적은 편이다.
의사결정나무는 Overfitting에 취약하다. 따라서, Depth 제한 등을 둬야한다.
또한, 의사결정 나무는 각 분기마다의 최적을 계산하기 때문에, 성능을 조금이라도 더 올려야 하는 Global Optimum을 찾는 문제에 약하다.
CNN의 유형에 다양한 모델이 있듯, 의사결정나무에도 ID3, C4.5, CART, CHARID 등 다양한 알고리즘 등이 존재한다.
의사결정나무 구성요소
의사결정나무에는 Node, Branch, Depth 개념이 있다.
Node : 의사결정나무에서 분할 기준과 그 답(위의 결정 나무 그림에서 박스로 표시되는 부분)
Root Node: 맨 상위에 존재하는 Node
Inter Node : 중간에 존재하는 Node
Terminal or Leaf Node : 맨 마지막, 자식이 없는 node
Branch : 하나의 Node로부터 끝 Node까지 연결된 Node들
Depth : Branch를 이루는 Node의 개수
의사결정나무 기본 원리
의사결정나무의 핵심 아이디어는 각 분기마다, 데이터를 가장 잘 구분할 수 있는 특성을 뽑아서, 데이터를 분할하는 것이다.
즉, 데이터를 분할하는 방식이 매우 중요한데, 이를 위해 불순도(Impurity) 개념을 사용한다.
불순도란 특정 노드 내에 있는 데이터들이 얼마나 서로 다른 클래스 또는 값들을 가지고 있는지를 의미한다. 즉, 현재 분할된 데이터의 집합들이 불순도가 낮다면, 이 데이터를 나누었던 분할과정이 잘 수행되었다고 할 수 있다. (같은 특징만을 가진 데이터끼리 모은 분할이기 때문에)
다만, 단순 불순도를 낮추는 방향으로 학습하면, 이미 잘 분할된 데이터도 계속 분할하는 상태가 발생한다. 이를 예방하기 위해 , 현재 노드의 불순도와 자식 노드의 불순도 차이를 Information Gain이라고 하고, Information Gain이 클수록 좋은 분할 기준이다. (가중 평균 불순도는 왼쪽 자식노드와 오른쪽 자식노드의 불순도를 각 노드의 데이터개수에 대한 가중평균을 통해 합한 값을 의미한다.)
즉, 의사결정나무는 재귀적으로, Information Gain이 큰 방향으로 데이터를 분할하는 과정이다.
불순도 측정
불순도를 측정하는 방법은 크게 3가지가 있다.
Gini 지수 : Gini 수는 무작위로 선택한 데이터의 Class가 오분류되었을 확률을 나타낸다. 전 노드에서 완벽하게 분할되었다면, 불순도가 하나의 class가 p가 1.0이 될 것이고, Gini 지수는 0이 된다.
Entropy : Entropy는 자주 등장하는 개념이어서 익숙할 것이다. 데이터의 혼잡도를 의미한다. 마찬가지로, 전 노드에서 완벽하게 분할되었다면, 하나의 class만 있고, p가 1.0이나 0.0 값이다. 두 경우 모두 식의 값이 0이 되고, (1인 경우는 log항에 의해, 0인 경우는 극한을 생각해 보면 쉽게 이해 간다.) 합인 entropy도 0이 된다.
Variance : 회귀분석에서는 일반적으로 불순도를 분산으로 정의한다.
가지치기 (Pruning)
위의 의사결정나무 과정을 요약하면, Information Gain이 최대가 되는 방향으로 자식노드를 만들어, 데이터를 분할하는 것이다.
다만, 이 경우에는 모든 데이터가 Terminal Node가 되어(Full Tree, 모든 데이터를 고유의 특성으로 각각 분할하여 일반화의 특성이 없어짐) Overfitting이 발생한다.
이를 해결하기 위해, 오히려 분기를 합치는 과정이 필요하다. 가지치기에는 2가지 방법이 있는데, 사전가지치기와 사후가지치기이다.
사전 가지치기 (Pre-Pruning) : 분할하는 조건을 사전에 정의하여, 해당 조건을 만족하지 않으면 더 이상 분할하지 않는다. 한 Node의 데이터 개수가 일정 값 미만이면 분할을 멈추는 등의 방법이 있다.
사후 가지치기 (Post-Pruning) : 우선 full tree를 만들고, 불필요한 Branch를 제거하는 방식. Pruning 후의 예측 성능과 복잡성 사이의 균형을 측정하도록 아래와 같이 Cost를 줌.
의사결정나무 파이썬 구현
의사결정나무는 sklearn을 통해 쉽게 사용 가능하다.
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
if __name__ == '__main__':
# 데이터 불러오기
iris = load_iris()
X = iris.data
y = iris.target
# 의사결정 트리 모델 학습
clf = DecisionTreeClassifier()
clf.fit(X, y)
# 예측
new_data = [[5.1, 3.5, 1.4, 0.2]]
predicted_class = clf.predict(new_data)
print("Predicted class:", predicted_class)
패키지를 설치하다 보면, 의존성이 꼬이는 경우가 많다. 이런 경우, pip install --upgrade를 사용하는 방법도 있지만, 아예 package를 지우고 다시 설치하는 편이 좋은 경우도 있는데, uninstall을 통해 삭제한다.
pip uninstall을 하면, 해당 패키지를 위해 설치되었던, 의존성 있는 라이브러리들은 잔존하게 되는데, 이것은 pip-autoremove를 통해 모두 삭제할 수 있다.
pip uninstall {패키지명}
pip install pip-autoremove #패키지 설치
pip-autoremove {패키지명}
설치 가능한 패키지 조회
기존에는 pip search를 통해, 특정 패키지의 설치 가능한 모든 버전을 확인할 수 있었다.
하지만, 너무 많은 API call이 있어서, 지원을 멈췄다고 한다.
설치 가능한 패키지를 확인하는 방법은 pypi.org(https://pypi.org/)에 접속하여, 직접 검색해 보는 것 밖에 없다. (예전 버전은 pip search {패키지명} 사용하면 된다.)
설치된 패키지 조회
pip list는 현재 환경 (local or 가상환경) 내에 존재하는 패키지들과 각 패키지의 버전을 나열해 준다.
pip freeze도 pip list처럼 설치된 패키지 목록을 출력하지만, requirements.txt를 바로 구성할 수 있는 형태로 출력된다.
따라서, pip freeze를 requirements.txt로 export 하고, 다른 환경에서 install 하면 현재 가상환경의 pypi 패키지들을 그대로 설치할 수 있다. (테스트 환경 구축 시 많이 활용한다.)
pip list
pip freeze
pip freeze > requirements.txt
pip listpip frreze
의존성 확인
계속 언급하듯, pypi 내에서는 의존성이 꼬이는 경우가 많다.(가상환경이 자주 쓰이는 이유이다.)
물론, 설치 시에 의존성에 대한 문제를 제기하겠지만, 당장 실행되면 넘어가는 경우가 많다.
이렇게 의존성이 꼬이는 경우가 많아, 의존성을 check 하기 위한 명령어가 존재하는데, 바로 pip check이다.
pip check
폐쇄망 Pypi 사용법
pypi는 기본적으로 원격 저장소에서 패키지를 가져오는 것이기 때문에, 인터넷 연결이 존재해야 한다.
아예 오프라인 환경이나, 방화벽 등에 의해, 원격 저장소에 접근하지 못하는 환경에서는 단순 pip install을 이용하여 설치가 불가능하다.
우선, 프락시 서버가 있는 경우에는 아래와 같이 proxy 서버를 명시하여 사용할 수 있다.
pip install --proxy {proxy 서버 IP}:{proxy 서버 port} {패키지명}
proxy 서버도 존재하지 않는 경우에는 인터넷 망에서 패키지를 설치하고, 오프라인 환경에서 빌드하여 사용하는 방법을 사용할 수 있다.
우선 인터넷망에서 pip download를 통해, 패키지를 빌드 전 파일로 내려준다.
설치된 파일들을 USB 등을 통해, 폐쇄망 서버로 옮기고, 아래와 같이 --no-index(index 서버를 사용하지 않겠다는 뜻)와 --find-link 명령어를 포함한 pip install 명령어를 통해 설치해 준다.
download를 하나하나 하기 귀찮다면(보통은 의존성 때문에), pip freeze를 이용하여, requirement 형태로 떨군 후, pip download -r requirements.txt를 이용하여, 모든 패키지를 설치하고, 이 패키지를 폐쇄망에서 설치하는 방법도 있다.
(인터넷망) pip download {패키지명}
(폐쇄망) pip install --no-index --find-links={패키지 파일 저장 경로}
NaViT은 Google DeepMind에서 2023년 7월(리뷰 시점에서 1달 전)에 나온 논문이다.
Model 크기에 맞게 Input size를 조정하던 기존의 CNN 구조에서 벗어나, ViT로 다양한 resolution의 input을 학습하고자 하였다.
Abstact
computer vision model에서 이미지 처리 전에 고정된 이미지 resoultion은 최적이 아님에도 불구하고, 보편적으로 사용된다.
ViT 같은 모델은 flexible한 sequence-based modeling을 제공하기 때문에, input sequence 길이를 가변적으로 사용 가능하다.
이 논문에서는 ViT의 특징을 이용한, 학습과정에서 무작위의 resolution과 aspect ratio을 다룰 수 있도록 하는 sequence packing을 사용했다.
이 논문에서는 large-scale의 supervised 및 contrastive image-text pretraining을 통해 모델의 효과성을 보여준다.
또한, 이 모델은 image, video classification이나, object detection, semantic segment등에 transfer 되어, 성능 향상에 사용될 수 있다.
inference time에서, input resolution의 유연성은 time cost와 performance의 trade-off 사이에서 최적을 찾을 수 있게 한다.
Introduction
[배경]
ViT는 간단하고, flexible, scalable 하며, 기존 CNN의 대체로 사용할 수 있다.
ViT는 input image들을 resize 하고, 고정된 aspec ratio의 patch들로 잘라서, 모델의 input으로 사용한다.
최근 고정된 aspect ratio을 사용하는 것을 대체할 방법을 제시하는 논문들이 등장하고 있다.
FliexiViT는 다양한 patch size를 하나의 architecture에서 다룬다. 이것은 각 training step에서 patch size를 random sampling 하고, reszing algorithm이 초기 convolutional embedding이 다양한 patch size를 다룰 수 있게 하기 때문이다. (이 논문도 읽어 봐야겠다.)
[소개]
이 논문에서 다른 이미지들에서의 여러 patch들이, single sequence로 묶여 처리하는 NaViT라는 모델을 소개한다. 논문의 아이디어는 NLP에서 다양한 example들을 singlel sequence로 처리하는 example packing에서 영감을 받았다.
NaViT은 다음과 같은 장점이 있다.
학습 과정에서 training cost를 줄이기 위해, resolution을 randomly sampling 한다.
NaViT는 다양한 resolutons에서 좋은 성능을 보이고, cost-performance가 smooth 한 trade-off를 제공한다.
고정된 batch shape은 aspect-ratio preserving resoltion sampling이나, variable token dropping rates, adaptive computation 등의 새로운 아이디어를 이끈다.
동일한 computational cost 내에서, NaViT는 ViT를 능가하는 성능을 보인다. 이는 NaViT 한정된 computational cost 내에서 더 많은 양의 training example을 처리할 수 있기 때문이다.
향상된 efficiency는 fine-tuning process에서도 이어진다. NaViT는 pre-training과 fine-tuning에서 다양한 resolution으로 학습되었기 때문에, 무작위 resolution으로 평가하였을 때, NaViT는 더욱 효과적이다.
Method
기존 딥러닝 모델들은 fixed 된 이미지 사이즈를 사용한다. 이를 위해, 이미지를 resizing 하거나, padding을 하는데, 성능이 떨어지고, 비효율적이다.
한편, Language Modeling에서는 example packing(다양한 example들을 하나의 sequence에 묶어서 학습을 가속화함)을 이용하여, 고정된 sequence length의 한계를 넘는다.
이 논문에서는 image를 token으로 대하여, ViT도 같은 방법으로 효과를 볼 수 있음을 보여준다. 이를 Patch n'Pack이라 명명한다. 또, 이미지가 native resolution으로 학습될 수 있기 때문에, 이 모델을 NaViT로 명명한다.
[구조 변화]
NaViT는 ViT를 기반으로 만들어졌다. Patch n'Pack을 가능하게 하기 위해, 몇 가지의 구조적 변화를 주었다.
1. Masked self attention and masked pooling
example들이 서로 겹치는 것을 막기 위해, self-attention masked를 추가하였다.
마찬가지로, encode 최상단의 masked pooling은 token을 pooling 하는 것을 목표로 한다. sequence 내의 각 example은 single vector representation으로 표현된다.
2. Factorized & fractional positional embeddings
무작위 resolution과 aspect ratio를 다루기 위해, factorized position embeddings를 제안한다.
factorized position embeddings에서는 embeddings을 x방향과 y방향으로 decomposition 하고, 각각 합해진다.
2개의 스키마를 고려하였는데, absolute embeddings와 factional embeddings이다. 특히, fractional embeddings는 상대적 거리이기 때문에, 이미지 사이즈와 무관하지만, original aspect ratio가 깨질 수 있다.
Token dropping (학습 과정에서 input patch를 무작위로 빼는 것)은 학습을 빠르게 하기 위해 고안되었다.
기존 Token dropping에서는 모든 example들에서 동일한 비율로 token이 drop 되지만, continuous token dropping은 이미지마다 drop 비율이 달라질 수 있다.
이로 인해, 학습이 빨라지고(처리 token 양이 줄기 때문) , 학습 시에 완전 이미지(drop 안 한 이미지)도 같이 학습할 수 있다는 장점이 있다.
2. Resolution sampling
NaViT은 original image의 aspect ratio를 유지하면서, random sampling 된 사이즈를 이용한다.
original ViT에서는 작은 이미지를 통해 throughput이 커지면, performance도 증가하는 특징을 가지고 있다.
NaviT은 다양한 resolution을 학습 시에 사용하기 때문에, 높은 throughput과 큰 이미지로 학습이 모두 포함되기 때문에, original ViT보다 성능 향상을 보인다.
[Efficiency of NaViT]
NaViT의 computational cost에 대한 장이다.
1. Self attention cost
원래 이미지의 patch를 자를수록 computational cost가 매우 증가하지만(quadratic 하게), Transformer의 hidden dimension이 늘리면, computational cost가 original image를 한 번에 처리하는 것보다 아주 조금만 늘어난다.
매우 긴 sequence를 사용하면, memory cost가 많아, 속도가 느려지는 현상이 있는데, memory-efficient 방법을 사용하여 이 문제를 해결하였다.
2. Packing, and sequence-level padding
prediction을 위한 최종 sequence length는 동일해야 한다.
길이를 맞추기 위해, example들을 perfect combination 하는 것이 아닌, fixed length가 되도록, 더해서 맞추거나, padding을 사용한다.
padding 되는 toekn은 전체의 2% 이하이기 때문에, 간단한 방법으로 충분하다.
3. Padding examples and the contrastive loss
per-token loss가 직관적이지만, 많은 computer vision model들은 example 단위의 loss를 구한다.
이를 도입하기 위해서는 example 개수의 max를 정해놓고, 그 이상은 drop 하는 방법을 사용한다. 그런데, 이럼 학습 시에 아무것도 학습하지 않지만, computational cost를 낭비하는 상황이 발생한다.
contrastive learning은 이 상황에 취약한데, time과 memory의 loss computational scale이 quadratic 하게 증가한다.
이를 방지하기 위해, chunked contrastive loss라는 방법을 사용하는데, softmax 계산을 위해 모든 데이터를 모으는 것이 아닌, local device subset에 각각 데이터를 모으고, global softmax normalization을 위한 통계값만 뽑는 형식이다.
이로 인해, 최대 example 수를 늘릴 수 있다.
Experiments
NaViT은 기본적으로 original ViT을 따랐다.
NaViT을 2개 setup으로 학습했다. classification training으로 JFT-4B를 사용했고(sigmoid cross-entropy loss 사용), contrastive language-image training으로 WebLI를 사용(contrastive image-text loss 사용)했다.
FLAX library를 이용했고, JAX로 구현했다.
[Improved Training Efficiency and performance]
동일 computational cost에서 NaViT은 ViT을 능가한다.
동일 성능(Accuracy)을 위해, NaViT은 ViT보다 4배 이상의 빠르게 학습되었다.
[variable resolution의 장점]
variable-resolution pre-training : fixed image로 학습한 최고의 결과도 variable resolution과 동일할 정도로, variable resolution이 우위에 있다.
variable-resolution fine-tuning : variable resolution으로 fine-tuning 한 게 성능이 더 좋고, fine-tuning을 low resolution으로 했더라도, higher resolution에 대한 성능을 유지하는 것을 보여준다.
Reference
Dehghani, Mostafa, et al. "Patch n'Pack: NaViT, a Vision Transformer for any Aspect Ratio and Resolution." arXiv preprint arXiv:2307.06304 (2023).
JAX란, 머신러닝의 연산을 가속화하기 위해, Google에서 발표한 컴파일러를 최적화하는 기술이다.
JAX는 머신러닝에서 필수적인 Autograd와 XLA(integrated with Accelerated Linear Algebra, 가속 선형 대수) 컴파일러를 통해, 머신러닝의 연산을 빠르게 실행해 준다.
JAX는 설치가 매우 쉽고, 기존 Python에서 구현된 Numpy를 쉽게 변환할 수 있어서, 많이 활용되고 있다.
다만 JAX는 구글의 공식 제품이 아닌, 연구 프로젝트 기 때문에, 아직은 이런저런 버그가 있을 수 있다고 한다.
JAX 설치 방법
JAX는 우선 기본적으로 Linux나 Mac 운영 체제에서 동작한다.
Window도 동작하기는 하지만, 실험버전으로 CPU를 활용한 jax만 지원된다. (WSL을 사용하면 GPU를 사용할 수 있긴 하다.)
[CPU 설치]
pip install --upgrade "jax[cpu]"
[GPU & TPU 설치]
GPU에서도 pypi를 통해 쉽게 설치가 가능하다. 하지만, GPU는 Linux 환경에서만 설치되는 것을 명심하자. (나의 경우에는 WSL로 진행했다.)
# CUDA 12
pip install --upgrade "jax[cuda12_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
# CUDA 11
pip install --upgrade "jax[cuda11_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
JAX 기본 기능
jax.numpy
jax는 기본적으로 jax.numpy를 통해, numpy의 API를 그대로 호환해 준다.
jax.numpy와 numpy는 거의 비슷하지만, 차이가 있는데, jax는 함수형 프로그래밍으로 설계되어 있다는 점이다.
즉, numpy는 배열에 직접 접근해서, 값을 바꾸는 것이 허용되지만, jax.numpy는 데이터를 직접 조작하는 것이 허용되지 않는다. → 거의 모든 Python 가속기들의 특징인 것 같다.
다만, 값을 직접 바꾸는 것은 불가능하지만, 해당 요소를 반영한 새로운 배열을 생성할 수 있다.
import jax.numpy as jnp
if __name__ == '__main__':
data = jnp.array([1,2,3,4])
data[0] = 5
# ERROR
data = data.at[0].set(5)
# data = [5,2,3,4]
[grad]
JAX는 native Python 및 numpy 코드를 자동으로 미분할 수 있는 기능을 제공한다.
JAX의 grad 함수는 함수의 입력에 대한 gradient를 자동으로 계산해 주는 함수이다.
JAX의 grad 함수는 loss의 기울기를 구할 때, 매우 빠르고 쉽게 활용될 수 있다.
JAX의 grad는 N차 미분값까지 쉽게 구할 수 있다.
import jax
import jax.numpy as jnp
def square(x):
return x ** 2
if __name__ == '__main__':
grad_square = jax.grad(square)
# Calculate Gradient
x = jnp.array(2.0)
grad_value = grad_square(x)
print("Input:", x)
print("Gradient:", grad_value)
[jit]
jax.jit 함수는 JAX에서 제공하는 함수를 최적화해 주는 메커니즘이다.
jit 함수를 통해, 정의한 함수를 컴파일하여, 최적화된 코드로 변환하고, 이를 Cache에 저장해 둔 뒤, 호출 시, 최적화된 코드를 통해 빠르게 실행된다.
최적화된 Code를 Cache에 저장해 두기 때문에, 반복 변환이나, 불필요한 변환은 피하는 것이 좋다.
다만, jit은 아래와 같은 경우에는 속도 향상이 없거나, 오히려 늦어질 수 있다.
변환하려는 함수 내에 제어문이 포함된 경우
재귀함수
데이터를 조작하는 함수
크고 복잡한 함수 → 변환을 위한 cost가 더 많이 들 수 있음
다른 모듈처럼, jit 사용을 위해, 단순 decorator만 사용해 주면 된다. 하지만, 변환을 위한 cost가 더 많이 들 수 있기 때문에, 꼭 비교해 보고 사용하는 것이 좋다.
import jax
import jax.numpy as jnp
@jax.jit
def square(x):
return x ** 2
if __name__ == '__main__':
grad_square = jax.grad(square)
# Calculate Gradient
x = jnp.array(2.0)
grad_value = grad_square(x)
print("Input:", x)
print("Gradient:", grad_value)
[vmap]
jax.vmap 함수는 함수를 Vector 화하여 mapping 하는 함수이다.
vmap 함수를 통해, 배열의 각 요소에 함수를 병렬로 실행할 수 있다. (pandas의 apply와 비슷한 개념이다.)
jit과 vmap은 같이 사용될 수 있다. (jit을 먼저 래핑 한 후, vmap을 하거나, vmap을 래핑한 후, jit을 하거나 둘 다 가능하다.)
import jax
import jax.numpy as jnp
def dot_product(x, y):
return jnp.dot(x, y)
if __name__ == '__main__':
grad_square = jax.grad(dot_product)
vectorized_dot_product = jax.vmap(dot_product)
x = jnp.array([i for i in range(10000)])
y = jnp.array([i for i in range(10000)])
grad_value = dot_product(x, y)
JAX 사용후기
JAX는 기본적으로 multi GPU 환경이나, TPU 환경에서 유리하다. 나의 경우에는 single GPU 환경이기 때문에, JAX를 쓰면 오히려 변환에 더 오랜 시간이 걸렸다. (JAX가 분산에 최적화되었기 때문이다.)
JAX가 numpy를 호환한다고 하지만, 아직 torch 등의 딥러닝 프레임워크와 호환이 부족하다. 따라서, 단순 기존 코드의 최적화가 아닌, 분산 환경에서 속도를 향상시키기 위한 대대적 Refactoring이나 개발에 사용하는 것이 좋을 것 같다.
JAX는 현재 기준(2023.08.07)으로 CUDA 11버전까지만 지원한다. 이것도 환경을 제한하는 요소인 것 같다.
그럼에도 불구하고, JAX는 딥러닝 코드를 Python 언어 내에서 최적화할 수 있는 선택지를 제공한다는 점에서 매우 유용한 것 같다.
Pandas는 파이썬에서 데이터 처리와 분석을 위한 라이브러리로, numpy를 기반으로 개발되었다.
Pandas는 DataFrame과 Series라는 데이터 구조를 사용하여, 데이터를 쉽게 처리할 수 있도록 한다.
Pandas는 C 언어 등, low level의 언어로 개발된 numpy를 기반으로 하고, 수년간의 버전 업그레이드로 그 자체에 최적화를 해놓았기 때문에, 일반적으로 Pandas에서 제공하는 함수들을 사용하는 것이 성능 면에서 가장 좋다.
하지만, 데이터 크기와 연산의 복잡성에 따라, 특정한 상황에서는 Pandas의 성능을 최적화하기 위한 방법이 필요하다.
Pandas의 데이터 처리 최적화 원리
Pandas는 기본적으로 low level 언어로 최적화가 많이 되었기 때문에, Pandas 데이터 처리를 위한 연산 과정에 Python 언어로 처리하는 과정이 생략되는 것이 좋다.
Pandas는 메모리 위에서 동작한다. 이에 따라, 메모리의 가용 용량을 벗어나는 데이터 처리 및 연산은 한 번에 처리할 수 없다. 따라서, 메모리를 효율적으로 사용할 수 있도록 변경하는 것이 좋다.
Pandas 데이터 로드
사실, Pandas를 많이 활용하는 이유 중 하나는 Pandas의 Dataframe이 SQL 테이블 형태와 거의 유사하기 때문이다.
Pandas에 들어갈 데이터를 Code 내부에서 주입하는 경우도 있지만, 대부분의 경우, Database나, CSV File 등에서 Import 해오는 경우가 많다.
Pandas는 앞서 말한대로, 메모리에 DataFrame을 올려놓고, 연산하는 형태이기 때문에, 메모리가 연산을 효율적으로 처리할 수 있도록, 작은 단위의 필요한 데이터만 사용하는 것이 연산 측면에서 유리하다.
1. Query 및 파일 최적화
Pandas에서 SQL이나 CSV 등의 Raw 형태의 데이터를 읽고, 이를 Filtering하여Filtering 하여 사용하는 경우가 많은데, 이는 Raw 데이터 전체를 메모리 올려, 메모리 & I/O 부담을 증가시킨다. 따라서, 필요한 데이터만 미리 Filtering 하여 가져오는 것이 좋다.
이렇게 Pandas에서 필요한 데이터만 가져오면, 전체 Series의 갯수(Row 수)가 줄기 때문에, Index 활용 측면에서도 유리하다.
예시로, 한국어 형태소 분석을 위해 SQL 테이블에서 1주일치 데이터를 읽어서, 처리하였는데, 하루씩 읽어서 7번 처리하는 게 속도 면에서 더 효율적이었다.
chuncksize를 지정해줘서, 한 번에 읽을(메모리에 올릴) Series(row) 수를 지정할 수 있다.
하지만, 전체 데이터가 같이 필요한 것들(특정 칼럼 sort 등)은 처리가 까다롭기 때문에, 다른 행들 간의 연산이 비교적 적은 경우에 활용하는 것이 좋다.
for chunk in pd.read_csv('raw_data.csv', chunksize=10000):
processing(chunk)
4. Dask 사용
만약, 메모리가 감당하기 어려운 정도의 어려운 정도의 데이터 양과 연산이 포함된다면, 대용량 데이터를 분산 처리하기 위해 개발된, Dask를 사용할 수 있다.
Dask는 Pandas와 달리, Disk에 저장된 데이터를 처리하기 때문에, 여러 머신에서 분산처리가 가능하고, 지연 연산을 사용하기 때문에, 실제 연산을 최적화하는 과정이 포함된다.(SQL의 실행 Plan을 생각하면 된다.) 따라서, 초 대용량 데이터 처리에는 Dask의 강점이 있다.
하지만, 메모리가 감당 가능한 수준의 연산에서는 메모리와 디스크의 속도 차이 등 때문에, Pandas가 유리하다.
import dask.dataframe as dd
if __name__ == "__main__":
df = dd.read_csv('raw_data.csv')
Pandas 연산 & 조회
[실험 데이터셋]
Pandas 연산 테스트를 위해, 예시 데이터로 Kaggle 데이터셋을 사용했다. (https://www.kaggle.com/datasets/jordankrishnayah/45m-headlines-from-2007-2022-10-largest-sites?resource=download)
사용할 데이터는, 4.5M 분량의 2007년부터 2022년 주요 언론사의 기사 제목 headline 데이터이다. 데이터는 총, 4405392개 row로 구성되어 있고, [Date, Publication, Headline, URL]의 4개의 칼럼으로 구성되어 있다.
1. 반복문 최적화
Pandas 연산에서 가장 큰 성능 개선 포인트는 반복문 연산이다.
Pandas가 Python 언어로 동작하기 때문에, Python의 list의 개념으로 Dataframe을 다루기 때문에, 이런 문제가 많이 발생한다.
Pandas를 For문을 통해, 각 row에 접근하는 경우에는, 각 row마다 연산을 각각 실행한다. 이에 따라, 데이터 크기가 커질수록 연산의 Overhead는 가중화된다.
가장 쉬운 방법은 Pandas의 apply를 사용하는 것이다.
또한, Numpy Vectorize를 사용하는 방법, iterrows, itertuples를 사용하는 방법들이 있는데, 일반적으로 itertuples와 numpy vectorize는 Pandas Apply보다 좋은 성능을 보인다고 알려져 있다.
추가적으로 멀티스레드를 이용하여, Pandas 연산을 병렬화 하고, 효율적으로 처리하는 swifter가 있다.
(테스트 상황)
headline 데이터셋에서 URL의 "http://" or "https://" 부분을 제거하는 작업을 테스트
headline 데이터셋에서 Date의 연도를 제거하는 작업을 테스트
(1) 단순 For문
for i in range(data.shape[0]):
data["URL"][i] = data["URL"][i].replace('http://', '').replace('https://', '')
→ 실행 시간 : 94848.09 s(1000 row 실행시간: 21.53으로 추정)
for i in range(data.shape[0]):
data["Date"][i] = data["Date"][i]%10000
data["Date"] = data["Date"].swifter.apply(lambda x: x % 10000)
→ 실행 시간 : 0.37s
[실험 결과]
Python 영역의 연산을 활용하는 경우(Python 라이브러리 or String 사용 등)에는 apply나 itertuples를 사용한 순회가 가장 좋은 성능을 보인다. → 첫 번째 실험
Python 영역의 연산을 활용하지 않는 경우, 즉, Cython으로 변환이 가능한 연산등은 np.vectorize가 가장 좋은 성능을 보인다.
데이터의 타입, 크기, 연산에 따라, 가장 적합한 연산은 다르겠지만,
일반적으로 apply나 itertuples를 사용한 순회가 가장 좋다.(일반적으로 대용량에선 itertuples가 apply보다 낫다고 함.)
연산이 간단한 경우(Cython으로 변환이 될만한 간단한 연산)에는 np.vectorize를 통해 최적화가 가능하다.
단순 for문은 사용하지 않는 것이 좋다.
Swifter는 데이터의 크기가 매우 크고, 연산이 복잡하지 않은 연산에서 효과적이다.
2. 특정 조건 데이터 조회
특정 조건 데이터 조회는 Pandas에서 자주 사용된다.
연산에 비해, 긴 시간이 걸리지는 않지만, 데이터가 많고, 연산이 복잡해질수록 조건에 맞는 데이터를 찾는 시간이 오래 걸린다.
(테스트 상황)
headline 데이터셋에서 2022년부터 데이터 중, New York Times의 데이터를 찾으려고 한다.
(1) Boolean Type으로 indexing
가장 일반적인 방법이다. 여러 개의 칼럼들의 조건의 boolean 형태로 각각 연산하여 구할 True인 값만 가져올 수 있다.
filtered_data = data[(data["Date"]>20220000) & (data["Publication"]=='New York Times')]
→ 실행 시간 :0.14s
(2) loc를 이용한 indexing
Boolean Type으로 indexing과 동일하다.
filtered_data = data.loc[(data["Date"]>20220000) & (data["Publication"]=='New York Times')]
→ 실행 시간 :0.14s
(3) query를 사용한 조회
Dataframe은 query를 지원한다. (하지만, like 등의 조건은 지원하지 않는다.)
참조하는 칼럼이 많고, 데이터가 클수록, query를 내부적으로 최적화하는 단계가 있어 더 좋은 성능을 보인다.
filtered_data = data.query("Date >20220000 and Publication == 'New York Times'")
→ 실행 시간 :0.07s
(4) isin을 사용한 indexing
큰 범위애서 보면, Boolean Type으로 indexing에 속하는데, 특정 문자열과 일치하는 조건을 찾을 때는, boolean type에 isin을 넣어주면 더 빨리 찾을 수 있다.
filtered_data = data[(data["Publication"].isin(['New York Times'])) & (data["Date"] > 20220000)]
→ 실행 시간 :0.05s
(5) itertuples를 사용한 순회
순회를 이용한 데이터 indexing은 별로 좋은 방법은 아니다.
하지만, 연산과 조회를 같이하는 경우에는 한 번의 순회에 조회 조건을 넣어, 데이터를 찾는 것도 고려해 볼 수 있다.
find_index = []
for i, row in enumerate(data.itertuples(index=False), start=0):
if row.Date > 20220000 and row.Publication == 'New York Times':
find_index.append(i)
filtered_data = data.iloc[find_index]
→ 실행 시간 :2.01s
[실험 결과]
일반적으로 사용되는 boolean을 사용하는 것이 좋다고 알려져 있지만, 참조하는 칼럼이 많고, 데이터가 많을 경우에는 query를 사용하는 것이 효과적일 수 있다.
Boolean Type도 단순히 조건을 넣어서 indexing 하는 것보다, isin 같은 pandas 연산자를 함께 사용해서 데이터를 찾는 것이 효율적이다.
3. 문자열 포함 검색
SQL에서는 LIKE라는 특정 문자열을 포함했는지 여부를 찾는 방법이 있지만, Pandas에서는 LIKE를 지원하지 않는다.
생각보다, 특정 문자를 포함하는지 여부를 점검하는 경우가 많은데, 이런 경우 어느 방법이 효과적일까?
Transformer는 사실, NLP분야뿐만아니라, 다양한 분야에서 많이 사용되기 때문에, 그만큼 구현 소스를 쉽게 찾을 수 있다. 나도, Transformer를 자주 사용하지만, 라이브러리에서 읽어오는 형태로 사용하기 때문에, 그 상세 구조에 대해서는 대략적으로만 알고 있다. 이번 기회에 Transformer를 pytorch로 직접 짜보면서 그 구조를 정확히 이해하고자 한다.
Multi-Head Attention은 scaled Dot-Product Attention을 query에 해당하는 value 값들을 참조하기 위해 사용하는데, query, key, value를 그대로 사용하는 것이 아니라, 여러 개의 head로 나누고, query, key, value를 linear projection 한 후, 사용한다.
Scaled Dot-Product Attention 이후, 각 head의 value 값을 concat하고, linear layer을 거쳐 output을 낸다.
주의할 점은, sequence의 순서가 중요하기 때문에, contiguous를 사용해서, 순서를 유지한다는 점이다.
실제 NLP 단어 예측 등, 데이터셋을 넣어보기 위해, dataloader와 학습 등을 연결해 봐야겠다.
특정 task를 풀기 위해, 데이터셋을 처리하기 위한 model을 짜는 것도 좋지만, 가끔은 논문을 그대로 구현해 보는 것도 좋을 것 같다. 특히, 그림과 글만 보고 구현을 하려고 하니, 내가 정확하게 알지 못했던 부분, 특히 머리로 이해하고 넘어간 부분을 완전히 알게 된 것 같아 좋다.
NLP 분야에서 광범위하게 사용되고 있던, Transformer를 computer vision 분야에 적용해 좋은 성능을 보여주었다.
Abstact
Transformer가 NLP 분야에서는 standard로 자리 잡았지만, computer vision 분야에서 활용은 아직 한계가 있다.
vision 분야에서는 attention은 attention은 CNN과 함께 적용되거나, 그 요소를 바꾸는 데 사용하는 등, 전체적인 구조는 그대로이다.
이 논문에서는 CNN구조의 중심이 불필요하고, image patches를 sequence 형태로 pure transformer에 바로 적용하는 것이 image classification에서 잘 working한다는 것을 보여준다.
많은 양의 pre-trained 데이터로 학습하고, 적은 양의 image recognition benchmark들로 실험했을 때, Vision Transformer(ViT)는 SOTA CNN 구조보다 학습에 적은 연산 cost를 사용하면서 좋은 성능을 낸다.
Introduction
[배경]
NLP 분야에서는 Transformer를 선두로 한, Self-attention-based 구조를 채택해서, 매우 좋은 성능을 보이고 있다.
Computer vision에서는 CNN 구조가 아직 대세이다. CNN 구조와 self-attention 구조를 연결하려고 노력하거나, conviolution을 대체하는 등 여러 연구들도 있었다.
특히, convolution을 대체하는 연구는 이론적으로는 효율적이지만, 현재(그 당시) hardware accelerator 구조로는 적용이 어려웠다. 따라서, large-scale image recognition에서는 classic resnet 구조가 아직 SOTA였다.
[소개]
이 논문에서는 standard Transformer를 거의 변경없이, 이미지에 적용한다. 이를 위해, image를 patch로 나누고, 이 patch들을 linear embeddings sequence 형태로 transformer에 넣는다. (image patche들은 NLP의 token처럼 다뤄진다.)
모델은 image classification을 supervised learning으로 학습한다.
ImageNet 같은 mid-sized 데이터셋에서 이 모델은 비슷한 크기의 resnet보다 몇 % 정도 낮은 수준의 정확도를 보인다.
이 결과는 기대에 밑돌아, Transformer가 inductive biases(추상적 일반화)가 CNN에 비해 떨어진다고 생각할 수 있다.
하지만, 대용량 dataset에서 실험했을 때, 상황은 바뀐다.
ViT는 충분한 pre-trained 데이터가 있을 때, 매우 좋은 성능을 보인다.
Method
모델 디자인은 original Transformer를 최대한 비슷하게 따랐다. (구현이 되어 있기에 바로 적용할 수 있어서)
[ViT]
Transformer는 1D 데이터를 처리하는데, 이미지는 2D이다. 이미지(HXWXC)를 다루기 위해, Image를 2D patches(PXPXC) 개로 나누었다.
Transformer는 각 layer에서 constant latent vector size D를 유지하는데, 이를 위해, patch들을 학습 가능한 linear projection을 통해, D dimension 화하였다. 그리고, 이 결과를 patch embeddings라고 부른다.
BERT의 class token 처럼, patch embedding의 앞에 learnable embedding을 붙인다. 이것은 Transformer encoder의 output이 이미지 representation(y)이 될 수 있도록 사용된다.
pre-training과 fine-tuning 단계에서 모두, Transformer encoder의 ouput이 classification의 head로 이용된다.
classification head는 pre-training 단에서는 one hidden layer의 MLP로, fine-trurning 단계에서는 하나의 linear layer로 구성된다.
Position embeddings는 patch embeddings에 더해져, 공간 정보를 제공한다.
ViT에서는 학습 가능한 1D position embeddings를 사용했는데, 2D의 position embedding이 성능에 딱히 영향이 없는 것 같아서 그랬다고 한다.
Transformer encoder는 multiheaded self-attention의 대체 layer들과 MLP block으로 구성되어있다.
Layernorm은 각 block 전에 적용되어 있고, 모든 block 끝에는 residual connection이 존재한다.
MLP는 GELU 함수를 사용한 2개의 latyer로 구성되어 있다.
[Inductive bias]
ViT는 image specific inductive bias가 CNN에 비해 덜하다.
CNN에서는 지역 정보, 2D neighborhood 정보, translation 등분산성(골고루 보고 처리한다.)이 각 layer에 담긴다.
ViT에서는 MLP layer에서만 translation 등분산성과 지역 정보를 보고, self-attention layer들에서는 전체적으로 본다.
2D neighborhood 정보는 드물게 사용된다. model의 시작에 이미지를 cutting 하고, fine-tuning 때는 position emeddings를 다른 resolution으로 처리하기 때문이다. 또한, initinalization 시에 embedding에는 정보가 없기 때문에, patch의 2D 위치와 patch 간의 공간 관계에 대해 처음부터 스스로 학습해야 한다.
[Hybrid Architecture]
raw image patches의 대안으로, CNN의 feature 형태로 input sequence를 구성할 수 있다. hybrid model에서는 patch embedding을 CNN feature map으로부터 뽑는다.
어떤 케이스에서는 1X1이 될 수 있는데, 이 것은 input sequence가 spatial dimension 정보를 flatten 한 케이스이다.
기본적으로 ViT를 large dataset에서 pre-train 하였고, 적은 데이터셋에서 fine-tune 하였다.
이를 위해, pre-trained prediction head를 지우고, zero-initialized D X K layer를 넣었다. (K는 classification class 개수)
pre-trained 보디, fine-tune 때 높은 해상도의 이미지를 사용하는 것이 유리하다.
고해상도 이미지를 넣을 때, patch size는 동일하게 유지한다. (sequence length만 늘어난다.)
ViT는 임의의 sequence length를 다룰 수 있지만, 그러면 pre-training 된 position embedding은 더 이상 의미가 없다.
이때는 pre-trained position embedding에 original image에서의 위치에 따라, 2D interpolation을 통해 처리했다.
Experiments
Resnet, ViT, hybrid model을 실험했다.
각 모델의 데이터 필요도를 확인하기 위해, 다양한 사이즈에서 pre-train을 하였고, 다양한 benchmark에서 실험했다.
pre-training의 연산 cost를 생각했을 때, ViT는 매우 순조롭게, 적은 양의 연산 cost 만으로 SOTA recognition benchmark에 도달했다.
[Setup]
Dataset : ILSVRC-2012 ImageNet 데이터셋(1000 classes, 1.3M images), superset ImageNet-21k(21k classes, 14M images), JFT(18k classes, 303M high resolution images)을 사용했다. benchmark로는 ImageNet의 original validation labels와 cleaned-up Real labels, CIFAR-10/100, Oxford-IIIT Pets, Oxford Flowers-102를 사용했다.
Model Variants : ViT의 configuration는 BERT를 기반으로 했다. patch size가 작아질 수 록 연산은 expensive 해진다. (token이 많다고 생각하면 됨) CNN의 baseline으로는 ResNet을 사용했지만, Batch Normalizaation layer를 Group Normalization으로 대체했다.
[SOTA와 비교]
특정 모델에서 ImageNet의 SOTA인 NoisyStudent보다 좋은 성능을 보여준다.
Conclusion
image recognition에 Transformer를 사용해 보았다.
과거 computer vision에서의 self-attention 구조와 다르게, image-specific inductive biases를 구조에 넣지 않았다.
대신에, 이미지를 patch들의 sequence로 다뤄, NLP처럼 처리했다.
scalable 하고, large dataset에서 pre-training 했을 때, 잘 working 하여, ViT는 pre-trained에 많은 cost를 쓰지 않고도, SOTA image classification에 버금가는 성능을 보여주었다.
아직, 나아갈 길이 많다. (detection이나 segmentation 적용 등)
Reference
Dosovitskiy, Alexey, et al. "140 Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, 141 Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image 142 recognition at scale." ICLR 3 (2021): 143.
총평
NLP 분야에서 혁신을 이뤄낸, transformer를 vision 분야에 도입하여 성능을 낸 게, 지금 시점에서는 당연해 보이지만, 이 도입을 위해 얼마나 고민하고, 실험했을지 싶다.
NLP처럼 transformer를 시작으로, GPT, BERT 등으로 이어지는 거대 모델의 흐름이 vision에도 적용될 것인지 살펴봐야겠다.
이때, profiling의 결과는 테이블 구조의 텍스트 형태로 터미널에 출력 or 파일에 저장 가능하다.
이 결과로도 Insight를 충분히 추출할 수 있지만, 텍스트 형태로 분석하다 보면, 가시성이 떨어진다는 점과, profiling 이력 간 비교가 어렵다는 점이 아쉽다.
이를 해결할 수 있는 딥러닝의 시각화 툴인 Tensorboard에 profiling 결과를 올리는 방법이 있어서, 이 방법을 알아보고자 한다.
원리
torch profiler의 옵션에 "on_trace_ready"라는 옵션이 존재한다. 이것은 profiling 결과가 준비되었을 때, 호출할 callback 함수를 지정하는 것인데, 이 callback 함수로 tensorboard에서 제공하는 trace handler를 연결하여, tensorboard에서 읽을 수 있는 log 형태로 떨궈준다.
Setup
tensorboard에서 torch profiler의 결과를 읽어서 표현할 수 있는 plugin을 추가로 설치해야한다. (당연히, tensorboard가 필요하기 때문에, 아래 plugin을 설치하면, tensorboard도 자동으로 설치된다.)
pip install torch_tb_profiler
사용법
torch profiler를 이용하기 위한, 콘텍스트 관리자(with 절)에 on_trace_ready 옵션에, "tensorboard_trace_handler" 함수를 지정해 준다.
이때, tensorboard_trace_handler 함수의 인자로, tensorboard에서 읽을 수 있도록 log 디렉터리를 지정해 준다.
...
with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA], record_shapes=True,
profile_memory=True, on_trace_ready=torch.profiler.tensorboard_trace_handler('./log/resnet18')) as prof:
for epoch in range(TRAIN_EPOCH):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data[0].to(device), data[1].to(device)
optimizer.zero_grad()
with record_function("model_inference"):
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if i % TRAIN_PRINT_FREQUENCY == TRAIN_PRINT_FREQUENCY - 1:
print(f'Epoch: {epoch + 1}, Batch: {i + 1}, Loss: {running_loss / 200:.3f}')
running_loss = 0.0
...
그 후에, tensorboard 실행을 해주면 끝난다.
tensorboard --logdir=./log/resnet18
결과
[NORMAL]
Overview : Overview는 전체적인 프로파일링의 결과에 대해 보여주는 화면이다.
Configuration : Profiling 시 사용된 설정 정보를 표시한다.
Execution Summary : 전체 수행 시간과, 각 단계에 소요된 수행시간을 보여준다.
Spen Time Breakdown : 코드 또는 연산의 실행 시간을 단계별(Kernel, Memcpy, Memset, Runtime, DataLoader, CPU Exec, Other)로 분해하여 보여준다.
Performance Recommentation : profiling 결과를 기반으로 한 성능 개선 권장 사항을 자동으로 생성해 준다. (실제로 어떤 원리로 동작하는지는 잘 모른다.)
Operator : 연산에 대한 profiling 결과를 보여준다. torch profiling 결과를 터미널에서 출력하였을 때, 보여주던 결과를 그대로 보여준다고 생각하면 된다. 추가적으로 Tensor Cores Eligible 옵션이 있는데, 해당 연산이 GPU를 사용할 수 있는지에 대한 가능 여부를 표시한 것이다. Group By 조건을 바꾸면, input shape도 볼 수 있다.
Trace : 함수 및 연산의 실행 시간을 시간 경과에 따라 그래프 형태로 표시한다. 해당 코드의 실행에 사용된 Process와 그 안의 Thread의 동작을 확인 할 수 있다. (사실 이 UI는 torch profiler의 chrome tracing 기능으로도 볼 수 있다.)
Memory : 실행 시간에 따른 Memory 사용 추이를 보여준다. 각 연산마다 할당한 메모리와, Allocation Time과 Release Time, Duration을 보여준다. 코드 실행에 사용한 H/W 별로 볼 수 있다. (다만, 해당 UI에서 Memory를 많이 사용하는지, Chrome이 계속 죽는다.)
[DIFF]
Tensorboard를 통한 torch profiler 시각화의 가장 큰 장점이라고 할 수 있는 이력 간 비교 기능이다. Baseline의 log를 정한 뒤, 비교하고자 하는 log를 대입하면, 그 둘 간의 profiling 결과의 delta 값을 보여준다.
이를 통해, Profiling 결과를 비교하면서, H/W 효율화를 위한 구조 개선을 진행할 수 있다.
Torch 모델에서 torch profiling을 시각화하여 비교하는 방법을 알아보았다. 개인 프로젝트에서는 그 효용이 덜하겠지만, 많은 사람들이 같은 모델을 연구할 때, 성능과 profiling 결과를 모두 tensorboard를 통해 시각화하여, 성능을 유지하면서 모델의 연산 효율성을 향상하거나, 모델의 연산 효율성을 유지하면서 모델의 성능을 향상하는 데, 사용하면 매우 유용할 것이다.
