Word2Vec/Doc2Vec offer model-minimization method Fix issue #446

gensim/models/doc2vec.py

@@ -392,6 +392,7 @@ def init_sims(self, replace=False):
         etc., but not `train` or `infer_vector`.
 
         """
+        print ('HELLO DOC!!!')
         if getattr(self, 'doctag_syn0norm', None) is None or replace:
             logger.info("precomputing L2-norms of doc weight vectors")
             if replace:
@@ -508,8 +509,8 @@ def similarity_unseen_docs(self, model, doc_words1, doc_words2, alpha=0.1, min_a
         d1 = model.infer_vector(doc_words=doc_words1, alpha=alpha, min_alpha=min_alpha, steps=steps)
         d2 = model.infer_vector(doc_words=doc_words2, alpha=alpha, min_alpha=min_alpha, steps=steps)
         return dot(matutils.unitvec(d1), matutils.unitvec(d2))
-        
-        
+
+
 class Doctag(namedtuple('Doctag', 'offset, word_count, doc_count')):
     """A string document tag discovered during the initial vocabulary
     scan. (The document-vector equivalent of a Vocab object.)
@@ -553,7 +554,7 @@ def __init__(self, documents=None, size=300, alpha=0.025, window=8, min_count=5,
 
         `alpha` is the initial learning rate (will linearly drop to zero as training progresses).
 
-        `seed` = for the random number generator. 
+        `seed` = for the random number generator.
         Note that for a fully deterministically-reproducible run, you must also limit the model to
         a single worker thread, to eliminate ordering jitter from OS thread scheduling. (In Python
         3, reproducibility between interpreter launches also requires use of the PYTHONHASHSEED
@@ -570,7 +571,7 @@ def __init__(self, documents=None, size=300, alpha=0.025, window=8, min_count=5,
 
         `workers` = use this many worker threads to train the model (=faster training with multicore machines).
 
-        `iter` = number of iterations (epochs) over the corpus. The default inherited from Word2Vec is 5, 
+        `iter` = number of iterations (epochs) over the corpus. The default inherited from Word2Vec is 5,
         but values of 10 or 20 are common in published 'Paragraph Vector' experiments.
 
         `hs` = if 1 (default), hierarchical sampling will be used for model training (else set to 0).
@@ -778,6 +779,15 @@ def __str__(self):
             segments.append('t%d' % self.workers)
         return '%s(%s)' % (self.__class__.__name__, ','.join(segments))
 
+    def finished_training(self):
+        """
+        Discard parametrs that are used in training and score. Use if you're sure you're done training a model.
+        """
+        self._minimize_model(self.hs, self.negative > 0, True)
+        if hasattr(self, 'doctag_syn0'):
+            del self.doctag_syn0
+        if hasattr(self, 'doctag_syn0_lockf'):
+            del self.doctag_syn0_lockf
 
 class TaggedBrownCorpus(object):
     """Iterate over documents from the Brown corpus (part of NLTK data), yielding

gensim/models/word2vec.py

@@ -1750,6 +1750,24 @@ def accuracy(self, questions, restrict_vocab=30000, most_similar=most_similar, c
     def __str__(self):
         return "%s(vocab=%s, size=%s, alpha=%s)" % (self.__class__.__name__, len(self.index2word), self.vector_size, self.alpha)
 
+    def _minimize_model(self, save_syn1 = False, save_syn1neg = False, save_syn0_lockf = False):
+        if hasattr(self, 'syn1') and not save_syn1:
+            del self.syn1
+        if hasattr(self, 'syn1neg') and not save_syn1neg:
+            del self.syn1neg
+        if hasattr(self, 'syn0_lockf') and not save_syn0_lockf:
+            del self.syn0_lockf
+
+    def finished_training(self):
+        """
+        Discard parametrs that are used in training and score. Use if you're sure you're done training a model.
+        """
+        self.training_finished = True
+        for i in xrange(self.syn0.shape[0]):
+            self.syn0[i, :] /= sqrt((self.syn0[i, :] ** 2).sum(-1))
+        self.syn0norm = self.syn0
+        self._minimize_model()
+
     def save(self, *args, **kwargs):
         # don't bother storing the cached normalized vectors, recalculable table
         kwargs['ignore'] = kwargs.get('ignore', ['syn0norm', 'table', 'cum_table'])

gensim/test/test_doc2vec.py

@@ -280,6 +280,24 @@ def models_equal(self, model, model2):
         self.assertEqual(len(model.docvecs.offset2doctag), len(model2.docvecs.offset2doctag))
         self.assertTrue(np.allclose(model.docvecs.doctag_syn0, model2.docvecs.doctag_syn0))
 
+    def test_finished_training(self):
+        """Test doc2vec model after finishing training"""
+        for i in [0, 1]:
+            for j in [0, 1]:
+                model = doc2vec.Doc2Vec(sentences, size=5, min_count=1, hs=i, negative=j)
+                model.finished_training()
+                self.assertTrue(len(model['human']), 10)
+                self.assertTrue(model.vocab['graph'].count, 5)
+                if (i == 1):
+                    self.assertTrue(hasattr(model, 'syn1'))
+                else:
+                    self.assertTrue(not hasattr(model, 'syn1'))
+                if (j == 1):
+                    self.assertTrue(hasattr(model, 'syn1neg'))
+                else:
+                    self.assertTrue(not hasattr(model, 'syn1neg'))
+                self.assertTrue(hasattr(model, 'syn0_lockf'))
+
     @log_capture()
     def testBuildVocabWarning(self, l):
         """Test if logger warning is raised on non-ideal input to a doc2vec model"""

gensim/test/test_word2vec.py

@@ -434,7 +434,7 @@ def testSimilarities(self):
         model = word2vec.Word2Vec(size=2, min_count=1, sg=0, hs=0, negative=2)
         model.build_vocab(sentences)
         model.train(sentences)
-        
+
         self.assertTrue(model.n_similarity(['graph', 'trees'], ['trees', 'graph']))
         self.assertTrue(model.n_similarity(['graph'], ['trees']) == model.similarity('graph', 'trees'))
         self.assertRaises(ZeroDivisionError, model.n_similarity, ['graph', 'trees'], [])
@@ -482,6 +482,24 @@ def models_equal(self, model, model2):
         most_common_word = max(model.vocab.items(), key=lambda item: item[1].count)[0]
         self.assertTrue(numpy.allclose(model[most_common_word], model2[most_common_word]))
 
+    def testFinishedTraining(self):
+        """Test word2vec model after finishing training"""
+        for i in [0, 1]:
+            for j in [0, 1]:
+                model = word2vec.Word2Vec(sentences, size=10, min_count=0, seed=42, hs=i, negative=j)
+                model.finished_training()
+                self.assertTrue(len(model['human']), 10)
+                self.assertTrue(len(model.vocab), 12)
+                self.assertTrue(model.vocab['graph'].count, 3)
+                self.assertTrue(not hasattr(model, 'syn1'))
+                self.assertTrue(not hasattr(model, 'syn1neg'))
+                self.assertTrue(not hasattr(model, 'syn0_lockf'))
+        model = word2vec.Word2Vec(sentences, min_count=1)
+        model.save_word2vec_format(testfile(), binary=True)
+        norm_only_model = word2vec.Word2Vec.load_word2vec_format(testfile(), binary=True)
+        norm_only_model.finished_training()
+        self.assertFalse(numpy.allclose(model['human'], norm_only_model['human']))
+
     @log_capture()
     def testBuildVocabWarning(self, l):
         """Test if warning is raised on non-ideal input to a word2vec model"""