Question: I want to load a pre-trained word2vec embedding with gensim into a PyTorch embedding layer.

How do I get the embedding weights loaded by gensim into the PyTorch embedding layer?

Answer: 
I just wanted to report my findings about loading a gensim embedding with PyTorch.

---

* Solution for PyTorch `0.4.0` and newer:
---------------------------------------

From `v0.4.0` there is a new function [`from_pretrained()`](https://pytorch.org/docs/stable/nn.html#torch.nn.Embedding.from_pretrained) which makes loading an embedding very comfortable.
Here is an example from the documentation.

```
import torch
import torch.nn as nn

# 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)

```

The weights from [*gensim*](https://radimrehurek.com/gensim/) can easily be obtained by:

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

```

As noted by @Guglie: in newer gensim versions the weights can be obtained by [`model.wv`](https://radimrehurek.com/gensim/models/word2vec.html):

```
weights = model.wv

```

---

* Solution for PyTorch version `0.3.1` and older:
-----------------------------------------------

I'm using version `0.3.1` and [`from_pretrained()`](https://pytorch.org/docs/stable/nn.html#torch.nn.Embedding.from_pretrained) isn't available in this version.

Therefore I created my own `from_pretrained` so I can also use it with `0.3.1`.

*Code for `from_pretrained` for PyTorch versions `0.3.1` or lower:*

```
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

```

The embedding can be loaded then just like this:

```
embedding = from_pretrained(weights)

```

I hope this is helpful for someone.
I had the same question except that I use [torchtext](https://github.com/pytorch/text) library with pytorch as it helps with padding, batching, and other things. This is what I've done to load pre-trained embeddings with torchtext 0.3.0 and to pass them to pytorch 0.4.1 (the pytorch part uses the method mentioned by [blue-phoenox](https://stackoverflow.com/a/49802495/401075)):

```
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)

```