Spark kullanarak Twitter Duygu Analizi

Akshay Nagpal2018-07-31 · 15 min read

Bir önceki yazımızda, gerçek zamanlı Twitter verilerini Apache Flume kullanarak ayıklamanın bir yolunu bulmuştum. Şu anda Twitter'dan çok fazla veri elde ettim. Bu nedenle, bu verileri analiz etmek ve bunlardan bazı trendler çıkarmak istiyorum. Twitter verilerinin duygu analizini gerçekleştirmek için başka bir Büyük Veri aracı olan Apache Spark.

Göre: Hortonworks, “Apache Spark, veri çalışanlarının veri kümelerine hızlı yinelemeli erişim gerektiren akış, makine öğrenimi veya SQL iş yüklerini verimli bir şekilde yürütmelerine olanak tanıyan zarif ve ifade gücü yüksek geliştirme API'lerine sahip hızlı, bellek içi bir veri işleme motorudur. Spark'ın Apache Hadoop YARN üzerinde çalışmasıyla, her yerdeki geliştiriciler artık Spark'ın gücünden yararlanmak, içgörüler elde etmek ve Hadoop'taki tek bir paylaşılan veri kümesi içinde veri bilimi iş yüklerini zenginleştirmek için uygulamalar oluşturabilirler.”

Bir Spark programı JAVA, Scala, Python veya R dillerinde yazılabilir. Bu durumda, şununla birlikte JAVA kullanacağız: Maven. Ek olarak Spark, hem HDP hem de Cloudera dağıtımıyla birlikte gelir. Spark 2 şu anda kullanılan sürümdür.

Spark ile duygu analizini gerçekleştirmek için yeni bir Maven projesi oluşturuyorum. Adını 'Twitter Sentiment Analyzer’ koyuyorum. Ardından, gerekli tüm yöntemleri uygulayacağım “TwitterDataFlow.java” adında bir sınıf oluşturuyorum.

Dil Aracı: Yazım Düzeltici

Başlangıçta, POC'ta, tweet'lerdeki yazım yanlışsa Duygu Analizi sonuçlarının olumsuz etkilendiğini gördüm. Bu nedenle, bir SpellChecker (Yazım Denetleyicisi) tanıtıyorum. Bu, tweet'leri Duygu Analizi için kullanmadan önce yazımlarını düzeltmemize yardımcı olacak.

Bunu ‘CorrectSpell’ adında yeni bir statik yöntem oluşturarak yapacağım. Ayrıca, yazımları kontrol etmek ve düzeltmek için bir LanguageTool kullanacağım.

Göre: LanguageTool’un GIT'i, “LanguageTool; İngilizce, Fransızca, Almanca, Lehçe, Rusça ve 20'den fazla diğer dil için açık kaynaklı bir düzeltme okuma yazılımıdır. Basit bir yazım denetleyicinin tespit edemediği birçok hatayı bulur.”

Ardından, pom.xml dosyasına dil aracı için bir bağımlılık ekliyorum:

<dependency>
<groupId>org.languagetool</groupId>
<artifactId>language-en</artifactId>
<version>4.0</version>
</dependency>

Bundan sonra, JLanguageTool sınıfından statik bir sınıf düzeyi değişkeni olan langTool'u tanımlıyorum. Ardından, langTool'u AmericanEnglish sınıfından bir nesne ile başlatıyorum.

Ardından, girdi olarak String text (normal metin) ve dönüş türü olarak da String (Doğru Yazımlı Metin) alan SpellChecker adlı yöntemi kodluyorum. JLanguageTool'un check yöntemini, parametre olarak denetlenmemiş metin ile kullanıyorum. Sonrasında, bu yöntem bir RuleMatch listesi döndürür. JLanguageTool Java Belgelerine göre, RuleMatch sınıfı şunları sağlar: “metinle eşleşen bir hata kuralı ve eşleşmenin konumu hakkında bilgi.”

Bunu takiben, String türünde ‘result’, tamsayı (integer) türünde ‘lastPos’ ve String türünde ‘tmp’ olmak üzere üç değişken tanımlıyorum. Ek olarak, her RuleMatch ile, araçtan gelen ilk önerilen yazımla cümleyi yeniden oluşturuyorum. Bununla birlikte, gereken her yere gerekli try-catch bloklarını ekledim.

package com.CloudSigma.Spark.TwitterSentiment;

import java.util.List;
import org.languagetool.JLanguageTool;
import org.languagetool.language.AmericanEnglish;
import org.languagetool.rules.RuleMatch;


public class LanguageCheck {
	
	static JLanguageTool langTool = new JLanguageTool(new AmericanEnglish());

    public static String CorrectSpell(String text) {
 	
    	 String query = text;
    	 
         try {
             List matches = langTool.check(query);
             String result = "";

             int lastPos = 0;
             String tmp = "";

             for (RuleMatch ma : matches) {

                 try {

                     tmp = ma.getSuggestedReplacements().get(0);
                     result += query.substring(lastPos, ma.getFromPos());
                     result += tmp;
                     lastPos = ma.getToPos();

                 } catch (Exception e) {
                     return text;
                 }
             }

             if (lastPos &lt; query.length()) {
                 result += query.substring(lastPos, query.length());
             }

             return result;

         } catch (Exception e) {
             return text;
         }
    	
    }
    
}

package com.CloudSigma.Spark.TwitterSentiment;

import java.util.List;

import org.languagetool.JLanguageTool;

import org.languagetool.language.AmericanEnglish;

import org.languagetool.rules.RuleMatch;

public class LanguageCheck {

static JLanguageTool langTool = new JLanguageTool(new AmericanEnglish());

public static String CorrectSpell(String text) {

String query = text;

try {

List matches = langTool.check(query);

String result = "";

int lastPos = 0;

String tmp = "";

for (RuleMatch ma : matches) {

try {

tmp = ma.getSuggestedReplacements().get(0);

result += query.substring(lastPos, ma.getFromPos());

result += tmp;

lastPos = ma.getToPos();

} catch (Exception e) {

return text;

}

if (lastPos < query.length()) {

result += query.substring(lastPos, query.length());

}

return result;

} catch (Exception e) {

return text;

}

Duygu Analizörü: Stanford CoreNLP

Spark ile duygu analizindeki bir sonraki adım, metinden duyguları bulmaktır. Bunu yapmak için, duygu değerlerini bulmak üzere Stanford’un Core NLP Kütüphanesini kullanıyorum. Ardından, metnimizdeki duyguları bulmak için kütüphaneyi uygulayacağım ‘StanfordSentiment’ adında bir sınıf oluşturuyorum.

Bunu yapmak için, pom.xml dosyasına aşağıdaki bağımlılıkları ekliyorum:

<!– Bu, stanford Core NLP Kütüphanesidir –>
<dependency>
<groupId>edu.stanford.nlp</groupId>
<artifactId>stanford-corenlp</artifactId>
<version>3.8.0</version>
</dependency>

<!– Bu, stanford Core NLP’nin modeller dosyasıdır –>
<dependency>
<groupId>edu.stanford.nlp</groupId>
<artifactId>stanford-corenlp</artifactId>
<version>3.8.0</version>
<classifier>models</classifier>
</dependency>

Stanford Core NLP’nin işlem hattı için özellikleri tanımlayan statik bir nesne değişkeni olan ‘props’u oluşturuyorum. Mümkün olduğunca hafif olması için minimum özellikleri seçtim. Bundan sonra, annotator'ları tokenize, ssplit, pos, parse, sentiment olarak ayarlıyorum. StanfordCoreNLP sınıfından başka bir statik nesne değişkeni olan ‘pipeline’ı oluşturuyorum. Son olarak, işlem hattını ‘props’ özellikleri ile başlatıyorum.

GetSentiment:

Girdisi String ve çıktısı Double olan GetSentiment adında bir metot oluşturdum. LanguageCheck.java dosyasında oluşturduğum CorrectSpell metodunu kullanıyorum. LanguageCheck nesnesinin CorrectSpell metodu bana girilen tweet'in doğru yazılışını döndürüyor. Bu düzeltilmiş metinle StanfordCoreNLP'nin annotate metodunu kullanıyorum. Bu kütüphane tarafından verilen duygu değerleri şunlardır:

0 => çok olumsuz

1 => olumsuz

2 => nötr

3 => olumlu

4 => çok olumlu

Aşağıdaki yeni Duygu kategorilerini elde etmek için cümle başına sonucu 2 çıkarıyorum:

-2 => çok olumsuz

-1 => olumsuz

0 => nötr

1 => olumlu

2 => çok olumlu

Her bir tweet'in duygu sonucunu, tweet'teki her bir cümlenin duygusunun ortalaması olarak döndürüyorum. Tweetler yapılandırılmış bir biçimde yazılmaz. Bu nedenle, bir tweet'in belirli bir satırına diğerlerinden daha yüksek bir ağırlık atayamam. Dolayısıyla, bir tweet'teki her satırın eşit öneme sahip olduğunu varsayıyorum. Tweet'in nihai duygu değerini içeren Double türündeki ‘total’ değişkenini döndürüyorum.

package com.CloudSigma.Spark.TwitterSentiment;

import java.util.List;
import java.util.Properties;
import edu.stanford.nlp.ling.CoreAnnotations.SentencesAnnotation;
import edu.stanford.nlp.neural.rnn.RNNCoreAnnotations;
import edu.stanford.nlp.pipeline.Annotation;
import edu.stanford.nlp.pipeline.StanfordCoreNLP;
import edu.stanford.nlp.sentiment.SentimentCoreAnnotations;
import edu.stanford.nlp.trees.Tree;
import edu.stanford.nlp.util.CoreMap;
import static com.CloudSigma.Spark.TwitterSentiment.LanguageCheck.*;


public class StanfordSentiment  {

	static Properties props = new Properties();
	static {
	props.setProperty("annotators", "tokenize,ssplit,pos,parse,sentiment");}
	static StanfordCoreNLP pipeline = new StanfordCoreNLP(props);


	public static Double GetSentiment(String text) {
		String checkedText = CorrectSpell(text);

		Annotation document = new Annotation(checkedText);
		pipeline.annotate(document);
		List sentences = document.get(SentencesAnnotation.class);

		Double sum = 0.0;

		for (CoreMap sentence : sentences) {
			Tree tree = sentence.get(SentimentCoreAnnotations.SentimentAnnotatedTree.class);
			int sentiment = RNNCoreAnnotations.getPredictedClass(tree);
			int scaled = sentiment - 2;
			sum = sum + scaled;
		}

		Double total = sum / sentences.size();
		System.out.println("Tweet Metni: " + checkedText);
		System.out.println("Duygu Değeri: " + total);
		return total;
	}

}

paket com.CloudSigma.Spark.TwitterSentiment;

import java.util.List;

import java.util.Properties;

import edu.stanford.nlp.ling.CoreAnnotations.SentencesAnnotation;

import edu.stanford.nlp.neural.rnn.RNNCoreAnnotations;

import edu.stanford.nlp.pipeline.Annotation;

import edu.stanford.nlp.pipeline.StanfordCoreNLP;

import edu.stanford.nlp.sentiment.SentimentCoreAnnotations;

import edu.stanford.nlp.trees.Tree;

import edu.stanford.nlp.util.CoreMap;

import static com.CloudSigma.Spark.TwitterSentiment.LanguageCheck.*;

public class StanfordSentiment {

static Properties props = new Properties();

static {

props.setProperty("annotators", "tokenize,ssplit,pos,parse,sentiment");}

static StanfordCoreNLP pipeline = new StanfordCoreNLP(props);

public static Double GetSentiment(String text) {

String checkedText = CorrectSpell(text);

Annotation document = new Annotation(checkedText);

pipeline.annotate(document);

List sentences = document.get(SentencesAnnotation.class);

Double sum = 0.0;

for (CoreMap sentence : sentences) {

Tree tree = sentence.get(SentimentCoreAnnotations.SentimentAnnotatedTree.class);

int sentiment = RNNCoreAnnotations.getPredictedClass(tree);

int scaled = sentiment - 2;

sum = sum + scaled;

}

Double total = sum / sentences.size();

System.out.println("Tweet Metni: " + checkedText);

System.out.println("Duygu Değeri: " + total);

return total;

}

Program Başlatma:

Bu iki sınıf tamamlandığına göre, bunları kullanmak üzere ilerleyeceğiz. Bu nedenle, yeni bir sınıf olan “TwitterDataFlow.java” dosyasını oluşturuyorum. İlk olarak, yalnızca geçirilen girdi argümanlarının sayısı tam olarak 2 olduğunda programı çalıştıracak koşullu bir kontrol yazıyorum. Argüman sayısı 2'ye eşit değilse, yanlış kullanım mesajını yazdırır ve ayrıca 1 çıkış durumuyla sonlanır.

Uygulama adı Sentiment Analyzer olan bir SparkSession oluşturuyorum. Spark context’in hadoop yapılandırmasının “mapreduce input fileinputformat input dir recursive” özelliğini true olarak ayarlıyorum. Bu, klasörlerden dosyaları özyinelemeli olarak almama olanak tanıyacak. Girdi argümanının yanı sıra Flume tarafından depolanan bölümlenmiş verileri okumamı sağlayacak olan ‘/*/*’ ifadesini de atadığım String sınıfından bir ‘inputPath’ değişkeni oluşturuyorum. Flume'un json verilerini Dataset<Row> ‘data’ içinde okuyorum.

Ardından, Spark SQL Context ile bir String alan ve üzerinde StanfordSentiment’in GetSentiment yöntemini uygulayarak Double değer veri türü döndüren ‘Sentiment’ adında bir UDF (Kullanıcı Tanımlı Fonksiyon) kaydediyorum.

Şu anda flume'dan Apple, Google, Tesla, Infosys, TCS, Oracle, Microsoft ve Facebook anahtar kelimelerine ait verilere sahibim. Bu yüzden, bu anahtar kelimelerle bir String listesi oluşturuyorum. Bu şirketlerin her biri için aşağıdaki işlemleri çalıştırıyorum.

İşlem akışı:

İlk olarak, sonuçları kaydetmek istediğim bir outPath oluşturuyorum. ‘data’ veri kümesi üzerinde geçici bir görünüm olan ‘complete’ oluşturuyorum. Ardından, verilerden timestamp, partitionBy (sonuçları kaydederken verileri bölümlemek için), text, main_text (düzenli ifadeler için kullanmak üzere) ve followers bilgilerini çıkarıyorum.

Sonuçlar üzerinde geçici bir görünüm oluşturuyorum ve oradan belirli bir şirketin verilerini filtreliyorum. Ayrıca, bana ‘seVal’ sütunundaki duygu değerlerini döndüren Sentiment UDF'sini uyguluyorum. Serileştirilmiş verileri bellekte ve disk taşması olarak kalıcı hale getiriyorum. Bu verilerden, Takipçi Sayısı ile o tweet'in Duygu Değeri'nin çarpımı olan NetSentiment değerini elde ediyorum. Bu, o tweet'in sahip olabileceği etkiyi bilmeye yardımcı olur. Bunun için farklı formüllerim olabilir.

Duygu analizi hesaplama açısından yoğun bir görev olduğundan, tüm sonucun depolanmasını istediğimiz için serileştirilmiş verileri bellekte ve diskte kalıcı hale getiriyoruz. Bunu kalıcı hale getirmezsek ve NetSentiment veya etkiyi hesaplamak için birden fazla formül kullanmayı planlarsak, Sentiment yönteminin değerini birden çok kez kullanacağımız önceki sorguda, tweet'in Duygu Analizini birden çok kez yapacaktır.

Veri gruplama:

Şimdi, verileri timestamp ve partitionBy sütununa göre gruplandırıyorum ve bu gruplandırma ile NetSentiment ortalamasını alıyorum. Bu bana şirketin belirli bir dakikadaki olumlu veya olumsuz ortalama etkisini veriyor. Sonuç olarak, her şirket için sonuçları partitionBy sütununa göre bölümlendirerek outPath içine yazıyorum.

package com.CloudSigma.Spark.TwitterSentiment;

import java.util.Arrays;
import java.util.List;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.storage.StorageLevel;
import static com.CloudSigma.Spark.TwitterSentiment.StanfordSentiment.*;


public class TwitterDataFlow {

	public static void main(String[] args) {

		if (args.length != 2) {
			System.out.println("Geçersiz argüman sayısı! \n");
			System.out.println(
					"Kullanım: Girdi Çıktı \n " + "Girdi: Bölümlenmiş verilerin okunması gereken konum"
							+ "Çıktı: Nihai sonucun saklanması gereken yer");
			System.exit(1);
		}
		

		

		SparkSession spark = SparkSession.builder().appName("Sentiment Analyzer").getOrCreate();

		spark.sparkContext().hadoopConfiguration().set("mapreduce.input.fileinputformat.input.dir.recursive", "true");

		String inputPath = args[0] + "/*/*";

		Dataset data = spark.read().json(inputPath);


		spark.sqlContext().udf().register("Sentiment", (String s) -&gt; GetSentiment(s), DataTypes.DoubleType);

		List list = Arrays.asList("apple", "google", "tesla", "infosys", "tcs", "oracle", "microsoft",
				"facebook");

		String query;
		String outPath;

		Dataset result;

		for (String company : list) {

			outPath = args[1] + "/" + company;

			data.createOrReplaceTempView("complete");

			// tmp1; TimeStamp, partitionBy (Tarih), tweet metni, küçük harfli tweet metni
			// ve tweet atan kullanıcının followers_count değerini çıkarır
			Dataset tmp1 = spark.sql(
						"select concat(substr(created_at,5,6), substr(created_at,26,5),' ',substr(created_at,12,6),'00') as timestamp,substr(created_at,5,6) as partitionBy,text,lower(text) as main_text,user.followers_count as followers from complete");

			tmp1.createOrReplaceTempView("tmp");

			// İçinde belirli şirket adları geçen tweetleri filtreleme
			Dataset tmp2 = spark.sql("select * from tmp where main_text regexp '(" + company + ")'");

			// twitter adında bir görünüm oluşturur
			tmp2.createOrReplaceTempView("twitter");

			// tmp3, seçilen tüm verileri ve tweetlerin
			// Sentiment değerini içerir
			Dataset tmp3 = spark.sql("select  *, Sentiment(text) as seVal from twitter");

			tmp3.persist(StorageLevel.MEMORY_AND_DISK());

			// Başka bir görünüm oluşturma
			tmp3.createOrReplaceTempView("dataSe");

			Dataset net = spark.sql(
					"select  *,followers*seVal as NetSentiment from dataSe");

			// Verileri kaydetmek için nihai bir görünüm oluşturma
			net.createOrReplaceTempView("final");

			// Verileri gruplandırarak dakika başına Duygu Değerlerinin ortalamasını alma
			query = "select timestamp,partitionBy,AVG(NetSentiment) from final group by timestamp,partitionBy";

			// Sonucu result veri kümesine kaydetme
			result = spark.sql(query);

			// Sonucu diske yazma
			result.write().partitionBy("partitionBy").json(outPath);
		}
	}
}

package com.CloudSigma.Spark.TwitterSentiment;

import java.util.Arrays;

import java.util.List;

import org.apache.spark.sql.Dataset;

import org.apache.spark.sql.Row;

import org.apache.spark.sql.SparkSession;

import org.apache.spark.sql.types.DataTypes;

import org.apache.spark.storage.StorageLevel;

import static com.CloudSigma.Spark.TwitterSentiment.StanfordSentiment.*;

public class TwitterDataFlow {

public static void main(String[] args) {

if (args.length != 2) {

System.out.println("Geçersiz argüman sayısı! \n");

System.out.println(

"Kullanım: Girdi Çıktı \n " + "Girdi: Bölümlenmiş verilerin okunması gereken konum"

+ "Çıktı: Nihai sonucun saklanması gereken yer");

System.exit(1);

}

SparkSession spark = SparkSession.builder().appName("Sentiment Analyzer").getOrCreate();

spark.sparkContext().hadoopConfiguration().set("mapreduce.input.fileinputformat.input.dir.recursive", "true");

String inputPath = args[0] + "/*/*";

Dataset data = spark.read().json(inputPath);

spark.sqlContext().udf().register("Sentiment", (String s) -> GetSentiment(s), DataTypes.DoubleType);

List list = Arrays.asList("apple", "google", "tesla", "infosys", "tcs", "oracle", "microsoft",

"facebook");

String query;

String outPath;

Dataset result;

for (String company : list) {

outPath = args[1] + "/" + company;

data.createOrReplaceTempView("complete");

// tmp1 extracts TimeStamp, partitionBy (Date), tweet text, tweet text in lower

// case and followers_count of the user tweeting

Dataset tmp1 = spark.sql(

"select concat(substr(created_at,5,6), substr(created_at,26,5),' ',substr(created_at,12,6),'00') as timestamp,substr(created_at,5,6) as partitionBy,text,lower(text) as main_text,user.followers_count as followers from complete");

tmp1.createOrReplaceTempView("tmp");

// Filtering tweets having certain company names in it

Dataset tmp2 = spark.sql("select * from tmp where main_text regexp '(" + company + ")'");

// Creates a view named twitter

tmp2.createOrReplaceTempView("twitter");

// tmp3 contains the entire selected data along with the Sentiment value of the

// tweets

Dataset tmp3 = spark.sql("select *, Sentiment(text) as seVal from twitter");

tmp3.persist(StorageLevel.MEMORY_AND_DISK());

// Creating another view

tmp3.createOrReplaceTempView("dataSe");

Dataset net = spark.sql(

"select *,followers*seVal as NetSentiment from dataSe");

// Creating a final view to save the data

net.createOrReplaceTempView("final");

// Averaging the Sentiment Values per minute by grouping the data onto it

query = "select timestamp,partitionBy,AVG(NetSentiment) from final group by timestamp,partitionBy";

// Saving the result in result dataset

result = spark.sql(query);

// Writing the result onto the disk

result.write().partitionBy("partitionBy").json(outPath);

}

Ayrıca, kod tamamlandıktan sonra, içindeki tüm bağımlılıklarla birlikte çalıştırılabilir bir jar dışa aktarıyorum ve bunu bu işi çalıştırmak istediğim sunucuya kopyalıyorum. Ardından, aşağıdaki komutu kullanarak gönderebilirim,

spark-submit --master yarn --deploy-mode cluster SentimentAnalyzer.jar /flume/Twitter/PublicStream/ /flume/output

1	spark-submit --master yarn --deploy-mode cluster SentimentAnalyzer.jar /flume/Twitter/PublicStream/ /flume/output

burada (Kaynak):

--master: Küme için master URL (örneğin spark://23.195.26.187:7077)

--deploy-mode: Sürücünüzün (driver) çalışan düğümlerde (küme) mi yoksa yerel olarak harici bir istemci (istemci) olarak mı dağıtılacağı (varsayılan: istemci)
uygulama-jar: Uygulamanızı ve tüm bağımlılıkları içeren paketlenmiş bir jar dosyasının yolu. URL'nin kümeniz içinde küresel olarak görünür olması gerektiğini göz önünde bulundurun, örneğin tüm düğümlerde mevcut olan bir hdfs:// yolu veya bir file:// yolu.
uygulama-argümanları: Varsa, ana sınıfınızın ana metoduna iletilen argümanlar. Burada, giriş ve çıkış yolu

Son Adımlar:

Ardından, Spark kullanarak yapılan duygu analizinin sonuçlarını çıkış yolundan alacağız. Örneğin, apple için olası bir sonuç şöyledir:

{“timestamp”:”Apr 30 2018 20:31:00″,”avg(NetSentiment)”:-3678.768518518518}
{“timestamp”:”Apr 30 2018 20:32:00″,”avg(NetSentiment)”:-883.002824858757}

Bu uygulamayı 5 düğümlü bir HDP kümesi ile CloudSigma üzerinde dağıttım. Özellikle, her bir düğüm aşağıdaki yapılandırmaya sahipti:

256 GB SSD
16 GB RAM
20 GHz CPU

Sonuç olarak, Spark kullanarak yapılan duygu analizinden yaklaşık 19 saat içinde sonuç alabildim. Ayrıca, 80+ GB'lık bir veri kümesi üzerinde programdan daha gelişmiş hesaplamalar ekledim.

Kod şurada bulunabilir: GITHUB.

Akshay Nagpal

Yazar · CloudSigma

Preslav Dobrev, CloudSigma'da Kreatif Tasarımcı olarak görev yapmakta olup geleneksel ve yenilikçi pazarlama kanallarını kullanarak tutarlı bir kurumsal kimlik oluşturmaya odaklanmaktadır. Sanatsal vizyonu stratejik pazarlamayla harmanlayarak etkili marka anlatıları oluşturma konusunda oldukça yeteneklidir.

Spark kullanarak Twitter Duygu Analizi

Dil Aracı: Yazım Düzeltici

Duygu Analizörü: Stanford CoreNLP

GetSentiment:

Program Başlatma:

İşlem akışı:

Veri gruplama:

Son Adımlar:

Akshay Nagpal

Yorumlar