DeepChatModels
1.0.0
Notes aux visiteurs :
python3 manage.py runserver . Si vous n'êtes pas familier avec l'exécution de Flask de cette façon, consultez la documentation de Flask-Script. Désolé pour tout inconvénient !Au 9 mai 2017, les principaux packages du projet sont les suivants :
python3 manage.py runserverDu point de vue de l'utilisateur/développeur, ce projet offre une interface plus propre pour bricoler des modèles séquence à séquence. Le résultat idéal est une API de chatbot avec la lisibilité de Keras, mais avec un degré de flexibilité plus proche de TensorFlow.
Du côté « client », jouer avec les paramètres du modèle et les exécuter est aussi simple que de créer un fichier de configuration (yaml), d'ouvrir un interpréteur Python et d'émettre une poignée de commandes. L'extrait suivant, par exemple, est tout ce dont vous avez besoin pour démarrer l'entraînement sur le jeu de données Cornell (après l'avoir téléchargé bien sûr) avec votre configuration :
import data
import chatbot
from utils import io_utils
# Load config dictionary with the flexible parse_config() function,
# which can handle various inputs for building your config dictionary.
config = io_utils . parse_config ( config_path = 'path_to/my_config.yml' )
dataset = getattr ( data , config [ 'dataset' ])( config [ 'dataset_params' ])
bot = getattr ( chatbot , config [ 'model' ])( dataset , config )
bot . train () Ce n'est qu'une façon d'interfacer avec le projet. Par exemple, l'utilisateur peut également transmettre des paramètres via des arguments de ligne de commande, qui seront également fusionnés avec tous les fichiers de configuration qu'ils spécifient (priorité donnée aux arguments de ligne de commande en cas de conflit). Vous pouvez également transmettre l'emplacement d'un chatbot précédemment enregistré pour reprendre son entraînement ou démarrer une conversation. Voir main.py pour plus de détails.
Ubuntu Dialogue Corpus : l'approche de pré-traitement peut être vue dans ubuntu_reformat.ipynb dans le dossier notebooks. L'utilisation prévue de l'ensemble de données est le classement des réponses pour les dialogues à plusieurs tours, mais j'ai adopté une approche plutôt simple consistant à extraire des paires d'énoncés et à les interpréter comme une phrase unique à une réponse unique, qui correspondent aux entrées de l'encodeur et du décodeur. , respectivement, dans les modèles.
Cornell Movie-Dialogs : J'ai commencé avec cette version prétraitée du corpus Cornell et j'ai apporté des modifications mineures pour réduire le bruit.
Commentaires sur Reddit : env. 1,7 milliard de commentaires sur Reddit. Je travaille actuellement sur le prétraitement et la réduction de cet ensemble de données massif dans un format approprié pour la formation des modèles de conversation. Publiera les liens de téléchargement des ensembles de données traités une fois terminé !
DynamicBot : utilise une approche plus orientée objet proposée par les classes personnalisées dans model_components.py. Le résultat est une intégration concaténée par lots en ligne plus rapide et une approche plus naturelle du chat. Il utilise la (fantastique) nouvelle API Python de la version TensorFlow 1.0, notamment Dynamic_rnn. Il adhère également aux bonnes pratiques de portée des variables et aux conventions Tensorflow courantes que j'ai observées dans la documentation et le code source, ce qui a des effets secondaires intéressants tels que des visualisations graphiques claires dans TensorBoard.
SimpleBot : modèle groupé simplifié basé sur le modèle « ChatBot » plus compliqué ci-dessous. Bien qu'il soit moins flexible dans la personnalisation des partitions de compartiment et qu'il utilise un softmax clairsemé sur l'ensemble du vocabulaire au lieu de l'échantillonnage, il est beaucoup plus transparent dans sa mise en œuvre. Il utilise très peu tf.contrib, par opposition à ChatBot, et est plus ou moins implémenté à partir de zéro, dans le sens où il s'appuie principalement sur les méthodes tensorflow de base. Si vous êtes nouveau sur TensorFlow, il peut être utile de lire son implémentation pour avoir une idée des conventions courantes dans la programmation Tensorflow, car c'est le résultat de ma lecture du code source de toutes les méthodes dans ChatBot et de l'écriture du mien, plus compact. interprétation.
ChatBot : version étendue du modèle décrit dans ce didacticiel TensorFlow. Caractéristiques de l'architecture : entrées regroupées, le décodeur utilise un mécanisme d'attention (voir page 69 de mes notes, et les entrées sont intégrées aux fonctions simples fournies dans la bibliothèque tf.contrib. Utilise également une fonction de perte softmax échantillonnée pour permettre des tailles de vocabulaire plus grandes (page 67 des notes). Commentaires supplémentaires : en raison de la nature des modèles en compartiments, la création du modèle prend beaucoup plus de temps que les autres. Le principal goulot d'étranglement semble être la taille du plus grand compartiment et la manière dont les opérations de dégradé sont créées en fonction de celui-ci. tailles de seau.
Le répertoire de pages Web présente un moyen simple et économe en espace de déployer vos modèles TensorFlow dans une application Flask. Les modèles sont « gelés » : tous les composants non nécessaires au chat (par exemple les optimiseurs) sont supprimés et toutes les variables restantes sont converties en constantes. Lorsque l'utilisateur clique sur un nom de modèle, une API REST pour ce modèle est créée. Lorsque l'utilisateur saisit une phrase dans le formulaire, une requête POST (AJAX) est émise, où la réponse est la phrase de réponse du chatbot. Pour plus de détails sur l'API REST, consultez vues.py.
L'application Flask suit les meilleures pratiques, telles que l'utilisation de modèles pour instancier des applications, de différentes bases de données en fonction de l'environnement de l'application (par exemple développement ou production), et bien plus encore.
Ici, je vais entrer plus en détail sur la façon dont les modèles sont construits et comment ils peuvent être visualisés. Cette section est un travail en cours et pas encore terminé.
Au lieu d'utiliser l'argument feed_dict pour saisir des lots de données dans le modèle, il est beaucoup plus rapide de coder les informations d'entrée et les techniques de prétraitement dans la structure graphique elle-même. Cela signifie que nous ne nourrissons rien le modèle au moment de la formation. Le modèle utilise plutôt une séquence de files d'attente pour accéder aux données des fichiers au format protobuf de Google, décoder les fichiers en séquences tensorielles, regrouper et compléter dynamiquement les séquences, puis transmettre ces lots au décodeur d'intégration. Le tout dans la structure graphique. De plus, ce traitement des données est coordonné par plusieurs threads en parallèle. Nous pouvons utiliser Tensorboard (et les meilleures pratiques en matière de portée variable) pour visualiser ce type de pipeline à un niveau élevé.
(Plus de descriptions à venir !)
De nombreuses recherches ont été consacrées à ces modèles, et j'ai documenté mes notes sur les articles les plus « importants » ici dans la dernière section de mes notes d'apprentissage en profondeur ici. Les notes incluent également la façon dont j'ai essayé de traduire le contenu des articles en code TensorFlow. Je mettrai à jour cela au fur et à mesure que les idées provenant d'autres articles seront intégrées à ce projet.
Papiers:
Ressources en ligne :
