项目作者: allenai

项目描述 :
A deep NLP library, based on Keras / tf, focused on question answering (but useful for other NLP too)
高级语言: Python
项目地址: git://github.com/allenai/deep_qa.git
创建时间: 2015-12-10T23:16:40Z
项目社区:https://github.com/allenai/deep_qa

开源协议:Apache License 2.0

下载


Build Status
Documentation Status
codecov

DEPRECATED

DeepQA is built on top of Keras. We’ve decided that pytorch is a
better platform for NLP research. We re-wrote DeepQA into a pytorch library called
AllenNLP. There will be no more development
of DeepQA. But, we’re pretty excited about AllenNLP - if you’re doing deep learning
for natural language processing, you should check it out!

DeepQA

DeepQA is a library for doing high-level NLP tasks with deep learning, particularly focused on
various kinds of question answering. DeepQA is built on top of Keras and
TensorFlow, and can be thought of as an interface to these
systems that makes NLP easier.

Specifically, this library provides the following benefits over plain Keras / TensorFlow:

  • It is easy to get NLP right in DeepQA.
    • In Keras, there are a lot of issues around padding sequences and masking
      that are not handled well in the main Keras code, and we have well-tested
      code that does the right thing for, e.g., computing attentions over
      padded sequences, padding all training instances to the same lengths
      (possibly dynamically by batch, to minimize computation wasted on padding
      tokens), or distributing text encoders across several sentences or words.
    • DeepQA provides a nice, consistent API around building NLP models. This
      API has functionality around processing data instances, embedding words
      and/or characters, easily getting various kinds of sentence encoders, and
      so on. It makes building models for high-level NLP tasks easy.
  • DeepQA provides a clean interface to training, validating, and debugging
    Keras models. It is easy to experiment with variants of a model family just
    by changing some parameters in a JSON file. For example, the particulars of
    how words are represented, either with fixed GloVe vectors, fine-tuned
    word2vec vectors, or a concatenation of those with a character-level CNN, are
    all specified by parameters in a JSON file, not in your actual code. This
    makes it trivial to switch the details of your model based on the data that
    you’re working with.
  • DeepQA contains a number of state-of-the-art models, particularly focused
    around question answering systems (though we’ve dabbled in models for other
    tasks, as well). The actual model code for these systems is typically 50
    lines or less.

Running DeepQA

Setting up a development environment

DeepQA is built using Python 3. The easiest way to set up a compatible
environment is to use Conda. This will set up a virtual
environment with the exact version of Python used for development along with all the
dependencies needed to run DeepQA.

  1. Download and install Conda.
  2. Create a Conda environment with Python 3.

    1. conda create -n deep_qa python=3.5
  3. Now activate the Conda environment.

    1. source activate deep_qa
  4. Install the required dependencies.

    1. ./scripts/install_requirements.sh
  5. Set the PYTHONHASHSEED for repeatable experiments.

    1. export PYTHONHASHSEED=2157

You should now be able to test your installation with pytest -v. Congratulations!
You now have a development environment for deep_qa that uses TensorFlow with CPU support.
(For GPU support, see requirements.txt for information on how to install tensorflow-gpu).

Using DeepQA as an executable

To train or evaluate a model using a clone of the DeepQA repository, the recommended entry point is
to use the run_model.py script. The first argument to that script
is a parameter file, described more below. The second argument determines the behavior, either
training a model or evaluating a trained model against a test dataset. Current valid options for
the second argument are train and test (omitting the argument is the same as passing train).

Parameter files specify the model class you’re using, model hyperparameters, training details,
data files, data generator details, and many other things. You can see example parameter files in
the examples directory. You can get some notion of what parameters are
available by looking through the documentation.

Actually training a model will require input files, which you need to provide. We have a companion
library, DeepQA Experiments, which was
originally designed to produce input files and run experiments, and can be used to generate
required data files for most of the tasks we have models for. We’re moving towards putting the
data processing code directly into DeepQA, so that DeepQA Experiments is not necessary, but for
now, getting training data files in the right format is most easily done with DeepQA
Experiments
.

Using DeepQA as a library

If you are using DeepQA as a library in your own code, it is still straightforward to run your
model. Instead of using the run_model.py script to do the
training/evaluation, you can do it yourself as follows:

  1. from deep_qa import run_model, evaluate_model, load_model, score_dataset
  2. # Train a model given a json specification
  3. run_model("/path/to/json/parameter/file")
  4. # Load a model given a json specification
  5. loaded_model = load_model("/path/to/json/parameter/file")
  6. # Do some more exciting things with your model here!
  7. # Get predictions from a pre-trained model on some test data specified in the json parameters.
  8. predictions = score_dataset("/path/to/json/parameter/file")
  9. # Compute your own metrics, or do beam search, or whatever you want with the predictions here.
  10. # Compute Keras' metrics on a test dataset, using a pre-trained model.
  11. evaluate_model("/path/to/json/parameter/file", ["/path/to/data/file"])

The rest of the usage guidelines, examples, etc., are the same as when working in a clone of the
repository
.

Implementing your own models

To implement a new model in DeepQA, you need to subclass TextTrainer. There is
documentation on what is
necessary for this; see in particular the Abstract
methods

section. For a simple example of a fully functional model, see the simple sequence
tagger
, which has about 20 lines of actual
implementation code.

In order to train, load and evaluate models which you have written yourself, simply pass an
additional argument to the functions above and remove the model_class parameter from your json
specification. For example:

  1. from deep_qa import run_model
  2. from .local_project import MyGreatModel
  3. # Train a model given a json specification (without a "model_class" attribute).
  4. run_model("/path/to/json/parameter/file", model_class=MyGreatModel)

If you’re doing a new task, or a new variant of a task with a different input/output specification,
you probably also need to implement an Instance type.
The Instance handles reading data from a file and converting it into numpy arrays that can be
used for training and evaluation. This only needs to happen once for each input/output spec.

Implemented models

DeepQA has implementations of state-of-the-art methods for a variety of tasks. Here are a few of
them:

Reading comprehension

Entailment

Datasets

This code allows for easy experimentation with the following datasets:

Note that the data processing code for most of this currently lives in DeepQA
Experiments
, however.

Contributing

If you use this code and think something could be improved, pull requests are very welcome. Opening
an issue is ok, too, but we can respond much more quickly to pull requests.

Contributors

License

This code is released under the terms of the Apache 2
license
.