Introduction

In Gensim, a Word2Vec model learns an embedding vector for each token in its vocabulary. When people ask how to match words and vectors, they usually mean one of four tasks: get the vector for a word, get the index for a word, map an index back to the token, or find the nearest words for a given vector.

Use model.wv, Not the Training Wrapper

After training, the main vocabulary and vector interface lives on model.wv. The Word2Vec object itself holds training-related state, while model.wv exposes keyed vector access.

1from gensim.models import Word2Vec
2
3sentences = [
4    ["cat", "sat", "on", "mat"],
5    ["dog", "sat", "on", "rug"],
6    ["cat", "chased", "mouse"],
7    ["dog", "chased", "ball"],
8]
9
10model = Word2Vec(
11    sentences=sentences,
12    vector_size=50,
13    window=3,
14    min_count=1,
15    workers=1,
16    sg=1,
17)

Once training finishes, think of model.wv as the dictionary-like interface for tokens and vectors.

Get the Vector for a Word

The most direct match is a word-to-vector lookup.

vector = model.wv["cat"]
print(vector.shape)
print(vector[:5])

You can also use get_vector, which makes the intent explicit:

vector = model.wv.get_vector("cat")
print(vector.shape)

Both forms return a NumPy array. If the token is not in the vocabulary, the lookup fails, so it is often worth checking membership first.

1word = "elephant"
2
3if word in model.wv:
4    print(model.wv[word])
5else:
6    print("word not in vocabulary")

Map Words to Indices and Back

Gensim stores a stable vocabulary order, and current versions expose it through key_to_index and index_to_key.

1index = model.wv.key_to_index["cat"]
2print(index)
3
4word = model.wv.index_to_key[index]
5print(word)

This is the safest way to align tokens with rows in exported arrays. Do not guess the ordering of internal structures when Gensim already gives you the mapping explicitly.

If you need the full matrix of embeddings, it is also available:

all_vectors = model.wv.vectors
print(all_vectors.shape)

Each row corresponds to the token at the same position in index_to_key.

Match a Vector Back to Words by Similarity

There is usually no exact reverse lookup for an arbitrary vector. The meaningful operation is nearest-neighbor search: find the stored words whose vectors are closest to the input vector.

similar = model.wv.most_similar("cat", topn=3)
print(similar)

You can also start from a raw vector:

cat_vector = model.wv["cat"]
nearest = model.wv.similar_by_vector(cat_vector, topn=3)
print(nearest)

This is what most "vector to word" questions are really asking for. You are not perfectly inverting the embedding. You are asking which learned words live closest to this vector in embedding space.

Build Phrase or Sentence Vectors

A common follow-up task is to combine several word vectors into one vector for a short phrase. A simple baseline is to average the word embeddings.

1import numpy as np
2
3phrase = ["cat", "sat", "on", "mat"]
4vectors = [model.wv[token] for token in phrase if token in model.wv]
5phrase_vector = np.mean(vectors, axis=0)
6
7print(phrase_vector.shape)
8print(model.wv.similar_by_vector(phrase_vector, topn=3))

This is not the only sentence-embedding approach, but it is a common and useful debugging or baseline technique.

Gensim also exposes helpers such as get_mean_vector in keyed vectors, which can simplify this type of aggregation in newer code.

Understand Why a Word Might Be Missing

A token may fail lookup for normal reasons:

• the token never appeared in training data
• tokenization did not match your expectation
• 'min_count filtered rare words out'
• casing or preprocessing changed the vocabulary

For example, "Cat" and "cat" are different tokens unless your preprocessing normalizes case.

That is why out-of-vocabulary handling should be considered part of the normal workflow, not an exceptional bug.

Keep Export Logic Explicit

If you need a clean word-to-vector table for another system, export it explicitly rather than depending on undocumented assumptions.

for word in model.wv.index_to_key:
    vector = model.wv[word]
    print(word, vector[:3])

This keeps the mapping obvious and avoids subtle indexing mistakes when converting embeddings into files or downstream ML pipelines.

Common Pitfalls

One common mistake is trying to access vocabulary and vectors directly on model instead of model.wv.

Another pitfall is assuming every lookup token must exist. In practice, vocabulary filtering and preprocessing differences make missing tokens normal.

A third issue is expecting an arbitrary vector to map back to exactly one original word. The meaningful operation is nearest-neighbor search, not perfect inversion.

Finally, if you need a stable token-to-row alignment, always use key_to_index, index_to_key, or the keyed vector matrix directly rather than relying on guessed ordering.

Summary

• In Gensim Word2Vec, use model.wv for word and vector access after training.
• Retrieve a vector with model.wv["word"] or model.wv.get_vector("word").
• Use key_to_index and index_to_key to map between tokens and internal positions.
• Use similar_by_vector or most_similar when you need the nearest words for a vector.
• Treat out-of-vocabulary handling and preprocessing consistency as normal parts of embedding work.