PyTorch / Gensim - 如何加载预训练的单词嵌入

Question

我想将带有gensim的预训练word2vec嵌入到PyTorch嵌入层中。

所以我的问题是，如何将gensim加载的嵌入权重加到PyTorch嵌入层中。

提前致谢！

Answer 1

我只是想报告关于使用PyTorch加载gensim嵌入的结果。

• PyTorch 0.4.0及更新版本的解决方案：

从v0.4.0开始，有一个新功能from_pretrained()，这使得嵌入非常舒适。 以下是文档中的示例。

>> # FloatTensor containing pretrained weights
>> weight = torch.FloatTensor([[1, 2.3, 3], [4, 5.1, 6.3]])
>> embedding = nn.Embedding.from_pretrained(weight)
>> # Get embeddings for index 1
>> input = torch.LongTensor([1])
>> embedding(input)

gensim的权重可以通过以下方式轻松获得：

import gensim
model = gensim.models.KeyedVectors.load_word2vec_format('path/to/file')
weights = torch.FloatTensor(model.vectors) # formerly syn0, which is soon deprecated

• PyTorch版本0.3.1及更早版本的解决方案：

我正在使用版本0.3.1，此版本中没有from_pretrained()。

因此我创建了自己的from_pretrained，因此我也可以将其与0.3.1一起使用。

PyTorch版本from_pretrained或更低版本0.3.1的代码：

def from_pretrained(embeddings, freeze=True):
    assert embeddings.dim() == 2, \
         'Embeddings parameter is expected to be 2-dimensional'
    rows, cols = embeddings.shape
    embedding = torch.nn.Embedding(num_embeddings=rows, embedding_dim=cols)
    embedding.weight = torch.nn.Parameter(embeddings)
    embedding.weight.requires_grad = not freeze
    return embedding

可以加载嵌入，就像这样：

embedding = from_pretrained(weights)

我希望这对某人有帮助。

Answer 2

我认为这很容易。只需将gensim中的嵌入权重复制到PyTorch embedding layer中的相应权重。

你需要确保两件事情是正确的：首先是重量形状必须正确，其次是重量必须转换为PyTorch FloatTensor类型。

Answer 3

我有一个相同的问题，只是我将pytorch与torchtext库一起使用，因为它有助于填充，批处理和其他操作。这是我用torchtext 0.3.0加载预训练的嵌入并将它们传递给pytorch 0.4.1（pytorch部分使用blue-phoenox所提到的方法）所做的工作：

import torch
import torch.nn as nn
import torchtext.data as data
import torchtext.vocab as vocab

# use torchtext to define the dataset field containing text
text_field = data.Field(sequential=True)

# load your dataset using torchtext, e.g.
dataset = data.Dataset(examples=..., fields=[('text', text_field), ...])

# build vocabulary
text_field.build_vocab(dataset)

# I use embeddings created with
# model = gensim.models.Word2Vec(...)
# model.wv.save_word2vec_format(path_to_embeddings_file)

# load embeddings using torchtext
vectors = vocab.Vectors(path_to_embeddings_file) # file created by gensim
text_field.vocab.set_vectors(vectors.stoi, vectors.vectors, vectors.dim)

# when defining your network you can then use the method mentioned by blue-phoenox
embedding = nn.Embedding.from_pretrained(torch.FloatTensor(text_field.vocab.vectors))

# pass data to the layer
dataset_iter = data.Iterator(dataset, ...)
for batch in dataset_iter:
    ...
    embedding(batch.text)

Answer 4

from gensim.models import Word2Vec

model = Word2Vec(reviews,size=100, window=5, min_count=5, workers=4)
#gensim model created

import torch

weights = torch.FloatTensor(model.wv.vectors)
embedding = nn.Embedding.from_pretrained(weights)

Answer 5

我自己在理解文档时遇到了很多问题，周围没有很多好的例子。希望这个例子可以帮助其他人。这是一个简单的分类器，它接受matrix_embeddings中的预训练嵌入。通过将requires_grad设置为false，可以确保我们没有更改它们。

class InferClassifier（nn.Module）：

def __init__(self, input_dim, n_classes, matrix_embeddings):
    """initializes a 2 layer MLP for classification.
    There are no non-linearities in the original code, Katia instructed us 
    to use tanh instead"""

    super(InferClassifier, self).__init__()

    #dimensionalities
    self.input_dim = input_dim
    self.n_classes = n_classes
    self.hidden_dim = 512

    #embedding
    self.embeddings = nn.Embedding.from_pretrained(matrix_embeddings)
    self.embeddings.requires_grad = False

    #creates a MLP
    self.classifier = nn.Sequential(
            nn.Linear(self.input_dim, self.hidden_dim),
            nn.Tanh(), #not present in the original code.
            nn.Linear(self.hidden_dim, self.n_classes))

def forward(self, sentence):
    """forward pass of the classifier
    I am not sure it is necessary to make this explicit."""

    #get the embeddings for the inputs
    u = self.embeddings(sentence)

    #forward to the classifier
    return self.classifier(x)

sentence是一个带有matrix_embeddings而不是单词的索引的向量。

Answer 6

有类似的问题：“在使用gensim训练并以 binary 格式保存嵌入后，如何将它们加载到torchtext？”

我只是将文件保存为txt格式，然后遵循加载自定义单词嵌入的精湛tutorial。

def convert_bin_emb_txt(out_path,emb_file):
    txt_name = basename(emb_file).split(".")[0] +".txt"
    emb_txt_file = os.path.join(out_path,txt_name)
    emb_model = KeyedVectors.load_word2vec_format(emb_file,binary=True)
    emb_model.save_word2vec_format(emb_txt_file,binary=False)
    return emb_txt_file

emb_txt_file = convert_bin_emb_txt(out_path,emb_bin_file)
custom_embeddings = vocab.Vectors(name=emb_txt_file,
                                  cache='custom_embeddings',
                                  unk_init=torch.Tensor.normal_)

TEXT.build_vocab(train_data,
                 max_size=MAX_VOCAB_SIZE,
                 vectors=custom_embeddings,
                 unk_init=torch.Tensor.normal_)

经过测试：PyTorch：1.2.0和TorchText：0.4.0。

我添加了此答案，因为对于所接受的答案，我不确定如何遵循链接的tutorial并使用正态分布来初始化嵌入中未包含的所有单词以及如何使向量等于零。 / p>