Pour mon projet de fin d'études pour un cours Java avancé que je suivais à l'école, j'ai décidé de combiner mon intérêt pour l'apprentissage automatique avec Java et de faire un projet de traitement du langage naturel. L'un des projets de traitement du langage naturel les plus élémentaires consiste à analyser l'analyse des sentiments des tweets sur Twitter. Alors naturellement, j'ai tenté d'analyser les sentiments des tweets avec les mots "USA Coronavirus Response".

Obtention des données.

Au début de tout projet de Machine Learning, la première chose à faire est d'obtenir des données. Pour obtenir les tweets dont vous aurez besoin pour faire votre analyse, vous allez devoir accéder à l'API Twitter. Python a une tonne de bibliothèques pour faire cela, comme Tweepy. Cependant, nous utilisons Java qui n'a pas autant de packages que Python, mais il a un excellent package d'API Twitter que nous pouvons utiliser pour obtenir des données : twitter4j . Tout d'abord, vous devez installer le package, je vous recommande d'utiliser Maven comme gestionnaire de build pour le projet. Donc, pour ajouter la bibliothèque twitter4j à votre projet Java, ajoutez ceci à votre vie 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>

Voici le code dont vous avez besoin pour récupérer les données. Faites-en votre fichier 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);
}

Construire la classe Sentiment Analyzer

Pour construire notre classe Sentiment Analyzer, nous allons utiliser le package Standford coreNLP. Pour ajouter ce package à votre projet, ajoutez la dépendance suivante à votre fichier 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
    }
​
}

Mettre tous ensemble

Nous allons tout mettre ensemble dans le fichier Main.java. Voici le code :

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