LLM架构从基础到精通之词向量2

关注

原创 2025-01-08 08:08:21 825 阅读 AI 写同款· GEO 优化 ›

深度学习之词向量 一、词向量 自上世纪90年代开始，特征空间模型就应用于分布式语言理解中，在当时许多模型用连续性的表征来表示词语，包括潜在语义分析LSA、隐含狄利克雷分布LDA主题模型。Bengio et al.在2003年首先提出了词向量的概念，当时是将其与语言模型的参数一并训练得到的。Collobert和Weston则第一次正式使用预训练的词向量，不仅将词向量方法作为处理下游任务的有效工具，还引入了神经网络模... 阅读详情

自然语言处理中的词嵌入技术全解析

在自然语言处理的奇妙世界里，词嵌入技术是一座关键的桥梁，连接着文本与机器可理解的语义表达。此前我们探讨了词嵌入的基础概念，现在让我们深入到具体的技术细节中，从 3.1.4 N-Grams 开始，一步步揭开这些技术的神秘面纱。

3.1.4 N-Grams

N-grams 是在文本分析中可作为一个单元共同使用的单词序列。像 “Mary had a little lamb” 这句话中，“Mary had”、“had a”、“a little” 和 “little lamb” 等都是二元组（N = 2）。然而，许多 N-grams 在数据中可能出现频率过低，导致其表示稀疏且意义有限。

它主要有以下几种类型：

Unigram：即单个单词。
Bigram：由两个单词组成的对。
Trigram：三个单词构成的序列。

其重要性在于能够捕捉文本中的上下文和单词之间的依赖关系。

以下是一段 Python 示例代码，展示如何生成和分析 N-grams：

import nltk
from nltk.util import ngrams
from collections import Counter

text = "The quick brown fox jumps over the lazy dog"
tokens = nltk.word_tokenize(text)
unigrams = list(ngrams(tokens, 1))
print("Unigrams:")
print(unigrams)
bigrams = list(ngrams(tokens, 2))
print("\nBigrams:")
print(bigrams)
trigrams = list(ngrams(tokens, 3))
print("\nTrigrams:")
print(trigrams)

unigram_freq = Counter(unigrams)
bigram_freq = Counter(bigrams)
trigram_freq = Counter(trigrams)

print("\nUnigram Frequencies:")
print(unigram_freq)
print("\nBigram Frequencies:")
print(bigram_freq)
print("\nTrigram Frequencies:")
print(trigram_freq)

输出结果如下：

Unigrams:
[('The',), ('quick',), ('brown',), ('fox',), ('jumps',), ('over',), ('the',), ('lazy',), ('dog',)]
Bigrams:
[('The', 'quick'), ('quick', 'brown'), ('brown', 'fox'), ('fox', 'jumps'), ('jumps', 'over'), ('over', 'the'), ('the', 'lazy'), ('lazy', 'dog')]
Trigrams:
[('The', 'quick', 'brown'), ('quick', 'brown', 'fox'), ('brown', 'fox', 'jumps'), ('fox', 'jumps', 'over'), ('jumps', 'over', 'the'), ('over', 'the', 'lazy'), ('the', 'lazy', 'dog')]
Unigram Frequencies:
Counter({('The',): 1, ('quick',): 1, ('brown',): 1, ('fox',): 1, ('jumps',): 1, ('over',): 1, ('the',): 1, ('lazy',): 1, ('dog',): 1})
Bigram Frequencies:
Counter({('The', 'quick'): 1, ('quick', 'brown'): 1, ('brown', 'fox'): 1, ('fox', 'jumps'): 1, ('jumps', 'over'): 1, ('over', 'the'): 1, ('the', 'lazy'): 1, ('lazy', 'dog'): 1})
Trigram Frequencies:
Counter({('The', 'quick', 'brown'): 1, ('quick', 'brown', 'fox'): 1, ('brown', 'fox', 'jumps'): 1, ('fox', 'jumps', 'over'): 1, ('jumps', 'over', 'the'): 1, ('over', 'the', 'lazy'): 1, ('the', 'lazy', 'dog'): 1})

尽管 N-grams 有一定的作用，但也存在一些局限性：

高维度和稀疏性：会产生大量的 N-grams 组合，导致向量空间维度极高且非常稀疏，增加了计算和存储的负担。
缺乏语义理解：仅仅基于单词的连续组合，难以深入理解单词之间的语义关系。
忽略上下文：不能很好地捕捉长距离的上下文信息，对文本的整体语义把握有限。
可扩展性问题：随着文本数据量的增加，N-grams 的数量会迅速增长，使得处理变得困难。
对噪声和罕见词敏感：容易受到数据中的噪声影响，并且在处理罕见词时效果不佳。
难以捕捉多义词和同义词：不能有效区分具有相同或相似含义的单词，以及一个单词的不同含义。
无法跨语言通用：在不同语言中，N-grams 的组合和语义关系差异较大，难以直接应用。
难以捕捉长时依赖：对于文本中较长距离的单词依赖关系，N-grams 难以有效捕捉。

3.1.5 共现矩阵（Co-occurrence Matrices）

共现矩阵用于捕捉在给定的上下文窗口中单词共同出现的频率。它量化了单词之间的统计关系，为生成词嵌入提供了基础。

例如，假设有一个包含以下三个文档的语料库：

文档 1：“The quick brown fox jumps over the lazy dog.”
文档 2：“The brown dog barks loudly.”
文档 3：“The lazy cat sleeps peacefully.”

我们想基于这些文档构建一个窗口大小为 1 的共现矩阵，这意味着我们考虑每个单词与其紧邻单词的共现情况，同时忽略标点并以不区分大小写的方式处理单词。

首先，根据语料库中的唯一单词构建词汇表：
Vocabulary: [the, quick, brown, fox, jumps, over, lazy, dog, barks, loudly, cat, sleeps, peacefully]

然后创建共现矩阵，其中行和列代表词汇表中的单词。矩阵中每个单元格 (i, j) 的值表示单词 i 在指定窗口大小内与单词 j 共现的次数。

the  quick  brown  fox  jumps  over  lazy  dog  barks  loudly  cat  sleeps peacefully
the         0      1      1    0      0     0     1    1      0       0     1       1         1
quick       1      0      0    1      0     0     0    0      0       0     0       0         0
brown       1      0      0    0      0     0     0    1      1       0     0       0         0
fox         0      1      0    0      1     0     0    0      0       0     0       0         0
jumps       0      0      0    1      0     1     0    0      0       0     0       0         0
over        0      0      0    0      1     0     1    0      0       0     0       0         0
lazy        1      0      0    0      0     1     0    1      0       0     1       0         0
dog         1      0      1    0      0     0     1    0      1       1     0       0         0
barks       0      0      1    0      0     0     0    1      0       1     0       0         0
loudly      0      0      0    0      0     0     0    1      1       0     0       0         0
cat         1      0      0    0      0     0     1    0      0       0     0       1         1
sleeps      1      0      0    0      0     0     0    0      0       0     1       0         1
peacefully  1      0      0    0      0     0     0    0      0       0     1       1         0

这个共现矩阵捕捉了在窗口大小为 1 的情况下每个单词与其他单词的共现频率。例如，“the” 行和 “lazy” 列的条目值为 1，表示在整个语料库中，“lazy” 与 “the” 在指定窗口内共现了一次。

在自然语言处理中，共现矩阵的一个主要应用是生成词嵌入。通过分析语料库中单词的共现模式，共现矩阵可以捕捉每个单词周围的上下文信息。像 Word2Vec 和 GloVe 等技术利用这些矩阵创建密集、低维的单词向量表示，其中向量之间的几何关系反映了单词之间的语义相似性，从而实现单词相似性的测量、类比检测和语义搜索等任务。

以下是一段 Python 示例代码，展示如何构建和处理共现矩阵：

import numpy as np
import pandas as pd
from collections import Counter
from sklearn.preprocessing import normalize

corpus = [
    "I love machine learning",
    "machine learning is great",
    "I love deep learning",
    "deep learning and machine learning are related"
]
corpus = [sentence.lower().split() for sentence in corpus]
vocab = set([word for sentence in corpus for word in sentence])
vocab = sorted(vocab)
vocab_size = len(vocab)
co_occurrence_matrix = np.zeros((vocab_size, vocab_size))
window_size = 2
word2idx = {word: i for i, word in enumerate(vocab)}

for sentence in corpus:
    for i, word in enumerate(sentence):
        word_idx = word2idx[word]
        start = max(0, i - window_size)
        end = min(len(sentence), i + window_size + 1)
        for j in range(start, end):
            if i!= j:
                context_word = sentence[j]
                context_idx = word2idx[context_word]
                co_occurrence_matrix[word_idx, context_idx] += 1

co_occurrence_df = pd.DataFrame(co_occurrence_matrix, index=vocab, columns=vocab)
co_occurrence_normalized = normalize(co_occurrence_matrix, norm='l1', axis=1)
co_occurrence_normalized_df = pd.DataFrame(co_occurrence_normalized, index=vocab, columns=vocab)

print("Co-occurrence Matrix:")
print(co_occurrence_df)
print("\nNormalized Co-occurrence Matrix:")
print(co_occurrence_normalized_df)

然而，共现矩阵也存在一些局限性：

高维度导致效率和存储问题：随着词汇量的增加，矩阵的维度会迅速增长，导致计算效率低下和存储需求巨大。
极度稀疏：由于大多数单词对很少共现，矩阵中大部分元素为 0，造成了数据的稀疏性。
捕捉深层语义关系的能力有限：虽然能反映共现频率，但难以深入挖掘单词之间的深层次语义联系。
上下文独立性：不能区分同一个单词在不同上下文中的不同含义。
对大型语料库的可扩展性挑战：矩阵大小随词汇量呈二次增长，在处理大规模语料库时面临巨大挑战。
对频繁词的偏向：频繁出现的单词在矩阵中的权重较大，对罕见词或短语的表示不可靠。
表达能力有限：无法捕捉复杂的语言结构和语义关系。
噪声数据：由于存在停用词和无意义的单词对，会引入噪声数据。

3.1.6 独热编码（One-Hot Encoding）

独热编码是自然语言处理中表示单词的一种基本方法。词汇表中的每个单词都被表示为一个独特的向量，除了对应单词索引位置的元素为 1 外，其他所有元素都设置为 0。

例如，假设有一个包含 10,000 个单词的词汇表，对于单词 “aardvark”，其向量表示为 [1, 0, 0, 0, …, 0]，即在第一个位置为 1，后面跟着 9,999 个 0；对于单词 “ant”，其向量表示为 [0, 1, 0, 0, …, 0]，即在第二个位置为 1，其余位置为 0，以此类推。这个过程就称为独热向量编码，它也常用于多类分类问题中表示标签。

假设我们正在构建一个自然语言处理项目中的翻译模型，需要将英文句子 “the cat is black” 翻译成另一种语言。首先要对每个单词进行独热编码。查找第一个单词 “the” 在 10,000 长的词汇表中的索引，假设其索引为 8676，那么 “the” 就可以用一个长度为 10,000 的向量表示，其中除了第 8676 个位置为 1 外，其他位置均为 0。对输入句子中的每个单词都进行这样的索引查找，并创建向量来表示每个输入单词。

以下是一段 Python 示例代码，展示如何实现独热编码：

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

example_text = "cat in the hat dog on the mat bird in the tree"
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: {'mat', 'the', 'bird', 'hat', 'on', 'in', 'cat', 'tree', 'dog'}
Word to Index Mapping: {'mat': 0, 'the': 1, 'bird': 2, 'hat': 3, 'on': 4, 'in': 5, 'cat': 6, 'tree': 7, 'dog': 8}
One-Hot Encoded Matrix:
cat: [0, 0, 0, 0, 0, 0, 1, 0, 0]
in: [0, 0, 0, 0, 0, 1, 0, 0, 0]
the: [0, 1, 0, 0, 0, 0, 0, 0, 0]
hat: [0, 0, 0, 1, 0, 0, 0, 0, 0]
dog: [0, 0, 0, 0, 0, 0, 0, 0, 1]
on: [0, 0, 0, 0, 1, 0, 0, 0, 0]
the: [0, 1, 0, 0, 0, 0, 0, 0, 0]
mat: [1, 0, 0, 0, 0, 0, 0, 0, 0]
bird: [0, 0, 1, 0, 0, 0, 0, 0, 0]
in: [0, 0, 0, 0, 0, 1, 0, 0, 0]
the: [0, 1, 0, 0, 0, 0, 0, 0, 0]
tree: [0, 0, 0, 0, 0, 0, 0, 1, 0]

虽然独热编码能够将单词表示为实数值向量，但也存在一些问题：

缺乏语义相似性：无法捕捉单词之间的语义关系。例如，“cat” 和 “tiger” 被表示为完全不同的向量，没有体现出它们的相似性，这对于基于类比的向量操作等任务来说是个很大的问题。
高维度：独热向量的维度与词汇表大小呈线性增长。随着词汇量的增加，特征向量会变得非常大，加剧了维度灾难。这不仅增加了需要估计的参数数量，还需要指数级更多的数据来训练一个泛化良好的模型。
计算效率低下：独热编码向量是稀疏且高维的，大部分元素为 0。许多机器学习模型，尤其是神经网络，在处理这种稀疏数据时会遇到困难。庞大的特征空间也会导致内存和存储方面的挑战，特别是当模型不能有效地处理稀疏矩阵时。

后续我们将继续探讨如何解决这些问题，以及其他更先进的词嵌入技术，敬请期待！

希望这篇文章能帮助到大家。

收录于