PyTorch深度学习实战 |词嵌入和位置编码

from torchtext.vocab import import GloVe  # 导入GloVe词向量
# 简单介绍
# GloVe词向量，它是斯坦福大学的研究者在2014年开发和发布的
# GloVe和word2vec与fasttext，是当前最常用的3个词向量版本
# 6B表示了模型是基于60 亿个单词的语料库训练的
# 300表示一个单词，使用300维的向量表示
glove = GloVe(name='6B', dim=300)

import torch
from torch import nn
# 使用nn.Embedding创建词嵌入层
# 将glove.vectors，通过from_pretrained接口，导入到Embedding层中
# 此时的embedding层，就载入了GloVe词向量数据
embedding = nn.Embedding.from_pretrained(glove.vectors)
# 打印embedding层中的weight的尺寸
print(f"embedding.shape: {embedding.weight.shape}")

# 将man、woman、king、queen等8个词语的词向量，绘制到二维平面上
words = ['man', 'woman', 'king', 'queen', 'cat', 'dog', 'mother', 'father']
indices = []
for word in words:
    # 将单词word，通过glove的词汇表，转换为单词的索引
    index = glove.stoi[word]
    # 将这些索引保存到indices数组中
    indices.append(index)
    # 打印单词word和索引index的对应关系
    print(f"{word} -> {index}")

# 将索引列表，使用torch.tensor，转为张量的形式
indices = torch.tensor(indices)
# 将索引列表转换为，词向量的矩阵
vectors = embedding(indices).detach().numpy()
# 打印vector的尺寸
print(f"vectors.shape: {vectors.shape}")

from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
# 使用PCA降维算法，将向量vectors进行降维
pca = PCA(n_components=2)
vectors_2d = pca.fit_transform(vectors)
# 将单词和向量，绘制到二维平面上
plt.scatter(vectors_2d[:, 0], vectors_2d[:, 1])
for i, word in enumerate(words):
    plt.annotate(word,
                 xy=(vectors_2d[i, 0], vectors_2d[i, 1]),
                 xytext=(-10, 10),
                 textcoords='offset points')
plt.show()

from torchtext.vocab import GloVe  # 导入GloVe词向量
# 简单介绍
# GloVe词向量，它是斯坦福大学的研究者在2014年开发和发布的
# GloVe和word2vec与fasttext，是当前最常用的3个词向量版本
# 6B表示了模型是基于60 亿个单词的语料库训练的
# 300表示一个单词，使用300维的向量表示
glove = GloVe(name='6B', dim=300)
import torch
from torch import nn
# 使用nn.Embedding创建词嵌入层
# 将glove.vectors，通过from_pretrained接口，导入到Embedding层中
# 此时的embedding层，就载入了GloVe词向量数据
embedding = nn.Embedding.from_pretrained(glove.vectors)
# 打印embedding层中的weight的尺寸
print(f"embedding.shape: {embedding.weight.shape}")
# 将man、woman、king、queen等8个词语的词向量，绘制到二维平面上
words = ['man', 'woman', 'king', 'queen', 'cat', 'dog', 'mother', 'father']
indices = []
for word in words:
    # 将单词word，通过glove的词汇表，转换为单词的索引
    index = glove.stoi[word]
    # 将这些索引保存到indices数组中
    indices.append(index)
    # 打印单词word和索引index的对应关系
    print(f"{word} -> {index}")
# 将索引列表，使用torch.tensor，转为张量的形式
indices = torch.tensor(indices)
# 将索引列表转换为，词向量的矩阵
vectors = embedding(indices).detach().numpy()
# 打印vector的尺寸
print(f"vectors.shape: {vectors.shape}")
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
# 使用PCA降维算法，将向量vectors进行降维
pca = PCA(n_components=2)
vectors_2d = pca.fit_transform(vectors)
# 将单词和向量，绘制到二维平面上
plt.scatter(vectors_2d[:, 0], vectors_2d[:, 1])
for i, word in enumerate(words):
    plt.annotate(word,
                 xy=(vectors_2d[i, 0], vectors_2d[i, 1]),
                 xytext=(-10, 10),
                 textcoords='offset points')
plt.show()

word_embeds = torch.tensor([
    [0.4002, 0.9882, 0.6261, 0.1502],  # Are
    [0.3413, 0.9284, 0.9349, 0.8958],  # you
    [0.5347, 0.2969, 0.7019, 0.6293],  # OK
    [0.8704, 0.4956, 0.3794, 0.5646]   # ?
])
print("图片中的词向量矩阵：")
print(word_embeds)

embed_dim=4
max_pos=5
# 1. 生成位置索引（0到max_pos-1）
pos = torch.arange(max_pos).unsqueeze(1)  # 形状：[max_pos, 1]
print(pos)
# 2. 计算正余弦编码的频率项（公式中的10000^(2i/d_model)的倒数）
div_term = torch.exp(torch.arange(0, embed_dim, 2) * (-math.log(10000.0) / embed_dim))
print(div_term)
# 3. 初始化位置编码矩阵（全零）
pe = torch.zeros(max_pos, embed_dim)  # 形状：[max_pos, embed_dim]
print(pe)
# 4. 填充偶数维度（用正弦函数）
pe[:, 0::2] = torch.sin(pos * div_term)  # 0::2表示从0开始，步长为2的列（偶数维）
print(pe[:, 0::2])
# 5. 填充奇数维度（用余弦函数）
pe[:, 1::2] = torch.cos(pos * div_term)  # 1::2表示从1开始，步长为2的列（奇数维）
print(pe[:, 1::2])
print(pos_encoder.pe[:4])  # 取前4个位置的编码

import torch
import torch.nn as nn
import math
# 1. 定义位置编码模块（复用之前的实现）
class PositionalEncoding(nn.Module):
    def __init__(self, embed_dim: int, max_pos: int = 10):
        super().__init__()
        pos = torch.arange(max_pos).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, embed_dim, 2) * (-math.log(10000.0) / embed_dim))
        pe = torch.zeros(max_pos, embed_dim)
        pe[:, 0::2] = torch.sin(pos * div_term)
        pe[:, 1::2] = torch.cos(pos * div_term)
        self.register_buffer('pe', pe)
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        seq_len = x.size(0)
        return x + self.pe[:seq_len]  # 这里x是[序列长度, 词向量维度]，无需批次维度
# 2. 构造图片中的词向量矩阵（形状：[5, 4]）
word_embeds = torch.tensor([
    [0.4002, 0.9882, 0.6261, 0.1502],  # Are
    [0.3413, 0.9284, 0.9349, 0.8958],  # you
    [0.5347, 0.2969, 0.7019, 0.6293],  # OK
    [0.8704, 0.4956, 0.3794, 0.5646]   # ?
])
print("图片中的词向量矩阵：")
print(word_embeds)
# 3. 初始化位置编码模块（embed_dim=4，max_pos=5）
pos_encoder = PositionalEncoding(embed_dim=4, max_pos=5)
print("\n图片对应的位置编码矩阵：")
print(pos_encoder.pe[:4])  # 取前4个位置的编码
# 4. 计算“词向量 + 位置编码”的结果
output = pos_encoder(word_embeds)
print("\n最终相加结果：")
print(output)