---
author: François Pelletier
title: Notes de cours - examen partiel
fig_caption: yes
highlight: pygments
number_sections: yes
toc: yes
toc_depth: 3
geometry: "left=2cm,right=2cm,top=2cm,bottom=2cm"
fontsize: 12pt
---

# Expressions régulières

## Définitions

- **Patron**: représentation compacte d’un ensemble de chaînes de caractères
- **Recherche**: filtrer les textes qui correspondent au patron

## Types de recherches

- Littéral
- Classe de caractères
  - Alphanumériques: `/\w/`
  - Numériques: `/\d/`
- Registre de valeurs
  - Lettres: `/[a-z]/`
  - Chiffres: `/[0-9]/`
- Négation
  - Aucun chiffre: `/[^0-9]/`
  - Aucun espace: `/[^\s]/`
- Optionnel
  - Orthographes alternatives: `/colou?r/`
  - Mot facultatif: `/(\w+)?/`
- N'importe quel caractère: `/./`
- Alias
- Compteurs
  - Zéro ou plusieurs espaces (en début de ligne): `/^\s*/`
  - Un ou plusieurs caractères (un mot): `/\w+/`
- Groupes de capture
  - Multiple, optionnel ou non quantifié: `/(groupe 1)+(groupe 2)?(groupe 3)*/`
- Conditions
  - `/(?(?=si_expression)alors|sinon)/`
 
## Erreurs possibles

- Faux positifs
  - n'auraient pas dû correspondre au patron
  - métrique: précision
- Faux négatifs
  - auraient dû correspondre au patron
  - métrique: rappel
  
## Python

Module **re**

|fonction|usage|
|---|---|
|compile|générer une version compilée de l'expression régulière|
|match|rechercher depuis le début d'une chaîne de caractères|
|search|rechercher dans une chaîne de caractères|
|sub|remplacer la première occurrence d'un patron|
 
## Automates à états finis

- Servent à implémenter une version compilée des expressions régulières
- Deux types:
  - Déterministes
  - Probabilistes (non-déterministes)
- Représentés sous forme de graphes
- Alphabet: ensemble fini de symboles. Peuvent désigner de plus gros objets.
- Tableau: représente la fonction de transition $q_{i+1} = f(q_i,I)$ pour un état $q_i$ et un symbole en entrée $I$.

### Exemple: langage des moutons

- Expression régulière: `/baa+!/`
- Graphe: 
  - ![FSA sheep language](fsa_sheep.png)
- Caractéristiques:
  - 5 états:
  - Alphabet: a,b,!
  - $q_0$ est l'état de départ
  - $q_4$ est un état terminal
  - 5 transitions
- Tableau

| |b|a|!|e|
|---|---|---|---|---|
|0|1||||
|1||1|||
|2||3|||
|3||3|4||
|4:|||||

### Reconnaissance déterministe

Processus qui:

- Démarre dans l'état initial
- Examine le symbole en entrée
- Consulte la table
- Sélectionne le nouvel état et mets à jour le ruban
- Continue jusqu'à ce qu'on atteigne le bout du ruban

Algorithme déterministe: D-Recognise

- Une seule transition possible à chaque instant
- Interpréteur dirigé par une table de transition
- Trivial: On sait qu'on démarre sur le premier caractère et qu'on a un succès si on atteint l'état terminal à la fin du ruban. Mais, on peut atteindre l'état terminal avant la fin du ruban, et débuter ailleurs qu'au début du ruban.

Vérification d'expressions régulières:

- Traduire l'expression en table de transition
- Passer la table et la chaîne à un interpréteur

### Reconnaissance non déterministe

Deux approches de base:

- Convertir un automate non déterministe en automate déterministe. 
  - Transition $\epsilon$ qui n'avance pas le ruban.
- Gérer les différentes options comme une exploration dans un espace d'états
  - Il existe au moins un chemin complet pour une chaîne définie par le langage de l'automate.
  - Les chemins ne mènent pas tous à un état final.
  - Aucun chemin ne mène à un état final si la chaîne ne fait pas partie du langage
- Les états de l'espace sont des paires (position du ruban, état de l'automate)
- On garde une trace des états non explorés. Exploration en profondeur.
- Pour éviter le catastrophic backtracking, il fait éviter d'avoir deux match possibles pour le même caractère dans un groupe.

## Conclusion

Toute expression régulière peut être compilée automatiquement en un automate non déterministe, que l'on peut convertir en automate déterministe.

# Prétraitement des textes

## Définitions

- **Jetons**: Nombre d'occurrences de mots ($N$)
- **Types**: Nombre de mots distincts dans le vocabulaire ($|V|$)
- **Mot**: Plus petit élément pouvant être prononcé ou écrit en isolation avec un contenu sémantique. On peut accepter les signes de ponctuation dans certaines tâches.

Loi de Heaps: $|V| = kN^{\beta}, 0.67 < \beta < 0.75$

Dictionnaires: 

- Oxford English (600 000 mots)
- Petit Robert (60 000 mots)

## Types de traitements

Les traitements les plus fréquents sont:

- Découper le texte en mots (segmentation)
- Uniformiser les mots (normalisation)
- Découper le texte en phrases (segmentation)

## Segmentation de mots (tokenisation)

- Utilisation de délimiteurs (ponctuation et espaces)
  - Difficultés:
	- Apostrophes qui relient des mots
	- Traits d'union reliant deux parties d'une entité ou deux entités séparées
	- Acronymes
	- Mots composés et noms propres
	- Nombres et termes spéciaux
- Choix du tokeniseur:
  - Split
  - Whitespace
  - WordPunct
  - Treebank
  - Tweet
  - Regexp
- Disponible dans toutes les librairies NLP
  - Efficace, utilise des expressions régulières et correction avec un dictionnaire

## Normalisation

Utile en recherche d'information

- On ne veut pas conserver tous les termes
- Classes d'équivalences
  - Suppression de la ponctuation dans les abréviations
  - Remplacement des majuscules par des minuscules
  - Retrait des accords en genre et en nombre
  
Techniques, en ordre décroissant de complexité:

- Analyse morphologique
- Lemmatisation
- Stemming

### Analyse morphologique

- Étude de la composition des mots en morphèmes
- **Morphèmes** : Plus petite unité lexicale ayant un sens spécifique
  - **Racines** : Morphèmes lexicaux (*stems*)
	- Central; donne le sens au mot.
	- Radical ou lexème
  - **Affixes** : Morphèmes grammaticaux
	- Préfixe (**pré**historique), suffixes (préhistor**ique**) et infixe (t**a**ke, t**oo**k)
	- Deux classes:
		- Dérivatifs: modifie la syntaxe (**-ment** change les adjectifs en adverbes)
		- Flexionnels: pas de dérivation du mot
	- Peuvent être composés

### Lemmatisation

Réduction à une seule forme de base, le lemme

- **Lemme**: Unité lexicale qui porte le sens, pas nécessairement présente dans la composition du mot, contrairement au lexème
- Dictionnaire de formes de base
- Nécessite de connaître la nature des mots (*POS*)

Approches

- Fonction `morphy` de WordNet, utilise des suffixes pour trouver le mot dans le lexique
- Approches probabilistes avec *Hidden Markov Models (HMM)*

### Stemming

Consiste à trouver la racine du mot par troncature et des règles de réécriture.

- Aucun lexique
- Dépends de la langue
  - Anglais: Lovins, Porter, Snowball
  - Français: Snowball
- Peut faire des erreurs

## Segmentation de phrases

Découpage d'un texte en phrases

- Délimitation par un signe de ponctuation

|Signe|Précision|Exemple|
|---|---|---|
|! et ?|Assez fiable, sauf dans les dialogues|"Pourquoi aussi êtes-vous si insatiable?" répondit le renard.|
|.|Quelques ambigüités, abréviations et nombres|Monsieur Brossard, ing., Ph.D., est arrivé.|
|...|Interruption ou hésitation|Mais... c'est mon ami !|

- Approximation à l'aide de règles
  - Mot suivant débute par majuscule
  - Mot précédent tout en majuscules
  - Précédé d'une abréviation
  - Précédé et suivi de caractères sans espaces
  - Suivi de plusieurs espaces
  - Précédé ou suivi de signes de ponctuation
  - Suivi de guillemets
  - ...
- Une décision pour chaque signe de ponctuation selon le contexte
- Meilleure performance: Apprentissage automatique, classification binaire

## Distance minimale d'édition

Utilisations:

- Distance entre les mots (correction d'orthographe)
- Distance entre des séquences de mots (similarité dans le discours)

Distance de Levenshtein: nombre minimal d'opérations nécessaires pour transformer un mot en un autre.

- Alignement des chaînes de caractères
- Édition par exploration: 
  - Branche la plus courte
  - Problèmes:
	- Nombre exponentiel de chemins
	- Plusieurs chemins pour le même résultat
	- Séquences potentiellement inefficaces
	
On utilise la programmation dynamique:

- Sous-ensemble de caractères
- Conserver les résultats dans un tableau
- On calcule la distance avec ces résultats partiels

$$
\mathit{distance}[i,j]=
\mathit{min}
\begin{cases}
\mathit{distance}[i-1,j]+{C}_{\mathit{ins}}({\mathit{target}}_{i-1}) \\
\mathit{distance}[i-1,j-1]+{C}_{\mathit{subst}}({\mathit{source}}_{j-1},{\mathit{target}}_{i-1}) \\
\mathit{distance}[i,j-1]+{C}_{\mathit{del}}({\mathit{source}}_{j-1})
\end{cases}
$$

Résolution:

- On remplit le tableau de gauche à droite et de bas en haut
- Pour remplir le tableau
  - Si les deux caractères sont différents: on prend le minimum des trois cases adjacentes, et on ajoute le coût de l'opération 
	- horizontal = insertion
	- vertical = suppression
	- diagonale = substitution
  - Si les caractères sont identiques, on reprend la valeur sur la diagonale


# Modèles de langue N-grammes

L'objectif d'un modèle de langue est classifier un texte selon son vocabulaire ou de prédire le prochain mot.

- Observer les mots précédents
- Conserver des comptes relativement simples des mots

## Définition

- **$N$-gramme**: Séquence de $N$ mots
  - Les plus fréquents sont les bigrammes (2) et trigrammes(3)
- **Corpus**:  Ensemble de documents représentatif de notre application ou du sujet d'intérêt

## Applications

La prédiction du mot suivant est utilisée dans plusieurs domaines

- Reconnaissance vocale
- Correction d'orthographe
- Traduction automatique

Classification de textes, désambiguïsation

## Modèles

Approches:

- Estimer les probabilités à partir des fréquences relatives des mots
- Compter les sous-séquences dans un corpus

Décompte des mots:

- On utilise seulement les formes de mots (les mots tels quels)

Calcul:

- On évalue la probabilité d'une séquence de longueur $N$ à partir de la probabilité de la séquence de longueur $N-1$.
  - Ex: $P(w_4|w_1,w_2,w_3)$
- On évalue la probabilité d'une séquence entière
  - $P(W) = P(w_1,w_2,w_3,w_4)$

Règle de Bayes:

$$
\begin{aligned}
P(B|A) &= \frac{P(A,B)}{P(A)} 
&= \frac{P(B)P(A|B)}{P(A)} 
\end{aligned}
$$

Exemple:

$$
\begin{aligned}
&P(\text{nous} | \text{les minions sont de retour et}) \\
&=\frac{P(\text{les minions sont de retour et nous})}{P(\text{les minions sont de retour et})}
\end{aligned}
$$

## Chainage de probabilités

- Selon Google, les comptes de ces séquences sont de 0. 
- Solution: Règle de chaînage de probabilité 
  - Assumer une forme d'indépendance entre les mots.
  - $P(ABC) = P(A) P(B|A) P(C|AB)$
- Forme générale:

$$
\begin{aligned}
P(w_i^n) &= P(w_1)P(w_2|w_1)P(w_3|w_1^2) \ldots P(w_n|w_1^{n-1}) \\
&= \prod_{k=1}^{n} P(w_k|w_1^{k-1})
\end{aligned}
$$

- Exemple:

$$
\begin{aligned}
P(\text{les minions sont de retour}) &= \\
P(\text{les}) \times \\
P(\text{minions}|\text{les}) \times \\
P(\text{sont}|\text{les minions}) \times \\
P(\text{de}|\text{les minions sont}) \times \\
P(\text{retour}|\text{les minions sont de}) \times \\
\end{aligned}
$$

Encore une fois, il y a trop de phrases possibles pour pouvoir calculer les statistiques de longs historiques. On pose une autre hypothèse d'indépendance, l'hypothèse de Markov.

$$
\begin{aligned}
P(\text{retour}|\text{les minions sont de}) 
&\sim P(\text{retour}|\text{de})
&\sim P(\text{retour}|\text{sont de})
\end{aligned}
$$

**Hypothèse de Markov**: Les mots sont indépendants du début de l'historique, et seulement des $N$ mots précédents.

$$
P(w_n|w_1{n-1}) \sim P(w_n|w_{n-N+1}^{n-1})
$$

## Estimation des probabilités

Estimateur du maximum de vraisemblance pour les N-grammes, déterminé à partir d'un corpus d'entraînement.

$$
\begin{aligned}
P(w_i|w_{i-1}) &= \frac{\text{count}(w_{i-1},w_i)}{\text{count}(w_{i-1})} \\
&= \frac{C(w_{i-1},w_i)}{C(w_{i-1})} \\
&= \frac{C(w_{n-1}w_n)}{\sum_{w \in V}C(w_{n-1}w)}
\end{aligned}
$$

Pour calculer les probabilités des bigrammes, on doit faire le compte des unigrammes et des bigrammes, puis, on divise le compte du bigramme par le compte de l'unigramme

Ex: 

$$
\begin{aligned}
P(\text{want}|\text{I}) \\ 
&= \frac{P(\text{I want})}{P(\text{I})} \\
&= \frac{827}{2533} = 0.3265
\end{aligned}
$$

- Pour éviter de calculer des probabilités trop petites, on utilise des log-probabilités que l'on additionne au lieu de multiplier.
- On doit délimiter les débuts `<s>` et les fins de phrases `</s>`. On ajoute aussi la fin de phrase au vocabulaire.
- On valide la capacité de généralisation du modèle en générant des phrases ou en analysant les modèles N-grammes (aspects reliés à une langue).

### Génération aléatoire

- Choisir un bigramme aléatoire `(<s>,w)`
- Échantillonner un bigramme `(w,x)`
- Itérer jusqu'à l'obtention d'un bigramme `(x,</s>)`

### Différents corpus

Shakespeare:

- N=884647 jetons
- V=29066 types
- 300000 types de bigrammes, sur 844M possibles, soit 0.04%

### Évaluation

Les textes générés avec des modèles d'ordres supérieurs sont plus cohérents. Ils ressemblent aux textes utilisés pour construire les modèles.

Méthodes de validation intrinsèques:

- Holdout: ensembles d'entraînement et de test
- Métrique d'évaluation: 
  - Perplexité (à minimiser)
- Limites:
  - Données de test peuvent être très différentes des données d'entraînement
  - La perplexité est une mauvaise approximation dans ce cas

$$
\begin{aligned}
PP(W) &= \sqrt[N]{\frac{1}{P(w_1,\ldots,w_N)}} \\
&= \sqrt[N]{\prod_{i=1}^{N}\frac{1}{P(w_i|w_1,\ldots,w_{i-1})}}
\end{aligned}
$$

- Méthodes extrinsèques: tester deux modèles dans une application et prendre le meilleur selon une métrique propre à l'application.

## Lissage

- Les bigrammes qui sont rares ont souvent une probabilité de 0 avec la méthode du maximum de vraisemblance, car ils ne seront pas rencontrés dans le corpus d'entraînement.
- On veut les considérer dans nos calculs: on applique un lissage

### Lissage de Laplace

- Consiste à ajouter un compte de 1 à tous les n-grammes. On augmente donc la taille du corpus de $|V|$ jetons.

La probabilité de rencontrer le mot $w_i$ devient:

$$
P_{\text{Laplace}}(w_i) = \frac{c_i+1}{N+V}
$$

Les comptes reconstruits sont:

$$
c_i^{\star} = (c_i+1)\frac{N}{N+V}
$$

Appliqué aux bigrammes, ces équations deviennent:

$$
\begin{aligned}
P_{\text{Laplace}}(w_n|w_{n-1}) &= \frac{C(w_{n-1}w_n)+1}{C(w_{n-1})+V} \\
c^{\star}(w_{n-1}w_n) &= (C(w_{n-1}w_n)+1)\frac{C(w_{n-1})}{C(w_{n-1})+V}
\end{aligned}
$$

- Enjeux
  - Approche trop drastique
	- On peut utiliser une valeur $\delta \in [0,1]$, mais ce choix est difficile
  - pas utilisé en pratique pour les N-grammes, il y a de meilleures méthodes.
  - Utilisé pour lisser d'autres types de modèles probabilistes.
	- Classification de textes
	- Études pilotes
	- Lorsqu'il n'y a pas beaucoup de zéros.

### Autres approches de lissage:
- Si $C(xyz)=0$, on peut utiliser $p(z|y)$ et $p(z)$
- Interpolation (combinaison)
	- Interpolation simple:
	$$
	\begin{aligned}
	\hat{P}(w_n|w_{n-2}w_{n-1}) &= \lambda_{1}P(w_n|w_{n-2}w_{n-1})\\
	&+\lambda_{2}P(w_n|w_{n-1})\\
	&+\lambda_{3}P(w_n)\\
	\sum_{i} \lambda_i&=1
	\end{aligned}
	$$
	- Version plus sophistiquée:
	$$
	\begin{aligned}
	\hat{P}(w_n|w_{n-2}w_{n-1}) &= \lambda_{1}(w_{n-2}^{n-1})P(w_n|w_{n-2}w_{n-1})\\
	&+\lambda_{2}(w_{n-2}^{n-1})P(w_n|w_{n-1})\\
	&+\lambda_{3}(w_{n-2}^{n-1})P(w_n)
	\end{aligned}
	$$
	- Les lambdas sont déterminés à partir d'un jeu de validation (devset) séparé du jeu d'entraînement et de celui de test.
- Backoff (on utilise le premier non-nul en ordre décroissant: $C(zyx)$, $C(zy)$, $C(z)$
  - Katz Backoff
  - Stupid (web) backoff. Cet algorithme ne génère pas une distribution de probabilité, on identifie alors la mesure par $S$.
	$$
	\begin{aligned}
	S(w_i|w_{i-k+1}^{i-1}) &= 
	\begin{cases} 
		\frac{C(w_{i-k+1}^i)}{C(w_{i-k+1}^{i-1})}&,\text{si } C(w_{i-k+1}^i) >0\\
		0.4S(w_i|C(w_{i-k+2}^{i-1}))&,\text{sinon}
	\end{cases} \\
	S(w_i) &= \frac{C(w_i)}{N}\\
	\end{aligned}
	$$

# Classification de textes

Pourquoi classifier des textes:

- Filtrage du pourriel
- Services d'information
- Déterminer le genre de l'auteur
- Analyse de sentiments
- Sujet d'un document
- Détecter les fins de phrase
- Routage de courriel
- Priorisation de documents
- Détection de la langue
- Analyse des médias sociaux
- Étiquetage des pages web

Étant donné un document $\text{doc}$ et un ensemble prédéterminé de classes $C=\lbrace c_1, c_2, \ldots, c_J \rbrace$:

- Prédire la classe du document $\text{doc}$ où la fonction de classification $f(doc) \in C$

## Approches de classification

- Règles construites à la main
  - Combinaison de mots
  - Performances potentiellement élevées, mais difficiles à construire et à maintenir
- Apprentissage supervisé
  - Construire automatiquement un classificateur à partir de données d'entraînement.
  - $f: \text{doc} \rightarrow c$
  - Méthodes courantes:
	- Naive Bayes
	- Régression logistique
	- Réseaux de neurones
	- K-nearest neighbors
	- Arbres de décisions
	- Support vector machines
  - Limitations: L'étiquetage des données d'entraînement se fait à la main

## Naive Bayes

- Basée sur la règle de Bayes
- Représentation simplifiée des documents: 
  - **Sac de mots**: ensemble de mots sans ordre particulier
- Avantages:
  - Bons résultats en pratique
  - Peu de traitement pour construire le modèle, léger en utilisation mémoire
  - Bonne base de comparaison avec peu d'exemples ou des textes courts
- Inconvénients
  - Si un terme n'est pas dans les exemples d'une classe. On a recours au lissage pour corriger.
- Deux étapes:
  - Prétraitement
  - Classification

### Définition

On pose le problème d'optimisation suivant:
$$
\begin{aligned}
c^{\star} &= arg\,max_{c} P(c|doc) \\
&= arg\,max_{c} \frac{P(doc|c)P(c)}{P(doc)} \\
&\propto arg\,max_{c}P(doc|c)P(c)
\end{aligned}
$$

On représente un document selon la présence des termes:
$$
\text{doc} = \langle t_1,t_2,\ldots,t_n \rangle
$$

On obtient donc, en posant ensuite l'hypothèse d'indépendance entre les termes (d'où l'appellation naïve):
$$
\begin{aligned}
c^{\star} &= arg\,max_{c} P(c) \prod_{i=1}^{n} P(t_i|c) \\
&= arg\,max_{c} \log {P(c)} \sum_{i=1}^{n} \log {P(t_i|c)}
\end{aligned}
$$

### Calcul

La probabilité d'une classe $P(c)$ est:

$$
\begin{aligned}
P(c) &= \frac{\text{Nb. documents de classe c}}{\text{Nb. total de documents}} \\
&= \frac{N_c}{N_{doc}}
\end{aligned}
$$

La probabilité de retrouver $t_k$ dans un document de classe $c$ est:

$$
\begin{aligned}
P(t_k|c) &= \frac{\text{Nb. documents de classe c contenant }t_k}{\text{Nb. documents ayant la classe c}} \\
&= \frac{C(t_k,c)}{\sum_t C(t,c)}
\end{aligned}
$$

Pour la calculer, on rassemble tous les documents de la classe $c$ dans un seul document et on calcule la fréquence de $t_k$. C'est un modèle unigramme.

Enjeux:

- Si le mot n'apparaît pas
  - Lissage de Laplace:
  $$
  P(t_k|c) = \frac{C(t_k,c)+1}{\sum_t C(t,c) + |V|}
  $$
  - Add-delta
- Si le mot est inconnu: 
  - On le retire, comme en recherche d'information
  
### Attributs

- Pas nécessairement des mots:
  - N-grammes (lettres)
  - SpamAssasin:
	- Probabilité des mots
	- Mentions particulières (blacklist)
	- Expressions régulières
	- Expéditeur
	- Majuscules
	- Ratio texte-images
	- Émetteur est un proxy

### Analyse de sentiments

- On remplace les fréquences des mots par document par leur occurrence 
  - **Occurrence**: Nombre de documents contenant le mot au moins une fois
- Négation: inversion de la polarité des mots
  - Astuce: convertir en une représentation distincte (NOT_x)
  - Il y a d'autres approches plus précises avec une analyse syntaxique
- Lexiques de sentiments:
  - Dictionnaire indiquant la polarité d'un mot:
	- General Inquirer, LIWC, Opinion Lexicon, SentiWordNet
  - Compteur de mots négatifs ou positifs par document

# Évaluation

- Échantillon de test ou validation croisée. 
- Éviter de mémoriser les exemples d'entraînement (peeking)

## Métriques

![Matrice de contingence](matrice_contingence.png)

- Précision (ligne): 
$$
\frac{tp}{tp+fp}
$$
- Rappel (colonne):
$$
\frac{tp}{tp+fn}
$$
- Exactitude (diagonale): 
$$
\frac{tp+tn}{tp+fp+tn+fn}
$$
- Mesure F1: 
$$
F1 = 2\left(\frac{\text{precision}\times\text{rappel}}{\text{precision}+\text{rappel}}\right)
$$
- Mesure F:
$$
F_{\alpha} = \frac{1}{\alpha P^{-1}+(1-\alpha) R^{-1}}
$$

- Si $\alpha < 0.5$, la précision est plus importante
- Si $\alpha > 0.5$, le rappel est plus important
- F1: $\alpha = 0.5$

## Validation croisée

Meilleure estimation de la qualité du classificateur.

- Diviser les données en $k$ sous-ensembles
- Prendre aléatoirement $k-1$ sous-ensembles pour l'entraînement et celui qui reste pour le test de performance.
- Répéter $k$ fois et faire la moyenne des différentes métriques

Évaluation multiclasses:

- Tables de contingence 2x2
- Micro-averaging
  - Somme des tableaux pour chaque classe, puis calcul des métriques
- Macro-averaging
  - Moyenne des métriques pour chaque classe, calculées indépendamment

## Sélection des attributs

- Les collections de documents ont un grand nombre d'attributs. Les approches ne peuvent pas toutes les traiter. 
- Réduire le temps d'entraînement et rendre les classificateurs petits et efficaces. 
- Généraliser les données. Éliminer le bruit, la redondance.
- Éviter le surentraînement

Approche:

- Fréquence
- Mots-outils (stop words)
- Inverse document frequency
- BNS
- Information mutuelle

## Types de modèles

### Modèle génératif

Ce type de modèle va générer les mots $x$ associés à une classe $c$. 

- Par exemple: Naive Bayes $P(w|c)$
- Apprentissage "online"

### Modèle discriminatif

Ce type de modèle va discriminer parmi les classes possibles $P(c|doc)$

- Par exemple: Régression logistique (entropie maximale)
- Apprentissage "supervisé"

## Régression logistique

Forme générale de la régression:

$$
P(y=c|x) = \sum_{i=1}^N{w_{i}f_{i}+b}
$$

Classificateur binaire:

$$
\log \left( \frac{P(y=0|x)}{P(y=1|x)} \right) = \sum_{i=1}^N{w_{i}f_{i}}
$$

En utilisant la fonction sigmoïde:

$$
\begin{aligned}
P(y=1) &= \sigma(w \cdot x + b) \\
&= \frac{1}{1+e^{-(w \cdot x + b)}} \\
P(y=0) &= 1- \sigma(w \cdot x + b) \\
&= \frac{e^{-(w \cdot x + b)}}{1+e^{-(w \cdot x + b)}}
\end{aligned}
$$

On obtient une fonction de décision:

$$
\begin{aligned}
\hat{y} = 
\begin{cases}
1 &, P(y=1|x)>0.5 \\
0 &, sinon
\end{cases}
\end{aligned}
$$

Pour la régression multiple, on utilise la fonction softmax:

$$
p(y=c|x) = \frac{e^{w_c \cdot x + b_c}}{\sum_{j=1}^k e^{w_j \cdot x + b_j}}
$$

### Construction des attributs

- Variables indicatrices sur une caractéristique du document
- Compteurs de mots ou de polarités
- Logarithme de la longueur du document

Chaque attribut a un poids positif ou négatif

### Évaluation

Pour choisir la classe la plus probable, on peut simplifier le problème de régression:

$$
\begin{aligned}
\hat{c} &= arg\,max_{c \in C} P(c|x) \\
&=arg\,max_{c \in C} \frac{\exp({\sum_{i=1}^N w_{i}f_{i}(c,x)})}{\sum_{c^{\prime} \in C}{\exp({\sum_{i=1}^N w_{i}f_{i}(c,x)})}} \\
&=arg\,max_{c \in C} \exp({\sum_{i=1}^N w_{i}f_{i}(c,x)}) \\
&=arg\,max_{c \in C} \sum_{i=1}^N w_{i}f_{i}(c,x) \\
\end{aligned}
$$

On ignore le dénominateur et la fonction exponentielle tout en conservant l'ordre.

### Apprentissage

Trouver les paramètres $w_i$ et $b$ qui minimisent les erreurs du classificateur. On veut minimiser une fonction de perte ou maximiser une fonction de vraisemblance.

Pour la régression logistique: on maximise la vraisemblance:

$$
\begin{aligned}
\log(P(y|x)) &= \log(\hat{y}^y(1-\hat{y}^{1-y}))
\end{aligned}
$$

Ce qui revient à minimiser la fonction de perte suivante:

$$
\begin{aligned}
L_{CE}(\hat{y},y) &= -\log(P(y|x)) \\
&= -[y \log(\hat{y})+(1-y)\log(1-\hat{y})] \\
L_{CE}(w,b) &= -[y \log(\sigma(w \cdot x + b))+(1-y)\log(1-\sigma(w \cdot x + b))]
\end{aligned}
$$

La fonction de coût est:

$$
Cost(w,b) = \frac{1}{m} \sum_{i=1}^m L_{CE}(w,b)
$$

On minimise la fonction de perte:

$$
\begin{aligned}
\frac{\partial L_{CE}(w,b)}{\partial w_j} &= [\sigma(w \cdot x+b)-y]x_j
\end{aligned}
$$

Algorithme utilisé: Descente de gradient stochastique ou avec mini-batch.

## Conclusion

||Régression logistique|Naive Bayes|
|---|---|---|
|Hypothèse d'indépendance|Non|Oui|
|Ajustement pour corrélation|Oui|Non|
|Interprétabilité|Oui|Non|
|Taille de l'échantillon|Grand|Petit|
|Entraînement|Algorithme complexe|Simple et rapide|


# Analyse grammaticale

**Analyse grammaticale**: Attribuer une étiquette lexicale à chaque mot d’un texte

Usages:

- Synthèse vocale (prononciation)
- Analyse syntaxique (nom ou verbe)
- Extraction d’information (noms, relations)
- Traduction automatique (prendre le bon sens)

## Classes de mots

- Classes fermées
  - Nombre fixe de membres:
	- Prépositions et conjonctions: de, en, vers, et, mais, car,...
	- Pronoms: je, tu, elle, le mien, ...
	- Verbes auxiliaires: *may*, *can*, *will*, *been*, ...
	- Déterminants et nombres: un, la, le, ses, mon, ...
	- Particules (anglais): up, down, off, on
- Classes ouvertes
  - On peut ajouter de nouveaux mots
	- Noms (propres, communs, comptables, massifs)
	- Verbes (action, processus)
	- Adjectifs
	- Adverbes (manière, temps, quantité, lieu, ...)

## POS Tags

- Plusieurs ensembles d'étiquettes disponibles
  - Haut niveau (N, V, ADJ, ADV, DET, PRE, PRO)
  - Plus détaillé (Penn Treebank: 45 étiquettes)
  
|Tag  |Description                              |Example                    |
|-----|-----------------------------------------|---------------------------|
|CC   |conjunction, coordinating                |and, or, but               |
|CD   |cardinal number                          |five, three, 13%           |
|DT   |determiner                               |the, a, these              |
|EX   |existential there                        |there were six boys        |
|FW   |foreign word                             |mais                       |
|IN   |conjunction, subordinating or preposition|of, on, before, unless     |
|JJ   |adjective                                |nice, easy                 |
|JJR  |adjective, comparative                   |nicer, easier              |
|JJS  |adjective, superlative                   |nicest, easiest            |
|LS   |list item marker                         |                           |
|MD   |verb, modal auxillary                    |may, should                |
|NN   |noun, singular or mass                   |tiger, chair, laughter     |
|NNS  |noun, plural                             |tigers, chairs, insects    |
|NNP  |noun, proper singular                    |Germany, God, Alice        |
|NNPS |noun, proper plural                      |we met two Christmases ago |
|PDT  |predeterminer                            |both his children          |
|POS  |possessive ending                        |'s                         |
|PRP  |pronoun, personal                        |me, you, it                |
|PRP$ |pronoun, possessive                      |my, your, our              |
|RB   |adverb                                   |extremely, loudly, hard    |
|RBR  |adverb, comparative                      |better                     |
|RBS  |adverb, superlative                      |best                       |
|RP   |adverb, particle                         |about, off, up             |
|SYM  |symbol                                   |%                          |
|TO   |infinitival to                           |what to do?                |
|UH   |interjection                             |oh, oops, gosh             |
|VB   |verb, base form                          |think                      |
|VBZ  |verb, 3rd person singular present        |she thinks                 |
|VBP  |verb, non-3rd person singular present    |I think                    |
|VBD  |verb, past tense                         |they thought               |
|VBN  |verb, past participle                    |a sunken ship              |
|VBG  |verb, gerund or present participle       |thinking is fun            |
|WDT  |wh-determiner                            |which, whatever, whichever |
|WP   |wh-pronoun, personal                     |what, who, whom            |
|WP$  |wh-pronoun, possessive                   |whose, whosever            |
|WRB  |wh-adverb                                |where, when                |
|.    |punctuation mark, sentence closer        |.;?*                       |
|,    |punctuation mark, comma                  |,                          |
|:    |punctuation mark, colon                  |:                          |
|(    |contextual separator, left paren         |(                          |
|)    |contextual separator, right paren        |)                          |

Problème: Les mots ont souvent plus d'une étiquette, il faut alors déterminer la bonne.

## Modèle HMM

**HMM**: Hidden Markov Models

- Approche probabiliste
- Cas spécial d'inférence bayésienne
- Modèle génératif:
  - On détermine la structure de la phrase
  - On choisit le mot associé à chaque étiquette
  - La première étape est une chaîne de Markov et la seconde, l'extension cachée

### Définitions

- **Chaîne de Markov**: Automate avec des probabilités associées aux transitions. Chaque état ne dépend que du précédent.
- **Séquence d'entrée**: États suivis par l'automate.
- **Espace d'états**: Ensemble fermé d'états
- **Probabilité de transition**: Probabilité de passer de l'état $i$ à l'état $j$: $P(q_i=j|q_{i-1}=i)$
- **Probabilité initiale**: $\pi_i$: probabilité de démarrer dans l'état $q_i$

### Application au POS tagging

- Les états correspondent aux étiquettes lexicales. Ils sont cachés, ce qu'on observe, ce sont les mots. D'où le besoin d'une extension.
- Probabilité de transition $A=\lbrace a_{ij} \rbrace$: modélise la séquence d'étiquettes
- Probabilité d'émission $B=\lbrace b_i(k) \rbrace$: associe les mots aux étiquettes

![Hidden Markov Model](hmm.png)

Quelle est la meilleure séquence d'étiquettes qui correspond à la séquence d'observations ?

### Approche probabiliste

- Considérer toutes les séquences possibles $t_1, t_2, \ldots, t_n$
- Sélectionner celle qui est la plus probable: maximiser $P(t_1, t_2, \ldots, t_n|w_1,\ldots,w_n)$
- Problème d'optimisation:

$$
\hat{t}_1^n = arg\,max_{t_1^n} \frac{P(w_1^n|t_1^n)P(t_1^n)}{P(w_1^n)}
$$

Comme le dénominateur est une constante dans cette optimisation, on peut simplifier le problème:

$$
\hat{t}_1^n = arg\,max_{t_1^n} \overbrace{P(w_1^n|t_1^n)}^{\text{vraisemblance}}\overbrace{P(t_1^n)}^{\text{a priori}}
$$

- Vraisemblance: les mots correspondent aux étiquettes
- a priori: probabilité de retrouver une séquence d'étiquettes

Estimation:

- Présence d'une étiquette ne dépend que de la précédente: bigrammes
$$
P(t_1^n) \approx \prod_{i=1}^n P(t_i|t_{i-1})
$$
- Exemple: 
$$
P(\text{DT JJ NN} \ldots) = P(\text{DT}|\text{<s>})P(\text{JJ}|\text{DT})P(\text{NN}|\text{JJ})\ldots
$$
- Présence d'un mot ne dépend que de son étiquette
$$
P(w_1^n|t_1^n) \approx \prod_{i=1}^n P(w_i|t_i)
$$
- Exemple:
$$
P(\text{le petit chien}|\text{DT JJ NN}) = P(\text{le}|\text{DT})P(\text{petit}|\text{JJ})P(\text{chien}|\text{NN})
$$
- Résultat:
$$
\hat{t}_1^n = arg\,max_{t_1^n}P(w_1^n|t_1^n)P(t_1^n) \approx \prod_{i=1}^n \overbrace{P(w_i|t_i)}^{\text{émission}}\overbrace{P(t_i|t_{i-1})}^{\text{transition}}
$$

### Estimation des probabilités

À l'aide d'un corpus étiqueté

- Transition: $$P(t_i|t_{i-1}) = \frac{C(t_{t-1}|t_i)}{C(t_{i-1})}$$
- Émission: $$P(w_i|t_i)=\frac{C(t_i,w_i)}{C(t_i)}$$

## Décodage: Algorithme de Viterbi

Comme il n'est pas pratique d'énumérer tous les chemins possibles et d'estimer leurs probabilités, on utilise la programmation dynamique.

Tableau:

- Lignes: État possible
- Colonnes: Mots
- Treillis reliant les états possibles
- On multiplie les probabilités sur chacun des chemins et on conserve celui avec la probabilité la plus élevée aux noeuds qui recoupent deux chemins.
- $v_t(j)=\max_{i=1}^N v_{t-1}(i)a_{ij}b_j(o_t)$

### Extension

- Utiliser des trigrammes: 
$$
P(t_1^n) \approx \prod_{i=1}^n P(t_i|t_{i-1}t_{i-2})
$$
- Lissage des probabilités de transition par interpolation linéaire:
$$
P(t_i|t_{i-1}t_{i-2}) = \lambda_3 P(t_i|t_{i-1}t_{i-2}) + \lambda_2 P(t_i|t_{i-1}) + \lambda_1 P(t_i)
$$
- Mots inconnus:
  - Utiliser les suffixes des mots
  - Probabilité que les suffixes correspondent aux étiquettes:
	- Ex: P(-ment|RB)

## MEMM

- Chaque étiquette dépend du mot et d'autres attributs (étiquettes et mots précédents et suivants, par exemple, ou tout autre attribut du mot, dont la forme)

$$
\begin{aligned}
\hat{T} = arg\,max_{T} \prod_{i} P(t_i|t_{i-1},w_i,f_i)
\end{aligned}
$$

### Attributs possibles:

- $w_i$ contient un préfixe particulier (de tous les préfixes de longueur $\leq 4$)
- $w_i$ contient un suffixe particulier (de tous les suffixes de longueur $\leq 4$)
- $w_i$ contient un nombre
- $w_i$ contient une lettre majuscule
- $w_i$ contient un trait d'union
- $w_i$ est tout en majuscules
- la forme du mot $w_i$ 
- la forme courte du mot $w_i$
- $w_i$ est en majuscules et comporte un chiffre et un tiret (comme CFC-12)
- $w_i$ est en majuscules et suivi en 3 mots par Co, Inc.

### Séquence la plus probable:

$$
\begin{aligned}
\hat{T} = arg\,max_{T} \prod_{i}\frac{\exp\left(\sum_{j}\theta_{j}f_{j}(t_i,w_{i-l}^{i+l},t_{i-k}^{i-1})\right)}{\sum_{t^{\prime} \in \text{tagset}}\exp\left(\sum_{j}\theta_{j}f_{j}(t^{\prime},w_{i-l}^{i+l},t_{i-k}^{i-1})\right)}
\end{aligned}
$$

- Décodage avec l'algorithme de Viterbi, comme pour les HMM

$$
v_t(j) = \max_{i=1}^N v_{t-1}(i)P(q_j|q_i,o_t)
$$

- La résolution peut être bidirectionnelle.
- La performance se mesure par l'exactitude. 
  - Les meilleurs algorithmes obtiennent 97% en anglais.

# Analyse syntaxique

## Groupes syntaxiques

Groupes de mots formant une seule unité dans la phrase:

- Nominal (NP)
  - Exemples de règles
	- NP -> Pronoun
	- NP -> ProperNoun
	- NP -> Det Nominal
	- Nominal -> Noun | Nominam Noun
  - Noyau (Head noun): rôle central du groupe nominal
  - Modifiants:
	- Déterminants
	- Nombre
	- Adjectif
	- Adjectif indéfini
	- Groupe prépositionnel
- Verbal (VP)
  - Exemples:
	- VP -> Verb
	- VP -> Verb NP
	- VP -> Verb PP
	- VP -> Verb NP PP
  - Verbe de tête (head verb)
  - Arguments
- Prépositionnel
- Adverbial
- Adjectival

Ils ont une structure interne souvent similaire

Comportement externe:

- Par rapport aux autres unités
- On peut changer leur position dans la phrase
- Il est difficile de déplacer les mots individuellement

## Grammaire

Formalisation: grammaire hors contexte

- Règles
  - Un non terminal à gauche et un certain nombre de terminaux et non-terminaux à droite
- Symboles terminaux
  - Mots des phrases
- Symboles non terminaux
  - Groupes de mots
  
Types de phrases

- Déclarative
  - S -> NP VP
- Impérative
  - S -> VP
- Question oui-non
  - S -> Aux NP VP
- Question ouverte (WH question)
  - S -> WH-NP VP
  - S -> WH-NP Aux NP VP

## Analyseur

L'analyseur:

- Accepte ou rejette une phrase selon le respect de la grammaire d'une langue.
- Assigne une structure appropriée à une phrase (parsing):
  - Arbre
  - Représentation compacte
- Il peut produire plus d'un arbre

**Dérivation**: Séquence de règles appliquées à une phrase, recouvre tous les mots et seulement ceux-ci.
**Treebanks**: corpus de phrases associées à un arbre syntaxique. 

- Analyseur automatique et correction par l'humain. 
- Sers à définir une grammaire à partir des dérivations.
- Grammaire partielle, bonne couverture avec un large corpus

Approches:

- Descendant
  - Explore les arbres qui peuvent être des solutions
  - Suggère des arbres non consistants par rapport aux mots
- Ascendant
  - Suggère seulement des arbres compatibles
  - Les arbres peuvent ne faire aucun sens globalement
  
Enjeux du backtracking:

- Ambiguïté (problème de rattachement, groupes de mots qui ne font pas de sens au niveau sémantique)
- Répétition de sous-arbres à différents endroits

Solution: dynamic programming

- Éviter de refaire du travail inutilement
- Résoudre des problèmes exponentiels en temps polynomial
- Emmaganiser les sous-structures ambiguës avec leurs sous-parties communes
- CKY, Earley, Chart Parser

## CKY

- La grammaire doit être composée de règles binaires
- Si A, alors B et C existe et il y a un endroit pour les séparer
- Réécrire les règles non binaires sous la forme normale de Chomsky:
  - Deux symboles non terminaux ou un symbole terminal
  - Remplacer les symboles non terminaux uniques par toutes les formes qu'il peut prendre
  - Remplacer les symboles non terminaux au nombre de 3 ou plus par de nouvelles règles et de nouveaux symboles pour faire le découpage:
	- S -> A B C
	- S -> X C; X -> A B

### Algorithme

1. Construire le tableau. Les mots forment les colonnes.
2. Identifier les POS sur la diagonale selon le lexique
3. Traverser le tableau et identifier les groupes applicables à partir des règles de la grammaire sans contexte. Il peut y avoir plusieurs combinaisons à regarder pour chaque case.

Les boucles sont imbriquées pour remplir le tableau:

- Une colonne à la fois
- De gauche à droite
- Du bas vers le haut

- Les résultats nécessaires sont déjà présents dans le tableau. 
- Algorithme en ligne (online).
- Approche simplifiée
  - On connaît tous les mots via un lexique. 
  - La chaîne n'a pas d'étiquette lexicale.
  - Pas de genre ni de nombre
  - Pas d'analyse morphologique
- En pratique, on devrait considérer ces éléments

### Approche probabiliste

- On ajoute des probabilités à toutes les règles de la grammaire.
- On reprend l'algorithme CKY, mais en multipliant les probabilités des règles précédentes et de la règle courante. 
- On retient la plus grande probabilité pour chaque cellule. 

## Analyseur de dépendances

- Analyse syntaxique des relations entre les mots d'une phrase.
- Arbre dont:
  - Les noeuds représentent les mots
  - Les liens représentent les relations de dépendance entre les paires de mots
- Avantages:
  - Plus rapide à construire
  - Moins dépendant de l'ordre des mots
  - Capture des relations syntaxiques
- Approche vorace (voir Stanford Parser)
- Universal Dependancies: différentes langues

![Universal Dependency Relations](ud_relations.png)

Liste des dépendances

- acl: clausal modifier of noun (adjectival clause)
- advcl: adverbial clause modifier
- advmod: adverbial modifier
- amod: adjectival modifier
- appos: appositional modifier
- aux: auxiliary
- case: case marking
- cc: coordinating conjunction
- ccomp: clausal complement
- clf: classifier
- compound: compound
- conj: conjunct
- cop: copula
- csubj: clausal subject
- dep: unspecified dependency
- det: determiner
- discourse: discourse element
- dislocated: dislocated elements
- expl: expletive
- fixed: fixed multiword expression
- flat: flat multiword expression
- goeswith: goes with
- iobj: indirect object
- list: list
- mark: marker
- nmod: nominal modifier
- nsubj: nominal subject
- nummod: numeric modifier
- obj: object
- obl: oblique nominal
- orphan: orphan
- parataxis: parataxis
- punct: punctuation
- reparandum: overridden disfluency
- root: root
- vocative: vocative
- xcomp: open clausal complement

## Chunking

Analyse de surface: 

- Début et fin des groupes syntaxiques
- Pas d'arbre
- Seulement les parties qui nous intéressent

C'est un problème d'étiquetage

# Recherche d'information

**Recherche d'information**:

- Matériel (documents)
- Non structuré
- Besoin d'information
- Grandes collections

![Schéma général](recherche_info.png)

- Plusieurs modèles:
  - Booléen
  - Vectoriel
  - Probabiliste
  - Latent semantic indexing
  
## Recherche booléenne

- Expressions booléennes
- Retourne tous les documents qui satisfont l'expression
- Rencontré dans les bibliothèques (fonction de recherche avancée)
- Éviter d'utiliser des expressions régulières:
  - Lent pour de grandes collections
  - Orienté sur la ligne
  - Négation n'est pas triviale
  - Pas d'opérateur de proximité
- Construction d'une matrice terme-document
- Enjeux:
  - Avec beaucoup de mots et de documents: matrice très large et très creuse
  - N'enregistrer que les 1
- Index inversé:
  - Pour chaque terme, on garde une liste chaînée de tous les documents qui contiennent ce terme
  - Structure de données: dictionnaire, trié par ordre alphabétique
- Avantages:
  - Peut traiter toutes les requêtes booléennes
  - Résultats précis: le document satisfait ou non
- Inconvénients:
  - Il manque parfois un terme dans les longues requêtes
	- Variantes morphologiques
	- Texte d'ancrage
  - Résultats sans ordre particulier
	- Tous les résultats ont la même importance

![Index inversé](index_inverse.png)

### Construire l'index inversé

1. Prétraiter les documents
   - Tokenisation
   - Normalisation
2. Générer les postings (terme, identifiant document)
3. Trier les postings
4. Créer les listes et les compteurs de documents
5. Créer les structures de données (dictionnaire et listes)

### Étapes de la requête

- Recherche naïve: intersection des listes $O(N^2)$
- Listes triées: avancer dans les listes en ordre croissant

## Recherche vectorielle

### Représentation

Documents et requêtes: vecteurs de poids à N dimensions:

- Poids: importance du terme $T_i$ dans le document $D_j$
- Un terme fréquent dans un document est important
- Un terme fréquent dans plusieurs documents n'est pas important (stop words ou sujet général)
- Types de poids:
  - Binaires (0 ou 1)
  - Fréquence des termes (sans aucune modification)
  - TF-IDF
  - Poids TF-IDF: cette mesure présente plusieurs alternatives
  - Information mutuelle
- Similarité entre les vecteurs
- Matrice de comptes (CountVectorizer dans scikit-learn).

### TF-IDF

$$
w_{ik} = {tf}_{ik} \log(\frac{N}{n_k})
$$

- $T_k$: Terme $k$ dans le document $D_i$
- $tf_{ik}$: Fréquence de $T_k$ dans $D_i$
- $N$: Nombre total de documents dans la collection $C$
- $n_k$: Nombre de documents dans $C$ qui contiennent $T_k$
- $idf_k$: Fréquence inverse de $T_k$ dans C

### Similarité

- Angle entre les vecteurs: produit scalaire ou cosinus.
- Certains vecteurs sont plus longs que d'autres, ce qui leur donne une importance relative.
- Il faut normaliser les vecteurs (leur donner une longueur de 1)

$$
\begin{aligned}
cos(\vec{q},\vec{d}) &= \frac{\vec{q} \cdot \vec{d}}{|\vec{q}||\vec{d}|} \\
&= \frac{\sum_{i=1}^{|V|} q_{i}d_{i}}{\sqrt{\sum_{i=1}^{|V|} q_{i}^2}\sqrt{\sum_{i=1}^{|V|} d_{i}^2}}
\end{aligned}
$$

On peut alors retourner les documents qui ont le plus grand cosinus.
Mais on peut faire mieux en utilisant l'index inversé.

$$
\text{score}_d = \frac{\sum_{t} wf_{t,d}w_{t,q}}{|d|}
$$

Mesure de l'efficacité:

- Précision: 

$$
\frac{\text{pertinent et retenus}}{\text{retenus}}
$$

- Rappel: 

$$
\frac{\text{pertinent et retenus}}{\text{pertinents}}
$$

- Mesure F
- Mean average precision: on calcule la précision pour chaque document retourné, cumulativement, pour plusieurs requêtes, et on fait la moyenne ensuite.
- Précision à 5, à 10 ...
- Mean reciprocal rank: inverse du rang du document le plus pertinent 
$$
\text{MRR} = \frac{1}{|Q|} \sum_{i=1}^{|Q|}\frac{1}{\text{rank}_i}
$$
- Discounted cumulative gain: Tient compte du rang des documents pertinents 
$$
\text{DCG}_p=rel_1 + \sum_{i=2}^p \frac{rel_i}{\log_2{i}}
$$
  
## Lucene

![Lucene: Indexation et recherche](lucene.png)

# Sémantique lexicale

- Raisonnement: idées similaires avec des mots différents (thesaurus)
- Utilisation: détection de plagiat, système question-réponse, résumé de textes
- Approches possibles:
  - Taxonomie et thesaurus
  - Approche distributionnelle
- Relations entre les mots (lemmes)
  - Un lemme peut avoir plusieurs sens
  - **Sens**: Représentation d'un aspect de la signification d'un mot

## Relations

Les mots et leurs sens peuvent être reliés par différentes relations:

- Homonymie: forme commune (phonologie, orthographique ou les deux), mais sens différents
  - Homophones
  - Homographes
  - Les deux
  - Problèmes en NLP:
    - Synthèse vocale (même orthographe, mais phonologie différente)
    - Recherche d'information (même mot, sens différents)
    - Traduction automatique
    - Reconnaissance vocale (même phonologie, orthographe différente)
- Polysémie: Un mot a plusieurs sens
- Synonymie: Peuvent être remplacés l’un pour l’autre
- Antonymie: s’opposent sur un aspect
  - Binaire (adjectif)
  - Échelle de valeurs (mesure)
  - Réversibilité (action/verbes)
- Hyperonymie: plus général, regroupement
- Hyponymie: plus spécifique, sous-classe (inverse d'hyperonymie)
- Holonymie: compose le tout d'une partie (inverse de méronymie)
- Méronymie: une partie d'un tout

## Wordnet

Collection de sens de mots, regroupés sous la forme de *synsets*, des quasi-synonymes

Il y a 4 types de synsets:

- Nom
- Verbe
- Adjectif
- Adverbe

Ils forment un graphe sémantique. Ils forment aussi une hiérarchie de concepts.

### SentiWordNet

- Extension de WordNet pour l'analyse de sentiments et le forage d'opinions. Annotation de positivité, négativité ou neutralité.

## Mesure de la similarité

- Synonymie (simple)
- En pratique, on utilise la hiérarchie de concepts (noms et verbes). 
- On calcule la proximité par les chemins
  - $pathlen(c_1,c_2)$: 1+ nombre de liens
  - $sim_path(c_1,c_2) = \frac{1}{pathlen(c_1,c_2)}$
  - $wordsim(w_1,w_2) = max_{c_1 \in senses(w_1),c_2 \in senses(w_2)}$
