Qu'est-ce qu'un index inversé dans un moteur de recherche ?

Un index inversé est une structure de données qui associe chaque mot à la liste des documents qui le contiennent. Cela permet une recherche rapide par mot-clé, contrairement à une recherche séquentielle dans tous les documents.

Le PageRank est-il encore utilisé par Google ?

Oui, le PageRank fait toujours partie des nombreux signaux utilisés par Google, mais il n'est plus le seul critère de classement. Google utilise aujourd'hui des centaines de facteurs pour classer les pages.

Comment implémenter un moteur de recherche simple en Python ?

On peut construire un index inversé avec un dictionnaire Python, puis pour une requête, récupérer les listes de documents correspondant à chaque mot et les intersecter. On peut ensuite classer les résultats avec TF-IDF.

Qu'est-ce que le TF-IDF et à quoi sert-il ?

TF-IDF (Term Frequency – Inverse Document Frequency) est une mesure statistique qui évalue l'importance d'un mot dans un document par rapport à un corpus. Plus un mot est rare dans le corpus mais fréquent dans un document, plus son poids est élevé.

Quels sont les pièges courants sur les moteurs de recherche en NSI ?

Les pièges fréquents sont : confondre indexation et recherche, croire que PageRank est l'unique critère, négliger l'index inversé, oublier le traitement des requêtes (stop words, stemming), sous-estimer la pertinence (TF-IDF) et ignorer l'évaluation des performances.

Les pièges à éviter sur les algorithmes des moteurs de recherche en NSI

Tu travailles sur le thème des moteurs de recherche en NSI ? Entre le PageRank, l'indexation et les requêtes, il y a pas mal de pièges dans lesquels les lycéens tombent souvent. Pas de panique : dans cet article, on va voir ensemble les erreurs les plus fréquentes et comment les éviter. Prêt à devenir un pro des algorithmes de recherche ? C'est parti !

Piège n°1 : Confondre indexation et recherche

Beaucoup d'élèves pensent qu'un moteur de recherche parcourt tout le web à chaque requête. En réalité, il utilise un index inversé construit lors de l'indexation. L'indexation est une phase préalable où le moteur explore les pages (grâce à des robots) et crée une structure de données qui associe chaque mot aux pages qui le contiennent. La recherche se fait ensuite dans cet index, pas sur le web en direct.

Pour t'en souvenir, imagine une bibliothèque : l'indexation c'est le classement des livres par thème, la recherche c'est consulter le catalogue. Sans index, ta requête mettrait des heures.

Piège n°2 : Croire que PageRank est le seul critère de classement

Le PageRank est un algorithme célèbre de Google, mais ce n'est plus le seul. Il mesure l'importance d'une page en comptant le nombre et la qualité des liens entrants. Cependant, les moteurs modernes utilisent des centaines de signaux : pertinence du contenu, fraîcheur, localisation, etc. En NSI, on étudie souvent le PageRank comme exemple d'algorithme de graphe, mais ne tombe pas dans le piège de penser qu'il explique tout le classement.

Exemple simplifié de PageRank en Python

Voici un petit code pour calculer le PageRank d'un graphe de pages (version itérative simple) :

import numpy as np

def pagerank(M, d=0.85, tol=1e-6, max_iter=100):
    n = M.shape[0]
    r = np.ones(n) / n
    for _ in range(max_iter):
        r_new = (1 - d) / n + d * M.T @ r
        if np.linalg.norm(r_new - r) < tol:
            break
        r = r_new
    return r

# Exemple : 3 pages A, B, C
# Matrice de transition (ligne i -> colonne j : proba d'aller de i à j)
M = np.array([[0, 1, 0],
              [0.5, 0, 0.5],
              [0, 1, 0]])
print(pagerank(M))
# Résultat approximatif : [0.15, 0.69, 0.15]

Ce code montre bien que le PageRank distribue l'importance via les liens. Mais retiens que ce n'est qu'un modèle pédagogique.

Piège n°3 : Négliger la structure des données (index inversé)

En NSI, on te demande souvent d'implémenter un petit moteur de recherche. L'erreur classique est de stocker les données de façon naïve (liste de mots par page). La solution efficace est l'index inversé : un dictionnaire dont la clé est un mot et la valeur la liste des documents contenant ce mot. Cela permet une recherche en O(1) par mot.

Exemple :

documents = {
    'doc1': 'le chat mange la souris',
    'doc2': 'la souris mange le fromage'
}
# Construction de l'index inversé
index = {}
for doc_id, text in documents.items():
    for word in text.split():
        index.setdefault(word, []).append(doc_id)
print(index)
# {'le': ['doc1','doc2'], 'chat': ['doc1'], ...}

Pour une requête "chat souris", tu peux intersecter les listes de 'chat' et 'souris'. Simple et rapide.

Piège n°4 : Oublier le traitement des requêtes (tokenisation, stop words)

Une requête brute ne donne pas de bons résultats. Il faut la tokeniser (découper en mots), supprimer les stop words (mots très fréquents comme "le", "la", "de") et éventuellement appliquer une racinisation (stemming) pour traiter les variations (ex: "manger", "mange"). En NSI, on simplifie souvent, mais n'oublie pas ces étapes dans tes projets.

Piège n°5 : Sous-estimer l'importance de la pertinence (TF-IDF)

Classer les résultats seulement par présence de mots-clés ne suffit pas. L'algorithme TF-IDF (Term Frequency – Inverse Document Frequency) permet de mesurer l'importance d'un mot dans un document par rapport à l'ensemble de la collection. Un mot rare dans le corpus mais fréquent dans un document est plus significatif. En NSI, tu peux l'implémenter facilement :

from math import log

def tf(word, doc):
    return doc.count(word) / len(doc)

def idf(word, docs):
    n = sum(1 for doc in docs if word in doc)
    return log(len(docs) / (1 + n))

def tfidf(word, doc, docs):
    return tf(word, doc) * idf(word, docs)

N'oublie pas que TF-IDF n'est qu'un exemple ; les moteurs modernes utilisent des modèles plus complexes comme BM25.

Piège n°6 : Ignorer l'évaluation des performances

Quand tu codes un algorithme de recherche, il faut tester sa rapidité et sa pertinence. Beaucoup d'élèves ne mesurent pas le temps d'exécution ou ne comparent pas leurs résultats avec une référence. Utilise timeit en Python et pense à des métriques comme la précision et le rappel (si tu as des jugements de pertinence). Pour le bac NSI, on peut te demander d'analyser la complexité de ton algorithme.

Cas d'usage concret : construire un mini-moteur de recherche

Pour t'entraîner, tu peux créer un petit moteur de recherche sur un corpus de textes (par exemple des résumés de cours). Commence par l'indexation inversée, puis implémente une fonction de requête avec classement TF-IDF. Ensuite, ajoute une gestion des stop words. Enfin, mesure le temps de réponse. C'est un excellent projet pour le bac NSI.

Tu trouveras des exercices similaires sur notre page d'exercices et des compléments de cours sur les cours NSI. Si tu as besoin d'aide en SQL pour gérer une base de documents, consulte cette ressource.

Conseils pour le bac NSI

Dans les épreuves, on peut te demander d'expliquer le fonctionnement d'un moteur de recherche, de coder un PageRank simplifié ou d'analyser un index inversé. Voici quelques conseils :

Maîtrise le vocabulaire : indexation, crawling, PageRank, TF-IDF, stop words.
Entraîne-toi sur des petits exemples : écris à la main l'index de 3 documents.
Révise les graphes : le PageRank est un algorithme sur graphe, donc revois les notions de matrice d'adjacence et de vecteur propre.
Ne néglige pas l'algorithmique : complexité, structures de données (dictionnaires, listes).

Pour approfondir, tu peux aussi consulter AlloBac ou AlloLycée pour des fiches de révision.

Conclusion

Les moteurs de recherche sont un thème passionnant en NSI, mais ils cachent des pièges. Retiens bien les différences entre indexation et recherche, ne surestime pas le PageRank, et n'oublie pas le traitement des requêtes ni la pertinence. Avec ces conseils, tu es paré pour briller en cours et au bac. Continue à coder, à expérimenter, et surtout, amuse-toi !