Analyse sentimentale des tweets avec Text Analyctics API, partie I : accès à Twitter,

Par Hinault Romaric

Le 28 février 2020, par Hinault Romaric

0PARTAGES

Dans ce billet de blog en deux parties, nous verrons comment mettre en place une simple application ASP.NET Core capable d’analyser des tweets pour détecter la langue de l’auteur, ainsi que le sentiment exprimé au travers des écrits de ce dernier.

Il s’agit de la démo que j’avais faite pour une de mes présentations sur les services cognitifs d’Azure. J’ai eu un peu de disponibilité ces derniers jours et je me suis lancé dans l’écriture de ce billet de blog pour offrir un guide pas à pas pour mettre en place une solution similaire et jouer un peu avec TextAnalytics API.

Outils utilisés :

Visual Studio 2019 : Environnement de développement permettant de développer différents types d'applications (Windows, Web, Android, iOS, Cloud, etc.), en utilisant de nombreux langages de programmation, dont C#, VB.NET, C++, JavaScript et bien plus. L’édition communautaire est disponible gratuitement en téléchargement sur la page suivante : https://visualstudio.microsoft.com/fr/downloads/

ASP.NET Core : plateforme de développement Web open source. Nous allons utiliser le modèle de projet Razor Page et le langage C#.

Azure Text Analyctis API : service cognitif de traitement en langage naturel de texte brut. Ce service inclut la détection de la langue de l’utilisateur, la détection des mots-clés, la détection d’entités et l’analyse des sentiments.
Pour utiliser Text Analytics, vous devez disposer d’un compte Microsoft Azure. Vous pouvez en créer un gratuitement si vous n’en disposez pas d’un.

TwwtinviAPI : Tweetinvi est une bibliothèque intuitive .NET permettant d'accéder à l'API REST de Twitter. Il s'agit d'une bibliothèque de classes .NETCore et Portable, pouvant être utilisée pour le développement sur Windows, Windows RT, Windows Phone, Mono, Xamarin Android et Xamarin iOS.

Création du projet

Pour commencer, vous devez créer une nouvelle application ASP.NET Core Razor Pages en utilisant Visual Studio 2019.

Installation de l’API Twitter

Une fois l’application créée, procédez à l’installation de l’API Tweetinvi en utilisant le gestionnaire de packages NuGet :

Une fois l’API installé, nous devons procéder à la configuration de celle-ci afin de nous connecter à Twitter.

La plateforme Twitter expose un EndPoint public qui peut être utilisé par les développeurs pour interagir avec cette dernière. Le EndPoint permet notamment de consulter les données publiées sur Twitter, publié du contenu sur Twitter, etc. Tweetinvi simplifié l’accès à cette API.

Avant toute utilisation de Twitter dans une application, vous devez disposer un compte développeur sur Twitter : https://developer.twitter.com/

Ensuite, vous devez créer une application depuis le portail développeur de Twitter.

L’application Twitter est en quelque sorte une passerelle entre votre application et la plateforme Twitter. Elle fournit des informations que vous allez utiliser dans votre application pour notamment vous authentifier auprès de Twitter.

Une fois l’application créée, vous trouverez dans l’onglet Key and tokens les informations que vous avez besoin pour authentifier votre application :

Revenez dans Visual Studio, ouvrez le fichier de configuration appsettings.json de votre application et ajoutez les informations suivantes :

Code json :

Sélectionner tout

1
2
3
4
5
6
7
  "Twitter": { 
    "ConsumerKey": "", 
    "ConsumerSecret": "", 
    "AccesToken": "", 
    "AccesTokenSecret": "" 
  
  }

Chaque propriété doit être remplacée avec la valeur correspondante dans l’application Twitter.

Mise en place du service de recherche des tweets

Une fois la configuration nécessaire pour se connecter à l’API Twitter mise en place, nous allons créer un service qui permettra d’effectuer des recherches sur Twitter à partir d’un Tag.

Vous allez dans un premier temps créer un dossier Services, ensuite une interface ITwwtsSearch :

Code csharp :

Sélectionner tout

1
2
3
4
  public interface ITweetsSearch 
    { 
        IList<string> GetTweets(string tag); 
    }

Vous devez créer la classe TweetsSearch qui doit être l’implémentation de l’interface ITweetsSearch :

Code csharp :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class TweetsSearch : ITweetsSearch 
    { 
  
        /// <summary> 
        /// Journalisation 
        /// </summary> 
        private readonly ILogger<TweetsSearch> _logger; 
        /// <summary> 
        /// Configuration 
        /// </summary> 
        private readonly IConfiguration _config; 
  
        /// <summary> 
        /// Initialisation d’une nouvelle instance de la classe TweetsSearch 
        /// </summary> 
        /// <param name="logger">Requis pour la journalisation</param> 
        /// <param name="config">Requis pour l'accès aux informations de configuration</param> 
        public TweetsSearch(ILogger<TweetsSearch> logger, IConfiguration config) 
        { 
            _config = config; 
            _logger = logger; 
  
        } 
  
        /// <summary> 
        /// Méthode pour obtenir les tweets Twitter en fonction du Tag 
        /// </summary> 
        /// <param name="tag">Paramètre utilisé pour filtrer les tweets</param> 
        /// <returns>Retrourne une liste de sting</returns> 
        public IList<string> GetTweets(string tag) 
        { 
  
        } 
    }

Les paramètres de type ILogger, et IConfiguration, doivent être passés au constructeur. Ils seront utilisés respectivement pour la journalisation et lire les informations d’authentification à Twitter dans le fichier de configuration (appSettings.json).

Dans la méthode GetTweets, la première chose à faire sera d’utiliser la méthode statique SetUserCredentials de la classe Auth offerte par l’API Tweetinvi pour nous authentifier. Cette classe prend en paramètre le ConsumerKey, ConsumerSecret, AccesToken et AccesTokenSecret :

Code csharp :

Sélectionner tout

1
2
Auth.SetUserCredentials(_config.GetValue<string>("Twitter:ConsumerKey"), _config.GetValue<string>("Twitter:ConsumerSecret"), 
              _config.GetValue<string>("Twitter:AccesToken"), _config.GetValue<string>("Twitter:AccesTokenSecret"));

Ensuite, nous devons définir nos paramètres de recherche en utilisant la méthode statique CreateTweetSearchParameter(string query) de la classe Search. Nous allons limiter le nombre de résultat à 50 :

Code csharp :

Sélectionner tout

1
2
   var searchParameter =  Search.CreateTweetSearchParameter("#"+tag); 
            searchParameter.MaximumNumberOfResults = 50;

Pour finir, il faudra effectuer la recherche en utilisant la méthode SearchTweets et en passant en nos paramètres de recherche.

Code csharp :

Sélectionner tout

1
2
//Recherche des Tweets 
 var tweets = Search.SearchTweets(searchParameter);

Le code complet de classe TweetsSearch est le suivant :

Code csharp :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
/// <summary> 
    /// Service pour la recherche sur Twitter 
    /// </summary> 
    public class TweetsSearch : ITweetsSearch 
    { 
  
        /// <summary> 
        /// Journalisation 
        /// </summary> 
        private readonly ILogger<TweetsSearch> _logger; 
        /// <summary> 
        /// Configuration 
        /// </summary> 
        private readonly IConfiguration _config; 
  
        /// <summary> 
        /// Initialisation d’une nouvelle instance de la classe TweetsSearch 
        /// </summary> 
        /// <param name="logger">Requis pour la journalisation</param> 
        /// <param name="config">Requis pour l'accès aux informations de configuration</param> 
        public TweetsSearch(ILogger<TweetsSearch> logger, IConfiguration config) 
        { 
            _config = config; 
            _logger = logger; 
  
        } 
  
        /// <summary> 
        /// Méthode pour obtenir les tweets Twitter en fonction du Tag 
        /// </summary> 
        /// <param name="tag">Paramètre utilisé pour filtrer les tweets</param> 
        /// <returns>Retrourne une liste de sting</returns> 
        public IList<string> GetTweets(string tag) 
        { 
            //Authentification de l'application 
            Auth.SetUserCredentials(_config.GetValue<string>("Twitter:ConsumerKey"), _config.GetValue<string>("Twitter:ConsumerSecret"), 
              _config.GetValue<string>("Twitter:AccesToken"), _config.GetValue<string>("Twitter:AccesTokenSecret")); 
  
            //Journalisation 
            _logger.LogInformation( 
            "TweetsSearch.GetTweets called. tag: {TAG}", 
            tag); 
  
            //Initialisation des paramètres de recherches  
            var searchParameter =  Search.CreateTweetSearchParameter("#"+tag); 
            searchParameter.MaximumNumberOfResults = 50; 
  
            //Recherche des Tweets 
            var tweets = Search.SearchTweets(searchParameter); 
  
          return  tweets!=null && tweets.Any() ? tweets.Select(x => x.FullText).ToList() : new List<string>(); 
        } 
    }

Pour finir avec la création de ce service, nous allons modifier la méthode ConfigureServices du fichier Startup.cs pour ajouter la classe TweetsSearch au conteneur d’IoC de ASP.NET Core :

Code csharp :

Sélectionner tout

  services.AddTransient<ITweetsSearch, TweetsSearch>();

Appel du service

Pour commencer, vous devez modifier la classe IndexModel dans le fichier Index.cshtml.cs. Les propriétés suivantes doivent être créées :

Code csharp :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/// <summary> 
        /// Liste des Tweets 
        /// </summary> 
        public IList<string> Tweets { get; set; } 
  
        /// <summary> 
        /// Paramètre de recherche 
        /// </summary> 
        [Required] 
        [StringLength(50)] 
        [BindProperty]  
        public string Tag { get; set; } 
  
        /// <summary> 
        /// Recherche avec Twitter 
        /// </summary> 
        private readonly ITweetsSearch _tweetsSearch;

Le constructeur de cette classe doit être modifié pour injecter le service ITweetsSearch :

Code csharp :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
/// <summary> 
        ///  Initialisation d’une nouvelle instance de la classe PageModel 
        /// </summary> 
        /// <param name="tweetsSearch">Requis pour injecter le service ITweetsSearch </param> 
        public IndexModel(ITweetsSearch tweetsSearch) 
        { 
  
            _tweetsSearch = tweetsSearch; 
  
        }

Dans la méthode OnGet, vous devez initialiser la propriété Tweets :

Code csharp :

Sélectionner tout

1
2
3
4
5
6
7
/// <summary> 
        /// Méthode appelée lors d'une requête Get 
        /// </summary> 
        public void OnGet() 
        { 
            Tweets = new List<string>(); 
        }

Cette méthode est appelée à chaque chargement de la page (Requête Get).

Vous devez ensuite créer la méthode OnPost, qui est appelée lorsque l’utilisateur transmet les informations du formulaire de recherche :

Code csharp :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
/// <summary> 
        /// Méthode appelée lors d'une requête Post 
        /// </summary> 
        public void OnPost() 
        { 
  
  
            Tweets = _tweetsSearch.GetTweets(Tag); 
  
        }

Mise à jour de la vue

Éditez maintenant le fichier Index.cshtml et remplacez son contenu par le code suivant :

Code html :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
@page 
@model IndexModel 
@{ 
    ViewData["Title"] = "Home page"; 
} 
  
<h2>Tweets</h2> 
  
<div class="row"> 
    <div class="col-md-4"> 
        <form method="post"> 
            <div asp-validation-summary="ModelOnly" class="text-danger"></div> 
            <div class="form-group"> 
                <label asp-for="Tag" class="control-label"></label> 
                <input asp-for="Tag" class="form-control" /> 
                <span asp-validation-for="Tag" class="text-danger"></span> 
            </div> 
            <div class="form-group"> 
                <input type="submit" value="Search" class="btn btn-default" /> 
            </div> 
        </form> 
    </div> 
</div> 
  
<table class="table"> 
    <thead> 
        <tr> 
            <th> 
                ID  
            </th> 
            <th> 
                Text 
            </th> 
            <th> 
                Language 
            </th> 
            <th>Score</th> 
        </tr> 
    </thead> 
    <tbody> 
        @foreach (var item in Model.Tweets) 
        { 
            <tr> 
                <td> 
  
                </td> 
                <td> 
                    @Html.DisplayFor(modelItem => item) 
                </td> 
                <td> 
  
                </td> 
                <td> 
  
                </td> 
            </tr> 
        } 
    </tbody> 
</table>

Exécutez l’application et vous obtiendrez le résultat suivant pour une recherche donnée.

Dans le prochain billet, nous verrons comment utiliser l'API TextAnalytics pour analyser les Tweets obtenus de Twitter.

Une erreur dans cette actualité ? Signalez-nous-la !

Votre nom : Votre e-mail :

Décrivez l'erreur que vous souhaitez porter à notre connaissance :

Identifiez-vous

Créer un compte

Analyse sentimentale des tweets avec Text Analyctics API, partie I : accès à Twitter,

Par Hinault Romaric

Identifiant
Mot de passe

Mot de passe oublié ?

Identifiez-vous

Créer un compte

Analyse sentimentale des tweets avec Text Analyctics API, partie I : accès à Twitter, Par Hinault Romaric

Analyse sentimentale des tweets avec Text Analyctics API, partie I : accès à Twitter,

Par Hinault Romaric