이 글은 하단의 Reference에 있는 강의, 교재를 보고 정리한 것입니다.

9.0 Intro

앞 장에 이어 이번 장의 주제도 단어의 분산 표현이다. 저번 장에서는 '통계 기반 기법'을 통해 단어의 분산 표현을 얻었으나, 이번 장에서는 '추론 기반 기법'을 이용해 단어의 분산 표현을 얻는 법에 대해 살펴본다. 최종적인 이번 장의 목표는 간단한 word2vec 구현하기다.

9.1 추론 기반 기법과 신경망

단어를 벡터로 표현하는 가장 대표적인 두 방법으로는 통계 기반 기법과 추론 기반 기법이 있다. 이 절에서는 통계 기반 기법의 문제점을 알아보고 추론 기반 기법의 이점을 설명한다.

9.1.1 통계 기반 기법의 문제

이전 장에서 다룬 통계 기반 기법에서는 주변 단어의 빈도를 기초로 단어를 표현했다. 그러나 이 방식은 말뭉치가 커지면 문제가 생기는데, 큰 말뭉치에는 어휘가 매우 많기 때문이다. 예를 들어 어떤 대량의 텍스트에 어휘가 10만개가 넘어간다면 10만x10만 이라는 거대한 행렬에 대해 SVD를 처리해야 하는데, SVD의 계산량은 n³이기 때문에 이런 계산은 현실적이지 못하다.

통계 기반 기법은 말뭉치 전체의 통계량(co-occur matrix, ppmi matrix)를 이용해 한 번의 처리만에 단어의 분산 표현을 얻었다. 그러나 추론 기반 기법에서는 신경망을 사용하는 경우 미니배치로 학습하는 것이 일반적이다. 미니배치 학습에서는 한 번에 일부의 샘플들을 가져와 학습하여 가중치를 갱신한다. 다음 <그림1>을 보면 이 차이를 표현하고 있다. 추론 기반 기법에서는 미니 배치 학습을 진행하므로 SVD등 계산량이 큰 작업을 처리할 때도 신경망을 학습시킬 수 있다.

9.1.2 추론 기반 기법의 개요

추론 기반 기법의 '추론'이란 <그림2>처럼 주변 단어가 주어졌을 때 빈칸에 어떤 단어가 들어가는지를 추측하는 작업이다.

이를 모델 관점에서 보면 다음 <그림3>처럼 input으로 주어진 단어들을 통해 가장 높은 확률을 갖는 단어를 출력하는 것이다. 여기서의 모델은 구체적으로는 신경망을 사용한다.

9.1.3 신경망에서의 단어 처리

신경망을 이용하여 단어를 처리할 때는 단어 그대로 input에 넣을 수 없으므로 단어를 고정 길이의 벡터로 변환해야 하는데 여기서는 one-hot encoding방법을 쓰기로 한다. one-hot encoding은 벡터의 원소 중 하나만 1이고 나머지는 0인 벡터 표현을 의미한다. 예를 들어, "You say goodbye and I say hello."라는 문장을 input으로 생각해보자. 이 때 You의 단어 ID가 0, goodbye의 단어 ID가 2라면 다음 <그림4>와 같이 You는 0번째 원소만 1인 벡터, goodbye는 2번째 원소만 1인 벡터로 encoding할 수 있다. 이 때 벡터의 크기는 어휘의 수가 되어야 모든 단어를 one-hot encoding할 수 있을 것이다.

이렇게 단어들을 one-hot-encoding으로 표현할 수 있으면 입력층도 one-hot-encoding된 벡터와 동일 크기로 설정한 다음에 입력층에서 각 단어 벡터를 다음 <그림5>처럼 처리할 수 있다.

<그림5: 신경망 input에서 one-hot encoding벡터의 처리>

이제 단어를 신경망으로 처리할 수 있게 되었으므로 다음 <그림6>과 같이 완전 연결형태의 입력층-은닉층 연결도 그려볼 수 있다.

이 때 입력층의 벡터는 하나만 1이므로 k번째 원소가 1인 input은 다음 <그림7>에서와 같이 W의 k행 벡터만을 뽑아내는 연산을 수행한다.

9.2 Simple word2vec

이제 Word2vec을 구현해본다. 이는 <그림3>의 '모델'을 신경망으로 구축하는 작업이다. 특히 이번에 word2vec을 구현할 때 사용하는 신경망은 CBOW^{continuous bag-of-words}모델이다.

9.2.1 CBOW 모델의 추론 처리

CBOW모델은 맥락으로부터 타깃을 추측하는 용도의 신경망이다. 여기서 말하는 타깃이란 <그림2>의 빈칸에 들어올 단어를 의미한다. 우리의 목표는 이 CBOW모델을 훈련시켜서 단어의 분산 표현을 얻어내는 것이다. CBOW모델은 다음 <그림8>과 같은 구조로 되어있다. 단순한 2층 신경망이다. 또한 여러 W_in은 서로 동일한 값임에 주의하자.

보통의 신경망과 다르게 입력층이 2개인 것을 확인할 수 있는데, 이는 맥락에 속하는 단어의 수를 2개로 정했기 때문이다. 만약 N개의 단어를 맥락으로 본다면 N개의 입력층이 필요하다. 또, 이렇게 입력층이 여러개인 경우 출력은 각 입력층 출력의 평균이 된다. 이렇게 얻어낸 출력은 <그림8>에서 볼 수 있듯이 뉴런 하나가 각각의 단어에 대응하므로 이 출력값(점수)을 softmax에 넣어 처리하면 출력은 각 단어가 출현할 확률로 해석이 가능하다. 또한, 입력층에서 은닉층으로의 변환은 7x3 가중치 행렬 W_in에 의해 이루어지는데, 이 가중치가 단어의 분산 표현이다. 그림으로 표현하면 다음 <그림9>와 같다.

따라서 CBOW에서 학습이란 이 가중치를 갱신하는 것이고, 이 가중치를 갱신하는 것은 단어의 분산 표현을 갱신하는 것이 된다. 이것이 CBOW의 전체적인 그림이고 이를 뉴런 관점이 아닌 계층의 관점에서 다시 그려보면 다음 <그림10>과 같다.

또한, 출력층의 값은 실제로 확률이 아닌 '점수'이기 때문에, 이를 확률로 변환하기 위해 softmax layer를 output에 연결하여 사용하기 때문에 최종적인 구조는 다음 <그림11>과 같다.

9.2.2 CBOW 모델의 학습

CBOW 모델의 학습은 일반적인 신경망의 학습과 같이 가중치를 갱신하는 일을 한다. 그러나 그 가중치는 자체로 단어의 분산 표현이라는 중요한 의미를 갖고 있고, 이 표현은 단어의 의미/문법 면에서 사람의 직관에 부합하는 경우가 많다.

또, 신경망의 관점에서 CBOW 모델은 다중 클래스 분류를 수행하는 모델이다. 따라서 이 신경망을 학습하기 위해서는 cross-entropy error layer, softmax layer를 사용해야한다. 즉, 훈련 과정은 일반적인 신경망처럼 다음과 같이 수행하면 된다.

input으로부터 output을 계산한다. 이 과정에서 output layer의 값을 확률로 변환하는데 softmax layer를 사용한다.
확률 출력과 정답 레이블로부터 cross-entropy 오차를 구하여 학습을 진행한다.

이 과정을 전부 포함하여 다시 CBOW의 전체 구조를 그려보면 다음 <그림12>와 같다. Softmax with Loss는 위에서 언급한 두 신경망을 하나의 계층으로 구현한 것이다.

9.2.3 Word2vec의 가중치와 분산 표현

<그림12>의 word2vec에는 크게 입력 층 가중치, 출력 층 가중치의 두가지 가중치가 있다. 이 때 입력층 가중치 W_in의 각 행이 각 단어의 분산 표현에 해당했다. 또한 출력 측 가중치 W_out에도 열 방향으로 단어의 의미가 인코딩된 벡터가 저장되고 있다고 해석할 수 있다. 이를 그림으로 표현해보면 다음 <그림13>과 같다.

그러면 최종적으로 단어의 분산 표현으로

입력 측의 가중치만 이용
출력 측의 가중치만 이용
양쪽 가중치를 모두 이용

하는 방법이 있으므로 이 중 선택해야 한다. 일반적인 word2vec에서는 입력 측의 가중치만 분산 표현으로 사용하므로 이 글의 구현도 그것에 따른다. (GloVe와 같은 다른 모델에서는 양쪽 가중치를 모두 이용하는 선택지가 더 좋은 성능을 보여줄 때도 있다고 한다.)

9.3 학습 데이터 준비

우선 "You say goodbye and I say hello."라는 간단한 말뭉치에 대한 모델 구현과 학습을 진행해본다.

9.3.1 맥락과 타깃

word2vec에서 입력은 맥락, 출력은 타깃이라고 불렀다. 따라서 우리가 훈련에서 해야할 일은 신경망에 맥락을 입력했을 때 타깃이 출현할 확률을 높이는 것이다. 말뭉치에서 맥락과 타깃을 추출하는 <그림14>의 간단한 예를 보자.

훈련 때는 이렇게 말뭉치로부터 맥락과 타깃(정답 레이블)을 추출하는 작업이 필요하므로 이를 코드로 구현해보자.

# Corpus로부터 맥락, target추출
def create_contexts_target(corpus,window_size=1):
    target = corpus[window_size:-window_size] # target이 될 수 있는 놈들
    contexts=[]
    for idx in range(window_size,len(corpus)-window_size):
        cs = []
        for t in range(-window_size,window_size+1): # idx를 원점으로 봤을 때 상대적인 위치의 indexing

            if t == 0: # 자기 자신을 보는 경우
                continue
            cs.append(corpus[idx+t]) # 그 위치의 단어 ID를 추가, 즉 idx-window_size,idx+window_size까지의 단어 ID들을 추가한다.
        contexts.append(cs)
    return np.array(contexts),np.array(target)

시험해보면

# test
import sys
sys.path.append('..')
from common.util import *
text = "You say goodbye and I say hello."
corpus,word_to_id,id_to_word = preprocess(text)
#print(corpus)
#print(id_to_word)
contexts,target = create_contexts_target(corpus)
print(contexts)
print(target)

결과는 다음과 같이 맥락-타깃 쌍이 잘 나온다.

# Result
[[0 2]
 [1 3]
 [2 4]
 [3 1]
 [4 5]
 [1 6]]
[1 2 3 4 1 5]

의도하던 결과와 가까웠으나 우리의 레이블은 one-hot encoding되어야 하므로 벡터에 대해 다음 <그림15>와 같은 작업을 해주는 함수를 구현해야한다.

9.3.2 one-hot encoding

vocab_size를 인수로 받아 이 역할을 하는 함수를 구현해보면 다음과 같다. 인수인 corpus가 target으로 ndim=1 일때는 2차원 배열을 반환, corpus가 contexts로 ndim=2일때는 3차원 배열을 반환하는 함수.

# one-hot encoding function
def convert_one_hot(corpus, vocab_size):
    '''원핫 표현으로 변환

    :param corpus: 단어 ID 목록(1차원 또는 2차원 넘파이 배열)
    :param vocab_size: 어휘 수
    :return: 원핫 표현(2차원 또는 3차원 넘파이 배열)
    '''
    N = corpus.shape[0]

    if corpus.ndim == 1:
        one_hot = np.zeros((N, vocab_size), dtype=np.int32)
        for idx, word_id in enumerate(corpus):
            one_hot[idx, word_id] = 1

    elif corpus.ndim == 2:
        C = corpus.shape[1]
        one_hot = np.zeros((N, C, vocab_size), dtype=np.int32)
        for idx_0, word_ids in enumerate(corpus):
            for idx_1, word_id in enumerate(word_ids):
                one_hot[idx_0, idx_1, word_id] = 1

    return one_hot

이 함수는 다음과 같이 써먹으면 된다.

# 함수 사용
context,target= create_contexts_target(corpus)
vocab_size = len(corpus)

target = convert_one_hot(target,vocab_size)
context = convert_one_hot(context,vocab_size)

9.4 CBOW 모델 구현

이제는 <그림12>에 있는 simple한 CBOW 모델을 구현해보자. 나중에 더 개선할 가능성이 있으므로 simpleCBOW라는 이름으로 구현해본다. 구체적 설명은 주석을 참고.

9.4.1 CBOW Class 구현

여타 Neural Network와 같이 초기화 함수, forward, backward를 구현하면 된다. 살펴봐야 할 것은 input layer들이 동일 W_in을 사용한다는 것 정도. 이유는 주석에 달아놓았다. (참고로 이 구현에서는 W_in과 같은 가중치가 여러번 layer에 쌓이게 되는데, 따라서 params list에 동일한 가중치가 여러개 쌓인다. Deep Learning from scratch 2 에서는 trainer class에 중복 관련 처리 코드를 넣었으니 신경쓸 필요가 없다.)

# Implement CBOW model
import sys
sys.path.append('..')
import numpy as np
from common.util import *
from common.layers import *
class SimpleCBOW:
    def __init__(self,vocab_size,hidden_size):
        V,H = vocab_size,hidden_size

        # Init Weight
        W_in = 0.01 * np.random.randn(V,H).astype('f')
        W_out = 0.01 * np.random.randn(H,V).astype('f')

        # Create layer
        self.in_layer0 = MatMul(W_in)
        self.in_layer1 = MatMul(W_in)
        # 이 구현에서 두 input layer는 같은 W_in값을 갖게 된다. 왜냐하면 backprop이 동일한 초기 W_in에 대해 동일한 값을 계속하여 바꾸기 때문.
        self.out_layer = MatMul(W_out)
        self.loss_layer = SoftmaxWithLoss()

        # Listing all weights and grads
        layers = [self.in_layer0,self.in_layer1,self.out_layer]
        self.params, self.grads = [],[]
        # 모든 layer에 있는 parameter들을 하나의 리스트에 저장
        for layer in layers:
            self.params += layer.params
            self.grads += layer.grads

        # save distributional representation of word in instance variable
        self.word_vecs = W_in

    def forward(self,contexts,target):
        h0 = self.in_layer0.forward(contexts[:,0])
        # contexts[:,0] 맥락 단어 2개 중 앞단어'들', one-hot encoding이 여러개 붙어있는 것이므로 2차원임.
        h1 = self.in_layer1.forward(contexts[:,1])
        # contexts[:,1] 맥락 단어 2개 중 뒷단어'들

        '''
        print("DEBUG IN FORWARD")
        print(contexts[:,0])
        print(contexts[:,1])
        '''
        # DEbug

        h = (h0+h1)*0.5
        score = self.out_layer.forward(h)
        loss = self.loss_layer.forward(score,target)
        return loss

    def backward(self,dout=1):
        ds = self.loss_layer.backward(dout)
        da = self.out_layer.backward(ds)
        da *= 0.5
        self.in_layer1.backward(da)
        self.in_layer0.backward(da)
        return None

backward전파는 다음 <그림16>과 같이 진행되므로 그냥 저 값을 쭉 코드에 넣으면 된다.

backprop과정이 잘 이해되지 않는다면 다음 글을 읽어보는 것도 좋다.

BackProp에 대해 설명한 글: https://hezma.tistory.com/95

9.4.2 CBOW 모델 학습

Training은 다음과 같이 하면 된다. 책에서 구현된 Trainer class를 구현하면 매우 편하게 할 수 있다. trainer class 준비 전까지의 코드는 사전 작업으로써, 위에서 쭉 다루었으므로 설명하지 않겠다. trainer class를 준비하면 fit함수를 통해 model과 설정한 optimizer를 넣어 훈련을 진행한다. model은 self.params에 이미 모든 layer의 parameter가 들어가 있으므로 알아서 grads계산을 통해 매개변수를 갱신해준다. 참고로 fit함수의 매개변수 목록은 fit(self, x, t, max_epoch=10, batch_size=32, max_grad=None, eval_interval=20)이다.

# coding: utf-8
import sys
sys.path.append('..')  # 부모 디렉터리의 파일을 가져올 수 있도록 설정
from common.trainer import Trainer
from common.optimizer import Adam
#from simple_cbow import SimpleCBOW
from common.util import preprocess, create_contexts_target, convert_one_hot

# Set hyperparams
window_size = 1
hidden_size = 5
batch_size = 3
max_epoch = 1000

# set corpus
text = 'You say goodbye and I say hello.'
corpus, word_to_id, id_to_word = preprocess(text)

vocab_size = len(word_to_id)
contexts, target = create_contexts_target(corpus, window_size)
target = convert_one_hot(target, vocab_size)
contexts = convert_one_hot(contexts, vocab_size)

model = SimpleCBOW(vocab_size, hidden_size)
optimizer = Adam()
trainer = Trainer(model, optimizer)

trainer.fit(contexts, target, max_epoch, batch_size)
trainer.plot()

word_vecs = model.word_vecs
for word_id, word in id_to_word.items():
    print(word, word_vecs[word_id])

이 코드의 실행 결과 fit method를 통해 확인한 loss의 추이는 다음 <그림17>과 같다.

<그림17: 훈련 횟수(단위: epoch=20)에 따른 loss 값의 변화>

그리고 단어의 벡터 표현은 다음과 같이 출력된다. hidden_size = 5이므로 길이가 5인 밀집 벡터로 출력되는 것을 확인할 수 있다.

you [-1.0535545   1.5625883   1.1367095  -0.86172616  1.1446581 ]
say [ 1.1565381  -1.2511314  -0.29281798  1.1505251  -1.1646844 ]
goodbye [-0.9073448   0.09148943  0.89825845 -1.1231521   0.79867315]
and [ 0.901978   -1.1413794  -1.9207017   0.7914086  -0.90681213]
i [-0.9078278   0.08025153  0.89914554 -1.1502426   0.81140995]
hello [-1.0571245  1.5759369  1.157329  -0.8432223  1.1402406]
. [ 1.1161418 -0.9917648  1.8246069  1.127886  -1.0949212]

9.5 Word2Vec 보충

여기서는 CBOW model을 확률적 관점에서 다루어보고, word2vec의 또다른 모델인 skip-gram model에 대해서도 다룬다. 또한 이전에 다룬 통계 기반 기법과 추론 기반 기법에 대해 몇 가지 비교해볼 점에 대해서도 다룬다.

9.5.1 확률적 관점에서 본 CBOW 모델

CBOW 모델을 확률적 관점에서 기술해보자. 쓰이는 수학적 기술법은 아래에 있는 것 정도만 알면 된다.

P(A): A라는 사건이 발생할 확률
P(A|B): B가 일어났을 때, A가 일어날 확률 (사후 확률, 조건부 확률)
P(A,B): A와 B가 동시에 발생할 확률

CBOW 모델이 하는 일은 맥락이 주어졌을 때, 타깃이 출현할 확률을 계산하는 것이다. 여기서는 <그림18>처럼 T개의 단어로 이루어진 말뭉치를 w₁,w₂,...,w_T의 단어 시퀀스로 표기하고, t번째 단어 w_t에 대해 윈도우 크기가 1인 맥락을 고려해보자.

이 때 맥락으로 w_t-1과w_t+1이 주어졌을 때 w_t가 출현할 확률은, 두 단어의 동시 발생시 타깃이 일어날 확률이므로
$$
P(w_t|w_{t-1},w_{t+1})
$$
과 같이 표기할 수 있다. 즉, CBOW 모델은 상기 식을 모델링 하고 있는 것이다.

이 식을 이용하면 CBOW 모델의 손실 함수도 간결하게 표현할 수 있다. cross-entropy-error를 적용한 손실 함수는 다음 식과 같이 정의된다.
$$
L=-\sum_{k}{t_k\log{y_k}}
$$
(t_k:정답 레이블, y_k: 모델의 출력, 각 레이블은 one-hot encoding 되어있었음)

즉, 정답 레이블에 해당하는 모델의 출력만을 log에 넣어 부호반전 시킨것의 합이 Loss였으므로 그대로 CBOW 모델의 것을 적용해보면,

정답 레이블은 'w_t가 발생'이므로 w_t에 해당하는 원소만 1
이 것에 해당하는 모델의 출력은 'w_t가 발생할 확률'이므로 P(w|..)

따라서 CBOW에서 하나의 단어 w_t에 해당하는 loss는 다음 식과 같이 정의된다. 이런 식의 형태를 음의 로그 가능도라 부른다.
$$
L = -\log{P(w_t|w_{t-1},w_{t+1})}
$$
이를 말뭉치 전체에 대하여 확장하면, 다음과 같다.
$$
L = -\frac{1}{T}\sum{\log{P(w_t|w_{t-1},w_{t+1})}}
$$
따라서 CBOW model의 학습은 이 손실함수의 값을 작게 만드는 것이 되고, 이것을 달성하는 가중치 W가 단어의 분산 표현이 될 것이다.

상기 Loss 식에 대한 이해를 위해 식을 조금 더 설명하자면, 이 Loss function이 작아지려면 log안의 P가 1에 가까워져야 한다. 그런데 생각해보면 P의 괄호 안에 있는 사건은 제대로 된 사건이다. 왜냐하면 w_t|w_t-1,w_t+1이라는 사건은 '맥락이 주어졌을 때 올바른 단어가 출현하는 사건'이기 때문. 따라서 model이 잘 추리할 수록 이 loss값은 작아지게 되므로 이 식은 우리의 직관과 상당히 맞는 것을 알 수 있다.

9.5.2 skip-gram 모델

word2vec은 CBOW model외에도 skip-gram model을 지원하고있다. skip-gram은 CBOW에서 맥락과 타깃의 관계를 반전시킨 모델로써, 다음 <그림19>는 두 모델의 차이를 나타내고 있다.

즉, CBOW 모델은 여러 맥락으로부터 타겟을 추출, skip-gram model은 타깃으로부터 주변의 여러 단어를 추측하는 것으로 차이점을 정리해볼 수 있다. 이 때 skip-gram model의 신경망은 다음 <그림20>과 같이 구성되어있다. 마치 CBOW model의 출력/입력층을 반전시킨 것 같은 구성이다. 또한, 출력층의 수는 추출하는 맥락의 수만큼 존재할 수 있다.

이런 skip-gram model을 9.5.1에서 한것과 같이 확률 표기로 나타내보면 다음의 확률을 modeling하는 것이 될 것이다.
$$
P(w_{t-1},w_{t+1}|w_t)
$$
이 식은 맥락의 단어들 간 조건부 독립을 가정할 때 다음과 같이 풀어쓸 수 있다. (조건부 독립에 대해 궁금하면 아래의 글을 참고해보자.)

조건부 독립이란: http://norman3.github.io/prml/docs/chapter08/2

$$
P(w_{t-1},w_{t+1}|w_t)=P(w_{t-1}|w_t)P(w_{t+1}|w_t)
$$

이 식을 교차 엔트로피 오차에 적용해 skip-gram model의 손실 함수를 유도할 수 있다.
$$
L = -\log{P(w_{t-1},w_{t+1}|w_t)}=-\log{P(w_{t-1}|w_t)P(w_{t+1}|w_t)}=-\log{P(w_{t-1}|w_t)}+\log{P(w_{t+1}|w_t)}
$$
이를 말뭉치 전체에 대해 확장하면 손실함수는 다음과 같이 계산된다.
$$
L=-\frac{1}{T}\sum{\log{P(w_{t-1}|w_t)}+\log{P(w_{t+1}|w_t)}}
$$
이상으로 확률적 관점에서 두 모델을 살펴보았으며, 보통은 skip-gram model의 정확도가 더 높다고 한다. 그러나 skip-gram은 계산량이 많기 때문에 학습 시간이 더 오래 걸리는 경향이 있다.

9.5.3 통계 기반 vs 추론 기반

저번 장과 이번 장에 배운 내용들을 비교 정리해보자.

학습하는 데이터에 대해

통계 기반 기법: 데이터 전체를 한 번 학습하여 단어의 분산표현을 얻는다

추론 기반 기법: 데이터(말뭉치)를 일부분씩 여러번 보며 학습한다.(미니배치)
어휘에 추가할 새 단어가 생겨서 단어의 분산 표현을 갱신해야 하는 경우

통계 기반 기법: 동시발생 행렬부터 SVD까지의 모든 계산을 처음부터 전부 다시 해야함.

추론 기반 기법: 지금까지 학습한 가중치를 초깃값으로 사용해 다시 학습하면 됨 -> 효율적 갱신이 가능
단어 분산 표현의 성격

통계 기반 기법: 단어의 유사성이 encoding되는 경향이 있다.

추론 기반 기법: 단어의 유사성은 물론 한층 복잡한 단어 사이의 패턴까지도 encoding된다. ex) king-man+woman = queen같은 문제풀이가 가능
단어 분산 표현의 정밀도

두 기법이 큰 차이가 없었다고 한다.

Reference
- All pictures on: Deep Learning from scratch 2 by Saito Goki
- All codes on: https://github.com/WegraLee/deep-learning-from-scratch-2

[ML/NLP] 11. RNN (0)	2020.09.10
[ML/NLP] 10. Improving Word2Vec (0)	2020.09.05
[ML/NLP] 8. Distributional Representation of Words (0)	2020.08.25
[ML] 7. Convolutional Neural Network (0)	2020.08.22
[ML] 6. Back Propagation (2)	2020.08.08

복습용

티스토리 뷰

[ML/NLP] 9. Simple Word2vec