[NLP] 4. Natural Language Embeddings

서쿠·2024년 7월 28일
1

NLP 강의요약

목록 보기
4/4
post-thumbnail

Natural Language Embeddings

자연어 처리(NLP)에서 텍스트 데이터를 효율적으로 다루기 위해 다양한 자연어 임베딩 기법(Natural Language Embedding)이 사용됩니다. 이번 포스트에서는 이러한 기법들을 자세히 설명하고, 각 기법의 예시를 통해 이해를 돕고자 합니다.

🔎 Text Representation Learning & Natural Language Embedding이란?

  • 텍스트 표현 학습(Text Representation Learning)은 비정형 텍스트 데이터를 정형 데이터로 변환하여 컴퓨터가 이해하고 처리할 수 있게 만드는 과정입니다.
  • 자연어 임베딩(Natural Language Embedding)은 이러한 과정에서 텍스트 데이터를 벡터 형식으로 변환하는 다양한 기법들을 포함합니다.
  • 이 과정에서 중요한 것은 단어 간의 의미적 유사성과 문맥 정보를 유지하면서 데이터를 변환하는 것입니다.

1. 비정형 데이터를 정형 데이터로 변환하기

  • 비정형 데이터는 텍스트와 같은 비구조화된 데이터를 말하며, 이를 정형 데이터로 변환하는 것이 자연어 처리(NLP)의 첫 번째 단계입니다.

  • 이 과정은 데이터를 컴퓨터가 이해할 수 있는 형태로 바꾸는 것을 목표로 합니다.

  • 비정형 데이터를 벡터 또는 매트릭스 형식으로 변환하여 정형 데이터로 만들 수 있습니다.

  • 주요 과정:

    • 데이터 수집: 서적, 인터넷 등 다양한 소스로부터 데이터를 수집합니다.
    • 데이터 전처리: 수집한 데이터를 NLP 기법을 이용해 전처리합니다.
      • 대소문자 통일: "They"와 "they"를 모두 소문자로 통일.
      • 불필요한 문장 기호 제거: 예를 들어, "!"나 "?" 같은 기호를 제거.
      • 숫자 제거: 필요 없는 숫자는 제거.
      • 불용어 제거: 문법 요소 등 중요한 의미를 담고 있지 않은 단어 제거.
    • 정형 데이터로 변환: 비정형 데이터를 벡터 또는 매트릭스 형태로 변환합니다.

2. 텍스트 벡터화 기법

텍스트를 벡터로 변환하는 다양한 기법을 소개합니다.

2.1 백 오브 워즈 (Bag-of-Words) 모델

Bag of Words는 단어를 벡터로 표현하는 가장 간단한 방법으로, 단어의 순서를 고려하지 않고 문서 내 단어의 빈도를 기반으로 문서를 벡터화합니다.

서로 다른 문서들의 BoW들을 결합하면 문서 단어 행렬(Document-Term Matrix, DTM) 또는 단어 문서 행렬(Term-Document Matrix, TDM)으로 표현할 수 있습니다. 이렇게 하면 서로 다른 문서들까지 확장해서 비교할 수 있게 됩니다.

  • 개념: 단어의 등장 순서를 고려하지 않고, 문서 내 단어의 빈도를 세어 벡터를 구성합니다.
  • BoW 생성 방식:
    (1) 각 단어에 고유한 정수 인덱스 부여.
    (2) 각 인덱스의 위치에 단어 토큰의 등장 횟수를 기록한 벡터 생성.
  • 특징: 단어의 순서를 무시하며 빈도 기반으로 벡터를 구성합니다.
  • 예시:
    문서1: "I love machine learning."
    문서2: "Machine learning is fun."
    
    BoW 벡터:
    문서1: [1, 1, 1, 1, 0, 0]  # "I", "love", "machine", "learning", "is", "fun"의 순서
    문서2: [0, 0, 1, 1, 1, 1]
  • 예시 코드:
from konlpy.tag import Okt

okt = Okt()

def build_bag_of_words(document):
  # 온점 제거 및 형태소 분석
  document = document.replace('.', '')
  tokenized_document = okt.morphs(document)

  word_to_index = {}
  bow = []

  for word in tokenized_document:  
    if word not in word_to_index.keys():
      word_to_index[word] = len(word_to_index)  
      # BoW에 전부 기본값 1을 넣는다.
      bow.insert(len(word_to_index) - 1, 1)
    else:
      # 재등장하는 단어의 인덱스
      index = word_to_index.get(word)
      # 재등장한 단어는 해당하는 인덱스의 위치에 1을 더한다.
      bow[index] = bow[index] + 1

  return word_to_index, bow

2.2 단어 가중치 (Word Weighting) - TF-IDF

특정 단어가 문서에서 얼마나 중요한지를 측정하기 위해 단어 빈도(TF, Term-Frequency)와 문서 빈도(DF, Document-Frequency)를 사용합니다.

  • 개념: 자주 등장하지 않는 단어가 특정 문서에서 많이 등장할 경우 해당 단어의 가중치를 높입니다.

  • TF-IDF 생성 방식:

    • TF (Term Frequency): tf(d,t), 특정 문서 d에서의 특정 단어 t의 등장 횟수.
    • DF (Document Frequency): df(t), 특정 단어 t가 등장한 문서의 수.
    • IDF (Inverse Document Frequency): idf(t), 전체 문서에서 단어가 등장한 빈도의 역수
      - 수식: log(n/(1+df(t)))log({n}/{(1+df(t))})
    • TF-IDF: TF와 IDF를 곱하여 계산.

  • 특징: 단순 빈도의 단점을 보완하여 단어의 중요성을 반영합니다. (가중치 개념 추가)

  • 예시:

    • 문서1: "I love machine learning."
    • 문서2: "Machine learning is fun."
    • 단어 'machine'에 대해:
      • n=2n = 2 (전체 문서 수)
      • df(t)=2\text{df}(t) = 2 ('machine'이 등장하는 문서 수)
    • 따라서 IDF는 다음과 같이 계산됩니다:
      • IDF(machine)=log⁡(21+2)=log⁡(23)=log⁡(0.6667)≈−0.176\text{IDF}(machine) = \log\left(\frac{2}{1 + 2}\right) = \log\left(\frac{2}{3}\right) = \log(0.6667) \approx -0.176
    • TF 계산
      • 문서1에서 'machine'의 TF: 1
      • 문서2에서 'machine'의 TF: 1
    • TF-IDF 계산
      • 문서1: TF-IDF(machine)=1×−0.176=−0.176\text{TF-IDF}(machine) = 1 \times -0.176 = -0.176
      • 문서2: TF-IDF(machine)=1×−0.176=−0.176\text{TF-IDF}(machine) = 1 \times -0.176 = -0.176

  • 예시 코드:

    from sklearn.feature_extraction.text import TfidfVectorizer
    
    documents = ["I love machine learning.", "Machine learning is fun."]
    
    tfidf_vectorizer = TfidfVectorizer()
    tfidf_matrix = tfidf_vectorizer.fit_transform(documents)
    
    print(tfidf_matrix.toarray())
    print(tfidf_vectorizer.get_feature_names_out())

2.3 N-Grams 모델

단어의 순서를 고려하기 위해 N-Grams 모델을 사용합니다. 이는 단어의 연속된 N개의 단어 조합을 특징으로 합니다.

  • 개념: N개의 연속된 단어를 하나의 토큰으로 취급하여 벡터를 구성합니다.
    • 유니그램(Unigram): 단일 단어로 구성된 N-그램. (N=1)
    • 바이그램(Bigram): 두 단어로 구성된 N-그램. (N=2)
    • 트라이그램(Trigram): 세 단어로 구성된 N-그램. (N=3)
    • 4-그램(4-gram): 네 단어로 구성된 N-그램. (N=4)
  • N-Gram 생성 방식:
    (1) 텍스트를 N개의 단어 묶음으로 나눕니다.
    (2) 각 N-Gram 묶음을 벡터화합니다.
  • 특징: 단어의 순서를 반영하여 문맥을 고려합니다.
  • 예시:
    문장: "I love machine learning"
    
    Unigram: ["I", "love", "machine", "learning"]
    Bigram: ["I love", "love machine", "machine learning"]
    Trigram: ["I love machine", "love machine learning"]
    4-gram: ["I love machine learning"]
  • 예시 코드:
    from sklearn.feature_extraction.text import CountVectorizer
    
    bigram_vectorizer = CountVectorizer(ngram_range=(2, 2))
    trigram_vectorizer = CountVectorizer(ngram_range=(3, 3))
    
    documents = ["I love machine learning."]
    
    bigram_matrix = bigram_vectorizer.fit_transform(documents)
    trigram_matrix = trigram_vectorizer.fit_transform(documents)
    
    print("Bigram:\\n", bigram_matrix.toarray())
    print("Bigram Features:\\n", bigram_vectorizer.get_feature_names_out())
    
    print("Trigram:\\n", trigram_matrix.toarray())
    print("Trigram Features:\\n", trigram_vectorizer.get_feature_names_out())

3. 분산 표현 (Distributed Representation)

분산 표현이란, 단어를 분산 벡터로 표현하여 단어 간의 유사성을 보존하는 방법입니다. 이는 단어의 의미를 벡터 공간 상에서 유사하게 배치하여 단어 간의 관계를 학습할 수 있게 합니다.

3.1 NNLM (NeuralNet Language Model)

  • 개념: NNLM은 단어의 시퀀스를 입력받아 다음에 올 단어를 예측하는 방식으로 단어 벡터를 학습합니다. 입력된 단어 시퀀스를 고정 길이의 벡터로 변환하고, 이를 바탕으로 다음 단어의 확률 분포를 출력합니다. (RNN/LSTM 계열 모델)

  • NNLM 생성 방식:
    (1) 단어 시퀀스를 입력받아 단어 임베딩 레이어를 통해 고정 길이의 벡터로 변환합니다.
    (2) 은닉층을 거쳐 다음 단어의 확률 분포를 출력합니다.
    (3) 모델을 학습하여 단어 임베딩 벡터를 최적화합니다.

  • 특징: NNLM은 단어의 순서를 고려하여 문맥을 반영하며, 다음 단어를 예측하는 방식으로 단어 간의 관계를 학습합니다.

  • 예시:

    문장: "I love machine learning"
    >>> 입력: ["I", "love", "machine"]
    >>> 출력: "learning"
  • 예시 코드:
    from tensorflow.keras.preprocessing.text import Tokenizer
    from tensorflow.keras.preprocessing.sequence import pad_sequences
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Embedding, LSTM, Dense
    
    # 샘플 데이터
    sentences = ["I love machine learning", "Machine learning is fun", "I love deep learning"]
    
    # 토크나이저 생성
    tokenizer = Tokenizer()
    tokenizer.fit_on_texts(sentences)
    total_words = len(tokenizer.word_index) + 1
    
    # 시퀀스 생성
    input_sequences = []
    for line in sentences:
        token_list = tokenizer.texts_to_sequences([line])[0]
        for i in range(1, len(token_list)):
            n_gram_sequence = token_list[:i+1]
            input_sequences.append(n_gram_sequence)
    
    # 패딩
    max_sequence_len = max([len(x) for x in input_sequences])
    input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')
    
    # 특징과 레이블 분리
    X, y = input_sequences[:,:-1], input_sequences[:,-1]
    
    # 레이블 원-핫 인코딩
    y = tf.keras.utils.to_categorical(y, num_classes=total_words)
    
    # 모델 생성
    model = Sequential()
    model.add(Embedding(total_words, 10, input_length=max_sequence_len-1))
    model.add(LSTM(100))
    model.add(Dense(total_words, activation='softmax'))
    
    # 모델 컴파일
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    
    # 모델 학습
    model.fit(X, y, epochs=100, verbose=1)
    
    # 예측
    seed_text = "I love"
    next_words = 3
    for _ in range(next_words):
        token_list = tokenizer.texts_to_sequences([seed_text])[0]
        token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')
        predicted = model.predict(token_list, verbose=0)
        output_word = tokenizer.index_word[np.argmax(predicted)]
        seed_text += " " + output_word
    print(seed_text)

3.2 Word2Vec

  • 개념: 단어를 벡터 공간에 매핑하여 단어 간의 유사성을 보존하는 임베딩 기법입니다.
    - 주요 모델로는 CBOW(Continuous Bag of Words)와 Skip-gram이 있습니다.

    • Word2Vec을 학습할 때는 CBOW와 Skip-gram 중 하나를 선택적으로 사용합니다. 두 방법은 서로 다른 접근 방식을 가지고 있으며, 각각의 장단점이 있습니다.

    • CBOW (Continuous Bag of Words):

      • 주변 단어들로 중심 단어를 예측합니다.
      • 일반적으로 작은 데이터셋에서 더 잘 작동합니다.
      • 빈번한 단어에 대해 더 나은 성능을 보입니다.

    • Skip-gram:

      • 중심 단어로 주변 단어들을 예측합니다.
      • 대규모 데이터셋에서 더 좋은 성능을 보입니다.
      • 드문 단어에 대해 더 나은 표현을 학습합니다.

  • (Method 1) CBOW: 주변 단어들로 중심 단어를 예측.

  • (Method 2) Skip-gram: 중심 단어로 주변 단어들을 예측.

  • 특징: 유사한 의미의 단어들이 가까운 벡터로 표현됩니다. 신경망을 통해 단어 벡터를 학습합니다.

  • 예시:

    문장: "The cat sat on the mat"
    중심 단어: "sat"
    주변 단어: ["The", "cat", ___, "on", "the", "mat"]
    
    ## CBOW: 주변 단어들 → 중심 단어 예측
    >> 인풋: ["The", "cat", "on", "the", "mat"]
    >> 아웃풋: "sat"
    
    ## Skip-gram: 중심 단어 → 주변 단어들 예측
    >> 인풋: "sat"
    >> 아웃풋: ["The", "cat", "on", "the", "mat"]
  • 예시 코드:
    from gensim.models import Word2Vec
    
    sentences = [["the", "cat", "sat", "on", "the", "mat"],
                 ["the", "dog", "sat", "on", "the", "couch"]]
    
    model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, sg=0)  # CBOW
    
    vector = model.wv['cat']
    print(vector)

3.3 GloVe (Global Vectors for Word Representation)

  • 개념: 글로브(Global Vectors for Word Representation, GloVe)는 카운트 기반과 예측 기반을 모두 사용하는 방법론으로 2014년에 미국 스탠포드대학에서 개발한 단어 임베딩 방법론으로, 단어의 동시 등장 행렬을 활용하여 단어 벡터를 학습하는 방법입니다.
    • LSA 기법은 DTM(TDM)이나 TF-IDF 행렬과 같이 각 문서에서의 각 단어의 빈도수를 카운트 한 행렬이라는 전체적인 통계 정보를 입력으로 받아 차원을 축소(Truncated SVD)하여 잠재된 의미를 끌어내고자 합니다.
      • (단점) LSA는 카운트 기반으로 코퍼스의 전체적인 통계 정보를 고려하기는 하지만, King : Man = Queen : ? (Woman) 또는 Korea : Seoul = Japan : ? (Tokyo)와 같은 단어 의미의 유추 작업(Analogy task)에는 성능이 떨어집니다.
    • Word2Vec 기법은 CBOW와 Skip-gram이라는 딥러닝 학습방법을 활용하여 실제값과 예측값에 대한 오차를 손실 함수를 통해 줄여나가며 학습하며 잠재된 의미를 끌어내고자 합니다.
      • (단점) Word2Vec는 임베딩 벡터가 단어 간의 상관성을 고려하여 학습하기 때문에 유추 작업은 LSA보다 뛰어나지만, 윈도우 크기 내에서만 주변 단어를 고려하기 때문에 코퍼스의 전체적인 통계 정보를 반영하지 못합니다.
    • Glove는 이러한 각각의 모델의 장점을 합쳐서 각각의 단점을 해결하고자 했습니다.

  • GloVe 생성 방식:
    1. 동시 등장 행렬 (Co-occurrence Matrix)을 생성합니다.
      • 정의: 전체 코퍼스에서 각 단어 쌍이 특정 문맥 윈도우 내에서 함께 등장하는 빈도를 나타내는 행렬입니다.
      • 구조: 행과 열이 모두 어휘의 단어들로 이루어진 정사각 행렬입니다.
      • 값: 행렬의 각 셀 XijX_{ij}는 단어 i의 문맥에서 단어 j가 등장한 횟수를 나타냅니다.
    2. 동시 등장 빈도 (Co-occurrence Frequency)를 기반으로 단어 벡터를 학습합니다.
      • 정의: 특정 단어 쌍이 정의된 문맥 윈도우 내에서 함께 등장하는 횟수입니다.
      • 구조: 보통 중심 단어로부터 일정 거리(윈도우 크기) 내의 단어들을 문맥으로 간주하여 계산합니다.
      • 값: 이 빈도는 단어 간의 관계를 나타내는 중요한 통계적 정보를 제공합니다.

  • 특징: 전체 코퍼스에서 단어가 함께 등장하는 빈도를 활용하여 전역적인 통계 정보를 반영합니다.

  • 예시:

문장들:
1. "The cat sits on the mat"
2. "The dog chases the cat"
3. "A cat and a dog play"

>> 문맥 윈도우 크기: 2 (중심 단어의 양쪽으로 2개의 단어까지 고려)

>> 동시 등장 행렬:
       the  cat  sits  on   mat  dog  chases  a    and  play
the    0    3    1     1    1    1    1       0    0    0
cat    3    0    1     1    1    2    1       2    1    1
sits   1    1    0     1    1    0    0       0    0    0
on     1    1    1     0    1    0    0       0    0    0
mat    1    1    1     1    0    0    0       0    0    0
dog    1    2    0     0    0    0    1       2    1    1
chases 1    1    0     0    0    1    0       0    0    0
a      0    2    0     0    0    2    0       0    1    1
and    0    1    0     0    0    1    0       1    0    1
play   0    1    0     0    0    1    0       1    1    0
  • 예시 코드:
    • GloVe 사용시, Stanford의 pre-trained 벡터를 다운로드 후 사용하실 수 있습니다.
    • 이는 다음 링크에서 직접 받으실 수도 있습니다: https://nlp.stanford.edu/projects/glove/
  • 아래는 사전 학습된 Glove 임배딩을 호출하고, 'cat'이라는 단어의 임배딩 값을 확인해보는 예제 코드입니다.
from urllib.request import urlretrieve
import zipfile

# glove 사전학습 파일 다운로드
urlretrieve("http://nlp.stanford.edu/data/glove.6B.zip", filename="glove.6B.zip")

# glove 사전학습 파일 압축 해제
with zipfile.ZipFile('glove.6B.zip', 'r') as zip_ref:
    zip_ref.extractall()

from gensim.scripts.glove2word2vec import glove2word2vec
from gensim.models import KeyedVectors

# GloVe 파일 경로
glove_input_file = './glove.6B.100d.txt'

# 변환된 Word2Vec 파일 경로
word2vec_output_file = 'glove.6B.100d.word2vec.txt'

# GloVe 형식을 Word2Vec 형식으로 변환
glove2word2vec(glove_input_file, word2vec_output_file)

# 변환된 Word2Vec 형식의 파일을 로드
model = KeyedVectors.load_word2vec_format(word2vec_output_file, binary=False)

# 특정 단어의 벡터를 출력
vector = model['cat']
print(vector)

3.3 FastText

  • 개념: FastText는 Facebook(현 Meta)에서 개발한 임배딩 기법으로, 단어 내부의 문자 n-gram을 활용하여 단어 벡터를 학습하는 방법입니다.
    • Word2Vec와 FastText와의 가장 큰 차이점이라면 Word2Vec는 단어를 기본 단위로 생각한다면, FastText는 하나의 단어 안에도 단위들이 있다고 간주합니다. 즉, 단어의 형태소 정보를 반영합니다.

  • FastText 생성 방식:
    ## Subword Model
    (1) 단어를 문자 n-gram으로 분해합니다.
    (2) 각 n-gram 벡터를 합산하여 단어 벡터를 생성합니다.

  • 특징: 문자 n-gram을 사용하여 단어의 내부 구조를 반영하며, 모르는 단어(Out Of Vocabulary, OOV)도 효과적으로 학습합니다.

  • 예시:

    단어: "apple"
    문자 n-gram: ["a", "ap", "app", "p", "pp", "ple", "e"]
    벡터 학습: 각 문자 n-gram의 벡터를 합산하여 단어 벡터를 생성합니다.
  • 예시 코드:
    from gensim.models import FastText
    
    sentences = [["the", "cat", "sat", "on", "the", "mat"],
                 ["machine", "learning", "is", "fun"]]
    
    model = FastText(sentences, vector_size=100, window=5, min_count=1)
    vector = model.wv['cat']
    print(vector)

4. 문서 임베딩 (Document Embedding)

문서 전체를 하나의 벡터로 표현하는 기법입니다. 이는 문서의 내용을 종합적으로 고려하여 벡터화합니다.

4.1 단어 임베딩의 평균 (Averaging Word Embeddings)

  • 개념: 가장 원초적인 방법으로, 문서 내의 모든 단어 임베딩 벡터의 평균을 구하여 문서 벡터를 생성하는 방법입니다.

  • 생성 방식:

    (1) 문서 내의 모든 단어를 임베딩 벡터로 변환합니다.
    (2) 변환된 모든 단어 임베딩 벡터의 평균을 구합니다.
  • 특징: 간단하고 계산이 빠르지만, 평균을 연산을 수행하기 때문에 문서 내 단어 순서나 문맥 정보를 반영하지 못합니다.
  • 예시 코드:
    import numpy as np
    from gensim.models import Word2Vec
    
    sentences = [["I", "love", "machine", "learning"], ["Machine", "learning", "is", "fun"]]
    word2vec_model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=4)
    
    def average_word_embeddings(document):
    
        vectors = [word2vec_model.wv[word] for word in document if word in word2vec_model.wv]
        
        return np.mean(vectors, axis=0)
    
    document = ["I", "love", "machine", "learning"]
    document_vector = average_word_embeddings(document)
    
    print(document_vector)

4.2 PV-DM (Distributed Memory Model of Paragraph Vectors)

  • 개념: 문서와 단어를 동시에 임베딩하여 문서 벡터를 학습하는 방법입니다. 문맥 단어와 문서 벡터를 조합하여 중심 단어를 예측합니다.

  • 생성 방식:
    (1) 각 문서에 고유한 ID를 부여합니다.
    (2) 문맥 단어와 문서 ID를 입력으로 받아 중심 단어를 예측합니다.
  • 특징: 문서의 문맥 정보를 반영하여 문서 벡터를 학습합니다.
  • 예시 코드:
    from gensim.models.doc2vec import Doc2Vec, TaggedDocument
    
    documents = [TaggedDocument(words=["I", "love", "machine", "learning"], tags=['doc1']),
                 TaggedDocument(words=["Machine", "learning", "is", "fun"], tags=['doc2'])]
    
    model = Doc2Vec(documents, vector_size=100, window=2, min_count=1, workers=4, dm=1)  # PV-DM
    vector = model.dv['doc1']
    
    print(vector)

4.3 PV-DBOW (Distributed Bag of Words Model of Paragraph Vectors)

  • 개념: 단어 순서를 고려하지 않고 문서 벡터만으로 중심 단어를 예측하는 방법입니다. 단어의 순서나 문맥 정보를 반영하지 않으며, Skip-gram 모델과 유사합니다.

  • 생성 방식:
    (1) 각 문서에 고유한 ID를 부여합니다.
    (2) 문서 ID를 입력으로 받아 중심 단어를 예측합니다.
  • 특징: 단어의 순서를 고려하지 않으며, 문서 벡터만으로 단어를 예측합니다. 계산이 간단하고 빠릅니다.
  • 예시 코드:
    from gensim.models.doc2vec import Doc2Vec, TaggedDocument
    
    documents = [TaggedDocument(words=["I", "love", "machine", "learning"], tags=['doc1']),
                 TaggedDocument(words=["Machine", "learning", "is", "fun"], tags=['doc2'])]
    
    model = Doc2Vec(documents, vector_size=100, window=2, min_count=1, workers=4, dm=0)  # PV-DBOW
    vector = model.dv['doc1']
    
    print(vector)

이번 포스트에서는 자연어 임베딩 학습을 위한 다양한 기법과 알고리즘에 대해 설명했습니다.

  • 비정형 데이터를 정형 데이터로 변환하는 과정에서 Bag-of-Words(BoW), TF-IDF, N-Grams 모델을 통해 단어의 빈도와 순서를 반영한 벡터화를 살펴보았습니다.
  • Word2Vec, GloVe, FastText를 통해 단어의 의미와 유사성을 반영한 분산 표현 기법을 살펴보았습니다.
  • 또한, 문서 임베딩 기법을 통해 문서 전체를 벡터로 표현하는 방법도 설명하였습니다.

긴 글 읽어주셔서 감사합니다 💌

profile
서쿠
Always be passionate ✨
이전 포스트

[NLP] 3. Natural Language Preprocessing

0개의 댓글