Université Mohammed Premier, Oujda

Faculté multidisciplinaire, Nador

Département d’informatique
⋄ Maroc ⋄

Rapport de Mini Projet

Module : Python et R
Data Science and Intelligent Systems .

Par

Rami Chaymae

HIDDEN MARKOV MODEL POUR L’ANALYSE DES SENTIMENTS

Encadré par :
Pr. Safae El Ouahabi

Academic year : 2022/2023

 Remerciement

Avant tous nous remercions ALLAH tout puissant de nous avoir donné la force et le courage mais surtout
la volonté nécessaire pour la réalisation de ce mini projet.
Tout d’abord, ce travail ne serait pas aussi riche et n’aurait pas pu avoir le jour sans l’aide et l’encadrement
de Prof Safae El Ouahabi, je la remercie pour la qualité de son encadrement exceptionnel, pour sa patience
et sa rigueur.
Enfin nous tenons à remercier l’ensemble du corps enseignant du Master "Big data et systèmes intelli-
gents".
 Résumé

Le présent rapport est la synthèse de notre mini projet au sein de la Faculté pluridisciplinaire de Nador
et sous l’encadrement de Madame Safae El Ouahabi. Ce projet a comme objectif de proposer un modèle
intelligent capable de classifier une base de données composée des tweets tout en appliquant les concepts
étudiés pendant notre formation. Pour atteindre cet objectif, nous nous sommes basés sur des concepts
parmi les plus importants qui ont gagné en popularité ces dernières années en raison de leur grande impor-
tance dans notre vie quotidienne : Intelligence Artificielle, Machine Learning. Bien que ce travail soit plus
spécifique à l’analyse des sentiments dans les réseaux sociaux , Twitter. Ainsi, nous avons dû, en premier
lieu commencer par comprendre la structure et la description mathématique de l’algorithme d’apprentis-
sage : Hidden Markov Model. Au second lieu, nous avons pu extraire les caractéristiques spécifiques d’un
tweet, par des différentes methodes afin d’appliquer la méthode de l’intelligence artificiel sur une dataset
qui contient des tweets de 3 classes différentes : positive , negatives , neutres.
Table des matières

1 Introducion 6

2 Natural Language Processing 7

2.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Bibliothéques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.1 SpaCy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.2 Natural Language Toolkit (NLTK) . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.3 Scikit-learn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 Hidden Markov Model 9

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2 La structure de HMM : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3 Forward algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.4 Viterbi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4 Les etapes de l’analyse des sentiments : 14

4.1 Nettoyage des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.2 Pre-processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.3 Extraction de caractéristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.3.1 Bag of word . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.3.2 TF-IDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.4 Bibiothéques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

5 Partie pratique 20
5.1 Nettoyage des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.2 Pre-processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.3 L’extraction des caractéristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.4 Code final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.4.1 Preparer dataset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.4.2 Hmm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.4.3 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.4.4 snscrape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

6 Conclusion 35

4
 Liste d’abréviations

BoW : Bag of word

DL : Deep Learning
Hmm : Hidden markov model
IA : Intelligence Artificielle
ML : Machine Learning
TF-IDF : term frequency-inverse document frequency
TF : term frequency
IDF : inverse document frequency
NLTK : Natural Language Toolkit
Chapitre 1

Introducion

L’intelligence artificielle (IA), est un processus consistant à transmettre des données, des informations
et une intelligence humaine à des machines afin d’être capables de penser et d’agir comme des humains
et accomplir des tâches en apprenant et en résolvant des problèmes. Nous l’utilisons tous des certaines
de fois par jour sans même de se rendre, chaque fois que nous effectuons une recherche à Google, une
des raisons pour laquelle nous tombons sur des résultats plutôt pertinents car il y’a un algorithme de
l’IA qui a appris comment de trouver ces résultats parmi des milliards des résultats possibles. Machine
Learning (ML) et Deep Learning (DL) sont les deux concepts les plus importants qui rendent l’IA possible.
Nous comptons tout plein de modèle comme machines à vecteurs de support, l’arbre de décision, Hidden
Markov model (HMM) . . . Nous distinguons deux techniques de IA, l’apprentissage supervisé (Supervised
Learning) qui s’appuie sur des données ou exemples étiquetés pour entraîner des modèles d’IA prédictifs
et non supervisé (Unsupervised Learning) qui consiste à entraîner des modèles, sans réaliser d’étiquetage
manuel ou automatique des données au préalable, tel que des algorithmes regroupent les données en
fonction de leur similitude, sans aucune intervention humaine .
Parmi les applications de L’IA est l’analyse des sentiments dans les réseaux sociaux, et c’est l’un des
objectifs principals de ce travail. Donc c’est quoi l’analyse des sentiments ? l’analyse des sentiments (ou
sentiment analysis en anglais) est le processus qui consiste à déterminer l’opinion, le jugement et l’émotion
qui se cache derrière le langage naturel. Elle fait partie de ce qu’on appelle le text mining (ou exploration et
analyse textuelle). Cette technique analytique consiste à extraire le sens de nombreuses sources textuelles,
comme des réponses à des sondages, des critiques en ligne ou encore des commentaires sur les réseaux
sociaux. Un score est ensuite appliqué en fonction du sentiment exprimé : négatif, positif ou neutre. Cette
transcription est réalisée grâce au traitement du langage naturel : Natural Language Processing (NLP).
Dans ce travail, il faut comprendre comment la machine peut classer si un tweet appartient à une catégorie
ou non. Pour cela, nous utiliserons une méthodes de l’IA :HMM. Tel que la première étape consiste à
comprendre sa structure mathématique. Notre base de données utilisée de Twitter pour la classification
est une base de données non structurée, et comme la machine ne peut pas la comprendre, nous avons besoin
d’une méthode de la convertir en une base de données structurée qui contient des données réelles. Et parmi
les méthodes de traitement des textes, nous trouvons les term frequency-inverse document frequency (TF-
IDF) et Bag of word (BoW), qui extraient les caractéristiques de chaque entrée text à travers plusieurs
étapes. Puis, nous formons le modèle sur un ensemble de données et nous le testons sur un autre pour
assurer un bon apprentissage du système.

6
Chapitre 2

Natural Language Processing

2.1 Définition
NLP est un sous-domaine de l’IA qui a vocation à donner la faculté à un programme informatique de
comprendre et d’interpréter le langage tel qu’il est parlé et écrit par les êtres humains, dans toutes ses
complexités et ses nuances. Ainsi, un algorithme qui utilise le NLP est capable d’analyser les phrases, de
saisir le sens des mots dans leur contexte.
Le but est de fluidifier les communications entre les hommes et les machines, en aidant ces dernières à
parler le même langage que les premiers. Avec deux effets immédiats et tangibles : la simplification de
l’utilisation des technologies, et l’automatisation rapide des tâches rébarbatives grâce à la capacité des
programmes à traiter d’énormes volumes de données brutes en un temps record. Ces informations, une
fois structurées, peuvent ensuite être exploitées.
Dans les faits, NLP est déjà employé pour des applications utilisées au quotidien par les particuliers et
les entreprises (sans même parler encore des moteurs de recherche et de l’API Google NLP). Quelques
exemples concrets :
Les traducteurs automatiques, comme Google Translate, qui restituent un texte dans la langue souhaitée
de manière instantanée.

Les assistants vocaux, ces logiciels intégrés aux smartphones ou aux ordinateurs (Siri, Cortana) et aux
enceintes connectées (Google Home, Alexa).

Les chatbots, des programmes qui simulent des conversations humaines et qui sont capables de répondre
aux questions simples des utilisateurs (ils pullulent sur les sites web des entreprises).

Les correcteurs automatiques, comme celui qui est intégré à Microsoft Word, ou le logiciel Antidote, etc.

De façon plus générale, tous les programmes qui s’appuient sur la compréhension du langage naturel
reposent sur une technologie NLP, et tous ont pour but de simplifier les tâches humaines. On est donc très
loin des fantasmes parfois associés aux progrès de l’IA, avec ses machines qui prennent le pouvoir !
NLP mêle des compétences informatiques, mathématiques et linguistiques. Dans le domaine de l’IA, il se
place au croisement du ML et DL, comme on peut le voir sur le schéma ci-dessous :

7
2.2 Bibliothéques
2.2.1 SpaCy
spaCy est une bibliothèque Python pour le traitement automatique du langage naturel (NLP). Elle est
conçue pour être rapide, efficace et extensible. Elle fournit des outils pour le prétraitement des données
textuelles, l’analyse syntaxique, la lemmatisation, et bien d’autres tâches de NLP.

2.2.2 Natural Language Toolkit (NLTK)

Natural Language Toolkit ( NLTK ) est certainement une des library les plus répandus en Python lorsqu’il
s’agit de travailler avec des données texte, on la retrouve notamment dans de nombreux tutoriels. Elle
fournit un accès à plus de 50 corpus et ressources lexicales telles que WordNet, ainsi qu’une suite de
bibliothèques de traitement de texte pour la classification, la tokenisation etc. . . Elle fournit une bonne
introduction pratique à la programmation pour le NLP en Python.

2.2.3 Scikit-learn
Scikit-learn est construit sur les bibliothèques NumPy, SciPy et matplotlib, qui offrent une grande variété
de fonctions mathématiques et statistiques, ainsi que des fonctions de visualisation.
Scikit-learn comprend de nombreux algorithmes populaires d’apprentissage supervisé et non supervisé,
tels que la régression linéaire, les arbres de décision, les SVM (Support Vector Machines), le clustering
K-Means, le PCA (Principal Component Analysis), etc.
La bibliothèque offre également des fonctions de prétraitement des données, telles que l’extraction des
caractéristiques. Scikit-learn fournit également des outils pour l’évaluation des performances des modèles,
tels que le calcul de la précision, le rappel, le F1-score, etc.

8
Chapitre 3

Hidden Markov Model

3.1 Introduction
HMM est l’acronyme pour "Hidden Markov model". Il est considéré comme un algorithme de machine
learning plutôt qu’un algorithme de deep learning. C’est un type de modèle probabiliste utilisé pour
représenter des séquences de données qui peuvent être observées de manière incomplète ou indirecte dans
le temps. Il est appelé "caché" car il utilise des probabilités cachées pour décrire la transition entre les
états d’un système, qui ne sont pas directement observables.

3.2 La structure de HMM :

Voici un exemple simple de la structure de Hmm :

Pour spécifier complètement un hmm, vous avez besoin de cinq paramètres :

1. N, le nombre d’états du modèle. Nous désignons l’ensemble de tous les états possibles comme suit S
= {S1, S2, - - - , SN } , l’état à l’instant t est notté qt. (dans notre cas de classification, les états sont les
classes )

2. M, le nombre de symboles d’observation distincts par état, c’est-à-dire la taille de l’alphabet discret de
l’ensemble de sortie. Nous désignons par V = v1, v1, v2 l’ensemble de tous les symboles de sortie possibles

9
. Le symbole de sortie au temps t par Ot, et la séquence de symboles symboles observés est désignée par
O = O1O2 - - - OT .(dans notre cas de classification, les observations sont les mots de chaque classe) .

3. La distribution de probabilité de transition d’état A ={aij}, où

aij = P [qt+1 = Sj |qt = Si ], 1 ≤ i, j ≤ N

Pour le cas de la structure précedente , la matrice de transition est :

4. La distribution de probabilité des symboles d’observation dans l’état j, B = {bj (k)}, où

bj(k) = P [Ot = vk |qt = Sj ], 1 ≤ i, j ≤ N

Pour le cas de la structure précedente , la matrice d’emmision est :

5. Les distributions d’état initial

π = πi = πi = P [qi = Si ], 1 ≤ i, j ≤ N

En résumé, une représentation compacte d’un modèle est le paramètre

λ = (A, B, π)

Un problème d’apprentissage consiste à ajuster le paramètre du modèle , de sorte que que P (O|λ) soit
maximisé.

3.3 Forward algorithm

L’algorithme de forward est utilisé pour calculer la probabilité d’une séquence d’observations dans un
HMM donné. Supposons que nous avons une séquence d’observations ( Y0 , Y1 , Y2) , et nous avons 2

10
états ( N , P ) . Donc quel est la probabilité de cette séquence observée étant donné les paramétres de
HMM ? Nous définissons au début toutes les chaînes possibles des états et nous obtenons
Nombre d’obseravations
Nombre d’états

( Dans notre cas, c’est 8 ) .

L’objectif de l’algorithme avancé est de calculer la probabilité conjointe p(xt , y1:t ), où pour des raisons
de commodité de notation nous avons abrégé x(t) comme xt = (X0, X1, X2) et (Y0,Y1,...,Yt) en tant
que y1:t . Calculer p(xt , y1:t ) directement nécessiterait une marginalisation sur toutes les séquences d’état
possibles x1:t−1 , dont le nombre croît exponentiellement avec t. Au lieu de cela, l’algorithme forward tire
parti des règles d’indépendance conditionnelle du HMM pour effectuer le calcul de manière récursive.
Pour démontrer la récursion, laissons

αt (xt ) = p(xt , y1:t ) = Σxt−1 p(xt , xt−1 , y1:t )

En utilisant la règle de la chaîne pour développer p(xt , xt−1 , y1:t ), on peut alors écrire

αt (xt ) = Σxt−1 p(yt |xt , xt−1 , y1:t−1 )p(xt−1 , y1:t−1 )

Parce que yt est conditionnellement indépendant de tout sauf de xt , et xt est conditionnellement indé-
pendant de tout sauf de xt−1 , cela se simplifie en

αt (xt ) = p(yt , xt )Σxt−1 p(xt |xt−1 )αt−1 (xt−1 )

La condition initiale est définie comme une certaine probabilité préalable sur x0 comme

α1 (x0 ) = p(x0 )

tel que Σx0 α0 (x0 ) = 1

Dans notre cas d’exemple, on aura les résultats suivants :

11
Une fois la probabilité conjointe αt (xt ) = p(xt , y1:t ) a été calculée à l’aide de l’algorithme direct, nous
pouvons facilement obtenir la probabilité conjointe correspondante p(y1:t ) comme Une fois la probabilité
conjointe
αt = p(y1:t ) = Σxt p(xt , y1:t ) = Σαt (xt )
et la probabilité conditionnelle requise p(xt |y1:t ) comme
p(xt , y1:t ) αt (xt )
p(xt |y1:t ) = =
y1:t αt
Une fois la probabilité conditionnelle calculée, nous pouvons également trouver l’estimation ponctuelle de
xt . Par exemple, l’estimation MAP de xt est donnée par

xM
t
AP
= arg max p(xt |y1:t ) = arg max αt (xt )
xt xt

3.4 Viterbi
L’algorithme de forward et l’algorithme de Viterbi sont deux algorithmes largement utilisés pour résoudre
des problèmes liés aux HMM. Bien qu’ils soient similaires dans leur structure et leur utilisation des pro-
babilités, ils ont des objectifs différents et des résultats différents.
L’algorithme de forward est utilisé pour calculer la probabilité d’une séquence d’observations donnée
dans un modèle de Markov caché. L’objectif est de calculer la probabilité d’observation de l’ensemble des
séquences possibles. L’algorithme de forward peut également être utilisé pour calculer la vraisemblance
d’un modèle, c’est-à-dire à quel point le modèle correspond à la séquence observée.
En revanche, L’algorithme de Viterbi est utilisé pour trouver la séquence d’états cachés la plus probable,
donnée une séquence d’observations. L’objectif est de trouver la séquence d’états cachés qui correspond le
mieux à la séquence observée. Donc l’algorithme de viterbi est le suivant :

Initialisation :

δ1 (i) = πi bi (O1 ), 1 ≤ i ≤ N

ψ1 (i) = 0, 1 ≤ i ≤ N

12
où δt (i) est la probabilité maximale d’être dans l’état qi après avoir observé les t premières observations
et ψt (i) est l’indice de l’état précédent le plus probable menant à qi à l’étape t.

Récursion :
δt (j) = max δt−1 (i)aij bj (Ot ), 2 ≤ t ≤ T, 1 ≤ j ≤ N
1≤i≤N

ψt (j) = arg max δt−1 (i)aij , 2 ≤ t ≤ T, 1 ≤ j ≤ N

1≤i≤N

où δt (j) est la probabilité maximale d’être dans l’état qj après avoir observé les t premières observations,
en supposant que l’état précédent était qi et ψt (j) est l’indice de l’état précédent le plus probable menant
à qj à l’étape t.

Terminaison :

P ∗ = max δT (i)|
1≤i≤N

où P ∗ est la probabilité maximale de la séquence d’observations.

Cheminement arrière :

i∗T = arg max δT (i)

1≤i≤N

3.5 Conclusion
En conclusion, l’algorithme de forward et l’algorithme de Viterbi sont deux algorithmes importants pour
travailler avec les modèles de Markov cachés, mais ils ont des objectifs différents et des résultats diffé-
rents. En termes de structure, l’algorithme de Viterbi utilise une approche de programmation dynamique
similaire à l’algorithme de forward, mais il utilise une approche différente pour le calcul des probabilités.
L’algorithme de forward est utilisé pour calculer la probabilité d’observation de l’ensemble des séquences
possibles, tandis que l’algorithme de Viterbi est utilisé pour trouver la séquence d’états cachés la plus
probable pour une séquence d’observations donnée.

13
Chapitre 4

Les etapes de l’analyse des sentiments :

N’oubliez pas que toutes ces procédures ne sont pas toujours nécessaires et qu’elles ne doivent pas toutes
être effectuées dans l’ordre indiqué. Lors de la suppression des chiffres et de la ponctuation, par exemple,
l’ordre dans lequel ils sont éliminés peut ne pas avoir d’importance. Cependant, avant de procéder à ces
procédures, nous mettons généralement le texte en minuscules.

4.1 Nettoyage des données

Le nettoyage de texte consiste à extraire le texte brut des données d’entrée et à le convertir au format
d’encodage requis en supprimant tous les éléments non textuels tels que les balises et les métadonnées, afin
d’obtenir des données exactes et appropriées pour produire des visualisations, des modèles et des décisions
fiables. C’est une étape cruciale dans l’analyse des sentiments, car il peut exercer une grande influence sur
la qualité et la fiabilité des résultats obtenus. Les étapes courantes de ce processus sont les suivantes :
- Suppression des doublons : Il s’agit de supprimer les doublons de données pour éviter de compter
deux fois le même sentiment.
- Retrait des mentions @, des liens web et des caractères spéciaux.
- Correction d’orthographe et de grammaire : Pour un modèle NLP, la compréhension du contexte
est très importante. Si l’orthographe est incorrecte, tout le contexte du texte peut être faussé.
- Normalisation Unicode : Pour deux chaînes de caractères contenants plusieurs types de polices, le
modèle NLP traitera les deux chaînes différemment bien qu’elles représentent la même signification séman-
tique. Pour surmonter ce problème, nous effectuons une normalisation Unicode, tel que toutes les chaînes
seront écrites par la même police.
- Manipulation les émojis et les émoticônes : Nous devons manipuler les emojis car ils stockent beau-
coup d’informations importantes sur le sentiment du texte et nous ne voulons pas perdre ces informations
en les supprimant simplement du texte. On les remplace alors par leur signification.
Comme conclusion, Le nettoyage du texte est une étape importante de tout effort de traitement automa-
tique des langues.

4.2 Pre-processing
Pourquoi avons-nous besoin de la phase de prétraitement du texte ? La réponse est assez simple : tout
projet NLP comprend une phase de modélisation dans laquelle nous formons le modèle afin de pouvoir
l’utiliser pour les données du monde réel. Et le modèle a besoin de données numériques, mais nos données
sont textuelles, c’est pourquoi nous devons effectuer diverses tâches de prétraitement du texte, pour que
les données seront prêtes pour la phase suivantes .

14
Nous pouvons avoir plusieurs tâches :

Préliminaires :
Toute tâche basée sur NLP peut être effectuée en décomposant le texte en phrases (tokenisation des
phrases) et ensuite en mots (tokenisation des mots).
Dans le cas de notre dataset, il nous suffit de procéder à la tokenisation des mots car les données textuelles
ne sont pas volumineuses .

Suppression des mots d’arrêt ( Stop words) : .

Supposons que nous disposions d’un tokenizer ( listes des mots ). Certains termes anglais couramment
utilisés, tels que a, an, the, of, in, etc., ne sont pas particulièrement utiles à cette fin, car ils n’ont pas
suffisamment de substance pour distinguer le sentiment du texte. Les mots d’arrêt sont des mots qui
sont généralement (mais pas toujours) éliminés du traitement ultérieur dans des scénarios problématiques
comme celui-ci.

Stemming : .
Stemming consiste à supprimer les suffixes et à réduire un mot à une forme de base de sorte que toutes les
variantes de ce mot puissent être représentées par la même forme (par exemple, "change" , "changing" ,
"changes" ,"changed" sont tous réduits à "chang"). Pour ce faire, on applique un ensemble fixe de règles
(par exemple, si le mot se termine par "-es", on supprime "-es").

Lemmatization : .
Stemming consiste simplement à supprimer le suffixe pour obtenir la forme de base du mot, mais le
mot résultant n’est pas le résultat souhaité, c’est-à-dire qu’il peut avoir un effet négatif sur l’utilisation
ultérieure de l’intégration des mots. Nous devons donc utiliser la lemmatisation, qui permet d’obtenir la
forme de base du mot sur la base de son contexte.
La lemmatisation est le processus qui consiste à faire correspondre toutes les différentes formes d’un mot à
son mot de base, ou lemme. Elle requiert davantage de connaissances linguistiques. Bien que cette définition
semble proche de celle du déracinement, elles sont en fait différentes.Voici la différence :

La détection de la langue : .
Nous allons expliquer quelques processus de prétraitement supplémentaires pour traiter de tels cas.
Nous avons présumé jusqu’à présent que nous avions affaire à un texte anglais standard, bien que dans nos
jours, beaucoup d’informations sur le web sont multilingues. Il ne nous reste plus qu’à ajouter un autre
composant au début du pipeline NLP pour la détection de la langue.

Mélange de codes et translittération : .

Dans la section précédente, nous avons discuté d’un scénario dans lequel le contenu était écrit dans une
langue autre que l’anglais. Un autre exemple est celui d’un contenu unique disponible en plusieurs langues.
De nombreuses personnes dans le monde utilisent plusieurs langues dans leurs messages sur les médias
sociaux, et un seul message peut contenir plusieurs langues.

15
Le mélange de codes fait référence à ce phénomène de passage d’une langue à l’autre. Lorsque les gens
utilisent plusieurs langues dans leurs écrits, ils tapent souvent les mots de ces langues en caractères romains,
avec une orthographe anglaise. Ainsi, les mots d’une autre langue sont écrits avec le texte anglais. C’est
ce qu’on appelle la translittération.

4.3 Extraction de caractéristiques

Le problème de la modélisation du texte est qu’il est désordonné, et que les techniques comme les algo-
rithmes d’apprentissage automatique préfèrent des entrées et des sorties de longueur fixe bien définies, et
il est difficile de former un modéle d’apprentissage automatique qui peut comprendre le langage humain.
Les méthodes d’analyse de données ne peuvent pas travailler directement avec du texte brut ; le texte doit
être converti en chiffres. Plus précisément, des vecteurs de nombres. Cette opération est appelée extraction
de caractéristiques ou codage de caractéristiques. C’est une étape importante dans la NLP.
Cette étape est supplimentaire dans le cas de HMM car ce dernier apprend par les observations.
Les techniques courantes d’extraction de caractéristiques incluent TF-IDF , Bag Of Word ( BOW ) ,

4.3.1 Bag of word

BOW est un moyen d’extraire des caractéristiques du texte pour les utiliser dans la modélisation, par
exemple avec des algorithmes d’apprentissage automatique.

L’approche est très simple à comprendre et à mettre en œuvre et a connu un grand succès dans des
problèmes tels que la modélisation du langage et la classification des documents.

Fonctionnement de BOW
Prenons l’exemple de dataset suivante contenant des textes et leurs classes :

Texte Classe
This is a positive sentence 2
This is a negative sentence 1
This is a neural sentence 0
Nous créons ensuite le vocabulaire de mots connus. Dans notre cas c’est ( this , is , a , positive , sentence,
negative , neural )
Puis, nous établissons une mesure de la présence des mots connus. Si le mot est présent dans le text, nous
lui établissons la valeur 1 , sinon la valeur 0. Dans notre cas, nous aurons les résultats suivantes :

Texte this is a positive sentence negative neural Classe

This is a positive sentence 1 1 1 1 1 0 0 2
This is a negative sentence 1 1 1 0 1 1 0 1
This is a neural sentence 1 1 1 0 1 0 1 0

4.3.2 TF-IDF
Un problème avec la notation de la fréquence des mots est que les mots très fréquents commencent à
dominer dans le document (par exemple, un score plus élevé), mais peuvent ne pas contenir autant de
"contenu informationnel" pour le modèle que des mots plus rares mais peut-être spécifiques au domaine.

16
Une approche consiste à réévaluer la fréquence des mots en fonction de leur fréquence d’apparition dans
tous les documents, de sorte que les scores des mots fréquents , qui sont également fréquents dans tous les
documents, sont pénalisés.

Cette approche de notation est appelée Fréquence des termes - Fréquence inverse ( TF-IDF ) des docu-
ments, où :
1.Fréquence des termes (TF) : est un score de la fréquence du mot dans le document actuel.
2.Fréquence inverse du document ( IDF ) : il s’agit d’une évaluation de la rareté du mot dans les documents.
Les scores sont une pondération où tous les mots n’ont pas la même importance ou le même intérêt. Les
scores ont pour effet de mettre en évidence les mots qui sont distincts (contenant des informations utiles)
dans un document donné.

Fonctionnement
Prenons le même exemple précedent :
Texte Classe
This is a positive sentence 2
This is a negative sentence 1
This is a neural sentence 0
Nous créons ensuite le vocabulaire de mots connus. Dans notre cas c’est ( this , is , a , positive , sentence,
negative , neural )
Puis, nous établissons une mesure de la présence des mots connus. Si le mot est présent dans le text, nous
lui établissons la valeur TF-IDF , sinon la valeur 0. tel que :

T F − IDF (t, d) = T F (t, d) ∗ IDF (t) (4.1)

tel que :
t : le mot à compter la valeur TF-IDF
d : le texte du dataset qui contient le mot t

numbers of times t appears in d

T F (t, d) = (4.2)
total numbers of terms in d

N
T DF (t) = ln (4.3)
1 + df
tel que :
N : le nombre de texte dans le corpus (dataset)
df : : nombres des textes qui contiennent le mot t
Dans notre cas, nous aurons les résultats finals suivantes :

Texte this is a positive sentence negative neural Classe

This is a positive sentence 0.726816 0.1682 0.67162 0.12345 0.34567 0 0 2
This is a negative sentence 0.24345 0.4644 0.3463 0 0.24143 0.4634 0 1
This is a neural sentence 0.3255 0.25225 0.2525 0 0.2352 0 0.2523 0
On remarque qu’nous donne des valeurs réels donc cette methode est plus robuste que BOW.

17
Limitations :
Bien que TF-IDF soit une méthode courante et utile pour l’extraction de caractéristiques de texte, il
présente certaines limites qui doivent être prises en compte lors de son utilisation :

Ne prend pas en compte le contexte : TF-IDF est basé sur la fréquence d’un terme dans un document
et sa rareté dans l’ensemble des documents, mais il ne prend pas en compte le contexte. Par exemple, si
un mot est souvent utilisé dans un document mais n’est pas pertinent pour le sujet, il peut obtenir un
score TF-IDF élevé qui ne reflète pas son importance réelle.
Ne gère pas les synonymes : TF-IDF ne prend pas en compte les synonymes et les mots apparentés.
Deux mots différents qui ont le même sens peuvent être traités comme deux termes différents, ce qui peut
conduire à des résultats incohérents.
Ne gère pas les polysemes : Les polysemes sont des mots qui ont plusieurs significations. TF-IDF
traite ces différents sens de la même manière, ce qui peut conduire à une confusion dans l’interprétation
des résultats.
Sensibilité aux erreurs de saisie : Les erreurs de saisie dans les termes peuvent affecter le score TF-IDF.
Par exemple, si "apprentissage automatique" est mal orthographié comme "apprentissage automtique", il
sera considéré comme deux termes différents et aura des scores TF-IDF distincts.
Ne tient pas compte de la structure du document : TF-IDF ne prend pas en compte la structure du
document, comme la position ou l’en-tête, qui peuvent avoir une incidence sur l’importance d’un terme.

4.4 Bibiothéques
1. re : La bibliothèque "re" (pour "regular expression") est une bibliothèque standard Python qui per-
met de travailler avec des expressions régulières. Elle offre une variété d’opérations pour la recherche, la
manipulation et la transformation des chaînes de caractères selon des règles spécifiques. Cette bibliothèque
permet encore de supprimer les ponctuations , URL , etc, du chaîne de caractères.

2. demoji : Contient des fonctions qui permet de trouver , supprimer , ou donner les sens des emojies
d’un texte en utilisant la base de données Unicode Consortium’s .

3. unicodedata : c’est une bibliothèque standard qui fournit des fonctions pour travailler avec les carac-
tères Unicode. Elle permet d’effectuer des opérations telles que la normalisation des chaînes de caractères,
la recherche de catégories de caractères Unicode, la conversion entre différents encodages de caractères, et
bien plus encore.
L’une des fonctions les plus courantes de la bibliothèque "unicodedata" est la normalisation de chaînes
de caractères en utilisant la norme Unicode. La normalisation Unicode est le processus de conversion de
chaînes de caractères en une forme canonique, ce qui permet de comparer et de manipuler les chaînes de
caractères plus facilement. La bibliothèque "unicodedata" fournit des fonctions pour normaliser les chaînes
de caractères selon différents modes, tels que NFC, NFD, NFKC, NFKD.

4. spellchecker : c’est une bibliothèque Python open-source qui fournit des fonctions pour la correction
orthographique en utilisant des algorithmes de vérification orthographique. La bibliothèque SpellChecker
utilise l’algorithme de Levenshtein pour calculer la distance de Levenshtein, qui mesure le nombre minimal
d’opérations (insertions, suppressions ou substitutions) nécessaires pour transformer un mot en un autre

18
mot. La bibliothèque peut également utiliser un dictionnaire pour suggérer des corrections orthographiques
en fonction des mots les plus couramment utilisés. Elle peut être utile dans de nombreuses applications,
notamment pour améliorer la qualité des textes et faciliter la saisie de données.

5. langdetect : La bibliothèque Python "langdetect" est une bibliothèque open source qui permet de
détecter automatiquement la langue d’un texte donné. Elle prend en charge plus de 55 langues et utilise
des algorithmes statistiques pour déterminer la langue la plus probable d’une chaîne de caractères. Elle
est également capable de détecter les langues mixtes et les expressions en langue étrangère dans un texte
en langue principale.
La bibliothèque "langdetect" utilise des modèles de langue basés sur des caractéristiques linguistiques,
telles que la fréquence des lettres, des mots, la syntaxe, la structure grammaticale, etc. Elle fonctionne
bien pour des textes de taille moyenne à grande, tels que des articles de journaux, des pages web, des
documents PDF, des messages électroniques, etc.

6. deep_translator : La bibliothèque Python "deep_translator" est une bibliothèque open source qui
permet de traduire des textes entre plusieurs langues en spécifiant la langue source et la langue cible.
Elle utilise des services de traduction en ligne pour effectuer la traduction, notamment Google Translate,
Microsoft Translate, Yandex Translate et DeepL. Elle prend en charge plus de 30 langues et offre plusieurs
options pour personnaliser la traduction, telles que la détection automatique de la langue source, la spé-
cification d’un modèle de traduction, la limitation du nombre de caractères, etc.

7. NLTK

8. spacy

9. Sklearn

19
Chapitre 5

Partie pratique

5.1 Nettoyage des données

Grace à la fonction sub() de la bibliothéque re, nous pouvons supprimer les ponctuations, Urls , et tous
ce que nous voulons de chaîne de caractére text.

20
Puis, la fonction normalize() de la bibliothèque Python unicodedata permet de normaliser les chaînes de
caractères Unicode. Elle prend deux arguments : le premier spécifie le type de normalisation à appliquer
et le second est la chaîne de caractères à normaliser.

La fonction findall() de la bibliothéque demoji retourne un dictionnaire contenant tous les émojis trouvés
dans un texte avec leus significations. Puis la fonction replace() , une méthode intégrée aux objets de type
str en Python, remplace les emojis par leurs significations dans le texte.

21
Dans cet exemple, nous avons créé une instance de la classe SpellChecker en spécifiant la langue anglaise
(’en’) pour la correction d’orthographe. Nous avons ensuite utilisé la méthode correction pour corriger
chaque mot de la phrase .

5.2 Pre-processing
word_tokenize est une fonction de la bibliothèque Python nltk (Natural Language Toolkit) qui permet
de découper une chaîne de caractères en une liste de mots (ou "tokens"). Cette fonction utilise des règles
spécifiques pour diviser la chaîne de caractères en mots, telles que la ponctuation et les espaces blancs.

22
Et voici la liste de toutes les Stop Words en anglais.

Ce qu’il faut faire maintenant est les effacer

Nous avons importé la classe PorterStemmer de la bibliothèque nltk. Nous avons ensuite créé un objet
PorterStemmer. Nous avons ensuite appliqué la méthode stem de l’objet PorterStemmer pour raciniser les
mots.

spacy.load("en_core_web_sm") est une commande de la bibliothèque Python spacy qui permet

de charger un modèle de traitement du langage naturel pour la langue anglaise. Plus précisément, cette
commande charge le modèle en_core_web_sm, qui est un petit modèle anglais pré-entraîné pour la
reconnaissance d’entités nommées, le marquage de parties du discours, la reconnaissance de dépendances
syntaxiques et la lemmatisation.

23
Nous avons utilisé la fonction detect() pour détecter la langue de text.

Nous pouvons aussi importer la fonction GoogleTranslator à partir de la bibliothèque deep_translator.

Nous avons créé un objet de la classe GoogleTranslator en spécifiant la langue source (auto) et la langue
cible (en). Nous avons ensuite utilisé la méthode translate() de l’objet translator pour traduire la phrase
vers l’anglais .

5.3 L’extraction des caractéristiques

Nous avons au début créé un objet CountVectorizer, qui nous permet d’apprendre le vocabulaire des
termes à partir des textes à l’aide de la méthode fit. Enfin, nous avons transformé les textes en vecteurs
de fréquences de termes à l’aide de la méthode transform. La matrice de fréquences de termes résultante
est affichée à l’aide de la méthode toarray.

24
Nous refaisons le même travail, juste nous allons au début créé un objet tfidfVectorizer.

5.4 Code final

Notre but est de classifier le sentiment d’un tweet. Nous travaillons sur 3 classes : positive,neutre,négative.

5.4.1 Preparer dataset

Nous importons toutes les bibliothéques :

25
Voici notre data :

Lorsqu’il y a des valeurs manquantes ( NaN ) ou des valeurs dupliquées dans les données, cela peut poser
des problèmes pour l’analyse ou la modélisation. dropna() et drop_duplicate() permet de supprimer les
lignes ou colonnes qui contiennent ces valeurs .

26
HMM prend beaucoup de temps pour l’exécution, c’est pour ça nous avons fait quelques modifications sur
dataset.

Nous pouvons visualiser les données de notre dataset par les fonctions suivantes :

Ajouter une colonne ’sentiment’

27
Pour un meilleur apprentissage du modèle, nous divisons la base de données par la méthode test_train_split
(). L’idée est de diviser l’ensemble de données en ensembles d’entraînement et de test d’une manière qui
préserve les mêmes proportions d’exemples dans chaque classe que celles observées dans l’ensemble de
données original. C’est ce que nous appelons une division train-test stratifiée. On peut y parvenir en
définissant l’argument "stratify" à la fonction train_test_split ().

Nous nettoyons les données.

28
Puis nous réalisons le pre-processing

5.4.2 Hmm
Voici toutes les fonctions qui permet de calculer les cinq paramètres cités dans le chapitre 1 :

29
30
Puis on définit le modéle HMM :

31
Enfin , nous prédirons les étiquettes des valeurs de données test sur la base du modèle entraîné.

5.4.3 Evaluation
Nous introduisons maintenant la matrice de confusion qui est nécessaire pour calculer l’accuracy de l’al-
gorithme d’apprentissage dans la classification des données dans les étiquettes correspondantes.

32
Dans ce cas l’accuracy n’est pas élevée car nous avons pas travailler sur une grande dataset, donc le modéle
n’a pas bien appris.

5.4.4 snscrape
snscrape : est une bibliothèque Python qui permet d’extraire des données de réseaux sociaux tels que
Twitter, Instagram, Facebook et YouTube. Elle utilise l’API non officielle de Twitter pour récupérer des
tweets en temps réel, mais elle est capable de récupérer des données historiques en utilisant l’URL d’un
tweet. Nous Utilisons de TwitterSearchScraper pour extraire des données selon des contraintes et ajouter
des tweets à une liste.

Voici les tweets extraits :

33
Nous preparons cette dataset pour le modele HMM.

Puis, nous réalisons une analyse des sentiments.

34
Chapitre 6

Conclusion

Tout au long du présent travail, nous nous sommes basés sur les méthodes d’extraire des données d’un
texte, qu’ils nous permettent d’obtenir une nouvelle base de données structuré, et sur laquelle nous testons
l’algorithmes d’apprentissage HMM. Après ces études, je ne préfére plus HMM. C’est plus coûteuse en
termes de calcul et nécessite de CPU pour terminer la formation. Pour être efficaces, HMM est mois
performant que d’autre algorithmes de classification surtout reseaux neuronnes.

35
 Réference
https://www.netapp.com/fr/artificial-intelligence/what-is-artificial-intelligence/

https://www.journaldunet.fr/web-tech/guide-de-l-intelligence-artificielle/1501311-apprentissage-su

https://www.qualtrics.com/fr/gestion-de-l-experience/etude-marche/analyse-sentiment/

https://www.eskimoz.fr/google-nlp/

https://beranger.medium.com/nlp-extraire-des-caractÃľristiques-pour-utiliser-des-algorithmes-ml-1c

https://machinelearningmastery.com/gentle-introduction-bag-words-model/

https://docs.python.org/3/library/

https://www.youtube.com/watch?v=xejm-z3sbWA

http://pascal.rigaud4.free.fr/Polytech/cours/fc/Algo%20Viterbi.pdf

https://buildingenergygeeks.org/hmm.html

https://birc.au.dk/~cstorm/courses/ML_e19/slides/ml\protect\discretionary{\char\hyphenchar\
font}{}{}3\protect\discretionary{\char\hyphenchar\font}{}{}hmm-implementations.pdf

https://www.kaggle.com/code/nkitgupta/aspect\protect\discretionary{\char\hyphenchar\font}{}{}based\
protect\discretionary{\char\hyphenchar\font}{}{}sentiment\protect\discretionary{\char\hyphenchar\
font}{}{}analysis

36