As tecnologias de processamento de linguagem natural tornaram-se bastante sofisticadas nos últimos anos. De gigantes da tecnologia a entusiastas, muitos estão correndo para construir interfaces ricas que possam analisar, entender e responder à linguagem natural. Alexa da Amazon, Cortana da Microsoft, Google Home do Google e Siri da Apple visam mudar a forma como interagimos com os computadores.

A análise de sentimento, um subcampo do processamento de linguagem natural, consiste em técnicas que determinam o tom de um texto ou fala. Hoje, com o aprendizado de máquina e grandes quantidades de dados coletados de mídias sociais e sites de revisão, podemos treinar modelos para identificar o sentimento de uma passagem de linguagem natural com precisão razoável.

Neste tutorial, você aprenderá como construir um bot que pode analisar o sentimento dos emails que recebe e notificá-lo sobre emails que podem exigir sua atenção imediatamente.

Analisando sentimento em e-mails

O bot será construído usando uma mistura de Java e Desenvolvimento Python . Os dois processos se comunicarão um com o outro usando Thrift. Se você não estiver familiarizado com uma ou ambas as linguagens, poderá continuar lendo, pois os conceitos fundamentais deste artigo também serão válidos para outras linguagens.

Para determinar se um e-mail precisa de sua atenção, o bot irá analisá-lo e determinar se há um tom negativo forte. Em seguida, ele enviará um alerta de texto, se necessário.

Usaremos Sendgrid para se conectar à nossa caixa de correio e Twilio para enviar alertas de texto.

Análise de sentimento: um problema enganosamente simples

Existem palavras que associamos a emoções positivas, como amor, alegria e prazer. E, existem palavras que associamos com emoções negativas, como ódio, tristeza e dor. Por que não treinar o modelo para reconhecer essas palavras e contar a frequência relativa e a força de cada palavra positiva e negativa?

Bem, existem alguns problemas com isso.

Primeiro, existe o problema da negação. Por exemplo, uma frase como “O pêssego não é ruim” implica em uma emoção positiva usando uma palavra que geralmente associamos a ser negativa. Um modelo simples de saco de palavras não será capaz de reconhecer a negação nesta frase.

Além disso, sentimentos mistos provam ser outro problema com a análise de sentimento ingênua. Por exemplo, uma frase como “O pêssego não é ruim, mas a maçã é realmente terrível” contém sentimentos mistos de intensidades misturadas que interagem entre si. Uma abordagem simples não será capaz de resolver os sentimentos combinados, a intensidade diferente ou as interações entre os sentimentos.

Análise de sentimento usando rede de tensores neurais recursivos

o Stanford Natural Language Processing biblioteca para análise de sentimento resolve esses problemas usando uma rede de tensor neural recursiva (RNTN).

O algoritmo RNTN primeiro divide uma frase em palavras individuais. Em seguida, ele constrói uma rede neural onde os nós são as palavras individuais. Finalmente, uma camada tensorial é adicionada para que o modelo possa se ajustar adequadamente às interações entre as palavras e frases.

Você pode encontrar uma demonstração visual do algoritmo em seu website oficial .

O grupo de PNL de Stanford treinou a rede de tensores neurais recursivos usando análises de filmes IMDB marcadas manualmente e descobriu que seu modelo é capaz de prever o sentimento com uma precisão muito boa.

Bot que recebe emails

A primeira coisa que você deseja fazer é configurar a integração de e-mail para que os dados possam ser canalizados para o seu bot.

Há muitas maneiras de fazer isso, mas por uma questão de simplicidade, vamos configurar um servidor web simples e usar o gancho de análise de entrada de Sendgrid para canalizar e-mails para o servidor. Podemos encaminhar e-mails para o endereço de análise de entrada de Sendgrid. Sendgrid irá então enviar uma solicitação POST para nosso servidor web, e então seremos capazes de processar os dados através de nosso servidor.

Para construir o servidor, vamos usar Flask, uma estrutura web simples para Pitão .

Além de construir o servidor web, queremos conectar o serviço web a um domínio. Para resumir, vamos pular a escrita sobre isso no artigo. No entanto, você pode ler mais sobre isso Aqui .

Construindo um servidor web em Frasco é incrivelmente simples.

Basta criar um app.py e adicione isso ao arquivo:

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')

Se implementarmos este aplicativo atrás de um nome de domínio e atingirmos o ponto de extremidade “/ analisar”, você deverá ver algo assim:

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

Em seguida, queremos enviar e-mails para este endpoint.

Você pode encontrar mais documentação Aqui mas você deseja essencialmente configurar o Sendgrid para ser o seu processador de e-mail e fazer com que o Sendgrid encaminhe os e-mails para o nosso servidor web.

Aqui está minha configuração no Sendgrid. Isso encaminhará emails para @sentibot.shanglunwang.com como solicitações POST para “http://sentiments.shanglunwang.com/analyze”:

Você pode usar qualquer outro serviço que ofereça suporte ao envio de e-mails de entrada por webhooks.

Depois de configurar tudo, tente enviar um e-mail para o seu endereço Sendgrid. Você deverá ver algo assim nos logs:

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

Isso é ótimo! Agora você tem um bot que pode receber e-mails. Isso é metade do que estamos tentando fazer.

Agora, você quer dar a este bot a capacidade de analisar sentimentos em e-mails.

Análise de sentimento de e-mail com Stanford NLP

Como a biblioteca Stanford NLP é escrita em Java, queremos construir o mecanismo de análise em Java.

Vamos começar baixando a biblioteca e os modelos de PNL de Stanford no Maven. Crie um novo Java projeto, adicione o seguinte às dependências do Maven e importe:

edu.stanford.nlp stanford-corenlp 3.6.0

O mecanismo de análise de sentimento de Stanford NLP pode ser acessado especificando o anotador de sentimento no código de inicialização do pipeline. A anotação pode então ser recuperada como uma estrutura de árvore.

Para os fins deste tutorial, queremos apenas saber o sentimento geral de uma frase, portanto, não precisamos analisar a árvore. Precisamos apenas olhar para o nó base.

Isso torna o código principal relativamente simples:

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 = 'Amazingly grateful beautiful friends are fulfilling an incredibly joyful accomplishment. What an truly terrible idea.'; 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); } } }

Experimente algumas frases e você verá as anotações apropriadas. Executando as saídas de código de exemplo:

Very Positive Negative

Integrando o Bot e o Analysis Engine

Portanto, temos um programa analisador de sentimento escrito em Java e um bot de e-mail escrito em Python. Como fazemos com que eles falem uns com os outros?

Existem muitas soluções possíveis para este problema, mas aqui vamos usar Thrift . Vamos girar o Sentiment Analyzer como um servidor Thrift e o bot de e-mail como um cliente Thrift.

Thrift é um gerador de código e um protocolo usado para permitir que dois aplicativos, geralmente escritos em linguagens diferentes, sejam capazes de se comunicarem usando um protocolo definido. As equipes poliglotas usam o Thrift para construir redes de microsserviços para aproveitar o melhor de cada linguagem que usam.

Para usar Thrift, precisaremos de duas coisas: a .thrift arquivo para definir os pontos de extremidade de serviço e código gerado para fazer uso do protocolo definido no .proto Arquivo. Para o serviço do analisador, o sentiment.thrift se parece com isso:

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

Podemos gerar código de cliente e servidor usando este arquivo .thrift. Corre:

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

Nota: Eu gerei o código em uma máquina Windows. Você desejará usar o caminho apropriado para o executável Thrift em seu ambiente.

Agora, vamos fazer as alterações apropriadas no mecanismo de análise para criar um servidor. Seu programa Java deve ser semelhante a este:

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); } }

Esse manipulador é onde recebemos a solicitação de análise por meio do protocolo 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; } }

O Analyzer usa a biblioteca Stanford NLP para determinar o sentimento do texto e produz uma string contendo as anotações de sentimento para cada frase do texto.

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(); } } }

Observe que eu não incluí o SentimentAnalysisService.java arquivo aqui, pois é um arquivo gerado. Você vai querer colocar o código gerado em um local onde o resto do seu código possa acessá-lo.

Agora que temos o servidor ativo, vamos escrever um cliente Python para usar o servidor.

client.py

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'))

Execute isso e você verá:

Very Positive

Ótimo! Agora que temos o servidor em execução e conversando com o cliente, vamos integrá-lo ao bot de e-mail instanciando um cliente e canalizando o e-mail para ele.

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'

Agora implante seu serviço Java na mesma máquina em que você está executando o servidor da web, inicie o serviço e reinicie o aplicativo. Envie um e-mail para o bot com uma frase de teste e você deverá ver algo assim no arquivo de log:

Amazingly wonderfully positive and beautiful sentence. Very Positive

Analisando o Email

Tudo certo! Agora temos um bot de e-mail capaz de realizar análises de sentimento! Podemos enviar um e-mail e receber uma etiqueta de sentimento para cada frase enviada. Agora, vamos explorar como podemos tornar a inteligência acionável.

Para manter as coisas simples, vamos nos concentrar em e-mails onde há uma alta concentração de frases negativas e muito negativas. Vamos usar um sistema de pontuação simples e dizer que se um e-mail contiver mais de 75% de sentenças de sentimento negativo, marcaremos isso como um potencial e-mail de alarme que pode exigir uma resposta imediata. Vamos implementar a lógica de pontuação na rota de análise:

@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'

O código acima faz algumas suposições, mas funcionará para fins de demonstração. Envie alguns e-mails para o seu bot e você verá a análise do e-mail nos logs:

Received: Here is a test for the system. This is supposed to be a non-urgent request. It's very good! For the most part this is positive or neutral. Great things are happening! urgent = False Received: This is an urgent request. Everything is truly awful. This is a disaster. People hate this tasteless mail. urgent = True

Enviando um Alerta

Estamos quase terminando!

Construímos um bot de e-mail que pode receber e-mails, realizar análises de sentimento e determinar se um e-mail requer atenção imediata. Agora, só temos que enviar um alerta de texto quando um e-mail for particularmente negativo.

Usaremos Twilio para enviar um alerta de texto. Sua API Python, que está documentada Aqui , é bastante simples. Vamos modificar a rota de análise para enviar uma solicitação quando receber uma solicitação 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'

Você precisará definir as variáveis ​​de ambiente para as credenciais da sua conta Twilio e definir o número de plantão para um telefone que você possa verificar. Depois de fazer isso, envie um e-mail para o endpoint de análise e você verá um texto sendo enviado para o número de telefone em questão.

o que é uma restrição de design

E pronto!

Processamento de linguagem natural facilitado com Stanford PNL

Neste artigo, você aprendeu como construir um bot de análise de sentimento de e-mail usando a biblioteca de PNL de Stanford. A biblioteca ajuda a abstrair todos os detalhes essenciais do processamento de linguagem natural e permite que você a use como um bloco de construção para seus aplicativos de PNL.

Espero que este post tenha demonstrado uma das muitas aplicações potenciais incríveis da análise de sentimento, e que isso inspire você a construir uma aplicação de PNL própria.

Você pode encontrar o código para o bot de análise de sentimento de e-mail neste tutorial de PNL em GitHub .

Relacionado: Quatro armadilhas da precisão da análise de sentimento

Compreender o básico

O que é processamento de linguagem natural?

O processamento de linguagem natural é o uso de algoritmos para analisar e compreender a fala humana comum para determinar métricas como o sentimento.

O que é a biblioteca de PNL de Stanford?

A biblioteca Stanford NLP é um conjunto de software de processamento de linguagem natural escrito em Java, desenvolvido e disponibilizado em código aberto pelo Stanford NLP Group.

O que são Redes de Tensores Neurais Recursivos (RNTN)?

Redes de tensores neurais recursivas são grupos de redes neurais organizadas em uma estrutura de árvore onde cada nó é uma rede neural. Eles são particularmente úteis no processamento de linguagem natural, onde o algoritmo processa palavras e sua interação em uma frase.