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

#

models.word2vec – Deep learning with word2vec

# `models.word2vec` – Deep learning with word2vec

Deep learning via word2vec’s “hierarchical softmax skip-gram model” [1].

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

Install Cython with `pip install cython` before to use optimized word2vec training (70x speedup [2]).

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.

[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] | Optimizing word2vec in gensim, http://radimrehurek.com/2013/09/word2vec-in-python-part-two-optimizing/

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

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

class `gensim.models.word2vec.` `Text8Corpus`(fname)

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

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

  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, seed=1, workers=1, min_alpha=0.0001)

  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 (utf8 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.

  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. min_count = ignore all words with total frequency lower than this. workers = use this many worker threads to train the model (=faster training with multicore machines)

  `accuracy`(questions, restrict_vocab=30000)

    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 utf8 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'

  classmethod `load`(fname)

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

  classmethod `load_word2vec_format`(fname, binary=False)

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

    Note that the information loaded 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.

  `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), ...]

  `reset_weights`()

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

  `save`(fname)

    Save the object to file via pickling (also see load).

  `save_word2vec_format`(fname, 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 utf8 strings.