Cara Membuat Bot Analisis Sentimen Email: Tutorial NLP

Teknologi pemrosesan bahasa alami telah menjadi sangat canggih selama beberapa tahun terakhir. Dari raksasa teknologi hingga penghobi, banyak yang bergegas membangun antarmuka kaya yang dapat menganalisis, memahami, dan merespons bahasa alami. Alexa dari Amazon, Cortana dari Microsoft, Google Home Google, dan Siri dari Apple semuanya bertujuan untuk mengubah cara kita berinteraksi dengan komputer.

Analisis sentimen, subbidang pemrosesan bahasa alami, terdiri dari teknik yang menentukan nada teks atau ucapan. Saat ini, dengan pembelajaran mesin dan sejumlah besar data yang diambil dari media sosial dan situs ulasan, kami dapat melatih model untuk mengidentifikasi sentimen dari bagian bahasa alami dengan akurasi yang wajar.

Dalam tutorial ini, Anda akan belajar bagaimana membuat bot yang dapat menganalisis sentimen email yang diterimanya dan memberi tahu Anda tentang email yang mungkin memerlukan perhatian Anda segera.

Menganalisis Sentimen dalam Email

Bot akan dibangun menggunakan campuran pengembangan Java dan Python. Kedua proses akan berkomunikasi satu sama lain menggunakan Hemat. Jika Anda tidak terbiasa dengan salah satu atau kedua bahasa ini, Anda masih dapat membaca karena konsep dasar artikel ini juga berlaku untuk bahasa lain.

Untuk menentukan apakah sebuah email membutuhkan perhatian Anda, bot akan menguraikannya dan menentukan apakah ada nada negatif yang kuat. Ini kemudian akan mengirimkan peringatan teks jika diperlukan.

Kami akan menggunakan Sendgrid untuk terhubung ke kotak surat kami dan Twilio untuk mengirimkan peringatan teks.

Analisis Sentimen: Masalah Sederhana yang Terlihat

Ada kata-kata yang kita kaitkan dengan emosi positif, seperti cinta, kegembiraan, dan kesenangan. Dan, ada kata-kata yang kita kaitkan dengan emosi negatif, seperti benci, sedih, dan sakit. Mengapa tidak melatih model untuk mengenali kata-kata ini dan menghitung frekuensi dan kekuatan relatif dari setiap kata positif dan negatif?

Nah, ada beberapa masalah dengan itu.

Pertama, ada masalah negasi. Misalnya, kalimat seperti "Persik tidak buruk" menyiratkan emosi positif menggunakan kata yang paling sering kita kaitkan dengan negatif. Model bag-of-words sederhana tidak akan bisa mengenali negasi dalam kalimat ini.

Selanjutnya, sentimen campuran terbukti menjadi masalah lain dengan analisis sentimen naif. Misalnya, kalimat seperti "Persik tidak buruk, tetapi apel benar-benar mengerikan" mengandung sentimen campuran dengan intensitas campuran yang berinteraksi satu sama lain. Pendekatan sederhana tidak akan mampu menyelesaikan gabungan sentimen, perbedaan intensitas, atau interaksi antar sentimen.

Analisis Sentimen Menggunakan Recursive Neural Tensor Network

Pustaka Pemrosesan Bahasa Alami Stanford untuk analisis sentimen menyelesaikan masalah ini menggunakan Recursive Neural Tensor Network (RNTN).

Algoritma RNTN pertama-tama membagi kalimat menjadi kata-kata individual. Kemudian membangun jaringan saraf di mana node adalah kata-kata individu. Terakhir, lapisan tensor ditambahkan sehingga model dapat menyesuaikan interaksi antara kata dan frasa dengan tepat.

Anda dapat menemukan demonstrasi visual dari algoritme di situs web resmi mereka.

Grup Stanford NLP melatih Recursive Neural Tensor Network menggunakan ulasan film IMDB yang diberi tag secara manual dan menemukan bahwa model mereka mampu memprediksi sentimen dengan akurasi yang sangat baik.

Bot yang Menerima Email

Hal pertama yang ingin Anda lakukan adalah menyiapkan integrasi email sehingga data dapat disalurkan ke bot Anda.

Ada banyak cara untuk mencapai ini, tetapi demi kesederhanaan, mari siapkan server web sederhana dan gunakan kait penguraian masuk Sendgrid untuk menyalurkan email ke server. Kami dapat meneruskan email ke alamat parse masuk Sendgrid. Sendgrid kemudian akan mengirimkan permintaan POST ke server web kami, dan kami kemudian akan dapat memproses data melalui server kami.

Untuk membangun server, kami akan menggunakan Flask, kerangka kerja web sederhana untuk Python.

Selain membangun server web, kami ingin menghubungkan layanan web ke domain. Untuk singkatnya, kami akan melewatkan penulisan tentang ini di artikel. Namun, Anda dapat membaca lebih lanjut tentangnya di sini.

Membangun server web di Flask sangat sederhana.

Cukup buat app.py dan tambahkan ini ke file:

 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 \n' % datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')) return "Got it" app.run(host='0.0.0.0')

Jika kami menerapkan aplikasi ini di belakang nama domain dan mencapai titik akhir "/ menganalisis", Anda akan melihat sesuatu seperti ini:

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

Selanjutnya, kami ingin mengirim email ke titik akhir ini.

Anda dapat menemukan lebih banyak dokumentasi di sini tetapi pada dasarnya Anda ingin mengatur Sendgrid menjadi pemroses email Anda dan meminta Sendgrid meneruskan email ke server web kami.

Ini adalah pengaturan saya di Sendgrid. Ini akan meneruskan email ke @sentibot.shanglunwang.com sebagai permintaan POST ke “http://sentiments.shanglunwang.com/analyze”:

Anda dapat menggunakan layanan lain yang mendukung pengiriman email masuk melalui webhook.

Setelah mengatur semuanya, coba kirim email ke alamat Sendgrid Anda, Anda akan melihat sesuatu seperti ini di log:

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

Itu keren! Anda sekarang memiliki bot yang dapat menerima email. Itu adalah setengah dari apa yang kami coba lakukan.

Sekarang, Anda ingin memberi bot ini kemampuan untuk menganalisis sentimen dalam email.

Analisis Sentimen Email dengan Stanford NLP

Karena perpustakaan Stanford NLP ditulis dalam Java, kami ingin membangun mesin analisis di Jawa.

Mari kita mulai dengan mengunduh perpustakaan dan model Stanford NLP di Maven. Buat proyek Java baru, tambahkan berikut ini ke dependensi Maven Anda, dan impor:

 <dependency> <groupId>edu.stanford.nlp</groupId> <artifactId>stanford-corenlp</artifactId> <version>3.6.0</version> </dependency>

Mesin analisis sentimen Stanford NLP dapat diakses dengan menentukan annotator sentimen dalam kode inisialisasi saluran. Anotasi kemudian dapat diambil sebagai struktur pohon.

Untuk keperluan tutorial ini, kita hanya ingin mengetahui sentimen umum dari sebuah kalimat, jadi kita tidak perlu mengurai pohon. Kita hanya perlu melihat simpul dasar.

Ini membuat kode utama relatif sederhana:

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

Cobalah beberapa kalimat dan Anda akan melihat anotasi yang sesuai. Menjalankan output kode contoh:

 Very Positive Negative

Mengintegrasikan Bot dan Mesin Analisis

Jadi kami memiliki program penganalisis sentimen yang ditulis dalam Java dan bot email yang ditulis dengan Python. Bagaimana kita membuat mereka berbicara satu sama lain?

Ada banyak kemungkinan solusi untuk masalah ini, tetapi di sini kita akan menggunakan Hemat. Kami akan menjalankan Penganalisis Sentimen sebagai server Hemat dan bot email sebagai klien Hemat.

Hemat adalah generator kode dan protokol yang digunakan untuk mengaktifkan dua aplikasi, sering ditulis dalam bahasa yang berbeda, untuk dapat berkomunikasi satu sama lain menggunakan protokol yang ditentukan. Tim Polyglot menggunakan Thrift untuk membangun jaringan layanan mikro untuk memanfaatkan yang terbaik dari setiap bahasa yang mereka gunakan.

Untuk menggunakan Thrift, kita memerlukan dua hal: file .thrift untuk menentukan titik akhir layanan, dan kode yang dihasilkan untuk menggunakan protokol yang ditentukan dalam file .proto . Untuk layanan penganalisis, sentiment.thrift terlihat seperti ini:

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

Kami dapat menghasilkan kode klien dan server menggunakan file .thrift ini. Lari:

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

Catatan: Saya membuat kode pada mesin Windows. Anda akan ingin menggunakan jalur yang sesuai ke Thrift yang dapat dieksekusi di lingkungan Anda.

Sekarang, mari kita buat perubahan yang sesuai pada mesin analisis untuk membuat server. Program Java Anda akan terlihat seperti ini:

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

Handler ini adalah tempat kami menerima permintaan analisis melalui protokol Thrift.

SentimenAnalyzer.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 += "\n"; } return output; } }

Penganalisis menggunakan perpustakaan Stanford NLP untuk menentukan sentimen teks dan menghasilkan string yang berisi anotasi sentimen untuk setiap kalimat dalam teks.

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

Perhatikan bahwa saya tidak menyertakan file SentimentAnalysisService.java di sini karena ini adalah file yang dihasilkan. Anda akan ingin meletakkan kode yang dihasilkan di tempat di mana sisa kode Anda dapat mengaksesnya.

Sekarang setelah server kita aktif, mari kita tulis klien Python untuk menggunakan server.

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

Jalankan ini dan Anda akan melihat:

 Very Positive

Besar! Sekarang setelah server kita berjalan dan berbicara dengan klien, mari kita integrasikan dengan bot email dengan membuat instance klien dan menyalurkan email ke dalamnya.

 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"

Sekarang terapkan layanan Java Anda ke mesin yang sama tempat Anda menjalankan server web, mulai layanan, dan mulai ulang aplikasi. Kirim email ke bot dengan kalimat percobaan dan Anda akan melihat sesuatu seperti ini di file log:

 Amazingly wonderfully positive and beautiful sentence. Very Positive

Menganalisis Email

Baiklah! Sekarang kami memiliki bot email yang mampu melakukan analisis sentimen! Kami dapat mengirim email dan menerima tag sentimen untuk setiap kalimat yang kami kirim. Sekarang, mari kita jelajahi bagaimana kita dapat membuat intelijen dapat ditindaklanjuti.

Untuk mempermudah, mari fokus pada email yang memiliki konsentrasi kalimat negatif dan sangat negatif yang tinggi. Mari gunakan sistem penilaian sederhana dan katakan bahwa jika email berisi lebih dari 75% kalimat sentimen negatif, kami akan menandainya sebagai email alarm potensial yang mungkin memerlukan tanggapan segera. Mari kita terapkan logika penilaian dalam rute analisis:

 @app.route('/analyze', methods=['POST']) def analyze(): text = str(request.form.get('text')) sentiment_client = client.SentimentClient() text.replace('\n', '') # 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"

Kode di atas membuat beberapa asumsi tetapi akan berfungsi untuk tujuan demonstrasi. Kirim beberapa email ke bot Anda dan Anda akan melihat analisis email di log:

 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

Mengirim Peringatan

Kami hampir selesai!

Kami telah membangun bot email yang dapat menerima email, melakukan analisis sentimen, dan menentukan apakah email memerlukan perhatian segera. Sekarang, kita hanya perlu mengirimkan peringatan teks ketika email sangat negatif.

Kami akan menggunakan Twilio untuk mengirimkan peringatan teks. API Python mereka, yang didokumentasikan di sini, cukup mudah. Mari kita ubah rute analisis untuk mengirimkan permintaan saat menerima permintaan mendesak.

 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('\n', '') # 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("\n") return "Got it"

Anda perlu mengatur variabel lingkungan Anda ke kredensial akun Twilio Anda dan mengatur nomor panggilan ke telepon yang dapat Anda periksa. Setelah Anda selesai melakukannya, kirim email ke titik akhir analisis dan Anda akan melihat teks yang dikirim ke nomor telepon yang dimaksud.

Dan kita sudah selesai!

Pemrosesan Bahasa Alami Menjadi Mudah dengan Stanford NLP

Dalam artikel ini, Anda mempelajari cara membuat bot analisis sentimen email menggunakan perpustakaan Stanford NLP. Pustaka membantu mengabstraksikan semua detail seluk beluk pemrosesan bahasa alami dan memungkinkan Anda menggunakannya sebagai blok bangunan untuk aplikasi NLP Anda.

Saya harap posting ini telah menunjukkan salah satu dari banyak potensi aplikasi analisis sentimen yang luar biasa, dan ini menginspirasi Anda untuk membangun aplikasi NLP Anda sendiri.

Anda dapat menemukan kode untuk bot analisis sentimen email dari tutorial NLP ini di GitHub.