Efficient Estimation Of Word Representations In Vector Space (Word2Vec) (2)

cleanUrl: "/paper/word2vec-code"

To begin

CBOW(Continuous Bag-of-words) : 주변(맥락)의 단어들로 중간(중심)의 단어를 예측

 

• input : 예측에 이용할 2n개의 주변단어 1-of-V 벡터

• output label : 예측하고자 하는 중간단어의 1-of-V 벡터

• training complexity Q = N x D + D x log(V)
N : 이전 단어의 개수
D : vector의 차원
V : Vocabulary 내 전체 단어 수

Skip-gram : 중간의 단어로 주변의 단어들을 예측

• input : 예측에 이용할 중간단어의 1-of-V 벡터

• output label : 예측하고자 하는 2n개의 주변단어 1-of-V 벡터

• training complexity Q = C x (D + D x log(V))
C : 단어의 최대 거리
D : vector의 차원
V : Vocabulary 내 전체 단어 수

CBOW 모델 구현

CBOW 코드 구현

import nltk
nltk.download('punkt')

import re
import urllib.request
import zipfile
from lxml import etree
from nltk.tokenize import word_tokenize, sent_tokenize

urllib.request.urlretrieve("https://raw.githubusercontent.com/ukairia777/tensorflow-nlp-tutorial/main/09.%20Word%20Embedding/dataset/ted_en-20160408.xml", filename="ted_en-20160408.xml")

targetXML = open('ted_en-20160408.xml', 'r', encoding='UTF8')
target_text = etree.parse(targetXML)

parse_text = '\n'.join(target_text.xpath('//content/text()'))
context_text = re.sub(r'\([^)]*\)', '', parse_text)

sent_text = sent_tokenize(context_text)

result = list()
normalized_text = []
for string in sent_text:
     tokens = re.sub(r"[^a-z0-9]+", " ", string.lower())
     normalized_text.append(tokens)

for sentence in normalized_text:
    tokenized_text = word_tokenize(sentence)

    for tokenized_word in tokenized_text:
        result.append(tokenized_word)

# result에 tokenized words가 담겨있음

import torch
from torch import nn
from torch.autograd import Variable
from torch.optim import SGD
import torch.nn.functional as F

CBOW Class

CONTEXT_SIZE = 4      # 중심 단어 양 옆으로 4개씩, 총 8개의 단어를 input으로 받는다
EMBEDDING_DIM = 300   # 단어 벡터를 300 dimension의 vector로 구성한다
EPOCH = 20            # 단어 set에 대한 반복 학습 횟수

class CBOW(nn.Module):
    def __init__(self, vocab_size, embedding_size, context_size):
        super(CBOW, self).__init__()
				#가중치 초기화
        self.vocab_size = vocab_size
        self.embedding_size = embedding_size
        self.context_size = context_size
        self.embeddings = nn.Embedding(self.vocab_size, self.embedding_size)

        # 계층 생성
				# input layer  -> proj layer(lin1)
        self.lin1 = nn.Linear(self.context_size * 2 * self.embedding_size, 512)
				# proj layer -> output layer(lin2)
        self.lin2 = nn.Linear(512, self.vocab_size)
    
    def forward(self, inp):
        out = self.embeddings(inp).view(1, -1)
        out = self.lin1(out)
				# proj layer의 활성화 함수로 reLU를 사용
        out = F.relu(out)
        out = self.lin2(out)
				# output layer의 활성화 함수로 log_softmax를 사용
        out = F.log_softmax(out, dim=1)
        return out
    
    def get_word_vector(self, word_idx):
        word = Variable(torch.LongTensor([word_idx]))
        return self.embeddings(word).view(1, -1)

• __init__ : CBOW 선언 및 초기화
• vocab_size : 어휘 수
• embedding_size : 단어 벡터의 차원 수
• context_size : input layer로 받아들일 단어의 개수 (현재 작성한 코드에서는 중심 단어 기준 양 옆으로 2 x context_size 개의 단어를 사용합니다)

• forward : 학습 방법 정의
• inp : 주변 단어 리스트 (중심 단어 주변 단어의 word vector list를 가져옵니다)

• get_word_vector : 단어의 벡터 반환
• word_idx : 찾고자 하는 단어의 인덱스
 

학습

CORPUS_SIZE = 10000     # Corpus size 조정으로 학습 데이터 사이즈 결정

def main():
    corpus_text = result[0:CORPUS_SIZE]

		# Corpus Data 가공
    data = list()
    for i in range(CONTEXT_SIZE, CORPUS_SIZE - CONTEXT_SIZE):
        data_context = list()
        for j in range(CONTEXT_SIZE):
            data_context.append(corpus_text[i - CONTEXT_SIZE + j])
        
        for j in range(1, CONTEXT_SIZE + 1):
            data_context.append(corpus_text[i + j])

        data_target = corpus_text[i]
        data.append((data_context, data_target))
    
    global unique_vocab 
    unique_vocab = list(set(corpus_text))
    
    # mapping to index
    global word_to_idx 
    word_to_idx = {w: i for i, w in enumerate(unique_vocab)}


    # CBOW 모델 학습 (정의는 아래에)
    global cbow 
    cbow = train_cbow(data, unique_vocab, word_to_idx)

if __name__ == "__main__":
    main()

[예시]
주어진 단어 나열 : here are two reasons "companies" fail they only do
중심 단어 : companies
주변 단어 : here are two reasons fail they only do

-> (['here','are','two','reasons','fail','they','only','do'],'companies')
   ([주변 8개 단어] + 중심 단어) 한 묶음으로 data에 append 된다.

train_cbow - 학습 과정

def train_cbow(data, unique_vocab, word_to_idx):
		# CBOW 모델 선언
    cbow = CBOW(len(unique_vocab), EMBEDDING_DIM, CONTEXT_SIZE)
    
		# Loss function, Optimizer
    nll_loss = nn.NLLLoss()
    optimizer = SGD(cbow.parameters(), lr=0.01)

		# EPOCH : 현재 데이터셋에 대한 학습 횟수
    for epoch in range(EPOCH):
        for context, target in data:            
		        inp_var = Variable(torch.LongTensor([word_to_idx[word] for word in context]))
            target_var = Variable(torch.LongTensor([word_to_idx[target]]))
                            
            cbow.zero_grad()
            log_prob = cbow(inp_var)
            loss = nll_loss(log_prob, target_var)
            loss.backward()
            optimizer.step()
        
    return cbow

• loss function - Negative Log Likelihood Loss. NLL Loss에서는 모델이 예측한 확률 값을 직접 반영하여 손실을 평가합니다. 확률 값을 음의 로그 함수로 변환시켜 이용하면, 정답에 가까울 확률이 낮을수록 더 많은 패널티를 부여할 수 있습니다. 이를 통해 모델에 대한 더 정교한 평가가 가능합니다. (열심히 공부하여 정답을 맞출 확률이 99%인 학생과 찍어서 맞출 확률이 20%인 학생이 있다고 하면, 둘 다 동일한 정답을 내리더라도, 맞출 확률을 기준으로 평가를 진행하여 학생 간의 정교한 평가가 가능합니다. )

• Optimizer - Stochastic Gradient Descent 최적화를 위해 계산하는 데이터 단위인 batch의 크기를 1로 계산하는 경사하강법으로, 연산할 데이터셋의 규모가 큰 경우에 비교적 빠르게 최적 값을 찾기위해 사용하는 최적화 방식입니다. Gradient Descent 등의 다른 optimizer 보다 노이즈가 크게 발생하지만, 계산량을 줄여 빠르게 최적화된 기울기를 찾을 수 있다는 장점이 있습니다.

inp_var = Variable(torch.LongTensor([word_to_idx[word] for word in context]))
target_var = Variable(torch.LongTensor([word_to_idx[target]]))

cbow.zero_grad()
log_prob = cbow(inp_var)
loss = nll_loss(log_prob, target_var)
loss.backward()
optimizer.step()

1. data 리스트에서 튜플(8개의 주변 단어와 1개의 목표 단어로 구성)을 가져와 inp_var, target_var을 초기화

2. 현재 모델의 변화도를 0으로 초기화

3. 모델의 input layer로 8개의 주변 단어를 전달

4. 모델이 목표 단어를 맞출 확률을 계산하고, 손실함수가 평가를 내림

5. 역전파를 수행 (Autograd가 attribution에 변화도를 계산하고 저장함)

6. 저장된 변화도에 따라 Optimizer가 매개변수를 조정함

7. data 리스트의 모든 튜플에 대해 1~6을 반복

8. EPOCH 의 크기만큼 1~7을 반복

주어진 EPOCH 만큼 학습을 반복하는 동안, 각 EPOCH 단계에 대한 손실함수의 평균값을 계산해본 결과, 학습을 통해 단어벡터들이 적절한 위치에 배치되면서, 학습이 진행될수록 평균 손실이 줄어드는 것을 확인할 수 있습니다.

오른쪽 사진은 CBOW 모델의 학습 횟수와 평균 손실률을 출력한 것입니다.

학습 결과

dimension을 300으로 주었으므로, 각각의 단어 벡터는 300개의 가중치에 의해 그 의미가 결정됩니다.

between [-0.4627,  0.5517,  0.9427, -1.2970,  0.4817, -0.5149, -2.0008, -1.6774,
         -0.1271, -0.1935, -0.7941,  0.6387,  0.7139,  1.1319,  1.1475,  0.9229,
	     				                 ... 중략 (300개의 가중치) ...
          0.1773, -0.2089,  1.7897, -1.3952,  0.8338, -0.9995,  0.5707,  0.3273,
          1.4372,  0.7663,  0.2333,  0.1943]

단어 간 유사도 연산

def similarity_between_words(word_1_vec, word_2_vec):
		# 두 벡터간의 유사도를 계산하기 위해, 코사인을 이용함
		# 두 벡터의 사이각의 작을수록 (유사할수록) cosine 값이 1에 가까워짐을 이용
    result = (torch.dot(word_1_vec, word_2_vec) / (torch.norm(word_1_vec) * torch.norm(word_2_vec)))

		# 양수 값 반환을 위해 값 보정
    if(result < 0): 
        result *= -1
    return result

def get_similarity(cbow, word1, word2, unique_vocab, word_to_idx):
    if not((word1 in unique_vocab) and (word2 in unique_vocab)):
        print("word is not in the vocabulary")
        return

    # (1) 두 단어 word1, word2 사이의 유사도를 확인
    word_1 = unique_vocab[unique_vocab.index(word1)]
    word_2 = unique_vocab[unique_vocab.index(word2)]
    
    word_1_vec = cbow.get_word_vector(word_to_idx[word_1])
    word_2_vec = cbow.get_word_vector(word_to_idx[word_2])
    
    word_1_vec = torch.flatten(word_1_vec)
    word_2_vec = torch.flatten(word_2_vec)
    
    word_similarity = similarity_between_words(word_1_vec, word_2_vec)
    if(word_similarity < 0):
        word_similarity *= -1

    print("Similarity between '{}' & '{}' : {:0.4f}".format(word_1, word_2, word_similarity))

def get_most_similar_word(cbow, word, unique_vocab, word_to_idx):
    word_1 = unique_vocab[unique_vocab.index(word)]
    word_1_vec = cbow.get_word_vector(word_to_idx[word_1])
    word_1_vec = torch.flatten(word_1_vec)

    most_similar_word = 0
    most_similarity = 0.0
    print(len(unique_vocab))

    for i in range(0, len(unique_vocab)):
        if(i == unique_vocab.index(word1)):
            continue
        
        word_3_vec = torch.flatten(cbow.get_word_vector(word_to_idx[unique_vocab[i]]))
        word_similarity = similarity_between_words(word_1_vec, word_3_vec)
        # print(unique_vocab[i], '{:.4f}'.format(word_similarity))

        if(most_similarity < word_similarity):
            most_similar_word = i
            most_similarity = word_similarity

    print("most similar word between '{}' is '{}' with {:.4f} of similarity".format(word_1, unique_vocab[most_similar_word], most_similarity))

Skip-gram 모델 구현

Skip-gram Class

class SimpleSkipGram:
    def __init__(self, vocab_size, hidden_size):
        V, H = vocab_size, hidden_size

        # 가중치 초기화
        W_in = 0.01 * np.random.randn(V, H).astype('f')
        W_out = 0.01 * np.random.randn(H, V).astype('f')

        # 계층 생성
        self.in_layer = MatMul(W_in) # 입력층
        self.out_layer = MatMul(W_out) # 출력층
        self.loss_layer1 = SoftmaxWithLoss() # Softmax 계층
        self.loss_layer2 = SoftmaxWithLoss() # Softmax 계층

        # 모든 가중치와 기울기를 리스트에 모은다.
        layers = [self.in_layer, self.out_layer]
        self.params, self.grads = [], []
        for layer in layers:
            self.params += layer.params
            self.grads += layer.grads

        # 인스턴스 변수에 단어의 분산 표현을 저장한다.
        self.word_vecs = W_in

• SimpleSkipGram 클래스의 인수
• vocab_size : 어휘 수
• hidden_size : hidden layer의 뉴런 수

• W_in , W_out 두개의 가중치
• 각각 작은 무작위 값으로 초기화 됩니다.

• 계층 생성
• 입력층의 Matmul 계층 1개, 출력층의 Matmul 계층 1개
• Softmax with Loss 계층 주변단어 수(=윈도우 크기) 만큼 (여기서는 2개) 계층을 생성합니다. ( Softmax와 Cross entropy error를 Softmax with loss로 합침 )

• word_vec에 분산표현 저장

forward

def forward(self, contexts, target):
        h = self.in_layer.forward(target)
        s = self.out_layer.forward(h)
        l1 = self.loss_layer1.forward(s, contexts[:, 0])
        l2 = self.loss_layer2.forward(s, contexts[:, 1])
        loss = l1 + l2
        return loss

backward

def backward(self, dout=1):
        dl1 = self.loss_layer1.backward(dout)
        dl2 = self.loss_layer2.backward(dout)
        ds = dl1 + dl2
        dh = self.out_layer.backward(ds)
        self.in_layer.backward(dh)
        return None

학습

## 학습데이터 준비과정
window_size = 1
hidden_size = 5 # 은닉층의 뉴런수
batch_size = 3
max_epoch = 1000

text = x # 데이터
corpus, word_to_id, id_to_word = preprocess(text) # corpus를 단어 id로 반환

vocab_size = len(word_to_id) # 어휘 수
contexts, target = create_contexts_target(corpus, window_size) # 중심, 주변단어 반환

# one-hot encoding
target = convert_one_hot(target, vocab_size) 
contexts = convert_one_hot(contexts, vocab_size)

## 모델학습
model_2 = SimpleSkipGram(vocab_size, hidden_size)
optimizer = Adam()
trainer_2 = Trainer(model_2, optimizer)

trainer_2.fit(contexts, target, max_epoch, batch_size)

1. preprocess() : corpus를 단어 id로 반환

2. create_contexts_target() : 중심 단어, 주변 단어를 만들기 target은 중심단어 리스트, contexts는 target을 기준으로 window size 만큼 양 옆 주변단어 리스트

3. 각각을 one-hot encoding을 해 학습데이터를 준비

학습 결과

단어의 분산 표현

# (중략) 
ghosts [ -1.554753  -14.199934    5.4088864  -8.995648   -4.0544376]
mind [ 10.231861  -12.334701    2.9066288   2.9563556   5.0717473]
saying [  0.6028301  -16.115307     0.48380145  -6.917041     2.6495762 ]
reality [ 14.173826   -0.3625413 -10.682704    4.753849    8.219211 ]
advocated [13.001251   3.5767713 -6.613554   9.323543   7.023613 ]

Results

Maximization of Accuracy

Comparison of Model Architectures

Large Scale Parallel Training of Models

• Ada-grad : 지금까지 많이 변화한 값은 적게 변화하도록, 적게 변화한 값은 많이 변화하도록 learning rate를 조절

• DistBelief : 같은 모델에 대하여 복제본을 만들어 병렬적으로 실행되는데, 각각의 복제본은 중앙의 server를 통하여 기울기 update 동기화

Microsoft Research Sentence Completion Challenge

Examples of the Learned Relationships

Conclusion

• 카운트 기반의 representation(LSA, HAL 등)과 다르게 단어의 의미를 보존하고, 벡터의 연산 또한 가능함을 확인할 수 있었습니다.

• 당시의 다른 모델들에 비해 낮은 계산복잡도 덕분에, 훨씬 더 큰 데이터셋으로부터 매우 정확한 고차원 word vector를 계산할 수 있습니다.

• Word2vec은 NNLM(Neural Network Language Model)을 계승하면서도 직관적이며 간단한 모델로 우수한 성과를 내 다양한 NLP task에 대중적으로 활용되는 방법론입니다.

• 자연어가 가지고 있는 동일한 의미에 대한 다양한 표현 방법(자연어의 Flexibility)을 기계가 이해하고 활용할 수 있게 해줍니다.

• 계속 새로운 단어가 생겨나고 기존 단어가 없어지면서 발전하는 자연어와 다르게, 컴퓨터 언어는 고정된 문법을 따라야 하는 정적인 언어입니다. 그러나, Word2Vec 기법을 통해 변화하는 단어의 의미와 새로 등장하는 표현에 대해서도 컴퓨터가 학습하고 이해(evolution)하는 것이 가능하게 되었습니다.

• 단어를 벡터화하는 것에 그치지 않고, Item2vec(추천시스템), live2vec(아프리카TV Live 방송), song2vec(Sportify 플레이리스트), lda2vec(LDA와 word2vec의 결합), 질병과 유전자 간의 연관성 연구 등 다양한 분야에서 본 논문에서 제시한 벡터화 기법을 활용하고 있습니다.

reference