【NLP 20、Encoding编码 和 Embedding嵌入】

目录

一、核心定义与区别

二、常见Encoding编码

(1) 独热编码（One-Hot Encoding）

(2) 位置编码（Positional Encoding）

(3) 标签编码（Label Encoding）

(4) 注意事项 

三、常见Embedding词嵌入

(1) 基础词嵌入（nn.Embedding）

(2) 预训练嵌入（from_pretrained） 

(3) 类别特征嵌入（自定义类）

(4) 注意事项 

四、对比总结

五、编码与嵌入的联合使用

总结

---

新年快乐，这几天将之前做的笔记整理了一下，补充了一点，正式开始学习！ 

                                                                                                                —— 24.2.4

一、核心定义与区别

二、常见Encoding编码

(1) 独热编码（One-Hot Encoding）

• 定义：将离散类别映射为二进制向量，仅一个位置为1，其余为0。

• 注意：

  独热编码	使用 torch.nn.functional.one_hot，注意设置 num_classes 参数。

• 示例：

# 类别：["猫", "狗", "鸟"]
"猫" → [1, 0, 0]
"狗" → [0, 1, 0]
"鸟" → [0, 0, 1]

• 缺点：维度爆炸（高维稀疏），无法表达类别间关系。

(2) 位置编码（Positional Encoding）

• 定义：为序列数据（如文本、时间序列）添加位置信息，常用正弦/余弦函数生成。

• 注意：

  位置编码	自定义生成矩阵后叠加到词嵌入上，需与输入张量形状匹配。

• Transformer 中的公式：

  

(3) 标签编码（Label Encoding）

• 定义：将类别映射为整数（如 "红"→0, "蓝"→1, "绿"→2），但可能引入错误的大小关系。

(4) 注意事项 

1. 独热编码的输入限制：

   • 输入张量必须是整数类型（如 torch.long）。

   • 索引值必须小于 num_classes，否则会越界。

2. 位置编码的叠加方式：

   • 需与词嵌入维度一致（d_model），且直接相加前确保形状匹配。

三、常见Embedding词嵌入

(1) 基础词嵌入（nn.Embedding）

nn.Embedding()模块

注意：

embedding_layer = nn.Embedding(num_embeddings=10000, embedding_dim=300)

import torch.nn as nn

# 定义嵌入层：词汇表大小=10000，嵌入维度=300
embedding_layer = nn.Embedding(num_embeddings=10000, embedding_dim=300)

# 输入：单词索引（形状 [batch_size, seq_len]）
input_ids = torch.LongTensor([[1, 22, 45], [3, 8, 2]])  # 示例输入

# 获取词嵌入向量
embeddings = embedding_layer(input_ids)  # 输出形状 [2, 3, 300]

(2) 预训练嵌入（from_pretrained） 

nn.Embedding.from_pretrained()

注意： 

pretrained_emb = nn.Embedding.from_pretrained(glove.vectors, freeze=True)

如GloVe： 

from torchtext.vocab import GloVe

# 加载预训练的 GloVe 词向量
glove = GloVe(name='6B', dim=100)  # 使用 100 维的 GloVe

# 获取单词 "apple" 的向量
apple_vector = glove['apple']  # 形状 [100]

# 将预训练向量转换为嵌入层
pretrained_emb = nn.Embedding.from_pretrained(glove.vectors, freeze=False)  # freeze=True 表示不更新

(3) 类别特征嵌入（自定义类）

CategoryEmbedding

user_embedding = CategoryEmbedding(num_categories=1000, embedding_dim=64)

注意：

import torch.nn as nn

class CategoryEmbedding(nn.Module):
    def __init__(self, num_categories, embedding_dim):
        super().__init__()
        self.embedding = nn.Embedding(num_categories, embedding_dim)
    
    def forward(self, category_ids):
        return self.embedding(category_ids)

# 示例：用户ID嵌入（假设有 1000 个用户）
user_embedding = CategoryEmbedding(num_categories=1000, embedding_dim=64)
user_ids = torch.tensor([5, 12, 8])  # 输入用户ID
embedded_users = user_embedding(user_ids)  # 形状 [3, 64]

(4) 注意事项 

1. 嵌入层的输入要求：

   • nn.Embedding 的输入为整数索引，非浮点数。

2. 预训练嵌入的兼容性：

   • 加载预训练向量时，需确保 num_embeddings 和 embedding_dim 与预训练矩阵一致。

四、对比总结

五、编码与嵌入的联合使用

在 Transformer 中，词嵌入和位置编码共同构成输入表示：

import torch
import torch.nn as nn

class TransformerInput(nn.Module):
    def __init__(self, vocab_size, d_model, max_seq_len):
        super().__init__()
        self.token_embedding = nn.Embedding(vocab_size, d_model)
        self.position_encoding = self._generate_position_encoding(max_seq_len, d_model)
        
    def _generate_position_encoding(self, max_len, d_model):
        position = torch.arange(max_len).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))
        pe = torch.zeros(max_len, d_model)
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        return pe  # 形状: [max_len, d_model]
    
    def forward(self, x):
        # x: [batch_size, seq_len]
        token_emb = self.token_embedding(x)  # [batch_size, seq_len, d_model]
        seq_len = x.size(1)
        positions = self.position_encoding[:seq_len, :]  # [seq_len, d_model]
        return token_emb + positions  # [batch_size, seq_len, d_model]

总结

• Encoding 是广义的数据转换方式，强调格式兼容性（如独热编码、位置编码）。

• Embedding 是特殊的编码方法，通过可学习的低维向量捕捉语义信息（如词嵌入）。

• 两者常结合使用（如 Transformer 中的词嵌入+位置编码），分别处理不同维度的信息。