gensim: models.word2vec – Deep learning with word2vec
Description: Efficient topic modelling of text semantics in Python.

#

### Get Expert Help

• machine learning, NLP, data mining

• custom SW design, development, optimizations

• tech trainings & IT consulting

models.word2vec – Deep learning with word2vec

# `models.word2vec` – Deep learning with word2vec

Deep learning via word2vec’s “skip-gram and CBOW models”, using either hierarchical softmax or negative sampling [1] [2].

The training algorithms were originally ported from the C package https://code.google.com/p/word2vec/ and extended with additional functionality.

For a blog tutorial on gensim word2vec, with an interactive web app trained on GoogleNews, visit http://radimrehurek.com/2014/02/word2vec-tutorial/

Make sure you have a C compiler before installing gensim, to use optimized (compiled) word2vec training (70x speedup compared to plain NumPy implemenation [3]).

Initialize a model with e.g.:

    >>> model = Word2Vec(sentences, size=100, window=5, min_count=5, workers=4)

Persist a model to disk with:

    >>> model.save(fname)
    >>> model = Word2Vec.load(fname)  # you can continue training with the loaded model!

The model can also be instantiated from an existing file on disk in the word2vec C format:

    >>> model = Word2Vec.load_word2vec_format('/tmp/vectors.txt', binary=False)  # C text format
    >>> model = Word2Vec.load_word2vec_format('/tmp/vectors.bin', binary=True)  # C binary format

You can perform various syntactic/semantic NLP word tasks with the model. Some of them are already built-in:

    >>> model.most_similar(positive=['woman', 'king'], negative=['man'])
    [('queen', 0.50882536), ...]

    >>> model.doesnt_match("breakfast cereal dinner lunch".split())
    'cereal'

    >>> model.similarity('woman', 'man')
    0.73723527

    >>> model['computer']  # raw numpy vector of a word
    array([-0.00449447, -0.00310097,  0.02421786, ...], dtype=float32)

and so on.

If you’re finished training a model (=no more updates, only querying), you can do

    >>> model.init_sims(replace=True)

to trim unneeded model memory = use (much) less RAM.

Note that there is a `gensim.models.phrases` module which lets you automatically detect phrases longer than one word. Using phrases, you can learn a word2vec model where “words” are actually multiword expressions, such as new_york_times or financial_crisis:

    >>> bigram_transformer = gensim.models.Phrases(sentences)
    >>> model = Word2Vec(bigram_transformed[sentences], size=100, ...)

[1] | Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient Estimation of Word Representations in Vector Space. In Proceedings of Workshop at ICLR, 2013.

[2] | Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg Corrado, and Jeffrey Dean. Distributed Representations of Words and Phrases and their Compositionality. In Proceedings of NIPS, 2013.

[3] | Optimizing word2vec in gensim, http://radimrehurek.com/2013/09/word2vec-in-python-part-two-optimizing/

class `gensim.models.word2vec.` `BrownCorpus`(dirname)

  Bases: `object`

  Iterate over sentences from the Brown corpus (part of NLTK data).

class `gensim.models.word2vec.` `LineSentence`(source)

  Bases: `object`

  Simple format: one sentence = one line; words already preprocessed and separated by whitespace.

  source can be either a string or a file object.

  Example:

      sentences = LineSentence('myfile.txt')

  Or for compressed files:

      sentences = LineSentence('compressed_text.txt.bz2')
      sentences = LineSentence('compressed_text.txt.gz')

class `gensim.models.word2vec.` `Text8Corpus`(fname, max_sentence_length=1000)

  Bases: `object`

  Iterate over sentences from the “text8” corpus, unzipped from http://mattmahoney.net/dc/text8.zip .

class `gensim.models.word2vec.` `Vocab`(**kwargs)

  Bases: `object`

  A single vocabulary item, used internally for constructing binary trees (incl. both word leaves and inner nodes).

class `gensim.models.word2vec.` `Word2Vec`(sentences=None, size=100, alpha=0.025, window=5, min_count=5, sample=0, seed=1, workers=1, min_alpha=0.0001, sg=1, hs=1, negative=0, cbow_mean=0, hashfxn=<built-in function hash>, iter=1)

  Bases: `gensim.utils.SaveLoad`

  Class for training, using and evaluating neural networks described in https://code.google.com/p/word2vec/

  The model can be stored/loaded via its save() and load() methods, or stored/loaded in a format compatible with the original word2vec implementation via save_word2vec_format() and load_word2vec_format().

  Initialize the model from an iterable of sentences. Each sentence is a list of words (unicode strings) that will be used for training.

  The sentences iterable can be simply a list, but for larger corpora, consider an iterable that streams the sentences directly from disk/network. See `BrownCorpus`, `Text8Corpus` or `LineSentence` in this module for such examples.

  If you don’t supply sentences, the model is left uninitialized – use if you plan to initialize it in some other way.

  sg defines the training algorithm. By default (sg=1), skip-gram is used. Otherwise, cbow is employed.

  size is the dimensionality of the feature vectors.

  window is the maximum distance between the current and predicted word within a sentence.

  alpha is the initial learning rate (will linearly drop to zero as training progresses).

  seed = for the random number generator. Initial vectors for each word are seeded with a hash of the concatenation of word + str(seed).

  min_count = ignore all words with total frequency lower than this.

  sample = threshold for configuring which higher-frequency words are randomly downsampled;
    default is 0 (off), useful value is 1e-5.

  workers = use this many worker threads to train the model (=faster training with multicore machines).

  hs = if 1 (default), hierarchical sampling will be used for model training (else set to 0).

  negative = if > 0, negative sampling will be used, the int for negative specifies how many “noise words” should be drawn (usually between 5-20).

  cbow_mean = if 0 (default), use the sum of the context word vectors. If 1, use the mean. Only applies when cbow is used.

  hashfxn = hash function to use to randomly initialize weights, for increased training reproducibility. Default is Python’s rudimentary built in hash function.

  iter = number of iterations (epochs) over the corpus.

  `accuracy`(questions, restrict_vocab=30000, most_similar=<function most_similar at 0x1152fded8>)

    Compute accuracy of the model. questions is a filename where lines are 4-tuples of words, split into sections by ”: SECTION NAME” lines. See https://code.google.com/p/word2vec/source/browse/trunk/questions-words.txt for an example.

    The accuracy is reported (=printed to log and returned as a list) for each section separately, plus there’s one aggregate summary at the end.

    Use restrict_vocab to ignore all questions containing a word whose frequency is not in the top-N most frequent words (default top 30,000).

    This method corresponds to the compute-accuracy script of the original C word2vec.

  `build_vocab`(sentences)

    Build vocabulary from a sequence of sentences (can be a once-only generator stream). Each sentence must be a list of unicode strings.

  `create_binary_tree`()

    Create a binary Huffman tree using stored vocabulary word counts. Frequent words will have shorter binary codes. Called internally from build_vocab().

  `doesnt_match`(words)

    Which word from the given list doesn’t go with the others?

    Example:

        >>> trained_model.doesnt_match("breakfast cereal dinner lunch".split())
        'cereal'

  `init_sims`(replace=False)

    Precompute L2-normalized vectors.

    If replace is set, forget the original vectors and only keep the normalized ones = saves lots of memory!

    Note that you cannot continue training after doing a replace. The model becomes effectively read-only = you can call most_similar, similarity etc., but not train.

  classmethod `load`(fname, mmap=None)

    Load a previously saved object from file (also see save).

    If the object was saved with large arrays stored separately, you can load these arrays via mmap (shared memory) using mmap=’r’. Default: don’t use mmap, load large arrays as normal objects.

  classmethod `load_word2vec_format`(fname, fvocab=None, binary=False, norm_only=True)

    Load the input-hidden weight matrix from the original C word2vec-tool format.

    Note that the information stored in the file is incomplete (the binary tree is missing), so while you can query for word similarity etc., you cannot continue training with a model loaded this way.

    binary is a boolean indicating whether the data is in binary word2vec format. norm_only is a boolean indicating whether to only store normalised word2vec vectors in memory. Word counts are read from fvocab filename, if set (this is the file generated by -save-vocab flag of the original C tool).

  static `log_accuracy`(section)
  `make_table`(table_size=100000000, power=0.75)

    Create a table using stored vocabulary word counts for drawing random words in the negative sampling training routines.

    Called internally from build_vocab().

  `most_similar`(positive=[], negative=[], topn=10)

    Find the top-N most similar words. Positive words contribute positively towards the similarity, negative words negatively.

    This method computes cosine similarity between a simple mean of the projection weight vectors of the given words, and corresponds to the word-analogy and distance scripts in the original word2vec implementation.

    Example:

        >>> trained_model.most_similar(positive=['woman', 'king'], negative=['man'])
        [('queen', 0.50882536), ...]

  `most_similar_cosmul`(positive=[], negative=[], topn=10)

    Find the top-N most similar words, using the multiplicative combination objective proposed by Omer Levy and Yoav Goldberg in [4]. Positive words still contribute positively towards the similarity, negative words negatively, but with less susceptibility to one large distance dominating the calculation.

    In the common analogy-solving case, of two positive and one negative examples, this method is equivalent to the “3CosMul” objective (equation (4)) of Levy and Goldberg.

    Additional positive or negative examples contribute to the numerator or denominator, respectively – a potentially sensible but untested extension of the method. (With a single positive example, rankings will be the same as in the default most_similar.)

    Example:

        >>> trained_model.most_similar_cosmul(positive=['baghdad','england'],negative=['london'])
        [(u'iraq', 0.8488819003105164), ...]

    [4] | Omer Levy and Yoav Goldberg. Linguistic Regularities in Sparse and Explicit Word Representations, 2014.

  `n_similarity`(ws1, ws2)

    Compute cosine similarity between two sets of words.

    Example:

        >>> trained_model.n_similarity(['sushi', 'shop'], ['japanese', 'restaurant'])
        0.61540466561049689

        >>> trained_model.n_similarity(['restaurant', 'japanese'], ['japanese', 'restaurant'])
        1.0000000000000004

        >>> trained_model.n_similarity(['sushi'], ['restaurant']) == trained_model.similarity('sushi', 'restaurant')
        True

  `precalc_sampling`()

    Precalculate each vocabulary item’s threshold for sampling

  `reset_weights`()

    Reset all projection weights to an initial (untrained) state, but keep the existing vocabulary.

  `save`(*args, **kwargs)

    Save the object to file (also see load).

    If separately is None, automatically detect large numpy/scipy.sparse arrays in the object being stored, and store them into separate files. This avoids pickle memory errors and allows mmap’ing large arrays back on load efficiently.

    You can also set separately manually, in which case it must be a list of attribute names to be stored in separate files. The automatic check is not performed in this case.

    ignore is a set of attribute names to not serialize (file handles, caches etc). On subsequent load() these attributes will be set to None.

  `save_word2vec_format`(fname, fvocab=None, binary=False)

    Store the input-hidden weight matrix in the same format used by the original C word2vec-tool, for compatibility.

  `similarity`(w1, w2)

    Compute cosine similarity between two words.

    Example:

        >>> trained_model.similarity('woman', 'man')
        0.73723527

        >>> trained_model.similarity('woman', 'woman')
        1.0

  `train`(sentences, total_words=None, word_count=0, chunksize=100)

    Update the model’s neural weights from a sequence of sentences (can be a once-only generator stream). Each sentence must be a list of unicode strings.

`gensim.models.word2vec.` `train_cbow_pair`(model, word, word2_indices, l1, alpha, labels, train_w1=True, train_w2=True)

`gensim.models.word2vec.` `train_sg_pair`(model, word, word2, alpha, labels, train_w1=True, train_w2=True)