[PYTHON] Une histoire d'un an de fonctionnement d'un chatbot de manière étouffée

Cet article est le 7ème jour de My Navi Advent Calendar 2019!

Je m'occupe généralement du big data et de l'IA, et je me spécialise principalement dans le traitement du langage naturel. Cette fois, je passerai beaucoup de temps à parler de jouer avec le chatbot lancé dans la société Slack.

Aperçu

Un bot avec des performances de ventilation élevées s'exécute sur AWS. Parfois, je reçois une attaque par injection de mon aîné au travail, mais je vais bien. Je regrette qu'il aurait été préférable d'avoir un seul cloud au lieu d'un multi-cloud.

Ci-dessous, une image de jouer avec le chatbot.

Hmmm, quel visage pour mes parents ...

introduction

Contexte que je voulais créer

Tous les êtres humains vivent avec le désir de créer des chatbots. Au moins je le suis, donc je suis sûr que d'autres le sont. Pendant ce temps, un article sur l'IA des lycéennes de Microsoft "Rinna" a été publié dans le monde (2016).

• Page d'accueil officielle: https://www.rinna.jp
• Thèse de la Language Processing Society: Rinna: High School Girl Artificial Intelligence

mignonne

Je dois faire ça ... (2 ans se sont écoulés)

À propos de Slack

J'utilise Slack comme principal outil de communication. Il y en avait 677 sur la seule chaîne publique. Je ne sais pas si c'est plus ou moins: penser:

Depuis l'époque où la culture est enracinée, le but de ce chatbot est de le faire fonctionner à mon rythme et de «faire sourire tout le monde». La prière que je devienne un tel robot de dialogue est incluse. J'étais là. Au fait, le nom est "Natsu-chan" car il est sorti en été. Chaque fois que la version monte, la saison à ce moment-là est nommée.

L'API Slack utilisée est l'API Events (https://api.slack.com/events-api). Je n'oublie pas de restreindre les autorisations afin que l'API ne soit appelée que lorsqu'elle est mentionnée.

Livrables

Diagramme de configuration du chatbot

Je l'ai fait avec précision.

Le schéma de configuration du chatbot est présenté ci-dessous.

En fait, j'ai fait de mon mieux.

Au début, j'ai donné une adresse IP Elastic à un seul EC2, enregistré la session avec la commande Screen et l'ai liée à Slack. Cependant, il y a eu une annonce du dieu disant qu '"il n'y a aucun intérêt à utiliser AWS", et j'ai pensé que c'était le cas, et je me suis beaucoup amusé avec.

Problèmes de configuration du système

Je vais lister les problèmes de la configuration actuelle à ma manière.

• Non sécurisé
• En raison du souci de "que dois-je faire avec le certificat SSL ...", j'ai lié Slack à la communication HTTP.
• En utilisant API Gateway, bien qu'il s'agisse d'un domaine Amazon, la communication HTTPS est possible.
• Dans ce cas, je pense qu'il est préférable de créer NLB au lieu d'ALB et de se connecter avec VPC Link.
• (C'était à peu près à l'époque où je voulais utiliser ALB)
• Je ne sais pas pourquoi j'ai choisi le multi-cloud
• Après avoir pensé à utiliser Colaboratory après avoir construit une infrastructure sur AWS, j'ai décidé d'utiliser GCP en coopération.
• Je pense qu'il valait mieux construire avec GCP à ce stade
• La sélection de la technologie / de l'environnement est importante
• (Je veux un GPU qui peut être utilisé indéfiniment)
• Pourquoi EC2?
• À cette époque, je n'avais aucune connaissance ou compétence particulière sur Docker.
• Je souhaite convertir la partie API en conteneur Docker et l'exploiter avec ECS
• Je souhaite gérer Terraform (désir)
• Étant donné que l'infrastructure AWS a été gérée par Terraform dans un autre projet, j'aimerais éventuellement gérer l'environnement de chatbot par Terraform.

À propos de l'algorithme du chatbot

Cette fois, je l'ai implémenté avec Seq2Seq + Attention + Sentencepiece. Le groupe technologique spécifique est illustré ci-dessous.

• Veuillez vous référer au lien à la fin pour les données d'entraînement.

Nous utilisons Word2Vec pour apprendre des vecteurs de mots à partir d'un corpus d'apprentissage tokenisé par Sentencepiece comme pré-apprentissage. Le vecteur de mot appris a été utilisé comme valeur initiale de l'incorporation de mots de l'encodeur et du décodeur.

Ci-dessous se trouve la partie __init__.

def __init__(self, vocab_size, embed_size, hidden_size, eos, w=None, ignore_label=-1):
    super(Seq2Seq, self).__init__()

    self.unk = ignore_label
    self.eos = eos

    with self.init_scope():

        # Embedding Layer
        self.x_embed = L.EmbedID(vocab_size, embed_size, initialW=w, ignore_label=ignore_label)
        self.y_embed = L.EmbedID(vocab_size, embed_size, initialW=w, ignore_label=ignore_label)
        # 4-Layer LSTM
        self.encoder = L.NStepLSTM(n_layers=4, in_size=embed_size, out_size=hidden_size, dropout=0.1)
        self.decoder = L.NStepLSTM(n_layers=4, in_size=embed_size, out_size=hidden_size, dropout=0.1)

        # Attention Layer
        self.attention = L.Linear(2*hidden_size, hidden_size)

        # Output Layer
        self.y = L.Linear(hidden_size, vocab_size)

Seq2Seq est un modèle de conversion en série qui utilise Encoder-Decoder. Dans l'article original, cela a été annoncé en traduction automatique (tâche de traduction anglais-français), mais la conversion d'une chaîne de caractères d'entrée en chaîne de caractères de sortie peut également être utilisée dans le dialogue! C'est la reconnaissance qui est également utilisée dans le dialogue Bot.

Les données d'apprentissage sont un ensemble de phrase d'entrée-sortie de phrase comme suit.

Déclaration d'entrée:C'est vraiment amusant de te parler. Voulez-vous monter dans le salon et parler?
Instruction de sortie:J'ai quelque chose à faire aujourd'hui, donc je serai libre.

Les réponses obtenues à partir du modèle entraîné sont comme une formule de questions-réponses, sans tenir compte du tout du flux de conversation. Parfois, on dirait que la conversation s'est poursuivie, mais elle s'est juste poursuivie et je ne la considérais pas du tout comme un modèle.

Voici la partie __call__.

def __call__(self, x, y):

    """

    :param x:Données d'entrée mini-batch
    :param y:Sortie mini-lot correspondant aux données d'entrée
    :return:Erreur et précision
    """

    batch_size = len(x)
    eos = self.xp.array([self.eos], dtype='int32')

    #Intégration du signal EOS
    y_in = [F.concat((eos, tmp), axis=0) for tmp in y]
    y_out = [F.concat((tmp, eos), axis=0) for tmp in y]

    # Embedding Layer
    emb_x = sequence_embed(self.x_embed, x)
    emb_y = sequence_embed(self.y_embed, y_in)

    # Encoder,Entrée vers le décodeur
    h, c, a = self.encoder(None, None, emb_x)  # h => hidden, c => cell, a => output(Attention)
    _, _, dec_hs = self.decoder(h, c, emb_y)  # dec_hs=> output

    #Sortie Concat du décodeur de taille de lot
    dec_h = chainer.functions.concat(dec_hs, axis=0)
    
    #Calcul de l'attention
    attention = chainer.functions.concat(a, axis=0)
    o = self.global_attention_layer(dec_h, attention)

    t = chainer.functions.concat(y_out, axis=0)

    loss = F.softmax_cross_entropy(o, t)  #Calcul d'erreur
    accuracy = F.accuracy(o, t)  #Calcul de la précision

    return loss, accuracy

La recherche par faisceau est utilisée pour l'inférence. La largeur du faisceau est de 3. La longueur maximale des mots est de 50.

Pour ces implémentations, je me suis référé au blog de @ nojima ci-dessous. C'était une aide précieuse. Je vous remercie! https://nojima.hatenablog.com/entry/2017/10/10/023147

Learning utilise Google Colaboratory. https://colab.research.google.com/notebooks/welcome.ipynb?hl=ja

Des difficultés

• Arrêt de l'environnement Jupyter en raison de règles de collaboration
• Après 90 minutes d'inactivité et 12 heures de fonctionnement continu, Colab sera arrêté et les données internes seront ensevelies dans l'obscurité d'Internet.
• Par conséquent, j'ai pris un instantané pour chaque époque, je l'ai sauvegardé et je l'ai lu à plusieurs reprises.
• (Je veux un GPU qui peut être utilisé indéfiniment)
• Décollaboratoire
• Je voudrais essayer MLOps qui seront déployés sur la plate-forme d'apprentissage lorsque git push de Jupyter ou d'un script

Implémentation côté API

Il est implémenté par Flask + uWSGI. Lorsque vous travaillez avec l'API Events, un Challenge se produit du côté de Slack. https://api.slack.com/events-api#subscriptions

Plus précisément, le POST suivant est lancé au point de terminaison. Si vous renvoyez la valeur de ce «défi» telle quelle, le défi est réussi. Après cela, il est possible de créer un lien avec Slack en fonction des paramètres d'API Slack définis. Notez que si le défi échoue, Slack ne POSTERA pas sur le point de terminaison de l'API.

{
    "token": "Jeton d'API Slack",
    "challenge": "3eZbrw1aBm2rZgRNFdxV2595E9CY3gmdALWMmHkvFXO7tYXAYM8P",
    "type": "url_verification"
}

Les paramètres d'autorisation peuvent être définis dans «S'abonner aux événements de bot» dans «Abonnements aux événements». J'ai ajouté ʻapp_mention` comme événement. Il s'agit d'un événement qui POST publie des données sur le point de terminaison configuré lorsqu'il est mentionné sur le canal qui a introduit le bot.

Sous «S'abonner aux événements de bot», il y a «S'abonner aux événements de l'espace de travail», qui est un paramètre appliqué en tant qu'événement pour l'ensemble de l'espace de travail. Veuillez noter que ce sera difficile.

Défis API

Les problèmes du côté de l'API sont les suivants.

• Je veux le rendre un peu plus moderne en utilisant Swagger (Connexion)
• Séparez la partie inférence du point final qui interagit avec Slack
• Étant donné que le point final et la partie inférence sont liés à Mitsuzuki, je veux éliminer cette malsaine.
• Je veux faire CI / CD correctement
• J'ai utilisé Bitbucket Pipelines dans un autre projet, je souhaite donc exécuter CI / CD lors du prochain déploiement.

Réaction après la libération

J'étais heureux qu'ils aient été acceptés favorablement dans les délais. Pour une raison quelconque, j'interagis avec Bot plus d'une fois par semaine (y compris moi-même).

Parfois j'entends des chiennes, parfois j'ai des attaques par injection, et parfois des mots "forts". Quand je pense aux ingénieurs derrière le chatbot, je ne peux plus frapper fortement le chatbot. Je suis désolé, Siri. Je suis désolé, Cortana. Je suis désolé, Kyle.

C'est une année que j'ai réalisé qu'il y avait beaucoup de choses que je peux comprendre pour la première fois après l'avoir fait.

À la fin

:innocent:

Lien

• Corpus des échecs de dialogue
  • https://sites.google.com/site/dialoguebreakdowndetection/chat-dialogue-corpus
• Corpus de conversation Meidai
  • https://mmsrv.ninjal.ac.jp/nucc/
• Sequence to Sequence Learning with Neural Networks
  • https://arxiv.org/pdf/1409.3215.pdf
• Effective Approaches to Attention-based Neural Machine Translation
  • https://www-nlp.stanford.edu/pubs/emnlp15_attn.pdf
• SentencePiece: A simple and language independent subword tokenizer and detokenizer for Neural Text Processing
  • https://arxiv.org/pdf/1808.06226.pdf
• Distributed Representations of Words and Phrases and their Compositionality
  • https://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf