Les technologies de traitement du langage naturel sont devenues assez sophistiquées ces dernières années. Des géants de la technologie aux amateurs, beaucoup se précipitent pour créer des interfaces riches capables d'analyser, de comprendre et de répondre au langage naturel. Alexa d'Amazon, Cortana de Microsoft, Google Home et Siri d'Apple visent tous à changer la façon dont nous interagissons avec les ordinateurs.

L'analyse des sentiments, un sous-domaine du traitement du langage naturel, consiste en des techniques qui déterminent le ton d'un texte ou d'un discours. Aujourd'hui, grâce à l'apprentissage automatique et à la grande quantité de données collectées sur les réseaux sociaux et les sites d'avis, nous pouvons former des modèles pour identifier le sentiment d'un passage en langage naturel avec une précision raisonnable.

Dans ce didacticiel, vous apprendrez comment créer un bot capable d'analyser le sentiment des e-mails que vous recevez et de vous informer des e-mails susceptibles de nécessiter votre attention immédiatement.

Analyse des sentiments dans les e-mails

Le bot sera construit en utilisant un mélange de Java et Python. Les deux processus communiqueront entre eux en utilisant Thrift. Si vous n'êtes pas familier avec une ou les deux langues, vous pouvez continuer à lire car les concepts fondamentaux de cet article s'appliqueront également à d'autres langues.

Pour déterminer si un e-mail a besoin de votre attention, le bot l'analysera et déterminera s'il y a un fort ton négatif. Il enverra ensuite une alerte texte si nécessaire.

Nous utiliserons Sendgrid pour nous connecter à notre boîte aux lettres et Twilio enverra des alertes textuelles. ## Analyse des sentiments: un problème d'une simplicité trompeuse

Il y a des mots que nous associons à des émotions positives, telles que l'amour, la joie et le plaisir. Et il y a des mots que nous associons à des émotions négatives, telles que la haine, la tristesse et la douleur. Pourquoi ne pas entraîner le modèle à reconnaître ces mots et à compter la fréquence et la force relatives de chaque mot positif et négatif?

Eh bien, cela pose quelques problèmes.

Premièrement, il y a un problème de déni. Par exemple, une phrase comme 'La pêche n'est pas mauvaise' implique une émotion positive en utilisant un mot que nous associons souvent à être négatif. Un simple modèle de sac de mots ne pourra pas reconnaître la négation dans cette phrase.

En outre, les sentiments mitigés s'avèrent être un autre problème avec l'analyse naïve des sentiments. Par exemple, une phrase comme 'La pêche n'est pas mauvaise, mais la pomme est vraiment terrible' contient des sentiments mitigés d'intensités mélangées qui interagissent les uns avec les autres. Une approche simple ne sera pas en mesure de résoudre des sentiments mitigés, une intensité différente ou des interactions entre les sentiments.

Analyse des sentiments à l'aide du réseau récursif du tenseur neuronal

La bibliothèque Traitement du langage naturel de Stanford pour l'analyse des sentiments résout ces problèmes en utilisant un réseau de tenseurs neuronaux récursifs (RNTN).

L'algorithme RNTN décompose d'abord une phrase en mots individuels. Ensuite, construisez un réseau neuronal où les nœuds sont les mots individuels. Enfin, une couche tenseur est ajoutée afin que le modèle puisse correctement ajuster les interactions entre les mots et les phrases.

Vous pouvez trouver une démonstration visuelle de l'algorithme dans votre site officiel .

Le groupe PNL de Stanford a formé le réseau de tenseurs neuronaux récursifs à l'aide d'évaluations de films IMDB étiquetés manuellement et a constaté que leur modèle est capable de prédire les sensations avec une très bonne précision.

Bot qui reçoit des e-mails

La première chose à faire est de configurer l'intégration de la messagerie afin que les données puissent être transférées vers votre bot.

Il existe de nombreuses façons d'y parvenir, mais pour plus de simplicité, configurons un serveur Web simple et utilisons le crochet d'analyse d'entrée de Sendgrid pour diriger les e-mails vers le serveur. Nous pouvons transférer des e-mails à l'adresse analytique entrante de Sendgrid. Sendgrid enverra une requête POST à ​​notre serveur Web, puis nous pourrons traiter les données via notre serveur.

Pour construire le serveur, nous utiliserons Flask, un framework web simple pour Python .

En plus de créer le serveur Web, nous voudrons connecter le service Web à un domaine. En bref, nous éviterons d'écrire à ce sujet dans l'article. Cependant, vous pouvez en savoir plus à ce sujet ici .

Créer un serveur Web dans Ballon c'est incroyablement simple.

Créez simplement un app.py et ajoutez-le au fichier:

from flask import Flask, request import datetime app = Flask(__name__) @app.route('/analyze', methods=['POST']) def analyze(): with open('logfile.txt', 'a') as fp_log: fp_log.write('endpoint hit %s ' % datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')) return 'Got it' app.run(host='0.0.0.0')

Si nous déployons cette application derrière un nom de domaine et cliquons sur le point de terminaison '/ analyser', vous devriez voir quelque chose comme ceci:

> >> requests.post ('http://sentiments.shanglunwang.com:5000/analyze') .text 'Lo tengo'

Ensuite, nous voulons envoyer des e-mails à ce point final.

Vous pouvez trouver plus de documentation ici mais fondamentalement, vous voulez configurer Sendgrid pour qu'il soit votre processeur de messagerie et Sendgrid transfère les e-mails vers notre serveur Web.

Voici ma configuration dans Sendgrid. Cela transférera les e-mails à @sentibot.shanglunwang.com comme POST demande à «http://sentiments.shanglunwang.com/analyze»:

Vous pouvez utiliser tout autre service prenant en charge l'envoi d'e-mails entrants via des webhooks.

Après avoir tout configuré, essayez d'envoyer un e-mail à votre adresse SendGrid. Vous devriez voir quelque chose comme ça dans les journaux:

endpoint hit 2017-05-25 14:35:46

Ça c'est génial! Maintenant, vous avez un robot qui peut recevoir des e-mails. C'est la moitié de ce que nous essayons de faire.

principes de conception accent définition

Maintenant, vous voulez donner à ce bot la possibilité d'analyser le sentiment dans les e-mails.

Analyse des sentiments des e-mails avec Stanford NLP

Puisque la bibliothèque PNL de Stanford est écrite en Java, nous voudrons construire le moteur d'analyse en Java.

Commençons par télécharger la bibliothèque et les modèles PNL de Stanford sur Maven. Créer un nouveau projet Java , ajoutez ce qui suit à vos dépendances Maven et importez:

edu.stanford.nlp stanford-corenlp 3.6.0

Le moteur d'analyse des sentiments PNL de Stanford est accessible en spécifiant l'annotateur de sentiment dans le code d'initialisation du pipeline. L'annotation peut être récupérée sous forme d'arborescence.

Pour les besoins de ce didacticiel, nous voulons uniquement connaître le sentiment général d'une phrase, il n'est donc pas nécessaire d'analyser l'arbre. Il suffit de regarder le nœud de base.

Cela rend le code principal relativement simple:

package seanwang; import edu.stanford.nlp.pipeline.*; import edu.stanford.nlp.util.CoreMap; import edu.stanford.nlp.ling.CoreAnnotations; import edu.stanford.nlp.sentiment.SentimentCoreAnnotations; import java.util.*; public class App { public static void main( String[] args ) { Properties pipelineProps = new Properties(); Properties tokenizerProps = new Properties(); pipelineProps.setProperty('annotators', 'parse, sentiment'); pipelineProps.setProperty('parse.binaryTrees', 'true'); pipelineProps.setProperty('enforceRequirements', 'false'); tokenizerProps.setProperty('annotators', 'tokenize ssplit'); StanfordCoreNLP tokenizer = new StanfordCoreNLP(tokenizerProps); StanfordCoreNLP pipeline = new StanfordCoreNLP(pipelineProps); String line = 'Los amigos hermosos increíblemente agradecidos están cumpliendo un logro increíblemente alegre. ¡Qué idea verdaderamente terrible!'; Annotation annotation = tokenizer.process(line); pipeline.annotate(annotation); // normal output for (CoreMap sentence : annotation.get(CoreAnnotations.SentencesAnnotation.class)) { String output = sentence.get(SentimentCoreAnnotations.SentimentClass.class); System.out.println(output); } } }

Essayez quelques phrases et vous devriez voir les annotations appropriées. Exécution des résultats de l'exemple de code:

Muy positivo Negativo

Intégration du bot et du moteur d'analyse

Nous avons donc un programme d'analyse des sentiments écrit en Java et un bot de messagerie écrit en Python. Comment les amener à se parler?

Il existe de nombreuses solutions possibles à ce problème, mais ici nous utiliserons Épargne . Nous activerons l'analyseur de sentiments en tant que serveur Thrift et le bot de messagerie en tant que client Thrift.

Thrift est un générateur de code et un protocole utilisé pour permettre à deux applications, souvent écrites dans des langues différentes, de pouvoir communiquer entre elles en utilisant un protocole défini. Les équipes Polyglot utilisent Thrift pour créer des réseaux de microservices afin de tirer parti du meilleur de chaque langage utilisé.

Pour utiliser Thrift, nous aurons besoin de deux choses: un fichier .thrift pour définir les extrémités du service et un code généré pour utiliser le protocole défini dans le fichier .proto. Pour le service d'analyseur, le sentiment.thrift ça ressemble à ceci:

namespace java sentiment namespace py sentiment service SentimentAnalysisService { string sentimentAnalyze(1:string sentence), }

Nous pouvons générer du code client et serveur en utilisant ce fichier .thrift. Courir:

thrift-0.10.0.exe --gen py sentiment.thrift thrift-0.10.0.exe --gen java sentiment.thrift

Remarque: créez le code sur une machine Windows. Vous devrez utiliser le chemin d'accès approprié à l'exécutable Thrift dans votre environnement.

Maintenant, apportons les modifications appropriées au moteur de scan pour créer un serveur. Votre programme Java devrait ressembler à ceci:

SentimentHandler.java

package seanwang; public class SentimentHandler implements SentimentAnalysisService.Iface { SentimentAnalyzer analyzer; SentimentHandler() { analyzer = new SentimentAnalyzer(); } public String sentimentAnalyze(String sentence) { System.out.println('got: ' + sentence); return analyzer.analyze(sentence); } }

Ce gestionnaire est l'endroit où nous recevons la demande d'analyse sur le protocole Thrift.

SentimentAnalyzer.java

package seanwang; // ... public class SentimentAnalyzer { StanfordCoreNLP tokenizer; StanfordCoreNLP pipeline; public SentimentAnalyzer() { Properties pipelineProps = new Properties(); Properties tokenizerProps = new Properties(); pipelineProps.setProperty('annotators', 'parse, sentiment'); pipelineProps.setProperty('parse.binaryTrees', 'true'); pipelineProps.setProperty('enforceRequirements', 'false'); tokenizerProps.setProperty('annotators', 'tokenize ssplit'); tokenizer = new StanfordCoreNLP(tokenizerProps); pipeline = new StanfordCoreNLP(pipelineProps); } public String analyze(String line) { Annotation annotation = tokenizer.process(line); pipeline.annotate(annotation); String output = ''; for (CoreMap sentence : annotation.get(CoreAnnotations.SentencesAnnotation.class)) { output += sentence.get(SentimentCoreAnnotations.SentimentClass.class); output += ' '; } return output; } }

L'analyseur utilise la bibliothèque PNL de Stanford pour déterminer le sentiment du texte et produit une chaîne contenant les annotations de sentiment pour chaque phrase du texte.

SentimentServer.java

package seanwang; // ... public class SentimentServer { public static SentimentHandler handler; public static SentimentAnalysisService.Processor processor; public static void main(String [] args) { try { handler = new SentimentHandler(); processor = new SentimentAnalysisService.Processor(handler); Runnable simple = new Runnable() { public void run() { simple(processor); } }; new Thread(simple).start(); } catch (Exception x) { x.printStackTrace(); } } public static void simple(SentimentAnalysisService.Processor processor) { try { TServerTransport serverTransport = new TServerSocket(9090); TServer server = new TSimpleServer(new Args(serverTransport).processor(processor)); System.out.println('Starting the simple server...'); server.serve(); } catch (Exception e) { e.printStackTrace(); } } }

Notez que je n'ai pas inclus le fichier SentimentAnalysisService.java ici car il s'agit d'un fichier généré. Vous devez placer le code généré dans un endroit où le reste de votre code peut y accéder.

Maintenant que nous avons le serveur en place, écrivons un client Python pour utiliser le serveur.

client.py

fichiers d'en-tête c++

from sentiment import SentimentAnalysisService from thrift.transport import TSocket from thrift.transport import TTransport from thrift.protocol import TBinaryProtocol class SentimentClient: def __init__(self, server='localhost', socket=9090): transport = TSocket.TSocket(server, socket) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) self.transport = transport self.client = SentimentAnalysisService.Client(protocol) self.transport.open() def __del__(self): self.transport.close() def analyze(self, sentence): return self.client.sentimentAnalyze(sentence) if __name__ == '__main__': client = SentimentClient() print(client.analyze('An amazingly wonderful sentence'))

Exécutez ceci et vous devriez voir:

Muy positivo

Formidable! Maintenant que le serveur est en cours d'exécution et qu'il parle au client, intégrons-le au robot de messagerie en instanciant un client et en le connectant au courrier électronique.

import client # ... @app.route('/analyze', methods=['POST']) def analyze(): sentiment_client = client.SentimentClient() with open('logfile.txt', 'a') as fp_log: fp_log.write(str(request.form.get('text'))) fp_log.write(request.form.get('text')) fp_log.write(sentiment_client.analyze(request.form.get('text'))) return 'Got it'

Maintenant, déployez votre service Java sur la même machine sur laquelle vous exécutez le serveur Web, démarrez le service et redémarrez l'application. Envoyez un e-mail au bot avec une phrase de test et vous devriez voir quelque chose comme ceci dans le fichier journal:

Increíblemente maravillosamente positiva y hermosa frase. Muy positivo

Analyse du courrier électronique

Tout va bien! Maintenant, nous avons un bot de messagerie qui peut effectuer une analyse des sentiments! Nous pouvons envoyer un e-mail et recevoir une étiquette d'opinion pour chaque phrase que nous envoyons. Voyons maintenant comment nous pouvons rendre le renseignement exploitable.

Pour garder les choses simples, concentrons-nous sur les e-mails où il y a une forte concentration de phrases négatives et très négatives. Utilisons un système de notation simple et disons que si un e-mail contient plus de 75% de phrases de sentiment négatif, nous le marquerons comme un e-mail d'alarme potentiel pouvant nécessiter une réponse immédiate. Implémentons la logique de notation dans le chemin d'analyse:

@app.route('/analyze', methods=['POST']) def analyze(): text = str(request.form.get('text')) sentiment_client = client.SentimentClient() text.replace(' ', '') # remove all new lines sentences = text.rstrip('.').split('.') # remove the last period before splitting negative_sentences = [ sentence for sentence in sentences if sentiment_client.analyze(sentence).rstrip() in ['Negative', 'Very negative'] # remove newline char ] urgent = len(negative_sentences) / len(sentences) > 0.75 with open('logfile.txt', 'a') as fp_log: fp_log.write('Received: %s' % (request.form.get('text'))) fp_log.write('urgent = %s' % (str(urgent))) return 'Got it'

Le code ci-dessus fait certaines hypothèses, mais il fonctionnera à des fins de démonstration. Envoyez quelques e-mails à votre bot et vous devriez voir l'analyse des e-mails dans les journaux:

Recibido: Aquí hay una prueba para el sistema. Se supone que es una solicitud no urgente. ¡Es muy bueno! En su mayor parte esto es positivo o neutral. Grandes cosas están sucediendo! urgente = Falso Recibido: esta es una solicitud urgente. Todo es realmente horrible Esto es un desastre. La gente odia este correo insípido. urgente = True

Envoi d'une alerte

Nous avons presque fini!

Nous avons créé un bot de messagerie capable de recevoir des e-mails, d'effectuer une analyse des sentiments et de déterminer si un e-mail nécessite une attention immédiate. Désormais, nous n'avons qu'à envoyer une alerte texte lorsqu'un email est particulièrement négatif.

Nous utiliserons Twilio pour envoyer une alerte texte. Votre API Python, qui est documentée ici , c'est assez simple. Modifions le chemin d'analyse pour soumettre une demande lorsque vous recevez une demande urgente.

def send_message(body): twilio_client.messages.create( to=on_call, from_=os.getenv('TWILIO_PHONE_NUMBER'), body=body ) app = Flask(__name__) @app.route('/analyze', methods=['POST']) def analyze(): text = str(request.form.get('text')) sentiment_client = client.SentimentClient() text.replace(' ', '') # remove all new lines sentences = text.rstrip('.').split('.') # remove the last period before splitting negative_sentences = [ sentence for sentence in sentences if sentiment_client.analyze(sentence).rstrip() in ['Negative', 'Very negative'] # remove newline char ] urgent = len(negative_sentences) / len(sentences) > 0.75 if urgent: send_message('Highly negative email received. Please take action') with open('logfile.txt', 'a') as fp_log: fp_log.write('Received: ' % request.form.get('text')) fp_log.write('urgent = %s' % (str(urgent))) fp_log.write(' ') return 'Got it'

Vous devrez définir les variables d'environnement dans les informations d'identification de votre compte Twilio et définir le numéro d'appel sur un téléphone qu'il peut vérifier. Une fois que vous avez fait cela, envoyez un e-mail au point de terminaison de l'analyse et vous verrez un message texte envoyé au numéro de téléphone en question.

Et nous avons fini!

Traitement simplifié du langage naturel avec la PNL de Stanford

Dans cet article, vous avez appris à créer un bot d'analyse des sentiments des e-mails à l'aide de la bibliothèque PNL de Stanford. La bibliothèque permet d'abstraire tous les détails essentiels du traitement du langage naturel et vous permet de l'utiliser comme élément de base pour vos applications PNL.

J'espère que cet article a démontré l'une des nombreuses applications potentielles étonnantes de l'analyse des sentiments, et que cela vous incite à créer votre propre application PNL.