Extraction de filtres : Correspondance par expressions régulières avec limites de mots

Cet article explique comment nous extrayons des filtres de produits structurés à partir de requêtes de recherche en langage naturel en utilisant la correspondance par expressions régulières avec limites de mots sur des correspondances phrase-à-filtre.

Le problème : Du langage naturel aux filtres structurés

Lorsqu'un utilisateur recherche "mini pc with 16gb ram", nous devons extraire :

{
  "Form Factor": "Mini PC",
  "Main Memory": "16"
}

Ces filtres structurés permettent :

  • Le filtrage de produits : Afficher uniquement les produits correspondants

  • La navigation à facettes : Afficher les options de filtres disponibles

  • La génération de pages de requêtes : Créer des pages optimisées pour le SEO

  • Les recherches associées : Trouver des requêtes similaires

Le défi est de gérer toutes les façons dont les utilisateurs expriment la même intention.

L'algorithme : Correspondance par expressions régulières avec limites de mots

Étape 1 : Charger les correspondances de phrases

Nous chargeons les correspondances phrase-à-filtre générées par le pipeline SEO. Ces correspondances relient des phrases à des valeurs de filtre, permettant une recherche de la phrase vers la clé et la valeur de filtre correspondantes.

Nous inversons cette structure pour une recherche rapide, afin de pouvoir rechercher par phrase plutôt que par filtre :

phrase_to_filter = {
    "16gb ram": ("Main Memory", "16"),
    "16 gb ram": ("Main Memory", "16"),
    "mini pc": ("Form Factor", "Mini PC"),
    "mini computer": ("Form Factor", "Mini PC")
}

Étape 2 : Normaliser la requête

Convertir la requête en minuscules pour une correspondance insensible à la casse.

Étape 3 : Faire correspondre les phrases avec des limites de mots

Pour chaque phrase dans les correspondances, nous vérifions si elle apparaît dans la requête en utilisant des ancres de limite de mot dans les expressions régulières.

Les ancres \b garantissent que nous faisons correspondre des mots complets, pas des sous-chaînes : "mini pc" correspond à "mini pc with ram" mais ne correspond PAS à "minipc" (pas d'espace), et "16gb" correspond à "16gb ram" mais ne correspond PAS à "216gb" (correspondance partielle).

Étape 4 : Collecter toutes les correspondances

Nous parcourons toutes les phrases et collectons les filtres correspondants. Pour "mini pc with 16gb ram", cela produit des filtres comme {"Form Factor": "Mini PC", "Main Memory": "16"}.

Pourquoi des limites de mots ?

Les limites de mots empêchent les fausses correspondances :

Sans limites de mots :

  • "i5" correspondrait à "i5000" (incorrect)

  • "ram" correspondrait à "program" (incorrect)

  • "pc" correspondrait à "pcie" (incorrect)

Avec limites de mots : "i5" correspond à "i5 processor" ✅ mais ne correspond PAS à "i5000" ❌ ; "ram" correspond à "16gb ram" ✅ mais ne correspond PAS à "program" ❌. L'ancre \b garantit que nous faisons correspondre uniquement aux frontières des mots.

Gestion des correspondances multiples

Si plusieurs phrases correspondent au même filtre, la dernière correspondance l'emporte :

# Requête : "mini pc small computer"
# "mini pc" et "small computer" correspondent à "Form Factor:Mini PC"
# Résultat : {"Form Factor": "Mini PC"} (dédoublonné)

Si plusieurs phrases correspondent à des valeurs différentes pour le même filtre, la dernière correspondance l'emporte :

# Requête : "8gb 16gb ram"
# "8gb" → Main Memory:8
# "16gb" → Main Memory:16
# Résultat : {"Main Memory": "16"} (dernière correspondance l'emporte)

En pratique, les utilisateurs spécifient rarement des valeurs conflictuelles, donc ce n'est pas un problème.

Priorité des phrases

Les phrases sont comparées dans l'ordre où elles apparaissent dans les correspondances. Étant donné que les correspondances sont triées par similarité (la plus élevée d'abord) puis par longueur (la plus courte d'abord), les correspondances de meilleure qualité sont vérifiées en premier. Cependant, puisque nous parcourons toutes les phrases, l'ordre n'affecte pas le résultat final — la dernière correspondance l'emporte.

Optimisation des performances

Mise en cache

La correspondance phrase-à-filtre est chargée une fois au démarrage et mise en cache en mémoire, évitant ainsi des entrées/sorties disque répétées à chaque requête.

Solution de repli Valkey

Nous essayons d'abord de charger les correspondances depuis Valkey (fork de Redis), avec un repli sur des fichiers JSON :

  1. Vérifier Valkey pour une recherche rapide en mémoire
  2. Charger depuis JSON en cas d'absence dans Valkey
  3. Stocker dans Valkey avec une expiration du cache

Cela réduit la latence pour les requêtes suivantes.

Correspondance par expressions régulières

Les motifs utilisent re.search() avec des ancres de limite de mot pour faire correspondre efficacement des mots complets sans fausses correspondances partielles.

Intégration avec le service de recherche

L'extraction de filtres est implémentée comme un point de terminaison de service API qui accepte les requêtes de recherche et renvoie les filtres extraits.

Le service :

  1. Accepte une requête de recherche en entrée
  2. Charge les correspondances phrase-à-filtre en mémoire
  3. Normalise et fait correspondre les phrases avec des limites de mots
  4. Renvoie des paires clé-valeur de filtres structurées

Le serveur web principal appelle ce service pour extraire les filtres des requêtes utilisateur :

filters = extract_filters_from_query("mini pc 16gb ram")
# Renvoie : {"Form Factor": "Mini PC", "Main Memory": "16"}

Cette séparation des préoccupations permet :

  • Une mise à l'échelle indépendante : L'extraction de filtres peut s'exécuter sur un serveur séparé

  • Un isolement du cache : Le service gère son propre cache de correspondances

  • Un redémarrage du service : Le service peut être redémarré indépendamment sans affecter le serveur web principal

Voir Architecture du service de recherche pour plus de détails.

Journalisation des requêtes

Chaque extraction de filtre est journalisée pour consommation par le pipeline SEO. Ces journaux alimentent en retour le pipeline SEO pour découvrir de nouveaux modèles de requêtes et améliorer les correspondances de phrases au fil du temps.

Cas d'utilisation

Pages de requêtes (/q/)

Les pages de requêtes extraient les filtres de l'identifiant d'URL pour déterminer quels produits afficher.

API de recherche (/api/search)

L'API de recherche extrait les filtres de la requête de recherche pour trouver et renvoyer les produits correspondants.

Saisie semi-automatique

Les suggestions de saisie semi-automatique extraient les filtres pour fournir des aperçus de filtres aux côtés des suggestions de recherche.

Recherches associées

La génération de recherches associées utilise les filtres extraits pour trouver des requêtes similaires :

Requête : "mini pc 16gb ram"
→ Filtres : {"Form Factor": "Mini PC", "Main Memory": "16"}
→ Trouver des requêtes avec des filtres similaires
→ Suggérer : "mini pc 32gb ram", "mini pc 16gb ssd"

Voir Génération de recherches associées pour plus de détails.

Gestion des erreurs

Correspondances manquantes

Si les correspondances de phrases ne sont pas chargées, nous renvoyons des filtres vides. Cela empêche les plantages lorsque le pipeline SEO n'a pas encore été exécuté.

Requêtes invalides

Les requêtes vides ou composées uniquement d'espaces renvoient des filtres vides.

Erreurs d'expressions régulières

Nous utilisons l'échappement d'expressions régulières pour assainir les phrases avant la correspondance par regex, empêchant ainsi les erreurs de syntaxe dues aux caractères spéciaux dans les phrases.

Caractéristiques de performance

L'extraction de filtres fonctionne efficacement grâce à la correspondance par expressions régulières avec limites de mots et une mise en cache agressive :

  • Le chargement des correspondances se produit une fois au démarrage

  • L'extraction par requête est limitée par le CPU (correspondance par regex)

  • L'utilisation de la mémoire pour les caches reste gérable

  • Les taux de succès du cache sont élevés en production

Les expressions régulières avec limites de mots sont plus rapides que la recherche par sous-chaîne car le moteur de regex peut ignorer efficacement les positions non correspondantes.

Limitations

Dépendance à l'ordre des phrases

Nous faisons correspondre les phrases dans l'ordre d'itération, qui n'est pas garanti. Si deux phrases se chevauchent, la dernière correspondance l'emporte :

# Requête : "mini pc"
# Phrases : ["mini", "mini pc"]
# Si "mini" est vérifié en dernier, il écrase "mini pc"

En pratique, cela n'arrive pas car :

  • Les phrases plus longues sont plus spécifiques et apparaissent en premier dans les correspondances triées

  • Les phrases qui se chevauchent correspondent généralement à la même valeur de filtre

Aucune combinaison de phrases

Nous ne combinons pas plusieurs phrases en une seule valeur de filtre :

# Requête : "dual core quad core"
# Résultat : {"Cores": "4"} (dernière correspondance l'emporte)
# PAS : {"Cores": ["2", "4"]} (valeurs multiples)

C'est intentionnel — les utilisateurs spécifient rarement plusieurs valeurs pour le même filtre.

Aucune négation

Nous ne gérons pas la négation (par exemple, "mini pc without Windows"). La négation est rare dans les requêtes de recherche, donc elle n'est actuellement pas prise en charge.

Références

Concepts techniques

Documentation Python

Articles connexes

Résumé

Nous extrayons les filtres des requêtes de recherche en utilisant la correspondance par expressions régulières avec limites de mots :

  • Charger les correspondances : Correspondances phrase-à-filtre du pipeline SEO

  • Normaliser la requête : Convertir en minuscules

  • Faire correspondre les phrases : Utiliser les limites de mots \b pour faire correspondre des mots complets

  • Collecter les filtres : Construire un dictionnaire de paires clé-valeur de filtres

  • Mettre en cache agressivement : Cache en mémoire + repli Valkey

  • Journaliser les requêtes : Alimenter en retour le pipeline SEO

L'algorithme est simple, efficace et gère toutes les variations de phrases générées par le pipeline SEO. Les limites de mots empêchent les fausses correspondances tout en permettant une correspondance flexible des phrases. Le résultat est une extraction de filtres robuste qui alimente les pages de requêtes, la recherche, la saisie semi-automatique et les recherches associées.

← Retour à l'index de la documentation