PyTorch如何使用embedding对特征向量进行嵌入

mathematician={ "can run" : 2.3, "likes coffee" : 9.4,"majored in Physics" : −5.5,…}
physicist={ "can run" : 2.5 "likes coffee" : 9.1,"majored in Physics" : 6.4,…}

import torch
import torch.nn as nn

word_to_ix = {"hello": 0, "world": 1, "nice": 2, "to": 3, "see": 4, "you": 5}
embeds = nn.Embedding(6, 2)  # 构建模型
lookup_tensor = torch.tensor([word_to_ix["nice"]], dtype=torch.long)
print(lookup_tensor)
nice_embed = embeds(lookup_tensor)     # 进行编码
print(nice_embed)
'''
tensor([2])
tensor([[ 0.7950, -0.3999]], grad_fn=<EmbeddingBackward>)
'''

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

CONTEXT_SIZE = 2
EMBEDDING_DIM = 10  # 编码向量的维度

test_sentence = """When forty winters shall besiege thy brow,
And dig deep trenches in thy beauty's field,
Thy youth's proud livery so gazed on now,
Will be a totter'd weed of small worth held:
Then being asked, where all thy beauty lies,
Where all the treasure of thy lusty days;
To say, within thine own deep sunken eyes,
Were an all-eating shame, and thriftless praise.
How much more praise deserv'd thy beauty's use,
If thou couldst answer 'This fair child of mine
Shall sum my count, and make my old excuse,'
Proving his beauty by succession thine!
This were to be new made when thou art old,
And see thy blood warm when thou feel'st it cold.""".split()
# 构建训练集数据 ([ 第一个单词, 第二个单词 ], 预测目标)
trigrams = [([test_sentence[i], test_sentence[i + 1]], test_sentence[i + 2])
            for i in range(len(test_sentence) - 2)]
# 构建测试集数据
vocab = set(test_sentence)
word_to_ix = {word: i for i, word in enumerate(vocab)}

# 定义模型
class NGramLanguageModeler(nn.Module):

    def __init__(self, vocab_size, embedding_dim, context_size):
        super(NGramLanguageModeler, self).__init__()
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.linear1 = nn.Linear(context_size * embedding_dim, 128)
        self.linear2 = nn.Linear(128, vocab_size)

    def forward(self, inputs):
        embeds = self.embeddings(inputs).view((1, -1))  # 进行embedding
        out = F.relu(self.linear1(embeds))  # 经过第一个全连接层
        out = self.linear2(out)  # 经过第二个全连接层
        log_probs = F.log_softmax(out, dim=1)
        return log_probs

# 进行训练
losses = []
loss_function = nn.NLLLoss()
model = NGramLanguageModeler(len(vocab), EMBEDDING_DIM, CONTEXT_SIZE)
optimizer = optim.SGD(model.parameters(), lr=0.001)

for epoch in range(10):
    total_loss = 0
    for context, target in trigrams:
        # 准备输入模型的数据
        context_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)

        model.zero_grad()  # 清零梯度缓存

        # 进行训练得到预测结果
        log_probs = model(context_idxs)

        # 计算损失值
        loss = loss_function(log_probs, torch.tensor([word_to_ix[target]], dtype=torch.long))

        # 反向传播更新梯度
        loss.backward()
        optimizer.step()

        total_loss += loss.item()  # 累计损失
    losses.append(total_loss)
print(losses)