📜

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

Created

2022/02/02

Editor

To begin

오늘의 포스트를 작성하기에 앞서, 이전 포스트를 요약하며 시작하겠습니다.

자세한 내용은 이전 포스트Efficient Estimation Of Word Representations In Vector Space (Word2Vec) (1) 를 참고해주세요!

본 논문에서는 단어를 벡터화할 때 분산 표현(distributed representation)을 통해 단어 간 의미적 유사도를 표현할 수 있을 뿐만 아니라, multiple degrees of similarity를 가질 수 있도록 하였습니다. vector(“서울”) - vector(“수도”) + vector(“일본”) 의 결과로 얻은 벡터와 가장 가까운 단어 벡터가 “도쿄”를 가리키는 방식으로, 단어 벡터의 연산이 단어 의미의 연산으로 가능하도록 새로운 모델 아키텍쳐를 구성하여 syntactic, semantic 영역에서 높은 정확도를 가질 수 있도록 하였습니다.

word2vec 기법을 적용하는데에 있어서 처리 성능 및 학습 속도의 개선을 위해 CBOW(Continuous Bag-of-words)와 Skip-gram 2가지의 architecture를 제시하였습니다.

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 모델 구현

아래 글과 코드는 Python 언어와 PyTorch를 사용하여 CBOW(Continuous Bag-Of-Word) 모델을 구현하는 과정입니다. 찾고자 하는 단어 위치의 주변의 단어들을 보고 어떤 단어가 가장 적합할 지를 예측하는 것, 즉 여러 개의 Input Layer를 받아들여 Hidden Layer를 거쳐 하나의 Output Layer를 출력하는 것이 CBOW 모델의 구조입니다. 주변 단어들이 주어졌을 때 중심 단어가 등장할 조건부 확률을 최대화하는 방향으로 학습을 진행하며 각 레이어 사이의 가중치를 조정합니다.

CBOW 코드 구현

학습을 위한 Corpus 전처리

CBOW 모델 구현을 위해 torch 라이브러리를 활용하였습니다.

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

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)
Python
복사

•

__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()
Python
복사

CORPUS_SIZE는 학습시키고자 하는 말뭉치의 크기를 결정합니다. 시간과 컴퓨터의 성능 등을 고려하여 모델 학습 및 테스트를 진행할 수 있도록 삽입하였습니다.

ted 강연의 데이터에서 토큰화 처리한 데이터인 result를 가공하여, 학습을 위한 데이터를 만들어줍니다. 중심 단어(data_target)를 기준으로 왼쪽 4단어, 오른쪽 4단어를 data_context에 삽입하고, 두 값들을 튜플로써 data 리스트에 추가합니다.

[예시]
주어진 단어 나열 : 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 된다.
Plain Text
복사

이렇게 생성된 data 리스트의 원소는 각각 8개의 input word + 목표 word 1개로 구성된 튜플이며, 학습과정에서 8개의 단어와 목표 단어 간의 관계(가중치)를 찾는데에 사용됩니다.

unique_vocab은 corpus에 등장한 단어를 중복되지 않게 모아둔 단어의 list 입니다. word_to_idx는 unique_vocab의 단어를 key로 사용하고, index 번호를 value로 사용하는 dictionary 입니다. data 리스트의 단어를 dictionary에서 찾아 index 번호를 받고, 이를 이용해

train_cbow - 학습 과정

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
Python
복사

우선, CBOW 모델과 손실함수, 최적화방식은 아래와 같습니다.

•

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

이미지 출처 : https://wiznxt.tistory.com/783

•

Optimizer - Stochastic Gradient Descent
최적화를 위해 계산하는 데이터 단위인 batch의 크기를 1로 계산하는 경사하강법으로, 연산할 데이터셋의 규모가 큰 경우에 비교적 빠르게 최적 값을 찾기위해 사용하는 최적화 방식입니다. 

Gradient Descent 등의 다른 optimizer 보다 노이즈가 크게 발생하지만, 계산량을 줄여 빠르게 최적화된 기울기를 찾을 수 있다는 장점이 있습니다.

이미지 출처 : http://pages.cs.wisc.edu/~spehlmann/cs760/_site//assets/SGDvGD.svg

아래 나열된 일련의 순서로 CBOW 모델이 학습을 실시합니다.

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()
Python
복사

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

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

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

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

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

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

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

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

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

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

학습 결과

학습이 완료되면, 아래 예시와 같이 corpus에 속한 단어들은 가중치를 갖게되고, 이것이 특정한 단어의 의미를 나타내게 됩니다.

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]
Plain Text
복사

단어 간 유사도 연산

학습 결과 테스트를 위해 두 가지 기능을 정의하였습니다.

(1) get_similarity : 입력한 두 단어간의 유사도 출력

(2) get_most_similar_word : 현재 corpus에서 입력한 단어와 가장 유사한 단어 출력

해당 기능 구현 소스코드

두 단어 벡터간의 유사도를 계산하여 출력하고, 단어와 가장 유사한 단어를 출력하는 기능이 제대로 작동함을 확인할 수 있습니다.

Corpus의 사이즈를 더 크게 키워 학습하였을 때, 단어간의 의미 관계가 더욱 적절해집니다. 위 모델보다 10배 더 많은 단어를 이용해 모델을 학습한 경우, 유사하다고 판단된 단어가 더욱 유의미하다고 판단됩니다.

더 좋은 성능의 학습머신과, 더 많은 데이터를 이용해 모델을 학습시킨다면 더욱 유의미한 단어간의 관계를 뽑아낼 수 있을 것이라 생각됩니다.

Skip-gram 모델 구현

Skip-gram 알고리즘을 구현하는 과정입니다. kaggle의 text8.txt 데이터의 일부(1000개의 단어)로 학습했습니다. 중심단어를 입력했을 때, 그 주변단어가 도출될 확률을 높이도록 학습해야합니다.

Skip-gram은 하나의 input layers가 있고 hidden layer를 거쳐 주변단어 개수만큼 output layer로 출력하는 구조입니다. 단어출현 패턴을 학습해 단어의 분산표현을 도출합니다. 다중 클래스 분류이기 때문에 소프트맥스와 교차 엔트로피 오차만 사용하면 됩니다. 소프트맥스 함수를 이용해 점수를 확률로 변환하고, 그 확률과 정답 레이블로부터 교차 엔트로피 오차로 구한 손실을 사용해 학습합니다.

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
Python
복사

•

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
Python
복사

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
Python
복사

학습

## 학습데이터 준비과정
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)
Python
복사

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

trainer_2.fit(contexts, target, max_epoch, batch_size)
Python
복사

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

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

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

여기서 매개변수 갱신 방법은 SGD, AdaGrad 등 중 Adam을 사용했습니다.

가로축은 학습 횟수, 세로축은 손실인 그래프입니다. 학습경과를 그래프로 나타내면 학습을 할 수록 손실이 감소하고 있는 것을 볼 수 있습니다.

학습 결과

단어의 분산 표현

각 단어의 분산 표현은 다음과 같습니다. Skip-gram을 사용하여 이렇게 단어를 벡터화시켜, 분산표현으로 단어의 의미를 나타낼 수 있습니다.

# (중략) 
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 ]
Python
복사

Results

word vector의 quality를 측정하기 위하여, 5개 type의 의미적인 질의와 9개 type의 문법적인 질의로 구성된 comprehensive test를 정의하였습니다. 총 8869개의 의미적인 질의와 10675개의 문법적인 질의로 이루어져있습니다.

각 카테고리의 질의는 두 단계로 이루어져 있는데,

1. 유사 단어쌍을 수동으로 만듭니다. 2. 두 단어쌍을 연결하여 질의 list를 만들 수 있습니다.

예를 들어 68개의 미국 대도시와 그 도시에 속한 주를 연결합니다. 그 다음 랜덤으로 2개의 단어쌍을 선택하여 약 2.5K개의 질의를 생성할 수 있습니다.

해당 논문에서 제시된 테스트 셋에서는 New York 과 같은 multi-word는 사용하지 않았고, 단일 언어 set으로만 구성하였습니다.

본 논문에서는 모든 타입의 질의를 이용하여 정확도를 측정하였고, 질의는 벡터의 대수적 연산의 결과로 나온 closest word가 correct word와 정확하게 일치할 때만 정답이라고 평가하였습니다. 동의어도 오답으로 측정되었기 때문에, 정확도가 100%에 도달하는 것은 거의 불가능하다고 볼 수 있습니다.

Maximization of Accuracy

약 60억개의 토큰으로 구성된 Google News Corpus를 training에 사용하였고, vocabulary size(단어의 수)는 10만개로 제한하였습니다. 최적화 문제에 대해 시간적 제약에 직면하게 되는데, 이는 더 많은 데이터와 더 고차원의 워드벡터를 사용하면 정확도의 향상을 기대할 수 있다는 것입니다. 가능한 가장 좋은 모델을 빠르게 선택하기 위해서 가장 많이 쓰이는 3만개의 데이터로 subset을 구성하여 훈련을 진행하였습니다.

먼저 CBOW 구조에 대하여 서로 다른 차원과 훈련 dataset의 word 개수에 따른 결과를 보여주는데, 차원과 training data의 양을 함께 증가시켜야 정확도가 향상된다고 할 수 있습니다.

실제 실험에서는 3 epoch 과 0.025의 learning rate를 hyper-parameter로 하여 stochastic gradient descent와 역전파를 이용하여 훈련하였습니다.

Comparison of Model Architectures

먼저, 서로 다른 모델 구조를 비교하기 위해 동일한 training data에 대하여 word vector 차원을 640으로 동일하게 맞춰 실험하였습니다. 추후의 실험에서는 3만개의 단어 제한을 두지 않고 모든 semantic-syntatic word relationship test를 사용하였습니다.

RNN의 word vector는 syntatic 질의에서 더 좋은 성능을 보이는 것을 확인할 수 있습니다.

NNLM의 word vector는 RNN보다 훨씬 더 좋은 성능을 보이고 있는데, RNNLM의 word vector는 바로 비선형의 hidden layer로 연결되기 때문입니다.

CBOW의 경우 syntatic 질의에서는 NNLM보다 좋은 성능을 내고 있고, semantic 질의에서는 비슷한 모습을 보입니다.

Skip-gram는 syntatic 질의에서는 CBOW보다 다소 좋지 않은 성능을 보였지만, semantic 질의에서는 어떠한 모델보다 훨씬 더 좋은 성능을 보였습니다.

다음으로는 오직 하나의 CPU를 사용하여 모델을 학습하였고 공적으로 사용가능한 word vector과 비교하여 평가하였습니다.

CBOW 모델은 Google News Data의 subset으로 약 하루동안 training하였고, Skip-gram 모델은 약 3일동안 training 하였습니다.

추후의 실험에서는 1 epoch만을 사용하였고, learning rate를 줄여가면서 훈련이 끝날 시에는 learning rate가 0이 되게 하였습니다.

1 epoch에 대하여 2배 더 많은 데이터를 사용하는 것은 3 epoch에 대하여 동일한 데이터를 사용하는 것과 동일하거나 더 나은 성능을 보였습니다.

Large Scale Parallel Training of Models

본 논문의 실험에서는 분산 연산 프레임워크인 DistBelief를 적용하였습니다.

Google News 60억개의 데이터셋에 대하여 mini-batch 비동기화 gradient descent 와 Ada-grad를 이용하여 훈련하였는데, 50~100개의 복제본을 이용하여 CPU 개수에 따라 training 결과를 정리한 것입니다. (1000차원의 벡터를 NNLM으로 훈련시키는 것은 마무리하기에 너무 긴 시간이 소요되었습니다.)

•

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

•

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

Microsoft Research Sentence Completion Challenge

: Langauge Modeling과 다른 NLP 기술에 대하여 최근에 소개된 task

1040개의 문장으로 되어 있으며, 각 문장에는 한 단어가 비어있는데 5개의 선택지 중 가장 일관성있는 단어를 선택하는 것이 목표입니다. N-gram, LSA-based model, log-bilinear, combination of recurrent neural network의 결과는 55.4%의 정확도로 이미 보고되어 있습니다.

본 논문에서는 Skip-gram 구조의 성능을 탐구하기 위하여 5000만개의 단어로 640차원의 모델을 훈련시키고 test set의 각 문장에 대하여 성능을 확인한 후 각 prediction을 합산하여 최종 점수를 측정하였습니다.

Skip-gram 단일 모델은 LSA 기반보다 좋은 성능을 보이지 못했지만, 이전까지 가장 좋은 성능을 보였던 RNNLMs와 weight를 결합하였을 때는 58.9%의 정확도를 보였습니다.

Examples of the Learned Relationships

하단의 표는 다양한 relationship을 보여줍니다. relationship을 두 word vector의 뺄셈으로 정의하였고, result는 다른 단어가 더해진 결과가 나와있습니다.

e.g. Paris - France + Italy = Rome

아직 성능의 개선 필요성은 보이지만 현재의 성능도 나쁘지 않고, 더 많은 데이터셋에 대하여 더 고차원의 벡터로 train 된다면 훨씬 더 좋은 성능을 보일 것이라 예상하고 있고, 새로운 혁신적인 응용 또한 가능할 것으로 보입니다.

Conclusion

•

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

•

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

•

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

Word2Vec이 갖는 의의

•

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

•

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

•

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

reference

Word2Vec ⌜Efficient Estimation Of Word Representations In Vector Space⌟

밑바닥부터 시작하는 딥러닝2 (사이토 고키)

https://github.com/WegraLee/deep-learning-from-scratch-2/tree/master/ch03

https://www.kaggle.com/ashukr/implementation-of-word2vec-paper/data

https://wikidocs.net/50739

https://reniew.github.io/21/

https://github.com/smafjal/continuous-bag-of-words-pytorch

https://www.youtube.com/watch?v=i5U2inxzXx4

https://stackabuse.com/implementing-word2vec-with-gensim-library-in-python/

https://brunch.co.kr/@goodvc78/16

이전 글 읽기

다음 글 읽기

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

GloVe: Global Vectors for Word Representation