Analyse Sémantique Latente

Partie 1 : Comprendre l’Idée Derrière LSA

Le Défi du Sens : Synonymes et Polysémie

Imagine que tu cherches des informations sur “l’achat d’une voiture”. Tu trouveras probablement des documents contenant ces mots exacts. Mais qu’en est-il des textes qui parlent d’“acquérir un véhicule”, de “s’offrir une automobile” ou même de “l’investissement dans un nouveau moyen de transport personnel” ? Tous ces termes partagent un sens similaire, mais une simple recherche par mots-clés pourrait les manquer. C’est le problème de la synonymie : des mots différents pour exprimer la même idée.

Inversement, un mot comme “banque” peut avoir plusieurs significations : un établissement financier ou le bord d’une rivière. Si ta recherche porte sur la finance, tu ne voudrais pas être submergé de résultats concernant la géographie ! C’est le défi de la polysémie : un mot avec plusieurs sens.

Ces deux phénomènes rendent parfois difficile pour les ordinateurs (et même pour nous !) de comprendre le véritable sens d’un texte en se basant uniquement sur les mots qu’il contient.

L’Intuition de l’Espace Sémantique

Pour surmonter ces défis, imagine un espace où chaque mot et chaque document ont une position. Les mots et les documents qui sont proches dans cet espace partagent un sens similaire. C’est l’idée d’un espace sémantique.

Pense à un nuancier de couleurs. Le rouge et le cramoisi sont proches l’un de l’autre car ils se ressemblent. Le rouge et le bleu sont plus éloignés car ils sont très différents. De la même manière, dans un espace sémantique, “voiture” et “automobile” seraient plus proches que “voiture” et “arbre”.

L’Idée Clé de LSA : Aller au-delà des Mots

L’Analyse Sémantique Latente (LSA) est une technique qui essaie de construire cet espace sémantique automatiquement à partir d’une collection de textes. L’idée fondamentale est de découvrir les concepts latents (cachés) qui sous-tendent l’utilisation des mots.

Imagine un ensemble d’articles de journaux. Certains parlent de “chats” et de “croquettes”, d’autres de “chiens” et de “laisses”. LSA essaie de déduire qu’il existe des concepts sous-jacents comme “animaux de compagnie” ou “soins des animaux”, même si ces mots exacts ne sont pas toujours présents.

En quelque sorte, LSA agit comme un détective linguistique. Au lieu de se fier uniquement aux indices apparents (les mots), il cherche des indices cachés dans la façon dont les mots co-apparaissent dans différents documents pour déduire le véritable sens.

Dans les prochaines parties de ce tutoriel, nous allons explorer comment LSA fonctionne concrètement pour découvrir ces “concepts cachés” et comment nous pouvons l’utiliser pour mieux comprendre nos textes. Accroche-toi, l’aventure ne fait que commencer !

Excellent ! Reprenons la Partie 2 de notre tutoriel Quarto en utilisant notre nouveau corpus de textes sur le Machine Learning et la Science Physique.

Partie 2 : Préparer nos Textes : De la Parole aux Nombres (avec un Corpus Thématique)

Maintenant que nous avons une idée de ce que LSA essaie d’accomplir, il est temps de comprendre comment nous pouvons donner à LSA des textes à analyser. L’astuce consiste à transformer nos mots en nombres, car les algorithmes adorent les chiffres !

Notre Corpus de Travail Thématique

Pour illustrer les étapes avec un peu plus de contexte, voici un ensemble de 10 textes : 5 sur le Machine Learning et 5 sur la Science Physique.

documents:
  - "L'apprentissage automatique utilise des algorithmes pour extraire des motifs à partir de données."
  - "Le machine learning permet aux ordinateurs d'apprendre sans être explicitement programmés."
  - "Les réseaux de neurones sont une architecture clé du deep learning, une branche de l'apprentissage automatique."
  - "L'entraînement de modèles de machine learning nécessite de grands ensembles de données labellisées."
  - "La classification et la régression sont des tâches fondamentales en apprentissage automatique."
  - "La relativité générale décrit la gravitation comme une courbure de l'espace-temps due à la masse et à l'énergie."
  - "La mécanique quantique étudie le comportement des particules au niveau atomique et subatomique."
  - "L'énergie nucléaire est libérée lors des réactions de fission ou de fusion des noyaux atomiques."
  - "La thermodynamique régit les échanges de chaleur et de travail dans les systèmes physiques."
  - "L'électromagnétisme unifie les forces électriques et magnétiques en une seule interaction fondamentale."

Ce sera notre corpus, une collection de documents qui aborde deux thèmes distincts. L’objectif sera de voir comment LSA peut potentiellement identifier ces thèmes.

Transformer les Textes en Données : La Matrice Terme-Document

L’étape cruciale est de représenter ce corpus sous forme de matrice terme-document. Rappelons qu’il s’agit d’un tableau où les lignes représentent chaque mot unique de notre corpus et les colonnes représentent chaque document. La valeur à l’intersection d’une ligne (terme) et d’une colonne (document) indique l’importance de ce terme dans ce document.

Voici les étapes pour construire cette matrice pour notre corpus thématique :

Tokenisation

Nous commençons par diviser chaque document en mots individuels (tokens). Par exemple :

• “L’apprentissage automatique utilise des algorithmes pour extraire des motifs à partir de données.” \(\rightarrow\) [“L’”, “apprentissage”, “automatique”, “utilise”, “des”, “algorithmes”, “pour”, “extraire”, “des”, “motifs”, “à”, “partir”, “de”, “données.”]
• “La relativité générale décrit la gravitation comme une courbure de l’espace-temps due à la masse et à l’énergie.” \(\rightarrow\) [“La”, “relativité”, “générale”, “décrit”, “la”, “gravitation”, “comme”, “une”, “courbure”, “de”, “l’”, “espace-temps”, “due”, “à”, “la”, “masse”, “et”, “à”, “l’”, “énergie.”]
• Et ainsi de suite pour les 10 documents.

Nettoyage

Ensuite, nous nettoyons ces tokens en supprimant la ponctuation et en mettant tous les mots en minuscules pour uniformiser notre vocabulaire. Par exemple, “L’” et “l’” deviendront “l’”.

Mots Vides (Stop Words)

Nous identifions et supprimons les mots courants sans signification distinctive, comme “le”, “la”, “les”, “des”, “de”, “à”, “pour”, “une”, “est”, etc. Après cette étape, nos listes de tokens seront plus concises et contiendront les mots porteurs de sens.

Pondération des Termes : L’Importance des Mots (TF-IDF)

Comme expliqué précédemment, nous utilisons la méthode TF-IDF (Term Frequency-Inverse Document Frequency) pour évaluer l’importance de chaque terme dans chaque document relativement à l’ensemble du corpus. Un mot qui apparaît fréquemment dans un document mais rarement ailleurs aura un score TF-IDF élevé.

Rappel des formules :

\[IDF(t) = \log \left( \dfrac{N}{df(t)} \right)\]

\[TF\cdot IDF(t, d) = TF(t, d) \times IDF(t)\]

où \(N=10\) dans notre cas (10 documents).

Par exemple, le mot “apprentissage” apparaîtra fréquemment dans les 5 premiers documents (Machine Learning) et rarement dans les 5 derniers (Science Physique), ce qui lui donnera un score TF-IDF potentiellement élevé dans les documents de Machine Learning. Inversement, des mots comme “gravitation” ou “quantique” auront des scores TF-IDF élevés dans les documents de Science Physique. Les mots très courants comme “de” ou “la” auront des scores TF-IDF faibles car ils apparaissent dans de nombreux documents.

Construction de la Matrice Terme-Document

Après avoir calculé les scores TF-IDF pour chaque terme dans chaque document de notre corpus thématique, nous pouvons construire la matrice terme-document. Cette matrice aura en lignes tous les termes uniques de notre corpus (après tokenisation, nettoyage et suppression des stop words) et en colonnes nos 10 documents. La valeur de chaque cellule \((i, j)\) sera le score TF-IDF du terme \(i\) dans le document \(j\).

Cette matrice numérique représente la base de notre analyse sémantique latente. Dans la prochaine partie, nous appliquerons la Décomposition en Valeurs Singulières (SVD) à cette matrice pour essayer de découvrir les “concepts” cachés qui distinguent les textes sur le Machine Learning de ceux sur la Science Physique.

import spacy
from sklearn.feature_extraction.text import TfidfVectorizer

# Charger le modèle de langue de spaCy (vous devrez peut-être le télécharger si ce n'est pas déjà fait)
# python -m spacy download fr_core_news_sm
nlp = spacy.load("fr_core_news_sm")

# Notre corpus thématique
corpus = [
    "L'apprentissage automatique utilise des algorithmes pour extraire des motifs à partir de données.",
    "Le machine learning permet aux ordinateurs d'apprendre sans être explicitement programmés.",
    "Les réseaux de neurones sont une architecture clé du deep learning, une branche de l'apprentissage automatique.",
    "L'entraînement de modèles de machine learning nécessite de grands ensembles de données labellisées.",
    "La classification et la régression sont des tâches fondamentales en apprentissage automatique.",
    "La relativité générale décrit la gravitation comme une courbure de l'espace-temps due à la masse et à l'énergie.",
    "La mécanique quantique étudie le comportement des particules au niveau atomique et subatomique.",
    "L'énergie nucléaire est libérée lors des réactions de fission ou de fusion des noyaux atomiques.",
    "La thermodynamique régit les échanges de chaleur et de travail dans les systèmes physiques.",
    "L'électromagnétisme unifie les forces électriques et magnétiques en une seule interaction fondamentale.",
]

def lemmatize_text(text):
    """Tokenise et lemmatise un texte en utilisant spaCy."""
    doc = nlp(text)
    lemmatized_tokens = [token.lemma_ for token in doc if not token.is_stop and not token.is_punct]
    return " ".join(lemmatized_tokens)

# Lemmatiser chaque document du corpus
lemmatized_corpus = [lemmatize_text(doc) for doc in corpus]

# Initialiser le vectoriseur TF-IDF
tfidf_vectorizer = TfidfVectorizer()

# Calculer la matrice TF-IDF
tfidf_matrix = tfidf_vectorizer.fit_transform(lemmatized_corpus)

# Obtenir les noms des caractéristiques (les lemmes)
feature_names = tfidf_vectorizer.get_feature_names_out()

# Convertir la matrice TF-IDF en un format plus lisible (pour l'inspection)
import pandas as pd
tfidf_df = pd.DataFrame(tfidf_matrix.toarray(), columns=feature_names)

print("Corpus Lemmatisé :")
for i, doc in enumerate(lemmatized_corpus):
    print(f"Document {i+1}: {doc}")

print("\nMatrice TF-IDF :")
print(tfidf_df)

Module 3 : Application de la SVD pour l’Analyse Sémantique Latente (Session 3)

• Réduction de la Dimensionalité avec la SVD Tronquée
  • L’idée de conserver les \(k\) plus grandes valeurs singulières et leurs vecteurs singuliers correspondants.
  • Pourquoi la réduction de la dimensionnalité capture la sémantique latente ?
  • Choix du nombre optimal de dimensions (\(k\)) : Compromis entre perte d’information et réduction du bruit.
  • Visualisation de l’espace sémantique réduit.
• Interprétation des Résultats de LSA
  • Identification des concepts latents à partir des vecteurs singuliers.
  • Similarité sémantique entre termes et entre documents dans l’espace réduit.
  • Utilisation de mesures de similarité (cosinus, etc.).
• Applications Pratiques de LSA
  • Recherche d’information sémantique : Aller au-delà de la correspondance de mots-clés.
  • Recommandation de documents basées sur le contenu sémantique.
  • Clustering de documents par similarité sémantique.

Module 4 : Extensions, Limitations et Mise en Œuvre (Session 4)

• Extensions de LSA
  • LSI (Latent Semantic Indexing) et ses variations.
  • Comparaison avec d’autres techniques de réduction de la dimensionnalité (PCA).
  • Introduction aux modèles de plongement de mots (Word Embeddings) comme alternative moderne.
• Limitations de LSA
  • Sensibilité à la qualité de la matrice terme-document.
  • Difficulté d’interprétation directe des dimensions latentes.
  • Coût computationnel pour de très grands corpus.
• Mise en Œuvre Pratique (si le temps le permet)
  • Présentation de librairies Python (par exemple, scikit-learn, gensim) pour effectuer la SVD et l’LSA.
  • Exemple simple de code pour illustrer les étapes clés.
  • Discussion des considérations pratiques lors de l’application de LSA à des données réelles.

Méthodes Pédagogiques Suggérées

: Exposés interactifs, discussions en groupe, exercices pratiques, études de cas.

Évaluation (Suggérée)

: Participation, exercices, (optionnel) projet.

Exercise 1 (Implémentation de LSA)  

import numpy as np

class LSA:
  def __init__(self)->None:
    return
  
  @classmethod
  def tfIdf(cls, corpus)->np.array:
    """
    Compute Document-Term matrix TF-IDF from a corpus of documents.
    Use scikit-learn library.
    """
    pass
  
  def fit(self, X:np.array)->None:
    """
    Fit LSA
    """
    pass
  
  def plotDocs(self):
    """
    Scatter of documents in the first latent plan.
    """
    pass
  
  def plotTerms(self):
    """
    Scatter of terms in the first latent plan
    """
    pass
  
  def selectDimension(self, threshold:float)->None:
    """
    Select optimal dimension k for a given threshold in ]0, 1[.
    """
    pass
  
  @classmethod
  def similarity(cls, doc1:np.array, doc2:np.array)->float:
    """
    Compute similary fo documents doc1 and doc2.
    """
    pass
  
  def encoder(self, doc:str)->np.array:
    """
    Tranform a doc from natural language to an array of 0-1. 
    """
    pass
  
  def projection(self, doc:np.array):
    """
    Project a document as a vector of 0-1, on the latent space
    """
    pass
  
  def query(self, q:str, p:int=1)->dict:
    """
    Prend une requête q et renvoie les p premiers documents les plus similaires
    dans l'ordre décroissant de similarité.
    
    Return {order: document}
    """
    pass

class Example:
  def __init__(self):
    print("instanciate an object of type Example")
    return
  
  @classmethod
  def hello(cls, nom:str):
    print(f"Hello {nom}")
    return 
  
  def method(self):
    pass