Projet NSI : creer un moteur de recherche simplifie

Pourquoi coder un moteur de recherche en NSI ?

Tu utilises Google tous les jours, mais sais-tu comment il fonctionne vraiment ? Coder un moteur de recherche simplifie est un projet NSI parfait pour comprendre les algorithmes qui regissent le web. Ce projet te permettra de manipuler des structures de donnees complexes (dictionnaires, listes), d'appliquer des algorithmes de traitement de texte et de mettre en œuvre des concepts mathematiques comme le TF-IDF. C'est une excellente facon de synthetiser tes connaissances en Python et en algorithmique, tout en creant un programme concret et impressionnant pour ton portfolio.

Les etapes cles de la construction

Notre moteur de recherche ne va pas scanner tout Internet, mais une petite collection de documents texte (comme des articles, des resumes de livres ou des pages web sauvegardees). Le processus se decompose en trois grandes phases :

1. L'indexation des documents

C'est la phase la plus importante. L'objectif est de creer une structure de donnees, appelee index inversé, qui nous permet de trouver rapidement les documents contenant un mot. Au lieu de stocker "document -> mots", on stocke "mot -> documents".

• Tokenisation : On decoupe le texte de chaque document en mots individuels (tokens).
• Nettoyage : On supprime la ponctuation, on met tout en minuscules et on enleve les mots vides ("le", "de", "un", etc.) qui n'ont pas de valeur pour la recherche.
• Creation de l'index : Pour chaque mot unique, on enregistre dans un dictionnaire Python la liste des documents ou il apparait, et souvent le nombre d'occurrences.

Voici un exemple simplifie d'index inversé :

{ "python": {"doc1.txt": 5, "doc3.txt": 2}, "algorithme": {"doc2.txt": 3, "doc3.txt": 1} }

2. Le calcul de la pertinence avec TF-IDF

Lorsqu'un utilisateur fait une recherche, il ne veut pas juste une liste de documents contenant les mots. Il veut les documents les plus pertinents. Pour cela, on utilise une methode statistique : TF-IDF (Term Frequency - Inverse Document Frequency).

• TF (Frequence du terme) : Mesure a quel point un mot est frequent dans un document. Plus un mot apparait souvent dans un doc, plus son score TF est eleve pour ce doc.
• IDF (Frequence inverse du document) : Mesure l'importance du terme dans l'ensemble du corpus. Plus un mot est rare (present dans peu de documents), plus son score IDF est eleve. Un mot comme "le" a un IDF tres bas, tandis qu'un mot technique comme "recursivite" a un IDF eleve.

Le score TF-IDF pour un mot dans un document est le produit TF * IDF. Pour une requete contenant plusieurs mots, on additionne les scores TF-IDF de chaque mot pour chaque document. Les documents avec le score total le plus eleve sont les plus pertinents.

3. L'interface de recherche et le classement

Enfin, il faut coder la fonction de recherche qui :

1. Recoit la requete de l'utilisateur.
2. La nettoie et la tokenise (comme lors de l'indexation).
3. Consulte l'index inversé pour trouver les documents candidats.
4. Calcule le score TF-IDF total pour chaque document candidat.
5. Trie et affiche les documents par ordre de pertinence decroissante.

Exemple de code Python pour demarrer

Voici un squelette de code pour te lancer. Il manque des fonctions a completer, c'est la ou ton travail d'eleve de NSI commence !

import os
import math

class MoteurDeRecherche:
    def __init__(self):
        self.index = {}  # Notre index inversé
        self.documents = {} # Pour stocker le contenu brut des docs
        self.nb_documents = 0

    def indexer_dossier(self, chemin_dossier):
        """Parcourt un dossier et indexe tous les fichiers .txt"""
        for nom_fichier in os.listdir(chemin_dossier):
            if nom_fichier.endswith('.txt'):
                chemin = os.path.join(chemin_dossier, nom_fichier)
                with open(chemin, 'r', encoding='utf-8') as f:
                    texte = f.read()
                self._ajouter_au_index(nom_fichier, texte)
        self.nb_documents = len(self.documents)

    def _ajouter_au_index(self, doc_id, texte):
        # A TOI DE COMPLETER :
        # 1. Tokeniser et nettoyer le texte.
        # 2. Pour chaque mot, mettre a jour self.index.
        #    Ex: self.index[ mot ] = {doc_id: compte}
        self.documents[doc_id] = texte
        pass

    def rechercher(self, requete):
        # A TOI DE COMPLETER :
        # 1. Nettoyer la requete.
        # 2. Trouver les documents candidats depuis self.index.
        # 3. Calculer le score TF-IDF pour chaque doc.
        # 4. Trier et retourner les resultats.
        pass

# Utilisation
if __name__ == "__main__":
    moteur = MoteurDeRecherche()
    moteur.indexer_dossier("mes_documents/")
    resultats = moteur.rechercher("python algorithme")
    print(resultats)

Idees pour aller plus loin

Une fois la version de base fonctionnelle, tu peux complexifier ton projet pour impressionner ton examinateur :

• Interface Web : Utilise Flask ou Streamlit pour creer une page web ou taper ses requetes.
• Recherche booleenne : Gere les operateurs AND, OR, NOT (ex: "python AND (liste OR dictionnaire)").
• Suggestion de mots : Propose une autocompletion ou une correction orthographique.
• Indexation du Web : Utilise la bibliotheque `requests` et `BeautifulSoup` pour indexer des pages web directement depuis leurs URL.

Ce projet, bien que complexe, est tres formateur. Il te fera voir Python sous un nouvel angle et te donnera une vision profonde d'une technologie omnipresente. Bon courage pour ton code !