Per il mio progetto finale per un corso Java avanzato che stavo frequentando a scuola, ho deciso di unire il mio interesse per l'apprendimento automatico con Java e realizzare un progetto di elaborazione del linguaggio naturale. Uno dei progetti più basilari di Natural Language Processing sta analizzando l'analisi del sentiment dei tweet su Twitter. Quindi, naturalmente, ho cercato di analizzare i sentimenti dei tweet con le parole "USA Coronavirus Response".

Ottenere i Dati.

All'inizio di qualsiasi progetto di Machine Learning, la prima cosa che devi fare è ottenere i dati. Per ottenere i tweet dovrai fare la tua analisi, dovrai accedere all'API di Twitter. Python ha un sacco di librerie per farlo, come Tweepy. Tuttavia, stiamo usando Java che non ha tanti pacchetti come Python, ma ha un ottimo pacchetto API di Twitter che possiamo usare per ottenere dati: twitter4j . Innanzitutto, dovresti installare il pacchetto, ti consiglio di utilizzare Maven come build manager per il progetto. Quindi, per aggiungere la libreria twitter4j al tuo progetto java, aggiungilo alla tua vita pom.xml.

<dependencies>
<dependency>
            <groupId>org.twitter4j</groupId>
            <artifactId>twitter4j-core</artifactId>
            <version>4.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.twitter4j</groupId>
            <artifactId>twitter4j-async</artifactId>
            <version>4.0.0</version>
            <scope>test</scope>
</dependency>
</dependencies>

Ecco il codice necessario per raschiare i dati. Rendi questo il tuo file Main.java.

package sample;
​
import twitter4j.*;
import twitter4j.conf.ConfigurationBuilder;
​
public class Main{
    ConfigurationBuilder cb = new ConfigurationBuilder();
        cb.setDebugEnabled(true)
                .setOAuthConsumerKey("Your Consumer Key")               .setOAuthConsumerSecret("Your Consumer Secret")
                .setOAuthAccessToken("Your Access Token")                .setOAuthAccessTokenSecret("Your Access Token Secret");
        TwitterFactory tf = new TwitterFactory(cb.build());
        Twitter twitter = tf.getInstance();
        Query query = new Query("USA Coronavirus Response");
        query.setCount(100);
        QueryResult result = twitter.search(query);
}

Creazione della classe Sentiment Analyzer

Per creare la nostra classe Sentiment Analyzer, utilizzeremo il pacchetto CoreNLP Standford. Per aggiungere questo pacchetto al tuo progetto, aggiungi la seguente dipendenza al tuo file pom.xml.

<dependency>
            <groupId>edu.stanford.nlp</groupId>
            <artifactId>stanford-corenlp</artifactId>
            <version>4.0.0</version>
        </dependency>
        <dependency>
            <groupId>edu.stanford.nlp</groupId>
            <artifactId>stanford-corenlp</artifactId>
            <version>4.0.0</version>
            <classifier>models</classifier>
</dependency>

package sample;
import java.util.Properties;
import org.ejml.simple.SimpleMatrix;
import edu.stanford.nlp.ling.CoreAnnotations;
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.sentiment.SentimentCoreAnnotations.SentimentAnnotatedTree;
import edu.stanford.nlp.trees.Tree;
import edu.stanford.nlp.util.CoreMap;
​
public class SentimentAnalyzer {
    static StanfordCoreNLP pipeline;
​
​
    public static void init() {
        Properties props = new Properties();
        props.setProperty("annotators", "tokenize, ssplit, parse, sentiment");
        pipeline = new StanfordCoreNLP(props);
    }
​
    public static void main(String[] args) {
        init();
    }
​
​
    public static String findSentiment(String tweet) {
​
        int mainSentiment = 0;
        String sentimentType = "NULL";
        if (tweet != null && tweet.length() > 0) {
            int longest = 0;
            Annotation annotation = pipeline.process(tweet);
            for (CoreMap sentence : annotation
                    .get(CoreAnnotations.SentencesAnnotation.class)) {
                Tree tree = sentence
                        .get(SentimentAnnotatedTree.class);
                int sentiment = RNNCoreAnnotations.getPredictedClass(tree);
                sentimentType = sentence.get(SentimentCoreAnnotations.SentimentClass.class);
            }
        }
        return sentimentType;
        //sentiment ranges from very negative, negative, neutral, positive, very positive
    }
​
}

Mettere tutto insieme

Metteremo tutto insieme nel file Main.java. Ecco il codice:

package sample;
​
import twitter4j.*;
import twitter4j.conf.ConfigurationBuilder;
import static sample.SentimentAnalyzer.findSentiment;
import static sample.SentimentAnalyzer.init;
​
public class Main{
    SentimentAnalyzer.init();
    ConfigurationBuilder cb = new ConfigurationBuilder();
        cb.setDebugEnabled(true)
                .setOAuthConsumerKey("Your Consumer Key")               .setOAuthConsumerSecret("Your Consumer Secret")
                .setOAuthAccessToken("Your Access Token")                .setOAuthAccessTokenSecret("Your Access Token Secret");
        TwitterFactory tf = new TwitterFactory(cb.build());
        Twitter twitter = tf.getInstance();
        Query query = new Query("USA Coronavirus Response");
        query.setCount(100);
        QueryResult result = twitter.search(query);
    //The following lines of code initialize variables that represent the number of tweets of each sentiment. 
    
    int num_neutral = 0;
    int num_negative = 0;
    int num_realnegative = 0;
    int num_positive = 0;
    int num_realpositive = 0;
    
    for(int i=0; i<result.getTweets().size(); i++){
        String tweet = result.getTweets().get(i).getText();
            String sentiment = findSentiment(tweet);
            if(sentiment.equalsIgnoreCase("Neutral")){
                num_neutral++;
            }
            else if(sentiment.equalsIgnoreCase("Negative")){
                num_negative++;
            }
            else if(sentiment.equalsIgnoreCase("Very Negative")){
                num_realnegative++;
            }
            else if(sentiment.equalsIgnoreCase("Very Positive")){
                num_realpositive++;
            }
            else{
                num_positive++;
            }       
    }
    
    System.out.println(num_neutral);
    System.out.println(num_negative);
    System.out.println(num_realnegative);
    System.out.println(num_realpositive);
    System.out.println(num_realnegative);
}