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

# Extraction d'information

Objectif : obtenir de l'information utile et la structurer.

Usages :

- Compréhension de textes
- Systèmes questions-réponses
- Traductions automatiques

Approches :

- À base de règles
- Par apprentissage

## Types d'information :

- Quasi structurée : texte formaté, par exemple un bulletin météo
- semi-structurée : texte en points de forme, par exemple une annonce classée
- non structurée : texte libre, par exemple un article de nouvelles

## Types d'extraction

- Reconnaissance d'entités nommées
- Détection et classification de relations
- Détection et classification d'évènements

## Reconnaissance d'entités nommées

**Entité nommée **: Se désigne par un nom propre, une quantité, une date, une marque temporelle ou un montant d'argent. Peuvent être spécifiques au domaine d'application.

Objectif : Trouver les entités nommées et les classer selon leur type. 

Usages :

- Indexation
- Identification de relations
- Résolution de requêtes
- Lien avec une base de connaissances

Exemples de types d'entités nommées :

- Personne
- Marques de commerce
- Lieu
- Organisation
- Géopolitique
- Argent
- Temps

Enjeux : ambigüité du type des entités. Peuvent appartenir à plusieurs catégories.

### Approches de NER

#### Apprentissage automatique :

Encodage IOB mot par mot :

- **B**eginning (premier jeton de l'entité)
- **I**nside (autres jetons de l'entité)
- **O**utside (ne fais pas partie d'une entité nommée)

Chaque étiquette a une position et un type, pour un total de $2n+1$ étiquettes possibles.

Étiquetage séquentiel :

- MEMM/CRF (généralisation de Viterbi)
- bi-LSTM (réseau de neurones récurrent et bidirectionnel)
- HMM (Modèle de Markov caché)
- SVM (Modèle discriminant)

Extraction des attributs des mots :

- identité, plongement, POS du mot et des voisins
- Étiquette syntaxique du mot, du groupe de mots et des mots voisins
- Mot présent dans un index géographique
- Contiens un préfixe ou un suffixe
- Tout en majuscules
- Forme du mot et des voisins
- Forme du mot court et des voisins
- Présente de trait ou de tiret

Portée d'un classificateur MEMM :

![Diagramme MEMM pour NER](memm-ner.png)

#### Base de règles

Caractéristiques :

- Largement utilisé en pratique
- Fort niveau de précision

Composantes :

- Listes d'entités
- Patrons ou expressions régulières pour reconnaitre des entités potentielles
- Patrons pour reconnaitre les environnements où des entités peuvent se trouver

Approche hybride :

1. Identifier les attributs :
    - Règles pour repérer les entités non ambiguës
    - Comparer des sous-chaînes avec des entités connues
    - Listes de noms d'entités spécifiques
2. Classificateur de séquence

## Détection et classification de relations

Objectif : capturer les relations sémantiques du domaine d'application, peupler une base de données

Formes des relations :

ENTITÉ - RELATION - ENTITÉ

Types de relations :

- PERSON-SOCIAL
    - Family
    - Business
    - Lasting personal
- PHYSICAL
    - Near
    - Located
- GENERAL AFFILIATION
    - Citizen
    - Resident
    - Ethnicity
    - Religion
    - Org-Location-Origin
- PART-WHOLE
    - Subsidiary
    - Geographical
- ORG AFFILIATION
    - Founder
    - Ownership
    - Membership
    - Sports affiliation
    - Employment
    - Student-Alumni
    - Investor
- ARTIFACT
    - User
    - Owner
    - Inventor
    - Manufacturer

### Exemple

| Domain | D = {a, b, c, d, e, f , g, h, i} |
|----------------------------------------------------------|--------------------------------------------|
| United, UAL, American Airlines, AMR | a, b, c, d |
| Tim Wagner | e |
| Chicago, Dallas, Denver, and San Francisco | f , g, h, i |


| Classes |  |
|----------------------------------------------------------|--------------------------------------------|
| United, UAL, American, and AMR are organizations | Org = {a, b, c, d} |
| Tim Wagner is a person | Pers = {e} |
| Chicago, Dallas, Denver, and San Francisco are places  | Loc = { f , g, h, i} |


| Relations |  |
|----------------------------------------------------------|--------------------------------------------|
| United is a unit of UAL | PartOf = {ha, bi, hc, di} |
| American is a unit of AMR |  |
| Tim Wagner works for American Airlines | OrgAff = {hc, ei} |
| United serves Chicago, Dallas, Denver, and San Francisco | Serves = {ha, f i, ha, gi, ha, hi, ha, ii} |

### Ressources

- Wikipedia
    - Infobox
- DBPedia
    - Représentation structurée de données provenant de Wikipédia
- Freebase
    - Personnes, lieux et objets
- Wordnet
    - Différentes relations sémantiques

### Approches possibles

- Règles écrites à la main
    - Forte précision
    - Faible rappel
    - Utiles pour un domaine spécifique, demande du temps pour la création des règles
- Apprentissage supervisé
    - Corpus d'entraînement étiqueté avec des entités et des relations
    - Classificateur pour chaque paire d'entités : 
        - Vérifier si reliées (modèle 1, exemples positifs et négatifs), 
        - Puis classifier la relation (modèle 2)
        - Régression logistique, Naïve Bayes, SVM
    - Attributs :
        - Prémisse (headword)
        - Mots précédant M1
        - Mots suivants M2
        - Mots entre M1 et M2
        - Type d'entité de M1
        - Type d'entité de M2
        - Concaténation des types
        - Analyse syntaxique des constituants
        - Analyse par morceaux (chunk) des constituants
        - Analyse des dépendances syntaxiques
- Apprentissage semi-supervisé
    - Classifier une relation sans corpus étiqueté
    - Bootstrapping (répéter plusieurs fois):
        - Quelques exemples
        - Extraire les paires d'entités de ces exemples
        - On les recherche dams un corpus ou sur le web
        - On apprend des patrons qui généralisent le contexte
        - On recherche ces patrons et on conserve ceux qui donnent plusieurs résultats
    - Semantic drift
        - Exemples erronés
        - Niveau de confiance :

        $$
        Conf(p) = \frac{hits_p}{finds_p} log(finds_p)
        $$

        - Niveau de confiance d'un exemple : 

        $$
        Conf(t) = 1-\prod_{p \in P}(1-Conf(p))
        $$

- Supervision distante
    - Utiliser une ressource avec un grand nombre d'exemples de qualité (DBPedia, Freebase, WordNet)
    - Trouver des phrases avec les entités de cette ressource
    - Extraire des exemples d'entraînement
    - Classificateur supervisé (avec les mêmes types d'attributs que l'approche supervisée)
    - Exemples négatifs : paires d'entités tirées au hasard qui n'apparaissent pas dans les relations
    - Avantages : mêmes que ceux des approches précédentes
    - Désavantage : Peu de relations pour de nouveaux domaines
- Apprentissage non supervisé
    - Patrons syntaxiques pour les relations :
    ```
    V | VP | VW*P
    V = verb particle? adv?
    W = (noun|adj|adv|pron|det)
    P = (prep|particle|inf. marker)
    ```
    - Segmenter les textes en phrases
    - Pour chaque phrase :
        - Faire un POS tagging et une analyse syntaxique
        - Trouver la plus longue séquence qui satisfait un patron à partir d'un verbe
        - Trouver les groupes nominaux à gauche et à droite
        - Déterminer un niveau de confiance en fonction de la fréquence des relations
    - Avantage : pas besoin de connaître les relations
    - Désavantage : On doit les convertir en relations sémantiques pour les stocker. Les relations sont basées sur des verbes, on va manquer les autres types de relations.

## Autres extractions

### Extraction d'expressions temporelles

- Similaire à l'extraction d'entités nommées
- Doivent être normalisées. Peuvent être absolues, relatives ou sous la forme de durées.

### Détection et classification d'évènements

- Repérage des verbes d'actions, d'état ou de communication
- Classificateurs de séquences
- Tri chronologique des évènements, en utilisant aussi l'extraction d'expressions temporelles

# Systèmes questions-réponses

Types de questions :

- Factuelles (Qui, où) ?
- Complexes (Que pense, Comment) ?

![Système QA factuel](systeme-qa-factuel.png)

## Approche avec un corpus de texte

- Réponses dans des documents
- Recherche d'information (moteur de recherche et indexation)

### Traitement des questions

- Détection du type de réponse
- Formulation de requête pour le moteur de recherche d'information
- Information à extraire de la question :
    - Type de réponse
    - Focus
    - Type de question
    - Mots-clés pour la requête

### Extraction des termes de requête

- Termes de requête : pour repérer des passages. 
Exclure :
    - le mot-question, 
    - les mots-outils et 
    - les verbes fréquents
- Taille du corpus : une seule réponse, formulation différente
- Expansion de requête : 
    - variantes morphologiques (mots de la même famille)
    - synonymes (provenant d'un thesaurus)
- Reformulation :
    - Forme affirmative, avec règles de réécriture (phrase ou le mot manquant est la réponse)
    - Ex : 
    ```
    wh-word did A verb B -> A verb +ed B
    Where is A -> A is located in
    ```

### Détection du type d'entité de la réponse

- Permets de limiter les passages pertinents et se concentrer sur les bonnes phrases.
- **Limitations **: les types d'entités détectés par les logiciels NER sont limités
- Taxonomie de réponse à deux niveaux : Li&Roth
    - 6 grandes classes
    - 50 sous-classes

Deux approches :

- Règles manuelles (expressions régulières)
- Classification automatique :
    - Annotation des données d'entraînement
    - Classification avec ces attributs
        - Mots de la question
        - POS
        - Entités nommées
        - Mot principal (headword), premier groupe nominal après le mot question

### Traitement de passages

- Résultat de la recherche : liste de documents priorisés selon leur similarité
- Problèmes :
    - Les documents ne sont pas les meilleures unités
    - Les documents en haut de la liste ne contiennent pas nécessairement la réponse
- Solution :
    - Découper les extraits des documents (segmentation)
        - Section, paragraphe, phrase
        - Fenêtre de mots
    - Filtrer les extraits qui ne semblent pas contenir de réponse
    - Réordonner ces extraits (avec des attributs)
        - \# d'entités nommées du bon type
        - \# de mots-clés de la requête
        - Plus longue séquence de mots de la question
        - Rang du document d'où le passage provient
        - Proximité des mots-clés de la requête
        - Nombre de N-grammes en commun
    - Sur le web, utiliser les "snippets"

### Extraction de réponses

- Span labeling : identifier la portion du texte qui constitue la réponse
    - Approche : NER, retourner la chaîne du bon type
    - Si la réponse n'est pas une entité nommée, on utilise des règles. Ces règles peuvent être apprises (comme pour l'extraction de relations, par exemple)
- Si plusieurs réponses : on propose les différentes réponses ou on utilise un classificateur
    - Type de la réponse
    - Correspondance à un patron
    - Distance du mot-clé
    - Mot observé pour la première fois
    - Apposition (nombre de mots entre le mot-question et la réponse, avec un maximum de 3 mots et une virgule)
    - Position des ponctuations
    - Séquence de mots de la question
- Mean reciprocal rank

$$
MRR = \frac{1}{N}\sum_{i=1}^N \frac{1}{rank_i} 
$$

## Approche avec des données structurées

- Base de connaissances (entités et relations, dbPedia, Freebase, WordNet). Extraction d'information
- Ex : Siri, Wolfram Alpha

# Modèles statistiques de traduction automatique

Traduction statistique : difficile de trouver les ressources autrement

- Corpus bitextes (mêmes textes dans deux langues)
- Trouver les mots ou les groupes de mots qui vont ensemble
- Parfois difficile d'avoir une bonne traduction, le sens des mots est différent entre les langues.
- **modèle IBM **: Compromis entre **fidélité** et **fluidité**

| Fidélité              | Fluidité                |
|-----------------------|-------------------------|
| sens de la traduction | lisibilité              |
| même information      | respect de la grammaire |
|                       | qualité du texte        |

Mathématiquement :

$$
\hat{T} = argmax_T fidelite(T,S) fluidite(T)
$$

En probabilités, on obtient :

$$
\hat{T} = argmax_T P(T|S) = argmax_T \frac{P(S|T)P(T)}{P(S)} = argmax_T P(S|T)P(T)
$$

où $P(S|T)$ est un modèle de traduction et $P(T)$ un modèle de langue.

## Canal bruité

![Traduction avec l'analogie du canal bruité](traduction-canal-bruite.png)

## Modèle de langue

- Modèle N-grammes (jusqu'à 5-grammes en anglais)
- Modèles syntaxiques (dépendance plus longue entre les mots)

## Modèle de traduction

Permets de quantifier les meilleures traductions pour un segment de phrase ou une phrase complète.

### Mots individuels

![Traduction de mots individuels](traduction-mots-invid.png)

- Les mots d'une phrase sont des traductions plausibles des mots de l'autre phrase

### Par séquence de mots (phrase-based)

![Traduction par séquence de mots](traduction-phrase-based.png)

- Inclus aussi des mots individuels
- Donne de meilleurs résultats que des mots individuels
- 3 étapes :
    - Regroupes les mots en groupes $E=\bar{e}_1, \bar{e}_2, \ldots$ (segmentation)
    - Traduire chaque groupe $\bar{e}$ en $f_i$:  $\phi(f_i|\bar{e}_i)$
    - Déplacer les groupes

$$
P(F|E) = \prod_{i=1}^I \phi(\bar{f}_i,\bar{e}_i)d(i)\\
$$

- **Distorsion **: Distance à laquelle le groupe est déplacé
- **Probabilité de distorsion** $d(i)$ du ième groupe. Distance entre $a_i$, la position de $f$ généré par $\bar{e}_i$ et $b_{i-1}$, la position de $f$ généré par le groupe précédent $\bar{e}_{i-1}$

$$
d(i)=\alpha^{|a_i-b_{i-1}-1|},\,0<\alpha<1
$$

- **Probabilités de traduction **: $\phi(f_i|\bar{e}_i)$
    - Corpus parallèle, avec correspondance entre les groupes de $E$ et $F$
    - Maximum de vraisemblance des probabilités
        - Compte des fréquences :

        $$
        \bar\phi(f_i|\bar{e}_i) = \frac{count(\bar{f}_i|\bar{e}_i)}{\sum_{\bar{f}}count(\bar{f}_i|\bar{e}_i)}
        $$

        - Corpus d'alignements de groupes de mots : difficile à construire.
        - On utilise les **alignements de mots **: Association des mots sources aux mots cibles dans des phrases parallèles.

        ![](traduction-alignement-mots.png)

        - Alignement un à plusieurs : Chaque mot cible a un seul mot source. Représentation sous forme de vecteur
        - Mots parasites : générés par un mot nul $e_0$
        - L'algorithme d'alignement donne les paramètres du modèle $P(F,E)$

## Modèle IBM 1

- Approche générative : $E \rightarrow F$
- Choix de la longueur $J$ de $F$ : $F=f_1,f_2,\ldots,f_j$
- Alignement 1 à plusieurs
- Pour chaque position de Fm générer $f_j$ correspondant à $e_{aj}$

### Calcul de $P(F|E)$

- $(I+1)^J$ alignements possibles, incluant le *mot nul*
- Distribution de longueur $\epsilon=P(J|E)$
- Alignements équiprobables :

$$
P(A|E) = P(A|E,J)P(J|E) = \frac{\epsilon}{(I+1)^J}
$$

- Soit $t(f_x,e_y)$ la probabilité de traduire $e_y$ en $f_x$ :

$$
P(F|E,A) = \prod_{j=1}^J t(f_i,e_{a_j})
$$

- $P(F|E)$ est la somme sur tous les alignements

$$
P(F|E) = \sum_A P(F|E,A)P(A|E) = \sum_{a \in A} \frac{\epsilon}{(I+1)^J} \prod_{j=1}^J t(f_i,e_{a_j})
$$

## Apprentissage des alignements

- Corpus parallèles (Hansard canadien, Hong Kong Hansards)
- Alignement des phrases
    - Longueur en mots ou en caractères
    - Programmation dynamique
    - Modèle simple de traduction
    - Retrait des phrases non alignées, fusion des phrases sources des alignements qui ont la même phrase dans la destination (n à m, $n,m>0$)
- Alignement des mots dans les phrases
    - Bootstrapping
    - Algorithme Expectation-Maximization
        - E : probabilité de tous les alignements possibles (paramètres courants du modèle)
        - M : réestimer les valeurs de chaque paramètre
- Alignement des groupes de mots
    - Application de la symétrie à partir des alignements de mots, en faisant l'intersection des alignements pour $E \rightarrow F$ et $F \rightarrow E$. On ajoute des alignements en utilisant l'union (Algorithme de Och and Ney), avec des critères tels que :
        - case vide,
        - adjacence,
        - probabilité
        
    - Table de traduction : on conserve les groupes de mots pour le décodage

## Décodage

Obtenir la meilleure traduction E depuis la phrase F

$$
argmax_{E \in English} P(F|E)P(E)
$$

- On ne peut énumérer toutes les phrases possibles
- Algorithme d'exploration (stack decoding, A*)
    - $f(s) = g(s)+h(s)$ : coût actuel (partiel) + coût estimé. Optimal si $h(s)$ ne surestime pas, donc est admissible

    ![Stack decoding - A*](stack-decoding.png)

- On considère seulement les groupes possibles avec la table de traduction
- Coût actuel $g(s)$ : probabilité totale pour les groupes traduits

$$
cost(E,F) = \prod_{i \in S} \phi(\bar{f}_i,\bar{e}_i) d(a_i-b_{i-1}) P(E)
$$

- Coût futur
    - Le coût de traduire les mots restants dans la phrase source
    - Très coûteux à évaluer précisément
    - Approximation :
        - Pas de distorsion 
        - Minimiser le produit du modèle de traduction et de langue
        - Séquence la plus probable par Viterbi
- Q devient rapidement trop grand
    - Recherche par faisceau : on conserve les $k$ solutions les plus prometteuses à chaque étape.
- Difficile de comparer le coût pour un nombre de mots différents
    - Solution possible : Une file par nombre de mots traduits
    - Multistack 
    
## Évaluation

- Évaluation humaine : la plus fiable
- Évaluation automatique : moins coûteuse
    - Traductions de référence
    - Similarité avec les traductions de référence :
    - Différentes mesures : BLEU, NIST, Précision/Rappel, METEOR

### BLEU

- Nombre de n-grammes de différentes tailles en commun avec la traduction de référence. 
    - Mesure de précision modifiée : Moyenne des précisions pour tous les N-grammes jusqu'à N.
- Clip count: nombre maximum d'apparitions d'un mot dans les références (peut être 1). Mesure de référence.

$$
p_n = \frac{\sum_{C \in corpus}\sum_{ngram \in C} count_{clip}(ngram)}{\sum_{C \in corpus}\sum_{ngram \in C} count(ngram)}
$$

$$
p = \sqrt[N]{\prod_{n=1}^N p_n}
$$

- Pénalité pour les phrases courtes :
    - c = longueur de la traduction
    - r = longueur de la phrase de référence ayant le plus grand nombre de n-grammes en commun avec la traduction

$$
BP = 1_{c>r} + e^{1-r/c}*1_{c \leq r}
$$

# Introduction aux réseaux de neurones

## Trois visions du réseau de neurones :

- Métaphore de la structure du cerveau. Un neurone est composé de :
    - Dendrites
    - Noyau
    - Axone
    - Synapses
- Une cascade de régressions logistiques
    - Somme pondérée des valeurs en entrée (signal z)
    - Fonction d'activation sigmoïde
    - Signal en sortie

    $$
    y = \sigma(w \cdot x + b) = (1+\exp(-(w \cdot x + b)))^{-1}
    $$
- Un large réseau d'opérations simples
    - Différentes fonctions d'activation
        - sigmoïde : $\frac{1}{1-e^{-x}}$
        - tanh : $\frac{e^x-e^{-x}}{e^x+e^{-x}}$
        - RELU : $max(x,0)$

## Réseau feedforward

- Unités connectées sans cycle
    - Plusieurs neurones = plus discriminant
    - Plusieurs séparateurs
- Pas de retour en arrière
- Couches :
    - Entrée
    - Cachées (représentation intermédiaire)
    - Sortie

![Un réseau de neurones feedforward](NeuralNetwork.png)

- Notation matricielle :

$$
\begin{aligned}
\mathbf{W} &= \begin{pmatrix}{w_{1,1}} & {w_{1,2}} & {w_{1,3}} & \cdots & {w_{1,n_0}}\\
{w_{2,1}} & {w_{2,2}} & {w_{2,3}} & \cdots & {w_{2,n_0}}\end{pmatrix}\\
\mathbf{b} &= \begin{pmatrix}{b_{h,1}} & {b_{h,2}} & {b_{h,3}} & \cdots & {b_{h,n,1}}\end{pmatrix}\\
\mathbf{h} &= \begin{pmatrix}{a_{h,1}} & {a_{h,2}} & {a_{h,3}} & \cdots & {a_{h,n,1}}\end{pmatrix}
\mathbf{h} &= \sigma(\mathbf{W}x+\mathbf{b})\\
\mathbf{U} &= \begin{pmatrix}{u_{1,1}} & {u_{1,2}} & {u_{1,3}} & \cdots & {u_{1,n_0}}\\
{u_{2,1}} & {u_{2,2}} & {u_{2,3}} & \cdots & {u_{2,n_0}}\end{pmatrix}\\
\mathbf{z} &= \mathbf{U}h \\
\mathbf{y} &= softmax(\mathbf{z}) \\
&=  \begin{pmatrix}{\frac{e^{z_1}}{\sum_{j=1}^d e^{z_j}}} & \cdots & {\frac{e^{z_d}}{\sum_{j=1}^d e^{z_j}}}\end{pmatrix}
\end{aligned}
$$

On veut minimiser une fonction de perte $L$ à l'aide des poids $w_i$ et des biais $b$.

- Rétropropagation des erreurs
- Descente de gradient

## Utilisation en NLP

Classificateurs supervisés :

- Segmentation de phrases
- Identification de la langue
- Analyse de sentiments (classificateur binaire)
- Extraction de relations

Approches :

- Sélection automatique des attributs
- Prétraitement des textes pour construire des attributs
    - Sac de mots
    - Mots négatifs
    - Entités nommées
- Classificateur supervisé sur ces attributs

**Apprentissage de la représentation** (*representation learning*): 

- Le classificateur utilisé précédemment est remplacé par un réseau de neurones.
- On fournit un texte brut au réseau et on lui laisse découvrir les bons attributs.
- Une bonne représentation des bots : plongements de mots (*word embeddings*) 

# Plongements de mots

Représentations d'un mot :

- Vecteur one-hot (indicateur 1 sur le mot exact) : 
    - [0 0 0 0 1 0 0 0 0 ...] (chat)
- Expansion de mots similaires (ex : synonymes et hyperonymes de WordNet) : 
    - [0,1,...,0,1,0,0,1,...] (animal, chat, félin, mammifère)
- Vecteur de contexte (compte, Positive Pointwise Mutual Information - PPMI)
    - [0,1,...,0,1,0,0,1,0,1,0,1,...] (animal, chat, félin, litière, poil, lait, boire)

Inconvénients :

- Ces vecteurs sont parfois très longs et contiennent de nombreux 0. 
- On veut des vecteurs **courts** et **denses** (Entre 50 et 1000 dimensions).
    - Facile à emmagasiner et à charger en mémoire
    - Attributs de classificateurs (moins de paramètres ou de poids)
    - Les dimensions recoupent des mots différents
    - Un peu comme un PCA, mais pour des mots.

Approches possibles :

- Réduction de dimensionnalité
- Réseaux de neurones

## Réduction de dimensionnalité

- Plusieurs matrices de plus petite dimension
- Matrice mots-contexte décomposée en matrice de mots (plongement de mot) et matrice de contextes (plongement de contexte) :
    - $(|v| \times c) = (|V| \times m)(m \times c)$
- Décomposition en valeur singulière
- Latent semantic analysis (LSA)
- 3 matrices : $(|V| \times c) = (|V| \times m) (m \times m) (m \times c)$
- $X = W \Sigma C$ où $\Sigma$ est une matrice diagonale de valeurs singulières $\sigma_1, \ldots, \sigma_m$. On conserve les lignes et les colonnes pour les $k$ plus grandes valeurs singulières afin de réduire la dimensionnalité.

Avantages :

- Retire l'information moins importante
- Capacité de généralisation
- Facilite l'apprentissage

Inconvénients

- Pas nécessairement meilleur que PPMI
- Effort de calcul considérable

## Réseaux de neurones

- On construit un plongement de mots à l'aide d'un réseau de neurones encodeur-décodeur. La première section du réseau représente le mot et la seconde tente de recréer le contexte (le mot suivant, par exemple)

![Réseau de neurones](neural-network-1.png)

## Word2vec

### CBOW

 **CBOW** (Continuous bag of words) : Représentation d'un mot cible à partir d'une fenêtre de mots sources. Par exemple, prendre 3 mots d'une phrase et tenter de prédire le quatrième.

### Skip-gram

**Skip-gram**: Représentation d'un contexte cible à partir d'un mot source. Par exemple, tenter de prédire les 3 mots précédant le quatrième mot.

![CBOW et Skip-Gram](Illustration-of-the-word2vec-models-a-CBOW-b-skip-gram-16-33.png)

### Étapes

- Assigner des poids aléatoires
- Corpus d'entraînement
    - Fenêtre de mots
    - One hot vector pour chaque mot (entrée)
    - Prédire la probabilité des mots de contexte (sortie)
    - Calculer l'entropie croisée pour $T$ instances (fonction de coût)

    $$
    J = - \frac{1}{T} \sum_{i=1}^T \log\,p(c_i|w_i)
    $$

    - Corriger les poids (rétropropagation)

    $$
    w_{ij}^{\prime\,(new)} = w_{ij}^{\prime\,(old)} - \eta \cdot \sum_{c=1}^C(y_{c,j}-t_{c,j}) \cdot h_i
    $$

    - Récupérer les plongements (poids des liens vers un mot ou un contexte) et les conserver dans une structure de données

- Similarité de vecteurs de mot $v_j$ et de contexte $c_k$ : 
    - produit scalaire des vecteurs correspondants dans les matrices de poids.

![Embeddings depuis le modèle skip-gram](skip-gram-embeddings.png)

- Avec le modèle Skip-gram, on obtient des probabilités de cooccurrence en utilisant un softmax.
    - Problème : le dénominateur est coûteux à calculer.

$$
p(w_j|w_k) = \frac{\exp(c_k \cdot v_j)}{\sum_{i \in |V|} \exp(c_i \cdot v_j)}
$$

### Negative sampling

On choisir au hasard des mots qui ne sont pas dans le contexte du mot cible.
On minimise $L(\theta)$ :

$$
\begin{aligned}
P(+|t,c) &= \frac{1}{1+e^{-t \cdot c}}\\
P(-|t,c) &= \frac{e^{-t \cdot c}}{1+e^{-t \cdot c}}\\
L(\theta) &= \sum_{(t,c) \in +} log\,P(+|t,c) + \sum_{(t,c) \in -} log\,P(-|t,c)
\end{aligned}
$$

### Propriétés

- Visualisation
    - Listes de mots similaires
    - Par regroupement de mots (clustering)
- Propriétés des embeddings
    - Petite fenêtre de mots : représentation syntaxique (catégorie grammaticale)
    - Grande fenêtre de mots : représentation lexicale (thème)
    - Analogie : 
    ```
    vecteur(king)-vecteur(man)+vecteur(woman) -> vecteur(queen)
    ```
    - superlatif (strong, stronger, strongest) tous sur le même axe
- Autres plongements :
    - Glove (matrice de cooccurrence)
    - FastText (mots et n-grammes de caractères)
    - Elmo (plusieurs vecteurs de contexte)
    - Bert (plongements contextuels)
    - Tensorflow Lite SGNNs (prédiction synamique des plongements)

# Modèles et applications

## Modèle de langue (feedforward)

- Le réseau de neurones approxime la matrice de probabilités
- L'historique des N-grammes est représenté par des plongements
- Plongements pré-entraînés + N-grammes = prédiction du prochain mot
    - On réutilise toujours le même réseau

![Modèle de langue avec réseau de neurones](neural-net-modele-langue.png)

Approche :

- Assignation du vecteur de plongement à chaque mot
- Concaténation des vecteurs ($1 \times Nd$)
- On propage les valeurs sur la couche cachée ($1 \times h$)
- La dernière couche prédit le scode de chaque mot du vocabulaire.
- Conversion en probabilités avec softmax.

Nouveaux mots :

- Les mots similaires ont des plongements similaires
- Remplace le lissage

Avantages de l'approche RN :

- Pas de lissage
- Historique plus long
- Pouvoir prédictif plus élevé pour un même corpus
- Modèles réutilisables pour d'autres tâches

Désavantage :

- Temps d'entraînement beaucoup plus important

### Apprentissage simultané des plongements

- Il est possible d'apprendre les plongements de mots simultanément avec le modèle en utilisant des one-hot vectors en entrée. 
    - La matrice de poids de projection $E$ est partagée pour tous les mots.
    - Initialisation avec poids aléatoires
    - Pratique pour apprendre la polarité en analyse de sentiments

![Modèle de langue et apprentissage des plongements avec réseau de neurones](neural-net-modele-langue-2.png)

## Classification de texte (feedforward)

- **Enjeu **: textes de longueurs variables
- **Solution **: continuous bag of words

$$
\text{CBOW}(f_q,\ldots,f_k) = \frac{1}{k}\sum_{i=1}^k v(f_i)
$$

- **Amélioration **: Utiliser un poids relatif pour chaque mot, par exemple tf*idf

$$
\text{WCBOW}(f_q,\ldots,f_k) = \frac{1}{\sum_{i=1}^k a_i}\sum_{i=1}^k v(f_i)
$$

- **Avantages : efficace, bon *baseline* pour évaluer d'autres algorithmes

## POS tagging et réseaux de neurones (RNN)

Caractéristique du problème du POS tagging :

- Une étiquette pour chaque mot, qui dépend aussi des étiquettes précédentes
- La longueur des phrases varie, on ne peut pas utiliser une fentêtre fixe
- L'ordre des mots est important

Besoin : architecture adaptée

- On a vu précédemment les MEMM qui répondent à ce besoin
- On utilise un réseau de neurones récurrent : l'étiquette $y_t$ dépend du mot $x_t$ et du contexte précédent $h_{t-1}$

![Inférence POS dans un réseau RNN](inference-rnn.png)

- Les poids U, W et V sont les mêmes à chaque étape du réseau de neurones

![Architecture du RNN](architecture-rnn.png)

Approches :

1. Choisir l'étiquette la plus probable à chaque étape
2. Trouver la meilleure séquence d'étiquettes avec Viterbi (aussi appelé CRF)
    - Considère les probabilités de transition $P(tag_t|tag_{t-1})$

Extension :

- On aimerait aussi considérer le contexte à droite au lieu de seulement le contexte à gauche.

3. Réseau bidirectionnel. On combine les deux couches cachées $h^{forward}$ et $h^{backward}$ avant de calculer la couche de sortie.

- Problèmes avec l'utilisation des mots :
    - Lexique volumineux = plongement pour tous les mots
    - Mots inconnus (fautes, noms propres, autre langue, termes techniques, ...)

4. Utilisation du mot et de la séquence de caractères
    - Identification de la langue
    - Analyse grammaticale (forme du mot)
    - Augmentation de la représentation du mot avec les caractères (avec son propre RNN)

## Autres applications des RNN 

- Modèle de langue : permet d'estimer les probabilités ou encore de faire de la génération de texte

- Classification de texte : 
    - RNN pour effectuer l'**encodage en un seul vecteur de contexte** $h_n$ de tout le texte
    - On peut aussi utiliser un réseau bidirectionnel pour éviter que la classification dépende trop des mots à la fin du texte
    - Réseau feedforward pour la classification.

- Entités nommées :
    - Plusieurs approches récurrentes

![RNN pour NER](ner-rnn.png)

## Extension des RNN

Problèmes des RNN :

- Gradient evanescent (le signal s'atténue rapidement lors de la rétropropagation)
- Chaque unité a de l'information locale principalement
- Information distante parfois importante (coréférences par exemple)
- Les poids servent à deux choses : 
    - décision sur le contexte actuel
    - propager l'information utile pour les décisions futures

On se retrouve avec différentes unités de traitement, dont la complexité peut être encapsulée dans la neurone.

### Gated-recurrent unit (GRU)

- Vecteur de portes booléennes $p$. 
- L'état $h_t$ provient en partie de l'état précédent $h_{t-1}$ et de l'inférence au temps $t$
- Les portes r et x sont calculées dynamiquement en fonction de $h_{t-1}$ et $x_t$ ou apprises en fonction du problème.

$$
h^{\prime} = p \cdot x + (1-p) \cdot h
$$

![Gated recurrent unit](780px-Gated_Recurrent_Unit,_type_2.svg.png)

### Long short-term memory (LSTM)

- Mémoire à long terme $c_t$
- 3 portes : 
    - $f$ (forget)
    - $i$ (input)
    - $o$ (output)

![Long short-term memory](640px-The_LSTM_cell.png)

## Traduction automatique (Seq2Seq)

- Neural machine translation
- Un seul réseau qui encore la phrase source comme un vecteur et génère la phrase correspondante dans la langue cible
- Encodeur-décodeur
    - Un réseau récurrent encore la phraise initiale
    - Un autre réseau décode cette phrase
    - Sortie du décodeur :
        - 1 meilleur (mot le plus probable, vorace, pas de garantie de trouver la traduction la plus probable)
        - k meilleur (beam search)

![Encoder-decoder Models (Neubig)](encoder-decoder-translation.png)

- Limitation importante : tout est encodé dans un seul vecteur de longueur fixe
- On conserve un vecteur pour chaque mot de la phrase source
    - On réfère à ces vecteurs pour le décodage
    - Les références varient selon le contexte
- Mécanisme d'attention
    - Permet de reproduire le principe des alignements
    - Score d'attention $a_{ij}$ après normalisation
    - Encodage dans des vecteur $h_j$
    - Contexte : $c_i = \sum_j a_{ij} \cdot h_j$
    - Plusieurs options :
        - produit scalaire de $h_t^{(e)}$ et $h_t^{(f)}$
        - fonction bilinéaire de $h_t^{(e)}$, $W$ et $h_t^{(f)}$
        - MLP avec tanh où on calcule $\mathbf{v}^T \tanh(W_f h_t^{(f)} + W_e h_t^{(e)})$
        
