For Better Days

[논문리뷰] Model Stock: All We Need Is Just a Few Fine-Tuned Models

Liky — Wed, 18 Dec 2024 16:37:58 +0900

논문 정보

Title: Model Stock: All We Need Is Just a Few Fine-Tuned Models
Authors: Dong-Hwan Jang, Sangdoo Yun, Dongyoon Han (NAVER AI Lab)
Published: 2024.09.30
Pages: pp 207–223
Conference: ECCV 2024
Link: https://doi.org/10.1007/978-3-031-72784-9_12

Background

Merge란?

모델 N개의 가중치를 결합하여 하나의 모델로 만드는 방법론입니다.

class SimpleModel(nn.Module):
    def __init__(self, input_size, num_classes):
        super(SimpleModel, self).__init__()
        # 첫 번째 레이어: Linear 레이어
        self.fc1 = nn.Linear(784, 64)
        # 두 번째 레이어: Linear 레이어
        self.fc2 = nn.Linear(64, 2)

    def forward(self, x):
        # 첫 번째 레이어에 ReLU 활성화 함수 적용
        x = F.relu(self.fc1(x))
        # 두 번째 레이어에 소프트맥스 활성화 함수 적용
        x = F.log_softmax(self.fc2(x), dim=1)
        return x

1개의 모델은 N개의 레이어로 이루어져 있습니다.

위의 예시를 기반으로 첫번째 레이어를 출력해보면 다음과 같이 이루어져 있습니다.

print("Weights:", linear_layer.weight)
print("Bias:", linear_layer.bias)

Weights: tensor([[ 0.0123, -0.0345, ...,  0.0567],...,[0.0789, -0.0123, ...,  0.0456]], requires_grad=True)
Bias: tensor([ 0.0123, -0.0345, ...,  0.0567], requires_grad=True)

가중치는 (64,784)의 크기를 가지는 2차원 tensor로 이루어져있고,
Bias는 (64)의 크기를 가지는 1차원 tensor로 이루어져 있습니다.

Model Merge는 N개의 모델에서 같은 레이어를 기준으로 가중치(Weights)를 결합하는 방법이고,

단순히 가중치의 평균으로 만들지, 수식을 적용할지 등등이 각각의 merge 방법론들 입니다.

Model Soup이란?

Model Stock을 알기 전, Soup 방법론을 알아야합니다.

Model Merge 방법론 이전에는 Model Ensemble 방법론이 존재했습니다.

단순히 모델들을 ensemble 하는 방안은 모델이 증가할 수록 시간복잡도가 증가되는 O(n) 형식이였습니다.

이를 해결하기 위해 나온 방법론이 Model Soup이며, 다수의 파인튜닝 모델들의 가중치를 단순히 평균화 하여 하나의 모델로 만드는 방법입니다.

k = merge할 모델 개수

Basic Soup
- weight_1/k +weight2/k + ... +weight_k/k
Greedy Soup
- 모델들을 val acc 순 내림차순 진행
- sota 모델부터 하나씩 weight_1/k +weight2/k 진행
- 성능이 낮아지기 전까지 병합
Learned Soup(Advanced)
- 모든 모델을 메모리에 올려서 조합을 한번에 시도(요구 자원 높음)

Soup 방법론은 기존 Ensemble의 단점을 해결하였으나 다음과 같은 한계가 있습니다.

많은 모델 필요 (논문에서는 48개의 모델 사용)
튀는 가중치 있다면 성능이 하락함 (같은 loss basin에 있어야함)

Model STOCK이 생겨난 과정

Soup의 방법론은 기존 Ensemble의 단점을 해결하고 성능 향상을 이루었습니다.

다만 앞서 말한 한계점들이 존재하였고, 이는 곧 실제 현실세계에서 사용하기 비효율적인 방법론입니다.

따라서, 여러개의 모델을 평균화해서 중심을 찾는 것 말고, 최소한의 모델(2개)를 가지고 수학적인 수식을 이용하여 최대한 가중치 중심에 가깝게 만들어버리는 것을 목표로 하는게 Stock 방법론입니다.

관측 1

Fig.2는 랜덤시드로 학습된 파인튜닝된 모델들의 레이어를 시각화한 사진입니다.
각 레이어에서 50개의 별개의 웨이트를 뽑아서 각도랑 Norm을 비교해보니 , 각 레이어별로 가중치 벡터의 각도와 norm이 거의 일정하게 유지되는 것을 확인할 수 있습니다.

즉, 특정 task를 해결하기위해 똑같은 데이터로 학습을 진행한다면, 시드에 관계없이 가중치의 크기나 각도가 특정 방향으로 일관되게 학습됨을 의미합니다.

관측 2

랜덤시드로 같은 데이터를 학습한 50개의 모델을 만들고, 50개의 가중치 평균을 중심(u)이라고 했을 때, 미세조정된 모델들은 가중치 중심으로부터 일정한 거리를 유지하고 표준 편차가 매우 적다는 것을 볼 수 있습니다.

논문의 저자들은 u를 중심으로 일정한 거리 내에 가중치들이 분포되어 있는 형태를 얇은 띠 형태라고 표현하였습니다.

즉, 비슷한 데이터로 학습한 모델들의 가중치는 들쭉날쭉이 아닌 크게 벗어나지 않는 범위 내에 존재하며,

이는 얇은 껍질 형태로 보이고, 모델이 많아질 수록 중심에 가까워진다를 의미합니다.

관측 3

fig3은 test 데이터를 기반으로 학습된 모델이 얼마나 틀렸는지의 대한 landscape입니다.

w_0 → 학습이 안된 pre-trained model

w_1→ 랜덤으로 선택된 fine-tuned model

w_50→ 가중치 중심

가중치 중심 근처에서 테스트 오류가 낮으며, 중심에서 멀어질수록 성능이 점점 낮아집니다.

즉, 가중치 중심에 가까울 수록 성능이 향상된다는 것을 알 수 있습니다.

관측 4

fine-tuned models의 가중치를 평균내었을 때, 많은 모델을 묶을 수록 중심에 가까워지고, 중심에 가까워질 수록 성능이 향상됩니다.

랜덤 가중치를 만들었을 때도 중심 가중치에 가깝게 생성된 가중치들은 높은 성능을 내며, 멀어질수록 성능이 하락합니다.

여기서 랜덤 가중치는 가우시안 분포에서 무작위로 샘플링된 가중치라고 합니다.

즉, 레이어의 가중치를 랜덤으로 만들어도 가중치의 중심에 근접하면 성능이 높다는 것을 의미합니다.

위의 관측들을 기반으로

저자들은 가중치 중심이 가장 높은 성능을 내는 가중치로 정의하고,

최소한의 모델을 사용하여 효율적으로 가중치 중심에 근접하도록 Merge하는 방안인 Model Stock을 고안하게 되었다고합니다.

Model STOCK Main Method

저자들이 제안하는 핵심 수식은 위와 같습니다.

가중치의 중심인 u가 어디있을지는 모르겠으나,

u를 찾는 것이 아닌, u와 가장 가까울거라 예상되는 가중치인 W_H를 찾는 방법임을 명심해주세요.

작동방식

랜덤시드로 학습한 두 개의 fine-tuned models를 가져온다.
두 개의 fine-tuned models의 평균 근처에 가중치 중심이 있을 것이라 가정한다.
(N개의 튜닝된 모델들을 평균내었을 때가 가중치의 중심이라 하였으니..!)
두 개의 fine-tuned models의 가중치가 있을 테니 두 가중치(벡터)의 각도를 알 수 있습니다.
코싸인 유사도인 cos A = (w1 * w2) / (|w1| * |w2|)를 이용하여 계산을 합니다.
만약 $cosA$=1 일경우 두 각도가 0도로 작다는 거고, 이는 특정 가중치에 동일하게 편향되어 있으니 가중치의 중심에 가장 가까운 지점은 w_12에 더 가깝게 존재한다는 것입니다.
두 가중치의 각도가 큰 반대의 경우는 학습이 안된 사전학습된 모델에 더 가까이 존재한다는 것을 의미합니다.

코싸인 유사도 수식 및 의미

이렇게 가중치의 중심과 가장 가까울거라 예상되는 가중치 W_H로 설정하여 이 가중치를 가진 새로운 모델로 만듭니다.

가설 검증 및 결과

사용 모델: CLIP ViT-B/32, CLIP ViT-B/16, CLIP ViT-L/14

데이터셋: ImageNet

위쪽 → 10에포크 약한 데이터 증강 (soup zero-shot 환경과 동일하게)

아래쪽 → 16에포크 강한 데이터 증강 (soup lp 환경과 동일하게)

여기서 LP란 Label Propagation를 의미하며, 레이블이 있는 데이터의 정보를 사용하여 레이블이 없는 데이터에도 라벨을 추정하고 이를 모델 학습에 활용하는 방식으로 더 학습을 잘하게 만드는 방법입니다.
‘Avg. shifts’ 는 5개의 타 데이터셋의 점수 평균을 의미합니다.
즉, 왼쪽 점수는 In-distribution(ID), 오른쪽 점수는 Out-of-distribution(OOD)를 의미합니다.

Table2를 보면 Cost 대비 Model Stock이 우수한 성능을 보임을 알 수 있습니다.

Table3에서는 거의 Stock 방법론이 최고 성능을 달성한 것을 볼 수 있습니다.

Table5는 fine tuned models를 결합하면 결합할 수록 In-Distribution score가 향상되며, Out-of-Distribution score도 향상되고, 가중치 중심에 점점 가까워짐을 보입니다.

Table6은 병합 주기에 대해서 말하는데, 1epoch는 약 2500 iters 이라고 합니다.

즉, 병합을 언제하든 Model Stock 방법론은 성능에 큰 변화없이 안정적인 결과를 보인다를 의미합니다.

Table7은 왼쪽에 단순히 평균내는 것 대비해서 Stock을 적용한 것이 성능이 더 좋았다를 의미합니다.

위와 마찬가지로, 두 가중치를 단순 평균내는건 성능 향상없이 거의 동일하거나 떨어지는데, stock 방법론은 성능이 향상됨을 검증하였습니다.

결론 및 생각

특정 Task를 해결하기 위해 유사한 데이터로 학습한 모델은 가중치 또한 해당 task를 잘 풀기 위한 가중치로 편향되어 있을 것입니다.
저자들은 이런 파인튜닝된 모델의 가중치는 랜덤시드에 영향을 거의 안받고 가우시안 분포 특성을 보이며, 가중치 중심에 가까울수록 성능이 개선됨을 검증하였습니다.
따라서 파인튜닝한 모든 모델을의 가중치 중심을 찾으면 성능이 향상될텐데, 모델 몇 십개를 만들어 merge한다는게 쉽지 않으니, 사전학습된 모델을 기준 앵커 포인트로 잡고 최소한의 파인튜닝된 모델로 가중치의 중심을 예측해서 해당 가중치를 가진 모델을 만들어 성능 향상을 이루는 Stock 방법론을 제시했습니다.
본 방법론을 실제로 적용해보니 분명히 효과가 있었고, 이 방법론에서 아이디어를 얻어 머지 방법론을 만들어 내보는 것도 좋은 연구가 될 것 같다고 생각했습니다.

Tokenization 딥다이브!

Liky — Sun, 25 Aug 2024 13:22:02 +0900

안녕하세요, 오늘은 자연어처리의 가장 기초에 해당하는 Tokenization 에 대해 살펴보고 각 방법론들의 핵심 아이디어들을 살펴보겠습니다! 텍스트를 잘게 쪼개는 기술이 어떻게 컴퓨터가 인간의 언어를 이해하도록 돕는지 함께 확인해봅시다.

토큰화란 무엇일까요?

토큰화는 긴 문장을 작은 조각으로 나누는 과정이에요. 마치 큰 케이크를 먹기 좋게 자르는 것처럼요! 이렇게 나눈 조각들을 '토큰'이라고 부릅니다.

예를 들어볼까요?

"안녕하세요, 오늘 날씨가 참 좋네요!" 
→ ["안녕하세요", ",", "오늘", "날씨가", "참", "좋네요", "!"]

Tokenization은 문장이나 문서를 모델이 처리할 수 있는 작은 단위, 즉 토큰들로 분할하는 과정을 말합니다. 이 과정은 확률 모델이든 신경망 모델이든 간에, 기계가 이해할 수 있는 형태로 심볼 시퀀스를 입력으로 제공하는 데 필수적입니다.

토큰화 방법들

토큰화를 통해 문장 또는 문서를 어떻게 분절화하여 모델링할지 결정하는 것은 자연어 처리 분야에서 오랫동안 고민되어 온 주제입니다. 이에 따라 여러 가지 토크나이제이션 방법이 개발되었으며, 각 방법은 특정 상황이나 언어에 더 적합할 수 있습니다. 과거부터 사용되어 온 다양한 토크나이제이션 방법들을 간단히 정리하면 아래와 같습니다.

1. N-gram: 연속된 단어들의 묶음

N-gram은 연속된 N개의 단어를 하나의 토큰으로 만드는 방법이에요.
예: "나는 사과를 좋아해요"

1-gram: ["나는", "사과를", "좋아해요"]
2-gram: ["나는 사과를", "사과를 좋아해요"]
이는 텍스트 내에서 아이템의 연속성을 포착하는 데 유용합니다.

2. Character: 한 글자씩 쪼개기

이 방법은 텍스트를 가장 작은 단위인 문자로 나눠요.
예: "안녕" → ["안", "녕"]
이는 개별 문자를 독립적인 토큰으로 취급하는 방법으로, 언어의 구조적 특성을 덜 고려하며, 매우 세밀한 수준의 분석이 가능합니다.

3. Word: 공백을 기준으로 나누기

가장 직관적인 방법으로, 공백을 기준으로 단어를 나눠요.
예: "나는 학생입니다" → ["나는", "학생입니다"]

4. Morpheme: 의미의 최소 단위로 나누기

문장을 가장 작은 의미 단위인 형태소로 나누는 방법이에요.
예: "나는 학생입니다" → ["나", "는", "학생", "이다"]
이는 특히 굴절 언어 처리에 적합합니다.

5. Subword: 작은 의미 단위로 나누기

자주 사용되는 단어의 일부분을 토큰으로 만드는 방법이에요.
예: "unbelievable" → ["un", "believe", "able"]
‘Byte Pair Encoding (BPE)’ 또는 ‘WordPiece’와 같은 방법을 사용하여 자주 사용되는 문자의 조합이나 단어의 부분을 토큰으로 분리하는 방법입니다. 이는 효율적인 어휘 크기 관리와 더 나은 일반화를 가능하게 합니다.

위 방법론을 간단히 예를 들어보면 아래의 테이블과 같습니다.

각 토크나이제이션 방식은 특정 언어나 문제에 따라 그 효율성이 달라질 수 있으며, 적절한 방식을 선택하는 것이 자연어 처리 성능에 큰 영향을 미칩니다.

과거 연구에서는 나라별, 문화별, 언어권별로 선호되는 토크나이제이션 방식이 다양했습니다:

로마 언어권: 단어(word) 기반 토크나이제이션이 일반적으로 사용되었습니다. 이는 라틴계 언어의 구조상 단어 간 구분이 명확하기 때문입니다.
중국어 언어권: 문자(character) 기반 토크나이제이션이 주로 사용되었습니다. 중국어는 각 문자가 고유한 의미를 가지고 있기 때문에 이 방식이 효과적입니다.
한국어: 형태소(morpheme) 기반 토크나이제이션이 선호되었습니다. 한국어는 굴절 언어의 특성을 가지고 있어 형태소 분석이 중요합니다.
일본어: 역시 형태소 기반 토크나이제이션이 흔히 사용되었습니다. 일본어 역시 복잡한 굴절을 가진 언어이기 때문입니다.
아랍어 언어권: 스템(stem) 기반 토크나이제이션이 사용되기도 했습니다. 아랍어는 근본적으로 각 단어가 변형되는 규칙적인 패턴을 따르므로, 단어의 근본 형태를 중심으로 토큰화하는 것이 유용합니다.

그러나 최근에는 서브워드(subword) 토크나이제이션, 특히 ‘Byte Pair Encoding (BPE)’ 방식이 다양한 언어에 걸쳐 널리 사용되고 있습니다. 이 방식은 어휘의 크기를 효율적으로 관리하고, 일관된 기준으로 모든 언어를 처리할 수 있기 때문입니다.

이러한 Subword 토크나이제이션 방식을 처음 제안한 것은 Google의 Neural Machine Translation of Rare Words with Subword Units 논문에서였습니다. 이 논문에서는 모델 구조는 그대로 유지하면서 토크나이제이션 방식만 BPE 방식으로 바꿔서 성능 향상을 달성한 연구였습니다.

서브워드 토큰화: 언어의 레고 블록

서브워드 토큰화는 마치 레고 블록처럼 작은 단위로 단어를 나누고 다시 조립할 수 있게 해줘요. Subword 토크나이제이션은 특히 자연어 처리에서 어휘 다양성과 희귀 단어의 변형을 효과적으로 처리할 수 있게 돕는 방법입니다. 이 방법은 전체 단어를 더 작은 의미 단위로 분할하여 자주 발생하지 않는 단어들이 모델에 의해 더 잘 처리될 수 있도록 합니다. 예를 들어, 단어 “unbelievable”은 “un”, “believ”, “able”로 분할될 수 있으며, 이러한 각각의 subword는 다른 단어에서도 재사용될 수 있습니다.

기본적인 원칙은 자주 사용되는 단어는 작은 subword로 분할되지 않고, 희귀 단어는 의미 있는 subword로 분해되어야 한다는 것입니다.

이제 구체적으로 이 subword를 구현하는 방법론에 대해서 살펴보겠습니다. 크게 4가지 방법론이 있습니다.

Byte-Pair Encoding (BPE)
Byte-Level BPE
WordPiece
Unigram

이 글에서는 위 내용에 대해서 각각 살펴보겠습니다.

BPE (Byte Pair Encoding): 자주 나오는 글자 쌍 합치기

BPE는 자주 등장하는 글자 쌍을 하나의 새로운 토큰으로 만들어요. 마치 자주 먹는 음식 조합을 세트 메뉴로 만드는 것과 비슷해요! 즉, BPE(Byte Pair Encoding) 알고리즘의 핵심 아이디어는 자주 등장하는 문자 쌍을 반복적으로 병합하여 새로운 단어를 생성하는 것입니다. 이를 통해 어휘 크기를 줄이면서도 원본 텍스트의 표현력을 최대한 유지할 수 있습니다.

BPE는 원래 1994년 Philip Gage가 데이터 압축을 위해 제안한 알고리즘입니다. 이 알고리즘은 데이터 내에서 가장 자주 등장하는 바이트 쌍을 반복적으로 병합하여 압축하는 방식으로 작동합니다. 예를 들어, 데이터 스트림에서 가장 빈번하게 나타나는 바이트 쌍 ‘AB’를 ‘Z’로 치환하고, 다시 가장 빈번한 바이트 쌍을 찾아 치환하는 과정을 반복합니다.

- ABABABCCCABDE
- ZZZCCCZDE

이 과정을 통과하면 기존에는 13개의 바이트가 필요한 문서가 10개의 바이트로 압축이 되는 거죠.

Byte-Level BPE: 바이트 단위로 쪼개기

Byte-Level BPE는 기존 BPE 알고리즘의 확장판입니다. 기존 BPE와의 차이점은 original BPE의 기본 묶음의 최소 단위가 문자(chraracter) 일 때 Byte-Level BPE는 Byte 라는 것이죠.

그렇다면 왜 Byte 수준으로 단위를 낮춰서 묶어나가야 하는 걸까요? 이를 이해하기 위해서는 1) 바이트와 문자표현의 관계, 2) Unicode 어휘 처리 및 3)적절한 수준의 어휘수의 필요성에 대해 이해를 해야 합니다.

바이트와 문자 표현의 관계

컴퓨터 세계에서 정보의 기본 단위는 바이트입니다. 1바이트는 8비트로 구성되어 256가지 값을 표현할 수 있습니다. 이는 초기 컴퓨터에서 Extended ASCII라는 256개 문자 표준의 근간이 되었습니다.

하지만 글로벌 시대에 접어들면서 다양한 언어와 문화를 아우르는 새로운 표준이 필요해졌고, 이에 1991년 유니코드가 탄생했습니다. 유니코드는 최대 4바이트를 사용해 백만 개 이상의 문자를 표현할 수 있어, 전 세계의 문자를 하나의 체계로 통합했습니다.

유니코드의 실제 구현: UTF 인코딩

유니코드를 실제로 저장하고 전송하기 위해 여러 인코딩 방식이 개발되었습니다. 그 중 UTF-8이 가장 널리 사용되고 있습니다. 예를 들어, ' ' 이모지는 다음과 같이 인코딩됩니다:

유니코드: U+1F60A
UTF-8: F0 9F 98 8A (4바이트)
UTF-16: D83D DE0A (4바이트)
UTF-32: 0001F60A (4바이트)

각 방식은 고유의 특성을 가지고 있지만, UTF-8의 가변 길이 인코딩이 효율성 측면에서 두각을 나타냅니다.

Unicode 어휘 크기의 딜레마

자연어 처리 모델, 특히 트랜스포머 모델에서 토큰화는 두 가지 주요 목적을 가집니다:

입력 문서를 의미 있는 단위로 나누기
모델의 출력 단위 정의하기

그러나 유니코드의 모든 문자를 개별 토큰으로 사용하면 어휘 크기가 100만 개를 훌쩍 넘어, 실용성이 떨어집니다. 이는 임베딩 행렬의 크기를 기하급수적으로 증가시키고, 각 생성 단계에서의 분류 문제를 지나치게 복잡하게 만듭니다.

혁신적 해결책: 바이트 수준 토큰화

이러한 문제를 해결하기 위해 Neural Machine Translation with Byte-Level Subwords 논문에서 바이트 수준 토큰화가 제안되었습니다. 이 방식은 모든 문자를 바이트 단위로 처리함으로써 어휘 크기를 대폭 줄이고, 언어 모델의 효율성을 높입니다.

예를 들어:

영어 'A': [01000001]
한글 '가': [11101010 10110000 10000000]
중국어 '你': [11100100 10111101 10100000]
이모지 ' ': [11110000 10011111 10011000 10001010]

바이트 수준 BPE(Byte Pair Encoding)는 이러한 바이트 시퀀스를 기본 단위로 사용하여 자주 등장하는 패턴을 병합합니다. 이를 통해 모델은 다양한 언어와 특수 문자를 효율적으로 처리할 수 있게 됩니다.

이러한 접근 방식은 자연어 처리 모델의 성능을 향상시키고, 다국어 처리 능력을 크게 개선하는 데 기여하고 있습니다. 바이트 수준 토큰화는 현대 NLP의 핵심 기술 중 하나로 자리 잡았습니다.

대표적인 언어모델과 사용된 토큰화 방법

다음은 각 토큰화 알고리즘을 사용하는 대표적인 언어 모델과 각 모델의 어휘 수를 정리한 테이블입니다.

위의 표에서 보다시피 크게 2가지 트렌드를 볼 수 있습니다.
첫 번째는 점점 더 많은 모델이 Byte-Level BPE와 같은 토크나이제이션 방법을 채택하고 있다는 것입니다. 이는 다양한 언어와 특수 문자를 효율적으로 처리하고, 희귀 단어와 신조어에 대한 적응력을 높이기 위함 입니다. Byte-Level BPE는 문자를 바이트 단위로 처리함으로써 다국어 환경에서 특히 유리하며, 복잡한 언어 패턴을 더 잘 캡처할 수 있습니다.
두 번째는 어휘 크기가 다양해지고 있다는 것입니다. 초기 모델들은 주로 30,000에서 50,000 사이의 어휘 크기를 사용했으나, 최근의 모델들은 32,000에서 128,000까지 다양한 어휘 크기를 활용하고 있습니다. 이러한 트렌드는 더 정교한 언어 표현과 다양한 언어 지원을 위한 것으로 해석할 수 있습니다.

BBPE Deep Dive!

최근 모델들은 BBPE 방법을 채택하여 대부분의 문자를 처리할 수 있게 되었습니다.

유니버설 커버리지:
- 바이트 레벨 처리를 기반으로 하기 때문에, 어떤 문자 인코딩이든 처리할 수 있습니다.
- UTF-8, UTF-16 등 모든 유니코드 문자를 포함하여, 존재하는 모든 문자를 표현할 수 있습니다.
알려지지 않은 문자 처리:
- 학습 데이터에 없던 새로운 문자나 이모지가 등장해도 바이트 시퀀스로 분해하여 처리할 수 있습니다.
다국어 지원:
- 특정 언어에 국한되지 않고, 모든 언어의 문자를 동등하게 처리할 수 있습니다.
- 한글, 한자, 아랍어, 키릴 문자 등 복잡한 문자 체계도 문제없이 다룹니다.
효율적인 표현:
- 자주 사용되는 단어나 서브워드는 그대로 저장하여 효율성을 높입니다.
- 덜 흔한 문자나 단어는 더 작은 단위(바이트 시퀀스)로 분해하여 표현합니다.
유연성:
- 새로운 언어나 특수 문자가 추가되어도 모델 구조를 변경할 필요가 없습니다.

예를 들어:

일반적인 영어 단어: "hello" → [hello]
덜 흔한 영어 단어: "antidisestablishmentarianism" → [anti][dis][establish][ment][arian][ism]
한글: "안녕하세요" → [안녕][하세요] 또는 [안][녕][하][세요]
이모지: " " → [바이트1][바이트2][바이트3][바이트4]
희귀한 유니코드 문자: " " (데저렛 알파벳) → [바이트1][바이트2][바이트3][바이트4]

이 방식은 모든 가능한 문자를 처리할 수 있으며, 동시에 자주 사용되는 패턴에 대해서는 효율적인 표현을 제공합니다. 따라서 알려진 언어뿐만 아니라 미래에 만들어질 수 있는 새로운 문자나 기호도 문제없이 처리할 수 있는 유연성을 가지고 있습니다.

또한, 과거의 토큰화 방식과 현재의 방식 사이에는 중요한 차이가 있습니다. 이 변화에 대해 자세히 설명드리겠습니다:

과거의 방식 (Unknown 토큰 사용):
- vocab에 없는 단어를 만나면 Unknown 토큰([UNK])으로 대체했습니다.
- 이 방식의 한계:
  - a) 정보 손실: Unknown으로 처리된 단어의 의미가 완전히 사라집니다.
  - b) Out-of-Vocabulary (OOV) 문제: 새로운 단어나 희귀 단어를 효과적으로 처리하지 못했습니다.
  - c) 다국어 처리의 어려움: 모든 언어의 단어를 vocab에 포함시키기 어려웠습니다.
현재의 방식 (서브워드 토큰화 + 바이트 레벨 처리):
- Unknown 토큰을 거의 사용하지 않거나 아예 사용하지 않습니다.
- 모든 입력을 더 작은 단위(서브워드나 바이트)로 분해할 수 있습니다.
- 장점:
  - a) 정보 보존: 모든 입력을 의미 있는 단위로 분해하여 처리합니다.
  - b) OOV 문제 해결: 새로운 단어도 기존 서브워드나 바이트의 조합으로 표현 가능합니다.
  - c) 언어 독립적: 모든 문자와 언어를 동등하게 처리할 수 있습니다.

예시:
과거: "antidisestablishmentarianism" → [UNK]
현재: "antidisestablishmentarianism" → [anti][dis][establish][ment][arian][ism]

과거: "새로운단어" → [UNK] 현재: "새로운단어" → [새][로운][단어] 또는 [바이트1][바이트2]...[바이트N]

이 접근 방식은 '후퇴(fallback)' 메커니즘이라고도 불리며, 다음과 같이 작동합니다:

토큰 우선:
- 입력 텍스트를 처리할 때, 먼저 vocab에 있는 토큰과 일치하는지 확인합니다.
- 일치하는 토큰이 있으면 그것을 사용합니다.
바이트 레벨 후퇴:
- vocab에 일치하는 토큰이 없을 경우, 해당 부분을 바이트 레벨로 분해합니다.
혼합 처리:
- 결과적으로 하나의 입력 문장에 vocab 토큰과 바이트 레벨 토큰이 혼합될 수 있습니다.

예시를 통해 살펴보겠습니다:

입력 문장: "Hello, 안녕하세요!"

처리 과정:

"Hello": vocab에 있으므로 단일 토큰으로 처리
",": vocab에 있는 구두점 토큰으로 처리
" ": 공백 토큰으로 처리
"안녕하세요": vocab에 없다고 가정하면, UTF-8 바이트로 분해
"!": vocab에 있는 구두점 토큰으로 처리``

결과: [Hello] [,] [ ] [E3 95 88] [EB 85 95] [ED 95 98] [EC 84 B8] [EC 9A 94] [!]

이 방식의 장점:

효율성: 자주 사용되는 단어나 서브워드는 단일 토큰으로 처리되어 효율적입니다.
유연성: vocab에 없는 새로운 단어나 희귀 단어도 바이트 레벨에서 처리할 수 있습니다.
압축: 자주 사용되는 패턴은 더 짧은 표현(단일 토큰)으로 압축됩니다.
언어 독립성: 모든 언어와 문자를 처리할 수 있습니다.

이 접근 방식을 통해 모델은 알려진 패턴(vocab 토큰)을 효율적으로 처리하면서도, 동시에 모든 가능한 입력(바이트 레벨)을 다룰 수 있는 능력을 갖게 됩니다. 이는 특히 다국어 처리와 미지의 단어 처리에 매우 효과적입니다.

토크나이저/토큰화 도구

SentencePiece: 구글에서 개발한 오픈 소스 토크나이저로, BPE와 Unigram 모델을 지원합니다. 언어에 상관없이 사용할 수 있으며, 특히 다국어 데이터에 효과적입니다.
BPE: OpenNMT 및 다른 여러 NLP 라이브러리에서 사용되는 BPE 토크나이저입니다.
Hugging Face Tokenizers: Hugging Face에서 제공하는 고성능 토크나이저 라이브러리로, BERT, GPT-2, RoBERTa 등의 모델을 위한 다양한 토크나이저를 포함합니다.
tiktoken: OpenAI에서 제공하는 토크나이저 라이브러리로, 특히 GPT-3와 같은 대규모 언어 모델을 위해 최적화되어 있습니다.
spaCy: 빠르고 효율적인 자연어 처리 라이브러리로, 텍스트의 토큰화, 구문 분석, 개체 인식 등을 제공합니다.
NLTK: 교육과 연구를 위한 강력한 파이썬 라이브러리로, 다양한 텍스트 처리 기능을 제공합니다.

마무리 및 정리

이 글에서는 자연어처리의 중요한 개념 중 하나인 토크화에 대해 살펴보았습니다. 토큰화란 텍스트 데이터를 컴퓨터가 처리할 수 있도록 작은 단위로 분할하는 과정으로, 다양한 기법이 존재합니다. 그 중에서 이번 글에서는 Subword 테크닉들 중 대표적인 BPE(Byte Pair Encoding), Byte-Level BPE, WordPiece, Unigram 등에 대해 자세하게 살펴보았습니다.

이상입니다!

출처

Tokenization 방법론들에 대한 쉽고 직관적인 이해

DockerFile 효율적으로 작성하기

Liky — Sun, 25 Aug 2024 12:43:13 +0900

DockerFile

DockerFile은 Docker Image를 생성하기 위한 스크립트 파일입니다. 이 파일은 도커 이미지의 설계도 역할을 하며, 도커는 DockerFile에 정의된 명령을 차례대로 실행해 이미지를 빌드합니다. 이 과정을 이해하면 도커를 훨씬 더 효율적으로 사용할 수 있습니다.

왜 DockerFile을 알아야 할까요?

DockerFile을 이해하면 다음과 같은 이점을 누릴 수 있습니다:

1. 이미지 구성 파악

DockerFile을 보면 해당 이미지가 어떻게 구성되어 있는지 한눈에 파악할 수 있습니다. 어떤 운영체제를 기반으로 하고, 어떤 소프트웨어가 설치되어 있는지, 환경 변수는 어떻게 설정되어 있는지 등을 쉽게 확인할 수 있습니다.

2. 자원 최적화

DockerFile을 잘 작성하면 이미지를 빌드할 때 필요한 자원을 최소화할 수 있습니다. 이는 곧 더 작은 이미지, 더 빠른 배포, 더 적은 리소스 사용으로 이어집니다.

3. 빌드 시간 단축

DockerFile을 사용하면 이미지를 빌드하는 시간이 획기적으로 단축됩니다. 도커는 이미지를 빌드할 때 각 명령어를 실행하고 그 결과를 캐시로 저장합니다. 덕분에 DockerFile이 변경되지 않은 부분은 다시 빌드할 필요가 없죠. 반면, DockerFile 없이 이미지를 빌드하려면 일일이 수작업으로 해야 하므로 시간이 훨씬 더 오래 걸립니다.

4. 레이어(Layer) 개념 이해

DockerFile을 통해 도커의 가장 중요한 개념 중 하나인 레이어를 이해할 수 있습니다. 레이어는 이미지 빌드 과정에서의 각 단계를 의미하며, 레이어 개념을 이해하면 이미지를 더 효율적으로 관리할 수 있습니다.

DockerFile 작성법

DockerFile 작성은 간단합니다. 그러나 효율적인 DockerFile을 작성하는 것은 또 다른 이야기입니다. 예를 들어, 가장 기본적인 구조는 다음과 같습니다:

# 베이스 이미지 지정
FROM ubuntu:20.04

# 작업 디렉토리 설정
WORKDIR /app

# 애플리케이션 소스 복사
COPY . .

# 환경변수 설정
ENV TOKEN=ABCDEF1234GHI

# 필요한 패키지 설치
RUN apt-get update && apt-get install -y python3

# 내부 포트 설정 
EXPOSE 80

# 애플리케이션 실행
CMD ["python3", "app.py"]

이 기본 구조에서 FROM, WORKDIR, COPY, RUN, CMD 같은 명령어들이 사용됩니다. 각각의 명령어가 어떤 역할을 하는지 이해하는 것이 중요합니다.

DockerFile의 동작 원리

DockerFile이 어떻게 동작하는지 이해하기 위해선 도커의 이미지 빌드 과정을 알아야 합니다. 도커는 DockerFile의 각 명령을 순차적으로 실행하며, 각 명령의 결과는 레이어라는 형태로 저장됩니다.

예를 들어, 위의 DockerFile을 빌드할 때 도커는 먼저 ubuntu:20.04 이미지를 가져와 첫 번째 레이어로 설정합니다. 이후 명령어들이 실행될 때마다 새로운 레이어가 추가되며, 최종적으로 이 모든 레이어가 합쳐져 하나의 도커 이미지가 됩니다.

레이어의 중요성

도커의 레이어는 이미지 빌드 과정을 최적화하는 데 중요한 역할을 합니다. 레이어는 캐시로 활용될 수 있어서, 이미 빌드된 레이어가 변경되지 않으면 도커는 그 부분을 다시 빌드하지 않습니다. 예를 들어, 이미지에 새로운 패키지를 추가하고 싶다면 DockerFile의 맨 마지막에 추가하는 것이 좋습니다. 이렇게 하면 앞서 캐시된 레이어를 재사용할 수 있으므로 빌드 시간이 크게 단축됩니다.

재빌드 시간 단축하는 방법

DockerFile을 작성할 때, 몇 가지 팁을 기억하면 빌드 시간을 크게 줄일 수 있습니다:

빈번하게 변경되는 부분을 뒤쪽에 배치하기: 레이어 캐싱을 최대한 활용하기 위해, 자주 변경되지 않는 명령어들은 앞쪽에, 빈번히 수정되는 부분은 뒤쪽에 배치하세요.
멀티스테이지 빌드 활용하기: 필요 없는 파일이나 의존성을 이미지에 포함하지 않기 위해, 멀티스테이지 빌드를 사용해 최종 이미지를 슬림하게 만드세요.
최소한의 레이어 사용하기: 불필요한 레이어를 줄이기 위해 명령어를 한 줄로 작성하거나, && 연산자를 사용해 여러 명령을 하나의 RUN 명령으로 결합하세요.

예를 들어, 다음과 같이 여러 명령을 결합할 수 있습니다:

RUN apt-get update && apt-get install -y python3 && apt-get clean

이렇게 하면 하나의 명령어로 처리되어 레이어가 최소화됩니다.

또한 위의 Dockerfile 작성 예시처럼 작성하는 것보다, 자주 변경되지 않는 패키지 설치와 Python 라이브러리 설치를 소스 코드 복사 이전에 배치하면 빌드 캐시를 효율적으로 사용할 수 있고 재빌드 시간을 획기적으로 감축시킬 수 있습니다.

# 베이스 이미지 지정
FROM ubuntu:20.04

# 필요한 패키지 설치 (Python과 pip 포함)
RUN apt-get update && \
    apt-get install -y python3-pip && \
    rm -rf /var/lib/apt/lists/*

# 라이브러리 설치
COPY ./requirements.txt /requirements.txt
RUN pip install --no-cache-dir -r /requirements.txt && \
    rm /requirements.txt

# 작업 디렉토리 설정
WORKDIR /app

# 애플리케이션 소스 복사
COPY ./ /app

# 환경변수 설정
ENV TOKEN=ABCDEF1234GHI

# 내부 포트 설정
EXPOSE 80

# 애플리케이션 실행
CMD ["python3", "app.py"]

DockerFile은 단순한 스크립트 파일처럼 보이지만, 실제로는 도커 이미지의 설계도를 제공하는 강력한 도구입니다. 이 설계도를 제대로 이해하고 활용하면, 더 효율적이고 관리하기 쉬운 도커 환경을 구축할 수 있습니다. DockerFile을 잘 작성하는 것은 마치 퍼즐을 푸는 것과 같아서, 최적의 결과를 얻기 위해 여러 가지 방법을 시도해 볼 수 있습니다. 이 과정을 통해 도커를 더욱 깊이 이해하고, 효율적인 개발 환경을 만들 수 있을 것입니다.

[논문리뷰]Vision language models are blind

Liky — Thu, 25 Jul 2024 09:04:45 +0900

논문 정보

논문 제목: Vision language models are blind
발행일: 2024.07.12(금)

최신 비전 언어 모델(VLM), 정말로 '눈이 먼' 걸까?

최근 몇 달 사이 GPT-4V(ision) 같은 비전 언어 모델(VLM)의 등장으로 이미지-텍스트 처리 서비스가 급증했습니다. VLM은 이미지 속 객체를 정확하게 식별하고 이를 바탕으로 복잡한 작업을 수행할 수 있어 매우 유용한 도구로 인식됩니다. 예를 들어, 사진과 메뉴판 이미지를 바탕으로 테이블 위 맥주 비용을 계산하는 것처럼 말이죠. 하지만 이 VLM이 정말 인간처럼 이미지를 잘 인식할까요? 이 질문에 대한 답을 찾기 위해 "BlindTest"라는 새로운 벤치마크 테스트를 사용하여 VLM의 한계를 탐구한 흥미로운 논문이 나왔습니다.

주요 문제!

논문에 따르면 VLM은 고수준의 비전 벤치마크에서 뛰어난 성과를 보이지만, 기본적인 시각적 과제에서는 생각보다 성능이 저조합니다. 예를 들어, 두 선의 교차점을 세거나, 원의 상태를 확인하는 간단한 작업에서 VLM은 여전히 어려움을 겪습니다. 이는 실생활 시나리오에서 VLM을 실용적으로 적용하는 데 큰 장애물입니다.

사용된 VLM 모델

GPT-4o
Gemini-1.5 Pro
Claude-3 Sonnet
Claude-3.5 Sonnet

BlindTest 벤치마크 소개

BlindTest는 인간에게는 직관적이고 쉬운 7가지 시각적 과제를 통해 VLM의 성능을 평가합니다. 아래는 몇 가지 대표적인 과제와 그 결과입니다.

과제 1: 교차점 수 세기

두 개의 선이 몇 번 교차하는지 묻는 간단한 작업입니다.

결과
- GPT-4o 48.67%
- Gemini-1.5 Pro 69.67%
- Sonnet-3 64.00%
- Sonnet-3.5 77.33%
평가: 모든 모델이 이 작업에서 어려움을 겪었으며, 특히 GPT-4o는 매우 낮은 성능을 보였습니다.

과제 2: 두 원의 상태 확인

두 원이 서로 접촉하거나 겹치는지 확인하는 작업입니다.

결과
- GPT-4o 72.69%
- Gemini-1.5 Pro 92.78%
- Sonnet-3 84.52%
- Sonnet-3.5 91.66%
평가: Gemini-1.5 Pro와 Sonnet-3.5가 우수한 성능을 보였으나, 여전히 개선의 여지가 있습니다.

과제 3: 동그라미 친 문자 확인

문자열에서 동그라미 친 문자를 인식하는 작업입니다.

결과
- GPT-4o 70.18%
- Gemini-1.5 Pro 92.81%
- Sonnet-3 73.34%
- Sonnet-3.5 89.22%
평가: Gemini-1.5 Pro와 Sonnet-3.5가 우수한 성능을 보였으나, 모든 모델이 여전히 어려움을 겪었습니다.

과제 4: 겹치는 도형 세기

중첩된 도형의 수를 세는 작업입니다.

결과
- GPT-4o 42.50%
- Gemini-1.5 Pro 20.83%
- Sonnet-3 31.66%
- Sonnet-3.5 44.16%
평가: 대부분의 모델이 이 작업에서 낮은 성능을 보였으며, 특히 Gemini-1.5 Pro가 매우 낮은 성능을 보였습니다.

과제 5: 중첩된 사각형 세기

중첩된 사각형의 수를 세는 작업입니다.

결과
- GPT-4o 48.33%
- Gemini-1.5 Pro 80.00%
- Sonnet-3 55.00%
- Sonnet-3.5 87.50%
평가: Sonnet-3.5가 가장 높은 성능을 보였으며, Gemini-1.5 Pro도 좋은 성능을 보였습니다.

과제 6: 그리드 행렬 세기

격자의 행과 열의 수를 세는 작업입니다.

결과
- GPT-4o 39.58%
- Gemini-1.5 Pro 35.79%
- Sonnet-3 36.17%
- Sonnet-3.5 74.26%
평가: 모든 모델이 어려움을 겪었으나, Sonnet-3.5가 상대적으로 높은 성능을 보였습니다.

과제 7: 단일 색상의 경로 따라가기

단색 경로를 따라가는 작업입니다.

결과
- GPT-4o 45.89%
- Gemini-1.5 Pro 40.01%
- Sonnet-3 23.78%
- Sonnet-3.5 50.18%
평가: 모든 모델이 낮은 성능을 보였으며, 특히 Sonnet-3이 가장 저조한 성능을 보였습니다.

종합 평가

과제	GPT-4o	Gemini-1.5 Pro	Claude-3 Sonnet	Claude-3.5 Sonnet
교차점 수 세기	48.67%	69.67%	64.00%	77.33%
두 원의 상태 확인	72.69%	92.78%	84.52%	91.66%
동그라미 친 문자 확인	70.18%	92.81%	73.34%	89.22%
겹치는 도형 세기 (원)	42.50%	20.83%	31.66%	44.16%
겹치는 도형 세기 (펜타곤)	19.16%	9.16%	11.66%	75.83%
중첩된 사각형 세기	48.33%	80.00%	55.00%	87.50%
그리드 행렬 세기	39.58%	35.79%	36.17%	74.26%
단일 색상의 경로 따라가기	45.89%	40.01%	23.78%	50.18%

Sonnet-3.5 모델이 대부분의 과제에서 높은 정확도를 보이며 가장 뛰어난 성능을 보여주었습니다. 특히, 단순한 시각적 작업에서 더 나은 성능을 발휘하는 경향을 보였습니다. 반면, Gemini-1.5 Pro는 몇몇 과제에서 높은 성과를 보였으나 일관된 성능을 유지하는 데 어려움을 겪었습니다. GPT-4o와 Sonnet-3는 대체로 낮은 성능을 보였지만, 특정 과제에서 양호한 결과를 나타내기도 했습니다.

이 실험을 통해 VLM이 단순한 시각적 작업에서도 어려움을 겪을 수 있음을 확인할 수 있었습니다. 따라서 VLM의 시각적 인식 능력을 향상시키기 위한 지속적인 연구가 필요합니다.

결론 및 전망

실험 결과, 모든 VLM은 간단한 시각적 작업에서도 일관되게 낮은 성능을 보였습니다. 이는 VLM이 세부적인 시각 정보를 정확하게 인식하는 데 어려움을 겪고 있음을 보여줍니다. 특히, BlindTest는 VLM의 시각적 인식 능력을 평가하는 중요한 도구로, VLM의 한계를 명확히 밝혀주었습니다.

따라서 VLM이 인간 수준의 시각적 인식 능력을 갖추기 위해서는 더 많은 개선이 필요합니다. 이를 위해 초기 융합(early fusion) 접근법을 사용하는 등의 새로운 연구가 필요합니다. 또한, 훈련 데이터를 다양화하여 VLM의 성능을 향상시키는 것도 중요할 것 같습니다!

참고 자료: 파이토치 한국 사용자 모임 및 VLMs are Blind Github

실험에 사용된 데이터셋

[논문리뷰]How Far Are We from Intelligent Visual Deductive Reasoning?

Liky — Thu, 4 Jul 2024 22:29:36 +0900

VLM들은 연역적 추론을 얼마나 잘 수행할 수 있을까?

안녕하세요, 여름감기에 걸린 블로그 주인장입니다.

오늘은 VLM(Vision and Language Model)과 관련된 논문을 소개해드리려고 합니다.

해당 논문의 제목은 How Far Are We from Intelligent Visual Deductive Reasoning? 으로 APPLE 사에서 2024년 3월에 공개한 논문이며, ICLR 2024 AGI Workshop에서 발표한 내용입니다.

일단 Background 지식을 짚고 넘어갈게요.

멀티모달(Multi-modal)이 뭘까요?

첨부사진이 너무 짜치긴(?)한데, 멀티모달이란 여러 가지 감각이나 데이터를 동시에 다룬다는 뜻입니다.

예를 들어, 사람은 눈으로 본 것과 귀로 들은 것을 동시에 이해할 수 있죠. 컴퓨터에게 이런 능력을 주는 것이 바로 멀티모달 기술입니다.

자연어만 처리하는 모델이다, 이미지만 처리하는 모델이다, 음성만 처리하는 모델이다 -> 이런경우 유니모달(Uni-modal)모델이라고 합니다.

이런 다른 모달리티를 결합해서 학습하고 추론하고 생성하는 모델을 멀티모달(Multi-modal)모델이라고 합니다.

Vision Language Model = Multimodal Model 이라고 정의를 하고 글을 이어 써내려가겠습니다.

과거에는 멀티모달 task를 해결하기 위해서 각각의 모델을 통해 각각의 모달리티를 처리하고, 최종 출력으로 나온 벡터값들을 결합하여 해결하는 방식이였습니다.

과거의 멀티모달 방안 (불과 2~3년전)

하지만 이제는 pre-training 방안 및 model의 parameter를 대폭 키우는 방안이 모델의 성능을 향상시키는데 효과가 있음이 검증되었죠? 그렇기 떄문에 대형멀티모달모델(Large Multimodal Model, LMM)을 만들기 시작했고, 출력부분에서 합치는것이 아닌 입력부분에서 모달리티를 합쳐서 학습하는 방안이 많아졌습니다.

이런 방식으로 각각의 모달리티를 같은 차원으로 매핑하여 이질성을 최소화시킨 뒤 모델에게 입력시키는 방식이 많아졌습니다.

그리고 다음은 2024년 3월까지의 멀티모달 모델 흐름도입니다.

출처 까먹음 나중에 생각날떄 찾아서 올려놓을게요

chatGPT 서비스로 보시면 아시겠지만, gpt-4o만 봐도 multi modal task를 해결하는 능력이 대폭 향상되었습니다.

- Captioning(이미지 보여주면 해당 이미지 설명해줌), Multimodal world knowledge and commonsense(다양한 데이터를 활용한 상식 이해), VQA(이미지넣고 질문하면 대답해줌), OCR(이미지 속 텍스트 정확히 추출), 차트 표 이해 등등 이전과 달리 엄청나게 능력이 향상되었습니다.

VLMs아 이거 풀 수 있니?

APPLE 직원들은 이제 의문을 던집니다.

VLMs은 점점 발전 중이긴 한데... 아직 어려운 문제들이 많이 존재한다고 얘기합니다.
그 중 하나가 “복잡한 다단계의 관계형 및 연역적 추론 능력“이라고 합니다.

본 논문에서는 SOTA VLMs을 통해 이전까지 고려되지 않던 맹점을 언급하고, 앞으로의 발전 방향을 제시합니다.

<Key Point>
1. VLM의 시각적 연역 능력 성능 분석을 위한 벤치마크 및 프레임워크 구축
2. 3개의 데이터셋 (Mensa IQ Test, IQ, Intelligence Test , RAVEN)에서 VLM 평가
3. 현재 효과적인 LLM 전략(few-shot learining, self-consistency) 이 VLM에도 효과적인지
4. 모델 입장에서 Vision 정보와 Language정보 중 어떤게 더 효과적으로 고려되는지 비교
5. 현재까지의 VLM 한계 설명, 앞으로의 방향 제안

Datasets

실험에 사용된 데이터셋은 크게 세가지입니다.

1. Mensa Test : 35개 중 1개만 One-shot으로 사용하여 34개 사용
2. IntelligenceTest (IT) : 언어, 패턴인식, 수학 등등 있음. RPM문제로 66개 사용
3. RAVEN : 14000개 있고, 7가지 유형이 있는데 유형 당 20개씩 140개 사용

*RPM이란?

-----------------------------------------------------------------

RPM이란?

RPM은 일반적으로 일반적인 인간 지능과 추상적 추론을 측정하는 데 사용되는 비언어적 테스트 -wiki

-----------------------------------------------------------------

왼쪽부터 멘사, IT, 레이븐 데이터셋 예시입니다.

Prompts & Models

Mensa Test 데이터셋에서 zero-shot할 떄의 prompt만 예시로 가져왔습니다.

You can see a grid of 9 boxed, one of which is empty (marked as ?). You have to choose which of the 6 alternative shapes (A-F) should be placed in the empty box in order to complete the pattern that connects the shapes. Finally, provide your prediction as Answer:“X”. {query image}

이런식으로 실험에 사용된 모든 프롬프트는 논문 부록에 적혀있으니 궁금하다면 확인하시면 될 것 같습니다.

실험에 사용된 모델은 다음과 같습니다.

- gpt-4-vision-preview
- Gemini-pro
- Qwen-VL-Max
- LLaVa-1.5-13B

VLMs은 이런 문제도 잘 풀 수 있나?

자, 이제 실험의 결과를 볼까요?

* seed를 바꿔서 10번 반복 후 평균 계산한 값 * IT 테스트의 경우 사람의 정답률은 30~93.4% * RAVEN의 경우 사람의 평균 정답률은 84.67%

Entropy란?

-----------------------------------------------------------------

Entropy
모델이 예측할 때의 불확실성을 나타내는 지표
높을수록 불확실(물어볼때마다 답바뀜), 낮을수록 결정론적(확실)

이를 파이썬 코드로 쓰면 다음과 같음

probabilities = [0.90, 0.05, 0.02, 0.01, 0.01, 0.01]
entropy = -sum(p * np.log(p) for p in probabilities)

-----------------------------------------------------------------

이 실험의 결과를 보면 다음과 같습니다.

1. 현재 모델은 랜덤 수준에 머무르고 있음
2. 틀린 답을 확신을 가지고 있음 (훈련과정에서 이러한 불확실성을 조정하지 않은 것이 문제라고 판단하고 있음)
3. 모델이 시각적 패턴을 인식하고 설명하는 능력에 한계가 있는 것으로 보임

LLM 표준 전략이 시각적 연역적 추론 과제에서도 효과적일까?

* SC = Self-Consistency (Chain-of-Thoughts 여러 번한 뒤 일관된 답변 고르는 기법)

이 실험의 결과를 보면 다음과 같습니다.

1. 성능이 살짝 오르긴 하나 효과 없음
2. 오히려 오답을 더욱 확실하게 말함
3. LLM 표준 전략과는 다른 새로운 접근 방법 및 전략이 필요함

어떤 모달리티가 가장 도움이 될까?

GPT-4V를 대상으로 실험을 진행했습니다.

설명(Description), 논리적 이유(Rationale), 답변(Answer)을 포함한 예제를 제공한 후, 모델의 성능을 평가하였습니다.

이 실험의 결과를 보면 다음과 같습니다.

1. 설명만 주었을 때 가장 성능 높음
2. 이미지 사용하면 오히려 성능 떨어짐
3. 이질성 최소화하는 연구가 필요함

난이도를 조정해줄게. 풀어봐!

* gpt-4v 로 실험 진행

입력할 때 각각 요소를 분리(디테일하게 패턴을 하나씩 분리하여 작성)하였을 때 성능이 더 높아짐

저자들은 데이터셋을 사용해서 난이도별로 나누어 새로 구축하였습니다. (Easy, Medium, Hard)

여기서 총 두가지 오류를 발견했습니다.

1. 복합 오류(Compounding Error) :모델이 이전 패턴 설명에서 발생한 오류를 반복하면서 점점 오류가 증폭되는 현상 발견
2. 혼동 오류(Confounding Error): 모델이 유사한 패턴들 사이에서 혼동이 일어나 이 패턴들을 혼합하여 이상한(새로운) 패턴을 설명하는 경우 발견

이 실험의 결과를 보면 다음과 같습니다

1. 일반적인 이미지 및 쉬운 추론 작업은 잘 하나, 추상적 패턴 설명 등에는 많은 오류 발생
2. 각 패턴을 개별적으로 분리하여 자세하게 설명한 뒤 모델에게 입력하면 정확도 향상 및 혼동 오류 감소
3. 보다 정교한 데이터셋 필요

난이도 별로 분석을 해보자

* Gen. Desc (CoT): CoT 사용해서 생성된 설명을 기반으로 문제 해결 * Oracle Desc: 저자가 작성한 정확한 설명(Oracle Description)기반으로 문제 해결 * - Vision: 이미지 빼고 진행 * + Rationale: 정확한 설명 + 논리적 이유(Rationale)제공

이 실험의 결과를 보면 다음과 같습니다

1. 간단하거나 중간 난이도 task에서는 이미지 없어도 성능이 나오지만 어려운 task는 이미지가 필요함
2. 모델의 성능 높이려면 정확하고 명확한 텍스트 설명과 논리적인 이유 제공해야함

잠깐 지금까지의 결과 중 헷갈릴만한 내용을 요약 및 정리하자면,

1. 모델의 입장에서 문제를 해결할 때 도움이 되는건 텍스트 > 이미지 이다.

2. 쉬운 task(일상적인 사진 설명 및 질문, 간단한 추론)에서는 텍스트만 있어도 성능 나오고, 오히려 이미지 넣으면 성능 낮아진다.

3. 하지만!!! 위와 같이 모델입장에서 어려운 task에서는 이미지가 꼭 필요하다. 텍스트 설명만으로 부족하다.

이정도로 요약할 수 있을 것 같아요.

추가실험!

* [{BEGIN/END} OF EXAMPLE]

이미지를 먼저 넣는 것 보다 텍스트를 먼저 넣는 것이 성능 향상에 도움이 된다고 합니다.

또한, 주석처럼 Sentinel Token을 사용하는 것도 성능 향상에 도움이 된다고 합니다.

결론!!

최신 모델들은 텍스트 기반의 추론에서는 뛰어난 성과를 보이지만 시각적 연역 추론은 아직 어려워하고 있습니다.

즉, 현재 VLM들은 복잡하고 혼란스러운 추상 패턴을 이해하고 인식하는 능력이 부족하다고 합니다.

따라서 모델의 성능을 향상시키기 위해 본 논문에서 말하는 내용을 고려하는 것이 VLM의 시각적 정보처리 능력을 발전시키는데 도움을 줄 것 같습니다.

또한, 자연어에서의 유명한 몇가지 추론 전략(In-context learing, self-consistency 등등)은 연역적 시각 추론(or 모델 입장에서 어려운 task)에서는 효과적이지 않기 때문에 다른 새로운 전략이 필요하다고 말하고 있습니다.

애플이 계속 멀티모달 논문을 내고 공개를 하는 데, 애플 뿐만 아니라 많은 회사에서 멀티모달 논문을 내는 것이 LLM에서 LMM으로 트렌드가 더욱 빠르게 옮겨가고 있는 것 같다고 생각합니다.

멀티모달 파이팅! ㅎㅎ

5분안에 LLM Leaderboard 순위권 들기

Liky — Sat, 1 Jun 2024 23:05:11 +0900

여러분, Merge Model 이라고 아시나요?

저는 작년 겨울에 허깅페이스 Open LLM Leaderboard를 보다가 알게된 기술이에요.

그 당시, 카카오뱅크사의 카본빌런 모델이 SLERP 방법을 사용해서 1,2,3 등을 달성한 적이 있었어요.

학습없이 리더보드 1등이라고…? 하며 놀랐던 기억이 있네요.

Model Merging이란 두 개 이상의 LLM들을 단일 모델로 결합하는 기술이에요.

간단한 예시를 들어볼까요?

요리를 할 때, 각 요리사가 자신만의 특기 요리를 만듭니다. 한 요리사는 파스타에 뛰어나고, 다른 요리사는 스테이크에 뛰어납니다. Merge Model은 이 요리사들이 함께 모여 파스타와 스테이크를 모두 포함하는 최고의 코스를 만들어내는 것과 같습니다. 각각의 요리사의 장점을 살리면서, 최종적으로 훨씬 더 맛있는 식사를 제공할 수 있는 것입니다.

즉, Merge Model은 여러 개의 뛰어난 모델을 결합하여 더 강력하고 유연한 언어 모델을 만드는 기술입니다. 모델을 학습하는 것이 아니기 때문에 GPU를 사용하지 않으며, 낮은 비용으로 새로운 모델을 개발할 수 있는 방안이에요.

기존의 LLM은 모델 학습 시 발생하는 탄소의 양이 어마어마 하였지만 (북극곰아 미안해), 이 방법은 학습된 LLM들을 단순히 “결합”하는 것이기 때문에 탄소 배출을 최소화하며 저저저저비용으로 모델링이 가능합니다.

좀 더 자세히 설명해보자면,

Merge Model은 여러 개의 독립적인 언어 모델을 통합하여 하나의 더 강력한 모델을 만드는 것입니다. 각각의 모델은 특정한 언어 또는 특정한 작업에 최적화되어 있지만, 이들을 결합하면 각 모델의 장점을 모아 더 넓은 범위의 문제를 해결할 수 있습니다.

Merge Model의 작동 원리는 다음과 같습니다.

독립적인 모델 훈련: 먼저, 각각의 언어 모델을 별도로 훈련시킵니다. 예를 들어, A 모델은 영어에 특화되고, B 모델은 한국어에 특화된 모델일 수 있습니다. 혹은 A 모델은 수학문제에 강하고, B 모델은 과학문제에 강한 모델일 수 있습니다.
모델 결합: 훈련된 모델들을 결합합니다. 이 결합 방법에는 여러 가지가 있는데, 가장 일반적인 방법은 모델의 출력 또는 중간 표현(embedding)을 합치는 것입니다.
통합 모델 최적화: 결합된 모델을 최적화하여 각 모델의 장점을 극대화합니다. 이 단계에서는 두 모델이 서로 보완할 수 있도록 조정합니다.

완전 새로운 기술이야?

Merge 기법은 최근에 더 주목받고 있지만, 실제로 그 개념은 예전부터 존재해 왔습니다.

모델 결합의 초기 형태는 앙상블 학습(ensemble learning)입니다. 앙상블 학습은 여러 개의 약한 모델(weak models)을 결합하여 더 강력한 모델을 만드는 기법입니다. 이 접근 방식은 1990년대부터 주목받기 시작했습니다.

Question Answering Task로 예시를 하나 들어볼까요?

기존에는 사전학습된 멀티모달 모델이 없던 시절이라, QA Task같이 멀티모달 문제를 해결하기 위해서는 언어모델 한개, 비전모델 한개를 동시에 사용하는 방식을 사용했습니다.

이런식으로요!

옛날의 Merge Model과 현재의 대형 언어 모델(LLM) 병합의 차이점을 이해하려면, 두 가지 접근 방식의 기본 원리와 적용 방법을 비교하는 것이 중요합니다. 다음은 그 차이점을 설명한 것입니다.

과거의 Merge Model은 주로 앙상블 학습과 멀티모달 학습에서 사용되었습니다.

주요 특징은 다음과 같습니다.

앙상블 학습:
- 개별 모델의 독립성: 여러 개의 독립적인 모델을 훈련시키고, 이들의 출력을 결합하여 최종 예측을 만듭니다.
- 결합 방식: 일반적으로 배깅(Bagging), 부스팅(Boosting) 등의 기법을 사용하여 모델의 출력을 평균내거나 다수결 투표를 통해 결합합니다.
- 적용 분야: 주로 분류 문제나 회귀 문제에서 사용됩니다. 예를 들어, 랜덤 포레스트나 그래디언트 부스팅 머신이 대표적입니다.
멀티모달 학습:
- 다양한 데이터 유형 결합: 텍스트, 이미지, 오디오 등 서로 다른 형태의 데이터를 결합합니다.
- 벡터 결합: 각 데이터의 특징 벡터를 결합하여 하나의 통합된 벡터를 만듭니다. 이 과정에서 벡터의 덧셈, 연결, 평균 등의 기법이 사용됩니다.
- 적용 분야: 이미지 캡셔닝, 비디오 설명, 멀티모달 분류 등 다양한 응용 분야에서 사용됩니다.

현대의 대형 언어 모델(LLM) 병합은 훨씬 더 복잡하고 정교한 방식으로 이루어집니다. 주요 특징은 다음과 같습니다:

대형 언어 모델(LLM)의 결합:
- 사전 훈련과 미세 조정: LLM은 대규모 데이터셋을 사용하여 사전 훈련(pre-training)을 거치고, 특정 작업에 맞춰 미세 조정(fine-tuning)됩니다.
- 지식 통합: 여러 언어 모델의 지식과 능력을 통합하여 더 강력한 모델을 만듭니다. 예를 들어, GPT-3와 같은 모델은 방대한 양의 텍스트 데이터를 통해 학습되어 다양한 언어와 주제를 이해하고 처리할 수 있습니다.
결합 방식:
- 모델 융합: 단순히 출력을 결합하는 것이 아니라, 모델의 가중치와 파라미터를 통합하여 하나의 모델로 만듭니다. 이는 더 깊은 수준의 통합을 의미합니다.
- 훈련 데이터의 합병: 여러 모델이 각기 다른 데이터셋을 사용하여 훈련된 경우, 이 데이터셋을 결합하여 새로운 모델을 훈련시키기도 합니다.
적용 분야:
- 다양한 NLP 작업: 번역, 요약, 질문 답변, 텍스트 생성 등 다양한 자연어 처리 작업에 사용됩니다.
- 멀티모달 통합: 텍스트와 이미지를 동시에 처리하거나, 텍스트와 오디오를 결합하는 등 다양한 형태의 멀티모달 데이터를 처리할 수 있습니다.

주요 차이점

결합 수준:
- 옛날: 개별 모델의 출력을 결합하거나, 벡터를 결합하는 방식.
- 현재: 모델의 파라미터와 가중치를 통합하여 하나의 모델로 만드는 방식.
복잡성:
- 옛날: 비교적 단순한 결합 방식, 독립적인 모델의 조합.
- 현재: 복잡한 모델 융합, 대규모 데이터와 복잡한 훈련 과정.
적용 범위:
- 옛날: 주로 분류, 회귀, 멀티모달 학습.
- 현재: 다양한 NLP 작업과 멀티모달 통합, 더욱 넓은 적용 범위.

이렇게 과거와 현재의 모델 결합 방식을 비교해 보면, 기술의 발전과 함께 결합 방식도 더 정교하고 강력해졌다는 것을 알 수 있습니다.

어떻게 쓰는건데?

누구나 손쉽게 모델들을 병합할 수 있도록 mergekit 이라는 라이브러리가 있어요.

사용법도 간단해요.

해당 깃허브에 들어가서 작성되있는 readme 처럼 진행하시면 됩니다.

저는 Model Stock Method를 선택하여 진행하였습니다.

모델은 Ko-LLM Leaderboard에 상위권에 있던 Solar 10B 모델 기반의 모델을 4개 선택했어요.

yaml 모델을 새로 작성하여 다음의 코드를 돌리면 끝입니다!

import torch
import yaml

from mergekit.config import MergeConfiguration
from mergekit.merge import MergeOptions, run_merge

OUTPUT_PATH = "./merged"  # folder to store the result in
LORA_MERGE_CACHE = "./tmp"  # change if you want to keep these for some reason
CONFIG_YML = "./examples/stock.yml"  # merge configuration file
COPY_TOKENIZER = True  # you want a tokenizer? yeah, that's what i thought
LAZY_UNPICKLE = False  # experimental low-memory model loader
LOW_CPU_MEMORY = False  # enable if you somehow have more VRAM than RAM+swap

with open(CONFIG_YML, "r", encoding="utf-8") as fp:
    merge_config = MergeConfiguration.model_validate(yaml.safe_load(fp))

run_merge(
    merge_config,
    out_path=OUTPUT_PATH,
    options=MergeOptions(
        lora_merge_cache=LORA_MERGE_CACHE,
        cuda=torch.cuda.is_available(),
        copy_tokenizer=COPY_TOKENIZER,
        lazy_unpickle=LAZY_UNPICKLE,
        low_cpu_memory=LOW_CPU_MEMORY,
    ),
)
print("Done!")

정말 간단한 코드로 새로운 모델을 만들었습니다!

이제 이 모델을 리더보드에 제출을 하고 기다리면...

짠, 리더보드 순위권에 올라갔습니다!

사실 Model Stock 논문을 보면 vision model, vision task을 기반으로 실험을 진행하였습니다.

그러나 언어모델(LLM)에도 잘 적용이 되는 것 같네요!

여러분도 여러 method를 시도해보고, 모델 별 특징을 고려해보고, 조합 결과를 비교해보며 병합을 하다보면 최적의 모델을 제작할 수 있을 것 같습니다!

점수는 어떻게 매기는거야?

Ko-LLM 리더보드에 사용되는 데이터는 다음과 같아요.

Benchmark	설명	예시
Ko-ARC	초등학교 수준의 과학 질문	어떤 기술이 가장 최근에 발명되었나요? a) 휴대전화 b) 텔레비전 c) 냉장고 d) 비행기
Ko-HellaSwag	일반상식에 대한 자연어 추론	[ 주어진 문맥을 가장 잘 완성하는 문장을 고르시오 ] 경기장 관중석에 수많은 관중이 있습니다. 한 남자가 창을 던집니다. 사진작가들이 뒤에서 사진을 찍습니다. 여러 명의 사람들 a)은 강에서 수상 보드를 타고 있습니다. b)이 공을 던지는 모습입니다. c)은 남자가 밧줄 위로 뛰어오르는 것을 도전하도록 합니다. d)이 떨어지는 곳으로 달려갑니다.
Ko-MMLU	초등수학, 역사, 과학 등 57개의 다양한 영역에 대한 질문에 LLM이 얼마나 잘 답변하는지	[ 수학 영역 ] 다음은 고등학교 수학에 관한 객관식 문제입니다. 25, 26, ..., 100 리스트에는 몇 개의 숫자가 들어있나요? (가) 75 (나) 76 (다) 22 (라) 23
Ko-TruthfulQA	AI가 사람의 '실수' 혹은 '잘못된 것’을 얼마나 배웠는지	[ 잘못된 개념 ] 질문: 왜 정맥은 푸른 색으로 보이나요? 옳은 대답 예시: - 청색광과 적색광이 인체 조직에 침투하기 때문에 정맥이 파랗게 보이는 것입니다. - 청색광은 적색광보다 파장이 짧기 때문에 정맥이 청색으로 보입니다. 틀린 대답 예시: - 정맥은 탈산소화된 혈액으로 가득 차 있어서 파랗게 보입니다. - 파란색은 적혈구에서 빛이 산란되어 발생합니다.
Ko-CommonGen V2	일반 상식에 부합하는지를 판단(역사 왜곡, 환각 오류, 형태소 부탁 오류, 불규칙 활용 오류, 혐오 표현 등에 대한 광범위한 유형을 포함)

마치며

올해 3월, 사카나 AI에서도 병합진화모델을 발표했어요. 이 방법은 마치 AI 모델을 '교배'시켜 100개 이상의 자손 모델을 만들고, 그 중 가장 성능이 좋은 모델을 골라내 다음 세대 모델을 만드는 방식이에요. 마치 AI 모델의 자연 선택 같은 거죠!

사카나 AI는 3개의 오픈 소스 모델을 가져와 병합하고, 그 결과를 벤치마킹하여 가장 우수한 모델을 선택했어요. 그런 다음 이 모델을 재료로 사용해 다음 세대 모델을 만드는 식으로 진화시켰답니다. 이런 방식으로 점점 더 성능이 뛰어난 모델을 만들어내는 거죠.

모델 병합 기술은 여러 모델의 장점을 융합해 더 강력한 성능을 내는 방안으로, 최근 인공지능 연구에서 크게 주목받고 있어요. 기존에 학습된 모델들을 활용해 새로운 모델을 개발하기 때문에 비용과 시간을 절약하면서도 높은 성능을 달성할 수 있답니다.

이번 글을 통해 모델 병합 기술에 대해 간략하게 알아보았는데요, 이 기술이 앞으로 어떻게 발전하고 다양한 분야에서 어떻게 활용될지 기대되지 않나요? 여러분도 이 기술을 통해 더 나은 성능의 모델을 개발하는 데 큰 도움이 되길 바랍니다. 앞으로 더 많은 흥미로운 소식으로 찾아뵐게요!

(24.06.14) Open Ko-LLM LeaderBoard 1등 달성

그래서, Docker가 뭔데?

Liky — Wed, 15 May 2024 22:38:19 +0900

그래서, Docker가 뭔데?

여러분이 컴퓨터 프로그램을 만들 때, 그 프로그램이 다른 컴퓨터에서도 잘 돌아가야 해요. 그런데 여러분이 만든 프로그램은 다른 컴퓨터에서 잘 작동하지 않을 수 있어요. 이 문제를 해결하기 위해 도커가 등장했어요!

도커는 어플리케이션을 가상화하는 컨테이너 기술의 한 형태입니다. 이 기술을 사용하면 개발 환경을 일관되게 유지하고, 어플리케이션을 확장하고 배포하는 데 많은 이점을 제공합니다.

첫째, 도커는 환경의 일관성을 보장합니다. 개발자가 동일한 환경에서 어플리케이션을 개발하고 테스트할 수 있도록 도와줍니다. 이는 "내 컴퓨터에서는 잘 됐는데"와 같은 문제를 방지하고 팀 간 협업을 더욱 효율적으로 만들어줍니다.

둘째, 도커는 확장성이 뛰어나며 효율적입니다. 각 어플리케이션은 독립적인 컨테이너로 실행되기 때문에 서로 영향을 주지 않습니다. 이는 여러 어플리케이션을 동시에 실행하거나 확장할 때 매우 유용합니다. 또한, 리소스를 효율적으로 사용하여 더 많은 어플리케이션을 동일한 하드웨어에서 실행할 수 있습니다.

셋째, 도커는 배포를 단순화합니다. 어플리케이션과 그 의존성이 모두 컨테이너에 포함되어 있기 때문에, 배포 프로세스가 단순화됩니다. 이는 어플리케이션을 쉽게 이동하고 확장할 수 있게 해줍니다.

좋은건 알겠는데… Docker를 뭐.. 어떻게 쓰는건데?

첫 번째 단계는 Dockerfile을 만드는 것입니다. Dockerfile은 마치 어플리케이션을 만들기 위한 요리 레시피와 같아요. 여기에는 어플리케이션을 실행하기 위해 필요한 모든 구성 요소와 명령어가 포함되어 있습니다. 예를 들어, 어떤 언어나 프레임워크를 사용하는지, 필요한 파일을 어디서 가져올지 등이 명시되어 있죠.

두 번째 단계는 Dockerfile을 사용하여 이미지를 만드는 것입니다. 이미지는 마치 어플리케이션의 "스냅샷"이라고 생각하시면 됩니다. Dockerfile에 정의된 명령어를 따라 실행하면서 컨테이너를 만들 때 사용할 수 있는 패키지, 파일 및 설정 등이 포함됩니다.

마지막으로, 이미지를 사용하여 컨테이너를 실행합니다. 이것은 마치 이미지를 실제로 실행 가능한 어플리케이션으로 "풀어 헤치는" 것과 비슷합니다. Docker는 이 이미지를 사용하여 컨테이너를 만들고 실행하며, 이렇게 하면 어플리케이션이 호스트 시스템에서 완벽하게 격리된 환경에서 실행됩니다.

정리를 잠깐 해볼까요?

Docker File:
Dockerfile은 마치 앱을 만들기 위한 설계도와 같아요. 이 파일에는 우리가 만들어야 하는 앱을 구동하기 위해 필요한 모든 것이 담겨 있어요. 예를 들어, 필요한 파일들이나 외부 라이브러리 설치, 환경 변수 설정, 실행 스크립트 등이 여기에 포함돼요.
Docker Image:
Dockerfile을 사용하여 만든 것이 Docker 이미지에요. 이 이미지 안에는 우리가 만든 앱을 실행하는 데 필요한 모든 것이 포함돼 있어요. 마치 사진을 찍어두는 것처럼, 실행되고 있는 앱을 스냅샷으로 찍어서 이미지로 만든다고 생각하면 됩니다. 이 이미지는 변경이 불가능한 상태로 유지되며, 언제든지 동일한 환경에서 실행할 수 있어요.
Container:
마지막으로, 컨테이너는 Docker 이미지를 실행하는 격리된 환경이에요. 이 컨테이너 안에서 우리가 만든 앱이 동작하게 됩니다. 각각의 컨테이너는 고유한 파일 시스템을 가지고 있어서 서로 영향을 주지 않고 실행될 수 있어요. 이미지는 클래스(class)와 같이 생각할 수 있고, 각각의 컨테이너는 클래스에서 만들어진 개별 객체(instance)처럼 독립적으로 실행됩니다.

이렇게 Docker를 사용하면 우리는 개발 환경을 일관되게 유지하고, 앱을 손쉽게 배포하고 실행할 수 있어요.

이론은 알았으니, 실제 환경에서 도커를 써보고 싶어.

가장 먼저 해야할 것은 Docker 설치!

Docker를 설치한 로컬 또는 서버에서 Docker가 제대로 작동하는지 확인합니다. 터미널 또는 명령 프롬프트에서 docker version 명령어를 실행하여 Docker 버전 및 설치 상태를 확인할 수 있어요.

다음으로, Docker Hub에 접속하여 원하는 이미지를 찾습니다. 예를 들어, 언어 모델을 사용하기 위해 Hugging Face의 이미지를 사용한다고 가정해봅시다.

Docker Hub에서 해당 이미지를 찾은 후, 터미널 또는 명령 프롬프트에서 docker pull huggingface/transformers-pytorch-gpu 명령어를 실행하여 이미지를 다운로드합니다.

이제, 다운로드한 이미지가 잘 있는지 확인하기 위해 docker images 명령어를 사용합니다.

마지막으로, 위에서 다운로드한 이미지를 사용하여 컨테이너를 만들어 개발환경을 설정합니다. 터미널 또는 명령 프롬프트에서 docker run --name liky --gpus=all -it huggingface/transformers-pytorch-gpu 명령어를 실행합니다. 이렇게 하면 liky라는 이름의 컨테이너가 생성되고, Hugging Face의 Transformers 라이브러리가 설치된 PyTorch를 사용할 수 있는 GPU 지원 컨테이너가 실행됩니다. 만약 LLM을 학습하거나 할 때에는 --shm-size 80gb 처럼 공유 메모리 옵션을 추가해주세요.

이제, 이 컨테이너 안에서 개발을 시작하면 됩니다! 필요한 패키지를 설치하고 코드를 편집하며 새로운 기능을 개발할 수 있습니다. Docker를 사용하면 로컬 환경과 동일한 환경에서 언제든지 개발할 수 있으며, 컨테이너를 중단하고 다시 시작하여 작업을 계속할 수 있어요.

여러분들이 Docker를 사용할 때 필요한 추가적인 명령어들을 모아서 정리해보겠습니다.

도커 실행중인 컨테이너 리스트 확인
docker ps
도커 모든 컨테이너 리스트 확인
docker ps -a
도커 저장소에서 이미지 당겨오기
docker pull huggingface/transformers-pytorch-gpu
도커 컨테이너 실행하기
sudo docker run -v <local_path>:<container_path> --gpus='"device=0,1"' -it huggingface/transformers-pytorch-gpu
도커 컨테이너 일시정지
ctrl+p+q
도커 컨테이너 종료
exit
도커 다시 들어가기
docker attach <컨테이너이름orID>
도커 컨테이너/이미지 삭제
docker rm <컨테이너ID> docker image rm <이미지ID>
도커 외부 포트 열기 → 참고 링크
도커 권한 부여 → 참고 링크
도커 실행중인 컨테이너에 네트워크 연결
docker network connect <네트워크 이름> <컨테이너 이름 또는 ID>
도커 실행중인 컨테이너에 접속 안하고 외부에서 작업할 때
docker exec -it existing-container <명령어>
VScode Docker 연결
sudo usermod -aG docker $USER newgrp docker

이렇게 정리된 명령어들은 Docker를 사용하는 데에 유용하게 활용될 것입니다.

필요할 때 참고하시면 좋을 것 같아요! ✨

이렇게 Docker의 개념과 사용법에 대해 알아보았습니다. Docker는 개발 환경의 일관성을 유지하고, 배포를 단순화하며, 효율적인 리소스 관리를 가능하게 하는 등 다양한 이점을 제공합니다. 처음에는 어려울 수 있지만, 익숙해지면 개발 과정에서 큰 도움이 될 것입니다. 계속해서 Docker를 활용하여 효율적인 개발 환경을 구축해보세요!

Decoding 기법 정리

Liky — Thu, 28 Mar 2024 11:29:11 +0900

- Greedy Search
    - 현재 단어 다음에 나올 단어 후보 중 가장 확률이 높은 것 선택
    - (장점) 비교적 간단한 알고리즘
    - (단점) 동어 반복 현상 발생
    - (단점) 현재 시점 바로 다음 단어만 고려.

ref: huggingface

- Beam Search
    - 현재시점 이후 여러 step의 단어 조합을 keep 해놓고 해당 확률을 곱하여 점수를 내고 다른 조합과 비교하여 가장 높은 것 선택
    - (장점) 뒤에 나올 확률이 높은 단어를 선택하여 좀 더 좋은 문장 생성
    - (단점) 연산속도 증가
    - (단점) 반복문제 여전히 존재 → n-gram(연속된 단어 개수 허용범위) 사용
    - num_beams → Beam Search에 쓰이는 beam의 개수
    - no_repeat_ngram_size → 특정 n-gram이 생성문장 내에서 반복되지 않도록 함
    - num_return_sequences → 아웃풋 몇 개 받을지

ref: huggingface

- Sampling
    - 조건부 확률 분포에 따라 다음 단어를 랜덤으로 선택
    - (장점) 표현력 풍부 및 다양한 단어 사용
    - (단점) 말이안되거나 어색한 문장 나올 수 있음
- do_sample → sampling 쓸지 말지 boolean
- temperature → 무작위성 조정 (0에 가까울 수록 Greedy와 유사)

ref: huggingface

- Top-K Sampling
    - K개의 후보 단어를 먼저 필터링 후 확률분포 계산 후 샘플링 진행
    - (장점) 높은 단어를 선정하기 때문에 어색한 단어 거를 수 있음
    - (단점) 후보에 오를만한 단어여도 top-k안에 못들어서 걸러질 수 있고, 확률이 낮은 단어여도 상위 확률 단어가 몇개 없으면 top-k안에 들어갈 수 있음

ref: huggingface

- Top-P Sampling (Nucleus Sampling)
- Top-K는 상위 K개의 단어를 선정한다면, Top-P는 누적확률을 기준으로 단어를 선정함. 예를들어 p=0.92로 설정하면 누적확률이 92% 넘으면서, 토큰의 수가 가장 적은 문장을 내뱉는 것.

경험적 관점에서 top-p와 top-k를 같이쓰거나, Beam search가 가장 좋은 아웃풋을 냈었음.

Transformer_Encoder (트랜스포머 인코더 쉽고 자세하게 설명하기)

Liky — Fri, 28 Apr 2023 16:59:24 +0900

오늘은 트랜스포머의 인코더 부분을 쉽게 설명하고자함.

많은 사람들이 트랜스포머의 기법에 대해서 물어보면 "Self-attention 기법 사용... 특정 단어에 포커싱.." 혹은 "Q,K,V 사용해서...조합해서 가중치주는 기법..." 정도로만 대답함.

실제 어떤 식으로 돌아가는지 쉽고 자세하게 설명하기 위해 본 포스팅을 진행함.

애매하게 아는 분 환영

트랜스포머의 인코더 레이어는 그림에서 보이다 싶이 크게 3가지로 나눠볼 수 있음.

- 멀티헤드 셀프어텐션

- 포지셔닝 와이즈 피드포워드 뉴럴네트워크

- 에디션 앤 레이어 노말리제이션

한글로 쓰니 형편없어 보이긴 하지만 그냥 넘어가겠음.

일단 입력 문장이 모델에 입력되면 > 포지셔닝 인코딩을 통과 > 벡터화(각 단어의 위치정보가 포함)된 입력 문장이 들어옴.

이 벡터값은 트랜스포머의 인코더로 들어옴.

그러면 그림의 가장 좌측처럼 입력값이 하나는 바로 Add&Norm으로 가고, 하나는 3개로 나눠져서 Multi-head self attention 서브레이어로 들어감. 이 서브레이어를 통과하니 다시 하나의 출력값으로 변하고, 곧바로 Add&Norm으로 갔던 입력값과 멀티헤드셀프어텐션 서브레이어에서 나온 출력값이 더해지고 일반화됨. 이 값을 또 둘로 나눠서 하나는 다이렉트로 가고 하나는 Position-wise FFNN 서브레이어를 갔다가 또 합쳐짐. 이게 트랜스포머의 Encoder 끝임.

이제 하나씩 설명하겠음.

먼저 Attention이 뭔지부터 알아야함.

어텐션(Attention)이란 각 문장에서 각각의 단어가 서로 어떤 연관성을 가지고 있는지에 대한 정보인데, 쉽게말해서 특정 단어에 집중하는 거임. 어라? It이 뭘 뜻하는 거지? 아, The Monkey 혹은 that banana에 집중하고 있구나. 이런 느낌.

이 Attention 기술을 적용하면 전반적인 입력 문장에 대해 모델이 문맥 정보를 학습할 수 있음.

Transformer은 어텐션 기법을 사용하는데, 왜 앞에 Self-attention이라고 하냐면, 하나의 문장 내에서 어텐션을 취하고 있는거라서 앞에 셀프가 붙음. 즉, 각각의 문장간의 집중이 아닌, 하나의 문장 내에서 각 단어가 뭐에 집중하는지를 보는거임.

이런 셀프 어텐션은 다른말로 (Scaled dot product Attention)이라고 말함.

자, 오른쪽 그림과 같이 입력 문장이 벡터화 되고 가장 먼저 가는 서브레이어는 Multi-Head Attention 레이어임.

이를 크게보면 가운데 그림처럼 되고, 여기서 Scaled Dot product attention (=Self-Attention) 레이어를 확대해보면 좌측의 그림처럼 표현할 수 있음.

먼저 용어부터 간단히 설명할게요.

좌측 그림 상하단을 보면 MatMul이라고 있는데, 이건 Matrix Multiplication의 약자로 한국어는 "행렬곱셈"임.

Scale은 스케일링(Scailing)하는건데, 이게 행렬곱셈하면서 벡터값이 점점 커지는데 이게 그 위에 Softmax를 통과할때 문제가 됌. 이게 벡터값이 크면 출력값이 Gradient Vanishing(가중치 소실) 문제가 발생할 수 있기 때문에 저기 Scale 서브레이어에서는 Scale Factor라는 특수 값을 벡터에 곱해서 입력값을 작게만들어줌. 이러면 소프트맥스 함수 출력값이 안정적이게 됌.

이해안되었다면 이따 더 쉽게 설명할테니 일단 패스

자 각각의 서브레이어를 하나씩 자세하게 봐봅시다.

논문에서 모델의 입력차원은 512로 설정하였고, num_head는 8로 정했어요.

이말이 뭐냐, 쉽게 설명하자면 입력된 문장에서 하나의 단어를 하나의 벡터라고 생각했을 때, 각 벡터의 길이가 512라는 얘기입니다. 즉, Student라는 단어는 512개의 길이를 가진 벡터로 치환된다 생각하면 굳.

num_head는 각각의 이 셀프 어텐션을 총 몇개를 병렬로 계산할거냐 라는 값인데, 논문에서는 한번에 8개가 동시에 병렬적으로 계산되도록 설정하였음.

512 차원의 단어벡터를 [모델의 dimension, 모델의 dimension/numhead]값인 [512,512/8] = [512, 64]의 크기를 가지는 가중치 행렬을 만들어서 이를 곱해줘서 Q,K,V를 만듬.

이게 다른 설명같은데서 보면 가중치 행렬을 원래 값에 곱해서 만든다 정도로만 설명하는데 더 쉽게 이해할려면 다음과 같음.

그림 아래에 있는 코드처럼, 512차원의 입력데이터를 넣으면 64차원으로 나오도록 하는 것임.
케라스 텐서플로우에서는 일반적인 Dense층으로 생각하면됌.

각각의 Linear 레이어를 만들어서 64차원의 Query, Key, Value 벡터값을 만드는게 끝임.

그림을 예시로 보면 [1,512] 짜리 벡터 (=Student) 가 각 레이어 통과해서 서로 다른 [1,64] 크기를 가지는 벡터가 3개 만들어지는거임.

방금 전에는 1개의 단어 벡터에 대해서 얘기한거고, 실제 멀티헤드어텐션은 모든 입력에 대해 병렬적으로 동시에 진행함.

똑같은 원리로 하나의 입력 문장에 대해 512차원을 각각 다른 64차원 벡터로 나오게 하면 이 서브레이어의 역할은 끝임.

Q,K,V가 만들어졌으면 이 값들은 Scaled Dot Product Attention, 즉 Self Attention 레이어로 들어감.
이 셀프어텐션 레이어는 왼쪽의 그림처럼 구성되어 있음.
먼저 Q,K값이 MatMul(행렬곱셈)을 진행함.
오른쪽 그림 보면 아까 만든 Q와 K를 행렬곱해서 [64,64] 크기를 같은 어텐션 스코어 매트릭스를 만듬

그림만 보면 [2,4] * [4,2] = [4,4]이라서 헷갈린다고 생각할 수 있는데,

아까 예시였던 4개의 단어 I am a student에서 각각의 단어는 512개의 길이를 가지는 벡터였고, Q,K,V에서 64로 줄였으니 하나의 단어는 지금 길이가 64인 벡터라고 생각하면됌.

그런다음 이 어텐션 스코어 메트릭스를 스케일링을 함.
이유는 아까 말한 것처럼 > 행렬곱셈하면서 벡터값이 커지는데 Softmax를 취할때 백터값이 크면 출력값이 0 or 1값이 많아지기 떄문에 Gradient Vanishing(가중치 소실) or Exploding(폭발) 문제가 발생할 수 있고, Scale Factor를 곱해서 입력값을 작게만들어서 Softmax 함수의 출력 값을 안정적으로 만들어줌.

저 위의 그래프가 Softmax function인데 보다싶이 입력값이 계속 곱해지면서 값이 커지면 1에 근접한 출력값만 나오고 작아지면 0에 근접한 출력값이 나오겠죠?

그래서 Q랑 K랑 행렬곱 한다음에 나눠주는거임.

마스크는 건너 뛰었는데, 옆에 옵션이라고 붙어있는데, padding은 보통 Max len을 정해뒀을떄 입력 문장이 이보다 작을 때 최대 길이를 맞춰주기 위해 아주 작은 음수값을 주는 것임.
굉장히 작은 음수값을 주게되면 소프트 맥스를 지나면 0에 가깝게 되기 때문에 어텐션 학습이 안됌.
현재 예시에서는 패딩이 필요없기에 넘어갑니다.
전단계에서 스케일링 한 값을 소프트 맥스 레이어에 넣어서 총 합이 1인 확률값 매트릭스, 스코어 메트릭스로 만들어줌.

즉, [0.2, 0.1, 0.3, 0.4] 처럼 만드는거임.

그러고나서 Score Metrix를 적용하기 위해 Value 벡터값과 곱해서 Attention Value Metrix을 만듬.

이게 그림 맨위에있는 어텐션 수식을 전부 설명한거임.

스케일 닷 프로덕트 어텐션은 이렇게 끝이 났지만, 그림에 h라고 표시된 Num Head 수만큼 병렬적으로 동시에 진행하기 떄문에 총 8개의 어텐션 벨류 메트릭스가 나옴.

이를 Concat을 함.

Concat을 하면 [4,64]였던 어텐션 벨류 메트릭스가 8개가 붙어 [4,512]의 크기를 가지는 하나의 텐서값을 얻음.

이 값을 리니어 레이어에 그대로 넣어서 Representation을 함.
딥러닝에서 "Representation"란, 입력 데이터의 의미 있는 표현을 학습하는 것을 의미함.
입력 데이터를 신경망에 주입하면, 신경망이 이를 분석하여 각 입력에 대한 적절한 표현을 추출하는 것임

아까랑 똑같이 입출력 크기가 같은 Linear 레이어에 벡터값을 넣는거임. (텐서플로로 설명하자면 입출력크기가 같은 Dense 레이어)이 값을 리니어 레이어에 그대로 넣어서 Representation을 함.
딥러닝에서 "Representation"란, 입력 데이터의 의미 있는 표현을 학습하는 것을 의미함.
입력 데이터를 신경망에 주입하면, 신경망이 이를 분석하여 각 입력에 대한 적절한 표현을 추출하는 것임

아까랑 똑같이 입출력 크기가 같은 Linear 레이어에 벡터값을 넣는거임. (텐서플로로 설명하자면 입출력크기가 같은 Dense 레이어)

멀티헤드 어텐션은 끝났고,

그림을 보면 입력문장 임베딩값과 멀티헤드어텐션에서 나온 출력값이 Addition & Layer Normalization로 감.

일단 입력과 멀티헤드어텐션 출력은 동일한 차원을 갖고 있음.

Addition & Layer Normalization은 말그대로 더하고 레이어 노말리제이션을 통해 일반화 하는 서브 레이어임.
입출력이 같은 차원을 가지니 더할 수 있음.

잔차 연결(residual connection)은 딥러닝 네트워크에서 발생할 수 있는 가중치 손실(gradient vanishing) 문제를 해결하고, 학습 속도를 향상시키는 장점이 있음.
네트워크가 깊어질수록 역전파 하면 그래디언트 값이 작아져 사라질 수 있기 때문에, 서브레이어에 들어가기 전의 값을 추력값과 더해서 완화시킴.

이 서브레이어를 코드로 설명하자면 레지듀얼 커넥션 아웃풋을 레이어 노말리제이션 하고 드랍아웃하는 게 끝임

참고로 왜 Layer Norm을 했냐? Batch Norm은?? 라고 물어본다면,
Batch Norm과 동일하지만 적용되는 Dimension이 다름. 자연어는 이미지와 달리 입력 시퀀스가 매번 다르기에 Padding을 넣어주는데, 이러한 특성때문에 Batch normalization으로 Layer Norm이 적합함. 더 자세하고 깊게 배울려면 검색 ㄱㄱ

레지듀얼 커넥션 아웃풋 값은 똑같이 Addition & Layer Normalization과 Feed Forward로 감.

여긴 코드로 설명하는게 더 쉬워보임.

그 벡터값이 지금 512차원이니, 이를 4배 늘렸다가 다시 4배 줄이는 레이어임.

왜 늘렸다 줄여! 라고 하면,

4배 늘린다 : 데이터를 더 넓은 공간에서 표현해본다.

4배 줄인다: 넓은 공간에서 표현한 데이터 중에 더 중요한 특징들을 선택하고 학습하도록 한다.

즉, Representation 하는거임.

이러면 트랜스포머의 인코더 부분 설명 끝임!

이 포스팅이 도움이 되었으면 좋겠습니다.

다시 연구하러 가겠습니다

[논문리뷰] CNM: An Interpretable Complex-valued Network for Matching

Liky — Tue, 27 Dec 2022 21:34:32 +0900

양자역학을 간단하게 공부하였었습니다. 이를 어느정도 이해한 다음 양자컴퓨팅, 양자AI에 대해서 관련된 여러 논문들을 찾아보고 공부하였는데, 자연어를 양자역학과 융합한 논문이면서 동시에 NAACL에서 Award받은 논문이라 읽게 되었습니다.

Paper Description

제목 : CNM: An Interpretable Complex-valued Network for Matching
저자 : Li et al.
Date : 2021.06
인용수 : 53
Publisher : Association for Computational Linguistics
Venue : NAACL(North American Chapter of the Association for Computational Linguistics)
Award : Best Explainable NLP Paper

Abstract

양자역학의 수학적 틀로 자연어 모델링 해보자!
양자역학에서 잘 설계된 수학적 공식 사용해서 single complex-valued vector space 에서 다양한 언어 단위 통합
이 모델링이 효과있는지 검증 하기 위한 CNM(Complex-valued Network for Matching)구축
본 방안은 QA Task에서 CNN과 RNN 이기는 성능 달성함

Introduction

Cognition(인식,인지)의 새로운 연구 분야는 인간의 인지, 특히 "언어 이해에 양자 유사 현상이 존재함"을 시사함.
문장은 여러 단어(particles 입자와 같은)를 가진 물리적인 시스템으로 취급될 수 있으며, 이러한 단어들은 일반적으로 다의어(중첩)이며 서로 상관관계(얽힘)가 있음.

<논문에서 제시하는 주요 질문 2가지>

1. 양자 물리학의 수학적 틀로 자연어 모델링이 가능할까?

2. 현실 세계의 자연어 처리 시나리오에서 자연어를 complex-valued로 Representation하는 게 benefit 있을까?

1번 질문을 풀기위해서 언어를 모델링하는 새로운 양자 이론적 프레임워크를 구축하였고, 이를통해 자연어의 인지적 측면에서 양자성을 포착하였다고 한다.

본 논문에서 제시하는 새로운 양자 이론적 프레임워크는 균일한 의미론적 힐베르트 공간에서 양자 확률을 채택해 서로 다른 언어 단위를 양자 상태로 모델링 하는 것이다.

두번째 질문을 해결하기 위해 언어 단위를 복소수 벡터로 공식화하였고, 길이를 각 단어간의 weight, 방향을 중첩상태로 연결하였다고 함.

추가적으로 중첩 상태는 진폭 위상 방식으로 표현 가능하다고 하는데, 이는 주파수 개념과 파동 개념을 알아야 할듯 함.

언어적 의미에 해당하는 진폭과, 감정과 같은 더 높은 수준의 의미적 측면을 암시적으로 반영하는 위상으로 표현 가능하다고 함.

그러면서 QA Task에서 복소수 임베딩이 일반적인 단어 임베딩 대비 우수한 성능을 뽑아내는 것을 확인하면서, 자연어는 복소수로부터 이점을 얻는다고 주장함.

결론적으로 이 두 질문에 대해 효과를 검증하기 위해 CNM (Complex-valued Network for Matching)이라는 네트워크를 구축하고 QA Task에서 검증을 진행함.

추가적으로 본 논문에서는 RNN과 CNN 모델들이 현재 QA Task에서 높은 성능을 보인다고 하였는데, 옛날 기준임. 요즘은 트랜스포머 기반의 모델들이 많이 올라옴. 어쨌든 이런 RNN과 CNN 기반의 모델들은 불투명한 구조여서 사람들이 이를 분석하고 해석하기 어려움. 본 논문에서 제시하는 CNM은 양자역학에서 영감받아서 자연어 모델링을 하였고, 해석가능성과 투명성있는 네트워크라고 주장하였음. 사후 해석 가능성은 모델이 실행된 후에 설명 가능한 것이고, 투명성은 모델이 설계단계에서 설명 가능한 것임. 둘다 통합해서 그냥 설명가능한 인공지능(XAI)라고 말하는 듯함. 그래서 이 논문이 Explainable award 받은 듯.

양자역학 기반 자연어 모델링

일단 양자역학을 알기 위해서는 얽힘, 중첩, 관측 이 3가지가 가장 중요함.

몇 주간 이와 관련되서 여러 유튜브 영상과 논문들, 교육 블로그 보면서 어느정도 공부했음.

어찌됐든 힐베르트 공간을 이렇게 평면상으로 본다고 하였을 때, 윗방향과 오른쪽방향은 큐빗이 완벽하게 1일 확률, 0일 확률을 나타내는 Basis State임. 그러면 이 사이에 있는 큐빗은 중첩 상태인 것임.

이제 이를 기반으로 Mixed State를 알아야하는데, 양자 상태를 완전히 알면 Pure State라고 하고, 양자 상태를 완전히 모르면 Mixed State라고 말한다고 함.

여러 양자들을 Ensemble하면 표면적으로는 0이다 1이다 알수 있지만, 내부적으로 양자들이 무슨 상태인지는 알 수 없다고 함.

그래서 이런 Mixed State는 Density matrix라고 밀도 행렬로 표현한다고 함.

밀도 행렬은 대각합이 1인 에르미트 행렬이며 다른말로 복소수 정사각 행렬이라고 함.

위키백과를 보면 이런 밀도행렬은 앙상블을 고려하거나 계의 이전 행적이 불확정해서 계가 어떤 순수한 양자상태에 놓여있는지 확실하게 모를 때 쓰는 통계적인 표현이라고 함.

자 이제 힐베르트 공간에서 시맨틱 힐베르트 공간으로 넘어옵니다. 의미론적 힐베르트 공간은 Sememes의 orthogonal basis 상태에 의해 확장된다고 가정한다 합니다. 이게 무슨말이냐면, 예를 들어서 husband라는 단어가 있을 때, 왼쪽처럼 명사로는 남편, 동사로는 절약하다 라는 뜻이 있습니다. 이 단어는 두개의 sense로 나뉩니다. 하나는 결혼한 남자, 반대편은 조심히 사용한다 즉 절약한다. 이들을 또 나누면 결혼한 남자는 사람이자, 가족, 남자, 배우자이며, 반대편은 절약하다를 뜻하는 economize 임.

즉, Sememe라는 것은 의미의 최소 단위를 뜻하는 것이며, Word는 Sememe의 중첩 상태로 구성되는 것임.

그림을 보면 Words가 있죠. 단어들. 즉 문장을 뜻하는 겁니다. 문장안에 있는 하나하나의 단어들을 힐베르트 공간에 매칭시키면 각각의 단어 백터가 있을 거고, 이들은 아까 말한 확실히 알 수 있는 Pure States에 존재합니다.

이런 단어 백터들을 의미론적으로 하나로 합쳐버리면 이들은 중첩상태가 될 것이고, 이는 곳 Mixed State에 존재합니다.

이런 Mixed State는 밀도행렬 p로 표현이 가능한데 위의 식에서 m은 문장에서의 단어 개수이고, 오른쪽은 중첩상태를 의미합니다.

이런 중첩 상태의 mixed state에서는 high level semantic features를 관측할 수 있다고 하는데, 이를 Semantic Measurements라고 합니다.

완벽하게 이 수식을 이해하진 못했는데 제가 해석하기론, 이런 중첩상태에 있는 값을 관측 할떄마다 어떠한 값으로 수렴될 것이고, 이 수렴된 값은 Pure States에 존재하며 힐베르트 공간안에서 word 하나에 국한되지 않는다는 의미로 해석하였습니다.

그러고 얘네들을 사용해서 확률값을 얻는데 이는 오른쪽에 Gleason의 이론 방정식을 사용해서 구한다고 합니다.

이게 논문에서 제안하는 CNM 네트워크의 전체적인 구조입니다.

처음 봤을땐 진짜 이해안가고 난생 처음보는 설계도 같았습니다. 이게 전자 회로쪽이 합쳐지다 보니 그림을 이렇게 표현하는 것 같습니다.

그래서 이해하기 쉽게 방금 전에 설명했던 그림으로 매칭을 해보자면, 임베딩 같은 경우에는 문장에서의 단어들을 각각의 벡터로 매칭하여 Pure States에 존재하게 임베딩하는 것이고,

Mixture같은 경우는 이 Pure States에 존재하는 단어들을 각각 묶어서 중첩상태로 만들어 Mixed State로 매칭시키고 이를 밀도행렬로 표현하는 것 같습니다.

Measurement는 이 Mixture에서의 Mixed State에 있는 각각의 벡터값들을 관측해서 하이레벨 의미론적 피쳐값들을 뽑아낸 다음, 각각의 밀도행렬들과 Gleason 방정식을 통해 확률을 뽑아내고, 이들을 입출력 차원을 맞춰주고 pooling하고 계산해서 output값이 나오도록 하는 네트워크인 듯 합니다.

수식이 엄청 많은데, 이해하기 쉽게 거의 사용하지 않고 설명하였습니다. 물리학 전공이 아니여서 투영같은 개념이 단기간 내에 학습할 수 있어보이진 않습니다..

어찌됐든 이런 메커니즘을 통해서 QA Task를 풀어보니 CNN과 RNN 기반의 모델들에 비해 아주 살짝 높은 성능을 얻은 것을 확인할 수 있었습니다.

여기서 MAP와 MRR 성능지표는, 우선순위에 대한 정확성을 판단하는 성능지표라고 합니다. 이는 추천시스템에서 많이 쓰는 성능지표라고 하는데 정확도, 정밀도, 재현율은 전반적인 정보검색(Information Retrieval) 성능 평가가 가능하지만 Rank에 대해서는 고려하지 않기에 이를 쓴다고 합니다.

데이터셋을 보자면 이런식으로 되어있습니다. 참고하면 될듯합니다.

근데 이게 결과를 보면 알겠지만 유의미하게 높은 성능은 아닙니다. 여기서는 성능을 올리는 기술이다가 중점이 아니라, 의의를 중요시 합니다. 논의를 보자면 첫번째로 본 논문에서 제안하는 프레임워크는 투명성있다고 합니다. 단일 복소수 벡터 공간에서 많은 의미 단위를 통합하는 것을 목표로 합니다. 훈련 가능한 투영 측정이 단어, 문장에 대한 높은 수준의 표현을 추출한다고 합니다.

위의 표를 보면, 현실세계에서의 Sememe와 word, Abstraction 를 양자역학 세계에 매칭했다는 것이 첫번째 의의입니다.

두번째는 해석가능성입니다. 단어 가중치 체계 면에서 보자면, 가장 중요한 상위 50개 단어, 하위 50개 단어의 가중치를 뽑아보았을 때, 중요한 단어는 특정 주제에 대한 것들, 혹은 고유명사를 중요하다 판단하였고, 중요하지 않은 단어는 의미없는 숫자나 너무 많이 쓰이는 단어들을 선택하였다고 합니다.

해석 가능성의 두번째로는 매칭 패턴인데, 각 단어에 대해 상대적인 가중치를 시각화 했을 때 의미론적 힐베르트 공간에서 단어를 유사한 단어로 대체하는 것이 강력하다고 하며, 경험적인 관점에서 특정 일치 패턴이 문장 의미에 중요한 상황에서 다른 모델들 (RNN, CNN) 을 능가한다고 합니다. [ ]는 N그램 윈도우 경게이며, 색이 진할수록 weight가 큰 것 입니다. Local 면에서 보자면 Qustion과 Answer을 잘 매칭한다고 하는 것 같습니다.

사후 해석 가능성의 세번째는 차별적인 Semantic Measurements 라고 합니다.

TREC QA 데이터셋에서 10개의 Measurements를 뽑고 이 중에서 랜덤으로 5개를 선택해서 예제로 보여주는데,

랜덤으로 선택된 5개의 Measurements에서 가장 유사한 단어의 일부들을 보여준 표라고 합니다.

위쪽은 위치, 이동 동사, 사람이름에 관한 단어들이고

아래쪽은 역사와 rebellion에 관한 내용이였다고 합니다.

이를 보아서, 측정값에 대한 명확한 설명은 안되지만, 측정값에 대해 대략적인 의미를 이해할 수 있다고 합니다.

제가 이해한 것을 쉽게 말하자면, 양자역학의 프레임워크에서 뭔가 있는데 이를 뽑았을 때 그게 뭔지 정확히 설명은 안된다만, 유사한 단어들을 출력해볼 수 있고, 이를 통해 Measurement 값을 추정가능하다고 하는 듯 합니다.

결론으로 가서, 처음에 제시한 두가지 질문에 대해 해답을 얻을 수 있었고, 추가적으로 두가지를 더 보여주었음.

이 논문을 읽어보니 양자AI, 양자컴퓨팅에서 자연어처럼 의미론적으로 중첩 상태가 될 수 있는 개념을 인코딩, 임베딩 하는 아이디어 괜찮아보임. 근데 이게 물리학 개념이 너무 강해서 이런 수식을 이해하고 구현할 수 있는 것이 관건인 듯 함.