Fixed tests (#345)

* Fixed tests by setting package versions
* Documentation fixes

Author: peteriz

doc/source/CONTRIBUTING.rst

@@ -19,10 +19,10 @@ Contribution Process
 
 1. File an issue (to track your contribution):
 
-   * Create an issue on github:
+   * Create an issue on GitHub:
      https://github.com/NervanaSystems/nlp-architect/issues
 
-2. Clone and/or update your checked out copy of nlp-achitect to ensure you have the
+2. Clone and/or update your checked out copy of nlp-architect to ensure you have the
    most recent commits from the master branch:
 
   .. code-block:: bash
@@ -59,8 +59,8 @@ Contribution Process
 
       nlp_architect doc   # builds the doc and starts a local server directly
 
-6. Commit your changes and push your feature branch to your github fork.  Be
-   sure to add a descriptive message and reference the github issue associated
+6. Commit your changes and push your feature branch to your GitHub fork.  Be
+   sure to add a descriptive message and reference the GitHub issue associated
    with your task (ex. #1).  You will also want to rebase your commits down to
    a single sensible commit to make things clean for the merge process:
 

doc/source/chunker.rst

@@ -41,7 +41,7 @@ We used the CONLL2000_ shared task dataset in our example for training a phrase
 The CONLL2000_ dataset has a ``train_set`` and ``test_set`` sets consisting of 8926 and 2009 sentences annotated with Part-of-speech and chunking information.
 We implemented a dataset loader, :py:class:`CONLL2000 <nlp_architect.data.sequential_tagging.CONLL2000>`, for loading and parsing :py:class:`CONLL2000 <nlp_architect.data.sequential_tagging.CONLL2000>` data into numpy arrays ready to be used sequential tagging models. For full set of options please see :py:class:`CONLL2000 <nlp_architect.data.sequential_tagging.CONLL2000>`.
 
-NLP Architect has a dataloader to easily load CONLL2000 which can be found in :py:class:`CONLL2000 <nlp_architect.data.sequential_tagging.CONLL2000>`. The loader supports the following feature generation when loading the dataset:
+NLP Architect has a data loader to easily load CONLL2000 which can be found in :py:class:`CONLL2000 <nlp_architect.data.sequential_tagging.CONLL2000>`. The loader supports the following feature generation when loading the dataset:
 
 1. Sentence words in sparse int representation
 2. Part-of-speech tags of words
@@ -53,7 +53,7 @@ To get the dataset follow these steps:
 
 1. download train and test files from dataset website.
 2. unzip files: ``gunzip *.gz``
-3. provide ``CONLL2000`` dataloader or ``train.py`` sample below the directory containing the files.
+3. provide ``CONLL2000`` data loader or ``train.py`` sample below the directory containing the files.
 
 Model
 =====
@@ -76,7 +76,7 @@ Running Modalities
 
 We provide a simple example for training and running inference using the :py:class:`SequenceChunker <nlp_architect.models.chunker.SequenceChunker>` model.
 
-``examples/chunker/train.py`` will load CONLL2000 dataset and train a model using given training parameters (batch size, epochs, external word embedding, etc.), save the model once done training and print the performance of the model on the test set. The example supports loading GloVe/Fasttext word embedding models to be used when training a model. The training method used in this example trains on both POS and Chunk labels concurently with equal targer loss weights, this is different than what is described in the paper_.
+``examples/chunker/train.py`` will load CONLL2000 dataset and train a model using given training parameters (batch size, epochs, external word embedding, etc.), save the model once done training and print the performance of the model on the test set. The example supports loading GloVe/Fasttext word embedding models to be used when training a model. The training method used in this example trains on both POS and Chunk labels concurrently with equal target loss weights, this is different than what is described in the paper_.
 
 ``examples/chunker/inference.py`` will load a saved model and a given text file with sentences and print the chunks found on the stdout.
 

doc/source/crosslingual_emb.rst

@@ -10,7 +10,7 @@ This model uses a GAN to learn mapping between two language embeddings without s
 
 Files
 =====
-- **nlp_architect/data/fasttext_emb.py**: Defines fasttext object for loading fasttext embeddings
+- **nlp_architect/data/fasttext_emb.py**: Defines Fasttext object for loading Fasttext embeddings
 - **nlp_architect/models/crossling_emb.py**: Defines GAN for learning crosslingual embeddings
 - **examples/crosslingembs/train.py**: Trains the model and writes final crosslingual embeddings to weight_dir directory.
 - **examples/crosslingembs/evaluate.py**: Defines graph for evaluating the quality of crosslingual embeddings
@@ -19,7 +19,7 @@ Usage
 =====
 Main arguments which need to be passed to train.py are
 
-- **emb_dir**: Directory where fasttext embeddings are present or need to be downloaded
+- **emb_dir**: Directory where Fasttext embeddings are present or need to be downloaded
 - **eval_dir**: Directory where evaluation dictionary is downloaded
 - **weight_dir**: Directory where final crosslingual dictionaries are defined
 

doc/source/identifying_semantic_relation.rst

@@ -187,7 +187,7 @@ Examples
 
 * Using Wikipedia Relation identifier for mentions of *'IBM'* and *'International Business Machines'* will result with the following relation types: ```WIKIPEDIA_CATEGORY, WIKIPEDIA_ALIASES, WIKIPEDIA_REDIRECT_LINK```
 
-* Using WordNet Relation idenfieir for mentions of *'lawyer'* and *'attorney'* will result with the following relations types: ```WORDNET_SAME_SYNSET, WORDNET_DERIVATIONALLY```
+* Using WordNet Relation identifier for mentions of *'lawyer'* and *'attorney'* will result with the following relations types: ```WORDNET_SAME_SYNSET, WORDNET_DERIVATIONALLY```
 
 * Using Referent-Dict Relation identifier for mentions of *'company'* and *'apple'* will result with ```REFERENT_DICT``` relation type.
 

doc/source/installation.rst

@@ -112,7 +112,7 @@ Tensorflow has a guide `guide <https://www.tensorflow.org/install/install_source
 
 Alternatively, follow the instructions below to compile and install the latest version of Tensorflow with MKL-DNN:
 
-* Clone Tensorflow repository from github:
+* Clone Tensorflow repository from GitHub:
 
   .. code::
 

doc/source/intent.rst

@@ -37,10 +37,10 @@ Models
 Multi-task Intent and slot tagging model
 ----------------------------------------
 
-:py:class:`MultiTaskIntentModel <nlp_architect.models.intent_extraction.MultiTaskIntentModel>` is a Multi-task model that is similar to the joint intent/slot tagging model. The model has 2 sources of input: 1 - words, 2 - characters of words. The model has 3 main features when compared to the other models, character information embedding acting as a feature extractor of the words, a CRF classifier for slot labels, and a cascasing structure of the intent and tag classificaion.
+:py:class:`MultiTaskIntentModel <nlp_architect.models.intent_extraction.MultiTaskIntentModel>` is a Multi-task model that is similar to the joint intent/slot tagging model. The model has 2 sources of input: 1 - words, 2 - characters of words. The model has 3 main features when compared to the other models, character information embedding acting as a feature extractor of the words, a CRF classifier for slot labels, and a cascading structure of the intent and tag classification.
 The intent classification is done by encoding the context of the sentences (words ``x_1, .., x_n``), using word embeddings (denoted as ``W``), by a bi-directional LSTM layer, and training a classifier on the last hidden state of the LSTM layer (using ``softmax``).
 Word-character embeddings (denoted as ``C``) are created using a bi-directional LSTM encoder which concatenates the last hidden states of the layers.
-The encoding of the word-context, in each time step (word location in the sentence) is concatenated with the word-charcter embeddings and pushed in another bi-directional LSTM which provides the final context encoding that a CRF layer uses for slot tag classification.
+The encoding of the word-context, in each time step (word location in the sentence) is concatenated with the word-character embeddings and pushed in another bi-directional LSTM which provides the final context encoding that a CRF layer uses for slot tag classification.
 
 .. image :: assets/mtl_model.png
 
@@ -72,7 +72,7 @@ We provide an additional dataset loader  :py:class:`TabularIntentDataset <nlp_ar
 -  each word encoded in a separate line: ``<token> <token_tag> <intent_type>``
 -  sentences are separated with an empty line
 
-The dataset loader extracts word and character sparse encoding and label/intent tags per sentence. This dataloader is useful for many intent extraction datasets that can be found on the web and used in academic literature (such as ATIS [3]_ [4]_, Conll, etc.).
+The dataset loader extracts word and character sparse encoding and label/intent tags per sentence. This data-loader is useful for many intent extraction datasets that can be found on the web and used in academic literature (such as ATIS [3]_ [4]_, Conll, etc.).
 
 Files
 =====

doc/source/memn2n.rst

@@ -19,7 +19,7 @@ End-to-End Memory Networks for Goal Oriented Dialogue
 
 Overview
 ========
-This directory contains an implementation of an End-to-End Memory Network for goal oriented dialogue in ngraph.
+This directory contains an implementation of an End-to-End Memory Network for goal oriented dialogue in TensorFlow.
 
 Goal oriented dialogue is a subset of open-domain dialogue where an automated agent has a specific
 goal for the outcome of the interaction. At a high level, the system needs to understand a user

doc/source/ner_crf.rst

@@ -49,9 +49,9 @@ In the above format each sentence is separated by an empty line. Each line consi
 Data loader
 -----------
 
-Loading data into the model can be done using the :py:class:`SequentialTaggingDataset <nlp_architect.data.sequential_tagging.SequentialTaggingDataset>` data loader which can be used with the preprared train and test data sets described above.
+Loading data into the model can be done using the :py:class:`SequentialTaggingDataset <nlp_architect.data.sequential_tagging.SequentialTaggingDataset>` data loader which can be used with the prepared train and test data sets described above.
 
-The data loader returns 2 numpy matrices:
+The data loader returns 2 Numpy matrices:
 1. sparse word representation of the sentence words
 2. sparse word character representation of sentence words
 
@@ -83,7 +83,7 @@ Prediction layer
 
 The main tagger model consists of a bidirectional LSTM layers. The input of the LSTM layers consists of a concatenation of the word embedding vector and the character embedding vector (provided by the character embedding network).
 
-Finally, the output of the LSTM layers are merged into a fully-connected layer (for each token) and fed into a `Conditional Random Field classifier`_. CRF prediction layers have been empirically proved to provide more accuract models when compared to single token prediction (when using a `softmax` layer).
+Finally, the output of the LSTM layers are merged into a fully-connected layer (for each token) and fed into a `Conditional Random Field classifier`_. Using CRF has been empirically shown to provide more accurate models when compared to single token prediction layers (such as a `softmax` layer).
 
 Running Modalities
 ==================

doc/source/np2vec.rst

@@ -24,7 +24,7 @@ This code consists in training a word embedding's model for Noun NP's using word
 It assumes that the NP's are already extracted and marked in the input corpus.
 All the terms in the corpus are used as context in order to train the word embedding's model; however,
 at the end of the training, only the word embedding's of the NP's are stored, except for the case of
-fasttext training with word_ngrams=1; in this case, we store all the word embedding's,
+Fasttext training with word_ngrams=1; in this case, we store all the word embedding's,
 including non-NP's in order to be able to estimate word embeddings of out-of-vocabulary NP's
 (NP's that don't appear in the training corpora).
 
@@ -69,7 +69,7 @@ To run inference with a saved model, the following command can be used:
   python examples/np2vec/inference.py --np2vec_model_file sample_np2vec.model --np <noun phrase>
 
 
-More details about the hyperparameters at https://radimrehurek.com/gensim/models/word2vec.html#gensim.models.word2vec.Word2Vec for word2vec and https://radimrehurek.com/gensim/models/fasttext.html#gensim.models.fasttext.FastText for fasttext.
+More details about the hyperparameters at https://radimrehurek.com/gensim/models/word2vec.html#gensim.models.word2vec.Word2Vec for word2vec and https://radimrehurek.com/gensim/models/fasttext.html#gensim.models.fasttext.FastText for Fasttext.
 
 .. _word2vec: https://code.google.com/archive/p/word2vec/
 .. _fasttext: https://github.com/facebookresearch/fastText

doc/source/publications.rst

@@ -24,6 +24,9 @@ Blog posts
 - `Revolutionizing Personal Assistant Through Understanding Actionable Requests in Human-to-Human Interactions <https://ai.intel.com/revolutionizing-personal-assistant-through-understanding-actionable-requests-in-human-to-human-interactions/>`_
 - `Introducing NLP Architect by Intel AI Lab <https://ai.intel.com/introducing-nlp-architect-by-intel-ai-lab/>`_
 - `Deep Learning Foundations to Enable Natural Language Processing Solutions <https://ai.intel.com/deep-learning-foundations-to-enable-natural-language-processing-solutions/>`_
+- `NLP Architect by Intel AI Lab: Release 0.2 <https://ai.intel.com/nlp-architect-by-intel-ai-lab-release-0-2/>`_
+- `NLP Architect Version 0.3 Release <https://ai.intel.com/nlp-architect-version-0-3-release/>`_
+- `Compressing GNMT Models <https://ai.intel.com/compressing-gnmt-models/>`_
 
 Conference Proceedings
 ======================
@@ -37,7 +40,7 @@ Tutorials
 
   - Natural Language Question/Answer Systems: Hands on Workshop - Andy Keller, Anna Bethke (`video <http://aidc.gallery.video/detail/videos/day-1:-hands-on-labs/video/5789368925001/natural-language-question-answer-systems:-hands-on-workshop?autoStart=false>`_, `slides <https://simplecore.intel.com/nervana/wp-content/uploads/sites/53/2018/06/AI-Devcon-Session-Natural-Language_AnnaBethkeAndyKeller_Interstellar_523_Final.pdf>`_)
   - Using Deep Learning for Entity Detection and Intent Extraction in Natural Language: Hands on Workshop - Peter Izsak (`video <http://aidc.gallery.video/detail/videos/day-2:-hands-on-labs/video/5790623335001/using-deep-learning-for-entity-detection-and-intent-extraction-in-natural-language?autoStart=false>`_, `slides <https://simplecore.intel.com/nervana/wp-content/uploads/sites/53/2018/06/IntelAIDC18_Izsak_Odyessey_524_Final.pdf>`_)
-  
+
 - Classifying NLP with Deep Learning: webinar - Anna Bethke (`video <https://software.intel.com/en-us/videos/deep-learning-and-natural-language-processing>`_)
 
 Demos

doc/source/reading_comprehension.rst

@@ -96,8 +96,8 @@ After training starts, you will see outputs similar to this:
   creating training and development sets
   Match LSTM Pass
   Answer Pointer Pass
-  Settting up Loss
-  Set up optmizer
+  Setting up Loss
+  Set up optimizer
   Begin Training
   Epoch Number:  0
   iteration = 1, train loss = 13.156427383422852

doc/source/service.rst

@@ -76,7 +76,7 @@ The request content has the following format:
         ]
     }
 
-In the example above, ``model_name`` is the desirted model to run the documents through and each input document is marked with an id and content.
+In the example above, ``model_name`` is the desired model to run the documents through and each input document is marked with an id and content.
 
 Responses
 ---------

doc/source/spacy_np_annotator.rst

@@ -28,7 +28,7 @@ The annotator implementation can be found in :py:class:`NPAnnotator <nlp_archite
 
 Usage example
 -------------
-Loading a spacy pipeline and adding a sentence breaker (required) and :py:class:`NPAnnotator <nlp_architect.pipelines.spacy_np_annotator.NPAnnotator>` annotator as the last annotator in the pipeline:
+Loading a Spacy pipeline and adding a sentence breaker (required) and :py:class:`NPAnnotator <nlp_architect.pipelines.spacy_np_annotator.NPAnnotator>` annotator as the last annotator in the pipeline:
 
 .. code:: python
 
@@ -47,12 +47,12 @@ Parse documents regularly and get the noun phrase annotations using a dedicated
 Standalone Spacy-NPAnnotator
 ============================
 
-For usecases in which the user is not interested in specialized Spacy pipelines we have implemented :py:class:`SpacyNPAnnotator <nlp_architect.pipelines.spacy_np_annotator.SpacyNPAnnotator>` which will run a spacy pipeline internally and provide string based noun phrase chunks given documents in string format.
+For use cases in which the user is not interested in specialized Spacy pipelines we have implemented :py:class:`SpacyNPAnnotator <nlp_architect.pipelines.spacy_np_annotator.SpacyNPAnnotator>` which will run a Spacy pipeline internally and provide string based noun phrase chunks given documents in string format.
 
 Usage example
 -------------
 
-Just as in :py:class:`NPAnnotator <nlp_architect.pipelines.spacy_np_annotator.NPAnnotator>`, we need to provide a trained :py:class:`SequenceChunker <nlp_architect.models.chunker.SequenceChunker>` model and its parameters file. It is also possible to provide a specific spacy model to base the pipeline on.
+Just as in :py:class:`NPAnnotator <nlp_architect.pipelines.spacy_np_annotator.NPAnnotator>`, we need to provide a trained :py:class:`SequenceChunker <nlp_architect.models.chunker.SequenceChunker>` model and its parameters file. It is also possible to provide a specific Spacy model to base the pipeline on.
 
 The following example shows how to load a model/parameters using the default Spacy English model (`en`) and how to get the noun phrase annotations.