단어 벡터 및 텍스트 벡터

소개

단어 벡터와 텍스트 벡터는 텍스트 데이터를 표현하기 위해 자연어 처리(NLP)에 사용되는 수학적 모델입니다.

단어 벡터:

1. 원-핫 인코딩: 각 단어는 매우 긴 벡터로 표현되며, 벡터의 길이는 사전의 크기이며, 한 요소만 1이고 나머지는 0입니다.
2. TF-IDF: 문서 내 단어 빈도와 전체 말뭉치에서의 역문서 빈도를 고려합니다.
3. Word2Vec: 신경망 모델을 통해 단어의 벡터를 학습하여 의미상 유사한 단어도 벡터 공간에서도 유사하도록 합니다.
4. GloVe: 동시 발생 행렬과 관련 단어의 상대적 비율을 기반으로 단어 벡터를 생성하는 전역 벡터입니다.
5. FastText: Word2Vec과 유사하지만 단어 내 문자의 하위 구조를 고려합니다.

텍스트 벡터:

1. Bag of Words(BoW): 텍스트는 단어 순서에 관계없이 단어 모음으로 표시됩니다.
2. TF-IDF: 텍스트의 각 단어는 TF-IDF 값으로 표시됩니다.
3. 단락 벡터(Doc2Vec): Word2Vec과 유사하지만 전체 문서에 대해 단일 벡터가 있습니다.
4. 평균 단어 벡터: 텍스트에 있는 모든 단어의 평균 단어 벡터입니다.
   10.BERT, GPT: 사전 훈련된 언어 모델을 사용하여 각 단어 또는 전체 문장/단락의 임베딩 벡터를 얻습니다.
5. RNN, LSTM, GRU: 시퀀스 텍스트의 경우 이러한 순환 네트워크는 텍스트의 타이밍 정보를 캡처하고 전체 시퀀스의 표현을 출력할 수 있습니다.

단어 벡터와 텍스트 벡터는 텍스트 분류, 정보 검색, 감정 분석, 기계 번역과 같은 NLP 작업에 널리 사용됩니다. 텍스트의 의미 정보를 효과적으로 캡처하고 다양한 기계 학습 모델에 사용할 수 있습니다.

1. 텍스트 벡터화

• 기계의 경우 문자는 의미가 없으며 차이점만 있습니다.
• 단어와 단어, 단어와 단어, 텍스트와 텍스트의 관계를 문자만으로 설명하는 것은 불가능합니다.
• 텍스트를 벡터로 변환하면 텍스트 간의 관계를 더 잘 설명할 수 있습니다.
• 벡터화 후에는 많은 수의 기계 학습 알고리즘을 활성화할 수 있으며 이는 큰 가치가 있습니다.
• 텍스트는 단어와 문자로 구성됩니다. 텍스트를 벡터로 변환하려면 먼저 단어와 문자를 벡터로 변환할 수 있어야 합니다.
• 모든 벡터는 동일한 차원 n을 가져야 하며, 이 n차원 공간을 의미 공간이라고 부를 수 있습니다.

나 [0.78029002 0.77010974 0.07479124 0.4106988]
사랑 [0.14092194 0.63690971 0.73774712 0.42768218]
북경 [0.95780568 0.51903789 0.7661 5855 0.6399924]
천안문 [0.73861383 0.49694373 0.13213538 0.41237077]

2. 원-핫 인코딩

원-핫 인코딩은 범주형 변수를 표현하는 방법으로, 자연어 처리 및 기타 기계 학습 애플리케이션에 자주 사용됩니다. 이 인코딩 체계에서 각 고유 카테고리 또는 단어는 1인 것을 제외하고 모두 0인 벡터로 표시됩니다. 이 "1"의 위치는 일반적으로 어휘 또는 범주 목록에 있는 단어 또는 범주의 색인에 의해 결정됩니다.

예를 들어, ['apple', 'banana', 'orange']라는 어휘가 있는 경우 해당 One-Hot 인코딩은 다음과 같을 수 있습니다. 'apple': [1, 0, 0] 'banana': [
0
, 1, 0]
'주황색': [0, 0, 1]

원-핫 인코딩의 장점은 간단하고 효과적이라는 점이지만, 단어 간의 관계를 포착할 수 없는 등의 단점도 있습니다(예: "사과"와 "바나나"는 모두 과일입니다). 또한 어휘가 큰 경우 각 단어에는 어휘 크기와 동일한 벡터가 필요하므로 원-핫 인코딩은 메모리와 계산 리소스를 많이 소모할 수 있습니다.

텍스트를 벡터화할 때 단어 빈도도 양호 양호 [0, 0, 0, 1, 0]
양호 양호 [0, 0, 0, 2, 0]로 간주될 수 있습니다.

때로는 사전에 어휘를 준비하고 일시적으로 구축할 필요가 없는 경우도 있습니다.예를 들어
텍스트 비교 작업을 하려면 쌍으로 입력합니다. 이때 차원은 언제든지 변경될 수 있습니다.

원-핫 인코딩 - 단점

• 단어가 많으면 인코딩 벡터 차원이 매우 높고 벡터가 매우 희박하며(대부분의 위치가 0임) 계산 부담이 매우 무거움(차원성의 저주)
• 인코딩 벡터는 단어 간의 의미적 유사성을 반영할 수 없으며 단어를 구별할 수만 있습니다.

3. 단어 벡터 - word2vec

Word2Vec은 Google 연구원 Mikolov et al.이 2013년에 제안한 단어 벡터 생성 모델입니다. One-Hot 인코딩과 달리 Word2Vec은 단어 간의 의미 관계를 포착할 수 있는 조밀한 저차원 벡터를 생성합니다.

Word2Vec에는 두 가지 주요 아키텍처가 있습니다.

1. 스킵그램(Skip-gram): 단어가 주어지면 그 문맥을 예측합니다.
2. CBOW(Continuous Bag of Words): 문맥이 주어지면 중간 단어를 예측합니다.

Word2Vec은 단어 간의 동시 발생 관계를 포착하고 이 정보를 저차원 벡터로 인코딩하기 위해 대량의 텍스트 데이터로 훈련됩니다. 이러한 벡터에는 유사한 단어가 벡터 공간의 유사한 점에 매핑되는 등 많은 흥미로운 속성이 있습니다.

예를 들어, Word2Vec은 "왕 - 남자 + 여자 = 여왕"과 같은 비유를 포착할 수 있습니다.

Word2Vec의 장점은 다음과 같습니다.

• 복잡한 단어 관계를 포착하세요.
• 벡터 차원은 상대적으로 낮기 때문에 저장 공간과 컴퓨팅 리소스가 절약됩니다.

단점은 다음과 같습니다.

• 학습을 위해서는 많은 양의 데이터가 필요합니다.
• 텍스트의 다의어를 잘 처리하지 못합니다.

우리는 벡터 관계가
cos (hello, hello) > cos (hello, Weather)와 같은 의미론적 관계를 반영할 수 있도록 단어 벡터를 얻기를 바랍니다
. 즉, 단어 의미의 유사성이 벡터의 유사성에 반영됩니다.

왕 - 남자 = 여왕 - 여자,
즉 벡터는 수치 연산을 통해 단어 간의 관계를 반영할 수 있습니다.

동시에 단어 수에 관계없이 벡터 차원은 고정되어야 합니다.

3.1 단어 벡터 - 언어 모델 기반

언어 모델을 기반으로 한 단어 벡터 생성 방법은 Word2Vec과 같은 단어 임베딩 기술과 근본적으로 다릅니다. 이러한 방법에서는 사전 훈련된 언어 모델의 부산물로 단어 벡터가 생성됩니다. 이러한 모델에는 LSTM(Long Short Term Memory), GRU(Gated Recurrent Unit) 또는 Transformer와 같은 고급 아키텍처가 포함됩니다.

언어 모델의 주요 임무는 일련의 단어가 주어졌을 때 다음 단어를 예측하는 것입니다. 이 예측은 전체 단어 시퀀스의 문맥 정보를 기반으로 합니다. 훈련 과정에서 모델이 학습한 단어 벡터는 풍부한 의미 및 문법 정보를 포착할 수 있습니다.

ELMo(언어 모델의 임베딩) 및 BERT(변환기의 양방향 인코더 표현)는 언어 모델을 기반으로 하는 두 가지 일반적인 단어 벡터 생성 방법입니다.

이점:

1. 단어 의미 명확성을 포함하여 더 풍부하고 복잡한 의미 정보를 캡처할 수 있습니다.
2. 예측은 전체 컨텍스트를 기반으로 하기 때문에 결과 단어 벡터는 일반적으로 더 정확합니다.
3. 텍스트 분류, 명명된 엔터티 인식 및 질문 응답 시스템을 포함하되 이에 국한되지 않는 다양한 NLP 작업에 적용 가능합니다.

결점:

1. 계산 복잡도가 높고 더 많은 컴퓨팅 리소스가 필요합니다.
2. 모델 아키텍처의 복잡성으로 인해 튜닝에는 일부 전문 지식이 필요합니다.

언어 모델을 기반으로 한 단어 임베딩은 높은 유연성과 정확성으로 인해 많은 NLP 응용 프로그램에서 널리 사용되었습니다.

4개의 단어 벡터 - Windows 기반 word2vec

4.1 단어 벡터 - 학습 방법

가설을 세웁니다.
두 단어가 텍스트 앞뒤에 유사한 단어와 함께 나타나면 의미상 유사합니다.

좋다:

앞서 언급한 아이디어를 바탕으로 창에 있는 단어(또는 주변 단어)를 사용하여 중간 단어를 표현(예측)하려고 합니다.

또는 중간 단어를 사용하여 주변 단어를 나타냅니다.

단어 임베딩 - 훈련 문제

1. 출력 레이어에서 원-핫 벡터를 사용하면 어휘가 매우 커질 수 있으므로 차원성의 저주에 직면하게 됩니다.
2. 느린 수렴

코덱보우.py
_

#coding:utf8

import torch
import torch.nn as nn
import numpy as np


"""
基于pytorch的词向量CBOW
模型部分
"""

class CBOW(nn.Module):
    def __init__(self, vocab_size, embedding_size, window_length):
        super(CBOW, self).__init__()
        self.word_vectors = nn.Embedding(vocab_size, embedding_size)
        self.pooling = nn.AvgPool1d(window_length)
        self.projection_layer = nn.Linear(embedding_size, vocab_size)

    def forward(self, context):
        context_embedding = self.word_vectors(context)
        context_embedding = self.pooling(context_embedding.transpose(1, 2)).squeeze()
        pred = self.projection_layer(context_embedding)
        return pred

vocab_size = 8  #词表大小
embedding_size = 4  #人为指定的向量维度
window_length = 4  #窗口长度
model = CBOW(vocab_size, embedding_size, window_length)
#假如选取一个词窗口【1,2,3,4,5】·
context = torch.LongTensor([[1,2,4,5]])
pred = model(context)  #训练目标是输出3
print("预测值：", pred)

print("词向量矩阵")
print(model.state_dict()["word_vectors.weight"])

5. 허프만 트리

모든 단어를 다음 특성을 따르도록 이진 인코딩합니다.

1. 다른 단어는 다르게 코딩됩니다.
2. 각 단어의 코드는 다른 단어 코드의 접두사가 되지 않습니다. 즉, 단어가 011로 코딩되면 0111, 0110 또는 011001 등으로 코딩된 단어가 있을 수 없습니다.
3. 생성된 워드코드의 전체 길이는 가장 작으며, 빈도가 높을수록 코드의 길이는 짧아진다

코드

"""
    构建霍夫曼树
"""


class HuffmanNode:
    def __init__(self, word_id, frequency):
        self.word_id = word_id  # 叶子结点存词对应的id, 中间节点存中间节点id
        self.frequency = frequency  # 存单词频次
        self.left_child = None
        self.right_child = None
        self.father = None
        self.Huffman_code = []  # 霍夫曼码（左1右0）
        self.path = []  # 根到叶子节点的中间节点id


class HuffmanTree:
    def __init__(self, wordid_frequency_dict):
        self.word_count = len(wordid_frequency_dict)  # 单词数量
        self.wordid_code = dict()
        self.wordid_path = dict()
        self.root = None
        unmerge_node_list = [HuffmanNode(wordid, frequency) for wordid, frequency in
                             wordid_frequency_dict.items()]  # 未合并节点list
        self.huffman = [HuffmanNode(wordid, frequency) for wordid, frequency in
                        wordid_frequency_dict.items()]  # 存储所有的叶子节点和中间节点
        # 构建huffman tree
        self.build_tree(unmerge_node_list)
        # 生成huffman code
        self.generate_huffman_code_and_path()

    def merge_node(self, node1, node2):
        sum_frequency = node1.frequency + node2.frequency
        mid_node_id = len(self.huffman)  # 中间节点的value存中间节点id
        father_node = HuffmanNode(mid_node_id, sum_frequency)
        if node1.frequency >= node2.frequency:
            father_node.left_child = node1
            father_node.right_child = node2
        else:
            father_node.left_child = node2
            father_node.right_child = node1
        self.huffman.append(father_node)
        return father_node

    def build_tree(self, node_list):
        while len(node_list) > 1:
            i1 = 0  # 概率最小的节点
            i2 = 1  # 概率第二小的节点
            if node_list[i2].frequency < node_list[i1].frequency:
                [i1, i2] = [i2, i1]
            for i in range(2, len(node_list)):
                if node_list[i].frequency < node_list[i2].frequency:
                    i2 = i
                    if node_list[i2].frequency < node_list[i1].frequency:
                        [i1, i2] = [i2, i1]
            father_node = self.merge_node(node_list[i1], node_list[i2])  # 合并最小的两个节点
            if i1 < i2:
                node_list.pop(i2)
                node_list.pop(i1)
            elif i1 > i2:
                node_list.pop(i1)
                node_list.pop(i2)
            else:
                raise RuntimeError('i1 should not be equal to i2')
            node_list.insert(0, father_node)  # 插入新节点
        self.root = node_list[0]

    def generate_huffman_code_and_path(self):
        stack = [self.root]
        while len(stack) > 0:
            node = stack.pop()
            # 顺着左子树走
            while node.left_child or node.right_child:
                code = node.Huffman_code
                path = node.path
                node.left_child.Huffman_code = code + [1]
                node.right_child.Huffman_code = code + [0]
                node.left_child.path = path + [node.word_id]
                node.right_child.path = path + [node.word_id]
                # 把没走过的右子树加入栈
                stack.append(node.right_child)
                node = node.left_child
            word_id = node.word_id
            word_code = node.Huffman_code
            word_path = node.path
            self.huffman[word_id].Huffman_code = word_code
            self.huffman[word_id].path = word_path
            # 把节点计算得到的霍夫曼码、路径  写入词典的数值中
            self.wordid_code[word_id] = word_code
            self.wordid_path[word_id] = word_path

    # 获取所有词的正向节点id和负向节点id数组
    def get_all_pos_and_neg_path(self):
        positive = []  # 所有词的正向路径数组
        negative = []  # 所有词的负向路径数组
        for word_id in range(self.word_count):
            pos_id = []  # 存放一个词 路径中的正向节点id
            neg_id = []  # 存放一个词 路径中的负向节点id
            for i, code in enumerate(self.huffman[word_id].Huffman_code):
                if code == 1:
                    pos_id.append(self.huffman[word_id].path[i])
                else:
                    neg_id.append(self.huffman[word_id].path[i])
            positive.append(pos_id)
            negative.append(neg_id)
        return positive, negative


def main():
    words = "你 我 他 你们 我们 他们 它们"
    freqs = "50 10 8 7 6 3 2"
    word_to_id = dict((word, i) for i, word in enumerate(words.split()))
    print(word_to_id)
    word_frequency = dict((word_to_id[x], int(y)) for x, y in zip(words.split(), freqs.split()))
    tree = HuffmanTree(word_frequency)
    word_code = dict((word, tree.wordid_code[word_to_id[word]]) for word in words.split())
    print(word_code)


if __name__ == '__main__':
    main()

6. 네거티브 샘플링-네거티브 샘플링

단어 벡터 훈련은 최종적으로 소프트맥스를 활성화 함수로 사용하여 배열 V에서 예측 단어의 분포를 얻습니다.
V에 요소가 많으면 계산에 시간이 많이 걸립니다.
역전파 중에 모든 가중치를 함께 업데이트하는 데 시간이 많이 걸립니다. .

대안
모든 단어의 확률을 계산하는 대신 특정 단어만 선택하여 확률을 계산합니다.

확률을 하나씩 계산하려면 시그모이드 함수를 사용하세요. 소프트맥스 대신
선택한 단어 부분의 가중치 행렬만 업데이트하세요.

7. 장갑은 동시 발생 매트릭스를 기반으로 합니다.

7.1 장갑 단어 벡터

• 문제 변환:
• 세 단어의 단어 벡터를 보면 Va, Vb, Vc를 특정 함수로 매핑한 후 그 비율은 ABC의 동시 발생 확률 비율에 가까워야 합니다.
• 즉, 목표는 f(Va, Vb, Vc) = P(A|B)/P(A|C)가 되는 벡터를 찾는 것입니다.
• 예측값은 회귀 문제에 속하며 손실 함수는 평균 제곱 오차를 사용합니다.
• f의 설계 문서에 주어진 것은 f(Va, Vb, Vc) = (Va - Vb ) Vc입니다.

7.2 장갑 대 word2vec

Glove는 모델이 동시발생 행렬을 통해 전체 텍스트의 정보를 볼 수 있게 해주는 반면, word2vec 모델은 특정 창을 보고 있었습니다.

8. 단어 벡터 훈련 요약

1. 단어 간의 관계에 대한 몇 가지 가정을 기반으로 학습 목표를 공식화합니다.
2. 디자인 모델, 단어 벡터를 입력으로 사용
3. 단어 벡터를 무작위로 초기화하고 훈련을 시작합니다.
4. 학습 과정에서 단어 벡터는 특정 의미 정보를 얻기 위해 매개 변수로 지속적으로 조정됩니다.
5. 다운스트림 작업에 훈련된 단어 벡터 사용

단어 벡터 관련 문제:

• 단어 벡터는 "정적"입니다. 문맥을 고려하지 않고 각 단어에 고정 벡터를 사용합니다.
• 다의성의 경우. 수박-애플-화웨이
• 효과에 영향을 미치는 요소는
  차원 선택, 무작위 초기화, 스킵그램/cbow/글러브, 단어 분할 품질, 단어 빈도 잘림, 미등록 단어, 창 크기, 반복 횟수, 중지 조건, 말뭉치 품질 등 여러 가지가 있습니다.
• 좋은 직접 평가 지표는 없습니다. 종종 다운스트림 작업으로 평가해야 합니다.

9. 단어 벡터 적용

9.1 단어 벡터 응용 - 동의어 찾기

9.2 단어 벡터 적용 - 문장 벡터 또는 텍스트 벡터

1. 문장이나 텍스트를 여러 단어로 나누기
2. 각 단어에 해당하는 단어 벡터를 찾습니다.
3. 모든 단어 벡터는 합산되고 평균화되거나 다양한 네트워크 모델을 통과하여 텍스트 벡터를 얻습니다.
4. 텍스트 벡터를 사용하여 유사성을 계산하거나 클러스터링 등을 수행합니다.

9.3 단어 벡터 응용 - KMeans

• k개 점을 초기 중심으로 무작위로 선택
• 반복하다
• 각 점을 가장 가까운 중심에 할당하여 k개의 클러스터를 형성합니다.
• 각 클러스터의 중심을 다시 계산합니다.
• ~까지
• Centroid는 변하지 않습니다.

코드
kmeans.py

import numpy as np
import random
import sys
'''
Kmeans算法实现
原文链接：https://blog.csdn.net/qingchedeyongqi/article/details/116806277
'''

class KMeansClusterer:  # k均值聚类
    def __init__(self, ndarray, cluster_num):
        self.ndarray = ndarray
        self.cluster_num = cluster_num
        self.points = self.__pick_start_point(ndarray, cluster_num)

    def cluster(self):
        result = []
        for i in range(self.cluster_num):
            result.append([])
        for item in self.ndarray:
            distance_min = sys.maxsize
            index = -1
            for i in range(len(self.points)):
                distance = self.__distance(item, self.points[i])
                if distance < distance_min:
                    distance_min = distance
                    index = i
            result[index] = result[index] + [item.tolist()]
        new_center = []
        for item in result:
            new_center.append(self.__center(item).tolist())
        # 中心点未改变，说明达到稳态，结束递归
        if (self.points == new_center).all():
            sum = self.__sumdis(result)
            return result, self.points, sum
        self.points = np.array(new_center)
        return self.cluster()

    def __sumdis(self,result):
        #计算总距离和
        sum=0
        for i in range(len(self.points)):
            for j in range(len(result[i])):
                sum+=self.__distance(result[i][j],self.points[i])
        return sum

    def __center(self, list):
        # 计算每一列的平均值
        return np.array(list).mean(axis=0)

    def __distance(self, p1, p2):
        #计算两点间距
        tmp = 0
        for i in range(len(p1)):
            tmp += pow(p1[i] - p2[i], 2)
        return pow(tmp, 0.5)

    def __pick_start_point(self, ndarray, cluster_num):
        if cluster_num < 0 or cluster_num > ndarray.shape[0]:
            raise Exception("簇数设置有误")
        # 取点的下标
        indexes = random.sample(np.arange(0, ndarray.shape[0], step=1).tolist(), cluster_num)
        points = []
        for index in indexes:
            points.append(ndarray[index].tolist())
        return np.array(points)

x = np.random.rand(100, 8)
kmeans = KMeansClusterer(x, 10)
result, centers, distances = kmeans.cluster()
print(result)
print(centers)
print(distances)

word2vec_kmeans.py

#!/usr/bin/env python3  
#coding: utf-8

#基于训练好的词向量模型进行聚类
#聚类采用Kmeans算法
import math
import re
import json
import jieba
import numpy as np
from gensim.models import Word2Vec
from sklearn.cluster import KMeans
from collections import defaultdict

#输入模型文件路径
#加载训练好的模型
def load_word2vec_model(path):
    model = Word2Vec.load(path)
    return model

def load_sentence(path):
    sentences = set()
    with open(path, encoding="utf8") as f:
        for line in f:
            sentence = line.strip()
            sentences.add(" ".join(jieba.cut(sentence)))
    print("获取句子数量：", len(sentences))
    return sentences

#将文本向量化
def sentences_to_vectors(sentences, model):
    vectors = []
    for sentence in sentences:
        words = sentence.split()  #sentence是分好词的，空格分开
        vector = np.zeros(model.vector_size)
        #所有词的向量相加求平均，作为句子向量
        for word in words:
            try:
                vector += model.wv[word]
            except KeyError:
                #部分词在训练中未出现，用全0向量代替
                vector += np.zeros(model.vector_size)
        vectors.append(vector / len(words))
    return np.array(vectors)


def main():
    model = load_word2vec_model("model.w2v") #加载词向量模型
    sentences = load_sentence("titles.txt")  #加载所有标题
    vectors = sentences_to_vectors(sentences, model)   #将所有标题向量化

    n_clusters = int(math.sqrt(len(sentences)))  #指定聚类数量
    print("指定聚类数量：", n_clusters)
    kmeans = KMeans(n_clusters)  #定义一个kmeans计算类
    kmeans.fit(vectors)          #进行聚类计算

    sentence_label_dict = defaultdict(list)
    for sentence, label in zip(sentences, kmeans.labels_):  #取出句子和标签
        sentence_label_dict[label].append(sentence)         #同标签的放到一起
    for label, sentences in sentence_label_dict.items():
        print("cluster %s :" % label)
        for i in range(min(10, len(sentences))):  #随便打印几个，太多了看不过来
            print(sentences[i].replace(" ", ""))
        print("---------")

if __name__ == "__main__":
    main()

KMeans의 장점:

• 속도가 빠르고 많은 양의 데이터를 지원할 수 있습니다.
• 샘플이 명백히 균일한 특성을 가지면 효과가 좋습니다.

KMeans의 단점:
클러스터 수를 인위적으로 설정합니다.
초기화 중심이 효과에 영향을 미쳐 결과가 불안정합니다.
개별 특수 샘플에 민감하여 클러스터 중심의 위치에 큰 영향을 미칩니다.
다중 범주 또는 다중 범주에는 적합하지 않습니다. 개별 데이터.

KMeans 사용에 대한 몇 가지 팁:

• 먼저 더 많은 클러스터링 카테고리를 설정하세요.
• 클러스터링 후 클래스 내 평균 거리를 계산합니다.
• 정렬 후 클래스 내의 하위 카테고리를 폐기합니다.
• 거리를 계산할 때 유클리드 거리, 코사인 거리 또는 기타 거리를 사용해 볼 수 있습니다.
• 짧은 텍스트를 클러스터링하려면 먼저 중복 제거를 수행하고 기타 전처리를 수행해야 합니다.

10. 단어 벡터 요약

1. 질적 변화: 개별 문자를 연속 값으로 변환
2. 의미론의 유사성은 벡터의 유사성으로 표현됩니다.
3. 단어 벡터의 훈련은 완전히 정확하지 않은 많은 가정을 기반으로 하지만 이를 기반으로 훈련된 단어 벡터는 의미가 있습니다.
4. 레이블이 없는 텍스트로 작업하는 좋은 방법