아래 표에 내가 생각한 각 논문에서 중요한 포인트를 적어두었다.

RT는 약간 특성이 달라서 이번엔 다루지 않을 예정이다. 그 외 논문들을 하나씩 보자면,

DCVC

왼쪽은 DCVC 전까지 일반적이던 residual 코딩 방식이다. 이미 코딩해둔 정보들을 바탕으로 현재 프레임을 예측하고 ($\tilde{x_t}$) 그 차이만을 ($x_t-\tilde{x_t}$)를 코딩한다.

DCVC에서 제안한 건 아니지만, 오른쪽의 conditional 코딩 방식은 이미 코딩해둔 정보들을 인코딩, 디코딩할 때 context로 활용해서 압축할 latent를 뽑는 방식이다.

DCVC-TCM

DCVC에서 context를 뽑을 때 복원한 이전 영상을 활용했었다.

하지만, 3채널 짜리 복원 영상은 feature 단계보다 정보가 많이 줄어든 상태이기 때문에, RGB영상을 뽑기 전 feature ($F_t$)도 같이 저장해 뒀다가, 이걸로 context를 뽑는 방식으로 바꿨다.

DCVC-HEM

다른 모듈 구성이나 이런건 동일한데, 단일 모델에서 여러 qs를 지원할 수 있도록 연산 중간중간에 learnable vector를 곱하는 연산을 추가해줬다.

DCVC-DC

크게 두개 모듈이 추가되었다.

1) 모션 예측시 offset을 여러개 같이 예측하는 모듈 2) Quadtree entropy model

1번은 크게 아이디어적인 것은 없어서 패스

2번의 quadtree entropy model 그림이다. Autoregressive 방식 중 하나로 볼 수 있는데, 비교적 성능도 꽤 좋아지면서 연산 복잡도는 적당히 높아진 밸런스 있는 모델인 것 같다.

DCVC-FM

TCM 이후부터 DC까지는 context를 만들 때 feature만을 사용했었다. 이게 언제 문제가 되냐면, I 프레임으로부터 점점 멀어질 수록 (GOP가 커질 수록) 문제가 발생한다.

P 프레임 코딩을 하면서 에러가 점점 누적되는건데, FM에서는 이를 해결하기 위해 context를 생성할 때 주기적으로 feature가 아닌 복원 영상을 활용한다.

그 결과, I 프레임 하나로 동영상 전체를 코딩하더라도 비교적 안정적인 모습을 보인다. (ECM은 딥러닝이 아닌 전통적인 코덱 방식)

정리

다음엔 어떤식으로 Neural video compression을 발전시킬지 기대가 된다. 다 좋은데 학습 코드가 없어서 재현이 어렵다. 그래서 점점 이 연구팀이랑 다른 팀간에 격차가 커지는 것 같다..

문제 제기

고전 코덱들은 비트레이트(bit rate)를 세세하게 조절해서 원하는 환경에 맞게 압축이 가능했다. 그러나, 딥러닝 기반의 비디오 압축 기법들은

고정된 $\lambda$값을 사용하여 Rate-Distortion 손실함수를 최소화 하기 때문에, 세세한 조절이 안된다.

기존 기법

딥러닝 기반 비디오 압축에서 세밀한 비트 조절을 위한 방식은 두가지로 구분 가능하다.

1. Multi-granularity quantization

DCVC-DC가 대표적인 예시인데, 피쳐단에서 qs 몇개에 대한 learnable vector를 곱하는 것으로 값을 크게 변화시키는게 아니라 scaling만 한다. -> quantization step 변화와 비슷함

2. Feature modulating

1과 다르게 실제 값이 바뀌게끔 하는 scaling 이상의 연산이 들어간다.

저자들이 제기한 문제

1번 같은 경우는 단순 선형 변환이라 당연히 네트워크를 따로 두는 것보다 제한적이라는 것, 그리고 1, 2번 모두 bit-rate 예측과정이 없기 때문에 정확하게 조절이 어렵다는 점이다.

제안 기법

요약

세가지를 제안한다.

1. Dynamic-Route Autoencoder (DRA) : Slimmable autoencoder를 사용해서 bit-rate에 맞게 전체 네트워크의 일부(Route)만으로도 코딩이 가능하다.
2. Rate Control Agent (RCA) : 원하는 bit-rate에 따라 route를 결정해준다.
3. Joint-Routes Optimization Strategy : 네트워크 일부만 쓰고, 공유하고 이런 스타일은 학습이 어렵기 때문에 학습 과정을 고안하였다.

1. Dynamic-Route Autoencoder (DRA)

간단하게 말하면 파라미터 일부만 사용해서 출력되는 절대적인 양을 줄여버린다.

그림은 Slimmable convolution 내용이다. (a) 출력이 잘리는 경우 (b) 입력이 잘려 있는 경우 이고, 자르는 단계가 0~3 단계라고 하면 0단계는 $W_0$만, 1단계는 $[W_0, W_1]$을 사용하는 이런식이다.

다른 autoregressive 모델과 똑같긴 한데, 엔트로피 모듈에서의 구현은 위 그림과 같다. 이전 route 출력 모두를 현재 route 를 예측하는데 사용한다.

$p_{ch}$는 확률 분포 예측기, Q는 quantization, FM은 feature modulation 네트워크에 해당한다. 그러면, 위 식은 k번째 route의 확률분포 $\Phi^k_{ch}$를 예측하기 위해, 이전 route 출력 $y^{k-1}_{ch}$ 와 hyperprior $z$를 사용한다는 식이 된다.

2. Rate Control Agent (RCA)

두가지 연산이 이루어진다.

1. 입력 영상 $x_t$와 모션 벡터 $mv$를 받아서 각 route별 bit-rate를 예측한다. ($R^0_{est}$ ~ $R^3_{est}$)
2. 목표 bit-rate $R_{tar}$와 이미 사용한 비트수 $R_{coded}$를 바탕으로 몇번째 route까지 쓸건지 결정한다.

(원 논문에서 notation을 비트레이트, 총 비트수를 같은 R로 써서 헷갈린다.) 예를 들어, 이미 코딩한 프레임 수 $N_{coded}=10$ 참고할 프레임 수 $SW=5$ $R_{tar}=0.5, R_{coded}=4.8$ 이라 하면, 현재 프레임 압축시 목표 bit-rate $T_{tar}=0.54$ 가 돼서 목표 비트수 보다 약간 더 써도 된다 는걸 유도할 수 있다.

즉, 만약 비트가 좀 여유있다면 ($R_{tar}\times N_{coded}>R_{coded}$) $T_{tar}$보다 큰 $R^i_{est}$들 중에서 젤 가까운 $i$를 route로 선택하는 방식이다.

3. Joint-Routes Optimization Strategy

일반적으로 variable-rate 코덱을 학습하는 방식은 다음과 같다.

모든 route (또는 qs)에 대해 Rate, Distortion loss를 구하고 다 합쳐서 업데이트하는데 사용한다. Variable-rate를 위해 $\lambda$ 값을 튜닝한다.

(Line 4, 5에서 $\lambda$만 바꾸고 R, D는 그대로인 것처럼 써놨는데, R, D도 각 qs별로 새로 측정한다.)

qs가 낮을수록 학습이 빠르기 때문에, 높은 qs의 (그림에선 $\lambda_3$) 부터 하나씩 고정하면서 학습을 진행한다.

Algorithm 1을 발전시켜서, $\lambda$ 값들을 같이 업데이트 하는 방식을 제안한다.

복잡한데, Algorithm 1 기준으로 rate-distortion 변화량 $\xi$(위 그래프와 같이 음수값을 가짐)이 하나 큰 qs에서의 변화량($\xi_{prev}$) 보다 작으면서(더 가파르면서)를 때까지 $\kappa$를 곱해 $\lambda$들을 줄여나간다.

즉, 완만했던 파란색 그래프에서 qs가 작아질 수록 점점 급해지는 빨간색 그래프로 변해 가면서 bit-rate 범위를 늘린다.

여기서도 높은 qs의 $\lambda$ 값부터 하나씩 고정시켜 나간다.

실험

DCVC-DC를 인용은 했는데, 같이 성능을 비교 안한걸로 봐서 잘 안나와서 뺀 것으로 의심이 된다..

그래도 이렇게 원하는 bpp에 딱맞게 나오는 것은 신기하다.

주관적인 생각

코드상에 모션 코딩 관련해선 엔 이런 처리를 안하고 모든 qs에서 똑같은 처리를 하는것으로 되어 있던데 왜 모션엔 따로 뭔갈 안했는지 궁금하다.

학습 난이도가 꽤 될 것 같은데, 구체적으로 어떻게 했을지 궁금하다.

DCVC-TCM을 쓴 Microsoft 팀에 계시던 저자분 두분이 학교에서 지도하신 논문인듯 하다.

딥러닝 기반의 이미지 압축 논문이다. 구조는 크게 Encoder, Decoder, Entropy module 3개로 구분이 가능한데, 이 논문은 Entropy module 부분이 메인이다.

저자들이 문제삼은 것은, Entropy module이 CNN 기반으로 Local redundancy를 활용하는 것에서 Transformer를 활용하여 global 특성도 활용하게 발전하고 있지만, 여전히 global redundancy 활용이 부족하다는 점이다.

제안한 것은 다음 두가지이다.

1. Hierarchical coding schedule
2. Progressive context fusion 별개로 다른 논문의 아이디어를 가져와 활용한 몇가지까지 있다.

최근 대부분 압축 논문에서 활용하고 있는 Autoregressive entropy module 기반이다.

Overview

일반적인 이미지 압축 구조와 같이

1) 입력 영상이 인코더를 통과하여 latent y 2) hyperprior 인코더로 z 3) entropy module로 y의 확률 분포 예측 4) 디코더로 영상 복원 하는 구조이다. 이 논문에서는 3번이 중요하다.

1. Hierarchical coding schedule

Autoregressive 구조로 y를 잘게 쪼개서 순차적으로 코딩을 하는데, 쪼개는 방식에 대한 제안이다. 그림이 조금 복잡해 보일 수 있으나, DCVC-DC 논문을 본 사람이라면 익숙할 그림이다. DCVC-DC의 quadtree와 매우 유사한 방식을 제안한다. 구체적으론,

1) 채널방향으로 균등하게 8조각으로 자른다. 2) y를 1/4 크기로 샘플링하여 (각 sub-latent마다 다른 위치) 코딩을 진행한다. (stage 1, 2) 3) y를 1/2 크기로 샘플링하여 코딩을 진행한다. (stage 3, 4, 5) 4) 원래 y 크기에서 나머지 부분 코딩을 진행한다. (stage 6, 7, 8, 9, 10, 11)

그림에서 각 칸에 적힌 숫자가 autoregressive 순서를 지칭하는 stage 번호이다.

이렇게 함으로써 초반 코딩 단계(1/4, 1/2 스케일)에서 attention 수행시 메모리를 줄일 수 있다.

2. Progressive context fusion

Autoregressive entropy module에서 중요한 context 생성 부분이다. Context란 현재 코딩하려는 $y_i$의 확률 분포 $\psi_i$ ($\mu, \sigma$)를 예측하기 위해 이미 코딩한 latent $\hat{y}_{<i}$ 와 같이 활용할 정보를 말한다.

1) 이전 stage와 현재 stage의 스케일이 바뀌지 않는 경우

$\psi_i=g_{ep}(C_i, \hat{y}{<i})$ 로 확률 분포를 예측하기 위한 파라미터를 얻는다. 이중 현재 코딩하고자 하는 부분($\psi{\hat{y}_i}$)만 사용한다.

Progressive Context Fusion

실질적인 Context를 업데이트를 하는 파트다. 구조는 그냥 cross attention이다. $C_{i+1}=CrossAttn(\psi_i, C_i)$

2) 이전 stage와 현재 stage의 스케일이 바뀌는 경우

Context 업데이트 시, 원래 샘플링 해왔던 위치에 이전 context를 넣어 주고, 나머지 부분은 hyperprior z에서 얻을 수 있는 확률 분포 파라미터 예측의 초기값인 $h_s(\hat{z})$으로 채워준다.

이외 변경사항

Partial convolution(Pconv) in Residual block

인코더 디코더에서 사용하는 Residual block에서 연산량을 줄이기 위해 Partial convolution (Run, Don’t Walk: Chasing Higher FLOPS for Faster Neural Networks CVPR 2023) 을 차용했다. 위 그림처럼, 채널 전체에 대해 convolution을 하는 것이 아니라 일부 채널(여기선 1/4)에만 연산을 진행한다.

Weight sharing entropy parameter network

파라미터 수를 줄이기 위해 확률 파라미터 예측 모듈인 $g_{ep}$를 일부 공유한다. 스케일로 말하자면, 1/4 1/2 스케일에서 같은 파라미터를 사용하고, 1 스케일에서 같은 파라미터를 사용한다. 코딩 stage를 구분짓기 위해 stage별로 따로 있는 Step adaptive embedding을 중간에 곱해주었다.

성능

다른 image compression 기법들에 비해 꽤 빠르고 높은 성능을 보인다. 중간의 *표된 두 모델은 인코더 디코더는 동일하지만, entropy model만 제안 기법으로 측정해 준 성능이다.

제안 기법들에서도 느껴지듯이 코드를 봤을 때도 DCVC-DC를 확실히 참고 잘 한듯 하다. 여러가지 아이디어들도 근거 있게 잘 제안 한 것 같다. 어텐션 과정에서 이렇게 스케일 구분해서 차례로 진행한다는 것은 다른 연구 분야에서도 활용할 수 있을 것 같다.

Overview

구조 자체는 hyperprior 기반의 autoregressive entropy model 과 동일하게, 인코더로 얻은 latent y 중 이미 전송한 $\hat{y}$과 hyper encoder로 얻은 z, $\hat{z}$으로 확률분포를 예측한다. 뒤에서 말하겠지만 autoregressive 방식은 아니고 y를 2단계로만 나누어서 코딩한다.

총 3가지 contribution으로 정리할 수 있다.

Diamond relative positional encoding

다이아몬드 형태의 positional encoding을 제안한다. 위 그림은 저자들이 한칸씩 직접 마스킹해가며 코딩을 진행하였을 때 떨어지는 성능이라고 한다. 가운데에 가까울수록 성능 하락 폭이 커지는 것을 보고 다이아몬드 형태의 positional encoding을 사용했다. $p_{ij}= \begin{cases} w_{ij}, & |i|+|j|\le h\ w_{hh} & otherwise \end{cases}$ 위 그림 같은 경우는 h=3으로 중간에서 3칸 밖에 있는 부분은 같은 벡터로 인코딩한다. 안쪽은 learnable parameter.

Top-k self attention

이건 특별할 거 없이 어텐션 결과에서 모든 value를 활용하는게 아니라 어텐션 스코어가 높은 k개만 사용해서 상관 없는 정보를 제외하겠다는 의도이다.

Parallel bidirectional context model

빠른 병렬처리를 위해서 checkerboard 형태로 공간상에서 2조각을 내어 하나씩 코딩한다.

인코더 디코더는 별로 안중요해서 Entropy model 내부만 봐보자

Overview

그림과 같이 세줄 구조로 되어있다. 위에서부터 Local, Global, Hyperprior path이다.

오른쪽과 아랫줄을 가리는 Mask convolution으로 Autoregressive를 구현하였다. 3x3 conv라면, 000 00X XXX 이런식으로 가리는 커널을 사용한다.

첫째줄 Local

Confidence map U를 얻는 과정이다. U는 latent 각 픽셀의 quality 정보를 담은 matrix다. CxHxW 형태일텐데, C방향으로 평균내서 쓴다. 이후 확률 파라미터 $\mu_1, \sigma_1$을 예측한다. 약간 디테일로 $\sigma$를 바로 예측하는 것에 비해 $log\sigma$를 예측하는게 더 안정적이라고 한다.

둘째줄 Global

Similarity map S를 얻고, U,S를 활용한다.

Cosine similarity로 하는데, mask convolution 하는 것 처럼 윗줄과 왼쪽 픽셀까지 4개 픽셀들을 사용해서 cosine similarity를 측정한다. 이렇게 얻은 S와 U로 Local path에서 얻은 $\mu_1, \sigma_1$를 업데이트 한다 ->$\mu_2, \sigma_2$

셋쨰줄 Hyperprior

다른 모델과 같이 z에서부터 위에서 얻은 $\mu_2, \sigma_2$를 업데이트해서 최종 $\mu_3, \sigma_3$을 얻어서 각 latents의 확률을 예측한다.

주로 보던 딥러닝 논문과는 다르게 엄청 자세한 알고리즘까진 언급이 안되어 있다. 아마 기존 고전 코덱들에서 쌓아 올려온 기술이기에 그런듯 하다.

인코더: Prediction -> transformation(ex. DCT) -> encoding(to bitstream)

디코더: Decoding -> inverse transformation(ex. IDCT) -> reconstruction

로 이루어져 있다.

과정

1) Prediction

이전 프레임들을 기반으로 현재 프레임을 예측한다. 이후 그 residual 영상만 저장한다.

2) Transformation

Prediction error를 조각내서 DCT와 같은 inverse가 존재하는 방식으로 분해한다.

3) Quantization

반올림같이 적당히 값을 날려준다.

4) Entropy coding

실제 전송에 사용할 bitstream 형태로 변환해준다. Huffman coding 같은 변환을 수행한다고 보면 된다.

5) Entropy decoding

bitstream을 실제 값을 다시 복원한다.

6) Inverse transformation

IDCT와 같이 변환에 사용한 역연산을 수행한다.

7) Reconstruction.

예측했던 프레임과 디코딩 결과를 합친다.

특징

Mode in H.264

블록별로 코딩을 수행할 때 참조하는 이전 블록들의 위치 방향을 모드라고 지칭한다.

16x16 크기를 macro block으로 지칭하고, 각 macro block을 quadtree로 쪼개면 8x8 블록 4개가 된다.

Deblocking filter

디코딩 과정 중에 포함되는 in-loop filter과 디코딩 이후 RGB / Luminance, chrominance에 직접 수행하는 post-processing 방식이 있다. 구체적으로 어떤 필터를 사용하는지는 논문에 포함되어 있지 않다. 참조한 이전 논문들 중 하나에 있을 것 같다.

ICLR 2024 논문으로 딥러닝을 이용한 이미지 압축 논문이다. (코드 O)

Contributions

• 인코더, 디코더 내에 Swin transformer의 4가지 형태로 윈도우 설정

• 인코더 디코더 FFN 부분에 주파수 변환 -> linear -> 역변환 수행

• Entropy module의 autoregressive를 masked transformer 형태로 구현하였다.

Overview

전체 모델 구조 그림이다. RBS: Residual block with stride RBU: Residual block with upsampling FAT: Frequency Aware Transformer

인코더, 디코더

여느 CNN+Transformer 조합의 autoencoder 구조와 같이 CNN 구조인 RBS / RBU와 Swin transformer 기반의 FAT block의 반복으로 이루어져 있다.

FAT (Frequency Aware Transformer)

4가지의 윈도우 형태

기존 Swin과 다르게 윈도우 형태를 4가지로 사용하였다. 위 그림과 같이 각 윈도우의 특성에 따라 얻을 수 있는 특징이 달라진다고 한다. -> 이건 이론적으로 예측하긴 어려울 것 같고, 대충 이럴 것 같다고 상상한 뒤 실험 해봐야 떠올릴 수 있는 아이디어일 듯 하다.

FM (Frequency Modulation)

기존 Transformer의 FFN를 통과한 뒤, 주파수 영역에서 Linear 연산이 하나 추가되었다. 동일 팀에서 ICLR 2025에 낸 논문 역시 에너지 관련 언급이 많은데, 이 팀은 이쪽으로 발전시키고 있는 것 같다.

Entropy Module

사실 다른 Autoregressive 방식과 알고리즘 자체는 같지만 더 효율적인 구현을 contribution 삼은 것 같다. 기존 연구들과의 차이점:

• hyperprior encoder, decoder 내부에 FAT block을 사용
• Autoregressive 구현에 masked transformer 사용

모델 코드도 정리도 잘 되어 있고, 이해하기 좋게 짜여 있어 참조하기 좋다. 성능, hyperparameter는 직접 논문을 보면 되겠다.

• SPyNet: Spatial Pyramid Network for Optical Flow
• PWC-Net: CNNs for Optical Flow Using Pyramid, Warping, and Cost Volume
• RAFT: Recurrent All-Pairs Field Transforms for Optical Flow
• SKFlow: Learning Optical Flow with Super Kernels

Video frame interpolation

• BMBC: Bilateral Motion Estimation with Bilateral Cost Volume for Video Interpolation
• Asymmetric Bilateral Motion Estimation for Video Frame Interpolation (ABME)
• BiFormer: Learning Bilateral Motion Estimation via Bilateral Transformer for 4K Video Frame Interpolation
• Quadratic Video Interpolation
• Video Frame Interpolation with Transformer
• AdaCoF: Adaptive Collaboration of Flows for Video Frame Interpolation
• A Unified Pyramid Recurrent Network for Video Frame Interpolation

Image compression

• VARIATIONAL IMAGE COMPRESSION WITH A SCALE HYPERPRIOR
• Joint Autoregressive and Hierarchical Priors for Learned Image Compression
• Content-aware Masked Image Modeling Transformer for Stereo Image Compression
• Learned Image Compression with Discretized Gaussian Mixture Likelihoods and Attention Modules
• DPICT: Deep Progressive Image Compression Using Trit-Planes
• Context-Based Trit-Plane Coding for Progressive Image Compression
• ANFIC: Image Compression Using Augmented Normalizing Flows

Video compression P-frame codec

• DVC: AnEnd-to-end Deep Video Compression Framework
• VCT: AVideo Compression Transformer
• Deep Contextual Video Compression (DCVC)
• Neural Video Compression with Diverse Contexts (DCVC-DC)

B-frame codec

• B-CANF: Adaptive B-Frame Coding With Conditional Augmented Normalizing Flows
• Conditional Variational Autoencoders for Hierarchical B-frame Coding
• MaskCRT: Masked Conditional Residual Transformer for Learned Video Compression
• OMRA: ONLINE MOTION RESOLUTION ADAPTATION TO REMEDY DOMAIN SHIFT IN LEARNED HIERARCHICAL B-FRAME CODING
• Hierarchical B-frame Video Coding Using Two-Layer CANF without Motion Coding

기타 알아야 할것

• Correlation (cost) volume
• Forward warping / Backward warping
• Entropy (coding)
• I, B, P frame

• Openlane
• ApolloSim
• Once 등

3d lane detection 구조 논문

• 3D-LaneNet: End-to-End 3D Multiple Lane Detection
• Gen-LaneNet: A Generalized and Scalable Approach for 3D Lane Detection
• PersFormer: 3D Lane Detection via Perspective Transformer and the OpenLane Benchmark
• Learning to Predict 3D Lane Shape and Camera Pose from a Single Image via Geometry Constraint (CLGO)
• Anchor3DLane: Learning to Regress 3D Anchors for Monocular 3D Lane Detection
• LATR: 3DLaneDetection from Monocular Images with Transformer
• LaneCPP: Continuous 3D Lane Detection using Physical Priors

EigenLane

• Eigenlanes: Data-Driven Lane Descriptors for Structurally Diverse Lanes [CVPR 2022]

기타 알아야할 것

• DETR End-to-End Object Detection with Transformers
• Deformable convolution / transformer
• World(Ground) coordinate, Camera coordinate
• Coordinate transform matrix
  • Camera parameter (intrinsic, extrinsic)

이 글 많이 참조했습니다.

Customer Position column에 있는 걸로 예를 들겠습니다.

우선 전체적인 구조는

1. column에 unique를 찍어봤더니 아래와 같이 비슷해 보이는 애들이 각각 다 다르게 적혀있는 상황

'''
academic coordinator/ post graduate teacher (accountancy, business studies)/ tgt (ict)      1
academic specialist                                                                         1
administrative                                                                              5
architect/consultant                                                                        2
architecture/consult                                                                        1
                                                                                         ... 
técnico                                                                                     1
unpaid                                                                                     16
vice president                                                                            492
vicepresident                                                                              11
vp                                                                                          1
Name: position, Length: 117, dtype: int64
'''

1. 각 단어들이 가진 의미를 기반으로 Clustering을 하고 싶다.

   1) / , . ( ) 같은 의미 해석에 방해되는 특수 문자 제거

   2) 띄어쓰기 단위로 분리:academic specialist →['academic', 'specialist']

   3) 미리 누군가가 학습시켜 둔 모델 불러오기

   4) 임베딩 이라고 칭하는 단어별 벡터 추출, 위 예시처럼 두 개 이상의 단어를 가진 경우 평균내기

   5) Kmeans로 Clustering

2. PCA, 직접 찍어봐서 잘 됐나 확인하고, 군집 갯수 바꿔보며 그럴듯하게 만들기

1. 데이터 확인

다들 알고있는 value_counts, unique를 쓴다.

이때 뒤에 sort_index를 붙이면 abc 순서, sort_values를 붙이면 많은 순서로 나열된다.

또 너무 많아서 …으로 생략된걸 보고 싶으면 아래 코드 첫줄을 넣어준다.

원래대로 하고싶다면 None 대신 80넣고 실행

# print할 때 보이는 줄 수 설정하기. 
# 80이 default라 아무것도 원래 찍히던 만큼을 생각하면 되고
# None을 넣으면 모든 줄이 다 찍힌다.
pd.set_option('display.max_rows', None)
customer['job'].value_counts().sort_index()

2. Clustering 시작

전처리 → 임베딩 추출 → 군집화 순으로 간다.

2-1) 전처리

특수문자 쓰인 게 몇 개 없어서 어렵게 코드 안쓰고 replace 하드 코딩 했다.

for idx,position in enumerate(customer['position'].unique()):
# position이 텍스트
    temp = position.replace('/',' ').replace('(',' ').replace(')',' ').replace('-',' ').replace('.',' ').replace(',',' ')

띄어쓰기 단위로 나눠준다.

    position_parsed = temp.split(' ')

오타+띄어쓰기 실수가 같이 있는 경우까지 커버 하지 못하지만 시도해 본 것 (궁금한 사람은 해보세요)

• 오타 잡기

  수연이가 얘기해 줬던 Textblob을 이용했다.

    from textblob import TextBlob
    blob = TextBlob('mindenes')
    print(blob.correct())
    # mindedness

  사용 방법은 라이브러리 다운받아서 TextBlob에 오타가 의심되는 단어를 넣고 .correct()를 찍어보면 된다.

• 띄어쓰기 잡기

  Word segmentation in a nutshell. 이걸 참조했다. 링크에 있는 segmentation.py를 이용할 것이다. 얘도 다른 사람이 학습 시켜둔 ngram모델을 불러와서 사용한다. ngram모델을 다운 받아야 한다.

  segmentation.py

  코드와 모델을 다운 받았다면 코드 맨 아래에 onegrams 세 개 중 본인이 다운 받은 모델 이름을 잘 확인해서 고쳐주면 된다.

  이 글에 써둔 파일을 다운 받았다면 아래처럼 쓰면 된다.

준비는 끝났다. 다시 원래 코드로 돌아와서

```python
from segmentation import OneGramDist,onegram_log,segment
import functools
onegrams = OneGramDist(filename='count_1w.txt')
onegram_fitness = functools.partial(onegram_log, onegrams)
```

!python ~~ 이런식으로 말고 ipynb파일에서 모듈처럼 불러와 사용하기 위해 segmentation.py파일의 main 함수 안에 있던 불러올 애들을 가져온다.

    sentence = 'levelexecutive'
    best = segment(sentence, word_seq_fitness=onegram_fitness)
    print(best)
    '''
    ['e'] -2.996351267959003
    ['v', 'e'] -6.455154678229892
    ['ve'] -4.890746540792021
    ...
    ['levelexecuti', 've'] -26.660215605718577
    ['levelexecutiv', 'e'] -25.76582033288556
    ['levelexecutive'] -23.769469064926557
    ['level', 'executive']
    '''

그러면 모델이 여러 번 쪼개보더니 가장 그럴듯한 녀석으로 쪼개서 알려준다.

2-2) word2vec 모델 불러오기

gensim이라는 라이브러리에 잘 되어 있다.

import gensim
word2vec_model = gensim.models.KeyedVectors.load_word2vec_format('경로/GoogleNews-vectors-negative300.bin', binary=True)

오타나 띄어쓰기 같은거 떄문에 FastText를 사용해봤지만 clustering을 잘 못해서 word2vec 모델 사용.

https://drive.google.com/file/d/0B7XkCwpI5KDYNlNUTTlSS21pQmM/edit

여기 미리 학습시켜둔 모델을 다운받아 사용한다.

아래와 같은 함수들을 사용할 수 있다.

# 두 단어가 얼마나 비슷한지 확률로 알려준다
word2vec_model.similarity("vicepresident","vp")
# 300개의 -1 ~ 1 사이 숫자들로 단어를 변환(임베딩)해 준다.
word2vec_model.get_vector(word)

이제 이걸 이용해서

vectors = pd.DataFrame({'name':[]})
for idx,position in enumerate(customer['position'].unique()):
    position_parsed = 전처리한 단어 리스트
    vec = np.array([0.0]*300)
    cnt=0
    for word in position_parsed:
        if word!=' ' and word!='':
            try:
                vec+=np.array(word2vec_model.get_vector(word))
                cnt+=1
            except:
                oob+=1

1. 데이터들의 임베딩을 저장할 DataFrame을 하나 생성한다.

2. unique() 리스트에서 하나씩 뽑아와 앞에 했던 전처리를 거친 뒤,

3. vec이라는 길이 300짜리 (임베딩의 길이가 300이다) float로 된 array에다가 각 단어의 임베딩을 더해준다.

   평균 낼 때 쓰기 위해 cnt변수에 이 데이터가 몇 개의 단어를 포함하는지 저장해 둔다.

4. 근데 만약 오타 같은 모델이 모르는 단어가 나왔을 때 OOB(out of bag) 문제가 발생한다.

   이거 때문에 try ~ except를 넣어 모르는 단어는 그냥 패스 한다.

if cnt!=0:
        vec /= cnt
else:
    print('no clue',position)
vectors.loc[idx] = [position,*vec]

평균 내고, 만약 데이터에 포함된 단어들 중 하나도 모른다면 뭔지 확인하기 위해 프린트 하나 넣어 줬다.

전체 코드

vectors = pd.DataFrame({'name':[]})
oob=0
for i in range(300):
    vectors[f'vector{i}']=[]
for idx,position in enumerate(customer['position'].unique()):
    temp = position.replace('/',' ').replace('(',' ').replace(')',' ').replace('-',' ').replace('.',' ').replace(',',' ')
    position_parsed = temp.split(' ')
    vec = np.array([0.0]*300)
    cnt=0
    for word in position_parsed:
        if word!=' ' and word!='':
            try:
                vec+=np.array(word2vec_model.get_vector(word))
                cnt+=1
            except:
                oob+=1
    if cnt!=0:
        vec /= cnt
    else:
        print('no clue',position)
    vectors.loc[idx] = [position,*vec]
print(oob)
'''
no clue bulgaria
no clue gerente
no clue tierarzt
no clue exhibitiontv
no clue proprietário(a)
no clue genel müdür
no clue mindenes
no clue főorvos
23
'''

아예 감도 못 잡은 데이터가 8개

oob가 23개 (찍어보니 a, of 보통 불용어 처리 하는 건 모델에 없는 듯 하다.)

나름 준수하게 처리한 것 같다면 다음단계로 가고, 못 찾은게 너무 많다면 전처리나 위의 오타/띄어쓰기 수정을 시도해 보자.

3) Clustering

Kmeans를 이용할 예정이다.

from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=8, max_iter=1000)
kmeans.fit(vectors.drop(['name'],axis=1))

앞서 만들어 둔 vectors df를 이용할 거고, 임베딩 벡터만 사용할 것이니 이름을 저장했던 name은 떼고 fitting 해 주자.

n_clusters는 이것 저것 시도해 보고 괜찮아 보이는 걸로 하자.

3. 확인

from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pcafit = pca.fit_transform(vectors.drop(['name'],axis=1))
x = pcafit[:,0]
y = pcafit[:,1]
import matplotlib.pyplot as plt
plt.scatter(x,y,marker='.',c=kmeans.labels_[:])
for i,v in enumerate(vectors['name'][:50]):
    plt.annotate(v[:7],xy=(x[i],y[i]))
plt.show()

PCA로 2차원 평면에 점을 찍어 확인해 보자.

PCA로 임베딩(300 차원)을 2차원으로 압축해 준다.

plt scatter로 잘 됐나 확인해 보자. 밑의 반복문은 포인트에 라벨링 해주는 부분인데,

v[:7] 해놓은 이유는 v가 이름인데, 전부다 라벨링 해주면 점들이 너무 많아서 글자가 안보인다. 그러니 반복문 횟수 조절이나 표시하는 글자수 적절히 조절해서 보면 된다.

잘 모르겠다면 class마다 찍어서 확인해 보자

vectors[kmeans.labels_==6]['name']
'''
19                      physics teacher
41                      science teacher
67    teacher/middle school coordinator
71             math and physics teacher
73      physics and mathematics teacher
75                             educator
86                    chemistry teacher
89                              teacher
Name: name, dtype: object
'''

확인해 보고 kmeans의 n_cluster를 조정하거나 kmeans말고도 다른 알고리즘을 고민해 보자

딥러닝을 이용한 자연어처리 입문 7시간 완성 - 메타코드M https://www.youtube.com/watch?v=Rf7wvs8ZbP4&ab_channel=%EB%A9%94%ED%83%80%EC%BD%94%EB%93%9CM

6회차는 GPT, BERT 입니다. 드디어 마지막이네요.

BERT나 GPT나 전에 배웠던 Glove, Fast text, SGN, CBOW 같은 word2vec 모델의 일종이다.

미리 대용량 corpus로 학습된 모델을 받아 원하는 task에 해당하는 부분을 transfer learning으로 fine tune 해줘서 사용하면 된다.

1. BERT

먼저 BERT를 알아보자.

Bidirectional Encoding Representation from Transformer (BERT)

여기서 Bidirectional: 양방향성을 띄고, Encoding: Transformer의 Encoder부분을 활용할 것이다. 이정도 기억하고 가봅시다.

먼저 Bidirectional 4회차때 Bi-LSTM 구조를 공부했었다. LSTM 모델을 쌓는데, 앞으로도 데이터를 참고하고, 뒤로도 참고하는 그런 구조를 띄었다. BERT도 비슷하다. 예를 들어 I love ___ so much. 라는 문장이 있다. 가운데 빈칸에 들어갈 단어를 예측하기 위해 앞의 I love, 뒤의 so much 둘다 참고하여 'you'를 예측한다.

구체적인 구조를 살펴보자

출처: https://tutorials.pytorch.kr/intermediate/dynamic_quantization_bert_tutorial.html

1. (분홍색) 문장 2개를 input으로 받아 두개 사이는 [SEP] 토큰으로 구분한다.

2. (노란색) 3개의 embedding: Token Embedding - 문장 토큰화 결과 Segment Embedding - 문장 단위 임베딩 (앞 문장인지 뒤 문장인지) Position Embedding - 몇번째 임베딩인지. (Transformer encoder의 position embedding과 같다.) 을 합친다.

3. (가운데) Transformer Layer를 거친다. Trasnformer의 encoder부분: Multi-head self-attention -> Add&Norm -> Feed forward -> Add&Norm 을 여러개 쌓아 학습시킨다. 논문 저자의 실험결과, 12 transformer block / 768 hidden size / 12 self-attention head 로 이루어진 구조가 최적이라고 한다.

   출처: https://wikidocs.net/115055

4. (초록색) 마지막 layer의 output으로 두가지(MLM, NSP)를 확인한다.

Masked Language Model (MLM): 처음 문장을 input으로 넣어 줄 때 일부 단어를 mask 씌워 입력하고, 이후 출력단에서 맞게 예측했는지 loss를 계산한다.

• 전체 문장의 15%를 Masking 한다.

  • 그 중 80%는 그대로 masking
  • 10%는 random word로 치환
  • 10%는 원래 단어 그대로 두고

  성능을 계산한다.

Next Sentence Prediction (NSP): 앞 뒤 문장이 서로 이어지는가 예를 들어 A: I studied hard today B: It is hard to predict stock market 라면 두 문장이 서로 이어지지 않는다. -> label=0 이어지는가/안 이어지는가 판단하는 Binary Classification과 같다. Output 중에서 Class Label 값으로 label 값과 비교한다.

이후 원하는 task에 맞춰

문장 유형을 판단하는 task라면 class label값만 활용하면 되고, 각 단어의 품사를 tagging하는 task라면 각 토큰들의 output 모두를 이용하는 식으로 활용하면 된다.

2. GPT

BERT와 다르게 앞으로만 예측한다. 즉, I love ___ very much. 라는 문장이 있으면 [ ] -> [I]

[ I ] -> [I love]

[I love] -> [I love you]

이런식으로 빈칸에 들어갈 단어를 앞의 단어들로만 예측한다.

구조

출처: https://paperswithcode.com/method/gpt

오른쪽 부분은 원하는 Task에 맞게 마지막 layer에 붙여주면 된다는 의미고 실제 모델 구조는 Transformer의 Decoder 구조인 왼쪽 모습이다. Masked multi Self attention -> Layer norm -> Feed forward -> Layer norm

코드 구현

pytorch-transformer 라이브러리를 다운받으면 다양한 버전의 BERT를 쓸 수 있다.

총정리

BERT GPT 까지 알아봤다. 알기 전에는 뭔가 어마어마한 구조일 것 같았는데, Vision으로 비유하면 CNN 공부하고, CNN 어떻게 쌓았느냐에 따라 모델이름 붙이는 것 처럼 Transformer를 어떻게 활용했느냐에 따라 BERT, GPT가 되는거라 아는만큼 보이는걸 다시 느꼈다.

이제 플젝 해보면서 NLP가 어떻게 돌아가는지 자세히 알아보자 + llm 관련해서도 알아보게 llama 논문 읽어보자

https://arxiv.org/abs/2208.06366

Abstract

앞선 BEIT v1 논문에서 vision transformer를 학습시킬 때 사용했던 Masked Image Modeling(MIM) 을 이번에도 사용할 건데, v1보다 좀더 high-level semantic을 잘 학습하도록 업그레이드 한 visual tokenizer를 제시한다. Vector-quantized knowledge distillation 을 활용할 것이다. patch aggregation strategy 로 discrete한 image patch들로부터 global semantic representation을 잘 보도록 곁들인다.

1. Introduction

기본은 BEIT v1과 같이 MIM 방식으로 학습 시키고, image patch 와 visual token 두가지를 학습 재료로 쓸 것이다. 복습: 원본 이미지를 자르고, 토큰화 하여 visual tokens를 만들고 토큰들 중 일부를 mask로 가려 image patches로부터 가린 visual token을 맞추는 방식으로 학습한다.

MIM 학습 방식은 크게 복원 대상을 기준으로 3가지로 나눌 수 있는데, 1. 픽셀값 자체(low-level image elements), 2. hand-crafted features, 3. visual tokens(-BEIT). 하지만 이 세가지 모두 직/간접적으로 픽셀값을 맞추는 거랑 크게 다르지 않다. 하지만 NLP 학습을 보면 high-level semantic으로 학습을 하고 있기 때문에, 거기에서 발전 가능성을 보고 출발 했다.

이 논문에서 Semantic-aware visual tokenizer를 학습 시킬 것이다. Vector-quantized Knowledge Distillation(VQ-KD) 알고리즘으로 semantic space를 표현한다.

1. VQ-KD encoder가 이미지를 learnable codebook에 따라 discrete token으로 변환 한다.
2. Decoder는 이 discrete token을 가지고 teacher model이 encode한 semantic feature를 복원하는걸 학습한다.
3. VQ-KD가 학습이 끝나면, encoder는 BEIT v1 구조에서 semantic visual tokenizer로 쓴다.

token들이 discrete한 상태이기 때문에 [CLS] token이 global한 image representation을 학습하도록 patch aggregation strategy를 적용한다.

2. Methodology

리마인드 차원에서 BEIT v1의 image patch - visual token 구조 v2에서는 visual token을 만드는데 vector-quantized knowledge distillation 알고리즘을 활용할 예정 patch aggregation strategy 곁들인다.

2.1 Image Representation

원본 이미지의 representation을 얻기 위해 Backbone network로 ViT를 쓴다. 원본 이미지를 쪼개 얻은 image patch를 ${x_i^p}{i=1}^N$, ViT의 output; encoding vector를 ${h_i}{i=1}^N$로 쓴다. N은 patch 총 갯수에 해당한다.

2.2 Training Visual Tokenizer

VQ-KD를 활용할 예정이고, visual tokenizer, decoder로 이루어진 구조이다.

Visual tokenizer 가 이미지를 visual tokens; discrete codes 으로 매핑한다. 즉, 이미지 $x$를 토큰 $z = [z_1,z_2,...,z_N] \in \nu^{(H/P) \times (W/P)}$으로 토큰화 한다. 이때, $\nu$가 codebook의 code 하나에 해당해서 $\nu \in R^{K\times D}$; K discrete codebook embedding을 가진다.

이 Tokenizer는 vision transformer encoder와 quantizer로 이루어져 있다. Tokenizer가 먼저 이미지를 vector($h_i)$로 만들고, quantizer가 codebook에서 nearest neighbor을 찾아 codebook embedding($v$)을 매칭해 준다. Nearest neighbor를 $l_2$ norm으로 찾는 과정을 수식으로 보면 $z_i = arg_jmin||l_2(h_i)-l_2(v_j)||_2$

• Cosine similarity를 찾는 과정과 동일하다.

Visual Tokens를 만들면, decoder에 $l_2$-normalized codebook embedding ${l_2(v_{z_i})}{i=1}^N$을 넣어 준다. decoder도 multi-layer transformer구조로 이루어져 있다. decoder의 output vectors ${o_i}{i=1}^N$ 로 teacher model(DINO, CLIP)의 semantic feature를 학습한다. 즉, teacher model의 feature vector $t_i$와 decoder의 output $o_i$사이의 cosine similarity가 커지도록 학습한다.

Quantization process는 미분이 불가능하기 때문에 encoder output을 학습시키기 애매해서, decoder input단의 gradient를 그대로 encoder의 output에 복붙한다.

전체적인 학습 식은 다음과 같다.

D: tokenizer 학습에 쓴 이미지 Data pool sg[ ] : forward pass 일땐 identity, backward pass일땐 0으로

하나씩 보자.

• $max\Sigma\Sigma$ -> 모든 이미지의 각 패치에 대해 계산한 값을 최대로 하겠다.
• $cos(o_i,t_i)$-> decoder에서 decoder output과 teacher model의 feature vector 사이의 cosine similarity를 최대화 (비슷하게)
• $-||sg[l_2(h_i)]-l_2(v_{z_i})||^2_2-||l_2(h_i)-sg[l_2(v_{z_i})]||^2_2$

• forward pass: 학습할 때는 encoder output과 매핑된 codebook embedding vector 사이의 $l_2$ 거리 최소화

• backward pass: $-||l_2(v_{z_i})||^2_2-||l_2(h_i)||^2_2$ -> gradient를 업데이트 할 때는 각 vector 크기를 줄인다? (이부분은 잘 모르겠다.)

문제가 있다. Codebook을 쓸 때 'codebook collapse'가 발생한다. ; code들 중 일부만 사용하는 현상. Empirical strategy 로 해결 가능하다. Encoder output 과 codebook 매핑 할 때 $l_2$ norm을 계산한다 했었다. 이때 codebook space embedding 을 32-d로 줄여서 계산하고, 실제 decoder로 넘어가기 전에 dimension을 키워서 전달하는 방식이다. Exponential moving average 를 계산해 codebook embedding을 업데이트 한다.

2.3 Pretraining BEIT v2

BEIT v1 논문에 등장했던 masking 규칙을 따른다. 요약하자면

• MIM을 할 때 image patches 앞에 학습 가능한 CLS 토큰을 붙인다.
• 특정 규칙에 따라 40% 정도에 해당하는 패치를 masking 한다.
• masking 한다는 건 원래 image patch 대신 학습가능한 패치 $e$로 대체한다.
• 마스킹된 부분을 포함한 image patch들로 2.2에서 만든 visual token을 softmax classifier로 예측하도록 학습한다.
• Cross Entropy로 loss 연산

Pretraining Global Representation

[CLS] 토큰이 global representation 담당이다. [CLS] 토큰을 학습시키기 위해 $l$번째 layer의 output vectors($h^l$)와 마지막 layer(L번째)의 output에서 CLS 토큰을 concat한다. -> $S=[h_{CLS}^L,h_1^l,h_2^l,...,h_N^l]$ 이제 이걸 Shallow Transformer decoder에 집어넣는다. figure 3의 오른쪽 두 ViT block이다. Shallow Transformer decoder 부분은 [CLS] 토큰 학습할 때만 사용해서, 학습 이후엔 안쓴다. 이 shallow transformer output으로 MIM loss 계산을 한다. 최종 Loss는 마지막 layer에서 계산한 MIM loss + shallow~에서 계산한 MIM loss 가 된다.

이유 부분 설명을 직관으로 해 두었는데 잘 이해가 안된다.

3. Experiments

각종 hyperparameter setting patch size, ViT 크기, layer 수, epoch 수 등

3.4 Analysis

• Decoder로 Deeper ViT를 사용하는게 성능이 MIM에 있어 좋지만, codebook usage와 downstream task 성능은 낮아지는 경향을 보인다.

• Codebook의 dimension 수를 줄이는게 codebook utilization을 올린다.

• Patch aggregation strategy (CLS 토큰 학습용 부분) l th layer는 9, head depth를 2로 하는게 좋은 성능을 보였다.

• VQ-KD target model로 (teacher model) CLIP, DINO 실험 결과 CLIP 성능이 좋았다.

• Visualization of codebook

4. Related Work

Visual Tokenizer

VQ-VAE 연계 연구들에서 이미지를 토큰화하는 방식들이 제안되었다.

Masked image Modeling

MIM method가 여러 연구서 등장한 바 있다.

총정리

논문 볼때마다 공부해야할게 늘어난다. Knowledge Distillation 알아보자 얼른 Transformer 자세히 파보자. CLS token, ViT 대충 아는걸 채워야겠다. 날잡아서 코드도 한번 파자.

딥러닝을 이용한 자연어처리 입문 7시간 완성 - 메타코드M https://www.youtube.com/watch?v=Rf7wvs8ZbP4&ab_channel=%EB%A9%94%ED%83%80%EC%BD%94%EB%93%9CM

5회차는 attention 이론과 LSTM, seq2seq 실습입니다.

1. Attention

attention 관련 정리는 한 번 한적이 있기에 아래링크로 대체 https://velog.io/@_chominseo/SEQ2SEQ-Attention

2. 실습

단순 구조

FC layer 2개와 output layer로 이루어진 단순한 구조 먼저 만들어 보자

class ANN(nn.Module):
    def __init__(self,num_output,input_size,hidden_size,device='cpu'):
        super(ANN,self).__init__()
        self.device = device
        self.fc1 = nn.Linear(input_size,hidden_size)
        self.fc2 = nn.Linear(hidden_size,hidden_size)
        self.outlayer = nn.Linear(hidden_size, num_output)
    def forward(self,x):
        h = self.fc1(x).relu()
        h = self.fc2(h).relu()
        predict = self.outlayer(h)
        return predict

input size -> hidden size -> hidden_size -> num_output 으로 channel수를 구성한 구조이다.

LSTM

출처: https://wikidocs.net/152773 LSTM 구조를 다시 보면 input과 이전 시점의 cell state, hidden state 가 들어가 다음 LSTM block을 위한 cell state, hidden state를 만들고, output 하나를 뽑아 낸다.

class LSTM_net(nn.Module):
    def __init__(self,num_output,size_vocab, dim_embed, hidden_size,linear_size,num_layers,device='cpu'):
        super(LSTM_net,self).__init__()
        self.device = device
        self.num_output = num_output
        self.hidden_size = hidden_size
        self.num_layers = num_layers

        self.embed = nn.Embedding(size_vocab,dim_embed)

        self.lstm = nn.LSTM(input_size = dim_embed, hidden_size = hidden_size, num_layers = num_layers, dropout = 0.3, bidirectional = True)
        self.fclayer = nn.Linear(hidden_size, linear_size)
        self.outlayer = nn.Linear(linear_size, num_output)

    def forward(self, x):
        scaler = 2 if self.lstm.bidirectional == True else 1

        emb = self.embed(x)

        h_state = Variable(torch.zeros(self.num_layers*scaler,emb.size(0),self.hidden_size,requires_grad=True)).to(self.device)
        c_state = Variable(torch.zeros(self.num_layers*scaler,emb.size(0),self.hidden_size,requires_grad=True)).to(self.device)

        lstm_out,(h,c) = self.lstm(emb.transpose(1,0),(h_state,c_state))
        h = h[-1]
        h = self.fclayer(h).relu()
        predict = self.outlayer(h)
        return predict

forward 함수를 기준으로 부분 부분 뜯어 보자

emb = self.embed(x)

x를 input으로 생각하면 된다. x가 들어와 self.embed를 거친다.

self.embed = nn.Embedding(size_vocab,dim_embed)

nn.Embedding이 등장하는데, 이건 x를 가지고 학습가능한 embedding vector를 생성해준다. size_vocab은 전체 단어 종류, dim_embed는 embedding vector를 몇 channel로 뽑을 것인지 정해주면 된다. 즉, x 라는 문장이 들어가면 [batch, size_vocab, dim_embed] 크기의 embedding vector 가 생성된다.

다음

h_state = Variable(torch.zeros(self.num_layers*scaler,emb.size(0),self.hidden_size,requires_grad=True)).to(self.device)
c_state = Variable(torch.zeros(self.num_layers*scaler,emb.size(0),self.hidden_size,requires_grad=True)).to(self.device)

LSTM이 만들어내는 hidden state와 cell state들을 일단 0으로 다 초기화 해 준다. shape은 [num_layers, batch, hidden_size] num_layers: LSTM block을 몇 번 쌓을 건지 hidden_size: LSTM 안에서 돌아가는 channel 수

scaler는 bidirectional 하게 할지 고려하는 부분이니 양방향으로 간다면 기존의 2배가 필요해서 scaler를 곱해준다.

다음

lstm_out,(h,c) = self.lstm(emb.transpose(1,0),(h_state,c_state))

LSTM에 input에서 얻은 embedding vector와 hidden state, cell state를 지정해 돌려준다. 이때 emb.transpose 부분에서 기존 shape이 [batch, size_vocab, dim_embed] 였던 emb를 [size_vocab, batch, dim_embed] 로 바꿔 넣어줘야 한다. (--batch size가 두번째에 오게)

다음

h = h[-1]
h = self.fclayer(h).relu()
predict = self.outlayer(h)
   return predict

classification task에서 필요한 부분은 마지막 h 또는 c 만 있으면 되기 때문에 마지막 h만 FC layer에 넣고, outlayer에 넣어 class 갯수만큼의 channel 수로 만들어 준다.

전처리

3회차에서 했던 전처리 과정 참조

토큰화, 정제/추출, 정수인코딩 까지 해주자.

Padding

각 문장별로 포함된 토큰 수가 다 제각각이기 때문에 가장 긴 문장 기준으로 나머지 문장에 Padding을 추가해 주자.

maxlen = 100
rowdata = []
for w in text_encoded:
    if len(w)>=maxlen:
        rowdata.append(w[:maxlen])
    else:
        rowdata.append(np.pad(w,(0,maxlen),'constant',constant_values=0)[:maxlen])
text_padded = np.concatenate(rowdata,axis=0).reshape(-1,maxlen)
print(text_padded.shape)

근데 가장 긴 문장이 너무 길어서 100 토큰만 봐도 판단할 수 있으리라 생각하여 최대 길이를 100으로 하고, 긴 문장은 잘라주고, 짧은 문장은 np.pad 함수를 활용해 <pad> 의 토큰 값을 0으로 늘려 주자.

Dataset, DataLoader

from torch.utils.data import DataLoader, random_split
from torch import LongTensor as LT
from torch import FloatTensor as FT

class Generate_Dataset(torch.utils.data.Dataset):
    def __init__(self,xdata,ydata,device='cpu'):
        self.x_data = xdata
        self.y_data = ydata
        self.device = device
    def __len__(self):
        return len(self.x_data)
    def __getitem__(self,idx):
        x = LT(self.x_data[idx]).to(self.device)
        y = LT(self.y_data[idx]).to(self.device)
        return x,y

x에 문장, y에 분류 문제 라벨값을 넣어 LongTensor 형태로 반환하는 class를 정의하자. vision 할 때는 cv2로 이미지 열어 그냥 tensor로 만들어 반환했는데 단어는 정수 인코딩을 했기 때문에 int형을 쓸 때 쓰는 Longtensor로 지정해 반환한다.

dataset = Generate_Dataset(text_padded,text_label.reshape([-1,1]))
train_dataset,test_dataset = random_split(dataset,[int(len(dataset)*0.8),int(len(dataset)*0.2)])
train_loader = DataLoader(train_dataset,batch_size=256,shuffle=True)
test_loader = DataLoader(test_dataset,batch_size=500,shuffle=False)

dataset, data loader를 정의해 주자.

모델 정의 및 학습

lstm_net = LSTM_net(num_output=2, size_vocab=5000,
                    dim_embed=64,hidden_size=64, linear_size=64,num_layers=2)
optimizer = torch.optim.Adam(lstm_net.parameters(),lr = 0.01)

앞에서 만든 LSTM 모델을 정의하자. size vocab에 내가 쓴 tokenizer가 정수 인코딩 할 때 최대로 쓴 숫자(--unique한 token 수)보다 크게 써야한다. optimizer는 adam을 썼다.

from tqdm import tqdm
def train(train_loader):
    for epoch in range(10):
        epoch_loss = 0
        for x,y in tqdm(train_loader):
            predict = lstm_net(x)
            loss = torch.nn.functional.cross_entropy(predict,y.ravel())
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            epoch_loss+=loss.item()
        print(f'train epoch {epoch+1} loss: {epoch_loss:6f}')

tqdm이 퍼센트, 남은시간을 알려줘서 좋다. 한 에폭마다 평균 loss값을 찍게 해 놨다.

loss function으로 cross entropy를 사용 했다. 여기서 y.ravel()이 등장한다. 1차원으로 평평하게 펴주는 함수이다. 예를 들어, [[1,2],[3,4]] 인걸 [1,2,3,4] 로 만들어주는 함수이다.

100%|██████████| 32/32 [00:12<00:00,  2.47it/s]
train epoch 1 loss: 22.009017
100%|██████████| 32/32 [00:15<00:00,  2.08it/s]
train epoch 2 loss: 20.640763
100%|██████████| 32/32 [00:15<00:00,  2.13it/s]
train epoch 3 loss: 18.696785
100%|██████████| 32/32 [00:14<00:00,  2.14it/s]
train epoch 4 loss: 16.637502
100%|██████████| 32/32 [00:14<00:00,  2.14it/s]
train epoch 5 loss: 15.229966
100%|██████████| 32/32 [00:14<00:00,  2.18it/s]
train epoch 6 loss: 14.672411
100%|██████████| 32/32 [00:14<00:00,  2.17it/s]
train epoch 7 loss: 14.386816
100%|██████████| 32/32 [00:14<00:00,  2.15it/s]
train epoch 8 loss: 14.013005
100%|██████████| 32/32 [00:15<00:00,  2.13it/s]
train epoch 9 loss: 13.750575
100%|██████████| 32/32 [00:14<00:00,  2.19it/s]
train epoch 10 loss: 13.491799

요런식으로 찍힌다.

Test

def test(test_loader):
    score = 0
    cnt = 0
    for x,y in tqdm(test_loader):
        predict = lstm_net(x).argmax(1).detach().numpy()
        answer = y.ravel().detach().numpy()
        for i in range(len(predict)):
            cnt+=1
            if predict[i]==answer[i]:
                score+=1
    print(f'test score: {score/cnt*100:6f}%')

마지막 열심히 학습시켰으니 점수를 확인해 보자

전체 갯수에서 정답인거만 카운트해 accuracy를 찍는다.

100%|██████████| 4/4 [00:01<00:00,  2.42it/s]test score: 69.600000%

70점 정도 나온다.

seq2seq

seq2seq는 encoder - decoder로 이루어진 구조고, 각각 안에는 LSTM들이 쌓여있는 형태다. 위 그림처럼 번역 task를 한다고 가정하자.

Encoder

class seq_Encoder(nn.Module):
    def __init__(self, vocab_size, dim_embed,hidden_size,num_layers,dropout):
        super().__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers

        self.embed = nn.Embedding(vocab_size, dim_embed)
        self.lstm = nn.LSTM(dim_embed, hidden_size, num_layers, dropout = dropout)
        self.dropout = nn.Dropout(dropout)
    def forward(self,src):
        outputs,(hidden,cell) = self.lstm(self.dropout(self.embed(src)))
        return hidden,cell

Encoder는 문장 전체를 input_data로 받아 LSTM을 통과 시킨다.

앞에서 했던 LSTM network에서 끝에 FC layer만 뺀 것과 같은 형태를 보인다. 그래야 Context Vector를 decoder에 전달할 것이다.

Decoder

class seq_Decoder(nn.Module):
    def __init__(self, output_size, dim_embed, hidden_size, num_layers, dropout):
        super().__init__()

        self.output_size = output_size
        self.hidden_size = hidden_size
        self.num_layers = num_layers

        self.embed = nn.Embedding(output_size, dim_embed)
        self.lstm = nn.LSTM(dim_embed,hidden_size, num_layers,dropout = dropout)
        self.fclayer = nn.Linear(hidden_size, output_size)
        self.dropout = nn.Dropout(dropout)
    def forward(self,input_data, hidden,cell):
        input_data = input_data.unsqueeze(0)
        embedded = self.dropout(self.embed(input_data))
        output,(hidden,cell) = self.lstm(embedded,(hidden,cell))
        prediction = self.fclayer(output.squeeze(0))

        return prediction, hidden, cell

Decoder는 encoder가 준 context vector를 받을 것이고, 매번 단어 하나만 받아 input_data로 사용할 것이다. decoder도 같고 encoder과 다른점은 FC layer까지 해서 Prediction에 해당하는게 다음 단어가 되어 hidden state, cell state와 같이 전달한다.

seq2seq

import random

class seq2seq(nn.Module):
    def __init__(self,encoder, decoder ,device = 'cpu'):
        super().__init__()
        self.encoder = encoder
        self.decoder = decoder
        self.device = device

    def forward(self,source,target,tf_ratio=0.5):
        batch_size = target.shape[1]
        translation_length = target.shape[0]
        target_vocab_size = self.decoder.output_size

        outputs = torch.zeros(translation_length, batch_size, target_vocab_size).to(self.device)
        hidden,cell = self.encoder(source)
        input_trans = target[0,:]

        for t in range(1,translation_length):
            output,hidden,cell = self.decoder(input_trans, hidden,cell)
            outputs[t] = output
            teacher_force = random.random()<tf_ratio
            input_trans = target[t] if teacher_force else output.argmax(1)
        return outputs

합치는 부분이다. 하나씩 보자

outputs = torch.zeros(translation_length, batch_size, target_vocab_size)

outputs에 최종 번역된 문장을 담을 예정이다. 미리 0으로 초기화해 둔다.

hidden,cell = self.encoder(source)

인코더에 입력 문장을 넣고 context vector를 받는다.

input_trans = target[0,:]

Decoder의 첫 입력으로 쓸 <sos>를 정의하고,

output,hidden,cell = self.decoder(input_trans, hidden,cell)

Encoder가 뱉은 hidden, cell과 함께 넣어준다.

for t in range(1,translation_length):
    output,hidden,cell = self.decoder(input_trans, hidden,cell)
    outputs[t] = output
    teacher_force = random.random()<tf_ratio
    input_trans = target[t] if teacher_force else output.argmax(1)

Decoder가 뱉은 hidden state, cell state, output을 받아 다시 decoder에 넣는 것을 반복하는데, 아래 두 줄 teacher force로 특정 decoder가 잘못 예측했을 때 정답으로 바꿔 넣어줄지 말지를 tf_ratio보다 크면 제대로, 아니면 틀린거 그대로 넣어주는 코드가 추가되어 있다.

모델 정의

enc = seq_Encoder(x_vocab_size,64,64,1,0.3)
dec = seq_Decoder(y_vocab_size,64,64,1,0.3)
seq_net = seq2seq(enc,dec).to('cpu')

번역이면 언어마다 사용한 tokenizer가 다를테니 encoder와 decoder에 들어갈 vocab size가 달라질 테니 고려해서 정의해 주자.

그러고 학습돌려주고 하면 된다.

총정리

Transformer를 사실 기대하고 이번 회차부분을 들었는데 없었고, attention 실습도 없었다. 다음 회차가 마지막 GPT BERT 이다보니 Transformer 얘기가 마구 나올텐데 미리 혼자서라도 해보자.

Encoder-Decoder 구조까지 해서 그래도 NLP 전체 프로세스를 모델 짜는 것 부터해서 해보니 감이 좀 잡히는 것 같다. (+ pytorch로 실습해주셔서 감사하다.)

https://arxiv.org/abs/2305.11033

VQA 분야 23년 6월에 나온 survey논문이다. VQA가 뭐하는건지, 어떤 모델들이 있는지, 등 알아보자

1. Introduction

VQA는 아무래도 multi-modal task 이기에 다른 modality를 합친다는데에서 어려움이 생긴다.

2. Visual Question Answering (VQA)

VQA는 image-question pair가 주어지면, 답의 정확도로 성능을 판단한다. 2017년 데이터셋인 VQA v1이 처음 나왔을 때, 도메인 불균형이나 난이도 불균형 같은 여러 문제가 많았다.

VQA의 첫 시도는 논문 지필자가 만든 데이터셋으로 57.75%를 달성한 이미지는 VGGNet으로, question은 deep LSTM으로 supervised learning 방식으로 학습한 모델이다. 그 이후로 각종 복잡한 모델들이 등장한다. bias-mitigation architectural branches, trilinear transformers, attention, external knowledge incorporation 등.

양이 많고, 고르게 분포된 데이터 셋인 VQA v2이 등장하고 현재 SOTA는 visual, language 둘 다에 large scale pre-trained Multiway Transformer를 활용한 연구가 84.03% 이다.

3. Known Approches

각종 연구들을 소개한다. - 29개 연구가 소개되어 있는데 차차 읽어 보자

4. Methodology

4.1 Datsets

VQA v1, v2 VQA CP v1,v2: VQA v1,v2 에서 answer에 bias를 줄인 버전이다. Medical VQA: medical특화로 전문가분이 만들어준 high quality 버전이다. GQA: Visual Genome 관련

4.2 Metrics

주로 나오는 평가방법을 알아보자

4.2.1 Accuracy

$Acc = min(\frac{num, of ,humans, that, provided, that, answer}{3},1)$ 주관식 객관식 모두 해당된다. human annotator 3명 이상이 정답을 인정하면 최고점을 얻는다. 가장 많이 쓰인다.

4.2.2 BLEU

BiLingual Evaluation Understudy(BLEU) 주관식 문제에 적합한 방법이다. 사람이 적은 답과 비교해 fluency, adequacy, length를 고려한다. modified precision score를 정답 후보들에 n-gram을 적용해 계산한다.

먼저, 정답 후보의 n-gram들 중 reference에 등장하는 횟수를 센다. : C 그리고, 각 reference 문장들에 같은 n-gram이 등장하는 횟수를 센다. : $R_k$ $k$: reference 문장 번호. Count clip: $C_{clip}=min(C,max,R)$ 으로 modified precision score: $p_n = \frac{\Sigma C_{clip}}{\Sigma C}$ 단어의 길이를 고려하기 위해 brevity penalty BP를 계산한다. $r_{words}, c_{words}$가 각각 reference 문장의 단어 수, candidate 문장의 단어 수로 $BP = 1$ if $c_{words} > r_{words}$ $BP = e^{\frac{1-r_{words}}{c_{words}}}$ if $c_{words} \leq r_{words}$ 최종 $BLEU = BP \times exp(\sum_{n=1}^{N} w_nlogp_n)$ N: number of n-grams, $w_n$: precision weight. 보통 1/N

6 Discussion

6.1 SOTA

BEIT-3이 현재 VQA v2 dataset 기준 SOTA이다. test-dev dataset 기준으론 PaLI가 SOTA이나 코드공개가 안돼 있고, 2등은 BEIT-3이다. VQA-CP2 기준으론 D-VQA에서 backbone을 교체하는 식으로 LXMERT, UpDn 순으로 좋다.

https://arxiv.org/abs/2106.08254

BEIT v1

Abstract

Bidirectional Encoder representation from Image Transformers(BEIT)

이미지를 image patches , visual tokens 이 두가지로 봐서 transformer를 masked image modeling 방법으로 pre-train 시키는 방법을 제안한다.

다시 말해, 이미지를 "토큰화"하여 visual tokens 로 쪼개고, 이미지를 쪼개기만 한 image patches 중 일부를 mask하여 mask된 부분의 visual token 값을 예측하도록 학습시켰다.

이후 classification, segmentation에 적용시켜 보았다.

1. Introduction

Transformer가 등장하고, vision 쪽에도 쓰이기 시작하면서, vision transformer를 학습하는데 CNN보다 더 많은 데이터가 필요해졌다. 이를 해결하기 위해 self-supervised 방식으로 해결하려 했고, contrastive learning 과 self-distillation(?) 방식으로 접근하였다.

BERT가 NLP에서 성공적이었던건 input text 일부를 mask하고 맞추는 방식으로 transformer를 학습했기 때문이다. 이 아이디어를 vision으로 끌어와서 할건데 고려할 게 있다. -> 언어와 다르게 이미지에는 pre-exist vocabulary가 없다. 따라서 mask된 부분을 예측할 때 후보라고 할 만한게 없어 softmax를 무한히 할 수도 없는 노릇이니 애매하다. -> 이걸 regression으로 각 픽셀값을 예측하게 하면 어떨까. 모델이 너무 세세한 부분(short range dependency, high-frequency detail)을 잡는데 낭비가 커진다는 문제가 생긴다.

이 논문에서 위 문제 해결을 위해 Masked Image Modeling (MIM) 을 제안한다.

1. 이미지를 패치단위로 쪼개고, 그 중 일부를 mask해 special mask embedding [M] 으로 대체하여 backbone vision Transformer의 입력으로 넣어준다. -> Image Patches
2. 이미지를 discrete VAE에서 사용한 코드로 토큰화해 준다.(-자세한건 VAE를 공부해보자) -> Visual Tokens
3. Transformer가 Image patch들을 보고 [M] 부분의 Visual token을 예측하도록 학습시킨다.

차이점: 기존엔 [M]부분의 실제 픽셀값을 예측하도록 했다면 BEIT에서는 visual token값을 예측하도록 한다.

2. Methods

input image $x$가 주어졌을 때 어떤일이 일어나는지 구체적으로 알아보자.

2.1.1 Image Patch

$x$의 shape이 $H\times W\times C$라 하면 이걸 N개의 patch로 쪼개 각 Patch $x^p$의 shape이 $P^2C$가 되도록 한다. 그러면 패치의 갯수 $N = HW/P^2$가 될 것이다. 이후 패치들을 flatten해 BEIT의 입력으로 사용된다. 구체적으로 논문에서 원본 이미지 224x224짜리를 각 패치 크기가 16x16이 되도록 총 14x14개의 패치로 쪼개 실험했다.

2.1.2 Visual Token

discrete Variational Autoencoder(dVAE)의 tokenizer를 사용했다. 픽셀 값 ; $x$들이 주어졌을 때 토큰 값 ; $z$를 계산하는 tokenizer ; $q_\phi(z|x)$과, 토큰 값 ; $z$들을 보고 다시 원본 픽셀 값 ; $x$를 복원하는 decoder ; $p_\psi(x|z)$로 이루어져있다.

따라서 학습 목표는 복원하는 decoder의 정확도를 높이는 $E_{z \sim q_\phi(z|x)}[logp_\psi(x|z)]$ 최대화 이다.

근데 visual token값들이 discrete하기 때문에 미분 불가능이라 학습할 때 Gumbel-softmax relaxation(?)을 활용했다.

또 학습시킬때 $q_\phi$는 uniform prior로 고정시켜놓고 했다.

image patch를 쪼갤때 처럼, visual token도 14x14개의 값을 가지도록 했고, vocabulary size는 8192로 설정, q는 <DALL-E: Zero-Shot Text-to-Image Generation> 논문의 것을 그대로 가져와 사용했다.

2.2 Backbone Network: Image Transformer

ViT말고, standard Transformer구조를 활용했다. Image patches $x_i^p$를 linearly project하여 $Ex_i^p$로 만들고, 앞에 Special token [s]를 붙이고, Position Embedding을 붙여 transformer의 input으로 사용했다. 즉, input vectors $H_0 = [e_{[s]},Ex_i^p,...,Ex_N^p]+E_{pos}$ 이다. 이후 L layer의 transformer block들을 거쳐 최종 L번째 layer의 output vector가 각 image patch들의 encoded representations이다.

2.3 Pre-Training BEIT: Masked Image Modeling

학습 목표는 모든 이미지 패치에서 visual token을 맞추도록 하는게 아니라 masked patch에서만 softmax를 한 결과를 가지고 계산했다.

이미지 패치들 중 mask할 때 단순 무작위로 하는게 아니라 알고리즘을 활용하여 정해진 범위내에서 0.4비율 이상 mask되도록 하였다.

딥러닝을 이용한 자연어처리 입문 7시간 완성 - 메타코드M https://www.youtube.com/watch?v=Rf7wvs8ZbP4&ab_channel=%EB%A9%94%ED%83%80%EC%BD%94%EB%93%9CM

4회차 RNN, LSTM,GRU, seq2seq, 1DCNN, Bi-LSTM 언어의 시계열 특성을 살린 인코더 구조를 알아보자

목차

1. RNN 원리 및 구조
2. LSTM, GRU
3. Seq2seq
4. 1D CNN
5. Bi-LSTM

1. RNN 원리 및 구조

약자를 풀어 쓰면 Recurrent Neural Network (RNN)이다. 여기서 recurrent 라는 말이 왜 붙었는지가 중요하다.

우선 배경 지식으로 First-Order system 은 현재 시간의 상태가 이전 시간의 상태와 관련이 있는 system이다. 수식으로 표현하면 $x_t = f(x_{t-1})$ 로 쓸 수 있다. 즉, t시점의 상태가 t-1시점의 함수로 표현 가능하다. ( 하나 더 가서 현재 시점이 앞의 두 시점과 관련 있다면, $x_t = f(x_{t-1}, x_{t-2})$는 second order system이다. )

여기까지는 현재에 추가적인 입력 없이 초기 값 ($x_0$)만 있으면 이후 모든 시점을 계산할 수 있었다. (Autonomous system)

현재 입력($u_t$)가 주어지는 경우를 수식으로 쓰면 $x_t = f(x_{t-1},u_t)$ 로 쓸 수 있다. 이제 곧 알아볼 RNN의 형태이다.

근데 t시점의 상태를 표현한 $x_t$가 관측 가능하냐 하면 관측 가능한 부분도 있고, 그렇지 않은 부분도 있다.

주식을 예로 들면, 관측 가능한 부분으로는 이전 시점의 주가, 금리, 비슷한 회사의 주가 등이 있을테고, 관측 불가능한 부분은 사람들 투자 심리, 분위기 같은게 있을 수 있다.

관측 가능한 상태만 모은 것을 출력 $y_t$로 표현하고, 수식으로는 $y_t = h(x_t)$로 $x_t$의 함수로 표현할 수 있다.

이제 RNN의 구조를 보면

출처: https://velog.io/@yuns_u/%EC%88%9C%ED%99%98-%EC%8B%A0%EA%B2%BD%EB%A7%9DRNN-Recurrent-Neural-Network

위 그림에서는 입력($u_t$)을 $x_t$, 각 시점의 상태($x_t$)를 $h_t$, 출력($y_t$)를 $o_t$로 쓰고 있음을 참고하자

가장 왼쪽부분을 보면 $x_t$가 모델에 들어가고, 출력이 다시 모델로 또 들어가는 화살표가 있다. 이거 때문에 recurrent 라는 단어가 붙었고, 이런 구조를 self feedback 이라고 부른다.

등호 오른쪽이 구조를 풀어서 그린 설명이다. parameter로는 입력-상태 사이의 $W_{hx}$, Self feedback의 $W_{hh}, b_h$, 상태-출력의 $W_{oh}, b_o$ 로 총 5개가 필요하고, 수식으로 보면

t 시점의 상태인 $h_t = \sigma(W_{hh}h_{t-1}+W_{hx}x_t+b_h)$ 로 이전 시점의 상태, 현재의 입력 에 대한 식으로 표현 할 수 있고, t 시점의 출력은 $y_t = \sigma(W_{oh}h_t+b_o)$ 로 현재의 상태 에 대한 식으로 표현 할 수 있다.

학습은 Backpropagation Through Time (BPTT)로 한다.

형태의 종류로는 many-to-many: Loss 계산시 각 시점의 출력(y)들을 모두 활용 Ex) 번역 many-to-one: 마지막 시점의 출력만 가지고 Loss 계산 Ex) 예측 one-to-many: 입력 하나만 주어진 경우 Ex) 문장 생성 가 있다.

2. LSTM, GRU

gradient flow를 제어하는 밸브 역할을 추가했다고 생각하면 된다.

출처: https://wikidocs.net/152773

각 Gate의 역할을 간단하게만 보면

1. Input Gate는 들어온 입력인 $x_t$ 를 얼마나 사용할 지 결정한다.
2. Forget Gate는 이전 시점의 상태 $h_{t-1}$를 얼마나 잊을지를 결정한다.
3. Input Gate와 Forget Gate를 거쳐 나온걸 섞어서 다음 cell로 보낸다.
4. Output Gate가 지금까지 한걸 종합해서 output을 뽑아낸다.

GRU는 LSTM의 간단화 버전인데, GRU가 간단하니 학습시간이 짧고 그런 장점은 있겠지만 둘 중에 뭐가 더 낫다는 실험을 통해서만 알 수 있다. (기본 RNN 구조보다는 당연히 둘 다 좋다.)

3. Seq2Seq

우선 등장한 이유인 RNN의 단점: Recurrent 구조인 만큼 시점 t가 반복될 수록 거기에 해당하는 Weight인 $W_{hh}$가 계속해서 곱해지는데, backpropagation을 할 때 (CNN에서 ResNet이 등장하기 전 CNN을 깊이 쌓을 때 발생하는 문제였던) Exploding/Vanishing gradient 문제가 발생한다.

Seq2Seq의 구조는 many-to-one + one-to-many 로 볼 수 있다.

인코더: 문장을 입력해 전체에 대한 정보를 담은 Context Vector를 뽑아낸다. (초기 상태 $h_0$는 랜덤하게 결정) 디코더: Context Vector를 초기 상태로 활용해 출력을 만들어 낸다. 첫 입력은 문장의 시작이라고 알려주는 <sos>를 넣어주고, $y_{t-1}$과 이전 상태를 입력으로 활용해 $y_t$를 얻고, 마지막 출력으로는 문장의 끝이라는 의미인 <eos>를 내보낸다.

학습 단계에서는 분명 이전 block이 제대로된 단어를 예측했으리란 보장이 없기 때문에 Teacher force training 으로 학습한다. 설령 $y_{t-1}$이 이상한 단어이더라도, $x_t$로는 정답을 넣어주는 방법이다.

예를 들어, 학습할 떄 그림의 두번째 block에서 je를 입력으로 받아 suis를 출력했어야 한다. 만약 suis 대신 asdf를 출력했다 하더라도 다음 block의 input으로는 정답인 suis를 넣어준다.

seq2seq도 분명 기본 RNN 구조보다 좋지만 업그레이드 버전인 Attention이 매우 효과적이다.

4. 1D-CNN

이미지의 공간 구조를 활용핸 구조인 CNN을 언어에 대입시켰다.

출처: https://wikidocs.net/80437

단어 임베딩을 이어 붙이고, CNN의 Kernel로 feature를 뽑아내는 구조이다.

그림상으로 입력 길이: 9, 임베딩 크기: 6, 한번에 볼 단어의 갯수: 3 이다. 아래로 내려가면서 Convolution 연산을 해 준다. 첫 CNN layer를 거치면 7x6 matrix가 나올 것이고, 그림상으론 바로 pooling을 거쳐 7x1 matrix를 뽑아냈다.

CNN layer를 더 많이 거쳐도 되고, kernel의 channel 수를 늘리는 방법으로 모델 크기를 키워 학습 시킬 수 있다.

나온 결과로 FC layer를 거쳐 분류나 회귀 문제에 활용할 수 있다.

5. Bi-LSTM

일반 RNN구조에 반대로 가는 길도 추가된 버전이라 할 수 있다. 혹은 RNN 구조 2개가 겹쳐진 버전으로 볼 수 있다.

출처: https://www.gabormelli.com/RKB/Bidirectional_LSTM_%28BiLSTM%29_Training_System

예를 들어 I love ___ for always 라는 문장이 있다. 빈칸에 들어갈 단어를 예측하기 위해 앞 뒤로 I love와 for always를 활용하는게 도움이 될 것이다. 이런 식으로 예측을 하는데 (과거 입력에만 영향을 받는다는 의미인) Causality를 무시해도 되고, 미래의 입력이 도움이 되는 경우에 활용 할 수 있는 구조이다.

$W_{hh}$가 기본 버전의 2배가 필요할 것이다.

총정리

오늘 RNN은 학교 수업에서도 한번 봤기에 잔잔하게 이해할 수 있었다. 그땐 NLP 분야의 존재조차 모르고 들었었기에 이런 구조가 큰 의미가 있나 싶었는데 아는 만큼 보인다는걸 느꼈다.

CNN은 알고 있었지만 1D-CNN은 처음 봤는데, 처음엔 CNN을 NLP에 어떻게 적용하지 했는데, 약간의 억지도 없지않아 보이긴 하지만 이런 상상력이 어떤 결과가 나올지 모르기 때문에 항상 다각도로 생각해 보자.

이제 이 강의를 선택한 목적인 Attention Transformer 부분을 앞두고 있다. 가보자.

https://arxiv.org/pdf/1808.06226.pdf https://github.com/google/sentencepiece

BEiT에서 언어 토큰화 툴로 사용한 SentencePiece이다. python에 간단히 pip로 다운받아 사용가능 하다.

Abstract

언어에 관계없는 subword tokenizer/detokenizer subword tokenizer들은 대부분 pre-tokenized된 데이터셋으로부터 학습했다. 하지만 Sentence Piece는 raw sentences로 부터 바로 학습 가능하다.

1. Introduction

띄어쓰기 단위로 대부분 구별 가능한 영어/유럽쪽 언어와 다르게 한/중/일 아시아쪽 언어는 띄어쓰기가 필요없는 부분이 있다. 기존 방식들은 언어마다 규칙을 찾아 하드코딩을 해주는 방식이었지만,

Byte-pair-encoding(BPE), unigram language model을 활용하여 언어에 관계없이, raw-sentences로부터 학습 가능한 구조를 만들었다.

2. System Overview

Normalizer, Trainer, Encoder, Decoder 4개로 이루어져 있다.

Normalizer

Unicode 형태 글자들을 canonical form으로 바꿔준다.

Trainer

normalized corpus로부터 모델을 학습시킨다. 모델 종류는 선택 가능하다.

Encoder

Normalizer를 돌려주고, subword 단위로 토큰화해서 Trainer에 넘겨주는 녀석

Decoder

다시 text로 바꿔준다.

단어를 id-mapping방식을 이용해 encode-decode한다. Hello world. <-> 151 88 21 887 6 ->Encode <-Decode

3. Library Design

기존 방식은 띄어쓰기가 필요한지, 없는지 구분할 수 없었다. Hello world. -> [Hello] [world] [.] 면 hello와 world사이엔 띄어쓰기가 들어가야 한다는건 알지만 world와 .사이는 들어가면 안되니까 애매해진다. 다른 언어는 더더욱 그렇다.

Encoder Decoder가 서로의 inverse operation이 되도록 Decode(Encode(Normalize(text))) = Normalize(text) 구현 했고, 이걸 여기서 lossless tokenization이라고 부를 것이다.

띄어쓰기를 _ 로 바꿔서 보는걸 포함해 모든 글자들을 Unicode로 보고 input text를 아래 예시처럼 arbitrary subword 단위로 쪼갠다.

heap구조를 사용해 기존 BPE 알고리즘에서 $O(N^2)$이던 시간을 $O(Nlog(N))$으로 줄였고,

id mapping 할 때 vocab_size를 학습시 입력으로 받아 그때그때 설정 할 수 있고 Unknown symbol: EOS </s> , padding <pad> 같은 애들은 따로 설정 가능하다.

Normalizing에서 기본적으로는 Unicode NFKC를 사용하는데 커스터마이징도 가능하다.

https://wikidocs.net/86657 위키독스에 한글로 설명된 실습 해보자

IMDB 영화리뷰 데이터셋을 불러와 학습을 위한 txt파일로 저장해 준다.

train_df = pd.read_csv('C:/nlp_datas/IMDB Dataset.csv')
train_df['review']
with open('imdb_review.txt','w',encoding='utf8') as f:
    f.write('\n'.join(train_df['review']))

학습 파라미터로 txt파일명, 생성될 파일 이름, vocab_size, model type등을 지정해 준다.

spm.SentencePieceTrainer.Train(
    '--input=imdb_review.txt --model_prefix=imdb\
    --vocab_size=5000 --model_type=bpe --max_sentence_length=9999')

학습된 모델을 불러와 Encoding Decoding해보자

sp = spm.SentencePieceProcessor()
vocab_file = 'imdb.model'
sp.Load(vocab_file)

Encoding

lines = ['This is very fun','He was crying']
for line in lines:
    print(line)
    print(sp.encode_as_pieces(line))
    print(sp.encode_as_ids(line))
    print()

This is very fun ['▁This', '▁is', '▁very', '▁fun'] [280, 43, 270, 411]

He was crying ['▁He', '▁was', '▁cry', 'ing'] [490, 84, 2625, 20]

Decoding

sp.DecodeIds([280,43,270,411])

'This is very fun'

총정리

쓰기 굉장히 편하고 언어 구별 없다는 점에서 장점이 큰 것 같다.

이제 정수 인코딩 했으니 BEiT에 집어넣을때는 One-hot으로 바꿔서 한건지, 그대로 썼는지 또 알아보자.

딥러닝을 이용한 자연어처리 입문 7시간 완성 - 메타코드M https://www.youtube.com/watch?v=Rf7wvs8ZbP4&ab_channel=%EB%A9%94%ED%83%80%EC%BD%94%EB%93%9CM

3회차는 지금까지 배웠던 전처리 실습입니다.

목차

1. 토큰화
2. 어간 추출, 표제어 추출
3. 불용어 처리
4. 정수 인코딩
5. 유사도 분석
6. CBOW/Skip gram 학습
7. SGNS 학습시키기

1. 토큰화

다양한 토큰화 함수들 중 TreebankWordTokenizer를 사용해 보았다. 뒤에서 또 다른 토큰화 함수 등장 예정

from nltk.tokenize import TreebankWordTokenizer
tokenizer = TreebankWordTokenizer()
text = "T1 won world championship by 3:1 score"
print(tokenizer.tokenize(text))

2. 어간 추출, 표제어 추출

어간추출 Stemmer

from nltk.stem import PorterStemmer, LancasterStemmer
stem1 = PorterStemmer()
stem2 = LancasterStemmer()
words = ['eat','ate','eaten','eating']
print('Porter',[stem1.stem(w) for w in words])
print('Lancaster',[stem2.stem(w) for w in words])

Porter ['eat', 'ate', 'eaten', 'eat'] Lancaster ['eat', 'at', 'eat', 'eat']

표제어 추출 Lemmatizer

import nltk
from nltk import WordNetLemmatizer
nltk.download('wordnet')
lemm = WordNetLemmatizer()
words = ['eat','ate','eaten','eating']
print('wordNet Lemm',[lemm.lemmatize(w,pos='v') for w in words])

wordNet Lemm ['eat', 'eat', 'eat', 'eat'] lemmatize 입력 변수로 pos에 v를 넣으면 동사, n을 넣으면 명사를 쪼개준다.

3. 불용어 처리

import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords

print(stopwords.words('english')[:5])

text = "hi how are you?"
word_tokens = tokenizer.tokenize(text)
stop_words = stopwords.words('english')
result = []
for w in word_tokens:
    if w not in stop_words:
        result.append(w)
print(word_tokens)
print(result)

['hi', 'how', 'are', 'you', '?'] ['hi', '?']

4. 정수 인코딩

vocab = {'apple':2,'July':6,'piano':4,'cup':8,'orange':1}
vocab_sort = sorted(vocab.items(),key=lambda x:x[1],reverse=True)
print(vocab_sort)
word2idx = {word[0]:index+1 for index,word in enumerate(vocab_sort)}
print(word2idx)

[('cup', 8), ('July', 6), ('piano', 4), ('apple', 2), ('orange', 1)] {'cup': 1, 'July': 2, 'piano': 3, 'apple': 4, 'orange': 5} 빈도가 주어졌다고 치고, 가장 많이 나온게 1, 2, 3 순서대로 인코딩 된다.

5. 유사도

코사인 유사도

import numpy as np
def cos_sim(A,B):
    return np.dot(A,B)/(np.linalg.norm(A)*np.linalg.norm(B))
a = [1,0,0,1]
b=[0,1,1,0]
c=[1,1,1,1]
print(cos_sim(a,b),cos_sim(b,c),cos_sim(c,a))

0.0 0.7071067811865475 0.7071067811865475

레반슈타인 거리

def leven(text1,text2):
    len1 = len(text1)+1
    len2 = len(text2)+1
    sim_array = np.zeros((len1,len2))
    sim_array[:,0] = np.linspace(0,len1-1,len1)
    sim_array[0,:] = np.linspace(0,len2-1,len2)
    for i in range(1,len1):
        for j in range(1,len2):
            add_char = sim_array[i-1,j]+1
            sub_char = sim_array[i,j-1]+1
            if text1[i-1] == text2[j-1]:
                mod_char = sim_array[i-1,j-1]
            else:
                mod_char = sim_array[i-1,j-1]+1
            sim_array[i,j] = min([add_char,sub_char,mod_char])
    return sim_array[-1,-1]
print(leven('데이터마이닝','데이타마닝'))

2.0

6. CBOW/Skip gram 학습

https://www.kaggle.com/datasets/lakshmi25npathi/imdb-dataset-of-50k-movie-reviews?resource=download IMDB 영화 리뷰 데이터셋을 활용하였다.

먼저 전처리 과정을 거쳐 준다

1) 토큰화를 해 주고

import pandas as pd
from nltk.tokenize import RegexpTokenizer
from nltk.corpus import stopwords
data=pd.read_csv('C:/nlp_datas/IMDB Dataset.csv')
print('missing Values: ',data.isnull().sum())
merge_data = ''.join(str(data.iloc[i,0]) for i in range(500))
print('Total word count:', len(merge_data))

missing Values: review 0 sentiment 0 dtype: int64 Total word count: 681583

Review에 실제 평가 문장, sentiment에 긍정/부정 인지 적혀있기에 Review 열만 사용할 예정이다.

2) 불용어를 없애주고

tokenizer = RegexpTokenizer('[\w]+')
token_text = tokenizer.tokenize(merge_data)

stop_words = set(stopwords.words('english'))
token_stop_text = []
for w in token_text:
    if w not in stop_words:
        token_stop_text.append(w)
print('After cleaning:', len(token_stop_text))

After cleaning: 70257

3) 빈도수 셀 겸 중복인 단어를 없애주고

word2idx={}
Bow=[]
for word in token_stop_text:
    if word not in word2idx.keys():
        word2idx[word] = len(word2idx)
        Bow.insert(len(word2idx)-1,1)
    else:
        idx = word2idx.get(word)
        Bow[idx] +=1
print('Unique Words Count: ',len(Bow))

Unique Words Count: 14216

4) 실제 학습 리스트 형태였던 토큰들을 np array로 바꿔주고, gensim 라이브러리에서 제공하는 Word2Vec 모델에

• 각 단어당 임베딩 벡터 길이(vector_size): 100,
• Skip gram의 hyperparameter인 어느 범위까지 참조할 건지(window): 5,
• 양 끝쪽에 참조할게 적어져 생략할 범위를 정하는(min_count): 2,
• skipgram을 쓸건지, cbow를 쓸건지(sg): 0 -> CBOW/ 1-> Skipgram

  import numpy as np
  token_stop_text = np.reshape(np.array(token_stop_text),[-1,1])
  from gensim.models import Word2Vec
  model = Word2Vec(vector_size = 100, window = 5, min_count=2, sg=0)
  model.build_vocab(token_stop_text)
  model.train(token_stop_text,total_examples=model.corpus_count,epochs= 30)
  vocabs = model.wv.key_to_index.keys()
  word_vec_list = [model.wv[i] for i in vocabs]

5) PCA로 시각화

from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pcafit = pca.fit_transform(word_vec_list)
x = pcafit[:50,0]
y = pcafit[:50,1]
import matplotlib.pyplot as plt
plt.scatter(x,y,marker='o')
for i,v in enumerate(vocabs):
    if i<=49:
        plt.annotate(v,xy=(x[i],y[i]))
plt.show()

7. SGNS 학습시키기

똑같이 전처리를 해준다.

import pandas as pd
from nltk.tokenize import RegexpTokenizer
from nltk.corpus import stopwords
data=pd.read_csv('C:/nlp_datas/IMDB Dataset.csv')
print('missing Values: ',data.isnull().sum())
merge_data = ''.join(str(data.iloc[i,0]) for i in range(200))
print('Total word count:', len(merge_data))
tokenizer = RegexpTokenizer('[\w]+')
token_text = tokenizer.tokenize(merge_data)

stop_words = set(stopwords.words('english'))
token_stop_text = []
for w in token_text:
    if w not in stop_words:
        token_stop_text.append(w)
print('After cleaning:', len(token_stop_text))

SGNS는 단어 두개가 이웃한지 여부를 이용하는 알고리즘이니, 이 형태의 데이터 셋을 만들기 위해 Tensorflow에서 제공하는 Tokenizer과 skipgrams를 사용한다.

(근데 tensorflow 설치가 안돼서 일단 급하게 소스코드를 복사하여 사용했다)

tokenizer = Tokenizer()
tokenizer.fit_on_texts(token_stop_text)
word2idx = tokenizer.word_index
encoded = tokenizer.texts_to_sequences(token_stop_text)
encoded = np.array(encoded).T
skip_gram = [skipgrams(sample,vocabulary_size = len(word2idx)+1,window_size = 10)for sample in encoded]

skip_gram안에는 단어 인덱스가 두개씩 묶인 쌍들이 저장된다. 그리고 두 숫자가 이웃해 있는지 여부가 뒤쪽에 저장된다.

[[[[1,2],[2,3]...],[1,1,0,0,...]]]

import torch
import torch.nn as nn
from torch import LongTensor as LT
from torch import FloatTensor as FT

class Word2Vec(nn.Module):
    def __init__(self,vocab_size,embed_size):
        super(Word2Vec,self).__init__()
        self.vocab_size = vocab_size
        self.embed_size = embed_size
        self.word1_vector = nn.Embedding(self.vocab_size,self.embed_size)
        self.word2_vector = nn.Embedding(self.vocab_size,self.embed_size)
        self.word1_vector_weight = nn.Parameter(torch.cat([torch.zeros(1,self.embed_size),FT(self.vocab_size-1,self.embed_size).uniform_(-0.1,0.1)]))
        self.word2_vector_weight = nn.Parameter(torch.cat([torch.zeros(1,self.embed_size),FT(self.vocab_size-1,self.embed_size).uniform_(-0.1,0.1)]))
        self.word1_vector.weight.requires_grad = True
        self.word2_vector.weight.requires_grad = True

    def forward_word1(self,data):
        vec = LT(data)
        vec = vec.cuda() if self.word1_vector.weight.is_cuda else vec
        return self.word1_vector(vec)
    def forward_word2(self,data):
        vec = LT(data)
        vec = vec.cuda() if self.word2_vector.weight.is_cuda else vec
        return self.word2_vector(vec)

단어 두개의 임베딩을 뽑아주는 Word2Vec class를 정의한다.

class SGNS(nn.Module):
    def __init__(self,embed,vocab_size):
        super(SGNS,self).__init__()
        self.embed = embed
        self.vocab_size = vocab_size
        self.weights = None
    def forward(self,word1, word2, label):
        soft = 1e-9
        word1 = self.embed.forward_word1(word1).unsqueeze(1)
        word2 = self.embed.forward_word2(word2).unsqueeze(2)
        label = LT(label).unsqueeze(1)
        prediction = torch.bmm(word1, word2).squeeze(2).sigmoid()
        pr1 = prediction.log()
        pr0 = (1-prediction+soft).log()
        loss = -label*pr1-(1-label)*pr0
        return loss.mean()

SGNS 모델 class를 정의한다. 각 단어 임베딩은 (Batch,100) 형태를 가질 텐데 여기서 해야하는 연산은 $word_1^Tword_2$이므로 unsqueeze 함수를 이용해 word1의 shape은 (Batch,1,100) word2의 shape은 (Batch,100,1)로 만들어 (1,100) x (100,1) 연산결과로 (1x1)을 얻어낸다. ; torch.bmm을 결과로 (Batch,1,1)의 결과가 나오는데, 1하나를 squeeze해준다.

이후 시그모이드에 로그확률 형태로 만들어 loss function은 binary cross entropy 모양을 그대로 가져왔다.

Adam쓸 예정이고, 필요한 word2vec 리스트, 모델을 정의해 준다.

from torch.optim import Adam
from torch.utils.data import DataLoader, TensorDataset
from tqdm import tqdm
vocab_size = len(word2idx)+1
word2vec = Word2Vec(vocab_size=vocab_size,embed_size=100)
sgns = SGNS(embed = word2vec, vocab_size = vocab_size)
optim = Adam(sgns.parameters())

데이터 로더를 정의할 건데, skip_gram 변수엔 [[[idx1, idx2],... , [1,0,...]]] 구조로 되어있다. element[0]에 해당하는게 숫자 인덱스 쌍들 [[idx1,idx2],[1,2]...] element[1]에 해당하는게 라벨값 [1,0,...]

word1에 기준 인덱스, word2에 근처인지 비교할 인덱스, label에 이웃한지 를 저장한다.

for _,element in enumerate(skip_gram):
    word1 = LT(np.array(list(zip(*element[0]))[0],dtype='int32'))
    word2 = LT(np.array(list(zip(*element[0]))[1],dtype='int32'))
    label = LT(np.array(element[1],dtype='int32'))
    dataset = TensorDataset(word1,word2,label)
    train_loader = DataLoader(dataset, batch_size=256, shuffle=True)    

학습

for epoch in range(5):
    with tqdm(train_loader) as tepoch:
        for word1, word2, label in tepoch:
            loss = sgns(word1, word2,label)
            optim.zero_grad()
            loss.backward()
            optim.step()
            tepoch.set_description(f"Epoch {epoch}")
            tepoch.set_postfix(loss = loss.item())

Epoch 0: 100%|██████████| 4346/4346 [01:15<00:00, 57.89it/s, loss=3.33]
Epoch 1: 100%|██████████| 4346/4346 [01:14<00:00, 58.42it/s, loss=2.64]
Epoch 2: 100%|██████████| 4346/4346 [01:17<00:00, 56.14it/s, loss=1.71]
Epoch 3: 100%|██████████| 4346/4346 [01:31<00:00, 47.28it/s, loss=1.4]  
Epoch 4: 100%|██████████| 4346/4346 [01:45<00:00, 41.14it/s, loss=0.806]

(5 에폭에 데이터도 많이 안써서 loss값이 형편없다.)

각 단어 인덱스를 받으면 sgns내에서 그 단어에 해당하는 임베딩들을 만들기 시작할 것이고, loss function 왔다갔다 하면서 업데이트 할 것이다.

결과 확인을 위해 임베딩값들을 저장해 준다.

import gensim
with open("C:/nlp_datas/vectors.txt",'w') as f:
    ww=0
    f.write('{} {}\n'.format(7500,100))
    vectors = word2vec.word1_vector.weight.detach().numpy()
    for i , v in enumerate(word2idx.keys()):
        try:
            f.write('{} {}\n'.format(v, ' '.join(map(str,list(vectors[i+1,:])))))
            ww+=1
        except:
            continue
embed_word2vec = gensim.models.KeyedVectors.load_word2vec_format("C:/nlp_datas/vectors.txt",)

마지막 줄에 이제 gensim 라이브러리를 활용해 비슷한 단어가 뭐가 있는지 보기위해 로드해 준다.

embed_word2vec.most_similar(positive = ['enjoy'])

 ('nights', 0.3993881344795227),
 ('great', 0.36998695135116577),
 ('fight', 0.35548287630081177),
 ('follow', 0.3486346900463104),
 ('i', 0.3483388423919678),
 ('the', 0.34802910685539246),
 ('parts', 0.3476596772670746),
 ('promise', 0.347569078207016),
 ('correct', 0.3447914719581604)]

예시로 enjoy와 비슷한 단어를 찍어보니 이렇게 나온다. 아무래도 영화리뷰이다 보니 movie라는 단어가 워낙 많이 있을 거라 movie와의 유사도가 높은것 같고, great, fight는 나름 연관성이 있어보이긴 한다.

학습을 더 시켜보면 좋은 결과가 나올 것 같긴 하다.

총정리

실제로 전처리부터 간단한 인코딩 알고리즘들을 돌려보니 NLP에 대해 감이 잡히는듯 안잡히는듯 아직 그렇다. 그래도 NLP를 몰랐을 때 보단 실제 코드로 실습도 하고 하니 뭔가 해볼 순 있겠다는 자신감은 생긴다.

지금까지 본건 사실상 현재 NLP에서 안쓰이는 기법들일 거고, 앞으로 RNN Attention Transformer를 볼 텐데 얼마나 성능향상이 있을지 기대된다.

대부분의 내용, 이미지는 Seq2Seq: https://wikidocs.net/24996 Attention: https://wikidocs.net/22893 에서 참고하였습니다.

일단 그 시초인 Seq2Seq에서 출발해 보자

Seq2Seq

Encoder - Decoder 구조를 가지고 그 내부에 RNN block들이 들어있다.

1. 입력 문장의 각 토큰의 임베딩을 뽑아 인코더 각 RNN block의 input으로 사용한다.
2. 인코더의 마지막 RNN block의 출력이 Context Vector 이 디코더의 첫번째 input이 된다.
3. <'sos'>: Start of Sentence, Context vector 부터 시작하여, 이전 RNN block에서 나온 출력 벡터와 결과 단어의 임베딩을 현재 RNN block의 input으로 사용한다.

결과 단어는 출력 벡터를 Dense layer, Softmax layer를 거쳐 결정된다.

Seq2Seq의 문제점:

• 벡터 크기를 고정시켜 두고, 단어에 해당하는 모든 정보를 압축하려니 정보가 손실된다.
• RNN의 특성상 나타나는 기울기 소실 문제가 나타나서 문장이 길어지면 성능이 떨어진다.

Attention

Attention으로 개선한다. 디코더에서 각 단어를 예측할 때 인코더의 input들을 참조할 건데, 굳이 처음부터 끝까지 다 볼 필요 없이 중요한 부분만 집중(Attention)해서 보자.

Attention(Q, K, V) = Attention Value 함수 모양으로 보면 간단히 이렇다. 여기서, Query(Q): 디코더에서 현재 시점의 출력 벡터, Key(K): 인코더의 각 Block Value(V): 인코더 각 Block의 값

Dot-product Attention

Attention score를 구한다

인코더의 각 출력 벡터를 $h_1, h_2 ... h_n$이라 하고, 그리고 디코더의 구하려는 시점의 출력 벡터를 $s_t$라 하자.

내적으로 $s_t^Th_1=\alpha_1, s_t^Th_2=\alpha_2$ 값들을 각각 구해서 Softmax 함수에 집어 넣으면 인코더의 Input 각 단어들과 얼마나 유사한지의 확률 값을 얻을 수 있다.

최종 Attention score $a_t = \Sigma_{i=1}^{N}\alpha_i^Th_i$ 로 얻어진다.

나온 $a_t$와 $s_t$를 concatenate해서 Weight matrix $W_c$ 와 계산을 통해 출력층(최종 Softmax layer) 의 입력을 계산한다. $\tilde s_t = tanh(W_c[a_t:s_t]+b_c)$

끝으로 다른 Weight matrix $W_y$와 다시 계산하고 Softmax layer에 넣어 준다.

$\hat y_t = softmax(W_y\tilde s_t+b_y)$ 이렇게 디코더에서 t 시점의 최종 단어를 예측할 수 있다.

https://arxiv.org/abs/2208.10442

BEiT v1, v2도 읽어볼 예정

Abstract

크게 3가지에 집중할 예정이다.

1. Backbone architecture
2. Pretraining task
3. Model scaling up

이 3가지를 하기 위해서 Multiway Transformer 논문에서 제시한다.

이미지를 하나의 언어로 보고 ('Imglish'), image-text pair에 마스크를 씌우는 학습방법을 활용하였다.

이렇게 했더니, 여러 데이터셋에서 Vision-Language multi-modal task 뿐만 아니라, Vision 단일 task에서도 좋은 성능을 보였다.

1. Introduction: The Big Convergence

Abstract에서 제시한 3가지를 어떻게 할 것이냐

1.1 Backbone architecture

Vision-Language 모델링에 있어 다양한 방법들이 존재한다.

• Dual-Encoder: Image-text retrieval task
• Encoder-Decoder: generation task
• Fusion-encoder: image-text encoding

이런 모델들 대부분은 특정 task를 하기 위한 변형을 끝단에 붙여줘야 한다. 게다가 여러 modality에 parameter들이 효과적으로 공유되지 않는데, Multiway Transformer로 점들을 개선한다.

1.2 Pretraining Task

Pretraining 할 때 task마다 다른 기법으로 학습시키는데, 이건 scaling 하기에 안좋고, 비효율적이다. General-purpose multi-modal 모델 학습으로 Mask-then-predict 이거 하나만 쓰자. 이미지도 text처럼 취급한다 했으니(Imglish) modality는 다르지만 두 개의 문장이 들어간 것처럼 학습시켜줄 것이다.

1.3 Model Scaling up

모델 크기를 키우고, 데이터 크기를 키우는게 성능을 높이는데 보통 좋다. 이 논문에서는 private한 데이터를 쓰지 않고, 공개된 데이터만 사용해도 SOTA보다 성능이 좋음을 보였다.

2. BEiT-3: A General-Purpose Multimodal Foundation Model

2.1 Backbone Network: Multiway Transformers

그림에 있는 것 처럼, Multiway Transformer 는 각 modality 마다 shared self-attention module , feed-forward network(FFN)으로 구성되어 있다.

(a),(b) 를 보면 Self-attention module 위에 각 modality에 해당하는 FFN 이 올라가 있고, (c)는 image와 text가 shared self-attention module, FFN 을 거쳐 나온 결과를 다시 self-attention, FFN 에 넣는데, 이렇게 하면 처음 shared self-attention 에서 다른 modality간의 alignment를 학습하는데 도움이 된다.

Vision task만, text만, multi-modal용이든 다 똑같은 구조로 이루어져 있어서 각종 downstream task에 활용하기에 좋다.

2.2 Pretraining Task: Masked Data Modeling

앞서 BEiT를 학습시킬 때 mask-then-predict 만 사용한다고 언급했다. 이렇게 하면 representation 뿐만 아니라 다른 modality간 alignment를 학습하는데에도 도움이 된다.

구체적으로, Text는 SentencePiece tokenizer 를 이용해서 토큰화 했고, Image는 BEiT v2에서 언급된 tokenizer를 이용했다. (찾아보자)

Text만 학습시킬땐 15%, Image-text pair로 학습할 땐 50%를 mask했다. 이미지는 40% image patch들을 BEiT논문에 등장하는 방식으로 block-wise masking 했다.(이것도 찾아보자)

각 Task마다 학습 방식이 달라지는 다른 Vision-language 모델들과의 차별점으로 똑같은 방식(mask-then-predict)만 사용해서 pretrain 시켰고, Contrastive-based model(CLIP, CoCa 등)들 보다 더 작은 batch size로 학습시킬 수 있었다. -> GPU memory에 있어 좋다.

2.3 Scaling Up: BEiT-3 Pretraining

위의 그림에서 각 부분별 parameter수를 제시 데이터 크기 제시 학습때 사용한 hyperparameter, augmentation종류 제시

3. Experiments on Vision and Vision-Language Tasks

Visual Question Answering(VQA)

VQA v2.0 dataset 으로 finetuning해서 실험했다. VQA를 일종의 Classification task처럼 해석하여, Trainset에 가장 자주 등장한 3129개의 대답 후보들 중 하나를 예측하도록 했다.

위 그림의 (c) Fusion Encoder 모양을 이용했고, Input으로 주어지는 Question에서 뽑은 embedding과, Image에서 뽑은 embedding을 concat하여 Multiway Transfomer 구조에 넣어 주었다. 이후 나온 output을 classifier layer에 넣어 최종 답을 예측하도록 하였다.

총정리

• 다른 VQA논문을 더 읽어봐야 알겠지만, 이걸 classification 문제로 풀지 않고 다른 방법이 있는지 궁금하다.
• 이 논문에 등장한 BEiT v1, v2의 image tokenizing 방법과 masking 방법을 반드시 알아보자
• 현재 VQA v2.0 데이터셋 기준 SOTA 모델이던데, 다른 논문에선 어떤 모델구조를 띄는지 2등 3등도 알아보자.
• Fusion Encoder에서 Image embedding, text embedding을 어떻게 만져서 모델에 넣었는지 코드를 한번 뜯어보자