# IDL - Cours 3 - idl03_metrics_ML

On a vu :
- il existe plein de tâches de TAL
- il existe différentes méthodes

:::info
**Question** : Comment évaluer un système de TAL pour une tâche X ?
:::

:question: la métrique d'évaluation dépend-elle de la tâche ?

Exemple de tâches :
- traduction
- modèle de langue
- ==classification==

## Exemples de métriques

### Trad : Métrique BLEU (bilingual evaluation understudy)
« plus une traduction automatique est ==proche== d’une traduction humaine professionnelle, mieux c’est »
- fait un calcul d'exactitude sur des n-grams de mots (généralement de 1 à 4)

#### 1-gram : comparaison des mots un à un


#### 2-gram : comparaison des mots par groupe de deux


#### 3-gram : ... par groupes de 3


#### 4-gram : ... par groupes de 4


Commentaire :

- ne prend pas en compte l'intelligibilité
- ne prend pas en compte la correction grammaticale ou syntaxique

Utilisation, avec la librairie `nltk` :

from nltk.translate.bleu_score import corpus_bleu

references = [[['my', 'first', 'correct', 'sentence'], ['my', 'second', 'valid', 'sentence']]]
candidates = [['my', 'sentence']]
score = corpus_bleu(references, candidates)

### LM : la perplexité :thinking_face:

Un modèle de langue est un modèle de probabilités sur des phrases.

Il est capable de :
- générer des phrases plausibles
- accorder une probabilité à une phrase qui lui est proposée

Si la phrase proposée est hors contexte, le modèle doit lui attribuer une faible probabilité, à l'inverse une phrase cohérente dans le contexte reçoit une forte probabilité.

La ==perplexité== du modèle capture la capacité du modèle à être correctement "perplexe" face au phrases qui lui sont proposées.

Le calcul de perplexité repose notamment sur le calcul de probabilité d'apparition d'un certain élément sachant le contexte précédent.

### Classification : combinaison de métriques

**Exemple 1 : Annotation en parties du discours (morphosyntaxe)**

Performances annoncées de Spacy : 95% ([source](https://spacy.io/models/fr))

95%... de quoi ? => d'*accuracy*, c'est à dire l'exactitude.

:question: à quoi sert une évaluation ?

:::spoiler
==Une évaluation doit servir à prédire la performance d'un système.==
:::

*Let's check !*

<sentence id='0'>
<mot type='NOUN'>Hymne</mot>$  ok
<mot type='ADP'>à</mot>   ok
<mot type='DET'>la</mot>   ok
<mot type='NOUN'>beauté</mot>   ok

</mot><mot type='PROPN'>Viens</mot>  nok
<mot type='PROPN'>-</mot>   nok
<mot type='VERB'>tu</mot>   nok
<mot type='ADP'>du</mot>   ok
<mot type='NOUN'>ciel</mot>   ok
<mot type='ADJ'>profond</mot>   ok
<mot type='CCONJ'>ou</mot>   ok
<mot type='ADV'>sors</mot>   nok
<mot type='NOUN'>-</mot>   nok
<mot type='VERB'>tu</mot>   nok
<mot type='ADP'>de</mot>   ok
<mot type='DET'>l'</mot>   ok
<mot type='NOUN'>abîme</mot>   ok
<mot type='PUNCT'>,</mot>   ok
</mot><mot type='NOUN'>Ô</mot>   nok
</sentence>

19 mots, 12 corrects, 7 incorrects.
==Exactitude== calculée : NB_correct / NB_total = 63%.

:::warning
=> Pourquoi cette valeur n'est pas celle annoncée ?
:::

#### Un autre cas d'étude : État de l'art automatique :rainbow:

:::info
**L'évaluation dont vous êtes le héros / l'héroïne**
Dans le cadre de votre projet tuteuré, vous utilisez un système qui sélectionne automatiquement pour vous dans une base de donnée les articles pertinents pour votre état de l'art.
- Vous lancez l'algo sur votre base de données de 50 articles
- L'algo vous renvoie 27 articles
- Vous décidez de vérifier quand même manuellement le résultat (20 sont en effet pertinents)
:::

**Comment évaluez vous cet outil (quel est votre avis sur sa performance) ?**

(**au tableau**) schéma de la classification / matrice de confusion / Précision / Rappel.

:question: À votre avis, vaut-il mieux :
- une plus grande ==précision== :
🐱🧟🐱🐱🧟🧟🐱 => 🐱:eight_pointed_black_star:🐱🐱:eight_pointed_black_star:🧟🐱
ici, chaque prédiction tombe juste, aucun chat n'a été blessé.
- un plus grand ==rappel== :
🐱🧟🐱🐱🧟🧟🐱 => :eight_pointed_black_star::eight_pointed_black_star::eight_pointed_black_star:🐱:eight_pointed_black_star::eight_pointed_black_star::eight_pointed_black_star:
ici, tous les zombies on été éliminés... mais pas qu'eux.

Plus grande précision = peu de ==*bruit*== (aucun article non-pertinent dans votre sélection)
Plus grand rappel = peu de ==*silence*== (il ne manque aucun article pertinent)

:::spoiler
...ça dépend beaucoup de la tâche à laquelle on s'attelle. Dans le cas de la détection automatique de contenu préjudiciable (*harmful content*), vaut-il mieux en laisser passer quelques uns ou risquer de censurer des contenus qui ne posent pas problème ?
:::

##### Métrique :

La F-mesure (moyenne harmonique de la précision et du rappel) comme mesure unique, adaptable selon les besoins. En effet, on peut ajouter des coefficients devant la précision et le recall (rappel) pour augmenter l'importance de l'un ou de l'autre dans l'évaluation d'un outil.


#### Retour à l'annotation en POS

==Précision== = qualité NB correct / NB attribué
P = ( 4/6 (NOUN) + 3/3 (ADP) + 2/2 (DET) + 0/2 (PROPN) + 0/2 (VERB) + 1/1 (ADJ) + 1/1 (CCONJ) + 0/1 (ADV) + 1/1 (PUNCT) + 0/0) / 9 = 63%

Rq: ici on ne prend pas en compte la catégorie "PRON" qui aurait dû apparaître.

Lorsque tout est annoté, exactitude et précision sont confondues, *car le nombre d'éléments annotés est égal au nombre d'éléments total*.

==Rappel== = NB correct classe i / NB attendu classe i
R = ( 4/4 (NOUN) + 3/3 (ADP) + 2/2 (DET) + 0/2 (PROPN) + 0/2 (VERB) + 1/1 (ADJ) + 1/1 (CCONJ) + 1/2 (PUNCT) + 0/2 (PRON) ) / 9 = 61%

==F-mesure== = ( 2 * P * R ) / ( P + R ) = 0.62

:question: Toutes les erreurs se valent-elles ?

- *le chat*/VERB *mange la souris*. (NOUN attendu) vs *il est fatigué*/VERB. (ADJ attendu)
- catégories plus ou moins fréquentes

## Préparation TP de demain : identification de langue

- corpus parallèle 22 langues ~ 10 000 mots chacuns
1. méthode des mots les plus fréquents
2. méthode des n-grams les plus fréquents (des 1-grams au 4-grams)
3. ==avec du machine learning== (supervisé)

:question: quel est le type de tâche qu'on essaye de résoudre ici ?

:question: de quoi a-t-on besoin ?

:::spoiler
- un corpus d'entraînement
- un corpus de test
- un algo d'apprentissage
- un vectoriseur
- un "classifieur"
:::

### Vectoriseur

`Sklearn Count Vectorizer` ([source](https://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html))

*Converts a collection of text documents to a matrix of token counts.*

:warning: code à tester : à quoi correspondent les coefficients dans les tableau à votre avis ?

from sklearn.feature_extraction.text import CountVectorizer
corpus = [
    'This is the first document, but this is the best one, in this great corpus.',
    'This document is the second document.',
    'And this is the third one.',
    'Is this the first document?',
    'This is the first document!',
    'the students are late today...'
]


print("----- Corpus ----- ")
print(corpus)

# Premier vectorizer (en mots)
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(corpus)
print("\n------------------ ")
print("Représentation \"en mots\" : \n")

print(X.toarray())
print("------------------ \n")

# Second vectorizer (en bigrammes)
vectorizer2 = CountVectorizer(analyzer='char', ngram_range=(2, 2))
X2 = vectorizer2.fit_transform(corpus)

print("----------------- ")
print("Représentation \"en 2-grams\" :\n")

print(X2.toarray())
print("----------------- \n")

On peut ajuster le nombre de *features* ou dimensions données à nos matrices

### Classifieur

`GaussianNB` ([source](https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html))

Nourri avec : la réprésentation matricielle des corpus + l'output désiré !