Intelligence artificielle

John Samuel
CPE Lyon

Year: 2023-2024
Email: john(dot)samuel(at)cpe(dot)fr

Intelligence artificielle

Le traitement automatique des langues (TAL) est un domaine interdisciplinaire de la linguistique informatique qui se concentre sur l'analyse et la compréhension du langage naturel (celui utilisé par les humains). Cette section aborde plusieurs aspects clés du TAL, notamment :

• Analyser et comprendre le langage naturel (humain): Le TAL se consacre à la compréhension du langage naturel dans divers contextes, qu'il s'agisse de textes écrits ou de discours verbal.
• Interaction homme-machine
• Syntaxe d'une langue
  • Parsing : Le parsing consiste à analyser la structure grammaticale des phrases.
  • L'étiquetage en parties du discours (PoS) : L'étiquetage PoS consiste à assigner des catégories grammaticales (comme verbe, nom, adjectif, etc.) aux mots d'une phrase.
• Sémantique d'une langue
  • Traduction automatique
  • Reconnaissance d'entités nommées (NER): La NER consiste à identifier des entités spécifiques (comme des noms de personnes, de lieux ou d'organisations) dans un texte.
  • Analyse des sentiments

Analyse de systèmes TAL

• Racinisation : La racinisation est le processus de réduction des mots à leur forme de base ou de racine.
• Étiquetage morpho-syntaxique : Cette étape consiste à attribuer des balises ou des étiquettes aux mots dans un texte en fonction de leur rôle grammatical et de leur structure.
• Lemmatisation : Contrairement à la racinisation, la lemmatisation consiste à ramener les mots à leur forme canonique ou lemmes.
• Morphologie : La morphologie concerne l'étude de la structure des mots, notamment comment ils sont formés à partir de morphèmes (unités de sens).

Racinisation [Frakes 2003]

• La racination, souvent appelée stemming en anglais, est un processus de normalisation linguistique visant à réduire les mots à leur forme racine, en ignorant les affixes. Elle est utilisée pour simplifier les variations morphologiques des mots.
• Les algorithmes de racination appliquent généralement des règles heuristiques pour éliminer les préfixes et suffixes courants.
  • Exemples : Porter, Snowball
  • Limitations : La racination peut conduire à des résultats non valides, car elle peut produire des racines qui ne sont pas des mots réels.
• Exemples
  • engineer: engineer, engineered, engineering

Racinisation

Quelques exemples d'issues potentiellement non valides :

• Racination excessive :
  • Mot d'origine : "happily"
  • Racination : "happi" (au lieu de la forme correcte "happy")
• Racination incorrecte :
  • Mot d'origine : "better"
  • Racination : "bet" (au lieu de la forme correcte "better")
• Création de faux mots :
  • Mot d'origine : "unhappiness"
  • Racination : "unhappi" (crée un faux mot au lieu de "unhappy")

Racinisation

• Ambiguïté des règles :
  • Mot d'origine : "flies" (verbe)
  • Racination : "fli" (peut être confondu avec le nom "fly")

Racinisation: mesures d'évaluation [Frakes 2003]

• La mesure dans laquelle un algorithm modifie des mots qu'elle réduit à ses racines est appelée la force de l'algorithme
• Une métrique de similarité des algorithmes met en correspondance les n-tuples d'algorithmes (n au moins 2), avec un nombre indiquant la similarité des algorithmes.

Racinisation: distance de Hamming [Frakes 2003]

1. La distance de Hamming entre deux chaînes de longueur égale est définie comme le nombre de caractères des deux chaînes qui sont différents à la même position.
2. Pour les chaînes de longueur inégale, ajouter la différence de longueur à la distance de Hamming pour obtenir une fonction de distance de Hamming modifiée \(d\)
3. Exemples
   • tri: try, tried, trying
   • \(d\)(tri, try)= 1
   • \(d\)(tri, tried)= 2
   • \(d\)(tri, trying)= 4

Racinisation: force [Frakes 2003]

1. Le nombre moyen de mots par classe
2. Facteur de compression de l'indice. Soit n est le nombre de mots dans le corpus et s est le nombre de racines. \[\frac{n - s}{n}\]
3. Le nombre de mots et de racines qui diffèrent
4. Le nombre moyen de caractères supprimés lors de la formation des racines
5. La médiane et la moyenne de la distance de Hamming modifiée entre les mots et leur racine

Racinisation: similarité [Frakes 2003]

1. Soit \(A1\) et \(A2\) sont deux algorithmes
2. Soit \(W\) une liste de mots et \(n\) le nombre de mots dans \(W\) \[ M(A1,A2,W) = \frac{n}{\Sigma d(x_i, y_i)}\]
3. pour tous les mots \(w_i\) en W, \(x_i\) est le résultat de l'application de \(A1\) à \(w_i\) et \(y_i\) est le résultat de l'application de \(A2\) à \(w_i\)
4. des algorithmes plus similaires auront des valeurs plus élevées de M

Racinisation: nltk

L'objectif est de réduire les mots à leur forme de base ou racine, en éliminant les suffixes, ce qui permet de regrouper différentes formes d'un mot sous une forme commune.

• Porter [Porter 1980] : Le Porter Stemming Algorithm, créé par Martin Porter en 1980, est basé sur un ensemble de règles heuristiques. Il suit une approche itérative en appliquant une série de transformations séquentielles aux mots.
• Snowball Le Snowball (anciennement appelé Porter2) est une amélioration du Porter Stemmer. Il suit également une approche basée sur des règles, mais il est plus systématique dans son traitement des différents cas de racination.

Porter

L'algorithme de Porter, également connu sous le nom de stemmer de Porter, est un algorithme de racination (stemming) développé par Martin Porter en 1980. Son objectif est de réduire les mots à leur forme racine ou base en éliminant les suffixes couramment utilisés en anglais.

• Prétraitement : Convertir le mot en minuscules. Identifier le préfixe 'y' et le traiter comme une voyelle s'il est en première position, sinon comme une consonne.
• Application des règles de racination : L'algorithme de Porter utilise une série de règles pour éliminer les suffixes. Ces règles sont appliquées séquentiellement jusqu'à ce qu'aucune d'entre elles ne s'applique plus. Les règles comprennent des opérations comme la suppression de suffixes spécifiques, la transformation de certains suffixes en d'autres, et la manipulation de la longueur des mots.
• Post-traitement : Certains ajustements post-traitement sont effectués pour améliorer la précision de la racination.

Porter

L'algorithme de Porter utilise une série de règles de racination pour réduire les mots à leur forme racine. Quelques-unes des règles de l'algorithme de Porter :

1. Règles de suppression de suffixes :
   • "s" : Supprimer le suffixe "s" à la fin des mots.
   • "sses" : Remplacer par "ss" si la séquence se termine par "sses".
2. Règles de traitement de suffixes spécifiques :
   • "eed" ou "eedly" : Remplacer par "ee" si la séquence se termine par "eed" ou "eedly".
   • "ed" : Supprimer "ed" à la fin du mot s'il y a une voyelle précédente.
   • "ing" : Supprimer "ing" à la fin du mot s'il y a une voyelle précédente.

Porter

3. Règles de transformation de suffixes en d'autres suffixes :
   • "at" : Remplacer par "ate" si la séquence se termine par "at".
   • "bl" : Ajouter "e" à la fin si la séquence se termine par "bl".
4. Règles de manipulation de la longueur des mots :
   • Si la séquence se termine par une consonne suivie de "y", remplacer par "i" à la fin.
   • Si la séquence se termine par deux consonnes, supprimer la dernière consonne si la précédente est une voyelle.
5. Règles de manipulation des doubles consonnes :
   • Supprimer une lettre double à la fin du mot.

Racinisation: Porter

from nltk.stem.porter import PorterStemmer

words = ["words", "eating", "went", "engineer", "tried"]
porter = PorterStemmer()
for word in words:
    print(porter.stem(word), end=" ")

Affichage

word eat went engin tri


Snowball

L'algorithme de Snowball, également connu sous le nom de Snowball stemmer, est un algorithme de racination (stemming) développé par Martin Porter comme une extension de son algorithme de Porter. Snowball a été conçu pour être plus modulaire et extensible, permettant aux utilisateurs de créer des stemmers pour différentes langues en utilisant un ensemble commun de conventions.

Les caractéristiques principales de l'algorithme de Snowball :

• Modularité : L'algorithme de Snowball est conçu de manière modulaire, permettant la définition de règles spécifiques pour chaque langue. Chaque règle est encapsulée dans une unité appelée "step."
• Structure du Langage : L'algorithme de Snowball est souvent utilisé pour différentes langues, et la structure du langage est définie par des fichiers de règles spécifiques à chaque langue. Ces fichiers décrivent comment les suffixes et préfixes doivent être traités.

Snowball

• Extensibilité : Les utilisateurs peuvent étendre l'algorithme de Snowball pour traiter des langues spécifiques en ajoutant des règles appropriées dans un fichier dédié à cette langue.
• Étape de Règle : Chaque étape (step) de l'algorithme de Snowball est constituée de règles qui décrivent comment transformer un mot. Chaque règle a une forme similaire à "condition -> action," où la condition spécifie quand appliquer la règle, et l'action définit la transformation à effectuer.
• Itération : L'algorithme de Snowball applique les étapes de règle itérativement jusqu'à ce qu'aucune d'entre elles ne puisse être appliquée. Cette itération permet de réduire progressivement les mots à leur forme racine.

Racinisation: Snowball

from nltk.stem.snowball import SnowballStemmer

words = ["words", "eating", "went", "engineer", "tried"]
snowball = SnowballStemmer("english")
for word in words:
    print(snowball.stem(word))

Affichage

word eat went engin tri


Étiquetage morpho-syntaxique [Màrquez 2000]

• L'étiquetage morpho-syntaxique, également appelé Part of Speech (PoS) Tagging, est un processus dans lequel chaque mot d'un texte se voit attribuer une balise morpho-syntaxique appropriée en fonction de son rôle grammatical et de son contexte d'apparition. Ces balises indiquent la catégorie grammaticale à laquelle chaque mot appartient.
• Il permet de capturer la structure grammaticale d'un texte, facilitant ainsi la compréhension et l'analyse linguistique automatisées.
• Les algorithmes d'étiquetage morpho-syntaxique utilisent généralement des modèles statistiques ou des règles linguistiques pour assigner ces balises en fonction du contexte entourant chaque mot.
• Exemples des balises
  • Noms : Indiquent des entités ou objets concrets. Exemple : "chat," "maison," "fleur"
  • Verbes : Indiquent des actions ou des états. Exemple : "marcher," "manger," "être"
  • Adjectifs : Décrivent ou qualifient des noms. Exemple : "beau," "rapide," "intelligent"
  • Adverbes : Modifient des verbes, des adjectifs ou d'autres adverbes, fournissant des informations sur la manière, le lieu, le temps, etc. Exemple : "rapidement," "bien," "ici"

Étiquetage morpho-syntaxique [Màrquez 2000]

Construction de modèles linguistiques

1. Approche manuelle :
   • Construction de règles linguistiques manuelles pour analyser la structure linguistique
   • Exemple : Définir des règles pour identifier les parties du discours en fonction de la syntaxe.
2. Approche statistique :
   • Utilisation de statistiques et de probabilités pour modéliser les relations linguistiques.
   • Collection de n-grammes (bi-grammes, tri-grammes, ...)
   • Ensemble de fréquences de cooccurrence
   • L'estimation de la probabilité d'une séquence de longueur n est calculée en tenant compte de son occurrence dans le corpus d'entraînement
3. Apprentissage machine :
   • Utilisation de techniques d'apprentissage machine pour apprendre automatiquement des modèles linguistiques à partir de données d'entraînement.
   • Les algorithmes peuvent être entraînés à reconnaître des motifs et des structures linguistiques complexes

nltk: ngrams

from nltk import ngrams

sentence = "He went to school yesterday and attended the classes"
for n in range(1, 5):
    print("\n{}-grams".format(n))
    n_grams = ngrams(sentence.split(), n)
    for ngram in n_grams:
        print(ngram, end=" ")

nltk: ngrams (affichage)

1-grams
('He',) ('went',) ('to',) ('school',) ('yesterday',) ('and',) ('attended',) ('the',) ('classes',)
2-grams
('He', 'went') ('went', 'to') ('to', 'school') ('school', 'yesterday') ('yesterday', 'and') ('and', 'attended') ('attended', 'the') ('the', 'classes')
3-grams
('He', 'went', 'to') ('went', 'to', 'school') ('to', 'school', 'yesterday') ('school', 'yesterday', 'and') ('yesterday', 'and', 'attended') ('and', 'attended', 'the') ('attended', 'the', 'classes')
4-grams
('He', 'went', 'to', 'school') ('went', 'to', 'school', 'yesterday') ('to', 'school', 'yesterday', 'and') ('school', 'yesterday', 'and', 'attended') ('yesterday', 'and', 'attended', 'the') ('and', 'attended', 'the', 'classes')


nltk: pos_tag

from nltk import pos_tag, word_tokenize

sentence = "He goes to school daily"

tokens = word_tokenize(sentence)
print(pos_tag(tokens))

Affichage

[('He', 'PRP'), ('goes', 'VBZ'), ('to', 'TO'), ('school', 'NN'), ('daily', 'RB')]

nltk: pos_tag

[('He', 'PRP'), ('goes', 'VBZ'), ('to', 'TO'), ('school', 'NN'), ('daily', 'RB')]

spaCy

Installation

$ pip3 install spacy
$ python3 -m spacy download en_core_web_sm


Usage

import spacy

nlp = spacy.load("en_core_web_sm")

spaCy

import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("He goes to school daily")
for token in doc:
    print(token.text, token.pos_, token.dep_)

He PRON nsubj
goes VERB ROOT
to ADP prep
school NOUN pobj
daily ADV advmod


spaCy: mots vides, forme, PoS, lemme

import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("He goes to school daily")
for token in doc:
    print(token.text, token.lemma_, token.pos_, token.tag_, token.dep_,
            token.shape_, token.is_alpha, token.is_stop)

He -PRON- PRON PRP nsubj Xx True True
goes go VERB VBZ ROOT xxxx True False
to to ADP IN prep xx True True
school school NOUN NN pobj xxxx True False
daily daily ADV RB advmod xxxx True False


Lemmatisation [Gesmundo 2012]

• La lemmatisation, consiste à regrouper les différentes formes d'un mot qui appartiennent au même paradigme morphologique flexionnel et à attribuer à chaque paradigme son lemme correspondant.
• Cette méthode vise à ramener les variations flexionnelles d'un mot à sa forme canonique ou à sa racine.
• La lemmatisation permet de simplifier la représentation des mots en les ramenant à leur forme de base, ce qui facilite la recherche, l'analyse et le traitement automatique du langage naturel.
• Exemples
  • go: go, goes, going, went, gone

Lemmatisation [Chrupała 2006, Gesmundo 2012]

• La lemmatisation comme une tâche d'étiquetage
• Attribuer un label pour chaque transformation d'un label en lemme
• 4 étapes [Gesmundo 2012]
  1. supprimer un suffixe de longueur \(N_s\)
  2. ajouter un nouveau suffixe de lemme \(L_s\)
  3. supprimer un préfixe de longueur \(N_p\)
  4. ajouter un nouveau préfixe lemme, \(L_p\)
• Transformation \(\tau = \langle N_s, L_s, N_p, L_p \rangle\)
• (going, go) = \(\langle 3, \emptyset, 0, \emptyset \rangle \)

nltk: WordNetLemmatizer

• WordNet [Miller 1995] : WordNet est une base de données lexicale de la langue anglaise qui organise les mots en synsets (ensembles de synonymes) et les relie entre eux par des relations lexicales telles que l'hypernymie (relation "est-un") et l'hyponymie (relation "a pour instance").
• WordNetLemmatizer : Le module WordNetLemmatizer dans NLTK utilise WordNet pour la lemmatisation des mots. Il attribue à chaque mot sa forme canonique ou lemme, en tenant compte des différentes formes flexionnelles.

import nltk
nltk.download('punkt')
nltk.download('wordnet')
nltk.download('averaged_perceptron_tagger')

nltk: WordNetLemmatizer (sans les balises PoS)

from nltk.stem import WordNetLemmatizer

sentence = "He went to school yesterday and attended the classes"
lemmatizer = WordNetLemmatizer()

for word in sentence.split():
    print(lemmatizer.lemmatize(word), end=' ')

Affichage

He went to school yesterday and attended the class

nltk: WordNetLemmatizer (avec les balises PoS)

from nltk.stem import WordNetLemmatizer
from nltk import word_tokenize, pos_tag
from nltk.corpus import wordnet as wn

# Check the complete list of tags http://www.nltk.org/book/ch05.html
def wntag(tag):
    if tag.startswith("J"):
        return wn.ADJ
    elif tag.startswith("R"):
        return wn.ADV
    elif tag.startswith("N"):
        return wn.NOUN
    elif tag.startswith("V"):
        return wn.VERB
    return None

nltk: WordNetLemmatizer (avec les balises PoS)

lemmatizer = WordNetLemmatizer()
sentence = "I went to school today and he goes daily"

tokens = word_tokenize(sentence)
for token, tag in pos_tag(tokens):
    if wntag(tag):
        print(lemmatizer.lemmatize(token, wntag(tag)), end=' ')
    else:
        print(lemmatizer.lemmatize(token), end=' ')

Affichage

I go to school today and he go daily

spaCy: mots vides, forme, PoS, lemme

import spacy

nlp = spacy.load("en_core_web_sm")
doc = nlp("I went to school today and he goes daily")

for token in doc:
    print(token.lemma_, end=' ')

-PRON- go to school today and -PRON- go daily


Morphologie

• La morphologie lexicale est une branche de la linguistique qui se concentre sur l'étude des mots, de leurs formes, de leurs paradigmes et de l'organisation des catégories grammaticales.
• Elle examine de près les parties du discours, l'intonation, l'accentuation, ainsi que la manière dont le contexte peut influencer la prononciation et le sens d'un mot.
• Elle explore la structure interne des mots et comment ils interagissent avec la grammaire et le contexte pour communiquer des significations spécifiques.

spaCy: mots vides, forme, PoS, lemme

import spacy
from spacy import displacy

nlp = spacy.load("en_core_web_sm")
doc = nlp("He goes to school daily")

displacy.render(doc, style="dep", jupyter=True)

Word Embeddings (Incorporation de mots)

Les embeddings de mots sont une technique d'apprentissage de caractéristiques où des mots ou des phrases du vocabulaire sont associés à des vecteurs de nombres réels.

• L'idée principale est de représenter chaque mot par un vecteur dense dans un espace continu, de telle sorte que des mots similaires aient des vecteurs similaires, capturant ainsi les relations sémantiques entre les mots.
• Quantifier et catégoriser les similarités sémantiques entre les éléments linguistiques en fonction de leurs propriétés de distribution dans de grands échantillons de données linguistiques.
• En d'autres termes, les mots qui ont des contextes similaires ou qui apparaissent dans des contextes similaires auront des embeddings de mots similaires.

Word Embeddings (Incorporation de mots)

Avantages de Word Embeddings

• Représentation dense : Les embeddings fournissent une représentation dense, contrairement à une représentation creuse où chaque mot serait représenté par un vecteur binaire indiquant sa présence ou son absence.
• Capture des relations sémantiques : Les embeddings captent les relations sémantiques et les similitudes entre les mots, ce qui les rend utiles dans de nombreuses tâches de traitement du langage naturel.

Word Embeddings (Incorporation de mots)

Applications de Word Embeddings

• Similarité sémantique : Mesurer la similarité sémantique entre les mots.
• Traduction automatique : Améliorer les performances des systèmes de traduction automatique.
• Analyse des sentiments : Mieux comprendre le contexte et les relations sémantiques dans l'analyse des sentiments, entre autres applications.

spaCy

spaCy est une bibliothèque open-source pour le traitement du langage naturel (NLP) en Python. Elle offre des outils performants et efficaces pour effectuer diverses tâches de traitement du langage naturel, de l'analyse syntaxique à la reconnaissance d'entités nommées. spaCy est conçu pour être rapide, précis et facile à utiliser.

• Collecte de données : Les modèles spaCy sont souvent entraînés sur de vastes ensembles de données annotées, qui peuvent inclure des corpus textuels avec des annotations pour l'analyse syntaxique, la reconnaissance d'entités nommées, etc.
• Annotation des données : Les données collectées sont annotées manuellement avec des informations linguistiques spécifiques telles que les parties du discours, les entités nommées, les relations syntaxiques, etc.
• Entraînement initial : Les modèles spaCy sont initialement entraînés sur ces ensembles de données annotées pour apprendre les structures linguistiques. Ce processus peut inclure l'utilisation d'algorithmes d'apprentissage automatique tels que les réseaux de neurones.
• Optimisation et réglage : Les modèles sont ensuite optimisés et réglés pour améliorer leurs performances sur des tâches spécifiques. Cela peut impliquer des itérations sur le processus d'entraînement en ajustant les hyperparamètres du modèle.

spaCy

• Évaluation : Les modèles sont évalués sur des ensembles de données de test distincts pour mesurer leur précision, leur rappel et d'autres métriques spécifiques à la tâche.
• Construction des modèles linguistiques pré-entraînés : Une fois le modèle entraîné et évalué, spaCy construit des modèles linguistiques pré-entraînés qui encapsulent les connaissances acquises sur la structure linguistique.
• Téléchargement et utilisation : Les utilisateurs peuvent télécharger ces modèles pré-entraînés via spaCy et les utiliser dans leurs applications pour effectuer diverses tâches de traitement du langage naturel sans avoir à entraîner un modèle de zéro.

spaCy

spaCy propose différents modèles linguistiques pré-entraînés pour différentes langues et tâches. Le modèle en_core_web_lg est un modèle vectoriel large d'anglais.

Installation du Modèle spaCy (en_core_web_lg) :

$ python3 -m spacy download en_core_web_lg


Chargement du Modèle spaCy :

import spacy

# Charger le modèle spaCy
nlp = spacy.load("en_core_web_lg")

spaCy

Avantages de spaCy :

• Performance élevée : spaCy est reconnu pour sa rapidité d'exécution, ce qui le rend adapté au traitement de grands volumes de texte en temps réel.
• Modèles pré-entraînés : spaCy propose des modèles linguistiques pré-entraînés pour plusieurs langues, ce qui facilite l'analyse de texte sans nécessiter d'entraînement à partir de zéro.
• Extraction d'informations linguistiques riches : spaCy fournit des informations linguistiques détaillées telles que les parties du discours, les entités nommées, les relations syntaxiques, et plus encore.
• API conviviale : L'API spaCy est conçue pour être intuitive et conviviale. Elle facilite la réalisation de tâches complexes avec des lignes de code concises.
• Intégration avec d'autres bibliothèques : spaCy s'intègre bien avec d'autres bibliothèques Python populaires, facilitant son utilisation dans des projets plus larges.

spaCy

Limites de spaCy :

• Dépendance des modèles linguistiques : L'utilisation de modèles pré-entraînés signifie que la qualité des résultats dépend de la qualité du modèle. Dans des domaines de spécialité ou pour des langues moins courantes, les modèles peuvent ne pas être aussi performants.
• Gestion des entités nommées : Bien que spaCy excelle dans la reconnaissance d'entités nommées, il peut parfois avoir du mal avec des tâches plus complexes impliquant des variations contextuelles.
• Taille des modèles : Les modèles pré-entraînés peuvent être relativement volumineux, ce qui peut être un inconvénient dans des environnements avec des restrictions de mémoire ou pour des applications mobiles.
• Personnalisation limitée : Bien que spaCy offre des fonctionnalités de personnalisation, elles peuvent être limitées par rapport à d'autres bibliothèques NLP plus flexibles.

spaCy: similarity

import spacy

# Charger le modèle spaCy
nlp = spacy.load("en_core_web_lg")

# Définir les mots à comparer
words_to_compare = ["dog", "cat", "apple"]

# Calculer la similarité entre les paires de mots
for i in range(len(words_to_compare)):
    for j in range(i + 1, len(words_to_compare)):
        word1, word2 = words_to_compare[i], words_to_compare[j]
        doc1, doc2 = nlp(word1), nlp(word2)
        similarity_score = doc1.similarity(doc2)
        print("Similarité ({} / {}): {:.4f}".format(word1, word2, similarity_score))

spaCy: similarity

Affichage

Similarité (dog / cat): ...
Similarité (dog / apple): ...
Similarité (cat / apple): ...
                

spaCy: vector

import spacy

# Charger le modèle spaCy
nlp = spacy.load("en_core_web_sm")

# Texte à analyser
text_to_analyze = "cat"
doc = nlp(text_to_analyze)

# Imprimer les vecteurs de chaque jeton sur une seule ligne
vector_list = [token.vector for token in doc]
print("Vecteurs de '{}' : {}".format(text_to_analyze, vector_list))

Word2Vec [Mikolov 2013]

Word2Vec a marqué un tournant significatif dans la représentation des mots dans le domaine de l'apprentissage automatique.

• C'est une technique publiée en 2013 par une équipe de chercheurs dirigée par Tomas Mikolov chez Google.
• Représentation vectorielle : Word2Vec représente chaque mot distinct avec un vecteur dans un espace continu. Ces vecteurs captent les relations sémantiques et syntaxiques entre les mots.
• Apprentissage basé sur un réseau neuronal : Le modèle utilise un réseau neuronal pour apprendre des associations de mots à partir d'un vaste corpus de texte. Cette approche permet de capturer des nuances complexes dans la signification des mots.
• Entrée et sortie : Word2Vec prend en entrée un large corpus de texte et produit un espace vectoriel, généralement de plusieurs centaines de dimensions. Cette représentation vectorielle permet de mesurer la similarité sémantique entre les mots.

Word2Vec [Mikolov 2013]

L'implémentation de Word2Vec se déroule en plusieurs étapes :

1. Prétraitement des données : Le texte est nettoyé et prétraité pour éliminer les éléments indésirables tels que la ponctuation et les stopwords.
2. Création d'un vocabulaire : Les mots uniques du corpus sont utilisés pour construire un vocabulaire. Chaque mot est ensuite associé à un index.
3. Génération de paires mot-contexte : Pour chaque mot du corpus, des paires mot-contexte sont créées en utilisant une fenêtre contextuelle glissante. Ces paires servent d'exemples d'entraînement.
4. Construction du modèle Word2Vec : Un modèle de réseau neuronal est créé, avec une couche d'entrée représentant les mots, une couche cachée (skip-gram ou CBOW), et une couche de sortie pour prédire le mot suivant dans le contexte.
5. Entraînement du modèle : Le modèle est entraîné sur les paires mot-contexte générées, ajustant les poids du réseau pour minimiser la différence entre les prédictions et les vrais mots du contexte.
6. Obtention des embeddings : Les vecteurs de mots appris pendant l'entraînement, appelés embeddings, sont extraits. Chaque mot du vocabulaire est maintenant représenté par un vecteur dense dans l'espace continu.

Word2Vec

• les vecteurs de mots sont positionnés dans l'espace vectoriel de telle sorte que les mots qui partagent des contextes communs dans le corpus soient situés à proximité les uns des autres dans l'espace
• une simple fonction mathématique (par exemple, la similarité cosinus entre les vecteurs) indique le niveau de similarité sémantique entre les mots représentés par ces vecteurs \[\text{similarity} = \cos(\theta) = {\mathbf{A} \cdot \mathbf{B} \over \|\mathbf{A}\| \|\mathbf{B}\|} = \frac{ \sum\limits_{i=1}^{n}{A_i B_i} }{ \sqrt{\sum\limits_{i=1}^{n}{A_i^2}} \sqrt{\sum\limits_{i=1}^{n}{B_i^2}} },\]
• les vecteurs de mots sont positionnés dans l'espace vectoriel de telle sorte que les mots qui partagent des contextes communs dans le corpus soient situés à proximité les uns des autres dans l'espace

Context Bag of Words (CBOW)

CBOW est un modèle spécifique de Word2Vec. Dans ce modèle, la prédiction du mot courant se fait en utilisant une fenêtre de mots contextuels voisins. L'ordre des mots de contexte n'influence pas la prédiction, ce qui en fait une approche robuste.

• Modèle prédictif : CBOW prédit le mot cible en se basant sur le contexte qui l'entoure, mais contrairement à d'autres modèles, l'ordre spécifique des mots dans ce contexte n'est pas pris en compte.

Context Bag of Words (CBOW)

• Entrée : La donnée d'entrée du modèle CBOW est une fenêtre de mots contextuels entourant le mot cible. Cette fenêtre est définie par un paramètre appelé la taille de la fenêtre.
• Architecture : CBOW utilise une architecture de réseau neuronal à une seule couche cachée. La couche d'entrée représente les mots du contexte, et la couche de sortie représente le mot cible à prédire.
• Entraînement : Le modèle est entraîné en ajustant les poids du réseau pour minimiser la différence entre les prédictions du modèle et le mot cible réel. Cela se fait à travers des techniques d'optimisation comme la rétropropagation du gradient.
• Sortie : Une fois le modèle entraîné, les poids de la couche d'entrée sont utilisés comme embeddings de mots. Ces embeddings capturent les relations sémantiques entre les mots, permettant ainsi de représenter chaque mot par un vecteur dans un espace continu.
• Avantages : CBOW est souvent plus rapide à entraîner que d'autres modèles comme le Skip-gram (une autre variante de Word2Vec) et peut être plus efficace dans des contextes où l'ordre séquentiel des mots n'est pas critique.

gensim: cbow

import gensim
from nltk.tokenize import sent_tokenize, word_tokenize

# Données d'exemple
data = "This is a class. This is a table"

# Prétraitement des données en utilisant nltk pour obtenir des phrases et des mots
sentences = [word_tokenize(sentence.lower()) for sentence in sent_tokenize(data)]

# Construction du modèle CBOW avec Gensim
# min_count: Ignorer tous les mots dont la fréquence totale est inférieure à cette valeur.
# vector_size: Dimension des embeddings de mots
# window: Distance maximale entre le mot courant et le mot prédit dans une phrase
cbow_model = gensim.models.Word2Vec(sentences, min_count=1, vector_size=100, window=3, sg=0)
	

gensim: cbow

# Affichage du vecteur du mot "this"
print("Vecteur du mot 'this':", cbow_model.wv["this"])

# Similarité entre les mots "this" et "class"
print("Similarité entre 'this' et 'class':", cbow_model.wv.similarity("this", "class"))

# Prédiction des deux mots les plus probables suivant le mot "is"
predicted_words = cbow_model.wv.most_similar(positive=["is"], topn=2)
print("Prédiction des mots suivant 'is':", predicted_words)
	

Skip grams

Le modèle Skip-gram est une autre variante de Word2Vec qui se concentre sur la prédiction de la fenêtre voisine des mots de contexte à partir du mot courant.

• Objectif : L'objectif principal du modèle Skip-gram est de prendre un mot source (le mot courant) et de prédire les mots qui l'entourent dans une fenêtre de contexte donnée.
• Entrée : Le mot source est utilisé comme donnée d'entrée du modèle, et la sortie souhaitée est la distribution des probabilités des mots du contexte.

Skip grams

• Architecture : Skip-gram utilise une architecture de réseau neuronal à une seule couche cachée. La couche d'entrée représente le mot source, et la couche de sortie représente les mots du contexte.
• Entraînement : Pendant l'entraînement, les poids du réseau sont ajustés pour minimiser la différence entre les prédictions du modèle et la véritable distribution des mots du contexte. Cela se fait généralement à l'aide de techniques d'optimisation comme la rétropropagation du gradient.
• Pondération du contexte : Une caractéristique importante du modèle Skip-gram est que l'architecture accorde plus de poids aux mots de contexte proches du mot source que ceux plus éloignés. Cela permet de mieux capturer les relations sémantiques et syntaxiques locales.
• Embeddings : Une fois le modèle entraîné, les poids de la couche d'entrée sont utilisés comme embeddings de mots. Ces embeddings capturent les similitudes sémantiques entre les mots, permettant de représenter chaque mot par un vecteur dans un espace continu.

gensim: skip-gram

import gensim
from nltk.tokenize import sent_tokenize, word_tokenize

# Données d'exemple
data = "This is a class. This is a table"

# Prétraitement des données en utilisant nltk pour obtenir des phrases et des mots
sentences = [word_tokenize(sentence.lower()) for sentence in sent_tokenize(data)]

# Construction du modèle Skip-gram avec Gensim
# min_count: Ignorer tous les mots dont la fréquence totale est inférieure à cette valeur.
# vector_size: Dimension des embeddings de mots
# window: Distance maximale entre le mot courant et le mot prédit dans une phrase
# sg: 1 pour skip-gram ; sinon CBOW.
skipgram_model = gensim.models.Word2Vec(sentences, min_count=1, vector_size=100, window=5, sg=1)

gensim: skip-gram

# Affichage du vecteur du mot "this"
print("Vecteur du mot 'this':", skipgram_model.wv["this"])

# Similarité entre les mots "this" et "class"
print("Similarité entre 'this' et 'class':", skipgram_model.wv.similarity("this", "class"))

# Prédiction des mots les plus probables dans le contexte entourant le mot "is"
predicted_words = skipgram_model.wv.most_similar(positive=["is"], topn=2)
print("Prédiction des mots dans le contexte de 'is':", predicted_words)

Reconnaissance d'entités nommées

La Reconnaissance d'Entités Nommées (NER) consiste à identifier et classer des entités spécifiques dans un texte. Ces entités peuvent inclure des personnes, des lieux, des organisations, des dates, des montants monétaires, etc. Le but est d'extraire des informations structurées à partir de données textuelles non structurées.

Reconnaissance d'entités nommées

• Identification d'entités : La première étape de la NER consiste à identifier les mots ou groupes de mots qui représentent des entités dans le texte. Ces entités peuvent être des noms de personnes, des noms de lieux, des noms d'organisations, etc.
• Classification des entités : Une fois les entités identifiées, elles sont classifiées dans des catégories spécifiques. Par exemple, une entité peut être classée comme "PERSON" si elle représente une personne, "LOCATION" si elle représente un lieu, "ORGANIZATION" si elle représente une organisation, et ainsi de suite.
• Contextualisation : La NER tient compte du contexte dans lequel une entité apparaît. Par exemple, le mot "banc" peut être classé comme une entité financière dans le contexte d'une discussion sur l'économie, mais comme une entité physique dans le contexte d'un parc.
• Relations entre entités : Dans certains cas, la NER peut également inclure la détection des relations entre différentes entités dans le texte. Par exemple, la relation entre une personne et l'organisation qu'elle travaille.
• Applications pratiques : Les résultats de la NER peuvent être utilisés dans diverses applications, telles que l'amélioration de la recherche d'informations, l'extraction de relations, la catégorisation de documents, la création de résumés automatiques, etc.

Reconnaissance d'entités nommées : Algorithmes

La Reconnaissance d'Entités Nommées (NER) est souvent réalisée à l'aide de modèles d'apprentissage automatique, et plusieurs algorithmes peuvent être utilisés dans ce contexte. Quelques-uns des algorithmes couramment employés :

• Modèles de markov cachés (HMM - Hidden Markov Models) : Les HMM ont été utilisés pour la NER, où l'idée est de modéliser la séquence des étiquettes d'entités en tant que séquence cachée derrière la séquence observable de mots.
• Réseaux de neurones : Les architectures de réseaux de neurones, y compris les réseaux de neurones récurrents (RNN), les réseaux de neurones récurrents bidirectionnels (BiRNN), et les réseaux de neurones récurrents à mémoire à court terme (LSTM), ont montré des performances significatives dans la NER.
• Transformers : Les modèles basés sur les transformers, tels que BERT (Bidirectional Encoder Representations from Transformers) et ses variantes, ont considérablement amélioré les performances en NER. Ces modèles sont pré-entraînés sur de grandes quantités de données textuelles et captent des représentations contextuelles riches.

Reconnaissance d'entités nommées : Algorithmes

• Modèles statistiques traditionnels : Des approches statistiques plus traditionnelles, comme les modèles de séquence et les classificateurs basés sur des caractéristiques, ont également été utilisées dans des scénarios où des quantités limitées de données annotées sont disponibles.
• Règles et expressions régulières : Dans certains cas, des règles manuelles ou des expressions régulières peuvent être utilisées pour extraire des entités spécifiques, surtout lorsque des motifs clairs et récurrents peuvent être définis.
• Entraînement supervisé : Les méthodes d'entraînement supervisé consistent à annoter manuellement un ensemble de données avec des entités nommées, puis à entraîner un modèle sur ces données annotées.

spaCy: Reconnaissance d'entités nommées

import spacy

# Charger le modèle spaCy
nlp = spacy.load("en_core_web_sm")

# Texte à analyser
text_to_analyze = "Paris is the capital of France. In 2015, its population was recorded as 2,206,488"

# Analyser le texte
doc = nlp(text_to_analyze)

spaCy: Reconnaissance d'entités nommées

# Afficher les informations sur les entités
for entity in doc.ents:
    entity_text = entity.text
    start_char = entity.start_char
    end_char = entity.end_char
    label = entity.label_

    print("Entité: {}, Début: {}, Fin: {}, Catégorie: {}".format(entity_text,
                  start_char, end_char, label))

spaCy: Reconnaissance d'entités nommées

Entité: Paris, Début: 0, Fin: 5, Catégorie: GPE
Entité: France, Début: 24, Fin: 30, Catégorie: GPE
Entité: 2015, Début: 35, Fin: 39, Catégorie: DATE
Entité: 2,206,488, Début: 72, Fin: 81, Catégorie: CARDINAL
                         

spaCy: Reconnaissance d'entités nommées

import spacy
from spacy import displacy

def visualize_entities(text):
    # Charger le modèle spaCy
    nlp = spacy.load("en_core_web_sm")
    # Analyser le texte
    doc = nlp(text)
    # Visualiser les entités nommées avec displaCy
    displacy.serve(doc, style="ent")

# Texte à analyser et visualiser
text_to_analyze = "Paris is the capital of France. In 2015, its population was recorded as 2,206,488"

# Appeler la fonction pour analyser et visualiser les entités
visualize_entities(text_to_analyze)

spaCy: Reconnaissance d'entités nommées

import spacy
from spacy import displacy

def visualize_entities(text):
    # Charger le modèle spaCy
    nlp = spacy.load("en_core_web_sm")
    # Analyser le texte
    doc = nlp(text)
    # Visualiser les entités nommées avec displaCy
    displacy.render(doc, style="ent", jupyter=True)

# Texte à analyser et visualiser
text_to_analyze = "Paris is the capital of France. In 2015, its population was recorded as 2,206,488"

# Appeler la fonction pour analyser et visualiser les entités
visualize_entities(text_to_analyze)

spaCy: Reconnaissance d'entités nommées

Le lexique VADER (Valence Aware Dictionary and sEntiment Reasoner) est spécifiquement conçu pour analyser les sentiments dans du texte en attribuant des scores de positivité, négativité et neutralité aux mots ainsi qu'aux expressions.

Installation

import nltk
nltk.download('vader_lexicon')

VADER

VADER est une bibliothèque d'analyse de sentiment conçue pour évaluer le sentiment d'un morceau de texte, généralement une phrase ou un paragraphe.

• Dictionnaire et Scores : VADER utilise un dictionnaire pré-annoté avec des scores de positivité, négativité et neutralité pour des milliers de mots et expressions. Chaque mot est associé à un score qui indique dans quelle mesure il est perçu comme positif ou négatif.
• Polarité des Mots : Pour chaque mot dans le texte, VADER examine son score dans le dictionnaire. Certains mots ont des scores forts, indiquant une polarité positive ou négative, tandis que d'autres ont des scores plus neutres.
• Modificateurs et Emphase : VADER prend en compte les modificateurs, tels que les adverbes, qui peuvent influencer la polarité d'un mot. Il reconnaît également l'emphase en attribuant des poids différents aux mots en majuscules.

VADER

• Calcul du Score Composé : VADER agrège les scores des mots en utilisant une formule qui prend en compte la distribution des polarités dans le texte. Le score composé résultant est une mesure globale du sentiment de la phrase.
• Résultats : Le résultat final de l'analyse est un ensemble de scores qui indiquent la positivité, la négativité, la neutralité et un score composé global. Ces scores sont normalisés dans une échelle de -1 à 1, où -1 représente un sentiment extrêmement négatif, 1 représente un sentiment extrêmement positif, et 0 représente la neutralité.

VADER est souvent utilisé pour l'analyse de sentiment rapide et basée sur des règles. Bien qu'il soit efficace dans de nombreux cas, il peut ne pas être aussi précis que des méthodes plus complexes basées sur l'apprentissage automatique, notamment dans des contextes où l'analyse nécessite une compréhension plus profonde du langage et de la syntaxe.

VADER: Usage

from nltk.sentiment.vader import SentimentIntensityAnalyzer
sia = SentimentIntensityAnalyzer()

sentiment = sia.polarity_scores("this movie is good")
print(sentiment)

sentiment = sia.polarity_scores("this movie is not very good")
print(sentiment)

sentiment = sia.polarity_scores("this movie is bad")
print(sentiment)

Les scores renvoyés par VADER représentent différentes mesures du sentiment dans un texte. Une explication de chaque score :

• Positivité (Positive Score) : Ce score mesure la positivité relative du texte. Il indique dans quelle mesure le texte contient des éléments positifs. Plus le score est élevé, plus le texte est perçu comme positif.
• Négativité (Negative Score) : - Ce score mesure la négativité relative du texte. Il indique dans quelle mesure le texte contient des éléments négatifs. Plus le score est élevé, plus le texte est perçu comme négatif.
• Neutralité (Neutral Score) : Ce score mesure la neutralité relative du texte. Il indique dans quelle mesure le texte est neutre, c'est-à-dire dépourvu d'éléments fortement positifs ou négatifs. Plus le score est élevé, plus le texte est perçu comme neutre.
• Score Composé (Compound Score) : Le score composé est une mesure agrégée du sentiment qui prend en compte à la fois la positivité et la négativité du texte. Il combine les scores positif, négatif et neutre en une seule valeur. Le score composé est souvent utilisé pour évaluer le sentiment global du texte. Un score composé élevé indique un sentiment fort, qu'il soit positif ou négatif, tandis qu'un score proche de zéro indique un texte neutre.

Les scores sont normalisés dans une échelle de -1 à 1, où -1 représente un sentiment extrêmement négatif, 1 représente un sentiment extrêmement positif, et 0 représente la neutralité. Les scores peuvent être interprétés individuellement ou conjointement pour obtenir une compréhension complète du sentiment dans le texte analysé.

Affichage

{'neg': 0.0, 'neu': 0.508, 'pos': 0.492, 'compound': 0.4404}
{'neg': 0.344, 'neu': 0.656, 'pos': 0.0, 'compound': -0.3865}
{'neg': 0.538, 'neu': 0.462, 'pos': 0.0, 'compound': -0.5423}


Traduction automatique

La traduction automatique est le processus d'utilisation de logiciels pour traduire un texte ou un discours d'une langue à une autre. Il existe plusieurs approches pour aborder ce problème complexe :

• Approche manuelle (règles) : Cette approche repose sur des règles linguistiques définies manuellement par des linguistes ou des experts en langues. Les règles peuvent inclure des correspondances mot à mot, des règles de grammaire, et d'autres connaissances linguistiques spécifiques.
• Approche statistique : Dans cette approche, les modèles statistiques sont utilisés pour apprendre les relations entre les phrases dans différentes langues à partir de grands ensembles de données parallèles. Ces modèles peuvent être basés sur des probabilités conditionnelles et des méthodes statistiques avancées.

Traduction automatique

• Approche hybride (règles et statistique) : L'approche hybride combine des éléments des approches manuelles et statistiques. Elle peut utiliser des règles pour des aspects spécifiques de la traduction tout en tirant parti de l'apprentissage statistique pour d'autres parties du processus.
• Apprentissage machine : L'apprentissage machine, en particulier les modèles neuronaux, a considérablement amélioré les performances de la traduction automatique. Les réseaux de neurones, tels que les réseaux de neurones récurrents (RNN) et les transformers, ont montré des résultats impressionnants en capturant des structures linguistiques complexes.

Traduction automatique : Approche manuelle (règles)

L'approche manuelle dans la traduction automatique repose sur l'utilisation de règles linguistiques préalablement définies par des linguistes ou des experts en langues. Ces règles spécifient comment traduire des éléments spécifiques d'une langue source vers une langue cible.

Exemple : Traduction de phrases simples (anglais vers français)

Supposons que nous avons une règle manuelle qui dit que le mot "hello" en anglais doit être traduit par "bonjour" en français. De plus, nous avons une règle indiquant que la phrase "I love" doit être traduite par "j'aime". Ces règles sont simples et sont utilisées mot à mot.

• Application des règles manuelles : "Hello" est traduit en "bonjour." "I love" est traduit en "j'aime." "programming" n'a pas de règle spécifique, donc nous le laissons tel quel.
• Traduction résultante : La phrase anglaise "Hello, I love programming" serait traduite en français par "Bonjour, j'aime programming."

Dans des situations réelles, les règles peuvent devenir extrêmement complexes, impliquant des contextes grammaticaux, des variations lexicales, des idiomes, etc.

Traduction automatique : Approche statistique

L'approche statistique de la traduction automatique repose sur l'utilisation de modèles statistiques pour apprendre les relations entre les phrases dans différentes langues à partir de grands ensembles de données parallèles. Contrairement à l'approche manuelle basée sur des règles linguistiques définies par des experts, l'approche statistique utilise des statistiques et des probabilités pour estimer la probabilité d'une traduction donnée.

Les étapes clés de l'approche statistique de la traduction automatique :

• Ensembles de données parallèles : Pour entraîner un modèle statistique, des ensembles de données parallèles sont nécessaires. Ces ensembles contiennent des phrases dans la langue source et leurs traductions correspondantes dans la langue cible.
• Alignement de phrases : Les phrases équivalentes dans les deux langues sont alignées dans l'ensemble de données parallèles. Cela crée des paires de phrases qui serviront de données d'entraînement pour le modèle.

Traduction automatique : Approche statistique

Les étapes clés de l'approche statistique de la traduction automatique :

• Extraction de caractéristiques : Des caractéristiques pertinentes sont extraites à partir des paires de phrases alignées. Ces caractéristiques peuvent inclure des n-grammes (groupes de mots consécutifs), des séquences de mots, des informations sur la syntaxe, etc.
• Entraînement du modèle : Un modèle statistique, souvent basé sur des méthodes probabilistes comme les modèles de langue conditionnels, est entraîné sur ces caractéristiques extraites. Le modèle apprend les probabilités conditionnelles des traductions données les phrases sources.
• Estimation des probabilités : Lors de la traduction d'une nouvelle phrase, le modèle estime les probabilités des différentes traductions possibles en fonction des caractéristiques de cette phrase.
• Sélection de la meilleure traduction : La traduction avec la probabilité la plus élevée est sélectionnée comme la traduction finale de la phrase source.

Traduction automatique : Approche statistique

Les étapes clés de l'approche statistique de la traduction automatique :

• Évaluation et ajustement : Le modèle est évalué sur des ensembles de données de test pour mesurer sa performance. Si nécessaire, le modèle peut être ajusté pour améliorer ses performances.

Un exemple concret de cette approche pourrait être l'utilisation de modèles de langues conditionnels (par exemple, les modèles de Markov conditionnels) pour estimer la probabilité d'une traduction donnée une phrase source.

Traduction automatique : Approche Hybride (Règles et Statistique)

L'approche hybride dans la traduction automatique combine des éléments des approches manuelles (basées sur des règles) et des approches statistiques. L'idée est d'utiliser des règles linguistiques pour certaines parties de la traduction tout en tirant parti de modèles statistiques pour d'autres parties du processus. Cette combinaison vise à exploiter les avantages des deux approches pour obtenir des traductions de meilleure qualité.

Les étapes clés :

Traduction automatique : Approche Hybride (Règles et Statistique)

Les étapes clés :

Traduction automatique : Apprentissage machine

L'approche machine dans la traduction automatique fait référence à l'utilisation de techniques d'apprentissage machine, en particulier d'algorithmes d'apprentissage automatique, pour automatiser le processus de traduction entre langues. Cette approche a considérablement évolué avec le développement de modèles plus avancés basés sur l'apprentissage profond, notamment les modèles de séquence à séquence.

Les étapes clés de l'approche machine dans la traduction automatique :

• Ensembles de données parallèles : Des ensembles de données parallèles sont nécessaires, contenant des phrases dans la langue source et leurs traductions correspondantes dans la langue cible. Ces ensembles serviront de données d'entraînement pour le modèle.
• Modèle de séquence à séquence (Seq2Seq) : Le modèle central dans cette approche est généralement un modèle de séquence à séquence (Seq2Seq). Ce type de modèle utilise un réseau neuronal récurrent (RNN) ou une architecture de transformer pour traiter des séquences de données.

Traduction automatique : Apprentissage machine

Les étapes clés de l'approche machine dans la traduction automatique :

• Encodage de la phrase source : La phrase source est encodée en une représentation vectorielle par le réseau neuronal. Cela capture les informations sémantiques et syntaxiques de la phrase source.
• Décodage vers la langue cible : Le modèle décode ensuite la représentation encodée pour générer la séquence de mots dans la langue cible. C'est le processus de génération de la traduction.
• Entraînement supervisé : Le modèle est entraîné sur les ensembles de données parallèles en utilisant une approche supervisée. Il apprend à minimiser la différence entre la séquence générée et la traduction attendue dans la langue cible.
• Optimisation : Des techniques d'optimisation, telles que la descente de gradient stochastique (SGD) ou des optimiseurs plus avancés comme Adam, sont utilisées pour ajuster les poids du modèle pendant l'entraînement.

Traduction automatique : Apprentissage machine

Les étapes clés de l'approche machine dans la traduction automatique :

• Évaluation et ajustement : Le modèle est évalué sur des ensembles de données de test indépendants pour mesurer sa performance. Des ajustements peuvent être effectués pour améliorer les résultats.
• Incorporation de méthodes plus avancées : Les modèles de traduction automatique basés sur l'apprentissage machine peuvent être améliorés en incorporant des techniques plus avancées telles que l'attention, qui permettent au modèle de se concentrer sur des parties spécifiques de la phrase source lors de la génération de la traduction.

Transformer

Le Transformer est une architecture de réseau de neurones qui a révolutionné le domaine du traitement du langage naturel depuis son introduction par Vaswani et al. en 2017. Deux des modèles les plus célèbres basés sur l'architecture Transformer sont :

• BERT (Bidirectional Encoder Representations from Transformers)
• GPT (Generative Pre-trained Transformer)

BERT (Bidirectional Encoder Representations from Transformers) :

BERT, développé par Google, est un modèle pré-entraîné qui a été formé sur de vastes corpus de texte. Ce qui distingue BERT, c'est son approche bidirectionnelle pour la représentation des mots. Contrairement à des modèles précédents qui utilisaient une compréhension unidirectionnelle du contexte, BERT prend en compte le contexte à la fois avant et après un mot dans une phrase, améliorant ainsi la compréhension du sens.

• Utilisation : BERT a été pré-entraîné sur des tâches telles que la prédiction de mots masqués dans une phrase (Masked Language Model) et la prédiction de la relation entre deux phrases (Next Sentence Prediction). Ces pré-entraînements permettent à BERT d'acquérir une compréhension profonde du langage.
• Applications : BERT est souvent utilisé comme base pour des tâches spécifiques telles que la classification de texte, l'extraction d'entités nommées, la compréhension de texte, etc. Des versions pré-entraînées de BERT sont disponibles, et les modèles peuvent être fine-tunés pour des tâches spécifiques.

BERT : composants

Un modèle BERT (Bidirectional Encoder Representations from Transformers) est composé de plusieurs éléments clés, reflétant l'architecture Transformer. Les composants principaux d'un modèle BERT :

• Embedding token : Cette couche transforme les tokens (mots ou sous-mots) d'une séquence en vecteurs d'embedding. Chaque token est représenté par un vecteur qui capture son sens sémantique. Ces embeddings peuvent également inclure des informations de position pour indiquer la position de chaque token dans la séquence.
• Embedding de segment : BERT prend en compte le contexte global d'une séquence, même lorsque celle-ci contient plusieurs phrases. Pour ce faire, une couche d'embedding de segment est utilisée. Elle attribue un segment spécifique à chaque token pour indiquer à quel segment il appartient. Cela permet au modèle de distinguer différentes parties de la séquence.

BERT : composants

• Encoder BERT (Transformateur) : L'élément central de BERT est l'encodeur, qui suit l'architecture du Transformer. L'encodeur est composé de plusieurs couches d'attention multi-têtes. Chaque couche prend en compte les relations entre les tokens et utilise l'attention pour attribuer des poids aux différents tokens en fonction de leur importance contextuelle.
• Attention multi-tête : Chaque couche d'attention contient plusieurs "têtes" d'attention. Chaque tête capture des aspects différents des relations entre les tokens. L'utilisation de plusieurs têtes permet au modèle de capturer des relations complexes dans le contexte.
• Couche de pooling : BERT utilise souvent une couche de pooling pour agréger les représentations de tous les tokens en une seule représentation. Cette représentation agrégée peut être utilisée pour des tâches spécifiques, comme la classification de texte.
• Couche de classification : Pour les tâches de classification, une couche de classification est ajoutée au-dessus du modèle BERT. Cette couche peut consister en une ou plusieurs couches denses qui projettent la représentation agrégée sur l'espace de sortie de la tâche.
• Fine-tuning et couches spécifiques à la tâche : Lorsque BERT est fine-tuné pour une tâche spécifique, des couches supplémentaires peuvent être ajoutées pour adapter le modèle à la tâche en question. Cela peut inclure des couches de classification, des couches de régression, ou d'autres couches spécifiques à la sortie souhaitée.

BERT : fonctionnement

• Prétraitement des données : Avant d'entraîner ou d'utiliser BERT, les données doivent être prétraitées. Cela inclut la tokenisation, où les phrases sont divisées en tokens (mots ou sous-mots), et l'ajout de tokens spéciaux, tels que [CLS] (pour le début de la phrase) et [SEP] (pour la séparation entre les phrases). De plus, des embeddings de segment peuvent être ajoutés pour indiquer à quel segment appartient chaque token, ce qui est utile pour les tâches de compréhension de texte.
• Architecture du modèle BERT : BERT utilise une architecture Transformer avec un encodeur bidirectionnel. La partie "bidirectionnelle" signifie que le modèle prend en compte le contexte à la fois avant et après chaque mot dans une phrase, ce qui améliore la compréhension du sens.
• Pré-entraînement : BERT est pré-entraîné sur de grandes quantités de données textuelles non annotées. Il est formé à prédire les mots masqués dans une séquence (Masked Language Model, MLM) et à prédire la relation entre deux phrases (Next Sentence Prediction, NSP). Le modèle apprend ainsi une représentation profonde et contextuelle du langage.

BERT : fonctionnement

• Fine-tuning : Après le pré-entraînement, BERT peut être fine-tuné sur des tâches spécifiques. Par exemple, pour la classification de texte, une couche de classification peut être ajoutée au-dessus de la représentation BERT, et le modèle peut être entraîné sur des données annotées pour la tâche spécifique.
• Utilisation du modèle fine-tuné : Une fois fine-tuné, le modèle BERT peut être utilisé pour effectuer des tâches spécifiques, telles que la classification de texte, la reconnaissance d'entités nommées, ou d'autres tâches de traitement du langage naturel.
• Gestion de la longueur des séquences : BERT a une limitation sur la longueur maximale des séquences qu'il peut traiter. Pour les textes plus longs, des techniques comme le fractionnement du texte ou le choix d'une sous-séquence significative peuvent être utilisées.

GPT (Generative Pre-trained Transformer)

GPT, développé par OpenAI, est un modèle basé sur l'architecture Transformer, mais avec une approche de génération de texte. GPT utilise un modèle de langage pré-entraîné qui a appris à prédire le mot suivant dans une séquence de mots. Il est capable de générer du texte cohérent et contextuellement approprié.

• Utilisation : GPT est pré-entraîné sur un large corpus de texte, et la pré-entraînement vise à enseigner au modèle la structure et les motifs du langage. Il peut ensuite être fine-tuné sur des tâches spécifiques selon les besoins.
• Applications : GPT est souvent utilisé pour des tâches de génération de texte, comme la rédaction automatique de contenu, la complétion de texte, et d'autres applications où la création de texte naturel est requise.

GPT (Generative Pre-trained Transformer) : composants

Le modèle GPT (Generative Pre-trained Transformer) est composé de plusieurs éléments clés qui suivent l'architecture Transformer. Les composants principaux de GPT :

• Embedding token : Tout comme dans BERT, GPT utilise une couche d'embedding pour convertir les tokens (mots ou sous-mots) en vecteurs d'embedding. Chaque token est représenté par un vecteur qui capture son sens sémantique.
• Positional encoding : GPT prend en compte la position des mots dans une séquence. Pour ce faire, une couche de Positional Encoding est ajoutée aux embeddings de token pour introduire des informations de position.
• Encodeur-décodeur transformer : Contrairement à BERT, GPT utilise une architecture encodeur-décodeur basée sur le Transformer. L'encodeur capture les relations entre les tokens dans une séquence, tandis que le décodeur est utilisé pour générer la séquence de sortie.

GPT (Generative Pre-trained Transformer) : composants

• Attention multi-tête : Comme dans BERT, GPT utilise une attention multi-tête pour capturer des relations complexes entre les mots. Chaque tête d'attention se concentre sur différents aspects des relations entre les tokens.
• Couche de pooling (ou moyenne) : GPT utilise souvent une couche de pooling pour agréger les représentations de tous les tokens en une seule représentation. Cette représentation agrégée est ensuite utilisée comme entrée pour le décodeur.
• Décodeur GPT : Le décodeur est la partie du modèle qui génère la séquence de sortie. Il prend la représentation agrégée en entrée et génère séquentiellement les tokens de sortie un par un.
• Fine-tuning : Après le pré-entraînement, GPT peut être fine-tuné pour des tâches spécifiques en ajoutant des couches spécifiques à la tâche. Ces couches supplémentaires sont souvent des couches de classification ou de régression, selon la nature de la tâche.

GPT (Generative Pre-trained Transformer) : fonctionnement

• Pré-entraînement : GPT est pré-entraîné sur un vaste corpus de texte non annoté. L'objectif du pré-entraînement est d'apprendre une représentation riche et contextuelle du langage. Pendant cette phase, le modèle apprend à prédire le mot suivant dans une séquence de mots. Il utilise une architecture encodeur-décodeur basée sur le Transformer.
• Embedding et positional encoding : Chaque mot dans une séquence est représenté par un vecteur d'embedding. GPT prend également en compte la position de chaque mot dans la séquence en utilisant une couche de Positional Encoding.
• Encodeur-décodeur transformer : GPT utilise une architecture de Transformer où l'encodeur capture les relations entre les mots dans une séquence, et le décodeur est utilisé pour générer la séquence de sortie. Cependant, GPT est principalement utilisé de manière autoregressive, ce qui signifie qu'il génère séquentiellement un mot à la fois en utilisant les mots précédemment générés comme contexte.

GPT (Generative Pre-trained Transformer) : fonctionnement

• Attention multi-tête : GPT utilise l'attention multi-tête pour capturer des relations complexes entre les mots. Chaque tête d'attention se concentre sur différents aspects du contexte, permettant au modèle de saisir des dépendances à long terme et des relations subtiles.
• Génération de texte : Lors de la génération de texte, le modèle prend une séquence initiale en entrée et génère séquentiellement les mots suivants. À chaque étape, le modèle utilise les mots générés précédemment comme contexte pour prédire le mot suivant. Ce processus se répète jusqu'à ce qu'une séquence complète soit générée.
• Fine-tuning pour des tâches spécifiques : Après le pré-entraînement, GPT peut être fine-tuné pour des tâches spécifiques en ajoutant des couches supplémentaires spécifiques à la tâche. Par exemple, pour la classification de texte, des couches de classification peuvent être ajoutées au-dessus du modèle pré-entraîné.
• Gestion de la longueur des séquences : GPT peut gérer des séquences de longueur variable, mais il a une limite pratique sur la longueur maximale de la séquence qu'il peut générer.

BERT vs. GPT

BERT vs. GPT

Système de recommandation

Le système de recommandation est un domaine essentiel de l'informatique qui vise à réduire la surcharge d'informations en fournissant des suggestions filtrées et pertinentes aux utilisateurs.

Réduction de la surcharge d'informations : Les systèmes de recommandation visent à aider les utilisateurs à naviguer à travers une grande quantité d'informations en fournissant des recommandations ciblées et adaptées à leurs préférences.

Fonctionnement

• Prédire la préférence de l'utilisateur : Les systèmes de recommandation utilisent des algorithmes pour analyser le comportement passé de l'utilisateur, ses préférences, et d'autres données pertinentes afin de prédire les éléments qui pourraient l'intéresser à l'avenir.
• Gestion de la surcharge d'informations : En filtrant et en triant les informations, ces systèmes aident à éviter la surcharge cognitive en présentant à l'utilisateur uniquement ce qui est le plus susceptible de l'intéresser.

Système de recommandation

Types de Recommandations

• Recommandations personnalisées : Basées sur l'historique et les préférences individuelles de l'utilisateur.
• Recommandations non personnalisées : Générales et applicables à un large groupe d'utilisateurs.

Algorithmes couramment utilisés

• Filtrage collaboratif : Basé sur les comportements et les préférences d'utilisateurs similaires.
• Filtrage basé sur le contenu : Utilise des caractéristiques du produit ou de l'élément lui-même pour faire des recommandations.
• Apprentissage profond : Des techniques telles que les réseaux de neurones profonds peuvent être utilisées pour modéliser des modèles complexes de préférences.

Système de recommandation

Applications

• Générateurs de playlists : Pour les services de vidéo et de musique, offrant des recommandations de chansons basées sur le goût musical de l'utilisateur.
• Recommandations de produits : Dans les plateformes de commerce électronique, suggérant des articles basés sur les achats antérieurs ou les préférences.
• Recommandations de livres : Sur les plateformes de vente de livres en ligne, proposant des ouvrages similaires à ceux déjà appréciés.
• Recommandations de contenu sur les réseaux sociaux : Proposant des publications, des amis ou des groupes en fonction de l'activité passée et des préférences de l'utilisateur.

Réalisation [Pazzani 2007, Ricci 2011]

Hypothèse

Les individus suivent souvent les recommandations des autres utilisateurs. Cela suppose que les préférences et les actions des utilisateurs peuvent être des indicateurs fiables pour recommander des articles ou des objets similaires à d'autres utilisateurs.

Sources des données :

• Utilisateurs : Les informations relatives aux utilisateurs, y compris leurs préférences, comportements, et actions.
• Articles ou objets : Les données concernant les articles ou objets à recommander. Cela peut inclure des détails sur les caractéristiques des articles, leurs catégories, etc.
• Transactions : Les interactions et transactions entre les utilisateurs et les articles. Cela peut inclure des achats, des clics, des évaluations, etc.

Réalisation [Pazzani 2007, Ricci 2011]

Collecte des Préférences des Utilisateurs :

• Préférences explicitement exprimées : Les évaluations et les actions des utilisateurs qui sont directement exprimées. Cela peut inclure les avis positifs et négatifs, les évaluations numériques, etc.
• Interprétation des actions des utilisateurs : Observation et interprétation des actions des utilisateurs, en particulier dans le contexte de la navigation web. Cela pourrait inclure des comportements tels que les pages visitées, le temps passé sur une page, les articles ajoutés au panier, etc.

Réalisation

Méthodes de Collecte des Données :

• Surveillance des activités utilisateurs : Utilisation de technologies de suivi pour observer et enregistrer les actions des utilisateurs, généralement dans le contexte d'une plateforme en ligne.
• Systèmes de retour d'information : Encouragement des utilisateurs à fournir des retours d'information explicites sous forme d'évaluations, de commentaires, etc.
• Analyse des transactions : Extraction d'informations à partir des transactions entre utilisateurs et articles pour déduire les préférences et les comportements.

Fonctions [Ricci 2011]

• Augmenter le nombre d'articles vendus : Les systèmes de recommandation visent à stimuler les ventes en suggérant des articles pertinents aux utilisateurs, augmentant ainsi les opportunités d'achat.
• Vendre des articles plus variés : En diversifiant les recommandations, les systèmes cherchent à élargir le choix des utilisateurs et à promouvoir la vente d'une gamme plus large d'articles.
• Augmenter la satisfaction des utilisateurs : En fournissant des recommandations pertinentes et adaptées aux préférences individuelles, les systèmes visent à accroître la satisfaction des utilisateurs.
• Augmenter la fidélité des utilisateurs : En offrant des expériences personnalisées et en répondant aux besoins des utilisateurs, les systèmes cherchent à fidéliser les clients, les incitant à revenir pour davantage d'achats.
• Mieux comprendre ce que veut l'utilisateur : Les systèmes de recommandation sont conçus pour comprendre les préférences des utilisateurs au fil du temps, améliorant ainsi la précision des recommandations et la compréhension des besoins individuels.

Objectifs [Herlocker 2000, Ricci 2011]

• Trouver de bons objets : Fournir des recommandations pour des articles ou des objets qui correspondent aux préférences individuelles de l'utilisateur.
• Trouver tous les bons articles : Identifier de manière exhaustive tous les articles pertinents en fonction des préférences spécifiques de l'utilisateur

Objectifs [Herlocker 2000, Ricci 2011]

Contexte et Variations de Recommandations

• Annotation dans le contexte : Intégrer des informations contextuelles dans les recommandations pour les rendre plus pertinentes et adaptées à la situation actuelle.
• Recommander une séquence : Proposer une séquence d'articles ou de contenus, tels que des livres ou des vidéos, sur un sujet donné pour une expérience d'apprentissage ou de divertissement cohérente.
• Recommander une combinaison : Offrir des suggestions de combinaisons d'articles, comme un itinéraire de voyage complet, pour répondre à des besoins complexes.

Objectifs [Herlocker 2000, Ricci 2011]

Navigation et consultation

• Navigation (consultation) : Faciliter la navigation et la consultation d'articles en recommandant des éléments pertinents à mesure que l'utilisateur explore la plateforme.
• Trouver un système de recommandation crédible : Identifier des systèmes de recommandation réputés et fiables pour garantir des suggestions de qualité.
• Améliorer le profil : Continuellement ajuster et améliorer le profil de l'utilisateur en fonction de ses préférences changeantes.

Objectifs [Herlocker 2000, Ricci 2011]

Interaction Sociale

• S'exprimer : Permettre aux utilisateurs de s'exprimer en fournissant des retours et en influençant les recommandations.
• Aider les autres : Offrir des mécanismes pour que les utilisateurs puissent recommander des articles à d'autres utilisateurs.
• Influencer les autres : Permettre aux utilisateurs d'influencer les préférences d'autres utilisateurs en partageant leurs recommandations.

Approches [Pazzani 2007, Ricci 2011]

• Filtrage collaboratif
  • Principe : basé sur les évaluations de plusieurs utilisateurs
  • Fonctionnement : Identifie des utilisateurs similaires à celui pour lequel la recommandation est générée et propose des articles appréciés par ces utilisateurs similaires.
• Filtrage basé sur le contenu
  • Principe : basé sur les profils des utilisateurs
  • Fonctionnement : Recommande des articles similaires à ceux que l'utilisateur a aimés par le passé, en se basant sur les caractéristiques ou le contenu des articles.
• Démographiques
  • Principe : le profil démographique de l'utilisateur, par exemple le lieu et la langue
  • Fonctionnement : Propose des recommandations en fonction des caractéristiques démographiques de l'utilisateur.

Approches [Pazzani 2007, Ricci 2011]

• Basé sur la connaissance
  • Principe :des recommandations basées sur la connaissance du domaine
  • Fonctionnement : Utilise une compréhension approfondie du contenu ou du domaine pour recommander des articles pertinents.
• Basé sur la communauté
  • Principe :des recommandations basées sur les préférences des amis des utilisateurs
  • Fonctionnement : Identifie les goûts et les préférences des amis de l'utilisateur pour proposer des recommandations similaires.
• Systèmes hybrides de recommandation [Gomez-Uribe 2016]
  • Principe : Intégration de plusieurs approches.
  • Fonctionnement : Combiner différentes méthodes de recommandation pour tirer parti de leurs avantages respectifs et fournir des suggestions plus précises et diversifiées.

Filtrage collaboratif

Le filtrage collaboratif basé sur les transactions implique l'analyse des transactions entre utilisateurs et articles pour générer des recommandations.

• Transactions : Les transactions font référence aux interactions ou aux actions effectuées par les utilisateurs lorsqu'ils interagissent avec des articles, tels que des achats, des évaluations, des clics, etc. Les informations sur les transactions sont collectées et utilisées comme base pour comprendre les préférences des utilisateurs et générer des recommandations.
• Algorithmes: Règles de l'association
  • Fonctionnement : Les règles de l'association identifient des modèles de co-occurrence dans les transactions. Par exemple, si les utilisateurs qui ont acheté l'article A ont également tendance à acheter l'article B, une règle de l'association peut être établie entre A et B.
  • Application : Ces règles peuvent être utilisées pour recommander des articles à un utilisateur en se basant sur les préférences d'autres utilisateurs ayant des transactions similaires.

Filtrage collaboratif

Avantages

• Personnalisation : Les recommandations sont personnalisées en fonction des comportements d'achat et des transactions passées de l'utilisateur.
• Découverte de modèles : Permet de découvrir des modèles de comportement d'achat et d'identifier des associations entre différents articles.

Limitations

• Sparsité des données : Si un utilisateur a effectué un nombre limité de transactions, les recommandations peuvent être moins précises en raison de la sparsité des données.
• Problème du démarrage à froid : Il peut y avoir des difficultés lorsqu'un nouvel utilisateur effectue peu ou pas de transactions, entraînant des défis dans la génération de recommandations.

Filtrage basé sur le contenu [Pazzani 2007]

Le filtrage collaboratif basé sur le contenu repose sur la description des objets et le profil des intérêts de l'utilisateur.

• Description d'objet
  • Les caractéristiques ou le contenu des objets (articles, produits, etc.) sont utilisés pour décrire chaque élément de manière détaillée.
• Profil d'intérêts de l'utilisateur
  • Modèle des préférences : Un modèle représentant les préférences de l'utilisateur basé sur la description des objets qu'il a aimés par le passé.
  • Historique d'interactions : L'historique des interactions de l'utilisateur avec le système de recommandation est également utilisé pour ajuster le modèle au fil du temps.

Filtrage basé sur le contenu [Pazzani 2007]

Algorithmes

• Arbres de décision : Les arbres de décision sont utilisés pour modéliser les préférences de l'utilisateur en fonction des caractéristiques des objets. L'arbre est construit pour prendre des décisions sur les recommandations en se basant sur ces caractéristiques.
• Méthodes du plus proche voisin : Les méthodes du plus proche voisin comparent le profil d'intérêts de l'utilisateur avec ceux d'autres utilisateurs pour trouver les plus similaires. Les objets appréciés par ces utilisateurs similaires sont recommandés.
• Classificateurs linéaires : Les classificateurs linéaires modélisent la relation entre les caractéristiques des objets et les préférences de l'utilisateur de manière linéaire. Cela peut inclure des modèles tels que la régression logistique.

Filtrage basé sur le contenu [Pazzani 2007]

Avantages

• Personnalisation : Les recommandations sont personnalisées en fonction du profil d'intérêts de l'utilisateur, ce qui les rend adaptées à ses goûts spécifiques.
• Gestion du problème du démarrage à froid : Peut mieux gérer le problème du démarrage à froid pour de nouveaux utilisateurs en se basant sur la description d'objets.

Filtrage basé sur le contenu [Pazzani 2007]

Limitations

• Dépendance à la description d'objet : L'efficacité dépend de la qualité de la description des objets, et certaines approches peuvent être sensibles à des descriptions incomplètes ou subjectives.
• Manque de diversité : Peut avoir tendance à recommander des objets similaires à ceux que l'utilisateur a aimés, limitant la diversité des suggestions.

Systèmes hybrides [Gomez-Uribe 2016]

• Filtrage basé sur le contenu et filtrage collaboratif : Combiner ces approches peut compenser les limitations individuelles, offrant des recommandations plus robustes qui tiennent compte à la fois du contenu des objets et des comportements d'autres utilisateurs.
• Filtrage basé sur le contenu, filtrage collaboratif et démographique : Cette approche hybride prend en compte non seulement les préférences individuelles de l'utilisateur mais aussi des aspects démographiques pour des recommandations plus contextualisées.

Systèmes hybrides

Avantages

• Meilleure précision : En combinant différentes approches, les systèmes hybrides peuvent fournir des recommandations plus précises et diversifiées.
• Gestion des limitations : Compenser les limitations spécifiques de chaque approche individuelle.
• Adaptabilité : S'adapter à différents types d'utilisateurs et de contextes.
• Réduction du problème du démarrage à froid : En intégrant des aspects démographiques, par exemple, les systèmes hybrides peuvent mieux gérer le démarrage à froid pour de nouveaux utilisateurs.

Mesures de performance [Ziegler 2005, Ricci 2011]

• Précision et efficacité [Beel 2013a] : La capacité du système à fournir des recommandations pertinentes et la rapidité avec laquelle le système génère des recommandations.
• Diversité : La variété des recommandations fournies pour éviter la redondance et introduire de nouveaux éléments.
• Persistance de la recommandation : La cohérence des recommandations au fil du temps, offrant une expérience utilisateur stable.
• Vie privée [Pu 2012] : La protection et le respect de la vie privée des utilisateurs lors de la collecte et de l'utilisation des données.
• Démographie des utilisateurs : L'intégration de facteurs démographiques pour des recommandations plus contextuelles.
• Robustesse (lutte contre la fraude) [Konstan 2012] : La capacité à résister aux tentatives de manipulation ou de fraude dans le système.
• Sérendipité : La capacité à surprendre l'utilisateur en proposant des recommandations inattendues mais appréciées.
• Confiance : La fiabilité perçue du système, renforçant la confiance de l'utilisateur dans les recommandations fournies.
• Étiquetage (recommandations organiques ou sponsorisées) [Beel 2013b] : La transparence dans la distinction entre les recommandations générées organiquement et celles sponsorisées.

Domaines à haut risque [Herlocker 2000]

Les recommandations à haut risque se réfèrent à des domaines où les conséquences d'une recommandation incorrecte ou inappropriée peuvent être significatives.

Exemple

Assurance : Les recommandations dans le domaine de l'assurance peuvent avoir des implications financières importantes. Par exemple, une recommandation inappropriée en matière d'assurance pourrait entraîner des conséquences financières négatives pour l'utilisateur.

Intégration des Capacités d'Explication

Les systèmes de recommandation à haut risque devraient intégrer des capacités d'explication, permettant de fournir des justifications claires pour chaque recommandation.

Domaines à haut risque [Herlocker 2000]

Avantages des explications

Représentation des connaissances et raisonnement (KRR)

La Représentation des connaissances et raisonnement (KRR) constituent un domaine clé de l'intelligence artificielle. La KRR est largement utilisée dans des domaines tels que la planification, la représentation du langage naturel, la gestion des connaissances, les systèmes experts, etc.

Représentation des Connaissances

La représentation des connaissances implique la création d'une représentation lisible par machine de la connaissance d'un monde ou d'un domaine particulier. Cela vise à permettre aux systèmes informatiques de comprendre, interpréter et raisonner sur l'information.

Exemples

• Réseaux Sémantiques : Utilisent des relations sémantiques pour connecter des entités et représenter la connaissance.
• Ontologies : Définissent des concepts, des propriétés et des relations dans un domaine spécifique.

Représentation des connaissances et raisonnement (KRR)

Raisonnement

Le raisonnement consiste à déduire de nouvelles informations à partir des connaissances existantes. C'est le processus par lequel les systèmes tirent des conclusions logiques.

Compromis entre expressivité et praticité

• Expressivité : La capacité à représenter une variété de connaissances de manière détaillée.
• Praticité : La facilité d'utilisation et de manipulation de la représentation des connaissances.

Web sémantique

Web sémantique

Le Semantic Web Stack, également connu sous le nom de pile sémantique, représente une série de technologies et de standards interconnectés qui ont été développés pour réaliser la vision du World Wide Web sémantique. Cette vision, initiée par Tim Berners-Lee, vise à rendre le contenu du web plus compréhensible par les machines en ajoutant une sémantique aux données, permettant ainsi une meilleure interopérabilité et une utilisation plus avancée des informations sur le web.

Les principales couches de la pile sémantique (du bas vers le haut) :

• XML (eXtensible Markup Language) : La base de la pile sémantique est constituée par XML, un langage de balisage extensible qui permet de structurer et de représenter des données de manière lisible par les machines.
• XML Namespaces : Les espaces de noms XML sont utilisés pour éviter les conflits de noms entre les éléments XML provenant de différentes sources.

Web sémantique

• RDF (Resource Description Framework) : RDF est un langage standardisé permettant de décrire des ressources du web de manière à faciliter le partage et la réutilisation d'informations entre applications. Il repose sur un modèle de graphe pour représenter les relations entre les entités.
• RDF Schema (RDFS) : RDFS est une extension de RDF qui fournit des classes et des propriétés permettant de définir la structure des données RDF, facilitant ainsi la création de schémas et de taxonomies.
• OWL (Web Ontology Language) : OWL est une extension de RDF qui permet de définir des ontologies, c'est-à-dire des modèles de connaissances formels décrivant les relations entre les concepts. Il offre une expressivité accrue par rapport à RDFS.
• SPARQL (SPARQL Protocol and RDF Query Language) : - SPARQL est un langage de requête permettant d'interroger des données RDF. Il offre une puissante capacité de recherche et d'interrogation des informations sémantiques.

Web sémantique

• RDFa et Microformats : RDFa (RDF in attributes) et Microformats sont des approches pour intégrer des données sémantiques dans des documents HTML, permettant aux agents intelligents d'extraire des informations à partir de pages web.
• Linked Data : Le concept de Linked Data encourage la publication de données structurées sur le web, avec des liens entre les ensembles de données, facilitant la découverte et l'intégration des informations.

En utilisant cette pile sémantique, le World Wide Web sémantique vise à créer une infrastructure où les machines peuvent comprendre, interpréter et exploiter le contenu du web de manière plus avancée, ouvrant ainsi la porte à de nombreuses applications intelligentes et à une meilleure interconnexion des données.

Web sémantique

• RIF (Rule Interchange Format) : RIF fournit un cadre standard pour l'échange de règles entre différentes applications. Il s'agit d'un langage formel permettant de spécifier des règles logiques, ce qui est crucial pour l'automatisation de l'inférence et du raisonnement sur les données sémantiques.
• Unifying Logic : Cette couche englobe les différentes logiques formelles utilisées dans le World Wide Web sémantique, y compris les logiques de description telles que OWL et les logiques de règles comme celles représentées par RIF. L'objectif est de fournir un cadre logique unifié pour décrire les connaissances.
• Proof and Trust (Preuve et Confiance) : Cette couche implique la capacité de fournir des preuves formelles pour les déclarations sémantiques. Elle intègre également des mécanismes de confiance, permettant d'évaluer la fiabilité des sources d'informations et d'inférer la crédibilité des données sémantiques.
• User Applications (Applications Utilisateur) : Au sommet de la pile, nous avons les applications utilisateur qui tirent parti des données sémantiques pour offrir des fonctionnalités avancées. Cela pourrait inclure des applications d'analyse des sentiments, de recherche sémantique, de recommandation personnalisée, etc.

Moteur de règles

Un moteur de règles, également connu sous le nom de moteur d'inférence, est un composant logiciel qui traite et applique un ensemble de règles et de contraintes définies.

• Règles : Les règles sont des instructions conditionnelles qui décrivent les relations entre différentes entités ou éléments dans un système. Chaque règle a une condition qui, si elle est remplie, déclenche une action spécifique.
• Contraintes : Les contraintes définissent des limitations ou des exigences spécifiques sur les données ou les actions dans un système. Elles contribuent à garantir la cohérence et la conformité des opérations.
• Traitement des données : Le moteur de règles traite les données en fonction des règles définies. Il examine l'état actuel du système et évalue si les conditions des règles sont satisfaites.

Moteur de règles

• Évaluation des conditions : Le moteur de règles évalue les conditions de chaque règle pour déterminer si elles sont vraies ou fausses. Si une condition est vraie, la règle associée est déclenchée.
• Action : Lorsqu'une règle est déclenchée, une action spécifique est exécutée. Cette action peut inclure la modification de données, la génération de notifications, ou d'autres opérations définies dans la logique métier.
• Cohérence du système : Le moteur de règles garantit la cohérence du système en appliquant les règles de manière séquentielle et en veillant à ce que les modifications apportées respectent l'ensemble des contraintes.
• Cycle d'évaluation : Le moteur de règles peut fonctionner de manière répétée, évaluant en continu l'état du système en fonction des règles. Cela permet une gestion dynamique et adaptative des opérations en réponse aux changements dans le système.

Les moteurs de règles sont largement utilisés dans divers domaines, tels que la gestion des workflows, la logique métier, les systèmes d'alerte, et d'autres applications où des règles spécifiques doivent être appliquées pour maintenir la cohérence et automatiser les processus. Ils offrent une approche déclarative pour spécifier la logique métier sans nécessiter une programmation explicite.

Moteur de règles : Applications

• Systèmes de gestion de workflow : Un moteur de règles peut être utilisé pour orchestrer le flux de travail dans une entreprise. Par exemple, il peut déclencher des étapes spécifiques en fonction de certaines conditions, comme l'approbation d'une demande ou la disponibilité de ressources.
• Systèmes d'alerte : Dans le domaine des systèmes de surveillance, un moteur de règles peut être employé pour déclencher des alertes en cas de dépassement de seuils prédéfinis. Cela pourrait inclure des alertes de performance, de sécurité, ou d'autres métriques.
• Logique métier dans les applications : Les applications métier complexes peuvent utiliser des moteurs de règles pour gérer la logique métier. Par exemple, dans un système bancaire, des règles peuvent être définies pour gérer les conditions d'octroi de prêts.

Moteur de règles : Applications

• Systèmes de gestion de la chaîne d'approvisionnement : Les moteurs de règles peuvent être intégrés aux systèmes de gestion de la chaîne d'approvisionnement pour automatiser des décisions telles que la sélection des fournisseurs en fonction de critères prédéfinis.
• Systèmes de tarification dynamique : Dans le commerce électronique, un moteur de règles peut être utilisé pour ajuster dynamiquement les prix en fonction de divers facteurs tels que la demande du marché, la disponibilité des produits, ou d'autres conditions commerciales.
• Systèmes de gestion des fraudes : Les moteurs de règles sont souvent utilisés dans les systèmes de détection de fraude. Ils peuvent déclencher des alertes lorsque des modèles de comportement suspects sont détectés, aidant ainsi à prévenir les activités frauduleuses.
• Systèmes de traitement des demandes : Les moteurs de règles peuvent être intégrés aux systèmes de traitement des demandes pour automatiser la prise de décision en fonction de critères prédéfinis, accélérant ainsi le processus global.

Moteur de règles : Langages

• Drools (langage Drools Rule Language - DRL) : - Drools est un moteur de règles open source basé sur le langage DRL. Il utilise une syntaxe déclarative pour définir des règles métier.
• RuleML (Rule Markup Language) : - RuleML est un langage de balisage spécialement conçu pour représenter des règles métier sous une forme lisible par machine.
• Jess (Java Expert System Shell) : - Jess est un moteur de règles pour Java qui utilise son propre langage basé sur le Lisp pour définir les règles.
• CLIPS (C Language Integrated Production System) : - CLIPS est un système expert qui inclut un moteur de règles. Il utilise un langage de programmation déclaratif pour spécifier des règles et des faits.
• Rete : - Rete est un algorithme utilisé dans plusieurs moteurs de règles, y compris CLIPS et Drools. Il est conçu pour optimiser l'évaluation des règles.

Moteur de règles : Logiciels

• Drools : Drools, mentionné ci-dessus, est un moteur de règles open source développé par Red Hat. Il offre des fonctionnalités avancées pour la gestion de règles métier.
• IBM Operational Decision Manager (ODM) : ODM est une solution d'IBM qui fournit un moteur de règles pour automatiser et gérer les décisions métier dans les applications.
• Corticon : Progress Corticon est une plateforme de gestion de règles métier qui permet aux utilisateurs de modéliser, exécuter et optimiser des règles métier.
• InRule : InRule est une plateforme de gestion de règles métier qui permet aux entreprises de définir, gérer et automatiser les règles métier.
• Camunda : Camunda propose un moteur de règles dans le cadre de son ensemble de solutions BPMN (Business Process Model and Notation) open source.
• JBoss Rules (anciennement JRules) : JBoss Rules, maintenant intégré à Drools, était un moteur de règles développé par IBM avant d'être open source.
• Microsoft BizTalk Rules Engine : Microsoft BizTalk Server inclut un moteur de règles qui permet aux entreprises de définir et de gérer les règles métier dans leurs processus.

Programmation logique

La programmation logique, en particulier la logique propositionnelle et la logique du premier ordre (FOL), joue un rôle fondamental dans le domaine de l'intelligence artificielle.

• Logique propositionnelle : En IA, la logique propositionnelle est souvent utilisée pour modéliser des systèmes de connaissance simples. Elle est adaptée pour représenter des faits, des règles et des relations de manière formelle.
• Logique du premier ordre (FOL, logique des prédicats) : La logique du premier ordre est largement utilisée en IA pour modéliser des connaissances plus riches et des raisonnements plus sophistiqués. Elle permet de décrire des entités, leurs attributs et les relations entre elles de manière plus expressive.

Prolog

Prolog (Programming in Logic) est un langage de programmation déclaratif, basé sur la logique du premier ordre.

• Prolog est souvent qualifié de langage de programmation déclaratif, car les programmes Prolog décrivent les relations entre les entités plutôt que de spécifier explicitement les étapes à suivre pour atteindre un résultat.
• Prolog repose sur la logique du premier ordre, ce qui signifie qu'il permet de décrire des relations logiques complexes à l'aide de prédicats, de variables et de quantificateurs. Les programmes Prolog sont composés de faits (des déclarations vraies) et de règles (des relations logiques).
• Prolog a été développé par Alain Colmerauer dans les années 1970 à l'Université de Marseille.
• Les programmes Prolog sont exprimés en termes de relations. Les faits décrivent des relations qui sont toujours vraies, tandis que les règles décrivent des relations qui sont vraies dans certaines conditions. L'exécution d'une requête en Prolog revient à chercher des solutions aux relations spécifiées.
• Prolog a été largement utilisé dans des domaines tels que la démonstration de théorèmes, les systèmes experts et le traitement du langage naturel. En raison de sa nature déclarative et de son approche logique, Prolog est bien adapté pour représenter et résoudre des problèmes impliquant des relations complexes.

Prolog: types de données

En Prolog, les types de données fondamentaux incluent les atomes, les nombres, les variables et les termes composés.

Atome :

Un atome est une chaîne de caractères qui représente un nom. Il commence généralement par une lettre minuscule et peut contenir des lettres, des chiffres et des caractères de soulignement. Les atomes sont utilisés pour représenter des constantes et des noms dans Prolog.

animal(chien).
couleur(rouge).

Prolog: types de données

Nombres :

Prolog prend en charge les entiers et les nombres à virgule flottante comme types de données numériques.

age(personne1, 23).
prix(livre1, 19.99).

Prolog: types de données

Variables :

Les variables sont des symboles qui représentent des valeurs inconnues. Elles commencent généralement par une lettre majuscule ou un soulignement.

personne(X).

Prolog: types de données

Terme Composé :

Les termes composés sont des structures de données complexes créées à partir de foncteurs (noms de termes) et d'arguments. Ils sont utilisés pour représenter des entités composées.

point(3, 7).
livre(titre('Introduction à Prolog'), auteur('John Doe')).

Les termes composés peuvent également être utilisés pour représenter des listes, des arbres et d'autres structures de données complexes.

Prolog: règles

En Prolog, les règles sont des clauses qui définissent des relations entre différents termes. La structure générale d'une règle est la suivante :

• Tête : La tête de la règle spécifie la relation que nous voulons définir. Elle est généralement composée d'un seul prédicat.
• Corps : Le corps de la règle contient une séquence de prédicats liés par des conjonctions (, pour ET) et des disjonctions (; pour OU). Le corps de la règle spécifie les conditions sous lesquelles la relation spécifiée dans la tête est vraie.

Prolog: faits

En Prolog, une clause avec un corps vide est en effet appelée un fait.

personne(bob).
personne(alice).

Les faits sont des affirmations qui sont considérées comme vraies dans le monde que vous décrivez. Ces faits peuvent ensuite être utilisés dans des requêtes ou d'autres règles pour déduire des informations supplémentaires.

Prolog: Installation

GNU Prolog, également connu sous le nom de gprolog, est un compilateur Prolog basé sur le standard ISO Prolog. Il est conçu pour être utilisé sur différentes plates-formes, y compris Linux, Windows et d'autres systèmes d'exploitation.

L'installation de gprolog sur une machine Ubuntu

Prolog: GNU Prolog

Prolog: GNU Prolog: interrogation

Prolog: GNU Prolog: interrogation

Prolog: GNU Prolog: interrogation

Prolog: GNU Prolog: interrogation

			
$ cat friend.pl
friend(bob, alice).
friend(alice, kevin).
friend(bob, thomas).
friend(bob, peter).
human(X):-friend(X,_).
human(Y):-friend(_,Y).

        
        
        

Prolog: GNU Prolog: interrogation

			
$ prolog --consult-file friend.pl
GNU Prolog 1.4.5 (64 bits)
Compiled Feb 23 2020, 20:14:50 with gcc
By Daniel Diaz
Copyright (C) 1999-2020 Daniel Diaz
compiling /home/user/friend.pl for byte code...
/home/user/friend.pl compiled, 4 lines read - 515 bytes written, 22 ms
| ?- friend(bob,alice).

true ?

yes
                        
			

Prolog: GNU Prolog: interrogation

			
$ prolog --consult-file friend.pl
| ?- human(X).
X = bob ? a
X = alice
X = bob
X = bob
X = alice
X = kevin
X = thomas
X = peter

yes
| ?-
                        
			

Prolog: GNU Prolog: interrogation

			
$ cat ancetre.pl
/* Faits : Déclaration des relations parents */
parent(kevin, jane).
parent(kevin, jim).
parent(jane, ann).
parent(jane, bob).
parent(jim, pat).

/* Règle : X est l'ancêtre de Y si X est le parent de Y ou si X est l'ancêtre d'un parent de Y. */
ancetre(X, Y) :- parent(X, Y).
ancetre(X, Y) :- parent(X, Z), ancetre(Z, Y).

        
        
        

Prolog: GNU Prolog: interrogation

			
$ prolog --consult-file friend.pl
GNU Prolog 1.4.5 (64 bits)
Compiled Feb 23 2020, 20:14:50 with gcc
By Daniel Diaz
Copyright (C) 1999-2020 Daniel Diaz
/home/user/ancetre.pl compiled, 11 lines read - 1119 bytes written, 14 ms
| ?- ancetre(kevin,X).
X = jane ? a
X = jim
X = ann
X = bob
X = pat

no
| ?-
                        
			

Prolog: GNU Prolog: interrogation

/* Faits : Déclaration des élèves et de leurs notes */
note(kevin, math, 85).
note(kevin, anglais, 90).
note(jane, math, 92).
note(jane, anglais, 88).
note(bob, math, 78).
note(bob, anglais, 85).

/* Règle : Calcul de la moyenne des notes d'un élève */
moyenne(Eleve, Moyenne) :-
    findall(Note, note(Eleve, _, Note), Notes),
    length(Notes, N),
    somme_liste(Notes, Sum),
    Moyenne is Sum / N.

Prolog: GNU Prolog: interrogation

/* Prédicat auxiliaire : Calcul de la somme d'une liste */
somme_liste([], 0).
somme_liste([X|Xs], Sum) :-
    somme_liste(Xs, Reste),
    Sum is X + Reste.

/* Prédicat auxiliaire : Calcul de la somme d'une liste */
somme_liste([], 0).
somme_liste([X|Xs], Sum) :-
    somme_liste(Xs, Reste),
    Sum is X + Reste.

Prolog: GNU Prolog: interrogation

/* Règle : Affichage des élèves avec leur moyenne */
afficher_moyennes :-
    setof(Eleve, Matiere^Note^(note(Eleve, Matiere, Note)), Eleves),
    member(Eleve, Eleves),
    moyenne(Eleve, Moyenne),
    format('Élève: ~w, Moyenne: ~2f~n', [Eleve, Moyenne]),
    fail.
afficher_moyennes.

Prolog: GNU Prolog: interrogation

			
$ prolog --consult-file notes.pl
GNU Prolog 1.4.5 (64 bits)
Compiled Feb 23 2020, 20:14:50 with gcc
By Daniel Diaz
Copyright (C) 1999-2020 Daniel Diaz
/home/user/notes.pl compiled, 30 lines read - 3086 bytes written, 3 ms 
| ?- afficher_moyennes.
Élève: bob, Moyenne: 81.50
Élève: jane, Moyenne: 90.00
Élève: kevin, Moyenne: 87.50

(1 ms) no
| ?-
                        
			

Articles de recherche

• [Beel 2013a] Beel, Joeran, et al. “A Comparative Analysis of Offline and Online Evaluations and Discussion of Research Paper Recommender System Evaluation.” Proceedings of the International Workshop on Reproducibility and Replication in Recommender Systems Evaluation, Association for Computing Machinery, 2013
• [Beel 2013b] Beel, Joeran, et al. “Sponsored vs. Organic (Research Paper) Recommendations and the Impact of Labeling.” Research and Advanced Technology for Digital Libraries, edited by Trond Aalberg et al., Springer, 2013, pp. 391–95.
• [Chrupała 2006] Chrupała, Grzegorz. Simple Data-Driven Context-Sensitive Lemmatization. 2006. doras.dcu.ie, http://www.unizar.es/departamentos/filologia_inglesa/sepln2006/.
• [Frakes 2003] Frakes, William B., and Christopher J. Fox. “Strength and Similarity of Affix Removal Stemming Algorithms.” ACM SIGIR Forum, vol. 37, no. 1, Apr. 2003, pp. 26–30. Spring 2003

Articles de recherche

• [Gomez-Uribe 2016] Gomez-Uribe, Carlos A., and Neil Hunt. “The Netflix Recommender System: Algorithms, Business Value, and Innovation.” ACM Transactions on Management Information Systems, vol. 6, no. 4, Dec. 2016, p. 13:1–13:19. January 2016 Proceedings of the 50th Annual Meeting of the Association for Computational Linguistics: Short Papers - Volume 2, Association for Computational Linguistics, 2012, pp. 368–372.
• [Gesmundo 2012] Gesmundo, Andrea, and Tanja Samardžić. “Lemmatisation as a Tagging Task.”
• [Herlocker 2000] Herlocker, Jonathan L., et al. “Explaining Collaborative Filtering Recommendations.” Proceedings of the 2000 ACM Conference on Computer Supported Cooperative Work, Association for Computing Machinery, 2000, pp. 241–250. ACM
• [Konstan 2012] Konstan, Joseph A., and John Riedl. “Recommender Systems: From Algorithms to User Experience.” User Modeling and User-Adapted Interaction, vol. 22, no. 1–2, Apr. 2012, pp. 101–123.
• [Màrquez 2000] Màrquez, Lluís, et al. “A Machine Learning Approach to POS Tagging.” Machine Learning, vol. 39, no. 1, Apr. 2000, pp. 59–91.
• [Mikolov 2013] Mikolov, Tomas, et al. “Efficient Estimation of Word Representations in Vector Space.” ArXiv:1301.3781 [Cs], Sept. 2013.

Articles de recherche

• [Miller 1995] Miller, George A. “WordNet: A Lexical Database for English.” Communications of the ACM, vol. 38, no. 11, Nov. 1995, pp. 39–41. Nov. 1995
• [Pazzani 2007] Pazzani, Michael J., and Daniel Billsus. “Content-Based Recommendation Systems.” The Adaptive Web: Methods and Strategies of Web Personalization, edited by Peter Brusilovsky et al., Springer, 2007, pp. 325–41.
• [Porter 1980] Porter, M. F. “An Algorithm for Suffix Stripping.” Program, vol. 14, no. 3, Jan. 1980, pp. 130–37. Emerald Insight
• [Pu 2012] Pu, Pearl, et al. “Evaluating Recommender Systems from the User’s Perspective: Survey of the State of the Art.” User Modeling and User-Adapted Interaction, vol. 22, no. 4, Oct. 2012, pp. 317–55.
• [Ricci 2011] Ricci, Francesco, et al. “Introduction to Recommender Systems Handbook.” Recommender Systems Handbook, edited by Francesco Ricci et al., Springer US, 2011, pp. 1–35.
• [Ziegler 2005] Ziegler, Cai-Nicolas, et al. “Improving Recommendation Lists through Topic Diversification.” Proceedings of the 14th International Conference on World Wide Web, Association for Computing Machinery, 2005, pp. 22–32.

Web

• https://fr.wikipedia.org/wiki/Syst%C3%A8me_de_recommandation
• https://fr.wikipedia.org/wiki/Racinisation
• https://fr.wikipedia.org/wiki/Intelligence_artificielle
• https://fr.wikipedia.org/wiki/Programmation_logique
• https://fr.wikipedia.org/wiki/Repr%C3%A9sentation_des_connaissances
• https://en.wikipedia.org/wiki/Morphology_(linguistics)
• https://en.wikipedia.org/wiki/Word_embedding
• https://en.wikipedia.org/wiki/Word2vec
• https://fr.wikipedia.org/wiki/Prolog
• https://www.nltk.org/howto/stem.html
• http://www.nltk.org/book/ch05.html
• https://spacy.io/usage/spacy-101
• https://spacy.io/usage/visualizers

Couleurs

• Color Tool - Material Design

Images

• Wikimedia Commons