deep_qa

Déprécié

Deepqa est construit sur des keras. Nous avons décidé que Pytorch est une meilleure plate-forme pour la recherche PNL. Nous avons réécrit Deepqa dans une bibliothèque Pytorch appelée Allenlp. Il n'y aura plus de développement de Deepqa. Mais, nous sommes très excités par ALLENNLP - si vous effectuez un apprentissage en profondeur pour le traitement du langage naturel, vous devriez le vérifier!

Deepqa

Deepqa est une bibliothèque pour effectuer des tâches de PNL de haut niveau avec un apprentissage en profondeur, en particulier axée sur divers types de réponses aux questions. Deepqa est construit sur des keras et Tensorflow, et peut être considéré comme une interface à ces systèmes qui facilite la NLP.

Plus précisément, cette bibliothèque offre les avantages suivants sur les keras simples / Tensorflow:

• Il est facile d'obtenir la NLP directement dans DeepQA.
  • Dans Keras, il y a beaucoup de problèmes concernant les séquences de rembourrage et le masquage qui ne sont pas bien gérés dans le code Keras principal, et nous avons un code bien testé qui fait la bonne chose pour, par exemple, en calcul des attentions sur des séquences rembourrées, un padding toutes les instances de formation à la même longueur (éventuellement en dynamiquement par lot, pour minimiser plusieurs éventuels condamnations ou des mots de padage), ou la répartition des échanges de textes à travers des conférences ou des mots.
  • Deepqa offre une API agréable et cohérente autour de la construction de modèles NLP. Cette API a des fonctionnalités concernant le traitement des instances de données, l'intégration de mots et / ou de caractères, d'obtenir facilement divers types d'encodeurs de phrases, etc. Il facilite les modèles de construction pour les tâches NLP de haut niveau.
• Deepqa fournit une interface propre à la formation, à la validation et à la débogage des modèles Keras. Il est facile d'expérimenter les variantes d'une famille de modèles simplement en modifiant certains paramètres dans un fichier JSON. Par exemple, les détails de la façon dont les mots sont représentés, soit avec des vecteurs à gants fixes, des vecteurs Word2Vec affinés, soit une concaténation de ceux avec un CNN au niveau du caractère, sont tous spécifiés par des paramètres dans un fichier JSON, pas dans votre code réel. Cela rend trivial de changer les détails de votre modèle en fonction des données avec lesquelles vous travaillez.
• DeepQA contient un certain nombre de modèles de pointe, en particulier axés sur les systèmes de réponse aux questions (bien que nous ayons également essayé des modèles pour d'autres tâches). Le code de modèle réel pour ces systèmes est généralement de 50 lignes ou moins.

Running Deepqa

Mettre en place un environnement de développement

Deepqa est construit à l'aide de Python 3. Le moyen le plus simple de configurer un environnement compatible est d'utiliser Conda. Cela mettra en place un environnement virtuel avec la version exacte de Python utilisée pour le développement ainsi que toutes les dépendances nécessaires pour exécuter DeepQA.

1. Téléchargez et installez conda.

2. Créez un environnement conda avec Python 3.

    conda create -n deep_qa python=3.5
   

3. Activez maintenant l'environnement Conda.

    source activate deep_qa
   

4. Installez les dépendances requises.

    ./scripts/install_requirements.sh
   

5. Réglez les PYTHONHASHSEED pour des expériences reproductibles.

    export PYTHONHASHSEED=2157
   

Vous devriez maintenant pouvoir tester votre installation avec pytest -v . Félicitations! Vous avez maintenant un environnement de développement pour Deep_QA qui utilise TensorFlow avec le support CPU. (Pour le support GPU, voir les exigences.txt pour plus d'informations sur la façon d'installer tensorflow-gpu ).

En utilisant Deepqa comme exécutable

Pour former ou évaluer un modèle à l'aide d'un clone du référentiel DeepQA, le point d'entrée recommandé consiste à utiliser le script run_model.py . Le premier argument de ce script est un fichier de paramètres, décrit plus ci-dessous. Le deuxième argument détermine le comportement, soit former un modèle, soit évaluer un modèle formé par rapport à un ensemble de données de test. Les options valides actuelles pour le deuxième argument sont train et test (l'omission de l'argument est le même que train de passer).

Les fichiers de paramètres spécifient la classe de modèle que vous utilisez, les hyperparamètres du modèle, les détails de formation, les fichiers de données, les détails du générateur de données et bien d'autres choses. Vous pouvez voir des exemples de fichiers de paramètres dans le répertoire des exemples. Vous pouvez obtenir une notion de quels paramètres sont disponibles en recherchant la documentation.

En fait, la formation d'un modèle nécessitera des fichiers d'entrée, que vous devez fournir. Nous avons une bibliothèque compagnon, DeepQA Experiments, qui a été initialement conçu pour produire des fichiers d'entrée et exécuter des expériences, et peut être utilisé pour générer des fichiers de données requis pour la plupart des tâches pour lesquelles nous avons des modèles. Nous nous efforçons de mettre le code de traitement des données directement dans DeepQA, de sorte que les expériences DeepQA ne sont pas nécessaires, mais pour l'instant, obtenir des fichiers de données de formation au bon format se fait plus facilement avec des expériences DeepQA.

Utiliser Deepqa comme bibliothèque

Si vous utilisez DeepQA comme bibliothèque dans votre propre code, il est toujours simple d'exécuter votre modèle. Au lieu d'utiliser le script run_model.py pour faire la formation / l'évaluation, vous pouvez le faire vous-même comme suit:

 from deep_qa import run_model, evaluate_model, load_model, score_dataset

# Train a model given a json specification
run_model("/path/to/json/parameter/file")


# Load a model given a json specification
loaded_model = load_model("/path/to/json/parameter/file")
# Do some more exciting things with your model here!


# Get predictions from a pre-trained model on some test data specified in the json parameters.
predictions = score_dataset("/path/to/json/parameter/file")
# Compute your own metrics, or do beam search, or whatever you want with the predictions here.


# Compute Keras' metrics on a test dataset, using a pre-trained model.
evaluate_model("/path/to/json/parameter/file", ["/path/to/data/file"])

Le reste des directives d'utilisation, des exemples, etc., sont les mêmes que lorsque vous travaillez dans un clone du référentiel.

Implémentation de vos propres modèles

Pour implémenter un nouveau modèle dans DeepQA, vous devez sous-classer TextTrainer . Il y a une documentation sur ce qui est nécessaire pour cela; Voir en particulier la section des méthodes abstraites. Pour un exemple simple d'un modèle entièrement fonctionnel, voir le tagger de séquence simple, qui a environ 20 lignes de code d'implémentation réel.

Afin de former, charger et évaluer les modèles que vous avez écrits vous-même, passez simplement un argument supplémentaire aux fonctions ci-dessus et supprimez le paramètre model_class de votre spécification JSON. Par exemple:

 from deep_qa import run_model
from .local_project import MyGreatModel

# Train a model given a json specification (without a "model_class" attribute).
run_model("/path/to/json/parameter/file", model_class=MyGreatModel)

Si vous effectuez une nouvelle tâche ou une nouvelle variante d'une tâche avec une spécification d'entrée / sortie différente, vous devez probablement également implémenter un type Instance . L' Instance gère les données de lecture d'un fichier et les convertir en tableaux Numpy qui peuvent être utilisés pour la formation et l'évaluation. Cela ne doit se produire qu'une seule fois pour chaque spécification d'entrée / sortie.

Modèles implémentés

DeepQA a des implémentations de méthodes de pointe pour une variété de tâches. Voici quelques-uns d'entre eux:

Compréhension de la lecture

• Le lecteur attentif, de l'enseignement des machines à lire et à comprendre, par Hermann et autres
• Lecteur d'attention fermé des lecteurs d'attention fermés pour la compréhension du texte,
• Flux d'attention bidirectionnel, du flux d'attention bidirectionnel pour la compréhension de la machine,

Impact

• Attention décomposable, d'un modèle d'attention décomposable pour l'inférence du langage naturel,

Ensembles de données

Ce code permet une expérimentation facile avec les ensembles de données suivants:

• Questions sur les sciences de l'école primaire AI2 (pas de diagrammes)
• L'ensemble de données de test de livres pour enfants Facebook
• L'ensemble de données Facebook Babi
• L'ensemble de données NewsQA
• L'ensemble de données de réponse à la question de Stanford (Squad)
• L'OMS a fait quel ensemble de données

Notez que le code de traitement des données pour la plupart de cela vit actuellement dans des expériences DeepQA, cependant.

Contributif

Si vous utilisez ce code et pensez que quelque chose pourrait être amélioré, les demandes de traction sont les bienvenues. L'ouverture d'un problème est également OK, mais nous pouvons répondre beaucoup plus rapidement pour extraire les demandes.

Contributeurs

• Matt Gardner
• Mark Neumann
• Nelson Liu.
• Pradeep Dasigi (l'auteur initial de cette base de code)

Licence

Ce code est publié selon les termes de la licence Apache 2.