Algorithmes de recherche TypeScript : Implémentation du type de récupération d'informations

Dans le domaine du développement logiciel, une récupération d'informations efficace est primordiale. Les algorithmes de recherche alimentent tout, des recherches de produits e-commerce aux consultations de bases de connaissances. TypeScript, avec son système de types robuste, offre une plateforme puissante pour implémenter et optimiser ces algorithmes. Cet article de blog explore comment tirer parti du système de types de TypeScript pour créer des solutions de recherche sûres, performantes et maintenables.

Comprendre les concepts de récupération d'informations

Avant de plonger dans les implémentations TypeScript, définissons quelques concepts clés en matière de récupération d'informations :

• Documents : Les unités d'information que nous voulons rechercher. Il peut s'agir de fichiers texte, d'enregistrements de base de données, de pages web ou de toute autre donnée structurée.
• Requêtes : Les termes ou phrases de recherche soumis par les utilisateurs pour trouver des documents pertinents.
• Indexation : Le processus de création d'une structure de données qui permet une recherche efficace. Une approche courante consiste à créer un index inversé, qui mappe les mots aux documents dans lesquels ils apparaissent.
• Classement : Le processus d'attribution d'un score à chaque document en fonction de sa pertinence par rapport à la requête. Des scores plus élevés indiquent une plus grande pertinence.
• Pertinence : Une mesure de la façon dont un document satisfait le besoin d'information de l'utilisateur, tel qu'exprimé dans la requête.

Choisir un algorithme de recherche

Plusieurs algorithmes de recherche existent, chacun avec ses propres forces et faiblesses. Parmi les choix populaires, on trouve :

• Recherche linéaire : L'approche la plus simple, consistant à parcourir chaque document et à le comparer à la requête. Cette méthode est inefficace pour les grands ensembles de données.
• Recherche binaire : Nécessite que les données soient triées et permet un temps de recherche logarithmique. Convient à la recherche dans des tableaux ou des arbres triés.
• Recherche par table de hachage : Offre une complexité de recherche moyenne en temps constant, mais nécessite une attention particulière aux collisions de fonctions de hachage.
• Recherche par index inversé : Une technique plus avancée qui utilise un index inversé pour identifier rapidement les documents contenant des mots-clés spécifiques.
• Moteurs de recherche plein texte (par exemple, Elasticsearch, Lucene) : Hautement optimisés pour la recherche textuelle à grande échelle, offrant des fonctionnalités telles que la racinisation, la suppression des mots vides et la correspondance floue.

Le meilleur choix dépend de facteurs tels que la taille de l'ensemble de données, la fréquence des mises à jour et la performance de recherche souhaitée.

Implémentation d'un index inversé de base en TypeScript

Démontrons une implémentation de base d'un index inversé en TypeScript. Cet exemple se concentre sur l'indexation et la recherche d'une collection de documents texte.

Définir les structures de données

Tout d'abord, nous définissons les structures de données pour représenter nos documents et l'index inversé :

            
interface Document {
  id: string;
  content: string;
}

interface InvertedIndex {
  [term: string]: string[]; // Term -> List of document IDs
}

            

              
                Copy
              
            
          

Créer l'index inversé

Ensuite, nous créons une fonction pour construire l'index inversé à partir d'une liste de documents :

            
function createInvertedIndex(documents: Document[]): InvertedIndex {
  const index: InvertedIndex = {};

  for (const document of documents) {
    const terms = document.content.toLowerCase().split(/\s+/); // Tokenize the content

    for (const term of terms) {
      if (!index[term]) {
        index[term] = [];
      }
      if (!index[term].includes(document.id)) {
        index[term].push(document.id);
      }
    }
  }

  return index;
}

            

              
                Copy
              
            
          

Rechercher dans l'index inversé

Maintenant, nous créons une fonction pour rechercher dans l'index inversé les documents correspondant à une requête :

            
function searchInvertedIndex(index: InvertedIndex, query: string): string[] {
  const terms = query.toLowerCase().split(/\s+/);
  let results: string[] = [];

  if (terms.length > 0) {
    results = index[terms[0]] || [];

    // For multi-word queries, perform intersection of results (AND operation)
    for (let i = 1; i < terms.length; i++) {
      const termResults = index[terms[i]] || [];
      results = results.filter(docId => termResults.includes(docId));
    }
  }

  return results;
}

            

              
                Copy
              
            
          

Exemple d'utilisation

Voici un exemple d'utilisation de l'index inversé :

            
const documents: Document[] = [
  { id: "1", content: "This is the first document about TypeScript." },
  { id: "2", content: "The second document discusses JavaScript and TypeScript." },
  { id: "3", content: "A third document focuses solely on JavaScript." },
];

const index = createInvertedIndex(documents);
const query = "TypeScript document";
const searchResults = searchInvertedIndex(index, query);

console.log("Search results for '" + query + "':", searchResults); // Output: ["1", "2"]

            

              
                Copy
              
            
          

Classement des résultats de recherche avec TF-IDF

L'implémentation de base de l'index inversé renvoie les documents qui contiennent les termes de recherche, mais ne les classe pas en fonction de leur pertinence. Pour améliorer la qualité de la recherche, nous pouvons utiliser l'algorithme TF-IDF (Term Frequency-Inverse Document Frequency) pour classer les résultats.

Le TF-IDF mesure l'importance d'un terme dans un document par rapport à son importance dans l'ensemble des documents. Les termes qui apparaissent fréquemment dans un document spécifique mais rarement dans d'autres documents sont considérés comme plus pertinents.

Calcul de la fréquence des termes (TF)

La fréquence des termes est le nombre de fois qu'un terme apparaît dans un document, normalisé par le nombre total de termes dans le document :

            
function calculateTermFrequency(term: string, document: Document): number {
  const terms = document.content.toLowerCase().split(/\s+/);
  const termCount = terms.filter(t => t === term).length;
  return termCount / terms.length;
}

            

              
                Copy
              
            
          

Calcul de la fréquence inverse des documents (IDF)

La fréquence inverse des documents mesure la rareté d'un terme dans l'ensemble des documents. Elle est calculée comme le logarithme du nombre total de documents divisé par le nombre de documents contenant le terme :

            
function calculateInverseDocumentFrequency(term: string, documents: Document[]): number {
  const documentCount = documents.length;
  const documentsContainingTerm = documents.filter(document =>
    document.content.toLowerCase().split(/\s+/).includes(term)
  ).length;

  return Math.log(documentCount / (1 + documentsContainingTerm)); // Add 1 to avoid division by zero
}

            

              
                Copy
              
            
          

Calcul du score TF-IDF

Le score TF-IDF pour un terme dans un document est simplement le produit de ses valeurs TF et IDF :

            
function calculateTfIdf(term: string, document: Document, documents: Document[]): number {
  const tf = calculateTermFrequency(term, document);
  const idf = calculateInverseDocumentFrequency(term, documents);
  return tf * idf;
}

            

              
                Copy
              
            
          

Classement des documents

Pour classer les documents en fonction de leur pertinence par rapport à une requête, nous calculons le score TF-IDF pour chaque terme de la requête pour chaque document et additionnons les scores. Les documents ayant des scores totaux plus élevés sont considérés comme plus pertinents.

            
function rankDocuments(query: string, documents: Document[]): { document: Document; score: number }[] {
  const terms = query.toLowerCase().split(/\s+/);
  const rankedDocuments: { document: Document; score: number }[] = [];

  for (const document of documents) {
    let score = 0;
    for (const term of terms) {
      score += calculateTfIdf(term, document, documents);
    }
    rankedDocuments.push({ document, score });
  }

  rankedDocuments.sort((a, b) => b.score - a.score); // Sort in descending order of score
  return rankedDocuments;
}

            

              
                Copy
              
            
          

Exemple d'utilisation avec TF-IDF

            
const rankedResults = rankDocuments(query, documents);

console.log("Ranked search results for '" + query + "':", rankedResults);
rankedResults.forEach(result => {
  console.log(`Document ID: ${result.document.id}, Score: ${result.score}`);
});

            

              
                Copy
              
            
          

Similarité cosinus pour la recherche sémantique

Bien que le TF-IDF soit efficace pour la recherche basée sur des mots-clés, il ne capture pas la similarité sémantique entre les mots. La similarité cosinus peut être utilisée pour comparer des vecteurs de documents, où chaque vecteur représente la fréquence des mots dans un document. Les documents avec des distributions de mots similaires auront une similarité cosinus plus élevée.

Création de vecteurs de documents

Tout d'abord, nous devons créer un vocabulaire de tous les mots uniques dans tous les documents. Ensuite, nous pouvons représenter chaque document comme un vecteur, où chaque élément correspond à un mot du vocabulaire et sa valeur représente la fréquence du terme ou le score TF-IDF de ce mot dans le document.

            
function createVocabulary(documents: Document[]): string[] {
  const vocabulary = new Set();
  for (const document of documents) {
    const terms = document.content.toLowerCase().split(/\s+/);
    terms.forEach(term => vocabulary.add(term));
  }
  return Array.from(vocabulary);
}

function createDocumentVector(document: Document, vocabulary: string[], useTfIdf: boolean, allDocuments: Document[]): number[] {
  const vector: number[] = [];
  for (const term of vocabulary) {
    if(useTfIdf){
        vector.push(calculateTfIdf(term, document, allDocuments));
    } else {
        vector.push(calculateTermFrequency(term, document));
    }

  }
  return vector;
}

            

              
                Copy
              
            
          

Calcul de la similarité cosinus

La similarité cosinus est calculée comme le produit scalaire de deux vecteurs divisé par le produit de leurs magnitudes :

            
function cosineSimilarity(vectorA: number[], vectorB: number[]): number {
  if (vectorA.length !== vectorB.length) {
    throw new Error("Vectors must have the same length");
  }

  let dotProduct = 0;
  let magnitudeA = 0;
  let magnitudeB = 0;

  for (let i = 0; i < vectorA.length; i++) {
    dotProduct += vectorA[i] * vectorB[i];
    magnitudeA += vectorA[i] * vectorA[i];
    magnitudeB += vectorB[i] * vectorB[i];
  }

  magnitudeA = Math.sqrt(magnitudeA);
  magnitudeB = Math.sqrt(magnitudeB);

  if (magnitudeA === 0 || magnitudeB === 0) {
    return 0; // Avoid division by zero
  }

  return dotProduct / (magnitudeA * magnitudeB);
}

            

              
                Copy
              
            
          

Classement avec la similarité cosinus

Pour classer les documents en utilisant la similarité cosinus, nous créons un vecteur pour la requête (en la traitant comme un document) puis nous calculons la similarité cosinus entre le vecteur de la requête et chaque vecteur de document. Les documents avec une similarité cosinus plus élevée sont considérés comme plus pertinents.

            
function rankDocumentsCosineSimilarity(query: string, documents: Document[], useTfIdf: boolean): { document: Document; similarity: number }[] {
    const vocabulary = createVocabulary(documents);
    const queryDocument: Document = { id: "query", content: query };
    const queryVector = createDocumentVector(queryDocument, vocabulary, useTfIdf, documents);
    const rankedDocuments: { document: Document; similarity: number }[] = [];

    for (const document of documents) {
        const documentVector = createDocumentVector(document, vocabulary, useTfIdf, documents);
        const similarity = cosineSimilarity(queryVector, documentVector);
        rankedDocuments.push({ document, similarity });
    }

    rankedDocuments.sort((a, b) => b.similarity - a.similarity); // Sort in descending order of similarity
    return rankedDocuments;
}

            

              
                Copy
              
            
          

Exemple d'utilisation avec la similarité cosinus

            
const rankedResultsCosine = rankDocumentsCosineSimilarity(query, documents, true); //Use TF-IDF for vector creation

console.log("Ranked search results (Cosine Similarity) for '" + query + "':");
rankedResultsCosine.forEach(result => {
    console.log(`Document ID: ${result.document.id}, Similarity: ${result.similarity}`);
});

            

              
                Copy
              
            
          

Le système de types de TypeScript pour une sécurité et une maintenabilité améliorées

Le système de types de TypeScript offre plusieurs avantages pour l'implémentation d'algorithmes de recherche :

• Sécurité des types : TypeScript aide à détecter les erreurs tôt en appliquant des contraintes de type. Cela réduit le risque d'exceptions d'exécution et améliore la fiabilité du code.
• Complétude du code : Les IDE peuvent fournir une meilleure complétion de code et des suggestions basées sur les types de variables et de fonctions.
• Support de la refactorisation : Le système de types de TypeScript facilite la refactorisation du code sans introduire d'erreurs.
• Maintenabilité améliorée : Les types fournissent une documentation et rendent le code plus facile à comprendre et à maintenir.

Utilisation des alias de type et des interfaces

Les alias de type et les interfaces nous permettent de définir des types personnalisés qui représentent nos structures de données et nos signatures de fonction. Cela améliore la lisibilité et la maintenabilité du code. Comme vu dans les exemples précédents, les interfaces `Document` et `InvertedIndex` améliorent la clarté du code.

Génériques pour la réutilisabilité

Les génériques peuvent être utilisés pour créer des algorithmes de recherche réutilisables qui fonctionnent avec différents types de données. Par exemple, nous pourrions créer une fonction de recherche générique qui peut rechercher dans des tableaux de nombres, de chaînes ou d'objets personnalisés.

Unions discriminées pour gérer différents types de données

Les unions discriminées peuvent être utilisées pour représenter différents types de documents ou de requêtes. Cela nous permet de gérer différents types de données de manière sécurisée en termes de types.

Considérations de performance

La performance des algorithmes de recherche est critique, en particulier pour les grands ensembles de données. Considérez les techniques d'optimisation suivantes :

• Structures de données efficaces : Utilisez des structures de données appropriées pour l'indexation et la recherche. Les index inversés, les tables de hachage et les arbres peuvent améliorer considérablement les performances.
• Mise en cache : Mettez en cache les données fréquemment accédées pour réduire le besoin de calculs répétés. Des bibliothèques comme `lru-cache` ou l'utilisation de techniques de mémoïsation peuvent être utiles.
• Opérations asynchrones : Utilisez des opérations asynchrones pour éviter de bloquer le thread principal. Ceci est particulièrement important pour les applications web.
• Traitement parallèle : Utilisez plusieurs cœurs ou threads pour paralléliser le processus de recherche. Les Web Workers dans le navigateur ou les worker threads dans Node.js peuvent être exploités.
• Bibliothèques d'optimisation : Envisagez d'utiliser des bibliothèques spécialisées pour le traitement de texte, telles que les bibliothèques de traitement du langage naturel (TLN), qui peuvent fournir des implémentations optimisées de la racinisation, de la suppression des mots vides et d'autres techniques d'analyse textuelle.

Applications réelles

Les algorithmes de recherche TypeScript peuvent être appliqués dans divers scénarios réels :

• Recherche e-commerce : Alimente les recherches de produits sur les sites web de commerce électronique, permettant aux utilisateurs de trouver rapidement les articles qu'ils recherchent. Des exemples incluent la recherche de produits sur Amazon, eBay ou les magasins Shopify.
• Recherche dans les bases de connaissances : Permet aux utilisateurs de rechercher dans la documentation, les articles et les FAQ. Utilisé dans les systèmes de support client comme Zendesk ou les bases de connaissances internes.
• Recherche de code : Aide les développeurs à trouver des extraits de code, des fonctions et des classes au sein d'une base de code. Intégré dans les IDE comme VS Code et les dépôts de code en ligne comme GitHub.
• Recherche d'entreprise : Fournit une interface de recherche unifiée pour accéder aux informations à travers divers systèmes d'entreprise, tels que les bases de données, les serveurs de fichiers et les archives de courrier électronique.
• Recherche sur les médias sociaux : Permet aux utilisateurs de rechercher des publications, des utilisateurs et des sujets sur les plateformes de médias sociaux. Des exemples incluent les fonctionnalités de recherche de Twitter, Facebook et Instagram.

Conclusion

TypeScript offre un environnement puissant et sûr en termes de types pour l'implémentation d'algorithmes de recherche. En tirant parti du système de types de TypeScript, les développeurs peuvent créer des solutions de recherche robustes, performantes et maintenables pour une large gamme d'applications. Des index inversés de base aux algorithmes de classement avancés comme TF-IDF et la similarité cosinus, TypeScript permet aux développeurs de construire des systèmes de récupération d'informations efficaces.

Cet article de blog a fourni un aperçu complet des algorithmes de recherche TypeScript, y compris les concepts sous-jacents, les détails d'implémentation et les considérations de performance. En comprenant ces concepts et techniques, les développeurs peuvent construire des solutions de recherche sophistiquées qui répondent aux besoins spécifiques de leurs applications.