Présid-Analayses
Analyses lexicales des campagnes présidentielles de 2017
Présid-Analyses
Présid-Analyses est le nom donné à un travail d'étude et de recherche (TER) réalisé en trinôme lors de ma première année de Master Informatique en 2017.
L'objectif de ce projet était de récupérer les données lexicales des candidats à la présidentielle de 2017 à des fins d'analyse. Pour cela, notre travail s'est concentré sur le réseau social Twitter et plus précisément, sur les tweets des candidats. Ces derniers ont été récupérés grâce à une API, insérés dans une base de données et traités informatiquement pour en extraire des informations pertinentes.
Les analyses menées sur les tweets ont été réalisées avec une bibliothèque Python spécialisée dans le traitement automatique de la langue naturelle (NLP). Les informations extraites étaient les suivantes :
- La "distance" qui sépare un candidat d'un autre
- Les mots les plus employés par un candidat
- Quel candidat a employé quel mot ?
Une interface web a été mise en place pour la consultation de ces informations :
Bien que nous nous sommes limités au réseau social Twitter, le travail aurait pu être encore plus grand en étendant les récupérations de données auprès d'autres réseaux sociaux (sachant quand même que les publications d'un candidat étant nombreuses, la quantité de données devient vite très importante).
Fonctionnement des traitements
1) Récupération des identifiants Twitter des candidats
Pour identifier les comptes Twitter des candidats, nous avons utilisé leur identifiant Twitter. En effet, chaque utilisateur de Twitter dispose d'un identifiant unique représentant son compte. Il est facile de retrouver un ID Twitter à partir d'un nom de compte via divers outils sur le web (en voici un exemple). Cet identifiant est nécessaire car il permet de cibler le compte Twitter sur lequel on souhaite faire des opérations, dont les récupérations de tweets.
La première étape que nous avons réalisé, a donc consisté en la récupération des ID Twitter de tous les candidats à la présidentielle 2017 et de les stocker dans la base de données du projet.
2) Réalisation du script de récupération des tweets
Nous avons ensuite créé un script Python qui consiste en la récupération des tweets de tous les candidats enregistrés précédemment en base. Cela est possible grâce à une API fourni par Twitter et permettant de réaliser des opérations à distance sur différents comptes. L'opération qui nous intéresse ici est la récupération des tweets.
Cela se programme simplement de la manière suivante :
import twitter
# Connexion à l'API via les token
api = twitter.Api(
consumer_key = '*******',
consumer_secret = '*******',
access_token_key = '******',
access_token_secret = '*******'
)
# Appel de l'API pour récupérer les tweets (ici 200 tweets)
tweets = api.GetUserTimeline(ID_Twitter, count=200)
La méthode GetUserTimeline nous permet de récupérer tous les tweets d'un compte utilisateur Twitter. Le paramètre "ID_Twitter" sera justement valorisé (via un algorithme plus conséquent) par l'identifiant du candidat. Un appel à l'API est donc effectué pour chaque candidat.
Afin d'éviter d'obtenir un flux de données trop important, à l'issue de cet appel, nous avons décidé de ne pas récupérer les tweets antérieurs à 2016. De même, afin d'assurer la prise en compte des éventuels nouveaux tweets des candidats, plutôt que de tout récupérer à nouveau, nous avons décidé de conserver l'identifiant du tweet le plus récent afin de repartir de celui-ci pour la prochaine exécution du script.
Tous ces tweets ont été enfin insérés dans la base de données du projet, afin d'y effectuer les analyses nécessaires.
3) Réalisation du script d'analyse des tweets
Ce script, réalisé également en Python, effectue une analyse approfondie des tweets récupérés afin d'en extraire les mots et leur type (adjectif, adverbe, nom commun...).
Cela est possible grâce à l'utilisation d'une bibliothèque Python (Syntatic Parser), spécialisée dans le traitement automatique de la langue naturelle (NLP) :
from syntactic_parser.parser import Parser
# Configuration de la langue à lire
parser = Parser(language='fr')
# Lecture approfondie d'un tweet encodé en UTF-8
result = parser.process_document(tweet.encode("utf8"))
# Parcours du résultat de la lecture pour récupérer les mots et leur type
for sentence in result:
for token in sentence:
lemma = token['lemma']
pos = token['pos']
if(pos in ['np', 'nc', 'adj', 'adv', 'v']):
rows_mot.append((lemma, pos))
rows_contenir.append((id_tweet, lemma))
Deux caractéristiques des mots sont récupérés ici :
- Le lemma qui est la racine d'un mot dans une langue (plus précisément sa forme canonique). Par exemple, le verbe conjugué "mange" aura pour lemma le mot "manger". Cette forme permet d'identifier la forme générique associée à un mot.
- Le pos qui est le type du mot (verbe, adverbe, adjectif...).
4) Réalisation du script de calcul de la distance
Toujours réalisé en Python ce script va calculer, via un enchaînement de formules mathématiques adaptées, l'écart entre un candidat et un autre (la distance sera représentée par une valeur numérique).
L'idée est de récupérer dans un premier temps tous les mots utilisés par les candidats et leur nombre d'utilisation (cf. requête SQL ci-dessous) puis, de récupérer tous les mots qui ont été extraits des tweets (tous candidats confondus). Cela permettra de tester chaque mot sur chaque paire de candidats :
from syntactic_parser.parser import Parser
# Requêtes SQL à exécuter
selection_mots = u"SELECT valeur_mot FROM mot;"
selection_candidats = u"SELECT nom_candidat FROM candidat;"
selection_resultats_analyse = u"SELECT nom_candidat, valeur_mot, compte_resultat FROM resultat_mot;"
# Récupération de tous les mots
cur.execute(selection_mots)
result = cur.fetchAll()
mots = []
for mot in result
mots.append(mot[0])
# Récupération des noms des candidats
cur.execute(selection_candidats)
result = cur.fetchAll()
nom_candidats = []
for nom in result
nom_candidats.append(nom[0])
# Récupération des résultats d'analyse
cur.execute(selection_resultats_analyse)
result = cur.fetchall()
candidats = {}
for res in result:
nom = res[0]
mot = res[1]
nb_utilisation = res[2]
candidats[nom][mot] = nb_utilisation
# Calcul de la distance entre deux candidats
for nom1 in nom_candidats:
for nom2 in nom_candidats:
if nom1 != nom2:
distance = distance(candidats[nom1], candidats[nom2], mots)
La méthode calculant la distance, appelée "distance" est la suivante :
def distance(mots_candidat_1, mots_candidat_2, mots):
scal = 0
cnorm1 = 0
cnorm2 = 0
for mot in mots:
scal += mots_candidat_1[mot] * mots_candidat_2[mot]
cnorm1 += pow(mots_candidat_1[mot], 2)
cnorm2 += pow(mots_candidat_2[mot], 2)
cnorm1 = math.sqrt(cnorm1)
cnorm2 = math.sqrt(cnorm2)
dist = scal / (cnorm1 * cnorm2)
return dist
La distance calculée est enfin enregistrée en base afin de la retranscrire sur l'interface.
5) Retranscription sur l'interface web
La distance est représentée sous la forme d'un graphique de type radar :
Le mot le plus employé par un candidat est représenté par un histogramme horizontal :
Enfin, les mots les plus employés par un candidat sont représentés sous la forme d'un nuage de mots :
Caractéristiques du projet
| Titre | Présid-Analyses |
| Description | Analyses lexicales des campagnes présidentielles en France en 2017. |
| Langages utilisés | Python, PHP, JS, CSS, HTML |
| Année de réalisation | 2017 |
| Accès au code | Lien |