Cours 4 · 2026–2027

L'IA symbolique et certaines applications

Fil rougeChaque application — étiqueter, traduire, recommander, raisonner — choisit entre règles écrites à la main et modèles appris des données.

4.1 · Intelligence artificielle

Où se situent ces applications : IA, apprentissage machine, apprentissage profond

4.1 · Traitement automatique des langues naturelles

Le TAL analyse et comprend le langage humain

4.1 · Traitement automatique des langues naturelles

Sémantique, traduction, entités, sentiments

4.1 · Analyse de systèmes TAL

Quatre traitements de base sur les mots

4.1.1 · Racinisation · [Frakes 2003]

Raciniser, c'est couper les affixes pour garder une racine

4.1.1 · Racinisation

Quand la racine n'est pas un mot : quatre défauts typiques

4.1.1 · Racinisation · évaluation · [Frakes 2003]

Évaluer un raciniseur : sa force et sa similarité à d'autres

4.1.1 · Racinisation · distance de Hamming · [Frakes 2003]

La distance de Hamming compte les positions qui diffèrent

4.1.1 · Racinisation · force · [Frakes 2003]

Cinq mesures de la force

4.1.1 · Racinisation · similarité · [Frakes 2003]

Deux raciniseurs sont similaires si leurs racines sont proches

4.1.1 · Racinisation · nltk

Deux raciniseurs de NLTK : Porter et Snowball

4.1.1 · Porter

L'algorithme de Porter en trois phases

4.1.1 · Porter · règles

Supprimer ou traiter les suffixes

4.1.1 · Porter · règles

Transformer, raccourcir, dédoubler

4.1.1 · Racinisation · Porter · nltk

Porter en cinq lignes

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

4.1.1 · Snowball

Snowball : Porter rendu modulaire et multilingue

4.1.1 · Snowball

Extensible, par étapes de règles, itératif

4.1.1 · Racinisation · Snowball · nltk

Snowball, même sortie sur ces cinq mots

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

À retenirRaciniser coupe des suffixes sans dictionnaire : rapide, mais « university » et « universe » donnent tous deux « univers ».

4.1.2 · Étiquetage morpho-syntaxique · [Màrquez 2000]

Chaque mot reçoit une balise selon son rôle grammatical et son contexte

4.1.2 · Étiquetage morpho-syntaxique · [Màrquez 2000]

Quatre balises et leurs exemples

4.1.2 · Construction de modèles linguistiques

Trois façons de construire un modèle : à la main, par les statistiques, par apprentissage

4.1.2 · nltk · ngrams

Découper une phrase en n-grammes

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=" ")

1-grams
('He',) ('went',) ('to',) ('school',) …
2-grams
('He', 'went') ('went', 'to') ('to', 'school') …
3-grams
('He', 'went', 'to') ('went', 'to', 'school') …
4-grams
('He', 'went', 'to', 'school') …

4.1.2 · nltk · ngrams

Les n-grammes de la phrase, au complet

LectureUn modèle n-gramme estime P(mot | n−1 mots précédents) en comptant ces fenêtres dans un grand corpus.

4.1.2 · nltk · pos_tag

pos_tag étiquette chaque token

from nltk import pos_tag, word_tokenize
sentence = "He goes to school daily"
tokens = word_tokenize(sentence)
print(pos_tag(tokens))

4.1.2 · nltk · pos_tag

Lire les balises du Penn Treebank

4.1.2 · spaCy

spaCy : installer un modèle, le charger, analyser

# Installation
$ pip3 install spacy
$ python3 -m spacy download en_core_web_sm

# Usage
import spacy
nlp = spacy.load("en_core_web_sm")

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

4.1.2 · spaCy

Un token porte lemme, PoS, balise fine, dépendance, forme, mot vide

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)

4.1.3 · Lemmatisation · [Gesmundo 2012]

Lemmatiser : regrouper les formes fléchies sous leur lemme

4.1.3 · Lemmatisation · [Chrupała 2006, Gesmundo 2012]

La lemmatisation comme une tâche d'étiquetage : une transformation en quatre nombres

4.1.3 · nltk · WordNetLemmatizer

WordNet : une base lexicale de synsets, et son lemmatiseur

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

4.1.3 · nltk · WordNetLemmatizer

Sans balise PoS, le lemmatiseur suppose que tout est un nom

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=' ')

He went to school yesterday and attended the class

4.1.3 · nltk · WordNetLemmatizer

Avec les balises PoS : convertir Penn Treebank vers WordNet

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

4.1.3 · nltk · WordNetLemmatizer

Étiqueter d'abord, lemmatiser ensuite

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=' ')

I go to school today and he go daily

À retenirLemmatiser rend le mot du dictionnaire (« était » → « être ») ; il faut connaître la catégorie grammaticale, donc étiqueter d'abord.

4.1.3 · spaCy · lemme

spaCy lemmatise en une ligne, PoS compris

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

4.1.4 · Morphologie

La morphologie lexicale étudie la forme et la structure des mots

4.1.4 · spaCy · displaCy

Visualiser l'arbre de dépendances avec displaCy

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)

4.2 · Word Embeddings

Un embedding : chaque mot devient un vecteur dense, les voisins ont un sens voisin

4.2 · Word Embeddings

Deux avantages : dense plutôt que creux, et sémantique

4.2 · Word Embeddings

Applications — et la limite des embeddings statiques

LimiteUn vecteur unique par mot, quel que soit le contexte (« avocat » le fruit ou le métier). Les embeddings contextuels des Transformers (BERT, voir 4.7) donnent un vecteur différent à chaque occurrence et ont supplanté les embeddings statiques depuis 2018.

4.2 · spaCy

spaCy : une bibliothèque NLP rapide, précise, facile

4.2 · spaCy

Évaluer, empaqueter, télécharger : le cycle d'un modèle spaCy

# Installation du modèle spaCy (en_core_web_lg)
$ python3 -m spacy download en_core_web_lg

# Chargement du modèle spaCy
import spacy
nlp = spacy.load("en_core_web_lg")

Repèreen_core_web_lg est un modèle vectoriel large d'anglais ; spaCy en propose pour différentes langues et tâches.

4.2 · spaCy

Cinq avantages de spaCy

4.2 · spaCy

Quatre limites de spaCy

4.2 · spaCy · similarity

Comparer des mots deux à deux avec 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))

4.2 · spaCy · vector

Le vecteur d'un token, et ce qu'en fait la similarité cosinus

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))

À retenirUn mot = un vecteur ; la similarité cosinus entre vecteurs approxime la similarité de sens.

4.3 · Word2Vec · [Mikolov 2013]

Word2Vec : un réseau apprend un vecteur par mot à partir d'un corpus

4.3 · Word2Vec · [Mikolov 2013]

Implémenter Word2Vec : six étapes

4.3 · Word2Vec

Contextes communs, vecteurs voisins

4.3.1 · Context Bag of Words (CBOW)

CBOW prédit le mot courant à partir de ses voisins, sans tenir compte de l'ordre

Word2Vec

Un modèle spécifique de Word2Vec

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.

prédictif

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.

4.3.1 · Context Bag of Words (CBOW)

CBOW : entrée, architecture, entraînement, sortie, avantages

fenêtre

Entrée

Une fenêtre de mots contextuels entourant le mot cible, définie par un paramètre appelé la taille de la fenêtre.

une couche cachée

Architecture

Un réseau neuronal à une seule couche cachée : la couche d'entrée représente les mots du contexte, la couche de sortie le mot cible à prédire.

rétropropagation

Entraînement

Ajuster les poids du réseau pour minimiser la différence entre les prédictions et le mot cible réel, par rétropropagation du gradient.

embeddings

Sortie

Une fois entraîné, les poids de la couche d'entrée sont utilisés comme embeddings de mots : chaque mot est un vecteur dans un espace continu.

4.3.1 · gensim · CBOW

Entraîner un CBOW avec gensim : sg=0

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)

4.3.1 · gensim · CBOW

Lire le modèle : vecteur, similarité, mots les plus proches

# 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)

4.3.2 · Skip-grams

Skip-gram fait l'inverse : du mot courant vers ses voisins

objectif

Prédire la fenêtre voisine

Le modèle Skip-gram, autre variante de Word2Vec, prend un mot source (le mot courant) et prédit les mots qui l'entourent dans une fenêtre de contexte donnée.

entrée

Le mot source

Le mot source est la donnée d'entrée du modèle ; la sortie souhaitée est la distribution des probabilités des mots du contexte.

4.3.2 · Skip-grams

Skip-gram : architecture, entraînement, pondération, embeddings

une couche cachée

Architecture

Un réseau à une seule couche cachée : la couche d'entrée représente le mot source, la couche de sortie les mots du contexte.

rétropropagation

Entraînement

Les poids sont ajustés pour minimiser la différence entre les prédictions et la véritable distribution des mots du contexte.

proximité

Pondération du contexte

L'architecture accorde plus de poids aux mots de contexte proches du mot source qu'à ceux plus éloignés : mieux capturer les relations locales.

embeddings

Embeddings

Une fois entraîné, les poids de la couche d'entrée sont les embeddings de mots, qui capturent les similitudes sémantiques.

4.3.2 · gensim · Skip-gram

Entraîner un Skip-gram avec gensim : sg=1

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)

4.3.2 · gensim · Skip-gram

Interroger le 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)

À retenirCBOW prédit le mot à partir du contexte, skip-gram le contexte à partir du mot ; les vecteurs sont un sous-produit de cette tâche.

4.4 · Reconnaissance d'entités nommées

La NER extrait des entités typées d'un texte non structuré

NER · Named Entity Recognition

Identifier et classer

La reconnaissance d'entités nommées consiste à identifier et classer des entités spécifiques dans un texte : personnes, lieux, organisations, dates, montants monétaires, etc.

Le but est d'extraire des informations structurées à partir de données textuelles non structurées.

4.4 · Reconnaissance d'entités nommées

Identifier, classer, contextualiser

4.4 · Reconnaissance d'entités nommées

Relations entre entités, et à quoi sert la NER

4.4 · NER · algorithmes

Des HMM aux réseaux de neurones et aux Transformers

4.4 · NER · algorithmes

Modèles statistiques, règles, entraînement supervisé

4.4 · spaCy · NER

Analyser un texte, puis parcourir doc.ents

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)

# 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))

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

4.4 · spaCy · displaCy

Visualiser les entités : serve() dans un navigateur, render() dans un notebook

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)

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)

4.4 · spaCy · NER

Le rendu displaCy, et le sens des trois balises

À retenirLa NER étiquette chaque token (B-PER, I-PER, O…) : un problème de séquence, d'où les RNN puis BERT.

4.5 · Analyse des sentiments · VADER

VADER : un lexique qui note la positivité, la négativité et la neutralité

# Installation
import nltk
nltk.download('vader_lexicon')

4.5 · VADER

Dictionnaire, polarité, modificateurs

4.5 · VADER

Un score composé entre −1 et 1

4.5 · VADER · usage

Trois phrases, trois dictionnaires de scores

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)

{'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}

4.5 · VADER · scores

Lire les quatre scores

ÉchelleDe −1 (extrêmement négatif) à 1 (extrêmement positif), 0 la neutralité ; les scores s'interprètent individuellement ou conjointement.

4.5 · Avec un modèle Transformer

La même tâche avec un Transformer pré-entraîné

from transformers import pipeline
modele = "distilbert-base-uncased-finetuned-sst-2-english"
classifier = pipeline("sentiment-analysis", model=modele)
print(classifier("this movie is good"))
# [{'label': 'POSITIVE', 'score': 0.9998}]
print(classifier("this movie is not very good"))
# [{'label': 'NEGATIVE', 'score': 0.9995}]

À retenirVADER : rapide et transparent ; Transformer : plus précis et multilingue, mais opaque et coûteux.

4.6 · Traduction automatique

Traduire par des règles, ou par des statistiques

4.6 · Traduction automatique

Hybride, puis apprentissage machine

4.6 · Traduction automatique

Soixante-dix ans de traduction automatique

À retenirChaque ère a remplacé la précédente en apprenant davantage à partir des données et en écrivant moins de règles à la main.

4.6 · Traduction automatique · apprentissage machine

Traduction neuronale : des données parallèles et un modèle séquence à séquence

4.6 · Traduction automatique · apprentissage machine

Encoder la source, décoder la cible

4.6 · Traduction automatique · apprentissage machine

Évaluer, ajuster, puis ajouter l'attention

À retenirTraduire = encoder la source, décoder la cible ; l'attention décide, pour chaque mot produit, quels mots sources regarder.

4.7 · Modèles de langage Transformer

Le Transformer, 2017 : l'architecture qui a révolutionné le TAL

4.7 · Modèles de langage Transformer

Trois familles, un même bloc d'attention

À retenirMême brique (attention multi-tête), trois masques : BERT voit toute la phrase, GPT ne voit que le passé, l'encodeur-décodeur lit la source en entier et écrit la cible mot à mot.

4.7 · BERT

BERT lit dans les deux sens

4.7 · BERT · composants

Les composants de BERT (1/3) : les embeddings

4.7 · BERT · composants

Les composants de BERT (2/3) : l'encodeur et l'attention multi-tête

4.7 · BERT · composants

Les composants de BERT (3/3) : pooling, classification, fine-tuning

4.7 · BERT · fonctionnement

BERT en marche (1/2) : prétraiter, encoder, pré-entraîner

4.7 · BERT · fonctionnement

BERT en marche (2/2) : fine-tuner, utiliser, gérer la longueur

4.7 · GPT

GPT prédit le mot suivant — et donc génère

4.7 · GPT · composants

Les composants de GPT (1/2) : embeddings, positions, décodeur seul

4.7 · GPT · composants

Les composants de GPT (2/2) : attention, masque, tête de langage, fine-tuning

4.7 · GPT · fonctionnement

GPT en marche (1/2) : pré-entraîner, encoder, décoder

4.7 · GPT · fonctionnement

GPT en marche (2/2) : attention, génération, adaptation, longueur

4.7 · BERT vs GPT

BERT contre GPT (1/2) : objectif, architecture, fine-tuning

4.7 · BERT vs GPT

BERT contre GPT (2/2) : contexte, applications, taille

À retenirEncodeur seul (BERT) pour comprendre, décodeur seul (GPT) pour générer, encodeur-décodeur (T5, BART) pour traduire.

4.8 · Systèmes de recommandation

Un système de recommandation filtre la surcharge d'informations

4.8 · Systèmes de recommandation

Deux types de recommandations, trois familles d'algorithmes

4.8 · Systèmes de recommandation

Playlists, produits, livres, réseaux sociaux

4.8 · Réalisation · [Pazzani 2007, Ricci 2011]

L'hypothèse : les gens suivent les recommandations des autres

4.8 · Réalisation

Collecter les préférences : explicites ou déduites des actions

4.8 · Fonctions · [Ricci 2011]

Cinq fonctions d'un système de recommandation

4.8 · Objectifs · [Herlocker 2000, Ricci 2011]

Objectifs (1/3) : trouver de bons objets, ou tous les bons

4.8 · Objectifs · [Herlocker 2000, Ricci 2011]

Objectifs (2/3) : contexte, séquence, combinaison ; navigation et profil

4.8 · Objectifs · [Herlocker 2000, Ricci 2011]

Objectifs (3/3) : l'interaction sociale

4.8 · Approches · [Pazzani 2007, Ricci 2011]

Six approches (1/2) : collaboratif, contenu, démographique

4.8 · Approches · [Pazzani 2007, Ricci 2011]

Six approches (2/2) : connaissance, communauté, hybride

4.8 · Filtrage collaboratif

Le filtrage collaboratif s'appuie sur les transactions

4.8 · Filtrage collaboratif

Collaboratif : personnalisé et révélateur, mais fragile au démarrage

4.8 · Filtrage basé sur le contenu · [Pazzani 2007]

Le contenu : décrire les objets, modéliser les intérêts

4.8 · Filtrage basé sur le contenu · [Pazzani 2007]

Trois algorithmes pour apprendre un profil

4.8 · Filtrage basé sur le contenu · [Pazzani 2007]

Contenu : bon au démarrage, mais peu de surprises

4.8 · Systèmes hybrides · [Gomez-Uribe 2016]

Hybride : combiner contenu, collaboratif et démographie

4.8 · Mesures de performance · [Ziegler 2005, Ricci 2011]

Mesurer un système de recommandation (1/2)

4.8 · Mesures de performance · [Ziegler 2005, Ricci 2011]

Mesurer un système de recommandation (2/2)

4.8 · Domaines à haut risque · [Herlocker 2000]

Quand une mauvaise recommandation coûte cher, il faut expliquer

4.8 · Domaines à haut risque · [Herlocker 2000]

Quatre avantages des explications

À retenirCollaboratif : « les gens comme vous ont aimé » ; contenu : « ressemble à ce que vous aimez » ; le réel combine les deux.

4.9 · Représentation des connaissances et raisonnement

KRR : rendre la connaissance lisible par une machine, puis raisonner dessus

4.9 · Représentation des connaissances et raisonnement

Deux exemples de représentation : réseaux sémantiques et ontologies

4.9 · Représentation des connaissances et raisonnement

Raisonner, et le compromis expressivité contre praticité

À retenirExpressivité contre efficacité : le formalisme le plus riche n'est pas celui qu'on peut interroger le plus vite.

4.10 · Web sémantique

La pile du web sémantique

4.10 · Web sémantique

La vision de Tim Berners-Lee : un web que les machines comprennent

4.10 · Web sémantique

RDF, RDFS, OWL, SPARQL : décrire, structurer, définir, interroger

4.10 · Web sémantique

RDFa, microformats, Linked Data : mettre la sémantique dans les pages et entre les jeux de données

4.10 · Web sémantique

RIF et Unifying Logic : des règles et une logique commune

4.10 · Web sémantique

Au sommet : preuve, confiance, applications

À retenirRDF pour les faits, RDFS/OWL pour le vocabulaire, SPARQL pour interroger : Wikidata en est l'exemple grandeur nature.

4.11 · Moteur de règles

Un moteur de règles applique des règles et des contraintes à des données

4.11 · Moteur de règles

Évaluer, agir, rester cohérent, recommencer

UsagesGestion des workflows, logique métier, systèmes d'alerte : une approche déclarative pour spécifier la logique métier sans programmation explicite.

4.11 · Moteur de règles · applications

Workflows, alertes, logique métier

4.11 · Moteur de règles · applications

Chaîne d'approvisionnement, tarification, fraude, demandes

4.11 · Moteur de règles · langages

Cinq langages et un algorithme : Drools, RuleML, Jess, CLIPS, Rete

À retenirUn moteur de règles sépare le « quoi » (règles métier, modifiables) du « comment » (l'algorithme d'inférence).

4.11 · Moteur de règles · logiciels

Sept logiciels de gestion de règles métier

4.12 · Programmation logique et IA

La programmation logique repose sur la logique propositionnelle et du premier ordre

4.12 · Prolog

Prolog : décrire des relations plutôt que des étapes

4.12 · Prolog

Exécuter une requête, c'est chercher des solutions aux relations

4.12 · Prolog · types de données

Atomes et nombres

animal(chien).
couleur(rouge).

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

4.12 · Prolog · types de données

Variables et termes composés

personne(X).

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

4.12 · Prolog · règles et faits

Une règle : Tête :- Corps. Un fait : une règle sans corps

personne(bob).
personne(alice).

4.12 · Prolog · installation

GNU Prolog : un compilateur ISO Prolog

# L'installation de gprolog sur une machine Ubuntu
$ sudo apt install gprolog

4.12 · Prolog · GNU Prolog

Saisir des faits dans l'interpréteur : [user]

$ prolog
GNU Prolog 1.4.5 (64 bits)
Compiled Feb  5 2017, 10:30:08 with gcc
By Daniel Diaz
Copyright (C) 1999-2016 Daniel Diaz
| ?- [user].
compiling user for byte code...
personne(tom).
personne(alice).
user compiled, 2 lines read - 241 bytes written, 12239 ms

(4 ms) yes
| ?-

4.12 · Prolog · interrogation

Interroger : une variable se lie, un fait absent répond « no »

?- personne(X).
X = tom ?

yes
| ?- cat(bob).
no

4.12 · Prolog · interrogation

findall : collecter toutes les solutions dans une liste

| ?- [user].
compiling user for byte code...
personne(tom).
personne(alice).
personnes(L) :- findall(X, personne(X), L).
user compiled, 3 lines read - 490 bytes written, 10638 ms

yes
| ?- personnes(L).
L = [tom,alice]

yes

4.12 · Prolog · interrogation

Plusieurs solutions : « a » les affiche toutes

| ?- [user].
compiling user for byte code...
friend(bob, alice).
friend(alice, kevin).
friend(bob, thomas).
friend(bob, peter).
user compiled, 4 lines read - 486 bytes written, 77256 ms

(10 ms) yes
| ?- friend(bob, X).
X = alice ? a
X = thomas
X = peter

(1 ms) yes

4.12 · Prolog · fichier

Un fichier friend.pl avec deux règles pour human/1

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

4.12 · Prolog · fichier

Consulter un fichier au lancement, puis interroger

$ 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 --consult-file friend.pl
| ?- human(X).
X = bob ? a
X = alice
X = bob
X = bob
X = alice
X = kevin
X = thomas
X = peter

yes
| ?-

Remarque« bob » apparaît trois fois : une solution par preuve, pas par valeur — Prolog ne dédoublonne pas (setof le ferait).

4.12 · Prolog · récursion

ancetre/2 : une règle récursive

$ 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).

4.12 · Prolog · récursion

Tous les descendants de kevin, par récursion et retour arrière

$ prolog --consult-file ancetre.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
| ?-

4.12 · Prolog · listes et arithmétique

notes.pl : des faits, puis une moyenne calculée avec findall

/* 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.

/* 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.

Lecture[X|Xs] sépare la tête de la queue d'une liste ; is évalue une expression arithmétique.

4.12 · Prolog · listes et arithmétique

afficher_moyennes : setof, member, format, et l'astuce du fail

/* 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 --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
| ?-

À retenirEn Prolog on décrit ce qui est vrai ; l'unification et le retour arrière trouvent comment le prouver.

Références

Articles de recherche (1/2)

Références

Articles de recherche (2/2)

Références · Web

Sur le web

CréditsImages : Wikimedia Commons · Couleurs : Material Design Color Tool · Licence CC BY-SA 4.0.