[NLP] Word Embedding - GloVe [practice]

🧑🏻‍💻 주요 정리
 
NLP
Word Embedding
GloVe

 

 

 

아래와 같이, GloVe에 대한 코드를 살펴봅니다.

 

GloVe

 

워드 임베딩은 하나의 원-핫 인코딩 벡터(한 요소만 1이고 나머지는 0인 벡터)를 훨씬 작은 실수 값의 벡터로 변환합니다. 원-핫 인코딩 벡터는 희소 벡터이며, 실수 값 벡터는 밀집 벡터입니다.

 

이 워드 임베딩에서 가장 중요한 개념은 비슷한 문맥에 나타나는 단어들은 벡터 공간에서 가까이 위치한다는 것입니다. 여기서 문맥이란 주변 단어를 말합니다. 예를 들어 "I purchased some items at the shop"과 "I purchased some items at the store" 두 문장에서 'shop'과 'store' 단어는 같은 문맥에 나타나기 때문에 벡터 공간에서 서로 가까이 있어야 합니다.

 

여기서 이미 GloVe 벡터로 미리 학습된 벡터를 사용할 것입니다. GloVe는 word2vec과 유사하지만 다른 알고리즘입니다. 이러한 미리 학습된 임베딩은 거대한 말뭉치에서 학습되었으며, 모델 내에서 이를 사용하여 단어의 문맥을 이미 학습한 상태에서 시작점으로 사용할 수 있습니다. 이는 일반적으로 더 빠른 학습 시간과/또는 향상된 정확도를 제공합니다.

 

파이토치에서는 단어 벡터를 nn.Embedding 레이어를 사용하여 사용합니다. 이 레이어는 [문장 길이, 배치 크기] 텐서를 가져와 [문장 길이, 배치 크기, 임베딩 차원] 텐서로 변환합니다. nn.Embedding 레이어는 처음부터 훈련할 수도 있고, 미리 학습된 임베딩 데이터로 초기화하고 (선택적으로 고정시킬 수도 있음) 사용할 수도 있습니다. nn.Embedding의 핵심은 명시적으로 원-핫 벡터 표현을 사용하지 않아도 된다는 것입니다. 단순히 인덱스를 벡터에 매핑하는 것입니다. 이것은 계산적인 측면에서 매우 중요합니다.

 

구체적으로는, nn.Embedding은 원-핫 sparse-벡터를 나타내는 인덱스에 해당하는 가중치 행렬의 열을 선택하여 낮은 차원 (dense) 출력을 생성하는 선형 맵입니다. 이번 파트에서는 모델을 훈련하지 않고, 단어 임베딩을 살펴보고, 그것들로 할 수 있는 몇 가지 흥미로운 것들을 조사해 볼 것입니다.

 

먼저, 미리 학습된 GloVe 벡터를 로드할 것입니다. name 필드는 벡터가 학습된 데이터를 지정하며, 여기서 6B는 60억 개의 단어 코퍼스를 의미합니다. dim 인수는 단어 벡터의 차원을 지정합니다. GloVe 벡터는 50, 100, 200 및 300 차원으로 제공됩니다. 또한 42B 및 840B glove 벡터도 있지만, 이들은 300 차원에서만 사용할 수 있습니다. 이것을 처음 실행할 때, 벡터를 다운로드하는 데 시간이 걸립니다.

 

 

import torchtext.vocab

glove = torchtext.vocab.GloVe(name='6B', dim=100) # 이미 학습된 것을 불러오기만 하는 것임. torchtext의 vocab에 존재.
# hidden size를 몇으로 정할래이다. V -> hidden (100 / 300 / 512 / 256)
print(f'There are {len(glove.itos)} words in the vocabulary')
# itos -> dictionary의 사이즈가 무엇이냐는 것.
# 우리는 지금 아래와 같이 400000개의 words를 사용 가능함.

 

.vector_cache/glove.6B.zip: 862MB [02:39, 5.40MB/s]                           
100%|█████████▉| 399999/400000 [00:19<00:00, 20515.34it/s]
There are 400000 words in the vocabulary

 

즉, 우리는 40000개의 words가 담긴 vocabulary가 생긴 것입니다.

 

 

glove.vectors.shape

 

위 결과로

torch.Size([400000, 100])

이것과 같이 40000 x 100 차원 짜리를 가져옵니다.

 

 

각 행이 어떤 단어와 관련이 있는지는 itos(int to string) 리스트를 확인하여 알 수 있습니다.

 

아래의 예시는 0번 행이 'the'와 관련된 벡터, 1번 행이 ','(쉼표)와 관련된 벡터, 2번 행이 '.'(마침표)와 관련된 벡터 등으로 이해할 수 있습니다.

 

 

glove.itos[:100]

 

이것을 찍으면 아래와 같이 결과가 나옵니다.

 

['the',
 ',',
 '.',
 'of',
 'to',
 'and',
 'in',
 'a',
 '"',
 "'s",
 'for',
 '-',
 'that',
 'on',
 'is',
 'was',
 'said',
 'with',
 'he',
 .
 .
 .
 '']

일부 생략했습니다.

 

위와 같이 나온 것을 보아서,

glove는 사전과도 같다는 것을 알 수 있었습니다. 어떤 단어에 대한 embedding 값을 쭉 가지고 있는 것입니다.

 

 

glove.stoi['the'] # 단어가 몇 번째에 존재하냐. keyerror 는 없는 것.
# 가장 많이 등장하는 단어를 앞에서부터 넣는다.

 

0

 

단어가 어디에 존재하나도 알 수 있습니다.

 

print(glove.stoi['the'])
glove.vectors[glove.stoi['the']]

 

우리의 목적은, 단어의 인텍스에서 벡터를 가져오는 것입니다.

 

이 벡터는 400000 x 100 차원 짜리인데, the 라는 단어를 가져오려면, the 라는 단어의 인덱스를 0으로 부여함.

 

컴퓨터는 단어를 알지는 못 한다. 숫자로 표현했다. 그래서 man - woman 와 같은 연산이 가능한 것이다.

 

 

 

아래 구현된 함수를 살펴보자.

def get_vector(embeddings, word):
  return embeddings.vectors[embeddings.stoi[word]]

 

• Glove라는 embedding에 vectors값을 넣음.
• 특정 embedding에 대한 단어를 뱉어라.

 

import torch

def closest_words(embeddings, vector, n=10):
    distances = [(w, torch.dist(vector, get_vector(embeddings, w)).item()) for w in embeddings.itos]
    return sorted(distances, key = lambda w: w[1])[:n]

 

• 모든 단어와 주어진 단어와의 모든 distance를 구해서 가장 거리가 짧은 애 n개를 리턴해줘.
• 가장 가까운 것을 찾음.
• embedding과 vector가 들어오면 찾음.
• 유클리디안 distance로 distance를 구해서서 계산함.

 

closest_words(glove, get_vector(glove, 'korea'))

 

•  glove와 korea라는 단어와 가장 가까운 단어 10개는 아래와 같다.

[('korea', 0.0),
 ('pyongyang', 3.9039547443389893),
 ('korean', 4.068886756896973),
 ('dprk', 4.2631049156188965),
 ('seoul', 4.340494632720947),
 ('japan', 4.551243305206299),
 ('koreans', 4.615607738494873),
 ('south', 4.65822696685791),
 ('china', 4.8395185470581055),
 ('north', 4.986356735229492)]

 

 

def print_tuples(tuples):
    for w, d in tuples:
        print(f'({d:02.04f}) {w}')

 

위 tuple을 이쁘게 출력하는 것.

 

print_tuples(closest_words(glove, get_vector(glove, 'ai')))

 

우리는 ai라는 단어를 원하지만 ,아래와 같이 다른 단어가 나올 수 있다.

 

glove라는 embedding을 학습한 데이터가 general하고, 대화 형식의 데이터를 학습했기 때문에 이렇게 나옴.

 

(0.0000) ai
(4.5332) hey
(4.5842) ok
(4.6785) fukuhara
(4.8145) fortunately
(4.8299) cause
(4.8935) yeah
(4.9061) hi
(4.9083) luckily
(4.9333) …

 

 

 

def analogy(embeddings, word1, word2, word3, n=5):

    candidate_words = closest_words(embeddings, get_vector(embeddings, word2) - get_vector(embeddings, word1) + get_vector(embeddings, word3), n+3)
    
    candidate_words = [x for x in candidate_words if x[0] not in [word1, word2, word3]][:n]
    
    print(f'{word1} is to {word2} as {word3} is to...')
    
    return candidate_words

 

 

• vector로 표현 했으니 빼기 더하기 이런 것이 되지 않을까 ?
  
  • king + woman - man =====> queen?이 나오지 않을까?
  • 어떤 embedding 값이 나올 텐데, 그것이 400000개 중 같은 게 나올 가능성은 거의 없다.
  • 그 결과로 나온 vector와 40000 단어 중에서 그나마 distance가 작은 것을 고른다.

 

print_tuples(analogy(glove, 'man', 'king', 'woman', n = 10))
print_tuples(analogy(glove, 'seoul', 'korea', 'india', n = 10))

 

 

잘 하긴 하지만 우리가 완벽히 원하는 것을 얻는 데에는 한계가 있다.

 

man is to king as woman is to...
(4.0811) queen
(4.6429) monarch
(4.9055) throne
(4.9216) elizabeth
(4.9811) prince
(4.9857) daughter
(5.0641) mother
(5.0775) cousin
(5.0787) princess
(5.1283) widow
seoul is to korea as india is to...
(5.8343) pakistan
(6.2924) lanka
(6.5571) australia
(6.5643) bangladesh
(6.5883) africa
(6.6894) sri
(6.7463) indonesia
(6.7763) indian
(6.9396) japan
(6.9865) zealand

 

따로 학습하지 않고 LSTM이나 다른 것에 껴서 학습을 진행합니다.