diff --git a/CHANGELOG.md b/CHANGELOG.md
index e19a2f3944..0c695cf0f5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,153 @@
 Changes
 ===========
+## 3.3.0, 2018-01-02
+
+:star2: New features:
+* Re-designed all "*2vec" implementations (__[@manneshiva](https://github.com/manneshiva)__, [#1777](https://github.com/RaRe-Technologies/gensim/pull/1777))
+    - Modular organization of `Word2Vec`, `Doc2Vec`, `FastText`, etc ..., making it easier to add new models in the future and re-use code
+    - Fully backward compatible (even with loading models stored by a previous Gensim version)
+    - [Detailed documentation for the *2vec refactoring project](https://github.com/manneshiva/gensim/wiki/Any2Vec-Refactoring-Summary)
+
+* Improve `gensim.scripts.segment_wiki` by retaining interwiki links. Fix #1712
+ (__[@steremma](https://github.com/steremma)__, [PR #1839](https://github.com/RaRe-Technologies/gensim/pull/1839))
+    - Optionally extract interlinks from Wikipedia pages (use the `--include-interlinks` option). This will output one additional JSON dict for each article:
+        ```
+        {
+            "interlinks": {
+                "article title 1": "interlink text 1",
+                "article title 2": "interlink text 2",
+                ...
+            }
+        }
+        ```
+
+    - Example: extract the Wikipedia graph with article links as edges, from a raw Wikipedia dump:
+        ```bash
+        python -m gensim.scripts.segment_wiki --include-interlinks --file ~/Downloads/enwiki-latest-pages-articles.xml.bz2 --output ~/Desktop/enwiki-latest.jsonl.gz
+        ```
+        - Read this field from the `segment_wiki` output:
+
+        ```python
+        import json
+        from smart_open import smart_open
+
+        with smart_open("enwiki-latest.jsonl.gz") as infile:
+            for doc in infile:
+                doc = json.loads(doc)
+
+                src_node = doc['title']
+                dst_nodes = doc['interlinks'].keys()
+
+                print(u"Source node: {}".format(src_node))
+                print(u"Destination nodes: {}".format(u", ".join(dst_nodes)))
+                break
+
+        """
+        OUTPUT:
+
+        Source node: Anarchism
+        Destination nodes: anarcha-feminist, Ivan Illich, Adolf Brand, Josiah Warren, will (philosophy), anarcha-feminism, Anarchism in Mexico, Lysander Spooner, English Civil War, G8, Sebastien Faure, Nihilist movement, Sébastien Faure, Left-wing politics, imamate, Pierre Joseph Proudhon, anarchist communism, Università popolare (Italian newspaper), 1848 Revolution, Synthesis anarchism, labour movement, anarchist communists, collectivist anarchism, polyamory, post-humanism, postcolonialism, anti war movement, State (polity), security culture, Catalan people, Stoicism, Progressive education, stateless society, Umberto I of Italy, German language, Anarchist schools of thought, NEFAC, Jacques Ellul, Spanish Communist Party, Crypto-anarchism, ruling class, non-violence, Platformist, The History of Sexuality, Revolutions of 1917–23, Federación Anarquista Ibérica, propaganda of the deed, William B. Greene, Platformism, mutually exclusive, Fraye Arbeter Shtime, Adolf Hitler, oxymoron, Paris Commune, Anarchism in Italy#Postwar years and today, Oranienburg, abstentionism, Free Society, Henry David Thoreau, privative alpha, George I of Greece, communards, Gustav Landauer, Lucifer the Lightbearer, Moses Harman, coercion, regicide, rationalist, Resistance during World War II, Christ (title), Bohemianism, individualism, Crass, black bloc, Spanish Revolution of 1936, Erich Mühsam, Empress Elisabeth of Austria, Free association (communism and anarchism), general strike, Francesc Ferrer i Guàrdia, Catalan anarchist pedagogue and free-thinker, veganarchism, Traditional knowledge, Japanese Anarchist Federation, Diogenes of Sinope, Hierarchy, sexual revolution, Naturism, Bavarian Soviet Republic, February Revolution, Eugene Varlin, Renaissance humanism, Mexican Liberal Party, Friedrich Engels, Fernando Tarrida del Mármol, Caliphate, Marxism, Jesus, John Cage, Umanita Nova, Anarcho-pacifism, Peter Kropotkin, Religious anarchism, Anselme Bellegarrigue, civilisation, moral obligation, hedonist, Free Territory (Ukraine), -ism, neo-liberalism, Austrian School, philosophy, freethought, Joseph Goebbels, Conservatism, anarchist economics, Cavalier, Maximilien de Robespierre, Comstockery, Dorothy Day, Anarchism in France, Fédération anarchiste, World Economic Forum, Amparo Poch y Gascón, Sex Pistols, women's rights, collectivisation, Taoism, common ownership, William Batchelder Greene, Collective farming, popular education, biphobia, targeted killings, Protestant Christianity, state socialism, Marie François Sadi Carnot, Stephen Pearl Andrews, World Trade Organization, Communist Party of Spain (main), Pluto Press, Levante, Spain, Alexander Berkman, Wilhelm Weitling, Kharijites, Bolshevik, Liberty (1881–1908), Anarchist Aragon, social democrats, Dielo Truda, Post-left anarchy, Age of Enlightenment, Blanquism, Walden, mutual aid (organization), Far-left politics, privative, revolutions of 1848, anarchism and nationalism, punk rock, Étienne de La Boétie, Max Stirner, Jacobin (politics), agriculture, anarchy, Confederacion General del Trabajo de España, toleration, reformism, International Anarchist Congress of Amsterdam, The Ego and Its Own, Ukraine, Civil Disobedience (Thoreau), Spanish Civil War, David Graeber, Anarchism and issues related to love and sex, James Guillaume, Insurrectionary anarchism, Political repression, International Workers' Association, Barcelona, Bulgaria, Voline, Zeno of Citium, anarcho-communists, organized religion, libertarianism, bisexuality, Ricardo Flores Magón, Henri Zisly, Eight-hour day, Freetown Christiania, heteronormativity, Mikhail Bakunin, Propagandaministerium, Ezra Heywood, individual reappropriation, Modern School (United States), archon, Confédération nationale du travail, socialist movement, History of Islam, Max Nettlau, Political Justice, Reichstag fire, Anti-Christianity, decentralised, Issues in anarchism#Communism, deschooling, Christian movement, squatter, Anarchism in Germany, Catalonia, Louise Michel, Solidarity Federation, What is Property?, European individualist anarchism, Pierre-Joseph Proudhon, Mexican Revolution, wikt:anarchism, Blackshirts, Jewish anarchism, Russian Civil War, property rights, anti-authoritarian, individual reclamation, propaganda by the deed, from each according to his ability, to each according to his need, Feminist movement, Confiscation, social anarchism, Anarchism in Russia, Daniel Guérin, Uruguayan Anarchist Federation, Anarcha-feminism, Enragés, Cynicism (philosophy), workers' council, The Word (free love), Allen Ginsberg, Campaign for Nuclear Disarmament, antimilitarism, Workers' self-management, Federación Obrera Regional Argentina, self-governance, free market, Carlos I of Portugal, Simon Critchley, Anti-clericalism, heterosexual, Layla AbdelRahim, Mexican Anarchist Federation, Anarchism and Marxism, October Revolution, Anti-nuclear movement, Joseph Déjacque, Bolsheviks, Luigi Fabbri, morality, Communist party, Sam Dolgoff, united front, Ammon Hennacy, social ecology, commune (intentional community), Oscar Wilde, French Revolution, egoist anarchism, Comintern, transphobia, anarchism without adjectives, social control, means of production, Michel Onfray, Anarchism in France#The Fourth Republic (1945–1958), syndicalism, Anarchism in Spain, Iberian Anarchist Federation, International of Anarchist Federations, Emma Goldman, Netherlands, anarchist free school, International Workingmen's Association, Queer anarchism, Cantonal Revolution, trade unionism, Karl Marx, LGBT community, humanism, Anti-fascism, Carrara, political philosophy, Anarcho-transhumanism, libertarian socialist, Russian Revolution (1917), Two Cheers for Anarchism: Six Easy Pieces on Autonomy, Dignity, and Meaningful Work and Play, Emile Armand, insurrectionary anarchism, individual, Zhuang Zhou, Free Territory, White movement, Greenwich Village, Virginia Bolten, transcendentalist, public choice theory, wikt:brigand, Issues in anarchism#Participation in statist democracy, free love, Mutualism (economic theory), Anarchist St. Imier International, censorship, federalist, 6 February 1934 crisis, biennio rosso, anti-clerical, centralism, Anarchism: A Documentary History of Libertarian Ideas, minarchism, James C. Scott, First International, homosexuality, political theology, spontaneous order, Oranienburg concentration camp, anarcho-communism, negative liberty, post-modernism, Anarchism in Italy, Leopold Kohr, union of egoists, counterculture, Miguel Gimenez Igualada, philosophical anarchism, International Libertarian Solidarity, homosexual, Counterculture of the 1960s, Errico Malatesta, strikebreaker, Workers' Party of Marxist Unification, Clifford Harper, Reification (fallacy), patriarchy, anarchist law, Apostle (Christian), market (economics), Summerhill School, positive liberty, socialism, feminism, Direct action, Melchor Rodríguez García, William Godwin, Nazi concentration camps, Synthesist anarchism, Margaret Anderson, Han Ryner, Federation of Organized Trades and Labor Unions, technology, Workers Solidarity Movement, Edmund Burke, Encyclopædia Britannica, state (polity), Herbert Read, Park Güell, utilitarian, far right leagues, Limited government, self-ownership, Pejorative, homophobia, Industrial Workers of the World, The Dispossessed, Hague Congress (1872), Stalinism, Reciprocity (cultural anthropology), Fernand Pelloutier, individualist anarchism in France, The False Principle of our Education, individualist anarchism, Pierre Monatte, Soviet Union, counter-economics, Rudolf Rocker, Anarchism and capitalism, Parma, Black Rose Books, lesbian, Arditi del Popolo, Emile Armand (1872–1962), who propounded the virtues of free love in the Parisian anarchist milieu of the early 20th century, collectivism, Development criticism, John Henry Mackay, Benoît Broutchoux, Illegalism, Laozi, feminist, Christiaan Cornelissen, Syndicalist Workers' Federation, anarcho-syndicalism, Andalusia, Renzo Novatore, trade union, autonomist marxism, dictatorship of the proletariat, Mujeres Libres, Voltairine de Cleyre, Post-anarchism, participatory economics, Confederación Nacional del Trabajo, Syncretic politics, direct democracy, Jean-Jacques Rousseau, Green anarchism, Surrealism, labour unions, A. S. Neill, christian anarchist, Bonnot Gang, Anti-capitalism, Anarchism in Brazil, simple living, enlightened self-interest, Confédération générale du travail, class conflict, International Workers' Day, Hébertists, Gerrard Winstanley, Francoism, anarcho-pacifist, Andrej Grubacic, individualist anarchist and social anarchist thinkers., April Carter, private property, penal colonies, Libertarian socialism, Camillo Berneri, Christian anarchism, transhumanism, Lucifer, the Light-Bearer, Edna St. Vincent Millay, unschooling, Leo Tolstoy, M. E. Lazarus, Spanish Anarchists, Buddhist anarchism, ideology, William McKinley, anarcho-primitivism, Francesc Pi i Margall, :Category:Anarchism by country, International Workers Association, Anarcho-capitalism, Lois Waisbrooker, wikt:Solidarity, Baja California, social revolution, Unione Sindacale Italiana, Lev Chernyi, Alex Comfort, Sonnenburg, Leon Czolgosz, Volin, utopian, Argentine Libertarian Federation, Nudism, Left-wing market anarchism, insurrection, definitional concerns in anarchist theory, infinitive, affinity group, World Trade Organization Ministerial Conference of 1999 protest activity, class struggle, nonviolence, John Zerzan, poststructuralist, Noam Chomsky, Second Fitna, Julian Beck, Philadelphes, League of Peace and Freedom, Fédération Anarchiste, Kronstadt rebellion, Cold War, André Breton, Silvio Gesell, libertarian anarchism, voluntary association, anti-globalisation movement, birth control, L. Susan Brown, anarcho-naturism, personal property, Roundhead, Harold Barclay, The Joy of Sex, Council communism, Lucía Sánchez Saornil, tyrannicide, Neopaganism, lois scélérates, Johann Most, Anarchist Catalonia, Albert Camus, Protests of 1968, Alexander II of Russia, Spain's economy, Federazione Anarchica Italiana, Cuba, German Revolution of 1918–1919, stirner, Property is theft, Situationist International, law and economics
+
+        ```
+
+* Add support for [SMART notation](https://nlp.stanford.edu/IR-book/html/htmledition/document-and-query-weighting-schemes-1.html) for `TfidfModel`. Fix #1785 (__[@markroxor](https://github.com/markroxor)__, [#1791](https://github.com/RaRe-Technologies/gensim/pull/1791))
+    - Natural extension of `TfidfModel` to allow different weighting and normalization schemes
+        ```python
+        from gensim.corpora import Dictionary
+        from gensim.models import TfidfModel
+        import gensim.downloader as api
+
+        data = api.load("text8")
+        dct = Dictionary(data)
+        corpus = [dct.doc2bow(line) for line in data]
+
+        # Train Tfidf model using the SMART notation, smartirs="ntc" where
+        # 'n' - natural term frequency
+        # 't' - idf document frequency
+        # 'c' - cosine normalization
+        #
+        # More information about possible values available in documentation or https://nlp.stanford.edu/IR-book/html/htmledition/document-and-query-weighting-schemes-1.html
+
+        model = TfidfModel(corpus, id2word=dct, smartirs="ntc")
+        vectorized_corpus = list(model[corpus])
+
+        ```
+    - [SMART Information Retrieval System (wiki)](https://en.wikipedia.org/wiki/SMART_Information_Retrieval_System)
+
+* Add CircleCI for building Gensim documentation. Fix #1807 (__[@menshikh-iv](https://github.com/menshikh-iv)__, [#1822](https://github.com/RaRe-Technologies/gensim/pull/1822))
+    - An easy way to preview the rendered documentation (especially, if don't use Linux)
+        - Go to "Details" link of CircleCI in your PR, click on the "Artifacts" tab, choose the HTML file that you want to view; a new tab will open with the rendered HTML page
+    - Integration with Github, to see the documentation directly from the pull request page
+        - Install a user-script plugin: [greasemonkey (for firefox)](https://addons.mozilla.org/en-US/firefox/addon/greasemonkey/) or [tampermonkey (for chrome)](https://chrome.google.com/webstore/detail/tampermonkey/dhdgffkkebhmkfjojejmpbldmpobfkfo?hl=en)
+        - Add [this user-script](https://gist.github.com/menshikh-iv/bfe9b8ef2db10e9511aa9fe5935a7289) to the plugin
+        - Now you’ll see a new button "See CircleCI doc for this PR" in each PR in the Gensim repository. Click it to see the full rendered documentation.
+
+
+:red_circle: Bug fixes:
+* Fix import in `get_my_ip`. Fix #1771 (__[@darindf](https://github.com/darindf)__, [#1772](https://github.com/RaRe-Technologies/gensim/pull/1772))
+* Fix tox.ini/setup.cfg configuration (__[@menshikh-iv](https://github.com/menshikh-iv)__, [#1815](https://github.com/RaRe-Technologies/gensim/pull/1815))
+* Fix formula in `gensim.summarization.bm25`. Fix #1828 (__[@sj29-innovate](https://github.com/sj29-innovate)__, [#1833](https://github.com/RaRe-Technologies/gensim/pull/1833))
+* Fix the train method of `TranslationMatrix` (__[@robotcator](https://github.com/robotcator)__, [#1838](https://github.com/RaRe-Technologies/gensim/pull/1838))
+* Fix positional params used for `gensim.models.CoherenceModel` in `gensim.models.callbacks` (__[@Alexjmsherman](https://github.com/Alexjmsherman)__, [#1823](https://github.com/RaRe-Technologies/gensim/pull/1823))
+* Fix parameter setting for `FastText.train`. Fix #1818 (__[@sj29-innovate](https://github.com/sj29-innovate)__, [#1837](https://github.com/RaRe-Technologies/gensim/pull/1837))
+* Pin python2 explicitly for building documentation (__[@menshikh-iv](https://github.com/menshikh-iv)__, [#1840](https://github.com/RaRe-Technologies/gensim/pull/1840))
+* Remove dispatcher deadlock for distributed LDA (__[@darindf](https://github.com/darindf)__, [#1817](https://github.com/RaRe-Technologies/gensim/pull/1817))
+* Fix `score_function` from `LexicalEntailmentEvaluation`. Fix #1858 (__[@hachibaka](https://github.com/hachibaka)__, [#1863](https://github.com/RaRe-Technologies/gensim/pull/1863))
+* Fix symmetrical case for hellinger distance. Fix #1854 (__[@caiyulun](https://github.com/caiyulun)__, [#1860](https://github.com/RaRe-Technologies/gensim/pull/1860))
+* Remove wrong logging at import. Fix #1706 (__[@menshikh-iv](https://github.com/menshikh-iv)__, [#1871](https://github.com/RaRe-Technologies/gensim/pull/1871))
+
+
+:books: Tutorial and doc improvements:
+* Refactor documentation API Reference for `gensim.summarization` (__[@yurkai](https://github.com/yurkai)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1709](https://github.com/RaRe-Technologies/gensim/pull/1709))
+* Fix docstrings for `gensim.similarities.index`. Partial fix #1666 (__[@menshikh-iv](https://github.com/menshikh-iv)__, [#1681](https://github.com/RaRe-Technologies/gensim/pull/1681))
+* Fix docstrings for `gensim.models.translation_matrix` (__[@KokuKUSIAKU](https://github.com/KokuKUSIAKU)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1806](https://github.com/RaRe-Technologies/gensim/pull/1806))
+* Fix docstrings for `gensim.models.rpmodel` (__[@jazzmuesli](https://github.com/jazzmuesli)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1802](https://github.com/RaRe-Technologies/gensim/pull/1802))
+* Fix docstrings for `gensim.utils` (__[@kakshay21](https://github.com/kakshay21)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1797](https://github.com/RaRe-Technologies/gensim/pull/1797))
+* Fix docstrings for `gensim.matutils` (__[@Cheukting](https://github.com/Cheukting)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1804](https://github.com/RaRe-Technologies/gensim/pull/1804))
+* Fix docstrings for `gensim.models.logentropy_model` (__[@minggli](https://github.com/minggli)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1803](https://github.com/RaRe-Technologies/gensim/pull/1803))
+* Fix docstrings for `gensim.models.normmodel` (__[@AustenLamacraft](https://github.com/AustenLamacraft)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1805](https://github.com/RaRe-Technologies/gensim/pull/1805))
+* Refactor API reference `gensim.topic_coherence`. Fix #1669 (__[@CLearERR](https://github.com/CLearERR)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1714](https://github.com/RaRe-Technologies/gensim/pull/1714))
+* Fix documentation for `gensim.corpora.dictionary` and `gensim.corpora.hashdictionary`. Partial fix #1671 (__[@CLearERR](https://github.com/CLearERR)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1814](https://github.com/RaRe-Technologies/gensim/pull/1814))
+* Fix documentation for `gensim.corpora`. Partial fix #1671 (__[@anotherbugmaster](https://github.com/anotherbugmaster)__ & __[@menshikh-iv](https://github.com/menshikh-iv)__, [#1729](https://github.com/RaRe-Technologies/gensim/pull/1729))
+* Update banner in doc pages (__[@piskvorky](https://github.com/piskvorky)__, [#1865](https://github.com/RaRe-Technologies/gensim/pull/1865))
+* Fix errors in the doc2vec-lee notebook (__[@PeterHamilton](https://github.com/PeterHamilton)__, [#1841](https://github.com/RaRe-Technologies/gensim/pull/1841))
+* Add wordnet mammal train file for Poincare notebook (__[@jayantj](https://github.com/jayantj)__, [#1781](https://github.com/RaRe-Technologies/gensim/pull/1781))
+* Update Poincare notebooks (#1774) (__[@jayantj](https://github.com/jayantj)__, [#1774](https://github.com/RaRe-Technologies/gensim/pull/1774))
+* Update contributing guide. Fix #1786 (__[@menshikh-iv](https://github.com/menshikh-iv)__, [#1793](https://github.com/RaRe-Technologies/gensim/pull/1793))
+* Add `model_to_dict` one-liner to word2vec notebook. Fix #1269 (__[@kakshay21](https://github.com/kakshay21)__, [#1776](https://github.com/RaRe-Technologies/gensim/pull/1776))
+* Add word embedding viz to word2vec notebook. Fix #1419 (__[@markroxor](https://github.com/markroxor)__, [#1800](https://github.com/RaRe-Technologies/gensim/pull/1800))
+* Fix description of `sg` parameter for `gensim.models.FastText` (__[@akutuzov](https://github.com/akutuzov)__, [#1801](https://github.com/RaRe-Technologies/gensim/pull/1801))
+* Fix typo in `doc2vec-IMDB`. Fix #1788 (__[@apoorvaeternity](https://github.com/apoorvaeternity)__, [#1796](https://github.com/RaRe-Technologies/gensim/pull/1796))
+* Remove outdated bz2 examples from tutorials[2] (__[@menshikh-iv](https://github.com/menshikh-iv)__, [#1868](https://github.com/RaRe-Technologies/gensim/pull/1868))
+* Remove outdated `bz2` + `MmCorpus` examples from tutorials (__[@menshikh-iv](https://github.com/menshikh-iv)__, [#1867](https://github.com/RaRe-Technologies/gensim/pull/1867))
+
+
+
+:+1: Improvements:
+* Refactor tests for `gensim.corpora.WikiCorpus` (__[@steremma](https://github.com/steremma)__, [#1821](https://github.com/RaRe-Technologies/gensim/pull/1821))
+
+
+:warning: Deprecations (will be removed in the next major release)
+* Remove
+    - `gensim.models.wrappers.fasttext` (obsoleted by the new native `gensim.models.fasttext` implementation)
+    - `gensim.examples`
+    - `gensim.nosy`
+    - `gensim.scripts.word2vec_standalone`
+    - `gensim.scripts.make_wiki_lemma`
+    - `gensim.scripts.make_wiki_online`
+    - `gensim.scripts.make_wiki_online_lemma`
+    - `gensim.scripts.make_wiki_online_nodebug`
+    - `gensim.scripts.make_wiki` (all of these obsoleted by the new native  `gensim.scripts.segment_wiki` implementation)
+    - "deprecated" functions and attributes
+
+* Move
+    - `gensim.scripts.make_wikicorpus` ➡ `gensim.scripts.make_wiki.py`
+    - `gensim.summarization` ➡ `gensim.models.summarization`
+    - `gensim.topic_coherence` ➡ `gensim.models._coherence`
+    - `gensim.utils` ➡ `gensim.utils.utils` (old imports will continue to work)
+    - `gensim.parsing.*` ➡ `gensim.utils.text_utils`
+
+
 ## 3.2.0, 2017-12-09
 
 :star2: New features:
diff --git a/docs/notebooks/doc2vec-lee.ipynb b/docs/notebooks/doc2vec-lee.ipynb
index 5ec5cf879f..aaeca5e224 100644
--- a/docs/notebooks/doc2vec-lee.ipynb
+++ b/docs/notebooks/doc2vec-lee.ipynb
@@ -610,11 +610,11 @@
    "source": [
     "# Pick a random document from the test corpus and infer a vector from the model\n",
     "doc_id = random.randint(0, len(test_corpus) - 1)\n",
-    "inferred_vector = model.infer_vector(test_corpus[doc_id].words)\n",
+    "inferred_vector = model.infer_vector(test_corpus[doc_id])\n",
     "sims = model.docvecs.most_similar([inferred_vector], topn=len(model.docvecs))\n",
     "\n",
     "# Compare and print the most/median/least similar documents from the train corpus\n",
-    "print('Test Document ({}): «{}»\\n'.format(doc_id, ' '.join(test_corpus[doc_id].words)))\n",
+    "print('Test Document ({}): «{}»\\n'.format(doc_id, ' '.join(test_corpus[doc_id])))\n",
     "print(u'SIMILAR/DISSIMILAR DOCS PER MODEL %s:\\n' % model)\n",
     "for label, index in [('MOST', 0), ('MEDIAN', len(sims)//2), ('LEAST', len(sims) - 1)]:\n",
     "    print(u'%s %s: «%s»\\n' % (label, sims[index], ' '.join(train_corpus[sims[index][0]].words)))"
diff --git a/docs/src/_static/css/style.css b/docs/src/_static/css/style.css
index e52a94e001..6ef7f74126 100644
--- a/docs/src/_static/css/style.css
+++ b/docs/src/_static/css/style.css
@@ -596,7 +596,7 @@ a.googlegroups{
 
 #middle1{
     float:left;
-    width:540px;
+    width:440px;
     padding-top: 53px;
 }
 
@@ -613,13 +613,13 @@ a.googlegroups{
 
 #right1 {
     float:right;
-    width: 351px;
+    width: 451px;
     padding-top: 53px;
 }
 
 .consulting-banner {
     background-color: #ff2010;
-    background-color: rgba(255, 32, 16, 0.2);
+    background-color: rgba(255, 32, 16, 0.4);
     padding: 1px 10px;
     -moz-border-radius: 15px;
     border-radius: 15px;
diff --git a/docs/src/apiref.rst b/docs/src/apiref.rst
index d67d27a16a..453b3ba864 100644
--- a/docs/src/apiref.rst
+++ b/docs/src/apiref.rst
@@ -55,6 +55,11 @@ Modules:
     models/wrappers/wordrank
     models/wrappers/varembed
     models/wrappers/fasttext
+    models/deprecated/doc2vec
+    models/deprecated/fasttext
+    models/deprecated/word2vec
+    models/deprecated/keyedvectors
+    models/deprecated/fasttext_wrapper
     similarities/docsim
     similarities/index
     sklearn_api/atmodel
diff --git a/docs/src/conf.py b/docs/src/conf.py
index d9b2935295..b8b108dbf6 100644
--- a/docs/src/conf.py
+++ b/docs/src/conf.py
@@ -53,9 +53,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = '3.2'
+version = '3.3'
 # The full version, including alpha/beta/rc tags.
-release = '3.2.0'
+release = '3.3.0'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
diff --git a/docs/src/dist_lsi.rst b/docs/src/dist_lsi.rst
index d221c330e9..15dfb41f9c 100644
--- a/docs/src/dist_lsi.rst
+++ b/docs/src/dist_lsi.rst
@@ -120,14 +120,14 @@ Distributed LSA on Wikipedia
 First, download and prepare the Wikipedia corpus as per :doc:`wiki`, then load
 the corpus iterator with::
 
-    >>> import logging, gensim, bz2
+    >>> import logging, gensim
     >>> logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
 
     >>> # load id->word mapping (the dictionary)
     >>> id2word = gensim.corpora.Dictionary.load_from_text('wiki_en_wordids.txt')
     >>> # load corpus iterator
     >>> mm = gensim.corpora.MmCorpus('wiki_en_tfidf.mm')
-    >>> # mm = gensim.corpora.MmCorpus(bz2.BZ2File('wiki_en_tfidf.mm.bz2')) # use this if you compressed the TFIDF output
+    >>> # mm = gensim.corpora.MmCorpus('wiki_en_tfidf.mm.bz2') # use this if you compressed the TFIDF output
 
     >>> print(mm)
     MmCorpus(3199665 documents, 100000 features, 495547400 non-zero entries)
diff --git a/docs/src/gensim_theme/layout.html b/docs/src/gensim_theme/layout.html
index c763ad9476..feac733791 100644
--- a/docs/src/gensim_theme/layout.html
+++ b/docs/src/gensim_theme/layout.html
@@ -33,7 +33,7 @@
 
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
   <head>
-    <!-- Google Tag Manager - JD-20170831 --> 
+    <!-- Google Tag Manager - JD-20170831 -->
     <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
     new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
     j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
@@ -79,10 +79,10 @@ <h1 class="h1gensim">
           </div>
           <div id="right1">
             <div class="consulting-banner">
-              <h3><a href="http://rare-technologies.com/">Get Expert Help</a></h3>
-              <p>• machine learning, NLP, data mining</p>
-              <p>• custom SW design, development, optimizations</p>
-              <p>• corporate trainings &amp; IT consulting</p>
+              <h3>Get Expert Help From The Gensim Authors</h3>
+              <p>• <a href="https://rare-technologies.com/">Consulting</a> in Machine Learning &amp; NLP</p>
+              <p>• Commercial document similarity engine: <a href="https://scaletext.com/">ScaleText.ai</a></p>
+              <p>• <a href="https://rare-technologies.com/corporate-training/">Corporate trainings</a> in Python Data Science and Deep Learning</p>
             </div>
           </div>
         </div>
diff --git a/docs/src/models/deprecated/doc2vec.rst b/docs/src/models/deprecated/doc2vec.rst
new file mode 100644
index 0000000000..e8fb2d96b3
--- /dev/null
+++ b/docs/src/models/deprecated/doc2vec.rst
@@ -0,0 +1,9 @@
+:mod:`models.deprecated.doc2vec` -- Deep learning with paragraph2vec
+====================================================================
+
+.. automodule:: gensim.models.deprecated.doc2vec
+    :synopsis: Deep learning with doc2vec
+    :members:
+    :inherited-members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/src/models/deprecated/fasttext.rst b/docs/src/models/deprecated/fasttext.rst
new file mode 100644
index 0000000000..08de0234d2
--- /dev/null
+++ b/docs/src/models/deprecated/fasttext.rst
@@ -0,0 +1,10 @@
+:mod:`models.deprecated.fasttext` -- FastText model
+===================================================
+
+.. automodule:: gensim.models.deprecated.fasttext
+    :synopsis: FastText model
+    :members:
+    :inherited-members:
+    :special-members: __getitem__
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/src/models/deprecated/fasttext_wrapper.rst b/docs/src/models/deprecated/fasttext_wrapper.rst
new file mode 100644
index 0000000000..020504de24
--- /dev/null
+++ b/docs/src/models/deprecated/fasttext_wrapper.rst
@@ -0,0 +1,10 @@
+:mod:`models.deprecated.fasttext_wrapper` -- Wrapper for Facebook implementation of FastText model
+==================================================================================================
+
+.. automodule:: gensim.models.deprecated.fasttext_wrapper
+    :synopsis: FastText model
+    :members:
+    :inherited-members:
+    :special-members: __getitem__
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/src/models/deprecated/keyedvectors.rst b/docs/src/models/deprecated/keyedvectors.rst
new file mode 100644
index 0000000000..7d55cbc798
--- /dev/null
+++ b/docs/src/models/deprecated/keyedvectors.rst
@@ -0,0 +1,9 @@
+:mod:`models.deprecated.keyedvectors` -- Store and query word vectors
+=====================================================================
+
+.. automodule:: gensim.models.deprecated.keyedvectors
+    :synopsis: Store and query word vectors
+    :members:
+    :inherited-members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/src/models/deprecated/word2vec.rst b/docs/src/models/deprecated/word2vec.rst
new file mode 100644
index 0000000000..3b80aaf196
--- /dev/null
+++ b/docs/src/models/deprecated/word2vec.rst
@@ -0,0 +1,9 @@
+:mod:`models.deprecated.word2vec` -- Deep learning with word2vec
+================================================================
+
+.. automodule:: gensim.models.deprecated.word2vec
+    :synopsis: Deep learning with word2vec
+    :members:
+    :inherited-members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/src/models/wrappers/fasttext.rst b/docs/src/models/wrappers/fasttext.rst
index 84877c2ca3..4476cc7b43 100644
--- a/docs/src/models/wrappers/fasttext.rst
+++ b/docs/src/models/wrappers/fasttext.rst
@@ -1,8 +1,8 @@
-:mod:`models.wrappers.fasttext` -- FastText Word Embeddings
-===========================================================
+:mod:`models.wrappers.fasttext` -- Wrapper for FastText implementation from Facebook
+====================================================================================
 
 .. automodule:: gensim.models.wrappers.fasttext
-    :synopsis: FastText Embeddings
+    :synopsis: FastText
     :members:
     :inherited-members:
     :undoc-members:
diff --git a/docs/src/wiki.rst b/docs/src/wiki.rst
index fc6c0f9e5d..2992cf8401 100644
--- a/docs/src/wiki.rst
+++ b/docs/src/wiki.rst
@@ -38,14 +38,14 @@ Latent Semantic Analysis
 
 First let's load the corpus iterator and dictionary, created in the second step above::
 
-    >>> import logging, gensim, bz2
+    >>> import logging, gensim
     >>> logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
 
     >>> # load id->word mapping (the dictionary), one of the results of step 2 above
     >>> id2word = gensim.corpora.Dictionary.load_from_text('wiki_en_wordids.txt')
     >>> # load corpus iterator
     >>> mm = gensim.corpora.MmCorpus('wiki_en_tfidf.mm')
-    >>> # mm = gensim.corpora.MmCorpus(bz2.BZ2File('wiki_en_tfidf.mm.bz2')) # use this if you compressed the TFIDF output (recommended)
+    >>> # mm = gensim.corpora.MmCorpus('wiki_en_tfidf.mm.bz2') # use this if you compressed the TFIDF output (recommended)
 
     >>> print(mm)
     MmCorpus(3931787 documents, 100000 features, 756379027 non-zero entries)
@@ -93,14 +93,14 @@ Latent Dirichlet Allocation
 
 As with Latent Semantic Analysis above, first load the corpus iterator and dictionary::
 
-    >>> import logging, gensim, bz2
+    >>> import logging, gensim
     >>> logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
 
     >>> # load id->word mapping (the dictionary), one of the results of step 2 above
     >>> id2word = gensim.corpora.Dictionary.load_from_text('wiki_en_wordids.txt')
     >>> # load corpus iterator
     >>> mm = gensim.corpora.MmCorpus('wiki_en_tfidf.mm')
-    >>> # mm = gensim.corpora.MmCorpus(bz2.BZ2File('wiki_en_tfidf.mm.bz2')) # use this if you compressed the TFIDF output
+    >>> # mm = gensim.corpora.MmCorpus('wiki_en_tfidf.mm.bz2') # use this if you compressed the TFIDF output
 
     >>> print(mm)
     MmCorpus(3931787 documents, 100000 features, 756379027 non-zero entries)
diff --git a/gensim/__init__.py b/gensim/__init__.py
index 0d96b46da0..8b1fb6817c 100644
--- a/gensim/__init__.py
+++ b/gensim/__init__.py
@@ -6,7 +6,7 @@
 from gensim import parsing, matutils, interfaces, corpora, models, similarities, summarization, utils  # noqa:F401
 import logging
 
-__version__ = '3.2.0'
+__version__ = '3.3.0'
 
 
 class NullHandler(logging.Handler):
diff --git a/gensim/corpora/ucicorpus.py b/gensim/corpora/ucicorpus.py
index a8911ee07f..6bff230c01 100644
--- a/gensim/corpora/ucicorpus.py
+++ b/gensim/corpora/ucicorpus.py
@@ -207,7 +207,7 @@ def save_corpus(fname, corpus, id2word=None, progress_cnt=10000, metadata=False)
             id2word = utils.dict_from_corpus(corpus)
             num_terms = len(id2word)
         else:
-            num_terms = 1 + max([-1] + id2word.keys())
+            num_terms = 1 + max([-1] + list(id2word))
 
         # write out vocabulary
         fname_vocab = utils.smart_extension(fname, '.vocab')
diff --git a/gensim/corpora/wikicorpus.py b/gensim/corpora/wikicorpus.py
index cd57f20109..06873e77d3 100644
--- a/gensim/corpora/wikicorpus.py
+++ b/gensim/corpora/wikicorpus.py
@@ -22,7 +22,6 @@
 
 """
 
-
 import bz2
 import logging
 import multiprocessing
@@ -45,7 +44,6 @@
 TOKEN_MIN_LEN = 2
 TOKEN_MAX_LEN = 15
 
-
 RE_P0 = re.compile(r'<!--.*?-->', re.DOTALL | re.UNICODE)
 """Comments."""
 RE_P1 = re.compile(r'<ref([> ].*?)(</ref>|/>)', re.DOTALL | re.UNICODE)
@@ -78,6 +76,8 @@
 """Categories."""
 RE_P15 = re.compile(r'\[\[([fF]ile:|[iI]mage)[^]]*(\]\])', re.UNICODE)
 """Remove File and Image templates."""
+RE_P16 = re.compile(r'\[{2}(.*?)\]{2}', re.UNICODE)
+"""Capture interlinks text and article linked"""
 
 IGNORED_NAMESPACES = [
     'Wikipedia', 'Category', 'File', 'Portal', 'Template',
@@ -93,34 +93,70 @@
 """
 
 
-def filter_wiki(raw):
+def find_interlinks(raw):
+    """Find all interlinks to other articles in the dump.
+
+    Parameters
+    ----------
+    raw : str
+        Unicode or utf-8 encoded string.
+
+    Returns
+    -------
+    dict
+        Mapping from the linked article to the actual text found.
+    """
+    filtered = filter_wiki(raw, promote_remaining=False, simplify_links=False)
+    interlinks_raw = re.findall(RE_P16, filtered)
+
+    interlinks = {}
+    for parts in [i.split('|') for i in interlinks_raw]:
+        actual_title = parts[0]
+        try:
+            interlink_text = parts[1]
+            interlinks[actual_title] = interlink_text
+        except IndexError:
+            interlinks[actual_title] = actual_title
+
+    legit_interlinks = {i: j for i, j in interlinks.items() if '[' not in i and ']' not in i}
+    return legit_interlinks
+
+
+def filter_wiki(raw, promote_remaining=True, simplify_links=True):
     """Filter out wiki markup from `raw`, leaving only text.
 
     Parameters
     ----------
     raw : str
         Unicode or utf-8 encoded string.
+    promote_remaining : bool
+        Whether uncaught markup should be promoted to plain text.
+    simplify_links : bool
+        Whether links should be simplified keeping only their description text.
 
     Returns
     -------
     str
         `raw` without markup.
-
     """
     # parsing of the wiki markup is not perfect, but sufficient for our purposes
     # contributions to improving this code are welcome :)
     text = utils.to_unicode(raw, 'utf8', errors='ignore')
     text = utils.decode_htmlentities(text)  # '&amp;nbsp;' --> '\xa0'
-    return remove_markup(text)
+    return remove_markup(text, promote_remaining, simplify_links)
 
 
-def remove_markup(text):
+def remove_markup(text, promote_remaining=True, simplify_links=True):
     """Filter out wiki markup from `text`, leaving only text.
 
     Parameters
     ----------
     text : str
         String containing markup.
+    promote_remaining : bool
+        Whether uncaught markup should be promoted to plain text.
+    simplify_links : bool
+        Whether links should be simplified keeping only their description text.
 
     Returns
     -------
@@ -145,8 +181,11 @@ def remove_markup(text):
         text = re.sub(RE_P11, '', text)  # remove all remaining tags
         text = re.sub(RE_P14, '', text)  # remove categories
         text = re.sub(RE_P5, '\\3', text)  # remove urls, keep description
-        text = re.sub(RE_P6, '\\2', text)  # simplify links, keep description only
+
+        if simplify_links:
+            text = re.sub(RE_P6, '\\2', text)  # simplify links, keep description only
         # remove table markup
+
         text = text.replace('||', '\n|')  # each table cell on a separate line
         text = re.sub(RE_P12, '\n', text)  # remove formatting lines
         text = re.sub(RE_P13, '\n\\3', text)  # leave only cell content
@@ -156,9 +195,9 @@ def remove_markup(text):
         if old == text or iters > 2:
             break
 
-    # the following is needed to make the tokenizer see '[[socialist]]s' as a single word 'socialists'
-    # TODO is this really desirable?
-    text = text.replace('[', '').replace(']', '')  # promote all remaining markup to plain text
+    if promote_remaining:
+        text = text.replace('[', '').replace(']', '')  # promote all remaining markup to plain text
+
     return text
 
 
@@ -333,7 +372,7 @@ def extract_pages(f, filter_namespaces=False):
                     text = None
 
             pageid = elem.find(pageid_path).text
-            yield title, text or "", pageid     # empty page will yield None
+            yield title, text or "", pageid  # empty page will yield None
 
             # Prune the element tree, as per
             # http://www.ibm.com/developerworks/xml/library/x-hiperfparse/
@@ -461,6 +500,7 @@ class WikiCorpus(TextCorpus):
     >>> MmCorpus.serialize('wiki_en_vocab200k.mm', wiki) # another 8h, creates a file in MatrixMarket format and mapping
 
     """
+
     def __init__(self, fname, processes=None, lemmatize=utils.has_pattern(), dictionary=None,
                  filter_namespaces=('0',), tokenizer_func=tokenize, article_min_tokens=ARTICLE_MIN_WORDS,
                  token_min_len=TOKEN_MIN_LEN, token_max_len=TOKEN_MAX_LEN, lower=True):
diff --git a/gensim/matutils.py b/gensim/matutils.py
index 3b4dce9c4a..570b025182 100644
--- a/gensim/matutils.py
+++ b/gensim/matutils.py
@@ -897,10 +897,9 @@ def hellinger(vec1, vec2):
     if isbow(vec1) and isbow(vec2):
         # if it is a BoW format, instead of converting to dense we use dictionaries to calculate appropriate distance
         vec1, vec2 = dict(vec1), dict(vec2)
-        if len(vec2) < len(vec1):
-            vec1, vec2 = vec2, vec1  # swap references so that we iterate over the shorter vector
+        indices = set(list(vec1.keys()) + list(vec2.keys()))
         sim = np.sqrt(
-            0.5 * sum((np.sqrt(value) - np.sqrt(vec2.get(index, 0.0)))**2 for index, value in iteritems(vec1))
+            0.5 * sum((np.sqrt(vec1.get(index, 0.0)) - np.sqrt(vec2.get(index, 0.0)))**2 for index in indices)
         )
         return sim
     else:
diff --git a/gensim/models/__init__.py b/gensim/models/__init__.py
index 88e0abf28d..4114724027 100644
--- a/gensim/models/__init__.py
+++ b/gensim/models/__init__.py
@@ -23,6 +23,7 @@
 from .translation_matrix import TranslationMatrix, BackMappingTranslationMatrix  # noqa:F401
 
 from . import wrappers  # noqa:F401
+from . import deprecated  # noqa:F401
 
 from gensim import interfaces, utils
 
diff --git a/gensim/models/base_any2vec.py b/gensim/models/base_any2vec.py
new file mode 100644
index 0000000000..e6a31263ec
--- /dev/null
+++ b/gensim/models/base_any2vec.py
@@ -0,0 +1,761 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Author: Shiva Manne <manneshiva@gmail.com>
+# Copyright (C) 2018 RaRe Technologies s.r.o.
+# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
+
+"""Contains base classes required for implementing any2vec algorithms."""
+from gensim import utils
+import logging
+from timeit import default_timer
+import threading
+from six.moves import xrange
+from six import itervalues
+from gensim import matutils
+from numpy import float32 as REAL, ones, random, dtype, zeros
+from types import GeneratorType
+from gensim.utils import deprecated
+import warnings
+
+try:
+    from queue import Queue
+except ImportError:
+    from Queue import Queue
+
+logger = logging.getLogger(__name__)
+
+
+class BaseAny2VecModel(utils.SaveLoad):
+    """Base class for training, using and evaluating any2vec model.
+    Contains implementation for multi-threaded training.
+
+    """
+
+    def __init__(self, workers=3, vector_size=100, epochs=5, callbacks=(), batch_words=10000):
+        """Initialize model parameters.
+
+        A subclass should initialize the following attributes:
+        - self.kv (instance of concrete implementation of `BaseKeyedVectors` interface)
+        - self.vocabulary (instance of concrete implementation of `BaseVocabBuilder` abstract class)
+        - self.trainables (instance of concrete implementation of `BaseTrainables` abstract class)
+
+        """
+        self.vector_size = int(vector_size)
+        self.workers = int(workers)
+        self.epochs = epochs
+        self.train_count = 0
+        self.total_train_time = 0
+        self.batch_words = batch_words
+        self.model_trimmed_post_training = False
+        self.callbacks = callbacks
+
+    def _get_job_params(self, cur_epoch):
+        """Get job parameters required for each batch."""
+        raise NotImplementedError()
+
+    def _set_train_params(self, **kwargs):
+        """Set model parameters required for training"""
+        raise NotImplementedError()
+
+    def _update_job_params(self, job_params, epoch_progress, cur_epoch):
+        """Get updated job parameters based on the epoch_progress and cur_epoch."""
+        raise NotImplementedError()
+
+    def _get_thread_working_mem(self):
+        """Get private working memory per thread."""
+        raise NotImplementedError()
+
+    def _raw_word_count(self, job):
+        """Get the number of words in a given job."""
+        raise NotImplementedError()
+
+    def _clear_post_train(self):
+        """Resets certain properties of the model post training. eg. `keyedvectors.vectors_norm`."""
+        raise NotImplementedError()
+
+    def _do_train_job(self, data_iterable, job_parameters, thread_private_mem):
+        """Train a single batch. Return 2-tuple `(effective word count, total word count)`."""
+        raise NotImplementedError()
+
+    def _check_training_sanity(self, epochs=None, total_examples=None, total_words=None, **kwargs):
+        """Check that the training parameters provided make sense. e.g. raise error if `epochs` not provided."""
+        raise NotImplementedError()
+
+    def _worker_loop(self, job_queue, progress_queue):
+        """Train the model, lifting lists of data from the job_queue."""
+        thread_private_mem = self._get_thread_working_mem()
+        jobs_processed = 0
+        while True:
+            job = job_queue.get()
+            if job is None:
+                progress_queue.put(None)
+                break  # no more jobs => quit this worker
+            data_iterable, job_parameters = job
+
+            for callback in self.callbacks:
+                callback.on_batch_begin(self)
+
+            tally, raw_tally = self._do_train_job(data_iterable, job_parameters, thread_private_mem)
+
+            for callback in self.callbacks:
+                callback.on_batch_end(self)
+
+            progress_queue.put((len(data_iterable), tally, raw_tally))  # report back progress
+            jobs_processed += 1
+        logger.debug("worker exiting, processed %i jobs", jobs_processed)
+
+    def _job_producer(self, data_iterator, job_queue, cur_epoch=0, total_examples=None, total_words=None):
+        """Fill jobs queue using the input `data_iterator`."""
+        job_batch, batch_size = [], 0
+        pushed_words, pushed_examples = 0, 0
+        next_job_params = self._get_job_params(cur_epoch)
+        job_no = 0
+
+        for data_idx, data in enumerate(data_iterator):
+            data_length = self._raw_word_count([data])
+
+            # can we fit this sentence into the existing job batch?
+            if batch_size + data_length <= self.batch_words:
+                # yes => add it to the current job
+                job_batch.append(data)
+                batch_size += data_length
+            else:
+                job_no += 1
+                job_queue.put((job_batch, next_job_params))
+
+                # update the learning rate for the next job
+                if total_examples:
+                    # examples-based decay
+                    pushed_examples += len(job_batch)
+                    epoch_progress = 1.0 * pushed_examples / total_examples
+                else:
+                    # words-based decay
+                    pushed_words += self._raw_word_count(job_batch)
+                    epoch_progress = 1.0 * pushed_words / total_words
+                next_job_params = self._update_job_params(next_job_params, epoch_progress, cur_epoch)
+
+                # add the sentence that didn't fit as the first item of a new job
+                job_batch, batch_size = [data], data_length
+        # add the last job too (may be significantly smaller than batch_words)
+        if job_batch:
+            job_no += 1
+            job_queue.put((job_batch, next_job_params))
+
+        if job_no == 0 and self.train_count == 0:
+            logger.warning(
+                "train() called with an empty iterator (if not intended, "
+                "be sure to provide a corpus that offers restartable iteration = an iterable)."
+            )
+
+        # give the workers heads up that they can finish -- no more work!
+        for _ in xrange(self.workers):
+            job_queue.put(None)
+        logger.debug("job loop exiting, total %i jobs", job_no)
+
+    def _log_progress(self, job_queue, progress_queue, cur_epoch, example_count, total_examples,
+                      raw_word_count, total_words, trained_word_count, elapsed):
+        raise NotImplementedError()
+
+    def _log_epoch_end(self, cur_epoch, example_count, total_examples, raw_word_count, total_words,
+                       trained_word_count, elapsed):
+        raise NotImplementedError()
+
+    def _log_train_end(self, raw_word_count, trained_word_count, total_elapsed, job_tally):
+        raise NotImplementedError()
+
+    def _log_epoch_progress(self, progress_queue, job_queue, cur_epoch=0, total_examples=None, total_words=None,
+                            report_delay=1.0):
+        example_count, trained_word_count, raw_word_count = 0, 0, 0
+        start, next_report = default_timer() - 0.00001, 1.0
+        job_tally = 0
+        unfinished_worker_count = self.workers
+
+        while unfinished_worker_count > 0:
+            report = progress_queue.get()  # blocks if workers too slow
+            if report is None:  # a thread reporting that it finished
+                unfinished_worker_count -= 1
+                logger.info("worker thread finished; awaiting finish of %i more threads", unfinished_worker_count)
+                continue
+            examples, trained_words, raw_words = report
+            job_tally += 1
+
+            # update progress stats
+            example_count += examples
+            trained_word_count += trained_words  # only words in vocab & sampled
+            raw_word_count += raw_words
+
+            # log progress once every report_delay seconds
+            elapsed = default_timer() - start
+            if elapsed >= next_report:
+                self._log_progress(
+                    job_queue, progress_queue, cur_epoch, example_count, total_examples,
+                    raw_word_count, total_words, trained_word_count, elapsed)
+                next_report = elapsed + report_delay
+        # all done; report the final stats
+        elapsed = default_timer() - start
+        self._log_epoch_end(
+            cur_epoch, example_count, total_examples, raw_word_count, total_words,
+            trained_word_count, elapsed)
+        self.total_train_time += elapsed
+        return trained_word_count, raw_word_count, job_tally
+
+    def _train_epoch(self, data_iterable, cur_epoch=0, total_examples=None,
+                     total_words=None, queue_factor=2, report_delay=1.0):
+        """Train one epoch."""
+        job_queue = Queue(maxsize=queue_factor * self.workers)
+        progress_queue = Queue(maxsize=(queue_factor + 1) * self.workers)
+
+        workers = [
+            threading.Thread(
+                target=self._worker_loop,
+                args=(job_queue, progress_queue,))
+            for _ in xrange(self.workers)
+        ]
+
+        workers.append(threading.Thread(
+            target=self._job_producer,
+            args=(data_iterable, job_queue),
+            kwargs={'cur_epoch': cur_epoch, 'total_examples': total_examples, 'total_words': total_words}))
+
+        for thread in workers:
+            thread.daemon = True  # make interrupting the process with ctrl+c easier
+            thread.start()
+
+        trained_word_count, raw_word_count, job_tally = self._log_epoch_progress(
+            progress_queue, job_queue, cur_epoch=cur_epoch, total_examples=total_examples, total_words=total_words,
+            report_delay=report_delay)
+
+        return trained_word_count, raw_word_count, job_tally
+
+    def train(self, data_iterable, epochs=None, total_examples=None,
+              total_words=None, queue_factor=2, report_delay=1.0, callbacks=(), **kwargs):
+        """Handle multi-worker training."""
+        self._set_train_params(**kwargs)
+        if callbacks:
+            self.callbacks = callbacks
+        self.epochs = epochs
+        self._check_training_sanity(
+            epochs=epochs,
+            total_examples=total_examples,
+            total_words=total_words, **kwargs)
+
+        for callback in self.callbacks:
+            callback.on_train_begin(self)
+
+        trained_word_count = 0
+        raw_word_count = 0
+        start = default_timer() - 0.00001
+        job_tally = 0
+
+        for cur_epoch in range(self.epochs):
+            for callback in self.callbacks:
+                callback.on_epoch_begin(self)
+
+            trained_word_count_epoch, raw_word_count_epoch, job_tally_epoch = self._train_epoch(
+                data_iterable, cur_epoch=cur_epoch, total_examples=total_examples, total_words=total_words,
+                queue_factor=queue_factor, report_delay=report_delay)
+            trained_word_count += trained_word_count_epoch
+            raw_word_count += raw_word_count_epoch
+            job_tally += job_tally_epoch
+
+            for callback in self.callbacks:
+                callback.on_epoch_end(self)
+
+        # Log overall time
+        total_elapsed = default_timer() - start
+        self._log_train_end(raw_word_count, trained_word_count, total_elapsed, job_tally)
+
+        self.train_count += 1  # number of times train() has been called
+        self._clear_post_train()
+
+        for callback in self.callbacks:
+            callback.on_train_end(self)
+        return trained_word_count, raw_word_count
+
+    @classmethod
+    def load(cls, fname_or_handle, **kwargs):
+        return super(BaseAny2VecModel, cls).load(fname_or_handle, **kwargs)
+
+    def save(self, fname_or_handle, **kwargs):
+        super(BaseAny2VecModel, self).save(fname_or_handle, **kwargs)
+
+
+class BaseWordEmbeddingsModel(BaseAny2VecModel):
+    """
+    Base class containing common methods for training, using & evaluating word embeddings learning models.
+    For example - `Word2Vec`, `FastText`, etc.
+
+    """
+
+    def _clear_post_train(self):
+        raise NotImplementedError()
+
+    def _do_train_job(self, data_iterable, job_parameters, thread_private_mem):
+        raise NotImplementedError()
+
+    def _set_train_params(self, **kwargs):
+        raise NotImplementedError()
+
+    def __init__(self, sentences=None, workers=3, vector_size=100, epochs=5, callbacks=(), batch_words=10000,
+                 trim_rule=None, sg=0, alpha=0.025, window=5, seed=1, hs=0, negative=5, cbow_mean=1,
+                 min_alpha=0.0001, compute_loss=False, fast_version=0, **kwargs):
+        self.sg = int(sg)
+        if vector_size % 4 != 0:
+            logger.warning("consider setting layer size to a multiple of 4 for greater performance")
+        self.alpha = float(alpha)
+        self.window = int(window)
+        self.random = random.RandomState(seed)
+        self.min_alpha = float(min_alpha)
+        self.hs = int(hs)
+        self.negative = int(negative)
+        self.cbow_mean = int(cbow_mean)
+        self.compute_loss = bool(compute_loss)
+        self.running_training_loss = 0
+        self.min_alpha_yet_reached = float(alpha)
+        self.corpus_count = 0
+
+        super(BaseWordEmbeddingsModel, self).__init__(
+            workers=workers, vector_size=vector_size, epochs=epochs, callbacks=callbacks, batch_words=batch_words)
+
+        if fast_version < 0:
+            warnings.warn(
+                "C extension not loaded, training will be slow. "
+                "Install a C compiler and reinstall gensim for fast training."
+            )
+            self.neg_labels = []
+            if self.negative > 0:
+                # precompute negative labels optimization for pure-python training
+                self.neg_labels = zeros(self.negative + 1)
+                self.neg_labels[0] = 1.
+
+        if sentences is not None:
+            if isinstance(sentences, GeneratorType):
+                raise TypeError("You can't pass a generator as the sentences argument. Try an iterator.")
+            self.build_vocab(sentences, trim_rule=trim_rule)
+            self.train(
+                sentences, total_examples=self.corpus_count, epochs=self.epochs, start_alpha=self.alpha,
+                end_alpha=self.min_alpha, compute_loss=compute_loss)
+        else:
+            if trim_rule is not None:
+                logger.warning(
+                    "The rule, if given, is only used to prune vocabulary during build_vocab() "
+                    "and is not stored as part of the model. Model initialized without sentences. "
+                    "trim_rule provided, if any, will be ignored.")
+
+    # for backward compatibility (aliases pointing to corresponding variables in trainables, vocabulary)
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.epochs instead")
+    def iter(self):
+        return self.epochs
+
+    @iter.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.epochs instead")
+    def iter(self, value):
+        self.epochs = value
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.syn1 instead")
+    def syn1(self):
+        return self.trainables.syn1
+
+    @syn1.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.syn1 instead")
+    def syn1(self, value):
+        self.trainables.syn1 = value
+
+    @syn1.deleter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.syn1 instead")
+    def syn1(self):
+        del self.trainables.syn1
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.syn1neg instead")
+    def syn1neg(self):
+        return self.trainables.syn1neg
+
+    @syn1neg.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.syn1neg instead")
+    def syn1neg(self, value):
+        self.trainables.syn1neg = value
+
+    @syn1neg.deleter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.syn1neg instead")
+    def syn1neg(self):
+        del self.trainables.syn1neg
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.vectors_lockf instead")
+    def syn0_lockf(self):
+        return self.trainables.vectors_lockf
+
+    @syn0_lockf.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.vectors_lockf instead")
+    def syn0_lockf(self, value):
+        self.trainables.vectors_lockf = value
+
+    @syn0_lockf.deleter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.vectors_lockf instead")
+    def syn0_lockf(self):
+        del self.trainables.vectors_lockf
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.layer1_size instead")
+    def layer1_size(self):
+        return self.trainables.layer1_size
+
+    @layer1_size.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.layer1_size instead")
+    def layer1_size(self, value):
+        self.trainables.layer1_size = value
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.hashfxn instead")
+    def hashfxn(self):
+        return self.trainables.hashfxn
+
+    @hashfxn.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.hashfxn instead")
+    def hashfxn(self, value):
+        self.trainables.hashfxn = value
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.vocabulary.sample instead")
+    def sample(self):
+        return self.vocabulary.sample
+
+    @sample.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.vocabulary.sample instead")
+    def sample(self, value):
+        self.vocabulary.sample = value
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.vocabulary.min_count instead")
+    def min_count(self):
+        return self.vocabulary.min_count
+
+    @min_count.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.vocabulary.min_count instead")
+    def min_count(self, value):
+        self.vocabulary.min_count = value
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.vocabulary.cum_table instead")
+    def cum_table(self):
+        return self.vocabulary.cum_table
+
+    @cum_table.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.vocabulary.cum_table instead")
+    def cum_table(self, value):
+        self.vocabulary.cum_table = value
+
+    @cum_table.deleter
+    @deprecated("Attribute will be removed in 4.0.0, use self.vocabulary.cum_table instead")
+    def cum_table(self):
+        del self.vocabulary.cum_table
+
+    def __str__(self):
+        return "%s(vocab=%s, size=%s, alpha=%s)" % (
+            self.__class__.__name__, len(self.wv.index2word), self.vector_size, self.alpha
+        )
+
+    def build_vocab(self, sentences, update=False, progress_per=10000, keep_raw_vocab=False, trim_rule=None, **kwargs):
+        """Build vocabulary from a sequence of sentences (can be a once-only generator stream).
+        Each sentence is a iterable of iterables (can simply be a list of unicode strings too).
+
+        Parameters
+        ----------
+        sentences : iterable of iterables
+            The `sentences` iterable can be simply a list of lists of tokens, but for larger corpora,
+            consider an iterable that streams the sentences directly from disk/network.
+            See :class:`~gensim.models.word2vec.BrownCorpus`, :class:`~gensim.models.word2vec.Text8Corpus`
+            or :class:`~gensim.models.word2vec.LineSentence` in :mod:`~gensim.models.word2vec` module for such examples.
+        update : bool
+            If true, the new words in `sentences` will be added to model's vocab.
+        progress_per : int
+            Indicates how many words to process before showing/updating the progress.
+
+        """
+        total_words, corpus_count = self.vocabulary.scan_vocab(
+            sentences, progress_per=progress_per, trim_rule=trim_rule)
+        self.corpus_count = corpus_count
+        report_values = self.vocabulary.prepare_vocab(
+            self.hs, self.negative, self.wv, update=update, keep_raw_vocab=keep_raw_vocab,
+            trim_rule=trim_rule, **kwargs)
+        report_values['memory'] = self.estimate_memory(vocab_size=report_values['num_retained_words'])
+        self.trainables.prepare_weights(self.hs, self.negative, self.wv, update=update, vocabulary=self.vocabulary)
+
+    def build_vocab_from_freq(self, word_freq, keep_raw_vocab=False, corpus_count=None, trim_rule=None, update=False):
+        """Build vocabulary from a dictionary of word frequencies.
+        Build model vocabulary from a passed dictionary that contains (word,word count).
+        Words must be of type unicode strings.
+
+        Parameters
+        ----------
+        word_freq : dict
+            Word,Word_Count dictionary.
+        keep_raw_vocab : bool
+            If not true, delete the raw vocabulary after the scaling is done and free up RAM.
+        corpus_count : int
+            Even if no corpus is provided, this argument can set corpus_count explicitly.
+        trim_rule : function
+            Vocabulary trimming rule, specifies whether certain words should remain in the vocabulary,
+            be trimmed away, or handled using the default (discard if word count < min_count).
+            Can be None (min_count will be used, look to :func:`~gensim.utils.keep_vocab_item`),
+            or a callable that accepts parameters (word, count, min_count) and returns either
+            :attr:`gensim.utils.RULE_DISCARD`, :attr:`gensim.utils.RULE_KEEP` or :attr:`gensim.utils.RULE_DEFAULT`.
+            Note: The rule, if given, is only used to prune vocabulary during build_vocab() and is not stored as part
+            of the model.
+        update : bool
+            If true, the new provided words in `word_freq` dict will be added to model's vocab.
+
+        Examples
+        --------
+        >>> from gensim.models import Word2Vec
+        >>>
+        >>> model= Word2Vec()
+        >>> model.build_vocab_from_freq({"Word1": 15, "Word2": 20})
+
+        """
+        logger.info("Processing provided word frequencies")
+        # Instead of scanning text, this will assign provided word frequencies dictionary(word_freq)
+        # to be directly the raw vocab
+        raw_vocab = word_freq
+        logger.info(
+            "collected %i different raw word, with total frequency of %i",
+            len(raw_vocab), sum(itervalues(raw_vocab))
+        )
+
+        # Since no sentences are provided, this is to control the corpus_count
+        self.corpus_count = corpus_count or 0
+        self.vocabulary.raw_vocab = raw_vocab
+
+        # trim by min_count & precalculate downsampling
+        report_values = self.vocabulary.prepare_vocab(
+            self.hs, self.negative, self.wv, keep_raw_vocab=keep_raw_vocab,
+            trim_rule=trim_rule, update=update)
+        report_values['memory'] = self.estimate_memory(vocab_size=report_values['num_retained_words'])
+        self.trainables.prepare_weights(
+            self.hs, self.negative, self.wv, update=update, vocabulary=self.vocabulary)  # build tables & arrays
+
+    def estimate_memory(self, vocab_size=None, report=None):
+        """Estimate required memory for a model using current settings and provided vocabulary size."""
+        vocab_size = vocab_size or len(self.wv.vocab)
+        report = report or {}
+        report['vocab'] = vocab_size * (700 if self.hs else 500)
+        report['vectors'] = vocab_size * self.vector_size * dtype(REAL).itemsize
+        if self.hs:
+            report['syn1'] = vocab_size * self.trainables.layer1_size * dtype(REAL).itemsize
+        if self.negative:
+            report['syn1neg'] = vocab_size * self.trainables.layer1_size * dtype(REAL).itemsize
+        report['total'] = sum(report.values())
+        logger.info(
+            "estimated required memory for %i words and %i dimensions: %i bytes",
+            vocab_size, self.vector_size, report['total']
+        )
+        return report
+
+    def train(self, sentences, total_examples=None, total_words=None,
+              epochs=None, start_alpha=None, end_alpha=None, word_count=0,
+              queue_factor=2, report_delay=1.0, compute_loss=False, callbacks=()):
+
+        self.alpha = start_alpha or self.alpha
+        self.min_alpha = end_alpha or self.min_alpha
+        self.compute_loss = compute_loss
+        self.running_training_loss = 0.0
+        return super(BaseWordEmbeddingsModel, self).train(
+            sentences, total_examples=total_examples, total_words=total_words,
+            epochs=epochs, start_alpha=start_alpha, end_alpha=end_alpha, word_count=word_count,
+            queue_factor=queue_factor, report_delay=report_delay, compute_loss=compute_loss, callbacks=callbacks)
+
+    def _get_job_params(self, cur_epoch):
+        """Get the parameter required for each batch."""
+        alpha = self.alpha - ((self.alpha - self.min_alpha) * float(cur_epoch) / self.epochs)
+        return alpha
+
+    def _update_job_params(self, job_params, epoch_progress, cur_epoch):
+        start_alpha = self.alpha
+        end_alpha = self.min_alpha
+        progress = (cur_epoch + epoch_progress) / self.epochs
+        next_alpha = start_alpha - (start_alpha - end_alpha) * progress
+        next_alpha = max(end_alpha, next_alpha)
+        self.min_alpha_yet_reached = next_alpha
+        return next_alpha
+
+    def _get_thread_working_mem(self):
+        work = matutils.zeros_aligned(self.trainables.layer1_size, dtype=REAL)  # per-thread private work memory
+        neu1 = matutils.zeros_aligned(self.trainables.layer1_size, dtype=REAL)
+        return work, neu1
+
+    def _raw_word_count(self, job):
+        """Get the number of words in a given job."""
+        return sum(len(sentence) for sentence in job)
+
+    def _check_training_sanity(self, epochs=None, total_examples=None, total_words=None, **kwargs):
+        if self.alpha > self.min_alpha_yet_reached:
+            logger.warning("Effective 'alpha' higher than previous training cycles")
+        if self.model_trimmed_post_training:
+            raise RuntimeError("Parameters for training were discarded using model_trimmed_post_training method")
+
+        if not self.wv.vocab:  # should be set by `build_vocab`
+            raise RuntimeError("you must first build vocabulary before training the model")
+        if not len(self.wv.vectors):
+            raise RuntimeError("you must initialize vectors before training the model")
+
+        if not hasattr(self, 'corpus_count'):
+            raise ValueError(
+                "The number of examples in the training corpus is missing. "
+                "Please make sure this is set inside `build_vocab` function."
+                "Call the `build_vocab` function before calling `train`."
+            )
+
+        if total_words is None and total_examples is None:
+            raise ValueError(
+                "You must specify either total_examples or total_words, for proper job parameters updation"
+                "and progress calculations. "
+                "The usual value is total_examples=model.corpus_count."
+            )
+        if epochs is None:
+            raise ValueError("You must specify an explict epochs count. The usual value is epochs=model.epochs.")
+        logger.info(
+            "training model with %i workers on %i vocabulary and %i features, "
+            "using sg=%s hs=%s sample=%s negative=%s window=%s",
+            self.workers, len(self.wv.vocab), self.trainables.layer1_size, self.sg,
+            self.hs, self.vocabulary.sample, self.negative, self.window
+        )
+
+    @classmethod
+    def load(cls, *args, **kwargs):
+        model = super(BaseWordEmbeddingsModel, cls).load(*args, **kwargs)
+        if model.negative and hasattr(model.wv, 'index2word'):
+            model.vocabulary.make_cum_table(model.wv)  # rebuild cum_table from vocabulary
+        if not hasattr(model, 'corpus_count'):
+            model.corpus_count = None
+        if not hasattr(model.trainables, 'vectors_lockf') and hasattr(model.wv, 'vectors'):
+            model.trainables.vectors_lockf = ones(len(model.wv.vectors), dtype=REAL)
+        if not hasattr(model, 'random'):
+            model.random = random.RandomState(model.trainables.seed)
+        if not hasattr(model, 'train_count'):
+            model.train_count = 0
+            model.total_train_time = 0
+        return model
+
+    def _log_progress(self, job_queue, progress_queue, cur_epoch, example_count, total_examples,
+                      raw_word_count, total_words, trained_word_count, elapsed):
+        if total_examples:
+            # examples-based progress %
+            logger.info(
+                "EPOCH %i - PROGRESS: at %.2f%% examples, %.0f words/s, in_qsize %i, out_qsize %i",
+                cur_epoch + 1, 100.0 * example_count / total_examples, trained_word_count / elapsed,
+                utils.qsize(job_queue), utils.qsize(progress_queue)
+            )
+        else:
+            # words-based progress %
+            logger.info(
+                "EPOCH %i - PROGRESS: at %.2f%% words, %.0f words/s, in_qsize %i, out_qsize %i",
+                cur_epoch + 1, 100.0 * raw_word_count / total_words, trained_word_count / elapsed,
+                utils.qsize(job_queue), utils.qsize(progress_queue)
+            )
+
+    def _log_epoch_end(self, cur_epoch, example_count, total_examples, raw_word_count, total_words,
+                       trained_word_count, elapsed):
+        logger.info(
+            "EPOCH - %i : training on %i raw words (%i effective words) took %.1fs, %.0f effective words/s",
+            cur_epoch + 1, raw_word_count, trained_word_count, elapsed, trained_word_count / elapsed
+        )
+
+        # check that the input corpus hasn't changed during iteration
+        if total_examples and total_examples != example_count:
+            logger.warning(
+                "EPOCH - %i : supplied example count (%i) did not equal expected count (%i)", cur_epoch + 1,
+                example_count, total_examples
+            )
+        if total_words and total_words != raw_word_count:
+            logger.warning(
+                "EPOCH - %i : supplied raw word count (%i) did not equal expected count (%i)", cur_epoch + 1,
+                raw_word_count, total_words
+            )
+
+    def _log_train_end(self, raw_word_count, trained_word_count, total_elapsed, job_tally):
+        logger.info(
+            "training on a %i raw words (%i effective words) took %.1fs, %.0f effective words/s",
+            raw_word_count, trained_word_count, total_elapsed, trained_word_count / total_elapsed
+        )
+        if job_tally < 10 * self.workers:
+            logger.warning(
+                "under 10 jobs per worker: consider setting a smaller `batch_words' for smoother alpha decay"
+            )
+
+    # for backward compatibility
+    @deprecated("Method will be removed in 4.0.0, use self.wv.most_similar() instead")
+    def most_similar(self, positive=None, negative=None, topn=10, restrict_vocab=None, indexer=None):
+        """
+        Deprecated. Use self.wv.most_similar() instead.
+        Refer to the documentation for `gensim.models.keyedvectors.WordEmbeddingsKeyedVectors.most_similar`
+        """
+        return self.wv.most_similar(positive, negative, topn, restrict_vocab, indexer)
+
+    @deprecated("Method will be removed in 4.0.0, use self.wv.wmdistance() instead")
+    def wmdistance(self, document1, document2):
+        """
+        Deprecated. Use self.wv.wmdistance() instead.
+        Refer to the documentation for `gensim.models.keyedvectors.WordEmbeddingsKeyedVectors.wmdistance`
+        """
+        return self.wv.wmdistance(document1, document2)
+
+    @deprecated("Method will be removed in 4.0.0, use self.wv.most_similar_cosmul() instead")
+    def most_similar_cosmul(self, positive=None, negative=None, topn=10):
+        """
+        Deprecated. Use self.wv.most_similar_cosmul() instead.
+        Refer to the documentation for `gensim.models.keyedvectors.WordEmbeddingsKeyedVectors.most_similar_cosmul`
+        """
+        return self.wv.most_similar_cosmul(positive, negative, topn)
+
+    @deprecated("Method will be removed in 4.0.0, use self.wv.similar_by_word() instead")
+    def similar_by_word(self, word, topn=10, restrict_vocab=None):
+        """
+        Deprecated. Use self.wv.similar_by_word() instead.
+        Refer to the documentation for `gensim.models.keyedvectors.WordEmbeddingsKeyedVectors.similar_by_word`
+        """
+        return self.wv.similar_by_word(word, topn, restrict_vocab)
+
+    @deprecated("Method will be removed in 4.0.0, use self.wv.similar_by_vector() instead")
+    def similar_by_vector(self, vector, topn=10, restrict_vocab=None):
+        """
+        Deprecated. Use self.wv.similar_by_vector() instead.
+        Refer to the documentation for `gensim.models.keyedvectors.WordEmbeddingsKeyedVectors.similar_by_vector`
+        """
+        return self.wv.similar_by_vector(vector, topn, restrict_vocab)
+
+    @deprecated("Method will be removed in 4.0.0, use self.wv.doesnt_match() instead")
+    def doesnt_match(self, words):
+        """
+        Deprecated. Use self.wv.doesnt_match() instead.
+        Refer to the documentation for `gensim.models.keyedvectors.WordEmbeddingsKeyedVectors.doesnt_match`
+        """
+        return self.wv.doesnt_match(words)
+
+    @deprecated("Method will be removed in 4.0.0, use self.wv.similarity() instead")
+    def similarity(self, w1, w2):
+        """
+        Deprecated. Use self.wv.similarity() instead.
+        Refer to the documentation for `gensim.models.keyedvectors.WordEmbeddingsKeyedVectors.similarity`
+        """
+        return self.wv.similarity(w1, w2)
+
+    @deprecated("Method will be removed in 4.0.0, use self.wv.n_similarity() instead")
+    def n_similarity(self, ws1, ws2):
+        """
+        Deprecated. Use self.wv.n_similarity() instead.
+        Refer to the documentation for `gensim.models.keyedvectors.WordEmbeddingsKeyedVectors.n_similarity`
+        """
+        return self.wv.n_similarity(ws1, ws2)
+
+    @deprecated("Method will be removed in 4.0.0, use self.wv.evaluate_word_pairs() instead")
+    def evaluate_word_pairs(self, pairs, delimiter='\t', restrict_vocab=300000,
+                            case_insensitive=True, dummy4unknown=False):
+        """
+        Deprecated. Use self.wv.evaluate_word_pairs() instead.
+        Refer to the documentation for `gensim.models.keyedvectors.WordEmbeddingsKeyedVectors.evaluate_word_pairs`
+        """
+        return self.wv.evaluate_word_pairs(pairs, delimiter, restrict_vocab, case_insensitive, dummy4unknown)
diff --git a/gensim/models/callbacks.py b/gensim/models/callbacks.py
index 9f098abe79..c974a0d5e3 100644
--- a/gensim/models/callbacks.py
+++ b/gensim/models/callbacks.py
@@ -330,3 +330,111 @@ def on_epoch_end(self, epoch, topics=None):
             self.previous = copy.deepcopy(self.model)
 
         return current_metrics
+
+
+class CallbackAny2Vec(object):
+    """Base class to build callbacks. Callbacks are used to apply custom functions over the model at specific points
+    during training (epoch start, batch end etc.). To implement a Callback, subclass
+    :class:`~gensim.models.callbacks.CallbackAny2Vec`, look at the example below
+    which creates a callback to save a training model after each epoch:
+
+    >>> from gensim.test.utils import common_texts as sentences
+    >>> from gensim.models.callbacks import CallbackAny2Vec
+    >>> from gensim.models import Word2Vec
+    >>> from gensim.test.utils import get_tmpfile
+    >>>
+    >>> class EpochSaver(CallbackAny2Vec):
+    ...     "Callback to save model after every epoch"
+    ...     def __init__(self, path_prefix):
+    ...         self.path_prefix = path_prefix
+    ...         self.epoch = 0
+    ...     def on_epoch_end(self, model):
+    ...         output_path = '{}_epoch{}.model'.format(self.path_prefix, self.epoch)
+    ...         print("Save model to {}".format(output_path))
+    ...         model.save(output_path)
+    ...         self.epoch += 1
+    ...
+    >>>
+    >>> class EpochLogger(CallbackAny2Vec):
+    ...     "Callback to log information about training"
+    ...     def __init__(self):
+    ...         self.epoch = 0
+    ...     def on_epoch_begin(self, model):
+    ...         print("Epoch #{} start".format(self.epoch))
+    ...     def on_epoch_end(self, model):
+    ...         print("Epoch #{} end".format(self.epoch))
+    ...         self.epoch += 1
+    ...
+    >>> epoch_saver = EpochSaver(get_tmpfile("temporary_model"))
+    >>> epoch_logger = EpochLogger()
+    >>> w2v_model = Word2Vec(sentences, iter=5, size=10, min_count=0, seed=42, callbacks=[epoch_saver, epoch_logger])
+
+    """
+
+    def on_epoch_begin(self, model):
+        """Method called on the start of epoch.
+
+        Parameters
+        ----------
+        model : class:`~gensim.models.base_any2vec.BaseWordEmbeddingsModel`
+            Current model.
+
+        """
+        pass
+
+    def on_epoch_end(self, model):
+        """Method called on the end of epoch.
+
+        Parameters
+        ----------
+        model
+
+        Returns
+        -------
+
+        """
+        pass
+
+    def on_batch_begin(self, model):
+        """Method called on the start of batch.
+
+        Parameters
+        ----------
+        model : class:`~gensim.models.base_any2vec.BaseWordEmbeddingsModel`
+            Current model.
+
+        """
+        pass
+
+    def on_batch_end(self, model):
+        """Method called on the end of batch.
+
+        Parameters
+        ----------
+        model : class:`~gensim.models.base_any2vec.BaseWordEmbeddingsModel`
+            Current model.
+
+        """
+        pass
+
+    def on_train_begin(self, model):
+        """Method called on the start of training process.
+
+        Parameters
+        ----------
+        model : class:`~gensim.models.base_any2vec.BaseWordEmbeddingsModel`
+            Current model.
+
+        """
+        pass
+
+    def on_train_end(self, model):
+        """Method called on the end of training process.
+
+        Parameters
+        ----------
+        model : class:`~gensim.models.base_any2vec.BaseWordEmbeddingsModel`
+            Current model.
+
+        """
+        pass
diff --git a/gensim/models/deprecated/__init__.py b/gensim/models/deprecated/__init__.py
new file mode 100644
index 0000000000..cfa71654f5
--- /dev/null
+++ b/gensim/models/deprecated/__init__.py
@@ -0,0 +1 @@
+"""This package contains some deprecated implementations of algorithm, will be removed soon."""
diff --git a/gensim/models/deprecated/doc2vec.py b/gensim/models/deprecated/doc2vec.py
new file mode 100644
index 0000000000..6ab43e6e7e
--- /dev/null
+++ b/gensim/models/deprecated/doc2vec.py
@@ -0,0 +1,1022 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 Radim Rehurek <me@radimrehurek.com>
+# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
+
+
+"""
+Warnings
+--------
+.. deprecated:: 3.3.0
+   Use :mod:`gensim.models.doc2vec` instead.
+
+
+
+Deep learning via the distributed memory and distributed bag of words models from
+[1]_, using either hierarchical softmax or negative sampling [2]_ [3]_. See [#tutorial]_
+
+**Make sure you have a C compiler before installing gensim, to use optimized (compiled)
+doc2vec training** (70x speedup [blog]_).
+
+Initialize a model with e.g.::
+
+>>> model = Doc2Vec(documents, size=100, window=8, min_count=5, workers=4)
+
+Persist a model to disk with::
+
+>>> model.save(fname)
+>>> model = Doc2Vec.load(fname)  # you can continue training with the loaded model!
+
+If you're finished training a model (=no more updates, only querying), you can do
+
+  >>> model.delete_temporary_training_data(keep_doctags_vectors=True, keep_inference=True):
+
+to trim unneeded model memory = use (much) less RAM.
+
+
+
+.. [1] Quoc Le and Tomas Mikolov. Distributed Representations of Sentences and Documents.
+       http://arxiv.org/pdf/1405.4053v2.pdf
+.. [2] Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean.
+       Efficient Estimation of Word Representations in Vector Space. In Proceedings of Workshop at ICLR, 2013.
+.. [3] 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.
+.. [blog] Optimizing word2vec in gensim, http://radimrehurek.com/2013/09/word2vec-in-python-part-two-optimizing/
+
+.. [#tutorial] Doc2vec in gensim tutorial,
+               https://github.com/RaRe-Technologies/gensim/blob/develop/docs/notebooks/doc2vec-lee.ipynb
+
+
+
+"""
+
+import logging
+import os
+
+try:
+    from queue import Queue
+except ImportError:
+    from Queue import Queue  # noqa:F401
+
+from collections import namedtuple, defaultdict
+from timeit import default_timer
+
+from numpy import zeros, sum as np_sum, add as np_add, concatenate, \
+    repeat as np_repeat, array, float32 as REAL, empty, ones, memmap as np_memmap, \
+    sqrt, newaxis, ndarray, dot, vstack, dtype, divide as np_divide, integer
+
+from gensim import utils
+from gensim.utils import call_on_class_only, deprecated
+from gensim.models.deprecated.word2vec import Word2Vec, train_cbow_pair, train_sg_pair, train_batch_sg
+from gensim.models.deprecated.keyedvectors import KeyedVectors
+from gensim.models.doc2vec import Doc2Vec as NewDoc2Vec
+from gensim.models.deprecated.old_saveload import SaveLoad
+
+from gensim import matutils  # utility fnc for pickling, common scipy operations etc
+from six.moves import xrange, zip
+from six import string_types, integer_types
+
+logger = logging.getLogger(__name__)
+
+
+def load_old_doc2vec(*args, **kwargs):
+    old_model = Doc2Vec.load(*args, **kwargs)
+    params = {
+        'dm_mean': old_model.__dict__.get('dm_mean', None),
+        'dm': old_model.dm,
+        'dbow_words': old_model.dbow_words,
+        'dm_concat': old_model.dm_concat,
+        'dm_tag_count': old_model.dm_tag_count,
+        'docvecs': old_model.__dict__.get('docvecs', None),
+        'docvecs_mapfile': old_model.__dict__.get('docvecs_mapfile', None),
+        'comment': old_model.__dict__.get('comment', None),
+        'size': old_model.vector_size,
+        'alpha': old_model.alpha,
+        'window': old_model.window,
+        'min_count': old_model.min_count,
+        'max_vocab_size': old_model.__dict__.get('max_vocab_size', None),
+        'sample': old_model.sample,
+        'seed': old_model.seed,
+        'workers': old_model.workers,
+        'min_alpha': old_model.min_alpha,
+        'hs': old_model.hs,
+        'negative': old_model.negative,
+        'cbow_mean': old_model.cbow_mean,
+        'hashfxn': old_model.hashfxn,
+        'iter': old_model.iter,
+        'sorted_vocab': old_model.sorted_vocab,
+        'batch_words': old_model.batch_words,
+        'compute_loss': old_model.__dict__.get('compute_loss', None)
+    }
+    new_model = NewDoc2Vec(**params)
+    # set word2vec trainables attributes
+    new_model.wv.vectors = old_model.wv.syn0
+    if hasattr(old_model.wv, 'syn0norm'):
+        new_model.docvecs.vectors_norm = old_model.wv.syn0norm
+    if hasattr(old_model, 'syn1'):
+        new_model.trainables.syn1 = old_model.syn1
+    if hasattr(old_model, 'syn1neg'):
+        new_model.trainables.syn1neg = old_model.syn1neg
+    if hasattr(old_model, 'syn0_lockf'):
+        new_model.trainables.vectors_lockf = old_model.syn0_lockf
+
+    # set doc2vec trainables attributes
+    new_model.docvecs.vectors_docs = old_model.docvecs.doctag_syn0
+    if hasattr(old_model.docvecs, 'doctag_syn0norm'):
+        new_model.docvecs.vectors_docs_norm = old_model.docvecs.doctag_syn0norm
+    if hasattr(old_model.docvecs, 'doctag_syn0_lockf'):
+        new_model.trainables.vectors_docs_lockf = old_model.docvecs.doctag_syn0_lockf
+    if hasattr(old_model.docvecs, 'mapfile_path'):
+        new_model.docvecs.mapfile_path = old_model.docvecs.mapfile_path
+
+    # set word2vec vocabulary attributes
+    new_model.wv.vocab = old_model.wv.vocab
+    new_model.wv.index2word = old_model.wv.index2word
+    new_model.vocabulary.cum_table = old_model.cum_table
+
+    # set doc2vec vocabulary attributes
+    new_model.docvecs.doctags = old_model.docvecs.doctags
+    new_model.docvecs.max_rawint = old_model.docvecs.max_rawint
+    new_model.docvecs.offset2doctag = old_model.docvecs.offset2doctag
+    new_model.docvecs.count = old_model.docvecs.count
+
+    new_model.train_count = old_model.train_count
+    new_model.corpus_count = old_model.corpus_count
+    new_model.running_training_loss = old_model.running_training_loss
+    new_model.total_train_time = old_model.total_train_time
+    new_model.min_alpha_yet_reached = old_model.min_alpha_yet_reached
+    new_model.model_trimmed_post_training = old_model.model_trimmed_post_training
+
+    return new_model
+
+
+def train_document_dbow(model, doc_words, doctag_indexes, alpha, work=None,
+                        train_words=False, learn_doctags=True, learn_words=True, learn_hidden=True,
+                        word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
+    """
+    Update distributed bag of words model ("PV-DBOW") by training on a single document.
+
+    Called internally from `Doc2Vec.train()` and `Doc2Vec.infer_vector()`.
+
+    The document is provided as `doc_words`, a list of word tokens which are looked up
+    in the model's vocab dictionary, and `doctag_indexes`, which provide indexes
+    into the doctag_vectors array.
+
+    If `train_words` is True, simultaneously train word-to-word (not just doc-to-word)
+    examples, exactly as per Word2Vec skip-gram training. (Without this option,
+    word vectors are neither consulted nor updated during DBOW doc vector training.)
+
+    Any of `learn_doctags', `learn_words`, and `learn_hidden` may be set False to
+    prevent learning-updates to those respective model weights, as if using the
+    (partially-)frozen model to infer other compatible vectors.
+
+    This is the non-optimized, Python version. If you have cython installed, gensim
+    will use the optimized version from doc2vec_inner instead.
+
+    """
+    if doctag_vectors is None:
+        doctag_vectors = model.docvecs.doctag_syn0
+    if doctag_locks is None:
+        doctag_locks = model.docvecs.doctag_syn0_lockf
+
+    if train_words and learn_words:
+        train_batch_sg(model, [doc_words], alpha, work)
+    for doctag_index in doctag_indexes:
+        for word in doc_words:
+            train_sg_pair(
+                model, word, doctag_index, alpha, learn_vectors=learn_doctags, learn_hidden=learn_hidden,
+                context_vectors=doctag_vectors, context_locks=doctag_locks
+            )
+
+    return len(doc_words)
+
+
+def train_document_dm(model, doc_words, doctag_indexes, alpha, work=None, neu1=None,
+                      learn_doctags=True, learn_words=True, learn_hidden=True,
+                      word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
+    """
+    Update distributed memory model ("PV-DM") by training on a single document.
+
+    Called internally from `Doc2Vec.train()` and `Doc2Vec.infer_vector()`. This
+    method implements the DM model with a projection (input) layer that is
+    either the sum or mean of the context vectors, depending on the model's
+    `dm_mean` configuration field.  See `train_document_dm_concat()` for the DM
+    model with a concatenated input layer.
+
+    The document is provided as `doc_words`, a list of word tokens which are looked up
+    in the model's vocab dictionary, and `doctag_indexes`, which provide indexes
+    into the doctag_vectors array.
+
+    Any of `learn_doctags', `learn_words`, and `learn_hidden` may be set False to
+    prevent learning-updates to those respective model weights, as if using the
+    (partially-)frozen model to infer other compatible vectors.
+
+    This is the non-optimized, Python version. If you have a C compiler, gensim
+    will use the optimized version from doc2vec_inner instead.
+
+    """
+    if word_vectors is None:
+        word_vectors = model.wv.syn0
+    if word_locks is None:
+        word_locks = model.syn0_lockf
+    if doctag_vectors is None:
+        doctag_vectors = model.docvecs.doctag_syn0
+    if doctag_locks is None:
+        doctag_locks = model.docvecs.doctag_syn0_lockf
+
+    word_vocabs = [model.wv.vocab[w] for w in doc_words if w in model.wv.vocab and
+                   model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+
+    for pos, word in enumerate(word_vocabs):
+        reduced_window = model.random.randint(model.window)  # `b` in the original doc2vec code
+        start = max(0, pos - model.window + reduced_window)
+        window_pos = enumerate(word_vocabs[start:(pos + model.window + 1 - reduced_window)], start)
+        word2_indexes = [word2.index for pos2, word2 in window_pos if pos2 != pos]
+        l1 = np_sum(word_vectors[word2_indexes], axis=0) + np_sum(doctag_vectors[doctag_indexes], axis=0)
+        count = len(word2_indexes) + len(doctag_indexes)
+        if model.cbow_mean and count > 1:
+            l1 /= count
+        neu1e = train_cbow_pair(model, word, word2_indexes, l1, alpha,
+                                learn_vectors=False, learn_hidden=learn_hidden)
+        if not model.cbow_mean and count > 1:
+            neu1e /= count
+        if learn_doctags:
+            for i in doctag_indexes:
+                doctag_vectors[i] += neu1e * doctag_locks[i]
+        if learn_words:
+            for i in word2_indexes:
+                word_vectors[i] += neu1e * word_locks[i]
+
+    return len(word_vocabs)
+
+
+def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None, neu1=None, learn_doctags=True,
+                             learn_words=True, learn_hidden=True, word_vectors=None, word_locks=None,
+                             doctag_vectors=None, doctag_locks=None):
+    """
+    Update distributed memory model ("PV-DM") by training on a single document, using a
+    concatenation of the context window word vectors (rather than a sum or average).
+
+    Called internally from `Doc2Vec.train()` and `Doc2Vec.infer_vector()`.
+
+    The document is provided as `doc_words`, a list of word tokens which are looked up
+    in the model's vocab dictionary, and `doctag_indexes`, which provide indexes
+    into the doctag_vectors array.
+
+    Any of `learn_doctags', `learn_words`, and `learn_hidden` may be set False to
+    prevent learning-updates to those respective model weights, as if using the
+    (partially-)frozen model to infer other compatible vectors.
+
+    This is the non-optimized, Python version. If you have a C compiler, gensim
+    will use the optimized version from doc2vec_inner instead.
+
+    """
+    if word_vectors is None:
+        word_vectors = model.wv.syn0
+    if word_locks is None:
+        word_locks = model.syn0_lockf
+    if doctag_vectors is None:
+        doctag_vectors = model.docvecs.doctag_syn0
+    if doctag_locks is None:
+        doctag_locks = model.docvecs.doctag_syn0_lockf
+
+    word_vocabs = [model.wv.vocab[w] for w in doc_words if w in model.wv.vocab and
+                   model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+    doctag_len = len(doctag_indexes)
+    if doctag_len != model.dm_tag_count:
+        return 0  # skip doc without expected number of doctag(s) (TODO: warn/pad?)
+
+    null_word = model.wv.vocab['\0']
+    pre_pad_count = model.window
+    post_pad_count = model.window
+    padded_document_indexes = (
+        (pre_pad_count * [null_word.index])  # pre-padding
+        + [word.index for word in word_vocabs if word is not None]  # elide out-of-Vocabulary words
+        + (post_pad_count * [null_word.index])  # post-padding
+    )
+
+    for pos in range(pre_pad_count, len(padded_document_indexes) - post_pad_count):
+        word_context_indexes = (
+            padded_document_indexes[(pos - pre_pad_count): pos]  # preceding words
+            + padded_document_indexes[(pos + 1):(pos + 1 + post_pad_count)]  # following words
+        )
+        predict_word = model.wv.vocab[model.wv.index2word[padded_document_indexes[pos]]]
+        # numpy advanced-indexing copies; concatenate, flatten to 1d
+        l1 = concatenate((doctag_vectors[doctag_indexes], word_vectors[word_context_indexes])).ravel()
+        neu1e = train_cbow_pair(model, predict_word, None, l1, alpha,
+                                learn_hidden=learn_hidden, learn_vectors=False)
+
+        # filter by locks and shape for addition to source vectors
+        e_locks = concatenate((doctag_locks[doctag_indexes], word_locks[word_context_indexes]))
+        neu1e_r = (neu1e.reshape(-1, model.vector_size)
+                   * np_repeat(e_locks, model.vector_size).reshape(-1, model.vector_size))
+
+        if learn_doctags:
+            np_add.at(doctag_vectors, doctag_indexes, neu1e_r[:doctag_len])
+        if learn_words:
+            np_add.at(word_vectors, word_context_indexes, neu1e_r[doctag_len:])
+
+    return len(padded_document_indexes) - pre_pad_count - post_pad_count
+
+
+class TaggedDocument(namedtuple('TaggedDocument', 'words tags')):
+    """
+    A single document, made up of `words` (a list of unicode string tokens)
+    and `tags` (a list of tokens). Tags may be one or more unicode string
+    tokens, but typical practice (which will also be most memory-efficient) is
+    for the tags list to include a unique integer id as the only tag.
+
+    Replaces "sentence as a list of words" from Word2Vec.
+
+    """
+
+    def __str__(self):
+        return '%s(%s, %s)' % (self.__class__.__name__, self.words, self.tags)
+
+
+# for compatibility
+@deprecated("Class will be removed in 4.0.0, use TaggedDocument instead")
+class LabeledSentence(TaggedDocument):
+    pass
+
+
+class DocvecsArray(SaveLoad):
+    """
+    Default storage of doc vectors during/after training, in a numpy array.
+
+    As the 'docvecs' property of a Doc2Vec model, allows access and
+    comparison of document vectors.
+
+    >>> docvec = d2v_model.docvecs[99]
+    >>> docvec = d2v_model.docvecs['SENT_99']  # if string tag used in training
+    >>> sims = d2v_model.docvecs.most_similar(99)
+    >>> sims = d2v_model.docvecs.most_similar('SENT_99')
+    >>> sims = d2v_model.docvecs.most_similar(docvec)
+
+    If only plain int tags are presented during training, the dict (of
+    string tag -> index) and list (of index -> string tag) stay empty,
+    saving memory.
+
+    Supplying a mapfile_path (as by initializing a Doc2Vec model with a
+    'docvecs_mapfile' value) will use a pair of memory-mapped
+    files as the array backing for doctag_syn0/doctag_syn0_lockf values.
+
+    The Doc2Vec model automatically uses this class, but a future alternative
+    implementation, based on another persistence mechanism like LMDB, LevelDB,
+    or SQLite, should also be possible.
+    """
+
+    def __init__(self, mapfile_path=None):
+        self.doctags = {}  # string -> Doctag (only filled if necessary)
+        self.max_rawint = -1  # highest rawint-indexed doctag
+        self.offset2doctag = []  # int offset-past-(max_rawint+1) -> String (only filled if necessary)
+        self.count = 0
+        self.mapfile_path = mapfile_path
+
+    def note_doctag(self, key, document_no, document_length):
+        """Note a document tag during initial corpus scan, for structure sizing."""
+        if isinstance(key, integer_types + (integer,)):
+            self.max_rawint = max(self.max_rawint, key)
+        else:
+            if key in self.doctags:
+                self.doctags[key] = self.doctags[key].repeat(document_length)
+            else:
+                self.doctags[key] = Doctag(len(self.offset2doctag), document_length, 1)
+                self.offset2doctag.append(key)
+        self.count = self.max_rawint + 1 + len(self.offset2doctag)
+
+    def indexed_doctags(self, doctag_tokens):
+        """Return indexes and backing-arrays used in training examples."""
+        return ([self._int_index(index) for index in doctag_tokens if index in self],
+                self.doctag_syn0, self.doctag_syn0_lockf, doctag_tokens)
+
+    def trained_item(self, indexed_tuple):
+        """Persist any changes made to the given indexes (matching tuple previously
+        returned by indexed_doctags()); a no-op for this implementation"""
+        pass
+
+    def _int_index(self, index):
+        """Return int index for either string or int index"""
+        if isinstance(index, integer_types + (integer,)):
+            return index
+        else:
+            return self.max_rawint + 1 + self.doctags[index].offset
+
+    @deprecated("Method will be removed in 4.0.0, use self.index_to_doctag instead")
+    def _key_index(self, i_index, missing=None):
+        """Return string index for given int index, if available"""
+        return self.index_to_doctag(i_index)
+
+    def index_to_doctag(self, i_index):
+        """Return string key for given i_index, if available. Otherwise return raw int doctag (same int)."""
+        candidate_offset = i_index - self.max_rawint - 1
+        if 0 <= candidate_offset < len(self.offset2doctag):
+            return self.offset2doctag[candidate_offset]
+        else:
+            return i_index
+
+    def __getitem__(self, index):
+        """
+        Accept a single key (int or string tag) or list of keys as input.
+
+        If a single string or int, return designated tag's vector
+        representation, as a 1D numpy array.
+
+        If a list, return designated tags' vector representations as a
+        2D numpy array: #tags x #vector_size.
+        """
+        if isinstance(index, string_types + integer_types + (integer,)):
+            return self.doctag_syn0[self._int_index(index)]
+
+        return vstack([self[i] for i in index])
+
+    def __len__(self):
+        return self.count
+
+    def __contains__(self, index):
+        if isinstance(index, integer_types + (integer,)):
+            return index < self.count
+        else:
+            return index in self.doctags
+
+    def save(self, *args, **kwargs):
+        # don't bother storing the cached normalized vectors
+        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm'])
+        super(DocvecsArray, self).save(*args, **kwargs)
+
+    def borrow_from(self, other_docvecs):
+        self.count = other_docvecs.count
+        self.doctags = other_docvecs.doctags
+        self.offset2doctag = other_docvecs.offset2doctag
+
+    def clear_sims(self):
+        self.doctag_syn0norm = None
+
+    def estimated_lookup_memory(self):
+        """Estimated memory for tag lookup; 0 if using pure int tags."""
+        return 60 * len(self.offset2doctag) + 140 * len(self.doctags)
+
+    def reset_weights(self, model):
+        length = max(len(self.doctags), self.count)
+        if self.mapfile_path:
+            self.doctag_syn0 = np_memmap(
+                self.mapfile_path + '.doctag_syn0', dtype=REAL, mode='w+', shape=(length, model.vector_size)
+            )
+            self.doctag_syn0_lockf = np_memmap(
+                self.mapfile_path + '.doctag_syn0_lockf', dtype=REAL, mode='w+', shape=(length,)
+            )
+            self.doctag_syn0_lockf.fill(1.0)
+        else:
+            self.doctag_syn0 = empty((length, model.vector_size), dtype=REAL)
+            self.doctag_syn0_lockf = ones((length,), dtype=REAL)  # zeros suppress learning
+
+        for i in xrange(length):
+            # construct deterministic seed from index AND model seed
+            seed = "%d %s" % (model.seed, self.index_to_doctag(i))
+            self.doctag_syn0[i] = model.seeded_vector(seed)
+
+    def init_sims(self, 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 or inference** after doing a replace.
+        The model becomes effectively read-only = you can call `most_similar`, `similarity`
+        etc., but not `train` or `infer_vector`.
+
+        """
+        if getattr(self, 'doctag_syn0norm', None) is None or replace:
+            logger.info("precomputing L2-norms of doc weight vectors")
+            if replace:
+                for i in xrange(self.doctag_syn0.shape[0]):
+                    self.doctag_syn0[i, :] /= sqrt((self.doctag_syn0[i, :] ** 2).sum(-1))
+                self.doctag_syn0norm = self.doctag_syn0
+            else:
+                if self.mapfile_path:
+                    self.doctag_syn0norm = np_memmap(
+                        self.mapfile_path + '.doctag_syn0norm', dtype=REAL,
+                        mode='w+', shape=self.doctag_syn0.shape)
+                else:
+                    self.doctag_syn0norm = empty(self.doctag_syn0.shape, dtype=REAL)
+                np_divide(self.doctag_syn0, sqrt((self.doctag_syn0 ** 2).sum(-1))[..., newaxis], self.doctag_syn0norm)
+
+    def most_similar(self, positive=None, negative=None, topn=10, clip_start=0, clip_end=None, indexer=None):
+        """
+        Find the top-N most similar docvecs known from training. Positive docs contribute
+        positively towards the similarity, negative docs negatively.
+
+        This method computes cosine similarity between a simple mean of the projection
+        weight vectors of the given docs. Docs may be specified as vectors, integer indexes
+        of trained docvecs, or if the documents were originally presented with string tags,
+        by the corresponding tags.
+
+        The 'clip_start' and 'clip_end' allow limiting results to a particular contiguous
+        range of the underlying doctag_syn0norm vectors. (This may be useful if the ordering
+        there was chosen to be significant, such as more popular tag IDs in lower indexes.)
+        """
+        if positive is None:
+            positive = []
+        if negative is None:
+            negative = []
+
+        self.init_sims()
+        clip_end = clip_end or len(self.doctag_syn0norm)
+
+        if isinstance(positive, string_types + integer_types + (integer,)) and not negative:
+            # allow calls like most_similar('dog'), as a shorthand for most_similar(['dog'])
+            positive = [positive]
+
+        # add weights for each doc, if not already present; default to 1.0 for positive and -1.0 for negative docs
+        positive = [
+            (doc, 1.0) if isinstance(doc, string_types + integer_types + (ndarray, integer))
+            else doc for doc in positive
+        ]
+        negative = [
+            (doc, -1.0) if isinstance(doc, string_types + integer_types + (ndarray, integer))
+            else doc for doc in negative
+        ]
+
+        # compute the weighted average of all docs
+        all_docs, mean = set(), []
+        for doc, weight in positive + negative:
+            if isinstance(doc, ndarray):
+                mean.append(weight * doc)
+            elif doc in self.doctags or doc < self.count:
+                mean.append(weight * self.doctag_syn0norm[self._int_index(doc)])
+                all_docs.add(self._int_index(doc))
+            else:
+                raise KeyError("doc '%s' not in trained set" % doc)
+        if not mean:
+            raise ValueError("cannot compute similarity with no input")
+        mean = matutils.unitvec(array(mean).mean(axis=0)).astype(REAL)
+
+        if indexer is not None:
+            return indexer.most_similar(mean, topn)
+
+        dists = dot(self.doctag_syn0norm[clip_start:clip_end], mean)
+        if not topn:
+            return dists
+        best = matutils.argsort(dists, topn=topn + len(all_docs), reverse=True)
+        # ignore (don't return) docs from the input
+        result = [
+            (self.index_to_doctag(sim + clip_start), float(dists[sim]))
+            for sim in best
+            if (sim + clip_start) not in all_docs
+        ]
+        return result[:topn]
+
+    def doesnt_match(self, docs):
+        """
+        Which doc from the given list doesn't go with the others?
+
+        (TODO: Accept vectors of out-of-training-set docs, as if from inference.)
+
+        """
+        self.init_sims()
+
+        docs = [doc for doc in docs if doc in self.doctags or 0 <= doc < self.count]  # filter out unknowns
+        logger.debug("using docs %s", docs)
+        if not docs:
+            raise ValueError("cannot select a doc from an empty list")
+        vectors = vstack(self.doctag_syn0norm[self._int_index(doc)] for doc in docs).astype(REAL)
+        mean = matutils.unitvec(vectors.mean(axis=0)).astype(REAL)
+        dists = dot(vectors, mean)
+        return sorted(zip(dists, docs))[0][1]
+
+    def similarity(self, d1, d2):
+        """
+        Compute cosine similarity between two docvecs in the trained set, specified by int index or
+        string tag. (TODO: Accept vectors of out-of-training-set docs, as if from inference.)
+
+        """
+        return dot(matutils.unitvec(self[d1]), matutils.unitvec(self[d2]))
+
+    def n_similarity(self, ds1, ds2):
+        """
+        Compute cosine similarity between two sets of docvecs from the trained set, specified by int
+        index or string tag. (TODO: Accept vectors of out-of-training-set docs, as if from inference.)
+
+        """
+        v1 = [self[doc] for doc in ds1]
+        v2 = [self[doc] for doc in ds2]
+        return dot(matutils.unitvec(array(v1).mean(axis=0)), matutils.unitvec(array(v2).mean(axis=0)))
+
+    def similarity_unseen_docs(self, model, doc_words1, doc_words2, alpha=0.1, min_alpha=0.0001, steps=5):
+        """
+        Compute cosine similarity between two post-bulk out of training documents.
+
+        Document should be a list of (word) tokens.
+        """
+        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.)
+
+    Will not be used if all presented document tags are ints.
+
+    The offset is only the true index into the doctags_syn0/doctags_syn0_lockf
+    if-and-only-if no raw-int tags were used. If any raw-int tags were used,
+    string Doctag vectors begin at index (max_rawint + 1), so the true index is
+    (rawint_index + 1 + offset). See also DocvecsArray.index_to_doctag().
+    """
+    __slots__ = ()
+
+    def repeat(self, word_count):
+        return self._replace(word_count=self.word_count + word_count, doc_count=self.doc_count + 1)
+
+
+class Doc2Vec(Word2Vec):
+    """Class for training, using and evaluating neural networks described in http://arxiv.org/pdf/1405.4053v2.pdf"""
+
+    def __init__(self, documents=None, dm_mean=None, dm=1, dbow_words=0, dm_concat=0, dm_tag_count=1,
+                 docvecs=None, docvecs_mapfile=None, comment=None, trim_rule=None, **kwargs):
+        """
+        Initialize the model from an iterable of `documents`. Each document is a
+        TaggedDocument object that will be used for training.
+
+        The `documents` iterable can be simply a list of TaggedDocument elements, but for larger corpora,
+        consider an iterable that streams the documents directly from disk/network.
+
+        If you don't supply `documents`, the model is left uninitialized -- use if
+        you plan to initialize it in some other way.
+
+        `dm` defines the training algorithm. By default (`dm=1`), 'distributed memory' (PV-DM) is used.
+        Otherwise, `distributed bag of words` (PV-DBOW) is employed.
+
+        `size` is the dimensionality of the feature vectors.
+
+        `window` is the maximum distance between the predicted word and context words used for prediction
+        within a document.
+
+        `alpha` is the initial learning rate (will linearly drop to `min_alpha` as training progresses).
+
+        `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
+        environment variable to control hash randomization.)
+
+        `min_count` = ignore all words with total frequency lower than this.
+
+        `max_vocab_size` = limit RAM during vocabulary building; if there are more unique
+        words than this, then prune the infrequent ones. Every 10 million word types
+        need about 1GB of RAM. Set to `None` for no limit (default).
+
+        `sample` = threshold for configuring which higher-frequency words are randomly downsampled;
+                default is 1e-3, values of 1e-5 (or lower) may also be useful, set to 0.0 to disable downsampling.
+
+        `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,
+        but values of 10 or 20 are common in published 'Paragraph Vector' experiments.
+
+        `hs` = if 1, hierarchical softmax will be used for model training.
+        If set to 0 (default), and `negative` is non-zero, negative sampling will be used.
+
+        `negative` = if > 0, negative sampling will be used, the int for negative
+        specifies how many "noise words" should be drawn (usually between 5-20).
+        Default is 5. If set to 0, no negative samping is used.
+
+        `dm_mean` = if 0 (default), use the sum of the context word vectors. If 1, use the mean.
+        Only applies when dm is used in non-concatenative mode.
+
+        `dm_concat` = if 1, use concatenation of context vectors rather than sum/average;
+        default is 0 (off). Note concatenation results in a much-larger model, as the input
+        is no longer the size of one (sampled or arithmetically combined) word vector, but the
+        size of the tag(s) and all words in the context strung together.
+
+        `dm_tag_count` = expected constant number of document tags per document, when using
+        dm_concat mode; default is 1.
+
+        `dbow_words` if set to 1 trains word-vectors (in skip-gram fashion) simultaneous with DBOW
+        doc-vector training; default is 0 (faster training of doc-vectors only).
+
+        `trim_rule` = vocabulary trimming rule, specifies whether certain words should remain
+        in the vocabulary, be trimmed away, or handled using the default (discard if word count < min_count).
+        Can be None (min_count will be used), or a callable that accepts parameters (word, count, min_count) and
+        returns either util.RULE_DISCARD, util.RULE_KEEP or util.RULE_DEFAULT.
+        Note: The rule, if given, is only used prune vocabulary during build_vocab() and is not stored as part
+        of the model.
+        """
+
+        if 'sentences' in kwargs:
+            raise DeprecationWarning(
+                "Parameter 'sentences' was renamed to 'documents', and will be removed in 4.0.0, "
+                "use 'documents' instead."
+            )
+
+        super(Doc2Vec, self).__init__(
+            sg=(1 + dm) % 2,
+            null_word=dm_concat,
+            **kwargs)
+
+        self.load = call_on_class_only
+
+        if dm_mean is not None:
+            self.cbow_mean = dm_mean
+
+        self.dbow_words = dbow_words
+        self.dm_concat = dm_concat
+        self.dm_tag_count = dm_tag_count
+        if self.dm and self.dm_concat:
+            self.layer1_size = (self.dm_tag_count + (2 * self.window)) * self.vector_size
+
+        self.docvecs = docvecs or DocvecsArray(docvecs_mapfile)
+        self.comment = comment
+        if documents is not None:
+            self.build_vocab(documents, trim_rule=trim_rule)
+            self.train(documents, total_examples=self.corpus_count, epochs=self.iter)
+
+    @property
+    def dm(self):
+        return not self.sg  # opposite of SG
+
+    @property
+    def dbow(self):
+        return self.sg  # same as SG
+
+    def clear_sims(self):
+        super(Doc2Vec, self).clear_sims()
+        self.docvecs.clear_sims()
+
+    def reset_weights(self):
+        if self.dm and self.dm_concat:
+            # expand l1 size to match concatenated tags+words length
+            self.layer1_size = (self.dm_tag_count + (2 * self.window)) * self.vector_size
+            logger.info("using concatenative %d-dimensional layer1", self.layer1_size)
+        super(Doc2Vec, self).reset_weights()
+        self.docvecs.reset_weights(self)
+
+    def reset_from(self, other_model):
+        """Reuse shareable structures from other_model."""
+        self.docvecs.borrow_from(other_model.docvecs)
+        super(Doc2Vec, self).reset_from(other_model)
+
+    def scan_vocab(self, documents, progress_per=10000, trim_rule=None, update=False):
+        logger.info("collecting all words and their counts")
+        document_no = -1
+        total_words = 0
+        min_reduce = 1
+        interval_start = default_timer() - 0.00001  # guard against next sample being identical
+        interval_count = 0
+        checked_string_types = 0
+        vocab = defaultdict(int)
+        for document_no, document in enumerate(documents):
+            if not checked_string_types:
+                if isinstance(document.words, string_types):
+                    logger.warning(
+                        "Each 'words' should be a list of words (usually unicode strings). "
+                        "First 'words' here is instead plain %s.",
+                        type(document.words)
+                    )
+                checked_string_types += 1
+            if document_no % progress_per == 0:
+                interval_rate = (total_words - interval_count) / (default_timer() - interval_start)
+                logger.info(
+                    "PROGRESS: at example #%i, processed %i words (%i/s), %i word types, %i tags",
+                    document_no, total_words, interval_rate, len(vocab), len(self.docvecs)
+                )
+                interval_start = default_timer()
+                interval_count = total_words
+            document_length = len(document.words)
+
+            for tag in document.tags:
+                self.docvecs.note_doctag(tag, document_no, document_length)
+
+            for word in document.words:
+                vocab[word] += 1
+            total_words += len(document.words)
+
+            if self.max_vocab_size and len(vocab) > self.max_vocab_size:
+                utils.prune_vocab(vocab, min_reduce, trim_rule=trim_rule)
+                min_reduce += 1
+
+        logger.info(
+            "collected %i word types and %i unique tags from a corpus of %i examples and %i words",
+            len(vocab), len(self.docvecs), document_no + 1, total_words
+        )
+        self.corpus_count = document_no + 1
+        self.raw_vocab = vocab
+
+    def _do_train_job(self, job, alpha, inits):
+        work, neu1 = inits
+        tally = 0
+        for doc in job:
+            indexed_doctags = self.docvecs.indexed_doctags(doc.tags)
+            doctag_indexes, doctag_vectors, doctag_locks, ignored = indexed_doctags
+            if self.sg:
+                tally += train_document_dbow(
+                    self, doc.words, doctag_indexes, alpha, work, train_words=self.dbow_words,
+                    doctag_vectors=doctag_vectors, doctag_locks=doctag_locks
+                )
+            elif self.dm_concat:
+                tally += train_document_dm_concat(
+                    self, doc.words, doctag_indexes, alpha, work, neu1,
+                    doctag_vectors=doctag_vectors, doctag_locks=doctag_locks
+                )
+            else:
+                tally += train_document_dm(
+                    self, doc.words, doctag_indexes, alpha, work, neu1,
+                    doctag_vectors=doctag_vectors, doctag_locks=doctag_locks
+                )
+            self.docvecs.trained_item(indexed_doctags)
+        return tally, self._raw_word_count(job)
+
+    def _raw_word_count(self, job):
+        """Return the number of words in a given job."""
+        return sum(len(sentence.words) for sentence in job)
+
+    def infer_vector(self, doc_words, alpha=0.1, min_alpha=0.0001, steps=5):
+        """
+        Infer a vector for given post-bulk training document.
+
+        Document should be a list of (word) tokens.
+        """
+        doctag_vectors = empty((1, self.vector_size), dtype=REAL)
+        doctag_vectors[0] = self.seeded_vector(' '.join(doc_words))
+        doctag_locks = ones(1, dtype=REAL)
+        doctag_indexes = [0]
+
+        work = zeros(self.layer1_size, dtype=REAL)
+        if not self.sg:
+            neu1 = matutils.zeros_aligned(self.layer1_size, dtype=REAL)
+
+        for i in range(steps):
+            if self.sg:
+                train_document_dbow(
+                    self, doc_words, doctag_indexes, alpha, work,
+                    learn_words=False, learn_hidden=False, doctag_vectors=doctag_vectors, doctag_locks=doctag_locks
+                )
+            elif self.dm_concat:
+                train_document_dm_concat(
+                    self, doc_words, doctag_indexes, alpha, work, neu1,
+                    learn_words=False, learn_hidden=False, doctag_vectors=doctag_vectors, doctag_locks=doctag_locks
+                )
+            else:
+                train_document_dm(
+                    self, doc_words, doctag_indexes, alpha, work, neu1,
+                    learn_words=False, learn_hidden=False, doctag_vectors=doctag_vectors, doctag_locks=doctag_locks
+                )
+            alpha = ((alpha - min_alpha) / (steps - i)) + min_alpha
+
+        return doctag_vectors[0]
+
+    def estimate_memory(self, vocab_size=None, report=None):
+        """Estimate required memory for a model using current settings."""
+        report = report or {}
+        report['doctag_lookup'] = self.docvecs.estimated_lookup_memory()
+        report['doctag_syn0'] = self.docvecs.count * self.vector_size * dtype(REAL).itemsize
+        return super(Doc2Vec, self).estimate_memory(vocab_size, report=report)
+
+    def __str__(self):
+        """Abbreviated name reflecting major configuration paramaters."""
+        segments = []
+        if self.comment:
+            segments.append('"%s"' % self.comment)
+        if self.sg:
+            if self.dbow_words:
+                segments.append('dbow+w')  # also training words
+            else:
+                segments.append('dbow')  # PV-DBOW (skip-gram-style)
+
+        else:  # PV-DM...
+            if self.dm_concat:
+                segments.append('dm/c')  # ...with concatenative context layer
+            else:
+                if self.cbow_mean:
+                    segments.append('dm/m')
+                else:
+                    segments.append('dm/s')
+        segments.append('d%d' % self.vector_size)  # dimensions
+        if self.negative:
+            segments.append('n%d' % self.negative)  # negative samples
+        if self.hs:
+            segments.append('hs')
+        if not self.sg or (self.sg and self.dbow_words):
+            segments.append('w%d' % self.window)  # window size, when relevant
+        if self.min_count > 1:
+            segments.append('mc%d' % self.min_count)
+        if self.sample > 0:
+            segments.append('s%g' % self.sample)
+        if self.workers > 1:
+            segments.append('t%d' % self.workers)
+        return '%s(%s)' % (self.__class__.__name__, ','.join(segments))
+
+    def delete_temporary_training_data(self, keep_doctags_vectors=True, keep_inference=True):
+        """
+        Discard parameters that are used in training and score. Use if you're sure you're done training a model.
+        Set `keep_doctags_vectors` to False if you don't want to save doctags vectors,
+        in this case you can't to use docvecs's most_similar, similarity etc. methods.
+        Set `keep_inference` to False if you don't want to store parameters that is used for infer_vector method
+        """
+        if not keep_inference:
+            self._minimize_model(False, False, False)
+        if self.docvecs and hasattr(self.docvecs, 'doctag_syn0') and not keep_doctags_vectors:
+            del self.docvecs.doctag_syn0
+        if self.docvecs and hasattr(self.docvecs, 'doctag_syn0_lockf'):
+            del self.docvecs.doctag_syn0_lockf
+
+    def save_word2vec_format(self, fname, doctag_vec=False, word_vec=True, prefix='*dt_', fvocab=None, binary=False):
+        """
+        Store the input-hidden weight matrix.
+
+         `fname` is the file used to save the vectors in
+         `doctag_vec` is an optional boolean indicating whether to store document vectors
+         `word_vec` is an optional boolean indicating whether to store word vectors
+         (if both doctag_vec and word_vec are True, then both vectors are stored in the same file)
+         `prefix` to uniquely identify doctags from word vocab, and avoid collision
+         in case of repeated string in doctag and word vocab
+         `fvocab` is an optional file used to save the vocabulary
+         `binary` is an optional boolean indicating whether the data is to be saved
+         in binary word2vec format (default: False)
+
+        """
+        total_vec = len(self.wv.vocab) + len(self.docvecs)
+        # save word vectors
+        if word_vec:
+            if not doctag_vec:
+                total_vec = len(self.wv.vocab)
+            KeyedVectors.save_word2vec_format(self.wv, fname, fvocab, binary, total_vec)
+        # save document vectors
+        if doctag_vec:
+            with utils.smart_open(fname, 'ab') as fout:
+                if not word_vec:
+                    total_vec = len(self.docvecs)
+                    logger.info("storing %sx%s projection weights into %s", total_vec, self.vector_size, fname)
+                    fout.write(utils.to_utf8("%s %s\n" % (total_vec, self.vector_size)))
+                # store as in input order
+                for i in range(len(self.docvecs)):
+                    doctag = u"%s%s" % (prefix, self.docvecs.index_to_doctag(i))
+                    row = self.docvecs.doctag_syn0[i]
+                    if binary:
+                        fout.write(utils.to_utf8(doctag) + b" " + row.tostring())
+                    else:
+                        fout.write(utils.to_utf8("%s %s\n" % (doctag, ' '.join("%f" % val for val in row))))
+
+
+class TaggedBrownCorpus(object):
+    """Iterate over documents from the Brown corpus (part of NLTK data), yielding
+    each document out as a TaggedDocument object."""
+
+    def __init__(self, dirname):
+        self.dirname = dirname
+
+    def __iter__(self):
+        for fname in os.listdir(self.dirname):
+            fname = os.path.join(self.dirname, fname)
+            if not os.path.isfile(fname):
+                continue
+            for item_no, line in enumerate(utils.smart_open(fname)):
+                line = utils.to_unicode(line)
+                # each file line is a single document in the Brown corpus
+                # each token is WORD/POS_TAG
+                token_tags = [t.split('/') for t in line.split() if len(t.split('/')) == 2]
+                # ignore words with non-alphabetic tags like ",", "!" etc (punctuation, weird stuff)
+                words = ["%s/%s" % (token.lower(), tag[:2]) for token, tag in token_tags if tag[:2].isalpha()]
+                if not words:  # don't bother sending out empty documents
+                    continue
+                yield TaggedDocument(words, ['%s_SENT_%s' % (fname, item_no)])
+
+
+class TaggedLineDocument(object):
+    """Simple format: one document = one line = one TaggedDocument object.
+
+    Words are expected to be already preprocessed and separated by whitespace,
+    tags are constructed automatically from the document line number."""
+
+    def __init__(self, source):
+        """
+        `source` can be either a string (filename) or a file object.
+
+        Example::
+
+            documents = TaggedLineDocument('myfile.txt')
+
+        Or for compressed files::
+
+            documents = TaggedLineDocument('compressed_text.txt.bz2')
+            documents = TaggedLineDocument('compressed_text.txt.gz')
+
+        """
+        self.source = source
+
+    def __iter__(self):
+        """Iterate through the lines in the source."""
+        try:
+            # Assume it is a file-like object and try treating it as such
+            # Things that don't have seek will trigger an exception
+            self.source.seek(0)
+            for item_no, line in enumerate(self.source):
+                yield TaggedDocument(utils.to_unicode(line).split(), [item_no])
+        except AttributeError:
+            # If it didn't work like a file, use it as a string filename
+            with utils.smart_open(self.source) as fin:
+                for item_no, line in enumerate(fin):
+                    yield TaggedDocument(utils.to_unicode(line).split(), [item_no])
diff --git a/gensim/models/deprecated/fasttext.py b/gensim/models/deprecated/fasttext.py
new file mode 100644
index 0000000000..3a2162d5ea
--- /dev/null
+++ b/gensim/models/deprecated/fasttext.py
@@ -0,0 +1,703 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Authors: Chinmaya Pancholi <chinmayapancholi13@gmail.com>, Shiva Manne <s.manne@rare-technologies.com>
+# Copyright (C) 2017 RaRe Technologies s.r.o.
+
+"""
+Warnings
+--------
+.. deprecated:: 3.3.0
+   Use :mod:`gensim.models.fasttext` instead.
+
+
+Learn word representations via fasttext's "skip-gram and CBOW models", using either
+hierarchical softmax or negative sampling [1]_.
+
+Notes
+-----
+There are more ways to get word vectors in Gensim than just FastText.
+See wrappers for VarEmbed and WordRank or Word2Vec
+
+This module allows training a word embedding from a training corpus with the additional ability
+to obtain word vectors for out-of-vocabulary words.
+
+For a tutorial on gensim's native fasttext, refer to the noteboook -- [2]_
+
+**Make sure you have a C compiler before installing gensim, to use optimized (compiled) fasttext training**
+
+.. [1] P. Bojanowski, E. Grave, A. Joulin, T. Mikolov
+       Enriching Word Vectors with Subword Information. In arXiv preprint arXiv:1607.04606.
+       https://arxiv.org/abs/1607.04606
+
+.. [2] https://github.com/RaRe-Technologies/gensim/blob/develop/docs/notebooks/FastText_Tutorial.ipynb
+
+"""
+
+import logging
+
+import numpy as np
+from numpy import zeros, ones, vstack, sum as np_sum, empty, float32 as REAL
+
+from gensim.models.deprecated.word2vec import Word2Vec, train_sg_pair, train_cbow_pair
+from gensim.models.deprecated.fasttext_wrapper import FastTextKeyedVectors
+from gensim.models.deprecated.fasttext_wrapper import FastText as Ft_Wrapper, compute_ngrams, ft_hash
+from gensim.models.fasttext import FastText as NewFastText
+
+logger = logging.getLogger(__name__)
+
+FAST_VERSION = -1
+MAX_WORDS_IN_BATCH = 10000
+
+
+def load_old_fasttext(*args, **kwargs):
+    old_model = FastText.load(*args, **kwargs)
+    params = {
+        'size': old_model.vector_size,
+        'alpha': old_model.alpha,
+        'window': old_model.window,
+        'min_count': old_model.min_count,
+        'max_vocab_size': old_model.__dict__.get('max_vocab_size', None),
+        'sample': old_model.sample,
+        'seed': old_model.seed,
+        'workers': old_model.workers,
+        'min_alpha': old_model.min_alpha,
+        'sg': old_model.sg,
+        'hs': old_model.hs,
+        'negative': old_model.negative,
+        'cbow_mean': old_model.cbow_mean,
+        'hashfxn': old_model.hashfxn,
+        'iter': old_model.iter,
+        'null_word': old_model.null_word,
+        'sorted_vocab': old_model.sorted_vocab,
+        'batch_words': old_model.batch_words,
+        'min_n': old_model.min_n,
+        'max_n': old_model.max_n,
+        'word_ngrams': old_model.word_ngrams,
+        'bucket': old_model.bucket
+    }
+    new_model = NewFastText(**params)
+    # set trainables attributes
+    new_model.wv.vectors = old_model.wv.syn0
+    new_model.wv.vectors_vocab = old_model.wv.syn0_vocab
+    new_model.wv.vectors_ngrams = old_model.wv.syn0_ngrams
+    if hasattr(old_model.wv, 'syn0norm'):
+        new_model.wv.vectors_norm = old_model.wv.syn0norm
+    if hasattr(old_model, 'syn1'):
+        new_model.trainables.syn1 = old_model.syn1
+    if hasattr(old_model, 'syn1neg'):
+        new_model.trainables.syn1neg = old_model.syn1neg
+    if hasattr(old_model, 'syn0_lockf'):
+        new_model.trainables.vectors_lockf = old_model.syn0_lockf
+
+    if hasattr(old_model, 'syn0_vocab_lockf'):
+        new_model.trainables.vectors_vocab_lockf = old_model.syn0_vocab_lockf
+    if hasattr(old_model, 'syn0_ngrams_lockf'):
+        new_model.trainables.vectors_ngrams_lockf = old_model.syn0_ngrams_lockf
+    if hasattr(old_model.wv, 'syn0_vocab_norm'):
+        new_model.trainables.vectors_vocab_norm = old_model.wv.syn0_vocab_norm
+    if hasattr(old_model.wv, 'syn0_ngrams_norm'):
+        new_model.trainables.vectors_ngrams_norm = old_model.wv.syn0_ngrams_norm
+
+    # set vocabulary attributes
+    new_model.wv.vocab = old_model.wv.vocab
+    new_model.wv.index2word = old_model.wv.index2word
+    new_model.vocabulary.cum_table = old_model.cum_table
+
+    new_model.wv.ngrams_word = old_model.wv.ngrams_word
+    new_model.wv.ngrams = old_model.wv.ngrams
+    new_model.wv.hash2index = old_model.wv.hash2index
+
+    new_model.train_count = old_model.train_count
+    new_model.corpus_count = old_model.corpus_count
+    new_model.running_training_loss = old_model.running_training_loss
+    new_model.total_train_time = old_model.total_train_time
+    new_model.min_alpha_yet_reached = old_model.min_alpha_yet_reached
+    new_model.model_trimmed_post_training = old_model.model_trimmed_post_training
+
+    new_model.trainables.num_ngram_vectors = old_model.num_ngram_vectors
+
+    return new_model
+
+
+def train_batch_cbow(model, sentences, alpha, work=None, neu1=None):
+    """Update CBOW model by training on a sequence of sentences.
+
+    Each sentence is a list of string tokens, which are looked up in the model's
+    vocab dictionary. Called internally from :meth:`gensim.models.fasttext.FastText.train()`.
+
+    This is the non-optimized, Python version. If you have cython installed, gensim
+    will use the optimized version from fasttext_inner instead.
+
+    Parameters
+    ----------
+    model : :class:`~gensim.models.fasttext.FastText`
+        `FastText` instance.
+    sentences : iterable of iterables
+        Iterable of the sentences directly from disk/network.
+    alpha : float
+        Learning rate.
+    work : :class:`numpy.ndarray`
+        Private working memory for each worker.
+    neu1 : :class:`numpy.ndarray`
+        Private working memory for each worker.
+
+    Returns
+    -------
+    int
+        Effective number of words trained.
+
+    """
+    result = 0
+    for sentence in sentences:
+        word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab and
+                       model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+        for pos, word in enumerate(word_vocabs):
+            reduced_window = model.random.randint(model.window)
+            start = max(0, pos - model.window + reduced_window)
+            window_pos = enumerate(word_vocabs[start:(pos + model.window + 1 - reduced_window)], start)
+            word2_indices = [word2.index for pos2, word2 in window_pos if (word2 is not None and pos2 != pos)]
+
+            word2_subwords = []
+            vocab_subwords_indices = []
+            ngrams_subwords_indices = []
+
+            for index in word2_indices:
+                vocab_subwords_indices += [index]
+                word2_subwords += model.wv.ngrams_word[model.wv.index2word[index]]
+
+            for subword in word2_subwords:
+                ngrams_subwords_indices.append(model.wv.ngrams[subword])
+
+            l1_vocab = np_sum(model.wv.syn0_vocab[vocab_subwords_indices], axis=0)  # 1 x vector_size
+            l1_ngrams = np_sum(model.wv.syn0_ngrams[ngrams_subwords_indices], axis=0)  # 1 x vector_size
+
+            l1 = np_sum([l1_vocab, l1_ngrams], axis=0)
+            subwords_indices = [vocab_subwords_indices] + [ngrams_subwords_indices]
+            if (subwords_indices[0] or subwords_indices[1]) and model.cbow_mean:
+                l1 /= (len(subwords_indices[0]) + len(subwords_indices[1]))
+
+            # train on the sliding window for target word
+            train_cbow_pair(model, word, subwords_indices, l1, alpha, is_ft=True)
+        result += len(word_vocabs)
+    return result
+
+
+def train_batch_sg(model, sentences, alpha, work=None, neu1=None):
+    """Update skip-gram model by training on a sequence of sentences.
+
+    Each sentence is a list of string tokens, which are looked up in the model's
+    vocab dictionary. Called internally from :meth:`gensim.models.fasttext.FastText.train()`.
+
+    This is the non-optimized, Python version. If you have cython installed, gensim
+    will use the optimized version from fasttext_inner instead.
+
+    Parameters
+    ----------
+    model : :class:`~gensim.models.fasttext.FastText`
+        `FastText` instance.
+    sentences : iterable of iterables
+        Iterable of the sentences directly from disk/network.
+    alpha : float
+        Learning rate.
+    work : :class:`numpy.ndarray`
+        Private working memory for each worker.
+    neu1 : :class:`numpy.ndarray`
+        Private working memory for each worker.
+
+    Returns
+    -------
+    int
+        Effective number of words trained.
+
+    """
+    result = 0
+    for sentence in sentences:
+        word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab and
+                       model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+        for pos, word in enumerate(word_vocabs):
+            reduced_window = model.random.randint(model.window)  # `b` in the original word2vec code
+            # now go over all words from the (reduced) window, predicting each one in turn
+            start = max(0, pos - model.window + reduced_window)
+
+            subwords_indices = [word.index]
+            word2_subwords = model.wv.ngrams_word[model.wv.index2word[word.index]]
+
+            for subword in word2_subwords:
+                subwords_indices.append(model.wv.ngrams[subword])
+
+            for pos2, word2 in enumerate(word_vocabs[start:(pos + model.window + 1 - reduced_window)], start):
+                if pos2 != pos:  # don't train on the `word` itself
+                    train_sg_pair(model, model.wv.index2word[word2.index], subwords_indices, alpha, is_ft=True)
+
+        result += len(word_vocabs)
+    return result
+
+
+class FastText(Word2Vec):
+    """Class for training, using and evaluating word representations learned using method
+    described in [1]_ aka Fasttext.
+
+    The model can be stored/loaded via its :meth:`~gensim.models.fasttext.FastText.save()` and
+    :meth:`~gensim.models.fasttext.FastText.load()` methods, or loaded in a format compatible with the original
+    fasttext implementation via :meth:`~gensim.models.fasttext.FastText.load_fasttext_format()`.
+
+    """
+    def __init__(
+            self, sentences=None, sg=0, hs=0, size=100, alpha=0.025, window=5, min_count=5,
+            max_vocab_size=None, word_ngrams=1, sample=1e-3, seed=1, workers=3, min_alpha=0.0001,
+            negative=5, cbow_mean=1, hashfxn=hash, iter=5, null_word=0, min_n=3, max_n=6, sorted_vocab=1,
+            bucket=2000000, trim_rule=None, batch_words=MAX_WORDS_IN_BATCH):
+        """Initialize the model from an iterable of `sentences`. Each sentence is a
+        list of words (unicode strings) that will be used for training.
+
+        Parameters
+        ----------
+        sentences : iterable of iterables
+            The `sentences` iterable can be simply a list of lists of tokens, but for larger corpora,
+            consider an iterable that streams the sentences directly from disk/network.
+            See :class:`~gensim.models.word2vec.BrownCorpus`, :class:`~gensim.models.word2vec.Text8Corpus`
+            or :class:`~gensim.models.word2vec.LineSentence` in :mod:`~gensim.models.word2vec` 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 : int {1, 0}
+            Defines the training algorithm. If 1, skip-gram is used, otherwise, CBOW is employed.
+        size : int
+            Dimensionality of the feature vectors.
+        window : int
+            The maximum distance between the current and predicted word within a sentence.
+        alpha : float
+            The initial learning rate.
+        min_alpha : float
+            Learning rate will linearly drop to `min_alpha` as training progresses.
+        seed : int
+            Seed for the random number generator. Initial vectors for each word are seeded with a hash of
+            the concatenation of word + `str(seed)`. Note that for a fully deterministically-reproducible run,
+            you must also limit the model to a single worker thread (`workers=1`), to eliminate ordering jitter
+            from OS thread scheduling. (In Python 3, reproducibility between interpreter launches also requires
+            use of the `PYTHONHASHSEED` environment variable to control hash randomization).
+        min_count : int
+            Ignores all words with total frequency lower than this.
+        max_vocab_size : int
+            Limits the RAM during vocabulary building; if there are more unique
+            words than this, then prune the infrequent ones. Every 10 million word types need about 1GB of RAM.
+            Set to `None` for no limit.
+        sample : float
+            The threshold for configuring which higher-frequency words are randomly downsampled,
+            useful range is (0, 1e-5).
+        workers : int
+            Use these many worker threads to train the model (=faster training with multicore machines).
+        hs : int {1,0}
+            If 1, hierarchical softmax will be used for model training.
+            If set to 0, and `negative` is non-zero, negative sampling will be used.
+        negative : int
+            If > 0, negative sampling will be used, the int for negative specifies how many "noise words"
+            should be drawn (usually between 5-20).
+            If set to 0, no negative sampling is used.
+        cbow_mean : int {1,0}
+            If 0, use the sum of the context word vectors. If 1, use the mean, only applies when cbow is used.
+        hashfxn : function
+            Hash function to use to randomly initialize weights, for increased training reproducibility.
+        iter : int
+            Number of iterations (epochs) over the corpus.
+        trim_rule : function
+            Vocabulary trimming rule, specifies whether certain words should remain in the vocabulary,
+            be trimmed away, or handled using the default (discard if word count < min_count).
+            Can be None (min_count will be used, look to :func:`~gensim.utils.keep_vocab_item`),
+            or a callable that accepts parameters (word, count, min_count) and returns either
+            :attr:`gensim.utils.RULE_DISCARD`, :attr:`gensim.utils.RULE_KEEP` or :attr:`gensim.utils.RULE_DEFAULT`.
+            Note: The rule, if given, is only used to prune vocabulary during build_vocab() and is not stored as part
+            of the model.
+        sorted_vocab : int {1,0}
+            If 1, sort the vocabulary by descending frequency before assigning word indexes.
+        batch_words : int
+            Target size (in words) for batches of examples passed to worker threads (and
+            thus cython routines).(Larger batches will be passed if individual
+            texts are longer than 10000 words, but the standard cython code truncates to that maximum.)
+        min_n : int
+            Min length of char ngrams to be used for training word representations.
+        max_n : int
+            Max length of char ngrams to be used for training word representations. Set `max_n` to be
+            lesser than `min_n` to avoid char ngrams being used.
+        word_ngrams : int {1,0}
+            If 1, uses enriches word vectors with subword(ngrams) information.
+            If 0, this is equivalent to word2vec.
+        bucket : int
+            Character ngrams are hashed into a fixed number of buckets, in order to limit the
+            memory usage of the model. This option specifies the number of buckets used by the model.
+
+        Examples
+        --------
+        Initialize and train a `FastText` model
+
+        >>> from gensim.models import FastText
+        >>> sentences = [["cat", "say", "meow"], ["dog", "say", "woof"]]
+        >>>
+        >>> model = FastText(sentences, min_count=1)
+        >>> say_vector = model['say']  # get vector for word
+        >>> of_vector = model['of']  # get vector for out-of-vocab word
+
+
+        """
+        # fastText specific params
+        self.bucket = bucket
+        self.word_ngrams = word_ngrams
+        self.min_n = min_n
+        self.max_n = max_n
+        if self.word_ngrams <= 1 and self.max_n == 0:
+            self.bucket = 0
+
+        super(FastText, self).__init__(
+            sentences=sentences, size=size, alpha=alpha, window=window, min_count=min_count,
+            max_vocab_size=max_vocab_size, sample=sample, seed=seed, workers=workers, min_alpha=min_alpha,
+            sg=sg, hs=hs, negative=negative, cbow_mean=cbow_mean, hashfxn=hashfxn, iter=iter, null_word=null_word,
+            trim_rule=trim_rule, sorted_vocab=sorted_vocab, batch_words=batch_words)
+
+    def initialize_word_vectors(self):
+        """Initializes FastTextKeyedVectors instance to store all vocab/ngram vectors for the model."""
+        self.wv = FastTextKeyedVectors()
+        self.wv.min_n = self.min_n
+        self.wv.max_n = self.max_n
+
+    def build_vocab(self, sentences, keep_raw_vocab=False, trim_rule=None, progress_per=10000, update=False):
+        """Build vocabulary from a sequence of sentences (can be a once-only generator stream).
+        Each sentence must be a list of unicode strings.
+
+        Parameters
+        ----------
+        sentences : iterable of iterables
+            The `sentences` iterable can be simply a list of lists of tokens, but for larger corpora,
+            consider an iterable that streams the sentences directly from disk/network.
+            See :class:`~gensim.models.word2vec.BrownCorpus`, :class:`~gensim.models.word2vec.Text8Corpus`
+            or :class:`~gensim.models.word2vec.LineSentence` in :mod:`~gensim.models.word2vec` module for such examples.
+        keep_raw_vocab : bool
+            If not true, delete the raw vocabulary after the scaling is done and free up RAM.
+        trim_rule : function
+            Vocabulary trimming rule, specifies whether certain words should remain in the vocabulary,
+            be trimmed away, or handled using the default (discard if word count < min_count).
+            Can be None (min_count will be used, look to :func:`~gensim.utils.keep_vocab_item`),
+            or a callable that accepts parameters (word, count, min_count) and returns either
+            :attr:`gensim.utils.RULE_DISCARD`, :attr:`gensim.utils.RULE_KEEP` or :attr:`gensim.utils.RULE_DEFAULT`.
+            Note: The rule, if given, is only used to prune vocabulary during build_vocab() and is not stored as part
+            of the model.
+        progress_per : int
+            Indicates how many words to process before showing/updating the progress.
+        update: bool
+            If true, the new words in `sentences` will be added to model's vocab.
+
+        Example
+        -------
+        Train a model and update vocab for online training
+
+        >>> from gensim.models import FastText
+        >>> sentences_1 = [["cat", "say", "meow"], ["dog", "say", "woof"]]
+        >>> sentences_2 = [["dude", "say", "wazzup!"]]
+        >>>
+        >>> model = FastText(min_count=1)
+        >>> model.build_vocab(sentences_1)
+        >>> model.train(sentences_1, total_examples=model.corpus_count, epochs=model.iter)
+        >>> model.build_vocab(sentences_2, update=True)
+        >>> model.train(sentences_2, total_examples=model.corpus_count, epochs=model.iter)
+
+        """
+        if update:
+            if not len(self.wv.vocab):
+                raise RuntimeError(
+                    "You cannot do an online vocabulary-update of a model which has no prior vocabulary. "
+                    "First build the vocabulary of your model with a corpus "
+                    "before doing an online update.")
+            self.old_vocab_len = len(self.wv.vocab)
+            self.old_hash2index_len = len(self.wv.hash2index)
+
+        super(FastText, self).build_vocab(
+            sentences, keep_raw_vocab=keep_raw_vocab, trim_rule=trim_rule, progress_per=progress_per, update=update)
+        self.init_ngrams(update=update)
+
+    def init_ngrams(self, update=False):
+        """Compute ngrams of all words present in vocabulary and stores vectors for only those ngrams.
+        Vectors for other ngrams are initialized with a random uniform distribution in FastText.
+
+        Parameters
+        ----------
+        update : bool
+            If True, the new vocab words and their new ngrams word vectors are initialized
+            with random uniform distribution and updated/added to the existing vocab word and ngram vectors.
+
+        """
+        if not update:
+            self.wv.ngrams = {}
+            self.wv.syn0_vocab = empty((len(self.wv.vocab), self.vector_size), dtype=REAL)
+            self.syn0_vocab_lockf = ones((len(self.wv.vocab), self.vector_size), dtype=REAL)
+
+            self.wv.syn0_ngrams = empty((self.bucket, self.vector_size), dtype=REAL)
+            self.syn0_ngrams_lockf = ones((self.bucket, self.vector_size), dtype=REAL)
+
+            all_ngrams = []
+            for w, v in self.wv.vocab.items():
+                self.wv.ngrams_word[w] = compute_ngrams(w, self.min_n, self.max_n)
+                all_ngrams += self.wv.ngrams_word[w]
+
+            all_ngrams = list(set(all_ngrams))
+            self.num_ngram_vectors = len(all_ngrams)
+            logger.info("Total number of ngrams is %d", len(all_ngrams))
+
+            self.wv.hash2index = {}
+            ngram_indices = []
+            new_hash_count = 0
+            for i, ngram in enumerate(all_ngrams):
+                ngram_hash = ft_hash(ngram) % self.bucket
+                if ngram_hash in self.wv.hash2index:
+                    self.wv.ngrams[ngram] = self.wv.hash2index[ngram_hash]
+                else:
+                    ngram_indices.append(ngram_hash % self.bucket)
+                    self.wv.hash2index[ngram_hash] = new_hash_count
+                    self.wv.ngrams[ngram] = self.wv.hash2index[ngram_hash]
+                    new_hash_count = new_hash_count + 1
+
+            self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)
+            self.syn0_ngrams_lockf = self.syn0_ngrams_lockf.take(ngram_indices, axis=0)
+            self.reset_ngram_weights()
+        else:
+            new_ngrams = []
+            for w, v in self.wv.vocab.items():
+                self.wv.ngrams_word[w] = compute_ngrams(w, self.min_n, self.max_n)
+                new_ngrams += [ng for ng in self.wv.ngrams_word[w] if ng not in self.wv.ngrams]
+
+            new_ngrams = list(set(new_ngrams))
+            logger.info("Number of new ngrams is %d", len(new_ngrams))
+            new_hash_count = 0
+            for i, ngram in enumerate(new_ngrams):
+                ngram_hash = ft_hash(ngram) % self.bucket
+                if ngram_hash not in self.wv.hash2index:
+                    self.wv.hash2index[ngram_hash] = new_hash_count + self.old_hash2index_len
+                    self.wv.ngrams[ngram] = self.wv.hash2index[ngram_hash]
+                    new_hash_count = new_hash_count + 1
+                else:
+                    self.wv.ngrams[ngram] = self.wv.hash2index[ngram_hash]
+
+            rand_obj = np.random
+            rand_obj.seed(self.seed)
+            new_vocab_rows = rand_obj.uniform(
+                -1.0 / self.vector_size, 1.0 / self.vector_size,
+                (len(self.wv.vocab) - self.old_vocab_len, self.vector_size)
+            ).astype(REAL)
+            new_vocab_lockf_rows = ones((len(self.wv.vocab) - self.old_vocab_len, self.vector_size), dtype=REAL)
+            new_ngram_rows = rand_obj.uniform(
+                -1.0 / self.vector_size, 1.0 / self.vector_size,
+                (len(self.wv.hash2index) - self.old_hash2index_len, self.vector_size)
+            ).astype(REAL)
+            new_ngram_lockf_rows = ones(
+                (len(self.wv.hash2index) - self.old_hash2index_len,
+                self.vector_size),
+                dtype=REAL)
+
+            self.wv.syn0_vocab = vstack([self.wv.syn0_vocab, new_vocab_rows])
+            self.syn0_vocab_lockf = vstack([self.syn0_vocab_lockf, new_vocab_lockf_rows])
+            self.wv.syn0_ngrams = vstack([self.wv.syn0_ngrams, new_ngram_rows])
+            self.syn0_ngrams_lockf = vstack([self.syn0_ngrams_lockf, new_ngram_lockf_rows])
+
+    def reset_ngram_weights(self):
+        """Reset all projection weights to an initial (untrained) state,
+        but keep the existing vocabulary and their ngrams.
+
+        """
+        rand_obj = np.random
+        rand_obj.seed(self.seed)
+        for index in range(len(self.wv.vocab)):
+            self.wv.syn0_vocab[index] = rand_obj.uniform(
+                -1.0 / self.vector_size, 1.0 / self.vector_size, self.vector_size
+            ).astype(REAL)
+        for index in range(len(self.wv.hash2index)):
+            self.wv.syn0_ngrams[index] = rand_obj.uniform(
+                -1.0 / self.vector_size, 1.0 / self.vector_size, self.vector_size
+            ).astype(REAL)
+
+    def _do_train_job(self, sentences, alpha, inits):
+        """Train a single batch of sentences. Return 2-tuple `(effective word count after
+        ignoring unknown words and sentence length trimming, total word count)`.
+
+        Parameters
+        ----------
+        sentences : iterable of iterables
+            The `sentences` iterable can be simply a list of lists of tokens, but for larger corpora,
+            consider an iterable that streams the sentences directly from disk/network.
+            See :class:`~gensim.models.word2vec.BrownCorpus`, :class:`~gensim.models.word2vec.Text8Corpus`
+            or :class:`~gensim.models.word2vec.LineSentence` in :mod:`~gensim.models.word2vec` module for such examples.
+        alpha : float
+            The current learning rate.
+        inits : (:class:`numpy.ndarray`, :class:`numpy.ndarray`)
+            Each worker's private work memory.
+
+        Returns
+        -------
+        (int, int)
+            Tuple of (effective word count after ignoring unknown words and sentence length trimming, total word count)
+
+        """
+        work, neu1 = inits
+        tally = 0
+        if self.sg:
+            tally += train_batch_sg(self, sentences, alpha, work, neu1)
+        else:
+            tally += train_batch_cbow(self, sentences, alpha, work, neu1)
+
+        return tally, self._raw_word_count(sentences)
+
+    def train(self, sentences, total_examples=None, total_words=None,
+              epochs=None, start_alpha=None, end_alpha=None,
+              word_count=0, queue_factor=2, report_delay=1.0):
+        """Update the model's neural weights from a sequence of sentences (can be a once-only generator stream).
+        For FastText, each sentence must be a list of unicode strings. (Subclasses may accept other examples.)
+
+        To support linear learning-rate decay from (initial) alpha to min_alpha, and accurate
+        progress-percentage logging, either total_examples (count of sentences) or total_words (count of
+        raw words in sentences) **MUST** be provided (if the corpus is the same as was provided to
+        :meth:`~gensim.models.fasttext.FastText.build_vocab()`, the count of examples in that corpus
+        will be available in the model's :attr:`corpus_count` property).
+
+        To avoid common mistakes around the model's ability to do multiple training passes itself, an
+        explicit `epochs` argument **MUST** be provided. In the common and recommended case,
+        where :meth:`~gensim.models.fasttext.FastText.train()` is only called once,
+        the model's cached `iter` value should be supplied as `epochs` value.
+
+        Parameters
+        ----------
+        sentences : iterable of iterables
+            The `sentences` iterable can be simply a list of lists of tokens, but for larger corpora,
+            consider an iterable that streams the sentences directly from disk/network.
+            See :class:`~gensim.models.word2vec.BrownCorpus`, :class:`~gensim.models.word2vec.Text8Corpus`
+            or :class:`~gensim.models.word2vec.LineSentence` in :mod:`~gensim.models.word2vec` module for such examples.
+        total_examples : int
+            Count of sentences.
+        total_words : int
+            Count of raw words in sentences.
+        epochs : int
+            Number of iterations (epochs) over the corpus.
+        start_alpha : float
+            Initial learning rate.
+        end_alpha : float
+            Final learning rate. Drops linearly from `start_alpha`.
+        word_count : int
+            Count of words already trained. Set this to 0 for the usual
+            case of training on all words in sentences.
+        queue_factor : int
+            Multiplier for size of queue (number of workers * queue_factor).
+        report_delay : float
+            Seconds to wait before reporting progress.
+
+        Examples
+        --------
+        >>> from gensim.models import FastText
+        >>> sentences = [["cat", "say", "meow"], ["dog", "say", "woof"]]
+        >>>
+        >>> model = FastText(min_count=1)
+        >>> model.build_vocab(sentences)
+        >>> model.train(sentences, total_examples=model.corpus_count, epochs=model.iter)
+
+        """
+        self.neg_labels = []
+        if self.negative > 0:
+                # precompute negative labels optimization for pure-python training
+                self.neg_labels = zeros(self.negative + 1)
+                self.neg_labels[0] = 1.
+
+        Word2Vec.train(
+            self, sentences, total_examples=self.corpus_count, epochs=self.iter,
+            start_alpha=self.alpha, end_alpha=self.min_alpha)
+        self.get_vocab_word_vecs()
+
+    def __getitem__(self, word):
+        """Get `word` representations in vector space, as a 1D numpy array.
+
+        Parameters
+        ----------
+        word : str
+            A single word whose vector needs to be returned.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            The word's representations in vector space, as a 1D numpy array.
+
+        Raises
+        ------
+        KeyError
+            For words with all ngrams absent, a KeyError is raised.
+
+        Example
+        -------
+        >>> from gensim.models import FastText
+        >>> from gensim.test.utils import datapath
+        >>>
+        >>> trained_model = FastText.load_fasttext_format(datapath('lee_fasttext'))
+        >>> meow_vector = trained_model['hello']  # get vector for word
+
+        """
+        return self.word_vec(word)
+
+    def get_vocab_word_vecs(self):
+        """Calculate vectors for words in vocabulary and stores them in `wv.syn0`."""
+        for w, v in self.wv.vocab.items():
+            word_vec = np.copy(self.wv.syn0_vocab[v.index])
+            ngrams = self.wv.ngrams_word[w]
+            ngram_weights = self.wv.syn0_ngrams
+            for ngram in ngrams:
+                word_vec += ngram_weights[self.wv.ngrams[ngram]]
+            word_vec /= (len(ngrams) + 1)
+            self.wv.syn0[v.index] = word_vec
+
+    def word_vec(self, word, use_norm=False):
+        """Get the word's representations in vector space, as a 1D numpy array.
+
+        Parameters
+        ----------
+        word : str
+            A single word whose vector needs to be returned.
+        use_norm : bool
+            If True, returns normalized vector.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            The word's representations in vector space, as a 1D numpy array.
+
+        Raises
+        ------
+        KeyError
+            For words with all ngrams absent, a KeyError is raised.
+
+        Example
+        -------
+        >>> from gensim.models import FastText
+        >>> sentences = [["cat", "say", "meow"], ["dog", "say", "woof"]]
+        >>>
+        >>> model = FastText(sentences, min_count=1)
+        >>> meow_vector = model.word_vec('meow')  # get vector for word
+
+        """
+        return FastTextKeyedVectors.word_vec(self.wv, word, use_norm=use_norm)
+
+    @classmethod
+    def load_fasttext_format(cls, *args, **kwargs):
+        """Load a :class:`~gensim.models.fasttext.FastText` model from a format compatible with
+        the original fasttext implementation.
+
+        Parameters
+        ----------
+        fname : str
+            Path to the file.
+
+        """
+        return Ft_Wrapper.load_fasttext_format(*args, **kwargs)
+
+    def save(self, *args, **kwargs):
+        """Save the model. This saved model can be loaded again using :func:`~gensim.models.fasttext.FastText.load`,
+        which supports online training and getting vectors for out-of-vocabulary words.
+
+        Parameters
+        ----------
+        fname : str
+            Path to the file.
+
+        """
+        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm', 'syn0_vocab_norm', 'syn0_ngrams_norm'])
+        super(FastText, self).save(*args, **kwargs)
diff --git a/gensim/models/deprecated/fasttext_wrapper.py b/gensim/models/deprecated/fasttext_wrapper.py
new file mode 100644
index 0000000000..e48a96072f
--- /dev/null
+++ b/gensim/models/deprecated/fasttext_wrapper.py
@@ -0,0 +1,456 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Author: Jayant Jain <jayantjain1992@gmail.com>
+# Copyright (C) 2017 Radim Rehurek <me@radimrehurek.com>
+# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
+
+
+"""
+Warnings
+--------
+.. deprecated:: 3.2.0
+   Use :mod:`gensim.models.fasttext` instead.
+
+
+Python wrapper around word representation learning from FastText, a library for efficient learning
+of word representations and sentence classification [1].
+
+This module allows training a word embedding from a training corpus with the additional ability
+to obtain word vectors for out-of-vocabulary words, using the fastText C implementation.
+
+The wrapped model can NOT be updated with new documents for online training -- use gensim's
+`Word2Vec` for that.
+
+Example:
+
+>>> from gensim.models.wrappers import FastText
+>>> model = FastText.train('/Users/kofola/fastText/fasttext', corpus_file='text8')
+>>> print model['forests']  # prints vector for given out-of-vocabulary word
+
+.. [1] https://github.com/facebookresearch/fastText#enriching-word-vectors-with-subword-information
+
+
+
+"""
+
+
+import logging
+import tempfile
+import os
+import struct
+
+import numpy as np
+from numpy import float32 as REAL, sqrt, newaxis
+from gensim import utils
+from gensim.models.deprecated.keyedvectors import KeyedVectors, Vocab
+from gensim.models.deprecated.word2vec import Word2Vec
+
+logger = logging.getLogger(__name__)
+
+try:
+    FileNotFoundError
+except NameError:
+    FileNotFoundError = IOError
+
+FASTTEXT_FILEFORMAT_MAGIC = 793712314
+
+
+class FastTextKeyedVectors(KeyedVectors):
+    """
+    Class to contain vectors, vocab and ngrams for the FastText training class and other methods not directly
+    involved in training such as most_similar().
+    Subclasses KeyedVectors to implement oov lookups, storing ngrams and other FastText specific methods
+
+    """
+
+    def __init__(self):
+        super(FastTextKeyedVectors, self).__init__()
+        self.syn0_vocab = None
+        self.syn0_vocab_norm = None
+        self.syn0_ngrams = None
+        self.syn0_ngrams_norm = None
+        self.ngrams = {}
+        self.hash2index = {}
+        self.ngrams_word = {}
+        self.min_n = 0
+        self.max_n = 0
+
+    def save(self, *args, **kwargs):
+        # don't bother storing the cached normalized vectors
+        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm', 'syn0_vocab_norm', 'syn0_ngrams_norm'])
+        super(FastTextKeyedVectors, self).save(*args, **kwargs)
+
+    def word_vec(self, word, use_norm=False):
+        """
+        Accept a single word as input.
+        Returns the word's representations in vector space, as a 1D numpy array.
+
+        The word can be out-of-vocabulary as long as ngrams for the word are present.
+        For words with all ngrams absent, a KeyError is raised.
+
+        Example::
+
+          >>> trained_model['office']
+          array([ -1.40128313e-02, ...])
+
+        """
+        if word in self.vocab:
+            return super(FastTextKeyedVectors, self).word_vec(word, use_norm)
+        else:
+            word_vec = np.zeros(self.syn0_ngrams.shape[1], dtype=np.float32)
+            ngrams = compute_ngrams(word, self.min_n, self.max_n)
+            ngrams = [ng for ng in ngrams if ng in self.ngrams]
+            if use_norm:
+                ngram_weights = self.syn0_ngrams_norm
+            else:
+                ngram_weights = self.syn0_ngrams
+            for ngram in ngrams:
+                word_vec += ngram_weights[self.ngrams[ngram]]
+            if word_vec.any():
+                return word_vec / len(ngrams)
+            else:  # No ngrams of the word are present in self.ngrams
+                raise KeyError('all ngrams for word %s absent from model' % word)
+
+    def init_sims(self, 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 only call `most_similar`, `similarity` etc.
+
+        """
+        super(FastTextKeyedVectors, self).init_sims(replace)
+        if getattr(self, 'syn0_ngrams_norm', None) is None or replace:
+            logger.info("precomputing L2-norms of ngram weight vectors")
+            if replace:
+                for i in range(self.syn0_ngrams.shape[0]):
+                    self.syn0_ngrams[i, :] /= sqrt((self.syn0_ngrams[i, :] ** 2).sum(-1))
+                self.syn0_ngrams_norm = self.syn0_ngrams
+            else:
+                self.syn0_ngrams_norm = \
+                    (self.syn0_ngrams / sqrt((self.syn0_ngrams ** 2).sum(-1))[..., newaxis]).astype(REAL)
+
+    def __contains__(self, word):
+        """
+        Check if `word` or any character ngrams in `word` are present in the vocabulary.
+        A vector for the word is guaranteed to exist if `__contains__` returns True.
+        """
+        if word in self.vocab:
+            return True
+        else:
+            char_ngrams = compute_ngrams(word, self.min_n, self.max_n)
+            return any(ng in self.ngrams for ng in char_ngrams)
+
+    @classmethod
+    def load_word2vec_format(cls, *args, **kwargs):
+        """Not suppported. Use gensim.models.KeyedVectors.load_word2vec_format instead."""
+        raise NotImplementedError("Not supported. Use gensim.models.KeyedVectors.load_word2vec_format instead.")
+
+
+class FastText(Word2Vec):
+    """
+    Class for word vector training using FastText. Communication between FastText and Python
+    takes place by working with data files on disk and calling the FastText binary with
+    subprocess.call().
+    Implements functionality similar to [fasttext.py](https://github.com/salestock/fastText.py),
+    improving speed and scope of functionality like `most_similar`, `similarity` by extracting vectors
+    into numpy matrix.
+
+    Warnings
+    --------
+    .. deprecated:: 3.2.0
+       Use :class:`gensim.models.fasttext.FastText` instead of :class:`gensim.models.wrappers.fasttext.FastText`.
+
+
+    """
+
+    def initialize_word_vectors(self):
+        self.wv = FastTextKeyedVectors()
+
+    @classmethod
+    def train(cls, ft_path, corpus_file, output_file=None, model='cbow', size=100, alpha=0.025, window=5, min_count=5,
+              word_ngrams=1, loss='ns', sample=1e-3, negative=5, iter=5, min_n=3, max_n=6, sorted_vocab=1, threads=12):
+        """
+        `ft_path` is the path to the FastText executable, e.g. `/home/kofola/fastText/fasttext`.
+
+        `corpus_file` is the filename of the text file to be used for training the FastText model.
+        Expects file to contain utf-8 encoded text.
+
+        `model` defines the training algorithm. By default, cbow is used. Accepted values are
+        'cbow', 'skipgram'.
+
+        `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.
+
+        `min_count` = ignore all words with total occurrences lower than this.
+
+        `word_ngram` = max length of word ngram
+
+        `loss` = defines training objective. Allowed values are `hs` (hierarchical softmax),
+        `ns` (negative sampling) and `softmax`. Defaults to `ns`
+
+        `sample` = threshold for configuring which higher-frequency words are randomly downsampled;
+            default is 1e-3, useful range is (0, 1e-5).
+
+        `negative` = the value for negative specifies how many "noise words" should be drawn
+        (usually between 5-20). Default is 5. If set to 0, no negative samping is used.
+        Only relevant when `loss` is set to `ns`
+
+        `iter` = number of iterations (epochs) over the corpus. Default is 5.
+
+        `min_n` = min length of char ngrams to be used for training word representations. Default is 3.
+
+        `max_n` = max length of char ngrams to be used for training word representations. Set `max_n` to be
+        lesser than `min_n` to avoid char ngrams being used. Default is 6.
+
+        `sorted_vocab` = if 1 (default), sort the vocabulary by descending frequency before
+        assigning word indexes.
+
+        `threads` = number of threads to use. Default is 12.
+
+        """
+        ft_path = ft_path
+        output_file = output_file or os.path.join(tempfile.gettempdir(), 'ft_model')
+        ft_args = {
+            'input': corpus_file,
+            'output': output_file,
+            'lr': alpha,
+            'dim': size,
+            'ws': window,
+            'epoch': iter,
+            'minCount': min_count,
+            'wordNgrams': word_ngrams,
+            'neg': negative,
+            'loss': loss,
+            'minn': min_n,
+            'maxn': max_n,
+            'thread': threads,
+            't': sample
+        }
+        cmd = [ft_path, model]
+        for option, value in ft_args.items():
+            cmd.append("-%s" % option)
+            cmd.append(str(value))
+
+        utils.check_output(args=cmd)
+        model = cls.load_fasttext_format(output_file)
+        cls.delete_training_files(output_file)
+        return model
+
+    def save(self, *args, **kwargs):
+        # don't bother storing the cached normalized vectors
+        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm', 'syn0_vocab_norm', 'syn0_ngrams_norm'])
+        super(FastText, self).save(*args, **kwargs)
+
+    @classmethod
+    def load_fasttext_format(cls, model_file, encoding='utf8'):
+        """
+        Load the input-hidden weight matrix from the fast text output files.
+
+        Note that due to limitations in the FastText API, you cannot continue training
+        with a model loaded this way, though you can query for word similarity etc.
+
+        `model_file` is the path to the FastText output files.
+        FastText outputs two model files - `/path/to/model.vec` and `/path/to/model.bin`
+
+        Expected value for this example: `/path/to/model` or `/path/to/model.bin`,
+        as gensim requires only `.bin` file to load entire fastText model.
+
+        """
+        model = cls()
+        if not model_file.endswith('.bin'):
+            model_file += '.bin'
+        model.file_name = model_file
+        model.load_binary_data(encoding=encoding)
+        return model
+
+    @classmethod
+    def load(cls, *args, **kwargs):
+        model = super(FastText, cls).load(*args, **kwargs)
+        if hasattr(model.wv, 'syn0_all'):
+            setattr(model.wv, 'syn0_ngrams', model.wv.syn0_all)
+            delattr(model.wv, 'syn0_all')
+        return model
+
+    @classmethod
+    def delete_training_files(cls, model_file):
+        """Deletes the files created by FastText training"""
+        try:
+            os.remove('%s.vec' % model_file)
+            os.remove('%s.bin' % model_file)
+        except FileNotFoundError:
+            logger.debug('Training files %s not found when attempting to delete', model_file)
+            pass
+
+    def load_binary_data(self, encoding='utf8'):
+        """Loads data from the output binary file created by FastText training"""
+        with utils.smart_open(self.file_name, 'rb') as f:
+            self.load_model_params(f)
+            self.load_dict(f, encoding=encoding)
+            self.load_vectors(f)
+
+    def load_model_params(self, file_handle):
+        magic, version = self.struct_unpack(file_handle, '@2i')
+        if magic == FASTTEXT_FILEFORMAT_MAGIC:  # newer format
+            self.new_format = True
+            dim, ws, epoch, min_count, neg, _, loss, model, bucket, minn, maxn, _, t = \
+                self.struct_unpack(file_handle, '@12i1d')
+        else:  # older format
+            self.new_format = False
+            dim = magic
+            ws = version
+            epoch, min_count, neg, _, loss, model, bucket, minn, maxn, _, t = self.struct_unpack(file_handle, '@10i1d')
+        # Parameters stored by [Args::save](https://github.com/facebookresearch/fastText/blob/master/src/args.cc)
+        self.vector_size = dim
+        self.window = ws
+        self.iter = epoch
+        self.min_count = min_count
+        self.negative = neg
+        self.hs = loss == 1
+        self.sg = model == 2
+        self.bucket = bucket
+        self.wv.min_n = minn
+        self.wv.max_n = maxn
+        self.sample = t
+
+    def load_dict(self, file_handle, encoding='utf8'):
+        vocab_size, nwords, nlabels = self.struct_unpack(file_handle, '@3i')
+        # Vocab stored by [Dictionary::save](https://github.com/facebookresearch/fastText/blob/master/src/dictionary.cc)
+        if nlabels > 0:
+            raise NotImplementedError("Supervised fastText models are not supported")
+        logger.info("loading %s words for fastText model from %s", vocab_size, self.file_name)
+
+        self.struct_unpack(file_handle, '@1q')  # number of tokens
+        if self.new_format:
+            pruneidx_size, = self.struct_unpack(file_handle, '@q')
+        for i in range(vocab_size):
+            word_bytes = b''
+            char_byte = file_handle.read(1)
+            # Read vocab word
+            while char_byte != b'\x00':
+                word_bytes += char_byte
+                char_byte = file_handle.read(1)
+            word = word_bytes.decode(encoding)
+            count, _ = self.struct_unpack(file_handle, '@qb')
+
+            self.wv.vocab[word] = Vocab(index=i, count=count)
+            self.wv.index2word.append(word)
+
+        assert len(self.wv.vocab) == nwords, (
+            'mismatch between final vocab size ({} words), '
+            'and expected number of words ({} words)'.format(len(self.wv.vocab), nwords))
+        if len(self.wv.vocab) != vocab_size:
+            # expecting to log this warning only for pretrained french vector, wiki.fr
+            logger.warning(
+                "mismatch between final vocab size (%s words), and expected vocab size (%s words)",
+                len(self.wv.vocab), vocab_size
+            )
+
+        if self.new_format:
+            for j in range(pruneidx_size):
+                self.struct_unpack(file_handle, '@2i')
+
+    def load_vectors(self, file_handle):
+        if self.new_format:
+            self.struct_unpack(file_handle, '@?')  # bool quant_input in fasttext.cc
+        num_vectors, dim = self.struct_unpack(file_handle, '@2q')
+        # Vectors stored by [Matrix::save](https://github.com/facebookresearch/fastText/blob/master/src/matrix.cc)
+        assert self.vector_size == dim, (
+            'mismatch between vector size in model params ({}) and model vectors ({})'
+            .format(self.vector_size, dim)
+        )
+        float_size = struct.calcsize('@f')
+        if float_size == 4:
+            dtype = np.dtype(np.float32)
+        elif float_size == 8:
+            dtype = np.dtype(np.float64)
+
+        self.num_original_vectors = num_vectors
+        self.wv.syn0_ngrams = np.fromfile(file_handle, dtype=dtype, count=num_vectors * dim)
+        self.wv.syn0_ngrams = self.wv.syn0_ngrams.reshape((num_vectors, dim))
+        assert self.wv.syn0_ngrams.shape == (self.bucket + len(self.wv.vocab), self.vector_size), \
+            'mismatch between actual weight matrix shape {} and expected shape {}'\
+            .format(
+                self.wv.syn0_ngrams.shape, (self.bucket + len(self.wv.vocab), self.vector_size)
+            )
+
+        self.init_ngrams()
+
+    def struct_unpack(self, file_handle, fmt):
+        num_bytes = struct.calcsize(fmt)
+        return struct.unpack(fmt, file_handle.read(num_bytes))
+
+    def init_ngrams(self):
+        """
+        Computes ngrams of all words present in vocabulary and stores vectors for only those ngrams.
+        Vectors for other ngrams are initialized with a random uniform distribution in FastText. These
+        vectors are discarded here to save space.
+
+        """
+        self.wv.ngrams = {}
+        all_ngrams = []
+        self.wv.syn0 = np.zeros((len(self.wv.vocab), self.vector_size), dtype=REAL)
+
+        for w, vocab in self.wv.vocab.items():
+            all_ngrams += compute_ngrams(w, self.wv.min_n, self.wv.max_n)
+            self.wv.syn0[vocab.index] += np.array(self.wv.syn0_ngrams[vocab.index])
+
+        all_ngrams = set(all_ngrams)
+        self.num_ngram_vectors = len(all_ngrams)
+        ngram_indices = []
+        for i, ngram in enumerate(all_ngrams):
+            ngram_hash = ft_hash(ngram)
+            ngram_indices.append(len(self.wv.vocab) + ngram_hash % self.bucket)
+            self.wv.ngrams[ngram] = i
+        self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)
+
+        ngram_weights = self.wv.syn0_ngrams
+
+        logger.info(
+            "loading weights for %s words for fastText model from %s",
+            len(self.wv.vocab), self.file_name
+        )
+
+        for w, vocab in self.wv.vocab.items():
+            word_ngrams = compute_ngrams(w, self.wv.min_n, self.wv.max_n)
+            for word_ngram in word_ngrams:
+                self.wv.syn0[vocab.index] += np.array(ngram_weights[self.wv.ngrams[word_ngram]])
+
+            self.wv.syn0[vocab.index] /= (len(word_ngrams) + 1)
+        logger.info(
+            "loaded %s weight matrix for fastText model from %s",
+            self.wv.syn0.shape, self.file_name
+        )
+
+
+def compute_ngrams(word, min_n, max_n):
+    BOW, EOW = ('<', '>')  # Used by FastText to attach to all words as prefix and suffix
+    extended_word = BOW + word + EOW
+    ngrams = []
+    for ngram_length in range(min_n, min(len(extended_word), max_n) + 1):
+        for i in range(0, len(extended_word) - ngram_length + 1):
+            ngrams.append(extended_word[i:i + ngram_length])
+    return ngrams
+
+
+def ft_hash(string):
+    """
+    Reproduces [hash method](https://github.com/facebookresearch/fastText/blob/master/src/dictionary.cc)
+    used in fastText.
+
+    """
+    # Runtime warnings for integer overflow are raised, this is expected behaviour. These warnings are suppressed.
+    old_settings = np.seterr(all='ignore')
+    h = np.uint32(2166136261)
+    for c in string:
+        h = h ^ np.uint32(ord(c))
+        h = h * np.uint32(16777619)
+    np.seterr(**old_settings)
+    return h
diff --git a/gensim/models/deprecated/keyedvectors.py b/gensim/models/deprecated/keyedvectors.py
new file mode 100644
index 0000000000..d86b0f3837
--- /dev/null
+++ b/gensim/models/deprecated/keyedvectors.py
@@ -0,0 +1,1074 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2016 Radim Rehurek <me@radimrehurek.com>
+# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
+
+"""
+Warnings
+--------
+.. deprecated:: 3.3.0
+   Use :mod:`gensim.models.keyedvectors` instead.
+
+
+Word vector storage and similarity look-ups.
+Common code independent of the way the vectors are trained(Word2Vec, FastText, WordRank, VarEmbed etc)
+
+The word vectors are considered read-only in this class.
+
+Initialize the vectors by training e.g. Word2Vec::
+
+>>> model = Word2Vec(sentences, size=100, window=5, min_count=5, workers=4)
+>>> word_vectors = model.wv
+
+Persist the word vectors to disk with::
+
+>>> word_vectors.save(fname)
+>>> word_vectors = KeyedVectors.load(fname)
+
+The vectors can also be instantiated from an existing file on disk
+in the original Google's word2vec C format as a KeyedVectors instance::
+
+  >>> from gensim.models.keyedvectors import KeyedVectors
+  >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.txt', binary=False)  # C text format
+  >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.bin', binary=True)  # C binary format
+
+You can perform various syntactic/semantic NLP word tasks with the vectors. Some of them
+are already built-in::
+
+  >>> word_vectors.most_similar(positive=['woman', 'king'], negative=['man'])
+  [('queen', 0.50882536), ...]
+
+  >>> word_vectors.most_similar_cosmul(positive=['woman', 'king'], negative=['man'])
+  [('queen', 0.71382287), ...]
+
+  >>> word_vectors.doesnt_match("breakfast cereal dinner lunch".split())
+  'cereal'
+
+  >>> word_vectors.similarity('woman', 'man')
+  0.73723527
+
+Correlation with human opinion on word similarity::
+
+  >>> word_vectors.evaluate_word_pairs(os.path.join(module_path, 'test_data','wordsim353.tsv'))
+  0.51, 0.62, 0.13
+
+And on analogies::
+
+  >>> word_vectors.accuracy(os.path.join(module_path, 'test_data', 'questions-words.txt'))
+
+and so on.
+
+"""
+from __future__ import division  # py3 "true division"
+
+import logging
+
+try:
+    from queue import Queue, Empty
+except ImportError:
+    from Queue import Queue, Empty  # noqa:F401
+
+# If pyemd C extension is available, import it.
+# If pyemd is attempted to be used, but isn't installed, ImportError will be raised in wmdistance
+try:
+    from pyemd import emd
+    PYEMD_EXT = True
+except ImportError:
+    PYEMD_EXT = False
+
+from numpy import dot, zeros, dtype, float32 as REAL,\
+    double, array, vstack, fromstring, sqrt, newaxis,\
+    ndarray, sum as np_sum, prod, ascontiguousarray,\
+    argmax
+import numpy as np
+
+from gensim import utils, matutils  # utility fnc for pickling, common scipy operations etc
+from gensim.corpora.dictionary import Dictionary
+from six import string_types, iteritems
+from six.moves import xrange
+from scipy import stats
+
+
+logger = logging.getLogger(__name__)
+
+
+class Vocab(object):
+    """
+    A single vocabulary item, used internally for collecting per-word frequency/sampling info,
+    and for constructing binary trees (incl. both word leaves and inner nodes).
+
+    """
+
+    def __init__(self, **kwargs):
+        self.count = 0
+        self.__dict__.update(kwargs)
+
+    def __lt__(self, other):  # used for sorting in a priority queue
+        return self.count < other.count
+
+    def __str__(self):
+        vals = ['%s:%r' % (key, self.__dict__[key]) for key in sorted(self.__dict__) if not key.startswith('_')]
+        return "%s(%s)" % (self.__class__.__name__, ', '.join(vals))
+
+
+class KeyedVectorsBase(utils.SaveLoad):
+    """
+    Base class to contain vectors and vocab for any set of vectors which are each associated with a key.
+
+    """
+
+    def __init__(self):
+        self.syn0 = []
+        self.vocab = {}
+        self.index2word = []
+        self.vector_size = None
+
+    def save_word2vec_format(self, fname, fvocab=None, binary=False, total_vec=None):
+        """
+        Store the input-hidden weight matrix in the same format used by the original
+        C word2vec-tool, for compatibility.
+
+         `fname` is the file used to save the vectors in
+         `fvocab` is an optional file used to save the vocabulary
+         `binary` is an optional boolean indicating whether the data is to be saved
+         in binary word2vec format (default: False)
+         `total_vec` is an optional parameter to explicitly specify total no. of vectors
+         (in case word vectors are appended with document vectors afterwards)
+
+        """
+        if total_vec is None:
+            total_vec = len(self.vocab)
+        vector_size = self.syn0.shape[1]
+        if fvocab is not None:
+            logger.info("storing vocabulary in %s", fvocab)
+            with utils.smart_open(fvocab, 'wb') as vout:
+                for word, vocab in sorted(iteritems(self.vocab), key=lambda item: -item[1].count):
+                    vout.write(utils.to_utf8("%s %s\n" % (word, vocab.count)))
+        logger.info("storing %sx%s projection weights into %s", total_vec, vector_size, fname)
+        assert (len(self.vocab), vector_size) == self.syn0.shape
+        with utils.smart_open(fname, 'wb') as fout:
+            fout.write(utils.to_utf8("%s %s\n" % (total_vec, vector_size)))
+            # store in sorted order: most frequent words at the top
+            for word, vocab in sorted(iteritems(self.vocab), key=lambda item: -item[1].count):
+                row = self.syn0[vocab.index]
+                if binary:
+                    fout.write(utils.to_utf8(word) + b" " + row.tostring())
+                else:
+                    fout.write(utils.to_utf8("%s %s\n" % (word, ' '.join("%f" % val for val in row))))
+
+    @classmethod
+    def load_word2vec_format(cls, fname, fvocab=None, binary=False, encoding='utf8', unicode_errors='strict',
+                             limit=None, datatype=REAL):
+        """
+        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).
+
+        If you trained the C model using non-utf8 encoding for words, specify that
+        encoding in `encoding`.
+
+        `unicode_errors`, default 'strict', is a string suitable to be passed as the `errors`
+        argument to the unicode() (Python 2.x) or str() (Python 3.x) function. If your source
+        file may include word tokens truncated in the middle of a multibyte unicode character
+        (as is common from the original word2vec.c tool), 'ignore' or 'replace' may help.
+
+        `limit` sets a maximum number of word-vectors to read from the file. The default,
+        None, means read all.
+
+        `datatype` (experimental) can coerce dimensions to a non-default float type (such
+        as np.float16) to save memory. (Such types may result in much slower bulk operations
+        or incompatibility with optimized routines.)
+
+        """
+        counts = None
+        if fvocab is not None:
+            logger.info("loading word counts from %s", fvocab)
+            counts = {}
+            with utils.smart_open(fvocab) as fin:
+                for line in fin:
+                    word, count = utils.to_unicode(line).strip().split()
+                    counts[word] = int(count)
+
+        logger.info("loading projection weights from %s", fname)
+        with utils.smart_open(fname) as fin:
+            header = utils.to_unicode(fin.readline(), encoding=encoding)
+            vocab_size, vector_size = (int(x) for x in header.split())  # throws for invalid file format
+            if limit:
+                vocab_size = min(vocab_size, limit)
+            result = cls()
+            result.vector_size = vector_size
+            result.syn0 = zeros((vocab_size, vector_size), dtype=datatype)
+
+            def add_word(word, weights):
+                word_id = len(result.vocab)
+                if word in result.vocab:
+                    logger.warning("duplicate word '%s' in %s, ignoring all but first", word, fname)
+                    return
+                if counts is None:
+                    # most common scenario: no vocab file given. just make up some bogus counts, in descending order
+                    result.vocab[word] = Vocab(index=word_id, count=vocab_size - word_id)
+                elif word in counts:
+                    # use count from the vocab file
+                    result.vocab[word] = Vocab(index=word_id, count=counts[word])
+                else:
+                    # vocab file given, but word is missing -- set count to None (TODO: or raise?)
+                    logger.warning("vocabulary file is incomplete: '%s' is missing", word)
+                    result.vocab[word] = Vocab(index=word_id, count=None)
+                result.syn0[word_id] = weights
+                result.index2word.append(word)
+
+            if binary:
+                binary_len = dtype(REAL).itemsize * vector_size
+                for _ in xrange(vocab_size):
+                    # mixed text and binary: read text first, then binary
+                    word = []
+                    while True:
+                        ch = fin.read(1)
+                        if ch == b' ':
+                            break
+                        if ch == b'':
+                            raise EOFError("unexpected end of input; is count incorrect or file otherwise damaged?")
+                        if ch != b'\n':  # ignore newlines in front of words (some binary files have)
+                            word.append(ch)
+                    word = utils.to_unicode(b''.join(word), encoding=encoding, errors=unicode_errors)
+                    weights = fromstring(fin.read(binary_len), dtype=REAL)
+                    add_word(word, weights)
+            else:
+                for line_no in xrange(vocab_size):
+                    line = fin.readline()
+                    if line == b'':
+                        raise EOFError("unexpected end of input; is count incorrect or file otherwise damaged?")
+                    parts = utils.to_unicode(line.rstrip(), encoding=encoding, errors=unicode_errors).split(" ")
+                    if len(parts) != vector_size + 1:
+                        raise ValueError("invalid vector on line %s (is this really the text format?)" % line_no)
+                    word, weights = parts[0], [REAL(x) for x in parts[1:]]
+                    add_word(word, weights)
+        if result.syn0.shape[0] != len(result.vocab):
+            logger.info(
+                "duplicate words detected, shrinking matrix size from %i to %i",
+                result.syn0.shape[0], len(result.vocab)
+            )
+            result.syn0 = ascontiguousarray(result.syn0[: len(result.vocab)])
+        assert (len(result.vocab), vector_size) == result.syn0.shape
+
+        logger.info("loaded %s matrix from %s", result.syn0.shape, fname)
+        return result
+
+    def similarity(self, w1, w2):
+        """
+        Compute similarity between vectors of two input words.
+        To be implemented by child class.
+
+        """
+        raise NotImplementedError
+
+    def distance(self, w1, w2):
+        """
+        Compute distance between vectors of two input words.
+        To be implemented by child class.
+
+        """
+        raise NotImplementedError
+
+    def distances(self, word_or_vector, other_words=()):
+        """
+        Compute distances from given word or vector to all words in `other_words`.
+        If `other_words` is empty, return distance between `word_or_vectors` and all words in vocab.
+        To be implemented by child class.
+
+        """
+        raise NotImplementedError
+
+    def word_vec(self, word):
+        """
+        Accept a single word as input.
+        Returns the word's representations in vector space, as a 1D numpy array.
+
+        Example::
+
+          >>> trained_model.word_vec('office')
+          array([ -1.40128313e-02, ...])
+
+        """
+        if word in self.vocab:
+            result = self.syn0[self.vocab[word].index]
+            result.setflags(write=False)
+            return result
+        else:
+            raise KeyError("word '%s' not in vocabulary" % word)
+
+    def __getitem__(self, words):
+        """
+        Accept a single word or a list of words as input.
+
+        If a single word: returns the word's representations in vector space, as
+        a 1D numpy array.
+
+        Multiple words: return the words' representations in vector space, as a
+        2d numpy array: #words x #vector_size. Matrix rows are in the same order
+        as in input.
+
+        Example::
+
+          >>> trained_model['office']
+          array([ -1.40128313e-02, ...])
+
+          >>> trained_model[['office', 'products']]
+          array([ -1.40128313e-02, ...]
+                [ -1.70425311e-03, ...]
+                 ...)
+
+        """
+        if isinstance(words, string_types):
+            # allow calls like trained_model['office'], as a shorthand for trained_model[['office']]
+            return self.word_vec(words)
+
+        return vstack([self.word_vec(word) for word in words])
+
+    def __contains__(self, word):
+        return word in self.vocab
+
+    def most_similar_to_given(self, w1, word_list):
+        """Return the word from word_list most similar to w1.
+
+        Args:
+            w1 (str): a word
+            word_list (list): list of words containing a word most similar to w1
+
+        Returns:
+            the word in word_list with the highest similarity to w1
+
+        Raises:
+            KeyError: If w1 or any word in word_list is not in the vocabulary
+
+        Example::
+
+          >>> trained_model.most_similar_to_given('music', ['water', 'sound', 'backpack', 'mouse'])
+          'sound'
+
+          >>> trained_model.most_similar_to_given('snake', ['food', 'pencil', 'animal', 'phone'])
+          'animal'
+
+        """
+        return word_list[argmax([self.similarity(w1, word) for word in word_list])]
+
+    def words_closer_than(self, w1, w2):
+        """
+        Returns all words that are closer to `w1` than `w2` is to `w1`.
+
+        Parameters
+        ----------
+        w1 : str
+            Input word.
+        w2 : str
+            Input word.
+
+        Returns
+        -------
+        list (str)
+            List of words that are closer to `w1` than `w2` is to `w1`.
+
+        Examples
+        --------
+
+        >>> model.words_closer_than('carnivore.n.01', 'mammal.n.01')
+        ['dog.n.01', 'canine.n.02']
+
+        """
+        all_distances = self.distances(w1)
+        w1_index = self.vocab[w1].index
+        w2_index = self.vocab[w2].index
+        closer_node_indices = np.where(all_distances < all_distances[w2_index])[0]
+        return [self.index2word[index] for index in closer_node_indices if index != w1_index]
+
+    def rank(self, w1, w2):
+        """
+        Rank of the distance of `w2` from `w1`, in relation to distances of all words from `w1`.
+
+        Parameters
+        ----------
+        w1 : str
+            Input word.
+        w2 : str
+            Input word.
+
+        Returns
+        -------
+        int
+            Rank of `w2` from `w1` in relation to all other nodes.
+
+        Examples
+        --------
+
+        >>> model.rank('mammal.n.01', 'carnivore.n.01')
+        3
+
+        """
+        return len(self.words_closer_than(w1, w2)) + 1
+
+
+class EuclideanKeyedVectors(KeyedVectorsBase):
+    """
+    Class to contain vectors and vocab for the Word2Vec training class and other w2v methods not directly
+    involved in training such as most_similar()
+    """
+
+    def __init__(self):
+        super(EuclideanKeyedVectors, self).__init__()
+        self.syn0norm = None
+
+    @property
+    def wv(self):
+        return self
+
+    def save(self, *args, **kwargs):
+        # don't bother storing the cached normalized vectors
+        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm'])
+        super(EuclideanKeyedVectors, self).save(*args, **kwargs)
+
+    def word_vec(self, word, use_norm=False):
+        """
+        Accept a single word as input.
+        Returns the word's representations in vector space, as a 1D numpy array.
+
+        If `use_norm` is True, returns the normalized word vector.
+
+        Example::
+
+          >>> trained_model['office']
+          array([ -1.40128313e-02, ...])
+
+        """
+        if word in self.vocab:
+            if use_norm:
+                result = self.syn0norm[self.vocab[word].index]
+            else:
+                result = self.syn0[self.vocab[word].index]
+
+            result.setflags(write=False)
+            return result
+        else:
+            raise KeyError("word '%s' not in vocabulary" % word)
+
+    def most_similar(self, positive=None, negative=None, topn=10, restrict_vocab=None, indexer=None):
+        """
+        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 the vectors for each word in the model.
+        The method corresponds to the `word-analogy` and `distance` scripts in the original
+        word2vec implementation.
+
+        If topn is False, most_similar returns the vector of similarity scores.
+
+        `restrict_vocab` is an optional integer which limits the range of vectors which
+        are searched for most-similar values. For example, restrict_vocab=10000 would
+        only check the first 10000 word vectors in the vocabulary order. (This may be
+        meaningful if you've sorted the vocabulary by descending frequency.)
+
+        Example::
+
+          >>> trained_model.most_similar(positive=['woman', 'king'], negative=['man'])
+          [('queen', 0.50882536), ...]
+
+        """
+        if positive is None:
+            positive = []
+        if negative is None:
+            negative = []
+
+        self.init_sims()
+
+        if isinstance(positive, string_types) and not negative:
+            # allow calls like most_similar('dog'), as a shorthand for most_similar(['dog'])
+            positive = [positive]
+
+        # add weights for each word, if not already present; default to 1.0 for positive and -1.0 for negative words
+        positive = [
+            (word, 1.0) if isinstance(word, string_types + (ndarray,)) else word
+            for word in positive
+        ]
+        negative = [
+            (word, -1.0) if isinstance(word, string_types + (ndarray,)) else word
+            for word in negative
+        ]
+
+        # compute the weighted average of all words
+        all_words, mean = set(), []
+        for word, weight in positive + negative:
+            if isinstance(word, ndarray):
+                mean.append(weight * word)
+            else:
+                mean.append(weight * self.word_vec(word, use_norm=True))
+                if word in self.vocab:
+                    all_words.add(self.vocab[word].index)
+        if not mean:
+            raise ValueError("cannot compute similarity with no input")
+        mean = matutils.unitvec(array(mean).mean(axis=0)).astype(REAL)
+
+        if indexer is not None:
+            return indexer.most_similar(mean, topn)
+
+        limited = self.syn0norm if restrict_vocab is None else self.syn0norm[:restrict_vocab]
+        dists = dot(limited, mean)
+        if not topn:
+            return dists
+        best = matutils.argsort(dists, topn=topn + len(all_words), reverse=True)
+        # ignore (don't return) words from the input
+        result = [(self.index2word[sim], float(dists[sim])) for sim in best if sim not in all_words]
+        return result[:topn]
+
+    def similar_by_word(self, word, topn=10, restrict_vocab=None):
+        """
+        Find the top-N most similar words.
+
+        If topn is False, similar_by_word returns the vector of similarity scores.
+
+        `restrict_vocab` is an optional integer which limits the range of vectors which
+        are searched for most-similar values. For example, restrict_vocab=10000 would
+        only check the first 10000 word vectors in the vocabulary order. (This may be
+        meaningful if you've sorted the vocabulary by descending frequency.)
+
+        Example::
+
+          >>> trained_model.similar_by_word('graph')
+          [('user', 0.9999163150787354), ...]
+
+        """
+        return self.most_similar(positive=[word], topn=topn, restrict_vocab=restrict_vocab)
+
+    def similar_by_vector(self, vector, topn=10, restrict_vocab=None):
+        """
+        Find the top-N most similar words by vector.
+
+        If topn is False, similar_by_vector returns the vector of similarity scores.
+
+        `restrict_vocab` is an optional integer which limits the range of vectors which
+        are searched for most-similar values. For example, restrict_vocab=10000 would
+        only check the first 10000 word vectors in the vocabulary order. (This may be
+        meaningful if you've sorted the vocabulary by descending frequency.)
+
+        Example::
+
+          >>> trained_model.similar_by_vector([1,2])
+          [('survey', 0.9942699074745178), ...]
+
+        """
+        return self.most_similar(positive=[vector], topn=topn, restrict_vocab=restrict_vocab)
+
+    def wmdistance(self, document1, document2):
+        """
+        Compute the Word Mover's Distance between two documents. When using this
+        code, please consider citing the following papers:
+
+        .. Ofir Pele and Michael Werman, "A linear time histogram metric for improved SIFT matching".
+        .. Ofir Pele and Michael Werman, "Fast and robust earth mover's distances".
+        .. Matt Kusner et al. "From Word Embeddings To Document Distances".
+
+        Note that if one of the documents have no words that exist in the
+        Word2Vec vocab, `float('inf')` (i.e. infinity) will be returned.
+
+        This method only works if `pyemd` is installed (can be installed via pip, but requires a C compiler).
+
+        Example:
+            >>> # Train word2vec model.
+            >>> model = Word2Vec(sentences)
+
+            >>> # Some sentences to test.
+            >>> sentence_obama = 'Obama speaks to the media in Illinois'.lower().split()
+            >>> sentence_president = 'The president greets the press in Chicago'.lower().split()
+
+            >>> # Remove their stopwords.
+            >>> from nltk.corpus import stopwords
+            >>> stopwords = nltk.corpus.stopwords.words('english')
+            >>> sentence_obama = [w for w in sentence_obama if w not in stopwords]
+            >>> sentence_president = [w for w in sentence_president if w not in stopwords]
+
+            >>> # Compute WMD.
+            >>> distance = model.wmdistance(sentence_obama, sentence_president)
+        """
+
+        if not PYEMD_EXT:
+            raise ImportError("Please install pyemd Python package to compute WMD.")
+
+        # Remove out-of-vocabulary words.
+        len_pre_oov1 = len(document1)
+        len_pre_oov2 = len(document2)
+        document1 = [token for token in document1 if token in self]
+        document2 = [token for token in document2 if token in self]
+        diff1 = len_pre_oov1 - len(document1)
+        diff2 = len_pre_oov2 - len(document2)
+        if diff1 > 0 or diff2 > 0:
+            logger.info('Removed %d and %d OOV words from document 1 and 2 (respectively).', diff1, diff2)
+
+        if len(document1) == 0 or len(document2) == 0:
+            logger.info(
+                "At least one of the documents had no words that werein the vocabulary. "
+                "Aborting (returning inf)."
+            )
+            return float('inf')
+
+        dictionary = Dictionary(documents=[document1, document2])
+        vocab_len = len(dictionary)
+
+        if vocab_len == 1:
+            # Both documents are composed by a single unique token
+            return 0.0
+
+        # Sets for faster look-up.
+        docset1 = set(document1)
+        docset2 = set(document2)
+
+        # Compute distance matrix.
+        distance_matrix = zeros((vocab_len, vocab_len), dtype=double)
+        for i, t1 in dictionary.items():
+            for j, t2 in dictionary.items():
+                if t1 not in docset1 or t2 not in docset2:
+                    continue
+                # Compute Euclidean distance between word vectors.
+                distance_matrix[i, j] = sqrt(np_sum((self[t1] - self[t2])**2))
+
+        if np_sum(distance_matrix) == 0.0:
+            # `emd` gets stuck if the distance matrix contains only zeros.
+            logger.info('The distance matrix is all zeros. Aborting (returning inf).')
+            return float('inf')
+
+        def nbow(document):
+            d = zeros(vocab_len, dtype=double)
+            nbow = dictionary.doc2bow(document)  # Word frequencies.
+            doc_len = len(document)
+            for idx, freq in nbow:
+                d[idx] = freq / float(doc_len)  # Normalized word frequencies.
+            return d
+
+        # Compute nBOW representation of documents.
+        d1 = nbow(document1)
+        d2 = nbow(document2)
+
+        # Compute WMD.
+        return emd(d1, d2, distance_matrix)
+
+    def most_similar_cosmul(self, positive=None, negative=None, 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.
+
+        """
+        if positive is None:
+            positive = []
+        if negative is None:
+            negative = []
+
+        self.init_sims()
+
+        if isinstance(positive, string_types) and not negative:
+            # allow calls like most_similar_cosmul('dog'), as a shorthand for most_similar_cosmul(['dog'])
+            positive = [positive]
+
+        all_words = {
+            self.vocab[word].index for word in positive + negative
+            if not isinstance(word, ndarray) and word in self.vocab
+            }
+
+        positive = [
+            self.word_vec(word, use_norm=True) if isinstance(word, string_types) else word
+            for word in positive
+        ]
+        negative = [
+            self.word_vec(word, use_norm=True) if isinstance(word, string_types) else word
+            for word in negative
+        ]
+
+        if not positive:
+            raise ValueError("cannot compute similarity with no input")
+
+        # equation (4) of Levy & Goldberg "Linguistic Regularities...",
+        # with distances shifted to [0,1] per footnote (7)
+        pos_dists = [((1 + dot(self.syn0norm, term)) / 2) for term in positive]
+        neg_dists = [((1 + dot(self.syn0norm, term)) / 2) for term in negative]
+        dists = prod(pos_dists, axis=0) / (prod(neg_dists, axis=0) + 0.000001)
+
+        if not topn:
+            return dists
+        best = matutils.argsort(dists, topn=topn + len(all_words), reverse=True)
+        # ignore (don't return) words from the input
+        result = [(self.index2word[sim], float(dists[sim])) for sim in best if sim not in all_words]
+        return result[:topn]
+
+    def doesnt_match(self, words):
+        """
+        Which word from the given list doesn't go with the others?
+
+        Example::
+
+          >>> trained_model.doesnt_match("breakfast cereal dinner lunch".split())
+          'cereal'
+
+        """
+        self.init_sims()
+
+        used_words = [word for word in words if word in self]
+        if len(used_words) != len(words):
+            ignored_words = set(words) - set(used_words)
+            logger.warning("vectors for words %s are not present in the model, ignoring these words", ignored_words)
+        if not used_words:
+            raise ValueError("cannot select a word from an empty list")
+        vectors = vstack(self.word_vec(word, use_norm=True) for word in used_words).astype(REAL)
+        mean = matutils.unitvec(vectors.mean(axis=0)).astype(REAL)
+        dists = dot(vectors, mean)
+        return sorted(zip(dists, used_words))[0][1]
+
+    @staticmethod
+    def cosine_similarities(vector_1, vectors_all):
+        """
+        Return cosine similarities between one vector and a set of other vectors.
+
+        Parameters
+        ----------
+        vector_1 : numpy.array
+            vector from which similarities are to be computed.
+            expected shape (dim,)
+        vectors_all : numpy.array
+            for each row in vectors_all, distance from vector_1 is computed.
+            expected shape (num_vectors, dim)
+
+        Returns
+        -------
+        numpy.array
+            Contains cosine distance between vector_1 and each row in vectors_all.
+            shape (num_vectors,)
+
+        """
+        norm = np.linalg.norm(vector_1)
+        all_norms = np.linalg.norm(vectors_all, axis=1)
+        dot_products = dot(vectors_all, vector_1)
+        similarities = dot_products / (norm * all_norms)
+        return similarities
+
+    def distances(self, word_or_vector, other_words=()):
+        """
+        Compute cosine distances from given word or vector to all words in `other_words`.
+        If `other_words` is empty, return distance between `word_or_vectors` and all words in vocab.
+
+        Parameters
+        ----------
+        word_or_vector : str or numpy.array
+            Word or vector from which distances are to be computed.
+
+        other_words : iterable(str) or None
+            For each word in `other_words` distance from `word_or_vector` is computed.
+            If None or empty, distance of `word_or_vector` from all words in vocab is computed (including itself).
+
+        Returns
+        -------
+        numpy.array
+            Array containing distances to all words in `other_words` from input `word_or_vector`,
+            in the same order as `other_words`.
+
+        Notes
+        -----
+        Raises KeyError if either `word_or_vector` or any word in `other_words` is absent from vocab.
+
+        """
+        if isinstance(word_or_vector, string_types):
+            input_vector = self.word_vec(word_or_vector)
+        else:
+            input_vector = word_or_vector
+        if not other_words:
+            other_vectors = self.syn0
+        else:
+            other_indices = [self.vocab[word].index for word in other_words]
+            other_vectors = self.syn0[other_indices]
+        return 1 - self.cosine_similarities(input_vector, other_vectors)
+
+    def distance(self, w1, w2):
+        """
+        Compute cosine distance between two words.
+
+        Example::
+
+          >>> trained_model.distance('woman', 'man')
+          0.34
+
+          >>> trained_model.distance('woman', 'woman')
+          0.0
+
+        """
+        return 1 - self.similarity(w1, w2)
+
+    def similarity(self, w1, w2):
+        """
+        Compute cosine similarity between two words.
+
+        Example::
+
+          >>> trained_model.similarity('woman', 'man')
+          0.73723527
+
+          >>> trained_model.similarity('woman', 'woman')
+          1.0
+
+        """
+        return dot(matutils.unitvec(self[w1]), matutils.unitvec(self[w2]))
+
+    def n_similarity(self, 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
+
+        """
+        if not(len(ws1) and len(ws2)):
+            raise ZeroDivisionError('At least one of the passed list is empty.')
+        v1 = [self[word] for word in ws1]
+        v2 = [self[word] for word in ws2]
+        return dot(matutils.unitvec(array(v1).mean(axis=0)), matutils.unitvec(array(v2).mean(axis=0)))
+
+    @staticmethod
+    def log_accuracy(section):
+        correct, incorrect = len(section['correct']), len(section['incorrect'])
+        if correct + incorrect > 0:
+            logger.info(
+                "%s: %.1f%% (%i/%i)",
+                section['section'], 100.0 * correct / (correct + incorrect), correct, correct + incorrect
+            )
+
+    def accuracy(self, questions, restrict_vocab=30000, most_similar=most_similar, case_insensitive=True):
+        """
+        Compute accuracy of the model. `questions` is a filename where lines are
+        4-tuples of words, split into sections by ": SECTION NAME" lines.
+        See questions-words.txt in
+        https://storage.googleapis.com/google-code-archive-source/v2/code.google.com/word2vec/source-archive.zip
+        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 not in the first `restrict_vocab`
+        words (default 30,000). This may be meaningful if you've sorted the vocabulary by descending frequency.
+        In case `case_insensitive` is True, the first `restrict_vocab` words are taken first, and then
+        case normalization is performed.
+
+        Use `case_insensitive` to convert all words in questions and vocab to their uppercase form before
+        evaluating the accuracy (default True). Useful in case of case-mismatch between training tokens
+        and question words. In case of multiple case variants of a single word, the vector for the first
+        occurrence (also the most frequent if vocabulary is sorted) is taken.
+
+        This method corresponds to the `compute-accuracy` script of the original C word2vec.
+
+        """
+        ok_vocab = [(w, self.vocab[w]) for w in self.index2word[:restrict_vocab]]
+        ok_vocab = {w.upper(): v for w, v in reversed(ok_vocab)} if case_insensitive else dict(ok_vocab)
+
+        sections, section = [], None
+        for line_no, line in enumerate(utils.smart_open(questions)):
+            # TODO: use level3 BLAS (=evaluate multiple questions at once), for speed
+            line = utils.to_unicode(line)
+            if line.startswith(': '):
+                # a new section starts => store the old section
+                if section:
+                    sections.append(section)
+                    self.log_accuracy(section)
+                section = {'section': line.lstrip(': ').strip(), 'correct': [], 'incorrect': []}
+            else:
+                if not section:
+                    raise ValueError("missing section header before line #%i in %s" % (line_no, questions))
+                try:
+                    if case_insensitive:
+                        a, b, c, expected = [word.upper() for word in line.split()]
+                    else:
+                        a, b, c, expected = [word for word in line.split()]
+                except ValueError:
+                    logger.info("skipping invalid line #%i in %s", line_no, questions)
+                    continue
+                if a not in ok_vocab or b not in ok_vocab or c not in ok_vocab or expected not in ok_vocab:
+                    logger.debug("skipping line #%i with OOV words: %s", line_no, line.strip())
+                    continue
+
+                original_vocab = self.vocab
+                self.vocab = ok_vocab
+                ignore = {a, b, c}  # input words to be ignored
+                predicted = None
+                # find the most likely prediction, ignoring OOV words and input words
+                sims = most_similar(self, positive=[b, c], negative=[a], topn=False, restrict_vocab=restrict_vocab)
+                self.vocab = original_vocab
+                for index in matutils.argsort(sims, reverse=True):
+                    predicted = self.index2word[index].upper() if case_insensitive else self.index2word[index]
+                    if predicted in ok_vocab and predicted not in ignore:
+                        if predicted != expected:
+                            logger.debug("%s: expected %s, predicted %s", line.strip(), expected, predicted)
+                        break
+                if predicted == expected:
+                    section['correct'].append((a, b, c, expected))
+                else:
+                    section['incorrect'].append((a, b, c, expected))
+        if section:
+            # store the last section, too
+            sections.append(section)
+            self.log_accuracy(section)
+
+        total = {
+            'section': 'total',
+            'correct': sum((s['correct'] for s in sections), []),
+            'incorrect': sum((s['incorrect'] for s in sections), []),
+        }
+        self.log_accuracy(total)
+        sections.append(total)
+        return sections
+
+    @staticmethod
+    def log_evaluate_word_pairs(pearson, spearman, oov, pairs):
+        logger.info('Pearson correlation coefficient against %s: %.4f', pairs, pearson[0])
+        logger.info('Spearman rank-order correlation coefficient against %s: %.4f', pairs, spearman[0])
+        logger.info('Pairs with unknown words ratio: %.1f%%', oov)
+
+    def evaluate_word_pairs(self, pairs, delimiter='\t', restrict_vocab=300000,
+                            case_insensitive=True, dummy4unknown=False):
+        """
+        Compute correlation of the model with human similarity judgments. `pairs` is a filename of a dataset where
+        lines are 3-tuples, each consisting of a word pair and a similarity value, separated by `delimiter`.
+        An example dataset is included in Gensim (test/test_data/wordsim353.tsv). More datasets can be found at
+        http://technion.ac.il/~ira.leviant/MultilingualVSMdata.html or https://www.cl.cam.ac.uk/~fh295/simlex.html.
+
+        The model is evaluated using Pearson correlation coefficient and Spearman rank-order correlation coefficient
+        between the similarities from the dataset and the similarities produced by the model itself.
+        The results are printed to log and returned as a triple (pearson, spearman, ratio of pairs with unknown words).
+
+        Use `restrict_vocab` to ignore all word pairs containing a word not in the first `restrict_vocab`
+        words (default 300,000). This may be meaningful if you've sorted the vocabulary by descending frequency.
+        If `case_insensitive` is True, the first `restrict_vocab` words are taken, and then case normalization
+        is performed.
+
+        Use `case_insensitive` to convert all words in the pairs and vocab to their uppercase form before
+        evaluating the model (default True). Useful when you expect case-mismatch between training tokens
+        and words pairs in the dataset. If there are multiple case variants of a single word, the vector for the first
+        occurrence (also the most frequent if vocabulary is sorted) is taken.
+
+        Use `dummy4unknown=True` to produce zero-valued similarities for pairs with out-of-vocabulary words.
+        Otherwise (default False), these pairs are skipped entirely.
+        """
+        ok_vocab = [(w, self.vocab[w]) for w in self.index2word[:restrict_vocab]]
+        ok_vocab = {w.upper(): v for w, v in reversed(ok_vocab)} if case_insensitive else dict(ok_vocab)
+
+        similarity_gold = []
+        similarity_model = []
+        oov = 0
+
+        original_vocab = self.vocab
+        self.vocab = ok_vocab
+
+        for line_no, line in enumerate(utils.smart_open(pairs)):
+            line = utils.to_unicode(line)
+            if line.startswith('#'):
+                # May be a comment
+                continue
+            else:
+                try:
+                    if case_insensitive:
+                        a, b, sim = [word.upper() for word in line.split(delimiter)]
+                    else:
+                        a, b, sim = [word for word in line.split(delimiter)]
+                    sim = float(sim)
+                except (ValueError, TypeError):
+                    logger.info('skipping invalid line #%d in %s', line_no, pairs)
+                    continue
+                if a not in ok_vocab or b not in ok_vocab:
+                    oov += 1
+                    if dummy4unknown:
+                        similarity_model.append(0.0)
+                        similarity_gold.append(sim)
+                        continue
+                    else:
+                        logger.debug('skipping line #%d with OOV words: %s', line_no, line.strip())
+                        continue
+                similarity_gold.append(sim)  # Similarity from the dataset
+                similarity_model.append(self.similarity(a, b))  # Similarity from the model
+        self.vocab = original_vocab
+        spearman = stats.spearmanr(similarity_gold, similarity_model)
+        pearson = stats.pearsonr(similarity_gold, similarity_model)
+        oov_ratio = float(oov) / (len(similarity_gold) + oov) * 100
+
+        logger.debug('Pearson correlation coefficient against %s: %f with p-value %f', pairs, pearson[0], pearson[1])
+        logger.debug(
+            'Spearman rank-order correlation coefficient against %s: %f with p-value %f',
+            pairs, spearman[0], spearman[1]
+        )
+        logger.debug('Pairs with unknown words: %d', oov)
+        self.log_evaluate_word_pairs(pearson, spearman, oov_ratio, pairs)
+        return pearson, spearman, oov_ratio
+
+    def init_sims(self, 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`.
+
+        """
+        if getattr(self, 'syn0norm', None) is None or replace:
+            logger.info("precomputing L2-norms of word weight vectors")
+            if replace:
+                for i in xrange(self.syn0.shape[0]):
+                    self.syn0[i, :] /= sqrt((self.syn0[i, :] ** 2).sum(-1))
+                self.syn0norm = self.syn0
+            else:
+                self.syn0norm = (self.syn0 / sqrt((self.syn0 ** 2).sum(-1))[..., newaxis]).astype(REAL)
+
+    def get_keras_embedding(self, train_embeddings=False):
+        """
+        Return a Keras 'Embedding' layer with weights set as the Word2Vec model's learned word embeddings
+        """
+        try:
+            from keras.layers import Embedding
+        except ImportError:
+            raise ImportError("Please install Keras to use this function")
+        weights = self.syn0
+
+        # set `trainable` as `False` to use the pretrained word embedding
+        # No extra mem usage here as `Embedding` layer doesn't create any new matrix for weights
+        layer = Embedding(
+            input_dim=weights.shape[0], output_dim=weights.shape[1],
+            weights=[weights], trainable=train_embeddings
+        )
+        return layer
+
+
+# For backward compatibility
+KeyedVectors = EuclideanKeyedVectors
diff --git a/gensim/models/deprecated/old_saveload.py b/gensim/models/deprecated/old_saveload.py
new file mode 100644
index 0000000000..44f4a5619d
--- /dev/null
+++ b/gensim/models/deprecated/old_saveload.py
@@ -0,0 +1,399 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2018 Radim Rehurek <me@radimrehurek.com>
+# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
+"""
+Warnings
+--------
+.. deprecated:: 3.3.0
+   Use :mod:`gensim.utils` instead.
+
+
+Class containing the old SaveLoad class with modeified `unpickle` function is support loading models saved using
+an older gensim version.
+
+"""
+from __future__ import with_statement
+
+import logging
+
+try:
+    import cPickle as _pickle
+except ImportError:
+    import pickle as _pickle
+
+import re
+import sys
+
+import numpy as np
+import scipy.sparse
+
+from six import iteritems
+
+from smart_open import smart_open
+
+if sys.version_info[0] >= 3:
+    unicode = str
+
+logger = logging.getLogger(__name__)
+
+
+PAT_ALPHABETIC = re.compile(r'(((?![\d])\w)+)', re.UNICODE)
+RE_HTML_ENTITY = re.compile(r'&(#?)([xX]?)(\w{1,8});', re.UNICODE)
+
+
+class SaveLoad(object):
+    """Class which inherit from this class have save/load functions, which un/pickle them to disk.
+
+    Warnings
+    --------
+    This uses pickle for de/serializing, so objects must not contain unpicklable attributes,
+    such as lambda functions etc.
+
+    """
+    @classmethod
+    def load(cls, fname, mmap=None):
+        """Load a previously saved object (using :meth:`~gensim.utils.SaveLoad.save`) from file.
+
+        Parameters
+        ----------
+        fname : str
+            Path to file that contains needed object.
+        mmap : str, optional
+            Memory-map option.  If the object was saved with large arrays stored separately, you can load these arrays
+            via mmap (shared memory) using `mmap='r'.
+            If the file being loaded is compressed (either '.gz' or '.bz2'), then `mmap=None` **must be** set.
+
+        See Also
+        --------
+        :meth:`~gensim.utils.SaveLoad.save`
+
+        Returns
+        -------
+        object
+            Object loaded from `fname`.
+
+        Raises
+        ------
+        IOError
+            When methods are called on instance (should be called from class).
+
+        """
+        logger.info("loading %s object from %s", cls.__name__, fname)
+
+        compress, subname = SaveLoad._adapt_by_suffix(fname)
+
+        obj = unpickle(fname)
+        obj._load_specials(fname, mmap, compress, subname)
+        logger.info("loaded %s", fname)
+        return obj
+
+    def _load_specials(self, fname, mmap, compress, subname):
+        """Loads any attributes that were stored specially, and gives the same opportunity
+        to recursively included :class:`~gensim.utils.SaveLoad` instances.
+
+        Parameters
+        ----------
+        fname : str
+            Path to file that contains needed object.
+        mmap : str
+            Memory-map option.
+        compress : bool
+            Set to True if file is compressed.
+        subname : str
+            ...
+
+
+        """
+        def mmap_error(obj, filename):
+            return IOError(
+                'Cannot mmap compressed object %s in file %s. ' % (obj, filename) +
+                'Use `load(fname, mmap=None)` or uncompress files manually.'
+            )
+
+        for attrib in getattr(self, '__recursive_saveloads', []):
+            cfname = '.'.join((fname, attrib))
+            logger.info("loading %s recursively from %s.* with mmap=%s", attrib, cfname, mmap)
+            getattr(self, attrib)._load_specials(cfname, mmap, compress, subname)
+
+        for attrib in getattr(self, '__numpys', []):
+            logger.info("loading %s from %s with mmap=%s", attrib, subname(fname, attrib), mmap)
+
+            if compress:
+                if mmap:
+                    raise mmap_error(attrib, subname(fname, attrib))
+
+                val = np.load(subname(fname, attrib))['val']
+            else:
+                val = np.load(subname(fname, attrib), mmap_mode=mmap)
+
+            setattr(self, attrib, val)
+
+        for attrib in getattr(self, '__scipys', []):
+            logger.info("loading %s from %s with mmap=%s", attrib, subname(fname, attrib), mmap)
+            sparse = unpickle(subname(fname, attrib))
+            if compress:
+                if mmap:
+                    raise mmap_error(attrib, subname(fname, attrib))
+
+                with np.load(subname(fname, attrib, 'sparse')) as f:
+                    sparse.data = f['data']
+                    sparse.indptr = f['indptr']
+                    sparse.indices = f['indices']
+            else:
+                sparse.data = np.load(subname(fname, attrib, 'data'), mmap_mode=mmap)
+                sparse.indptr = np.load(subname(fname, attrib, 'indptr'), mmap_mode=mmap)
+                sparse.indices = np.load(subname(fname, attrib, 'indices'), mmap_mode=mmap)
+
+            setattr(self, attrib, sparse)
+
+        for attrib in getattr(self, '__ignoreds', []):
+            logger.info("setting ignored attribute %s to None", attrib)
+            setattr(self, attrib, None)
+
+    @staticmethod
+    def _adapt_by_suffix(fname):
+        """Give appropriate compress setting and filename formula.
+
+        Parameters
+        ----------
+        fname : str
+            Input filename.
+
+        Returns
+        -------
+        (bool, function)
+            First argument will be True if `fname` compressed.
+
+        """
+        compress, suffix = (True, 'npz') if fname.endswith('.gz') or fname.endswith('.bz2') else (False, 'npy')
+        return compress, lambda *args: '.'.join(args + (suffix,))
+
+    def _smart_save(self, fname, separately=None, sep_limit=10 * 1024**2, ignore=frozenset(), pickle_protocol=2):
+        """Save the object to file.
+
+        Parameters
+        ----------
+        fname : str
+            Path to file.
+        separately : list, optional
+            Iterable of attributes than need to store distinctly.
+        sep_limit : int, optional
+            Limit for separation.
+        ignore : frozenset, optional
+            Attributes that shouldn't be store.
+        pickle_protocol : int, optional
+            Protocol number for pickle.
+
+        Notes
+        -----
+        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.
+
+        See Also
+        --------
+        :meth:`~gensim.utils.SaveLoad.load`
+
+        """
+        logger.info("saving %s object under %s, separately %s", self.__class__.__name__, fname, separately)
+
+        compress, subname = SaveLoad._adapt_by_suffix(fname)
+
+        restores = self._save_specials(fname, separately, sep_limit, ignore, pickle_protocol,
+                                       compress, subname)
+        try:
+            pickle(self, fname, protocol=pickle_protocol)
+        finally:
+            # restore attribs handled specially
+            for obj, asides in restores:
+                for attrib, val in iteritems(asides):
+                    setattr(obj, attrib, val)
+        logger.info("saved %s", fname)
+
+    def _save_specials(self, fname, separately, sep_limit, ignore, pickle_protocol, compress, subname):
+        """Save aside any attributes that need to be handled separately, including
+        by recursion any attributes that are themselves :class:`~gensim.utils.SaveLoad` instances.
+
+        Parameters
+        ----------
+        fname : str
+            Output filename.
+        separately : list or None
+            Iterable of attributes than need to store distinctly
+        sep_limit : int
+            Limit for separation.
+        ignore : iterable of str
+            Attributes that shouldn't be store.
+        pickle_protocol : int
+            Protocol number for pickle.
+        compress : bool
+            If True - compress output with :func:`numpy.savez_compressed`.
+        subname : function
+            Produced by :meth:`~gensim.utils.SaveLoad._adapt_by_suffix`
+
+        Returns
+        -------
+        list of (obj, {attrib: value, ...})
+            Settings that the caller should use to restore each object's attributes that were set aside
+            during the default :func:`~gensim.utils.pickle`.
+
+        """
+        asides = {}
+        sparse_matrices = (scipy.sparse.csr_matrix, scipy.sparse.csc_matrix)
+        if separately is None:
+            separately = []
+            for attrib, val in iteritems(self.__dict__):
+                if isinstance(val, np.ndarray) and val.size >= sep_limit:
+                    separately.append(attrib)
+                elif isinstance(val, sparse_matrices) and val.nnz >= sep_limit:
+                    separately.append(attrib)
+
+        # whatever's in `separately` or `ignore` at this point won't get pickled
+        for attrib in separately + list(ignore):
+            if hasattr(self, attrib):
+                asides[attrib] = getattr(self, attrib)
+                delattr(self, attrib)
+
+        recursive_saveloads = []
+        restores = []
+        for attrib, val in iteritems(self.__dict__):
+            if hasattr(val, '_save_specials'):  # better than 'isinstance(val, SaveLoad)' if IPython reloading
+                recursive_saveloads.append(attrib)
+                cfname = '.'.join((fname, attrib))
+                restores.extend(val._save_specials(cfname, None, sep_limit, ignore, pickle_protocol, compress, subname))
+
+        try:
+            numpys, scipys, ignoreds = [], [], []
+            for attrib, val in iteritems(asides):
+                if isinstance(val, np.ndarray) and attrib not in ignore:
+                    numpys.append(attrib)
+                    logger.info("storing np array '%s' to %s", attrib, subname(fname, attrib))
+
+                    if compress:
+                        np.savez_compressed(subname(fname, attrib), val=np.ascontiguousarray(val))
+                    else:
+                        np.save(subname(fname, attrib), np.ascontiguousarray(val))
+
+                elif isinstance(val, (scipy.sparse.csr_matrix, scipy.sparse.csc_matrix)) and attrib not in ignore:
+                    scipys.append(attrib)
+                    logger.info("storing scipy.sparse array '%s' under %s", attrib, subname(fname, attrib))
+
+                    if compress:
+                        np.savez_compressed(
+                            subname(fname, attrib, 'sparse'),
+                            data=val.data,
+                            indptr=val.indptr,
+                            indices=val.indices
+                        )
+                    else:
+                        np.save(subname(fname, attrib, 'data'), val.data)
+                        np.save(subname(fname, attrib, 'indptr'), val.indptr)
+                        np.save(subname(fname, attrib, 'indices'), val.indices)
+
+                    data, indptr, indices = val.data, val.indptr, val.indices
+                    val.data, val.indptr, val.indices = None, None, None
+
+                    try:
+                        # store array-less object
+                        pickle(val, subname(fname, attrib), protocol=pickle_protocol)
+                    finally:
+                        val.data, val.indptr, val.indices = data, indptr, indices
+                else:
+                    logger.info("not storing attribute %s", attrib)
+                    ignoreds.append(attrib)
+
+            self.__dict__['__numpys'] = numpys
+            self.__dict__['__scipys'] = scipys
+            self.__dict__['__ignoreds'] = ignoreds
+            self.__dict__['__recursive_saveloads'] = recursive_saveloads
+        except Exception:
+            # restore the attributes if exception-interrupted
+            for attrib, val in iteritems(asides):
+                setattr(self, attrib, val)
+            raise
+        return restores + [(self, asides)]
+
+    def save(self, fname_or_handle, separately=None, sep_limit=10 * 1024**2, ignore=frozenset(), pickle_protocol=2):
+        """Save the object to file.
+
+        Parameters
+        ----------
+        fname_or_handle : str or file-like
+            Path to output file or already opened file-like object. If the object is a file handle,
+            no special array handling will be performed, all attributes will be saved to the same file.
+        separately : list of str or None, optional
+            If 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.
+            If list of str - this attributes will be stored in separate files, the automatic check
+            is not performed in this case.
+        sep_limit : int
+            Limit for automatic separation.
+        ignore : frozenset of str
+            Attributes that shouldn't be serialize/store.
+        pickle_protocol : int
+            Protocol number for pickle.
+
+        See Also
+        --------
+        :meth:`~gensim.utils.SaveLoad.load`
+
+        """
+        try:
+            _pickle.dump(self, fname_or_handle, protocol=pickle_protocol)
+            logger.info("saved %s object", self.__class__.__name__)
+        except TypeError:  # `fname_or_handle` does not have write attribute
+            self._smart_save(fname_or_handle, separately, sep_limit, ignore, pickle_protocol=pickle_protocol)
+
+
+def unpickle(fname):
+    """Load object from `fname`.
+
+    Parameters
+    ----------
+    fname : str
+        Path to pickle file.
+
+    Returns
+    -------
+    object
+        Python object loaded from `fname`.
+
+    """
+    with smart_open(fname, 'rb') as f:
+        # Because of loading from S3 load can't be used (missing readline in smart_open)
+        file_bytes = f.read()
+        file_bytes = file_bytes.replace(b'gensim.models.word2vec', b'gensim.models.deprecated.word2vec')
+        file_bytes = file_bytes.replace(b'gensim.models.keyedvectors', b'gensim.models.deprecated.keyedvectors')
+        file_bytes = file_bytes.replace(b'gensim.models.doc2vec', b'gensim.models.deprecated.doc2vec')
+        file_bytes = file_bytes.replace(b'gensim.models.fasttext', b'gensim.models.deprecated.fasttext')
+        file_bytes = file_bytes.replace(
+            b'gensim.models.wrappers.fasttext', b'gensim.models.deprecated.fasttext_wrapper')
+        if sys.version_info > (3, 0):
+            return _pickle.loads(file_bytes, encoding='latin1')
+        else:
+            return _pickle.loads(file_bytes)
+
+
+def pickle(obj, fname, protocol=2):
+    """Pickle object `obj` to file `fname`.
+
+    Parameters
+    ----------
+    obj : object
+        Any python object.
+    fname : str
+        Path to pickle file.
+    protocol : int, optional
+        Pickle protocol number, default is 2 to support compatible across python 2.x and 3.x.
+
+    """
+    with smart_open(fname, 'wb') as fout:  # 'b' for binary, needed on Windows
+        _pickle.dump(obj, fout, protocol=protocol)
diff --git a/gensim/models/deprecated/word2vec.py b/gensim/models/deprecated/word2vec.py
new file mode 100644
index 0000000000..f5b5d87254
--- /dev/null
+++ b/gensim/models/deprecated/word2vec.py
@@ -0,0 +1,1904 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 Radim Rehurek <me@radimrehurek.com>
+# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
+
+
+"""
+Warnings
+--------
+.. deprecated:: 3.3.0
+   Use :mod:`gensim.models.word2vec` instead.
+
+
+Produce word vectors with deep learning via word2vec's "skip-gram and CBOW models", using either
+hierarchical softmax or negative sampling [1]_ [2]_.
+
+NOTE: There are more ways to get word vectors in Gensim than just Word2Vec.
+See wrappers for FastText, VarEmbed and WordRank.
+
+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 implementation [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 word vectors are stored in a KeyedVectors instance in model.wv.
+This separates the read-only word vector lookup operations in KeyedVectors from the training code in Word2Vec::
+
+  >>> model.wv['computer']  # numpy vector of a word
+  array([-0.00449447, -0.00310097,  0.02421786, ...], dtype=float32)
+
+The word vectors can also be instantiated from an existing file on disk in the word2vec C format
+as a KeyedVectors instance::
+
+    NOTE: It is impossible to continue training the vectors loaded from the C format because hidden weights,
+    vocabulary frequency and the binary tree is missing::
+
+        >>> from gensim.models.keyedvectors import KeyedVectors
+        >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.txt', binary=False)  # C text format
+        >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.bin', binary=True)  # C binary format
+
+
+You can perform various NLP word tasks with the model. Some of them
+are already built-in::
+
+  >>> model.wv.most_similar(positive=['woman', 'king'], negative=['man'])
+  [('queen', 0.50882536), ...]
+
+  >>> model.wv.most_similar_cosmul(positive=['woman', 'king'], negative=['man'])
+  [('queen', 0.71382287), ...]
+
+
+  >>> model.wv.doesnt_match("breakfast cereal dinner lunch".split())
+  'cereal'
+
+  >>> model.wv.similarity('woman', 'man')
+  0.73723527
+
+Probability of a text under the model::
+
+  >>> model.score(["The fox jumped over a lazy dog".split()])
+  0.2158356
+
+Correlation with human opinion on word similarity::
+
+  >>> model.wv.evaluate_word_pairs(os.path.join(module_path, 'test_data','wordsim353.tsv'))
+  0.51, 0.62, 0.13
+
+And on analogies::
+
+  >>> model.wv.accuracy(os.path.join(module_path, 'test_data', 'questions-words.txt'))
+
+and so on.
+
+If you're finished training a model (i.e. no more updates, only querying),
+then switch to the :mod:`gensim.models.KeyedVectors` instance in wv
+
+  >>> word_vectors = model.wv
+  >>> del model
+
+to trim unneeded model memory = use much less RAM.
+
+Note that there is a :mod:`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_transformer[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/
+"""
+from __future__ import division  # py3 "true division"
+
+import logging
+import sys
+import os
+import heapq
+from timeit import default_timer
+from copy import deepcopy
+from collections import defaultdict
+import threading
+import itertools
+import warnings
+
+from gensim.utils import keep_vocab_item, call_on_class_only
+from gensim.models.deprecated.keyedvectors import KeyedVectors, Vocab
+from gensim.models.word2vec import Word2Vec as NewWord2Vec
+from gensim.models.deprecated.old_saveload import SaveLoad
+
+try:
+    from queue import Queue, Empty
+except ImportError:
+    from Queue import Queue, Empty
+
+from numpy import exp, log, dot, zeros, outer, random, dtype, float32 as REAL,\
+    uint32, seterr, array, uint8, vstack, fromstring, sqrt,\
+    empty, sum as np_sum, ones, logaddexp
+
+from scipy.special import expit
+
+from gensim import utils
+from gensim import matutils  # utility fnc for pickling, common scipy operations etc
+from six import iteritems, itervalues, string_types
+from six.moves import xrange
+from types import GeneratorType
+
+logger = logging.getLogger(__name__)
+
+
+# failed... fall back to plain numpy (20-80x slower training than the above)
+FAST_VERSION = -1
+MAX_WORDS_IN_BATCH = 10000
+
+
+def load_old_word2vec(*args, **kwargs):
+    old_model = Word2Vec.load(*args, **kwargs)
+    params = {
+        'size': old_model.vector_size,
+        'alpha': old_model.alpha,
+        'window': old_model.window,
+        'min_count': old_model.min_count,
+        'max_vocab_size': old_model.__dict__.get('max_vocab_size', None),
+        'sample': old_model.sample,
+        'seed': old_model.seed,
+        'workers': old_model.workers,
+        'min_alpha': old_model.min_alpha,
+        'sg': old_model.sg,
+        'hs': old_model.hs,
+        'negative': old_model.negative,
+        'cbow_mean': old_model.cbow_mean,
+        'hashfxn': old_model.hashfxn,
+        'iter': old_model.iter,
+        'null_word': old_model.null_word,
+        'sorted_vocab': old_model.sorted_vocab,
+        'batch_words': old_model.batch_words,
+        'compute_loss': old_model.__dict__.get('compute_loss', None)
+    }
+    new_model = NewWord2Vec(**params)
+    # set trainables attributes
+    new_model.wv.vectors = old_model.wv.syn0
+    if hasattr(old_model.wv, 'syn0norm'):
+        new_model.wv.vectors_norm = old_model.wv.syn0norm
+    if hasattr(old_model, 'syn1'):
+        new_model.trainables.syn1 = old_model.syn1
+    if hasattr(old_model, 'syn1neg'):
+        new_model.trainables.syn1neg = old_model.syn1neg
+    if hasattr(old_model, 'syn0_lockf'):
+        new_model.trainables.vectors_lockf = old_model.syn0_lockf
+    # set vocabulary attributes
+    new_model.wv.vocab = old_model.wv.vocab
+    new_model.wv.index2word = old_model.wv.index2word
+    new_model.vocabulary.cum_table = old_model.cum_table
+
+    new_model.train_count = old_model.train_count
+    new_model.corpus_count = old_model.corpus_count
+    new_model.running_training_loss = old_model.__dict__.get('running_training_loss', None)
+    new_model.total_train_time = old_model.total_train_time
+    new_model.min_alpha_yet_reached = old_model.min_alpha_yet_reached
+    new_model.model_trimmed_post_training = old_model.__dict__.get('model_trimmed_post_training', None)
+
+    return new_model
+
+
+def train_batch_sg(model, sentences, alpha, work=None, compute_loss=False):
+    """
+    Update skip-gram model by training on a sequence of sentences.
+
+    Each sentence is a list of string tokens, which are looked up in the model's
+    vocab dictionary. Called internally from `Word2Vec.train()`.
+
+    This is the non-optimized, Python version. If you have cython installed, gensim
+    will use the optimized version from word2vec_inner instead.
+
+    """
+    result = 0
+    for sentence in sentences:
+        word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab and
+                       model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+        for pos, word in enumerate(word_vocabs):
+            reduced_window = model.random.randint(model.window)  # `b` in the original word2vec code
+
+            # now go over all words from the (reduced) window, predicting each one in turn
+            start = max(0, pos - model.window + reduced_window)
+            for pos2, word2 in enumerate(word_vocabs[start:(pos + model.window + 1 - reduced_window)], start):
+                # don't train on the `word` itself
+                if pos2 != pos:
+                    train_sg_pair(
+                        model, model.wv.index2word[word.index], word2.index, alpha, compute_loss=compute_loss
+                    )
+
+        result += len(word_vocabs)
+    return result
+
+
+def train_batch_cbow(model, sentences, alpha, work=None, neu1=None, compute_loss=False):
+    """
+    Update CBOW model by training on a sequence of sentences.
+
+    Each sentence is a list of string tokens, which are looked up in the model's
+    vocab dictionary. Called internally from `Word2Vec.train()`.
+
+    This is the non-optimized, Python version. If you have cython installed, gensim
+    will use the optimized version from word2vec_inner instead.
+
+    """
+    result = 0
+    for sentence in sentences:
+        word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab and
+                       model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+        for pos, word in enumerate(word_vocabs):
+            reduced_window = model.random.randint(model.window)  # `b` in the original word2vec code
+            start = max(0, pos - model.window + reduced_window)
+            window_pos = enumerate(word_vocabs[start:(pos + model.window + 1 - reduced_window)], start)
+            word2_indices = [word2.index for pos2, word2 in window_pos if (word2 is not None and pos2 != pos)]
+            l1 = np_sum(model.wv.syn0[word2_indices], axis=0)  # 1 x vector_size
+            if word2_indices and model.cbow_mean:
+                l1 /= len(word2_indices)
+            train_cbow_pair(model, word, word2_indices, l1, alpha, compute_loss=compute_loss)
+        result += len(word_vocabs)
+    return result
+
+
+def score_sentence_sg(model, sentence, work=None):
+    """
+    Obtain likelihood score for a single sentence in a fitted skip-gram representaion.
+
+    The sentence is a list of Vocab objects (or None, when the corresponding
+    word is not in the vocabulary). Called internally from `Word2Vec.score()`.
+
+    This is the non-optimized, Python version. If you have cython installed, gensim
+    will use the optimized version from word2vec_inner instead.
+
+    """
+    log_prob_sentence = 0.0
+    if model.negative:
+        raise RuntimeError("scoring is only available for HS=True")
+
+    word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab]
+    for pos, word in enumerate(word_vocabs):
+        if word is None:
+            continue  # OOV word in the input sentence => skip
+
+        # now go over all words from the window, predicting each one in turn
+        start = max(0, pos - model.window)
+        for pos2, word2 in enumerate(word_vocabs[start: pos + model.window + 1], start):
+            # don't train on OOV words and on the `word` itself
+            if word2 is not None and pos2 != pos:
+                log_prob_sentence += score_sg_pair(model, word, word2)
+
+    return log_prob_sentence
+
+
+def score_sentence_cbow(model, sentence, work=None, neu1=None):
+    """
+    Obtain likelihood score for a single sentence in a fitted CBOW representaion.
+
+    The sentence is a list of Vocab objects (or None, where the corresponding
+    word is not in the vocabulary. Called internally from `Word2Vec.score()`.
+
+    This is the non-optimized, Python version. If you have cython installed, gensim
+    will use the optimized version from word2vec_inner instead.
+
+    """
+    log_prob_sentence = 0.0
+    if model.negative:
+        raise RuntimeError("scoring is only available for HS=True")
+
+    word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab]
+    for pos, word in enumerate(word_vocabs):
+        if word is None:
+            continue  # OOV word in the input sentence => skip
+
+        start = max(0, pos - model.window)
+        window_pos = enumerate(word_vocabs[start:(pos + model.window + 1)], start)
+        word2_indices = [word2.index for pos2, word2 in window_pos if (word2 is not None and pos2 != pos)]
+        l1 = np_sum(model.wv.syn0[word2_indices], axis=0)  # 1 x layer1_size
+        if word2_indices and model.cbow_mean:
+            l1 /= len(word2_indices)
+        log_prob_sentence += score_cbow_pair(model, word, l1)
+
+    return log_prob_sentence
+
+
+def train_sg_pair(model, word, context_index, alpha, learn_vectors=True, learn_hidden=True,
+                  context_vectors=None, context_locks=None, compute_loss=False, is_ft=False):
+    if context_vectors is None:
+        if is_ft:
+            context_vectors_vocab = model.wv.syn0_vocab
+            context_vectors_ngrams = model.wv.syn0_ngrams
+        else:
+            context_vectors = model.wv.syn0
+    if context_locks is None:
+        if is_ft:
+            context_locks_vocab = model.syn0_vocab_lockf
+            context_locks_ngrams = model.syn0_ngrams_lockf
+        else:
+            context_locks = model.syn0_lockf
+
+    if word not in model.wv.vocab:
+        return
+    predict_word = model.wv.vocab[word]  # target word (NN output)
+
+    if is_ft:
+        l1_vocab = context_vectors_vocab[context_index[0]]
+        l1_ngrams = np_sum(context_vectors_ngrams[context_index[1:]], axis=0)
+        if context_index:
+            l1 = np_sum([l1_vocab, l1_ngrams], axis=0) / len(context_index)
+    else:
+        l1 = context_vectors[context_index]  # input word (NN input/projection layer)
+        lock_factor = context_locks[context_index]
+
+    neu1e = zeros(l1.shape)
+
+    if model.hs:
+        # work on the entire tree at once, to push as much work into numpy's C routines as possible (performance)
+        l2a = deepcopy(model.syn1[predict_word.point])  # 2d matrix, codelen x layer1_size
+        prod_term = dot(l1, l2a.T)
+        fa = expit(prod_term)  # propagate hidden -> output
+        ga = (1 - predict_word.code - fa) * alpha  # vector of error gradients multiplied by the learning rate
+        if learn_hidden:
+            model.syn1[predict_word.point] += outer(ga, l1)  # learn hidden -> output
+        neu1e += dot(ga, l2a)  # save error
+
+        # loss component corresponding to hierarchical softmax
+        if compute_loss:
+            sgn = (-1.0)**predict_word.code  # `ch` function, 0 -> 1, 1 -> -1
+            lprob = -log(expit(-sgn * prod_term))
+            model.running_training_loss += sum(lprob)
+
+    if model.negative:
+        # use this word (label = 1) + `negative` other random words not from this sentence (label = 0)
+        word_indices = [predict_word.index]
+        while len(word_indices) < model.negative + 1:
+            w = model.cum_table.searchsorted(model.random.randint(model.cum_table[-1]))
+            if w != predict_word.index:
+                word_indices.append(w)
+        l2b = model.syn1neg[word_indices]  # 2d matrix, k+1 x layer1_size
+        prod_term = dot(l1, l2b.T)
+        fb = expit(prod_term)  # propagate hidden -> output
+        gb = (model.neg_labels - fb) * alpha  # vector of error gradients multiplied by the learning rate
+        if learn_hidden:
+            model.syn1neg[word_indices] += outer(gb, l1)  # learn hidden -> output
+        neu1e += dot(gb, l2b)  # save error
+
+        # loss component corresponding to negative sampling
+        if compute_loss:
+            model.running_training_loss -= sum(log(expit(-1 * prod_term[1:])))  # for the sampled words
+            model.running_training_loss -= log(expit(prod_term[0]))  # for the output word
+
+    if learn_vectors:
+        if is_ft:
+            model.wv.syn0_vocab[context_index[0]] += neu1e * context_locks_vocab[context_index[0]]
+            for i in context_index[1:]:
+                model.wv.syn0_ngrams[i] += neu1e * context_locks_ngrams[i]
+        else:
+            l1 += neu1e * lock_factor  # learn input -> hidden (mutates model.wv.syn0[word2.index], if that is l1)
+    return neu1e
+
+
+def train_cbow_pair(model, word, input_word_indices, l1, alpha, learn_vectors=True, learn_hidden=True,
+                    compute_loss=False, context_vectors=None, context_locks=None, is_ft=False):
+    if context_vectors is None:
+        if is_ft:
+            context_vectors_vocab = model.wv.syn0_vocab
+            context_vectors_ngrams = model.wv.syn0_ngrams
+        else:
+            context_vectors = model.wv.syn0
+    if context_locks is None:
+        if is_ft:
+            context_locks_vocab = model.syn0_vocab_lockf
+            context_locks_ngrams = model.syn0_ngrams_lockf
+        else:
+            context_locks = model.syn0_lockf
+
+    neu1e = zeros(l1.shape)
+
+    if model.hs:
+        l2a = model.syn1[word.point]  # 2d matrix, codelen x layer1_size
+        prod_term = dot(l1, l2a.T)
+        fa = expit(prod_term)  # propagate hidden -> output
+        ga = (1. - word.code - fa) * alpha  # vector of error gradients multiplied by the learning rate
+        if learn_hidden:
+            model.syn1[word.point] += outer(ga, l1)  # learn hidden -> output
+        neu1e += dot(ga, l2a)  # save error
+
+        # loss component corresponding to hierarchical softmax
+        if compute_loss:
+            sgn = (-1.0)**word.code  # ch function, 0-> 1, 1 -> -1
+            model.running_training_loss += sum(-log(expit(-sgn * prod_term)))
+
+    if model.negative:
+        # use this word (label = 1) + `negative` other random words not from this sentence (label = 0)
+        word_indices = [word.index]
+        while len(word_indices) < model.negative + 1:
+            w = model.cum_table.searchsorted(model.random.randint(model.cum_table[-1]))
+            if w != word.index:
+                word_indices.append(w)
+        l2b = model.syn1neg[word_indices]  # 2d matrix, k+1 x layer1_size
+        prod_term = dot(l1, l2b.T)
+        fb = expit(prod_term)  # propagate hidden -> output
+        gb = (model.neg_labels - fb) * alpha  # vector of error gradients multiplied by the learning rate
+        if learn_hidden:
+            model.syn1neg[word_indices] += outer(gb, l1)  # learn hidden -> output
+        neu1e += dot(gb, l2b)  # save error
+
+        # loss component corresponding to negative sampling
+        if compute_loss:
+            model.running_training_loss -= sum(log(expit(-1 * prod_term[1:])))  # for the sampled words
+            model.running_training_loss -= log(expit(prod_term[0]))  # for the output word
+
+    if learn_vectors:
+        # learn input -> hidden, here for all words in the window separately
+        if is_ft:
+            if not model.cbow_mean and input_word_indices:
+                neu1e /= (len(input_word_indices[0]) + len(input_word_indices[1]))
+            for i in input_word_indices[0]:
+                context_vectors_vocab[i] += neu1e * context_locks_vocab[i]
+            for i in input_word_indices[1]:
+                context_vectors_ngrams[i] += neu1e * context_locks_ngrams[i]
+        else:
+            if not model.cbow_mean and input_word_indices:
+                neu1e /= len(input_word_indices)
+            for i in input_word_indices:
+                context_vectors[i] += neu1e * context_locks[i]
+
+    return neu1e
+
+
+def score_sg_pair(model, word, word2):
+    l1 = model.wv.syn0[word2.index]
+    l2a = deepcopy(model.syn1[word.point])  # 2d matrix, codelen x layer1_size
+    sgn = (-1.0)**word.code  # ch function, 0-> 1, 1 -> -1
+    lprob = -logaddexp(0, -sgn * dot(l1, l2a.T))
+    return sum(lprob)
+
+
+def score_cbow_pair(model, word, l1):
+    l2a = model.syn1[word.point]  # 2d matrix, codelen x layer1_size
+    sgn = (-1.0)**word.code  # ch function, 0-> 1, 1 -> -1
+    lprob = -logaddexp(0, -sgn * dot(l1, l2a.T))
+    return sum(lprob)
+
+
+class Word2Vec(SaveLoad):
+    """
+    Class for training, using and evaluating neural networks described in https://code.google.com/p/word2vec/
+
+    If you're finished training a model (=no more updates, only querying)
+    then switch to the :mod:`gensim.models.KeyedVectors` instance in wv
+
+    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 `wv.save_word2vec_format()`
+    and `KeyedVectors.load_word2vec_format()`.
+
+    """
+
+    def __init__(self, sentences=None, size=100, alpha=0.025, window=5, min_count=5,
+                 max_vocab_size=None, sample=1e-3, seed=1, workers=3, min_alpha=0.0001,
+                 sg=0, hs=0, negative=5, cbow_mean=1, hashfxn=hash, iter=5, null_word=0,
+                 trim_rule=None, sorted_vocab=1, batch_words=MAX_WORDS_IN_BATCH, compute_loss=False):
+        """
+        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 :class:`BrownCorpus`, :class:`Text8Corpus` or :class:`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=0`), CBOW is used.
+        Otherwise (`sg=1`), skip-gram 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 `min_alpha` 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).
+        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
+        environment variable to control hash randomization.)
+
+        `min_count` = ignore all words with total frequency lower than this.
+
+        `max_vocab_size` = limit RAM during vocabulary building; if there are more unique
+        words than this, then prune the infrequent ones. Every 10 million word types
+        need about 1GB of RAM. Set to `None` for no limit (default).
+
+        `sample` = threshold for configuring which higher-frequency words are randomly downsampled;
+            default is 1e-3, useful range is (0, 1e-5).
+
+        `workers` = use this many worker threads to train the model (=faster training with multicore machines).
+
+        `hs` = if 1, hierarchical softmax will be used for model training.
+        If set to 0 (default), and `negative` is non-zero, negative sampling will be used.
+
+        `negative` = if > 0, negative sampling will be used, the int for negative
+        specifies how many "noise words" should be drawn (usually between 5-20).
+        Default is 5. If set to 0, no negative samping is used.
+
+        `cbow_mean` = if 0, use the sum of the context word vectors. If 1 (default), 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. Default is 5.
+
+        `trim_rule` = vocabulary trimming rule, specifies whether certain words should remain
+        in the vocabulary, be trimmed away, or handled using the default (discard if word count < min_count).
+        Can be None (min_count will be used), or a callable that accepts parameters (word, count, min_count) and
+        returns either `utils.RULE_DISCARD`, `utils.RULE_KEEP` or `utils.RULE_DEFAULT`.
+        Note: The rule, if given, is only used to prune vocabulary during build_vocab() and is not stored as part
+        of the model.
+
+        `sorted_vocab` = if 1 (default), sort the vocabulary by descending frequency before
+        assigning word indexes.
+
+        `batch_words` = target size (in words) for batches of examples passed to worker threads (and
+        thus cython routines). Default is 10000. (Larger batches will be passed if individual
+        texts are longer than 10000 words, but the standard cython code truncates to that maximum.)
+
+        """
+
+        self.load = call_on_class_only
+
+        if FAST_VERSION == -1:
+            logger.warning('Slow version of %s is being used', __name__)
+        else:
+            logger.debug('Fast version of %s is being used', __name__)
+
+        self.initialize_word_vectors()
+        self.sg = int(sg)
+        self.cum_table = None  # for negative sampling
+        self.vector_size = int(size)
+        self.layer1_size = int(size)
+        if size % 4 != 0:
+            logger.warning("consider setting layer size to a multiple of 4 for greater performance")
+        self.alpha = float(alpha)
+        self.min_alpha_yet_reached = float(alpha)  # To warn user if alpha increases
+        self.window = int(window)
+        self.max_vocab_size = max_vocab_size
+        self.seed = seed
+        self.random = random.RandomState(seed)
+        self.min_count = min_count
+        self.sample = sample
+        self.workers = int(workers)
+        self.min_alpha = float(min_alpha)
+        self.hs = hs
+        self.negative = negative
+        self.cbow_mean = int(cbow_mean)
+        self.hashfxn = hashfxn
+        self.iter = iter
+        self.null_word = null_word
+        self.train_count = 0
+        self.total_train_time = 0
+        self.sorted_vocab = sorted_vocab
+        self.batch_words = batch_words
+        self.model_trimmed_post_training = False
+        self.compute_loss = compute_loss
+        self.running_training_loss = 0
+        if sentences is not None:
+            if isinstance(sentences, GeneratorType):
+                raise TypeError("You can't pass a generator as the sentences argument. Try an iterator.")
+            self.build_vocab(sentences, trim_rule=trim_rule)
+            self.train(
+                sentences, total_examples=self.corpus_count, epochs=self.iter,
+                start_alpha=self.alpha, end_alpha=self.min_alpha
+            )
+        else:
+            if trim_rule is not None:
+                logger.warning(
+                    "The rule, if given, is only used to prune vocabulary during build_vocab() "
+                    "and is not stored as part of the model. Model initialized without sentences. "
+                    "trim_rule provided, if any, will be ignored."
+                )
+
+    def initialize_word_vectors(self):
+        self.wv = KeyedVectors()
+
+    def make_cum_table(self, power=0.75, domain=2**31 - 1):
+        """
+        Create a cumulative-distribution table using stored vocabulary word counts for
+        drawing random words in the negative-sampling training routines.
+
+        To draw a word index, choose a random integer up to the maximum value in the
+        table (cum_table[-1]), then finding that integer's sorted insertion point
+        (as if by bisect_left or ndarray.searchsorted()). That insertion point is the
+        drawn index, coming up in proportion equal to the increment at that slot.
+
+        Called internally from 'build_vocab()'.
+        """
+        vocab_size = len(self.wv.index2word)
+        self.cum_table = zeros(vocab_size, dtype=uint32)
+        # compute sum of all power (Z in paper)
+        train_words_pow = 0.0
+        for word_index in xrange(vocab_size):
+            train_words_pow += self.wv.vocab[self.wv.index2word[word_index]].count**power
+        cumulative = 0.0
+        for word_index in xrange(vocab_size):
+            cumulative += self.wv.vocab[self.wv.index2word[word_index]].count**power
+            self.cum_table[word_index] = round(cumulative / train_words_pow * domain)
+        if len(self.cum_table) > 0:
+            assert self.cum_table[-1] == domain
+
+    def create_binary_tree(self):
+        """
+        Create a binary Huffman tree using stored vocabulary word counts. Frequent words
+        will have shorter binary codes. Called internally from `build_vocab()`.
+
+        """
+        logger.info("constructing a huffman tree from %i words", len(self.wv.vocab))
+
+        # build the huffman tree
+        heap = list(itervalues(self.wv.vocab))
+        heapq.heapify(heap)
+        for i in xrange(len(self.wv.vocab) - 1):
+            min1, min2 = heapq.heappop(heap), heapq.heappop(heap)
+            heapq.heappush(
+                heap, Vocab(count=min1.count + min2.count, index=i + len(self.wv.vocab), left=min1, right=min2)
+            )
+
+        # recurse over the tree, assigning a binary code to each vocabulary word
+        if heap:
+            max_depth, stack = 0, [(heap[0], [], [])]
+            while stack:
+                node, codes, points = stack.pop()
+                if node.index < len(self.wv.vocab):
+                    # leaf node => store its path from the root
+                    node.code, node.point = codes, points
+                    max_depth = max(len(codes), max_depth)
+                else:
+                    # inner node => continue recursion
+                    points = array(list(points) + [node.index - len(self.wv.vocab)], dtype=uint32)
+                    stack.append((node.left, array(list(codes) + [0], dtype=uint8), points))
+                    stack.append((node.right, array(list(codes) + [1], dtype=uint8), points))
+
+            logger.info("built huffman tree with maximum node depth %i", max_depth)
+
+    def build_vocab(self, sentences, keep_raw_vocab=False, trim_rule=None, progress_per=10000, update=False):
+        """
+        Build vocabulary from a sequence of sentences (can be a once-only generator stream).
+        Each sentence must be a list of unicode strings.
+        """
+        self.scan_vocab(sentences, progress_per=progress_per, trim_rule=trim_rule)  # initial survey
+        # trim by min_count & precalculate downsampling
+        self.scale_vocab(keep_raw_vocab=keep_raw_vocab, trim_rule=trim_rule, update=update)
+        self.finalize_vocab(update=update)  # build tables & arrays
+
+    def build_vocab_from_freq(self, word_freq, keep_raw_vocab=False, corpus_count=None, trim_rule=None, update=False):
+        """
+        Build vocabulary from a dictionary of word frequencies.
+        Build model vocabulary from a passed dictionary that contains (word,word count).
+        Words must be of type unicode strings.
+
+        Parameters
+        ----------
+        `word_freq` : dict
+            Word,Word_Count dictionary.
+        `keep_raw_vocab` : bool
+            If not true, delete the raw vocabulary after the scaling is done and free up RAM.
+        `corpus_count`: int
+            Even if no corpus is provided, this argument can set corpus_count explicitly.
+        `trim_rule` = vocabulary trimming rule, specifies whether certain words should remain
+        in the vocabulary, be trimmed away, or handled using the default (discard if word count < min_count).
+        Can be None (min_count will be used), or a callable that accepts parameters (word, count, min_count) and
+        returns either `utils.RULE_DISCARD`, `utils.RULE_KEEP` or `utils.RULE_DEFAULT`.
+        `update`: bool
+            If true, the new provided words in `word_freq` dict will be added to model's vocab.
+
+        Returns
+        --------
+        None
+
+        Examples
+        --------
+        >>> from gensim.models.word2vec import Word2Vec
+        >>> model= Word2Vec()
+        >>> model.build_vocab_from_freq({"Word1": 15, "Word2": 20})
+        """
+        logger.info("Processing provided word frequencies")
+        # Instead of scanning text, this will assign provided word frequencies dictionary(word_freq)
+        # to be directly the raw vocab
+        raw_vocab = word_freq
+        logger.info(
+            "collected %i different raw word, with total frequency of %i",
+            len(raw_vocab), sum(itervalues(raw_vocab))
+        )
+
+        # Since no sentences are provided, this is to control the corpus_count
+        self.corpus_count = corpus_count if corpus_count else 0
+        self.raw_vocab = raw_vocab
+
+        # trim by min_count & precalculate downsampling
+        self.scale_vocab(keep_raw_vocab=keep_raw_vocab, trim_rule=trim_rule, update=update)
+        self.finalize_vocab(update=update)  # build tables & arrays
+
+    def scan_vocab(self, sentences, progress_per=10000, trim_rule=None):
+        """Do an initial scan of all words appearing in sentences."""
+        logger.info("collecting all words and their counts")
+        sentence_no = -1
+        total_words = 0
+        min_reduce = 1
+        vocab = defaultdict(int)
+        checked_string_types = 0
+        for sentence_no, sentence in enumerate(sentences):
+            if not checked_string_types:
+                if isinstance(sentence, string_types):
+                    logger.warning(
+                        "Each 'sentences' item should be a list of words (usually unicode strings). "
+                        "First item here is instead plain %s.",
+                        type(sentence)
+                    )
+                checked_string_types += 1
+            if sentence_no % progress_per == 0:
+                logger.info(
+                    "PROGRESS: at sentence #%i, processed %i words, keeping %i word types",
+                    sentence_no, total_words, len(vocab)
+                )
+            for word in sentence:
+                vocab[word] += 1
+            total_words += len(sentence)
+
+            if self.max_vocab_size and len(vocab) > self.max_vocab_size:
+                utils.prune_vocab(vocab, min_reduce, trim_rule=trim_rule)
+                min_reduce += 1
+
+        logger.info(
+            "collected %i word types from a corpus of %i raw words and %i sentences",
+            len(vocab), total_words, sentence_no + 1
+        )
+        self.corpus_count = sentence_no + 1
+        self.raw_vocab = vocab
+        return total_words
+
+    def scale_vocab(self, min_count=None, sample=None, dry_run=False,
+                    keep_raw_vocab=False, trim_rule=None, update=False):
+        """
+        Apply vocabulary settings for `min_count` (discarding less-frequent words)
+        and `sample` (controlling the downsampling of more-frequent words).
+
+        Calling with `dry_run=True` will only simulate the provided settings and
+        report the size of the retained vocabulary, effective corpus length, and
+        estimated memory requirements. Results are both printed via logging and
+        returned as a dict.
+
+        Delete the raw vocabulary after the scaling is done to free up RAM,
+        unless `keep_raw_vocab` is set.
+
+        """
+        min_count = min_count or self.min_count
+        sample = sample or self.sample
+        drop_total = drop_unique = 0
+
+        if not update:
+            logger.info("Loading a fresh vocabulary")
+            retain_total, retain_words = 0, []
+            # Discard words less-frequent than min_count
+            if not dry_run:
+                self.wv.index2word = []
+                # make stored settings match these applied settings
+                self.min_count = min_count
+                self.sample = sample
+                self.wv.vocab = {}
+
+            for word, v in iteritems(self.raw_vocab):
+                if keep_vocab_item(word, v, min_count, trim_rule=trim_rule):
+                    retain_words.append(word)
+                    retain_total += v
+                    if not dry_run:
+                        self.wv.vocab[word] = Vocab(count=v, index=len(self.wv.index2word))
+                        self.wv.index2word.append(word)
+                else:
+                    drop_unique += 1
+                    drop_total += v
+            original_unique_total = len(retain_words) + drop_unique
+            retain_unique_pct = len(retain_words) * 100 / max(original_unique_total, 1)
+            logger.info(
+                "min_count=%d retains %i unique words (%i%% of original %i, drops %i)",
+                min_count, len(retain_words), retain_unique_pct, original_unique_total, drop_unique
+            )
+            original_total = retain_total + drop_total
+            retain_pct = retain_total * 100 / max(original_total, 1)
+            logger.info(
+                "min_count=%d leaves %i word corpus (%i%% of original %i, drops %i)",
+                min_count, retain_total, retain_pct, original_total, drop_total
+            )
+        else:
+            logger.info("Updating model with new vocabulary")
+            new_total = pre_exist_total = 0
+            new_words = pre_exist_words = []
+            for word, v in iteritems(self.raw_vocab):
+                if keep_vocab_item(word, v, min_count, trim_rule=trim_rule):
+                    if word in self.wv.vocab:
+                        pre_exist_words.append(word)
+                        pre_exist_total += v
+                        if not dry_run:
+                            self.wv.vocab[word].count += v
+                    else:
+                        new_words.append(word)
+                        new_total += v
+                        if not dry_run:
+                            self.wv.vocab[word] = Vocab(count=v, index=len(self.wv.index2word))
+                            self.wv.index2word.append(word)
+                else:
+                    drop_unique += 1
+                    drop_total += v
+            original_unique_total = len(pre_exist_words) + len(new_words) + drop_unique
+            pre_exist_unique_pct = len(pre_exist_words) * 100 / max(original_unique_total, 1)
+            new_unique_pct = len(new_words) * 100 / max(original_unique_total, 1)
+            logger.info(
+                "New added %i unique words (%i%% of original %i) "
+                "and increased the count of %i pre-existing words (%i%% of original %i)",
+                len(new_words), new_unique_pct, original_unique_total, len(pre_exist_words),
+                pre_exist_unique_pct, original_unique_total
+            )
+            retain_words = new_words + pre_exist_words
+            retain_total = new_total + pre_exist_total
+
+        # Precalculate each vocabulary item's threshold for sampling
+        if not sample:
+            # no words downsampled
+            threshold_count = retain_total
+        elif sample < 1.0:
+            # traditional meaning: set parameter as proportion of total
+            threshold_count = sample * retain_total
+        else:
+            # new shorthand: sample >= 1 means downsample all words with higher count than sample
+            threshold_count = int(sample * (3 + sqrt(5)) / 2)
+
+        downsample_total, downsample_unique = 0, 0
+        for w in retain_words:
+            v = self.raw_vocab[w]
+            word_probability = (sqrt(v / threshold_count) + 1) * (threshold_count / v)
+            if word_probability < 1.0:
+                downsample_unique += 1
+                downsample_total += word_probability * v
+            else:
+                word_probability = 1.0
+                downsample_total += v
+            if not dry_run:
+                self.wv.vocab[w].sample_int = int(round(word_probability * 2**32))
+
+        if not dry_run and not keep_raw_vocab:
+            logger.info("deleting the raw counts dictionary of %i items", len(self.raw_vocab))
+            self.raw_vocab = defaultdict(int)
+
+        logger.info("sample=%g downsamples %i most-common words", sample, downsample_unique)
+        logger.info(
+            "downsampling leaves estimated %i word corpus (%.1f%% of prior %i)",
+            downsample_total, downsample_total * 100.0 / max(retain_total, 1), retain_total
+        )
+
+        # return from each step: words-affected, resulting-corpus-size, extra memory estimates
+        report_values = {
+            'drop_unique': drop_unique, 'retain_total': retain_total, 'downsample_unique': downsample_unique,
+            'downsample_total': int(downsample_total), 'memory': self.estimate_memory(vocab_size=len(retain_words))
+        }
+
+        return report_values
+
+    def finalize_vocab(self, update=False):
+        """Build tables and model weights based on final vocabulary settings."""
+        if not self.wv.index2word:
+            self.scale_vocab()
+        if self.sorted_vocab and not update:
+            self.sort_vocab()
+        if self.hs:
+            # add info about each word's Huffman encoding
+            self.create_binary_tree()
+        if self.negative:
+            # build the table for drawing random words (for negative sampling)
+            self.make_cum_table()
+        if self.null_word:
+            # create null pseudo-word for padding when using concatenative L1 (run-of-words)
+            # this word is only ever input – never predicted – so count, huffman-point, etc doesn't matter
+            word, v = '\0', Vocab(count=1, sample_int=0)
+            v.index = len(self.wv.vocab)
+            self.wv.index2word.append(word)
+            self.wv.vocab[word] = v
+        # set initial input/projection and hidden weights
+        if not update:
+            self.reset_weights()
+        else:
+            self.update_weights()
+
+    def sort_vocab(self):
+        """Sort the vocabulary so the most frequent words have the lowest indexes."""
+        if len(self.wv.syn0):
+            raise RuntimeError("cannot sort vocabulary after model weights already initialized.")
+        self.wv.index2word.sort(key=lambda word: self.wv.vocab[word].count, reverse=True)
+        for i, word in enumerate(self.wv.index2word):
+            self.wv.vocab[word].index = i
+
+    def reset_from(self, other_model):
+        """
+        Borrow shareable pre-built structures (like vocab) from the other_model. Useful
+        if testing multiple models in parallel on the same corpus.
+        """
+        self.wv.vocab = other_model.wv.vocab
+        self.wv.index2word = other_model.wv.index2word
+        self.cum_table = other_model.cum_table
+        self.corpus_count = other_model.corpus_count
+        self.reset_weights()
+
+    def _do_train_job(self, sentences, alpha, inits):
+        """
+        Train a single batch of sentences. Return 2-tuple `(effective word count after
+        ignoring unknown words and sentence length trimming, total word count)`.
+        """
+        work, neu1 = inits
+        tally = 0
+        if self.sg:
+            tally += train_batch_sg(self, sentences, alpha, work, self.compute_loss)
+        else:
+            tally += train_batch_cbow(self, sentences, alpha, work, neu1, self.compute_loss)
+        return tally, self._raw_word_count(sentences)
+
+    def _raw_word_count(self, job):
+        """Return the number of words in a given job."""
+        return sum(len(sentence) for sentence in job)
+
+    def train(self, sentences, total_examples=None, total_words=None,
+              epochs=None, start_alpha=None, end_alpha=None, word_count=0,
+              queue_factor=2, report_delay=1.0, compute_loss=None):
+        """
+        Update the model's neural weights from a sequence of sentences (can be a once-only generator stream).
+        For Word2Vec, each sentence must be a list of unicode strings. (Subclasses may accept other examples.)
+
+        To support linear learning-rate decay from (initial) alpha to min_alpha, and accurate
+        progres-percentage logging, either total_examples (count of sentences) or total_words (count of
+        raw words in sentences) MUST be provided. (If the corpus is the same as was provided to
+        `build_vocab()`, the count of examples in that corpus will be available in the model's
+        `corpus_count` property.)
+
+        To avoid common mistakes around the model's ability to do multiple training passes itself, an
+        explicit `epochs` argument MUST be provided. In the common and recommended case, where `train()`
+        is only called once, the model's cached `iter` value should be supplied as `epochs` value.
+        """
+        if self.model_trimmed_post_training:
+            raise RuntimeError("Parameters for training were discarded using model_trimmed_post_training method")
+        if FAST_VERSION < 0:
+            warnings.warn(
+                "C extension not loaded for Word2Vec, training will be slow. "
+                "Install a C compiler and reinstall gensim for fast training."
+            )
+            self.neg_labels = []
+            if self.negative > 0:
+                # precompute negative labels optimization for pure-python training
+                self.neg_labels = zeros(self.negative + 1)
+                self.neg_labels[0] = 1.
+
+        if compute_loss:
+            self.compute_loss = compute_loss
+        self.running_training_loss = 0
+
+        logger.info(
+            "training model with %i workers on %i vocabulary and %i features, "
+            "using sg=%s hs=%s sample=%s negative=%s window=%s",
+            self.workers, len(self.wv.vocab), self.layer1_size, self.sg,
+            self.hs, self.sample, self.negative, self.window
+        )
+
+        if not self.wv.vocab:
+            raise RuntimeError("you must first build vocabulary before training the model")
+        if not len(self.wv.syn0):
+            raise RuntimeError("you must first finalize vocabulary before training the model")
+
+        if not hasattr(self, 'corpus_count'):
+            raise ValueError(
+                "The number of sentences in the training corpus is missing. "
+                "Did you load the model via KeyedVectors.load_word2vec_format?"
+                "Models loaded via load_word2vec_format don't support further training. "
+                "Instead start with a blank model, scan_vocab on the new corpus, "
+                "intersect_word2vec_format with the old model, then train."
+            )
+
+        if total_words is None and total_examples is None:
+            raise ValueError(
+                "You must specify either total_examples or total_words, for proper alpha and progress calculations. "
+                "The usual value is total_examples=model.corpus_count."
+            )
+        if epochs is None:
+            raise ValueError("You must specify an explict epochs count. The usual value is epochs=model.iter.")
+        start_alpha = start_alpha or self.alpha
+        end_alpha = end_alpha or self.min_alpha
+
+        job_tally = 0
+
+        if epochs > 1:
+            sentences = utils.RepeatCorpusNTimes(sentences, epochs)
+            total_words = total_words and total_words * epochs
+            total_examples = total_examples and total_examples * epochs
+
+        def worker_loop():
+            """Train the model, lifting lists of sentences from the job_queue."""
+            work = matutils.zeros_aligned(self.layer1_size, dtype=REAL)  # per-thread private work memory
+            neu1 = matutils.zeros_aligned(self.layer1_size, dtype=REAL)
+            jobs_processed = 0
+            while True:
+                job = job_queue.get()
+                if job is None:
+                    progress_queue.put(None)
+                    break  # no more jobs => quit this worker
+                sentences, alpha = job
+                tally, raw_tally = self._do_train_job(sentences, alpha, (work, neu1))
+                progress_queue.put((len(sentences), tally, raw_tally))  # report back progress
+                jobs_processed += 1
+            logger.debug("worker exiting, processed %i jobs", jobs_processed)
+
+        def job_producer():
+            """Fill jobs queue using the input `sentences` iterator."""
+            job_batch, batch_size = [], 0
+            pushed_words, pushed_examples = 0, 0
+            next_alpha = start_alpha
+            if next_alpha > self.min_alpha_yet_reached:
+                logger.warning("Effective 'alpha' higher than previous training cycles")
+            self.min_alpha_yet_reached = next_alpha
+            job_no = 0
+
+            for sent_idx, sentence in enumerate(sentences):
+                sentence_length = self._raw_word_count([sentence])
+
+                # can we fit this sentence into the existing job batch?
+                if batch_size + sentence_length <= self.batch_words:
+                    # yes => add it to the current job
+                    job_batch.append(sentence)
+                    batch_size += sentence_length
+                else:
+                    # no => submit the existing job
+                    logger.debug(
+                        "queueing job #%i (%i words, %i sentences) at alpha %.05f",
+                        job_no, batch_size, len(job_batch), next_alpha
+                    )
+                    job_no += 1
+                    job_queue.put((job_batch, next_alpha))
+
+                    # update the learning rate for the next job
+                    if end_alpha < next_alpha:
+                        if total_examples:
+                            # examples-based decay
+                            pushed_examples += len(job_batch)
+                            progress = 1.0 * pushed_examples / total_examples
+                        else:
+                            # words-based decay
+                            pushed_words += self._raw_word_count(job_batch)
+                            progress = 1.0 * pushed_words / total_words
+                        next_alpha = start_alpha - (start_alpha - end_alpha) * progress
+                        next_alpha = max(end_alpha, next_alpha)
+
+                    # add the sentence that didn't fit as the first item of a new job
+                    job_batch, batch_size = [sentence], sentence_length
+
+            # add the last job too (may be significantly smaller than batch_words)
+            if job_batch:
+                logger.debug(
+                    "queueing job #%i (%i words, %i sentences) at alpha %.05f",
+                    job_no, batch_size, len(job_batch), next_alpha
+                )
+                job_no += 1
+                job_queue.put((job_batch, next_alpha))
+
+            if job_no == 0 and self.train_count == 0:
+                logger.warning(
+                    "train() called with an empty iterator (if not intended, "
+                    "be sure to provide a corpus that offers restartable iteration = an iterable)."
+                )
+
+            # give the workers heads up that they can finish -- no more work!
+            for _ in xrange(self.workers):
+                job_queue.put(None)
+            logger.debug("job loop exiting, total %i jobs", job_no)
+
+        # buffer ahead only a limited number of jobs.. this is the reason we can't simply use ThreadPool :(
+        job_queue = Queue(maxsize=queue_factor * self.workers)
+        progress_queue = Queue(maxsize=(queue_factor + 1) * self.workers)
+
+        workers = [threading.Thread(target=worker_loop) for _ in xrange(self.workers)]
+        unfinished_worker_count = len(workers)
+        workers.append(threading.Thread(target=job_producer))
+
+        for thread in workers:
+            thread.daemon = True  # make interrupting the process with ctrl+c easier
+            thread.start()
+
+        example_count, trained_word_count, raw_word_count = 0, 0, word_count
+        start, next_report = default_timer() - 0.00001, 1.0
+
+        while unfinished_worker_count > 0:
+            report = progress_queue.get()  # blocks if workers too slow
+            if report is None:  # a thread reporting that it finished
+                unfinished_worker_count -= 1
+                logger.info("worker thread finished; awaiting finish of %i more threads", unfinished_worker_count)
+                continue
+            examples, trained_words, raw_words = report
+            job_tally += 1
+
+            # update progress stats
+            example_count += examples
+            trained_word_count += trained_words  # only words in vocab & sampled
+            raw_word_count += raw_words
+
+            # log progress once every report_delay seconds
+            elapsed = default_timer() - start
+            if elapsed >= next_report:
+                if total_examples:
+                    # examples-based progress %
+                    logger.info(
+                        "PROGRESS: at %.2f%% examples, %.0f words/s, in_qsize %i, out_qsize %i",
+                        100.0 * example_count / total_examples, trained_word_count / elapsed,
+                        utils.qsize(job_queue), utils.qsize(progress_queue)
+                    )
+                else:
+                    # words-based progress %
+                    logger.info(
+                        "PROGRESS: at %.2f%% words, %.0f words/s, in_qsize %i, out_qsize %i",
+                        100.0 * raw_word_count / total_words, trained_word_count / elapsed,
+                        utils.qsize(job_queue), utils.qsize(progress_queue)
+                    )
+                next_report = elapsed + report_delay
+
+        # all done; report the final stats
+        elapsed = default_timer() - start
+        logger.info(
+            "training on %i raw words (%i effective words) took %.1fs, %.0f effective words/s",
+            raw_word_count, trained_word_count, elapsed, trained_word_count / elapsed
+        )
+        if job_tally < 10 * self.workers:
+            logger.warning(
+                "under 10 jobs per worker: consider setting a smaller `batch_words' for smoother alpha decay"
+            )
+
+        # check that the input corpus hasn't changed during iteration
+        if total_examples and total_examples != example_count:
+            logger.warning(
+                "supplied example count (%i) did not equal expected count (%i)", example_count, total_examples
+            )
+        if total_words and total_words != raw_word_count:
+            logger.warning(
+                "supplied raw word count (%i) did not equal expected count (%i)", raw_word_count, total_words
+            )
+
+        self.train_count += 1  # number of times train() has been called
+        self.total_train_time += elapsed
+        self.clear_sims()
+        return trained_word_count
+
+    # basics copied from the train() function
+    def score(self, sentences, total_sentences=int(1e6), chunksize=100, queue_factor=2, report_delay=1):
+        """
+        Score the log probability for a sequence of sentences (can be a once-only generator stream).
+        Each sentence must be a list of unicode strings.
+        This does not change the fitted model in any way (see Word2Vec.train() for that).
+
+        We have currently only implemented score for the hierarchical softmax scheme,
+        so you need to have run word2vec with hs=1 and negative=0 for this to work.
+
+        Note that you should specify total_sentences; we'll run into problems if you ask to
+        score more than this number of sentences but it is inefficient to set the value too high.
+
+        See the article by [#taddy]_ and the gensim demo at [#deepir]_ for examples of
+        how to use such scores in document classification.
+
+        .. [#taddy] Taddy, Matt.  Document Classification by Inversion of Distributed Language Representations,
+                    in Proceedings of the 2015 Conference of the Association of Computational Linguistics.
+        .. [#deepir] https://github.com/piskvorky/gensim/blob/develop/docs/notebooks/deepir.ipynb
+
+        """
+        if FAST_VERSION < 0:
+            warnings.warn(
+                "C extension compilation failed, scoring will be slow. "
+                "Install a C compiler and reinstall gensim for fastness."
+            )
+
+        logger.info(
+            "scoring sentences with %i workers on %i vocabulary and %i features, "
+            "using sg=%s hs=%s sample=%s and negative=%s",
+            self.workers, len(self.wv.vocab), self.layer1_size, self.sg, self.hs, self.sample, self.negative
+        )
+
+        if not self.wv.vocab:
+            raise RuntimeError("you must first build vocabulary before scoring new data")
+
+        if not self.hs:
+            raise RuntimeError(
+                "We have currently only implemented score for the hierarchical softmax scheme, "
+                "so you need to have run word2vec with hs=1 and negative=0 for this to work."
+            )
+
+        def worker_loop():
+            """Compute log probability for each sentence, lifting lists of sentences from the jobs queue."""
+            work = zeros(1, dtype=REAL)  # for sg hs, we actually only need one memory loc (running sum)
+            neu1 = matutils.zeros_aligned(self.layer1_size, dtype=REAL)
+            while True:
+                job = job_queue.get()
+                if job is None:  # signal to finish
+                    break
+                ns = 0
+                for sentence_id, sentence in job:
+                    if sentence_id >= total_sentences:
+                        break
+                    if self.sg:
+                        score = score_sentence_sg(self, sentence, work)
+                    else:
+                        score = score_sentence_cbow(self, sentence, work, neu1)
+                    sentence_scores[sentence_id] = score
+                    ns += 1
+                progress_queue.put(ns)  # report progress
+
+        start, next_report = default_timer(), 1.0
+        # buffer ahead only a limited number of jobs.. this is the reason we can't simply use ThreadPool :(
+        job_queue = Queue(maxsize=queue_factor * self.workers)
+        progress_queue = Queue(maxsize=(queue_factor + 1) * self.workers)
+
+        workers = [threading.Thread(target=worker_loop) for _ in xrange(self.workers)]
+        for thread in workers:
+            thread.daemon = True  # make interrupting the process with ctrl+c easier
+            thread.start()
+
+        sentence_count = 0
+        sentence_scores = matutils.zeros_aligned(total_sentences, dtype=REAL)
+
+        push_done = False
+        done_jobs = 0
+        jobs_source = enumerate(utils.grouper(enumerate(sentences), chunksize))
+
+        # fill jobs queue with (id, sentence) job items
+        while True:
+            try:
+                job_no, items = next(jobs_source)
+                if (job_no - 1) * chunksize > total_sentences:
+                    logger.warning(
+                        "terminating after %i sentences (set higher total_sentences if you want more).",
+                        total_sentences
+                    )
+                    job_no -= 1
+                    raise StopIteration()
+                logger.debug("putting job #%i in the queue", job_no)
+                job_queue.put(items)
+            except StopIteration:
+                logger.info("reached end of input; waiting to finish %i outstanding jobs", job_no - done_jobs + 1)
+                for _ in xrange(self.workers):
+                    job_queue.put(None)  # give the workers heads up that they can finish -- no more work!
+                push_done = True
+            try:
+                while done_jobs < (job_no + 1) or not push_done:
+                    ns = progress_queue.get(push_done)  # only block after all jobs pushed
+                    sentence_count += ns
+                    done_jobs += 1
+                    elapsed = default_timer() - start
+                    if elapsed >= next_report:
+                        logger.info(
+                            "PROGRESS: at %.2f%% sentences, %.0f sentences/s",
+                            100.0 * sentence_count, sentence_count / elapsed
+                        )
+                        next_report = elapsed + report_delay  # don't flood log, wait report_delay seconds
+                else:
+                    # loop ended by job count; really done
+                    break
+            except Empty:
+                pass  # already out of loop; continue to next push
+
+        elapsed = default_timer() - start
+        self.clear_sims()
+        logger.info(
+            "scoring %i sentences took %.1fs, %.0f sentences/s",
+            sentence_count, elapsed, sentence_count / elapsed
+        )
+        return sentence_scores[:sentence_count]
+
+    def clear_sims(self):
+        """
+        Removes all L2-normalized vectors for words from the model.
+        You will have to recompute them using init_sims method.
+        """
+
+        self.wv.syn0norm = None
+
+    def update_weights(self):
+        """
+        Copy all the existing weights, and reset the weights for the newly
+        added vocabulary.
+        """
+        logger.info("updating layer weights")
+        gained_vocab = len(self.wv.vocab) - len(self.wv.syn0)
+        newsyn0 = empty((gained_vocab, self.vector_size), dtype=REAL)
+
+        # randomize the remaining words
+        for i in xrange(len(self.wv.syn0), len(self.wv.vocab)):
+            # construct deterministic seed from word AND seed argument
+            newsyn0[i - len(self.wv.syn0)] = self.seeded_vector(self.wv.index2word[i] + str(self.seed))
+
+        # Raise an error if an online update is run before initial training on a corpus
+        if not len(self.wv.syn0):
+            raise RuntimeError(
+                "You cannot do an online vocabulary-update of a model which has no prior vocabulary. "
+                "First build the vocabulary of your model with a corpus before doing an online update."
+            )
+
+        self.wv.syn0 = vstack([self.wv.syn0, newsyn0])
+
+        if self.hs:
+            self.syn1 = vstack([self.syn1, zeros((gained_vocab, self.layer1_size), dtype=REAL)])
+        if self.negative:
+            self.syn1neg = vstack([self.syn1neg, zeros((gained_vocab, self.layer1_size), dtype=REAL)])
+        self.wv.syn0norm = None
+
+        # do not suppress learning for already learned words
+        self.syn0_lockf = ones(len(self.wv.vocab), dtype=REAL)  # zeros suppress learning
+
+    def reset_weights(self):
+        """Reset all projection weights to an initial (untrained) state, but keep the existing vocabulary."""
+        logger.info("resetting layer weights")
+        self.wv.syn0 = empty((len(self.wv.vocab), self.vector_size), dtype=REAL)
+        # randomize weights vector by vector, rather than materializing a huge random matrix in RAM at once
+        for i in xrange(len(self.wv.vocab)):
+            # construct deterministic seed from word AND seed argument
+            self.wv.syn0[i] = self.seeded_vector(self.wv.index2word[i] + str(self.seed))
+        if self.hs:
+            self.syn1 = zeros((len(self.wv.vocab), self.layer1_size), dtype=REAL)
+        if self.negative:
+            self.syn1neg = zeros((len(self.wv.vocab), self.layer1_size), dtype=REAL)
+        self.wv.syn0norm = None
+
+        self.syn0_lockf = ones(len(self.wv.vocab), dtype=REAL)  # zeros suppress learning
+
+    def seeded_vector(self, seed_string):
+        """Create one 'random' vector (but deterministic by seed_string)"""
+        # Note: built-in hash() may vary by Python version or even (in Py3.x) per launch
+        once = random.RandomState(self.hashfxn(seed_string) & 0xffffffff)
+        return (once.rand(self.vector_size) - 0.5) / self.vector_size
+
+    def intersect_word2vec_format(self, fname, lockf=0.0, binary=False, encoding='utf8', unicode_errors='strict'):
+        """
+        Merge the input-hidden weight matrix from the original C word2vec-tool format
+        given, where it intersects with the current vocabulary. (No words are added to the
+        existing vocabulary, but intersecting words adopt the file's weights, and
+        non-intersecting words are left alone.)
+
+        `binary` is a boolean indicating whether the data is in binary word2vec format.
+
+        `lockf` is a lock-factor value to be set for any imported word-vectors; the
+        default value of 0.0 prevents further updating of the vector during subsequent
+        training. Use 1.0 to allow further training updates of merged vectors.
+        """
+        overlap_count = 0
+        logger.info("loading projection weights from %s", fname)
+        with utils.smart_open(fname) as fin:
+            header = utils.to_unicode(fin.readline(), encoding=encoding)
+            vocab_size, vector_size = (int(x) for x in header.split())  # throws for invalid file format
+            if not vector_size == self.vector_size:
+                raise ValueError("incompatible vector size %d in file %s" % (vector_size, fname))
+                # TOCONSIDER: maybe mismatched vectors still useful enough to merge (truncating/padding)?
+            if binary:
+                binary_len = dtype(REAL).itemsize * vector_size
+                for _ in xrange(vocab_size):
+                    # mixed text and binary: read text first, then binary
+                    word = []
+                    while True:
+                        ch = fin.read(1)
+                        if ch == b' ':
+                            break
+                        if ch != b'\n':  # ignore newlines in front of words (some binary files have)
+                            word.append(ch)
+                    word = utils.to_unicode(b''.join(word), encoding=encoding, errors=unicode_errors)
+                    weights = fromstring(fin.read(binary_len), dtype=REAL)
+                    if word in self.wv.vocab:
+                        overlap_count += 1
+                        self.wv.syn0[self.wv.vocab[word].index] = weights
+                        self.syn0_lockf[self.wv.vocab[word].index] = lockf  # lock-factor: 0.0 stops further changes
+            else:
+                for line_no, line in enumerate(fin):
+                    parts = utils.to_unicode(line.rstrip(), encoding=encoding, errors=unicode_errors).split(" ")
+                    if len(parts) != vector_size + 1:
+                        raise ValueError("invalid vector on line %s (is this really the text format?)" % line_no)
+                    word, weights = parts[0], [REAL(x) for x in parts[1:]]
+                    if word in self.wv.vocab:
+                        overlap_count += 1
+                        self.wv.syn0[self.wv.vocab[word].index] = weights
+                        self.syn0_lockf[self.wv.vocab[word].index] = lockf  # lock-factor: 0.0 stops further changes
+        logger.info("merged %d vectors into %s matrix from %s", overlap_count, self.wv.syn0.shape, fname)
+
+    def most_similar(self, positive=None, negative=None, topn=10, restrict_vocab=None, indexer=None):
+        """
+        Deprecated. Use self.wv.most_similar() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.most_similar`
+        """
+        return self.wv.most_similar(positive, negative, topn, restrict_vocab, indexer)
+
+    def wmdistance(self, document1, document2):
+        """
+        Deprecated. Use self.wv.wmdistance() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.wmdistance`
+        """
+        return self.wv.wmdistance(document1, document2)
+
+    def most_similar_cosmul(self, positive=None, negative=None, topn=10):
+        """
+        Deprecated. Use self.wv.most_similar_cosmul() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.most_similar_cosmul`
+        """
+        return self.wv.most_similar_cosmul(positive, negative, topn)
+
+    def similar_by_word(self, word, topn=10, restrict_vocab=None):
+        """
+        Deprecated. Use self.wv.similar_by_word() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.similar_by_word`
+        """
+        return self.wv.similar_by_word(word, topn, restrict_vocab)
+
+    def similar_by_vector(self, vector, topn=10, restrict_vocab=None):
+        """
+        Deprecated. Use self.wv.similar_by_vector() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.similar_by_vector`
+        """
+        return self.wv.similar_by_vector(vector, topn, restrict_vocab)
+
+    def doesnt_match(self, words):
+        """
+        Deprecated. Use self.wv.doesnt_match() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.doesnt_match`
+        """
+        return self.wv.doesnt_match(words)
+
+    def __getitem__(self, words):
+        """
+        Deprecated. Use self.wv.__getitem__() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.__getitem__`
+        """
+        return self.wv.__getitem__(words)
+
+    def __contains__(self, word):
+        """
+        Deprecated. Use self.wv.__contains__() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.__contains__`
+        """
+        return self.wv.__contains__(word)
+
+    def similarity(self, w1, w2):
+        """
+        Deprecated. Use self.wv.similarity() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.similarity`
+        """
+        return self.wv.similarity(w1, w2)
+
+    def n_similarity(self, ws1, ws2):
+        """
+        Deprecated. Use self.wv.n_similarity() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.n_similarity`
+        """
+        return self.wv.n_similarity(ws1, ws2)
+
+    def predict_output_word(self, context_words_list, topn=10):
+        """Report the probability distribution of the center word given the context words
+        as input to the trained model."""
+        if not self.negative:
+            raise RuntimeError(
+                "We have currently only implemented predict_output_word for the negative sampling scheme, "
+                "so you need to have run word2vec with negative > 0 for this to work."
+            )
+
+        if not hasattr(self.wv, 'syn0') or not hasattr(self, 'syn1neg'):
+            raise RuntimeError("Parameters required for predicting the output words not found.")
+
+        word_vocabs = [self.wv.vocab[w] for w in context_words_list if w in self.wv.vocab]
+        if not word_vocabs:
+            warnings.warn("All the input context words are out-of-vocabulary for the current model.")
+            return None
+
+        word2_indices = [word.index for word in word_vocabs]
+
+        l1 = np_sum(self.wv.syn0[word2_indices], axis=0)
+        if word2_indices and self.cbow_mean:
+            l1 /= len(word2_indices)
+
+        prob_values = exp(dot(l1, self.syn1neg.T))  # propagate hidden -> output and take softmax to get probabilities
+        prob_values /= sum(prob_values)
+        top_indices = matutils.argsort(prob_values, topn=topn, reverse=True)
+        # returning the most probable output words with their probabilities
+        return [(self.wv.index2word[index1], prob_values[index1]) for index1 in top_indices]
+
+    def init_sims(self, replace=False):
+        """
+        init_sims() resides in KeyedVectors because it deals with syn0 mainly, but because syn1 is not an attribute
+        of KeyedVectors, it has to be deleted in this class, and the normalizing of syn0 happens inside of KeyedVectors
+        """
+        if replace and hasattr(self, 'syn1'):
+            del self.syn1
+        return self.wv.init_sims(replace)
+
+    def estimate_memory(self, vocab_size=None, report=None):
+        """Estimate required memory for a model using current settings and provided vocabulary size."""
+        vocab_size = vocab_size or len(self.wv.vocab)
+        report = report or {}
+        report['vocab'] = vocab_size * (700 if self.hs else 500)
+        report['syn0'] = vocab_size * self.vector_size * dtype(REAL).itemsize
+        if self.hs:
+            report['syn1'] = vocab_size * self.layer1_size * dtype(REAL).itemsize
+        if self.negative:
+            report['syn1neg'] = vocab_size * self.layer1_size * dtype(REAL).itemsize
+        report['total'] = sum(report.values())
+        logger.info(
+            "estimated required memory for %i words and %i dimensions: %i bytes",
+            vocab_size, self.vector_size, report['total']
+        )
+        return report
+
+    @staticmethod
+    def log_accuracy(section):
+        return KeyedVectors.log_accuracy(section)
+
+    def accuracy(self, questions, restrict_vocab=30000, most_similar=None, case_insensitive=True):
+        most_similar = most_similar or KeyedVectors.most_similar
+        return self.wv.accuracy(questions, restrict_vocab, most_similar, case_insensitive)
+
+    @staticmethod
+    def log_evaluate_word_pairs(pearson, spearman, oov, pairs):
+        """
+        Deprecated. Use self.wv.log_evaluate_word_pairs() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.log_evaluate_word_pairs`
+        """
+        return KeyedVectors.log_evaluate_word_pairs(pearson, spearman, oov, pairs)
+
+    def evaluate_word_pairs(self, pairs, delimiter='\t', restrict_vocab=300000,
+                            case_insensitive=True, dummy4unknown=False):
+        """
+        Deprecated. Use self.wv.evaluate_word_pairs() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.evaluate_word_pairs`
+        """
+        return self.wv.evaluate_word_pairs(pairs, delimiter, restrict_vocab, case_insensitive, dummy4unknown)
+
+    def __str__(self):
+        return "%s(vocab=%s, size=%s, alpha=%s)" % (
+            self.__class__.__name__, len(self.wv.index2word), self.vector_size, self.alpha
+        )
+
+    def _minimize_model(self, save_syn1=False, save_syn1neg=False, save_syn0_lockf=False):
+        warnings.warn(
+            "This method would be deprecated in the future. "
+            "Keep just_word_vectors = model.wv to retain just the KeyedVectors instance "
+            "for read-only querying of word vectors."
+        )
+        if save_syn1 and save_syn1neg and save_syn0_lockf:
+            return
+        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
+        self.model_trimmed_post_training = True
+
+    def delete_temporary_training_data(self, replace_word_vectors_with_normalized=False):
+        """
+        Discard parameters that are used in training and score. Use if you're sure you're done training a model.
+        If `replace_word_vectors_with_normalized` is set, forget the original vectors and only keep the normalized
+        ones = saves lots of memory!
+        """
+        if replace_word_vectors_with_normalized:
+            self.init_sims(replace=True)
+        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'])
+
+        super(Word2Vec, self).save(*args, **kwargs)
+
+    save.__doc__ = SaveLoad.save.__doc__
+
+    @classmethod
+    def load(cls, *args, **kwargs):
+        model = super(Word2Vec, cls).load(*args, **kwargs)
+        # update older models
+        if hasattr(model, 'table'):
+            delattr(model, 'table')  # discard in favor of cum_table
+        if model.negative and hasattr(model.wv, 'index2word'):
+            model.make_cum_table()  # rebuild cum_table from vocabulary
+        if not hasattr(model, 'corpus_count'):
+            model.corpus_count = None
+        for v in model.wv.vocab.values():
+            if hasattr(v, 'sample_int'):
+                break  # already 0.12.0+ style int probabilities
+            elif hasattr(v, 'sample_probability'):
+                v.sample_int = int(round(v.sample_probability * 2**32))
+                del v.sample_probability
+        if not hasattr(model, 'syn0_lockf') and hasattr(model, 'syn0'):
+            model.syn0_lockf = ones(len(model.wv.syn0), dtype=REAL)
+        if not hasattr(model, 'random'):
+            model.random = random.RandomState(model.seed)
+        if not hasattr(model, 'train_count'):
+            model.train_count = 0
+            model.total_train_time = 0
+        return model
+
+    def _load_specials(self, *args, **kwargs):
+        super(Word2Vec, self)._load_specials(*args, **kwargs)
+        # loading from a pre-KeyedVectors word2vec model
+        if not hasattr(self, 'wv'):
+            wv = KeyedVectors()
+            wv.syn0 = self.__dict__.get('syn0', [])
+            wv.syn0norm = self.__dict__.get('syn0norm', None)
+            wv.vocab = self.__dict__.get('vocab', {})
+            wv.index2word = self.__dict__.get('index2word', [])
+            self.wv = wv
+
+    @classmethod
+    def load_word2vec_format(cls, fname, fvocab=None, binary=False, encoding='utf8', unicode_errors='strict',
+                         limit=None, datatype=REAL):
+        """Deprecated. Use gensim.models.KeyedVectors.load_word2vec_format instead."""
+        raise DeprecationWarning("Deprecated. Use gensim.models.KeyedVectors.load_word2vec_format instead.")
+
+    def save_word2vec_format(self, fname, fvocab=None, binary=False):
+        """Deprecated. Use model.wv.save_word2vec_format instead."""
+        raise DeprecationWarning("Deprecated. Use model.wv.save_word2vec_format instead.")
+
+    def get_latest_training_loss(self):
+        return self.running_training_loss
+
+
+class BrownCorpus(object):
+    """Iterate over sentences from the Brown corpus (part of NLTK data)."""
+
+    def __init__(self, dirname):
+        self.dirname = dirname
+
+    def __iter__(self):
+        for fname in os.listdir(self.dirname):
+            fname = os.path.join(self.dirname, fname)
+            if not os.path.isfile(fname):
+                continue
+            for line in utils.smart_open(fname):
+                line = utils.to_unicode(line)
+                # each file line is a single sentence in the Brown corpus
+                # each token is WORD/POS_TAG
+                token_tags = [t.split('/') for t in line.split() if len(t.split('/')) == 2]
+                # ignore words with non-alphabetic tags like ",", "!" etc (punctuation, weird stuff)
+                words = ["%s/%s" % (token.lower(), tag[:2]) for token, tag in token_tags if tag[:2].isalpha()]
+                if not words:  # don't bother sending out empty sentences
+                    continue
+                yield words
+
+
+class Text8Corpus(object):
+    """Iterate over sentences from the "text8" corpus, unzipped from http://mattmahoney.net/dc/text8.zip ."""
+
+    def __init__(self, fname, max_sentence_length=MAX_WORDS_IN_BATCH):
+        self.fname = fname
+        self.max_sentence_length = max_sentence_length
+
+    def __iter__(self):
+        # the entire corpus is one gigantic line -- there are no sentence marks at all
+        # so just split the sequence of tokens arbitrarily: 1 sentence = 1000 tokens
+        sentence, rest = [], b''
+        with utils.smart_open(self.fname) as fin:
+            while True:
+                text = rest + fin.read(8192)  # avoid loading the entire file (=1 line) into RAM
+                if text == rest:  # EOF
+                    words = utils.to_unicode(text).split()
+                    sentence.extend(words)  # return the last chunk of words, too (may be shorter/longer)
+                    if sentence:
+                        yield sentence
+                    break
+                last_token = text.rfind(b' ')  # last token may have been split in two... keep for next iteration
+                words, rest = (utils.to_unicode(text[:last_token]).split(),
+                               text[last_token:].strip()) if last_token >= 0 else ([], text)
+                sentence.extend(words)
+                while len(sentence) >= self.max_sentence_length:
+                    yield sentence[:self.max_sentence_length]
+                    sentence = sentence[self.max_sentence_length:]
+
+
+class LineSentence(object):
+    """
+    Simple format: one sentence = one line; words already preprocessed and separated by whitespace.
+    """
+
+    def __init__(self, source, max_sentence_length=MAX_WORDS_IN_BATCH, limit=None):
+        """
+        `source` can be either a string or a file object. Clip the file to the first
+        `limit` lines (or not clipped if limit is None, the default).
+
+        Example::
+
+            sentences = LineSentence('myfile.txt')
+
+        Or for compressed files::
+
+            sentences = LineSentence('compressed_text.txt.bz2')
+            sentences = LineSentence('compressed_text.txt.gz')
+
+        """
+        self.source = source
+        self.max_sentence_length = max_sentence_length
+        self.limit = limit
+
+    def __iter__(self):
+        """Iterate through the lines in the source."""
+        try:
+            # Assume it is a file-like object and try treating it as such
+            # Things that don't have seek will trigger an exception
+            self.source.seek(0)
+            for line in itertools.islice(self.source, self.limit):
+                line = utils.to_unicode(line).split()
+                i = 0
+                while i < len(line):
+                    yield line[i: i + self.max_sentence_length]
+                    i += self.max_sentence_length
+        except AttributeError:
+            # If it didn't work like a file, use it as a string filename
+            with utils.smart_open(self.source) as fin:
+                for line in itertools.islice(fin, self.limit):
+                    line = utils.to_unicode(line).split()
+                    i = 0
+                    while i < len(line):
+                        yield line[i: i + self.max_sentence_length]
+                        i += self.max_sentence_length
+
+
+class PathLineSentences(object):
+    """
+
+    Works like word2vec.LineSentence, but will process all files in a directory in alphabetical order by filename.
+    The directory can only contain files that can be read by LineSentence: .bz2, .gz, and text files.
+    Any file not ending with .bz2 or .gz is assumed to be a text file. Does not work with subdirectories.
+
+    The format of files (either text, or compressed text files) in the path is one sentence = one line,
+    with words already preprocessed and separated by whitespace.
+
+    """
+
+    def __init__(self, source, max_sentence_length=MAX_WORDS_IN_BATCH, limit=None):
+        """
+        `source` should be a path to a directory (as a string) where all files can be opened by the
+        LineSentence class. Each file will be read up to `limit` lines (or not clipped if limit is None, the default).
+
+        Example::
+
+            sentences = PathLineSentences(os.getcwd() + '\\corpus\\')
+
+        The files in the directory should be either text files, .bz2 files, or .gz files.
+
+        """
+        self.source = source
+        self.max_sentence_length = max_sentence_length
+        self.limit = limit
+
+        if os.path.isfile(self.source):
+            logger.debug('single file given as source, rather than a directory of files')
+            logger.debug('consider using models.word2vec.LineSentence for a single file')
+            self.input_files = [self.source]  # force code compatibility with list of files
+        elif os.path.isdir(self.source):
+            self.source = os.path.join(self.source, '')  # ensures os-specific slash at end of path
+            logger.info('reading directory %s', self.source)
+            self.input_files = os.listdir(self.source)
+            self.input_files = [self.source + filename for filename in self.input_files]  # make full paths
+            self.input_files.sort()  # makes sure it happens in filename order
+        else:  # not a file or a directory, then we can't do anything with it
+            raise ValueError('input is neither a file nor a path')
+        logger.info('files read into PathLineSentences:%s', '\n'.join(self.input_files))
+
+    def __iter__(self):
+        """iterate through the files"""
+        for file_name in self.input_files:
+            logger.info('reading file %s', file_name)
+            with utils.smart_open(file_name) as fin:
+                for line in itertools.islice(fin, self.limit):
+                    line = utils.to_unicode(line).split()
+                    i = 0
+                    while i < len(line):
+                        yield line[i:i + self.max_sentence_length]
+                        i += self.max_sentence_length
+
+
+# Example: ./word2vec.py -train data.txt -output vec.txt -size 200 -window 5 -sample 1e-4 \
+# -negative 5 -hs 0 -binary 0 -cbow 1 -iter 3
+if __name__ == "__main__":
+    import argparse
+    logging.basicConfig(
+        format='%(asctime)s : %(threadName)s : %(levelname)s : %(message)s',
+        level=logging.INFO
+    )
+    logger.info("running %s", " ".join(sys.argv))
+    logger.info("using optimization %s", FAST_VERSION)
+
+    # check and process cmdline input
+    program = os.path.basename(sys.argv[0])
+    if len(sys.argv) < 2:
+        print(globals()['__doc__'] % locals())
+        sys.exit(1)
+
+    from gensim.models.word2vec import Word2Vec  # noqa:F811 avoid referencing __main__ in pickle
+
+    seterr(all='raise')  # don't ignore numpy errors
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-train", help="Use text data from file TRAIN to train the model", required=True)
+    parser.add_argument("-output", help="Use file OUTPUT to save the resulting word vectors")
+    parser.add_argument("-window", help="Set max skip length WINDOW between words; default is 5", type=int, default=5)
+    parser.add_argument("-size", help="Set size of word vectors; default is 100", type=int, default=100)
+    parser.add_argument(
+        "-sample",
+        help="Set threshold for occurrence of words. "
+             "Those that appear with higher frequency in the training data will be randomly down-sampled;"
+             " default is 1e-3, useful range is (0, 1e-5)",
+        type=float, default=1e-3
+    )
+    parser.add_argument(
+        "-hs", help="Use Hierarchical Softmax; default is 0 (not used)",
+        type=int, default=0, choices=[0, 1]
+    )
+    parser.add_argument(
+        "-negative", help="Number of negative examples; default is 5, common values are 3 - 10 (0 = not used)",
+        type=int, default=5
+    )
+    parser.add_argument("-threads", help="Use THREADS threads (default 12)", type=int, default=12)
+    parser.add_argument("-iter", help="Run more training iterations (default 5)", type=int, default=5)
+    parser.add_argument(
+        "-min_count", help="This will discard words that appear less than MIN_COUNT times; default is 5",
+        type=int, default=5
+    )
+    parser.add_argument(
+        "-cbow", help="Use the continuous bag of words model; default is 1 (use 0 for skip-gram model)",
+        type=int, default=1, choices=[0, 1]
+    )
+    parser.add_argument(
+        "-binary", help="Save the resulting vectors in binary mode; default is 0 (off)",
+        type=int, default=0, choices=[0, 1]
+    )
+    parser.add_argument("-accuracy", help="Use questions from file ACCURACY to evaluate the model")
+
+    args = parser.parse_args()
+
+    if args.cbow == 0:
+        skipgram = 1
+    else:
+        skipgram = 0
+
+    corpus = LineSentence(args.train)
+
+    model = Word2Vec(
+        corpus, size=args.size, min_count=args.min_count, workers=args.threads,
+        window=args.window, sample=args.sample, sg=skipgram, hs=args.hs,
+        negative=args.negative, cbow_mean=1, iter=args.iter
+    )
+
+    if args.output:
+        outfile = args.output
+        model.wv.save_word2vec_format(outfile, binary=args.binary)
+    else:
+        outfile = args.train
+        model.save(outfile + '.model')
+    if args.binary == 1:
+        model.wv.save_word2vec_format(outfile + '.model.bin', binary=True)
+    else:
+        model.wv.save_word2vec_format(outfile + '.model.txt', binary=False)
+
+    if args.accuracy:
+        model.accuracy(args.accuracy)
+
+    logger.info("finished running %s", program)
diff --git a/gensim/models/doc2vec.py b/gensim/models/doc2vec.py
index e693c5400b..1bb77f02a2 100644
--- a/gensim/models/doc2vec.py
+++ b/gensim/models/doc2vec.py
@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2013 Radim Rehurek <me@radimrehurek.com>
+# Author: Shiva Manne <manneshiva@gmail.com>
+# Copyright (C) 2018 RaRe Technologies s.r.o.
 # Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
 
 
@@ -46,6 +47,7 @@
 
 import logging
 import os
+import warnings
 
 try:
     from queue import Queue
@@ -55,26 +57,27 @@
 from collections import namedtuple, defaultdict
 from timeit import default_timer
 
-from numpy import zeros, sum as np_sum, add as np_add, concatenate, \
-    repeat as np_repeat, array, float32 as REAL, empty, ones, memmap as np_memmap, \
-    sqrt, newaxis, ndarray, dot, vstack, dtype, divide as np_divide, integer
+from numpy import zeros, float32 as REAL, empty, ones, \
+    memmap as np_memmap, vstack, integer, dtype, sum as np_sum, add as np_add, repeat as np_repeat, concatenate
 
 
-from gensim.utils import call_on_class_only, deprecated
+from gensim.utils import call_on_class_only
 from gensim import utils, matutils  # utility fnc for pickling, common scipy operations etc
-from gensim.models.word2vec import Word2Vec, train_cbow_pair, train_sg_pair, train_batch_sg
-from gensim.models.keyedvectors import KeyedVectors
-from six.moves import xrange, zip
-from six import string_types, integer_types
+from gensim.models.word2vec import Word2VecKeyedVectors, Word2VecVocab, Word2VecTrainables, train_cbow_pair,\
+    train_sg_pair, train_batch_sg
+from six.moves import xrange
+from six import string_types, integer_types, itervalues
+from gensim.models.base_any2vec import BaseWordEmbeddingsModel
+from gensim.models.keyedvectors import Doc2VecKeyedVectors
+from types import GeneratorType
 
 logger = logging.getLogger(__name__)
 
 try:
     from gensim.models.doc2vec_inner import train_document_dbow, train_document_dm, train_document_dm_concat
     from gensim.models.word2vec_inner import FAST_VERSION  # blas-adaptation shared from word2vec
-    logger.debug('Fast version of %s is being used', __name__)
+
 except ImportError:
-    logger.warning('Slow version of %s is being used', __name__)
     # failed... fall back to plain numpy (20-80x slower training than the above)
     FAST_VERSION = -1
 
@@ -83,24 +86,18 @@ def train_document_dbow(model, doc_words, doctag_indexes, alpha, work=None,
                             word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
         """
         Update distributed bag of words model ("PV-DBOW") by training on a single document.
-
         Called internally from `Doc2Vec.train()` and `Doc2Vec.infer_vector()`.
-
         The document is provided as `doc_words`, a list of word tokens which are looked up
         in the model's vocab dictionary, and `doctag_indexes`, which provide indexes
         into the doctag_vectors array.
-
         If `train_words` is True, simultaneously train word-to-word (not just doc-to-word)
         examples, exactly as per Word2Vec skip-gram training. (Without this option,
         word vectors are neither consulted nor updated during DBOW doc vector training.)
-
         Any of `learn_doctags', `learn_words`, and `learn_hidden` may be set False to
         prevent learning-updates to those respective model weights, as if using the
         (partially-)frozen model to infer other compatible vectors.
-
         This is the non-optimized, Python version. If you have cython installed, gensim
         will use the optimized version from doc2vec_inner instead.
-
         """
         if doctag_vectors is None:
             doctag_vectors = model.docvecs.doctag_syn0
@@ -123,24 +120,19 @@ def train_document_dm(model, doc_words, doctag_indexes, alpha, work=None, neu1=N
                           word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
         """
         Update distributed memory model ("PV-DM") by training on a single document.
-
         Called internally from `Doc2Vec.train()` and `Doc2Vec.infer_vector()`. This
         method implements the DM model with a projection (input) layer that is
         either the sum or mean of the context vectors, depending on the model's
         `dm_mean` configuration field.  See `train_document_dm_concat()` for the DM
         model with a concatenated input layer.
-
         The document is provided as `doc_words`, a list of word tokens which are looked up
         in the model's vocab dictionary, and `doctag_indexes`, which provide indexes
         into the doctag_vectors array.
-
         Any of `learn_doctags', `learn_words`, and `learn_hidden` may be set False to
         prevent learning-updates to those respective model weights, as if using the
         (partially-)frozen model to infer other compatible vectors.
-
         This is the non-optimized, Python version. If you have a C compiler, gensim
         will use the optimized version from doc2vec_inner instead.
-
         """
         if word_vectors is None:
             word_vectors = model.wv.syn0
@@ -152,7 +144,7 @@ def train_document_dm(model, doc_words, doctag_indexes, alpha, work=None, neu1=N
             doctag_locks = model.docvecs.doctag_syn0_lockf
 
         word_vocabs = [model.wv.vocab[w] for w in doc_words if w in model.wv.vocab and
-                       model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+                       model.wv.vocab[w].sample_int > model.random.rand() * 2 ** 32]
 
         for pos, word in enumerate(word_vocabs):
             reduced_window = model.random.randint(model.window)  # `b` in the original doc2vec code
@@ -182,20 +174,15 @@ def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None,
         """
         Update distributed memory model ("PV-DM") by training on a single document, using a
         concatenation of the context window word vectors (rather than a sum or average).
-
         Called internally from `Doc2Vec.train()` and `Doc2Vec.infer_vector()`.
-
         The document is provided as `doc_words`, a list of word tokens which are looked up
         in the model's vocab dictionary, and `doctag_indexes`, which provide indexes
         into the doctag_vectors array.
-
         Any of `learn_doctags', `learn_words`, and `learn_hidden` may be set False to
         prevent learning-updates to those respective model weights, as if using the
         (partially-)frozen model to infer other compatible vectors.
-
         This is the non-optimized, Python version. If you have a C compiler, gensim
         will use the optimized version from doc2vec_inner instead.
-
         """
         if word_vectors is None:
             word_vectors = model.wv.syn0
@@ -207,7 +194,7 @@ def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None,
             doctag_locks = model.docvecs.doctag_syn0_lockf
 
         word_vocabs = [model.wv.vocab[w] for w in doc_words if w in model.wv.vocab and
-                       model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+                       model.wv.vocab[w].sample_int > model.random.rand() * 2 ** 32]
         doctag_len = len(doctag_indexes)
         if doctag_len != model.dm_tag_count:
             return 0  # skip doc without expected number of doctag(s) (TODO: warn/pad?)
@@ -216,15 +203,15 @@ def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None,
         pre_pad_count = model.window
         post_pad_count = model.window
         padded_document_indexes = (
-            (pre_pad_count * [null_word.index])  # pre-padding
-            + [word.index for word in word_vocabs if word is not None]  # elide out-of-Vocabulary words
-            + (post_pad_count * [null_word.index])  # post-padding
+                (pre_pad_count * [null_word.index])  # pre-padding
+                + [word.index for word in word_vocabs if word is not None]  # elide out-of-Vocabulary words
+                + (post_pad_count * [null_word.index])  # post-padding
         )
 
         for pos in range(pre_pad_count, len(padded_document_indexes) - post_pad_count):
             word_context_indexes = (
-                padded_document_indexes[(pos - pre_pad_count): pos]  # preceding words
-                + padded_document_indexes[(pos + 1):(pos + 1 + post_pad_count)]  # following words
+                    padded_document_indexes[(pos - pre_pad_count): pos]  # preceding words
+                    + padded_document_indexes[(pos + 1):(pos + 1 + post_pad_count)]  # following words
             )
             predict_word = model.wv.vocab[model.wv.index2word[padded_document_indexes[pos]]]
             # numpy advanced-indexing copies; concatenate, flatten to 1d
@@ -260,286 +247,6 @@ def __str__(self):
         return '%s(%s, %s)' % (self.__class__.__name__, self.words, self.tags)
 
 
-# for compatibility
-@deprecated("Class will be removed in 4.0.0, use TaggedDocument instead")
-class LabeledSentence(TaggedDocument):
-    pass
-
-
-class DocvecsArray(utils.SaveLoad):
-    """
-    Default storage of doc vectors during/after training, in a numpy array.
-
-    As the 'docvecs' property of a Doc2Vec model, allows access and
-    comparison of document vectors.
-
-    >>> docvec = d2v_model.docvecs[99]
-    >>> docvec = d2v_model.docvecs['SENT_99']  # if string tag used in training
-    >>> sims = d2v_model.docvecs.most_similar(99)
-    >>> sims = d2v_model.docvecs.most_similar('SENT_99')
-    >>> sims = d2v_model.docvecs.most_similar(docvec)
-
-    If only plain int tags are presented during training, the dict (of
-    string tag -> index) and list (of index -> string tag) stay empty,
-    saving memory.
-
-    Supplying a mapfile_path (as by initializing a Doc2Vec model with a
-    'docvecs_mapfile' value) will use a pair of memory-mapped
-    files as the array backing for doctag_syn0/doctag_syn0_lockf values.
-
-    The Doc2Vec model automatically uses this class, but a future alternative
-    implementation, based on another persistence mechanism like LMDB, LevelDB,
-    or SQLite, should also be possible.
-    """
-
-    def __init__(self, mapfile_path=None):
-        self.doctags = {}  # string -> Doctag (only filled if necessary)
-        self.max_rawint = -1  # highest rawint-indexed doctag
-        self.offset2doctag = []  # int offset-past-(max_rawint+1) -> String (only filled if necessary)
-        self.count = 0
-        self.mapfile_path = mapfile_path
-
-    def note_doctag(self, key, document_no, document_length):
-        """Note a document tag during initial corpus scan, for structure sizing."""
-        if isinstance(key, integer_types + (integer,)):
-            self.max_rawint = max(self.max_rawint, key)
-        else:
-            if key in self.doctags:
-                self.doctags[key] = self.doctags[key].repeat(document_length)
-            else:
-                self.doctags[key] = Doctag(len(self.offset2doctag), document_length, 1)
-                self.offset2doctag.append(key)
-        self.count = self.max_rawint + 1 + len(self.offset2doctag)
-
-    def indexed_doctags(self, doctag_tokens):
-        """Return indexes and backing-arrays used in training examples."""
-        return ([self._int_index(index) for index in doctag_tokens if index in self],
-                self.doctag_syn0, self.doctag_syn0_lockf, doctag_tokens)
-
-    def trained_item(self, indexed_tuple):
-        """Persist any changes made to the given indexes (matching tuple previously
-        returned by indexed_doctags()); a no-op for this implementation"""
-        pass
-
-    def _int_index(self, index):
-        """Return int index for either string or int index"""
-        if isinstance(index, integer_types + (integer,)):
-            return index
-        else:
-            return self.max_rawint + 1 + self.doctags[index].offset
-
-    @deprecated("Method will be removed in 4.0.0, use self.index_to_doctag instead")
-    def _key_index(self, i_index, missing=None):
-        """Return string index for given int index, if available"""
-        return self.index_to_doctag(i_index)
-
-    def index_to_doctag(self, i_index):
-        """Return string key for given i_index, if available. Otherwise return raw int doctag (same int)."""
-        candidate_offset = i_index - self.max_rawint - 1
-        if 0 <= candidate_offset < len(self.offset2doctag):
-            return self.offset2doctag[candidate_offset]
-        else:
-            return i_index
-
-    def __getitem__(self, index):
-        """
-        Accept a single key (int or string tag) or list of keys as input.
-
-        If a single string or int, return designated tag's vector
-        representation, as a 1D numpy array.
-
-        If a list, return designated tags' vector representations as a
-        2D numpy array: #tags x #vector_size.
-        """
-        if isinstance(index, string_types + integer_types + (integer,)):
-            return self.doctag_syn0[self._int_index(index)]
-
-        return vstack([self[i] for i in index])
-
-    def __len__(self):
-        return self.count
-
-    def __contains__(self, index):
-        if isinstance(index, integer_types + (integer,)):
-            return index < self.count
-        else:
-            return index in self.doctags
-
-    def save(self, *args, **kwargs):
-        # don't bother storing the cached normalized vectors
-        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm'])
-        super(DocvecsArray, self).save(*args, **kwargs)
-
-    def borrow_from(self, other_docvecs):
-        self.count = other_docvecs.count
-        self.doctags = other_docvecs.doctags
-        self.offset2doctag = other_docvecs.offset2doctag
-
-    def clear_sims(self):
-        self.doctag_syn0norm = None
-
-    def estimated_lookup_memory(self):
-        """Estimated memory for tag lookup; 0 if using pure int tags."""
-        return 60 * len(self.offset2doctag) + 140 * len(self.doctags)
-
-    def reset_weights(self, model):
-        length = max(len(self.doctags), self.count)
-        if self.mapfile_path:
-            self.doctag_syn0 = np_memmap(
-                self.mapfile_path + '.doctag_syn0', dtype=REAL, mode='w+', shape=(length, model.vector_size)
-            )
-            self.doctag_syn0_lockf = np_memmap(
-                self.mapfile_path + '.doctag_syn0_lockf', dtype=REAL, mode='w+', shape=(length,)
-            )
-            self.doctag_syn0_lockf.fill(1.0)
-        else:
-            self.doctag_syn0 = empty((length, model.vector_size), dtype=REAL)
-            self.doctag_syn0_lockf = ones((length,), dtype=REAL)  # zeros suppress learning
-
-        for i in xrange(length):
-            # construct deterministic seed from index AND model seed
-            seed = "%d %s" % (model.seed, self.index_to_doctag(i))
-            self.doctag_syn0[i] = model.seeded_vector(seed)
-
-    def init_sims(self, 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 or inference** after doing a replace.
-        The model becomes effectively read-only = you can call `most_similar`, `similarity`
-        etc., but not `train` or `infer_vector`.
-
-        """
-        if getattr(self, 'doctag_syn0norm', None) is None or replace:
-            logger.info("precomputing L2-norms of doc weight vectors")
-            if replace:
-                for i in xrange(self.doctag_syn0.shape[0]):
-                    self.doctag_syn0[i, :] /= sqrt((self.doctag_syn0[i, :] ** 2).sum(-1))
-                self.doctag_syn0norm = self.doctag_syn0
-            else:
-                if self.mapfile_path:
-                    self.doctag_syn0norm = np_memmap(
-                        self.mapfile_path + '.doctag_syn0norm', dtype=REAL,
-                        mode='w+', shape=self.doctag_syn0.shape)
-                else:
-                    self.doctag_syn0norm = empty(self.doctag_syn0.shape, dtype=REAL)
-                np_divide(self.doctag_syn0, sqrt((self.doctag_syn0 ** 2).sum(-1))[..., newaxis], self.doctag_syn0norm)
-
-    def most_similar(self, positive=None, negative=None, topn=10, clip_start=0, clip_end=None, indexer=None):
-        """
-        Find the top-N most similar docvecs known from training. Positive docs contribute
-        positively towards the similarity, negative docs negatively.
-
-        This method computes cosine similarity between a simple mean of the projection
-        weight vectors of the given docs. Docs may be specified as vectors, integer indexes
-        of trained docvecs, or if the documents were originally presented with string tags,
-        by the corresponding tags.
-
-        The 'clip_start' and 'clip_end' allow limiting results to a particular contiguous
-        range of the underlying doctag_syn0norm vectors. (This may be useful if the ordering
-        there was chosen to be significant, such as more popular tag IDs in lower indexes.)
-        """
-        if positive is None:
-            positive = []
-        if negative is None:
-            negative = []
-
-        self.init_sims()
-        clip_end = clip_end or len(self.doctag_syn0norm)
-
-        if isinstance(positive, string_types + integer_types + (integer,)) and not negative:
-            # allow calls like most_similar('dog'), as a shorthand for most_similar(['dog'])
-            positive = [positive]
-
-        # add weights for each doc, if not already present; default to 1.0 for positive and -1.0 for negative docs
-        positive = [
-            (doc, 1.0) if isinstance(doc, string_types + integer_types + (ndarray, integer))
-            else doc for doc in positive
-        ]
-        negative = [
-            (doc, -1.0) if isinstance(doc, string_types + integer_types + (ndarray, integer))
-            else doc for doc in negative
-        ]
-
-        # compute the weighted average of all docs
-        all_docs, mean = set(), []
-        for doc, weight in positive + negative:
-            if isinstance(doc, ndarray):
-                mean.append(weight * doc)
-            elif doc in self.doctags or doc < self.count:
-                mean.append(weight * self.doctag_syn0norm[self._int_index(doc)])
-                all_docs.add(self._int_index(doc))
-            else:
-                raise KeyError("doc '%s' not in trained set" % doc)
-        if not mean:
-            raise ValueError("cannot compute similarity with no input")
-        mean = matutils.unitvec(array(mean).mean(axis=0)).astype(REAL)
-
-        if indexer is not None:
-            return indexer.most_similar(mean, topn)
-
-        dists = dot(self.doctag_syn0norm[clip_start:clip_end], mean)
-        if not topn:
-            return dists
-        best = matutils.argsort(dists, topn=topn + len(all_docs), reverse=True)
-        # ignore (don't return) docs from the input
-        result = [
-            (self.index_to_doctag(sim + clip_start), float(dists[sim]))
-            for sim in best
-            if (sim + clip_start) not in all_docs
-        ]
-        return result[:topn]
-
-    def doesnt_match(self, docs):
-        """
-        Which doc from the given list doesn't go with the others?
-
-        (TODO: Accept vectors of out-of-training-set docs, as if from inference.)
-
-        """
-        self.init_sims()
-
-        docs = [doc for doc in docs if doc in self.doctags or 0 <= doc < self.count]  # filter out unknowns
-        logger.debug("using docs %s", docs)
-        if not docs:
-            raise ValueError("cannot select a doc from an empty list")
-        vectors = vstack(self.doctag_syn0norm[self._int_index(doc)] for doc in docs).astype(REAL)
-        mean = matutils.unitvec(vectors.mean(axis=0)).astype(REAL)
-        dists = dot(vectors, mean)
-        return sorted(zip(dists, docs))[0][1]
-
-    def similarity(self, d1, d2):
-        """
-        Compute cosine similarity between two docvecs in the trained set, specified by int index or
-        string tag. (TODO: Accept vectors of out-of-training-set docs, as if from inference.)
-
-        """
-        return dot(matutils.unitvec(self[d1]), matutils.unitvec(self[d2]))
-
-    def n_similarity(self, ds1, ds2):
-        """
-        Compute cosine similarity between two sets of docvecs from the trained set, specified by int
-        index or string tag. (TODO: Accept vectors of out-of-training-set docs, as if from inference.)
-
-        """
-        v1 = [self[doc] for doc in ds1]
-        v2 = [self[doc] for doc in ds2]
-        return dot(matutils.unitvec(array(v1).mean(axis=0)), matutils.unitvec(array(v2).mean(axis=0)))
-
-    def similarity_unseen_docs(self, model, doc_words1, doc_words2, alpha=0.1, min_alpha=0.0001, steps=5):
-        """
-        Compute cosine similarity between two post-bulk out of training documents.
-
-        Document should be a list of (word) tokens.
-        """
-        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.)
@@ -549,7 +256,7 @@ class Doctag(namedtuple('Doctag', 'offset, word_count, doc_count')):
     The offset is only the true index into the doctags_syn0/doctags_syn0_lockf
     if-and-only-if no raw-int tags were used. If any raw-int tags were used,
     string Doctag vectors begin at index (max_rawint + 1), so the true index is
-    (rawint_index + 1 + offset). See also DocvecsArray.index_to_doctag().
+    (rawint_index + 1 + offset). See also _index_to_doctag().
     """
     __slots__ = ()
 
@@ -557,78 +264,85 @@ def repeat(self, word_count):
         return self._replace(word_count=self.word_count + word_count, doc_count=self.doc_count + 1)
 
 
-class Doc2Vec(Word2Vec):
+class Doc2Vec(BaseWordEmbeddingsModel):
     """Class for training, using and evaluating neural networks described in http://arxiv.org/pdf/1405.4053v2.pdf"""
 
     def __init__(self, documents=None, dm_mean=None, dm=1, dbow_words=0, dm_concat=0, dm_tag_count=1,
-                 docvecs=None, docvecs_mapfile=None, comment=None, trim_rule=None, **kwargs):
-        """
-        Initialize the model from an iterable of `documents`. Each document is a
+                 docvecs=None, docvecs_mapfile=None, comment=None, trim_rule=None, callbacks=(), **kwargs):
+        """Initialize the model from an iterable of `documents`. Each document is a
         TaggedDocument object that will be used for training.
 
-        The `documents` iterable can be simply a list of TaggedDocument elements, but for larger corpora,
-        consider an iterable that streams the documents directly from disk/network.
-
-        If you don't supply `documents`, the model is left uninitialized -- use if
-        you plan to initialize it in some other way.
-
-        `dm` defines the training algorithm. By default (`dm=1`), 'distributed memory' (PV-DM) is used.
-        Otherwise, `distributed bag of words` (PV-DBOW) is employed.
-
-        `size` is the dimensionality of the feature vectors.
-
-        `window` is the maximum distance between the predicted word and context words used for prediction
-        within a document.
-
-        `alpha` is the initial learning rate (will linearly drop to `min_alpha` as training progresses).
-
-        `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
-        environment variable to control hash randomization.)
+        Parameters
+        ----------
+        documents : iterable of iterables
+            The `documents` iterable can be simply a list of TaggedDocument elements, but for larger corpora,
+            consider an iterable that streams the documents directly from disk/network.
+            If you don't supply `documents`, the model is left uninitialized -- use if
+            you plan to initialize it in some other way.
+
+        dm : int {1,0}
+            Defines the training algorithm. If `dm=1`, 'distributed memory' (PV-DM) is used.
+            Otherwise, `distributed bag of words` (PV-DBOW) is employed.
+
+        size : int
+            Dimensionality of the feature vectors.
+        window : int
+            The maximum distance between the current and predicted word within a sentence.
+        alpha : float
+            The initial learning rate.
+        min_alpha : float
+            Learning rate will linearly drop to `min_alpha` as training progresses.
+        seed : int
+            Seed for the random number generator. Initial vectors for each word are seeded with a hash of
+            the concatenation of word + `str(seed)`. Note that for a fully deterministically-reproducible run,
+            you must also limit the model to a single worker thread (`workers=1`), to eliminate ordering jitter
+            from OS thread scheduling. (In Python 3, reproducibility between interpreter launches also requires
+            use of the `PYTHONHASHSEED` environment variable to control hash randomization).
+        min_count : int
+            Ignores all words with total frequency lower than this.
+        max_vocab_size : int
+            Limits the RAM during vocabulary building; if there are more unique
+            words than this, then prune the infrequent ones. Every 10 million word types need about 1GB of RAM.
+            Set to `None` for no limit.
+        sample : float
+            The threshold for configuring which higher-frequency words are randomly downsampled,
+            useful range is (0, 1e-5).
+        workers : int
+            Use these many worker threads to train the model (=faster training with multicore machines).
+        iter : int
+            Number of iterations (epochs) over the corpus.
+        hs : int {1,0}
+            If 1, hierarchical softmax will be used for model training.
+            If set to 0, and `negative` is non-zero, negative sampling will be used.
+        negative : int
+            If > 0, negative sampling will be used, the int for negative specifies how many "noise words"
+            should be drawn (usually between 5-20).
+            If set to 0, no negative sampling is used.
+        dm_mean : int {1,0}
+            If 0 , use the sum of the context word vectors. If 1, use the mean.
+            Only applies when `dm` is used in non-concatenative mode.
+        dm_concat : int {1,0}
+            If 1, use concatenation of context vectors rather than sum/average;
+            Note concatenation results in a much-larger model, as the input
+            is no longer the size of one (sampled or arithmetically combined) word vector, but the
+            size of the tag(s) and all words in the context strung together.
+        dm_tag_count : int
+            Expected constant number of document tags per document, when using
+            dm_concat mode; default is 1.
+        dbow_words : int {1,0}
+            If set to 1 trains word-vectors (in skip-gram fashion) simultaneous with DBOW
+            doc-vector training; If 0, only trains doc-vectors (faster).
+        trim_rule : function
+            Vocabulary trimming rule, specifies whether certain words should remain in the vocabulary,
+            be trimmed away, or handled using the default (discard if word count < min_count).
+            Can be None (min_count will be used, look to :func:`~gensim.utils.keep_vocab_item`),
+            or a callable that accepts parameters (word, count, min_count) and returns either
+            :attr:`gensim.utils.RULE_DISCARD`, :attr:`gensim.utils.RULE_KEEP` or :attr:`gensim.utils.RULE_DEFAULT`.
+            Note: The rule, if given, is only used to prune vocabulary during build_vocab() and is not stored as part
+            of the model.
+        callbacks : :obj: `list` of :obj: `~gensim.models.callbacks.CallbackAny2Vec`
+            List of callbacks that need to be executed/run at specific stages during training.
 
-        `min_count` = ignore all words with total frequency lower than this.
-
-        `max_vocab_size` = limit RAM during vocabulary building; if there are more unique
-        words than this, then prune the infrequent ones. Every 10 million word types
-        need about 1GB of RAM. Set to `None` for no limit (default).
-
-        `sample` = threshold for configuring which higher-frequency words are randomly downsampled;
-                default is 1e-3, values of 1e-5 (or lower) may also be useful, set to 0.0 to disable downsampling.
-
-        `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,
-        but values of 10 or 20 are common in published 'Paragraph Vector' experiments.
-
-        `hs` = if 1, hierarchical softmax will be used for model training.
-        If set to 0 (default), and `negative` is non-zero, negative sampling will be used.
-
-        `negative` = if > 0, negative sampling will be used, the int for negative
-        specifies how many "noise words" should be drawn (usually between 5-20).
-        Default is 5. If set to 0, no negative samping is used.
-
-        `dm_mean` = if 0 (default), use the sum of the context word vectors. If 1, use the mean.
-        Only applies when dm is used in non-concatenative mode.
-
-        `dm_concat` = if 1, use concatenation of context vectors rather than sum/average;
-        default is 0 (off). Note concatenation results in a much-larger model, as the input
-        is no longer the size of one (sampled or arithmetically combined) word vector, but the
-        size of the tag(s) and all words in the context strung together.
-
-        `dm_tag_count` = expected constant number of document tags per document, when using
-        dm_concat mode; default is 1.
-
-        `dbow_words` if set to 1 trains word-vectors (in skip-gram fashion) simultaneous with DBOW
-        doc-vector training; default is 0 (faster training of doc-vectors only).
-
-        `trim_rule` = vocabulary trimming rule, specifies whether certain words should remain
-        in the vocabulary, be trimmed away, or handled using the default (discard if word count < min_count).
-        Can be None (min_count will be used), or a callable that accepts parameters (word, count, min_count) and
-        returns either util.RULE_DISCARD, util.RULE_KEEP or util.RULE_DEFAULT.
-        Note: The rule, if given, is only used prune vocabulary during build_vocab() and is not stored as part
-        of the model.
         """
 
         if 'sentences' in kwargs:
@@ -637,9 +351,19 @@ def __init__(self, documents=None, dm_mean=None, dm=1, dbow_words=0, dm_concat=0
                 "use 'documents' instead."
             )
 
+        if 'iter' in kwargs:
+            warnings.warn("The parameter `iter` is deprecated, will be removed in 4.0.0, use `epochs` instead.")
+            kwargs['epochs'] = kwargs['iter']
+
+        if 'size' in kwargs:
+            warnings.warn("The parameter `size` is deprecated, will be removed in 4.0.0, use `vector_size` instead.")
+            kwargs['vector_size'] = kwargs['size']
+
         super(Doc2Vec, self).__init__(
             sg=(1 + dm) % 2,
             null_word=dm_concat,
+            callbacks=callbacks,
+            fast_version=FAST_VERSION,
             **kwargs)
 
         self.load = call_on_class_only
@@ -647,95 +371,73 @@ def __init__(self, documents=None, dm_mean=None, dm=1, dbow_words=0, dm_concat=0
         if dm_mean is not None:
             self.cbow_mean = dm_mean
 
-        self.dbow_words = dbow_words
-        self.dm_concat = dm_concat
-        self.dm_tag_count = dm_tag_count
-        if self.dm and self.dm_concat:
-            self.layer1_size = (self.dm_tag_count + (2 * self.window)) * self.vector_size
+        self.dbow_words = int(dbow_words)
+        self.dm_concat = int(dm_concat)
+        self.dm_tag_count = int(dm_tag_count)
+
+        kwargs['null_word'] = dm_concat
+        vocabulary_keys = ['max_vocab_size', 'min_count', 'sample', 'sorted_vocab', 'null_word']
+        vocabulary_kwargs = dict((k, kwargs[k]) for k in vocabulary_keys if k in kwargs)
+        self.vocabulary = Doc2VecVocab(**vocabulary_kwargs)
+
+        trainables_keys = ['seed', 'hashfxn', 'window']
+        trainables_kwargs = dict((k, kwargs[k]) for k in trainables_keys if k in kwargs)
+        self.trainables = Doc2VecTrainables(
+            dm=dm, dm_concat=dm_concat, dm_tag_count=dm_tag_count,
+            vector_size=self.vector_size, **trainables_kwargs)
+
+        self.wv = Word2VecKeyedVectors(self.vector_size)
+        self.docvecs = docvecs or Doc2VecKeyedVectors(self.vector_size, docvecs_mapfile)
 
-        self.docvecs = docvecs or DocvecsArray(docvecs_mapfile)
         self.comment = comment
         if documents is not None:
+            if isinstance(documents, GeneratorType):
+                raise TypeError("You can't pass a generator as the documents argument. Try an iterator.")
             self.build_vocab(documents, trim_rule=trim_rule)
-            self.train(documents, total_examples=self.corpus_count, epochs=self.iter)
+            self.train(
+                documents, total_examples=self.corpus_count, epochs=self.epochs,
+                start_alpha=self.alpha, end_alpha=self.min_alpha, callbacks=callbacks)
 
     @property
     def dm(self):
+        """int {1,0} : `dm=1` indicates 'distributed memory' (PV-DM) else
+        `distributed bag of words` (PV-DBOW) is used."""
         return not self.sg  # opposite of SG
 
     @property
     def dbow(self):
+        """int {1,0} : `dbow=1` indicates `distributed bag of words` (PV-DBOW) else
+        'distributed memory' (PV-DM) is used."""
         return self.sg  # same as SG
 
-    def clear_sims(self):
-        super(Doc2Vec, self).clear_sims()
-        self.docvecs.clear_sims()
+    def _set_train_params(self, **kwargs):
+        pass
 
-    def reset_weights(self):
-        if self.dm and self.dm_concat:
-            # expand l1 size to match concatenated tags+words length
-            self.layer1_size = (self.dm_tag_count + (2 * self.window)) * self.vector_size
-            logger.info("using concatenative %d-dimensional layer1", self.layer1_size)
-        super(Doc2Vec, self).reset_weights()
-        self.docvecs.reset_weights(self)
+    def _clear_post_train(self):
+        self.clear_sims()
+
+    def clear_sims(self):
+        self.wv.vectors_norm = None
+        self.wv.vectors_docs_norm = None
 
     def reset_from(self, other_model):
         """Reuse shareable structures from other_model."""
-        self.docvecs.borrow_from(other_model.docvecs)
-        super(Doc2Vec, self).reset_from(other_model)
-
-    def scan_vocab(self, documents, progress_per=10000, trim_rule=None, update=False):
-        logger.info("collecting all words and their counts")
-        document_no = -1
-        total_words = 0
-        min_reduce = 1
-        interval_start = default_timer() - 0.00001  # guard against next sample being identical
-        interval_count = 0
-        checked_string_types = 0
-        vocab = defaultdict(int)
-        for document_no, document in enumerate(documents):
-            if not checked_string_types:
-                if isinstance(document.words, string_types):
-                    logger.warning(
-                        "Each 'words' should be a list of words (usually unicode strings). "
-                        "First 'words' here is instead plain %s.",
-                        type(document.words)
-                    )
-                checked_string_types += 1
-            if document_no % progress_per == 0:
-                interval_rate = (total_words - interval_count) / (default_timer() - interval_start)
-                logger.info(
-                    "PROGRESS: at example #%i, processed %i words (%i/s), %i word types, %i tags",
-                    document_no, total_words, interval_rate, len(vocab), len(self.docvecs)
-                )
-                interval_start = default_timer()
-                interval_count = total_words
-            document_length = len(document.words)
-
-            for tag in document.tags:
-                self.docvecs.note_doctag(tag, document_no, document_length)
-
-            for word in document.words:
-                vocab[word] += 1
-            total_words += len(document.words)
-
-            if self.max_vocab_size and len(vocab) > self.max_vocab_size:
-                utils.prune_vocab(vocab, min_reduce, trim_rule=trim_rule)
-                min_reduce += 1
-
-        logger.info(
-            "collected %i word types and %i unique tags from a corpus of %i examples and %i words",
-            len(vocab), len(self.docvecs), document_no + 1, total_words
-        )
-        self.corpus_count = document_no + 1
-        self.raw_vocab = vocab
+        self.wv.vocab = other_model.wv.vocab
+        self.wv.index2word = other_model.wv.index2word
+        self.vocabulary.cum_table = other_model.vocabulary.cum_table
+        self.corpus_count = other_model.corpus_count
+        self.docvecs.count = other_model.docvecs.count
+        self.docvecs.doctags = other_model.docvecs.doctags
+        self.docvecs.offset2doctag = other_model.docvecs.offset2doctag
+        self.trainables.reset_weights(self.hs, self.negative, self.wv, self.docvecs)
 
     def _do_train_job(self, job, alpha, inits):
         work, neu1 = inits
         tally = 0
         for doc in job:
-            indexed_doctags = self.docvecs.indexed_doctags(doc.tags)
-            doctag_indexes, doctag_vectors, doctag_locks, ignored = indexed_doctags
+            doctag_indexes = self.vocabulary.indexed_doctags(doc.tags, self.docvecs)
+            doctag_vectors = self.docvecs.vectors_docs
+            doctag_locks = self.trainables.vectors_docs_lockf
             if self.sg:
                 tally += train_document_dbow(
                     self, doc.words, doctag_indexes, alpha, work, train_words=self.dbow_words,
@@ -751,27 +453,91 @@ def _do_train_job(self, job, alpha, inits):
                     self, doc.words, doctag_indexes, alpha, work, neu1,
                     doctag_vectors=doctag_vectors, doctag_locks=doctag_locks
                 )
-            self.docvecs.trained_item(indexed_doctags)
         return tally, self._raw_word_count(job)
 
+    def train(self, documents, total_examples=None, total_words=None,
+              epochs=None, start_alpha=None, end_alpha=None,
+              word_count=0, queue_factor=2, report_delay=1.0, callbacks=()):
+        """Update the model's neural weights from a sequence of sentences (can be a once-only generator stream).
+        The `documents` iterable can be simply a list of TaggedDocument elements.
+
+        To support linear learning-rate decay from (initial) alpha to min_alpha, and accurate
+        progress-percentage logging, either total_examples (count of sentences) or total_words (count of
+        raw words in sentences) **MUST** be provided (if the corpus is the same as was provided to
+        :meth:`~gensim.models.word2vec.Word2Vec.build_vocab()`, the count of examples in that corpus
+        will be available in the model's :attr:`corpus_count` property).
+
+        To avoid common mistakes around the model's ability to do multiple training passes itself, an
+        explicit `epochs` argument **MUST** be provided. In the common and recommended case,
+        where :meth:`~gensim.models.word2vec.Word2Vec.train()` is only called once,
+        the model's cached `iter` value should be supplied as `epochs` value.
+
+        Parameters
+        ----------
+        documents : iterable of iterables
+            The `documents` iterable can be simply a list of TaggedDocument elements, but for larger corpora,
+            consider an iterable that streams the documents directly from disk/network.
+            See :class:`~gensim.models.doc2vec.TaggedBrownCorpus` or :class:`~gensim.models.doc2vec.TaggedLineDocument`
+            in :mod:`~gensim.models.doc2vec` module for such examples.
+        total_examples : int
+            Count of sentences.
+        total_words : int
+            Count of raw words in documents.
+        epochs : int
+            Number of iterations (epochs) over the corpus.
+        start_alpha : float
+            Initial learning rate.
+        end_alpha : float
+            Final learning rate. Drops linearly from `start_alpha`.
+        word_count : int
+            Count of words already trained. Set this to 0 for the usual
+            case of training on all words in sentences.
+        queue_factor : int
+            Multiplier for size of queue (number of workers * queue_factor).
+        report_delay : float
+            Seconds to wait before reporting progress.
+        callbacks : :obj: `list` of :obj: `~gensim.models.callbacks.CallbackAny2Vec`
+            List of callbacks that need to be executed/run at specific stages during training.
+        """
+        super(Doc2Vec, self).train(
+            documents, total_examples=total_examples, total_words=total_words,
+            epochs=epochs, start_alpha=start_alpha, end_alpha=end_alpha, word_count=word_count,
+            queue_factor=queue_factor, report_delay=report_delay, callbacks=callbacks)
+
     def _raw_word_count(self, job):
         """Return the number of words in a given job."""
         return sum(len(sentence.words) for sentence in job)
 
+    def estimated_lookup_memory(self):
+        """Estimated memory for tag lookup; 0 if using pure int tags."""
+        return 60 * len(self.docvecs.offset2doctag) + 140 * len(self.docvecs.doctags)
+
     def infer_vector(self, doc_words, alpha=0.1, min_alpha=0.0001, steps=5):
         """
         Infer a vector for given post-bulk training document.
 
-        Document should be a list of (word) tokens.
+        Parameters
+        ----------
+        doc_words : :obj: `list` of :obj: `str`
+            Document should be a list of (word) tokens.
+        alpha : float
+            The initial learning rate.
+        min_alpha : float
+            Learning rate will linearly drop to `min_alpha` as training progresses.
+        steps : int
+            Number of times to train the new document.
+
+        Returns
+        -------
+        :obj: `numpy.ndarray`
+            Returns the inferred vector for the new document.
+
         """
-        doctag_vectors = empty((1, self.vector_size), dtype=REAL)
-        doctag_vectors[0] = self.seeded_vector(' '.join(doc_words))
-        doctag_locks = ones(1, dtype=REAL)
+        doctag_vectors, doctag_locks = self.trainables.get_doctag_trainables(doc_words, self.docvecs.vector_size)
         doctag_indexes = [0]
-
-        work = zeros(self.layer1_size, dtype=REAL)
+        work = zeros(self.trainables.layer1_size, dtype=REAL)
         if not self.sg:
-            neu1 = matutils.zeros_aligned(self.layer1_size, dtype=REAL)
+            neu1 = matutils.zeros_aligned(self.trainables.layer1_size, dtype=REAL)
 
         for i in range(steps):
             if self.sg:
@@ -793,12 +559,12 @@ def infer_vector(self, doc_words, alpha=0.1, min_alpha=0.0001, steps=5):
 
         return doctag_vectors[0]
 
-    def estimate_memory(self, vocab_size=None, report=None):
-        """Estimate required memory for a model using current settings."""
-        report = report or {}
-        report['doctag_lookup'] = self.docvecs.estimated_lookup_memory()
-        report['doctag_syn0'] = self.docvecs.count * self.vector_size * dtype(REAL).itemsize
-        return super(Doc2Vec, self).estimate_memory(vocab_size, report=report)
+    def __getitem__(self, tag):
+        if isinstance(tag, string_types + integer_types + (integer,)):
+            if tag not in self.wv.vocab:
+                return self.docvecs[tag]
+            return self.wv[tag]
+        return vstack([self[i] for i in tag])
 
     def __str__(self):
         """Abbreviated name reflecting major configuration paramaters."""
@@ -819,71 +585,326 @@ def __str__(self):
                     segments.append('dm/m')
                 else:
                     segments.append('dm/s')
-        segments.append('d%d' % self.vector_size)  # dimensions
+        segments.append('d%d' % self.docvecs.vector_size)  # dimensions
         if self.negative:
             segments.append('n%d' % self.negative)  # negative samples
         if self.hs:
             segments.append('hs')
         if not self.sg or (self.sg and self.dbow_words):
             segments.append('w%d' % self.window)  # window size, when relevant
-        if self.min_count > 1:
-            segments.append('mc%d' % self.min_count)
-        if self.sample > 0:
-            segments.append('s%g' % self.sample)
+        if self.vocabulary.min_count > 1:
+            segments.append('mc%d' % self.vocabulary.min_count)
+        if self.vocabulary.sample > 0:
+            segments.append('s%g' % self.vocabulary.sample)
         if self.workers > 1:
             segments.append('t%d' % self.workers)
         return '%s(%s)' % (self.__class__.__name__, ','.join(segments))
 
     def delete_temporary_training_data(self, keep_doctags_vectors=True, keep_inference=True):
-        """
-        Discard parameters that are used in training and score. Use if you're sure you're done training a model.
-        Set `keep_doctags_vectors` to False if you don't want to save doctags vectors,
-        in this case you can't to use docvecs's most_similar, similarity etc. methods.
-        Set `keep_inference` to False if you don't want to store parameters that is used for infer_vector method
+        """Discard parameters that are used in training and score. Use if you're sure you're done training a model.
+
+        Parameters
+        ----------
+        keep_doctags_vectors : bool
+            Set `keep_doctags_vectors` to False if you don't want to save doctags vectors,
+            in this case you can't to use docvecs's most_similar, similarity etc. methods.
+        keep_inference : bool
+            Set `keep_inference` to False if you don't want to store parameters that is used for infer_vector method
+
         """
         if not keep_inference:
-            self._minimize_model(False, False, False)
-        if self.docvecs and hasattr(self.docvecs, 'doctag_syn0') and not keep_doctags_vectors:
-            del self.docvecs.doctag_syn0
-        if self.docvecs and hasattr(self.docvecs, 'doctag_syn0_lockf'):
-            del self.docvecs.doctag_syn0_lockf
+            if hasattr(self.trainables, 'syn1'):
+                del self.trainables.syn1
+            if hasattr(self.trainables, 'syn1neg'):
+                del self.trainables.syn1neg
+            if hasattr(self.trainables, 'vectors_lockf'):
+                del self.trainables.vectors_lockf
+        self.model_trimmed_post_training = True
+        if self.docvecs and hasattr(self.docvecs, 'vectors_docs') and not keep_doctags_vectors:
+            del self.docvecs.vectors_docs
+        if self.docvecs and hasattr(self.trainables, 'vectors_docs_lockf'):
+            del self.trainables.vectors_docs_lockf
 
     def save_word2vec_format(self, fname, doctag_vec=False, word_vec=True, prefix='*dt_', fvocab=None, binary=False):
-        """
-        Store the input-hidden weight matrix.
-
-         `fname` is the file used to save the vectors in
-         `doctag_vec` is an optional boolean indicating whether to store document vectors
-         `word_vec` is an optional boolean indicating whether to store word vectors
-         (if both doctag_vec and word_vec are True, then both vectors are stored in the same file)
-         `prefix` to uniquely identify doctags from word vocab, and avoid collision
-         in case of repeated string in doctag and word vocab
-         `fvocab` is an optional file used to save the vocabulary
-         `binary` is an optional boolean indicating whether the data is to be saved
-         in binary word2vec format (default: False)
+        """Store the input-hidden weight matrix in the same format used by the original
+        C word2vec-tool, for compatibility.
+
+        Parameters
+        ----------
+        fname : str
+            The file path used to save the vectors in.
+        doctag_vec : bool
+            Indicates whether to store document vectors.
+        word_vec : bool
+            Indicates whether to store word vectors.
+        prefix : str
+            Uniquely identifies doctags from word vocab, and avoids collision
+            in case of repeated string in doctag and word vocab.
+        fvocab : str
+            Optional file path used to save the vocabulary
+        binary : bool
+            If True, the data wil be saved in binary word2vec format, else it will be saved in plain text.
 
         """
         total_vec = len(self.wv.vocab) + len(self.docvecs)
+        write_first_line = False
         # save word vectors
         if word_vec:
             if not doctag_vec:
                 total_vec = len(self.wv.vocab)
-            KeyedVectors.save_word2vec_format(self.wv, fname, fvocab, binary, total_vec)
+            self.wv.save_word2vec_format(fname, fvocab, binary, total_vec)
         # save document vectors
         if doctag_vec:
-            with utils.smart_open(fname, 'ab') as fout:
-                if not word_vec:
-                    total_vec = len(self.docvecs)
-                    logger.info("storing %sx%s projection weights into %s", total_vec, self.vector_size, fname)
-                    fout.write(utils.to_utf8("%s %s\n" % (total_vec, self.vector_size)))
-                # store as in input order
-                for i in range(len(self.docvecs)):
-                    doctag = u"%s%s" % (prefix, self.docvecs.index_to_doctag(i))
-                    row = self.docvecs.doctag_syn0[i]
-                    if binary:
-                        fout.write(utils.to_utf8(doctag) + b" " + row.tostring())
-                    else:
-                        fout.write(utils.to_utf8("%s %s\n" % (doctag, ' '.join("%f" % val for val in row))))
+            if not word_vec:
+                total_vec = len(self.docvecs)
+                write_first_line = True
+            self.docvecs.save_word2vec_format(
+                fname, prefix=prefix, fvocab=fvocab, total_vec=total_vec,
+                binary=binary, write_first_line=write_first_line)
+
+    def init_sims(self, 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 or inference** after doing a replace.
+        The model becomes effectively read-only = you can call `most_similar`, `similarity`
+        etc., but not `train` or `infer_vector`.
+
+        """
+        return self.docvecs.init_sims(replace=replace)
+
+    @classmethod
+    def load(cls, *args, **kwargs):
+        try:
+            return super(Doc2Vec, cls).load(*args, **kwargs)
+        except AttributeError:
+            logger.info('Model saved using code from earlier Gensim Version. Re-loading old model in a compatible way.')
+            from gensim.models.deprecated.doc2vec import load_old_doc2vec
+            return load_old_doc2vec(*args, **kwargs)
+
+    def estimate_memory(self, vocab_size=None, report=None):
+        """Estimate required memory for a model using current settings."""
+        report = report or {}
+        report['doctag_lookup'] = self.estimated_lookup_memory()
+        report['doctag_syn0'] = self.docvecs.count * self.vector_size * dtype(REAL).itemsize
+        return super(Doc2Vec, self).estimate_memory(vocab_size, report=report)
+
+    def build_vocab(self, documents, update=False, progress_per=10000, keep_raw_vocab=False, trim_rule=None, **kwargs):
+        """Build vocabulary from a sequence of sentences (can be a once-only generator stream).
+        Each sentence is a iterable of iterables (can simply be a list of unicode strings too).
+
+        Parameters
+        ----------
+        documents : iterable of iterables
+            The `documents` iterable can be simply a list of TaggedDocument elements, but for larger corpora,
+            consider an iterable that streams the documents directly from disk/network.
+            See :class:`~gensim.models.doc2vec.TaggedBrownCorpus` or :class:`~gensim.models.doc2vec.TaggedLineDocument`
+            in :mod:`~gensim.models.doc2vec` module for such examples.
+        keep_raw_vocab : bool
+            If not true, delete the raw vocabulary after the scaling is done and free up RAM.
+        trim_rule : function
+            Vocabulary trimming rule, specifies whether certain words should remain in the vocabulary,
+            be trimmed away, or handled using the default (discard if word count < min_count).
+            Can be None (min_count will be used, look to :func:`~gensim.utils.keep_vocab_item`),
+            or a callable that accepts parameters (word, count, min_count) and returns either
+            :attr:`gensim.utils.RULE_DISCARD`, :attr:`gensim.utils.RULE_KEEP` or :attr:`gensim.utils.RULE_DEFAULT`.
+            Note: The rule, if given, is only used to prune vocabulary during build_vocab() and is not stored as part
+            of the model.
+        progress_per : int
+            Indicates how many words to process before showing/updating the progress.
+        update : bool
+            If true, the new words in `sentences` will be added to model's vocab.
+        """
+        total_words, corpus_count = self.vocabulary.scan_vocab(
+            documents, self.docvecs, progress_per=progress_per, trim_rule=trim_rule)
+        self.corpus_count = corpus_count
+        report_values = self.vocabulary.prepare_vocab(
+            self.hs, self.negative, self.wv, update=update, keep_raw_vocab=keep_raw_vocab, trim_rule=trim_rule,
+            **kwargs)
+
+        report_values['memory'] = self.estimate_memory(vocab_size=report_values['num_retained_words'])
+        self.trainables.prepare_weights(
+            self.hs, self.negative, self.wv, self.docvecs, update=update)
+
+    def build_vocab_from_freq(self, word_freq, keep_raw_vocab=False, corpus_count=None, trim_rule=None, update=False):
+        """
+        Build vocabulary from a dictionary of word frequencies.
+        Build model vocabulary from a passed dictionary that contains (word,word count).
+        Words must be of type unicode strings.
+
+        Parameters
+        ----------
+        word_freq : dict
+            Word,Word_Count dictionary.
+        keep_raw_vocab : bool
+            If not true, delete the raw vocabulary after the scaling is done and free up RAM.
+        corpus_count : int
+            Even if no corpus is provided, this argument can set corpus_count explicitly.
+        trim_rule : function
+            Vocabulary trimming rule, specifies whether certain words should remain in the vocabulary,
+            be trimmed away, or handled using the default (discard if word count < min_count).
+            Can be None (min_count will be used, look to :func:`~gensim.utils.keep_vocab_item`),
+            or a callable that accepts parameters (word, count, min_count) and returns either
+            :attr:`gensim.utils.RULE_DISCARD`, :attr:`gensim.utils.RULE_KEEP` or :attr:`gensim.utils.RULE_DEFAULT`.
+            Note: The rule, if given, is only used to prune vocabulary during build_vocab() and is not stored as part
+            of the model.
+        update : bool
+            If true, the new provided words in `word_freq` dict will be added to model's vocab.
+
+        Examples
+        --------
+        >>> from gensim.models.word2vec import Word2Vec
+        >>> model= Word2Vec()
+        >>> model.build_vocab_from_freq({"Word1": 15, "Word2": 20})
+        """
+        logger.info("Processing provided word frequencies")
+        # Instead of scanning text, this will assign provided word frequencies dictionary(word_freq)
+        # to be directly the raw vocab
+        raw_vocab = word_freq
+        logger.info(
+            "collected %i different raw word, with total frequency of %i",
+            len(raw_vocab), sum(itervalues(raw_vocab))
+        )
+
+        # Since no sentences are provided, this is to control the corpus_count
+        self.corpus_count = corpus_count or 0
+        self.vocabulary.raw_vocab = raw_vocab
+
+        # trim by min_count & precalculate downsampling
+        report_values = self.vocabulary.prepare_vocab(
+            self.hs, self.negative, self.wv, keep_raw_vocab=keep_raw_vocab,
+            trim_rule=trim_rule, update=update)
+        report_values['memory'] = self.estimate_memory(vocab_size=report_values['num_retained_words'])
+        self.trainables.prepare_weights(
+            self.hs, self.negative, self.wv, self.docvecs, update=update)
+
+
+class Doc2VecVocab(Word2VecVocab):
+    def __init__(self, max_vocab_size=None, min_count=5, sample=1e-3, sorted_vocab=True, null_word=0):
+        super(Doc2VecVocab, self).__init__(
+            max_vocab_size=max_vocab_size, min_count=min_count, sample=sample,
+            sorted_vocab=sorted_vocab, null_word=null_word)
+
+    def scan_vocab(self, documents, docvecs, progress_per=10000, trim_rule=None):
+        logger.info("collecting all words and their counts")
+        document_no = -1
+        total_words = 0
+        min_reduce = 1
+        interval_start = default_timer() - 0.00001  # guard against next sample being identical
+        interval_count = 0
+        checked_string_types = 0
+        vocab = defaultdict(int)
+        for document_no, document in enumerate(documents):
+            if not checked_string_types:
+                if isinstance(document.words, string_types):
+                    logger.warning(
+                        "Each 'words' should be a list of words (usually unicode strings). "
+                        "First 'words' here is instead plain %s.",
+                        type(document.words)
+                    )
+                checked_string_types += 1
+            if document_no % progress_per == 0:
+                interval_rate = (total_words - interval_count) / (default_timer() - interval_start)
+                logger.info(
+                    "PROGRESS: at example #%i, processed %i words (%i/s), %i word types, %i tags",
+                    document_no, total_words, interval_rate, len(vocab), docvecs.count
+                )
+                interval_start = default_timer()
+                interval_count = total_words
+            document_length = len(document.words)
+
+            for tag in document.tags:
+                self.note_doctag(tag, document_no, document_length, docvecs)
+
+            for word in document.words:
+                vocab[word] += 1
+            total_words += len(document.words)
+
+            if self.max_vocab_size and len(vocab) > self.max_vocab_size:
+                utils.prune_vocab(vocab, min_reduce, trim_rule=trim_rule)
+                min_reduce += 1
+
+        logger.info(
+            "collected %i word types and %i unique tags from a corpus of %i examples and %i words",
+            len(vocab), docvecs.count, document_no + 1, total_words
+        )
+        corpus_count = document_no + 1
+        self.raw_vocab = vocab
+        return total_words, corpus_count
+
+    def note_doctag(self, key, document_no, document_length, docvecs):
+        """Note a document tag during initial corpus scan, for structure sizing."""
+        if isinstance(key, integer_types + (integer,)):
+            docvecs.max_rawint = max(docvecs.max_rawint, key)
+        else:
+            if key in docvecs.doctags:
+                docvecs.doctags[key] = docvecs.doctags[key].repeat(document_length)
+            else:
+                docvecs.doctags[key] = Doctag(len(docvecs.offset2doctag), document_length, 1)
+                docvecs.offset2doctag.append(key)
+        docvecs.count = docvecs.max_rawint + 1 + len(docvecs.offset2doctag)
+
+    def indexed_doctags(self, doctag_tokens, docvecs):
+        """Return indexes and backing-arrays used in training examples."""
+        return [
+            Doc2VecKeyedVectors._int_index(index, docvecs.doctags, docvecs.max_rawint)
+            for index in doctag_tokens if self._tag_seen(index, docvecs)]
+
+    def _tag_seen(self, index, docvecs):
+        if isinstance(index, integer_types + (integer,)):
+            return index < docvecs.count
+        else:
+            return index in docvecs.doctags
+
+
+class Doc2VecTrainables(Word2VecTrainables):
+    def __init__(self, dm=1, dm_concat=0, dm_tag_count=1, vector_size=100, seed=1, hashfxn=hash, window=5):
+        super(Doc2VecTrainables, self).__init__(
+            vector_size=vector_size, seed=seed, hashfxn=hashfxn)
+        if dm and dm_concat:
+            self.layer1_size = (dm_tag_count + (2 * window)) * vector_size
+            logger.info("using concatenative %d-dimensional layer1", self.layer1_size)
+
+    def prepare_weights(self, hs, negative, wv, docvecs, update=False):
+        """Build tables and model weights based on final vocabulary settings."""
+        # set initial input/projection and hidden weights
+        if not update:
+            self.reset_weights(hs, negative, wv, docvecs)
+        else:
+            self.update_weights(hs, negative, wv)
+
+    def reset_weights(self, hs, negative, wv, docvecs, vocabulary=None):
+        super(Doc2VecTrainables, self).reset_weights(hs, negative, wv)
+        self.reset_doc_weights(docvecs)
+
+    def reset_doc_weights(self, docvecs):
+        length = max(len(docvecs.doctags), docvecs.count)
+        if docvecs.mapfile_path:
+            docvecs.vectors_docs = np_memmap(
+                docvecs.mapfile_path + '.vectors_docs', dtype=REAL, mode='w+', shape=(length, docvecs.vector_size)
+            )
+            self.vectors_docs_lockf = np_memmap(
+                docvecs.mapfile_path + '.vectors_docs_lockf', dtype=REAL, mode='w+', shape=(length,)
+            )
+            self.vectors_docs_lockf.fill(1.0)
+        else:
+            docvecs.vectors_docs = empty((length, docvecs.vector_size), dtype=REAL)
+            self.vectors_docs_lockf = ones((length,), dtype=REAL)  # zeros suppress learning
+
+        for i in xrange(length):
+            # construct deterministic seed from index AND model seed
+            seed = "%d %s" % (
+                self.seed, Doc2VecKeyedVectors._index_to_doctag(i, docvecs.offset2doctag, docvecs.max_rawint))
+            docvecs.vectors_docs[i] = self.seeded_vector(seed, docvecs.vector_size)
+
+    def get_doctag_trainables(self, doc_words, vector_size):
+        doctag_vectors = zeros((1, vector_size), dtype=REAL)
+        doctag_vectors[0] = self.seeded_vector(' '.join(doc_words), vector_size)
+        doctag_locks = ones(1, dtype=REAL)
+        return doctag_vectors, doctag_locks
 
 
 class TaggedBrownCorpus(object):
diff --git a/gensim/models/doc2vec_inner.c b/gensim/models/doc2vec_inner.c
index d5638cba20..fbdc47e657 100644
--- a/gensim/models/doc2vec_inner.c
+++ b/gensim/models/doc2vec_inner.c
@@ -1505,7 +1505,6 @@ static const char __pyx_k_item[] = "item";
 static const char __pyx_k_main[] = "__main__";
 static const char __pyx_k_neu1[] = "neu1";
 static const char __pyx_k_size[] = "size";
-static const char __pyx_k_syn0[] = "syn0";
 static const char __pyx_k_syn1[] = "syn1";
 static const char __pyx_k_test[] = "__test__";
 static const char __pyx_k_work[] = "work";
@@ -1536,6 +1535,7 @@ static const char __pyx_k_float32[] = "float32";
 static const char __pyx_k_indexes[] = "indexes";
 static const char __pyx_k_randint[] = "randint";
 static const char __pyx_k_syn1neg[] = "syn1neg";
+static const char __pyx_k_vectors[] = "vectors";
 static const char __pyx_k_vlookup[] = "vlookup";
 static const char __pyx_k_codelens[] = "codelens";
 static const char __pyx_k_negative[] = "negative";
@@ -1548,10 +1548,10 @@ static const char __pyx_k_inv_count[] = "inv_count";
 static const char __pyx_k_ValueError[] = "ValueError";
 static const char __pyx_k_doctag_len[] = "doctag_len";
 static const char __pyx_k_sample_int[] = "sample_int";
-static const char __pyx_k_syn0_lockf[] = "syn0_lockf";
+static const char __pyx_k_trainables[] = "trainables";
+static const char __pyx_k_vocabulary[] = "vocabulary";
 static const char __pyx_k_word_locks[] = "word_locks";
 static const char __pyx_k_ImportError[] = "ImportError";
-static const char __pyx_k_doctag_syn0[] = "doctag_syn0";
 static const char __pyx_k_layer1_size[] = "layer1_size";
 static const char __pyx_k_learn_words[] = "learn_words";
 static const char __pyx_k_next_random[] = "next_random";
@@ -1564,12 +1564,14 @@ static const char __pyx_k_doctag_locks[] = "doctag_locks";
 static const char __pyx_k_document_len[] = "document_len";
 static const char __pyx_k_learn_hidden[] = "learn_hidden";
 static const char __pyx_k_predict_word[] = "predict_word";
+static const char __pyx_k_vectors_docs[] = "vectors_docs";
 static const char __pyx_k_word_locks_2[] = "_word_locks";
 static const char __pyx_k_word_vectors[] = "word_vectors";
 static const char __pyx_k_cum_table_len[] = "cum_table_len";
 static const char __pyx_k_learn_doctags[] = "learn_doctags";
 static const char __pyx_k_learn_words_2[] = "_learn_words";
 static const char __pyx_k_train_words_2[] = "_train_words";
+static const char __pyx_k_vectors_lockf[] = "vectors_lockf";
 static const char __pyx_k_doctag_indexes[] = "doctag_indexes";
 static const char __pyx_k_doctag_locks_2[] = "_doctag_locks";
 static const char __pyx_k_doctag_vectors[] = "doctag_vectors";
@@ -1581,9 +1583,9 @@ static const char __pyx_k_null_word_index[] = "null_word_index";
 static const char __pyx_k_reduced_windows[] = "reduced_windows";
 static const char __pyx_k_doctag_indexes_2[] = "_doctag_indexes";
 static const char __pyx_k_doctag_vectors_2[] = "_doctag_vectors";
-static const char __pyx_k_doctag_syn0_lockf[] = "doctag_syn0_lockf";
 static const char __pyx_k_scipy_linalg_blas[] = "scipy.linalg.blas";
 static const char __pyx_k_train_document_dm[] = "train_document_dm";
+static const char __pyx_k_vectors_docs_lockf[] = "vectors_docs_lockf";
 static const char __pyx_k_expected_doctag_len[] = "expected_doctag_len";
 static const char __pyx_k_train_document_dbow[] = "train_document_dbow";
 static const char __pyx_k_train_document_dm_concat[] = "train_document_dm_concat";
@@ -1623,8 +1625,6 @@ static PyObject *__pyx_n_s_doctag_indexes_2;
 static PyObject *__pyx_n_s_doctag_len;
 static PyObject *__pyx_n_s_doctag_locks;
 static PyObject *__pyx_n_s_doctag_locks_2;
-static PyObject *__pyx_n_s_doctag_syn0;
-static PyObject *__pyx_n_s_doctag_syn0_lockf;
 static PyObject *__pyx_n_s_doctag_vectors;
 static PyObject *__pyx_n_s_doctag_vectors_2;
 static PyObject *__pyx_n_s_document_len;
@@ -1680,8 +1680,6 @@ static PyObject *__pyx_n_s_sample;
 static PyObject *__pyx_n_s_sample_int;
 static PyObject *__pyx_n_s_scipy_linalg_blas;
 static PyObject *__pyx_n_s_size;
-static PyObject *__pyx_n_s_syn0;
-static PyObject *__pyx_n_s_syn0_lockf;
 static PyObject *__pyx_n_s_syn1;
 static PyObject *__pyx_n_s_syn1neg;
 static PyObject *__pyx_n_s_test;
@@ -1691,10 +1689,16 @@ static PyObject *__pyx_n_s_train_document_dm;
 static PyObject *__pyx_n_s_train_document_dm_concat;
 static PyObject *__pyx_n_s_train_words;
 static PyObject *__pyx_n_s_train_words_2;
+static PyObject *__pyx_n_s_trainables;
 static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
 static PyObject *__pyx_n_s_vector_size;
+static PyObject *__pyx_n_s_vectors;
+static PyObject *__pyx_n_s_vectors_docs;
+static PyObject *__pyx_n_s_vectors_docs_lockf;
+static PyObject *__pyx_n_s_vectors_lockf;
 static PyObject *__pyx_n_s_vlookup;
 static PyObject *__pyx_n_s_vocab;
+static PyObject *__pyx_n_s_vocabulary;
 static PyObject *__pyx_n_s_window;
 static PyObject *__pyx_n_s_window_indexes;
 static PyObject *__pyx_n_s_word2vec;
@@ -3369,7 +3373,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
  *                         word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
  *     cdef int hs = model.hs             # <<<<<<<<<<<<<<
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_hs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
@@ -3381,7 +3385,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
  *                         word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative             # <<<<<<<<<<<<<<
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int _train_words = train_words
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_negative); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error)
@@ -3393,21 +3397,24 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
   /* "gensim/models/doc2vec_inner.pyx":232
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)             # <<<<<<<<<<<<<<
+ *     cdef int sample = (model.vocabulary.sample != 0)             # <<<<<<<<<<<<<<
  *     cdef int _train_words = train_words
  *     cdef int _learn_words = learn_words
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_sample); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sample); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 232, __pyx_L1_error)
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 232, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 232, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_sample = __pyx_t_2;
 
   /* "gensim/models/doc2vec_inner.pyx":233
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int _train_words = train_words             # <<<<<<<<<<<<<<
  *     cdef int _learn_words = learn_words
  *     cdef int _learn_hidden = learn_hidden
@@ -3416,7 +3423,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
   __pyx_v__train_words = __pyx_t_2;
 
   /* "gensim/models/doc2vec_inner.pyx":234
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int _train_words = train_words
  *     cdef int _learn_words = learn_words             # <<<<<<<<<<<<<<
  *     cdef int _learn_hidden = learn_hidden
@@ -3449,7 +3456,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
  *     cdef REAL_t *_doctag_locks
  *     cdef REAL_t *_work
  *     cdef REAL_t _alpha = alpha             # <<<<<<<<<<<<<<
- *     cdef int size = model.layer1_size
+ *     cdef int size = model.trainables.layer1_size
  * 
  */
   __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_v_alpha); if (unlikely((__pyx_t_4 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 243, __pyx_L1_error)
@@ -3458,12 +3465,15 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
   /* "gensim/models/doc2vec_inner.pyx":244
  *     cdef REAL_t *_work
  *     cdef REAL_t _alpha = alpha
- *     cdef int size = model.layer1_size             # <<<<<<<<<<<<<<
+ *     cdef int size = model.trainables.layer1_size             # <<<<<<<<<<<<<<
  * 
  *     cdef int codelens[MAX_DOCUMENT_LEN]
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 244, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_size = __pyx_t_2;
@@ -3494,7 +3504,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
  * 
  *     # default vectors, locks from syn0/doctag_syn0
  *     if word_vectors is None:             # <<<<<<<<<<<<<<
- *        word_vectors = model.wv.syn0
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  */
   __pyx_t_5 = (__pyx_v_word_vectors == Py_None);
@@ -3504,13 +3514,13 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
     /* "gensim/models/doc2vec_inner.pyx":271
  *     # default vectors, locks from syn0/doctag_syn0
  *     if word_vectors is None:
- *        word_vectors = model.wv.syn0             # <<<<<<<<<<<<<<
+ *        word_vectors = model.wv.vectors             # <<<<<<<<<<<<<<
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:
  */
     __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 271, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 271, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 271, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF_SET(__pyx_v_word_vectors, __pyx_t_1);
@@ -3520,26 +3530,26 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
  * 
  *     # default vectors, locks from syn0/doctag_syn0
  *     if word_vectors is None:             # <<<<<<<<<<<<<<
- *        word_vectors = model.wv.syn0
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  */
   }
 
   /* "gensim/models/doc2vec_inner.pyx":272
  *     if word_vectors is None:
- *        word_vectors = model.wv.syn0
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))             # <<<<<<<<<<<<<<
  *     if doctag_vectors is None:
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  */
   if (!(likely(((__pyx_v_word_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 272, __pyx_L1_error)
   __pyx_v__word_vectors = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_word_vectors)));
 
   /* "gensim/models/doc2vec_inner.pyx":273
- *        word_vectors = model.wv.syn0
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:             # <<<<<<<<<<<<<<
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  */
   __pyx_t_6 = (__pyx_v_doctag_vectors == Py_None);
@@ -3549,42 +3559,42 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
     /* "gensim/models/doc2vec_inner.pyx":274
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:
- *        doctag_vectors = model.docvecs.doctag_syn0             # <<<<<<<<<<<<<<
+ *        doctag_vectors = model.docvecs.vectors_docs             # <<<<<<<<<<<<<<
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:
  */
     __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_docvecs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 274, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_doctag_syn0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_docs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_DECREF_SET(__pyx_v_doctag_vectors, __pyx_t_3);
     __pyx_t_3 = 0;
 
     /* "gensim/models/doc2vec_inner.pyx":273
- *        word_vectors = model.wv.syn0
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:             # <<<<<<<<<<<<<<
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  */
   }
 
   /* "gensim/models/doc2vec_inner.pyx":275
  *     if doctag_vectors is None:
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))             # <<<<<<<<<<<<<<
  *     if word_locks is None:
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  */
   if (!(likely(((__pyx_v_doctag_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_doctag_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 275, __pyx_L1_error)
   __pyx_v__doctag_vectors = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_doctag_vectors)));
 
   /* "gensim/models/doc2vec_inner.pyx":276
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:             # <<<<<<<<<<<<<<
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  */
   __pyx_t_5 = (__pyx_v_word_locks == Py_None);
@@ -3594,39 +3604,42 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
     /* "gensim/models/doc2vec_inner.pyx":277
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:
- *        word_locks = model.syn0_lockf             # <<<<<<<<<<<<<<
+ *        word_locks = model.trainables.vectors_lockf             # <<<<<<<<<<<<<<
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn0_lockf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 277, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 277, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF_SET(__pyx_v_word_locks, __pyx_t_3);
-    __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 277, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF_SET(__pyx_v_word_locks, __pyx_t_1);
+    __pyx_t_1 = 0;
 
     /* "gensim/models/doc2vec_inner.pyx":276
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:             # <<<<<<<<<<<<<<
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  */
   }
 
   /* "gensim/models/doc2vec_inner.pyx":278
  *     if word_locks is None:
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))             # <<<<<<<<<<<<<<
  *     if doctag_locks is None:
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *        doctag_locks = model.trainables.vectors_docs_lockf
  */
   if (!(likely(((__pyx_v_word_locks) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_locks, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 278, __pyx_L1_error)
   __pyx_v__word_locks = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_word_locks)));
 
   /* "gensim/models/doc2vec_inner.pyx":279
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:             # <<<<<<<<<<<<<<
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *        doctag_locks = model.trainables.vectors_docs_lockf
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  */
   __pyx_t_6 = (__pyx_v_doctag_locks == Py_None);
@@ -3636,30 +3649,30 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
     /* "gensim/models/doc2vec_inner.pyx":280
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:
- *        doctag_locks = model.docvecs.doctag_syn0_lockf             # <<<<<<<<<<<<<<
+ *        doctag_locks = model.trainables.vectors_docs_lockf             # <<<<<<<<<<<<<<
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  * 
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_docvecs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_doctag_syn0_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 280, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 280, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_DECREF_SET(__pyx_v_doctag_locks, __pyx_t_1);
-    __pyx_t_1 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_docs_lockf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF_SET(__pyx_v_doctag_locks, __pyx_t_3);
+    __pyx_t_3 = 0;
 
     /* "gensim/models/doc2vec_inner.pyx":279
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:             # <<<<<<<<<<<<<<
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *        doctag_locks = model.trainables.vectors_docs_lockf
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  */
   }
 
   /* "gensim/models/doc2vec_inner.pyx":281
  *     if doctag_locks is None:
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *        doctag_locks = model.trainables.vectors_docs_lockf
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))             # <<<<<<<<<<<<<<
  * 
  *     if hs:
@@ -3671,7 +3684,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   __pyx_t_5 = (__pyx_v_hs != 0);
@@ -3680,12 +3693,15 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
     /* "gensim/models/doc2vec_inner.pyx":284
  * 
  *     if hs:
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))             # <<<<<<<<<<<<<<
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))             # <<<<<<<<<<<<<<
  * 
  *     if negative:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 284, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 284, __pyx_L1_error)
     __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -3694,17 +3710,17 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   }
 
   /* "gensim/models/doc2vec_inner.pyx":286
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   __pyx_t_5 = (__pyx_v_negative != 0);
   if (__pyx_t_5) {
@@ -3712,54 +3728,63 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
     /* "gensim/models/doc2vec_inner.pyx":287
  * 
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))             # <<<<<<<<<<<<<<
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))             # <<<<<<<<<<<<<<
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 287, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 287, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 287, __pyx_L1_error)
-    __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 287, __pyx_L1_error)
+    __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
     /* "gensim/models/doc2vec_inner.pyx":288
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))             # <<<<<<<<<<<<<<
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))             # <<<<<<<<<<<<<<
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 288, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 288, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 288, __pyx_L1_error)
     __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
     /* "gensim/models/doc2vec_inner.pyx":289
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)             # <<<<<<<<<<<<<<
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)             # <<<<<<<<<<<<<<
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 289, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 289, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_7 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 289, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 289, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_7 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 289, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_v_cum_table_len = __pyx_t_7;
 
     /* "gensim/models/doc2vec_inner.pyx":286
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   }
 
   /* "gensim/models/doc2vec_inner.pyx":290
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -3776,42 +3801,42 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
   if (__pyx_t_5) {
 
     /* "gensim/models/doc2vec_inner.pyx":291
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_randint); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
+    __pyx_t_1 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_randint); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 291, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 291, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 291, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 291, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __pyx_t_8 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 291, __pyx_L1_error)
+    __pyx_t_8 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 291, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_t_9 = __Pyx_PyInt_As_unsigned_PY_LONG_LONG(__pyx_t_8); if (unlikely((__pyx_t_9 == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 291, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
     __pyx_v_next_random = __pyx_t_9;
 
     /* "gensim/models/doc2vec_inner.pyx":290
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -3822,7 +3847,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  *     if work is None:             # <<<<<<<<<<<<<<
- *        work = zeros(model.layer1_size, dtype=REAL)
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  */
   __pyx_t_5 = (__pyx_v_work == Py_None);
@@ -3832,14 +3857,17 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
     /* "gensim/models/doc2vec_inner.pyx":295
  *     # convert Python structures to primitive types, so we can release the GIL
  *     if work is None:
- *        work = zeros(model.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  * 
  */
     __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_zeros); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 295, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 295, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 295, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_GIVEREF(__pyx_t_1);
@@ -3863,14 +3891,14 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_train_document_dbow(CY
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  *     if work is None:             # <<<<<<<<<<<<<<
- *        work = zeros(model.layer1_size, dtype=REAL)
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  */
   }
 
   /* "gensim/models/doc2vec_inner.pyx":296
  *     if work is None:
- *        work = zeros(model.layer1_size, dtype=REAL)
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)             # <<<<<<<<<<<<<<
  * 
  *     vlookup = model.wv.vocab
@@ -5011,7 +5039,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  *                       word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
  *     cdef int hs = model.hs             # <<<<<<<<<<<<<<
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_hs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 366, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
@@ -5023,7 +5051,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  *                       word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative             # <<<<<<<<<<<<<<
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int _learn_doctags = learn_doctags
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_negative); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 367, __pyx_L1_error)
@@ -5035,21 +5063,24 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
   /* "gensim/models/doc2vec_inner.pyx":368
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)             # <<<<<<<<<<<<<<
+ *     cdef int sample = (model.vocabulary.sample != 0)             # <<<<<<<<<<<<<<
  *     cdef int _learn_doctags = learn_doctags
  *     cdef int _learn_words = learn_words
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_sample); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 368, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 368, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 368, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sample); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 368, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 368, __pyx_L1_error)
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 368, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 368, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_sample = __pyx_t_2;
 
   /* "gensim/models/doc2vec_inner.pyx":369
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int _learn_doctags = learn_doctags             # <<<<<<<<<<<<<<
  *     cdef int _learn_words = learn_words
  *     cdef int _learn_hidden = learn_hidden
@@ -5058,7 +5089,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
   __pyx_v__learn_doctags = __pyx_t_2;
 
   /* "gensim/models/doc2vec_inner.pyx":370
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int _learn_doctags = learn_doctags
  *     cdef int _learn_words = learn_words             # <<<<<<<<<<<<<<
  *     cdef int _learn_hidden = learn_hidden
@@ -5084,10 +5115,10 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  *     cdef REAL_t count, inv_count = 1.0
  * 
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cbow_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 372, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 372, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cbow_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 372, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 372, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_cbow_mean = __pyx_t_2;
 
   /* "gensim/models/doc2vec_inner.pyx":373
@@ -5103,7 +5134,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  *     cdef REAL_t *_work
  *     cdef REAL_t *_neu1
  *     cdef REAL_t _alpha = alpha             # <<<<<<<<<<<<<<
- *     cdef int size = model.layer1_size
+ *     cdef int size = model.trainables.layer1_size
  * 
  */
   __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_v_alpha); if (unlikely((__pyx_t_4 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 381, __pyx_L1_error)
@@ -5112,12 +5143,15 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
   /* "gensim/models/doc2vec_inner.pyx":382
  *     cdef REAL_t *_neu1
  *     cdef REAL_t _alpha = alpha
- *     cdef int size = model.layer1_size             # <<<<<<<<<<<<<<
+ *     cdef int size = model.trainables.layer1_size             # <<<<<<<<<<<<<<
  * 
  *     cdef int codelens[MAX_DOCUMENT_LEN]
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 382, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 382, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 382, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 382, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_size = __pyx_t_2;
@@ -5144,276 +5178,291 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
   __pyx_v_result = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":407
+  /* "gensim/models/doc2vec_inner.pyx":408
  * 
  *     # default vectors, locks from syn0/doctag_syn0
  *     if word_vectors is None:             # <<<<<<<<<<<<<<
- *        word_vectors = model.wv.syn0
+ *         word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  */
   __pyx_t_5 = (__pyx_v_word_vectors == Py_None);
   __pyx_t_6 = (__pyx_t_5 != 0);
   if (__pyx_t_6) {
 
-    /* "gensim/models/doc2vec_inner.pyx":408
+    /* "gensim/models/doc2vec_inner.pyx":409
  *     # default vectors, locks from syn0/doctag_syn0
  *     if word_vectors is None:
- *        word_vectors = model.wv.syn0             # <<<<<<<<<<<<<<
+ *         word_vectors = model.wv.vectors             # <<<<<<<<<<<<<<
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 408, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 409, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 408, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 409, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF_SET(__pyx_v_word_vectors, __pyx_t_1);
     __pyx_t_1 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":407
+    /* "gensim/models/doc2vec_inner.pyx":408
  * 
  *     # default vectors, locks from syn0/doctag_syn0
  *     if word_vectors is None:             # <<<<<<<<<<<<<<
- *        word_vectors = model.wv.syn0
+ *         word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":409
+  /* "gensim/models/doc2vec_inner.pyx":410
  *     if word_vectors is None:
- *        word_vectors = model.wv.syn0
+ *         word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))             # <<<<<<<<<<<<<<
  *     if doctag_vectors is None:
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *         doctag_vectors = model.docvecs.vectors_docs
  */
-  if (!(likely(((__pyx_v_word_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 409, __pyx_L1_error)
+  if (!(likely(((__pyx_v_word_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 410, __pyx_L1_error)
   __pyx_v__word_vectors = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_word_vectors)));
 
-  /* "gensim/models/doc2vec_inner.pyx":410
- *        word_vectors = model.wv.syn0
+  /* "gensim/models/doc2vec_inner.pyx":411
+ *         word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:             # <<<<<<<<<<<<<<
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *         doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  */
   __pyx_t_6 = (__pyx_v_doctag_vectors == Py_None);
   __pyx_t_5 = (__pyx_t_6 != 0);
   if (__pyx_t_5) {
 
-    /* "gensim/models/doc2vec_inner.pyx":411
+    /* "gensim/models/doc2vec_inner.pyx":412
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:
- *        doctag_vectors = model.docvecs.doctag_syn0             # <<<<<<<<<<<<<<
+ *         doctag_vectors = model.docvecs.vectors_docs             # <<<<<<<<<<<<<<
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_docvecs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 411, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_docvecs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 412, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_doctag_syn0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 411, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_docs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 412, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_DECREF_SET(__pyx_v_doctag_vectors, __pyx_t_3);
     __pyx_t_3 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":410
- *        word_vectors = model.wv.syn0
+    /* "gensim/models/doc2vec_inner.pyx":411
+ *         word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:             # <<<<<<<<<<<<<<
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *         doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":412
+  /* "gensim/models/doc2vec_inner.pyx":413
  *     if doctag_vectors is None:
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *         doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))             # <<<<<<<<<<<<<<
  *     if word_locks is None:
- *        word_locks = model.syn0_lockf
+ *         word_locks = model.trainables.vectors_lockf
  */
-  if (!(likely(((__pyx_v_doctag_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_doctag_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 412, __pyx_L1_error)
+  if (!(likely(((__pyx_v_doctag_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_doctag_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 413, __pyx_L1_error)
   __pyx_v__doctag_vectors = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_doctag_vectors)));
 
-  /* "gensim/models/doc2vec_inner.pyx":413
- *        doctag_vectors = model.docvecs.doctag_syn0
+  /* "gensim/models/doc2vec_inner.pyx":414
+ *         doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:             # <<<<<<<<<<<<<<
- *        word_locks = model.syn0_lockf
+ *         word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  */
   __pyx_t_5 = (__pyx_v_word_locks == Py_None);
   __pyx_t_6 = (__pyx_t_5 != 0);
   if (__pyx_t_6) {
 
-    /* "gensim/models/doc2vec_inner.pyx":414
+    /* "gensim/models/doc2vec_inner.pyx":415
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:
- *        word_locks = model.syn0_lockf             # <<<<<<<<<<<<<<
+ *         word_locks = model.trainables.vectors_lockf             # <<<<<<<<<<<<<<
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn0_lockf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 414, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 415, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF_SET(__pyx_v_word_locks, __pyx_t_3);
-    __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 415, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF_SET(__pyx_v_word_locks, __pyx_t_1);
+    __pyx_t_1 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":413
- *        doctag_vectors = model.docvecs.doctag_syn0
+    /* "gensim/models/doc2vec_inner.pyx":414
+ *         doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:             # <<<<<<<<<<<<<<
- *        word_locks = model.syn0_lockf
+ *         word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":415
+  /* "gensim/models/doc2vec_inner.pyx":416
  *     if word_locks is None:
- *        word_locks = model.syn0_lockf
+ *         word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))             # <<<<<<<<<<<<<<
  *     if doctag_locks is None:
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *         doctag_locks = model.trainables.vectors_docs_lockf
  */
-  if (!(likely(((__pyx_v_word_locks) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_locks, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 415, __pyx_L1_error)
+  if (!(likely(((__pyx_v_word_locks) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_locks, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 416, __pyx_L1_error)
   __pyx_v__word_locks = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_word_locks)));
 
-  /* "gensim/models/doc2vec_inner.pyx":416
- *        word_locks = model.syn0_lockf
+  /* "gensim/models/doc2vec_inner.pyx":417
+ *         word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:             # <<<<<<<<<<<<<<
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *         doctag_locks = model.trainables.vectors_docs_lockf
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  */
   __pyx_t_6 = (__pyx_v_doctag_locks == Py_None);
   __pyx_t_5 = (__pyx_t_6 != 0);
   if (__pyx_t_5) {
 
-    /* "gensim/models/doc2vec_inner.pyx":417
+    /* "gensim/models/doc2vec_inner.pyx":418
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:
- *        doctag_locks = model.docvecs.doctag_syn0_lockf             # <<<<<<<<<<<<<<
+ *         doctag_locks = model.trainables.vectors_docs_lockf             # <<<<<<<<<<<<<<
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  * 
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_docvecs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 417, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_doctag_syn0_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 417, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_DECREF_SET(__pyx_v_doctag_locks, __pyx_t_1);
-    __pyx_t_1 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_docs_lockf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 418, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF_SET(__pyx_v_doctag_locks, __pyx_t_3);
+    __pyx_t_3 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":416
- *        word_locks = model.syn0_lockf
+    /* "gensim/models/doc2vec_inner.pyx":417
+ *         word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:             # <<<<<<<<<<<<<<
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *         doctag_locks = model.trainables.vectors_docs_lockf
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":418
+  /* "gensim/models/doc2vec_inner.pyx":419
  *     if doctag_locks is None:
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *         doctag_locks = model.trainables.vectors_docs_lockf
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))             # <<<<<<<<<<<<<<
  * 
  *     if hs:
  */
-  if (!(likely(((__pyx_v_doctag_locks) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_doctag_locks, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 418, __pyx_L1_error)
+  if (!(likely(((__pyx_v_doctag_locks) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_doctag_locks, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 419, __pyx_L1_error)
   __pyx_v__doctag_locks = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_doctag_locks)));
 
-  /* "gensim/models/doc2vec_inner.pyx":420
+  /* "gensim/models/doc2vec_inner.pyx":421
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   __pyx_t_5 = (__pyx_v_hs != 0);
   if (__pyx_t_5) {
 
-    /* "gensim/models/doc2vec_inner.pyx":421
+    /* "gensim/models/doc2vec_inner.pyx":422
  * 
  *     if hs:
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))             # <<<<<<<<<<<<<<
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))             # <<<<<<<<<<<<<<
  * 
  *     if negative:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 421, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 422, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 422, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 421, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 422, __pyx_L1_error)
     __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":420
+    /* "gensim/models/doc2vec_inner.pyx":421
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":423
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+  /* "gensim/models/doc2vec_inner.pyx":424
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   __pyx_t_5 = (__pyx_v_negative != 0);
   if (__pyx_t_5) {
 
-    /* "gensim/models/doc2vec_inner.pyx":424
+    /* "gensim/models/doc2vec_inner.pyx":425
  * 
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))             # <<<<<<<<<<<<<<
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))             # <<<<<<<<<<<<<<
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 424, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 425, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 424, __pyx_L1_error)
-    __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 425, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 425, __pyx_L1_error)
+    __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":425
+    /* "gensim/models/doc2vec_inner.pyx":426
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))             # <<<<<<<<<<<<<<
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))             # <<<<<<<<<<<<<<
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 425, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 426, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 426, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 425, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 426, __pyx_L1_error)
     __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":426
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)             # <<<<<<<<<<<<<<
+    /* "gensim/models/doc2vec_inner.pyx":427
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)             # <<<<<<<<<<<<<<
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 426, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 427, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_7 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 426, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_7 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 427, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_v_cum_table_len = __pyx_t_7;
 
-    /* "gensim/models/doc2vec_inner.pyx":423
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+    /* "gensim/models/doc2vec_inner.pyx":424
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":427
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+  /* "gensim/models/doc2vec_inner.pyx":428
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -5429,83 +5478,86 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
   __pyx_L10_bool_binop_done:;
   if (__pyx_t_5) {
 
-    /* "gensim/models/doc2vec_inner.pyx":428
- *         cum_table_len = len(model.cum_table)
+    /* "gensim/models/doc2vec_inner.pyx":429
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 428, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_randint); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 428, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 429, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 428, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 429, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 428, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 429, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 428, __pyx_L1_error)
+    __pyx_t_1 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 429, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_randint); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 428, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 429, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 429, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 428, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 429, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __pyx_t_8 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 428, __pyx_L1_error)
+    __pyx_t_8 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 429, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_9 = __Pyx_PyInt_As_unsigned_PY_LONG_LONG(__pyx_t_8); if (unlikely((__pyx_t_9 == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 428, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_9 = __Pyx_PyInt_As_unsigned_PY_LONG_LONG(__pyx_t_8); if (unlikely((__pyx_t_9 == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
     __pyx_v_next_random = __pyx_t_9;
 
-    /* "gensim/models/doc2vec_inner.pyx":427
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+    /* "gensim/models/doc2vec_inner.pyx":428
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":431
+  /* "gensim/models/doc2vec_inner.pyx":432
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  *     if work is None:             # <<<<<<<<<<<<<<
- *        work = zeros(model.layer1_size, dtype=REAL)
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  */
   __pyx_t_5 = (__pyx_v_work == Py_None);
   __pyx_t_6 = (__pyx_t_5 != 0);
   if (__pyx_t_6) {
 
-    /* "gensim/models/doc2vec_inner.pyx":432
+    /* "gensim/models/doc2vec_inner.pyx":433
  *     # convert Python structures to primitive types, so we can release the GIL
  *     if work is None:
- *        work = zeros(model.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  *     if neu1 is None:
  */
-    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_zeros); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 432, __pyx_L1_error)
+    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_zeros); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 433, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 432, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 433, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 433, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 432, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 433, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_GIVEREF(__pyx_t_1);
     PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
     __pyx_t_1 = 0;
-    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 432, __pyx_L1_error)
+    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 433, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_REAL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 432, __pyx_L1_error)
+    __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_REAL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 433, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
-    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(0, 432, __pyx_L1_error)
+    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(0, 433, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 432, __pyx_L1_error)
+    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 433, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -5513,101 +5565,104 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
     __Pyx_DECREF_SET(__pyx_v_work, __pyx_t_10);
     __pyx_t_10 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":431
+    /* "gensim/models/doc2vec_inner.pyx":432
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  *     if work is None:             # <<<<<<<<<<<<<<
- *        work = zeros(model.layer1_size, dtype=REAL)
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":433
+  /* "gensim/models/doc2vec_inner.pyx":434
  *     if work is None:
- *        work = zeros(model.layer1_size, dtype=REAL)
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)             # <<<<<<<<<<<<<<
  *     if neu1 is None:
- *        neu1 = zeros(model.layer1_size, dtype=REAL)
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
  */
-  if (!(likely(((__pyx_v_work) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_work, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 433, __pyx_L1_error)
+  if (!(likely(((__pyx_v_work) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_work, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 434, __pyx_L1_error)
   __pyx_v__work = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_work)));
 
-  /* "gensim/models/doc2vec_inner.pyx":434
- *        work = zeros(model.layer1_size, dtype=REAL)
+  /* "gensim/models/doc2vec_inner.pyx":435
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  *     if neu1 is None:             # <<<<<<<<<<<<<<
- *        neu1 = zeros(model.layer1_size, dtype=REAL)
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
  */
   __pyx_t_6 = (__pyx_v_neu1 == Py_None);
   __pyx_t_5 = (__pyx_t_6 != 0);
   if (__pyx_t_5) {
 
-    /* "gensim/models/doc2vec_inner.pyx":435
+    /* "gensim/models/doc2vec_inner.pyx":436
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  *     if neu1 is None:
- *        neu1 = zeros(model.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
  * 
  */
-    __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_zeros); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 435, __pyx_L1_error)
+    __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_zeros); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 436, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 435, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 436, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 436, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_GIVEREF(__pyx_t_1);
-    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
-    __pyx_t_1 = 0;
-    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 435, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 436, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_REAL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 435, __pyx_L1_error)
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 436, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_REAL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 436, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 435, __pyx_L1_error)
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_8) < 0) __PYX_ERR(0, 436, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 435, __pyx_L1_error)
+    __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 436, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF_SET(__pyx_v_neu1, __pyx_t_8);
     __pyx_t_8 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":434
- *        work = zeros(model.layer1_size, dtype=REAL)
+    /* "gensim/models/doc2vec_inner.pyx":435
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  *     if neu1 is None:             # <<<<<<<<<<<<<<
- *        neu1 = zeros(model.layer1_size, dtype=REAL)
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":436
+  /* "gensim/models/doc2vec_inner.pyx":437
  *     if neu1 is None:
- *        neu1 = zeros(model.layer1_size, dtype=REAL)
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)             # <<<<<<<<<<<<<<
  * 
  *     vlookup = model.wv.vocab
  */
-  if (!(likely(((__pyx_v_neu1) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_neu1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 436, __pyx_L1_error)
+  if (!(likely(((__pyx_v_neu1) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_neu1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 437, __pyx_L1_error)
   __pyx_v__neu1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_neu1)));
 
-  /* "gensim/models/doc2vec_inner.pyx":438
+  /* "gensim/models/doc2vec_inner.pyx":439
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
  * 
  *     vlookup = model.wv.vocab             # <<<<<<<<<<<<<<
  *     i = 0
  *     for token in doc_words:
  */
-  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 438, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 439, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_vocab); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 438, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_vocab); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 439, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __pyx_v_vlookup = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_v_vlookup = __pyx_t_3;
+  __pyx_t_3 = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":439
+  /* "gensim/models/doc2vec_inner.pyx":440
  * 
  *     vlookup = model.wv.vocab
  *     i = 0             # <<<<<<<<<<<<<<
@@ -5616,7 +5671,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
   __pyx_v_i = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":440
+  /* "gensim/models/doc2vec_inner.pyx":441
  *     vlookup = model.wv.vocab
  *     i = 0
  *     for token in doc_words:             # <<<<<<<<<<<<<<
@@ -5624,39 +5679,39 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  *         if predict_word is None:  # shrink document to leave out word
  */
   if (likely(PyList_CheckExact(__pyx_v_doc_words)) || PyTuple_CheckExact(__pyx_v_doc_words)) {
-    __pyx_t_1 = __pyx_v_doc_words; __Pyx_INCREF(__pyx_t_1); __pyx_t_7 = 0;
+    __pyx_t_3 = __pyx_v_doc_words; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0;
     __pyx_t_11 = NULL;
   } else {
-    __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_doc_words); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 440, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_11 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 440, __pyx_L1_error)
+    __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_doc_words); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_11 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 441, __pyx_L1_error)
   }
   for (;;) {
     if (likely(!__pyx_t_11)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_1)) break;
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_8 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_8); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 440, __pyx_L1_error)
+        __pyx_t_8 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_8); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 441, __pyx_L1_error)
         #else
-        __pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 440, __pyx_L1_error)
+        __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 441, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_8);
         #endif
       } else {
-        if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+        if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_8); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 440, __pyx_L1_error)
+        __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_8); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 441, __pyx_L1_error)
         #else
-        __pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 440, __pyx_L1_error)
+        __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 441, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_8);
         #endif
       }
     } else {
-      __pyx_t_8 = __pyx_t_11(__pyx_t_1);
+      __pyx_t_8 = __pyx_t_11(__pyx_t_3);
       if (unlikely(!__pyx_t_8)) {
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
           if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(0, 440, __pyx_L1_error)
+          else __PYX_ERR(0, 441, __pyx_L1_error)
         }
         break;
       }
@@ -5665,19 +5720,19 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
     __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_8);
     __pyx_t_8 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":441
+    /* "gensim/models/doc2vec_inner.pyx":442
  *     i = 0
  *     for token in doc_words:
  *         predict_word = vlookup[token] if token in vlookup else None             # <<<<<<<<<<<<<<
  *         if predict_word is None:  # shrink document to leave out word
  *             continue  # leaving i unchanged
  */
-    __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_token, __pyx_v_vlookup, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 441, __pyx_L1_error)
+    __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_token, __pyx_v_vlookup, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 442, __pyx_L1_error)
     if ((__pyx_t_5 != 0)) {
-      __pyx_t_3 = PyObject_GetItem(__pyx_v_vlookup, __pyx_v_token); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
-      __pyx_t_8 = __pyx_t_3;
-      __pyx_t_3 = 0;
+      __pyx_t_1 = PyObject_GetItem(__pyx_v_vlookup, __pyx_v_token); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 442, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __pyx_t_8 = __pyx_t_1;
+      __pyx_t_1 = 0;
     } else {
       __Pyx_INCREF(Py_None);
       __pyx_t_8 = Py_None;
@@ -5685,7 +5740,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
     __Pyx_XDECREF_SET(__pyx_v_predict_word, __pyx_t_8);
     __pyx_t_8 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":442
+    /* "gensim/models/doc2vec_inner.pyx":443
  *     for token in doc_words:
  *         predict_word = vlookup[token] if token in vlookup else None
  *         if predict_word is None:  # shrink document to leave out word             # <<<<<<<<<<<<<<
@@ -5696,7 +5751,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
     __pyx_t_6 = (__pyx_t_5 != 0);
     if (__pyx_t_6) {
 
-      /* "gensim/models/doc2vec_inner.pyx":443
+      /* "gensim/models/doc2vec_inner.pyx":444
  *         predict_word = vlookup[token] if token in vlookup else None
  *         if predict_word is None:  # shrink document to leave out word
  *             continue  # leaving i unchanged             # <<<<<<<<<<<<<<
@@ -5705,7 +5760,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
       goto __pyx_L14_continue;
 
-      /* "gensim/models/doc2vec_inner.pyx":442
+      /* "gensim/models/doc2vec_inner.pyx":443
  *     for token in doc_words:
  *         predict_word = vlookup[token] if token in vlookup else None
  *         if predict_word is None:  # shrink document to leave out word             # <<<<<<<<<<<<<<
@@ -5714,7 +5769,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
     }
 
-    /* "gensim/models/doc2vec_inner.pyx":444
+    /* "gensim/models/doc2vec_inner.pyx":445
  *         if predict_word is None:  # shrink document to leave out word
  *             continue  # leaving i unchanged
  *         if sample and predict_word.sample_int < random_int32(&next_random):             # <<<<<<<<<<<<<<
@@ -5727,20 +5782,20 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
       __pyx_t_6 = __pyx_t_5;
       goto __pyx_L18_bool_binop_done;
     }
-    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_sample_int); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 444, __pyx_L1_error)
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_sample_int); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 445, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __pyx_t_3 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(__pyx_f_6gensim_6models_14word2vec_inner_random_int32((&__pyx_v_next_random))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_10 = PyObject_RichCompare(__pyx_t_8, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 444, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(__pyx_f_6gensim_6models_14word2vec_inner_random_int32((&__pyx_v_next_random))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 445, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_10 = PyObject_RichCompare(__pyx_t_8, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 445, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 444, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 445, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
     __pyx_t_6 = __pyx_t_5;
     __pyx_L18_bool_binop_done:;
     if (__pyx_t_6) {
 
-      /* "gensim/models/doc2vec_inner.pyx":445
+      /* "gensim/models/doc2vec_inner.pyx":446
  *             continue  # leaving i unchanged
  *         if sample and predict_word.sample_int < random_int32(&next_random):
  *             continue             # <<<<<<<<<<<<<<
@@ -5749,7 +5804,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
       goto __pyx_L14_continue;
 
-      /* "gensim/models/doc2vec_inner.pyx":444
+      /* "gensim/models/doc2vec_inner.pyx":445
  *         if predict_word is None:  # shrink document to leave out word
  *             continue  # leaving i unchanged
  *         if sample and predict_word.sample_int < random_int32(&next_random):             # <<<<<<<<<<<<<<
@@ -5758,20 +5813,20 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
     }
 
-    /* "gensim/models/doc2vec_inner.pyx":446
+    /* "gensim/models/doc2vec_inner.pyx":447
  *         if sample and predict_word.sample_int < random_int32(&next_random):
  *             continue
  *         indexes[i] = predict_word.index             # <<<<<<<<<<<<<<
  *         if hs:
  *             codelens[i] = <int>len(predict_word.code)
  */
-    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_index); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 446, __pyx_L1_error)
+    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_index); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 447, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
-    __pyx_t_12 = __Pyx_PyInt_As_npy_uint32(__pyx_t_10); if (unlikely((__pyx_t_12 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 446, __pyx_L1_error)
+    __pyx_t_12 = __Pyx_PyInt_As_npy_uint32(__pyx_t_10); if (unlikely((__pyx_t_12 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 447, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
     (__pyx_v_indexes[__pyx_v_i]) = __pyx_t_12;
 
-    /* "gensim/models/doc2vec_inner.pyx":447
+    /* "gensim/models/doc2vec_inner.pyx":448
  *             continue
  *         indexes[i] = predict_word.index
  *         if hs:             # <<<<<<<<<<<<<<
@@ -5781,46 +5836,46 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
     __pyx_t_6 = (__pyx_v_hs != 0);
     if (__pyx_t_6) {
 
-      /* "gensim/models/doc2vec_inner.pyx":448
+      /* "gensim/models/doc2vec_inner.pyx":449
  *         indexes[i] = predict_word.index
  *         if hs:
  *             codelens[i] = <int>len(predict_word.code)             # <<<<<<<<<<<<<<
  *             codes[i] = <np.uint8_t *>np.PyArray_DATA(predict_word.code)
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)
  */
-      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_code); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 448, __pyx_L1_error)
+      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_code); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 449, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_10);
-      __pyx_t_13 = PyObject_Length(__pyx_t_10); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 448, __pyx_L1_error)
+      __pyx_t_13 = PyObject_Length(__pyx_t_10); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 449, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
       (__pyx_v_codelens[__pyx_v_i]) = ((int)__pyx_t_13);
 
-      /* "gensim/models/doc2vec_inner.pyx":449
+      /* "gensim/models/doc2vec_inner.pyx":450
  *         if hs:
  *             codelens[i] = <int>len(predict_word.code)
  *             codes[i] = <np.uint8_t *>np.PyArray_DATA(predict_word.code)             # <<<<<<<<<<<<<<
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)
  *         result += 1
  */
-      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_code); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 449, __pyx_L1_error)
+      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_code); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 450, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_10);
-      if (!(likely(((__pyx_t_10) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_10, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 449, __pyx_L1_error)
+      if (!(likely(((__pyx_t_10) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_10, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 450, __pyx_L1_error)
       (__pyx_v_codes[__pyx_v_i]) = ((__pyx_t_5numpy_uint8_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_10)));
       __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
 
-      /* "gensim/models/doc2vec_inner.pyx":450
+      /* "gensim/models/doc2vec_inner.pyx":451
  *             codelens[i] = <int>len(predict_word.code)
  *             codes[i] = <np.uint8_t *>np.PyArray_DATA(predict_word.code)
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)             # <<<<<<<<<<<<<<
  *         result += 1
  *         i += 1
  */
-      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_point); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 450, __pyx_L1_error)
+      __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_point); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 451, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_10);
-      if (!(likely(((__pyx_t_10) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_10, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 450, __pyx_L1_error)
+      if (!(likely(((__pyx_t_10) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_10, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 451, __pyx_L1_error)
       (__pyx_v_points[__pyx_v_i]) = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_10)));
       __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
 
-      /* "gensim/models/doc2vec_inner.pyx":447
+      /* "gensim/models/doc2vec_inner.pyx":448
  *             continue
  *         indexes[i] = predict_word.index
  *         if hs:             # <<<<<<<<<<<<<<
@@ -5829,7 +5884,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
     }
 
-    /* "gensim/models/doc2vec_inner.pyx":451
+    /* "gensim/models/doc2vec_inner.pyx":452
  *             codes[i] = <np.uint8_t *>np.PyArray_DATA(predict_word.code)
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)
  *         result += 1             # <<<<<<<<<<<<<<
@@ -5838,7 +5893,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
     __pyx_v_result = (__pyx_v_result + 1);
 
-    /* "gensim/models/doc2vec_inner.pyx":452
+    /* "gensim/models/doc2vec_inner.pyx":453
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)
  *         result += 1
  *         i += 1             # <<<<<<<<<<<<<<
@@ -5847,7 +5902,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
     __pyx_v_i = (__pyx_v_i + 1);
 
-    /* "gensim/models/doc2vec_inner.pyx":453
+    /* "gensim/models/doc2vec_inner.pyx":454
  *         result += 1
  *         i += 1
  *         if i == MAX_DOCUMENT_LEN:             # <<<<<<<<<<<<<<
@@ -5857,7 +5912,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
     __pyx_t_6 = ((__pyx_v_i == 0x2710) != 0);
     if (__pyx_t_6) {
 
-      /* "gensim/models/doc2vec_inner.pyx":454
+      /* "gensim/models/doc2vec_inner.pyx":455
  *         i += 1
  *         if i == MAX_DOCUMENT_LEN:
  *             break  # TODO: log warning, tally overflow?             # <<<<<<<<<<<<<<
@@ -5866,7 +5921,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
       goto __pyx_L15_break;
 
-      /* "gensim/models/doc2vec_inner.pyx":453
+      /* "gensim/models/doc2vec_inner.pyx":454
  *         result += 1
  *         i += 1
  *         if i == MAX_DOCUMENT_LEN:             # <<<<<<<<<<<<<<
@@ -5875,7 +5930,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
     }
 
-    /* "gensim/models/doc2vec_inner.pyx":440
+    /* "gensim/models/doc2vec_inner.pyx":441
  *     vlookup = model.wv.vocab
  *     i = 0
  *     for token in doc_words:             # <<<<<<<<<<<<<<
@@ -5885,9 +5940,9 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
     __pyx_L14_continue:;
   }
   __pyx_L15_break:;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":455
+  /* "gensim/models/doc2vec_inner.pyx":456
  *         if i == MAX_DOCUMENT_LEN:
  *             break  # TODO: log warning, tally overflow?
  *     document_len = i             # <<<<<<<<<<<<<<
@@ -5896,7 +5951,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
   __pyx_v_document_len = __pyx_v_i;
 
-  /* "gensim/models/doc2vec_inner.pyx":458
+  /* "gensim/models/doc2vec_inner.pyx":459
  * 
  *     # single randint() call avoids a big thread-sync slowdown
  *     for i, item in enumerate(model.random.randint(0, window, document_len)):             # <<<<<<<<<<<<<<
@@ -5904,49 +5959,49 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  * 
  */
   __pyx_t_2 = 0;
-  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 458, __pyx_L1_error)
+  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 459, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_10);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_randint); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 458, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_randint); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 459, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-  __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_window); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 458, __pyx_L1_error)
+  __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_window); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 459, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_10);
-  __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_document_len); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 458, __pyx_L1_error)
+  __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_document_len); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 459, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
   __pyx_t_14 = NULL;
   __pyx_t_15 = 0;
-  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
-    __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_3);
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+    __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_1);
     if (likely(__pyx_t_14)) {
-      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
       __Pyx_INCREF(__pyx_t_14);
       __Pyx_INCREF(function);
-      __Pyx_DECREF_SET(__pyx_t_3, function);
+      __Pyx_DECREF_SET(__pyx_t_1, function);
       __pyx_t_15 = 1;
     }
   }
   #if CYTHON_FAST_PYCALL
-  if (PyFunction_Check(__pyx_t_3)) {
+  if (PyFunction_Check(__pyx_t_1)) {
     PyObject *__pyx_temp[4] = {__pyx_t_14, __pyx_int_0, __pyx_t_10, __pyx_t_8};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_15, 3+__pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_15, 3+__pyx_t_15); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 459, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
   } else
   #endif
   #if CYTHON_FAST_PYCCALL
-  if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
     PyObject *__pyx_temp[4] = {__pyx_t_14, __pyx_int_0, __pyx_t_10, __pyx_t_8};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_15, 3+__pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_15, 3+__pyx_t_15); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 459, __pyx_L1_error)
     __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
   } else
   #endif
   {
-    __pyx_t_16 = PyTuple_New(3+__pyx_t_15); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 458, __pyx_L1_error)
+    __pyx_t_16 = PyTuple_New(3+__pyx_t_15); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 459, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_16);
     if (__pyx_t_14) {
       __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_14); __pyx_t_14 = NULL;
@@ -5960,67 +6015,67 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
     PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_15, __pyx_t_8);
     __pyx_t_10 = 0;
     __pyx_t_8 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_16, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_16, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 459, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
   }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-    __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
+    __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); __pyx_t_7 = 0;
     __pyx_t_11 = NULL;
   } else {
-    __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 458, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_11 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 458, __pyx_L1_error)
+    __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 459, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_11 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 459, __pyx_L1_error)
   }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   for (;;) {
     if (likely(!__pyx_t_11)) {
-      if (likely(PyList_CheckExact(__pyx_t_3))) {
-        if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break;
+      if (likely(PyList_CheckExact(__pyx_t_1))) {
+        if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_1)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_1); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 458, __pyx_L1_error)
+        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_3); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 459, __pyx_L1_error)
         #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 459, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
         #endif
       } else {
-        if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_1); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 458, __pyx_L1_error)
+        __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_3); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 459, __pyx_L1_error)
         #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 458, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 459, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
         #endif
       }
     } else {
-      __pyx_t_1 = __pyx_t_11(__pyx_t_3);
-      if (unlikely(!__pyx_t_1)) {
+      __pyx_t_3 = __pyx_t_11(__pyx_t_1);
+      if (unlikely(!__pyx_t_3)) {
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
           if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(0, 458, __pyx_L1_error)
+          else __PYX_ERR(0, 459, __pyx_L1_error)
         }
         break;
       }
-      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_3);
     }
-    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_1);
-    __pyx_t_1 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3);
+    __pyx_t_3 = 0;
     __pyx_v_i = __pyx_t_2;
     __pyx_t_2 = (__pyx_t_2 + 1);
 
-    /* "gensim/models/doc2vec_inner.pyx":459
+    /* "gensim/models/doc2vec_inner.pyx":460
  *     # single randint() call avoids a big thread-sync slowdown
  *     for i, item in enumerate(model.random.randint(0, window, document_len)):
  *         reduced_windows[i] = item             # <<<<<<<<<<<<<<
  * 
  *     doctag_len = <int>min(MAX_DOCUMENT_LEN, len(doctag_indexes))
  */
-    __pyx_t_12 = __Pyx_PyInt_As_npy_uint32(__pyx_v_item); if (unlikely((__pyx_t_12 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L1_error)
+    __pyx_t_12 = __Pyx_PyInt_As_npy_uint32(__pyx_v_item); if (unlikely((__pyx_t_12 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 460, __pyx_L1_error)
     (__pyx_v_reduced_windows[__pyx_v_i]) = __pyx_t_12;
 
-    /* "gensim/models/doc2vec_inner.pyx":458
+    /* "gensim/models/doc2vec_inner.pyx":459
  * 
  *     # single randint() call avoids a big thread-sync slowdown
  *     for i, item in enumerate(model.random.randint(0, window, document_len)):             # <<<<<<<<<<<<<<
@@ -6028,16 +6083,16 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  * 
  */
   }
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":461
+  /* "gensim/models/doc2vec_inner.pyx":462
  *         reduced_windows[i] = item
  * 
  *     doctag_len = <int>min(MAX_DOCUMENT_LEN, len(doctag_indexes))             # <<<<<<<<<<<<<<
  *     for i in range(doctag_len):
  *         _doctag_indexes[i] = doctag_indexes[i]
  */
-  __pyx_t_7 = PyObject_Length(__pyx_v_doctag_indexes); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 461, __pyx_L1_error)
+  __pyx_t_7 = PyObject_Length(__pyx_v_doctag_indexes); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 462, __pyx_L1_error)
   __pyx_t_17 = 0x2710;
   if (((__pyx_t_7 < __pyx_t_17) != 0)) {
     __pyx_t_13 = __pyx_t_7;
@@ -6046,7 +6101,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
   }
   __pyx_v_doctag_len = ((int)__pyx_t_13);
 
-  /* "gensim/models/doc2vec_inner.pyx":462
+  /* "gensim/models/doc2vec_inner.pyx":463
  * 
  *     doctag_len = <int>min(MAX_DOCUMENT_LEN, len(doctag_indexes))
  *     for i in range(doctag_len):             # <<<<<<<<<<<<<<
@@ -6057,20 +6112,20 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
   for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_2; __pyx_t_15+=1) {
     __pyx_v_i = __pyx_t_15;
 
-    /* "gensim/models/doc2vec_inner.pyx":463
+    /* "gensim/models/doc2vec_inner.pyx":464
  *     doctag_len = <int>min(MAX_DOCUMENT_LEN, len(doctag_indexes))
  *     for i in range(doctag_len):
  *         _doctag_indexes[i] = doctag_indexes[i]             # <<<<<<<<<<<<<<
  *         result += 1
  * 
  */
-    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_doctag_indexes, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 463, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_12 = __Pyx_PyInt_As_npy_uint32(__pyx_t_3); if (unlikely((__pyx_t_12 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 463, __pyx_L1_error)
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_doctag_indexes, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 464, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_12 = __Pyx_PyInt_As_npy_uint32(__pyx_t_1); if (unlikely((__pyx_t_12 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 464, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     (__pyx_v__doctag_indexes[__pyx_v_i]) = __pyx_t_12;
 
-    /* "gensim/models/doc2vec_inner.pyx":464
+    /* "gensim/models/doc2vec_inner.pyx":465
  *     for i in range(doctag_len):
  *         _doctag_indexes[i] = doctag_indexes[i]
  *         result += 1             # <<<<<<<<<<<<<<
@@ -6080,7 +6135,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
     __pyx_v_result = (__pyx_v_result + 1);
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":467
+  /* "gensim/models/doc2vec_inner.pyx":468
  * 
  *     # release GIL & train on the document
  *     with nogil:             # <<<<<<<<<<<<<<
@@ -6094,7 +6149,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
       #endif
       /*try:*/ {
 
-        /* "gensim/models/doc2vec_inner.pyx":468
+        /* "gensim/models/doc2vec_inner.pyx":469
  *     # release GIL & train on the document
  *     with nogil:
  *         for i in range(document_len):             # <<<<<<<<<<<<<<
@@ -6105,7 +6160,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
         for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_2; __pyx_t_15+=1) {
           __pyx_v_i = __pyx_t_15;
 
-          /* "gensim/models/doc2vec_inner.pyx":469
+          /* "gensim/models/doc2vec_inner.pyx":470
  *     with nogil:
  *         for i in range(document_len):
  *             j = i - window + reduced_windows[i]             # <<<<<<<<<<<<<<
@@ -6114,7 +6169,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           __pyx_v_j = ((__pyx_v_i - __pyx_v_window) + (__pyx_v_reduced_windows[__pyx_v_i]));
 
-          /* "gensim/models/doc2vec_inner.pyx":470
+          /* "gensim/models/doc2vec_inner.pyx":471
  *         for i in range(document_len):
  *             j = i - window + reduced_windows[i]
  *             if j < 0:             # <<<<<<<<<<<<<<
@@ -6124,7 +6179,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           __pyx_t_6 = ((__pyx_v_j < 0) != 0);
           if (__pyx_t_6) {
 
-            /* "gensim/models/doc2vec_inner.pyx":471
+            /* "gensim/models/doc2vec_inner.pyx":472
  *             j = i - window + reduced_windows[i]
  *             if j < 0:
  *                 j = 0             # <<<<<<<<<<<<<<
@@ -6133,7 +6188,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
             __pyx_v_j = 0;
 
-            /* "gensim/models/doc2vec_inner.pyx":470
+            /* "gensim/models/doc2vec_inner.pyx":471
  *         for i in range(document_len):
  *             j = i - window + reduced_windows[i]
  *             if j < 0:             # <<<<<<<<<<<<<<
@@ -6142,7 +6197,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":472
+          /* "gensim/models/doc2vec_inner.pyx":473
  *             if j < 0:
  *                 j = 0
  *             k = i + window + 1 - reduced_windows[i]             # <<<<<<<<<<<<<<
@@ -6151,7 +6206,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           __pyx_v_k = (((__pyx_v_i + __pyx_v_window) + 1) - (__pyx_v_reduced_windows[__pyx_v_i]));
 
-          /* "gensim/models/doc2vec_inner.pyx":473
+          /* "gensim/models/doc2vec_inner.pyx":474
  *                 j = 0
  *             k = i + window + 1 - reduced_windows[i]
  *             if k > document_len:             # <<<<<<<<<<<<<<
@@ -6161,7 +6216,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           __pyx_t_6 = ((__pyx_v_k > __pyx_v_document_len) != 0);
           if (__pyx_t_6) {
 
-            /* "gensim/models/doc2vec_inner.pyx":474
+            /* "gensim/models/doc2vec_inner.pyx":475
  *             k = i + window + 1 - reduced_windows[i]
  *             if k > document_len:
  *                 k = document_len             # <<<<<<<<<<<<<<
@@ -6170,7 +6225,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
             __pyx_v_k = __pyx_v_document_len;
 
-            /* "gensim/models/doc2vec_inner.pyx":473
+            /* "gensim/models/doc2vec_inner.pyx":474
  *                 j = 0
  *             k = i + window + 1 - reduced_windows[i]
  *             if k > document_len:             # <<<<<<<<<<<<<<
@@ -6179,7 +6234,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":477
+          /* "gensim/models/doc2vec_inner.pyx":478
  * 
  *             # compose l1 (in _neu1) & clear _work
  *             memset(_neu1, 0, size * cython.sizeof(REAL_t))             # <<<<<<<<<<<<<<
@@ -6188,7 +6243,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           memset(__pyx_v__neu1, 0, (__pyx_v_size * (sizeof(__pyx_t_6gensim_6models_14word2vec_inner_REAL_t))));
 
-          /* "gensim/models/doc2vec_inner.pyx":478
+          /* "gensim/models/doc2vec_inner.pyx":479
  *             # compose l1 (in _neu1) & clear _work
  *             memset(_neu1, 0, size * cython.sizeof(REAL_t))
  *             count = <REAL_t>0.0             # <<<<<<<<<<<<<<
@@ -6197,7 +6252,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           __pyx_v_count = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t)0.0);
 
-          /* "gensim/models/doc2vec_inner.pyx":479
+          /* "gensim/models/doc2vec_inner.pyx":480
  *             memset(_neu1, 0, size * cython.sizeof(REAL_t))
  *             count = <REAL_t>0.0
  *             for m in range(j, k):             # <<<<<<<<<<<<<<
@@ -6208,7 +6263,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           for (__pyx_t_19 = __pyx_v_j; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) {
             __pyx_v_m = __pyx_t_19;
 
-            /* "gensim/models/doc2vec_inner.pyx":480
+            /* "gensim/models/doc2vec_inner.pyx":481
  *             count = <REAL_t>0.0
  *             for m in range(j, k):
  *                 if m == i:             # <<<<<<<<<<<<<<
@@ -6218,7 +6273,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
             __pyx_t_6 = ((__pyx_v_m == __pyx_v_i) != 0);
             if (__pyx_t_6) {
 
-              /* "gensim/models/doc2vec_inner.pyx":481
+              /* "gensim/models/doc2vec_inner.pyx":482
  *             for m in range(j, k):
  *                 if m == i:
  *                     continue             # <<<<<<<<<<<<<<
@@ -6227,7 +6282,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
               goto __pyx_L33_continue;
 
-              /* "gensim/models/doc2vec_inner.pyx":480
+              /* "gensim/models/doc2vec_inner.pyx":481
  *             count = <REAL_t>0.0
  *             for m in range(j, k):
  *                 if m == i:             # <<<<<<<<<<<<<<
@@ -6236,7 +6291,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
             }
 
-            /* "gensim/models/doc2vec_inner.pyx":483
+            /* "gensim/models/doc2vec_inner.pyx":484
  *                     continue
  *                 else:
  *                     count += ONEF             # <<<<<<<<<<<<<<
@@ -6246,7 +6301,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
             /*else*/ {
               __pyx_v_count = (__pyx_v_count + __pyx_v_6gensim_6models_13doc2vec_inner_ONEF);
 
-              /* "gensim/models/doc2vec_inner.pyx":484
+              /* "gensim/models/doc2vec_inner.pyx":485
  *                 else:
  *                     count += ONEF
  *                     our_saxpy(&size, &ONEF, &_word_vectors[indexes[m] * size], &ONE, _neu1, &ONE)             # <<<<<<<<<<<<<<
@@ -6258,7 +6313,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
             __pyx_L33_continue:;
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":485
+          /* "gensim/models/doc2vec_inner.pyx":486
  *                     count += ONEF
  *                     our_saxpy(&size, &ONEF, &_word_vectors[indexes[m] * size], &ONE, _neu1, &ONE)
  *             for m in range(doctag_len):             # <<<<<<<<<<<<<<
@@ -6269,7 +6324,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) {
             __pyx_v_m = __pyx_t_19;
 
-            /* "gensim/models/doc2vec_inner.pyx":486
+            /* "gensim/models/doc2vec_inner.pyx":487
  *                     our_saxpy(&size, &ONEF, &_word_vectors[indexes[m] * size], &ONE, _neu1, &ONE)
  *             for m in range(doctag_len):
  *                 count += ONEF             # <<<<<<<<<<<<<<
@@ -6278,7 +6333,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
             __pyx_v_count = (__pyx_v_count + __pyx_v_6gensim_6models_13doc2vec_inner_ONEF);
 
-            /* "gensim/models/doc2vec_inner.pyx":487
+            /* "gensim/models/doc2vec_inner.pyx":488
  *             for m in range(doctag_len):
  *                 count += ONEF
  *                 our_saxpy(&size, &ONEF, &_doctag_vectors[_doctag_indexes[m] * size], &ONE, _neu1, &ONE)             # <<<<<<<<<<<<<<
@@ -6288,7 +6343,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
             __pyx_v_6gensim_6models_14word2vec_inner_our_saxpy((&__pyx_v_size), (&__pyx_v_6gensim_6models_13doc2vec_inner_ONEF), (&(__pyx_v__doctag_vectors[((__pyx_v__doctag_indexes[__pyx_v_m]) * __pyx_v_size)])), (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE), __pyx_v__neu1, (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE));
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":488
+          /* "gensim/models/doc2vec_inner.pyx":489
  *                 count += ONEF
  *                 our_saxpy(&size, &ONEF, &_doctag_vectors[_doctag_indexes[m] * size], &ONE, _neu1, &ONE)
  *             if count > (<REAL_t>0.5):             # <<<<<<<<<<<<<<
@@ -6298,7 +6353,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           __pyx_t_6 = ((__pyx_v_count > ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t)0.5)) != 0);
           if (__pyx_t_6) {
 
-            /* "gensim/models/doc2vec_inner.pyx":489
+            /* "gensim/models/doc2vec_inner.pyx":490
  *                 our_saxpy(&size, &ONEF, &_doctag_vectors[_doctag_indexes[m] * size], &ONE, _neu1, &ONE)
  *             if count > (<REAL_t>0.5):
  *                 inv_count = ONEF/count             # <<<<<<<<<<<<<<
@@ -6307,7 +6362,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
             __pyx_v_inv_count = (__pyx_v_6gensim_6models_13doc2vec_inner_ONEF / __pyx_v_count);
 
-            /* "gensim/models/doc2vec_inner.pyx":488
+            /* "gensim/models/doc2vec_inner.pyx":489
  *                 count += ONEF
  *                 our_saxpy(&size, &ONEF, &_doctag_vectors[_doctag_indexes[m] * size], &ONE, _neu1, &ONE)
  *             if count > (<REAL_t>0.5):             # <<<<<<<<<<<<<<
@@ -6316,7 +6371,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":490
+          /* "gensim/models/doc2vec_inner.pyx":491
  *             if count > (<REAL_t>0.5):
  *                 inv_count = ONEF/count
  *             if cbow_mean:             # <<<<<<<<<<<<<<
@@ -6326,7 +6381,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           __pyx_t_6 = (__pyx_v_cbow_mean != 0);
           if (__pyx_t_6) {
 
-            /* "gensim/models/doc2vec_inner.pyx":491
+            /* "gensim/models/doc2vec_inner.pyx":492
  *                 inv_count = ONEF/count
  *             if cbow_mean:
  *                 sscal(&size, &inv_count, _neu1, &ONE)  # (does this need BLAS-variants like saxpy?)             # <<<<<<<<<<<<<<
@@ -6335,7 +6390,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
             __pyx_v_6gensim_6models_14word2vec_inner_sscal((&__pyx_v_size), (&__pyx_v_inv_count), __pyx_v__neu1, (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE));
 
-            /* "gensim/models/doc2vec_inner.pyx":490
+            /* "gensim/models/doc2vec_inner.pyx":491
  *             if count > (<REAL_t>0.5):
  *                 inv_count = ONEF/count
  *             if cbow_mean:             # <<<<<<<<<<<<<<
@@ -6344,7 +6399,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":492
+          /* "gensim/models/doc2vec_inner.pyx":493
  *             if cbow_mean:
  *                 sscal(&size, &inv_count, _neu1, &ONE)  # (does this need BLAS-variants like saxpy?)
  *             memset(_work, 0, size * cython.sizeof(REAL_t))  # work to accumulate l1 error             # <<<<<<<<<<<<<<
@@ -6353,7 +6408,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           memset(__pyx_v__work, 0, (__pyx_v_size * (sizeof(__pyx_t_6gensim_6models_14word2vec_inner_REAL_t))));
 
-          /* "gensim/models/doc2vec_inner.pyx":493
+          /* "gensim/models/doc2vec_inner.pyx":494
  *                 sscal(&size, &inv_count, _neu1, &ONE)  # (does this need BLAS-variants like saxpy?)
  *             memset(_work, 0, size * cython.sizeof(REAL_t))  # work to accumulate l1 error
  *             if hs:             # <<<<<<<<<<<<<<
@@ -6363,7 +6418,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           __pyx_t_6 = (__pyx_v_hs != 0);
           if (__pyx_t_6) {
 
-            /* "gensim/models/doc2vec_inner.pyx":494
+            /* "gensim/models/doc2vec_inner.pyx":495
  *             memset(_work, 0, size * cython.sizeof(REAL_t))  # work to accumulate l1 error
  *             if hs:
  *                 fast_document_dm_hs(points[i], codes[i], codelens[i],             # <<<<<<<<<<<<<<
@@ -6372,7 +6427,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
             __pyx_f_6gensim_6models_13doc2vec_inner_fast_document_dm_hs((__pyx_v_points[__pyx_v_i]), (__pyx_v_codes[__pyx_v_i]), (__pyx_v_codelens[__pyx_v_i]), __pyx_v__neu1, __pyx_v_syn1, __pyx_v__alpha, __pyx_v__work, __pyx_v_size, __pyx_v__learn_hidden);
 
-            /* "gensim/models/doc2vec_inner.pyx":493
+            /* "gensim/models/doc2vec_inner.pyx":494
  *                 sscal(&size, &inv_count, _neu1, &ONE)  # (does this need BLAS-variants like saxpy?)
  *             memset(_work, 0, size * cython.sizeof(REAL_t))  # work to accumulate l1 error
  *             if hs:             # <<<<<<<<<<<<<<
@@ -6381,7 +6436,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":497
+          /* "gensim/models/doc2vec_inner.pyx":498
  *                                     _neu1, syn1, _alpha, _work,
  *                                     size, _learn_hidden)
  *             if negative:             # <<<<<<<<<<<<<<
@@ -6391,7 +6446,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           __pyx_t_6 = (__pyx_v_negative != 0);
           if (__pyx_t_6) {
 
-            /* "gensim/models/doc2vec_inner.pyx":498
+            /* "gensim/models/doc2vec_inner.pyx":499
  *                                     size, _learn_hidden)
  *             if negative:
  *                 next_random = fast_document_dm_neg(negative, cum_table, cum_table_len, next_random,             # <<<<<<<<<<<<<<
@@ -6400,7 +6455,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
             __pyx_v_next_random = __pyx_f_6gensim_6models_13doc2vec_inner_fast_document_dm_neg(__pyx_v_negative, __pyx_v_cum_table, __pyx_v_cum_table_len, __pyx_v_next_random, __pyx_v__neu1, __pyx_v_syn1neg, (__pyx_v_indexes[__pyx_v_i]), __pyx_v__alpha, __pyx_v__work, __pyx_v_size, __pyx_v__learn_hidden);
 
-            /* "gensim/models/doc2vec_inner.pyx":497
+            /* "gensim/models/doc2vec_inner.pyx":498
  *                                     _neu1, syn1, _alpha, _work,
  *                                     size, _learn_hidden)
  *             if negative:             # <<<<<<<<<<<<<<
@@ -6409,7 +6464,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":502
+          /* "gensim/models/doc2vec_inner.pyx":503
  *                                                    size, _learn_hidden)
  * 
  *             if not cbow_mean:             # <<<<<<<<<<<<<<
@@ -6419,7 +6474,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           __pyx_t_6 = ((!(__pyx_v_cbow_mean != 0)) != 0);
           if (__pyx_t_6) {
 
-            /* "gensim/models/doc2vec_inner.pyx":503
+            /* "gensim/models/doc2vec_inner.pyx":504
  * 
  *             if not cbow_mean:
  *                 sscal(&size, &inv_count, _work, &ONE)  # (does this need BLAS-variants like saxpy?)             # <<<<<<<<<<<<<<
@@ -6428,7 +6483,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
             __pyx_v_6gensim_6models_14word2vec_inner_sscal((&__pyx_v_size), (&__pyx_v_inv_count), __pyx_v__work, (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE));
 
-            /* "gensim/models/doc2vec_inner.pyx":502
+            /* "gensim/models/doc2vec_inner.pyx":503
  *                                                    size, _learn_hidden)
  * 
  *             if not cbow_mean:             # <<<<<<<<<<<<<<
@@ -6437,7 +6492,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":505
+          /* "gensim/models/doc2vec_inner.pyx":506
  *                 sscal(&size, &inv_count, _work, &ONE)  # (does this need BLAS-variants like saxpy?)
  *             # apply accumulated error in work
  *             if _learn_doctags:             # <<<<<<<<<<<<<<
@@ -6447,7 +6502,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           __pyx_t_6 = (__pyx_v__learn_doctags != 0);
           if (__pyx_t_6) {
 
-            /* "gensim/models/doc2vec_inner.pyx":506
+            /* "gensim/models/doc2vec_inner.pyx":507
  *             # apply accumulated error in work
  *             if _learn_doctags:
  *                 for m in range(doctag_len):             # <<<<<<<<<<<<<<
@@ -6458,7 +6513,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
             for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) {
               __pyx_v_m = __pyx_t_19;
 
-              /* "gensim/models/doc2vec_inner.pyx":507
+              /* "gensim/models/doc2vec_inner.pyx":508
  *             if _learn_doctags:
  *                 for m in range(doctag_len):
  *                     our_saxpy(&size, &_doctag_locks[_doctag_indexes[m]], _work,             # <<<<<<<<<<<<<<
@@ -6468,7 +6523,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
               __pyx_v_6gensim_6models_14word2vec_inner_our_saxpy((&__pyx_v_size), (&(__pyx_v__doctag_locks[(__pyx_v__doctag_indexes[__pyx_v_m])])), __pyx_v__work, (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE), (&(__pyx_v__doctag_vectors[((__pyx_v__doctag_indexes[__pyx_v_m]) * __pyx_v_size)])), (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE));
             }
 
-            /* "gensim/models/doc2vec_inner.pyx":505
+            /* "gensim/models/doc2vec_inner.pyx":506
  *                 sscal(&size, &inv_count, _work, &ONE)  # (does this need BLAS-variants like saxpy?)
  *             # apply accumulated error in work
  *             if _learn_doctags:             # <<<<<<<<<<<<<<
@@ -6477,7 +6532,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":509
+          /* "gensim/models/doc2vec_inner.pyx":510
  *                     our_saxpy(&size, &_doctag_locks[_doctag_indexes[m]], _work,
  *                               &ONE, &_doctag_vectors[_doctag_indexes[m] * size], &ONE)
  *             if _learn_words:             # <<<<<<<<<<<<<<
@@ -6487,7 +6542,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
           __pyx_t_6 = (__pyx_v__learn_words != 0);
           if (__pyx_t_6) {
 
-            /* "gensim/models/doc2vec_inner.pyx":510
+            /* "gensim/models/doc2vec_inner.pyx":511
  *                               &ONE, &_doctag_vectors[_doctag_indexes[m] * size], &ONE)
  *             if _learn_words:
  *                 for m in range(j, k):             # <<<<<<<<<<<<<<
@@ -6498,7 +6553,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
             for (__pyx_t_19 = __pyx_v_j; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) {
               __pyx_v_m = __pyx_t_19;
 
-              /* "gensim/models/doc2vec_inner.pyx":511
+              /* "gensim/models/doc2vec_inner.pyx":512
  *             if _learn_words:
  *                 for m in range(j, k):
  *                     if m == i:             # <<<<<<<<<<<<<<
@@ -6508,7 +6563,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
               __pyx_t_6 = ((__pyx_v_m == __pyx_v_i) != 0);
               if (__pyx_t_6) {
 
-                /* "gensim/models/doc2vec_inner.pyx":512
+                /* "gensim/models/doc2vec_inner.pyx":513
  *                 for m in range(j, k):
  *                     if m == i:
  *                         continue             # <<<<<<<<<<<<<<
@@ -6517,7 +6572,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
                 goto __pyx_L47_continue;
 
-                /* "gensim/models/doc2vec_inner.pyx":511
+                /* "gensim/models/doc2vec_inner.pyx":512
  *             if _learn_words:
  *                 for m in range(j, k):
  *                     if m == i:             # <<<<<<<<<<<<<<
@@ -6526,7 +6581,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
               }
 
-              /* "gensim/models/doc2vec_inner.pyx":514
+              /* "gensim/models/doc2vec_inner.pyx":515
  *                         continue
  *                     else:
  *                          our_saxpy(&size, &_word_locks[indexes[m]], _work, &ONE,             # <<<<<<<<<<<<<<
@@ -6535,7 +6590,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  */
               /*else*/ {
 
-                /* "gensim/models/doc2vec_inner.pyx":515
+                /* "gensim/models/doc2vec_inner.pyx":516
  *                     else:
  *                          our_saxpy(&size, &_word_locks[indexes[m]], _work, &ONE,
  *                                    &_word_vectors[indexes[m] * size], &ONE)             # <<<<<<<<<<<<<<
@@ -6547,7 +6602,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
               __pyx_L47_continue:;
             }
 
-            /* "gensim/models/doc2vec_inner.pyx":509
+            /* "gensim/models/doc2vec_inner.pyx":510
  *                     our_saxpy(&size, &_doctag_locks[_doctag_indexes[m]], _work,
  *                               &ONE, &_doctag_vectors[_doctag_indexes[m] * size], &ONE)
  *             if _learn_words:             # <<<<<<<<<<<<<<
@@ -6558,7 +6613,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
         }
       }
 
-      /* "gensim/models/doc2vec_inner.pyx":467
+      /* "gensim/models/doc2vec_inner.pyx":468
  * 
  *     # release GIL & train on the document
  *     with nogil:             # <<<<<<<<<<<<<<
@@ -6576,7 +6631,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
       }
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":517
+  /* "gensim/models/doc2vec_inner.pyx":518
  *                                    &_word_vectors[indexes[m] * size], &ONE)
  * 
  *     return result             # <<<<<<<<<<<<<<
@@ -6584,10 +6639,10 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
  * 
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 517, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_r = __pyx_t_3;
-  __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v_result); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 518, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
   goto __pyx_L0;
 
   /* "gensim/models/doc2vec_inner.pyx":363
@@ -6624,7 +6679,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_2train_document_dm(CYT
   return __pyx_r;
 }
 
-/* "gensim/models/doc2vec_inner.pyx":520
+/* "gensim/models/doc2vec_inner.pyx":521
  * 
  * 
  * def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None, neu1=None,             # <<<<<<<<<<<<<<
@@ -6658,7 +6713,7 @@ static PyObject *__pyx_pw_6gensim_6models_13doc2vec_inner_5train_document_dm_con
     values[4] = ((PyObject *)Py_None);
     values[5] = ((PyObject *)Py_None);
 
-    /* "gensim/models/doc2vec_inner.pyx":521
+    /* "gensim/models/doc2vec_inner.pyx":522
  * 
  * def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None, neu1=None,
  *                              learn_doctags=True, learn_words=True, learn_hidden=True,             # <<<<<<<<<<<<<<
@@ -6669,7 +6724,7 @@ static PyObject *__pyx_pw_6gensim_6models_13doc2vec_inner_5train_document_dm_con
     values[7] = ((PyObject *)Py_True);
     values[8] = ((PyObject *)Py_True);
 
-    /* "gensim/models/doc2vec_inner.pyx":522
+    /* "gensim/models/doc2vec_inner.pyx":523
  * def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None, neu1=None,
  *                              learn_doctags=True, learn_words=True, learn_hidden=True,
  *                              word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):             # <<<<<<<<<<<<<<
@@ -6708,17 +6763,17 @@ static PyObject *__pyx_pw_6gensim_6models_13doc2vec_inner_5train_document_dm_con
         case  1:
         if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_doc_words)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("train_document_dm_concat", 0, 4, 13, 1); __PYX_ERR(0, 520, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("train_document_dm_concat", 0, 4, 13, 1); __PYX_ERR(0, 521, __pyx_L3_error)
         }
         case  2:
         if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_doctag_indexes)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("train_document_dm_concat", 0, 4, 13, 2); __PYX_ERR(0, 520, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("train_document_dm_concat", 0, 4, 13, 2); __PYX_ERR(0, 521, __pyx_L3_error)
         }
         case  3:
         if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_alpha)) != 0)) kw_args--;
         else {
-          __Pyx_RaiseArgtupleInvalid("train_document_dm_concat", 0, 4, 13, 3); __PYX_ERR(0, 520, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("train_document_dm_concat", 0, 4, 13, 3); __PYX_ERR(0, 521, __pyx_L3_error)
         }
         case  4:
         if (kw_args > 0) {
@@ -6767,7 +6822,7 @@ static PyObject *__pyx_pw_6gensim_6models_13doc2vec_inner_5train_document_dm_con
         }
       }
       if (unlikely(kw_args > 0)) {
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "train_document_dm_concat") < 0)) __PYX_ERR(0, 520, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "train_document_dm_concat") < 0)) __PYX_ERR(0, 521, __pyx_L3_error)
       }
     } else {
       switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -6804,7 +6859,7 @@ static PyObject *__pyx_pw_6gensim_6models_13doc2vec_inner_5train_document_dm_con
   }
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("train_document_dm_concat", 0, 4, 13, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 520, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("train_document_dm_concat", 0, 4, 13, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 521, __pyx_L3_error)
   __pyx_L3_error:;
   __Pyx_AddTraceback("gensim.models.doc2vec_inner.train_document_dm_concat", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __Pyx_RefNannyFinishContext();
@@ -6812,7 +6867,7 @@ static PyObject *__pyx_pw_6gensim_6models_13doc2vec_inner_5train_document_dm_con
   __pyx_L4_argument_unpacking_done:;
   __pyx_r = __pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_concat(__pyx_self, __pyx_v_model, __pyx_v_doc_words, __pyx_v_doctag_indexes, __pyx_v_alpha, __pyx_v_work, __pyx_v_neu1, __pyx_v_learn_doctags, __pyx_v_learn_words, __pyx_v_learn_hidden, __pyx_v_word_vectors, __pyx_v_word_locks, __pyx_v_doctag_vectors, __pyx_v_doctag_locks);
 
-  /* "gensim/models/doc2vec_inner.pyx":520
+  /* "gensim/models/doc2vec_inner.pyx":521
  * 
  * 
  * def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None, neu1=None,             # <<<<<<<<<<<<<<
@@ -6893,140 +6948,149 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
   __Pyx_INCREF(__pyx_v_doctag_vectors);
   __Pyx_INCREF(__pyx_v_doctag_locks);
 
-  /* "gensim/models/doc2vec_inner.pyx":523
+  /* "gensim/models/doc2vec_inner.pyx":524
  *                              learn_doctags=True, learn_words=True, learn_hidden=True,
  *                              word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
  *     cdef int hs = model.hs             # <<<<<<<<<<<<<<
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_hs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 523, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_hs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 524, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 524, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_hs = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":524
+  /* "gensim/models/doc2vec_inner.pyx":525
  *                              word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative             # <<<<<<<<<<<<<<
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int _learn_doctags = learn_doctags
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_negative); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 524, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_negative); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 525, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 524, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 525, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_negative = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":525
+  /* "gensim/models/doc2vec_inner.pyx":526
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)             # <<<<<<<<<<<<<<
+ *     cdef int sample = (model.vocabulary.sample != 0)             # <<<<<<<<<<<<<<
  *     cdef int _learn_doctags = learn_doctags
  *     cdef int _learn_words = learn_words
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_sample); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 525, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 526, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 525, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sample); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 526, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 525, __pyx_L1_error)
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 526, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_sample = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":526
+  /* "gensim/models/doc2vec_inner.pyx":527
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int _learn_doctags = learn_doctags             # <<<<<<<<<<<<<<
  *     cdef int _learn_words = learn_words
  *     cdef int _learn_hidden = learn_hidden
  */
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_v_learn_doctags); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_v_learn_doctags); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error)
   __pyx_v__learn_doctags = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":527
- *     cdef int sample = (model.sample != 0)
+  /* "gensim/models/doc2vec_inner.pyx":528
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int _learn_doctags = learn_doctags
  *     cdef int _learn_words = learn_words             # <<<<<<<<<<<<<<
  *     cdef int _learn_hidden = learn_hidden
  * 
  */
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_v_learn_words); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_v_learn_words); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error)
   __pyx_v__learn_words = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":528
+  /* "gensim/models/doc2vec_inner.pyx":529
  *     cdef int _learn_doctags = learn_doctags
  *     cdef int _learn_words = learn_words
  *     cdef int _learn_hidden = learn_hidden             # <<<<<<<<<<<<<<
  * 
  *     cdef REAL_t *_word_vectors
  */
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_v_learn_hidden); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_v_learn_hidden); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 529, __pyx_L1_error)
   __pyx_v__learn_hidden = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":536
+  /* "gensim/models/doc2vec_inner.pyx":537
  *     cdef REAL_t *_work
  *     cdef REAL_t *_neu1
  *     cdef REAL_t _alpha = alpha             # <<<<<<<<<<<<<<
- *     cdef int layer1_size = model.layer1_size
- *     cdef int vector_size = model.vector_size
+ *     cdef int layer1_size = model.trainables.layer1_size
+ *     cdef int vector_size = model.docvecs.vector_size
  */
-  __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_v_alpha); if (unlikely((__pyx_t_4 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 536, __pyx_L1_error)
+  __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_v_alpha); if (unlikely((__pyx_t_4 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 537, __pyx_L1_error)
   __pyx_v__alpha = __pyx_t_4;
 
-  /* "gensim/models/doc2vec_inner.pyx":537
+  /* "gensim/models/doc2vec_inner.pyx":538
  *     cdef REAL_t *_neu1
  *     cdef REAL_t _alpha = alpha
- *     cdef int layer1_size = model.layer1_size             # <<<<<<<<<<<<<<
- *     cdef int vector_size = model.vector_size
+ *     cdef int layer1_size = model.trainables.layer1_size             # <<<<<<<<<<<<<<
+ *     cdef int vector_size = model.docvecs.vector_size
  * 
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 537, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 538, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 538, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 537, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 538, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_layer1_size = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":538
+  /* "gensim/models/doc2vec_inner.pyx":539
  *     cdef REAL_t _alpha = alpha
- *     cdef int layer1_size = model.layer1_size
- *     cdef int vector_size = model.vector_size             # <<<<<<<<<<<<<<
+ *     cdef int layer1_size = model.trainables.layer1_size
+ *     cdef int vector_size = model.docvecs.vector_size             # <<<<<<<<<<<<<<
  * 
  *     cdef int codelens[MAX_DOCUMENT_LEN]
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vector_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 538, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_docvecs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 539, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 538, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vector_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 539, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 539, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_vector_size = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":546
+  /* "gensim/models/doc2vec_inner.pyx":547
  *     cdef int document_len
  *     cdef int doctag_len
  *     cdef int window = model.window             # <<<<<<<<<<<<<<
  *     cdef int expected_doctag_len = model.dm_tag_count
  * 
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 546, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 546, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 547, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 547, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_window = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":547
+  /* "gensim/models/doc2vec_inner.pyx":548
  *     cdef int doctag_len
  *     cdef int window = model.window
  *     cdef int expected_doctag_len = model.dm_tag_count             # <<<<<<<<<<<<<<
  * 
  *     cdef int i, j, k, m, n
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_dm_tag_count); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 547, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 547, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_dm_tag_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 548, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 548, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_expected_doctag_len = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":550
+  /* "gensim/models/doc2vec_inner.pyx":551
  * 
  *     cdef int i, j, k, m, n
  *     cdef long result = 0             # <<<<<<<<<<<<<<
@@ -7035,36 +7099,36 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
   __pyx_v_result = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":551
+  /* "gensim/models/doc2vec_inner.pyx":552
  *     cdef int i, j, k, m, n
  *     cdef long result = 0
  *     cdef int null_word_index = model.wv.vocab['\0'].index             # <<<<<<<<<<<<<<
  * 
  *     # For hierarchical softmax
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 551, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vocab); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 551, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 552, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_3 = PyObject_GetItem(__pyx_t_1, __pyx_kp_s__5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 551, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vocab); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 552, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 551, __pyx_L1_error)
+  __pyx_t_1 = PyObject_GetItem(__pyx_t_3, __pyx_kp_s__5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 552, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 551, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 552, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 552, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_null_word_index = __pyx_t_2;
 
-  /* "gensim/models/doc2vec_inner.pyx":564
+  /* "gensim/models/doc2vec_inner.pyx":565
  *     cdef unsigned long long next_random
  * 
  *     doctag_len = <int>min(MAX_DOCUMENT_LEN, len(doctag_indexes))             # <<<<<<<<<<<<<<
  *     if doctag_len != expected_doctag_len:
  *         return 0  # skip doc without expected number of tags
  */
-  __pyx_t_5 = PyObject_Length(__pyx_v_doctag_indexes); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(0, 564, __pyx_L1_error)
+  __pyx_t_5 = PyObject_Length(__pyx_v_doctag_indexes); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(0, 565, __pyx_L1_error)
   __pyx_t_6 = 0x2710;
   if (((__pyx_t_5 < __pyx_t_6) != 0)) {
     __pyx_t_7 = __pyx_t_5;
@@ -7073,7 +7137,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
   }
   __pyx_v_doctag_len = ((int)__pyx_t_7);
 
-  /* "gensim/models/doc2vec_inner.pyx":565
+  /* "gensim/models/doc2vec_inner.pyx":566
  * 
  *     doctag_len = <int>min(MAX_DOCUMENT_LEN, len(doctag_indexes))
  *     if doctag_len != expected_doctag_len:             # <<<<<<<<<<<<<<
@@ -7083,7 +7147,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
   __pyx_t_8 = ((__pyx_v_doctag_len != __pyx_v_expected_doctag_len) != 0);
   if (__pyx_t_8) {
 
-    /* "gensim/models/doc2vec_inner.pyx":566
+    /* "gensim/models/doc2vec_inner.pyx":567
  *     doctag_len = <int>min(MAX_DOCUMENT_LEN, len(doctag_indexes))
  *     if doctag_len != expected_doctag_len:
  *         return 0  # skip doc without expected number of tags             # <<<<<<<<<<<<<<
@@ -7095,7 +7159,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
     __pyx_r = __pyx_int_0;
     goto __pyx_L0;
 
-    /* "gensim/models/doc2vec_inner.pyx":565
+    /* "gensim/models/doc2vec_inner.pyx":566
  * 
  *     doctag_len = <int>min(MAX_DOCUMENT_LEN, len(doctag_indexes))
  *     if doctag_len != expected_doctag_len:             # <<<<<<<<<<<<<<
@@ -7104,276 +7168,291 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":569
+  /* "gensim/models/doc2vec_inner.pyx":570
  * 
  *     # default vectors, locks from syn0/doctag_syn0
  *     if word_vectors is None:             # <<<<<<<<<<<<<<
- *        word_vectors = model.wv.syn0
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  */
   __pyx_t_8 = (__pyx_v_word_vectors == Py_None);
   __pyx_t_9 = (__pyx_t_8 != 0);
   if (__pyx_t_9) {
 
-    /* "gensim/models/doc2vec_inner.pyx":570
+    /* "gensim/models/doc2vec_inner.pyx":571
  *     # default vectors, locks from syn0/doctag_syn0
  *     if word_vectors is None:
- *        word_vectors = model.wv.syn0             # <<<<<<<<<<<<<<
+ *        word_vectors = model.wv.vectors             # <<<<<<<<<<<<<<
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 570, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 570, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 571, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __Pyx_DECREF_SET(__pyx_v_word_vectors, __pyx_t_3);
-    __pyx_t_3 = 0;
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 571, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF_SET(__pyx_v_word_vectors, __pyx_t_1);
+    __pyx_t_1 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":569
+    /* "gensim/models/doc2vec_inner.pyx":570
  * 
  *     # default vectors, locks from syn0/doctag_syn0
  *     if word_vectors is None:             # <<<<<<<<<<<<<<
- *        word_vectors = model.wv.syn0
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":571
+  /* "gensim/models/doc2vec_inner.pyx":572
  *     if word_vectors is None:
- *        word_vectors = model.wv.syn0
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))             # <<<<<<<<<<<<<<
  *     if doctag_vectors is None:
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  */
-  if (!(likely(((__pyx_v_word_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 571, __pyx_L1_error)
+  if (!(likely(((__pyx_v_word_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 572, __pyx_L1_error)
   __pyx_v__word_vectors = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_word_vectors)));
 
-  /* "gensim/models/doc2vec_inner.pyx":572
- *        word_vectors = model.wv.syn0
+  /* "gensim/models/doc2vec_inner.pyx":573
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:             # <<<<<<<<<<<<<<
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  */
   __pyx_t_9 = (__pyx_v_doctag_vectors == Py_None);
   __pyx_t_8 = (__pyx_t_9 != 0);
   if (__pyx_t_8) {
 
-    /* "gensim/models/doc2vec_inner.pyx":573
+    /* "gensim/models/doc2vec_inner.pyx":574
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:
- *        doctag_vectors = model.docvecs.doctag_syn0             # <<<<<<<<<<<<<<
+ *        doctag_vectors = model.docvecs.vectors_docs             # <<<<<<<<<<<<<<
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_docvecs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 573, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_doctag_syn0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 573, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_docvecs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 574, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_DECREF_SET(__pyx_v_doctag_vectors, __pyx_t_1);
-    __pyx_t_1 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_docs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 574, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF_SET(__pyx_v_doctag_vectors, __pyx_t_3);
+    __pyx_t_3 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":572
- *        word_vectors = model.wv.syn0
+    /* "gensim/models/doc2vec_inner.pyx":573
+ *        word_vectors = model.wv.vectors
  *     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
  *     if doctag_vectors is None:             # <<<<<<<<<<<<<<
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":574
+  /* "gensim/models/doc2vec_inner.pyx":575
  *     if doctag_vectors is None:
- *        doctag_vectors = model.docvecs.doctag_syn0
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))             # <<<<<<<<<<<<<<
  *     if word_locks is None:
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  */
-  if (!(likely(((__pyx_v_doctag_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_doctag_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 574, __pyx_L1_error)
+  if (!(likely(((__pyx_v_doctag_vectors) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_doctag_vectors, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 575, __pyx_L1_error)
   __pyx_v__doctag_vectors = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_doctag_vectors)));
 
-  /* "gensim/models/doc2vec_inner.pyx":575
- *        doctag_vectors = model.docvecs.doctag_syn0
+  /* "gensim/models/doc2vec_inner.pyx":576
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:             # <<<<<<<<<<<<<<
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  */
   __pyx_t_8 = (__pyx_v_word_locks == Py_None);
   __pyx_t_9 = (__pyx_t_8 != 0);
   if (__pyx_t_9) {
 
-    /* "gensim/models/doc2vec_inner.pyx":576
+    /* "gensim/models/doc2vec_inner.pyx":577
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:
- *        word_locks = model.syn0_lockf             # <<<<<<<<<<<<<<
+ *        word_locks = model.trainables.vectors_lockf             # <<<<<<<<<<<<<<
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn0_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 576, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 577, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 577, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF_SET(__pyx_v_word_locks, __pyx_t_1);
     __pyx_t_1 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":575
- *        doctag_vectors = model.docvecs.doctag_syn0
+    /* "gensim/models/doc2vec_inner.pyx":576
+ *        doctag_vectors = model.docvecs.vectors_docs
  *     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
  *     if word_locks is None:             # <<<<<<<<<<<<<<
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":577
+  /* "gensim/models/doc2vec_inner.pyx":578
  *     if word_locks is None:
- *        word_locks = model.syn0_lockf
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))             # <<<<<<<<<<<<<<
  *     if doctag_locks is None:
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *        doctag_locks = model.trainables.vectors_docs_lockf
  */
-  if (!(likely(((__pyx_v_word_locks) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_locks, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 577, __pyx_L1_error)
+  if (!(likely(((__pyx_v_word_locks) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_word_locks, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 578, __pyx_L1_error)
   __pyx_v__word_locks = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_word_locks)));
 
-  /* "gensim/models/doc2vec_inner.pyx":578
- *        word_locks = model.syn0_lockf
+  /* "gensim/models/doc2vec_inner.pyx":579
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:             # <<<<<<<<<<<<<<
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *        doctag_locks = model.trainables.vectors_docs_lockf
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  */
   __pyx_t_9 = (__pyx_v_doctag_locks == Py_None);
   __pyx_t_8 = (__pyx_t_9 != 0);
   if (__pyx_t_8) {
 
-    /* "gensim/models/doc2vec_inner.pyx":579
+    /* "gensim/models/doc2vec_inner.pyx":580
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:
- *        doctag_locks = model.docvecs.doctag_syn0_lockf             # <<<<<<<<<<<<<<
+ *        doctag_locks = model.trainables.vectors_docs_lockf             # <<<<<<<<<<<<<<
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  * 
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_docvecs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 579, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 580, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_doctag_syn0_lockf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 579, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_docs_lockf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 580, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_DECREF_SET(__pyx_v_doctag_locks, __pyx_t_3);
     __pyx_t_3 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":578
- *        word_locks = model.syn0_lockf
+    /* "gensim/models/doc2vec_inner.pyx":579
+ *        word_locks = model.trainables.vectors_lockf
  *     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
  *     if doctag_locks is None:             # <<<<<<<<<<<<<<
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *        doctag_locks = model.trainables.vectors_docs_lockf
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":580
+  /* "gensim/models/doc2vec_inner.pyx":581
  *     if doctag_locks is None:
- *        doctag_locks = model.docvecs.doctag_syn0_lockf
+ *        doctag_locks = model.trainables.vectors_docs_lockf
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))             # <<<<<<<<<<<<<<
  * 
  *     if hs:
  */
-  if (!(likely(((__pyx_v_doctag_locks) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_doctag_locks, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 580, __pyx_L1_error)
+  if (!(likely(((__pyx_v_doctag_locks) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_doctag_locks, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 581, __pyx_L1_error)
   __pyx_v__doctag_locks = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_doctag_locks)));
 
-  /* "gensim/models/doc2vec_inner.pyx":582
+  /* "gensim/models/doc2vec_inner.pyx":583
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   __pyx_t_8 = (__pyx_v_hs != 0);
   if (__pyx_t_8) {
 
-    /* "gensim/models/doc2vec_inner.pyx":583
+    /* "gensim/models/doc2vec_inner.pyx":584
  * 
  *     if hs:
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))             # <<<<<<<<<<<<<<
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))             # <<<<<<<<<<<<<<
  * 
  *     if negative:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 584, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 583, __pyx_L1_error)
-    __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 584, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 584, __pyx_L1_error)
+    __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":582
+    /* "gensim/models/doc2vec_inner.pyx":583
  *     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":585
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+  /* "gensim/models/doc2vec_inner.pyx":586
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   __pyx_t_8 = (__pyx_v_negative != 0);
   if (__pyx_t_8) {
 
-    /* "gensim/models/doc2vec_inner.pyx":586
+    /* "gensim/models/doc2vec_inner.pyx":587
  * 
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))             # <<<<<<<<<<<<<<
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))             # <<<<<<<<<<<<<<
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 586, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 587, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 586, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 587, __pyx_L1_error)
     __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":587
+    /* "gensim/models/doc2vec_inner.pyx":588
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))             # <<<<<<<<<<<<<<
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))             # <<<<<<<<<<<<<<
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 588, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 587, __pyx_L1_error)
-    __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 588, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 588, __pyx_L1_error)
+    __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":588
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)             # <<<<<<<<<<<<<<
+    /* "gensim/models/doc2vec_inner.pyx":589
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)             # <<<<<<<<<<<<<<
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 588, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 589, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 589, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_7 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 588, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_7 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 589, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_v_cum_table_len = __pyx_t_7;
 
-    /* "gensim/models/doc2vec_inner.pyx":585
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+    /* "gensim/models/doc2vec_inner.pyx":586
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":589
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+  /* "gensim/models/doc2vec_inner.pyx":590
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -7389,143 +7468,149 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
   __pyx_L11_bool_binop_done:;
   if (__pyx_t_8) {
 
-    /* "gensim/models/doc2vec_inner.pyx":590
- *         cum_table_len = len(model.cum_table)
+    /* "gensim/models/doc2vec_inner.pyx":591
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 590, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 590, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 591, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 590, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 590, __pyx_L1_error)
+    __pyx_t_1 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 591, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 590, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 590, __pyx_L1_error)
+    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 591, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 590, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __pyx_t_10 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 590, __pyx_L1_error)
+    __pyx_t_10 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 591, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_11 = __Pyx_PyInt_As_unsigned_PY_LONG_LONG(__pyx_t_10); if (unlikely((__pyx_t_11 == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 590, __pyx_L1_error)
+    __pyx_t_11 = __Pyx_PyInt_As_unsigned_PY_LONG_LONG(__pyx_t_10); if (unlikely((__pyx_t_11 == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 591, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
     __pyx_v_next_random = __pyx_t_11;
 
-    /* "gensim/models/doc2vec_inner.pyx":589
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+    /* "gensim/models/doc2vec_inner.pyx":590
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":593
+  /* "gensim/models/doc2vec_inner.pyx":594
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  *     if work is None:             # <<<<<<<<<<<<<<
- *        work = zeros(model.layer1_size, dtype=REAL)
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  */
   __pyx_t_8 = (__pyx_v_work == Py_None);
   __pyx_t_9 = (__pyx_t_8 != 0);
   if (__pyx_t_9) {
 
-    /* "gensim/models/doc2vec_inner.pyx":594
+    /* "gensim/models/doc2vec_inner.pyx":595
  *     # convert Python structures to primitive types, so we can release the GIL
  *     if work is None:
- *        work = zeros(model.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  *     if neu1 is None:
  */
-    __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_zeros); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 594, __pyx_L1_error)
+    __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_zeros); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 595, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 594, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 594, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 595, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __Pyx_GIVEREF(__pyx_t_3);
-    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
-    __pyx_t_3 = 0;
-    __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 594, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_REAL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 594, __pyx_L1_error)
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+    __pyx_t_1 = 0;
+    __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 595, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_REAL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 595, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_12);
-    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_12) < 0) __PYX_ERR(0, 594, __pyx_L1_error)
+    if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_12) < 0) __PYX_ERR(0, 595, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
-    __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 594, __pyx_L1_error)
+    __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 595, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_12);
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __Pyx_DECREF_SET(__pyx_v_work, __pyx_t_12);
     __pyx_t_12 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":593
+    /* "gensim/models/doc2vec_inner.pyx":594
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  *     if work is None:             # <<<<<<<<<<<<<<
- *        work = zeros(model.layer1_size, dtype=REAL)
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":595
+  /* "gensim/models/doc2vec_inner.pyx":596
  *     if work is None:
- *        work = zeros(model.layer1_size, dtype=REAL)
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)             # <<<<<<<<<<<<<<
  *     if neu1 is None:
- *        neu1 = zeros(model.layer1_size, dtype=REAL)
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
  */
-  if (!(likely(((__pyx_v_work) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_work, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 595, __pyx_L1_error)
+  if (!(likely(((__pyx_v_work) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_work, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 596, __pyx_L1_error)
   __pyx_v__work = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_work)));
 
-  /* "gensim/models/doc2vec_inner.pyx":596
- *        work = zeros(model.layer1_size, dtype=REAL)
+  /* "gensim/models/doc2vec_inner.pyx":597
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  *     if neu1 is None:             # <<<<<<<<<<<<<<
- *        neu1 = zeros(model.layer1_size, dtype=REAL)
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
  */
   __pyx_t_9 = (__pyx_v_neu1 == Py_None);
   __pyx_t_8 = (__pyx_t_9 != 0);
   if (__pyx_t_8) {
 
-    /* "gensim/models/doc2vec_inner.pyx":597
+    /* "gensim/models/doc2vec_inner.pyx":598
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  *     if neu1 is None:
- *        neu1 = zeros(model.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)             # <<<<<<<<<<<<<<
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
  * 
  */
-    __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_zeros); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 597, __pyx_L1_error)
+    __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_zeros); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 598, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_12);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 597, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 598, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 598, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 597, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 598, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_GIVEREF(__pyx_t_3);
     PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
     __pyx_t_3 = 0;
-    __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 597, __pyx_L1_error)
+    __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 598, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_REAL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 597, __pyx_L1_error)
+    __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_REAL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 598, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
-    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(0, 597, __pyx_L1_error)
+    if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_10) < 0) __PYX_ERR(0, 598, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
-    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 597, __pyx_L1_error)
+    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 598, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
     __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -7533,41 +7618,41 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
     __Pyx_DECREF_SET(__pyx_v_neu1, __pyx_t_10);
     __pyx_t_10 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":596
- *        work = zeros(model.layer1_size, dtype=REAL)
+    /* "gensim/models/doc2vec_inner.pyx":597
+ *        work = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _work = <REAL_t *>np.PyArray_DATA(work)
  *     if neu1 is None:             # <<<<<<<<<<<<<<
- *        neu1 = zeros(model.layer1_size, dtype=REAL)
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
  */
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":598
+  /* "gensim/models/doc2vec_inner.pyx":599
  *     if neu1 is None:
- *        neu1 = zeros(model.layer1_size, dtype=REAL)
+ *        neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)             # <<<<<<<<<<<<<<
  * 
  *     vlookup = model.wv.vocab
  */
-  if (!(likely(((__pyx_v_neu1) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_neu1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 598, __pyx_L1_error)
+  if (!(likely(((__pyx_v_neu1) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_neu1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 599, __pyx_L1_error)
   __pyx_v__neu1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_neu1)));
 
-  /* "gensim/models/doc2vec_inner.pyx":600
+  /* "gensim/models/doc2vec_inner.pyx":601
  *     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
  * 
  *     vlookup = model.wv.vocab             # <<<<<<<<<<<<<<
  *     i = 0
  *     for token in doc_words:
  */
-  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 600, __pyx_L1_error)
+  __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 601, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_10);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_vocab); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_vocab); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
   __pyx_v_vlookup = __pyx_t_3;
   __pyx_t_3 = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":601
+  /* "gensim/models/doc2vec_inner.pyx":602
  * 
  *     vlookup = model.wv.vocab
  *     i = 0             # <<<<<<<<<<<<<<
@@ -7576,7 +7661,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
   __pyx_v_i = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":602
+  /* "gensim/models/doc2vec_inner.pyx":603
  *     vlookup = model.wv.vocab
  *     i = 0
  *     for token in doc_words:             # <<<<<<<<<<<<<<
@@ -7587,26 +7672,26 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
     __pyx_t_3 = __pyx_v_doc_words; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0;
     __pyx_t_13 = NULL;
   } else {
-    __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_doc_words); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error)
+    __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_doc_words); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 603, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 602, __pyx_L1_error)
+    __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 603, __pyx_L1_error)
   }
   for (;;) {
     if (likely(!__pyx_t_13)) {
       if (likely(PyList_CheckExact(__pyx_t_3))) {
         if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_10 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_10); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 602, __pyx_L1_error)
+        __pyx_t_10 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_10); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 603, __pyx_L1_error)
         #else
-        __pyx_t_10 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 602, __pyx_L1_error)
+        __pyx_t_10 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 603, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_10);
         #endif
       } else {
         if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_10 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_10); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 602, __pyx_L1_error)
+        __pyx_t_10 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_10); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 603, __pyx_L1_error)
         #else
-        __pyx_t_10 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 602, __pyx_L1_error)
+        __pyx_t_10 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 603, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_10);
         #endif
       }
@@ -7616,7 +7701,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
           if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
-          else __PYX_ERR(0, 602, __pyx_L1_error)
+          else __PYX_ERR(0, 603, __pyx_L1_error)
         }
         break;
       }
@@ -7625,16 +7710,16 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
     __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_10);
     __pyx_t_10 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":603
+    /* "gensim/models/doc2vec_inner.pyx":604
  *     i = 0
  *     for token in doc_words:
  *         predict_word = vlookup[token] if token in vlookup else None             # <<<<<<<<<<<<<<
  *         if predict_word is None:  # shrink document to leave out word
  *             continue  # leaving i unchanged
  */
-    __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_v_token, __pyx_v_vlookup, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 603, __pyx_L1_error)
+    __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_v_token, __pyx_v_vlookup, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 604, __pyx_L1_error)
     if ((__pyx_t_8 != 0)) {
-      __pyx_t_1 = PyObject_GetItem(__pyx_v_vlookup, __pyx_v_token); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 603, __pyx_L1_error)
+      __pyx_t_1 = PyObject_GetItem(__pyx_v_vlookup, __pyx_v_token); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 604, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_1);
       __pyx_t_10 = __pyx_t_1;
       __pyx_t_1 = 0;
@@ -7645,7 +7730,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
     __Pyx_XDECREF_SET(__pyx_v_predict_word, __pyx_t_10);
     __pyx_t_10 = 0;
 
-    /* "gensim/models/doc2vec_inner.pyx":604
+    /* "gensim/models/doc2vec_inner.pyx":605
  *     for token in doc_words:
  *         predict_word = vlookup[token] if token in vlookup else None
  *         if predict_word is None:  # shrink document to leave out word             # <<<<<<<<<<<<<<
@@ -7656,7 +7741,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
     __pyx_t_9 = (__pyx_t_8 != 0);
     if (__pyx_t_9) {
 
-      /* "gensim/models/doc2vec_inner.pyx":605
+      /* "gensim/models/doc2vec_inner.pyx":606
  *         predict_word = vlookup[token] if token in vlookup else None
  *         if predict_word is None:  # shrink document to leave out word
  *             continue  # leaving i unchanged             # <<<<<<<<<<<<<<
@@ -7665,7 +7750,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
       goto __pyx_L15_continue;
 
-      /* "gensim/models/doc2vec_inner.pyx":604
+      /* "gensim/models/doc2vec_inner.pyx":605
  *     for token in doc_words:
  *         predict_word = vlookup[token] if token in vlookup else None
  *         if predict_word is None:  # shrink document to leave out word             # <<<<<<<<<<<<<<
@@ -7674,7 +7759,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
     }
 
-    /* "gensim/models/doc2vec_inner.pyx":606
+    /* "gensim/models/doc2vec_inner.pyx":607
  *         if predict_word is None:  # shrink document to leave out word
  *             continue  # leaving i unchanged
  *         if sample and predict_word.sample_int < random_int32(&next_random):             # <<<<<<<<<<<<<<
@@ -7687,20 +7772,20 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
       __pyx_t_9 = __pyx_t_8;
       goto __pyx_L19_bool_binop_done;
     }
-    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_sample_int); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 606, __pyx_L1_error)
+    __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_sample_int); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 607, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_10);
-    __pyx_t_1 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(__pyx_f_6gensim_6models_14word2vec_inner_random_int32((&__pyx_v_next_random))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 606, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(__pyx_f_6gensim_6models_14word2vec_inner_random_int32((&__pyx_v_next_random))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 607, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_12 = PyObject_RichCompare(__pyx_t_10, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 606, __pyx_L1_error)
+    __pyx_t_12 = PyObject_RichCompare(__pyx_t_10, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 607, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 606, __pyx_L1_error)
+    __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 607, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
     __pyx_t_9 = __pyx_t_8;
     __pyx_L19_bool_binop_done:;
     if (__pyx_t_9) {
 
-      /* "gensim/models/doc2vec_inner.pyx":607
+      /* "gensim/models/doc2vec_inner.pyx":608
  *             continue  # leaving i unchanged
  *         if sample and predict_word.sample_int < random_int32(&next_random):
  *             continue             # <<<<<<<<<<<<<<
@@ -7709,7 +7794,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
       goto __pyx_L15_continue;
 
-      /* "gensim/models/doc2vec_inner.pyx":606
+      /* "gensim/models/doc2vec_inner.pyx":607
  *         if predict_word is None:  # shrink document to leave out word
  *             continue  # leaving i unchanged
  *         if sample and predict_word.sample_int < random_int32(&next_random):             # <<<<<<<<<<<<<<
@@ -7718,20 +7803,20 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
     }
 
-    /* "gensim/models/doc2vec_inner.pyx":608
+    /* "gensim/models/doc2vec_inner.pyx":609
  *         if sample and predict_word.sample_int < random_int32(&next_random):
  *             continue
  *         indexes[i] = predict_word.index             # <<<<<<<<<<<<<<
  *         if hs:
  *             codelens[i] = <int>len(predict_word.code)
  */
-    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_index); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 608, __pyx_L1_error)
+    __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_index); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 609, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_12);
-    __pyx_t_14 = __Pyx_PyInt_As_npy_uint32(__pyx_t_12); if (unlikely((__pyx_t_14 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 608, __pyx_L1_error)
+    __pyx_t_14 = __Pyx_PyInt_As_npy_uint32(__pyx_t_12); if (unlikely((__pyx_t_14 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 609, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
     (__pyx_v_indexes[__pyx_v_i]) = __pyx_t_14;
 
-    /* "gensim/models/doc2vec_inner.pyx":609
+    /* "gensim/models/doc2vec_inner.pyx":610
  *             continue
  *         indexes[i] = predict_word.index
  *         if hs:             # <<<<<<<<<<<<<<
@@ -7741,46 +7826,46 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
     __pyx_t_9 = (__pyx_v_hs != 0);
     if (__pyx_t_9) {
 
-      /* "gensim/models/doc2vec_inner.pyx":610
+      /* "gensim/models/doc2vec_inner.pyx":611
  *         indexes[i] = predict_word.index
  *         if hs:
  *             codelens[i] = <int>len(predict_word.code)             # <<<<<<<<<<<<<<
  *             codes[i] = <np.uint8_t *>np.PyArray_DATA(predict_word.code)
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)
  */
-      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_code); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 610, __pyx_L1_error)
+      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_code); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 611, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_12);
-      __pyx_t_5 = PyObject_Length(__pyx_t_12); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(0, 610, __pyx_L1_error)
+      __pyx_t_5 = PyObject_Length(__pyx_t_12); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(0, 611, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
       (__pyx_v_codelens[__pyx_v_i]) = ((int)__pyx_t_5);
 
-      /* "gensim/models/doc2vec_inner.pyx":611
+      /* "gensim/models/doc2vec_inner.pyx":612
  *         if hs:
  *             codelens[i] = <int>len(predict_word.code)
  *             codes[i] = <np.uint8_t *>np.PyArray_DATA(predict_word.code)             # <<<<<<<<<<<<<<
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)
  *         result += 1
  */
-      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_code); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 611, __pyx_L1_error)
+      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_code); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 612, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_12);
-      if (!(likely(((__pyx_t_12) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_12, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 611, __pyx_L1_error)
+      if (!(likely(((__pyx_t_12) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_12, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 612, __pyx_L1_error)
       (__pyx_v_codes[__pyx_v_i]) = ((__pyx_t_5numpy_uint8_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_12)));
       __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
 
-      /* "gensim/models/doc2vec_inner.pyx":612
+      /* "gensim/models/doc2vec_inner.pyx":613
  *             codelens[i] = <int>len(predict_word.code)
  *             codes[i] = <np.uint8_t *>np.PyArray_DATA(predict_word.code)
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)             # <<<<<<<<<<<<<<
  *         result += 1
  *         i += 1
  */
-      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_point); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 612, __pyx_L1_error)
+      __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_predict_word, __pyx_n_s_point); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 613, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_12);
-      if (!(likely(((__pyx_t_12) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_12, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 612, __pyx_L1_error)
+      if (!(likely(((__pyx_t_12) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_12, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 613, __pyx_L1_error)
       (__pyx_v_points[__pyx_v_i]) = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_12)));
       __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
 
-      /* "gensim/models/doc2vec_inner.pyx":609
+      /* "gensim/models/doc2vec_inner.pyx":610
  *             continue
  *         indexes[i] = predict_word.index
  *         if hs:             # <<<<<<<<<<<<<<
@@ -7789,7 +7874,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
     }
 
-    /* "gensim/models/doc2vec_inner.pyx":613
+    /* "gensim/models/doc2vec_inner.pyx":614
  *             codes[i] = <np.uint8_t *>np.PyArray_DATA(predict_word.code)
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)
  *         result += 1             # <<<<<<<<<<<<<<
@@ -7798,7 +7883,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
     __pyx_v_result = (__pyx_v_result + 1);
 
-    /* "gensim/models/doc2vec_inner.pyx":614
+    /* "gensim/models/doc2vec_inner.pyx":615
  *             points[i] = <np.uint32_t *>np.PyArray_DATA(predict_word.point)
  *         result += 1
  *         i += 1             # <<<<<<<<<<<<<<
@@ -7807,7 +7892,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
     __pyx_v_i = (__pyx_v_i + 1);
 
-    /* "gensim/models/doc2vec_inner.pyx":615
+    /* "gensim/models/doc2vec_inner.pyx":616
  *         result += 1
  *         i += 1
  *         if i == MAX_DOCUMENT_LEN:             # <<<<<<<<<<<<<<
@@ -7817,7 +7902,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
     __pyx_t_9 = ((__pyx_v_i == 0x2710) != 0);
     if (__pyx_t_9) {
 
-      /* "gensim/models/doc2vec_inner.pyx":616
+      /* "gensim/models/doc2vec_inner.pyx":617
  *         i += 1
  *         if i == MAX_DOCUMENT_LEN:
  *             break  # TODO: log warning, tally overflow?             # <<<<<<<<<<<<<<
@@ -7826,7 +7911,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
       goto __pyx_L16_break;
 
-      /* "gensim/models/doc2vec_inner.pyx":615
+      /* "gensim/models/doc2vec_inner.pyx":616
  *         result += 1
  *         i += 1
  *         if i == MAX_DOCUMENT_LEN:             # <<<<<<<<<<<<<<
@@ -7835,7 +7920,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
     }
 
-    /* "gensim/models/doc2vec_inner.pyx":602
+    /* "gensim/models/doc2vec_inner.pyx":603
  *     vlookup = model.wv.vocab
  *     i = 0
  *     for token in doc_words:             # <<<<<<<<<<<<<<
@@ -7847,7 +7932,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
   __pyx_L16_break:;
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":617
+  /* "gensim/models/doc2vec_inner.pyx":618
  *         if i == MAX_DOCUMENT_LEN:
  *             break  # TODO: log warning, tally overflow?
  *     document_len = i             # <<<<<<<<<<<<<<
@@ -7856,7 +7941,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
   __pyx_v_document_len = __pyx_v_i;
 
-  /* "gensim/models/doc2vec_inner.pyx":619
+  /* "gensim/models/doc2vec_inner.pyx":620
  *     document_len = i
  * 
  *     for i in range(doctag_len):             # <<<<<<<<<<<<<<
@@ -7867,20 +7952,20 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
   for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_2; __pyx_t_15+=1) {
     __pyx_v_i = __pyx_t_15;
 
-    /* "gensim/models/doc2vec_inner.pyx":620
+    /* "gensim/models/doc2vec_inner.pyx":621
  * 
  *     for i in range(doctag_len):
  *         _doctag_indexes[i] = doctag_indexes[i]             # <<<<<<<<<<<<<<
  *         result += 1
  * 
  */
-    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_doctag_indexes, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 620, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_doctag_indexes, __pyx_v_i, int, 1, __Pyx_PyInt_From_int, 0, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 621, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __pyx_t_14 = __Pyx_PyInt_As_npy_uint32(__pyx_t_3); if (unlikely((__pyx_t_14 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 620, __pyx_L1_error)
+    __pyx_t_14 = __Pyx_PyInt_As_npy_uint32(__pyx_t_3); if (unlikely((__pyx_t_14 == ((npy_uint32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 621, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     (__pyx_v__doctag_indexes[__pyx_v_i]) = __pyx_t_14;
 
-    /* "gensim/models/doc2vec_inner.pyx":621
+    /* "gensim/models/doc2vec_inner.pyx":622
  *     for i in range(doctag_len):
  *         _doctag_indexes[i] = doctag_indexes[i]
  *         result += 1             # <<<<<<<<<<<<<<
@@ -7890,7 +7975,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
     __pyx_v_result = (__pyx_v_result + 1);
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":624
+  /* "gensim/models/doc2vec_inner.pyx":625
  * 
  *     # release GIL & train on the document
  *     with nogil:             # <<<<<<<<<<<<<<
@@ -7904,7 +7989,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
       #endif
       /*try:*/ {
 
-        /* "gensim/models/doc2vec_inner.pyx":625
+        /* "gensim/models/doc2vec_inner.pyx":626
  *     # release GIL & train on the document
  *     with nogil:
  *         for i in range(document_len):             # <<<<<<<<<<<<<<
@@ -7915,7 +8000,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
         for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_2; __pyx_t_15+=1) {
           __pyx_v_i = __pyx_t_15;
 
-          /* "gensim/models/doc2vec_inner.pyx":626
+          /* "gensim/models/doc2vec_inner.pyx":627
  *     with nogil:
  *         for i in range(document_len):
  *             j = i - window      # negative OK: will pad with null word             # <<<<<<<<<<<<<<
@@ -7924,7 +8009,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
           __pyx_v_j = (__pyx_v_i - __pyx_v_window);
 
-          /* "gensim/models/doc2vec_inner.pyx":627
+          /* "gensim/models/doc2vec_inner.pyx":628
  *         for i in range(document_len):
  *             j = i - window      # negative OK: will pad with null word
  *             k = i + window + 1  # past document end OK: will pad with null word             # <<<<<<<<<<<<<<
@@ -7933,7 +8018,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
           __pyx_v_k = ((__pyx_v_i + __pyx_v_window) + 1);
 
-          /* "gensim/models/doc2vec_inner.pyx":630
+          /* "gensim/models/doc2vec_inner.pyx":631
  * 
  *             # compose l1 & clear work
  *             for m in range(doctag_len):             # <<<<<<<<<<<<<<
@@ -7944,7 +8029,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
           for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) {
             __pyx_v_m = __pyx_t_17;
 
-            /* "gensim/models/doc2vec_inner.pyx":632
+            /* "gensim/models/doc2vec_inner.pyx":633
  *             for m in range(doctag_len):
  *                 # doc vector(s)
  *                 memcpy(&_neu1[m * vector_size], &_doctag_vectors[_doctag_indexes[m] * vector_size],             # <<<<<<<<<<<<<<
@@ -7954,7 +8039,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
             memcpy((&(__pyx_v__neu1[(__pyx_v_m * __pyx_v_vector_size)])), (&(__pyx_v__doctag_vectors[((__pyx_v__doctag_indexes[__pyx_v_m]) * __pyx_v_vector_size)])), (__pyx_v_vector_size * (sizeof(__pyx_t_6gensim_6models_14word2vec_inner_REAL_t))));
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":634
+          /* "gensim/models/doc2vec_inner.pyx":635
  *                 memcpy(&_neu1[m * vector_size], &_doctag_vectors[_doctag_indexes[m] * vector_size],
  *                        vector_size * cython.sizeof(REAL_t))
  *             n = 0             # <<<<<<<<<<<<<<
@@ -7963,7 +8048,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
           __pyx_v_n = 0;
 
-          /* "gensim/models/doc2vec_inner.pyx":635
+          /* "gensim/models/doc2vec_inner.pyx":636
  *                        vector_size * cython.sizeof(REAL_t))
  *             n = 0
  *             for m in range(j, k):             # <<<<<<<<<<<<<<
@@ -7974,7 +8059,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
           for (__pyx_t_17 = __pyx_v_j; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) {
             __pyx_v_m = __pyx_t_17;
 
-            /* "gensim/models/doc2vec_inner.pyx":637
+            /* "gensim/models/doc2vec_inner.pyx":638
  *             for m in range(j, k):
  *                 # word vectors in window
  *                 if m == i:             # <<<<<<<<<<<<<<
@@ -7984,7 +8069,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
             __pyx_t_9 = ((__pyx_v_m == __pyx_v_i) != 0);
             if (__pyx_t_9) {
 
-              /* "gensim/models/doc2vec_inner.pyx":638
+              /* "gensim/models/doc2vec_inner.pyx":639
  *                 # word vectors in window
  *                 if m == i:
  *                     continue             # <<<<<<<<<<<<<<
@@ -7993,7 +8078,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
               goto __pyx_L32_continue;
 
-              /* "gensim/models/doc2vec_inner.pyx":637
+              /* "gensim/models/doc2vec_inner.pyx":638
  *             for m in range(j, k):
  *                 # word vectors in window
  *                 if m == i:             # <<<<<<<<<<<<<<
@@ -8002,7 +8087,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
             }
 
-            /* "gensim/models/doc2vec_inner.pyx":639
+            /* "gensim/models/doc2vec_inner.pyx":640
  *                 if m == i:
  *                     continue
  *                 if m < 0 or m >= document_len:             # <<<<<<<<<<<<<<
@@ -8020,7 +8105,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
             __pyx_L36_bool_binop_done:;
             if (__pyx_t_9) {
 
-              /* "gensim/models/doc2vec_inner.pyx":640
+              /* "gensim/models/doc2vec_inner.pyx":641
  *                     continue
  *                 if m < 0 or m >= document_len:
  *                     window_indexes[n] =  null_word_index             # <<<<<<<<<<<<<<
@@ -8029,7 +8114,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
               (__pyx_v_window_indexes[__pyx_v_n]) = __pyx_v_null_word_index;
 
-              /* "gensim/models/doc2vec_inner.pyx":639
+              /* "gensim/models/doc2vec_inner.pyx":640
  *                 if m == i:
  *                     continue
  *                 if m < 0 or m >= document_len:             # <<<<<<<<<<<<<<
@@ -8039,7 +8124,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
               goto __pyx_L35;
             }
 
-            /* "gensim/models/doc2vec_inner.pyx":642
+            /* "gensim/models/doc2vec_inner.pyx":643
  *                     window_indexes[n] =  null_word_index
  *                 else:
  *                     window_indexes[n] = indexes[m]             # <<<<<<<<<<<<<<
@@ -8051,7 +8136,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
             }
             __pyx_L35:;
 
-            /* "gensim/models/doc2vec_inner.pyx":643
+            /* "gensim/models/doc2vec_inner.pyx":644
  *                 else:
  *                     window_indexes[n] = indexes[m]
  *                 n += 1             # <<<<<<<<<<<<<<
@@ -8062,7 +8147,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
             __pyx_L32_continue:;
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":644
+          /* "gensim/models/doc2vec_inner.pyx":645
  *                     window_indexes[n] = indexes[m]
  *                 n += 1
  *             for m in range(2 * window):             # <<<<<<<<<<<<<<
@@ -8073,7 +8158,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
           for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_6; __pyx_t_16+=1) {
             __pyx_v_m = __pyx_t_16;
 
-            /* "gensim/models/doc2vec_inner.pyx":645
+            /* "gensim/models/doc2vec_inner.pyx":646
  *                 n += 1
  *             for m in range(2 * window):
  *                 memcpy(&_neu1[(doctag_len + m) * vector_size], &_word_vectors[window_indexes[m] * vector_size],             # <<<<<<<<<<<<<<
@@ -8083,7 +8168,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
             memcpy((&(__pyx_v__neu1[((__pyx_v_doctag_len + __pyx_v_m) * __pyx_v_vector_size)])), (&(__pyx_v__word_vectors[((__pyx_v_window_indexes[__pyx_v_m]) * __pyx_v_vector_size)])), (__pyx_v_vector_size * (sizeof(__pyx_t_6gensim_6models_14word2vec_inner_REAL_t))));
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":647
+          /* "gensim/models/doc2vec_inner.pyx":648
  *                 memcpy(&_neu1[(doctag_len + m) * vector_size], &_word_vectors[window_indexes[m] * vector_size],
  *                        vector_size * cython.sizeof(REAL_t))
  *             memset(_work, 0, layer1_size * cython.sizeof(REAL_t))  # work to accumulate l1 error             # <<<<<<<<<<<<<<
@@ -8092,7 +8177,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
           memset(__pyx_v__work, 0, (__pyx_v_layer1_size * (sizeof(__pyx_t_6gensim_6models_14word2vec_inner_REAL_t))));
 
-          /* "gensim/models/doc2vec_inner.pyx":649
+          /* "gensim/models/doc2vec_inner.pyx":650
  *             memset(_work, 0, layer1_size * cython.sizeof(REAL_t))  # work to accumulate l1 error
  * 
  *             if hs:             # <<<<<<<<<<<<<<
@@ -8102,7 +8187,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
           __pyx_t_9 = (__pyx_v_hs != 0);
           if (__pyx_t_9) {
 
-            /* "gensim/models/doc2vec_inner.pyx":650
+            /* "gensim/models/doc2vec_inner.pyx":651
  * 
  *             if hs:
  *                 fast_document_dmc_hs(points[i], codes[i], codelens[i],             # <<<<<<<<<<<<<<
@@ -8111,7 +8196,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
             __pyx_f_6gensim_6models_13doc2vec_inner_fast_document_dmc_hs((__pyx_v_points[__pyx_v_i]), (__pyx_v_codes[__pyx_v_i]), (__pyx_v_codelens[__pyx_v_i]), __pyx_v__neu1, __pyx_v_syn1, __pyx_v__alpha, __pyx_v__work, __pyx_v_layer1_size, __pyx_v_vector_size, __pyx_v__learn_hidden);
 
-            /* "gensim/models/doc2vec_inner.pyx":649
+            /* "gensim/models/doc2vec_inner.pyx":650
  *             memset(_work, 0, layer1_size * cython.sizeof(REAL_t))  # work to accumulate l1 error
  * 
  *             if hs:             # <<<<<<<<<<<<<<
@@ -8120,7 +8205,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":653
+          /* "gensim/models/doc2vec_inner.pyx":654
  *                                      _neu1, syn1, _alpha, _work,
  *                                      layer1_size, vector_size, _learn_hidden)
  *             if negative:             # <<<<<<<<<<<<<<
@@ -8130,7 +8215,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
           __pyx_t_9 = (__pyx_v_negative != 0);
           if (__pyx_t_9) {
 
-            /* "gensim/models/doc2vec_inner.pyx":654
+            /* "gensim/models/doc2vec_inner.pyx":655
  *                                      layer1_size, vector_size, _learn_hidden)
  *             if negative:
  *                 next_random = fast_document_dmc_neg(negative, cum_table, cum_table_len, next_random,             # <<<<<<<<<<<<<<
@@ -8139,7 +8224,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
             __pyx_v_next_random = __pyx_f_6gensim_6models_13doc2vec_inner_fast_document_dmc_neg(__pyx_v_negative, __pyx_v_cum_table, __pyx_v_cum_table_len, __pyx_v_next_random, __pyx_v__neu1, __pyx_v_syn1neg, (__pyx_v_indexes[__pyx_v_i]), __pyx_v__alpha, __pyx_v__work, __pyx_v_layer1_size, __pyx_v_vector_size, __pyx_v__learn_hidden);
 
-            /* "gensim/models/doc2vec_inner.pyx":653
+            /* "gensim/models/doc2vec_inner.pyx":654
  *                                      _neu1, syn1, _alpha, _work,
  *                                      layer1_size, vector_size, _learn_hidden)
  *             if negative:             # <<<<<<<<<<<<<<
@@ -8148,7 +8233,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":658
+          /* "gensim/models/doc2vec_inner.pyx":659
  *                                                    layer1_size, vector_size, _learn_hidden)
  * 
  *             if _learn_doctags:             # <<<<<<<<<<<<<<
@@ -8158,7 +8243,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
           __pyx_t_9 = (__pyx_v__learn_doctags != 0);
           if (__pyx_t_9) {
 
-            /* "gensim/models/doc2vec_inner.pyx":659
+            /* "gensim/models/doc2vec_inner.pyx":660
  * 
  *             if _learn_doctags:
  *                 for m in range(doctag_len):             # <<<<<<<<<<<<<<
@@ -8169,7 +8254,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
             for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) {
               __pyx_v_m = __pyx_t_17;
 
-              /* "gensim/models/doc2vec_inner.pyx":660
+              /* "gensim/models/doc2vec_inner.pyx":661
  *             if _learn_doctags:
  *                 for m in range(doctag_len):
  *                     our_saxpy(&vector_size, &_doctag_locks[_doctag_indexes[m]], &_work[m * vector_size],             # <<<<<<<<<<<<<<
@@ -8179,7 +8264,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
               __pyx_v_6gensim_6models_14word2vec_inner_our_saxpy((&__pyx_v_vector_size), (&(__pyx_v__doctag_locks[(__pyx_v__doctag_indexes[__pyx_v_m])])), (&(__pyx_v__work[(__pyx_v_m * __pyx_v_vector_size)])), (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE), (&(__pyx_v__doctag_vectors[((__pyx_v__doctag_indexes[__pyx_v_m]) * __pyx_v_vector_size)])), (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE));
             }
 
-            /* "gensim/models/doc2vec_inner.pyx":658
+            /* "gensim/models/doc2vec_inner.pyx":659
  *                                                    layer1_size, vector_size, _learn_hidden)
  * 
  *             if _learn_doctags:             # <<<<<<<<<<<<<<
@@ -8188,7 +8273,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
  */
           }
 
-          /* "gensim/models/doc2vec_inner.pyx":662
+          /* "gensim/models/doc2vec_inner.pyx":663
  *                     our_saxpy(&vector_size, &_doctag_locks[_doctag_indexes[m]], &_work[m * vector_size],
  *                               &ONE, &_doctag_vectors[_doctag_indexes[m] * vector_size], &ONE)
  *             if _learn_words:             # <<<<<<<<<<<<<<
@@ -8198,7 +8283,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
           __pyx_t_9 = (__pyx_v__learn_words != 0);
           if (__pyx_t_9) {
 
-            /* "gensim/models/doc2vec_inner.pyx":663
+            /* "gensim/models/doc2vec_inner.pyx":664
  *                               &ONE, &_doctag_vectors[_doctag_indexes[m] * vector_size], &ONE)
  *             if _learn_words:
  *                 for m in range(2 * window):             # <<<<<<<<<<<<<<
@@ -8209,7 +8294,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
             for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_6; __pyx_t_16+=1) {
               __pyx_v_m = __pyx_t_16;
 
-              /* "gensim/models/doc2vec_inner.pyx":664
+              /* "gensim/models/doc2vec_inner.pyx":665
  *             if _learn_words:
  *                 for m in range(2 * window):
  *                     our_saxpy(&vector_size, &_word_locks[window_indexes[m]], &_work[(doctag_len + m) * vector_size],             # <<<<<<<<<<<<<<
@@ -8219,7 +8304,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
               __pyx_v_6gensim_6models_14word2vec_inner_our_saxpy((&__pyx_v_vector_size), (&(__pyx_v__word_locks[(__pyx_v_window_indexes[__pyx_v_m])])), (&(__pyx_v__work[((__pyx_v_doctag_len + __pyx_v_m) * __pyx_v_vector_size)])), (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE), (&(__pyx_v__word_vectors[((__pyx_v_window_indexes[__pyx_v_m]) * __pyx_v_vector_size)])), (&__pyx_v_6gensim_6models_13doc2vec_inner_ONE));
             }
 
-            /* "gensim/models/doc2vec_inner.pyx":662
+            /* "gensim/models/doc2vec_inner.pyx":663
  *                     our_saxpy(&vector_size, &_doctag_locks[_doctag_indexes[m]], &_work[m * vector_size],
  *                               &ONE, &_doctag_vectors[_doctag_indexes[m] * vector_size], &ONE)
  *             if _learn_words:             # <<<<<<<<<<<<<<
@@ -8230,7 +8315,7 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
         }
       }
 
-      /* "gensim/models/doc2vec_inner.pyx":624
+      /* "gensim/models/doc2vec_inner.pyx":625
  * 
  *     # release GIL & train on the document
  *     with nogil:             # <<<<<<<<<<<<<<
@@ -8248,19 +8333,19 @@ static PyObject *__pyx_pf_6gensim_6models_13doc2vec_inner_4train_document_dm_con
       }
   }
 
-  /* "gensim/models/doc2vec_inner.pyx":667
+  /* "gensim/models/doc2vec_inner.pyx":668
  *                               &ONE, &_word_vectors[window_indexes[m] * vector_size], &ONE)
  * 
  *     return result             # <<<<<<<<<<<<<<
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 667, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 668, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __pyx_r = __pyx_t_3;
   __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "gensim/models/doc2vec_inner.pyx":520
+  /* "gensim/models/doc2vec_inner.pyx":521
  * 
  * 
  * def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None, neu1=None,             # <<<<<<<<<<<<<<
@@ -10854,8 +10939,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_doctag_len, __pyx_k_doctag_len, sizeof(__pyx_k_doctag_len), 0, 0, 1, 1},
   {&__pyx_n_s_doctag_locks, __pyx_k_doctag_locks, sizeof(__pyx_k_doctag_locks), 0, 0, 1, 1},
   {&__pyx_n_s_doctag_locks_2, __pyx_k_doctag_locks_2, sizeof(__pyx_k_doctag_locks_2), 0, 0, 1, 1},
-  {&__pyx_n_s_doctag_syn0, __pyx_k_doctag_syn0, sizeof(__pyx_k_doctag_syn0), 0, 0, 1, 1},
-  {&__pyx_n_s_doctag_syn0_lockf, __pyx_k_doctag_syn0_lockf, sizeof(__pyx_k_doctag_syn0_lockf), 0, 0, 1, 1},
   {&__pyx_n_s_doctag_vectors, __pyx_k_doctag_vectors, sizeof(__pyx_k_doctag_vectors), 0, 0, 1, 1},
   {&__pyx_n_s_doctag_vectors_2, __pyx_k_doctag_vectors_2, sizeof(__pyx_k_doctag_vectors_2), 0, 0, 1, 1},
   {&__pyx_n_s_document_len, __pyx_k_document_len, sizeof(__pyx_k_document_len), 0, 0, 1, 1},
@@ -10911,8 +10994,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_sample_int, __pyx_k_sample_int, sizeof(__pyx_k_sample_int), 0, 0, 1, 1},
   {&__pyx_n_s_scipy_linalg_blas, __pyx_k_scipy_linalg_blas, sizeof(__pyx_k_scipy_linalg_blas), 0, 0, 1, 1},
   {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
-  {&__pyx_n_s_syn0, __pyx_k_syn0, sizeof(__pyx_k_syn0), 0, 0, 1, 1},
-  {&__pyx_n_s_syn0_lockf, __pyx_k_syn0_lockf, sizeof(__pyx_k_syn0_lockf), 0, 0, 1, 1},
   {&__pyx_n_s_syn1, __pyx_k_syn1, sizeof(__pyx_k_syn1), 0, 0, 1, 1},
   {&__pyx_n_s_syn1neg, __pyx_k_syn1neg, sizeof(__pyx_k_syn1neg), 0, 0, 1, 1},
   {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
@@ -10922,10 +11003,16 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_train_document_dm_concat, __pyx_k_train_document_dm_concat, sizeof(__pyx_k_train_document_dm_concat), 0, 0, 1, 1},
   {&__pyx_n_s_train_words, __pyx_k_train_words, sizeof(__pyx_k_train_words), 0, 0, 1, 1},
   {&__pyx_n_s_train_words_2, __pyx_k_train_words_2, sizeof(__pyx_k_train_words_2), 0, 0, 1, 1},
+  {&__pyx_n_s_trainables, __pyx_k_trainables, sizeof(__pyx_k_trainables), 0, 0, 1, 1},
   {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
   {&__pyx_n_s_vector_size, __pyx_k_vector_size, sizeof(__pyx_k_vector_size), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors, __pyx_k_vectors, sizeof(__pyx_k_vectors), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors_docs, __pyx_k_vectors_docs, sizeof(__pyx_k_vectors_docs), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors_docs_lockf, __pyx_k_vectors_docs_lockf, sizeof(__pyx_k_vectors_docs_lockf), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors_lockf, __pyx_k_vectors_lockf, sizeof(__pyx_k_vectors_lockf), 0, 0, 1, 1},
   {&__pyx_n_s_vlookup, __pyx_k_vlookup, sizeof(__pyx_k_vlookup), 0, 0, 1, 1},
   {&__pyx_n_s_vocab, __pyx_k_vocab, sizeof(__pyx_k_vocab), 0, 0, 1, 1},
+  {&__pyx_n_s_vocabulary, __pyx_k_vocabulary, sizeof(__pyx_k_vocabulary), 0, 0, 1, 1},
   {&__pyx_n_s_window, __pyx_k_window, sizeof(__pyx_k_window), 0, 0, 1, 1},
   {&__pyx_n_s_window_indexes, __pyx_k_window_indexes, sizeof(__pyx_k_window_indexes), 0, 0, 1, 1},
   {&__pyx_n_s_word2vec, __pyx_k_word2vec, sizeof(__pyx_k_word2vec), 0, 0, 1, 1},
@@ -10955,7 +11042,7 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
   /* "gensim/models/doc2vec_inner.pyx":291
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
@@ -10968,31 +11055,31 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_GOTREF(__pyx_tuple__2);
   __Pyx_GIVEREF(__pyx_tuple__2);
 
-  /* "gensim/models/doc2vec_inner.pyx":428
- *         cum_table_len = len(model.cum_table)
+  /* "gensim/models/doc2vec_inner.pyx":429
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  */
-  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_16777216); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 428, __pyx_L1_error)
+  __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_16777216); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 429, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__3);
   __Pyx_GIVEREF(__pyx_tuple__3);
-  __pyx_tuple__4 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_16777216); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 428, __pyx_L1_error)
+  __pyx_tuple__4 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_16777216); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 429, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__4);
   __Pyx_GIVEREF(__pyx_tuple__4);
 
-  /* "gensim/models/doc2vec_inner.pyx":590
- *         cum_table_len = len(model.cum_table)
+  /* "gensim/models/doc2vec_inner.pyx":591
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  */
-  __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_16777216); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 590, __pyx_L1_error)
+  __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_16777216); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 591, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__6);
   __Pyx_GIVEREF(__pyx_tuple__6);
-  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_16777216); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 590, __pyx_L1_error)
+  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_16777216); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 591, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__7);
   __Pyx_GIVEREF(__pyx_tuple__7);
 
@@ -11117,17 +11204,17 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_GIVEREF(__pyx_tuple__20);
   __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(13, 0, 53, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_gensim_models_doc2vec_inner_pyx, __pyx_n_s_train_document_dm, 363, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 363, __pyx_L1_error)
 
-  /* "gensim/models/doc2vec_inner.pyx":520
+  /* "gensim/models/doc2vec_inner.pyx":521
  * 
  * 
  * def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None, neu1=None,             # <<<<<<<<<<<<<<
  *                              learn_doctags=True, learn_words=True, learn_hidden=True,
  *                              word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
  */
-  __pyx_tuple__22 = PyTuple_Pack(53, __pyx_n_s_model, __pyx_n_s_doc_words, __pyx_n_s_doctag_indexes, __pyx_n_s_alpha, __pyx_n_s_work, __pyx_n_s_neu1, __pyx_n_s_learn_doctags, __pyx_n_s_learn_words, __pyx_n_s_learn_hidden, __pyx_n_s_word_vectors, __pyx_n_s_word_locks, __pyx_n_s_doctag_vectors, __pyx_n_s_doctag_locks, __pyx_n_s_hs, __pyx_n_s_negative, __pyx_n_s_sample, __pyx_n_s_learn_doctags_2, __pyx_n_s_learn_words_2, __pyx_n_s_learn_hidden_2, __pyx_n_s_word_vectors_2, __pyx_n_s_doctag_vectors_2, __pyx_n_s_word_locks_2, __pyx_n_s_doctag_locks_2, __pyx_n_s_work_2, __pyx_n_s_neu1_2, __pyx_n_s_alpha_2, __pyx_n_s_layer1_size, __pyx_n_s_vector_size, __pyx_n_s_codelens, __pyx_n_s_indexes, __pyx_n_s_doctag_indexes_2, __pyx_n_s_window_indexes, __pyx_n_s_document_len, __pyx_n_s_doctag_len, __pyx_n_s_window, __pyx_n_s_expected_doctag_len, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_m, __pyx_n_s_n, __pyx_n_s_result, __pyx_n_s_null_word_index, __pyx_n_s_syn1, __pyx_n_s_points, __pyx_n_s_codes, __pyx_n_s_syn1neg, __pyx_n_s_cum_table, __pyx_n_s_cum_table_len, __pyx_n_s_next_random, __pyx_n_s_vlookup, __pyx_n_s_token, __pyx_n_s_predict_word); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 520, __pyx_L1_error)
+  __pyx_tuple__22 = PyTuple_Pack(53, __pyx_n_s_model, __pyx_n_s_doc_words, __pyx_n_s_doctag_indexes, __pyx_n_s_alpha, __pyx_n_s_work, __pyx_n_s_neu1, __pyx_n_s_learn_doctags, __pyx_n_s_learn_words, __pyx_n_s_learn_hidden, __pyx_n_s_word_vectors, __pyx_n_s_word_locks, __pyx_n_s_doctag_vectors, __pyx_n_s_doctag_locks, __pyx_n_s_hs, __pyx_n_s_negative, __pyx_n_s_sample, __pyx_n_s_learn_doctags_2, __pyx_n_s_learn_words_2, __pyx_n_s_learn_hidden_2, __pyx_n_s_word_vectors_2, __pyx_n_s_doctag_vectors_2, __pyx_n_s_word_locks_2, __pyx_n_s_doctag_locks_2, __pyx_n_s_work_2, __pyx_n_s_neu1_2, __pyx_n_s_alpha_2, __pyx_n_s_layer1_size, __pyx_n_s_vector_size, __pyx_n_s_codelens, __pyx_n_s_indexes, __pyx_n_s_doctag_indexes_2, __pyx_n_s_window_indexes, __pyx_n_s_document_len, __pyx_n_s_doctag_len, __pyx_n_s_window, __pyx_n_s_expected_doctag_len, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_m, __pyx_n_s_n, __pyx_n_s_result, __pyx_n_s_null_word_index, __pyx_n_s_syn1, __pyx_n_s_points, __pyx_n_s_codes, __pyx_n_s_syn1neg, __pyx_n_s_cum_table, __pyx_n_s_cum_table_len, __pyx_n_s_next_random, __pyx_n_s_vlookup, __pyx_n_s_token, __pyx_n_s_predict_word); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 521, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__22);
   __Pyx_GIVEREF(__pyx_tuple__22);
-  __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(13, 0, 53, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_gensim_models_doc2vec_inner_pyx, __pyx_n_s_train_document_dm_concat, 520, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 520, __pyx_L1_error)
+  __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(13, 0, 53, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_gensim_models_doc2vec_inner_pyx, __pyx_n_s_train_document_dm_concat, 521, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(0, 521, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -11496,16 +11583,16 @@ PyMODINIT_FUNC PyInit_doc2vec_inner(void)
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_train_document_dm, __pyx_t_4) < 0) __PYX_ERR(0, 363, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
-  /* "gensim/models/doc2vec_inner.pyx":520
+  /* "gensim/models/doc2vec_inner.pyx":521
  * 
  * 
  * def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None, neu1=None,             # <<<<<<<<<<<<<<
  *                              learn_doctags=True, learn_words=True, learn_hidden=True,
  *                              word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
  */
-  __pyx_t_4 = PyCFunction_NewEx(&__pyx_mdef_6gensim_6models_13doc2vec_inner_5train_document_dm_concat, NULL, __pyx_n_s_gensim_models_doc2vec_inner); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 520, __pyx_L1_error)
+  __pyx_t_4 = PyCFunction_NewEx(&__pyx_mdef_6gensim_6models_13doc2vec_inner_5train_document_dm_concat, NULL, __pyx_n_s_gensim_models_doc2vec_inner); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 521, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_train_document_dm_concat, __pyx_t_4) < 0) __PYX_ERR(0, 520, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_train_document_dm_concat, __pyx_t_4) < 0) __PYX_ERR(0, 521, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
   /* "gensim/models/doc2vec_inner.pyx":1
diff --git a/gensim/models/doc2vec_inner.pyx b/gensim/models/doc2vec_inner.pyx
index c4fee9ed0d..b41e8a8a3a 100644
--- a/gensim/models/doc2vec_inner.pyx
+++ b/gensim/models/doc2vec_inner.pyx
@@ -229,7 +229,7 @@ def train_document_dbow(model, doc_words, doctag_indexes, alpha, work=None,
                         word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
     cdef int hs = model.hs
     cdef int negative = model.negative
-    cdef int sample = (model.sample != 0)
+    cdef int sample = (model.vocabulary.sample != 0)
     cdef int _train_words = train_words
     cdef int _learn_words = learn_words
     cdef int _learn_hidden = learn_hidden
@@ -241,7 +241,7 @@ def train_document_dbow(model, doc_words, doctag_indexes, alpha, work=None,
     cdef REAL_t *_doctag_locks
     cdef REAL_t *_work
     cdef REAL_t _alpha = alpha
-    cdef int size = model.layer1_size
+    cdef int size = model.trainables.layer1_size
 
     cdef int codelens[MAX_DOCUMENT_LEN]
     cdef np.uint32_t indexes[MAX_DOCUMENT_LEN]
@@ -268,31 +268,31 @@ def train_document_dbow(model, doc_words, doctag_indexes, alpha, work=None,
 
     # default vectors, locks from syn0/doctag_syn0
     if word_vectors is None:
-       word_vectors = model.wv.syn0
+       word_vectors = model.wv.vectors
     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
     if doctag_vectors is None:
-       doctag_vectors = model.docvecs.doctag_syn0
+       doctag_vectors = model.docvecs.vectors_docs
     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
     if word_locks is None:
-       word_locks = model.syn0_lockf
+       word_locks = model.trainables.vectors_lockf
     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
     if doctag_locks is None:
-       doctag_locks = model.docvecs.doctag_syn0_lockf
+       doctag_locks = model.trainables.vectors_docs_lockf
     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
 
     if hs:
-        syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+        syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
 
     if negative:
-        syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
-        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
-        cum_table_len = len(model.cum_table)
+        syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+        cum_table_len = len(model.vocabulary.cum_table)
     if negative or sample:
         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
 
     # convert Python structures to primitive types, so we can release the GIL
     if work is None:
-       work = zeros(model.layer1_size, dtype=REAL)
+       work = zeros(model.trainables.layer1_size, dtype=REAL)
     _work = <REAL_t *>np.PyArray_DATA(work)
 
     vlookup = model.wv.vocab
@@ -365,7 +365,7 @@ def train_document_dm(model, doc_words, doctag_indexes, alpha, work=None, neu1=N
                       word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
     cdef int hs = model.hs
     cdef int negative = model.negative
-    cdef int sample = (model.sample != 0)
+    cdef int sample = (model.vocabulary.sample != 0)
     cdef int _learn_doctags = learn_doctags
     cdef int _learn_words = learn_words
     cdef int _learn_hidden = learn_hidden
@@ -379,7 +379,7 @@ def train_document_dm(model, doc_words, doctag_indexes, alpha, work=None, neu1=N
     cdef REAL_t *_work
     cdef REAL_t *_neu1
     cdef REAL_t _alpha = alpha
-    cdef int size = model.layer1_size
+    cdef int size = model.trainables.layer1_size
 
     cdef int codelens[MAX_DOCUMENT_LEN]
     cdef np.uint32_t indexes[MAX_DOCUMENT_LEN]
@@ -403,36 +403,37 @@ def train_document_dm(model, doc_words, doctag_indexes, alpha, work=None, neu1=N
     cdef unsigned long long cum_table_len
     cdef unsigned long long next_random
 
+
     # default vectors, locks from syn0/doctag_syn0
     if word_vectors is None:
-       word_vectors = model.wv.syn0
+        word_vectors = model.wv.vectors
     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
     if doctag_vectors is None:
-       doctag_vectors = model.docvecs.doctag_syn0
+        doctag_vectors = model.docvecs.vectors_docs
     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
     if word_locks is None:
-       word_locks = model.syn0_lockf
+        word_locks = model.trainables.vectors_lockf
     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
     if doctag_locks is None:
-       doctag_locks = model.docvecs.doctag_syn0_lockf
+        doctag_locks = model.trainables.vectors_docs_lockf
     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
 
     if hs:
-        syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+        syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
 
     if negative:
-        syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
-        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
-        cum_table_len = len(model.cum_table)
+        syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+        cum_table_len = len(model.vocabulary.cum_table)
     if negative or sample:
         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
 
     # convert Python structures to primitive types, so we can release the GIL
     if work is None:
-       work = zeros(model.layer1_size, dtype=REAL)
+       work = zeros(model.trainables.layer1_size, dtype=REAL)
     _work = <REAL_t *>np.PyArray_DATA(work)
     if neu1 is None:
-       neu1 = zeros(model.layer1_size, dtype=REAL)
+       neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
 
     vlookup = model.wv.vocab
@@ -522,7 +523,7 @@ def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None,
                              word_vectors=None, word_locks=None, doctag_vectors=None, doctag_locks=None):
     cdef int hs = model.hs
     cdef int negative = model.negative
-    cdef int sample = (model.sample != 0)
+    cdef int sample = (model.vocabulary.sample != 0)
     cdef int _learn_doctags = learn_doctags
     cdef int _learn_words = learn_words
     cdef int _learn_hidden = learn_hidden
@@ -534,8 +535,8 @@ def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None,
     cdef REAL_t *_work
     cdef REAL_t *_neu1
     cdef REAL_t _alpha = alpha
-    cdef int layer1_size = model.layer1_size
-    cdef int vector_size = model.vector_size
+    cdef int layer1_size = model.trainables.layer1_size
+    cdef int vector_size = model.docvecs.vector_size
 
     cdef int codelens[MAX_DOCUMENT_LEN]
     cdef np.uint32_t indexes[MAX_DOCUMENT_LEN]
@@ -567,34 +568,34 @@ def train_document_dm_concat(model, doc_words, doctag_indexes, alpha, work=None,
 
     # default vectors, locks from syn0/doctag_syn0
     if word_vectors is None:
-       word_vectors = model.wv.syn0
+       word_vectors = model.wv.vectors
     _word_vectors = <REAL_t *>(np.PyArray_DATA(word_vectors))
     if doctag_vectors is None:
-       doctag_vectors = model.docvecs.doctag_syn0
+       doctag_vectors = model.docvecs.vectors_docs
     _doctag_vectors = <REAL_t *>(np.PyArray_DATA(doctag_vectors))
     if word_locks is None:
-       word_locks = model.syn0_lockf
+       word_locks = model.trainables.vectors_lockf
     _word_locks = <REAL_t *>(np.PyArray_DATA(word_locks))
     if doctag_locks is None:
-       doctag_locks = model.docvecs.doctag_syn0_lockf
+       doctag_locks = model.trainables.vectors_docs_lockf
     _doctag_locks = <REAL_t *>(np.PyArray_DATA(doctag_locks))
 
     if hs:
-        syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+        syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
 
     if negative:
-        syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
-        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
-        cum_table_len = len(model.cum_table)
+        syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+        cum_table_len = len(model.vocabulary.cum_table)
     if negative or sample:
         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
 
     # convert Python structures to primitive types, so we can release the GIL
     if work is None:
-       work = zeros(model.layer1_size, dtype=REAL)
+       work = zeros(model.trainables.layer1_size, dtype=REAL)
     _work = <REAL_t *>np.PyArray_DATA(work)
     if neu1 is None:
-       neu1 = zeros(model.layer1_size, dtype=REAL)
+       neu1 = zeros(model.trainables.layer1_size, dtype=REAL)
     _neu1 = <REAL_t *>np.PyArray_DATA(neu1)
 
     vlookup = model.wv.vocab
diff --git a/gensim/models/fasttext.py b/gensim/models/fasttext.py
index b52b8ecbde..6ea76819cf 100644
--- a/gensim/models/fasttext.py
+++ b/gensim/models/fasttext.py
@@ -1,7 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-# Authors: Chinmaya Pancholi <chinmayapancholi13@gmail.com>, Shiva Manne <s.manne@rare-technologies.com>
-# Copyright (C) 2017 RaRe Technologies s.r.o.
+#
+# Authors: Shiva Manne <manneshiva@gmail.com>, Chinmaya Pancholi <chinmayapancholi13@gmail.com>
+# Copyright (C) 2018 RaRe Technologies s.r.o.
+# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
 
 """Learn word representations via fasttext's "skip-gram and CBOW models", using either
 hierarchical softmax or negative sampling [1]_.
@@ -27,36 +29,37 @@
 """
 
 import logging
+import struct
 
 import numpy as np
-from numpy import zeros, ones, vstack, sum as np_sum, empty, float32 as REAL
+from numpy import ones, vstack, empty, float32 as REAL, sum as np_sum
 
-from gensim.models.word2vec import Word2Vec, train_sg_pair, train_cbow_pair
-from gensim.models.wrappers.fasttext import FastTextKeyedVectors
-from gensim.models.wrappers.fasttext import FastText as Ft_Wrapper, compute_ngrams, ft_hash
+from gensim.models.word2vec import Word2VecVocab, Word2VecTrainables, train_sg_pair, train_cbow_pair
+from gensim.models.keyedvectors import Vocab, FastTextKeyedVectors
+from gensim.models.base_any2vec import BaseWordEmbeddingsModel
+from gensim.models.utils_any2vec import _compute_ngrams, _ft_hash
+
+from six import iteritems
+from gensim.utils import deprecated, call_on_class_only
+from gensim import utils
 
 logger = logging.getLogger(__name__)
 
 try:
     from gensim.models.fasttext_inner import train_batch_sg, train_batch_cbow
     from gensim.models.fasttext_inner import FAST_VERSION, MAX_WORDS_IN_BATCH
-    logger.debug('Fast version of Fasttext is being used')
 
 except ImportError:
     # failed... fall back to plain numpy (20-80x slower training than the above)
-    logger.warning('Slow version of Fasttext is being used')
     FAST_VERSION = -1
     MAX_WORDS_IN_BATCH = 10000
 
     def train_batch_cbow(model, sentences, alpha, work=None, neu1=None):
         """Update CBOW model by training on a sequence of sentences.
-
         Each sentence is a list of string tokens, which are looked up in the model's
         vocab dictionary. Called internally from :meth:`gensim.models.fasttext.FastText.train()`.
-
         This is the non-optimized, Python version. If you have cython installed, gensim
         will use the optimized version from fasttext_inner instead.
-
         Parameters
         ----------
         model : :class:`~gensim.models.fasttext.FastText`
@@ -69,17 +72,15 @@ def train_batch_cbow(model, sentences, alpha, work=None, neu1=None):
             Private working memory for each worker.
         neu1 : :class:`numpy.ndarray`
             Private working memory for each worker.
-
         Returns
         -------
         int
             Effective number of words trained.
-
         """
         result = 0
         for sentence in sentences:
             word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab and
-                           model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+                           model.wv.vocab[w].sample_int > model.random.rand() * 2 ** 32]
             for pos, word in enumerate(word_vocabs):
                 reduced_window = model.random.randint(model.window)
                 start = max(0, pos - model.window + reduced_window)
@@ -112,13 +113,10 @@ def train_batch_cbow(model, sentences, alpha, work=None, neu1=None):
 
     def train_batch_sg(model, sentences, alpha, work=None, neu1=None):
         """Update skip-gram model by training on a sequence of sentences.
-
         Each sentence is a list of string tokens, which are looked up in the model's
         vocab dictionary. Called internally from :meth:`gensim.models.fasttext.FastText.train()`.
-
         This is the non-optimized, Python version. If you have cython installed, gensim
         will use the optimized version from fasttext_inner instead.
-
         Parameters
         ----------
         model : :class:`~gensim.models.fasttext.FastText`
@@ -131,17 +129,15 @@ def train_batch_sg(model, sentences, alpha, work=None, neu1=None):
             Private working memory for each worker.
         neu1 : :class:`numpy.ndarray`
             Private working memory for each worker.
-
         Returns
         -------
         int
             Effective number of words trained.
-
         """
         result = 0
         for sentence in sentences:
             word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab and
-                           model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+                           model.wv.vocab[w].sample_int > model.random.rand() * 2 ** 32]
             for pos, word in enumerate(word_vocabs):
                 reduced_window = model.random.randint(model.window)  # `b` in the original word2vec code
                 # now go over all words from the (reduced) window, predicting each one in turn
@@ -160,8 +156,10 @@ def train_batch_sg(model, sentences, alpha, work=None, neu1=None):
             result += len(word_vocabs)
         return result
 
+FASTTEXT_FILEFORMAT_MAGIC = 793712314
 
-class FastText(Word2Vec):
+
+class FastText(BaseWordEmbeddingsModel):
     """Class for training, using and evaluating word representations learned using method
     described in [1]_ aka Fasttext.
 
@@ -170,11 +168,10 @@ class FastText(Word2Vec):
     fasttext implementation via :meth:`~gensim.models.fasttext.FastText.load_fasttext_format()`.
 
     """
-    def __init__(
-            self, sentences=None, sg=0, hs=0, size=100, alpha=0.025, window=5, min_count=5,
-            max_vocab_size=None, word_ngrams=1, sample=1e-3, seed=1, workers=3, min_alpha=0.0001,
-            negative=5, cbow_mean=1, hashfxn=hash, iter=5, null_word=0, min_n=3, max_n=6, sorted_vocab=1,
-            bucket=2000000, trim_rule=None, batch_words=MAX_WORDS_IN_BATCH):
+    def __init__(self, sentences=None, sg=0, hs=0, size=100, alpha=0.025, window=5, min_count=5,
+                 max_vocab_size=None, word_ngrams=1, sample=1e-3, seed=1, workers=3, min_alpha=0.0001,
+                 negative=5, cbow_mean=1, hashfxn=hash, iter=5, null_word=0, min_n=3, max_n=6, sorted_vocab=1,
+                 bucket=2000000, trim_rule=None, batch_words=MAX_WORDS_IN_BATCH, callbacks=()):
         """Initialize the model from an iterable of `sentences`. Each sentence is a
         list of words (unicode strings) that will be used for training.
 
@@ -252,6 +249,8 @@ def __init__(
         bucket : int
             Character ngrams are hashed into a fixed number of buckets, in order to limit the
             memory usage of the model. This option specifies the number of buckets used by the model.
+        callbacks : :obj: `list` of :obj: `~gensim.models.callbacks.CallbackAny2Vec`
+            List of callbacks that need to be executed/run at specific stages during training.
 
         Examples
         --------
@@ -266,27 +265,76 @@ def __init__(
 
 
         """
-        # fastText specific params
-        self.bucket = bucket
-        self.word_ngrams = word_ngrams
-        self.min_n = min_n
-        self.max_n = max_n
-        if self.word_ngrams <= 1 and self.max_n == 0:
-            self.bucket = 0
+        self.load = call_on_class_only
+        self.load_fasttext_format = call_on_class_only
+        self.callbacks = callbacks
+        self.word_ngrams = int(word_ngrams)
+        if self.word_ngrams <= 1 and max_n == 0:
+            bucket = 0
+
+        self.wv = FastTextKeyedVectors(size, min_n, max_n)
+        self.vocabulary = FastTextVocab(
+            max_vocab_size=max_vocab_size, min_count=min_count, sample=sample,
+            sorted_vocab=bool(sorted_vocab), null_word=null_word)
+        self.trainables = FastTextTrainables(
+            vector_size=size, seed=seed, bucket=bucket, hashfxn=hashfxn)
 
         super(FastText, self).__init__(
-            sentences=sentences, size=size, alpha=alpha, window=window, min_count=min_count,
-            max_vocab_size=max_vocab_size, sample=sample, seed=seed, workers=workers, min_alpha=min_alpha,
-            sg=sg, hs=hs, negative=negative, cbow_mean=cbow_mean, hashfxn=hashfxn, iter=iter, null_word=null_word,
-            trim_rule=trim_rule, sorted_vocab=sorted_vocab, batch_words=batch_words)
-
-    def initialize_word_vectors(self):
-        """Initializes FastTextKeyedVectors instance to store all vocab/ngram vectors for the model."""
-        self.wv = FastTextKeyedVectors()
-        self.wv.min_n = self.min_n
-        self.wv.max_n = self.max_n
-
-    def build_vocab(self, sentences, keep_raw_vocab=False, trim_rule=None, progress_per=10000, update=False):
+            sentences=sentences, workers=workers, vector_size=size, epochs=iter, callbacks=callbacks,
+            batch_words=batch_words, trim_rule=trim_rule, sg=sg, alpha=alpha, window=window, seed=seed,
+            hs=hs, negative=negative, cbow_mean=cbow_mean, min_alpha=min_alpha, fast_version=FAST_VERSION)
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use wv.min_n instead")
+    def min_n(self):
+        return self.wv.min_n
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use wv.max_n instead")
+    def max_n(self):
+        return self.wv.max_n
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use trainables.bucket instead")
+    def bucket(self):
+        return self.trainables.bucket
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.vectors_vocab_lockf instead")
+    def syn0_vocab_lockf(self):
+        return self.trainables.vectors_vocab_lockf
+
+    @syn0_vocab_lockf.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.vectors_vocab_lockf instead")
+    def syn0_vocab_lockf(self, value):
+        self.trainables.vectors_vocab_lockf = value
+
+    @syn0_vocab_lockf.deleter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.vectors_vocab_lockf instead")
+    def syn0_vocab_lockf(self):
+        del self.trainables.vectors_vocab_lockf
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.vectors_ngrams_lockf instead")
+    def syn0_ngrams_lockf(self):
+        return self.trainables.vectors_ngrams_lockf
+
+    @syn0_ngrams_lockf.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.vectors_ngrams_lockf instead")
+    def syn0_ngrams_lockf(self, value):
+        self.trainables.vectors_ngrams_lockf = value
+
+    @syn0_ngrams_lockf.deleter
+    @deprecated("Attribute will be removed in 4.0.0, use self.trainables.vectors_ngrams_lockf instead")
+    def syn0_ngrams_lockf(self):
+        del self.trainables.vectors_ngrams_lockf
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.wv.num_ngram_vectors instead")
+    def num_ngram_vectors(self):
+        return self.wv.num_ngram_vectors
+
+    def build_vocab(self, sentences, update=False, progress_per=10000, keep_raw_vocab=False, trim_rule=None, **kwargs):
         """Build vocabulary from a sequence of sentences (can be a once-only generator stream).
         Each sentence must be a list of unicode strings.
 
@@ -309,7 +357,7 @@ def build_vocab(self, sentences, keep_raw_vocab=False, trim_rule=None, progress_
             of the model.
         progress_per : int
             Indicates how many words to process before showing/updating the progress.
-        update: bool
+        update : bool
             If true, the new words in `sentences` will be added to model's vocab.
 
         Example
@@ -333,111 +381,20 @@ def build_vocab(self, sentences, keep_raw_vocab=False, trim_rule=None, progress_
                     "You cannot do an online vocabulary-update of a model which has no prior vocabulary. "
                     "First build the vocabulary of your model with a corpus "
                     "before doing an online update.")
-            self.old_vocab_len = len(self.wv.vocab)
-            self.old_hash2index_len = len(self.wv.hash2index)
-
-        super(FastText, self).build_vocab(
-            sentences, keep_raw_vocab=keep_raw_vocab, trim_rule=trim_rule, progress_per=progress_per, update=update)
-        self.init_ngrams(update=update)
-
-    def init_ngrams(self, update=False):
-        """Compute ngrams of all words present in vocabulary and stores vectors for only those ngrams.
-        Vectors for other ngrams are initialized with a random uniform distribution in FastText.
-
-        Parameters
-        ----------
-        update : bool
-            If True, the new vocab words and their new ngrams word vectors are initialized
-            with random uniform distribution and updated/added to the existing vocab word and ngram vectors.
-
-        """
-        if not update:
-            self.wv.ngrams = {}
-            self.wv.syn0_vocab = empty((len(self.wv.vocab), self.vector_size), dtype=REAL)
-            self.syn0_vocab_lockf = ones((len(self.wv.vocab), self.vector_size), dtype=REAL)
-
-            self.wv.syn0_ngrams = empty((self.bucket, self.vector_size), dtype=REAL)
-            self.syn0_ngrams_lockf = ones((self.bucket, self.vector_size), dtype=REAL)
+            self.vocabulary.old_vocab_len = len(self.wv.vocab)
+            self.trainables.old_hash2index_len = len(self.wv.hash2index)
 
-            all_ngrams = []
-            for w, v in self.wv.vocab.items():
-                self.wv.ngrams_word[w] = compute_ngrams(w, self.min_n, self.max_n)
-                all_ngrams += self.wv.ngrams_word[w]
+        return super(FastText, self).build_vocab(
+            sentences, update=update, progress_per=progress_per,
+            keep_raw_vocab=keep_raw_vocab, trim_rule=trim_rule, **kwargs)
 
-            all_ngrams = list(set(all_ngrams))
-            self.num_ngram_vectors = len(all_ngrams)
-            logger.info("Total number of ngrams is %d", len(all_ngrams))
-
-            self.wv.hash2index = {}
-            ngram_indices = []
-            new_hash_count = 0
-            for i, ngram in enumerate(all_ngrams):
-                ngram_hash = ft_hash(ngram) % self.bucket
-                if ngram_hash in self.wv.hash2index:
-                    self.wv.ngrams[ngram] = self.wv.hash2index[ngram_hash]
-                else:
-                    ngram_indices.append(ngram_hash % self.bucket)
-                    self.wv.hash2index[ngram_hash] = new_hash_count
-                    self.wv.ngrams[ngram] = self.wv.hash2index[ngram_hash]
-                    new_hash_count = new_hash_count + 1
+    def _set_train_params(self, **kwargs):
+        pass
 
-            self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)
-            self.syn0_ngrams_lockf = self.syn0_ngrams_lockf.take(ngram_indices, axis=0)
-            self.reset_ngram_weights()
-        else:
-            new_ngrams = []
-            for w, v in self.wv.vocab.items():
-                self.wv.ngrams_word[w] = compute_ngrams(w, self.min_n, self.max_n)
-                new_ngrams += [ng for ng in self.wv.ngrams_word[w] if ng not in self.wv.ngrams]
-
-            new_ngrams = list(set(new_ngrams))
-            logger.info("Number of new ngrams is %d", len(new_ngrams))
-            new_hash_count = 0
-            for i, ngram in enumerate(new_ngrams):
-                ngram_hash = ft_hash(ngram) % self.bucket
-                if ngram_hash not in self.wv.hash2index:
-                    self.wv.hash2index[ngram_hash] = new_hash_count + self.old_hash2index_len
-                    self.wv.ngrams[ngram] = self.wv.hash2index[ngram_hash]
-                    new_hash_count = new_hash_count + 1
-                else:
-                    self.wv.ngrams[ngram] = self.wv.hash2index[ngram_hash]
-
-            rand_obj = np.random
-            rand_obj.seed(self.seed)
-            new_vocab_rows = rand_obj.uniform(
-                -1.0 / self.vector_size, 1.0 / self.vector_size,
-                (len(self.wv.vocab) - self.old_vocab_len, self.vector_size)
-            ).astype(REAL)
-            new_vocab_lockf_rows = ones((len(self.wv.vocab) - self.old_vocab_len, self.vector_size), dtype=REAL)
-            new_ngram_rows = rand_obj.uniform(
-                -1.0 / self.vector_size, 1.0 / self.vector_size,
-                (len(self.wv.hash2index) - self.old_hash2index_len, self.vector_size)
-            ).astype(REAL)
-            new_ngram_lockf_rows = ones(
-                (len(self.wv.hash2index) - self.old_hash2index_len,
-                self.vector_size),
-                dtype=REAL)
-
-            self.wv.syn0_vocab = vstack([self.wv.syn0_vocab, new_vocab_rows])
-            self.syn0_vocab_lockf = vstack([self.syn0_vocab_lockf, new_vocab_lockf_rows])
-            self.wv.syn0_ngrams = vstack([self.wv.syn0_ngrams, new_ngram_rows])
-            self.syn0_ngrams_lockf = vstack([self.syn0_ngrams_lockf, new_ngram_lockf_rows])
-
-    def reset_ngram_weights(self):
-        """Reset all projection weights to an initial (untrained) state,
-        but keep the existing vocabulary and their ngrams.
-
-        """
-        rand_obj = np.random
-        rand_obj.seed(self.seed)
-        for index in range(len(self.wv.vocab)):
-            self.wv.syn0_vocab[index] = rand_obj.uniform(
-                -1.0 / self.vector_size, 1.0 / self.vector_size, self.vector_size
-            ).astype(REAL)
-        for index in range(len(self.wv.hash2index)):
-            self.wv.syn0_ngrams[index] = rand_obj.uniform(
-                -1.0 / self.vector_size, 1.0 / self.vector_size, self.vector_size
-            ).astype(REAL)
+    def _clear_post_train(self):
+        self.wv.vectors_norm = None
+        self.wv.vectors_vocab_norm = None
+        self.wv.vectors_ngrams_norm = None
 
     def _do_train_job(self, sentences, alpha, inits):
         """Train a single batch of sentences. Return 2-tuple `(effective word count after
@@ -472,9 +429,9 @@ def _do_train_job(self, sentences, alpha, inits):
 
     def train(self, sentences, total_examples=None, total_words=None,
               epochs=None, start_alpha=None, end_alpha=None,
-              word_count=0, queue_factor=2, report_delay=1.0):
+              word_count=0, queue_factor=2, report_delay=1.0, callbacks=(), **kwargs):
         """Update the model's neural weights from a sequence of sentences (can be a once-only generator stream).
-        For FastText, each sentence must be a list of unicode strings. (Subclasses may accept other examples.)
+        For FastText, each sentence must be a list of unicode strings.
 
         To support linear learning-rate decay from (initial) alpha to min_alpha, and accurate
         progress-percentage logging, either total_examples (count of sentences) or total_words (count of
@@ -511,6 +468,8 @@ def train(self, sentences, total_examples=None, total_words=None,
             Multiplier for size of queue (number of workers * queue_factor).
         report_delay : float
             Seconds to wait before reporting progress.
+        callbacks : :obj: `list` of :obj: `~gensim.models.callbacks.CallbackAny2Vec`
+            List of callbacks that need to be executed/run at specific stages during training.
 
         Examples
         --------
@@ -522,111 +481,402 @@ def train(self, sentences, total_examples=None, total_words=None,
         >>> model.train(sentences, total_examples=model.corpus_count, epochs=model.iter)
 
         """
-        self.neg_labels = []
-        if self.negative > 0:
-                # precompute negative labels optimization for pure-python training
-                self.neg_labels = zeros(self.negative + 1)
-                self.neg_labels[0] = 1.
 
         super(FastText, self).train(
-            sentences, total_examples=total_examples, total_words=total_words, epochs=epochs, start_alpha=start_alpha,
-            end_alpha=end_alpha, word_count=word_count, queue_factor=queue_factor, report_delay=report_delay
-        )
-        self.get_vocab_word_vecs()
+            sentences, total_examples=total_examples, total_words=total_words,
+            epochs=epochs, start_alpha=start_alpha, end_alpha=end_alpha, word_count=word_count,
+            queue_factor=queue_factor, report_delay=report_delay, callbacks=callbacks)
+        self.trainables.get_vocab_word_vecs(self.wv)
 
-    def __getitem__(self, word):
-        """Get `word` representations in vector space, as a 1D numpy array.
+    def init_sims(self, replace=False):
+        """
+        init_sims() resides in KeyedVectors because it deals with syn0 mainly, but because syn1 is not an attribute
+        of KeyedVectors, it has to be deleted in this class, and the normalizing of syn0 happens inside of KeyedVectors
+        """
+        if replace and hasattr(self.trainables, 'syn1'):
+            del self.trainables.syn1
+        return self.wv.init_sims(replace)
 
-        Parameters
-        ----------
-        word : str
-            A single word whose vector needs to be returned.
+    def clear_sims(self):
+        """
+        Removes all L2-normalized vectors for words from the model.
+        You will have to recompute them using init_sims method.
+        """
 
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            The word's representations in vector space, as a 1D numpy array.
+        self._clear_post_train()
 
-        Raises
-        ------
-        KeyError
-            For words with all ngrams absent, a KeyError is raised.
+    @deprecated("Method will be removed in 4.0.0, use self.wv.__getitem__() instead")
+    def __getitem__(self, words):
+        """
+        Deprecated. Use self.wv.__getitem__() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.__getitem__`
+        """
+        return self.wv.__getitem__(words)
 
-        Example
-        -------
-        >>> from gensim.models import FastText
-        >>> from gensim.test.utils import datapath
-        >>>
-        >>> trained_model = FastText.load_fasttext_format(datapath('lee_fasttext'))
-        >>> meow_vector = trained_model['hello']  # get vector for word
+    @deprecated("Method will be removed in 4.0.0, use self.wv.__contains__() instead")
+    def __contains__(self, word):
+        """
+        Deprecated. Use self.wv.__contains__() instead.
+        Refer to the documentation for `gensim.models.KeyedVectors.__contains__`
+        """
+        return self.wv.__contains__(word)
 
+    @classmethod
+    def load_fasttext_format(cls, model_file, encoding='utf8'):
         """
-        return self.word_vec(word)
-
-    def get_vocab_word_vecs(self):
-        """Calculate vectors for words in vocabulary and stores them in `wv.syn0`."""
-        for w, v in self.wv.vocab.items():
-            word_vec = np.copy(self.wv.syn0_vocab[v.index])
-            ngrams = self.wv.ngrams_word[w]
-            ngram_weights = self.wv.syn0_ngrams
-            for ngram in ngrams:
-                word_vec += ngram_weights[self.wv.ngrams[ngram]]
-            word_vec /= (len(ngrams) + 1)
-            self.wv.syn0[v.index] = word_vec
+        Load the input-hidden weight matrix from the fast text output files.
 
-    def word_vec(self, word, use_norm=False):
-        """Get the word's representations in vector space, as a 1D numpy array.
+        Note that due to limitations in the FastText API, you cannot continue training
+        with a model loaded this way, though you can query for word similarity etc.
 
         Parameters
         ----------
-        word : str
-            A single word whose vector needs to be returned.
-        use_norm : bool
-            If True, returns normalized vector.
+        model_file : str
+            Path to the FastText output files.
+            FastText outputs two model files - `/path/to/model.vec` and `/path/to/model.bin`
+            Expected value for this example: `/path/to/model` or `/path/to/model.bin`,
+            as gensim requires only `.bin` file to load entire fastText model.
+        encoding : str
+            Specifies the encoding.
 
         Returns
         -------
-        :class:`numpy.ndarray`
-            The word's representations in vector space, as a 1D numpy array.
+        :obj: `~gensim.models.fasttext.FastText`
+            Returns the loaded model as an instance of :class: `~gensim.models.fasttext.FastText`.
 
-        Raises
-        ------
-        KeyError
-            For words with all ngrams absent, a KeyError is raised.
+        """
+        model = cls()
+        if not model_file.endswith('.bin'):
+            model_file += '.bin'
+        model.file_name = model_file
+        model.load_binary_data(encoding=encoding)
+        return model
+
+    def load_binary_data(self, encoding='utf8'):
+        """Loads data from the output binary file created by FastText training"""
+        with utils.smart_open(self.file_name, 'rb') as f:
+            self._load_model_params(f)
+            self._load_dict(f, encoding=encoding)
+            self._load_vectors(f)
+
+    def _load_model_params(self, file_handle):
+        magic, version = self.struct_unpack(file_handle, '@2i')
+        if magic == FASTTEXT_FILEFORMAT_MAGIC:  # newer format
+            self.new_format = True
+            dim, ws, epoch, min_count, neg, _, loss, model, bucket, minn, maxn, _, t = \
+                self.struct_unpack(file_handle, '@12i1d')
+        else:  # older format
+            self.new_format = False
+            dim = magic
+            ws = version
+            epoch, min_count, neg, _, loss, model, bucket, minn, maxn, _, t = self.struct_unpack(file_handle, '@10i1d')
+        # Parameters stored by [Args::save](https://github.com/facebookresearch/fastText/blob/master/src/args.cc)
+        self.wv.vector_size = dim
+        self.vector_size = dim
+        self.window = ws
+        self.epochs = epoch
+        self.vocabulary.min_count = min_count
+        self.negative = neg
+        self.hs = loss == 1
+        self.sg = model == 2
+        self.trainables.bucket = bucket
+        self.wv.min_n = minn
+        self.wv.max_n = maxn
+        self.vocabulary.sample = t
+
+    def _load_dict(self, file_handle, encoding='utf8'):
+        vocab_size, nwords, nlabels = self.struct_unpack(file_handle, '@3i')
+        # Vocab stored by [Dictionary::save](https://github.com/facebookresearch/fastText/blob/master/src/dictionary.cc)
+        if nlabels > 0:
+            raise NotImplementedError("Supervised fastText models are not supported")
+        logger.info("loading %s words for fastText model from %s", vocab_size, self.file_name)
+
+        self.struct_unpack(file_handle, '@1q')  # number of tokens
+        if self.new_format:
+            pruneidx_size, = self.struct_unpack(file_handle, '@q')
+        for i in range(vocab_size):
+            word_bytes = b''
+            char_byte = file_handle.read(1)
+            # Read vocab word
+            while char_byte != b'\x00':
+                word_bytes += char_byte
+                char_byte = file_handle.read(1)
+            word = word_bytes.decode(encoding)
+            count, _ = self.struct_unpack(file_handle, '@qb')
+
+            self.wv.vocab[word] = Vocab(index=i, count=count)
+            self.wv.index2word.append(word)
+
+        assert len(self.wv.vocab) == nwords, (
+            'mismatch between final vocab size ({} words), '
+            'and expected number of words ({} words)'.format(len(self.wv.vocab), nwords))
+        if len(self.wv.vocab) != vocab_size:
+            # expecting to log this warning only for pretrained french vector, wiki.fr
+            logger.warning(
+                "mismatch between final vocab size (%s words), and expected vocab size (%s words)",
+                len(self.wv.vocab), vocab_size
+            )
+
+        if self.new_format:
+            for j in range(pruneidx_size):
+                self.struct_unpack(file_handle, '@2i')
+
+    def _load_vectors(self, file_handle):
+        if self.new_format:
+            self.struct_unpack(file_handle, '@?')  # bool quant_input in fasttext.cc
+        num_vectors, dim = self.struct_unpack(file_handle, '@2q')
+        # Vectors stored by [Matrix::save](https://github.com/facebookresearch/fastText/blob/master/src/matrix.cc)
+        assert self.wv.vector_size == dim, (
+            'mismatch between vector size in model params ({}) and model vectors ({})'
+            .format(self.wv.vector_size, dim)
+        )
+        float_size = struct.calcsize('@f')
+        if float_size == 4:
+            dtype = np.dtype(np.float32)
+        elif float_size == 8:
+            dtype = np.dtype(np.float64)
+
+        self.num_original_vectors = num_vectors
+        self.wv.vectors_ngrams = np.fromfile(file_handle, dtype=dtype, count=num_vectors * dim)
+        self.wv.vectors_ngrams = self.wv.vectors_ngrams.reshape((num_vectors, dim))
+        assert self.wv.vectors_ngrams.shape == (
+            self.trainables.bucket + len(self.wv.vocab), self.wv.vector_size), \
+            'mismatch between actual weight matrix shape {} and expected shape {}'\
+            .format(
+                self.wv.vectors_ngrams.shape, (self.trainables.bucket + len(self.wv.vocab), self.wv.vector_size)
+            )
+
+        self.trainables.init_ngrams_post_load(self.file_name, self.wv)
+        self._clear_post_train()
+
+    def struct_unpack(self, file_handle, fmt):
+        num_bytes = struct.calcsize(fmt)
+        return struct.unpack(fmt, file_handle.read(num_bytes))
 
-        Example
-        -------
-        >>> from gensim.models import FastText
-        >>> sentences = [["cat", "say", "meow"], ["dog", "say", "woof"]]
-        >>>
-        >>> model = FastText(sentences, min_count=1)
-        >>> meow_vector = model.word_vec('meow')  # get vector for word
+    def save(self, *args, **kwargs):
+        """Save the model. This saved model can be loaded again using :func:`~gensim.models.fasttext.FastText.load`,
+        which supports online training and getting vectors for out-of-vocabulary words.
+
+        Parameters
+        ----------
+        fname : str
+            Path to the file.
 
         """
-        return FastTextKeyedVectors.word_vec(self.wv, word, use_norm=use_norm)
+        kwargs['ignore'] = kwargs.get('ignore', ['vectors_norm', 'vectors_vocab_norm', 'vectors_ngrams_norm'])
+        super(FastText, self).save(*args, **kwargs)
 
     @classmethod
-    def load_fasttext_format(cls, *args, **kwargs):
-        """Load a :class:`~gensim.models.fasttext.FastText` model from a format compatible with
-        the original fasttext implementation.
+    def load(cls, *args, **kwargs):
+        """Loads a previously saved `FastText` model. Also see `save()`.
 
         Parameters
         ----------
         fname : str
-            Path to the file.
+            Path to the saved file.
 
+        Returns
+        -------
+        :obj: `~gensim.models.fasttext.FastText`
+            Returns the loaded model as an instance of :class: `~gensim.models.fasttext.FastText`.
         """
-        return Ft_Wrapper.load_fasttext_format(*args, **kwargs)
+        try:
+            model = super(FastText, cls).load(*args, **kwargs)
+            if not hasattr(model.trainables, 'vectors_vocab_lockf') and hasattr(model.wv, 'vectors_vocab'):
+                model.trainables.vectors_vocab_lockf = ones(len(model.trainables.vectors), dtype=REAL)
+            if not hasattr(model.trainables, 'vectors_ngrams_lockf') and hasattr(model.wv, 'vectors_ngrams'):
+                model.trainables.vectors_ngrams_lockf = ones(len(model.trainables.vectors), dtype=REAL)
+            return model
+        except AttributeError:
+            logger.info('Model saved using code from earlier Gensim Version. Re-loading old model in a compatible way.')
+            from gensim.models.deprecated.fasttext import load_old_fasttext
+            return load_old_fasttext(*args, **kwargs)
+
+    @deprecated("Method will be removed in 4.0.0, use self.wv.accuracy() instead")
+    def accuracy(self, questions, restrict_vocab=30000, most_similar=None, case_insensitive=True):
+        most_similar = most_similar or FastTextKeyedVectors.most_similar
+        return self.wv.accuracy(questions, restrict_vocab, most_similar, case_insensitive)
+
+
+class FastTextVocab(Word2VecVocab):
+    def __init__(self, max_vocab_size=None, min_count=5, sample=1e-3, sorted_vocab=True, null_word=0):
+        super(FastTextVocab, self).__init__(
+            max_vocab_size=max_vocab_size, min_count=min_count, sample=sample,
+            sorted_vocab=sorted_vocab, null_word=null_word)
+
+    def prepare_vocab(self, hs, negative, wv, update=False, keep_raw_vocab=False, trim_rule=None,
+                      min_count=None, sample=None, dry_run=False):
+        report_values = super(FastTextVocab, self).prepare_vocab(
+            hs, negative, wv, update=update, keep_raw_vocab=keep_raw_vocab, trim_rule=trim_rule,
+            min_count=min_count, sample=sample, dry_run=dry_run)
+        self.build_ngrams(wv, update=update)
+        return report_values
+
+    def build_ngrams(self, wv, update=False):
+        if not update:
+            wv.ngrams_word = {}
+            for w, v in iteritems(wv.vocab):
+                wv.ngrams_word[w] = _compute_ngrams(w, wv.min_n, wv.max_n)
+        else:
+            for w, v in iteritems(wv.vocab):
+                wv.ngrams_word[w] = _compute_ngrams(w, wv.min_n, wv.max_n)
 
-    def save(self, *args, **kwargs):
-        """Save the model. This saved model can be loaded again using :func:`~gensim.models.fasttext.FastText.load`,
-        which supports online training and getting vectors for out-of-vocabulary words.
+
+class FastTextTrainables(Word2VecTrainables):
+    def __init__(self, vector_size=100, seed=1, hashfxn=hash, bucket=2000000):
+        super(FastTextTrainables, self).__init__(
+            vector_size=vector_size, seed=seed, hashfxn=hashfxn)
+        self.bucket = int(bucket)
+
+    def prepare_weights(self, hs, negative, wv, update=False, vocabulary=None):
+        super(FastTextTrainables, self).prepare_weights(hs, negative, wv, update=update, vocabulary=vocabulary)
+        self.init_ngrams_weights(wv, update=update, vocabulary=vocabulary)
+
+    def init_ngrams_weights(self, wv, update=False, vocabulary=None):
+        """Compute ngrams of all words present in vocabulary and stores vectors for only those ngrams.
+        Vectors for other ngrams are initialized with a random uniform distribution in FastText.
 
         Parameters
         ----------
-        fname : str
-            Path to the file.
+        update : bool
+            If True, the new vocab words and their new ngrams word vectors are initialized
+            with random uniform distribution and updated/added to the existing vocab word and ngram vectors.
 
         """
-        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm', 'syn0_vocab_norm', 'syn0_ngrams_norm'])
-        super(FastText, self).save(*args, **kwargs)
+        if not update:
+            wv.ngrams = {}
+            wv.vectors_vocab = empty((len(wv.vocab), wv.vector_size), dtype=REAL)
+            self.vectors_vocab_lockf = ones((len(wv.vocab), wv.vector_size), dtype=REAL)
+
+            wv.vectors_ngrams = empty((self.bucket, wv.vector_size), dtype=REAL)
+            self.vectors_ngrams_lockf = ones((self.bucket, wv.vector_size), dtype=REAL)
+
+            all_ngrams = []
+            for w, ngrams in iteritems(wv.ngrams_word):
+                all_ngrams += ngrams
+
+            all_ngrams = list(set(all_ngrams))
+            wv.num_ngram_vectors = len(all_ngrams)
+            logger.info("Total number of ngrams is %d", len(all_ngrams))
+
+            wv.hash2index = {}
+            ngram_indices = []
+            new_hash_count = 0
+            for i, ngram in enumerate(all_ngrams):
+                ngram_hash = _ft_hash(ngram) % self.bucket
+                if ngram_hash in wv.hash2index:
+                    wv.ngrams[ngram] = wv.hash2index[ngram_hash]
+                else:
+                    ngram_indices.append(ngram_hash % self.bucket)
+                    wv.hash2index[ngram_hash] = new_hash_count
+                    wv.ngrams[ngram] = wv.hash2index[ngram_hash]
+                    new_hash_count = new_hash_count + 1
+
+            wv.vectors_ngrams = wv.vectors_ngrams.take(ngram_indices, axis=0)
+            self.vectors_ngrams_lockf = self.vectors_ngrams_lockf.take(ngram_indices, axis=0)
+            self.reset_ngrams_weights(wv)
+        else:
+            new_ngrams = []
+            for w, ngrams in iteritems(wv.ngrams_word):
+                new_ngrams += [ng for ng in ngrams if ng not in wv.ngrams]
+
+            new_ngrams = list(set(new_ngrams))
+            wv.num_ngram_vectors += len(new_ngrams)
+            logger.info("Number of new ngrams is %d", len(new_ngrams))
+            new_hash_count = 0
+            for i, ngram in enumerate(new_ngrams):
+                ngram_hash = _ft_hash(ngram) % self.bucket
+                if ngram_hash not in wv.hash2index:
+                    wv.hash2index[ngram_hash] = new_hash_count + self.old_hash2index_len
+                    wv.ngrams[ngram] = wv.hash2index[ngram_hash]
+                    new_hash_count = new_hash_count + 1
+                else:
+                    wv.ngrams[ngram] = wv.hash2index[ngram_hash]
+
+            rand_obj = np.random
+            rand_obj.seed(self.seed)
+            new_vocab_rows = rand_obj.uniform(
+                -1.0 / wv.vector_size, 1.0 / wv.vector_size,
+                (len(wv.vocab) - vocabulary.old_vocab_len, wv.vector_size)
+            ).astype(REAL)
+            new_vocab_lockf_rows = ones(
+                (len(wv.vocab) - vocabulary.old_vocab_len, wv.vector_size), dtype=REAL)
+            new_ngram_rows = rand_obj.uniform(
+                -1.0 / wv.vector_size, 1.0 / wv.vector_size,
+                (len(wv.hash2index) - self.old_hash2index_len, wv.vector_size)
+            ).astype(REAL)
+            new_ngram_lockf_rows = ones(
+                (len(wv.hash2index) - self.old_hash2index_len, wv.vector_size), dtype=REAL)
+
+            wv.vectors_vocab = vstack([wv.vectors_vocab, new_vocab_rows])
+            self.vectors_vocab_lockf = vstack([self.vectors_vocab_lockf, new_vocab_lockf_rows])
+            wv.vectors_ngrams = vstack([wv.vectors_ngrams, new_ngram_rows])
+            self.vectors_ngrams_lockf = vstack([self.vectors_ngrams_lockf, new_ngram_lockf_rows])
+
+    def reset_ngrams_weights(self, wv):
+        """Reset all projection weights to an initial (untrained) state,
+        but keep the existing vocabulary and their ngrams.
+
+        """
+        rand_obj = np.random
+        rand_obj.seed(self.seed)
+        for index in range(len(wv.vocab)):
+            wv.vectors_vocab[index] = rand_obj.uniform(
+                -1.0 / wv.vector_size, 1.0 / wv.vector_size, wv.vector_size
+            ).astype(REAL)
+        for index in range(len(wv.hash2index)):
+            wv.vectors_ngrams[index] = rand_obj.uniform(
+                -1.0 / wv.vector_size, 1.0 / wv.vector_size, wv.vector_size
+            ).astype(REAL)
+
+    def get_vocab_word_vecs(self, wv):
+        """Calculate vectors for words in vocabulary and stores them in `vectors`."""
+        for w, v in wv.vocab.items():
+            word_vec = np.copy(wv.vectors_vocab[v.index])
+            ngrams = wv.ngrams_word[w]
+            ngram_weights = wv.vectors_ngrams
+            for ngram in ngrams:
+                word_vec += ngram_weights[wv.ngrams[ngram]]
+            word_vec /= (len(ngrams) + 1)
+            wv.vectors[v.index] = word_vec
+
+    def init_ngrams_post_load(self, file_name, wv):
+        """
+        Computes ngrams of all words present in vocabulary and stores vectors for only those ngrams.
+        Vectors for other ngrams are initialized with a random uniform distribution in FastText. These
+        vectors are discarded here to save space.
+
+        """
+        all_ngrams = []
+        wv.vectors = np.zeros((len(wv.vocab), wv.vector_size), dtype=REAL)
+
+        for w, vocab in wv.vocab.items():
+            all_ngrams += _compute_ngrams(w, wv.min_n, wv.max_n)
+            wv.vectors[vocab.index] += np.array(wv.vectors_ngrams[vocab.index])
+
+        all_ngrams = set(all_ngrams)
+        wv.num_ngram_vectors = len(all_ngrams)
+        ngram_indices = []
+        for i, ngram in enumerate(all_ngrams):
+            ngram_hash = _ft_hash(ngram)
+            ngram_indices.append(len(wv.vocab) + ngram_hash % self.bucket)
+            wv.ngrams[ngram] = i
+        wv.vectors_ngrams = wv.vectors_ngrams.take(ngram_indices, axis=0)
+
+        ngram_weights = wv.vectors_ngrams
+
+        logger.info(
+            "loading weights for %s words for fastText model from %s",
+            len(wv.vocab), file_name
+        )
+
+        for w, vocab in wv.vocab.items():
+            word_ngrams = _compute_ngrams(w, wv.min_n, wv.max_n)
+            for word_ngram in word_ngrams:
+                wv.vectors[vocab.index] += np.array(ngram_weights[wv.ngrams[word_ngram]])
+
+            wv.vectors[vocab.index] /= (len(word_ngrams) + 1)
+        logger.info(
+            "loaded %s weight matrix for fastText model from %s",
+            wv.vectors.shape, file_name
+        )
diff --git a/gensim/models/fasttext_inner.c b/gensim/models/fasttext_inner.c
index f7bb4d285a..fb837e7b34 100644
--- a/gensim/models/fasttext_inner.c
+++ b/gensim/models/fasttext_inner.c
@@ -1568,30 +1568,34 @@ static const char __pyx_k_ValueError[] = "ValueError";
 static const char __pyx_k_index2word[] = "index2word";
 static const char __pyx_k_sample_int[] = "sample_int";
 static const char __pyx_k_syn0_vocab[] = "syn0_vocab";
+static const char __pyx_k_trainables[] = "trainables";
+static const char __pyx_k_vocabulary[] = "vocabulary";
 static const char __pyx_k_ImportError[] = "ImportError";
-static const char __pyx_k_layer1_size[] = "layer1_size";
 static const char __pyx_k_next_random[] = "next_random";
 static const char __pyx_k_ngrams_word[] = "ngrams_word";
 static const char __pyx_k_syn0_ngrams[] = "syn0_ngrams";
+static const char __pyx_k_vector_size[] = "vector_size";
 static const char __pyx_k_FAST_VERSION[] = "FAST_VERSION";
 static const char __pyx_k_RuntimeError[] = "RuntimeError";
 static const char __pyx_k_sentence_idx[] = "sentence_idx";
 static const char __pyx_k_subwords_idx[] = "subwords_idx";
 static const char __pyx_k_cum_table_len[] = "cum_table_len";
+static const char __pyx_k_vectors_vocab[] = "vectors_vocab";
 static const char __pyx_k_word_subwords[] = "word_subwords";
 static const char __pyx_k_subword_arrays[] = "subword_arrays";
 static const char __pyx_k_train_batch_sg[] = "train_batch_sg";
+static const char __pyx_k_vectors_ngrams[] = "vectors_ngrams";
 static const char __pyx_k_effective_words[] = "effective_words";
 static const char __pyx_k_reduced_windows[] = "reduced_windows";
 static const char __pyx_k_subwords_idx_len[] = "subwords_idx_len";
-static const char __pyx_k_syn0_vocab_lockf[] = "syn0_vocab_lockf";
 static const char __pyx_k_train_batch_cbow[] = "train_batch_cbow";
 static const char __pyx_k_word_locks_vocab[] = "word_locks_vocab";
 static const char __pyx_k_scipy_linalg_blas[] = "scipy.linalg.blas";
-static const char __pyx_k_syn0_ngrams_lockf[] = "syn0_ngrams_lockf";
 static const char __pyx_k_word_locks_ngrams[] = "word_locks_ngrams";
 static const char __pyx_k_MAX_WORDS_IN_BATCH[] = "MAX_WORDS_IN_BATCH";
 static const char __pyx_k_effective_sentences[] = "effective_sentences";
+static const char __pyx_k_vectors_vocab_lockf[] = "vectors_vocab_lockf";
+static const char __pyx_k_vectors_ngrams_lockf[] = "vectors_ngrams_lockf";
 static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
 static const char __pyx_k_gensim_models_fasttext_inner[] = "gensim.models.fasttext_inner";
 static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
@@ -1645,7 +1649,6 @@ static PyObject *__pyx_n_s_j;
 static PyObject *__pyx_n_s_k;
 static PyObject *__pyx_n_s_l1;
 static PyObject *__pyx_n_s_l1_2;
-static PyObject *__pyx_n_s_layer1_size;
 static PyObject *__pyx_n_s_main;
 static PyObject *__pyx_n_s_model;
 static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
@@ -1681,19 +1684,24 @@ static PyObject *__pyx_n_s_subwords;
 static PyObject *__pyx_n_s_subwords_idx;
 static PyObject *__pyx_n_s_subwords_idx_len;
 static PyObject *__pyx_n_s_syn0_ngrams;
-static PyObject *__pyx_n_s_syn0_ngrams_lockf;
 static PyObject *__pyx_n_s_syn0_vocab;
-static PyObject *__pyx_n_s_syn0_vocab_lockf;
 static PyObject *__pyx_n_s_syn1;
 static PyObject *__pyx_n_s_syn1neg;
 static PyObject *__pyx_n_s_test;
 static PyObject *__pyx_n_s_token;
 static PyObject *__pyx_n_s_train_batch_cbow;
 static PyObject *__pyx_n_s_train_batch_sg;
+static PyObject *__pyx_n_s_trainables;
 static PyObject *__pyx_n_s_uint32;
 static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
+static PyObject *__pyx_n_s_vector_size;
+static PyObject *__pyx_n_s_vectors_ngrams;
+static PyObject *__pyx_n_s_vectors_ngrams_lockf;
+static PyObject *__pyx_n_s_vectors_vocab;
+static PyObject *__pyx_n_s_vectors_vocab_lockf;
 static PyObject *__pyx_n_s_vlookup;
 static PyObject *__pyx_n_s_vocab;
+static PyObject *__pyx_n_s_vocabulary;
 static PyObject *__pyx_n_s_window;
 static PyObject *__pyx_n_s_word;
 static PyObject *__pyx_n_s_word_locks_ngrams;
@@ -3499,7 +3507,7 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
  * def train_batch_sg(model, sentences, alpha, _work, _l1):
  *     cdef int hs = model.hs             # <<<<<<<<<<<<<<
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_hs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
@@ -3511,7 +3519,7 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
  * def train_batch_sg(model, sentences, alpha, _work, _l1):
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative             # <<<<<<<<<<<<<<
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  * 
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_negative); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 249, __pyx_L1_error)
@@ -3523,57 +3531,63 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
   /* "gensim/models/fasttext_inner.pyx":250
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)             # <<<<<<<<<<<<<<
+ *     cdef int sample = (model.vocabulary.sample != 0)             # <<<<<<<<<<<<<<
  * 
- *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))
+ *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_sample); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sample); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 250, __pyx_L1_error)
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_sample = __pyx_t_2;
 
   /* "gensim/models/fasttext_inner.pyx":252
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  * 
- *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))             # <<<<<<<<<<<<<<
- *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))
- *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))
+ *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))
+ *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn0_vocab); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 252, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 252, __pyx_L1_error)
-  __pyx_v_syn0_vocab = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_vocab); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 252, __pyx_L1_error)
+  __pyx_v_syn0_vocab = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "gensim/models/fasttext_inner.pyx":253
  * 
- *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))
- *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))             # <<<<<<<<<<<<<<
- *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))
- *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.syn0_ngrams_lockf))
+ *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))
+ *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))
+ *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_ngrams_lockf))
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn0_vocab_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 253, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors_vocab_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 253, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 253, __pyx_L1_error)
   __pyx_v_word_locks_vocab = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "gensim/models/fasttext_inner.pyx":254
- *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))
- *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))
- *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))             # <<<<<<<<<<<<<<
- *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.syn0_ngrams_lockf))
+ *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))
+ *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))
+ *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_ngrams_lockf))
  * 
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn0_ngrams); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_ngrams); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 254, __pyx_L1_error)
@@ -3581,23 +3595,26 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "gensim/models/fasttext_inner.pyx":255
- *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))
- *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))
- *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.syn0_ngrams_lockf))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))
+ *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))
+ *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_ngrams_lockf))             # <<<<<<<<<<<<<<
  * 
  *     cdef REAL_t *work
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn0_ngrams_lockf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 255, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 255, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 255, __pyx_L1_error)
-  __pyx_v_word_locks_ngrams = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors_ngrams_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 255, __pyx_L1_error)
+  __pyx_v_word_locks_ngrams = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "gensim/models/fasttext_inner.pyx":260
  *     cdef REAL_t *l1
  * 
  *     cdef REAL_t _alpha = alpha             # <<<<<<<<<<<<<<
- *     cdef int size = model.layer1_size
+ *     cdef int size = model.wv.vector_size
  * 
  */
   __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_v_alpha); if (unlikely((__pyx_t_4 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 260, __pyx_L1_error)
@@ -3606,12 +3623,15 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
   /* "gensim/models/fasttext_inner.pyx":261
  * 
  *     cdef REAL_t _alpha = alpha
- *     cdef int size = model.layer1_size             # <<<<<<<<<<<<<<
+ *     cdef int size = model.wv.vector_size             # <<<<<<<<<<<<<<
  * 
  *     cdef int codelens[MAX_SENTENCE_LEN]
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 261, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vector_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 261, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_size = __pyx_t_2;
@@ -3655,7 +3675,7 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
  *     subword_arrays = {}
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   __pyx_t_5 = (__pyx_v_hs != 0);
@@ -3664,31 +3684,34 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
     /* "gensim/models/fasttext_inner.pyx":293
  * 
  *     if hs:
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))             # <<<<<<<<<<<<<<
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))             # <<<<<<<<<<<<<<
  * 
  *     if negative:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 293, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 293, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 293, __pyx_L1_error)
-    __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 293, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 293, __pyx_L1_error)
+    __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
     /* "gensim/models/fasttext_inner.pyx":292
  *     subword_arrays = {}
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   }
 
   /* "gensim/models/fasttext_inner.pyx":295
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   __pyx_t_5 = (__pyx_v_negative != 0);
   if (__pyx_t_5) {
@@ -3696,54 +3719,63 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
     /* "gensim/models/fasttext_inner.pyx":296
  * 
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))             # <<<<<<<<<<<<<<
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))             # <<<<<<<<<<<<<<
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 296, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 296, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 296, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 296, __pyx_L1_error)
     __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
     /* "gensim/models/fasttext_inner.pyx":297
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))             # <<<<<<<<<<<<<<
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))             # <<<<<<<<<<<<<<
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 297, __pyx_L1_error)
-    __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 297, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 297, __pyx_L1_error)
+    __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
     /* "gensim/models/fasttext_inner.pyx":298
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)             # <<<<<<<<<<<<<<
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)             # <<<<<<<<<<<<<<
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 298, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __pyx_t_6 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 298, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_v_cum_table_len = __pyx_t_6;
 
     /* "gensim/models/fasttext_inner.pyx":295
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   }
 
   /* "gensim/models/fasttext_inner.pyx":299
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -3760,7 +3792,7 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
   if (__pyx_t_5) {
 
     /* "gensim/models/fasttext_inner.pyx":300
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
@@ -3794,8 +3826,8 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_train_batch_sg(CYTHON
     __pyx_v_next_random = __pyx_t_9;
 
     /* "gensim/models/fasttext_inner.pyx":299
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -5003,7 +5035,7 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
  * def train_batch_cbow(model, sentences, alpha, _work, _neu1):
  *     cdef int hs = model.hs             # <<<<<<<<<<<<<<
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_hs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
@@ -5015,7 +5047,7 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
  * def train_batch_cbow(model, sentences, alpha, _work, _neu1):
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative             # <<<<<<<<<<<<<<
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int cbow_mean = model.cbow_mean
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_negative); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 379, __pyx_L1_error)
@@ -5027,70 +5059,76 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
   /* "gensim/models/fasttext_inner.pyx":380
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)             # <<<<<<<<<<<<<<
+ *     cdef int sample = (model.vocabulary.sample != 0)             # <<<<<<<<<<<<<<
  *     cdef int cbow_mean = model.cbow_mean
  * 
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_sample); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 380, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 380, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 380, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sample); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 380, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 380, __pyx_L1_error)
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 380, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 380, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_sample = __pyx_t_2;
 
   /* "gensim/models/fasttext_inner.pyx":381
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int cbow_mean = model.cbow_mean             # <<<<<<<<<<<<<<
  * 
- *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))
+ *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cbow_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 381, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 381, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cbow_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 381, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 381, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_cbow_mean = __pyx_t_2;
 
   /* "gensim/models/fasttext_inner.pyx":383
  *     cdef int cbow_mean = model.cbow_mean
  * 
- *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))             # <<<<<<<<<<<<<<
- *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))
- *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))
+ *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))
+ *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 383, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn0_vocab); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 383, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 383, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 383, __pyx_L1_error)
-  __pyx_v_syn0_vocab = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_vocab); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 383, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 383, __pyx_L1_error)
+  __pyx_v_syn0_vocab = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "gensim/models/fasttext_inner.pyx":384
  * 
- *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))
- *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))             # <<<<<<<<<<<<<<
- *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))
- *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.syn0_ngrams_lockf))
+ *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))
+ *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))
+ *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_ngrams_lockf))
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn0_vocab_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 384, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors_vocab_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 384, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 384, __pyx_L1_error)
   __pyx_v_word_locks_vocab = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "gensim/models/fasttext_inner.pyx":385
- *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))
- *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))
- *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))             # <<<<<<<<<<<<<<
- *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.syn0_ngrams_lockf))
+ *     cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))
+ *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))
+ *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_ngrams_lockf))
  * 
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 385, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn0_ngrams); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 385, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors_ngrams); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 385, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 385, __pyx_L1_error)
@@ -5098,23 +5136,26 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "gensim/models/fasttext_inner.pyx":386
- *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))
- *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))
- *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.syn0_ngrams_lockf))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))
+ *     cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))
+ *     cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_ngrams_lockf))             # <<<<<<<<<<<<<<
  * 
  *     cdef REAL_t *work
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn0_ngrams_lockf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 386, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 386, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 386, __pyx_L1_error)
-  __pyx_v_word_locks_ngrams = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors_ngrams_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 386, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 386, __pyx_L1_error)
+  __pyx_v_word_locks_ngrams = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "gensim/models/fasttext_inner.pyx":389
  * 
  *     cdef REAL_t *work
  *     cdef REAL_t _alpha = alpha             # <<<<<<<<<<<<<<
- *     cdef int size = model.layer1_size
+ *     cdef int size = model.wv.vector_size
  * 
  */
   __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_v_alpha); if (unlikely((__pyx_t_4 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 389, __pyx_L1_error)
@@ -5123,12 +5164,15 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
   /* "gensim/models/fasttext_inner.pyx":390
  *     cdef REAL_t *work
  *     cdef REAL_t _alpha = alpha
- *     cdef int size = model.layer1_size             # <<<<<<<<<<<<<<
+ *     cdef int size = model.wv.vector_size             # <<<<<<<<<<<<<<
  * 
  *     cdef int codelens[MAX_SENTENCE_LEN]
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 390, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 390, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vector_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 390, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 390, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_size = __pyx_t_2;
@@ -5172,7 +5216,7 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
  *     subword_arrays = {}
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   __pyx_t_5 = (__pyx_v_hs != 0);
@@ -5181,31 +5225,34 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
     /* "gensim/models/fasttext_inner.pyx":422
  * 
  *     if hs:
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))             # <<<<<<<<<<<<<<
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))             # <<<<<<<<<<<<<<
  * 
  *     if negative:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 422, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 422, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 422, __pyx_L1_error)
-    __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 422, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 422, __pyx_L1_error)
+    __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
     /* "gensim/models/fasttext_inner.pyx":421
  *     subword_arrays = {}
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   }
 
   /* "gensim/models/fasttext_inner.pyx":424
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   __pyx_t_5 = (__pyx_v_negative != 0);
   if (__pyx_t_5) {
@@ -5213,54 +5260,63 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
     /* "gensim/models/fasttext_inner.pyx":425
  * 
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))             # <<<<<<<<<<<<<<
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))             # <<<<<<<<<<<<<<
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 425, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 425, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 425, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 425, __pyx_L1_error)
     __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
     /* "gensim/models/fasttext_inner.pyx":426
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))             # <<<<<<<<<<<<<<
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))             # <<<<<<<<<<<<<<
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 426, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 426, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 426, __pyx_L1_error)
-    __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 426, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 426, __pyx_L1_error)
+    __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
     /* "gensim/models/fasttext_inner.pyx":427
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)             # <<<<<<<<<<<<<<
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)             # <<<<<<<<<<<<<<
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  */
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 427, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
     __pyx_t_6 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 427, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_v_cum_table_len = __pyx_t_6;
 
     /* "gensim/models/fasttext_inner.pyx":424
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   }
 
   /* "gensim/models/fasttext_inner.pyx":428
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -5277,7 +5333,7 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
   if (__pyx_t_5) {
 
     /* "gensim/models/fasttext_inner.pyx":429
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
@@ -5311,8 +5367,8 @@ static PyObject *__pyx_pf_6gensim_6models_14fasttext_inner_2train_batch_cbow(CYT
     __pyx_v_next_random = __pyx_t_9;
 
     /* "gensim/models/fasttext_inner.pyx":428
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -9158,7 +9214,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1},
   {&__pyx_n_s_l1, __pyx_k_l1, sizeof(__pyx_k_l1), 0, 0, 1, 1},
   {&__pyx_n_s_l1_2, __pyx_k_l1_2, sizeof(__pyx_k_l1_2), 0, 0, 1, 1},
-  {&__pyx_n_s_layer1_size, __pyx_k_layer1_size, sizeof(__pyx_k_layer1_size), 0, 0, 1, 1},
   {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
   {&__pyx_n_s_model, __pyx_k_model, sizeof(__pyx_k_model), 0, 0, 1, 1},
   {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
@@ -9194,19 +9249,24 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_subwords_idx, __pyx_k_subwords_idx, sizeof(__pyx_k_subwords_idx), 0, 0, 1, 1},
   {&__pyx_n_s_subwords_idx_len, __pyx_k_subwords_idx_len, sizeof(__pyx_k_subwords_idx_len), 0, 0, 1, 1},
   {&__pyx_n_s_syn0_ngrams, __pyx_k_syn0_ngrams, sizeof(__pyx_k_syn0_ngrams), 0, 0, 1, 1},
-  {&__pyx_n_s_syn0_ngrams_lockf, __pyx_k_syn0_ngrams_lockf, sizeof(__pyx_k_syn0_ngrams_lockf), 0, 0, 1, 1},
   {&__pyx_n_s_syn0_vocab, __pyx_k_syn0_vocab, sizeof(__pyx_k_syn0_vocab), 0, 0, 1, 1},
-  {&__pyx_n_s_syn0_vocab_lockf, __pyx_k_syn0_vocab_lockf, sizeof(__pyx_k_syn0_vocab_lockf), 0, 0, 1, 1},
   {&__pyx_n_s_syn1, __pyx_k_syn1, sizeof(__pyx_k_syn1), 0, 0, 1, 1},
   {&__pyx_n_s_syn1neg, __pyx_k_syn1neg, sizeof(__pyx_k_syn1neg), 0, 0, 1, 1},
   {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
   {&__pyx_n_s_token, __pyx_k_token, sizeof(__pyx_k_token), 0, 0, 1, 1},
   {&__pyx_n_s_train_batch_cbow, __pyx_k_train_batch_cbow, sizeof(__pyx_k_train_batch_cbow), 0, 0, 1, 1},
   {&__pyx_n_s_train_batch_sg, __pyx_k_train_batch_sg, sizeof(__pyx_k_train_batch_sg), 0, 0, 1, 1},
+  {&__pyx_n_s_trainables, __pyx_k_trainables, sizeof(__pyx_k_trainables), 0, 0, 1, 1},
   {&__pyx_n_s_uint32, __pyx_k_uint32, sizeof(__pyx_k_uint32), 0, 0, 1, 1},
   {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
+  {&__pyx_n_s_vector_size, __pyx_k_vector_size, sizeof(__pyx_k_vector_size), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors_ngrams, __pyx_k_vectors_ngrams, sizeof(__pyx_k_vectors_ngrams), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors_ngrams_lockf, __pyx_k_vectors_ngrams_lockf, sizeof(__pyx_k_vectors_ngrams_lockf), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors_vocab, __pyx_k_vectors_vocab, sizeof(__pyx_k_vectors_vocab), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors_vocab_lockf, __pyx_k_vectors_vocab_lockf, sizeof(__pyx_k_vectors_vocab_lockf), 0, 0, 1, 1},
   {&__pyx_n_s_vlookup, __pyx_k_vlookup, sizeof(__pyx_k_vlookup), 0, 0, 1, 1},
   {&__pyx_n_s_vocab, __pyx_k_vocab, sizeof(__pyx_k_vocab), 0, 0, 1, 1},
+  {&__pyx_n_s_vocabulary, __pyx_k_vocabulary, sizeof(__pyx_k_vocabulary), 0, 0, 1, 1},
   {&__pyx_n_s_window, __pyx_k_window, sizeof(__pyx_k_window), 0, 0, 1, 1},
   {&__pyx_n_s_word, __pyx_k_word, sizeof(__pyx_k_word), 0, 0, 1, 1},
   {&__pyx_n_s_word_locks_ngrams, __pyx_k_word_locks_ngrams, sizeof(__pyx_k_word_locks_ngrams), 0, 0, 1, 1},
@@ -9235,7 +9295,7 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
   /* "gensim/models/fasttext_inner.pyx":300
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
@@ -9249,7 +9309,7 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_GIVEREF(__pyx_tuple__2);
 
   /* "gensim/models/fasttext_inner.pyx":429
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
diff --git a/gensim/models/fasttext_inner.pyx b/gensim/models/fasttext_inner.pyx
index 09e75adba5..1a74b50ba5 100644
--- a/gensim/models/fasttext_inner.pyx
+++ b/gensim/models/fasttext_inner.pyx
@@ -247,18 +247,18 @@ cdef void fast_sentence_cbow_hs(
 def train_batch_sg(model, sentences, alpha, _work, _l1):
     cdef int hs = model.hs
     cdef int negative = model.negative
-    cdef int sample = (model.sample != 0)
+    cdef int sample = (model.vocabulary.sample != 0)
 
-    cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))
-    cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))
-    cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))
-    cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.syn0_ngrams_lockf))
+    cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))
+    cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))
+    cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))
+    cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_ngrams_lockf))
 
     cdef REAL_t *work
     cdef REAL_t *l1
     
     cdef REAL_t _alpha = alpha
-    cdef int size = model.layer1_size
+    cdef int size = model.wv.vector_size
 
     cdef int codelens[MAX_SENTENCE_LEN]
     cdef np.uint32_t indexes[MAX_SENTENCE_LEN]
@@ -290,12 +290,12 @@ def train_batch_sg(model, sentences, alpha, _work, _l1):
     subword_arrays = {} 
 
     if hs:
-        syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+        syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
 
     if negative:
-        syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
-        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
-        cum_table_len = len(model.cum_table)
+        syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+        cum_table_len = len(model.vocabulary.cum_table)
     if negative or sample:
         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
 
@@ -377,17 +377,17 @@ def train_batch_sg(model, sentences, alpha, _work, _l1):
 def train_batch_cbow(model, sentences, alpha, _work, _neu1):
     cdef int hs = model.hs
     cdef int negative = model.negative
-    cdef int sample = (model.sample != 0)
+    cdef int sample = (model.vocabulary.sample != 0)
     cdef int cbow_mean = model.cbow_mean
 
-    cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_vocab))
-    cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.syn0_vocab_lockf))
-    cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.syn0_ngrams))
-    cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.syn0_ngrams_lockf))
+    cdef REAL_t *syn0_vocab = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_vocab))
+    cdef REAL_t *word_locks_vocab = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_vocab_lockf))
+    cdef REAL_t *syn0_ngrams = <REAL_t *>(np.PyArray_DATA(model.wv.vectors_ngrams))
+    cdef REAL_t *word_locks_ngrams = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_ngrams_lockf))
 
     cdef REAL_t *work
     cdef REAL_t _alpha = alpha
-    cdef int size = model.layer1_size
+    cdef int size = model.wv.vector_size
 
     cdef int codelens[MAX_SENTENCE_LEN]
     cdef np.uint32_t indexes[MAX_SENTENCE_LEN]
@@ -419,12 +419,12 @@ def train_batch_cbow(model, sentences, alpha, _work, _neu1):
     subword_arrays = {}
 
     if hs:
-        syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+        syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
 
     if negative:
-        syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
-        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
-        cum_table_len = len(model.cum_table)
+        syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+        cum_table_len = len(model.vocabulary.cum_table)
     if negative or sample:
         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
 
diff --git a/gensim/models/keyedvectors.py b/gensim/models/keyedvectors.py
index 2fdfb5f5d3..677b9ca002 100644
--- a/gensim/models/keyedvectors.py
+++ b/gensim/models/keyedvectors.py
@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2016 Radim Rehurek <me@radimrehurek.com>
+# Author: Shiva Manne <manneshiva@gmail.com>
+# Copyright (C) 2018 RaRe Technologies s.r.o.
 # Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
 
 """
@@ -23,7 +24,7 @@
 The vectors can also be instantiated from an existing file on disk
 in the original Google's word2vec C format as a KeyedVectors instance::
 
-  >>> from gensim.models.keyedvectors import KeyedVectors
+  >>> from gensim.models import KeyedVectors
   >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.txt', binary=False)  # C text format
   >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.bin', binary=True)  # C binary format
 
@@ -71,18 +72,17 @@
 except ImportError:
     PYEMD_EXT = False
 
-from numpy import dot, zeros, dtype, float32 as REAL,\
-    double, array, vstack, fromstring, sqrt, newaxis,\
-    ndarray, sum as np_sum, prod, ascontiguousarray,\
-    argmax
+from numpy import dot, zeros, float32 as REAL, empty, memmap as np_memmap, \
+    double, array, vstack, sqrt, newaxis, integer, \
+    ndarray, sum as np_sum, prod, argmax, divide as np_divide
 import numpy as np
-
 from gensim import utils, matutils  # utility fnc for pickling, common scipy operations etc
 from gensim.corpora.dictionary import Dictionary
-from six import string_types, iteritems
-from six.moves import xrange
+from six import string_types, integer_types
+from six.moves import xrange, zip
 from scipy import stats
-
+from gensim.utils import deprecated
+from gensim.models.utils_any2vec import _save_word2vec_format, _load_word2vec_format, _compute_ngrams
 
 logger = logging.getLogger(__name__)
 
@@ -106,328 +106,143 @@ def __str__(self):
         return "%s(%s)" % (self.__class__.__name__, ', '.join(vals))
 
 
-class KeyedVectorsBase(utils.SaveLoad):
-    """
-    Base class to contain vectors and vocab for any set of vectors which are each associated with a key.
+class BaseKeyedVectors(utils.SaveLoad):
 
-    """
-
-    def __init__(self):
-        self.syn0 = []
+    def __init__(self, vector_size):
+        self.vectors = []
         self.vocab = {}
-        self.index2word = []
-        self.vector_size = None
+        self.vector_size = vector_size
+        self.index2entity = []
 
-    def save_word2vec_format(self, fname, fvocab=None, binary=False, total_vec=None):
-        """
-        Store the input-hidden weight matrix in the same format used by the original
-        C word2vec-tool, for compatibility.
-
-         `fname` is the file used to save the vectors in
-         `fvocab` is an optional file used to save the vocabulary
-         `binary` is an optional boolean indicating whether the data is to be saved
-         in binary word2vec format (default: False)
-         `total_vec` is an optional parameter to explicitly specify total no. of vectors
-         (in case word vectors are appended with document vectors afterwards)
-
-        """
-        if total_vec is None:
-            total_vec = len(self.vocab)
-        vector_size = self.syn0.shape[1]
-        if fvocab is not None:
-            logger.info("storing vocabulary in %s", fvocab)
-            with utils.smart_open(fvocab, 'wb') as vout:
-                for word, vocab in sorted(iteritems(self.vocab), key=lambda item: -item[1].count):
-                    vout.write(utils.to_utf8("%s %s\n" % (word, vocab.count)))
-        logger.info("storing %sx%s projection weights into %s", total_vec, vector_size, fname)
-        assert (len(self.vocab), vector_size) == self.syn0.shape
-        with utils.smart_open(fname, 'wb') as fout:
-            fout.write(utils.to_utf8("%s %s\n" % (total_vec, vector_size)))
-            # store in sorted order: most frequent words at the top
-            for word, vocab in sorted(iteritems(self.vocab), key=lambda item: -item[1].count):
-                row = self.syn0[vocab.index]
-                if binary:
-                    row = row.astype(REAL)
-                    fout.write(utils.to_utf8(word) + b" " + row.tostring())
-                else:
-                    fout.write(utils.to_utf8("%s %s\n" % (word, ' '.join(repr(val) for val in row))))
+    def save(self, fname_or_handle, **kwargs):
+        super(BaseKeyedVectors, self).save(fname_or_handle, **kwargs)
 
     @classmethod
-    def load_word2vec_format(cls, fname, fvocab=None, binary=False, encoding='utf8', unicode_errors='strict',
-                             limit=None, datatype=REAL):
-        """
-        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).
-
-        If you trained the C model using non-utf8 encoding for words, specify that
-        encoding in `encoding`.
-
-        `unicode_errors`, default 'strict', is a string suitable to be passed as the `errors`
-        argument to the unicode() (Python 2.x) or str() (Python 3.x) function. If your source
-        file may include word tokens truncated in the middle of a multibyte unicode character
-        (as is common from the original word2vec.c tool), 'ignore' or 'replace' may help.
-
-        `limit` sets a maximum number of word-vectors to read from the file. The default,
-        None, means read all.
-
-        `datatype` (experimental) can coerce dimensions to a non-default float type (such
-        as np.float16) to save memory. (Such types may result in much slower bulk operations
-        or incompatibility with optimized routines.)
-
-        """
-        counts = None
-        if fvocab is not None:
-            logger.info("loading word counts from %s", fvocab)
-            counts = {}
-            with utils.smart_open(fvocab) as fin:
-                for line in fin:
-                    word, count = utils.to_unicode(line).strip().split()
-                    counts[word] = int(count)
-
-        logger.info("loading projection weights from %s", fname)
-        with utils.smart_open(fname) as fin:
-            header = utils.to_unicode(fin.readline(), encoding=encoding)
-            vocab_size, vector_size = (int(x) for x in header.split())  # throws for invalid file format
-            if limit:
-                vocab_size = min(vocab_size, limit)
-            result = cls()
-            result.vector_size = vector_size
-            result.syn0 = zeros((vocab_size, vector_size), dtype=datatype)
-
-            def add_word(word, weights):
-                word_id = len(result.vocab)
-                if word in result.vocab:
-                    logger.warning("duplicate word '%s' in %s, ignoring all but first", word, fname)
-                    return
-                if counts is None:
-                    # most common scenario: no vocab file given. just make up some bogus counts, in descending order
-                    result.vocab[word] = Vocab(index=word_id, count=vocab_size - word_id)
-                elif word in counts:
-                    # use count from the vocab file
-                    result.vocab[word] = Vocab(index=word_id, count=counts[word])
-                else:
-                    # vocab file given, but word is missing -- set count to None (TODO: or raise?)
-                    logger.warning("vocabulary file is incomplete: '%s' is missing", word)
-                    result.vocab[word] = Vocab(index=word_id, count=None)
-                result.syn0[word_id] = weights
-                result.index2word.append(word)
-
-            if binary:
-                binary_len = dtype(REAL).itemsize * vector_size
-                for _ in xrange(vocab_size):
-                    # mixed text and binary: read text first, then binary
-                    word = []
-                    while True:
-                        ch = fin.read(1)
-                        if ch == b' ':
-                            break
-                        if ch == b'':
-                            raise EOFError("unexpected end of input; is count incorrect or file otherwise damaged?")
-                        if ch != b'\n':  # ignore newlines in front of words (some binary files have)
-                            word.append(ch)
-                    word = utils.to_unicode(b''.join(word), encoding=encoding, errors=unicode_errors)
-                    weights = fromstring(fin.read(binary_len), dtype=REAL).astype(datatype)
-                    add_word(word, weights)
-            else:
-                for line_no in xrange(vocab_size):
-                    line = fin.readline()
-                    if line == b'':
-                        raise EOFError("unexpected end of input; is count incorrect or file otherwise damaged?")
-                    parts = utils.to_unicode(line.rstrip(), encoding=encoding, errors=unicode_errors).split(" ")
-                    if len(parts) != vector_size + 1:
-                        raise ValueError("invalid vector on line %s (is this really the text format?)" % line_no)
-                    word, weights = parts[0], [datatype(x) for x in parts[1:]]
-                    add_word(word, weights)
-        if result.syn0.shape[0] != len(result.vocab):
-            logger.info(
-                "duplicate words detected, shrinking matrix size from %i to %i",
-                result.syn0.shape[0], len(result.vocab)
-            )
-            result.syn0 = ascontiguousarray(result.syn0[: len(result.vocab)])
-        assert (len(result.vocab), vector_size) == result.syn0.shape
-
-        logger.info("loaded %s matrix from %s", result.syn0.shape, fname)
-        return result
-
-    def similarity(self, w1, w2):
-        """
-        Compute similarity between vectors of two input words.
-        To be implemented by child class.
+    def load(cls, fname_or_handle, **kwargs):
+        return super(BaseKeyedVectors, cls).load(fname_or_handle, **kwargs)
 
+    def similarity(self, entity1, entity2):
+        """Compute cosine similarity between entities, specified by string tag.
         """
-        raise NotImplementedError
+        raise NotImplementedError()
 
-    def distance(self, w1, w2):
+    def most_similar(self, **kwargs):
+        """Find the top-N most similar entities.
+        Possibly have `positive` and `negative` list of entities in `**kwargs`.
         """
-        Compute distance between vectors of two input words.
-        To be implemented by child class.
+        return NotImplementedError()
 
+    def distance(self, entity1, entity2):
+        """Compute distance between vectors of two input entities, specified by string tag.
         """
-        raise NotImplementedError
-
-    def distances(self, word_or_vector, other_words=()):
-        """
-        Compute distances from given word or vector to all words in `other_words`.
-        If `other_words` is empty, return distance between `word_or_vectors` and all words in vocab.
-        To be implemented by child class.
+        raise NotImplementedError()
 
+    def distances(self, entity1, other_entities=()):
+        """Compute distances from given entity (string tag) to all entities in `other_entity`.
+        If `other_entities` is empty, return distance between `entity1` and all entities in vocab.
         """
-        raise NotImplementedError
-
-    def word_vec(self, word):
-        """
-        Accept a single word as input.
-        Returns the word's representations in vector space, as a 1D numpy array.
-
-        Example::
-
-          >>> trained_model.word_vec('office')
-          array([ -1.40128313e-02, ...])
+        raise NotImplementedError()
 
+    def get_vector(self, entity):
+        """Accept a single entity as input, specified by string tag.
+        Returns the entity's representations in vector space, as a 1D numpy array.
         """
-        if word in self.vocab:
-            result = self.syn0[self.vocab[word].index]
+        if entity in self.vocab:
+            result = self.vectors[self.vocab[entity].index]
             result.setflags(write=False)
             return result
         else:
-            raise KeyError("word '%s' not in vocabulary" % word)
+            raise KeyError("'%s' not in vocabulary" % entity)
 
-    def __getitem__(self, words):
+    def __getitem__(self, entities):
         """
-        Accept a single word or a list of words as input.
-
-        If a single word: returns the word's representations in vector space, as
-        a 1D numpy array.
-
-        Multiple words: return the words' representations in vector space, as a
-        2d numpy array: #words x #vector_size. Matrix rows are in the same order
-        as in input.
-
-        Example::
+        Accept a single entity (string tag) or list of entities as input.
 
-          >>> trained_model['office']
-          array([ -1.40128313e-02, ...])
-
-          >>> trained_model[['office', 'products']]
-          array([ -1.40128313e-02, ...]
-                [ -1.70425311e-03, ...]
-                 ...)
+        If a single string or int, return designated tag's vector
+        representation, as a 1D numpy array.
 
+        If a list, return designated tags' vector representations as a
+        2D numpy array: #tags x #vector_size.
         """
-        if isinstance(words, string_types):
+        if isinstance(entities, string_types):
             # allow calls like trained_model['office'], as a shorthand for trained_model[['office']]
-            return self.word_vec(words)
-
-        return vstack([self.word_vec(word) for word in words])
-
-    def __contains__(self, word):
-        return word in self.vocab
+            return self.get_vector(entities)
 
-    def most_similar_to_given(self, w1, word_list):
-        """Return the word from word_list most similar to w1.
+        return vstack([self.get_vector(entity) for entity in entities])
 
-        Args:
-            w1 (str): a word
-            word_list (list): list of words containing a word most similar to w1
+    def __contains__(self, entity):
+        return entity in self.vocab
 
-        Returns:
-            the word in word_list with the highest similarity to w1
+    def most_similar_to_given(self, entity1, entities_list):
+        """Return the entity from entities_list most similar to entity1."""
+        return entities_list[argmax([self.similarity(entity1, entity) for entity in entities_list])]
 
-        Raises:
-            KeyError: If w1 or any word in word_list is not in the vocabulary
+    def closer_than(self, entity1, entity2):
+        """Returns all entities that are closer to `entity1` than `entity2` is to `entity1`."""
+        all_distances = self.distances(entity1)
+        e1_index = self.vocab[entity1].index
+        e2_index = self.vocab[entity2].index
+        closer_node_indices = np.where(all_distances < all_distances[e2_index])[0]
+        return [self.index2entity[index] for index in closer_node_indices if index != e1_index]
 
-        Example::
+    def rank(self, entity1, entity2):
+        """Rank of the distance of `entity2` from `entity1`, in relation to distances of all entities from `entity1`."""
+        return len(self.closer_than(entity1, entity2)) + 1
 
-          >>> trained_model.most_similar_to_given('music', ['water', 'sound', 'backpack', 'mouse'])
-          'sound'
 
-          >>> trained_model.most_similar_to_given('snake', ['food', 'pencil', 'animal', 'phone'])
-          'animal'
+class WordEmbeddingsKeyedVectors(BaseKeyedVectors):
+    """Class containing common methods for operations over word vectors.
+    """
+    def __init__(self, vector_size):
+        super(WordEmbeddingsKeyedVectors, self).__init__(vector_size=vector_size)
+        self.vectors_norm = None
+        self.index2word = []
 
-        """
-        return word_list[argmax([self.similarity(w1, word) for word in word_list])]
+    @property
+    def index2entity(self):
+        return self.index2word
 
-    def words_closer_than(self, w1, w2):
-        """
-        Returns all words that are closer to `w1` than `w2` is to `w1`.
+    @index2entity.setter
+    def index2entity(self, value):
+        self.index2word = value
 
-        Parameters
-        ----------
-        w1 : str
-            Input word.
-        w2 : str
-            Input word.
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.wv.vectors instead")
+    def syn0(self):
+        return self.vectors
 
-        Returns
-        -------
-        list (str)
-            List of words that are closer to `w1` than `w2` is to `w1`.
+    @syn0.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.wv.vectors instead")
+    def syn0(self, value):
+        self.vectors = value
 
-        Examples
-        --------
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.wv.vectors_norm instead")
+    def syn0norm(self):
+        return self.vectors_norm
 
-        >>> model.words_closer_than('carnivore.n.01', 'mammal.n.01')
-        ['dog.n.01', 'canine.n.02']
+    @syn0norm.setter
+    @deprecated("Attribute will be removed in 4.0.0, use self.wv.vectors_norm instead")
+    def syn0norm(self, value):
+        self.vectors_norm = value
 
-        """
-        all_distances = self.distances(w1)
-        w1_index = self.vocab[w1].index
-        w2_index = self.vocab[w2].index
-        closer_node_indices = np.where(all_distances < all_distances[w2_index])[0]
-        return [self.index2word[index] for index in closer_node_indices if index != w1_index]
+    def __contains__(self, word):
+        return word in self.vocab
 
-    def rank(self, w1, w2):
-        """
-        Rank of the distance of `w2` from `w1`, in relation to distances of all words from `w1`.
+    def save(self, *args, **kwargs):
+        """Saves the keyedvectors. This saved model can be loaded again using
+        :func:`~gensim.models.*2vec.*2VecKeyedVectors.load` which supports
+        operations on trained word vectors like `most_similar`.
 
         Parameters
         ----------
-        w1 : str
-            Input word.
-        w2 : str
-            Input word.
-
-        Returns
-        -------
-        int
-            Rank of `w2` from `w1` in relation to all other nodes.
-
-        Examples
-        --------
-
-        >>> model.rank('mammal.n.01', 'carnivore.n.01')
-        3
+        fname : str
+            Path to the file.
 
         """
-        return len(self.words_closer_than(w1, w2)) + 1
-
-
-class EuclideanKeyedVectors(KeyedVectorsBase):
-    """
-    Class to contain vectors and vocab for the Word2Vec training class and other w2v methods not directly
-    involved in training such as most_similar()
-    """
-
-    def __init__(self):
-        super(EuclideanKeyedVectors, self).__init__()
-        self.syn0norm = None
-
-    @property
-    def wv(self):
-        return self
-
-    def save(self, *args, **kwargs):
         # don't bother storing the cached normalized vectors
-        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm'])
-        super(EuclideanKeyedVectors, self).save(*args, **kwargs)
+        kwargs['ignore'] = kwargs.get('ignore', ['vectors_norm'])
+        super(WordEmbeddingsKeyedVectors, self).save(*args, **kwargs)
 
     def word_vec(self, word, use_norm=False):
         """
@@ -436,23 +251,50 @@ def word_vec(self, word, use_norm=False):
 
         If `use_norm` is True, returns the normalized word vector.
 
-        Example::
-
-          >>> trained_model['office']
-          array([ -1.40128313e-02, ...])
+        Examples
+        --------
+        >>> trained_model['office']
+        array([ -1.40128313e-02, ...])
 
         """
         if word in self.vocab:
             if use_norm:
-                result = self.syn0norm[self.vocab[word].index]
+                result = self.vectors_norm[self.vocab[word].index]
             else:
-                result = self.syn0[self.vocab[word].index]
+                result = self.vectors[self.vocab[word].index]
 
             result.setflags(write=False)
             return result
         else:
             raise KeyError("word '%s' not in vocabulary" % word)
 
+    def get_vector(self, word):
+        return self.word_vec(word)
+
+    def words_closer_than(self, w1, w2):
+        """
+        Returns all words that are closer to `w1` than `w2` is to `w1`.
+
+        Parameters
+        ----------
+        w1 : str
+            Input word.
+        w2 : str
+            Input word.
+
+        Returns
+        -------
+        list (str)
+            List of words that are closer to `w1` than `w2` is to `w1`.
+
+        Examples
+        --------
+        >>> model.words_closer_than('carnivore', 'mammal')
+        ['dog', 'canine']
+
+        """
+        return super(WordEmbeddingsKeyedVectors, self).closer_than(w1, w2)
+
     def most_similar(self, positive=None, negative=None, topn=10, restrict_vocab=None, indexer=None):
         """
         Find the top-N most similar words. Positive words contribute positively towards the
@@ -463,17 +305,29 @@ def most_similar(self, positive=None, negative=None, topn=10, restrict_vocab=Non
         The method corresponds to the `word-analogy` and `distance` scripts in the original
         word2vec implementation.
 
-        If topn is False, most_similar returns the vector of similarity scores.
-
-        `restrict_vocab` is an optional integer which limits the range of vectors which
-        are searched for most-similar values. For example, restrict_vocab=10000 would
-        only check the first 10000 word vectors in the vocabulary order. (This may be
-        meaningful if you've sorted the vocabulary by descending frequency.)
+        Parameters
+        ----------
+        positive : :obj: `list` of :obj: `str`
+            List of words that contribute positively.
+        negative : :obj: `list` of :obj: `str`
+            List of words that contribute negatively.
+        topn : int
+            Number of top-N similar words to return.
+        restrict_vocab : int
+            Optional integer which limits the range of vectors which
+            are searched for most-similar values. For example, restrict_vocab=10000 would
+            only check the first 10000 word vectors in the vocabulary order. (This may be
+            meaningful if you've sorted the vocabulary by descending frequency.)
 
-        Example::
+        Returns
+        -------
+        :obj: `list` of :obj: `tuple`
+            Returns a list of tuples (word, similarity)
 
-          >>> trained_model.most_similar(positive=['woman', 'king'], negative=['man'])
-          [('queen', 0.50882536), ...]
+        Examples
+        --------
+        >>> trained_model.most_similar(positive=['woman', 'king'], negative=['man'])
+        [('queen', 0.50882536), ...]
 
         """
         if positive is None:
@@ -513,7 +367,7 @@ def most_similar(self, positive=None, negative=None, topn=10, restrict_vocab=Non
         if indexer is not None:
             return indexer.most_similar(mean, topn)
 
-        limited = self.syn0norm if restrict_vocab is None else self.syn0norm[:restrict_vocab]
+        limited = self.vectors_norm if restrict_vocab is None else self.vectors_norm[:restrict_vocab]
         dists = dot(limited, mean)
         if not topn:
             return dists
@@ -526,12 +380,23 @@ def similar_by_word(self, word, topn=10, restrict_vocab=None):
         """
         Find the top-N most similar words.
 
-        If topn is False, similar_by_word returns the vector of similarity scores.
+        Parameters
+        ----------
+        word : str
+            Word
+        topn : int
+            Number of top-N similar words to return. If topn is False, similar_by_word returns
+            the vector of similarity scores.
+        restrict_vocab : int
+            Optional integer which limits the range of vectors which
+            are searched for most-similar values. For example, restrict_vocab=10000 would
+            only check the first 10000 word vectors in the vocabulary order. (This may be
+            meaningful if you've sorted the vocabulary by descending frequency.)
 
-        `restrict_vocab` is an optional integer which limits the range of vectors which
-        are searched for most-similar values. For example, restrict_vocab=10000 would
-        only check the first 10000 word vectors in the vocabulary order. (This may be
-        meaningful if you've sorted the vocabulary by descending frequency.)
+        Returns
+        -------
+        :obj: `list` of :obj: `tuple`
+            Returns a list of tuples (word, similarity)
 
         Example::
 
@@ -545,17 +410,24 @@ def similar_by_vector(self, vector, topn=10, restrict_vocab=None):
         """
         Find the top-N most similar words by vector.
 
-        If topn is False, similar_by_vector returns the vector of similarity scores.
-
-        `restrict_vocab` is an optional integer which limits the range of vectors which
-        are searched for most-similar values. For example, restrict_vocab=10000 would
-        only check the first 10000 word vectors in the vocabulary order. (This may be
-        meaningful if you've sorted the vocabulary by descending frequency.)
-
-        Example::
+        Parameters
+        ----------
+        vector : numpy.array
+            vector from which similarities are to be computed.
+            expected shape (dim,)
+        topn : int
+            Number of top-N similar words to return. If topn is False, similar_by_vector returns
+            the vector of similarity scores.
+        restrict_vocab : int
+            Optional integer which limits the range of vectors which
+            are searched for most-similar values. For example, restrict_vocab=10000 would
+            only check the first 10000 word vectors in the vocabulary order. (This may be
+            meaningful if you've sorted the vocabulary by descending frequency.)
 
-          >>> trained_model.similar_by_vector([1,2])
-          [('survey', 0.9942699074745178), ...]
+        Returns
+        -------
+        :obj: `list` of :obj: `tuple`
+            Returns a list of tuples (word, similarity)
 
         """
         return self.most_similar(positive=[vector], topn=topn, restrict_vocab=restrict_vocab)
@@ -655,7 +527,7 @@ def nbow(document):
     def most_similar_cosmul(self, positive=None, negative=None, 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
+        proposed by Omer Levy and Yoav Goldberg. Positive words still contribute
         positively towards the similarity, negative words negatively, but with less
         susceptibility to one large distance dominating the calculation.
 
@@ -671,7 +543,7 @@ def most_similar_cosmul(self, positive=None, negative=None, topn=10):
           >>> 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.
+        .. Omer Levy and Yoav Goldberg. Linguistic Regularities in Sparse and Explicit Word Representations, 2014.
 
         """
         if positive is None:
@@ -704,8 +576,8 @@ def most_similar_cosmul(self, positive=None, negative=None, topn=10):
 
         # equation (4) of Levy & Goldberg "Linguistic Regularities...",
         # with distances shifted to [0,1] per footnote (7)
-        pos_dists = [((1 + dot(self.syn0norm, term)) / 2) for term in positive]
-        neg_dists = [((1 + dot(self.syn0norm, term)) / 2) for term in negative]
+        pos_dists = [((1 + dot(self.vectors_norm, term)) / 2) for term in positive]
+        neg_dists = [((1 + dot(self.vectors_norm, term)) / 2) for term in negative]
         dists = prod(pos_dists, axis=0) / (prod(neg_dists, axis=0) + 0.000001)
 
         if not topn:
@@ -719,10 +591,20 @@ def doesnt_match(self, words):
         """
         Which word from the given list doesn't go with the others?
 
-        Example::
+        Parameters
+        ----------
+        words : :obj: `list` of :obj: `str`
+            List of words
+
+        Returns
+        -------
+        str
+            The word further away from the mean of all words.
 
-          >>> trained_model.doesnt_match("breakfast cereal dinner lunch".split())
-          'cereal'
+        Example
+        -------
+        >>> trained_model.doesnt_match("breakfast cereal dinner lunch".split())
+        'cereal'
 
         """
         self.init_sims()
@@ -754,7 +636,7 @@ def cosine_similarities(vector_1, vectors_all):
 
         Returns
         -------
-        numpy.array
+        :obj: `numpy.array`
             Contains cosine distance between vector_1 and each row in vectors_all.
             shape (num_vectors,)
 
@@ -795,23 +677,24 @@ def distances(self, word_or_vector, other_words=()):
         else:
             input_vector = word_or_vector
         if not other_words:
-            other_vectors = self.syn0
+            other_vectors = self.vectors
         else:
             other_indices = [self.vocab[word].index for word in other_words]
-            other_vectors = self.syn0[other_indices]
+            other_vectors = self.vectors[other_indices]
         return 1 - self.cosine_similarities(input_vector, other_vectors)
 
     def distance(self, w1, w2):
         """
         Compute cosine distance between two words.
 
-        Example::
+        Examples
+        --------
 
-          >>> trained_model.distance('woman', 'man')
-          0.34
+        >>> trained_model.distance('woman', 'man')
+        0.34
 
-          >>> trained_model.distance('woman', 'woman')
-          0.0
+        >>> trained_model.distance('woman', 'woman')
+        0.0
 
         """
         return 1 - self.similarity(w1, w2)
@@ -820,13 +703,14 @@ def similarity(self, w1, w2):
         """
         Compute cosine similarity between two words.
 
-        Example::
+        Examples
+        --------
 
-          >>> trained_model.similarity('woman', 'man')
-          0.73723527
+        >>> trained_model.similarity('woman', 'man')
+        0.73723527
 
-          >>> trained_model.similarity('woman', 'woman')
-          1.0
+        >>> trained_model.similarity('woman', 'woman')
+        1.0
 
         """
         return dot(matutils.unitvec(self[w1]), matutils.unitvec(self[w2]))
@@ -835,16 +719,17 @@ def n_similarity(self, ws1, ws2):
         """
         Compute cosine similarity between two sets of words.
 
-        Example::
+        Examples
+        --------
 
-          >>> trained_model.n_similarity(['sushi', 'shop'], ['japanese', 'restaurant'])
-          0.61540466561049689
+        >>> trained_model.n_similarity(['sushi', 'shop'], ['japanese', 'restaurant'])
+        0.61540466561049689
 
-          >>> trained_model.n_similarity(['restaurant', 'japanese'], ['japanese', 'restaurant'])
-          1.0000000000000004
+        >>> trained_model.n_similarity(['restaurant', 'japanese'], ['japanese', 'restaurant'])
+        1.0000000000000004
 
-          >>> trained_model.n_similarity(['sushi'], ['restaurant']) == trained_model.similarity('sushi', 'restaurant')
-          True
+        >>> trained_model.n_similarity(['sushi'], ['restaurant']) == trained_model.similarity('sushi', 'restaurant')
+        True
 
         """
         if not(len(ws1) and len(ws2)):
@@ -1037,24 +922,106 @@ def init_sims(self, replace=False):
         effectively read-only = you can call `most_similar`, `similarity` etc., but not `train`.
 
         """
-        if getattr(self, 'syn0norm', None) is None or replace:
+        if getattr(self, 'vectors_norm', None) is None or replace:
             logger.info("precomputing L2-norms of word weight vectors")
             if replace:
-                for i in xrange(self.syn0.shape[0]):
-                    self.syn0[i, :] /= sqrt((self.syn0[i, :] ** 2).sum(-1))
-                self.syn0norm = self.syn0
+                for i in xrange(self.vectors.shape[0]):
+                    self.vectors[i, :] /= sqrt((self.vectors[i, :] ** 2).sum(-1))
+                self.vectors_norm = self.vectors
             else:
-                self.syn0norm = (self.syn0 / sqrt((self.syn0 ** 2).sum(-1))[..., newaxis]).astype(REAL)
+                self.vectors_norm = (self.vectors / sqrt((self.vectors ** 2).sum(-1))[..., newaxis]).astype(REAL)
+
+
+class Word2VecKeyedVectors(WordEmbeddingsKeyedVectors):
+    """Class to contain vectors and vocab for word2vec model.
+    Used to perform operations on the vectors such as vector lookup, distance, similarity etc.
+    """
+    def save_word2vec_format(self, fname, fvocab=None, binary=False, total_vec=None):
+        """Store the input-hidden weight matrix in the same format used by the original
+        C word2vec-tool, for compatibility.
+
+        Parameters
+        ----------
+        fname : str
+            The file path used to save the vectors in
+        fvocab : str
+            Optional file path used to save the vocabulary
+        binary : bool
+            If True, the data wil be saved in binary word2vec format, else it will be saved in plain text.
+        total_vec :  int
+            Optional parameter to explicitly specify total no. of vectors
+            (in case word vectors are appended with document vectors afterwards)
 
-    def get_keras_embedding(self, train_embeddings=False):
         """
-        Return a Keras 'Embedding' layer with weights set as the Word2Vec model's learned word embeddings
+        # from gensim.models.word2vec import save_word2vec_format
+        _save_word2vec_format(
+            fname, self.vocab, self.vectors, fvocab=fvocab, binary=binary, total_vec=total_vec)
+
+    @classmethod
+    def load_word2vec_format(cls, fname, fvocab=None, binary=False, encoding='utf8', unicode_errors='strict',
+                             limit=None, datatype=REAL):
+        """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.
+
+        Parameters
+        ----------
+        fname : str
+            The file path to the saved word2vec-format file.
+        fvocab : str
+                Optional file path to the vocabulary.Word counts are read from `fvocab` filename,
+                if set (this is the file generated by `-save-vocab` flag of the original C tool).
+        binary : bool
+            If True, indicates whether the data is in binary word2vec format.
+        encoding : str
+            If you trained the C model using non-utf8 encoding for words, specify that
+            encoding in `encoding`.
+        unicode_errors : str
+            default 'strict', is a string suitable to be passed as the `errors`
+            argument to the unicode() (Python 2.x) or str() (Python 3.x) function. If your source
+            file may include word tokens truncated in the middle of a multibyte unicode character
+            (as is common from the original word2vec.c tool), 'ignore' or 'replace' may help.
+        limit : int
+            Sets a maximum number of word-vectors to read from the file. The default,
+            None, means read all.
+        datatype : :class: `numpy.float*`
+            (Experimental) Can coerce dimensions to a non-default float type (such
+            as np.float16) to save memory. (Such types may result in much slower bulk operations
+            or incompatibility with optimized routines.)
+
+        Returns
+        -------
+        :obj: `~gensim.models.word2vec.Wod2Vec`
+            Returns the loaded model as an instance of :class: `~gensim.models.word2vec.Wod2Vec`.
+
+        """
+        # from gensim.models.word2vec import load_word2vec_format
+        return _load_word2vec_format(
+            Word2VecKeyedVectors, fname, fvocab=fvocab, binary=binary, encoding=encoding, unicode_errors=unicode_errors,
+            limit=limit, datatype=datatype)
+
+    def get_keras_embedding(self, train_embeddings=False):
+        """Return a Keras 'Embedding' layer with weights set as the Word2Vec model's learned word embeddings
+
+        Parameters
+        ----------
+        train_embeddings : bool
+            If False, the weights are frozen and stopped from being updated.
+            If True, the weights can/will be further trained/updated.
+
+        Returns
+        -------
+        :obj: `keras.layers.Embedding`
+            Embedding layer
+
         """
         try:
             from keras.layers import Embedding
         except ImportError:
             raise ImportError("Please install Keras to use this function")
-        weights = self.syn0
+        weights = self.vectors
 
         # set `trainable` as `False` to use the pretrained word embedding
         # No extra mem usage here as `Embedding` layer doesn't create any new matrix for weights
@@ -1065,5 +1032,516 @@ def get_keras_embedding(self, train_embeddings=False):
         return layer
 
 
-# For backward compatibility
-KeyedVectors = EuclideanKeyedVectors
+KeyedVectors = Word2VecKeyedVectors  # alias for backward compatibility
+
+
+class Doc2VecKeyedVectors(BaseKeyedVectors):
+
+    def __init__(self, vector_size, mapfile_path):
+        super(Doc2VecKeyedVectors, self).__init__(vector_size=vector_size)
+        self.doctags = {}  # string -> Doctag (only filled if necessary)
+        self.max_rawint = -1  # highest rawint-indexed doctag
+        self.offset2doctag = []  # int offset-past-(max_rawint+1) -> String (only filled if necessary)
+        self.count = 0
+        self.vectors_docs = []
+        self.mapfile_path = mapfile_path
+        self.vector_size = vector_size
+        self.vectors_docs_norm = None
+
+    @property
+    def index2entity(self):
+        return self.offset2doctag
+
+    @index2entity.setter
+    def index2entity(self, value):
+        self.offset2doctag = value
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use docvecs.vectors_docs instead")
+    def doctag_syn0(self):
+        return self.vectors_docs
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use docvecs.vectors_docs_norm instead")
+    def doctag_syn0norm(self):
+        return self.vectors_docs_norm
+
+    def __getitem__(self, index):
+        """
+        Accept a single key (int or string tag) or list of keys as input.
+
+        If a single string or int, return designated tag's vector
+        representation, as a 1D numpy array.
+
+        If a list, return designated tags' vector representations as a
+        2D numpy array: #tags x #vector_size.
+        """
+        if index in self:
+            if isinstance(index, string_types + integer_types + (integer,)):
+                return self.vectors_docs[self._int_index(index, self.doctags, self.max_rawint)]
+            return vstack([self[i] for i in index])
+        raise KeyError("tag '%s' not seen in training corpus/invalid" % index)
+
+    def __contains__(self, index):
+        if isinstance(index, integer_types + (integer,)):
+            return index < self.count
+        else:
+            return index in self.doctags
+
+    def __len__(self):
+        return self.count
+
+    def save(self, *args, **kwargs):
+        """Saves the keyedvectors. This saved model can be loaded again using
+        :func:`~gensim.models.doc2vec.Doc2VecKeyedVectors.load` which supports
+        operations on trained document vectors like `most_similar`.
+
+        Parameters
+        ----------
+        fname : str
+            Path to the file.
+
+        """
+        # don't bother storing the cached normalized vectors
+        kwargs['ignore'] = kwargs.get('ignore', ['vectors_docs_norm'])
+        super(Doc2VecKeyedVectors, self).save(*args, **kwargs)
+
+    def init_sims(self, 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 or inference** after doing a replace.
+        The model becomes effectively read-only = you can call `most_similar`, `similarity`
+        etc., but not `train` or `infer_vector`.
+
+        """
+        if getattr(self, 'vectors_docs_norm', None) is None or replace:
+            logger.info("precomputing L2-norms of doc weight vectors")
+            if replace:
+                for i in xrange(self.vectors_docs.shape[0]):
+                    self.vectors_docs[i, :] /= sqrt((self.vectors_docs[i, :] ** 2).sum(-1))
+                self.vectors_docs_norm = self.vectors_docs
+            else:
+                if self.mapfile_path:
+                    self.vectors_docs_norm = np_memmap(
+                        self.mapfile_path + '.vectors_docs_norm', dtype=REAL,
+                        mode='w+', shape=self.vectors_docs.shape)
+                else:
+                    self.vectors_docs_norm = empty(self.vectors_docs.shape, dtype=REAL)
+                np_divide(
+                    self.vectors_docs, sqrt((self.vectors_docs ** 2).sum(-1))[..., newaxis], self.vectors_docs_norm)
+
+    def most_similar(self, positive=None, negative=None, topn=10, clip_start=0, clip_end=None, indexer=None):
+        """
+        Find the top-N most similar docvecs known from training. Positive docs contribute
+        positively towards the similarity, negative docs negatively.
+
+        This method computes cosine similarity between a simple mean of the projection
+        weight vectors of the given docs. Docs may be specified as vectors, integer indexes
+        of trained docvecs, or if the documents were originally presented with string tags,
+        by the corresponding tags.
+
+        The 'clip_start' and 'clip_end' allow limiting results to a particular contiguous
+        range of the underlying `vectors_docs_norm` vectors. (This may be useful if the ordering
+        there was chosen to be significant, such as more popular tag IDs in lower indexes.)
+
+        Parameters
+        ----------
+        positive : :obj: `list`
+            List of Docs specifed as vectors, integer indexes of trained docvecs or string tags
+            that contribute positively.
+        negative : :obj: `list`
+            List of Docs specifed as vectors, integer indexes of trained docvecs or string tags
+            that contribute negatively.
+        topn : int
+            Number of top-N similar docvecs to return.
+        clip_start : int
+            Start clipping index.
+        clip_end : int
+            End clipping index.
+
+        Returns
+        -------
+        :obj: `list` of :obj: `tuple`
+            Returns a list of tuples (doc, similarity)
+
+        """
+        if positive is None:
+            positive = []
+        if negative is None:
+            negative = []
+
+        self.init_sims()
+        clip_end = clip_end or len(self.vectors_docs_norm)
+
+        if isinstance(positive, string_types + integer_types + (integer,)) and not negative:
+            # allow calls like most_similar('dog'), as a shorthand for most_similar(['dog'])
+            positive = [positive]
+
+        # add weights for each doc, if not already present; default to 1.0 for positive and -1.0 for negative docs
+        positive = [
+            (doc, 1.0) if isinstance(doc, string_types + integer_types + (ndarray, integer))
+            else doc for doc in positive
+        ]
+        negative = [
+            (doc, -1.0) if isinstance(doc, string_types + integer_types + (ndarray, integer))
+            else doc for doc in negative
+        ]
+
+        # compute the weighted average of all docs
+        all_docs, mean = set(), []
+        for doc, weight in positive + negative:
+            if isinstance(doc, ndarray):
+                mean.append(weight * doc)
+            elif doc in self.doctags or doc < self.count:
+                mean.append(weight * self.vectors_docs_norm[self._int_index(doc, self.doctags, self.max_rawint)])
+                all_docs.add(self._int_index(doc, self.doctags, self.max_rawint))
+            else:
+                raise KeyError("doc '%s' not in trained set" % doc)
+        if not mean:
+            raise ValueError("cannot compute similarity with no input")
+        mean = matutils.unitvec(array(mean).mean(axis=0)).astype(REAL)
+
+        if indexer is not None:
+            return indexer.most_similar(mean, topn)
+
+        dists = dot(self.vectors_docs_norm[clip_start:clip_end], mean)
+        if not topn:
+            return dists
+        best = matutils.argsort(dists, topn=topn + len(all_docs), reverse=True)
+        # ignore (don't return) docs from the input
+        result = [
+            (self._index_to_doctag(sim + clip_start, self.offset2doctag, self.max_rawint), float(dists[sim]))
+            for sim in best
+            if (sim + clip_start) not in all_docs
+        ]
+        return result[:topn]
+
+    def doesnt_match(self, docs):
+        """
+        Which doc from the given list doesn't go with the others?
+
+        (TODO: Accept vectors of out-of-training-set docs, as if from inference.)
+
+        Parameters
+        ----------
+        docs : :obj: `list` of (str or int)
+            List of seen documents specified by their corresponding string tags or integer indices.
+
+        Returns
+        -------
+        str or int
+            The document further away from the mean of all the documents.
+
+        """
+        self.init_sims()
+
+        docs = [doc for doc in docs if doc in self.doctags or 0 <= doc < self.count]  # filter out unknowns
+        logger.debug("using docs %s", docs)
+        if not docs:
+            raise ValueError("cannot select a doc from an empty list")
+        vectors = vstack(
+            self.vectors_docs_norm[self._int_index(doc, self.doctags, self.max_rawint)] for doc in docs).astype(REAL)
+        mean = matutils.unitvec(vectors.mean(axis=0)).astype(REAL)
+        dists = dot(vectors, mean)
+        return sorted(zip(dists, docs))[0][1]
+
+    def similarity(self, d1, d2):
+        """
+        Compute cosine similarity between two docvecs in the trained set, specified by int index or
+        string tag. (TODO: Accept vectors of out-of-training-set docs, as if from inference.)
+
+        Parameters
+        ----------
+        d1 : int or str
+            Indicate the first document by it's string tag or integer index.
+        d2 : int or str
+            Indicate the second document by it's string tag or integer index.
+
+        Returns
+        -------
+        float
+            The cosine similarity between the vectors of the two documents.
+
+        """
+        return dot(matutils.unitvec(self[d1]), matutils.unitvec(self[d2]))
+
+    def n_similarity(self, ds1, ds2):
+        """
+        Compute cosine similarity between two sets of docvecs from the trained set, specified by int
+        index or string tag. (TODO: Accept vectors of out-of-training-set docs, as if from inference.)
+
+        Parameters
+        ----------
+        ds1 : :obj: `list` of (str or int)
+            Specify the first set of documents as a list of their integer indices or string tags.
+        ds2 : :obj: `list` of (str or int)
+            Specify the second set of documents as a list of their integer indices or string tags.
+
+        Returns
+        -------
+        float
+            The cosine similarity between the means of the documents in each of the two sets.
+
+        """
+        v1 = [self[doc] for doc in ds1]
+        v2 = [self[doc] for doc in ds2]
+        return dot(matutils.unitvec(array(v1).mean(axis=0)), matutils.unitvec(array(v2).mean(axis=0)))
+
+    def distance(self, d1, d2):
+        """
+        Compute cosine distance between two documents.
+
+        """
+        return 1 - self.similarity(d1, d2)
+
+    # required by base keyed vectors class
+    def distances(self, d1, other_docs=()):
+        """Compute distances from given document (string tag or int index) to all documents in `other_docs`.
+        If `other_docs` is empty, return distance between `d1` and all documents seen during training.
+        """
+        input_vector = self[d1]
+        if not other_docs:
+            other_vectors = self.vectors_docs
+        else:
+            other_vectors = self[other_docs]
+        return 1 - WordEmbeddingsKeyedVectors.cosine_similarities(input_vector, other_vectors)
+
+    def similarity_unseen_docs(self, model, doc_words1, doc_words2, alpha=0.1, min_alpha=0.0001, steps=5):
+        """
+        Compute cosine similarity between two post-bulk out of training documents.
+
+        Parameters
+        ----------
+        model : :obj: `~gensim.models.doc2vec.Doc2Vec`
+            An instance of a trained `Doc2Vec` model.
+        doc_words1 : :obj: `list` of :obj: `str`
+            The first document. Document should be a list of (word) tokens.
+        doc_words2 : :obj: `list` of :obj: `str`
+            The second document. Document should be a list of (word) tokens.
+        alpha : float
+            The initial learning rate.
+        min_alpha : float
+            Learning rate will linearly drop to `min_alpha` as training progresses.
+        steps : int
+            Number of times to train the new document.
+
+        Returns
+        -------
+        float
+            The cosine similarity between the unseen documents.
+
+        """
+        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))
+
+    def save_word2vec_format(self, fname, prefix='*dt_', fvocab=None,
+                             total_vec=None, binary=False, write_first_line=True):
+        """Store the input-hidden weight matrix in the same format used by the original
+        C word2vec-tool, for compatibility.
+
+        Parameters
+        ----------
+        fname : str
+            The file path used to save the vectors in.
+        prefix : str
+            Uniquely identifies doctags from word vocab, and avoids collision
+            in case of repeated string in doctag and word vocab.
+        fvocab : str
+            Optional file path used to save the vocabulary
+        binary : bool
+            If True, the data wil be saved in binary word2vec format, else it will be saved in plain text.
+        total_vec :  int
+            Optional parameter to explicitly specify total no. of vectors
+            (in case word vectors are appended with document vectors afterwards)
+        write_first_line : bool
+            Whether to print the first line in the file. Useful when saving doc-vectors after word-vectors.
+
+        """
+        total_vec = total_vec or len(self)
+        with utils.smart_open(fname, 'ab') as fout:
+            if write_first_line:
+                logger.info("storing %sx%s projection weights into %s", total_vec, self.vectors_docs.shape[1], fname)
+                fout.write(utils.to_utf8("%s %s\n" % (total_vec, self.vectors_docs.shape[1])))
+            # store as in input order
+            for i in range(len(self)):
+                doctag = u"%s%s" % (prefix, self._index_to_doctag(i, self.offset2doctag, self.max_rawint))
+                row = self.vectors_docs[i]
+                if binary:
+                    fout.write(utils.to_utf8(doctag) + b" " + row.tostring())
+                else:
+                    fout.write(utils.to_utf8("%s %s\n" % (doctag, ' '.join("%f" % val for val in row))))
+
+    @staticmethod
+    def _int_index(index, doctags, max_rawint):
+        """Return int index for either string or int index"""
+        if isinstance(index, integer_types + (integer,)):
+            return index
+        else:
+            return max_rawint + 1 + doctags[index].offset
+
+    @staticmethod
+    def _index_to_doctag(i_index, offset2doctag, max_rawint):
+        """Return string key for given i_index, if available. Otherwise return raw int doctag (same int)."""
+        candidate_offset = i_index - max_rawint - 1
+        if 0 <= candidate_offset < len(offset2doctag):
+            return offset2doctag[candidate_offset]
+        else:
+            return i_index
+
+    # for backward compatibility
+    def index_to_doctag(self, i_index):
+        """Return string key for given i_index, if available. Otherwise return raw int doctag (same int)."""
+        candidate_offset = i_index - self.max_rawint - 1
+        if 0 <= candidate_offset < len(self.offset2doctag):
+            return self.ffset2doctag[candidate_offset]
+        else:
+            return i_index
+
+    # for backward compatibility
+    def int_index(self, index, doctags, max_rawint):
+        """Return int index for either string or int index"""
+        if isinstance(index, integer_types + (integer,)):
+            return index
+        else:
+            return max_rawint + 1 + doctags[index].offset
+
+
+class FastTextKeyedVectors(WordEmbeddingsKeyedVectors):
+    """
+    Class to contain vectors and vocab for the FastText training class and other methods not directly
+    involved in training such as most_similar()
+    """
+
+    def __init__(self, vector_size, min_n, max_n):
+        super(FastTextKeyedVectors, self).__init__(vector_size=vector_size)
+        self.vectors_vocab = None
+        self.vectors_vocab_norm = None
+        self.vectors_ngrams = None
+        self.vectors_ngrams_norm = None
+        self.ngrams = {}
+        self.hash2index = {}
+        self.ngrams_word = {}
+        self.min_n = min_n
+        self.max_n = max_n
+        self.num_ngram_vectors = 0
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.wv.vectors_vocab instead")
+    def syn0_vocab(self):
+        return self.vectors_vocab
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.wv.vectors_vocab_norm instead")
+    def syn0_vocab_norm(self):
+        return self.vectors_vocab_norm
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.wv.vectors_ngrams instead")
+    def syn0_ngrams(self):
+        return self.vectors_ngrams
+
+    @property
+    @deprecated("Attribute will be removed in 4.0.0, use self.wv.vectors_ngrams_norm instead")
+    def syn0_ngrams_norm(self):
+        return self.vectors_ngrams_norm
+
+    def __contains__(self, word):
+        """
+        Check if `word` or any character ngrams in `word` are present in the vocabulary.
+        A vector for the word is guaranteed to exist if `__contains__` returns True.
+        """
+        if word in self.vocab:
+            return True
+        else:
+            # from gensim.models.fasttext import compute_ngrams
+            char_ngrams = _compute_ngrams(word, self.min_n, self.max_n)
+            return any(ng in self.ngrams for ng in char_ngrams)
+
+    def save(self, *args, **kwargs):
+        """Saves the keyedvectors. This saved model can be loaded again using
+        :func:`~gensim.models.fasttext.FastTextKeyedVectors.load` which supports
+        getting vectors for out-of-vocabulary words.
+
+        Parameters
+        ----------
+        fname : str
+            Path to the file.
+
+        """
+        # don't bother storing the cached normalized vectors
+        kwargs['ignore'] = kwargs.get('ignore', ['vectors_norm', 'vectors_vocab_norm', 'vectors_ngrams_norm'])
+        super(FastTextKeyedVectors, self).save(*args, **kwargs)
+
+    def word_vec(self, word, use_norm=False):
+        """
+        Accept a single word as input.
+        Returns the word's representations in vector space, as a 1D numpy array.
+
+        If `use_norm` is True, returns the normalized word vector.
+
+        """
+        if word in self.vocab:
+            return super(FastTextKeyedVectors, self).word_vec(word, use_norm)
+        else:
+            # from gensim.models.fasttext import compute_ngrams
+            word_vec = np.zeros(self.vectors_ngrams.shape[1], dtype=np.float32)
+            ngrams = _compute_ngrams(word, self.min_n, self.max_n)
+            ngrams = [ng for ng in ngrams if ng in self.ngrams]
+            if use_norm:
+                ngram_weights = self.vectors_ngrams_norm
+            else:
+                ngram_weights = self.vectors_ngrams
+            for ngram in ngrams:
+                word_vec += ngram_weights[self.ngrams[ngram]]
+            if word_vec.any():
+                return word_vec / len(ngrams)
+            else:  # No ngrams of the word are present in self.ngrams
+                raise KeyError('all ngrams for word %s absent from model' % word)
+
+    def init_sims(self, 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 only call `most_similar`, `similarity` etc.
+
+        """
+        super(FastTextKeyedVectors, self).init_sims(replace)
+        if getattr(self, 'vectors_ngrams_norm', None) is None or replace:
+            logger.info("precomputing L2-norms of ngram weight vectors")
+            if replace:
+                for i in range(self.vectors_ngrams.shape[0]):
+                    self.vectors_ngrams[i, :] /= sqrt((self.vectors_ngrams[i, :] ** 2).sum(-1))
+                self.vectors_ngrams_norm = self.vectors_ngrams
+            else:
+                self.vectors_ngrams_norm = \
+                    (self.vectors_ngrams / sqrt((self.vectors_ngrams ** 2).sum(-1))[..., newaxis]).astype(REAL)
+
+    def save_word2vec_format(self, fname, fvocab=None, binary=False, total_vec=None):
+        """Store the input-hidden weight matrix in the same format used by the original
+        C word2vec-tool, for compatibility.
+
+        Parameters
+        ----------
+        fname : str
+            The file path used to save the vectors in.
+        fvocab : str
+            Optional file path used to save the vocabulary.
+        binary : bool
+            If True, the data wil be saved in binary word2vec format, else it will be saved in plain text.
+        total_vec :  int
+            Optional parameter to explicitly specify total no. of vectors
+            (in case word vectors are appended with document vectors afterwards).
+
+        """
+        # from gensim.models.word2vec import save_word2vec_format
+        _save_word2vec_format(
+            fname, self.vocab, self.vectors, fvocab=fvocab, binary=binary, total_vec=total_vec)
diff --git a/gensim/models/poincare.py b/gensim/models/poincare.py
index 921e7e74f6..6aa02d7983 100644
--- a/gensim/models/poincare.py
+++ b/gensim/models/poincare.py
@@ -52,7 +52,9 @@
 from smart_open import smart_open
 
 from gensim import utils, matutils
-from gensim.models.keyedvectors import KeyedVectorsBase, Vocab
+from gensim.models.keyedvectors import Vocab, BaseKeyedVectors
+from gensim.models.utils_any2vec import _save_word2vec_format, _load_word2vec_format
+from numpy import float32 as REAL
 
 try:
     from autograd import grad  # Only required for optionally verifying gradients while training
@@ -130,7 +132,7 @@ def __init__(self, train_data, size=50, alpha=0.1, negative=10, workers=1, epsil
 
         """
         self.train_data = train_data
-        self.kv = PoincareKeyedVectors()
+        self.kv = PoincareKeyedVectors(size)
         self.size = size
         self.train_alpha = alpha  # Learning rate for training
         self.burn_in_alpha = burn_in_alpha  # Learning rate for burn-in
@@ -754,16 +756,121 @@ def compute_loss(self):
         self._loss_computed = True
 
 
-class PoincareKeyedVectors(KeyedVectorsBase):
+class PoincareKeyedVectors(BaseKeyedVectors):
     """Class to contain vectors and vocab for the :class:`~gensim.models.poincare.PoincareModel` training class.
 
     Used to perform operations on the vectors such as vector lookup, distance etc.
 
     """
 
-    def __init__(self):
-        super(PoincareKeyedVectors, self).__init__()
+    def __init__(self, vector_size):
+        super(PoincareKeyedVectors, self).__init__(vector_size)
         self.max_distance = 0
+        self.index2word = []
+
+    @property
+    def vectors(self):
+        return self.syn0
+
+    @vectors.setter
+    def vectors(self, value):
+        self.syn0 = value
+
+    @property
+    def index2entity(self):
+        return self.index2word
+
+    @index2entity.setter
+    def index2entity(self, value):
+        self.index2word = value
+
+    def word_vec(self, word):
+        """
+        Accept a single word as input.
+        Returns the word's representations in vector space, as a 1D numpy array.
+
+        Example::
+
+          >>> trained_model.word_vec('office')
+          array([ -1.40128313e-02, ...])
+
+        """
+        return super(PoincareKeyedVectors, self).get_vector(word)
+
+    def words_closer_than(self, w1, w2):
+        """
+        Returns all words that are closer to `w1` than `w2` is to `w1`.
+
+        Parameters
+        ----------
+        w1 : str
+            Input word.
+        w2 : str
+            Input word.
+
+        Returns
+        -------
+        list (str)
+            List of words that are closer to `w1` than `w2` is to `w1`.
+
+        Examples
+        --------
+
+        >>> model.words_closer_than('carnivore.n.01', 'mammal.n.01')
+        ['dog.n.01', 'canine.n.02']
+
+        """
+        return super(PoincareKeyedVectors, self).closer_than(w1, w2)
+
+    def save_word2vec_format(self, fname, fvocab=None, binary=False, total_vec=None):
+        """
+        Store the input-hidden weight matrix in the same format used by the original
+        C word2vec-tool, for compatibility.
+
+         `fname` is the file used to save the vectors in
+         `fvocab` is an optional file used to save the vocabulary
+         `binary` is an optional boolean indicating whether the data is to be saved
+         in binary word2vec format (default: False)
+         `total_vec` is an optional parameter to explicitly specify total no. of vectors
+         (in case word vectors are appended with document vectors afterwards)
+
+        """
+        _save_word2vec_format(fname, self.vocab, self.syn0, fvocab=fvocab, binary=binary, total_vec=total_vec)
+
+    @classmethod
+    def load_word2vec_format(cls, fname, fvocab=None, binary=False, encoding='utf8', unicode_errors='strict',
+                             limit=None, datatype=REAL):
+        """
+        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).
+
+        If you trained the C model using non-utf8 encoding for words, specify that
+        encoding in `encoding`.
+
+        `unicode_errors`, default 'strict', is a string suitable to be passed as the `errors`
+        argument to the unicode() (Python 2.x) or str() (Python 3.x) function. If your source
+        file may include word tokens truncated in the middle of a multibyte unicode character
+        (as is common from the original word2vec.c tool), 'ignore' or 'replace' may help.
+
+        `limit` sets a maximum number of word-vectors to read from the file. The default,
+        None, means read all.
+
+        `datatype` (experimental) can coerce dimensions to a non-default float type (such
+        as np.float16) to save memory. (Such types may result in much slower bulk operations
+        or incompatibility with optimized routines.)
+
+        """
+        return _load_word2vec_format(
+            PoincareKeyedVectors, fname, fvocab=fvocab, binary=binary, encoding=encoding, unicode_errors=unicode_errors,
+            limit=limit, datatype=datatype)
 
     @staticmethod
     def vector_distance(vector_1, vector_2):
@@ -1519,7 +1626,7 @@ def score_function(self, embedding, trie, term_1, term_2):
         assert min_term_1 is not None and min_term_2 is not None
         vector_1, vector_2 = embedding.word_vec(min_term_1), embedding.word_vec(min_term_2)
         norm_1, norm_2 = np.linalg.norm(vector_1), np.linalg.norm(vector_2)
-        return -1 * (1 + self.alpha * (norm_2 - norm_1)) * distance
+        return -1 * (1 + self.alpha * (norm_2 - norm_1)) * min_distance
 
     @staticmethod
     def find_matching_terms(trie, word):
diff --git a/gensim/models/utils_any2vec.py b/gensim/models/utils_any2vec.py
new file mode 100644
index 0000000000..f0bc9077ed
--- /dev/null
+++ b/gensim/models/utils_any2vec.py
@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Author: Shiva Manne <s.manne@rare-technologies.com>
+# Copyright (C) 2018 RaRe Technologies s.r.o.
+
+"""This module contains various general functions useful for any2vec models."""
+
+import logging
+import numpy as np
+from gensim import utils
+
+from numpy import zeros, dtype, float32 as REAL, ascontiguousarray, fromstring
+
+from six.moves import xrange
+from six import iteritems
+
+logger = logging.getLogger(__name__)
+
+
+def _compute_ngrams(word, min_n, max_n):
+    """Returns the list of all possible ngrams for a given word.
+
+    Parameters
+    ----------
+    word : str
+        The word whose ngrams need to be computed
+    min_n : int
+        minimum character length of the ngrams
+    max_n : int
+        maximum character length of the ngrams
+
+    Returns
+    -------
+    :obj:`list` of :obj:`str`
+        List of character ngrams
+
+    """
+    BOW, EOW = ('<', '>')  # Used by FastText to attach to all words as prefix and suffix
+    extended_word = BOW + word + EOW
+    ngrams = []
+    for ngram_length in range(min_n, min(len(extended_word), max_n) + 1):
+        for i in range(0, len(extended_word) - ngram_length + 1):
+            ngrams.append(extended_word[i:i + ngram_length])
+    return ngrams
+
+
+def _ft_hash(string):
+    """Reproduces [hash method](https://github.com/facebookresearch/fastText/blob/master/src/dictionary.cc)
+    used in [1]_.
+
+    Parameter
+    ---------
+    string : str
+        The string whose hash needs to be calculated
+
+    Returns
+    -------
+    int
+        The hash of the string
+
+    """
+    # Runtime warnings for integer overflow are raised, this is expected behaviour. These warnings are suppressed.
+    old_settings = np.seterr(all='ignore')
+    h = np.uint32(2166136261)
+    for c in string:
+        h = h ^ np.uint32(ord(c))
+        h = h * np.uint32(16777619)
+    np.seterr(**old_settings)
+    return h
+
+
+def _save_word2vec_format(fname, vocab, vectors, fvocab=None, binary=False, total_vec=None):
+        """Store the input-hidden weight matrix in the same format used by the original
+        C word2vec-tool, for compatibility.
+
+        Parameters
+        ----------
+        fname : str
+            The file path used to save the vectors in
+        vocab : dict
+            The vocabulary of words
+        vectors : numpy.array
+            The vectors to be stored
+        fvocab : str
+            Optional file path used to save the vocabulary
+        binary : bool
+            If True, the data wil be saved in binary word2vec format, else it will be saved in plain text.
+        total_vec :  int
+            Optional parameter to explicitly specify total no. of vectors
+            (in case word vectors are appended with document vectors afterwards)
+
+        """
+        if not (vocab or vectors):
+            raise RuntimeError("no input")
+        if total_vec is None:
+            total_vec = len(vocab)
+        vector_size = vectors.shape[1]
+        if fvocab is not None:
+            logger.info("storing vocabulary in %s", fvocab)
+            with utils.smart_open(fvocab, 'wb') as vout:
+                for word, vocab_ in sorted(iteritems(vocab), key=lambda item: -item[1].count):
+                    vout.write(utils.to_utf8("%s %s\n" % (word, vocab_.count)))
+        logger.info("storing %sx%s projection weights into %s", total_vec, vector_size, fname)
+        assert (len(vocab), vector_size) == vectors.shape
+        with utils.smart_open(fname, 'wb') as fout:
+            fout.write(utils.to_utf8("%s %s\n" % (total_vec, vector_size)))
+            # store in sorted order: most frequent words at the top
+            for word, vocab_ in sorted(iteritems(vocab), key=lambda item: -item[1].count):
+                row = vectors[vocab_.index]
+                if binary:
+                    row = row.astype(REAL)
+                    fout.write(utils.to_utf8(word) + b" " + row.tostring())
+                else:
+                    fout.write(utils.to_utf8("%s %s\n" % (word, ' '.join(repr(val) for val in row))))
+
+
+def _load_word2vec_format(cls, fname, fvocab=None, binary=False, encoding='utf8', unicode_errors='strict',
+                          limit=None, datatype=REAL):
+    """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.
+
+    Parameters
+    ----------
+    fname : str
+        The file path to the saved word2vec-format file.
+    fvocab : str
+            Optional file path to the vocabulary.Word counts are read from `fvocab` filename,
+            if set (this is the file generated by `-save-vocab` flag of the original C tool).
+    binary : bool
+        If True, indicates whether the data is in binary word2vec format.
+    encoding : str
+        If you trained the C model using non-utf8 encoding for words, specify that
+        encoding in `encoding`.
+    unicode_errors : str
+        default 'strict', is a string suitable to be passed as the `errors`
+        argument to the unicode() (Python 2.x) or str() (Python 3.x) function. If your source
+        file may include word tokens truncated in the middle of a multibyte unicode character
+        (as is common from the original word2vec.c tool), 'ignore' or 'replace' may help.
+    limit : int
+        Sets a maximum number of word-vectors to read from the file. The default,
+        None, means read all.
+    datatype : :class: `numpy.float*`
+        (Experimental) Can coerce dimensions to a non-default float type (such
+        as np.float16) to save memory. (Such types may result in much slower bulk operations
+        or incompatibility with optimized routines.)
+
+    Returns
+    -------
+    :obj: `cls`
+        Returns the loaded model as an instance of :class: `cls`.
+
+    """
+    from gensim.models.keyedvectors import Vocab
+    counts = None
+    if fvocab is not None:
+        logger.info("loading word counts from %s", fvocab)
+        counts = {}
+        with utils.smart_open(fvocab) as fin:
+            for line in fin:
+                word, count = utils.to_unicode(line).strip().split()
+                counts[word] = int(count)
+
+    logger.info("loading projection weights from %s", fname)
+    with utils.smart_open(fname) as fin:
+        header = utils.to_unicode(fin.readline(), encoding=encoding)
+        vocab_size, vector_size = (int(x) for x in header.split())  # throws for invalid file format
+        if limit:
+            vocab_size = min(vocab_size, limit)
+        result = cls(vector_size)
+        result.vector_size = vector_size
+        result.vectors = zeros((vocab_size, vector_size), dtype=datatype)
+
+        def add_word(word, weights):
+            word_id = len(result.vocab)
+            if word in result.vocab:
+                logger.warning("duplicate word '%s' in %s, ignoring all but first", word, fname)
+                return
+            if counts is None:
+                # most common scenario: no vocab file given. just make up some bogus counts, in descending order
+                result.vocab[word] = Vocab(index=word_id, count=vocab_size - word_id)
+            elif word in counts:
+                # use count from the vocab file
+                result.vocab[word] = Vocab(index=word_id, count=counts[word])
+            else:
+                # vocab file given, but word is missing -- set count to None (TODO: or raise?)
+                logger.warning("vocabulary file is incomplete: '%s' is missing", word)
+                result.vocab[word] = Vocab(index=word_id, count=None)
+            result.vectors[word_id] = weights
+            result.index2word.append(word)
+
+        if binary:
+            binary_len = dtype(REAL).itemsize * vector_size
+            for _ in xrange(vocab_size):
+                # mixed text and binary: read text first, then binary
+                word = []
+                while True:
+                    ch = fin.read(1)
+                    if ch == b' ':
+                        break
+                    if ch == b'':
+                        raise EOFError("unexpected end of input; is count incorrect or file otherwise damaged?")
+                    if ch != b'\n':  # ignore newlines in front of words (some binary files have)
+                        word.append(ch)
+                word = utils.to_unicode(b''.join(word), encoding=encoding, errors=unicode_errors)
+                weights = fromstring(fin.read(binary_len), dtype=REAL).astype(datatype)
+                add_word(word, weights)
+        else:
+            for line_no in xrange(vocab_size):
+                line = fin.readline()
+                if line == b'':
+                    raise EOFError("unexpected end of input; is count incorrect or file otherwise damaged?")
+                parts = utils.to_unicode(line.rstrip(), encoding=encoding, errors=unicode_errors).split(" ")
+                if len(parts) != vector_size + 1:
+                    raise ValueError("invalid vector on line %s (is this really the text format?)" % line_no)
+                word, weights = parts[0], [datatype(x) for x in parts[1:]]
+                add_word(word, weights)
+    if result.vectors.shape[0] != len(result.vocab):
+        logger.info(
+            "duplicate words detected, shrinking matrix size from %i to %i",
+            result.vectors.shape[0], len(result.vocab)
+        )
+        result.vectors = ascontiguousarray(result.vectors[: len(result.vocab)])
+    assert (len(result.vocab), vector_size) == result.vectors.shape
+
+    logger.info("loaded %s matrix from %s", result.vectors.shape, fname)
+    return result
diff --git a/gensim/models/word2vec.py b/gensim/models/word2vec.py
old mode 100644
new mode 100755
index c4d953e123..50be048f4a
--- a/gensim/models/word2vec.py
+++ b/gensim/models/word2vec.py
@@ -1,16 +1,15 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2013 Radim Rehurek <me@radimrehurek.com>
+# Author: Shiva Manne <manneshiva@gmail.com>
+# Copyright (C) 2018 RaRe Technologies s.r.o.
 # Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
 
-
-"""
-Produce word vectors with deep learning via word2vec's "skip-gram and CBOW models", using either
+"""Produce word vectors with deep learning via word2vec's "skip-gram and CBOW models", using either
 hierarchical softmax or negative sampling [1]_ [2]_.
 
 NOTE: There are more ways to get word vectors in Gensim than just Word2Vec.
-See wrappers for FastText, VarEmbed and WordRank.
+See FastText and wrappers for VarEmbed and WordRank.
 
 The training algorithms were originally ported from the C package https://code.google.com/p/word2vec/
 and extended with additional functionality.
@@ -37,14 +36,14 @@
   array([-0.00449447, -0.00310097,  0.02421786, ...], dtype=float32)
 
 The word vectors can also be instantiated from an existing file on disk in the word2vec C format
-as a KeyedVectors instance::
+as a KeyedVectors instance.
 
-    NOTE: It is impossible to continue training the vectors loaded from the C format because hidden weights,
-    vocabulary frequency and the binary tree is missing::
+NOTE: It is impossible to continue training the vectors loaded from the C format because hidden weights,
+vocabulary frequency and the binary tree is missing::
 
-        >>> from gensim.models.keyedvectors import KeyedVectors
-        >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.txt', binary=False)  # C text format
-        >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.bin', binary=True)  # C binary format
+    >>> from gensim.models import KeyedVectors
+    >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.txt', binary=False)  # C text format
+    >>> word_vectors = KeyedVectors.load_word2vec_format('/tmp/vectors.bin', binary=True)  # C binary format
 
 
 You can perform various NLP word tasks with the model. Some of them
@@ -114,16 +113,17 @@
 import warnings
 
 from gensim.utils import keep_vocab_item, call_on_class_only
-from gensim.models.keyedvectors import KeyedVectors, Vocab
+from gensim.models.keyedvectors import Vocab, Word2VecKeyedVectors
+from gensim.models.base_any2vec import BaseWordEmbeddingsModel
 
 try:
     from queue import Queue, Empty
 except ImportError:
     from Queue import Queue, Empty
 
-from numpy import exp, log, dot, zeros, outer, random, dtype, float32 as REAL,\
+from numpy import exp, dot, zeros, random, dtype, float32 as REAL,\
     uint32, seterr, array, uint8, vstack, fromstring, sqrt,\
-    empty, sum as np_sum, ones, logaddexp
+    empty, sum as np_sum, ones, logaddexp, log, outer
 
 from scipy.special import expit
 
@@ -131,7 +131,6 @@
 from gensim.utils import deprecated
 from six import iteritems, itervalues, string_types
 from six.moves import xrange
-from types import GeneratorType
 
 logger = logging.getLogger(__name__)
 
@@ -139,6 +138,7 @@
     from gensim.models.word2vec_inner import train_batch_sg, train_batch_cbow
     from gensim.models.word2vec_inner import score_sentence_sg, score_sentence_cbow
     from gensim.models.word2vec_inner import FAST_VERSION, MAX_WORDS_IN_BATCH
+
 except ImportError:
     # failed... fall back to plain numpy (20-80x slower training than the above)
     FAST_VERSION = -1
@@ -147,18 +147,15 @@
     def train_batch_sg(model, sentences, alpha, work=None, compute_loss=False):
         """
         Update skip-gram model by training on a sequence of sentences.
-
         Each sentence is a list of string tokens, which are looked up in the model's
         vocab dictionary. Called internally from `Word2Vec.train()`.
-
         This is the non-optimized, Python version. If you have cython installed, gensim
         will use the optimized version from word2vec_inner instead.
-
         """
         result = 0
         for sentence in sentences:
             word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab and
-                           model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+                           model.wv.vocab[w].sample_int > model.random.rand() * 2 ** 32]
             for pos, word in enumerate(word_vocabs):
                 reduced_window = model.random.randint(model.window)  # `b` in the original word2vec code
 
@@ -177,18 +174,15 @@ def train_batch_sg(model, sentences, alpha, work=None, compute_loss=False):
     def train_batch_cbow(model, sentences, alpha, work=None, neu1=None, compute_loss=False):
         """
         Update CBOW model by training on a sequence of sentences.
-
         Each sentence is a list of string tokens, which are looked up in the model's
         vocab dictionary. Called internally from `Word2Vec.train()`.
-
         This is the non-optimized, Python version. If you have cython installed, gensim
         will use the optimized version from word2vec_inner instead.
-
         """
         result = 0
         for sentence in sentences:
             word_vocabs = [model.wv.vocab[w] for w in sentence if w in model.wv.vocab and
-                           model.wv.vocab[w].sample_int > model.random.rand() * 2**32]
+                           model.wv.vocab[w].sample_int > model.random.rand() * 2 ** 32]
             for pos, word in enumerate(word_vocabs):
                 reduced_window = model.random.randint(model.window)  # `b` in the original word2vec code
                 start = max(0, pos - model.window + reduced_window)
@@ -204,13 +198,10 @@ def train_batch_cbow(model, sentences, alpha, work=None, neu1=None, compute_loss
     def score_sentence_sg(model, sentence, work=None):
         """
         Obtain likelihood score for a single sentence in a fitted skip-gram representaion.
-
         The sentence is a list of Vocab objects (or None, when the corresponding
         word is not in the vocabulary). Called internally from `Word2Vec.score()`.
-
         This is the non-optimized, Python version. If you have cython installed, gensim
         will use the optimized version from word2vec_inner instead.
-
         """
         log_prob_sentence = 0.0
         if model.negative:
@@ -233,13 +224,10 @@ def score_sentence_sg(model, sentence, work=None):
     def score_sentence_cbow(model, sentence, work=None, neu1=None):
         """
         Obtain likelihood score for a single sentence in a fitted CBOW representaion.
-
         The sentence is a list of Vocab objects (or None, where the corresponding
         word is not in the vocabulary. Called internally from `Word2Vec.score()`.
-
         This is the non-optimized, Python version. If you have cython installed, gensim
         will use the optimized version from word2vec_inner instead.
-
         """
         log_prob_sentence = 0.0
         if model.negative:
@@ -303,7 +291,7 @@ def train_sg_pair(model, word, context_index, alpha, learn_vectors=True, learn_h
 
         # loss component corresponding to hierarchical softmax
         if compute_loss:
-            sgn = (-1.0)**predict_word.code  # `ch` function, 0 -> 1, 1 -> -1
+            sgn = (-1.0) ** predict_word.code  # `ch` function, 0 -> 1, 1 -> -1
             lprob = -log(expit(-sgn * prod_term))
             model.running_training_loss += sum(lprob)
 
@@ -365,7 +353,7 @@ def train_cbow_pair(model, word, input_word_indices, l1, alpha, learn_vectors=Tr
 
         # loss component corresponding to hierarchical softmax
         if compute_loss:
-            sgn = (-1.0)**word.code  # ch function, 0-> 1, 1 -> -1
+            sgn = (-1.0) ** word.code  # ch function, 0-> 1, 1 -> -1
             model.running_training_loss += sum(-log(expit(-sgn * prod_term)))
 
     if model.negative:
@@ -409,932 +397,390 @@ def train_cbow_pair(model, word, input_word_indices, l1, alpha, learn_vectors=Tr
 def score_sg_pair(model, word, word2):
     l1 = model.wv.syn0[word2.index]
     l2a = deepcopy(model.syn1[word.point])  # 2d matrix, codelen x layer1_size
-    sgn = (-1.0)**word.code  # ch function, 0-> 1, 1 -> -1
+    sgn = (-1.0) ** word.code  # ch function, 0-> 1, 1 -> -1
     lprob = -logaddexp(0, -sgn * dot(l1, l2a.T))
     return sum(lprob)
 
 
 def score_cbow_pair(model, word, l1):
     l2a = model.syn1[word.point]  # 2d matrix, codelen x layer1_size
-    sgn = (-1.0)**word.code  # ch function, 0-> 1, 1 -> -1
+    sgn = (-1.0) ** word.code  # ch function, 0-> 1, 1 -> -1
     lprob = -logaddexp(0, -sgn * dot(l1, l2a.T))
     return sum(lprob)
 
 
-class Word2Vec(utils.SaveLoad):
-    """
-    Class for training, using and evaluating neural networks described in https://code.google.com/p/word2vec/
+class Word2Vec(BaseWordEmbeddingsModel):
+    """Class for training, using and evaluating neural networks described in https://code.google.com/p/word2vec/
 
     If you're finished training a model (=no more updates, only querying)
     then switch to the :mod:`gensim.models.KeyedVectors` instance in wv
 
-    The model can be stored/loaded via its `save()` and `load()` methods, or stored/loaded in a format
+    The model can be stored/loaded via its :meth:`~gensim.models.word2vec.Word2Vec.save()` and
+    :meth:`~gensim.models.word2vec.Word2Vec.load()` methods, or stored/loaded in a format
     compatible with the original word2vec implementation via `wv.save_word2vec_format()`
-    and `KeyedVectors.load_word2vec_format()`.
+    and `Word2VecKeyedVectors.load_word2vec_format()`.
 
     """
 
     def __init__(self, sentences=None, size=100, alpha=0.025, window=5, min_count=5,
                  max_vocab_size=None, sample=1e-3, seed=1, workers=3, min_alpha=0.0001,
                  sg=0, hs=0, negative=5, cbow_mean=1, hashfxn=hash, iter=5, null_word=0,
-                 trim_rule=None, sorted_vocab=1, batch_words=MAX_WORDS_IN_BATCH, compute_loss=False):
+                 trim_rule=None, sorted_vocab=1, batch_words=MAX_WORDS_IN_BATCH, compute_loss=False, callbacks=()):
         """
         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 :class:`BrownCorpus`, :class:`Text8Corpus` or :class:`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=0`), CBOW is used.
-        Otherwise (`sg=1`), skip-gram is employed.
-
-        `size` is the dimensionality of the feature vectors.
-
-        `window` is the maximum distance between the current and predicted word within a sentence.
+        Parameters
+        ----------
+        sentences : iterable of iterables
+            The `sentences` iterable can be simply a list of lists of tokens, but for larger corpora,
+            consider an iterable that streams the sentences directly from disk/network.
+            See :class:`~gensim.models.word2vec.BrownCorpus`, :class:`~gensim.models.word2vec.Text8Corpus`
+            or :class:`~gensim.models.word2vec.LineSentence` in :mod:`~gensim.models.word2vec` 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 : int {1, 0}
+            Defines the training algorithm. If 1, CBOW is used, otherwise, skip-gram is employed.
+        size : int
+            Dimensionality of the feature vectors.
+        window : int
+            The maximum distance between the current and predicted word within a sentence.
+        alpha : float
+            The initial learning rate.
+        min_alpha : float
+            Learning rate will linearly drop to `min_alpha` as training progresses.
+        seed : int
+            Seed for the random number generator. Initial vectors for each word are seeded with a hash of
+            the concatenation of word + `str(seed)`. Note that for a fully deterministically-reproducible run,
+            you must also limit the model to a single worker thread (`workers=1`), to eliminate ordering jitter
+            from OS thread scheduling. (In Python 3, reproducibility between interpreter launches also requires
+            use of the `PYTHONHASHSEED` environment variable to control hash randomization).
+        min_count : int
+            Ignores all words with total frequency lower than this.
+        max_vocab_size : int
+            Limits the RAM during vocabulary building; if there are more unique
+            words than this, then prune the infrequent ones. Every 10 million word types need about 1GB of RAM.
+            Set to `None` for no limit.
+        sample : float
+            The threshold for configuring which higher-frequency words are randomly downsampled,
+            useful range is (0, 1e-5).
+        workers : int
+            Use these many worker threads to train the model (=faster training with multicore machines).
+        hs : int {1,0}
+            If 1, hierarchical softmax will be used for model training.
+            If set to 0, and `negative` is non-zero, negative sampling will be used.
+        negative : int
+            If > 0, negative sampling will be used, the int for negative specifies how many "noise words"
+            should be drawn (usually between 5-20).
+            If set to 0, no negative sampling is used.
+        cbow_mean : int {1,0}
+            If 0, use the sum of the context word vectors. If 1, use the mean, only applies when cbow is used.
+        hashfxn : function
+            Hash function to use to randomly initialize weights, for increased training reproducibility.
+        iter : int
+            Number of iterations (epochs) over the corpus.
+        trim_rule : function
+            Vocabulary trimming rule, specifies whether certain words should remain in the vocabulary,
+            be trimmed away, or handled using the default (discard if word count < min_count).
+            Can be None (min_count will be used, look to :func:`~gensim.utils.keep_vocab_item`),
+            or a callable that accepts parameters (word, count, min_count) and returns either
+            :attr:`gensim.utils.RULE_DISCARD`, :attr:`gensim.utils.RULE_KEEP` or :attr:`gensim.utils.RULE_DEFAULT`.
+            Note: The rule, if given, is only used to prune vocabulary during build_vocab() and is not stored as part
+            of the model.
+        sorted_vocab : int {1,0}
+            If 1, sort the vocabulary by descending frequency before assigning word indexes.
+        batch_words : int
+            Target size (in words) for batches of examples passed to worker threads (and
+            thus cython routines).(Larger batches will be passed if individual
+            texts are longer than 10000 words, but the standard cython code truncates to that maximum.)
+        compute_loss: bool
+            If True, computes and stores loss value which can be retrieved using `model.get_latest_training_loss()`.
+        callbacks : :obj: `list` of :obj: `~gensim.models.callbacks.CallbackAny2Vec`
+            List of callbacks that need to be executed/run at specific stages during training.
 
-        `alpha` is the initial learning rate (will linearly drop to `min_alpha` as training progresses).
+        Examples
+        --------
+        Initialize and train a `Word2Vec` model
 
-        `seed` = for the random number generator. Initial vectors for each
-        word are seeded with a hash of the concatenation of word + str(seed).
-        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
-        environment variable to control hash randomization.)
+        >>> from gensim.models import Word2Vec
+        >>> sentences = [["cat", "say", "meow"], ["dog", "say", "woof"]]
+        >>>
+        >>> model = Word2Vec(sentences, min_count=1)
+        >>> say_vector = model['say']  # get vector for word
 
-        `min_count` = ignore all words with total frequency lower than this.
+        """
 
-        `max_vocab_size` = limit RAM during vocabulary building; if there are more unique
-        words than this, then prune the infrequent ones. Every 10 million word types
-        need about 1GB of RAM. Set to `None` for no limit (default).
+        self.callbacks = callbacks
+        self.load = call_on_class_only
 
-        `sample` = threshold for configuring which higher-frequency words are randomly downsampled;
-            default is 1e-3, useful range is (0, 1e-5).
+        self.wv = Word2VecKeyedVectors(size)
+        self.vocabulary = Word2VecVocab(
+            max_vocab_size=max_vocab_size, min_count=min_count, sample=sample,
+            sorted_vocab=bool(sorted_vocab), null_word=null_word)
+        self.trainables = Word2VecTrainables(seed=seed, vector_size=size, hashfxn=hashfxn)
 
-        `workers` = use this many worker threads to train the model (=faster training with multicore machines).
+        super(Word2Vec, self).__init__(
+            sentences=sentences, workers=workers, vector_size=size, epochs=iter, callbacks=callbacks,
+            batch_words=batch_words, trim_rule=trim_rule, sg=sg, alpha=alpha, window=window, seed=seed,
+            hs=hs, negative=negative, cbow_mean=cbow_mean, min_alpha=min_alpha, compute_loss=compute_loss,
+            fast_version=FAST_VERSION)
 
-        `hs` = if 1, hierarchical softmax will be used for model training.
-        If set to 0 (default), and `negative` is non-zero, negative sampling will be used.
+    def _do_train_job(self, sentences, alpha, inits):
+        """
+        Train a single batch of sentences. Return 2-tuple `(effective word count after
+        ignoring unknown words and sentence length trimming, total word count)`.
+        """
+        work, neu1 = inits
+        tally = 0
+        if self.sg:
+            tally += train_batch_sg(self, sentences, alpha, work, self.compute_loss)
+        else:
+            tally += train_batch_cbow(self, sentences, alpha, work, neu1, self.compute_loss)
+        return tally, self._raw_word_count(sentences)
 
-        `negative` = if > 0, negative sampling will be used, the int for negative
-        specifies how many "noise words" should be drawn (usually between 5-20).
-        Default is 5. If set to 0, no negative samping is used.
+    def _clear_post_train(self):
+        """Resets certain properties of the model, post training."""
+        self.wv.vectors_norm = None
 
-        `cbow_mean` = if 0, use the sum of the context word vectors. If 1 (default), use the mean.
-        Only applies when cbow is used.
+    def _set_train_params(self, **kwargs):
+        if 'compute_loss' in kwargs:
+            self.compute_loss = kwargs['compute_loss']
+        self.running_training_loss = 0
 
-        `hashfxn` = hash function to use to randomly initialize weights, for increased
-        training reproducibility. Default is Python's rudimentary built in hash function.
+    def train(self, sentences, total_examples=None, total_words=None,
+              epochs=None, start_alpha=None, end_alpha=None, word_count=0,
+              queue_factor=2, report_delay=1.0, compute_loss=False, callbacks=()):
+        """Update the model's neural weights from a sequence of sentences (can be a once-only generator stream).
+        For Word2Vec, each sentence must be a list of unicode strings. (Subclasses may accept other examples.)
 
-        `iter` = number of iterations (epochs) over the corpus. Default is 5.
+        To support linear learning-rate decay from (initial) alpha to min_alpha, and accurate
+        progress-percentage logging, either total_examples (count of sentences) or total_words (count of
+        raw words in sentences) **MUST** be provided (if the corpus is the same as was provided to
+        :meth:`~gensim.models.word2vec.Word2Vec.build_vocab()`, the count of examples in that corpus
+        will be available in the model's :attr:`corpus_count` property).
 
-        `trim_rule` = vocabulary trimming rule, specifies whether certain words should remain
-        in the vocabulary, be trimmed away, or handled using the default (discard if word count < min_count).
-        Can be None (min_count will be used), or a callable that accepts parameters (word, count, min_count) and
-        returns either `utils.RULE_DISCARD`, `utils.RULE_KEEP` or `utils.RULE_DEFAULT`.
-        Note: The rule, if given, is only used to prune vocabulary during build_vocab() and is not stored as part
-        of the model.
+        To avoid common mistakes around the model's ability to do multiple training passes itself, an
+        explicit `epochs` argument **MUST** be provided. In the common and recommended case,
+        where :meth:`~gensim.models.word2vec.Word2Vec.train()` is only called once,
+        the model's cached `iter` value should be supplied as `epochs` value.
 
-        `sorted_vocab` = if 1 (default), sort the vocabulary by descending frequency before
-        assigning word indexes.
+        Parameters
+        ----------
+        sentences : iterable of iterables
+            The `sentences` iterable can be simply a list of lists of tokens, but for larger corpora,
+            consider an iterable that streams the sentences directly from disk/network.
+            See :class:`~gensim.models.word2vec.BrownCorpus`, :class:`~gensim.models.word2vec.Text8Corpus`
+            or :class:`~gensim.models.word2vec.LineSentence` in :mod:`~gensim.models.word2vec` module for such examples.
+        total_examples : int
+            Count of sentences.
+        total_words : int
+            Count of raw words in sentences.
+        epochs : int
+            Number of iterations (epochs) over the corpus.
+        start_alpha : float
+            Initial learning rate.
+        end_alpha : float
+            Final learning rate. Drops linearly from `start_alpha`.
+        word_count : int
+            Count of words already trained. Set this to 0 for the usual
+            case of training on all words in sentences.
+        queue_factor : int
+            Multiplier for size of queue (number of workers * queue_factor).
+        report_delay : float
+            Seconds to wait before reporting progress.
+        compute_loss: bool
+            If True, computes and stores loss value which can be retrieved using `model.get_latest_training_loss()`.
+        callbacks : :obj: `list` of :obj: `~gensim.models.callbacks.CallbackAny2Vec`
+            List of callbacks that need to be executed/run at specific stages during training.
 
-        `batch_words` = target size (in words) for batches of examples passed to worker threads (and
-        thus cython routines). Default is 10000. (Larger batches will be passed if individual
-        texts are longer than 10000 words, but the standard cython code truncates to that maximum.)
+        Examples
+        --------
+        >>> from gensim.models import Word2Vec
+        >>> sentences = [["cat", "say", "meow"], ["dog", "say", "woof"]]
+        >>>
+        >>> model = Word2Vec(min_count=1)
+        >>> model.build_vocab(sentences)
+        >>> model.train(sentences, total_examples=model.corpus_count, epochs=model.iter)
 
         """
 
-        self.load = call_on_class_only
-
-        if FAST_VERSION == -1:
-            logger.warning('Slow version of %s is being used', __name__)
-        else:
-            logger.debug('Fast version of %s is being used', __name__)
+        return super(Word2Vec, self).train(
+            sentences, total_examples=total_examples, total_words=total_words,
+            epochs=epochs, start_alpha=start_alpha, end_alpha=end_alpha, word_count=word_count,
+            queue_factor=queue_factor, report_delay=report_delay, compute_loss=compute_loss, callbacks=callbacks)
 
-        self.initialize_word_vectors()
-        self.sg = int(sg)
-        self.cum_table = None  # for negative sampling
-        self.vector_size = int(size)
-        self.layer1_size = int(size)
-        if size % 4 != 0:
-            logger.warning("consider setting layer size to a multiple of 4 for greater performance")
-        self.alpha = float(alpha)
-        self.min_alpha_yet_reached = float(alpha)  # To warn user if alpha increases
-        self.window = int(window)
-        self.max_vocab_size = max_vocab_size
-        self.seed = seed
-        self.random = random.RandomState(seed)
-        self.min_count = min_count
-        self.sample = sample
-        self.workers = int(workers)
-        self.min_alpha = float(min_alpha)
-        self.hs = hs
-        self.negative = negative
-        self.cbow_mean = int(cbow_mean)
-        self.hashfxn = hashfxn
-        self.iter = iter
-        self.null_word = null_word
-        self.train_count = 0
-        self.total_train_time = 0
-        self.sorted_vocab = sorted_vocab
-        self.batch_words = batch_words
-        self.model_trimmed_post_training = False
-        self.compute_loss = compute_loss
-        self.running_training_loss = 0
-        if sentences is not None:
-            if isinstance(sentences, GeneratorType):
-                raise TypeError("You can't pass a generator as the sentences argument. Try an iterator.")
-            self.build_vocab(sentences, trim_rule=trim_rule)
-            self.train(
-                sentences, total_examples=self.corpus_count, epochs=self.iter,
-                start_alpha=self.alpha, end_alpha=self.min_alpha
-            )
-        else:
-            if trim_rule is not None:
-                logger.warning(
-                    "The rule, if given, is only used to prune vocabulary during build_vocab() "
-                    "and is not stored as part of the model. Model initialized without sentences. "
-                    "trim_rule provided, if any, will be ignored."
-                )
+    def score(self, sentences, total_sentences=int(1e6), chunksize=100, queue_factor=2, report_delay=1):
+        """Score the log probability for a sequence of sentences (can be a once-only generator stream).
+        Each sentence must be a list of unicode strings.
+        This does not change the fitted model in any way (see Word2Vec.train() for that).
 
-    def initialize_word_vectors(self):
-        self.wv = KeyedVectors()
+        We have currently only implemented score for the hierarchical softmax scheme,
+        so you need to have run word2vec with hs=1 and negative=0 for this to work.
 
-    def make_cum_table(self, power=0.75, domain=2**31 - 1):
-        """
-        Create a cumulative-distribution table using stored vocabulary word counts for
-        drawing random words in the negative-sampling training routines.
+        Note that you should specify total_sentences; we'll run into problems if you ask to
+        score more than this number of sentences but it is inefficient to set the value too high.
 
-        To draw a word index, choose a random integer up to the maximum value in the
-        table (cum_table[-1]), then finding that integer's sorted insertion point
-        (as if by bisect_left or ndarray.searchsorted()). That insertion point is the
-        drawn index, coming up in proportion equal to the increment at that slot.
+        See the article by [#taddy]_ and the gensim demo at [#deepir]_ for examples of
+        how to use such scores in document classification.
 
-        Called internally from 'build_vocab()'.
-        """
-        vocab_size = len(self.wv.index2word)
-        self.cum_table = zeros(vocab_size, dtype=uint32)
-        # compute sum of all power (Z in paper)
-        train_words_pow = 0.0
-        for word_index in xrange(vocab_size):
-            train_words_pow += self.wv.vocab[self.wv.index2word[word_index]].count**power
-        cumulative = 0.0
-        for word_index in xrange(vocab_size):
-            cumulative += self.wv.vocab[self.wv.index2word[word_index]].count**power
-            self.cum_table[word_index] = round(cumulative / train_words_pow * domain)
-        if len(self.cum_table) > 0:
-            assert self.cum_table[-1] == domain
+        .. [#taddy] Taddy, Matt.  Document Classification by Inversion of Distributed Language Representations,
+                    in Proceedings of the 2015 Conference of the Association of Computational Linguistics.
+        .. [#deepir] https://github.com/piskvorky/gensim/blob/develop/docs/notebooks/deepir.ipynb
 
-    def create_binary_tree(self):
-        """
-        Create a binary Huffman tree using stored vocabulary word counts. Frequent words
-        will have shorter binary codes. Called internally from `build_vocab()`.
+        Parameters
+        ----------
+        sentences : iterable of iterables
+            The `sentences` iterable can be simply a list of lists of tokens, but for larger corpora,
+            consider an iterable that streams the sentences directly from disk/network.
+            See :class:`~gensim.models.word2vec.BrownCorpus`, :class:`~gensim.models.word2vec.Text8Corpus`
+            or :class:`~gensim.models.word2vec.LineSentence` in :mod:`~gensim.models.word2vec` module for such examples.
+        total_sentences : int
+            Count of sentences.
+        chunksize : int
+            Chunksize of jobs
+        queue_factor : int
+            Multiplier for size of queue (number of workers * queue_factor).
+        report_delay : float
+            Seconds to wait before reporting progress.
 
         """
-        logger.info("constructing a huffman tree from %i words", len(self.wv.vocab))
-
-        # build the huffman tree
-        heap = list(itervalues(self.wv.vocab))
-        heapq.heapify(heap)
-        for i in xrange(len(self.wv.vocab) - 1):
-            min1, min2 = heapq.heappop(heap), heapq.heappop(heap)
-            heapq.heappush(
-                heap, Vocab(count=min1.count + min2.count, index=i + len(self.wv.vocab), left=min1, right=min2)
+        if FAST_VERSION < 0:
+            warnings.warn(
+                "C extension compilation failed, scoring will be slow. "
+                "Install a C compiler and reinstall gensim for fastness."
             )
 
-        # recurse over the tree, assigning a binary code to each vocabulary word
-        if heap:
-            max_depth, stack = 0, [(heap[0], [], [])]
-            while stack:
-                node, codes, points = stack.pop()
-                if node.index < len(self.wv.vocab):
-                    # leaf node => store its path from the root
-                    node.code, node.point = codes, points
-                    max_depth = max(len(codes), max_depth)
-                else:
-                    # inner node => continue recursion
-                    points = array(list(points) + [node.index - len(self.wv.vocab)], dtype=uint32)
-                    stack.append((node.left, array(list(codes) + [0], dtype=uint8), points))
-                    stack.append((node.right, array(list(codes) + [1], dtype=uint8), points))
-
-            logger.info("built huffman tree with maximum node depth %i", max_depth)
+        logger.info(
+            "scoring sentences with %i workers on %i vocabulary and %i features, "
+            "using sg=%s hs=%s sample=%s and negative=%s",
+            self.workers, len(self.wv.vocab), self.trainables.layer1_size, self.sg, self.hs,
+            self.vocabulary.sample, self.negative
+        )
 
-    def build_vocab(self, sentences, keep_raw_vocab=False, trim_rule=None, progress_per=10000, update=False):
-        """
-        Build vocabulary from a sequence of sentences (can be a once-only generator stream).
-        Each sentence must be a list of unicode strings.
-        """
-        self.scan_vocab(sentences, progress_per=progress_per, trim_rule=trim_rule)  # initial survey
-        # trim by min_count & precalculate downsampling
-        self.scale_vocab(keep_raw_vocab=keep_raw_vocab, trim_rule=trim_rule, update=update)
-        self.finalize_vocab(update=update)  # build tables & arrays
+        if not self.wv.vocab:
+            raise RuntimeError("you must first build vocabulary before scoring new data")
 
-    def build_vocab_from_freq(self, word_freq, keep_raw_vocab=False, corpus_count=None, trim_rule=None, update=False):
-        """
-        Build vocabulary from a dictionary of word frequencies.
-        Build model vocabulary from a passed dictionary that contains (word,word count).
-        Words must be of type unicode strings.
+        if not self.hs:
+            raise RuntimeError(
+                "We have currently only implemented score for the hierarchical softmax scheme, "
+                "so you need to have run word2vec with hs=1 and negative=0 for this to work."
+            )
 
-        Parameters
-        ----------
-        `word_freq` : dict
-            Word,Word_Count dictionary.
-        `keep_raw_vocab` : bool
-            If not true, delete the raw vocabulary after the scaling is done and free up RAM.
-        `corpus_count`: int
-            Even if no corpus is provided, this argument can set corpus_count explicitly.
-        `trim_rule` = vocabulary trimming rule, specifies whether certain words should remain
-        in the vocabulary, be trimmed away, or handled using the default (discard if word count < min_count).
-        Can be None (min_count will be used), or a callable that accepts parameters (word, count, min_count) and
-        returns either `utils.RULE_DISCARD`, `utils.RULE_KEEP` or `utils.RULE_DEFAULT`.
-        `update`: bool
-            If true, the new provided words in `word_freq` dict will be added to model's vocab.
+        def worker_loop():
+            """Compute log probability for each sentence, lifting lists of sentences from the jobs queue."""
+            work = zeros(1, dtype=REAL)  # for sg hs, we actually only need one memory loc (running sum)
+            neu1 = matutils.zeros_aligned(self.trainables.layer1_size, dtype=REAL)
+            while True:
+                job = job_queue.get()
+                if job is None:  # signal to finish
+                    break
+                ns = 0
+                for sentence_id, sentence in job:
+                    if sentence_id >= total_sentences:
+                        break
+                    if self.sg:
+                        score = score_sentence_sg(self, sentence, work)
+                    else:
+                        score = score_sentence_cbow(self, sentence, work, neu1)
+                    sentence_scores[sentence_id] = score
+                    ns += 1
+                progress_queue.put(ns)  # report progress
 
-        Returns
-        --------
-        None
+        start, next_report = default_timer(), 1.0
+        # buffer ahead only a limited number of jobs.. this is the reason we can't simply use ThreadPool :(
+        job_queue = Queue(maxsize=queue_factor * self.workers)
+        progress_queue = Queue(maxsize=(queue_factor + 1) * self.workers)
 
-        Examples
-        --------
-        >>> from gensim.models.word2vec import Word2Vec
-        >>> model= Word2Vec()
-        >>> model.build_vocab_from_freq({"Word1": 15, "Word2": 20})
-        """
-        logger.info("Processing provided word frequencies")
-        # Instead of scanning text, this will assign provided word frequencies dictionary(word_freq)
-        # to be directly the raw vocab
-        raw_vocab = word_freq
-        logger.info(
-            "collected %i different raw word, with total frequency of %i",
-            len(raw_vocab), sum(itervalues(raw_vocab))
-        )
+        workers = [threading.Thread(target=worker_loop) for _ in xrange(self.workers)]
+        for thread in workers:
+            thread.daemon = True  # make interrupting the process with ctrl+c easier
+            thread.start()
 
-        # Since no sentences are provided, this is to control the corpus_count
-        self.corpus_count = corpus_count if corpus_count else 0
-        self.raw_vocab = raw_vocab
+        sentence_count = 0
+        sentence_scores = matutils.zeros_aligned(total_sentences, dtype=REAL)
 
-        # trim by min_count & precalculate downsampling
-        self.scale_vocab(keep_raw_vocab=keep_raw_vocab, trim_rule=trim_rule, update=update)
-        self.finalize_vocab(update=update)  # build tables & arrays
+        push_done = False
+        done_jobs = 0
+        jobs_source = enumerate(utils.grouper(enumerate(sentences), chunksize))
 
-    def scan_vocab(self, sentences, progress_per=10000, trim_rule=None):
-        """Do an initial scan of all words appearing in sentences."""
-        logger.info("collecting all words and their counts")
-        sentence_no = -1
-        total_words = 0
-        min_reduce = 1
-        vocab = defaultdict(int)
-        checked_string_types = 0
-        for sentence_no, sentence in enumerate(sentences):
-            if not checked_string_types:
-                if isinstance(sentence, string_types):
+        # fill jobs queue with (id, sentence) job items
+        while True:
+            try:
+                job_no, items = next(jobs_source)
+                if (job_no - 1) * chunksize > total_sentences:
                     logger.warning(
-                        "Each 'sentences' item should be a list of words (usually unicode strings). "
-                        "First item here is instead plain %s.",
-                        type(sentence)
+                        "terminating after %i sentences (set higher total_sentences if you want more).",
+                        total_sentences
                     )
-                checked_string_types += 1
-            if sentence_no % progress_per == 0:
-                logger.info(
-                    "PROGRESS: at sentence #%i, processed %i words, keeping %i word types",
-                    sentence_no, total_words, len(vocab)
-                )
-            for word in sentence:
-                vocab[word] += 1
-            total_words += len(sentence)
-
-            if self.max_vocab_size and len(vocab) > self.max_vocab_size:
-                utils.prune_vocab(vocab, min_reduce, trim_rule=trim_rule)
-                min_reduce += 1
+                    job_no -= 1
+                    raise StopIteration()
+                logger.debug("putting job #%i in the queue", job_no)
+                job_queue.put(items)
+            except StopIteration:
+                logger.info("reached end of input; waiting to finish %i outstanding jobs", job_no - done_jobs + 1)
+                for _ in xrange(self.workers):
+                    job_queue.put(None)  # give the workers heads up that they can finish -- no more work!
+                push_done = True
+            try:
+                while done_jobs < (job_no + 1) or not push_done:
+                    ns = progress_queue.get(push_done)  # only block after all jobs pushed
+                    sentence_count += ns
+                    done_jobs += 1
+                    elapsed = default_timer() - start
+                    if elapsed >= next_report:
+                        logger.info(
+                            "PROGRESS: at %.2f%% sentences, %.0f sentences/s",
+                            100.0 * sentence_count, sentence_count / elapsed
+                        )
+                        next_report = elapsed + report_delay  # don't flood log, wait report_delay seconds
+                else:
+                    # loop ended by job count; really done
+                    break
+            except Empty:
+                pass  # already out of loop; continue to next push
 
+        elapsed = default_timer() - start
+        self.clear_sims()
         logger.info(
-            "collected %i word types from a corpus of %i raw words and %i sentences",
-            len(vocab), total_words, sentence_no + 1
+            "scoring %i sentences took %.1fs, %.0f sentences/s",
+            sentence_count, elapsed, sentence_count / elapsed
         )
-        self.corpus_count = sentence_no + 1
-        self.raw_vocab = vocab
-        return total_words
+        return sentence_scores[:sentence_count]
 
-    def scale_vocab(self, min_count=None, sample=None, dry_run=False,
-                    keep_raw_vocab=False, trim_rule=None, update=False):
+    def clear_sims(self):
+        """Removes all L2-normalized vectors for words from the model.
+        You will have to recompute them using init_sims method.
         """
-        Apply vocabulary settings for `min_count` (discarding less-frequent words)
-        and `sample` (controlling the downsampling of more-frequent words).
 
-        Calling with `dry_run=True` will only simulate the provided settings and
-        report the size of the retained vocabulary, effective corpus length, and
-        estimated memory requirements. Results are both printed via logging and
-        returned as a dict.
+        self.wv.vectors_norm = None
 
-        Delete the raw vocabulary after the scaling is done to free up RAM,
-        unless `keep_raw_vocab` is set.
+    def intersect_word2vec_format(self, fname, lockf=0.0, binary=False, encoding='utf8', unicode_errors='strict'):
+        """Merge the input-hidden weight matrix from the original C word2vec-tool format
+        given, where it intersects with the current vocabulary. (No words are added to the
+        existing vocabulary, but intersecting words adopt the file's weights, and
+        non-intersecting words are left alone.)
 
-        """
-        min_count = min_count or self.min_count
-        sample = sample or self.sample
-        drop_total = drop_unique = 0
-
-        if not update:
-            logger.info("Loading a fresh vocabulary")
-            retain_total, retain_words = 0, []
-            # Discard words less-frequent than min_count
-            if not dry_run:
-                self.wv.index2word = []
-                # make stored settings match these applied settings
-                self.min_count = min_count
-                self.sample = sample
-                self.wv.vocab = {}
-
-            for word, v in iteritems(self.raw_vocab):
-                if keep_vocab_item(word, v, min_count, trim_rule=trim_rule):
-                    retain_words.append(word)
-                    retain_total += v
-                    if not dry_run:
-                        self.wv.vocab[word] = Vocab(count=v, index=len(self.wv.index2word))
-                        self.wv.index2word.append(word)
-                else:
-                    drop_unique += 1
-                    drop_total += v
-            original_unique_total = len(retain_words) + drop_unique
-            retain_unique_pct = len(retain_words) * 100 / max(original_unique_total, 1)
-            logger.info(
-                "min_count=%d retains %i unique words (%i%% of original %i, drops %i)",
-                min_count, len(retain_words), retain_unique_pct, original_unique_total, drop_unique
-            )
-            original_total = retain_total + drop_total
-            retain_pct = retain_total * 100 / max(original_total, 1)
-            logger.info(
-                "min_count=%d leaves %i word corpus (%i%% of original %i, drops %i)",
-                min_count, retain_total, retain_pct, original_total, drop_total
-            )
-        else:
-            logger.info("Updating model with new vocabulary")
-            new_total = pre_exist_total = 0
-            new_words = pre_exist_words = []
-            for word, v in iteritems(self.raw_vocab):
-                if keep_vocab_item(word, v, min_count, trim_rule=trim_rule):
-                    if word in self.wv.vocab:
-                        pre_exist_words.append(word)
-                        pre_exist_total += v
-                        if not dry_run:
-                            self.wv.vocab[word].count += v
-                    else:
-                        new_words.append(word)
-                        new_total += v
-                        if not dry_run:
-                            self.wv.vocab[word] = Vocab(count=v, index=len(self.wv.index2word))
-                            self.wv.index2word.append(word)
-                else:
-                    drop_unique += 1
-                    drop_total += v
-            original_unique_total = len(pre_exist_words) + len(new_words) + drop_unique
-            pre_exist_unique_pct = len(pre_exist_words) * 100 / max(original_unique_total, 1)
-            new_unique_pct = len(new_words) * 100 / max(original_unique_total, 1)
-            logger.info(
-                "New added %i unique words (%i%% of original %i) "
-                "and increased the count of %i pre-existing words (%i%% of original %i)",
-                len(new_words), new_unique_pct, original_unique_total, len(pre_exist_words),
-                pre_exist_unique_pct, original_unique_total
-            )
-            retain_words = new_words + pre_exist_words
-            retain_total = new_total + pre_exist_total
-
-        # Precalculate each vocabulary item's threshold for sampling
-        if not sample:
-            # no words downsampled
-            threshold_count = retain_total
-        elif sample < 1.0:
-            # traditional meaning: set parameter as proportion of total
-            threshold_count = sample * retain_total
-        else:
-            # new shorthand: sample >= 1 means downsample all words with higher count than sample
-            threshold_count = int(sample * (3 + sqrt(5)) / 2)
-
-        downsample_total, downsample_unique = 0, 0
-        for w in retain_words:
-            v = self.raw_vocab[w]
-            word_probability = (sqrt(v / threshold_count) + 1) * (threshold_count / v)
-            if word_probability < 1.0:
-                downsample_unique += 1
-                downsample_total += word_probability * v
-            else:
-                word_probability = 1.0
-                downsample_total += v
-            if not dry_run:
-                self.wv.vocab[w].sample_int = int(round(word_probability * 2**32))
-
-        if not dry_run and not keep_raw_vocab:
-            logger.info("deleting the raw counts dictionary of %i items", len(self.raw_vocab))
-            self.raw_vocab = defaultdict(int)
-
-        logger.info("sample=%g downsamples %i most-common words", sample, downsample_unique)
-        logger.info(
-            "downsampling leaves estimated %i word corpus (%.1f%% of prior %i)",
-            downsample_total, downsample_total * 100.0 / max(retain_total, 1), retain_total
-        )
-
-        # return from each step: words-affected, resulting-corpus-size, extra memory estimates
-        report_values = {
-            'drop_unique': drop_unique, 'retain_total': retain_total, 'downsample_unique': downsample_unique,
-            'downsample_total': int(downsample_total), 'memory': self.estimate_memory(vocab_size=len(retain_words))
-        }
-
-        return report_values
-
-    def finalize_vocab(self, update=False):
-        """Build tables and model weights based on final vocabulary settings."""
-        if not self.wv.index2word:
-            self.scale_vocab()
-        if self.sorted_vocab and not update:
-            self.sort_vocab()
-        if self.hs:
-            # add info about each word's Huffman encoding
-            self.create_binary_tree()
-        if self.negative:
-            # build the table for drawing random words (for negative sampling)
-            self.make_cum_table()
-        if self.null_word:
-            # create null pseudo-word for padding when using concatenative L1 (run-of-words)
-            # this word is only ever input – never predicted – so count, huffman-point, etc doesn't matter
-            word, v = '\0', Vocab(count=1, sample_int=0)
-            v.index = len(self.wv.vocab)
-            self.wv.index2word.append(word)
-            self.wv.vocab[word] = v
-        # set initial input/projection and hidden weights
-        if not update:
-            self.reset_weights()
-        else:
-            self.update_weights()
-
-    def sort_vocab(self):
-        """Sort the vocabulary so the most frequent words have the lowest indexes."""
-        if len(self.wv.syn0):
-            raise RuntimeError("cannot sort vocabulary after model weights already initialized.")
-        self.wv.index2word.sort(key=lambda word: self.wv.vocab[word].count, reverse=True)
-        for i, word in enumerate(self.wv.index2word):
-            self.wv.vocab[word].index = i
-
-    def reset_from(self, other_model):
-        """
-        Borrow shareable pre-built structures (like vocab) from the other_model. Useful
-        if testing multiple models in parallel on the same corpus.
-        """
-        self.wv.vocab = other_model.wv.vocab
-        self.wv.index2word = other_model.wv.index2word
-        self.cum_table = other_model.cum_table
-        self.corpus_count = other_model.corpus_count
-        self.reset_weights()
-
-    def _do_train_job(self, sentences, alpha, inits):
-        """
-        Train a single batch of sentences. Return 2-tuple `(effective word count after
-        ignoring unknown words and sentence length trimming, total word count)`.
-        """
-        work, neu1 = inits
-        tally = 0
-        if self.sg:
-            tally += train_batch_sg(self, sentences, alpha, work, self.compute_loss)
-        else:
-            tally += train_batch_cbow(self, sentences, alpha, work, neu1, self.compute_loss)
-        return tally, self._raw_word_count(sentences)
-
-    def _raw_word_count(self, job):
-        """Return the number of words in a given job."""
-        return sum(len(sentence) for sentence in job)
-
-    def train(self, sentences, total_examples=None, total_words=None,
-              epochs=None, start_alpha=None, end_alpha=None, word_count=0,
-              queue_factor=2, report_delay=1.0, compute_loss=None):
-        """
-        Update the model's neural weights from a sequence of sentences (can be a once-only generator stream).
-        For Word2Vec, each sentence must be a list of unicode strings. (Subclasses may accept other examples.)
-
-        To support linear learning-rate decay from (initial) alpha to min_alpha, and accurate
-        progres-percentage logging, either total_examples (count of sentences) or total_words (count of
-        raw words in sentences) MUST be provided. (If the corpus is the same as was provided to
-        `build_vocab()`, the count of examples in that corpus will be available in the model's
-        `corpus_count` property.)
-
-        To avoid common mistakes around the model's ability to do multiple training passes itself, an
-        explicit `epochs` argument MUST be provided. In the common and recommended case, where `train()`
-        is only called once, the model's cached `iter` value should be supplied as `epochs` value.
-        """
-        if self.model_trimmed_post_training:
-            raise RuntimeError("Parameters for training were discarded using model_trimmed_post_training method")
-        if FAST_VERSION < 0:
-            warnings.warn(
-                "C extension not loaded for Word2Vec, training will be slow. "
-                "Install a C compiler and reinstall gensim for fast training."
-            )
-            self.neg_labels = []
-            if self.negative > 0:
-                # precompute negative labels optimization for pure-python training
-                self.neg_labels = zeros(self.negative + 1)
-                self.neg_labels[0] = 1.
-
-        if compute_loss:
-            self.compute_loss = compute_loss
-        self.running_training_loss = 0
-
-        logger.info(
-            "training model with %i workers on %i vocabulary and %i features, "
-            "using sg=%s hs=%s sample=%s negative=%s window=%s",
-            self.workers, len(self.wv.vocab), self.layer1_size, self.sg,
-            self.hs, self.sample, self.negative, self.window
-        )
-
-        if not self.wv.vocab:
-            raise RuntimeError("you must first build vocabulary before training the model")
-        if not len(self.wv.syn0):
-            raise RuntimeError("you must first finalize vocabulary before training the model")
-
-        if not hasattr(self, 'corpus_count'):
-            raise ValueError(
-                "The number of sentences in the training corpus is missing. "
-                "Did you load the model via KeyedVectors.load_word2vec_format?"
-                "Models loaded via load_word2vec_format don't support further training. "
-                "Instead start with a blank model, scan_vocab on the new corpus, "
-                "intersect_word2vec_format with the old model, then train."
-            )
-
-        if total_words is None and total_examples is None:
-            raise ValueError(
-                "You must specify either total_examples or total_words, for proper alpha and progress calculations. "
-                "The usual value is total_examples=model.corpus_count."
-            )
-        if epochs is None:
-            raise ValueError("You must specify an explict epochs count. The usual value is epochs=model.iter.")
-        start_alpha = start_alpha or self.alpha
-        end_alpha = end_alpha or self.min_alpha
-
-        job_tally = 0
-
-        if epochs > 1:
-            sentences = utils.RepeatCorpusNTimes(sentences, epochs)
-            total_words = total_words and total_words * epochs
-            total_examples = total_examples and total_examples * epochs
-
-        def worker_loop():
-            """Train the model, lifting lists of sentences from the job_queue."""
-            work = matutils.zeros_aligned(self.layer1_size, dtype=REAL)  # per-thread private work memory
-            neu1 = matutils.zeros_aligned(self.layer1_size, dtype=REAL)
-            jobs_processed = 0
-            while True:
-                job = job_queue.get()
-                if job is None:
-                    progress_queue.put(None)
-                    break  # no more jobs => quit this worker
-                sentences, alpha = job
-                tally, raw_tally = self._do_train_job(sentences, alpha, (work, neu1))
-                progress_queue.put((len(sentences), tally, raw_tally))  # report back progress
-                jobs_processed += 1
-            logger.debug("worker exiting, processed %i jobs", jobs_processed)
-
-        def job_producer():
-            """Fill jobs queue using the input `sentences` iterator."""
-            job_batch, batch_size = [], 0
-            pushed_words, pushed_examples = 0, 0
-            next_alpha = start_alpha
-            if next_alpha > self.min_alpha_yet_reached:
-                logger.warning("Effective 'alpha' higher than previous training cycles")
-            self.min_alpha_yet_reached = next_alpha
-            job_no = 0
-
-            for sent_idx, sentence in enumerate(sentences):
-                sentence_length = self._raw_word_count([sentence])
-
-                # can we fit this sentence into the existing job batch?
-                if batch_size + sentence_length <= self.batch_words:
-                    # yes => add it to the current job
-                    job_batch.append(sentence)
-                    batch_size += sentence_length
-                else:
-                    # no => submit the existing job
-                    logger.debug(
-                        "queueing job #%i (%i words, %i sentences) at alpha %.05f",
-                        job_no, batch_size, len(job_batch), next_alpha
-                    )
-                    job_no += 1
-                    job_queue.put((job_batch, next_alpha))
-
-                    # update the learning rate for the next job
-                    if end_alpha < next_alpha:
-                        if total_examples:
-                            # examples-based decay
-                            pushed_examples += len(job_batch)
-                            progress = 1.0 * pushed_examples / total_examples
-                        else:
-                            # words-based decay
-                            pushed_words += self._raw_word_count(job_batch)
-                            progress = 1.0 * pushed_words / total_words
-                        next_alpha = start_alpha - (start_alpha - end_alpha) * progress
-                        next_alpha = max(end_alpha, next_alpha)
-
-                    # add the sentence that didn't fit as the first item of a new job
-                    job_batch, batch_size = [sentence], sentence_length
-
-            # add the last job too (may be significantly smaller than batch_words)
-            if job_batch:
-                logger.debug(
-                    "queueing job #%i (%i words, %i sentences) at alpha %.05f",
-                    job_no, batch_size, len(job_batch), next_alpha
-                )
-                job_no += 1
-                job_queue.put((job_batch, next_alpha))
-
-            if job_no == 0 and self.train_count == 0:
-                logger.warning(
-                    "train() called with an empty iterator (if not intended, "
-                    "be sure to provide a corpus that offers restartable iteration = an iterable)."
-                )
-
-            # give the workers heads up that they can finish -- no more work!
-            for _ in xrange(self.workers):
-                job_queue.put(None)
-            logger.debug("job loop exiting, total %i jobs", job_no)
-
-        # buffer ahead only a limited number of jobs.. this is the reason we can't simply use ThreadPool :(
-        job_queue = Queue(maxsize=queue_factor * self.workers)
-        progress_queue = Queue(maxsize=(queue_factor + 1) * self.workers)
-
-        workers = [threading.Thread(target=worker_loop) for _ in xrange(self.workers)]
-        unfinished_worker_count = len(workers)
-        workers.append(threading.Thread(target=job_producer))
-
-        for thread in workers:
-            thread.daemon = True  # make interrupting the process with ctrl+c easier
-            thread.start()
-
-        example_count, trained_word_count, raw_word_count = 0, 0, word_count
-        start, next_report = default_timer() - 0.00001, 1.0
-
-        while unfinished_worker_count > 0:
-            report = progress_queue.get()  # blocks if workers too slow
-            if report is None:  # a thread reporting that it finished
-                unfinished_worker_count -= 1
-                logger.info("worker thread finished; awaiting finish of %i more threads", unfinished_worker_count)
-                continue
-            examples, trained_words, raw_words = report
-            job_tally += 1
-
-            # update progress stats
-            example_count += examples
-            trained_word_count += trained_words  # only words in vocab & sampled
-            raw_word_count += raw_words
-
-            # log progress once every report_delay seconds
-            elapsed = default_timer() - start
-            if elapsed >= next_report:
-                if total_examples:
-                    # examples-based progress %
-                    logger.info(
-                        "PROGRESS: at %.2f%% examples, %.0f words/s, in_qsize %i, out_qsize %i",
-                        100.0 * example_count / total_examples, trained_word_count / elapsed,
-                        utils.qsize(job_queue), utils.qsize(progress_queue)
-                    )
-                else:
-                    # words-based progress %
-                    logger.info(
-                        "PROGRESS: at %.2f%% words, %.0f words/s, in_qsize %i, out_qsize %i",
-                        100.0 * raw_word_count / total_words, trained_word_count / elapsed,
-                        utils.qsize(job_queue), utils.qsize(progress_queue)
-                    )
-                next_report = elapsed + report_delay
-
-        # all done; report the final stats
-        elapsed = default_timer() - start
-        logger.info(
-            "training on %i raw words (%i effective words) took %.1fs, %.0f effective words/s",
-            raw_word_count, trained_word_count, elapsed, trained_word_count / elapsed
-        )
-        if job_tally < 10 * self.workers:
-            logger.warning(
-                "under 10 jobs per worker: consider setting a smaller `batch_words' for smoother alpha decay"
-            )
-
-        # check that the input corpus hasn't changed during iteration
-        if total_examples and total_examples != example_count:
-            logger.warning(
-                "supplied example count (%i) did not equal expected count (%i)", example_count, total_examples
-            )
-        if total_words and total_words != raw_word_count:
-            logger.warning(
-                "supplied raw word count (%i) did not equal expected count (%i)", raw_word_count, total_words
-            )
-
-        self.train_count += 1  # number of times train() has been called
-        self.total_train_time += elapsed
-        self.clear_sims()
-        return trained_word_count
-
-    # basics copied from the train() function
-    def score(self, sentences, total_sentences=int(1e6), chunksize=100, queue_factor=2, report_delay=1):
-        """
-        Score the log probability for a sequence of sentences (can be a once-only generator stream).
-        Each sentence must be a list of unicode strings.
-        This does not change the fitted model in any way (see Word2Vec.train() for that).
-
-        We have currently only implemented score for the hierarchical softmax scheme,
-        so you need to have run word2vec with hs=1 and negative=0 for this to work.
-
-        Note that you should specify total_sentences; we'll run into problems if you ask to
-        score more than this number of sentences but it is inefficient to set the value too high.
-
-        See the article by [#taddy]_ and the gensim demo at [#deepir]_ for examples of
-        how to use such scores in document classification.
-
-        .. [#taddy] Taddy, Matt.  Document Classification by Inversion of Distributed Language Representations,
-                    in Proceedings of the 2015 Conference of the Association of Computational Linguistics.
-        .. [#deepir] https://github.com/piskvorky/gensim/blob/develop/docs/notebooks/deepir.ipynb
-
-        """
-        if FAST_VERSION < 0:
-            warnings.warn(
-                "C extension compilation failed, scoring will be slow. "
-                "Install a C compiler and reinstall gensim for fastness."
-            )
-
-        logger.info(
-            "scoring sentences with %i workers on %i vocabulary and %i features, "
-            "using sg=%s hs=%s sample=%s and negative=%s",
-            self.workers, len(self.wv.vocab), self.layer1_size, self.sg, self.hs, self.sample, self.negative
-        )
-
-        if not self.wv.vocab:
-            raise RuntimeError("you must first build vocabulary before scoring new data")
-
-        if not self.hs:
-            raise RuntimeError(
-                "We have currently only implemented score for the hierarchical softmax scheme, "
-                "so you need to have run word2vec with hs=1 and negative=0 for this to work."
-            )
-
-        def worker_loop():
-            """Compute log probability for each sentence, lifting lists of sentences from the jobs queue."""
-            work = zeros(1, dtype=REAL)  # for sg hs, we actually only need one memory loc (running sum)
-            neu1 = matutils.zeros_aligned(self.layer1_size, dtype=REAL)
-            while True:
-                job = job_queue.get()
-                if job is None:  # signal to finish
-                    break
-                ns = 0
-                for sentence_id, sentence in job:
-                    if sentence_id >= total_sentences:
-                        break
-                    if self.sg:
-                        score = score_sentence_sg(self, sentence, work)
-                    else:
-                        score = score_sentence_cbow(self, sentence, work, neu1)
-                    sentence_scores[sentence_id] = score
-                    ns += 1
-                progress_queue.put(ns)  # report progress
-
-        start, next_report = default_timer(), 1.0
-        # buffer ahead only a limited number of jobs.. this is the reason we can't simply use ThreadPool :(
-        job_queue = Queue(maxsize=queue_factor * self.workers)
-        progress_queue = Queue(maxsize=(queue_factor + 1) * self.workers)
-
-        workers = [threading.Thread(target=worker_loop) for _ in xrange(self.workers)]
-        for thread in workers:
-            thread.daemon = True  # make interrupting the process with ctrl+c easier
-            thread.start()
-
-        sentence_count = 0
-        sentence_scores = matutils.zeros_aligned(total_sentences, dtype=REAL)
-
-        push_done = False
-        done_jobs = 0
-        jobs_source = enumerate(utils.grouper(enumerate(sentences), chunksize))
-
-        # fill jobs queue with (id, sentence) job items
-        while True:
-            try:
-                job_no, items = next(jobs_source)
-                if (job_no - 1) * chunksize > total_sentences:
-                    logger.warning(
-                        "terminating after %i sentences (set higher total_sentences if you want more).",
-                        total_sentences
-                    )
-                    job_no -= 1
-                    raise StopIteration()
-                logger.debug("putting job #%i in the queue", job_no)
-                job_queue.put(items)
-            except StopIteration:
-                logger.info("reached end of input; waiting to finish %i outstanding jobs", job_no - done_jobs + 1)
-                for _ in xrange(self.workers):
-                    job_queue.put(None)  # give the workers heads up that they can finish -- no more work!
-                push_done = True
-            try:
-                while done_jobs < (job_no + 1) or not push_done:
-                    ns = progress_queue.get(push_done)  # only block after all jobs pushed
-                    sentence_count += ns
-                    done_jobs += 1
-                    elapsed = default_timer() - start
-                    if elapsed >= next_report:
-                        logger.info(
-                            "PROGRESS: at %.2f%% sentences, %.0f sentences/s",
-                            100.0 * sentence_count, sentence_count / elapsed
-                        )
-                        next_report = elapsed + report_delay  # don't flood log, wait report_delay seconds
-                else:
-                    # loop ended by job count; really done
-                    break
-            except Empty:
-                pass  # already out of loop; continue to next push
-
-        elapsed = default_timer() - start
-        self.clear_sims()
-        logger.info(
-            "scoring %i sentences took %.1fs, %.0f sentences/s",
-            sentence_count, elapsed, sentence_count / elapsed
-        )
-        return sentence_scores[:sentence_count]
-
-    def clear_sims(self):
-        """
-        Removes all L2-normalized vectors for words from the model.
-        You will have to recompute them using init_sims method.
-        """
-
-        self.wv.syn0norm = None
-
-    def update_weights(self):
-        """
-        Copy all the existing weights, and reset the weights for the newly
-        added vocabulary.
-        """
-        logger.info("updating layer weights")
-        gained_vocab = len(self.wv.vocab) - len(self.wv.syn0)
-        newsyn0 = empty((gained_vocab, self.vector_size), dtype=REAL)
-
-        # randomize the remaining words
-        for i in xrange(len(self.wv.syn0), len(self.wv.vocab)):
-            # construct deterministic seed from word AND seed argument
-            newsyn0[i - len(self.wv.syn0)] = self.seeded_vector(self.wv.index2word[i] + str(self.seed))
-
-        # Raise an error if an online update is run before initial training on a corpus
-        if not len(self.wv.syn0):
-            raise RuntimeError(
-                "You cannot do an online vocabulary-update of a model which has no prior vocabulary. "
-                "First build the vocabulary of your model with a corpus before doing an online update."
-            )
-
-        self.wv.syn0 = vstack([self.wv.syn0, newsyn0])
-
-        if self.hs:
-            self.syn1 = vstack([self.syn1, zeros((gained_vocab, self.layer1_size), dtype=REAL)])
-        if self.negative:
-            self.syn1neg = vstack([self.syn1neg, zeros((gained_vocab, self.layer1_size), dtype=REAL)])
-        self.wv.syn0norm = None
-
-        # do not suppress learning for already learned words
-        self.syn0_lockf = ones(len(self.wv.vocab), dtype=REAL)  # zeros suppress learning
-
-    def reset_weights(self):
-        """Reset all projection weights to an initial (untrained) state, but keep the existing vocabulary."""
-        logger.info("resetting layer weights")
-        self.wv.syn0 = empty((len(self.wv.vocab), self.vector_size), dtype=REAL)
-        # randomize weights vector by vector, rather than materializing a huge random matrix in RAM at once
-        for i in xrange(len(self.wv.vocab)):
-            # construct deterministic seed from word AND seed argument
-            self.wv.syn0[i] = self.seeded_vector(self.wv.index2word[i] + str(self.seed))
-        if self.hs:
-            self.syn1 = zeros((len(self.wv.vocab), self.layer1_size), dtype=REAL)
-        if self.negative:
-            self.syn1neg = zeros((len(self.wv.vocab), self.layer1_size), dtype=REAL)
-        self.wv.syn0norm = None
+        Parameters
+        ----------
+        fname : str
+            The file path used to save the vectors in
 
-        self.syn0_lockf = ones(len(self.wv.vocab), dtype=REAL)  # zeros suppress learning
+        binary : bool
+            If True, the data wil be saved in binary word2vec format, else it will be saved in plain text.
 
-    def seeded_vector(self, seed_string):
-        """Create one 'random' vector (but deterministic by seed_string)"""
-        # Note: built-in hash() may vary by Python version or even (in Py3.x) per launch
-        once = random.RandomState(self.hashfxn(seed_string) & 0xffffffff)
-        return (once.rand(self.vector_size) - 0.5) / self.vector_size
+        lockf : float
+            Lock-factor value to be set for any imported word-vectors; the
+            default value of 0.0 prevents further updating of the vector during subsequent
+            training. Use 1.0 to allow further training updates of merged vectors.
 
-    def intersect_word2vec_format(self, fname, lockf=0.0, binary=False, encoding='utf8', unicode_errors='strict'):
-        """
-        Merge the input-hidden weight matrix from the original C word2vec-tool format
-        given, where it intersects with the current vocabulary. (No words are added to the
-        existing vocabulary, but intersecting words adopt the file's weights, and
-        non-intersecting words are left alone.)
-
-        `binary` is a boolean indicating whether the data is in binary word2vec format.
-
-        `lockf` is a lock-factor value to be set for any imported word-vectors; the
-        default value of 0.0 prevents further updating of the vector during subsequent
-        training. Use 1.0 to allow further training updates of merged vectors.
         """
         overlap_count = 0
         logger.info("loading projection weights from %s", fname)
         with utils.smart_open(fname) as fin:
             header = utils.to_unicode(fin.readline(), encoding=encoding)
             vocab_size, vector_size = (int(x) for x in header.split())  # throws for invalid file format
-            if not vector_size == self.vector_size:
+            if not vector_size == self.wv.vector_size:
                 raise ValueError("incompatible vector size %d in file %s" % (vector_size, fname))
                 # TOCONSIDER: maybe mismatched vectors still useful enough to merge (truncating/padding)?
             if binary:
@@ -1352,8 +798,8 @@ def intersect_word2vec_format(self, fname, lockf=0.0, binary=False, encoding='ut
                     weights = fromstring(fin.read(binary_len), dtype=REAL)
                     if word in self.wv.vocab:
                         overlap_count += 1
-                        self.wv.syn0[self.wv.vocab[word].index] = weights
-                        self.syn0_lockf[self.wv.vocab[word].index] = lockf  # lock-factor: 0.0 stops further changes
+                        self.wv.vectors[self.wv.vocab[word].index] = weights
+                        self.trainables.vectors_lockf[self.wv.vocab[word].index] = lockf  # lock-factor: 0.0=no changes
             else:
                 for line_no, line in enumerate(fin):
                     parts = utils.to_unicode(line.rstrip(), encoding=encoding, errors=unicode_errors).split(" ")
@@ -1362,63 +808,15 @@ def intersect_word2vec_format(self, fname, lockf=0.0, binary=False, encoding='ut
                     word, weights = parts[0], [REAL(x) for x in parts[1:]]
                     if word in self.wv.vocab:
                         overlap_count += 1
-                        self.wv.syn0[self.wv.vocab[word].index] = weights
-                        self.syn0_lockf[self.wv.vocab[word].index] = lockf  # lock-factor: 0.0 stops further changes
-        logger.info("merged %d vectors into %s matrix from %s", overlap_count, self.wv.syn0.shape, fname)
-
-    @deprecated("Method will be removed in 4.0.0, use self.wv.most_similar() instead")
-    def most_similar(self, positive=None, negative=None, topn=10, restrict_vocab=None, indexer=None):
-        """
-        Deprecated. Use self.wv.most_similar() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.most_similar`
-        """
-        return self.wv.most_similar(positive, negative, topn, restrict_vocab, indexer)
-
-    @deprecated("Method will be removed in 4.0.0, use self.wv.wmdistance() instead")
-    def wmdistance(self, document1, document2):
-        """
-        Deprecated. Use self.wv.wmdistance() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.wmdistance`
-        """
-        return self.wv.wmdistance(document1, document2)
-
-    @deprecated("Method will be removed in 4.0.0, use self.wv.most_similar_cosmul() instead")
-    def most_similar_cosmul(self, positive=None, negative=None, topn=10):
-        """
-        Deprecated. Use self.wv.most_similar_cosmul() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.most_similar_cosmul`
-        """
-        return self.wv.most_similar_cosmul(positive, negative, topn)
-
-    @deprecated("Method will be removed in 4.0.0, use self.wv.similar_by_word() instead")
-    def similar_by_word(self, word, topn=10, restrict_vocab=None):
-        """
-        Deprecated. Use self.wv.similar_by_word() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.similar_by_word`
-        """
-        return self.wv.similar_by_word(word, topn, restrict_vocab)
-
-    @deprecated("Method will be removed in 4.0.0, use self.wv.similar_by_vector() instead")
-    def similar_by_vector(self, vector, topn=10, restrict_vocab=None):
-        """
-        Deprecated. Use self.wv.similar_by_vector() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.similar_by_vector`
-        """
-        return self.wv.similar_by_vector(vector, topn, restrict_vocab)
-
-    @deprecated("Method will be removed in 4.0.0, use self.wv.doesnt_match() instead")
-    def doesnt_match(self, words):
-        """
-        Deprecated. Use self.wv.doesnt_match() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.doesnt_match`
-        """
-        return self.wv.doesnt_match(words)
+                        self.wv.vectors[self.wv.vocab[word].index] = weights
+                        self.trainables.vectors_lockf[self.wv.vocab[word].index] = lockf  # lock-factor: 0.0=no changes
+        logger.info("merged %d vectors into %s matrix from %s", overlap_count, self.wv.vectors.shape, fname)
 
     @deprecated("Method will be removed in 4.0.0, use self.wv.__getitem__() instead")
     def __getitem__(self, words):
         """
         Deprecated. Use self.wv.__getitem__() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.__getitem__`
+        Refer to the documentation for `gensim.models.keyedvectors.Word2VecKeyedVectors.__getitem__`
         """
         return self.wv.__getitem__(words)
 
@@ -1426,36 +824,34 @@ def __getitem__(self, words):
     def __contains__(self, word):
         """
         Deprecated. Use self.wv.__contains__() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.__contains__`
+        Refer to the documentation for `gensim.models.keyedvectors.Word2VecKeyedVectors.__contains__`
         """
         return self.wv.__contains__(word)
 
-    @deprecated("Method will be removed in 4.0.0, use self.wv.similarity() instead")
-    def similarity(self, w1, w2):
-        """
-        Deprecated. Use self.wv.similarity() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.similarity`
-        """
-        return self.wv.similarity(w1, w2)
-
-    @deprecated("Method will be removed in 4.0.0, use self.wv.n_similarity() instead")
-    def n_similarity(self, ws1, ws2):
-        """
-        Deprecated. Use self.wv.n_similarity() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.n_similarity`
-        """
-        return self.wv.n_similarity(ws1, ws2)
-
     def predict_output_word(self, context_words_list, topn=10):
         """Report the probability distribution of the center word given the context words
-        as input to the trained model."""
+        as input to the trained model.
+
+        Parameters
+        ----------
+        context_words_list : :obj: `list` of :obj: `str`
+            List of context words
+        topn: int
+            Return `topn` words and their probabilities
+
+        Returns
+        -------
+        :obj: `list` of :obj: `tuple`
+            `topn` length list of tuples of (word, probability)
+
+        """
         if not self.negative:
             raise RuntimeError(
                 "We have currently only implemented predict_output_word for the negative sampling scheme, "
                 "so you need to have run word2vec with negative > 0 for this to work."
             )
 
-        if not hasattr(self.wv, 'syn0') or not hasattr(self, 'syn1neg'):
+        if not hasattr(self.wv, 'vectors') or not hasattr(self.trainables, 'syn1neg'):
             raise RuntimeError("Parameters required for predicting the output words not found.")
 
         word_vocabs = [self.wv.vocab[w] for w in context_words_list if w in self.wv.vocab]
@@ -1465,11 +861,12 @@ def predict_output_word(self, context_words_list, topn=10):
 
         word2_indices = [word.index for word in word_vocabs]
 
-        l1 = np_sum(self.wv.syn0[word2_indices], axis=0)
+        l1 = np_sum(self.wv.vectors[word2_indices], axis=0)
         if word2_indices and self.cbow_mean:
             l1 /= len(word2_indices)
 
-        prob_values = exp(dot(l1, self.syn1neg.T))  # propagate hidden -> output and take softmax to get probabilities
+        # propagate hidden -> output and take softmax to get probabilities
+        prob_values = exp(dot(l1, self.trainables.syn1neg.T))
         prob_values /= sum(prob_values)
         top_indices = matutils.argsort(prob_values, topn=topn, reverse=True)
         # returning the most probable output words with their probabilities
@@ -1477,78 +874,40 @@ def predict_output_word(self, context_words_list, topn=10):
 
     def init_sims(self, replace=False):
         """
-        init_sims() resides in KeyedVectors because it deals with syn0 mainly, but because syn1 is not an attribute
-        of KeyedVectors, it has to be deleted in this class, and the normalizing of syn0 happens inside of KeyedVectors
+        init_sims() resides in KeyedVectors because it deals with syn0/vectors mainly, but because syn1 is not an
+        attribute of KeyedVectors, it has to be deleted in this class, and the normalizing of syn0/vectors happens
+        inside of KeyedVectors
         """
-        if replace and hasattr(self, 'syn1'):
-            del self.syn1
+        if replace and hasattr(self.trainables, 'syn1'):
+            del self.trainables.syn1
         return self.wv.init_sims(replace)
 
-    def estimate_memory(self, vocab_size=None, report=None):
-        """Estimate required memory for a model using current settings and provided vocabulary size."""
-        vocab_size = vocab_size or len(self.wv.vocab)
-        report = report or {}
-        report['vocab'] = vocab_size * (700 if self.hs else 500)
-        report['syn0'] = vocab_size * self.vector_size * dtype(REAL).itemsize
-        if self.hs:
-            report['syn1'] = vocab_size * self.layer1_size * dtype(REAL).itemsize
-        if self.negative:
-            report['syn1neg'] = vocab_size * self.layer1_size * dtype(REAL).itemsize
-        report['total'] = sum(report.values())
-        logger.info(
-            "estimated required memory for %i words and %i dimensions: %i bytes",
-            vocab_size, self.vector_size, report['total']
-        )
-        return report
+    def reset_from(self, other_model):
+        """Borrow shareable pre-built structures (like vocab) from the other_model. Useful
+        if testing multiple models in parallel on the same corpus.
+        """
+        self.wv.vocab = other_model.wv.vocab
+        self.wv.index2word = other_model.wv.index2word
+        self.vocabulary.cum_table = other_model.vocabulary.cum_table
+        self.corpus_count = other_model.corpus_count
+        self.trainables.reset_weights(self.hs, self.negative, self.wv)
 
     @staticmethod
     def log_accuracy(section):
-        return KeyedVectors.log_accuracy(section)
+        return Word2VecKeyedVectors.log_accuracy(section)
 
+    @deprecated("Method will be removed in 4.0.0, use self.wv.accuracy() instead")
     def accuracy(self, questions, restrict_vocab=30000, most_similar=None, case_insensitive=True):
-        most_similar = most_similar or KeyedVectors.most_similar
+        most_similar = most_similar or Word2VecKeyedVectors.most_similar
         return self.wv.accuracy(questions, restrict_vocab, most_similar, case_insensitive)
 
-    @staticmethod
-    @deprecated("Method will be removed in 4.0.0, use self.wv.log_evaluate_word_pairs() instead")
-    def log_evaluate_word_pairs(pearson, spearman, oov, pairs):
-        """
-        Deprecated. Use self.wv.log_evaluate_word_pairs() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.log_evaluate_word_pairs`
-        """
-        return KeyedVectors.log_evaluate_word_pairs(pearson, spearman, oov, pairs)
-
-    @deprecated("Method will be removed in 4.0.0, use self.wv.evaluate_word_pairs() instead")
-    def evaluate_word_pairs(self, pairs, delimiter='\t', restrict_vocab=300000,
-                            case_insensitive=True, dummy4unknown=False):
-        """
-        Deprecated. Use self.wv.evaluate_word_pairs() instead.
-        Refer to the documentation for `gensim.models.KeyedVectors.evaluate_word_pairs`
-        """
-        return self.wv.evaluate_word_pairs(pairs, delimiter, restrict_vocab, case_insensitive, dummy4unknown)
-
     def __str__(self):
         return "%s(vocab=%s, size=%s, alpha=%s)" % (
-            self.__class__.__name__, len(self.wv.index2word), self.vector_size, self.alpha
+            self.__class__.__name__, len(self.wv.index2word), self.wv.vector_size, self.alpha
         )
 
-    @deprecated(
-        "Method will be removed in 4.0.0, keep just_word_vectors = model.wv to retain just the KeyedVectors instance"
-    )
-    def _minimize_model(self, save_syn1=False, save_syn1neg=False, save_syn0_lockf=False):
-        if save_syn1 and save_syn1neg and save_syn0_lockf:
-            return
-        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
-        self.model_trimmed_post_training = True
-
     def delete_temporary_training_data(self, replace_word_vectors_with_normalized=False):
-        """
-        Discard parameters that are used in training and score. Use if you're sure you're done training a model.
+        """Discard parameters that are used in training and score. Use if you're sure you're done training a model.
         If `replace_word_vectors_with_normalized` is set, forget the original vectors and only keep the normalized
         ones = saves lots of memory!
         """
@@ -1557,63 +916,67 @@ def delete_temporary_training_data(self, replace_word_vectors_with_normalized=Fa
         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'])
+        """Save the model. This saved model can be loaded again using :func:`~gensim.models.word2vec.Word2Vec.load`,
+        which supports online training and getting vectors for vocabulary words.
 
+        Parameters
+        ----------
+        fname : str
+            Path to the file.
+
+        """
+        # don't bother storing the cached normalized vectors, recalculable table
+        kwargs['ignore'] = kwargs.get('ignore', ['vectors_norm', 'cum_table'])
         super(Word2Vec, self).save(*args, **kwargs)
 
-    save.__doc__ = utils.SaveLoad.save.__doc__
+    def get_latest_training_loss(self):
+        return self.running_training_loss
 
-    @classmethod
-    def load(cls, *args, **kwargs):
-        model = super(Word2Vec, cls).load(*args, **kwargs)
-        # update older models
-        if hasattr(model, 'table'):
-            delattr(model, 'table')  # discard in favor of cum_table
-        if model.negative and hasattr(model.wv, 'index2word'):
-            model.make_cum_table()  # rebuild cum_table from vocabulary
-        if not hasattr(model, 'corpus_count'):
-            model.corpus_count = None
-        for v in model.wv.vocab.values():
-            if hasattr(v, 'sample_int'):
-                break  # already 0.12.0+ style int probabilities
-            elif hasattr(v, 'sample_probability'):
-                v.sample_int = int(round(v.sample_probability * 2**32))
-                del v.sample_probability
-        if not hasattr(model, 'syn0_lockf') and hasattr(model, 'syn0'):
-            model.syn0_lockf = ones(len(model.wv.syn0), dtype=REAL)
-        if not hasattr(model, 'random'):
-            model.random = random.RandomState(model.seed)
-        if not hasattr(model, 'train_count'):
-            model.train_count = 0
-            model.total_train_time = 0
-        return model
-
-    def _load_specials(self, *args, **kwargs):
-        super(Word2Vec, self)._load_specials(*args, **kwargs)
-        # loading from a pre-KeyedVectors word2vec model
-        if not hasattr(self, 'wv'):
-            wv = KeyedVectors()
-            wv.syn0 = self.__dict__.get('syn0', [])
-            wv.syn0norm = self.__dict__.get('syn0norm', None)
-            wv.vocab = self.__dict__.get('vocab', {})
-            wv.index2word = self.__dict__.get('index2word', [])
-            self.wv = wv
+    @deprecated(
+        "Method will be removed in 4.0.0, keep just_word_vectors = model.wv to retain just the KeyedVectors instance"
+    )
+    def _minimize_model(self, save_syn1=False, save_syn1neg=False, save_vectors_lockf=False):
+        if save_syn1 and save_syn1neg and save_vectors_lockf:
+            return
+        if hasattr(self.trainables, 'syn1') and not save_syn1:
+            del self.trainables.syn1
+        if hasattr(self.trainables, 'syn1neg') and not save_syn1neg:
+            del self.trainables.syn1neg
+        if hasattr(self.trainables, 'vectors_lockf') and not save_vectors_lockf:
+            del self.trainables.vectors_lockf
+        self.model_trimmed_post_training = True
 
     @classmethod
-    @deprecated("Method will be removed in 4.0.0, use gensim.models.KeyedVectors.load_word2vec_format instead")
-    def load_word2vec_format(cls, fname, fvocab=None, binary=False, encoding='utf8', unicode_errors='strict',
-                         limit=None, datatype=REAL):
+    def load_word2vec_format(
+            cls, fname, fvocab=None, binary=False, encoding='utf8', unicode_errors='strict',
+            limit=None, datatype=REAL):
         """Deprecated. Use gensim.models.KeyedVectors.load_word2vec_format instead."""
         raise DeprecationWarning("Deprecated. Use gensim.models.KeyedVectors.load_word2vec_format instead.")
 
-    @deprecated("Method will be removed in 4.0.0, use model.wv.save_word2vec_format instead")
     def save_word2vec_format(self, fname, fvocab=None, binary=False):
         """Deprecated. Use model.wv.save_word2vec_format instead."""
         raise DeprecationWarning("Deprecated. Use model.wv.save_word2vec_format instead.")
 
-    def get_latest_training_loss(self):
-        return self.running_training_loss
+    @classmethod
+    def load(cls, *args, **kwargs):
+        """Loads a previously saved `Word2Vec` model. Also see `save()`.
+
+        Parameters
+        ----------
+        fname : str
+            Path to the saved file.
+
+        Returns
+        -------
+        :obj: `~gensim.models.word2vec.Word2Vec`
+            Returns the loaded model as an instance of :class: `~gensim.models.word2vec.Word2Vec`.
+        """
+        try:
+            return super(Word2Vec, cls).load(*args, **kwargs)
+        except AttributeError:
+            logger.info('Model saved using code from earlier Gensim Version. Re-loading old model in a compatible way.')
+            from gensim.models.deprecated.word2vec import load_old_word2vec
+            return load_old_word2vec(*args, **kwargs)
 
 
 class BrownCorpus(object):
@@ -1669,8 +1032,7 @@ def __iter__(self):
 
 
 class LineSentence(object):
-    """
-    Simple format: one sentence = one line; words already preprocessed and separated by whitespace.
+    """Simple format: one sentence = one line; words already preprocessed and separated by whitespace.
     """
 
     def __init__(self, source, max_sentence_length=MAX_WORDS_IN_BATCH, limit=None):
@@ -1716,9 +1078,7 @@ def __iter__(self):
 
 
 class PathLineSentences(object):
-    """
-
-    Works like word2vec.LineSentence, but will process all files in a directory in alphabetical order by filename.
+    """Works like word2vec.LineSentence, but will process all files in a directory in alphabetical order by filename.
     The directory can only contain files that can be read by LineSentence: .bz2, .gz, and text files.
     Any file not ending with .bz2 or .gz is assumed to be a text file. Does not work with subdirectories.
 
@@ -1770,6 +1130,334 @@ def __iter__(self):
                         i += self.max_sentence_length
 
 
+class Word2VecVocab(utils.SaveLoad):
+    def __init__(self, max_vocab_size=None, min_count=5, sample=1e-3, sorted_vocab=True, null_word=0):
+        self.max_vocab_size = max_vocab_size
+        self.min_count = min_count
+        self.sample = sample
+        self.sorted_vocab = sorted_vocab
+        self.null_word = null_word
+        self.cum_table = None  # for negative sampling
+        self.raw_vocab = None
+
+    def scan_vocab(self, sentences, progress_per=10000, trim_rule=None):
+        """Do an initial scan of all words appearing in sentences."""
+        logger.info("collecting all words and their counts")
+        sentence_no = -1
+        total_words = 0
+        min_reduce = 1
+        vocab = defaultdict(int)
+        checked_string_types = 0
+        for sentence_no, sentence in enumerate(sentences):
+            if not checked_string_types:
+                if isinstance(sentence, string_types):
+                    logger.warning(
+                        "Each 'sentences' item should be a list of words (usually unicode strings). "
+                        "First item here is instead plain %s.",
+                        type(sentence)
+                    )
+                checked_string_types += 1
+            if sentence_no % progress_per == 0:
+                logger.info(
+                    "PROGRESS: at sentence #%i, processed %i words, keeping %i word types",
+                    sentence_no, total_words, len(vocab)
+                )
+            for word in sentence:
+                vocab[word] += 1
+            total_words += len(sentence)
+
+            if self.max_vocab_size and len(vocab) > self.max_vocab_size:
+                utils.prune_vocab(vocab, min_reduce, trim_rule=trim_rule)
+                min_reduce += 1
+
+        logger.info(
+            "collected %i word types from a corpus of %i raw words and %i sentences",
+            len(vocab), total_words, sentence_no + 1
+        )
+        corpus_count = sentence_no + 1
+        self.raw_vocab = vocab
+        return total_words, corpus_count
+
+    def sort_vocab(self, wv):
+        """Sort the vocabulary so the most frequent words have the lowest indexes."""
+        if len(wv.vectors):
+            raise RuntimeError("cannot sort vocabulary after model weights already initialized.")
+        wv.index2word.sort(key=lambda word: wv.vocab[word].count, reverse=True)
+        for i, word in enumerate(wv.index2word):
+            wv.vocab[word].index = i
+
+    def prepare_vocab(self, hs, negative, wv, update=False, keep_raw_vocab=False, trim_rule=None,
+                      min_count=None, sample=None, dry_run=False):
+        """Apply vocabulary settings for `min_count` (discarding less-frequent words)
+        and `sample` (controlling the downsampling of more-frequent words).
+
+        Calling with `dry_run=True` will only simulate the provided settings and
+        report the size of the retained vocabulary, effective corpus length, and
+        estimated memory requirements. Results are both printed via logging and
+        returned as a dict.
+
+        Delete the raw vocabulary after the scaling is done to free up RAM,
+        unless `keep_raw_vocab` is set.
+
+        """
+        min_count = min_count or self.min_count
+        sample = sample or self.sample
+        drop_total = drop_unique = 0
+
+        if not update:
+            logger.info("Loading a fresh vocabulary")
+            retain_total, retain_words = 0, []
+            # Discard words less-frequent than min_count
+            if not dry_run:
+                wv.index2word = []
+                # make stored settings match these applied settings
+                self.min_count = min_count
+                self.sample = sample
+                wv.vocab = {}
+
+            for word, v in iteritems(self.raw_vocab):
+                if keep_vocab_item(word, v, min_count, trim_rule=trim_rule):
+                    retain_words.append(word)
+                    retain_total += v
+                    if not dry_run:
+                        wv.vocab[word] = Vocab(count=v, index=len(wv.index2word))
+                        wv.index2word.append(word)
+                else:
+                    drop_unique += 1
+                    drop_total += v
+            original_unique_total = len(retain_words) + drop_unique
+            retain_unique_pct = len(retain_words) * 100 / max(original_unique_total, 1)
+            logger.info(
+                "min_count=%d retains %i unique words (%i%% of original %i, drops %i)",
+                min_count, len(retain_words), retain_unique_pct, original_unique_total, drop_unique
+            )
+            original_total = retain_total + drop_total
+            retain_pct = retain_total * 100 / max(original_total, 1)
+            logger.info(
+                "min_count=%d leaves %i word corpus (%i%% of original %i, drops %i)",
+                min_count, retain_total, retain_pct, original_total, drop_total
+            )
+        else:
+            logger.info("Updating model with new vocabulary")
+            new_total = pre_exist_total = 0
+            new_words = pre_exist_words = []
+            for word, v in iteritems(self.raw_vocab):
+                if keep_vocab_item(word, v, min_count, trim_rule=trim_rule):
+                    if word in wv.vocab:
+                        pre_exist_words.append(word)
+                        pre_exist_total += v
+                        if not dry_run:
+                            wv.vocab[word].count += v
+                    else:
+                        new_words.append(word)
+                        new_total += v
+                        if not dry_run:
+                            wv.vocab[word] = Vocab(count=v, index=len(wv.index2word))
+                            wv.index2word.append(word)
+                else:
+                    drop_unique += 1
+                    drop_total += v
+            original_unique_total = len(pre_exist_words) + len(new_words) + drop_unique
+            pre_exist_unique_pct = len(pre_exist_words) * 100 / max(original_unique_total, 1)
+            new_unique_pct = len(new_words) * 100 / max(original_unique_total, 1)
+            logger.info(
+                "New added %i unique words (%i%% of original %i) "
+                "and increased the count of %i pre-existing words (%i%% of original %i)",
+                len(new_words), new_unique_pct, original_unique_total, len(pre_exist_words),
+                pre_exist_unique_pct, original_unique_total
+            )
+            retain_words = new_words + pre_exist_words
+            retain_total = new_total + pre_exist_total
+
+        # Precalculate each vocabulary item's threshold for sampling
+        if not sample:
+            # no words downsampled
+            threshold_count = retain_total
+        elif sample < 1.0:
+            # traditional meaning: set parameter as proportion of total
+            threshold_count = sample * retain_total
+        else:
+            # new shorthand: sample >= 1 means downsample all words with higher count than sample
+            threshold_count = int(sample * (3 + sqrt(5)) / 2)
+
+        downsample_total, downsample_unique = 0, 0
+        for w in retain_words:
+            v = self.raw_vocab[w]
+            word_probability = (sqrt(v / threshold_count) + 1) * (threshold_count / v)
+            if word_probability < 1.0:
+                downsample_unique += 1
+                downsample_total += word_probability * v
+            else:
+                word_probability = 1.0
+                downsample_total += v
+            if not dry_run:
+                wv.vocab[w].sample_int = int(round(word_probability * 2**32))
+
+        if not dry_run and not keep_raw_vocab:
+            logger.info("deleting the raw counts dictionary of %i items", len(self.raw_vocab))
+            self.raw_vocab = defaultdict(int)
+
+        logger.info("sample=%g downsamples %i most-common words", sample, downsample_unique)
+        logger.info(
+            "downsampling leaves estimated %i word corpus (%.1f%% of prior %i)",
+            downsample_total, downsample_total * 100.0 / max(retain_total, 1), retain_total
+        )
+
+        # return from each step: words-affected, resulting-corpus-size, extra memory estimates
+        report_values = {
+            'drop_unique': drop_unique, 'retain_total': retain_total, 'downsample_unique': downsample_unique,
+            'downsample_total': int(downsample_total), 'num_retained_words': len(retain_words)
+        }
+
+        if self.null_word:
+            # create null pseudo-word for padding when using concatenative L1 (run-of-words)
+            # this word is only ever input – never predicted – so count, huffman-point, etc doesn't matter
+            self.add_null_word(wv)
+
+        if self.sorted_vocab and not update:
+            self.sort_vocab(wv)
+        if hs:
+            # add info about each word's Huffman encoding
+            self.create_binary_tree(wv)
+        if negative:
+            # build the table for drawing random words (for negative sampling)
+            self.make_cum_table(wv)
+
+        return report_values
+
+    def add_null_word(self, wv):
+        word, v = '\0', Vocab(count=1, sample_int=0)
+        v.index = len(wv.vocab)
+        wv.index2word.append(word)
+        wv.vocab[word] = v
+
+    def create_binary_tree(self, wv):
+        """Create a binary Huffman tree using stored vocabulary word counts. Frequent words
+        will have shorter binary codes. Called internally from `build_vocab()`.
+
+        """
+        logger.info("constructing a huffman tree from %i words", len(wv.vocab))
+
+        # build the huffman tree
+        heap = list(itervalues(wv.vocab))
+        heapq.heapify(heap)
+        for i in xrange(len(wv.vocab) - 1):
+            min1, min2 = heapq.heappop(heap), heapq.heappop(heap)
+            heapq.heappush(
+                heap, Vocab(count=min1.count + min2.count, index=i + len(wv.vocab), left=min1, right=min2)
+            )
+
+        # recurse over the tree, assigning a binary code to each vocabulary word
+        if heap:
+            max_depth, stack = 0, [(heap[0], [], [])]
+            while stack:
+                node, codes, points = stack.pop()
+                if node.index < len(wv.vocab):
+                    # leaf node => store its path from the root
+                    node.code, node.point = codes, points
+                    max_depth = max(len(codes), max_depth)
+                else:
+                    # inner node => continue recursion
+                    points = array(list(points) + [node.index - len(wv.vocab)], dtype=uint32)
+                    stack.append((node.left, array(list(codes) + [0], dtype=uint8), points))
+                    stack.append((node.right, array(list(codes) + [1], dtype=uint8), points))
+
+            logger.info("built huffman tree with maximum node depth %i", max_depth)
+
+    def make_cum_table(self, wv, power=0.75, domain=2**31 - 1):
+        """Create a cumulative-distribution table using stored vocabulary word counts for
+        drawing random words in the negative-sampling training routines.
+
+        To draw a word index, choose a random integer up to the maximum value in the
+        table (cum_table[-1]), then finding that integer's sorted insertion point
+        (as if by bisect_left or ndarray.searchsorted()). That insertion point is the
+        drawn index, coming up in proportion equal to the increment at that slot.
+
+        Called internally from 'build_vocab()'.
+        """
+        vocab_size = len(wv.index2word)
+        self.cum_table = zeros(vocab_size, dtype=uint32)
+        # compute sum of all power (Z in paper)
+        train_words_pow = 0.0
+        for word_index in xrange(vocab_size):
+            train_words_pow += wv.vocab[wv.index2word[word_index]].count**power
+        cumulative = 0.0
+        for word_index in xrange(vocab_size):
+            cumulative += wv.vocab[wv.index2word[word_index]].count**power
+            self.cum_table[word_index] = round(cumulative / train_words_pow * domain)
+        if len(self.cum_table) > 0:
+            assert self.cum_table[-1] == domain
+
+
+class Word2VecTrainables(utils.SaveLoad):
+    def __init__(self, vector_size=100, seed=1, hashfxn=hash):
+        self.hashfxn = hashfxn
+        self.layer1_size = vector_size
+        self.seed = seed
+
+    def prepare_weights(self, hs, negative, wv, update=False, vocabulary=None):
+        """Build tables and model weights based on final vocabulary settings."""
+        # set initial input/projection and hidden weights
+        if not update:
+            self.reset_weights(hs, negative, wv)
+        else:
+            self.update_weights(hs, negative, wv)
+
+    def seeded_vector(self, seed_string, vector_size):
+        """Create one 'random' vector (but deterministic by seed_string)"""
+        # Note: built-in hash() may vary by Python version or even (in Py3.x) per launch
+        once = random.RandomState(self.hashfxn(seed_string) & 0xffffffff)
+        return (once.rand(vector_size) - 0.5) / vector_size
+
+    def reset_weights(self, hs, negative, wv):
+        """Reset all projection weights to an initial (untrained) state, but keep the existing vocabulary."""
+        logger.info("resetting layer weights")
+        wv.vectors = empty((len(wv.vocab), wv.vector_size), dtype=REAL)
+        # randomize weights vector by vector, rather than materializing a huge random matrix in RAM at once
+        for i in xrange(len(wv.vocab)):
+            # construct deterministic seed from word AND seed argument
+            wv.vectors[i] = self.seeded_vector(wv.index2word[i] + str(self.seed), wv.vector_size)
+        if hs:
+            self.syn1 = zeros((len(wv.vocab), self.layer1_size), dtype=REAL)
+        if negative:
+            self.syn1neg = zeros((len(wv.vocab), self.layer1_size), dtype=REAL)
+        wv.vectors_norm = None
+
+        self.vectors_lockf = ones(len(wv.vocab), dtype=REAL)  # zeros suppress learning
+
+    def update_weights(self, hs, negative, wv):
+        """
+        Copy all the existing weights, and reset the weights for the newly
+        added vocabulary.
+        """
+        logger.info("updating layer weights")
+        gained_vocab = len(wv.vocab) - len(wv.vectors)
+        newvectors = empty((gained_vocab, wv.vector_size), dtype=REAL)
+
+        # randomize the remaining words
+        for i in xrange(len(wv.vectors), len(wv.vocab)):
+            # construct deterministic seed from word AND seed argument
+            newvectors[i - len(wv.vectors)] = self.seeded_vector(wv.index2word[i] + str(self.seed), wv.vector_size)
+
+        # Raise an error if an online update is run before initial training on a corpus
+        if not len(wv.vectors):
+            raise RuntimeError(
+                "You cannot do an online vocabulary-update of a model which has no prior vocabulary. "
+                "First build the vocabulary of your model with a corpus before doing an online update."
+            )
+
+        wv.vectors = vstack([wv.vectors, newvectors])
+
+        if hs:
+            self.syn1 = vstack([self.syn1, zeros((gained_vocab, self.layer1_size), dtype=REAL)])
+        if negative:
+            self.syn1neg = vstack([self.syn1neg, zeros((gained_vocab, self.layer1_size), dtype=REAL)])
+        wv.vectors_norm = None
+
+        # do not suppress learning for already learned words
+        self.vectors_lockf = ones(len(wv.vocab), dtype=REAL)  # zeros suppress learning
+
+
 # Example: ./word2vec.py -train data.txt -output vec.txt -size 200 -window 5 -sample 1e-4 \
 # -negative 5 -hs 0 -binary 0 -cbow 1 -iter 3
 if __name__ == "__main__":
diff --git a/gensim/models/word2vec_inner.c b/gensim/models/word2vec_inner.c
index b6ccba2524..56cdcc130a 100644
--- a/gensim/models/word2vec_inner.c
+++ b/gensim/models/word2vec_inner.c
@@ -1547,6 +1547,7 @@ static const char __pyx_k_indexes[] = "indexes";
 static const char __pyx_k_our_dot[] = "our_dot";
 static const char __pyx_k_randint[] = "randint";
 static const char __pyx_k_syn1neg[] = "syn1neg";
+static const char __pyx_k_vectors[] = "vectors";
 static const char __pyx_k_vlookup[] = "vlookup";
 static const char __pyx_k_codelens[] = "codelens";
 static const char __pyx_k_cpointer[] = "_cpointer";
@@ -1564,17 +1565,19 @@ static const char __pyx_k_our_saxpy[] = "our_saxpy";
 static const char __pyx_k_sentences[] = "sentences";
 static const char __pyx_k_ValueError[] = "ValueError";
 static const char __pyx_k_sample_int[] = "sample_int";
-static const char __pyx_k_syn0_lockf[] = "syn0_lockf";
+static const char __pyx_k_trainables[] = "trainables";
+static const char __pyx_k_vocabulary[] = "vocabulary";
 static const char __pyx_k_word_locks[] = "word_locks";
 static const char __pyx_k_ImportError[] = "ImportError";
-static const char __pyx_k_layer1_size[] = "layer1_size";
 static const char __pyx_k_next_random[] = "next_random";
+static const char __pyx_k_vector_size[] = "vector_size";
 static const char __pyx_k_FAST_VERSION[] = "FAST_VERSION";
 static const char __pyx_k_RuntimeError[] = "RuntimeError";
 static const char __pyx_k_compute_loss[] = "compute_loss";
 static const char __pyx_k_sentence_idx[] = "sentence_idx";
 static const char __pyx_k_sentence_len[] = "sentence_len";
 static const char __pyx_k_cum_table_len[] = "cum_table_len";
+static const char __pyx_k_vectors_lockf[] = "vectors_lockf";
 static const char __pyx_k_compute_loss_2[] = "_compute_loss";
 static const char __pyx_k_train_batch_sg[] = "train_batch_sg";
 static const char __pyx_k_effective_words[] = "effective_words";
@@ -1640,7 +1643,6 @@ static PyObject *__pyx_n_s_init;
 static PyObject *__pyx_n_s_item;
 static PyObject *__pyx_n_s_j;
 static PyObject *__pyx_n_s_k;
-static PyObject *__pyx_n_s_layer1_size;
 static PyObject *__pyx_n_s_main;
 static PyObject *__pyx_n_s_model;
 static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
@@ -1684,16 +1686,20 @@ static PyObject *__pyx_n_s_size;
 static PyObject *__pyx_n_s_snrm2;
 static PyObject *__pyx_n_s_sscal;
 static PyObject *__pyx_n_s_syn0;
-static PyObject *__pyx_n_s_syn0_lockf;
 static PyObject *__pyx_n_s_syn1;
 static PyObject *__pyx_n_s_syn1neg;
 static PyObject *__pyx_n_s_test;
 static PyObject *__pyx_n_s_token;
 static PyObject *__pyx_n_s_train_batch_cbow;
 static PyObject *__pyx_n_s_train_batch_sg;
+static PyObject *__pyx_n_s_trainables;
 static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
+static PyObject *__pyx_n_s_vector_size;
+static PyObject *__pyx_n_s_vectors;
+static PyObject *__pyx_n_s_vectors_lockf;
 static PyObject *__pyx_n_s_vlookup;
 static PyObject *__pyx_n_s_vocab;
+static PyObject *__pyx_n_s_vocabulary;
 static PyObject *__pyx_n_s_window;
 static PyObject *__pyx_n_s_word;
 static PyObject *__pyx_n_s_word_locks;
@@ -3905,7 +3911,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
  * def train_batch_sg(model, sentences, alpha, _work, compute_loss):
  *     cdef int hs = model.hs             # <<<<<<<<<<<<<<
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_hs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 297, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
@@ -3917,7 +3923,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
  * def train_batch_sg(model, sentences, alpha, _work, compute_loss):
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative             # <<<<<<<<<<<<<<
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  * 
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_negative); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 298, __pyx_L1_error)
@@ -3929,28 +3935,31 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
   /* "gensim/models/word2vec_inner.pyx":299
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)             # <<<<<<<<<<<<<<
+ *     cdef int sample = (model.vocabulary.sample != 0)             # <<<<<<<<<<<<<<
  * 
  *     cdef int _compute_loss = (1 if compute_loss == True else 0)
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_sample); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sample); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 299, __pyx_L1_error)
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 299, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 299, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_sample = __pyx_t_2;
 
   /* "gensim/models/word2vec_inner.pyx":301
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  * 
  *     cdef int _compute_loss = (1 if compute_loss == True else 0)             # <<<<<<<<<<<<<<
  *     cdef REAL_t _running_training_loss = model.running_training_loss
  * 
  */
-  __pyx_t_3 = PyObject_RichCompare(__pyx_v_compute_loss, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error)
-  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 301, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = PyObject_RichCompare(__pyx_v_compute_loss, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 301, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 301, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if (__pyx_t_4) {
     __pyx_t_2 = 1;
   } else {
@@ -3963,48 +3972,51 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
  *     cdef int _compute_loss = (1 if compute_loss == True else 0)
  *     cdef REAL_t _running_training_loss = model.running_training_loss             # <<<<<<<<<<<<<<
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_running_training_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_5 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 302, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_running_training_loss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 302, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_5 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 302, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v__running_training_loss = __pyx_t_5;
 
   /* "gensim/models/word2vec_inner.pyx":304
  *     cdef REAL_t _running_training_loss = model.running_training_loss
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))             # <<<<<<<<<<<<<<
- *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.syn0_lockf))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_lockf))
  *     cdef REAL_t *work
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 304, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 304, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 304, __pyx_L1_error)
-  __pyx_v_syn0 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 304, __pyx_L1_error)
+  __pyx_v_syn0 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "gensim/models/word2vec_inner.pyx":305
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
- *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.syn0_lockf))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
+ *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_lockf))             # <<<<<<<<<<<<<<
  *     cdef REAL_t *work
  *     cdef REAL_t _alpha = alpha
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn0_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 305, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 305, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 305, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 305, __pyx_L1_error)
   __pyx_v_word_locks = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "gensim/models/word2vec_inner.pyx":307
- *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.syn0_lockf))
+ *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_lockf))
  *     cdef REAL_t *work
  *     cdef REAL_t _alpha = alpha             # <<<<<<<<<<<<<<
- *     cdef int size = model.layer1_size
+ *     cdef int size = model.wv.vector_size
  * 
  */
   __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_v_alpha); if (unlikely((__pyx_t_5 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 307, __pyx_L1_error)
@@ -4013,14 +4025,17 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
   /* "gensim/models/word2vec_inner.pyx":308
  *     cdef REAL_t *work
  *     cdef REAL_t _alpha = alpha
- *     cdef int size = model.layer1_size             # <<<<<<<<<<<<<<
+ *     cdef int size = model.wv.vector_size             # <<<<<<<<<<<<<<
  * 
  *     cdef int codelens[MAX_SENTENCE_LEN]
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 308, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 308, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 308, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vector_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 308, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 308, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_size = __pyx_t_2;
 
   /* "gensim/models/word2vec_inner.pyx":314
@@ -4030,10 +4045,10 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
  * 
  *     cdef int i, j, k
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 314, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 314, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 314, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 314, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_window = __pyx_t_2;
 
   /* "gensim/models/word2vec_inner.pyx":317
@@ -4050,7 +4065,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
  *     cdef unsigned long long next_random
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   __pyx_t_4 = (__pyx_v_hs != 0);
@@ -4059,12 +4074,15 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
     /* "gensim/models/word2vec_inner.pyx":333
  * 
  *     if hs:
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))             # <<<<<<<<<<<<<<
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))             # <<<<<<<<<<<<<<
  * 
  *     if negative:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 333, __pyx_L1_error)
     __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -4073,17 +4091,17 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
  *     cdef unsigned long long next_random
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   }
 
   /* "gensim/models/word2vec_inner.pyx":335
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   __pyx_t_4 = (__pyx_v_negative != 0);
   if (__pyx_t_4) {
@@ -4091,54 +4109,63 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
     /* "gensim/models/word2vec_inner.pyx":336
  * 
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))             # <<<<<<<<<<<<<<
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))             # <<<<<<<<<<<<<<
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 336, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 336, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 336, __pyx_L1_error)
-    __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 336, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 336, __pyx_L1_error)
+    __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
     /* "gensim/models/word2vec_inner.pyx":337
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))             # <<<<<<<<<<<<<<
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))             # <<<<<<<<<<<<<<
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 337, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 337, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 337, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 337, __pyx_L1_error)
     __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
     /* "gensim/models/word2vec_inner.pyx":338
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)             # <<<<<<<<<<<<<<
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)             # <<<<<<<<<<<<<<
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 338, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 338, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_6 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 338, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 338, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_6 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 338, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_v_cum_table_len = __pyx_t_6;
 
     /* "gensim/models/word2vec_inner.pyx":335
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   }
 
   /* "gensim/models/word2vec_inner.pyx":339
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -4155,42 +4182,42 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
   if (__pyx_t_4) {
 
     /* "gensim/models/word2vec_inner.pyx":340
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 340, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_randint); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 340, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 340, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 340, __pyx_L1_error)
+    __pyx_t_1 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 340, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_randint); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 340, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 340, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __pyx_t_8 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error)
+    __pyx_t_8 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_t_9 = __Pyx_PyInt_As_unsigned_PY_LONG_LONG(__pyx_t_8); if (unlikely((__pyx_t_9 == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 340, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
     __pyx_v_next_random = __pyx_t_9;
 
     /* "gensim/models/word2vec_inner.pyx":339
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -4216,11 +4243,11 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
  */
   __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 346, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_vocab); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 346, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_vocab); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 346, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __pyx_v_vlookup = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_v_vlookup = __pyx_t_3;
+  __pyx_t_3 = 0;
 
   /* "gensim/models/word2vec_inner.pyx":347
  *     # prepare C structures so we can go "full C" and release the Python GIL
@@ -4239,34 +4266,34 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
  *             continue  # ignore empty sentences; leave effective_sentences unchanged
  */
   if (likely(PyList_CheckExact(__pyx_v_sentences)) || PyTuple_CheckExact(__pyx_v_sentences)) {
-    __pyx_t_1 = __pyx_v_sentences; __Pyx_INCREF(__pyx_t_1); __pyx_t_6 = 0;
+    __pyx_t_3 = __pyx_v_sentences; __Pyx_INCREF(__pyx_t_3); __pyx_t_6 = 0;
     __pyx_t_10 = NULL;
   } else {
-    __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_sentences); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 348, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_10 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 348, __pyx_L1_error)
+    __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_sentences); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 348, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_10 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 348, __pyx_L1_error)
   }
   for (;;) {
     if (likely(!__pyx_t_10)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_1)) break;
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_3)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_8 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 348, __pyx_L1_error)
+        __pyx_t_8 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 348, __pyx_L1_error)
         #else
-        __pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error)
+        __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_8);
         #endif
       } else {
-        if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+        if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 348, __pyx_L1_error)
+        __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 348, __pyx_L1_error)
         #else
-        __pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error)
+        __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_8);
         #endif
       }
     } else {
-      __pyx_t_8 = __pyx_t_10(__pyx_t_1);
+      __pyx_t_8 = __pyx_t_10(__pyx_t_3);
       if (unlikely(!__pyx_t_8)) {
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
@@ -4329,23 +4356,23 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
         if (likely(PyList_CheckExact(__pyx_t_8))) {
           if (__pyx_t_11 >= PyList_GET_SIZE(__pyx_t_8)) break;
           #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_3 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_11); __Pyx_INCREF(__pyx_t_3); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 351, __pyx_L1_error)
+          __pyx_t_1 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_11); __Pyx_INCREF(__pyx_t_1); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 351, __pyx_L1_error)
           #else
-          __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_1 = PySequence_ITEM(__pyx_t_8, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_1);
           #endif
         } else {
           if (__pyx_t_11 >= PyTuple_GET_SIZE(__pyx_t_8)) break;
           #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_11); __Pyx_INCREF(__pyx_t_3); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 351, __pyx_L1_error)
+          __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_11); __Pyx_INCREF(__pyx_t_1); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 351, __pyx_L1_error)
           #else
-          __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_1 = PySequence_ITEM(__pyx_t_8, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_1);
           #endif
         }
       } else {
-        __pyx_t_3 = __pyx_t_12(__pyx_t_8);
-        if (unlikely(!__pyx_t_3)) {
+        __pyx_t_1 = __pyx_t_12(__pyx_t_8);
+        if (unlikely(!__pyx_t_1)) {
           PyObject* exc_type = PyErr_Occurred();
           if (exc_type) {
             if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
@@ -4353,10 +4380,10 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
           }
           break;
         }
-        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_1);
       }
-      __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_3);
-      __pyx_t_3 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_1);
+      __pyx_t_1 = 0;
 
       /* "gensim/models/word2vec_inner.pyx":352
  *             continue  # ignore empty sentences; leave effective_sentences unchanged
@@ -4369,14 +4396,14 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
       if ((__pyx_t_7 != 0)) {
         __pyx_t_13 = PyObject_GetItem(__pyx_v_vlookup, __pyx_v_token); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 352, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_13);
-        __pyx_t_3 = __pyx_t_13;
+        __pyx_t_1 = __pyx_t_13;
         __pyx_t_13 = 0;
       } else {
         __Pyx_INCREF(Py_None);
-        __pyx_t_3 = Py_None;
+        __pyx_t_1 = Py_None;
       }
-      __Pyx_XDECREF_SET(__pyx_v_word, __pyx_t_3);
-      __pyx_t_3 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_word, __pyx_t_1);
+      __pyx_t_1 = 0;
 
       /* "gensim/models/word2vec_inner.pyx":353
  *         for token in sent:
@@ -4420,12 +4447,12 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
         __pyx_t_4 = __pyx_t_7;
         goto __pyx_L15_bool_binop_done;
       }
-      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_word, __pyx_n_s_sample_int); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 355, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_word, __pyx_n_s_sample_int); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 355, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
       __pyx_t_13 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(__pyx_f_6gensim_6models_14word2vec_inner_random_int32((&__pyx_v_next_random))); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 355, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_13);
-      __pyx_t_14 = PyObject_RichCompare(__pyx_t_3, __pyx_t_13, Py_LT); __Pyx_XGOTREF(__pyx_t_14); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 355, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_14 = PyObject_RichCompare(__pyx_t_1, __pyx_t_13, Py_LT); __Pyx_XGOTREF(__pyx_t_14); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 355, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
       __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_14); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 355, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
@@ -4627,7 +4654,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
     __pyx_L8_continue:;
   }
   __pyx_L9_break:;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "gensim/models/word2vec_inner.pyx":376
  * 
@@ -4646,13 +4673,13 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
   __Pyx_GOTREF(__pyx_t_8);
   __pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_effective_words); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 376, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_13);
-  __pyx_t_3 = NULL;
+  __pyx_t_1 = NULL;
   __pyx_t_17 = 0;
   if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
-    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_14);
-    if (likely(__pyx_t_3)) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_14);
+    if (likely(__pyx_t_1)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
-      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_14, function);
       __pyx_t_17 = 1;
@@ -4660,20 +4687,20 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
   }
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_14)) {
-    PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_int_0, __pyx_t_8, __pyx_t_13};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
+    PyObject *__pyx_temp[4] = {__pyx_t_1, __pyx_int_0, __pyx_t_8, __pyx_t_13};
+    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 376, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
     __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
   } else
   #endif
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) {
-    PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_int_0, __pyx_t_8, __pyx_t_13};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
+    PyObject *__pyx_temp[4] = {__pyx_t_1, __pyx_int_0, __pyx_t_8, __pyx_t_13};
+    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 376, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
     __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
   } else
@@ -4681,8 +4708,8 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
   {
     __pyx_t_18 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 376, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_18);
-    if (__pyx_t_3) {
-      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    if (__pyx_t_1) {
+      __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_1); __pyx_t_1 = NULL;
     }
     __Pyx_INCREF(__pyx_int_0);
     __Pyx_GIVEREF(__pyx_int_0);
@@ -4693,42 +4720,42 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
     PyTuple_SET_ITEM(__pyx_t_18, 2+__pyx_t_17, __pyx_t_13);
     __pyx_t_8 = 0;
     __pyx_t_13 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_18, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 376, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
   }
   __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-    __pyx_t_14 = __pyx_t_1; __Pyx_INCREF(__pyx_t_14); __pyx_t_6 = 0;
+  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
+    __pyx_t_14 = __pyx_t_3; __Pyx_INCREF(__pyx_t_14); __pyx_t_6 = 0;
     __pyx_t_10 = NULL;
   } else {
-    __pyx_t_6 = -1; __pyx_t_14 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 376, __pyx_L1_error)
+    __pyx_t_6 = -1; __pyx_t_14 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 376, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_14);
     __pyx_t_10 = Py_TYPE(__pyx_t_14)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 376, __pyx_L1_error)
   }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   for (;;) {
     if (likely(!__pyx_t_10)) {
       if (likely(PyList_CheckExact(__pyx_t_14))) {
         if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_14)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_14, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 376, __pyx_L1_error)
+        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_14, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 376, __pyx_L1_error)
         #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_14, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_14, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 376, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
         #endif
       } else {
         if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_14)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_14, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 376, __pyx_L1_error)
+        __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_14, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 376, __pyx_L1_error)
         #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_14, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_14, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 376, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
         #endif
       }
     } else {
-      __pyx_t_1 = __pyx_t_10(__pyx_t_14);
-      if (unlikely(!__pyx_t_1)) {
+      __pyx_t_3 = __pyx_t_10(__pyx_t_14);
+      if (unlikely(!__pyx_t_3)) {
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
           if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
@@ -4736,10 +4763,10 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_train_batch_sg(CYTHON
         }
         break;
       }
-      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_3);
     }
-    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_1);
-    __pyx_t_1 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3);
+    __pyx_t_3 = 0;
     __pyx_v_i = __pyx_t_2;
     __pyx_t_2 = (__pyx_t_2 + 1);
 
@@ -5234,7 +5261,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  * def train_batch_cbow(model, sentences, alpha, _work, _neu1, compute_loss):
  *     cdef int hs = model.hs             # <<<<<<<<<<<<<<
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_hs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 404, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
@@ -5246,7 +5273,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  * def train_batch_cbow(model, sentences, alpha, _work, _neu1, compute_loss):
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative             # <<<<<<<<<<<<<<
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int cbow_mean = model.cbow_mean
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_negative); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 405, __pyx_L1_error)
@@ -5258,29 +5285,32 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
   /* "gensim/models/word2vec_inner.pyx":406
  *     cdef int hs = model.hs
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)             # <<<<<<<<<<<<<<
+ *     cdef int sample = (model.vocabulary.sample != 0)             # <<<<<<<<<<<<<<
  *     cdef int cbow_mean = model.cbow_mean
  * 
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_sample); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 406, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 406, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 406, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sample); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 406, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 406, __pyx_L1_error)
+  __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 406, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 406, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_sample = __pyx_t_2;
 
   /* "gensim/models/word2vec_inner.pyx":407
  *     cdef int negative = model.negative
- *     cdef int sample = (model.sample != 0)
+ *     cdef int sample = (model.vocabulary.sample != 0)
  *     cdef int cbow_mean = model.cbow_mean             # <<<<<<<<<<<<<<
  * 
  *     cdef int _compute_loss = (1 if compute_loss == True else 0)
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cbow_mean); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 407, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 407, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cbow_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 407, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_cbow_mean = __pyx_t_2;
 
   /* "gensim/models/word2vec_inner.pyx":409
@@ -5290,9 +5320,9 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  *     cdef REAL_t _running_training_loss = model.running_training_loss
  * 
  */
-  __pyx_t_3 = PyObject_RichCompare(__pyx_v_compute_loss, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 409, __pyx_L1_error)
-  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 409, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = PyObject_RichCompare(__pyx_v_compute_loss, Py_True, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 409, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 409, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if (__pyx_t_4) {
     __pyx_t_2 = 1;
   } else {
@@ -5305,48 +5335,51 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  *     cdef int _compute_loss = (1 if compute_loss == True else 0)
  *     cdef REAL_t _running_training_loss = model.running_training_loss             # <<<<<<<<<<<<<<
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_running_training_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 410, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_5 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 410, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_running_training_loss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 410, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_5 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 410, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v__running_training_loss = __pyx_t_5;
 
   /* "gensim/models/word2vec_inner.pyx":412
  *     cdef REAL_t _running_training_loss = model.running_training_loss
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))             # <<<<<<<<<<<<<<
- *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.syn0_lockf))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_lockf))
  *     cdef REAL_t *work
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 412, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 412, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 412, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 412, __pyx_L1_error)
-  __pyx_v_syn0 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 412, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 412, __pyx_L1_error)
+  __pyx_v_syn0 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "gensim/models/word2vec_inner.pyx":413
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
- *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.syn0_lockf))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
+ *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_lockf))             # <<<<<<<<<<<<<<
  *     cdef REAL_t *work
  *     cdef REAL_t _alpha = alpha
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn0_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 413, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 413, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vectors_lockf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 413, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 413, __pyx_L1_error)
   __pyx_v_word_locks = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
   /* "gensim/models/word2vec_inner.pyx":415
- *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.syn0_lockf))
+ *     cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_lockf))
  *     cdef REAL_t *work
  *     cdef REAL_t _alpha = alpha             # <<<<<<<<<<<<<<
- *     cdef int size = model.layer1_size
+ *     cdef int size = model.wv.vector_size
  * 
  */
   __pyx_t_5 = __pyx_PyFloat_AsFloat(__pyx_v_alpha); if (unlikely((__pyx_t_5 == ((npy_float32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 415, __pyx_L1_error)
@@ -5355,14 +5388,17 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
   /* "gensim/models/word2vec_inner.pyx":416
  *     cdef REAL_t *work
  *     cdef REAL_t _alpha = alpha
- *     cdef int size = model.layer1_size             # <<<<<<<<<<<<<<
+ *     cdef int size = model.wv.vector_size             # <<<<<<<<<<<<<<
  * 
  *     cdef int codelens[MAX_SENTENCE_LEN]
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 416, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 416, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 416, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vector_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 416, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 416, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_size = __pyx_t_2;
 
   /* "gensim/models/word2vec_inner.pyx":422
@@ -5372,10 +5408,10 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  * 
  *     cdef int i, j, k
  */
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 422, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 422, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 422, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   __pyx_v_window = __pyx_t_2;
 
   /* "gensim/models/word2vec_inner.pyx":425
@@ -5392,7 +5428,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  *     cdef unsigned long long next_random
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   __pyx_t_4 = (__pyx_v_hs != 0);
@@ -5401,12 +5437,15 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
     /* "gensim/models/word2vec_inner.pyx":441
  * 
  *     if hs:
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))             # <<<<<<<<<<<<<<
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))             # <<<<<<<<<<<<<<
  * 
  *     if negative:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 441, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_syn1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 441, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 441, __pyx_L1_error)
     __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -5415,17 +5454,17 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  *     cdef unsigned long long next_random
  * 
  *     if hs:             # <<<<<<<<<<<<<<
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  */
   }
 
   /* "gensim/models/word2vec_inner.pyx":443
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   __pyx_t_4 = (__pyx_v_negative != 0);
   if (__pyx_t_4) {
@@ -5433,54 +5472,63 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
     /* "gensim/models/word2vec_inner.pyx":444
  * 
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))             # <<<<<<<<<<<<<<
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))             # <<<<<<<<<<<<<<
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 444, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 444, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 444, __pyx_L1_error)
-    __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn1neg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 444, __pyx_L1_error)
+    __pyx_v_syn1neg = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
     /* "gensim/models/word2vec_inner.pyx":445
  *     if negative:
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))             # <<<<<<<<<<<<<<
- *         cum_table_len = len(model.cum_table)
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))             # <<<<<<<<<<<<<<
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 445, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 445, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 445, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 445, __pyx_L1_error)
     __pyx_v_cum_table = ((__pyx_t_5numpy_uint32_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_1)));
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
 
     /* "gensim/models/word2vec_inner.pyx":446
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)             # <<<<<<<<<<<<<<
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)             # <<<<<<<<<<<<<<
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 446, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_vocabulary); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 446, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_6 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 446, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cum_table); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 446, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __pyx_t_6 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 446, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_v_cum_table_len = __pyx_t_6;
 
     /* "gensim/models/word2vec_inner.pyx":443
- *         syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+ *         syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
  * 
  *     if negative:             # <<<<<<<<<<<<<<
- *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
+ *         syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
  */
   }
 
   /* "gensim/models/word2vec_inner.pyx":447
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -5497,42 +5545,42 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
   if (__pyx_t_4) {
 
     /* "gensim/models/word2vec_inner.pyx":448
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  */
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 448, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_randint); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 448, __pyx_L1_error)
+    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 448, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
     __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __pyx_t_3 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 448, __pyx_L1_error)
+    __pyx_t_1 = PyNumber_Multiply(__pyx_int_16777216, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 448, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_randint); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 448, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_random); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_randint); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 448, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 448, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-    __pyx_t_8 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 448, __pyx_L1_error)
+    __pyx_t_8 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 448, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_8);
-    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
     __pyx_t_9 = __Pyx_PyInt_As_unsigned_PY_LONG_LONG(__pyx_t_8); if (unlikely((__pyx_t_9 == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())) __PYX_ERR(0, 448, __pyx_L1_error)
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
     __pyx_v_next_random = __pyx_t_9;
 
     /* "gensim/models/word2vec_inner.pyx":447
- *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
- *         cum_table_len = len(model.cum_table)
+ *         cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:             # <<<<<<<<<<<<<<
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
  * 
@@ -5568,11 +5616,11 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  */
   __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 455, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_8);
-  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_vocab); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 455, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_vocab); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 455, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
-  __pyx_v_vlookup = __pyx_t_1;
-  __pyx_t_1 = 0;
+  __pyx_v_vlookup = __pyx_t_3;
+  __pyx_t_3 = 0;
 
   /* "gensim/models/word2vec_inner.pyx":456
  *     # prepare C structures so we can go "full C" and release the Python GIL
@@ -5591,34 +5639,34 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  *             continue  # ignore empty sentences; leave effective_sentences unchanged
  */
   if (likely(PyList_CheckExact(__pyx_v_sentences)) || PyTuple_CheckExact(__pyx_v_sentences)) {
-    __pyx_t_1 = __pyx_v_sentences; __Pyx_INCREF(__pyx_t_1); __pyx_t_6 = 0;
+    __pyx_t_3 = __pyx_v_sentences; __Pyx_INCREF(__pyx_t_3); __pyx_t_6 = 0;
     __pyx_t_10 = NULL;
   } else {
-    __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_sentences); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 457, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
-    __pyx_t_10 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 457, __pyx_L1_error)
+    __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_sentences); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 457, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_10 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 457, __pyx_L1_error)
   }
   for (;;) {
     if (likely(!__pyx_t_10)) {
-      if (likely(PyList_CheckExact(__pyx_t_1))) {
-        if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_1)) break;
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_3)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_8 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 457, __pyx_L1_error)
+        __pyx_t_8 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 457, __pyx_L1_error)
         #else
-        __pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 457, __pyx_L1_error)
+        __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 457, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_8);
         #endif
       } else {
-        if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+        if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 457, __pyx_L1_error)
+        __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 457, __pyx_L1_error)
         #else
-        __pyx_t_8 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 457, __pyx_L1_error)
+        __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 457, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_8);
         #endif
       }
     } else {
-      __pyx_t_8 = __pyx_t_10(__pyx_t_1);
+      __pyx_t_8 = __pyx_t_10(__pyx_t_3);
       if (unlikely(!__pyx_t_8)) {
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
@@ -5681,23 +5729,23 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
         if (likely(PyList_CheckExact(__pyx_t_8))) {
           if (__pyx_t_11 >= PyList_GET_SIZE(__pyx_t_8)) break;
           #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_3 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_11); __Pyx_INCREF(__pyx_t_3); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 460, __pyx_L1_error)
+          __pyx_t_1 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_11); __Pyx_INCREF(__pyx_t_1); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 460, __pyx_L1_error)
           #else
-          __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 460, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_1 = PySequence_ITEM(__pyx_t_8, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 460, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_1);
           #endif
         } else {
           if (__pyx_t_11 >= PyTuple_GET_SIZE(__pyx_t_8)) break;
           #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-          __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_11); __Pyx_INCREF(__pyx_t_3); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 460, __pyx_L1_error)
+          __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_11); __Pyx_INCREF(__pyx_t_1); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 460, __pyx_L1_error)
           #else
-          __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 460, __pyx_L1_error)
-          __Pyx_GOTREF(__pyx_t_3);
+          __pyx_t_1 = PySequence_ITEM(__pyx_t_8, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 460, __pyx_L1_error)
+          __Pyx_GOTREF(__pyx_t_1);
           #endif
         }
       } else {
-        __pyx_t_3 = __pyx_t_12(__pyx_t_8);
-        if (unlikely(!__pyx_t_3)) {
+        __pyx_t_1 = __pyx_t_12(__pyx_t_8);
+        if (unlikely(!__pyx_t_1)) {
           PyObject* exc_type = PyErr_Occurred();
           if (exc_type) {
             if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
@@ -5705,10 +5753,10 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
           }
           break;
         }
-        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GOTREF(__pyx_t_1);
       }
-      __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_3);
-      __pyx_t_3 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_token, __pyx_t_1);
+      __pyx_t_1 = 0;
 
       /* "gensim/models/word2vec_inner.pyx":461
  *             continue  # ignore empty sentences; leave effective_sentences unchanged
@@ -5721,14 +5769,14 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
       if ((__pyx_t_7 != 0)) {
         __pyx_t_13 = PyObject_GetItem(__pyx_v_vlookup, __pyx_v_token); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 461, __pyx_L1_error)
         __Pyx_GOTREF(__pyx_t_13);
-        __pyx_t_3 = __pyx_t_13;
+        __pyx_t_1 = __pyx_t_13;
         __pyx_t_13 = 0;
       } else {
         __Pyx_INCREF(Py_None);
-        __pyx_t_3 = Py_None;
+        __pyx_t_1 = Py_None;
       }
-      __Pyx_XDECREF_SET(__pyx_v_word, __pyx_t_3);
-      __pyx_t_3 = 0;
+      __Pyx_XDECREF_SET(__pyx_v_word, __pyx_t_1);
+      __pyx_t_1 = 0;
 
       /* "gensim/models/word2vec_inner.pyx":462
  *         for token in sent:
@@ -5772,12 +5820,12 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
         __pyx_t_4 = __pyx_t_7;
         goto __pyx_L15_bool_binop_done;
       }
-      __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_word, __pyx_n_s_sample_int); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 464, __pyx_L1_error)
-      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_word, __pyx_n_s_sample_int); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 464, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
       __pyx_t_13 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(__pyx_f_6gensim_6models_14word2vec_inner_random_int32((&__pyx_v_next_random))); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 464, __pyx_L1_error)
       __Pyx_GOTREF(__pyx_t_13);
-      __pyx_t_14 = PyObject_RichCompare(__pyx_t_3, __pyx_t_13, Py_LT); __Pyx_XGOTREF(__pyx_t_14); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 464, __pyx_L1_error)
-      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_14 = PyObject_RichCompare(__pyx_t_1, __pyx_t_13, Py_LT); __Pyx_XGOTREF(__pyx_t_14); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 464, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
       __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
       __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_14); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 464, __pyx_L1_error)
       __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
@@ -5979,7 +6027,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
     __pyx_L8_continue:;
   }
   __pyx_L9_break:;
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
   /* "gensim/models/word2vec_inner.pyx":485
  * 
@@ -5998,13 +6046,13 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
   __Pyx_GOTREF(__pyx_t_8);
   __pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_effective_words); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 485, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_13);
-  __pyx_t_3 = NULL;
+  __pyx_t_1 = NULL;
   __pyx_t_17 = 0;
   if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
-    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_14);
-    if (likely(__pyx_t_3)) {
+    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_14);
+    if (likely(__pyx_t_1)) {
       PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
-      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_1);
       __Pyx_INCREF(function);
       __Pyx_DECREF_SET(__pyx_t_14, function);
       __pyx_t_17 = 1;
@@ -6012,20 +6060,20 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
   }
   #if CYTHON_FAST_PYCALL
   if (PyFunction_Check(__pyx_t_14)) {
-    PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_int_0, __pyx_t_8, __pyx_t_13};
-    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 485, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
+    PyObject *__pyx_temp[4] = {__pyx_t_1, __pyx_int_0, __pyx_t_8, __pyx_t_13};
+    __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
     __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
   } else
   #endif
   #if CYTHON_FAST_PYCCALL
   if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) {
-    PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_int_0, __pyx_t_8, __pyx_t_13};
-    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 485, __pyx_L1_error)
-    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
-    __Pyx_GOTREF(__pyx_t_1);
+    PyObject *__pyx_temp[4] = {__pyx_t_1, __pyx_int_0, __pyx_t_8, __pyx_t_13};
+    __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_17, 3+__pyx_t_17); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
     __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
   } else
@@ -6033,8 +6081,8 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
   {
     __pyx_t_18 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 485, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_18);
-    if (__pyx_t_3) {
-      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_3); __pyx_t_3 = NULL;
+    if (__pyx_t_1) {
+      __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_1); __pyx_t_1 = NULL;
     }
     __Pyx_INCREF(__pyx_int_0);
     __Pyx_GIVEREF(__pyx_int_0);
@@ -6045,42 +6093,42 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
     PyTuple_SET_ITEM(__pyx_t_18, 2+__pyx_t_17, __pyx_t_13);
     __pyx_t_8 = 0;
     __pyx_t_13 = 0;
-    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 485, __pyx_L1_error)
-    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_18, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
     __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
   }
   __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
-  if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
-    __pyx_t_14 = __pyx_t_1; __Pyx_INCREF(__pyx_t_14); __pyx_t_6 = 0;
+  if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
+    __pyx_t_14 = __pyx_t_3; __Pyx_INCREF(__pyx_t_14); __pyx_t_6 = 0;
     __pyx_t_10 = NULL;
   } else {
-    __pyx_t_6 = -1; __pyx_t_14 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 485, __pyx_L1_error)
+    __pyx_t_6 = -1; __pyx_t_14 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 485, __pyx_L1_error)
     __Pyx_GOTREF(__pyx_t_14);
     __pyx_t_10 = Py_TYPE(__pyx_t_14)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 485, __pyx_L1_error)
   }
-  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
   for (;;) {
     if (likely(!__pyx_t_10)) {
       if (likely(PyList_CheckExact(__pyx_t_14))) {
         if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_14)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyList_GET_ITEM(__pyx_t_14, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 485, __pyx_L1_error)
+        __pyx_t_3 = PyList_GET_ITEM(__pyx_t_14, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 485, __pyx_L1_error)
         #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_14, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 485, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_14, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
         #endif
       } else {
         if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_14)) break;
         #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
-        __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_14, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 485, __pyx_L1_error)
+        __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_14, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 485, __pyx_L1_error)
         #else
-        __pyx_t_1 = PySequence_ITEM(__pyx_t_14, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 485, __pyx_L1_error)
-        __Pyx_GOTREF(__pyx_t_1);
+        __pyx_t_3 = PySequence_ITEM(__pyx_t_14, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
         #endif
       }
     } else {
-      __pyx_t_1 = __pyx_t_10(__pyx_t_14);
-      if (unlikely(!__pyx_t_1)) {
+      __pyx_t_3 = __pyx_t_10(__pyx_t_14);
+      if (unlikely(!__pyx_t_3)) {
         PyObject* exc_type = PyErr_Occurred();
         if (exc_type) {
           if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
@@ -6088,10 +6136,10 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
         }
         break;
       }
-      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_GOTREF(__pyx_t_3);
     }
-    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_1);
-    __pyx_t_1 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3);
+    __pyx_t_3 = 0;
     __pyx_v_i = __pyx_t_2;
     __pyx_t_2 = (__pyx_t_2 + 1);
 
@@ -6380,7 +6428,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_2train_batch_cbow(CYT
  * # Score is only implemented for hierarchical softmax
  * def score_sentence_sg(model, sentence, _work):             # <<<<<<<<<<<<<<
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
  */
 
 /* Python wrapper */
@@ -6489,13 +6537,13 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_4score_sentence_sg(CY
   /* "gensim/models/word2vec_inner.pyx":512
  * def score_sentence_sg(model, sentence, _work):
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))             # <<<<<<<<<<<<<<
  *     cdef REAL_t *work
- *     cdef int size = model.layer1_size
+ *     cdef int size = model.wv.vector_size
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 512, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 512, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 512, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 512, __pyx_L1_error)
@@ -6503,16 +6551,19 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_4score_sentence_sg(CY
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
 
   /* "gensim/models/word2vec_inner.pyx":514
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
  *     cdef REAL_t *work
- *     cdef int size = model.layer1_size             # <<<<<<<<<<<<<<
+ *     cdef int size = model.wv.vector_size             # <<<<<<<<<<<<<<
  * 
  *     cdef int codelens[MAX_SENTENCE_LEN]
  */
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 514, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 514, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 514, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_vector_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 514, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 514, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_size = __pyx_t_3;
 
   /* "gensim/models/word2vec_inner.pyx":519
@@ -6522,10 +6573,10 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_4score_sentence_sg(CY
  * 
  *     cdef int i, j, k
  */
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 519, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_2);
-  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 519, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_window = __pyx_t_3;
 
   /* "gensim/models/word2vec_inner.pyx":522
@@ -6540,12 +6591,15 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_4score_sentence_sg(CY
   /* "gensim/models/word2vec_inner.pyx":528
  *     cdef np.uint8_t *codes[MAX_SENTENCE_LEN]
  * 
- *     syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))             # <<<<<<<<<<<<<<
+ *     syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))             # <<<<<<<<<<<<<<
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  */
-  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 528, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 528, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 528, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 528, __pyx_L1_error)
   __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_2)));
   __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -7035,7 +7089,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_4score_sentence_sg(CY
  * # Score is only implemented for hierarchical softmax
  * def score_sentence_sg(model, sentence, _work):             # <<<<<<<<<<<<<<
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
  */
 
   /* function exit code */
@@ -7323,7 +7377,7 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_6score_sentence_cbow(
  * 
  *     cdef int cbow_mean = model.cbow_mean             # <<<<<<<<<<<<<<
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_cbow_mean); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 590, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
@@ -7334,13 +7388,13 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_6score_sentence_cbow(
   /* "gensim/models/word2vec_inner.pyx":592
  *     cdef int cbow_mean = model.cbow_mean
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))             # <<<<<<<<<<<<<<
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))             # <<<<<<<<<<<<<<
  *     cdef REAL_t *work
  *     cdef REAL_t *neu1
  */
   __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 592, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 592, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_vectors); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 592, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 592, __pyx_L1_error)
@@ -7350,14 +7404,17 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_6score_sentence_cbow(
   /* "gensim/models/word2vec_inner.pyx":595
  *     cdef REAL_t *work
  *     cdef REAL_t *neu1
- *     cdef int size = model.layer1_size             # <<<<<<<<<<<<<<
+ *     cdef int size = model.wv.vector_size             # <<<<<<<<<<<<<<
  * 
  *     cdef int codelens[MAX_SENTENCE_LEN]
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_layer1_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_wv); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 595, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_vector_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 595, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 595, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_size = __pyx_t_2;
 
   /* "gensim/models/word2vec_inner.pyx":600
@@ -7367,10 +7424,10 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_6score_sentence_cbow(
  * 
  *     cdef int i, j, k
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error)
-  __Pyx_GOTREF(__pyx_t_3);
-  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 600, __pyx_L1_error)
-  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_window); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 600, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 600, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_window = __pyx_t_2;
 
   /* "gensim/models/word2vec_inner.pyx":603
@@ -7385,12 +7442,15 @@ static PyObject *__pyx_pf_6gensim_6models_14word2vec_inner_6score_sentence_cbow(
   /* "gensim/models/word2vec_inner.pyx":610
  *     cdef np.uint8_t *codes[MAX_SENTENCE_LEN]
  * 
- *     syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))             # <<<<<<<<<<<<<<
+ *     syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))             # <<<<<<<<<<<<<<
  * 
  *     # convert Python structures to primitive types, so we can release the GIL
  */
-  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_syn1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_model, __pyx_n_s_trainables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 610, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_syn1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 610, __pyx_L1_error)
   __pyx_v_syn1 = ((__pyx_t_6gensim_6models_14word2vec_inner_REAL_t *)PyArray_DATA(((PyArrayObject *)__pyx_t_3)));
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -10999,7 +11059,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_item, __pyx_k_item, sizeof(__pyx_k_item), 0, 0, 1, 1},
   {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1},
   {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1},
-  {&__pyx_n_s_layer1_size, __pyx_k_layer1_size, sizeof(__pyx_k_layer1_size), 0, 0, 1, 1},
   {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
   {&__pyx_n_s_model, __pyx_k_model, sizeof(__pyx_k_model), 0, 0, 1, 1},
   {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
@@ -11043,16 +11102,20 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
   {&__pyx_n_s_snrm2, __pyx_k_snrm2, sizeof(__pyx_k_snrm2), 0, 0, 1, 1},
   {&__pyx_n_s_sscal, __pyx_k_sscal, sizeof(__pyx_k_sscal), 0, 0, 1, 1},
   {&__pyx_n_s_syn0, __pyx_k_syn0, sizeof(__pyx_k_syn0), 0, 0, 1, 1},
-  {&__pyx_n_s_syn0_lockf, __pyx_k_syn0_lockf, sizeof(__pyx_k_syn0_lockf), 0, 0, 1, 1},
   {&__pyx_n_s_syn1, __pyx_k_syn1, sizeof(__pyx_k_syn1), 0, 0, 1, 1},
   {&__pyx_n_s_syn1neg, __pyx_k_syn1neg, sizeof(__pyx_k_syn1neg), 0, 0, 1, 1},
   {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
   {&__pyx_n_s_token, __pyx_k_token, sizeof(__pyx_k_token), 0, 0, 1, 1},
   {&__pyx_n_s_train_batch_cbow, __pyx_k_train_batch_cbow, sizeof(__pyx_k_train_batch_cbow), 0, 0, 1, 1},
   {&__pyx_n_s_train_batch_sg, __pyx_k_train_batch_sg, sizeof(__pyx_k_train_batch_sg), 0, 0, 1, 1},
+  {&__pyx_n_s_trainables, __pyx_k_trainables, sizeof(__pyx_k_trainables), 0, 0, 1, 1},
   {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
+  {&__pyx_n_s_vector_size, __pyx_k_vector_size, sizeof(__pyx_k_vector_size), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors, __pyx_k_vectors, sizeof(__pyx_k_vectors), 0, 0, 1, 1},
+  {&__pyx_n_s_vectors_lockf, __pyx_k_vectors_lockf, sizeof(__pyx_k_vectors_lockf), 0, 0, 1, 1},
   {&__pyx_n_s_vlookup, __pyx_k_vlookup, sizeof(__pyx_k_vlookup), 0, 0, 1, 1},
   {&__pyx_n_s_vocab, __pyx_k_vocab, sizeof(__pyx_k_vocab), 0, 0, 1, 1},
+  {&__pyx_n_s_vocabulary, __pyx_k_vocabulary, sizeof(__pyx_k_vocabulary), 0, 0, 1, 1},
   {&__pyx_n_s_window, __pyx_k_window, sizeof(__pyx_k_window), 0, 0, 1, 1},
   {&__pyx_n_s_word, __pyx_k_word, sizeof(__pyx_k_word), 0, 0, 1, 1},
   {&__pyx_n_s_word_locks, __pyx_k_word_locks, sizeof(__pyx_k_word_locks), 0, 0, 1, 1},
@@ -11079,7 +11142,7 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
 
   /* "gensim/models/word2vec_inner.pyx":340
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
@@ -11093,7 +11156,7 @@ static int __Pyx_InitCachedConstants(void) {
   __Pyx_GIVEREF(__pyx_tuple__2);
 
   /* "gensim/models/word2vec_inner.pyx":448
- *         cum_table_len = len(model.cum_table)
+ *         cum_table_len = len(model.vocabulary.cum_table)
  *     if negative or sample:
  *         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)             # <<<<<<<<<<<<<<
  * 
@@ -11232,7 +11295,7 @@ static int __Pyx_InitCachedConstants(void) {
  * # Score is only implemented for hierarchical softmax
  * def score_sentence_sg(model, sentence, _work):             # <<<<<<<<<<<<<<
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
  */
   __pyx_tuple__19 = PyTuple_Pack(20, __pyx_n_s_model, __pyx_n_s_sentence, __pyx_n_s_work, __pyx_n_s_syn0, __pyx_n_s_work_2, __pyx_n_s_size, __pyx_n_s_codelens, __pyx_n_s_indexes, __pyx_n_s_sentence_len, __pyx_n_s_window, __pyx_n_s_i, __pyx_n_s_j, __pyx_n_s_k, __pyx_n_s_result, __pyx_n_s_syn1, __pyx_n_s_points, __pyx_n_s_codes, __pyx_n_s_vlookup, __pyx_n_s_token, __pyx_n_s_word); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 510, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__19);
@@ -11706,7 +11769,7 @@ PyMODINIT_FUNC PyInit_word2vec_inner(void)
  * # Score is only implemented for hierarchical softmax
  * def score_sentence_sg(model, sentence, _work):             # <<<<<<<<<<<<<<
  * 
- *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+ *     cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
  */
   __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_6gensim_6models_14word2vec_inner_5score_sentence_sg, NULL, __pyx_n_s_gensim_models_word2vec_inner); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 510, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
diff --git a/gensim/models/word2vec_inner.pyx b/gensim/models/word2vec_inner.pyx
index fe988fc24c..98e719c6d4 100755
--- a/gensim/models/word2vec_inner.pyx
+++ b/gensim/models/word2vec_inner.pyx
@@ -296,16 +296,16 @@ cdef unsigned long long fast_sentence_cbow_neg(
 def train_batch_sg(model, sentences, alpha, _work, compute_loss):
     cdef int hs = model.hs
     cdef int negative = model.negative
-    cdef int sample = (model.sample != 0)
+    cdef int sample = (model.vocabulary.sample != 0)
 
     cdef int _compute_loss = (1 if compute_loss == True else 0)
     cdef REAL_t _running_training_loss = model.running_training_loss
 
-    cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
-    cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.syn0_lockf))
+    cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
+    cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_lockf))
     cdef REAL_t *work
     cdef REAL_t _alpha = alpha
-    cdef int size = model.layer1_size
+    cdef int size = model.wv.vector_size
 
     cdef int codelens[MAX_SENTENCE_LEN]
     cdef np.uint32_t indexes[MAX_SENTENCE_LEN]
@@ -330,12 +330,12 @@ def train_batch_sg(model, sentences, alpha, _work, compute_loss):
     cdef unsigned long long next_random
 
     if hs:
-        syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+        syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
 
     if negative:
-        syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
-        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
-        cum_table_len = len(model.cum_table)
+        syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+        cum_table_len = len(model.vocabulary.cum_table)
     if negative or sample:
         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
 
@@ -403,17 +403,17 @@ def train_batch_sg(model, sentences, alpha, _work, compute_loss):
 def train_batch_cbow(model, sentences, alpha, _work, _neu1, compute_loss):
     cdef int hs = model.hs
     cdef int negative = model.negative
-    cdef int sample = (model.sample != 0)
+    cdef int sample = (model.vocabulary.sample != 0)
     cdef int cbow_mean = model.cbow_mean
 
     cdef int _compute_loss = (1 if compute_loss == True else 0)
     cdef REAL_t _running_training_loss = model.running_training_loss
 
-    cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
-    cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.syn0_lockf))
+    cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
+    cdef REAL_t *word_locks = <REAL_t *>(np.PyArray_DATA(model.trainables.vectors_lockf))
     cdef REAL_t *work
     cdef REAL_t _alpha = alpha
-    cdef int size = model.layer1_size
+    cdef int size = model.wv.vector_size
 
     cdef int codelens[MAX_SENTENCE_LEN]
     cdef np.uint32_t indexes[MAX_SENTENCE_LEN]
@@ -438,12 +438,12 @@ def train_batch_cbow(model, sentences, alpha, _work, _neu1, compute_loss):
     cdef unsigned long long next_random
 
     if hs:
-        syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+        syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
 
     if negative:
-        syn1neg = <REAL_t *>(np.PyArray_DATA(model.syn1neg))
-        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.cum_table))
-        cum_table_len = len(model.cum_table)
+        syn1neg = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1neg))
+        cum_table = <np.uint32_t *>(np.PyArray_DATA(model.vocabulary.cum_table))
+        cum_table_len = len(model.vocabulary.cum_table)
     if negative or sample:
         next_random = (2**24) * model.random.randint(0, 2**24) + model.random.randint(0, 2**24)
 
@@ -509,9 +509,9 @@ def train_batch_cbow(model, sentences, alpha, _work, _neu1, compute_loss):
 # Score is only implemented for hierarchical softmax
 def score_sentence_sg(model, sentence, _work):
 
-    cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+    cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
     cdef REAL_t *work
-    cdef int size = model.layer1_size
+    cdef int size = model.wv.vector_size
 
     cdef int codelens[MAX_SENTENCE_LEN]
     cdef np.uint32_t indexes[MAX_SENTENCE_LEN]
@@ -525,7 +525,7 @@ def score_sentence_sg(model, sentence, _work):
     cdef np.uint32_t *points[MAX_SENTENCE_LEN]
     cdef np.uint8_t *codes[MAX_SENTENCE_LEN]
 
-    syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+    syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
 
     # convert Python structures to primitive types, so we can release the GIL
     work = <REAL_t *>np.PyArray_DATA(_work)
@@ -589,10 +589,10 @@ def score_sentence_cbow(model, sentence, _work, _neu1):
 
     cdef int cbow_mean = model.cbow_mean
 
-    cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.syn0))
+    cdef REAL_t *syn0 = <REAL_t *>(np.PyArray_DATA(model.wv.vectors))
     cdef REAL_t *work
     cdef REAL_t *neu1
-    cdef int size = model.layer1_size
+    cdef int size = model.wv.vector_size
 
     cdef int codelens[MAX_SENTENCE_LEN]
     cdef np.uint32_t indexes[MAX_SENTENCE_LEN]
@@ -607,7 +607,7 @@ def score_sentence_cbow(model, sentence, _work, _neu1):
     cdef np.uint32_t *points[MAX_SENTENCE_LEN]
     cdef np.uint8_t *codes[MAX_SENTENCE_LEN]
 
-    syn1 = <REAL_t *>(np.PyArray_DATA(model.syn1))
+    syn1 = <REAL_t *>(np.PyArray_DATA(model.trainables.syn1))
 
     # convert Python structures to primitive types, so we can release the GIL
     work = <REAL_t *>np.PyArray_DATA(_work)
diff --git a/gensim/models/wrappers/fasttext.py b/gensim/models/wrappers/fasttext.py
index 8e7a966cee..3f7b65c21b 100644
--- a/gensim/models/wrappers/fasttext.py
+++ b/gensim/models/wrappers/fasttext.py
@@ -10,7 +10,7 @@
 Warnings
 --------
 .. deprecated:: 3.2.0
-   Use :class:`gensim.models.fasttext.FastText` instead of :class:`gensim.models.wrappers.fasttext.FastText`.
+   Use :mod:`gensim.models.fasttext` instead.
 
 
 
@@ -34,424 +34,5 @@
 
 
 """
-
-
-import logging
-import tempfile
-import os
-import struct
-
-import numpy as np
-from numpy import float32 as REAL, sqrt, newaxis
-from gensim import utils
-from gensim.models.keyedvectors import KeyedVectors, Vocab
-from gensim.models.word2vec import Word2Vec
-
-logger = logging.getLogger(__name__)
-
-try:
-    FileNotFoundError
-except NameError:
-    FileNotFoundError = IOError
-
-FASTTEXT_FILEFORMAT_MAGIC = 793712314
-
-
-class FastTextKeyedVectors(KeyedVectors):
-    """
-    Class to contain vectors, vocab and ngrams for the FastText training class and other methods not directly
-    involved in training such as most_similar().
-    Subclasses KeyedVectors to implement oov lookups, storing ngrams and other FastText specific methods
-
-    """
-
-    def __init__(self):
-        super(FastTextKeyedVectors, self).__init__()
-        self.syn0_vocab = None
-        self.syn0_vocab_norm = None
-        self.syn0_ngrams = None
-        self.syn0_ngrams_norm = None
-        self.ngrams = {}
-        self.hash2index = {}
-        self.ngrams_word = {}
-        self.min_n = 0
-        self.max_n = 0
-
-    def save(self, *args, **kwargs):
-        # don't bother storing the cached normalized vectors
-        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm', 'syn0_vocab_norm', 'syn0_ngrams_norm'])
-        super(FastTextKeyedVectors, self).save(*args, **kwargs)
-
-    def word_vec(self, word, use_norm=False):
-        """
-        Accept a single word as input.
-        Returns the word's representations in vector space, as a 1D numpy array.
-
-        The word can be out-of-vocabulary as long as ngrams for the word are present.
-        For words with all ngrams absent, a KeyError is raised.
-
-        Example::
-
-          >>> trained_model['office']
-          array([ -1.40128313e-02, ...])
-
-        """
-        if word in self.vocab:
-            return super(FastTextKeyedVectors, self).word_vec(word, use_norm)
-        else:
-            word_vec = np.zeros(self.syn0_ngrams.shape[1], dtype=np.float32)
-            ngrams = compute_ngrams(word, self.min_n, self.max_n)
-            ngrams = [ng for ng in ngrams if ng in self.ngrams]
-            if use_norm:
-                ngram_weights = self.syn0_ngrams_norm
-            else:
-                ngram_weights = self.syn0_ngrams
-            for ngram in ngrams:
-                word_vec += ngram_weights[self.ngrams[ngram]]
-            if word_vec.any():
-                return word_vec / len(ngrams)
-            else:  # No ngrams of the word are present in self.ngrams
-                raise KeyError('all ngrams for word %s absent from model' % word)
-
-    def init_sims(self, 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 only call `most_similar`, `similarity` etc.
-
-        """
-        super(FastTextKeyedVectors, self).init_sims(replace)
-        if getattr(self, 'syn0_ngrams_norm', None) is None or replace:
-            logger.info("precomputing L2-norms of ngram weight vectors")
-            if replace:
-                for i in range(self.syn0_ngrams.shape[0]):
-                    self.syn0_ngrams[i, :] /= sqrt((self.syn0_ngrams[i, :] ** 2).sum(-1))
-                self.syn0_ngrams_norm = self.syn0_ngrams
-            else:
-                self.syn0_ngrams_norm = \
-                    (self.syn0_ngrams / sqrt((self.syn0_ngrams ** 2).sum(-1))[..., newaxis]).astype(REAL)
-
-    def __contains__(self, word):
-        """
-        Check if `word` or any character ngrams in `word` are present in the vocabulary.
-        A vector for the word is guaranteed to exist if `__contains__` returns True.
-        """
-        if word in self.vocab:
-            return True
-        else:
-            char_ngrams = compute_ngrams(word, self.min_n, self.max_n)
-            return any(ng in self.ngrams for ng in char_ngrams)
-
-    @classmethod
-    def load_word2vec_format(cls, *args, **kwargs):
-        """Not suppported. Use gensim.models.KeyedVectors.load_word2vec_format instead."""
-        raise NotImplementedError("Not supported. Use gensim.models.KeyedVectors.load_word2vec_format instead.")
-
-
-class FastText(Word2Vec):
-    """
-    Class for word vector training using FastText. Communication between FastText and Python
-    takes place by working with data files on disk and calling the FastText binary with
-    subprocess.call().
-    Implements functionality similar to [fasttext.py](https://github.com/salestock/fastText.py),
-    improving speed and scope of functionality like `most_similar`, `similarity` by extracting vectors
-    into numpy matrix.
-
-    Warnings
-    --------
-    .. deprecated:: 3.2.0
-       Use :class:`gensim.models.fasttext.FastText` instead of :class:`gensim.models.wrappers.fasttext.FastText`.
-
-
-    """
-
-    def initialize_word_vectors(self):
-        self.wv = FastTextKeyedVectors()
-
-    @classmethod
-    def train(cls, ft_path, corpus_file, output_file=None, model='cbow', size=100, alpha=0.025, window=5, min_count=5,
-              word_ngrams=1, loss='ns', sample=1e-3, negative=5, iter=5, min_n=3, max_n=6, sorted_vocab=1, threads=12):
-        """
-        `ft_path` is the path to the FastText executable, e.g. `/home/kofola/fastText/fasttext`.
-
-        `corpus_file` is the filename of the text file to be used for training the FastText model.
-        Expects file to contain utf-8 encoded text.
-
-        `model` defines the training algorithm. By default, cbow is used. Accepted values are
-        'cbow', 'skipgram'.
-
-        `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.
-
-        `min_count` = ignore all words with total occurrences lower than this.
-
-        `word_ngram` = max length of word ngram
-
-        `loss` = defines training objective. Allowed values are `hs` (hierarchical softmax),
-        `ns` (negative sampling) and `softmax`. Defaults to `ns`
-
-        `sample` = threshold for configuring which higher-frequency words are randomly downsampled;
-            default is 1e-3, useful range is (0, 1e-5).
-
-        `negative` = the value for negative specifies how many "noise words" should be drawn
-        (usually between 5-20). Default is 5. If set to 0, no negative samping is used.
-        Only relevant when `loss` is set to `ns`
-
-        `iter` = number of iterations (epochs) over the corpus. Default is 5.
-
-        `min_n` = min length of char ngrams to be used for training word representations. Default is 3.
-
-        `max_n` = max length of char ngrams to be used for training word representations. Set `max_n` to be
-        lesser than `min_n` to avoid char ngrams being used. Default is 6.
-
-        `sorted_vocab` = if 1 (default), sort the vocabulary by descending frequency before
-        assigning word indexes.
-
-        `threads` = number of threads to use. Default is 12.
-
-        """
-        ft_path = ft_path
-        output_file = output_file or os.path.join(tempfile.gettempdir(), 'ft_model')
-        ft_args = {
-            'input': corpus_file,
-            'output': output_file,
-            'lr': alpha,
-            'dim': size,
-            'ws': window,
-            'epoch': iter,
-            'minCount': min_count,
-            'wordNgrams': word_ngrams,
-            'neg': negative,
-            'loss': loss,
-            'minn': min_n,
-            'maxn': max_n,
-            'thread': threads,
-            't': sample
-        }
-        cmd = [ft_path, model]
-        for option, value in ft_args.items():
-            cmd.append("-%s" % option)
-            cmd.append(str(value))
-
-        utils.check_output(args=cmd)
-        model = cls.load_fasttext_format(output_file)
-        cls.delete_training_files(output_file)
-        return model
-
-    def save(self, *args, **kwargs):
-        # don't bother storing the cached normalized vectors
-        kwargs['ignore'] = kwargs.get('ignore', ['syn0norm', 'syn0_vocab_norm', 'syn0_ngrams_norm'])
-        super(FastText, self).save(*args, **kwargs)
-
-    @classmethod
-    def load_fasttext_format(cls, model_file, encoding='utf8'):
-        """
-        Load the input-hidden weight matrix from the fast text output files.
-
-        Note that due to limitations in the FastText API, you cannot continue training
-        with a model loaded this way, though you can query for word similarity etc.
-
-        `model_file` is the path to the FastText output files.
-        FastText outputs two model files - `/path/to/model.vec` and `/path/to/model.bin`
-
-        Expected value for this example: `/path/to/model` or `/path/to/model.bin`,
-        as gensim requires only `.bin` file to load entire fastText model.
-
-        """
-        model = cls()
-        if not model_file.endswith('.bin'):
-            model_file += '.bin'
-        model.file_name = model_file
-        model.load_binary_data(encoding=encoding)
-        return model
-
-    @classmethod
-    def load(cls, *args, **kwargs):
-        model = super(FastText, cls).load(*args, **kwargs)
-        if hasattr(model.wv, 'syn0_all'):
-            setattr(model.wv, 'syn0_ngrams', model.wv.syn0_all)
-            delattr(model.wv, 'syn0_all')
-        return model
-
-    @classmethod
-    def delete_training_files(cls, model_file):
-        """Deletes the files created by FastText training"""
-        try:
-            os.remove('%s.vec' % model_file)
-            os.remove('%s.bin' % model_file)
-        except FileNotFoundError:
-            logger.debug('Training files %s not found when attempting to delete', model_file)
-            pass
-
-    def load_binary_data(self, encoding='utf8'):
-        """Loads data from the output binary file created by FastText training"""
-        with utils.smart_open(self.file_name, 'rb') as f:
-            self.load_model_params(f)
-            self.load_dict(f, encoding=encoding)
-            self.load_vectors(f)
-
-    def load_model_params(self, file_handle):
-        magic, version = self.struct_unpack(file_handle, '@2i')
-        if magic == FASTTEXT_FILEFORMAT_MAGIC:  # newer format
-            self.new_format = True
-            dim, ws, epoch, min_count, neg, _, loss, model, bucket, minn, maxn, _, t = \
-                self.struct_unpack(file_handle, '@12i1d')
-        else:  # older format
-            self.new_format = False
-            dim = magic
-            ws = version
-            epoch, min_count, neg, _, loss, model, bucket, minn, maxn, _, t = self.struct_unpack(file_handle, '@10i1d')
-        # Parameters stored by [Args::save](https://github.com/facebookresearch/fastText/blob/master/src/args.cc)
-        self.vector_size = dim
-        self.window = ws
-        self.iter = epoch
-        self.min_count = min_count
-        self.negative = neg
-        self.hs = loss == 1
-        self.sg = model == 2
-        self.bucket = bucket
-        self.wv.min_n = minn
-        self.wv.max_n = maxn
-        self.sample = t
-
-    def load_dict(self, file_handle, encoding='utf8'):
-        vocab_size, nwords, nlabels = self.struct_unpack(file_handle, '@3i')
-        # Vocab stored by [Dictionary::save](https://github.com/facebookresearch/fastText/blob/master/src/dictionary.cc)
-        if nlabels > 0:
-            raise NotImplementedError("Supervised fastText models are not supported")
-        logger.info("loading %s words for fastText model from %s", vocab_size, self.file_name)
-
-        self.struct_unpack(file_handle, '@1q')  # number of tokens
-        if self.new_format:
-            pruneidx_size, = self.struct_unpack(file_handle, '@q')
-        for i in range(vocab_size):
-            word_bytes = b''
-            char_byte = file_handle.read(1)
-            # Read vocab word
-            while char_byte != b'\x00':
-                word_bytes += char_byte
-                char_byte = file_handle.read(1)
-            word = word_bytes.decode(encoding)
-            count, _ = self.struct_unpack(file_handle, '@qb')
-
-            self.wv.vocab[word] = Vocab(index=i, count=count)
-            self.wv.index2word.append(word)
-
-        assert len(self.wv.vocab) == nwords, (
-            'mismatch between final vocab size ({} words), '
-            'and expected number of words ({} words)'.format(len(self.wv.vocab), nwords))
-        if len(self.wv.vocab) != vocab_size:
-            # expecting to log this warning only for pretrained french vector, wiki.fr
-            logger.warning(
-                "mismatch between final vocab size (%s words), and expected vocab size (%s words)",
-                len(self.wv.vocab), vocab_size
-            )
-
-        if self.new_format:
-            for j in range(pruneidx_size):
-                self.struct_unpack(file_handle, '@2i')
-
-    def load_vectors(self, file_handle):
-        if self.new_format:
-            self.struct_unpack(file_handle, '@?')  # bool quant_input in fasttext.cc
-        num_vectors, dim = self.struct_unpack(file_handle, '@2q')
-        # Vectors stored by [Matrix::save](https://github.com/facebookresearch/fastText/blob/master/src/matrix.cc)
-        assert self.vector_size == dim, (
-            'mismatch between vector size in model params ({}) and model vectors ({})'
-            .format(self.vector_size, dim)
-        )
-        float_size = struct.calcsize('@f')
-        if float_size == 4:
-            dtype = np.dtype(np.float32)
-        elif float_size == 8:
-            dtype = np.dtype(np.float64)
-
-        self.num_original_vectors = num_vectors
-        self.wv.syn0_ngrams = np.fromfile(file_handle, dtype=dtype, count=num_vectors * dim)
-        self.wv.syn0_ngrams = self.wv.syn0_ngrams.reshape((num_vectors, dim))
-        assert self.wv.syn0_ngrams.shape == (self.bucket + len(self.wv.vocab), self.vector_size), \
-            'mismatch between actual weight matrix shape {} and expected shape {}'\
-            .format(
-                self.wv.syn0_ngrams.shape, (self.bucket + len(self.wv.vocab), self.vector_size)
-            )
-
-        self.init_ngrams()
-
-    def struct_unpack(self, file_handle, fmt):
-        num_bytes = struct.calcsize(fmt)
-        return struct.unpack(fmt, file_handle.read(num_bytes))
-
-    def init_ngrams(self):
-        """
-        Computes ngrams of all words present in vocabulary and stores vectors for only those ngrams.
-        Vectors for other ngrams are initialized with a random uniform distribution in FastText. These
-        vectors are discarded here to save space.
-
-        """
-        self.wv.ngrams = {}
-        all_ngrams = []
-        self.wv.syn0 = np.zeros((len(self.wv.vocab), self.vector_size), dtype=REAL)
-
-        for w, vocab in self.wv.vocab.items():
-            all_ngrams += compute_ngrams(w, self.wv.min_n, self.wv.max_n)
-            self.wv.syn0[vocab.index] += np.array(self.wv.syn0_ngrams[vocab.index])
-
-        all_ngrams = set(all_ngrams)
-        self.num_ngram_vectors = len(all_ngrams)
-        ngram_indices = []
-        for i, ngram in enumerate(all_ngrams):
-            ngram_hash = ft_hash(ngram)
-            ngram_indices.append(len(self.wv.vocab) + ngram_hash % self.bucket)
-            self.wv.ngrams[ngram] = i
-        self.wv.syn0_ngrams = self.wv.syn0_ngrams.take(ngram_indices, axis=0)
-
-        ngram_weights = self.wv.syn0_ngrams
-
-        logger.info(
-            "loading weights for %s words for fastText model from %s",
-            len(self.wv.vocab), self.file_name
-        )
-
-        for w, vocab in self.wv.vocab.items():
-            word_ngrams = compute_ngrams(w, self.wv.min_n, self.wv.max_n)
-            for word_ngram in word_ngrams:
-                self.wv.syn0[vocab.index] += np.array(ngram_weights[self.wv.ngrams[word_ngram]])
-
-            self.wv.syn0[vocab.index] /= (len(word_ngrams) + 1)
-        logger.info(
-            "loaded %s weight matrix for fastText model from %s",
-            self.wv.syn0.shape, self.file_name
-        )
-
-
-def compute_ngrams(word, min_n, max_n):
-    BOW, EOW = ('<', '>')  # Used by FastText to attach to all words as prefix and suffix
-    extended_word = BOW + word + EOW
-    ngrams = []
-    for ngram_length in range(min_n, min(len(extended_word), max_n) + 1):
-        for i in range(0, len(extended_word) - ngram_length + 1):
-            ngrams.append(extended_word[i:i + ngram_length])
-    return ngrams
-
-
-def ft_hash(string):
-    """
-    Reproduces [hash method](https://github.com/facebookresearch/fastText/blob/master/src/dictionary.cc)
-    used in fastText.
-
-    """
-    # Runtime warnings for integer overflow are raised, this is expected behaviour. These warnings are suppressed.
-    old_settings = np.seterr(all='ignore')
-    h = np.uint32(2166136261)
-    for c in string:
-        h = h ^ np.uint32(ord(c))
-        h = h * np.uint32(16777619)
-    np.seterr(**old_settings)
-    return h
+from gensim.models.deprecated.fasttext_wrapper import FastText, FastTextKeyedVectors  # noqa:F401
+from gensim.models.deprecated.fasttext_wrapper import ft_hash, compute_ngrams  # noqa:F401
diff --git a/gensim/scripts/segment_wiki.py b/gensim/scripts/segment_wiki.py
old mode 100755
new mode 100644
index b43d9d4a30..98b99e91d8
--- a/gensim/scripts/segment_wiki.py
+++ b/gensim/scripts/segment_wiki.py
@@ -1,323 +1,377 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Author: Jayant Jain <jayant@rare-technologies.com>
-# Copyright (C) 2016 RaRe Technologies
-
-"""
-CLI script for extracting plain text out of a raw Wikipedia dump. Input is an xml.bz2 file provided by MediaWiki \
-that looks like <LANG>wiki-<YYYYMMDD>-pages-articles.xml.bz2 or <LANG>wiki-latest-pages-articles.xml.bz2 \
-(e.g. 14 GB of https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-pages-articles.xml.bz2).
-
-It streams through all the XML articles using multiple cores (#cores - 1, by default), \
-decompressing on the fly and extracting plain text from the articles and their sections.
-
-For each extracted article, it prints its title, section names and plain text section contents, in json-line format.
-
-Examples
---------
-
-  python -m gensim.scripts.segment_wiki -h
-
-  python -m gensim.scripts.segment_wiki -f enwiki-latest-pages-articles.xml.bz2 -o enwiki-latest.json.gz
-
-Processing the entire English Wikipedia dump takes 1.7 hours (about 3 million articles per hour, \
-or 10 MB of XML per second) on an 8 core Intel i7-7700 @3.60GHz.
-
-You can then read the created output (~6.1 GB gzipped) with:
-
->>> # iterate over the plain text data we just created
->>> for line in smart_open('enwiki-latest.json.gz'):
->>>    # decode each JSON line into a Python dictionary object
->>>    article = json.loads(line)
->>>
->>>    # each article has a "title" and a list of "section_titles" and "section_texts".
->>>    print("Article title: %s" % article['title'])
->>>    for section_title, section_text in zip(article['section_titles'], article['section_texts']):
->>>        print("Section title: %s" % section_title)
->>>        print("Section text: %s" % section_text)
-"""
-
-import argparse
-import json
-import logging
-import multiprocessing
-import re
-import sys
-from xml.etree import cElementTree
-
-from gensim.corpora.wikicorpus import IGNORED_NAMESPACES, WikiCorpus, filter_wiki, get_namespace, utils
-from smart_open import smart_open
-
-
-logger = logging.getLogger(__name__)
-
-
-def segment_all_articles(file_path, min_article_character=200, workers=None):
-    """Extract article titles and sections from a MediaWiki bz2 database dump.
-
-    Parameters
-    ----------
-    file_path : str
-        Path to MediaWiki dump, typical filename is <LANG>wiki-<YYYYMMDD>-pages-articles.xml.bz2
-        or <LANG>wiki-latest-pages-articles.xml.bz2.
-
-    min_article_character : int, optional
-        Minimal number of character for article (except titles and leading gaps).
-
-    workers: int or None
-        Number of parallel workers, max(1, multiprocessing.cpu_count() - 1) if None.
-
-    Yields
-    ------
-    (str, list of (str, str))
-        Structure contains (title, [(section_heading, section_content), ...]).
-
-    """
-    with smart_open(file_path, 'rb') as xml_fileobj:
-        wiki_sections_corpus = _WikiSectionsCorpus(
-            xml_fileobj, min_article_character=min_article_character, processes=workers)
-        wiki_sections_corpus.metadata = True
-        wiki_sections_text = wiki_sections_corpus.get_texts_with_sections()
-        for article_title, article_sections in wiki_sections_text:
-            yield article_title, article_sections
-
-
-def segment_and_write_all_articles(file_path, output_file, min_article_character=200, workers=None):
-    """Write article title and sections to `output_file` (or stdout, if output_file is None).
-
-    The output format is one article per line, in json-line format with 3 fields::
-
-        'title' - title of article,
-        'section_titles' - list of titles of sections,
-        'section_texts' - list of content from sections.
-
-    Parameters
-    ----------
-    file_path : str
-        Path to MediaWiki dump, typical filename is <LANG>wiki-<YYYYMMDD>-pages-articles.xml.bz2
-        or <LANG>wiki-latest-pages-articles.xml.bz2.
-
-    output_file : str or None
-        Path to output file in json-lines format, or None for printing to stdout.
-
-    min_article_character : int, optional
-        Minimal number of character for article (except titles and leading gaps).
-
-    workers: int or None
-        Number of parallel workers, max(1, multiprocessing.cpu_count() - 1) if None.
-
-    """
-    if output_file is None:
-        outfile = getattr(sys.stdout, 'buffer', sys.stdout)  # we want write bytes, so for py3 we used 'buffer'
-    else:
-        outfile = smart_open(output_file, 'wb')
-
-    try:
-        article_stream = segment_all_articles(file_path, min_article_character, workers=workers)
-        for idx, (article_title, article_sections) in enumerate(article_stream):
-            output_data = {"title": article_title, "section_titles": [], "section_texts": []}
-            for section_heading, section_content in article_sections:
-                output_data["section_titles"].append(section_heading)
-                output_data["section_texts"].append(section_content)
-            if (idx + 1) % 100000 == 0:
-                logger.info("processed #%d articles (at %r now)", idx + 1, article_title)
-            outfile.write((json.dumps(output_data) + "\n").encode('utf-8'))
-    finally:
-        if output_file is not None:
-            outfile.close()
-
-
-def extract_page_xmls(f):
-    """Extract pages from a MediaWiki database dump.
-
-    Parameters
-    ----------
-    f : file
-        File descriptor of MediaWiki dump.
-
-    Yields
-    ------
-    str
-        XML strings for page tags.
-
-    """
-    elems = (elem for _, elem in cElementTree.iterparse(f, events=("end",)))
-
-    elem = next(elems)
-    namespace = get_namespace(elem.tag)
-    ns_mapping = {"ns": namespace}
-    page_tag = "{%(ns)s}page" % ns_mapping
-
-    for elem in elems:
-        if elem.tag == page_tag:
-            yield cElementTree.tostring(elem)
-            # Prune the element tree, as per
-            # http://www.ibm.com/developerworks/xml/library/x-hiperfparse/
-            # except that we don't need to prune backlinks from the parent
-            # because we don't use LXML.
-            # We do this only for <page>s, since we need to inspect the
-            # ./revision/text element. The pages comprise the bulk of the
-            # file, so in practice we prune away enough.
-            elem.clear()
-
-
-def segment(page_xml):
-    """Parse the content inside a page tag
-
-    Parameters
-    ----------
-    page_xml : str
-        Content from page tag.
-
-    Returns
-    -------
-    (str, list of (str, str))
-        Structure contains (title, [(section_heading, section_content)]).
-
-    """
-    elem = cElementTree.fromstring(page_xml)
-    filter_namespaces = ('0',)
-    namespace = get_namespace(elem.tag)
-    ns_mapping = {"ns": namespace}
-    text_path = "./{%(ns)s}revision/{%(ns)s}text" % ns_mapping
-    title_path = "./{%(ns)s}title" % ns_mapping
-    ns_path = "./{%(ns)s}ns" % ns_mapping
-    lead_section_heading = "Introduction"
-    top_level_heading_regex = r"\n==[^=].*[^=]==\n"
-    top_level_heading_regex_capture = r"\n==([^=].*[^=])==\n"
-
-    title = elem.find(title_path).text
-    text = elem.find(text_path).text
-    ns = elem.find(ns_path).text
-    if ns not in filter_namespaces:
-        text = None
-
-    if text is not None:
-        section_contents = re.split(top_level_heading_regex, text)
-        section_headings = [lead_section_heading] + re.findall(top_level_heading_regex_capture, text)
-        assert len(section_contents) == len(section_headings)
-    else:
-        section_contents = []
-        section_headings = []
-
-    section_contents = [filter_wiki(section_content) for section_content in section_contents]
-    sections = list(zip(section_headings, section_contents))
-    return title, sections
-
-
-class _WikiSectionsCorpus(WikiCorpus):
-    """Treat a wikipedia articles dump (<LANG>wiki-<YYYYMMDD>-pages-articles.xml.bz2
-    or <LANG>wiki-latest-pages-articles.xml.bz2) as a (read-only) corpus.
-
-    The documents are extracted on-the-fly, so that the whole (massive) dump can stay compressed on disk.
-
-    """
-    def __init__(self, fileobj, min_article_character=200, processes=None,
-                 lemmatize=utils.has_pattern(), filter_namespaces=('0',)):
-        """
-        Parameters
-        ----------
-        fileobj : file
-            File descriptor of MediaWiki dump.
-        min_article_character : int, optional
-            Minimal number of character for article (except titles and leading gaps).
-        processes : int, optional
-            Number of processes, max(1, multiprocessing.cpu_count() - 1) if None.
-        lemmatize : bool, optional
-            If `pattern` package is installed, use fancier shallow parsing to get token lemmas.
-            Otherwise, use simple regexp tokenization.
-        filter_namespaces : tuple of int, optional
-            Enumeration of namespaces that will be ignored.
-
-        """
-        self.fileobj = fileobj
-        self.filter_namespaces = filter_namespaces
-        self.metadata = False
-        if processes is None:
-            processes = max(1, multiprocessing.cpu_count() - 1)
-        self.processes = processes
-        self.lemmatize = lemmatize
-        self.min_article_character = min_article_character
-
-    def get_texts_with_sections(self):
-        """Iterate over the dump, returning titles and text versions of all sections of articles.
-
-        Notes
-        -----
-        Only articles of sufficient length are returned (short articles & redirects
-        etc are ignored).
-
-        Note that this iterates over the **texts**; if you want vectors, just use
-        the standard corpus interface instead of this function::
-
-        >>> for vec in wiki_corpus:
-        >>>     print(vec)
-
-        Yields
-        ------
-        (str, list of (str, str))
-            Structure contains (title, [(section_heading, section_content), ...]).
-
-        """
-        skipped_namespace, skipped_length, skipped_redirect = 0, 0, 0
-        total_articles, total_sections = 0, 0
-        page_xmls = extract_page_xmls(self.fileobj)
-        pool = multiprocessing.Pool(self.processes)
-        # process the corpus in smaller chunks of docs, because multiprocessing.Pool
-        # is dumb and would load the entire input into RAM at once...
-        for group in utils.chunkize(page_xmls, chunksize=10 * self.processes, maxsize=1):
-            for article_title, sections in pool.imap(segment, group):  # chunksize=10):
-                # article redirects are pruned here
-                if any(article_title.startswith(ignore + ':') for ignore in IGNORED_NAMESPACES):  # filter non-articles
-                    skipped_namespace += 1
-                    continue
-                if not sections or sections[0][1].lstrip().lower().startswith("#redirect"):  # filter redirect
-                    skipped_redirect += 1
-                    continue
-                if sum(len(body.strip()) for (_, body) in sections) < self.min_article_character:
-                    # filter stubs (incomplete, very short articles)
-                    skipped_length += 1
-                    continue
-
-                total_articles += 1
-                total_sections += len(sections)
-                yield (article_title, sections)
-        logger.info(
-            "finished processing %i articles with %i sections (skipped %i redirects, %i stubs, %i ignored namespaces)",
-            total_articles, total_sections, skipped_redirect, skipped_length, skipped_namespace)
-        pool.terminate()
-        self.length = total_articles  # cache corpus length
-
-
-if __name__ == "__main__":
-    logging.basicConfig(format='%(asctime)s : %(processName)s : %(levelname)s : %(message)s', level=logging.INFO)
-    logger.info("running %s", " ".join(sys.argv))
-
-    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter, description=globals()['__doc__'])
-    default_workers = max(1, multiprocessing.cpu_count() - 1)
-    parser.add_argument('-f', '--file', help='Path to MediaWiki database dump (read-only).', required=True)
-    parser.add_argument(
-        '-o', '--output',
-        help='Path to output file (stdout if not specified). If ends in .gz or .bz2, '
-             'the output file will be automatically compressed (recommended!).')
-    parser.add_argument(
-        '-w', '--workers',
-        help='Number of parallel workers for multi-core systems. Default: %(default)s.',
-        type=int,
-        default=default_workers
-    )
-    parser.add_argument(
-        '-m', '--min-article-character',
-        help="Ignore articles with fewer characters than this (article stubs). Default: %(default)s.",
-        default=200
-    )
-    args = parser.parse_args()
-
-    segment_and_write_all_articles(
-        args.file, args.output,
-        min_article_character=args.min_article_character,
-        workers=args.workers
-    )
-
-    logger.info("finished running %s", sys.argv[0])
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Author: Jayant Jain <jayant@rare-technologies.com>
+# Copyright (C) 2016 RaRe Technologies
+
+"""
+CLI script for extracting plain text out of a raw Wikipedia dump. Input is an xml.bz2 file provided by MediaWiki \
+that looks like <LANG>wiki-<YYYYMMDD>-pages-articles.xml.bz2 or <LANG>wiki-latest-pages-articles.xml.bz2 \
+(e.g. 14 GB of https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-pages-articles.xml.bz2).
+
+It streams through all the XML articles using multiple cores (#cores - 1, by default), \
+decompressing on the fly and extracting plain text from the articles and their sections.
+
+For each extracted article, it prints its title, section names and plain text section contents, in json-line format.
+
+Examples
+--------
+
+  python -m gensim.scripts.segment_wiki -h
+
+  python -m gensim.scripts.segment_wiki -f enwiki-latest-pages-articles.xml.bz2 -o enwiki-latest.json.gz
+
+Processing the entire English Wikipedia dump takes 1.7 hours (about 3 million articles per hour, \
+or 10 MB of XML per second) on an 8 core Intel i7-7700 @3.60GHz.
+
+You can then read the created output (~6.1 GB gzipped) with:
+
+>>> # iterate over the plain text data we just created
+>>> for line in smart_open('enwiki-latest.json.gz'):
+>>>    # decode each JSON line into a Python dictionary object
+>>>    article = json.loads(line)
+>>>
+>>>    # each article has a "title", a mapping of interlinks and a list of "section_titles" and "section_texts".
+>>>    print("Article title: %s" % article['title'])
+>>>    print("Interlinks: %s" + article['interlinks'])
+>>>    for section_title, section_text in zip(article['section_titles'], article['section_texts']):
+>>>        print("Section title: %s" % section_title)
+>>>        print("Section text: %s" % section_text)
+"""
+
+import argparse
+import json
+import logging
+import multiprocessing
+import re
+import sys
+from xml.etree import cElementTree
+from functools import partial
+
+from gensim.corpora.wikicorpus import IGNORED_NAMESPACES, WikiCorpus, filter_wiki, find_interlinks, get_namespace, utils
+from smart_open import smart_open
+
+logger = logging.getLogger(__name__)
+
+
+def segment_all_articles(file_path, min_article_character=200, workers=None, include_interlinks=False):
+    """Extract article titles and sections from a MediaWiki bz2 database dump.
+
+    Parameters
+    ----------
+    file_path : str
+        Path to MediaWiki dump, typical filename is <LANG>wiki-<YYYYMMDD>-pages-articles.xml.bz2
+        or <LANG>wiki-latest-pages-articles.xml.bz2.
+
+    min_article_character : int, optional
+        Minimal number of character for article (except titles and leading gaps).
+
+    workers: int or None
+        Number of parallel workers, max(1, multiprocessing.cpu_count() - 1) if None.
+
+    include_interlinks: bool
+        Whether or not interlinks should be included in the output
+
+    Yields
+    ------
+    (str, list of (str, str), (Optionally) dict of str: str)
+        Structure contains (title, [(section_heading, section_content), ...], (Optionally) {interlinks}).
+
+    """
+    with smart_open(file_path, 'rb') as xml_fileobj:
+        wiki_sections_corpus = _WikiSectionsCorpus(
+            xml_fileobj, min_article_character=min_article_character, processes=workers,
+            include_interlinks=include_interlinks)
+        wiki_sections_corpus.metadata = True
+        wiki_sections_text = wiki_sections_corpus.get_texts_with_sections()
+
+        for article in wiki_sections_text:
+            yield article
+
+
+def segment_and_write_all_articles(file_path, output_file, min_article_character=200, workers=None,
+                                   include_interlinks=False):
+    """Write article title and sections to `output_file` (or stdout, if output_file is None).
+
+    The output format is one article per line, in json-line format with 4 fields::
+
+        'title' - title of article,
+        'section_titles' - list of titles of sections,
+        'section_texts' - list of content from sections,
+        (Optional) 'section_interlinks' - list of interlinks in the article.
+
+    Parameters
+    ----------
+    file_path : str
+        Path to MediaWiki dump, typical filename is <LANG>wiki-<YYYYMMDD>-pages-articles.xml.bz2
+        or <LANG>wiki-latest-pages-articles.xml.bz2.
+
+    output_file : str or None
+        Path to output file in json-lines format, or None for printing to stdout.
+
+    min_article_character : int, optional
+        Minimal number of character for article (except titles and leading gaps).
+
+    workers: int or None
+        Number of parallel workers, max(1, multiprocessing.cpu_count() - 1) if None.
+
+    include_interlinks: bool
+        Whether or not interlinks should be included in the output
+    """
+    if output_file is None:
+        outfile = getattr(sys.stdout, 'buffer', sys.stdout)  # we want write bytes, so for py3 we used 'buffer'
+    else:
+        outfile = smart_open(output_file, 'wb')
+
+    try:
+        article_stream = segment_all_articles(file_path, min_article_character, workers=workers,
+                                              include_interlinks=include_interlinks)
+        for idx, article in enumerate(article_stream):
+            article_title, article_sections = article[0], article[1]
+            if include_interlinks:
+                interlinks = article[2]
+
+            output_data = {
+                "title": article_title,
+                "section_titles": [],
+                "section_texts": [],
+            }
+            if include_interlinks:
+                output_data["interlinks"] = interlinks
+
+            for section_heading, section_content in article_sections:
+                output_data["section_titles"].append(section_heading)
+                output_data["section_texts"].append(section_content)
+
+            if (idx + 1) % 100000 == 0:
+                logger.info("processed #%d articles (at %r now)", idx + 1, article_title)
+            outfile.write((json.dumps(output_data) + "\n").encode('utf-8'))
+
+    finally:
+        if output_file is not None:
+            outfile.close()
+
+
+def extract_page_xmls(f):
+    """Extract pages from a MediaWiki database dump.
+
+    Parameters
+    ----------
+    f : file
+        File descriptor of MediaWiki dump.
+
+    Yields
+    ------
+    str
+        XML strings for page tags.
+
+    """
+    elems = (elem for _, elem in cElementTree.iterparse(f, events=("end",)))
+
+    elem = next(elems)
+    namespace = get_namespace(elem.tag)
+    ns_mapping = {"ns": namespace}
+    page_tag = "{%(ns)s}page" % ns_mapping
+
+    for elem in elems:
+        if elem.tag == page_tag:
+            yield cElementTree.tostring(elem)
+            # Prune the element tree, as per
+            # http://www.ibm.com/developerworks/xml/library/x-hiperfparse/
+            # except that we don't need to prune backlinks from the parent
+            # because we don't use LXML.
+            # We do this only for <page>s, since we need to inspect the
+            # ./revision/text element. The pages comprise the bulk of the
+            # file, so in practice we prune away enough.
+            elem.clear()
+
+
+def segment(page_xml, include_interlinks=False):
+    """Parse the content inside a page tag
+
+    Parameters
+    ----------
+    page_xml : str
+        Content from page tag.
+
+    include_interlinks : bool
+        Whether or not interlinks should be parsed.
+
+    Returns
+    -------
+    (str, list of (str, str), (Optionally) dict of (str: str))
+        Structure contains (title, [(section_heading, section_content), ...], (Optionally) {interlinks}).
+
+    """
+    elem = cElementTree.fromstring(page_xml)
+    filter_namespaces = ('0',)
+    namespace = get_namespace(elem.tag)
+    ns_mapping = {"ns": namespace}
+    text_path = "./{%(ns)s}revision/{%(ns)s}text" % ns_mapping
+    title_path = "./{%(ns)s}title" % ns_mapping
+    ns_path = "./{%(ns)s}ns" % ns_mapping
+    lead_section_heading = "Introduction"
+    top_level_heading_regex = r"\n==[^=].*[^=]==\n"
+    top_level_heading_regex_capture = r"\n==([^=].*[^=])==\n"
+
+    title = elem.find(title_path).text
+    text = elem.find(text_path).text
+    ns = elem.find(ns_path).text
+    if ns not in filter_namespaces:
+        text = None
+
+    if text is not None:
+        if include_interlinks:
+            interlinks = find_interlinks(text)
+        section_contents = re.split(top_level_heading_regex, text)
+        section_headings = [lead_section_heading] + re.findall(top_level_heading_regex_capture, text)
+        section_headings = [heading.strip() for heading in section_headings]
+        assert len(section_contents) == len(section_headings)
+    else:
+        interlinks = []
+        section_contents = []
+        section_headings = []
+
+    section_contents = [filter_wiki(section_content) for section_content in section_contents]
+    sections = list(zip(section_headings, section_contents))
+
+    if include_interlinks:
+        return title, sections, interlinks
+    else:
+        return title, sections
+
+
+class _WikiSectionsCorpus(WikiCorpus):
+    """Treat a wikipedia articles dump (<LANG>wiki-<YYYYMMDD>-pages-articles.xml.bz2
+    or <LANG>wiki-latest-pages-articles.xml.bz2) as a (read-only) corpus.
+
+    The documents are extracted on-the-fly, so that the whole (massive) dump can stay compressed on disk.
+
+    """
+
+    def __init__(self, fileobj, min_article_character=200, processes=None,
+                 lemmatize=utils.has_pattern(), filter_namespaces=('0',), include_interlinks=False):
+        """
+        Parameters
+        ----------
+        fileobj : file
+            File descriptor of MediaWiki dump.
+        min_article_character : int, optional
+            Minimal number of character for article (except titles and leading gaps).
+        processes : int, optional
+            Number of processes, max(1, multiprocessing.cpu_count() - 1) if None.
+        lemmatize : bool, optional
+            If `pattern` package is installed, use fancier shallow parsing to get token lemmas.
+            Otherwise, use simple regexp tokenization.
+        filter_namespaces : tuple of int, optional
+            Enumeration of namespaces that will be ignored.
+        include_interlinks: bool
+            Whether or not interlinks should be included in the output
+
+        """
+        self.fileobj = fileobj
+        self.filter_namespaces = filter_namespaces
+        self.metadata = False
+        if processes is None:
+            processes = max(1, multiprocessing.cpu_count() - 1)
+        self.processes = processes
+        self.lemmatize = lemmatize
+        self.min_article_character = min_article_character
+        self.include_interlinks = include_interlinks
+
+    def get_texts_with_sections(self):
+        """Iterate over the dump, returning titles and text versions of all sections of articles.
+
+        Notes
+        -----
+        Only articles of sufficient length are returned (short articles & redirects
+        etc are ignored).
+
+        Note that this iterates over the **texts**; if you want vectors, just use
+        the standard corpus interface instead of this function::
+
+        >>> for vec in wiki_corpus:
+        >>>     print(vec)
+
+        Yields
+        ------
+        (str, list of (str, str), dict of (str: str))
+            Structure contains (title, [(section_heading, section_content), ...], (Optionally){interlinks}).
+
+        """
+        skipped_namespace, skipped_length, skipped_redirect = 0, 0, 0
+        total_articles, total_sections = 0, 0
+        page_xmls = extract_page_xmls(self.fileobj)
+        pool = multiprocessing.Pool(self.processes)
+        # process the corpus in smaller chunks of docs, because multiprocessing.Pool
+        # is dumb and would load the entire input into RAM at once...
+        for group in utils.chunkize(page_xmls, chunksize=10 * self.processes, maxsize=1):
+            for article in pool.imap(partial(segment, include_interlinks=self.include_interlinks),
+                                     group):  # chunksize=10): partial(merge_names, b='Sons')
+                article_title, sections = article[0], article[1]
+
+                # article redirects are pruned here
+                if any(article_title.startswith(ignore + ':') for ignore in IGNORED_NAMESPACES):  # filter non-articles
+                    skipped_namespace += 1
+                    continue
+                if not sections or sections[0][1].lstrip().lower().startswith("#redirect"):  # filter redirect
+                    skipped_redirect += 1
+                    continue
+                if sum(len(body.strip()) for (_, body) in sections) < self.min_article_character:
+                    # filter stubs (incomplete, very short articles)
+                    skipped_length += 1
+                    continue
+                total_articles += 1
+                total_sections += len(sections)
+
+                if self.include_interlinks:
+                    interlinks = article[2]
+                    yield (article_title, sections, interlinks)
+                else:
+                    yield (article_title, sections)
+
+        logger.info(
+            "finished processing %i articles with %i sections (skipped %i redirects, %i stubs, %i ignored namespaces)",
+            total_articles, total_sections, skipped_redirect, skipped_length, skipped_namespace)
+        pool.terminate()
+        self.length = total_articles  # cache corpus length
+
+
+if __name__ == "__main__":
+    logging.basicConfig(format='%(asctime)s : %(processName)s : %(levelname)s : %(message)s', level=logging.INFO)
+    logger.info("running %s", " ".join(sys.argv))
+
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter, description=globals()['__doc__'])
+    default_workers = max(1, multiprocessing.cpu_count() - 1)
+    parser.add_argument('-f', '--file', help='Path to MediaWiki database dump (read-only).', required=True)
+    parser.add_argument(
+        '-o', '--output',
+        help='Path to output file (stdout if not specified). If ends in .gz or .bz2, '
+             'the output file will be automatically compressed (recommended!).')
+    parser.add_argument(
+        '-w', '--workers',
+        help='Number of parallel workers for multi-core systems. Default: %(default)s.',
+        type=int,
+        default=default_workers
+    )
+    parser.add_argument(
+        '-m', '--min-article-character',
+        help="Ignore articles with fewer characters than this (article stubs). Default: %(default)s.",
+        default=200
+    )
+    parser.add_argument(
+        '-i', '--include-interlinks',
+        help='Include a mapping for interlinks to other articles in the dump. The mappings format is: '
+             '"interlinks": {"article_title_1": "interlink_text_1", "article_title_2": "interlink_text_2", ...}',
+        action='store_true'
+    )
+    args = parser.parse_args()
+
+    segment_and_write_all_articles(
+        args.file, args.output,
+        min_article_character=args.min_article_character,
+        workers=args.workers,
+        include_interlinks=args.include_interlinks
+    )
+
+    logger.info("finished running %s", sys.argv[0])
diff --git a/gensim/similarities/index.py b/gensim/similarities/index.py
index 10a79dc8b7..f0b1ebc6de 100644
--- a/gensim/similarities/index.py
+++ b/gensim/similarities/index.py
@@ -8,7 +8,8 @@
 Intro
 -----
 This module contains integration Annoy with :class:`~gensim.models.word2vec.Word2Vec`,
-:class:`~gensim.models.doc2vec.Doc2Vec` and :class:`~gensim.models.keyedvectors.KeyedVectors`.
+:class:`~gensim.models.doc2vec.Doc2Vec`, :class:`~gensim.models.fasttext.FastText` and
+:class:`~gensim.models.keyedvectors.KeyedVectors`.
 
 
 What is Annoy
@@ -40,7 +41,9 @@
 
 from gensim.models.doc2vec import Doc2Vec
 from gensim.models.word2vec import Word2Vec
-from gensim.models.keyedvectors import KeyedVectors
+from gensim.models.fasttext import FastText
+from gensim.models import KeyedVectors
+from gensim.models.keyedvectors import WordEmbeddingsKeyedVectors
 try:
     from annoy import AnnoyIndex
 except ImportError:
@@ -50,17 +53,17 @@
 
 
 class AnnoyIndexer(object):
-    """This class allows to use `Annoy <https://github.com/spotify/annoy>`_ as indexer for ``most_similar`` method
-    from :class:`~gensim.models.word2vec.Word2Vec`, :class:`~gensim.models.doc2vec.Doc2Vec`
-    and :class:`~gensim.models.keyedvectors.KeyedVectors` classes.
+    """This class allows to use `Annoy <https://github.com/spotify/annoy>`_ as indexer for `most_similar` method
+    from :class:`~gensim.models.word2vec.Word2Vec`, :class:`~gensim.models.doc2vec.Doc2Vec`,
+    :class:`~gensim.models.fasttext.FastText` and :class:`~gensim.models.keyedvectors.Word2VecKeyedVectors` classes.
+
     """
 
     def __init__(self, model=None, num_trees=None):
         """
         Parameters
         ----------
-        model : :class:`~gensim.models.word2vec.Word2Vec`, :class:`~gensim.models.doc2vec.Doc2Vec` or
-                :class:`~gensim.models.keyedvectors.KeyedVectors`, optional
+        model : :class:`~gensim.models.base_any2vec.BaseWordEmbeddingsModel`, optional
             Model, that will be used as source for index.
         num_trees : int, optional
             Number of trees for Annoy indexer.
@@ -86,12 +89,12 @@ def __init__(self, model=None, num_trees=None):
         if model and num_trees:
             if isinstance(self.model, Doc2Vec):
                 self.build_from_doc2vec()
-            elif isinstance(self.model, Word2Vec):
+            elif isinstance(self.model, (Word2Vec, FastText)):
                 self.build_from_word2vec()
-            elif isinstance(self.model, KeyedVectors):
+            elif isinstance(self.model, (WordEmbeddingsKeyedVectors, KeyedVectors)):
                 self.build_from_keyedvectors()
             else:
-                raise ValueError("Only a Word2Vec, Doc2Vec or KeyedVectors instance can be used")
+                raise ValueError("Only a Word2Vec, Doc2Vec, FastText or KeyedVectors instance can be used")
 
     def save(self, fname, protocol=2):
         """Save AnnoyIndexer instance.
@@ -157,7 +160,7 @@ def build_from_word2vec(self):
         """Build an Annoy index using word vectors from a Word2Vec model."""
 
         self.model.init_sims()
-        return self._build_from_model(self.model.wv.syn0norm, self.model.wv.index2word, self.model.vector_size)
+        return self._build_from_model(self.model.wv.vectors_norm, self.model.wv.index2word, self.model.vector_size)
 
     def build_from_doc2vec(self):
         """Build an Annoy index using document vectors from a Doc2Vec model."""
@@ -165,7 +168,7 @@ def build_from_doc2vec(self):
         docvecs = self.model.docvecs
         docvecs.init_sims()
         labels = [docvecs.index_to_doctag(i) for i in range(0, docvecs.count)]
-        return self._build_from_model(docvecs.doctag_syn0norm, labels, self.model.vector_size)
+        return self._build_from_model(docvecs.vectors_docs_norm, labels, self.model.vector_size)
 
     def build_from_keyedvectors(self):
         """Build an Annoy index using word vectors from a KeyedVectors model."""
diff --git a/gensim/test/test_data/doc2vec_old b/gensim/test/test_data/doc2vec_old
new file mode 100644
index 0000000000..a03c0593a7
Binary files /dev/null and b/gensim/test/test_data/doc2vec_old differ
diff --git a/gensim/test/test_data/doc2vec_old_sep b/gensim/test/test_data/doc2vec_old_sep
new file mode 100644
index 0000000000..a1381ddc59
Binary files /dev/null and b/gensim/test/test_data/doc2vec_old_sep differ
diff --git a/gensim/test/test_data/doc2vec_old_sep.syn0_lockf.npy b/gensim/test/test_data/doc2vec_old_sep.syn0_lockf.npy
new file mode 100644
index 0000000000..40b2d588f7
Binary files /dev/null and b/gensim/test/test_data/doc2vec_old_sep.syn0_lockf.npy differ
diff --git a/gensim/test/test_data/doc2vec_old_sep.syn1neg.npy b/gensim/test/test_data/doc2vec_old_sep.syn1neg.npy
new file mode 100644
index 0000000000..6964841793
Binary files /dev/null and b/gensim/test/test_data/doc2vec_old_sep.syn1neg.npy differ
diff --git a/gensim/test/test_data/fasttext_old b/gensim/test/test_data/fasttext_old
new file mode 100644
index 0000000000..d646e49698
Binary files /dev/null and b/gensim/test/test_data/fasttext_old differ
diff --git a/gensim/test/test_data/fasttext_old_sep b/gensim/test/test_data/fasttext_old_sep
new file mode 100644
index 0000000000..5b9ab911a0
Binary files /dev/null and b/gensim/test/test_data/fasttext_old_sep differ
diff --git a/gensim/test/test_data/fasttext_old_sep.syn0_lockf.npy b/gensim/test/test_data/fasttext_old_sep.syn0_lockf.npy
new file mode 100644
index 0000000000..9705e44ce1
Binary files /dev/null and b/gensim/test/test_data/fasttext_old_sep.syn0_lockf.npy differ
diff --git a/gensim/test/test_data/fasttext_old_sep.syn1neg.npy b/gensim/test/test_data/fasttext_old_sep.syn1neg.npy
new file mode 100644
index 0000000000..cfc8a39de0
Binary files /dev/null and b/gensim/test/test_data/fasttext_old_sep.syn1neg.npy differ
diff --git a/gensim/test/test_data/word2vec_old b/gensim/test/test_data/word2vec_old
new file mode 100644
index 0000000000..d73b279eb0
Binary files /dev/null and b/gensim/test/test_data/word2vec_old differ
diff --git a/gensim/test/test_data/word2vec_old_sep b/gensim/test/test_data/word2vec_old_sep
new file mode 100644
index 0000000000..f82b05c428
Binary files /dev/null and b/gensim/test/test_data/word2vec_old_sep differ
diff --git a/gensim/test/test_data/word2vec_old_sep.syn0_lockf.npy b/gensim/test/test_data/word2vec_old_sep.syn0_lockf.npy
new file mode 100644
index 0000000000..9705e44ce1
Binary files /dev/null and b/gensim/test/test_data/word2vec_old_sep.syn0_lockf.npy differ
diff --git a/gensim/test/test_data/word2vec_old_sep.syn1neg.npy b/gensim/test/test_data/word2vec_old_sep.syn1neg.npy
new file mode 100644
index 0000000000..6157ae5e36
Binary files /dev/null and b/gensim/test/test_data/word2vec_old_sep.syn1neg.npy differ
diff --git a/gensim/test/test_doc2vec.py b/gensim/test/test_doc2vec.py
index 0499dd2210..20b9f3e083 100644
--- a/gensim/test/test_doc2vec.py
+++ b/gensim/test/test_doc2vec.py
@@ -86,6 +86,38 @@ def testPersistenceWord2VecFormat(self):
         binary_model_dv = keyedvectors.KeyedVectors.load_word2vec_format(test_word, binary=True)
         self.assertEqual(len(model.wv.vocab), len(binary_model_dv.vocab))
 
+    def testLoadOldModel(self):
+        """Test loading doc2vec models from previous version"""
+
+        model_file = 'doc2vec_old'
+        model = doc2vec.Doc2Vec.load(datapath(model_file))
+        self.assertTrue(model.wv.vectors.shape == (3955, 100))
+        self.assertTrue(len(model.wv.vocab) == 3955)
+        self.assertTrue(len(model.wv.index2word) == 3955)
+        self.assertTrue(model.syn1neg.shape == (len(model.wv.vocab), model.vector_size))
+        self.assertTrue(model.trainables.vectors_lockf.shape == (3955, ))
+        self.assertTrue(model.vocabulary.cum_table.shape == (3955, ))
+
+        self.assertTrue(model.docvecs.vectors_docs.shape == (300, 100))
+        self.assertTrue(model.trainables.vectors_docs_lockf.shape == (300, ))
+        self.assertTrue(model.docvecs.max_rawint == 299)
+        self.assertTrue(model.docvecs.count == 300)
+
+        # Model stored in multiple files
+        model_file = 'doc2vec_old_sep'
+        model = doc2vec.Doc2Vec.load(datapath(model_file))
+        self.assertTrue(model.wv.vectors.shape == (3955, 100))
+        self.assertTrue(len(model.wv.vocab) == 3955)
+        self.assertTrue(len(model.wv.index2word) == 3955)
+        self.assertTrue(model.syn1neg.shape == (len(model.wv.vocab), model.vector_size))
+        self.assertTrue(model.trainables.vectors_lockf.shape == (3955, ))
+        self.assertTrue(model.vocabulary.cum_table.shape == (3955, ))
+
+        self.assertTrue(model.docvecs.vectors_docs.shape == (300, 100))
+        self.assertTrue(model.trainables.vectors_docs_lockf.shape == (300, ))
+        self.assertTrue(model.docvecs.max_rawint == 299)
+        self.assertTrue(model.docvecs.count == 300)
+
     def test_unicode_in_doctag(self):
         """Test storing document vectors of a model with unicode titles."""
         model = doc2vec.Doc2Vec(DocsLeeCorpus(unicode_tags=True), min_count=1)
@@ -143,7 +175,9 @@ def test_string_doctags(self):
         self.assertTrue(all(model.docvecs['_*0'] == model.docvecs[0]))
         self.assertTrue(max(d.offset for d in model.docvecs.doctags.values()) < len(model.docvecs.doctags))
         self.assertTrue(
-            max(model.docvecs._int_index(str_key) for str_key in model.docvecs.doctags.keys())
+            max(
+                model.docvecs._int_index(str_key, model.docvecs.doctags, model.docvecs.max_rawint)
+                for str_key in model.docvecs.doctags.keys())
             < len(model.docvecs.doctag_syn0)
         )
         # verify docvecs.most_similar() returns string doctags rather than indexes
diff --git a/gensim/test/test_fasttext.py b/gensim/test/test_fasttext.py
index 5f630877f7..801d86f598 100644
--- a/gensim/test/test_fasttext.py
+++ b/gensim/test/test_fasttext.py
@@ -9,11 +9,11 @@
 import numpy as np
 
 from gensim import utils
-from gensim.models import keyedvectors
 from gensim.models.word2vec import LineSentence
 from gensim.models.fasttext import FastText as FT_gensim
 from gensim.models.wrappers.fasttext import FastTextKeyedVectors
 from gensim.models.wrappers.fasttext import FastText as FT_wrapper
+from gensim.models.keyedvectors import Word2VecKeyedVectors
 from gensim.test.utils import datapath, get_tmpfile, common_texts as sentences
 
 logger = logging.getLogger(__name__)
@@ -329,61 +329,121 @@ def test_doesnt_match(self):
         except Exception:
             self.fail('model.doesnt_match raises exception for oov words')
 
-    def compare_with_wrapper(self, model_gensim, model_wrapper):
-        # make sure we get >=2 overlapping words for top-10 similar words suggested for `night`
-        sims_gensim = model_gensim.most_similar('night', topn=10)
-        sims_gensim_words = (list(map(lambda x: x[0], sims_gensim)))  # get similar words
-
-        sims_wrapper = model_wrapper.most_similar('night', topn=10)
-        sims_wrapper_words = (list(map(lambda x: x[0], sims_wrapper)))  # get similar words
+    def test_cbow_hs_training(self):
 
-        overlap_count = len(set(sims_gensim_words).intersection(sims_wrapper_words))
+        model_gensim = FT_gensim(
+            size=50, sg=0, cbow_mean=1, alpha=0.05, window=5, hs=1, negative=0,
+            min_count=5, iter=5, batch_words=1000, word_ngrams=1, sample=1e-3, min_n=3, max_n=6,
+            sorted_vocab=1, workers=1, min_alpha=0.0)
 
-        # overlap increases as we increase `iter` value, min overlap set to 2 to avoid unit-tests taking too long
-        # this limit can be increased when using Cython code
+        lee_data = LineSentence(datapath('lee_background.cor'))
+        model_gensim.build_vocab(lee_data)
+        orig0 = np.copy(model_gensim.wv.vectors[0])
+        model_gensim.train(lee_data, total_examples=model_gensim.corpus_count, epochs=model_gensim.epochs)
+        self.assertFalse((orig0 == model_gensim.wv.vectors[0]).all())  # vector should vary after training
+
+        sims_gensim = model_gensim.wv.most_similar('night', topn=10)
+        sims_gensim_words = [word for (word, distance) in sims_gensim]  # get similar words
+        expected_sims_words = [
+            u'night,',
+            u'night.',
+            u'rights',
+            u'kilometres',
+            u'in',
+            u'eight',
+            u'according',
+            u'flights',
+            u'during',
+            u'comes']
+        overlap_count = len(set(sims_gensim_words).intersection(expected_sims_words))
         self.assertGreaterEqual(overlap_count, 2)
 
-    def test_cbow_hs_against_wrapper(self):
-        if self.ft_path is None:
-            logger.info("FT_HOME env variable not set, skipping test")
-            return
-
-        tmpf = get_tmpfile('gensim_fasttext.tst')
-        model_wrapper = FT_wrapper.train(ft_path=self.ft_path, corpus_file=datapath('lee_background.cor'),
-            output_file=tmpf, model='cbow', size=50, alpha=0.05, window=5, min_count=5, word_ngrams=1,
-            loss='hs', sample=1e-3, negative=0, iter=5, min_n=3, max_n=6, sorted_vocab=1, threads=12)
+    def test_sg_hs_training(self):
 
-        model_gensim = FT_gensim(size=50, sg=0, cbow_mean=1, alpha=0.05, window=5, hs=1, negative=0,
+        model_gensim = FT_gensim(
+            size=50, sg=1, cbow_mean=1, alpha=0.025, window=5, hs=1, negative=0,
             min_count=5, iter=5, batch_words=1000, word_ngrams=1, sample=1e-3, min_n=3, max_n=6,
             sorted_vocab=1, workers=1, min_alpha=0.0)
 
         lee_data = LineSentence(datapath('lee_background.cor'))
         model_gensim.build_vocab(lee_data)
-        orig0 = np.copy(model_gensim.wv.syn0[0])
-        model_gensim.train(lee_data, total_examples=model_gensim.corpus_count, epochs=model_gensim.iter)
-        self.assertFalse((orig0 == model_gensim.wv.syn0[0]).all())  # vector should vary after training
-        self.compare_with_wrapper(model_gensim, model_wrapper)
+        orig0 = np.copy(model_gensim.wv.vectors[0])
+        model_gensim.train(lee_data, total_examples=model_gensim.corpus_count, epochs=model_gensim.epochs)
+        self.assertFalse((orig0 == model_gensim.wv.vectors[0]).all())  # vector should vary after training
+
+        sims_gensim = model_gensim.wv.most_similar('night', topn=10)
+        sims_gensim_words = [word for (word, distance) in sims_gensim]  # get similar words
+        expected_sims_words = [
+            u'night,',
+            u'night.',
+            u'eight',
+            u'nine',
+            u'overnight',
+            u'crew',
+            u'overnight.',
+            u'manslaughter',
+            u'north',
+            u'flight']
+        overlap_count = len(set(sims_gensim_words).intersection(expected_sims_words))
+        self.assertGreaterEqual(overlap_count, 2)
 
-    def test_sg_hs_against_wrapper(self):
-        if self.ft_path is None:
-            logger.info("FT_HOME env variable not set, skipping test")
-            return
+    def test_cbow_neg_training(self):
 
-        tmpf = get_tmpfile('gensim_fasttext.tst')
-        model_wrapper = FT_wrapper.train(ft_path=self.ft_path, corpus_file=datapath('lee_background.cor'),
-            output_file=tmpf, model='skipgram', size=50, alpha=0.025, window=5, min_count=5, word_ngrams=1,
-            loss='hs', sample=1e-3, negative=0, iter=5, min_n=3, max_n=6, sorted_vocab=1, threads=12)
+        model_gensim = FT_gensim(
+            size=50, sg=0, cbow_mean=1, alpha=0.05, window=5, hs=0, negative=5,
+            min_count=5, iter=5, batch_words=1000, word_ngrams=1, sample=1e-3, min_n=3, max_n=6,
+            sorted_vocab=1, workers=1, min_alpha=0.0)
 
-        model_gensim = FT_gensim(size=50, sg=1, cbow_mean=1, alpha=0.025, window=5, hs=1, negative=0,
+        lee_data = LineSentence(datapath('lee_background.cor'))
+        model_gensim.build_vocab(lee_data)
+        orig0 = np.copy(model_gensim.wv.vectors[0])
+        model_gensim.train(lee_data, total_examples=model_gensim.corpus_count, epochs=model_gensim.epochs)
+        self.assertFalse((orig0 == model_gensim.wv.vectors[0]).all())  # vector should vary after training
+
+        sims_gensim = model_gensim.wv.most_similar('night', topn=10)
+        sims_gensim_words = [word for (word, distance) in sims_gensim]  # get similar words
+        expected_sims_words = [
+            u'night.',
+            u'night,',
+            u'eight',
+            u'fight',
+            u'month',
+            u'hearings',
+            u'Washington',
+            u'remains',
+            u'overnight',
+            u'running']
+        overlap_count = len(set(sims_gensim_words).intersection(expected_sims_words))
+        self.assertGreaterEqual(overlap_count, 2)
+
+    def test_sg_neg_training(self):
+
+        model_gensim = FT_gensim(
+            size=50, sg=1, cbow_mean=1, alpha=0.025, window=5, hs=0, negative=5,
             min_count=5, iter=5, batch_words=1000, word_ngrams=1, sample=1e-3, min_n=3, max_n=6,
             sorted_vocab=1, workers=1, min_alpha=0.0)
 
         lee_data = LineSentence(datapath('lee_background.cor'))
         model_gensim.build_vocab(lee_data)
-        orig0 = np.copy(model_gensim.wv.syn0[0])
-        model_gensim.train(lee_data, total_examples=model_gensim.corpus_count, epochs=model_gensim.iter)
-        self.assertFalse((orig0 == model_gensim.wv.syn0[0]).all())  # vector should vary after training
-        self.compare_with_wrapper(model_gensim, model_wrapper)
+        orig0 = np.copy(model_gensim.wv.vectors[0])
+        model_gensim.train(lee_data, total_examples=model_gensim.corpus_count, epochs=model_gensim.epochs)
+        self.assertFalse((orig0 == model_gensim.wv.vectors[0]).all())  # vector should vary after training
+
+        sims_gensim = model_gensim.wv.most_similar('night', topn=10)
+        sims_gensim_words = [word for (word, distance) in sims_gensim]  # get similar words
+        expected_sims_words = [
+            u'night.',
+            u'night,',
+            u'eight',
+            u'overnight',
+            u'overnight.',
+            u'month',
+            u'land',
+            u'firm',
+            u'singles',
+            u'death']
+        overlap_count = len(set(sims_gensim_words).intersection(expected_sims_words))
+        self.assertGreaterEqual(overlap_count, 2)
 
     def test_online_learning(self):
         model_hs = FT_gensim(sentences, size=10, min_count=1, seed=42, hs=1, negative=0)
@@ -463,7 +523,7 @@ def test_get_vocab_word_vecs(self):
         model = FT_gensim(size=10, min_count=1, seed=42)
         model.build_vocab(sentences)
         original_syn0_vocab = np.copy(model.wv.syn0_vocab)
-        model.get_vocab_word_vecs()
+        model.trainables.get_vocab_word_vecs(model.wv)
         self.assertTrue(np.all(np.equal(model.wv.syn0_vocab, original_syn0_vocab)))
 
     def test_persistence_word2vec_format(self):
@@ -471,11 +531,9 @@ def test_persistence_word2vec_format(self):
         tmpf = get_tmpfile('gensim_fasttext_w2v_format.tst')
         model = FT_gensim(sentences, min_count=1, size=10)
         model.wv.save_word2vec_format(tmpf, binary=True)
-        loaded_model_kv = keyedvectors.KeyedVectors.load_word2vec_format(tmpf, binary=True)
+        loaded_model_kv = Word2VecKeyedVectors.load_word2vec_format(tmpf, binary=True)
         self.assertEqual(len(model.wv.vocab), len(loaded_model_kv.vocab))
         self.assertTrue(np.allclose(model['human'], loaded_model_kv['human']))
-        self.assertRaises(DeprecationWarning, FT_gensim.load_word2vec_format, tmpf)
-        self.assertRaises(NotImplementedError, FastTextKeyedVectors.load_word2vec_format, tmpf)
 
     def test_bucket_ngrams(self):
         model = FT_gensim(size=10, min_count=1, bucket=20)
@@ -484,6 +542,100 @@ def test_bucket_ngrams(self):
         model.build_vocab(new_sentences, update=True)
         self.assertEqual(model.wv.syn0_ngrams.shape, (20, 10))
 
+    def testLoadOldModel(self):
+        """Test loading fasttext models from previous version"""
+
+        model_file = 'fasttext_old'
+        model = FT_gensim.load(datapath(model_file))
+        self.assertTrue(model.wv.vectors.shape == (12, 100))
+        self.assertTrue(len(model.wv.vocab) == 12)
+        self.assertTrue(len(model.wv.index2word) == 12)
+        self.assertTrue(model.syn1neg.shape == (len(model.wv.vocab), model.vector_size))
+        self.assertTrue(model.trainables.vectors_lockf.shape == (12, ))
+        self.assertTrue(model.vocabulary.cum_table.shape == (12, ))
+
+        self.assertEqual(len(model.wv.ngrams_word), 12)
+        self.assertEqual(len(model.wv.ngrams), 202)
+        self.assertEqual(len(model.wv.hash2index), 202)
+        self.assertTrue(model.wv.vectors_vocab.shape == (12, 100))
+        self.assertTrue(model.wv.vectors_ngrams.shape == (202, 100))
+
+        # Model stored in multiple files
+        model_file = 'fasttext_old_sep'
+        model = FT_gensim.load(datapath(model_file))
+        self.assertTrue(model.wv.vectors.shape == (12, 100))
+        self.assertTrue(len(model.wv.vocab) == 12)
+        self.assertTrue(len(model.wv.index2word) == 12)
+        self.assertTrue(model.syn1neg.shape == (len(model.wv.vocab), model.vector_size))
+        self.assertTrue(model.trainables.vectors_lockf.shape == (12, ))
+        self.assertTrue(model.vocabulary.cum_table.shape == (12, ))
+
+        self.assertEqual(len(model.wv.ngrams_word), 12)
+        self.assertEqual(len(model.wv.ngrams), 202)
+        self.assertEqual(len(model.wv.hash2index), 202)
+        self.assertTrue(model.wv.vectors_vocab.shape == (12, 100))
+        self.assertTrue(model.wv.vectors_ngrams.shape == (202, 100))
+
+    def compare_with_wrapper(self, model_gensim, model_wrapper):
+        # make sure we get >=2 overlapping words for top-10 similar words suggested for `night`
+        sims_gensim = model_gensim.most_similar('night', topn=10)
+        sims_gensim_words = (list(map(lambda x: x[0], sims_gensim)))  # get similar words
+
+        sims_wrapper = model_wrapper.most_similar('night', topn=10)
+        sims_wrapper_words = (list(map(lambda x: x[0], sims_wrapper)))  # get similar words
+
+        overlap_count = len(set(sims_gensim_words).intersection(sims_wrapper_words))
+
+        # overlap increases as we increase `iter` value, min overlap set to 2 to avoid unit-tests taking too long
+        # this limit can be increased when using Cython code
+        self.assertGreaterEqual(overlap_count, 2)
+
+    def test_cbow_hs_against_wrapper(self):
+        if self.ft_path is None:
+            logger.info("FT_HOME env variable not set, skipping test")
+            return
+
+        tmpf = get_tmpfile('gensim_fasttext.tst')
+        model_wrapper = FT_wrapper.train(ft_path=self.ft_path, corpus_file=datapath('lee_background.cor'),
+                                         output_file=tmpf, model='cbow', size=50, alpha=0.05, window=5, min_count=5,
+                                         word_ngrams=1,
+                                         loss='hs', sample=1e-3, negative=0, iter=5, min_n=3, max_n=6, sorted_vocab=1,
+                                         threads=12)
+
+        model_gensim = FT_gensim(size=50, sg=0, cbow_mean=1, alpha=0.05, window=5, hs=1, negative=0,
+                                 min_count=5, iter=5, batch_words=1000, word_ngrams=1, sample=1e-3, min_n=3, max_n=6,
+                                 sorted_vocab=1, workers=1, min_alpha=0.0)
+
+        lee_data = LineSentence(datapath('lee_background.cor'))
+        model_gensim.build_vocab(lee_data)
+        orig0 = np.copy(model_gensim.wv.syn0[0])
+        model_gensim.train(lee_data, total_examples=model_gensim.corpus_count, epochs=model_gensim.iter)
+        self.assertFalse((orig0 == model_gensim.wv.syn0[0]).all())  # vector should vary after training
+        self.compare_with_wrapper(model_gensim, model_wrapper)
+
+    def test_sg_hs_against_wrapper(self):
+        if self.ft_path is None:
+            logger.info("FT_HOME env variable not set, skipping test")
+            return
+
+        tmpf = get_tmpfile('gensim_fasttext.tst')
+        model_wrapper = FT_wrapper.train(ft_path=self.ft_path, corpus_file=datapath('lee_background.cor'),
+                                         output_file=tmpf, model='skipgram', size=50, alpha=0.025, window=5,
+                                         min_count=5, word_ngrams=1,
+                                         loss='hs', sample=1e-3, negative=0, iter=5, min_n=3, max_n=6, sorted_vocab=1,
+                                         threads=12)
+
+        model_gensim = FT_gensim(size=50, sg=1, cbow_mean=1, alpha=0.025, window=5, hs=1, negative=0,
+                                 min_count=5, iter=5, batch_words=1000, word_ngrams=1, sample=1e-3, min_n=3, max_n=6,
+                                 sorted_vocab=1, workers=1, min_alpha=0.0)
+
+        lee_data = LineSentence(datapath('lee_background.cor'))
+        model_gensim.build_vocab(lee_data)
+        orig0 = np.copy(model_gensim.wv.syn0[0])
+        model_gensim.train(lee_data, total_examples=model_gensim.corpus_count, epochs=model_gensim.iter)
+        self.assertFalse((orig0 == model_gensim.wv.syn0[0]).all())  # vector should vary after training
+        self.compare_with_wrapper(model_gensim, model_wrapper)
+
 
 if __name__ == '__main__':
     logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.DEBUG)
diff --git a/gensim/test/test_keyedvectors.py b/gensim/test/test_keyedvectors.py
index 8789ec38b3..178dfcc91e 100644
--- a/gensim/test/test_keyedvectors.py
+++ b/gensim/test/test_keyedvectors.py
@@ -14,7 +14,7 @@
 
 import numpy as np
 
-from gensim.models.keyedvectors import EuclideanKeyedVectors
+from gensim.models import KeyedVectors as EuclideanKeyedVectors
 from gensim.test.utils import datapath
 
 
diff --git a/gensim/test/test_scripts.py b/gensim/test/test_scripts.py
new file mode 100644
index 0000000000..001283e3c4
--- /dev/null
+++ b/gensim/test/test_scripts.py
@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2018 Manos Stergiadis <em.stergiadis@gmail.com>
+# Licensed under the GNU LGPL v2.1 - http://www.gnu.org/licenses/lgpl.html
+
+"""
+Automated tests for checking the output of gensim.scripts.
+"""
+
+from __future__ import unicode_literals
+
+import json
+import logging
+import os.path
+import unittest
+
+from gensim.scripts.segment_wiki import segment_all_articles, segment_and_write_all_articles
+from smart_open import smart_open
+from gensim.test.utils import datapath, get_tmpfile
+
+
+class TestSegmentWiki(unittest.TestCase):
+
+    def setUp(self):
+        self.fname = datapath('enwiki-latest-pages-articles1.xml-p000000010p000030302-shortened.bz2')
+        self.expected_title = 'Anarchism'
+        self.expected_section_titles = [
+            'Introduction',
+            'Etymology and terminology',
+            'History',
+            'Anarchist schools of thought',
+            'Internal issues and debates',
+            'Topics of interest',
+            'Criticisms',
+            'References',
+            'Further reading',
+            'External links'
+        ]
+
+    def tearDown(self):
+        # remove all temporary test files
+        fname = get_tmpfile('script.tst')
+        extensions = ['', '.json']
+        for ext in extensions:
+            try:
+                os.remove(fname + ext)
+            except OSError:
+                pass
+
+    def test_segment_all_articles(self):
+        title, sections, interlinks = next(segment_all_articles(self.fname, include_interlinks=True))
+
+        # Check title
+        self.assertEqual(title, self.expected_title)
+
+        # Check section titles
+        section_titles = [s[0] for s in sections]
+        self.assertEqual(section_titles, self.expected_section_titles)
+
+        # Check text
+        first_section_text = sections[0][1]
+        first_sentence = "'''Anarchism''' is a political philosophy that advocates self-governed societies"
+        self.assertTrue(first_sentence in first_section_text)
+
+        # Check interlinks
+        self.assertTrue(interlinks['self-governance'] == 'self-governed')
+        self.assertTrue(interlinks['Hierarchy'] == 'hierarchical')
+        self.assertTrue(interlinks['Pierre-Joseph Proudhon'] == 'Proudhon')
+
+    def test_generator_len(self):
+        expected_num_articles = 106
+        num_articles = sum(1 for x in segment_all_articles(self.fname))
+
+        self.assertEqual(num_articles, expected_num_articles)
+
+    def test_json_len(self):
+        tmpf = get_tmpfile('script.tst.json')
+        segment_and_write_all_articles(self.fname, tmpf, workers=1)
+
+        expected_num_articles = 106
+        num_articles = sum(1 for line in smart_open(tmpf))
+        self.assertEqual(num_articles, expected_num_articles)
+
+    def test_segment_and_write_all_articles(self):
+        tmpf = get_tmpfile('script.tst.json')
+        segment_and_write_all_articles(self.fname, tmpf, workers=1, include_interlinks=True)
+
+        # Get the first line from the text file we created.
+        with open(tmpf) as f:
+            first = next(f)
+
+        # decode JSON line into a Python dictionary object
+        article = json.loads(first)
+        title, section_titles, interlinks = article['title'], article['section_titles'], article['interlinks']
+
+        self.assertEqual(title, self.expected_title)
+        self.assertEqual(section_titles, self.expected_section_titles)
+
+        # Check interlinks
+        self.assertTrue(interlinks['self-governance'] == 'self-governed')
+        self.assertTrue(interlinks['Hierarchy'] == 'hierarchical')
+        self.assertTrue(interlinks['Pierre-Joseph Proudhon'] == 'Proudhon')
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.DEBUG)
+    unittest.main()
diff --git a/gensim/test/test_similarity_metrics.py b/gensim/test/test_similarity_metrics.py
index 2f7b39857c..a9420000fe 100644
--- a/gensim/test/test_similarity_metrics.py
+++ b/gensim/test/test_similarity_metrics.py
@@ -105,12 +105,21 @@ def test_inputs(self):
 
     def test_distributions(self):
 
-        # checking bag of words as inputs
+        # checking different length bag of words as inputs
         vec_1 = [(2, 0.1), (3, 0.4), (4, 0.1), (5, 0.1), (1, 0.1), (7, 0.2)]
         vec_2 = [(1, 0.1), (3, 0.8), (4, 0.1)]
         result = matutils.hellinger(vec_1, vec_2)
-        expected = 0.185241936534
+        expected = 0.484060507634
+        self.assertAlmostEqual(expected, result)
+
+        # checking symmetrical bag of words inputs return same distance
+        vec_1 = [(2, 0.1), (3, 0.4), (4, 0.1), (5, 0.1), (1, 0.1), (7, 0.2)]
+        vec_2 = [(1, 0.1), (3, 0.8), (4, 0.1), (8, 0.1), (10, 0.8), (9, 0.1)]
+        result = matutils.hellinger(vec_1, vec_2)
+        result_symmetric = matutils.hellinger(vec_2, vec_1)
+        expected = 0.856921568786
         self.assertAlmostEqual(expected, result)
+        self.assertAlmostEqual(expected, result_symmetric)
 
         # checking ndarray, csr_matrix as inputs
         vec_1 = np.array([[1, 0.3], [0, 0.4], [2, 0.3]])
diff --git a/gensim/test/test_word2vec.py b/gensim/test/test_word2vec.py
index 9a46d321da..d1ec2703e9 100644
--- a/gensim/test/test_word2vec.py
+++ b/gensim/test/test_word2vec.py
@@ -142,7 +142,7 @@ def testPruneVocab(self):
 
     def testTotalWordCount(self):
         model = word2vec.Word2Vec(size=10, min_count=0, seed=42)
-        total_words = model.scan_vocab(sentences)
+        total_words = model.vocabulary.scan_vocab(sentences)[0]
         self.assertEqual(total_words, 29)
 
     def testOnlineLearning(self):
@@ -731,6 +731,28 @@ def testPredictOutputWord(self):
         model_without_neg = word2vec.Word2Vec(sentences, min_count=1, negative=0)
         self.assertRaises(RuntimeError, model_without_neg.predict_output_word, ['system', 'human'])
 
+    def testLoadOldModel(self):
+        """Test loading word2vec models from previous version"""
+
+        model_file = 'word2vec_old'
+        model = word2vec.Word2Vec.load(datapath(model_file))
+        self.assertTrue(model.wv.vectors.shape == (12, 100))
+        self.assertTrue(len(model.wv.vocab) == 12)
+        self.assertTrue(len(model.wv.index2word) == 12)
+        self.assertTrue(model.syn1neg.shape == (len(model.wv.vocab), model.wv.vector_size))
+        self.assertTrue(model.trainables.vectors_lockf.shape == (12,))
+        self.assertTrue(model.vocabulary.cum_table.shape == (12,))
+
+        # Model stored in multiple files
+        model_file = 'word2vec_old_sep'
+        model = word2vec.Word2Vec.load(datapath(model_file))
+        self.assertTrue(model.wv.vectors.shape == (12, 100))
+        self.assertTrue(len(model.wv.vocab) == 12)
+        self.assertTrue(len(model.wv.index2word) == 12)
+        self.assertTrue(model.syn1neg.shape == (len(model.wv.vocab), model.wv.vector_size))
+        self.assertTrue(model.trainables.vectors_lockf.shape == (12,))
+        self.assertTrue(model.vocabulary.cum_table.shape == (12,))
+
     @log_capture()
     def testBuildVocabWarning(self, l):
         """Test if warning is raised on non-ideal input to a word2vec model"""
diff --git a/setup.py b/setup.py
index 2c16ded0f7..30d6b3f554 100644
--- a/setup.py
+++ b/setup.py
@@ -245,7 +245,7 @@ def finalize_options(self):
 
 setup(
     name='gensim',
-    version='3.2.0',
+    version='3.3.0',
     description='Python framework for fast Vector Space Modelling',
     long_description=LONG_DESCRIPTION,
 
diff --git a/tox.ini b/tox.ini
index 43f090ba47..2a26b9291d 100644
--- a/tox.ini
+++ b/tox.ini
@@ -15,7 +15,6 @@ builtins = get_ipython
 [pytest]
 addopts = -rfxEXs --durations=20 --showlocals --reruns 3 --reruns-delay 1
 
-
 [testenv]
 recreate = True