讲透Transformer(二):深入解析Embedding

nudt_qxx2026-02-23 11:49

深入解析Embedding: 词嵌入 vs 上下文嵌入

  • [什么是 Embedding？](#什么是 Embedding？)
    • [1.1 Embedding 的基本概念](#1.1 Embedding 的基本概念)
    • [1.2 为什么需要 Embedding](#1.2 为什么需要 Embedding)
    • [1.3 Embedding 的数学本质](#1.3 Embedding 的数学本质)
  • [词嵌入 (Word Embedding) - 静态嵌入](#词嵌入 (Word Embedding) - 静态嵌入)
    • [2.1 什么是词嵌入](#2.1 什么是词嵌入)
    • [2.2 实现方式](#2.2 实现方式)
    • [2.3 经典词嵌入方法](#2.3 经典词嵌入方法)
  • [上下文嵌入 (Contextual Embedding) - 动态嵌入](#上下文嵌入 (Contextual Embedding) - 动态嵌入)
    • [3.1 什么是上下文嵌入](#3.1 什么是上下文嵌入)
    • [3.2 实现方式](#3.2 实现方式)
    • [3.3 "bank" 的上下文嵌入示例](#3.3 "bank" 的上下文嵌入示例)
  • [词嵌入 vs 上下文嵌入：核心区别](#词嵌入 vs 上下文嵌入：核心区别)
    • [4.1 对比表格](#4.1 对比表格)
    • [4.2 可视化对比](#4.2 可视化对比)
  • [Transformer 中的嵌入流程](#Transformer 中的嵌入流程)
    • [5.1 完整流程图](#5.1 完整流程图)
    • [5.2 各层输出维度变化](#5.2 各层输出维度变化)
  • [常见 Embedding 模型汇总](#常见 Embedding 模型汇总)
    • [6.1 按类型分类](#6.1 按类型分类)
    • [6.2 静态词嵌入模型对比](#6.2 静态词嵌入模型对比)
    • [6.3 上下文嵌入模型对比](#6.3 上下文嵌入模型对比)
    • [6.4 大语言模型嵌入对比](#6.4 大语言模型嵌入对比)
    • [6.5 其他领域嵌入模型](#6.5 其他领域嵌入模型)
  • 不同模型的嵌入策略
    • [7.1 模型对比](#7.1 模型对比)
    • [7.2 代码对比](#7.2 代码对比)
  • [Embedding 的评估指标](#Embedding 的评估指标)
    • [8.1 词嵌入评估](#8.1 词嵌入评估)
    • [8.2 上下文嵌入评估](#8.2 上下文嵌入评估)
  • [Embedding 的可视化](#Embedding 的可视化)
    • [9.1 t-SNE 降维可视化](#9.1 t-SNE 降维可视化)
    • [9.2 语义空间性质](#9.2 语义空间性质)
  • 总结
    • [10.1 核心要点](#10.1 核心要点)
    • [10.2 简单记忆](#10.2 简单记忆)

Embedding确实是理解 Transformer 架构的关键基础，需要各位读者详细掌握！让我详细解释两者的区别和实现方式。

什么是 Embedding？

1.1 Embedding 的基本概念

Embedding（嵌入） 是将离散的符号（如单词、物品、用户）映射到连续向量空间的技术。它的核心思想是：让语义相似的实体在向量空间中也彼此接近。

Embedding : 离散符号 → R d \text{Embedding}: \text{离散符号} \rightarrow \mathbb{R}^d Embedding:离散符号→Rd

其中 d d d 是嵌入维度（通常 128、256、512、768、1024 等）。

直观理解：

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                      Embedding 的本质                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  现实世界            →         数学世界                      │
│  ───────────────                ───────────────             │
│  "猫"                          [0.23, -0.45, 0.67, ...]    │
│  "狗"                          [0.21, -0.42, 0.65, ...]    │
│  "苹果"                        [0.89, 0.12, -0.34, ...]    │
│                                                             │
│  语义相似 → 向量相似                                         │
│  cos("猫", "狗") ≈ 0.9  (高相似度)                          │
│  cos("猫", "苹果") ≈ 0.1  (低相似度)                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

1.2 为什么需要 Embedding

问题：计算机只能处理数值，无法直接处理离散符号。

表示方法 示例 问题
字符串 "cat" 无法计算相似度
One-hot [0,0,1,0,...] 维度灾难、无法表示语义关系
Embedding [0.23, -0.45, 0.67] ✅ 低维、✅ 可计算相似度、✅ 捕捉语义

One-hot 编码的局限：

假设词汇表大小 ∣ V ∣ = 10000 |V| = 10000 ∣V∣=10000：

复制代码 
"猫" → [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, ...]  (10000 维)
"狗" → [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0, ...]  (10000 维)

cos("猫", "狗") = 0  (所有 one-hot 向量都正交，无法表示相似关系)

Embedding 的优势：

复制代码 
"猫" → [0.23, -0.45, 0.67, 0.12, -0.34, 0.56, ...]  (d=512)
"狗" → [0.21, -0.42, 0.65, 0.11, -0.31, 0.52, ...]  (d=512)

cos("猫", "狗") ≈ 0.95  (可以计算语义相似度)

1.3 Embedding 的数学本质

形式化定义 ：Embedding 是一个映射函数 f f f：

f : V → R d f: \mathcal{V} \rightarrow \mathbb{R}^d f:V→Rd

其中 V \mathcal{V} V 是符号集合（词汇表）， R d \mathbb{R}^d Rd 是 d d d 维欧几里得空间。

嵌入矩阵 ：所有符号的嵌入向量堆叠成矩阵 E E E：

E ∈ R ∣ V ∣ × d = [ --- e 1 --- --- e 2 --- ⋮ --- e ∣ V ∣ --- ] E \in \mathbb{R}^{|\mathcal{V}| \times d} = \begin{bmatrix} --- & e_1 & --- \\ --- & e_2 & --- \\ & \vdots & \\ --- & e_{|\mathcal{V}|} & --- \end{bmatrix} E∈R∣V∣×d= ---------e1e2⋮e∣V∣---------

查找操作 ：给定符号索引 i i i，获取其嵌入向量：

embedding ( i ) = E [ i ] ∈ R d \text{embedding}(i) = E[i] \in \mathbb{R}^d embedding(i)=E[i]∈Rd

词嵌入 (Word Embedding) - 静态嵌入

2.1 什么是词嵌入

词嵌入是将离散的词元 (token) 映射到连续向量空间的技术：

Word Embedding : Vocabulary → R d \text{Word Embedding}: \text{Vocabulary} \rightarrow \mathbb{R}^d Word Embedding:Vocabulary→Rd

核心特点：

特性 说明
静态 每个词有固定的向量表示
与上下文无关 "bank" 在任何句子中向量都相同
预训练或随机初始化 可在训练前预训练，也可随机初始化后学习
查找表实现 本质是一个可学习的矩阵

2.2 实现方式

Embedding 层本质是一个查找表：

复制代码 
词汇表 (Vocabulary)
┌─────────────┬───────────────────────────────┐
│   Token ID  │   Embedding Vector (d 维)     │
├─────────────┼───────────────────────────────┤
│     0       │   [0.12, -0.45, 0.78, ...]    │  ← "king"
│     1       │   [0.11, -0.40, 0.75, ...]    │  ← "queen"
│     2       │   [-0.65, 0.23, 0.12, ...]    │  ← "apple"
│    ...      │   ...                         │
│   30522     │   [0.33, -0.12, 0.89, ...]    │  ← "bank"
└─────────────┴───────────────────────────────┘

数学表示：

E ∈ R ∣ V ∣ × d E \in \mathbb{R}^{|V| \times d} E∈R∣V∣×d

  • ∣ V ∣ |V| ∣V∣：词汇表大小 (如 30522, 50257, 100000+)
  • d d d：嵌入维度 (如 512, 768, 1024)

代码实现 (PyTorch)：

python 复制代码 
import torch
import torch.nn as nn

# 定义 Embedding 层
vocab_size = 30522  # 词汇表大小
embed_dim = 512     # 嵌入维度

embedding = nn.Embedding(num_embeddings=vocab_size, 
                         embedding_dim=embed_dim)

# 输入：token IDs [batch_size, seq_len]
input_ids = torch.tensor([[101, 2345, 6789, 102], 
                          [101, 3456, 7890, 102]])  # batch_size=2, seq_len=4

# 输出：embeddings [batch_size, seq_len, embed_dim]
embeddings = embedding(input_ids)  # shape: (2, 4, 512)

底层原理：

Embedding 层本质是矩阵查找：

python 复制代码 
# 方法 1: 直接查找 (高效)
embedding_weight = torch.randn(vocab_size, embed_dim)
token_id = 5
vector = embedding_weight[token_id]  # 直接取第 5 行

# 方法 2: one-hot × 矩阵 (理论等价，但效率低)
one_hot = torch.zeros(vocab_size)
one_hot[token_id] = 1
vector = one_hot @ embedding_weight  # 结果相同

2.3 经典词嵌入方法

方法 年份 特点
Word2Vec 2013 CBOW/Skip-gram，局部上下文
GloVe 2014 全局共现矩阵 + 最小二乘
FastText 2016 考虑子词 (subword) 信息

Word2Vec 示例：

训练语料: "the cat sat on the mat"

Skip-gram 目标: 给定中心词预测上下文

  • 输入: "cat" → 输出: ["the", "sat"]

训练后:

  • "cat" → [0.25, -0.88, 0.13, ...]
  • "dog" → [0.23, -0.85, 0.15, ...] ← 与 cat 接近
  • "mat" → [0.10, 0.45, -0.32, ...] ← 与 cat 较远

上下文嵌入 (Contextual Embedding) - 动态嵌入

3.1 什么是上下文嵌入

上下文嵌入根据词语在句子中的具体语境动态生成向量表示：

ContextualEmbedding : ( Token , Context ) → R d \text{ContextualEmbedding}: (\text{Token}, \text{Context}) \rightarrow \mathbb{R}^d ContextualEmbedding:(Token,Context)→Rd

核心特点：

特性 说明
动态 同一个词在不同句子中向量不同
与上下文相关 "bank" 在"河岸"和"银行"语境中向量不同
通过模型计算 由 Transformer/类 Transformer 架构生成
捕捉多义词 能区分一词多义

3.2 实现方式

上下文嵌入 = 词嵌入 + 位置编码 + Transformer 层

复制代码 
┌─────────────────────────────────────────────────────────────┐
│              上下文嵌入生成流程                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  输入句子: "I deposited money at the bank"                  │
│                                                             │
│  Step 1: Tokenization                                       │
│  ["I", "deposited", "money", "at", "the", "bank"]          │
│                                                             │
│  Step 2: 词嵌入查找 (静态)                                  │
│  E["I"], E["deposited"], E["money"], E["at"], E["the"], E["bank"]
│                                                             │
│  Step 3: + 位置编码                                         │
│  E["I"]+PE[0], E["deposited"]+PE[1], ...                   │
│                                                             │
│  Step 4: Transformer 层处理 (Self-Attention)                │
│  每个 token 的向量被更新，融合了上下文信息                   │
│                                                             │
│  Step 5: 输出上下文嵌入                                     │
│  H["bank"] = f(E["bank"], E["deposited"], E["money"], ...) │
│                                                             │
└─────────────────────────────────────────────────────────────┘

数学表示：

H = Transformer ( E + P E ) H = \text{Transformer}(E + PE) H=Transformer(E+PE)

  • E E E：词嵌入矩阵 [ n × d ] [n \times d] [n×d]
  • P E PE PE：位置编码矩阵 [ n × d ] [n \times d] [n×d]
  • H H H：上下文嵌入矩阵 [ n × d ] [n \times d] [n×d]

代码实现 (简化版 Transformer)：

python 复制代码 
import torch
import torch.nn as nn

class ContextualEmbedding(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_heads, num_layers):
        super().__init__()
        
        # Step 1: 词嵌入层 (静态)
        self.token_embedding = nn.Embedding(vocab_size, embed_dim)
        
        # Step 2: 位置编码 (可学习或固定)
        self.position_embedding = nn.Embedding(512, embed_dim)
        
        # Step 3: Transformer Encoder 层
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=embed_dim, 
            nhead=num_heads,
            batch_first=True
        )
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)
        
    def forward(self, input_ids):
        # input_ids: [batch_size, seq_len]
        
        # Step 1: 词嵌入查找
        token_embeds = self.token_embedding(input_ids)  # [batch, seq, dim]
        
        # Step 2: 位置编码
        positions = torch.arange(input_ids.shape[1], device=input_ids.device)
        pos_embeds = self.position_embedding(positions)  # [seq, dim]
        
        # Step 3: 相加
        embeds = token_embeds + pos_embeds  # [batch, seq, dim]
        
        # Step 4: Transformer 处理
        contextual_embeds = self.transformer(embeds)  # [batch, seq, dim]
        
        return contextual_embeds

# 使用示例
model = ContextualEmbedding(vocab_size=30522, embed_dim=512, 
                            num_heads=8, num_layers=6)

input_ids = torch.tensor([[101, 2345, 6789, 102]])  # 包含 "bank"
contextual_embeds = model(input_ids)  # 输出上下文嵌入

3.3 "bank" 的上下文嵌入示例

句子 1 : "I sat by the bank of the river"
句子 2: "I deposited money at the bank"

词嵌入 (静态):

  • E [ "bank" ] = [ 0.33 , − 0.12 , 0.89 , . . . ] E[\text{"bank"}] = [0.33, -0.12, 0.89, ...] E["bank"]=[0.33,−0.12,0.89,...] ← 两个句子中相同

上下文嵌入 (动态):

  • H 1 [ "bank" ] = [ 0.45 , 0.23 , 0.67 , . . . ] H_1[\text{"bank"}] = [0.45, 0.23, 0.67, ...] H1["bank"]=[0.45,0.23,0.67,...] ← 偏向"河岸"含义
  • H 2 [ "bank" ] = [ 0.12 , − 0.56 , 0.91 , . . . ] H_2[\text{"bank"}] = [0.12, -0.56, 0.91, ...] H2["bank"]=[0.12,−0.56,0.91,...] ← 偏向"银行"含义

向量相似度:

  • cos ⁡ ( H 1 [ "bank" ] , E [ "river" ] ) > cos ⁡ ( H 2 [ "bank" ] , E [ "river" ] ) \cos(H_1[\text{"bank"}], E[\text{"river"}]) > \cos(H_2[\text{"bank"}], E[\text{"river"}]) cos(H1["bank"],E["river"])>cos(H2["bank"],E["river"])
  • cos ⁡ ( H 2 [ "bank" ] , E [ "money" ] ) > cos ⁡ ( H 1 [ "bank" ] , E [ "money" ] ) \cos(H_2[\text{"bank"}], E[\text{"money"}]) > \cos(H_1[\text{"bank"}], E[\text{"money"}]) cos(H2["bank"],E["money"])>cos(H1["bank"],E["money"])

词嵌入 vs 上下文嵌入：核心区别

4.1 对比表格

维度 词嵌入 (Word Embedding) 上下文嵌入 (Contextual Embedding)
表示 静态，固定向量 动态，随上下文变化
一词多义 ❌ 无法区分 ✅ 可以区分
实现 Embedding 查找表 Transformer + Self-Attention
计算成本 低 ( O ( 1 ) O(1) O(1) 查找) 高 ( O ( n 2 ) O(n^2) O(n2) 注意力)
代表模型 Word2Vec, GloVe BERT, GPT, ELMo
训练方式 预训练后固定或微调 端到端训练
信息融合 无上下文信息 融合整个句子信息

4.2 可视化对比

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                    词嵌入 (静态)                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   "bank" (河岸) ──→ [0.33, -0.12, 0.89, ...]               │
│   "bank" (银行) ──→ [0.33, -0.12, 0.89, ...]  ← 相同！     │
│                                                             │
│   问题：无法区分多义词                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                  上下文嵌入 (动态)                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   "I sat by the bank of the river"                         │
│   "bank" ──→ [0.45, 0.23, 0.67, ...]  ← 偏向自然/地理      │
│                                                             │
│   "I deposited money at the bank"                          │
│   "bank" ──→ [0.12, -0.56, 0.91, ...] ← 偏向金融/商业      │
│                                                             │
│   优势：根据上下文动态调整                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Transformer 中的嵌入流程

5.1 完整流程图

复制代码 
┌─────────────────────────────────────────────────────────────┐
│              Transformer 嵌入处理流程                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  输入文本: "The cat sat on the mat"                         │
│                                                             │
│       ▼                                                     │
│  ┌─────────────────┐                                        │
│  │  Tokenization   │  ["The", "cat", "sat", "on", "the", "mat"]
│  └────────┬────────┘                                        │
│           ▼                                                 │
│  ┌─────────────────┐                                        │
│  │  Token IDs      │  [101, 2345, 6789, 3456, 102, 7890]   │
│  └────────┬────────┘                                        │
│           ▼                                                 │
│  ┌─────────────────┐                                        │
│  │  词嵌入查找     │  E[101], E[2345], E[6789], ...        │
│  │  (静态)         │  [batch, seq_len, d_model]            │
│  └────────┬────────┘                                        │
│           ▼                                                 │
│  ┌─────────────────┐                                        │
│  │  + 位置编码     │  PE[0], PE[1], PE[2], ...             │
│  │  (RoPE/绝对)    │  [batch, seq_len, d_model]            │
│  └────────┬────────┘                                        │
│           ▼                                                 │
│  ┌─────────────────┐                                        │
│  │  Transformer    │  Self-Attention 融合上下文             │
│  │  Encoder 层     │  [batch, seq_len, d_model]            │
│  └────────┬────────┘                                        │
│           ▼                                                 │
│  ┌─────────────────┐                                        │
│  │  上下文嵌入     │  H[0], H[1], H[2], ...                │
│  │  (动态)         │  每个 token 的向量已融合上下文信息      │
│  └─────────────────┘                                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

5.2 各层输出维度变化

假设: batch_size=2, seq_len=10, d_model=512

步骤 操作 输出维度
Step 1 输入 token IDs [ 2 , 10 ] [2, 10] [2,10] (int64)
Step 2 词嵌入查找后 [ 2 , 10 , 512 ] [2, 10, 512] [2,10,512] (float32)
Step 3 + 位置编码后 [ 2 , 10 , 512 ] [2, 10, 512] [2,10,512] (float32)
Step 4 Transformer Encoder (6 层) 后 [ 2 , 10 , 512 ] [2, 10, 512] [2,10,512] (float32) ← 上下文嵌入
Step 5 输出层 (可选) [ 2 , 10 , v o c a b _ s i z e ] [2, 10, vocab\_size] [2,10,vocab_size] (logits)

常见 Embedding 模型汇总

6.1 按类型分类

类型 代表模型 特点 适用场景
静态词嵌入 Word2Vec, GloVe, FastText 每个词固定向量 传统 NLP 任务、特征工程
上下文嵌入 BERT, GPT, RoBERTa 动态、上下文相关 现代 NLP、理解任务
多模态嵌入 CLIP, ALIGN 图文对齐 图文检索、多模态任务
图嵌入 Node2Vec, GCN 图结构编码 社交网络、推荐系统
知识图谱嵌入 TransE, ComplEx 关系推理 知识补全、问答系统
代码嵌入 CodeBERT, CodeT5 代码理解 代码生成、代码搜索

6.2 静态词嵌入模型对比

模型 年份 参数量 维度 训练方法 特点
Word2Vec 2013 ~1M 100-300 CBOW/Skip-gram 局部上下文，效率高
GloVe 2014 ~1M 50-300 共现矩阵分解 融合全局统计信息
FastText 2016 ~1M 100-300 Skip-gram + subword 处理未登录词，支持子词

6.3 上下文嵌入模型对比

模型 年份 参数量 维度 架构 最大长度 特点
ELMo 2018 94M 1024 双向 LSTM - 早期上下文嵌入
BERT 2018 110M-340M 768-1024 Transformer Encoder 512 双向上下文，奠基之作
GPT-2 2019 124M-1.5B 768-1600 Transformer Decoder 1024 单向，生成能力强
RoBERTa 2019 125M-355M 768-1024 Transformer Encoder 512 BERT 优化版
ALBERT 2019 12M-235M 768-4096 共享参数 512 参数共享，更小
XLNet 2019 110M-340M 768-1024 排列语言模型 512 融合 AR 和 AE
T5 2019 60M-11B 512-1024 Encoder-Decoder 512 统一文本到文本框架
DeBERTa 2020 140M-1.5B 768-1536 解耦注意力 512 分离内容和位置

6.4 大语言模型嵌入对比

模型 年份 参数量 维度 位置编码 注意力类型 上下文长度
GPT-3 2020 175B 12288 可学习位置编码 MHA 2048
LLaMA 2023 7B-65B 4096-8192 RoPE GQA 2048-4096
LLaMA-2 2023 7B-70B 4096-8192 RoPE GQA 4096
LLaMA-3 2024 8B-70B 4096-8192 RoPE GQA 8192-128K
Qwen-1.5 2023 1.8B-72B 2048-8192 RoPE GQA 32K
Qwen-2 2024 0.5B-72B 2048-8192 RoPE + YaRN GQA 128K
Qwen-2.5 2024 0.5B-72B 2048-8192 RoPE + YaRN GQA 128K
Qwen-3 2024 0.6B-236B 2048-16384 RoPE + YaRN GQA 256K+
DeepSeek-V2 2024 16B-236B 2048-7168 RoPE MLA 128K
DeepSeek-V3 2024 16B-671B 2048-7168 RoPE MLA + MoE 128K-1M
Gemini 2023 1.5T (MoE) 6144 RoPE MQA 32K-1M
Claude-3 2024 - - RoPE - 200K

6.5 其他领域嵌入模型

领域 模型 年份 特点
图嵌入 Node2Vec 2016 图结构随机游走
图嵌入 GraphSAGE 2017 归纳式学习
图嵌入 GCN 2017 图卷积网络
知识图谱 TransE 2013 关系三元组嵌入
知识图谱 ComplEx 2016 复数空间嵌入
多模态 CLIP 2021 图文对比学习
多模态 ALIGN 2021 大规模图文对齐
代码 CodeBERT 2020 代码-文本双向
代码 CodeT5 2021 代码生成和理解
代码 CodeLLaMA 2023 代码专用 LLaMA

不同模型的嵌入策略

7.1 模型对比

模型 词嵌入 位置编码 上下文嵌入
Word2Vec ✅ 静态 ❌ 无 ❌ 无
ELMo ✅ 双向 LSTM ✅ 位置 ✅ LSTM 上下文
BERT ✅ 可学习 ✅ 绝对位置 ✅ Transformer Encoder
GPT-2/3 ✅ 可学习 ✅ 绝对位置 ✅ Transformer Decoder
LLaMA ✅ 可学习 ✅ RoPE ✅ Transformer Decoder
Qwen ✅ 可学习 ✅ RoPE + YaRN ✅ Transformer Decoder
DeepSeek ✅ 可学习 ✅ RoPE ✅ Transformer Decoder + MLA

7.2 代码对比

Word2Vec (静态嵌入):

python 复制代码 
from gensim.models import Word2Vec

# 训练
sentences = [["the", "cat", "sat"], ["the", "dog", "ran"]]
model = Word2Vec(sentences, vector_size=300, window=5, min_count=1)

# 获取嵌入 (静态)
king_vector = model.wv["king"]  # 固定向量
queen_vector = model.wv["queen"]  # 固定向量

# 任何上下文中 "king" 的向量都相同

BERT (上下文嵌入):

python 复制代码 
from transformers import BertModel, BertTokenizer

# 加载模型
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

# 句子 1
text1 = "I sat by the bank of the river"
inputs1 = tokenizer(text1, return_tensors='pt')
outputs1 = model(**inputs1)
bank_embed1 = outputs1.last_hidden_state[0, -2]  # "bank" 的上下文嵌入

# 句子 2
text2 = "I deposited money at the bank"
inputs2 = tokenizer(text2, return_tensors='pt')
outputs2 = model(**inputs2)
bank_embed2 = outputs2.last_hidden_state[0, -2]  # "bank" 的上下文嵌入

# 两个向量不同！
print(torch.cosine_similarity(bank_embed1, bank_embed2))  # < 1.0

Embedding 的评估指标

8.1 词嵌入评估

指标 类型 说明
Word Similarity 内在评估 计算词对相似度与人工评分的相关性
Word Analogy 内在评估 "king - man + woman = queen" 准确率
Downstream Task 外在评估 在具体任务（分类、NER）上的表现

Word Analogy 示例：

king ⃗ − man ⃗ + woman ⃗ ≈ queen ⃗ \vec{\text{king}} - \vec{\text{man}} + \vec{\text{woman}} \approx \vec{\text{queen}} king −man +woman ≈queen

8.2 上下文嵌入评估

指标 说明
GLUE 通用语言理解评估（9 个任务）
SuperGLUE 更难的语言理解任务
SQuAD 阅读理解任务
BLEU / ROUGE 生成任务评估
Perplexity 语言模型困惑度

Embedding 的可视化

9.1 t-SNE 降维可视化

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                  词嵌入 t-SNE 可视化                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│                     animal                                  │
│                       │                                     │
│         cat ─────── dog                                     │
│                       │                                     │
│                     pet                                     │
│                                                             │
│    fruit                 vehicle                            │
│      │                     │                                │
│  apple─banana          car ─── truck                        │
│      │                     │                                │
│  orange                 bus                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

9.2 语义空间性质

向量算术：

巴黎 ⃗ − 法国 ⃗ ≈ 罗马 ⃗ − 意大利 ⃗ \vec{\text{巴黎}} - \vec{\text{法国}} \approx \vec{\text{罗马}} - \vec{\text{意大利}} 巴黎 −法国 ≈罗马 −意大利

语义相似度：

cos ⁡ ( 猫 ⃗ , 狗 ⃗ ) > cos ⁡ ( 猫 ⃗ , 汽车 ⃗ ) \cos(\vec{\text{猫}}, \vec{\text{狗}}) > \cos(\vec{\text{猫}}, \vec{\text{汽车}}) cos(猫 ,狗 )>cos(猫 ,汽车 )

总结

10.1 核心要点

复制代码 
┌─────────────────────────────────────────────────────────────┐
│                      核心要点总结                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1️⃣  什么是 Embedding                                        │
│      • 将离散符号映射到连续向量空间                           │
│      • 实现语义相似 → 向量相似                               │
│      • 解决 one-hot 的维度灾难和语义缺失问题                  │
│                                                             │
│  2️⃣  词嵌入 (Word Embedding)                                │
│      • 静态查找表，每个词固定向量                            │
│      • 实现：nn.Embedding(vocab_size, dim)                  │
│      • 无法区分一词多义                                      │
│      • 代表：Word2Vec, GloVe                                │
│                                                             │
│  3️⃣  上下文嵌入 (Contextual Embedding)                      │
│      • 动态计算，随上下文变化                                │
│      • 实现：词嵌入 + 位置编码 + Transformer                │
│      • 可以区分一词多义                                      │
│      • 代表：BERT, GPT, LLaMA, Qwen                         │
│                                                             │
│  4️⃣  Transformer 中的流程                                   │
│      Token IDs → 词嵌入 → +位置编码 → Transformer → 上下文嵌入│
│                                                             │
│  5️⃣  常见 Embedding 模型                                    │
│      • 静态：Word2Vec, GloVe, FastText                      │
│      • 上下文：BERT, GPT, LLaMA, Qwen, DeepSeek             │
│      • 多模态：CLIP, ALIGN                                  │
│      • 图嵌入：Node2Vec, GCN                                │
│      • 代码：CodeBERT, CodeT5                               │
│                                                             │
└─────────────────────────────────────────────────────────────┘

10.2 简单记忆

概念 类比
Embedding 将世界万物映射到数学空间
词嵌入 字典里每个词的固定定义
上下文嵌入 根据具体语境理解词的含义
静态 vs 动态 照片 vs 视频

现代大模型 (Qwen、LLaMA、DeepSeek 等) 使用的都是上下文嵌入，这是它们能够理解复杂语义的关键！🚀

相关推荐
大模型任我行2 小时前
谷歌：预训练到微调的知识迁移规律
人工智能·语言模型·自然语言处理·论文笔记
香芋Yu3 小时前
【2026大模型面试圣经】（1）Transformer全解析 | 从Self-Attention到Multi-Head，一文通关Transformer面试
面试·职场和发展·transformer
nudt_qxx3 小时前
讲透Transformer(五):Self-Attention与KV Cache的深度解析——从原理到实现
人工智能·深度学习·transformer
一个努力编程人5 小时前
NLP领域————Transformer
人工智能·自然语言处理·transformer
盼小辉丶6 小时前
Transformer实战（36）——Transformer模型部署
深度学习·transformer·模型部署
sanshanjianke8 小时前
AI辅助网文创作理论研究笔记（二）：一些新的思路和想法
语言模型·ai写作
大模型任我行15 小时前
华为：构建特征级LLM编码评测基准
人工智能·语言模型·自然语言处理·论文笔记
Zzz 小生17 小时前
LangChain Streaming-Overview：流式处理使用完全指南
人工智能·python·语言模型·langchain·github
眼镜哥（with glasses）19 小时前
0215笔记-语言模型，提问范式与 Token
人工智能·笔记·语言模型
热门推荐
01GitHub 镜像站点02AI Agent 平台横评：ZeroClaw vs OpenClaw vs Nanobot03Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services04HTML 早已不是标签了，它现在是系统级接口：这 9 个 API 直接干翻常用 JS 库05全面体验 Grok API 中转站（2025 · Grok 4 系列最新版）06如何解决 OpenClaw “Pairing required” 报错：两种官方解决方案详解07【OpenClaw 本地实战 Ep.3】突破瓶颈：强制修改 openclaw.json 解锁 32k 上下文记忆08MIUI显示/隐藏5G开关的方法，信号弱时开启手机Wifi通话方法09openClaw安装飞书插件｜核心踩坑：spawn EINVAL 错误终极解决指南10配置 OpenClaw 使用 Ollama 本地模型