自然语言处理中的词嵌入

2025年6月20日 | 阅读时长 16 分钟

词嵌入是降维的数值向量集，为相应的词提供语义和句法信息。它们在自然语言处理任务中至关重要。在本文中，我们回顾了 TF-IDF、Word2Vec 和 GloVe 等经典和神经网络方法，并对每种方法进行了批判。同时，它强调了所谓的预训练词嵌入的重要性，并列出了它们在不同 NLP 情况下的用途。

NLP 中的词嵌入是什么？

词嵌入是一种将单词和文档转换为表示的技术。它们也称为词向量，是将单词映射到较低维空间中的数值向量，使得相似或近似相似的单词具有最近的向量。

词嵌入用作将文本数据转换为一组数值特征以进行机器学习的技术，同时保留句法和语义属性。与词袋模型 (BOW)、CountVectorizer 和 TF-IDF 等传统方法相比，直接计算词向量可能会忽略单词的顺序，而词嵌入会生成词汇量大小的向量，因此矩阵可能稀疏，包含许多零。大型输入向量的一个缺点是计算复杂度可能存在问题，词嵌入可以解决这个问题。

为什么需要词嵌入？

降低维度
预测特定单词在周围文本中使用上下文的能力。
词间语义可以定义为两个单词之间的含义，因此要捕获它，应遵循以下步骤。

词嵌入如何使用？

在这种情况下，它们用数字代表单词，以便它们可以用于机器学习模型的训练和推理。它们还可以将训练语料库中的文本数据模式作为可视化部署。例如，在捕获常见情感时，每种情感都可以被向量化，以表示与该情感相关的每种状况。

同样，对于选定的特征，我们也可以获得不同单词的词向量。直观地说，向量在上下文中接近的单词将在语义上相关，或将表达相同的情感或观点。

文本表示技术

1. 传统方法

第一种方法非常基础，它涉及准备一个包含独特术语的列表，每个术语都有一个整数标识符。然后将此 ID 嵌入到句子中作为每个单词的标识符，并且操作词汇表中的每个单词都被视为一个特征。另一方面，非常大的词汇量会导致特征空间的高维度。常见的传统技术包括

1.1. One-Hot 编码

One-Hot 编码是一种在自然语言处理中创建单词向量的简单方法。这里，每个词汇表中的单词都得到特别的重视，每个向量的维度等于词汇量的大小。每个向量是一组零，除了特定于词汇表中给定单词的索引位置被设置为一。

代码

def one_hot_encode(text):
    words = text.split()
    vocabulary = set(words)
    word_to_index = {word: i for i, word in enumerate(vocabulary)}
    one_hot_encoded = []
    for word in words:
        one_hot_vector = [0] * len(vocabulary)
        one_hot_vector[word_to_index[word]] = 1
        one_hot_encoded.append(one_hot_vector)
 
    return one_hot_encoded, word_to_index, vocabulary
 
# New Sample
example_text = "apple orange banana grape pineapple lemon"
one_hot_encoded, word_to_index, vocabulary = one_hot_encode(example_text)
 
print("Vocabulary:", vocabulary)
print("Word to Index Mapping:", word_to_index)
print("One-Hot Encoded Matrix:")
for word, encoding in zip(example_text.split(), one_hot_encoded):
    print(f"{word}: {encoding}")

输出

Vocabulary: {'lemon', 'apple', 'pineapple', 'orange', 'grape', 'banana'}
Word to Index Mapping: {'lemon': 0, 'apple': 1, 'pineapple': 2, 'orange': 3, 'grape': 4, 'banana': 5}
One-Hot Encoded Matrix:
apple: [0, 1, 0, 0, 0, 0]
orange: [0, 0, 0, 1, 0, 0]
banana: [0, 0, 0, 0, 0, 1]
grape: [0, 0, 0, 0, 1, 0]
pineapple: [0, 0, 1, 0, 0, 0]
lemon: [1, 0, 0, 0, 0, 0]

然而，one-hot 编码技术易于理解，在 NLP 中进行单词表示时不需要大量计算能力，但它存在几个缺点，这些缺点可能导致它在多种应用中受到限制。

One-hot 编码会创建密集向量，由于创建的向量非常大，它们还会消耗大量 CPU 时间和内存，尤其是在使用的单词词汇量非常大的情况下。它们也不会定义单词之间的语义接近度，因为每个单词都被空格分隔，并且它的出现不取决于单词的语义含义。此外，它只能在已经训练过的词汇表上运行，因此无法处理新的、词汇表外的单词。

1.2. 词袋模型 (BoW)

词袋模型 (BoW) 机制将文档建模为一组非结构化的单词及其频率。与传统的文本检查不同，它不考虑单词或短语的位置，而是基于单词在文档中的频率进行向量化。

代码

from sklearn.feature_extraction.text import CountVectorizer

documents = [
    "Machine learning is fascinating.",
    "Artificial intelligence and machine learning are closely related.",
    "Deep learning is a subset of machine learning.",
    "The future of AI is exciting."
]

vectorizer = CountVectorizer()
X = vectorizer.fit_transform(documents)
feature_names = vectorizer.get_feature_names_out()

print("Bag-of-Words Matrix:")
print(X.toarray())
print("Vocabulary (Feature Names):", feature_names)

输出

Bag-of-Words Matrix:
[[0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0]
 [0 1 1 1 1 0 0 0 0 1 0 1 1 0 1 0 0]
 [0 0 0 0 0 1 0 0 0 0 1 2 1 1 0 1 0]
 [1 0 0 0 0 0 1 0 1 0 1 0 0 1 0 0 1]]
Vocabulary (Feature Names): ['ai' 'and' 'are' 'artificial' 'closely' 'deep' 'exciting' 'fascinating'
 'future' 'intelligence' 'is' 'learning' 'machine' 'of' 'related' 'subset'
 'the']

在此示例中，Scikit-Learn 的 CountVectorizer 类为文档集合创建 BoW 矩阵。矩阵的行是单个文档，列是相应的向量——该向量由整数值组成，每个值是语料库词汇表中唯一术语的出现次数。词汇表选项卡包含在语料库文档中识别出的不同单词。

虽然词袋模型 (BoW) 提供了一种简单易懂的文本表示方法，但它存在一些限制，降低了其捕捉某些语言和语义细节的有效性。

BoW 会丢弃单词在文档中的位置，因此它无法考虑顺序信息。这增加了它在单词顺序无关紧要的应用（如自然语言理解）中的优势。

一个缺点是 BoW 表示在向量中有许多零，因此即零，它有助于增加内存使用和内插，尤其是在处理大数据时。

1.3. 下一种技术是词频-逆文档频率 (TF-IDF)。

词频-逆文档频率 (TF-IDF) 是一种数值统计，用于量化文档中单词相对于语料库的重要性。TF-IDF 应用于 NL 处理和 IR，用于衡量一个词在文档集中的特定文档内的重要性。它包含两个组成部分

词频 (TF)：此度量标准用于衡量文档中术语的重复性，其计算公式为

Word Embedding in Natural Language Processing

逆文档频率 (IDF)：它反映了术语在一组文档中的重要性。要计算此值，请使用以下公式

然后通过将 TF 值和 IDF 值相乘来获得文档中术语 t 的 TF-IDF 分数。

TF-IDF(t, d, D) = TF(t, d) * IDF(t, D)

文档中某个术语的 TF-IDF 分数越高，意味着该术语相对于所有其他文档在文档中的相关性最高。这种加权方案尤其用于查找大型文档集中的术语，并且通常用于文本挖掘、信息检索和文档聚类。

要在 Python 中应用 TF-IDF，有一个名为 TfidfVectorizer 的类，位于 scikit-learn 中。我提供了一个示例，首先构建一组测试文档。使用 TfidfVectorizer 从这些文档创建 TF-IDF 向量，然后打印每个文档的术语的 tf IDF。此指标允许在信息检索和文本分析等更通用的任务中比较单词相对于整个文档集在文档内的相对重要性。

代码

from sklearn.feature_extraction.text import TfidfVectorizer

# New sample documents
documents = [
    "Quantum computing utilizes quantum-mechanical phenomena, such as superposition and entanglement.",
    "Machine learning models have revolutionized many fields, from healthcare to finance."
    "The future of artificial intelligence lies in developing more general and adaptable systems."
]

vectorizer = TfidfVectorizer()  # Create the TF-IDF vectorizer
tfidf_matrix = vectorizer.fit_transform(documents)
feature_names = vectorizer.get_feature_names_out()
tfidf_values = {}

for doc_index, doc in enumerate(documents):
    feature_index = tfidf_matrix[doc_index, :].nonzero()[1]
    tfidf_doc_values = zip(feature_index, [tfidf_matrix[doc_index, x] for x in feature_index])
    tfidf_values[doc_index] = {feature_names[i]: value for i, value in tfidf_doc_values}

# Print results
for doc_index, values in tfidf_values.items():
    print(f"Document {doc_index + 1}:")
    for word, tfidf_value in values.items():
        print(f"{word}: {tfidf_value:.4f}")
    print("\n")

输出

Document 1:
quantum: 0.5639
computing: 0.2820
utilizes: 0.2820
mechanical: 0.2820
phenomena: 0.2820
such: 0.2820
as: 0.2820
superposition: 0.2820
and: 0.2144
entanglement: 0.2820

Document 2:
machine: 0.3015
learning: 0.3015
models: 0.3015
have: 0.3015
revolutionized: 0.3015
many: 0.3015
fields: 0.3015
from: 0.3015
healthcare: 0.3015
to: 0.3015
finance: 0.3015

Document 3:
and: 0.2144
the: 0.2820
future: 0.2820
of: 0.2820
artificial: 0.2820
intelligence: 0.2820
lies: 0.2820
in: 0.2820
developing: 0.2820
more: 0.2820
general: 0.2820
adaptable: 0.2820
systems: 0.2820

说明

此示例展示了文档中单词的 TF-IDF 值，表明公司治理是相关的。每个单词的分数在仅在该特定文档中出现的单词处较高，从而指出了其在语料库上下文中的特异性。

虽然 TF-IDF 是文本挖掘和信息检索中特征提取的有效技术，但它也有一些明显的局限性，这些局限性会影响其在某些应用中的有效性。

缺乏语义上下文： TF-IDF 也不考虑单词之间的交互，因此不考虑单词的上下文含义。因此，它只能处理具体单词，并且不太理解短语或关键词的关联，这对于涉及二次语言理解任务至关重要。
偏向较长文档： 但较长文档中高词频的问题在于 TF-IDF 可能会突出使用这些术语或产生可能产生误导的结果。当由于重复术语的得分膨胀而导致文档长度差异时，这可能会降低匹配两个文档的精度。

尽管存在这些限制，TF-IDF 的应用可能最适用于围绕关键词识别或第一阶段文档筛选的任务，在这些任务中，更具上下文感知的方法（例如，通过词嵌入或 Transformer 模型）可能竞争力较弱。

2. 神经网络方法

2.1. Word2Vec

Word2Vec 是一种强大的神经网络方法，用于创建词表示，是 NLP 中更广泛的分布式表示方法的一部分。Word2Vec 由 Google 的一个团队开发，该算法旨在将单词映射到一个大而密集向量，从而保留语义关系，其中意思最相近的单词将具有相近的向量。这是通过任意地或借助 one-hot 编码为每个单词分配一个初始向量来完成的。

Word2Vec 采用两种主要架构来创建这些嵌入：

2.2. 连续词袋模型 (CBOW)

CBOW 模型旨在通过给定词袋中存在的目标词附近的上下文词来预测目标词。在此架构中，一系列单词占据输入位置，模型需要识别出现在特定上下文窗口中心的目标词。

CBOW 的主要特点

架构：CBOW 只是一个单隐藏层的单向神经网络模型。
输入层：在输入层，表示上下文单词，即给定窗口内的单词组合。
输出层：ann 的最终层表示系统正在学习识别的预期单词。
隐藏层：此层包含输入单词的已学习的密集实值向量表示（词嵌入）。
学习过程：在训练期间，学习输入层和隐藏层之间的权重，以向量形式表示单词。这意味着隐藏层中的节点数量决定了生成的嵌入的维度。
CBOW 方法能够学习用于词语目标实现和借助上下文细节预测语言模式的综合向量。

总而言之，Word2Vec 以及本文中介绍的 CBOW 模型是理解 NLP 上下文中单词含义和交互的重要贡献，并对 one-hot 编码、词袋模型编码技术进行了改进。

代码

import torch
import torch.nn as nn
import torch.optim as optim

# Define CBOW model
class CBOWModel(nn.Module):
    def __init__(self, vocab_size, embed_size):
        super(CBOWModel, self).__init__()
        self.embeddings = nn.Embedding(vocab_size, embed_size)
        self.linear = nn.Linear(embed_size, vocab_size)

    def forward(self, context):
        # Sum embeddings of context words and pass through linear layer
        context_embeds = self.embeddings(context).sum(dim=0)
        output = self.linear(context_embeds)
        return output

# New sample data
context_size = 2
raw_text = "artificial intelligence and machine learning are transforming industries"
tokens = raw_text.split()
vocab = set(tokens)
word_to_index = {word: i for i, word in enumerate(vocab)}

# Prepare context-target pairs for CBOW
data = []
for i in range(context_size, len(tokens) - context_size):
    context = [word_to_index[word] for word in tokens[i - context_size:i] + tokens[i + 1:i + 1 + context_size]]
    target = word_to_index[tokens[i]]
    data.append((torch.tensor(context), torch.tensor(target)))

# Hyperparameters
vocab_size = len(vocab)
embed_size = 8
learning_rate = 0.01
epochs = 50

# Initialize CBOW model
cbow_model = CBOWModel(vocab_size, embed_size)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(cbow_model.parameters(), lr=learning_rate)

# Training loop
for epoch in range(epochs):
    total_loss = 0
    for context, target in data:
        optimizer.zero_grad()
        output = cbow_model(context)
        loss = criterion(output.view(1, -1), target.view(1))
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch + 1}, Loss: {total_loss:.4f}")

# Example usage: Retrieve embedding for a specific word
word_to_lookup = "machine"
word_index = word_to_index[word_to_lookup]
embedding = cbow_model.embeddings(torch.tensor([word_index]))
print(f"Embedding for '{word_to_lookup}': {embedding.detach().numpy()}")

输出

Epoch 1, Loss: 8.8481
Epoch 2, Loss: 7.7283
Epoch 3, Loss: 6.7079……
Epoch 50, Loss: 0.5212
Embedding for 'machine': [[-0.50693065  0.19692205 -1.0433725   1.3049619  -0.62078935  1.215356
   0.555439   -0.2226701 ]]

2.3. Skip-Gram

Skip-Gram 模型旨在学习密集连续词空间中的实用分布式词嵌入。它的主要功能是猜测特定目标词周围的上下文词，这与 CBOW 模型相反，CBOW 模型的工作是根据目标词周围的上下文词来猜测特定目标词。研究表明，Skip-Gram 倾向于产生更具语义意义的嵌入。

在使用了这些神经网络嵌入方法之后，每个单词在通过语料库进行多次传递后都会得到一个训练过的向量。这些向量仍然保留句法或语义关系，并嵌入到低维空间中。在这个空间中，语义上相关或某种意义上的同义词会彼此靠近。

例如，让我们用一个简单的例子来理解它。在以下 Python 代码中需要的另一个附加参数是 vector_size，它规定了词向量的维度。另一方面，对于计算机系统来说不重要或不基本的其他参数，可以根据定义的需要进行更改，例如窗口。

代码

!pip install gensim
from gensim.models import Word2Vec
from nltk.tokenize import word_tokenize
import nltk
nltk.download('punkt') # Download the tokenizer models if not already downloaded

sample = "Word embeddings are dense vector representations of words."
tokenized_corpus = word_tokenize(sample.lower()) # Lowercasing for consistency

skipgram_model = Word2Vec(sentences=[tokenized_corpus],
            vector_size=100, # Dimensionality of the word vectors
            window=5,    # Maximum distance between the current and predicted word within a sentence
            sg=1,      # Skip-Gram model (1 for Skip-Gram, 0 for CBOW)
            min_count=1,   # Ignores all words with a total frequency lower than this
            workers=4)   # Number of CPU cores to use for training the model

# Training
skipgram_model.train([tokenized_corpus], total_examples=1, epochs=10)
skipgram_model.save("skipgram_model.model")
loaded_model = Word2Vec.load("skipgram_model.model")
vector_representation = loaded_model.wv['word']
print("Vector representation of 'word':", vector_representation)

输出

Vector representation of 'word': [-9.5800208e-03  8.9437785e-03  4.1664648e-03  9.2367809e-03
  6.6457358e-03  2.9233587e-03  9.8055992e-03 -4.4231843e-03
 -6.8048164e-03  4.2256550e-03  3.7299085e-03 -5.6668529e-03
  9.7035142e-03 -3.5551414e-03  9.5499391e-03  8.3657773e-04
 -6.3355025e-03 -1.9741615e-03 -7.3781307e-03 -2.9811086e-03
  1.0425397e-03  9.4814906e-03  9.3598543e-03 -6.5986011e-03
  3.4773252e-03  2.2767992e-03 -2.4910474e-03 -9.2290826e-03
  1.0267317e-03 -8.1645092e-03  6.3240929e-03 -5.8001447e-03
  5.5353874e-03  9.8330071e-03 -1.5987856e-04  4.5296676e-03
 -1.8086446e-03  7.3613892e-03  3.9419360e-03 -9.0095028e-03
 -2.3953868e-03  3.6261671e-03 -1.0080514e-04 -1.2024897e-03
 -1.0558038e-03 -1.6681013e-03  6.0541567e-04  4.1633579e-03
 -4.2531900e-03 -3.8336846e-03 -5.0755290e-05  2.6549282e-04
 -1.7014991e-04 -4.7843382e-03  4.3120929e-03 -2.1710952e-03
  2.1056964e-03  6.6702347e-04  5.9686624e-03 -6.8418151e-03
 -6.8183104e-03 -4.4762432e-03  9.4359247e-03 -1.5930856e-03
 -9.4291316e-03 -5.4270827e-04 -4.4478951e-03  5.9980620e-03
 -9.5831212e-03  2.8602476e-03 -9.2544509e-03  1.2484600e-03
  6.0004774e-03  7.4001122e-03 -7.6209377e-03 -6.0561695e-03
 -6.8399287e-03 -7.9184016e-03 -9.4984965e-03 -2.1255787e-03
 -8.3757477e-04 -7.2564054e-03  6.7876028e-03  1.1183097e-03
  5.8291717e-03  1.4714618e-03  7.9081533e-04 -7.3718326e-03
 -2.1769912e-03  4.3199472e-03 -5.0856168e-03  1.1304744e-03
  2.8835384e-03 -1.5386029e-03  9.9318363e-03  8.3507905e-03
  2.4184163e-03  7.1170190e-03  5.8888551e-03 -5.5787875e-03]

事实上，选择 CBOW 还是 Skip-gram 模型取决于数据集的特性和具体任务。CBOW 通常用于计算资源量是问题，并且主要关注语法关系。这就是 Skip-gram 更适用于捕获语义上下文或正确表示稀有词语的任务。

3. 预训练词嵌入

词向量是可训练的词向量，它们在大量文本上进行训练，并用于未来在各种 NLP 问题中的使用。这些嵌入捕获语义词关系，从而使模型能够与词语关联产生有意义的相似性。

3.1 GloVe

GloVe (Global Vectors for Word Representation) 也采用全局出现测量来开发词向量。利用这种上下文，GloVe 通过开发基于共现概率的嵌入来提供单词的“大局”。这些是通过一个过程生成的，该过程遍历语料库以编译一个共现矩阵，其中每个单词都有其对应的其他相关单词。当两个单词相邻时，两个单词物理出现相关联的值为 1。如果它们仅相隔一个单词，则它们各自得到 ½；相隔两个单词，则得到 ⅓；依此类推。

语料库示例

让我们看这个小语料库

“Rain is coming.”
“Is it raining?”

此语料库的共现矩阵可能如下所示

	rain	is	coming	it	raining
rain	0	1	0.5	0	0.5
is	1	0	1	0.5	0.5
coming	0.5	1	0	0	0
it	0	0.5	0	0	1
raining	0.5	0.5	0	1	0

如前所述，在共现矩阵的极端对角线上，前半部分对应于后半部分。通过在语料库中滑动，我们可以找到共现。每当遇到一个新识别的单词时，前一个窗口的频率计数会与新单词相加，然后窗口向前移动一个位置。这有助于捕获某些单词使用的上下文以及它们与其他单词的相关程度。

首先，在 ALS 模型中随机设置词向量以进行初始化。在训练中，会根据向量空间中的距离检查一对意义向量。换句话说，如果两个单词在共现矩阵中的共现分数很高，则会减少移动两个单词向量远离彼此的距离。另一方面，如果两个单词在向量空间中彼此靠近，但很少一起出现，则它们的向量会远离。

许多这样的周期会产生词向量，因此，最终的向量空间表示是从共现矩阵获得的。与 Word2Vec 相比，GloVe 在保留多个语义和句法相关词方面具有更优越的结果。

代码

from gensim.models import KeyedVectors
from gensim.downloader import load

glove_model = load('glove-wiki-gigaword-50')
word_pairs = [('happy', 'joyful'), ('cat', 'kitten'), ('bright', 'shine')]

# Compute similarity for each pair of words
for pair in word_pairs:
    similarity = glove_model.similarity(pair[0], pair[1])
    print(f"Similarity between '{pair[0]}' and '{pair[1]}' using GloVe: {similarity:.3f}")

输出

[==================================================] 100.0% 66.0/66.0MB downloaded
Similarity between 'happy' and 'joyful' using GloVe: 0.555
Similarity between 'cat' and 'kitten' using GloVe: 0.639
Similarity between 'bright' and 'shine' using GloVe: 0.679

3.2. FastText

FastText 是 Word2Vec 的改进，由 Facebook 的代表发明，其中每个单词都是一个字符 n-gram 的集合。这使得该系统能够区分具有相关根的近义词以及词汇表外的单词。

代码

import gensim.downloader as api
fasttext_model = api.load("fasttext-wiki-news-subwords-300")  # Load the pre-trained fastText model

# Define new word pairs to compute similarity for
word_pairs = [('happy', 'joyful'), ('cat', 'kitten'), ('bright', 'shine')]

# Compute similarity for each pair of words
for pair in word_pairs:
    similarity = fasttext_model.similarity(pair[0], pair[1])
    print(f"Similarity between '{pair[0]}' and '{pair[1]}' using FastText: {similarity:.3f}")

输出

[==================================================] 100.0% 958.5/958.4MB downloaded
Similarity between 'happy' and 'joyful' using FastText: 0.713
Similarity between 'cat' and 'kitten' using FastText: 0.748
Similarity between 'bright' and 'shine' using FastText: 0.589

这些值是从 FastText 嵌入计算出来的，分数越接近 1，两个单词的相似度就越高。

3.3. BERT 是 Bidirectional Encoders Representations from Transformers 的缩写。

BERT 是一个 Transformer 模型，它涉及自注意力机制，以学习关注单词的左右上下文特征的上下文表示，从而产生单词在其上下文中的精确含义。

代码

from transformers import BertTokenizer, BertModel
import torch

# Load pre-trained BERT model and tokenizer
model_name = 'bert-base-uncased'
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertModel.from_pretrained(model_name)

word_pairs = [('learn', 'learning'), ('india', 'indian'), ('fame', 'famous')]

# Compute similarity for each pair of words
for pair in word_pairs:
  tokens = tokenizer(pair, return_tensors='pt')
  with torch.no_grad():
    outputs = model(**tokens)
  
  # Extract embeddings for the [CLS] token
  cls_embedding = outputs.last_hidden_state[:, 0, :]

  similarity = torch.nn.functional.cosine_similarity(cls_embedding[0], cls_embedding[1], dim=0)
  
  print(f"Similarity between '{pair[0]}' and '{pair[1]}' using BERT: {similarity:.3f}")

输出

Similarity between 'learn' and 'learning' using BERT: 0.930
Similarity between 'india' and 'indian' using BERT: 0.957
Similarity between 'fame' and 'famous' using BERT: 0.956

BERT 的相似度得分通常较高，这表明 BERT 能够掌握和分析上下文关系。此输出还表明，BERT 在处理单词的语义关系方面非常有效，尤其是在处理相关单词时。

应用词嵌入模型时要考虑的因素

确实，要实施我们选择的词嵌入模型，重要的是要采用与准备训练数据时相同的管道。标记化或空格、标点符号等处理方式的微小变化都可能导致不兼容的输入。

输入中任何没有预训练词嵌入向量的单词都被描述为词汇表外 (OOV) 单词。这些通常被替换为“UNK”（未知）标记，以便单独处理。

另一个风险是维度不匹配。向量已被描述为具有不同的长度，并且当模型在长度为 400 的向量上进行训练时，如果将其应用于长度为 1000 的向量，它会报错。如果向量的维度未保持相同，则在训练和部署中可能会出现此问题。

下一主题数据科学与机器学习编码的区别

自然语言处理中的词嵌入

NLP 中的词嵌入是什么？

为什么需要词嵌入？

词嵌入如何使用？

文本表示技术

1. 传统方法

2. 神经网络方法

3. 预训练词嵌入

应用词嵌入模型时要考虑的因素

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

机器学习

监督式学习

分类

杂项

相关教程

面试题

自然语言处理中的词嵌入

NLP 中的词嵌入是什么？

为什么需要词嵌入？

词嵌入如何使用？

文本表示技术

1. 传统方法

2. 神经网络方法

3. 预训练词嵌入

应用词嵌入模型时要考虑的因素

相关帖子

过拟合与欠拟合

Transformer 注意力机制

使用 ColumnTransformer 和 OneHotEncoder 进行预测

Facebook Prophet

机器学习中的 5 种概率训练数据抽样方法

如何开始学习机器学习

机器学习如何工作

K-Means 聚类算法

概率密度函数

如何在决策树中避免过拟合

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器