Tu as une semaine pour réviser les moteurs de recherche en NSI ? Pas de panique. Avec un plan clair et des exercices ciblés, tu peux comprendre en profondeur le fonctionnement des moteurs comme Google, le PageRank, l'indexation inversée et les algorithmes de classement. Cet article te guide jour par jour pour être prêt le jour J.
Jour 1 : Comprendre l'architecture d'un moteur de recherche
Un moteur de recherche repose sur trois étapes principales : le crawling (exploration du web), l'indexation (organisation des pages) et le ranking (classement des résultats). En NSI, on s'intéresse surtout aux algorithmes derrière ces étapes.
Crawling et indexation
Le crawler parcourt les pages web en suivant les liens. Il récupère le contenu textuel et le stocke dans une structure de données appelée index inversé. Un index inversé associe chaque mot à la liste des documents qui le contiennent. Par exemple :
index = {
"chat": ["doc1", "doc3"],
"chien": ["doc2", "doc3"]
}Pour construire un index inversé en Python :
def construire_index(documents):
index = {}
for doc_id, texte in documents.items():
mots = set(texte.lower().split())
for mot in mots:
if mot not in index:
index[mot] = []
index[mot].append(doc_id)
return index
docs = {"doc1": "Le chat dort", "doc2": "Le chien court", "doc3": "Le chat et le chien"}
print(construire_index(docs))
# {'le': ['doc1', 'doc2', 'doc3'], 'chat': ['doc1', 'doc3'], 'dort': ['doc1'], 'chien': ['doc2', 'doc3'], 'court': ['doc2'], 'et': ['doc3']}Jour 2 : L'algorithme PageRank
Le PageRank est un algorithme inventé par Larry Page et Sergey Brin pour classer les pages web selon leur importance. Il repose sur l'idée qu'une page est importante si beaucoup de pages importantes pointent vers elle. En NSI, on étudie sa version simplifiée avec des itérations.
Principe mathématique
Chaque page a un score initial (souvent 1/N). À chaque itération, le score se redistribue via les liens sortants. On ajoute un facteur d'amortissement d (souvent 0.85) pour éviter les impasses. La formule :
PR(p) = (1-d)/N + d * somme(PR(q)/L(q)) pour chaque q qui pointe vers poù L(q) est le nombre de liens sortants de q.
Implémentation Python simple
def pagerank(graphe, d=0.85, iterations=10):
n = len(graphe)
pr = {page: 1/n for page in graphe}
for _ in range(iterations):
nouveau_pr = {}
for page in graphe:
somme = 0
for autre in graphe:
if page in graphe[autre]:
somme += pr[autre] / len(graphe[autre])
nouveau_pr[page] = (1-d)/n + d * somme
pr = nouveau_pr
return pr
graphe = {
'A': ['B', 'C'],
'B': ['C'],
'C': ['A'],
'D': ['C']
}
print(pagerank(graphe))
# Exemple de sortie : {'A': 0.368, 'B': 0.142, 'C': 0.368, 'D': 0.122}Jour 3 : Pondération TF-IDF
Le TF-IDF (Term Frequency – Inverse Document Frequency) est une mesure statistique qui évalue l'importance d'un mot dans un document par rapport à une collection. Il est utilisé pour le ranking dans les moteurs de recherche.
Calcul du TF-IDF
- TF = (nombre d'occurrences du mot dans le document) / (nombre total de mots dans le document)
- IDF = log(N / nombre de documents contenant le mot) où N est le nombre total de documents
- TF-IDF = TF * IDF
Exemple en Python :
import math
def tf_idf(documents):
N = len(documents)
idf = {}
for doc in documents:
mots = set(doc.split())
for mot in mots:
idf[mot] = idf.get(mot, 0) + 1
for mot in idf:
idf[mot] = math.log(N / idf[mot])
resultats = []
for doc in documents:
mots = doc.split()
tf = {}
for mot in mots:
tf[mot] = tf.get(mot, 0) + 1
for mot in tf:
tf[mot] /= len(mots)
tfidf = {mot: tf[mot] * idf.get(mot, 0) for mot in tf}
resultats.append(tfidf)
return resultats
docs = ["le chat dort", "le chien court", "le chat et le chien"]
print(tf_idf(docs))Jour 4 : Mise en pratique avec un mini moteur de recherche
Construis un mini moteur de recherche combinant index inversé et PageRank. Tu peux utiliser une petite collection de pages web factices (fichiers HTML). Entraîne-toi à écrire les requêtes et à classer les résultats. Pour t'aider, consulte le cours NSI sur le site : https://www.nsi-lycee.fr/cours.
Jour 5 : Exercices type bac et évaluations
Révise avec des exercices sur les algorithmes de recherche. Le site https://www.nsi-lycee.fr/exercices propose des QCM et des problèmes corrigés. Entraîne-toi aussi sur des sujets de bac : analyse d'un algorithme PageRank, calcul de TF-IDF, index inversé.
Jour 6 : Approfondissement et notions avancées
Explore des notions comme le web crawling avec gestion de la politesse (delay entre requêtes), le PageRank personnalisé, ou encore le HITS (Hyperlink-Induced Topic Search). Si tu veux aller plus loin, regarde les ressources sur AlloBac et AlloLycée.
Jour 7 : Synthèse et simulation d'épreuve
Réalise une synthèse sous forme de fiche mémo. Simule une épreuve écrite de 30 minutes : décris l'architecture d'un moteur de recherche, explique le PageRank, code un index inversé. Relis tes notes et vérifie que tu maîtrises les termes clés : crawl, index, PageRank, TF-IDF, requête, pertinence.
Conseils pour le bac NSI
À l'épreuve, on te demandera souvent de comprendre un algorithme existant plutôt que de l'inventer. Entraîne-toi à lire du code Python et à expliquer son fonctionnement. N'oublie pas de mentionner les structures de données (dictionnaires, listes) et les complexités. Pour réviser les bases de données liées aux moteurs de recherche, consulte https://www.nsi-lycee.fr/sql.
Conclusion
En une semaine, tu peux acquérir une solide compréhension des moteurs de recherche en NSI. L'essentiel est de pratiquer régulièrement : code chaque algorithme, teste-le, modifie-le. Tu verras, les concepts deviennent vite familiers. Bon courage, tu es capable !
