Traitement incrémental : Mises à jour rapides du pipeline

Cet article explique comment le pipeline SEO utilise le traitement incrémental pour s'exécuter en quelques secondes au lieu de plusieurs heures.

Le problème : Le retraitement complet est lent

Exécuter l'intégralité du pipeline depuis le début prend des heures :

  • Étape 0 (Intégration des sources) : 15 minutes (65 000 produits)

  • Étape 1 (Récupération des requêtes) : 10 minutes (appels API)

  • Étape 2 (Regroupement des requêtes) : 30 minutes (similarité 65K×65K)

  • Étape 3 (Correspondance des expressions) : 20 minutes (intégration + appariement)

  • Étape 4 (Appariement des produits) : 45 minutes (requêtes × produits)

  • Étape 5 (Recherches associées) : 25 minutes (similarité requête × requête)

Total : ~2,5 heures pour le pipeline complet

Problème : Des mises à jour quotidiennes gaspilleraient 2,5 heures à recalculer des données inchangées.

La solution : Une stratégie incrémentale à trois niveaux

Nous utilisons trois techniques pour éviter le travail inutile :

1. Saut d'étape (Granularité grossière)

Sauter des étapes entières si la sortie est récente et le script inchangé.

2. Intégration incrémentale (Granularité moyenne)

Intégrer uniquement les éléments nouveaux/modifiés, réutiliser les intégrations en cache.

3. Points de contrôle (Granularité fine)

Sauvegarder la progression pendant les opérations longues, reprendre depuis le point de contrôle en cas d'échec.

Stratégie de saut d'étape

Fonctionnement

Avant chaque étape, vérifier :

La sortie existe-t-elle ? Si non, exécuter l'étape.

Âge de la sortie : Si plus ancienne que 7 jours, exécuter l'étape.

Script modifié ? Si le script a été modifié depuis la génération de la sortie, exécuter l'étape.

Toutes les vérifications passent ? Sauter l'étape.

Implémentation

def should_skip_step(output_path, script_path, days=7):
    # Vérifier si la sortie existe
    if not os.path.exists(output_path):
# ... (détails d'implémentation omis)

Utilisation

Chaque script vérifie au démarrage :

from seo_common import should_skip_step

if should_skip_step(SEO_SOURCE_EMBEDDINGS_PATH, __file__):
    print("✓ Saut : La sortie est récente et le script inchangé")
    return

Avantages

Exécutions quotidiennes rapides : La plupart des étapes sont sautées si les données sont inchangées

Invalidation automatique : Les modifications du script déclenchent une ré-exécution

Fraîcheur configurable : Ajuster le paramètre days par étape

Stratégie d'intégration incrémentale

Fonctionnement

Lors de l'intégration d'éléments (produits, requêtes, expressions) :

Charger le cache : Lire les éléments précédemment intégrés et leurs clés

Comparer les clés : Identifier les éléments nouveaux, modifiés et supprimés

Intégrer uniquement les nouveaux : N'intégrer que les éléments absents du cache

Fusionner : Combiner les intégrations en cache avec les nouvelles intégrations dans le bon ordre

Sauvegarder : Écrire le cache mis à jour

Implémentation

La fonction incremental_embed_with_keys gère cela :

def incremental_embed_with_keys(
    items,           # Éléments actuels à intégrer
    keys,            # Clés uniques pour les éléments
# ... (détails d'implémentation omis)

Taux de succès du cache

Taux de succès typiques du cache après la première exécution :

Données sources (produits, pièces, articles) :

  • Première exécution : 0% (intégrer tous les 65 000 éléments)

  • Exécution quotidienne : 99,5% (seulement ~300 éléments nouveaux/modifiés)

Requêtes (depuis GSC, Ads, en direct) :

  • Première exécution : 0% (intégrer toutes les 65 000 requêtes)

  • Exécution quotidienne : 99,2% (seulement ~500 nouvelles requêtes)

Correspondance d'expressions :

  • Première exécution : 0% (intégrer toutes les 5 000 expressions)

  • Exécution quotidienne : 99,8% (seulement ~10 nouvelles expressions)

Impact sur les performances

Première exécution (cache froid) :

  • Intégration des sources : 15 minutes (65 000 éléments)

  • Intégration des requêtes : 10 minutes (65 000 requêtes)

  • Intégration des expressions : 2 minutes (5 000 expressions)

Exécution quotidienne (cache chaud) :

  • Intégration des sources : 10 secondes (300 éléments, taux de succès 99,5%)

  • Intégration des requêtes : 5 secondes (500 requêtes, taux de succès 99,2%)

  • Intégration des expressions : 1 seconde (10 expressions, taux de succès 99,8%)

Accélération : 90 à 180 fois plus rapide

Stratégie de points de contrôle

Fonctionnement

Pour les opérations de longue durée (intégration de 65 000 éléments) :

Traitement par lots : Traiter les éléments par lots (ex. 1 000 éléments)

Sauvegarder un point de contrôle : Après chaque lot, sauvegarder les résultats accumulés

Reprendre en cas d'échec : Si le processus plante, reprendre depuis le dernier point de contrôle

Sauvegarde finale : Après tous les lots, sauvegarder les résultats complets

Implémentation

La gestion des points de contrôle est intégrée à incremental_embed_with_keys :

checkpoint_every = 1000  # Sauvegarder tous les 1 000 éléments

embeddings_list = []
# ... (détails d'implémentation omis)

Avantages

Récupération après plantage : Reprendre depuis le dernier point de contrôle au lieu de recommencer

Visibilité de la progression : Voir la progression tous les 1 000 éléments

Efficacité mémoire : Traiter par lots, ne pas tout charger en mémoire

Intégration à travers le pipeline

Le traitement incrémental est utilisé dans plusieurs étapes :

Étape 0 : Intégration des données sources

Incrémental : Intégrer uniquement les produits, pièces, articles nouveaux/modifiés

Points de contrôle : Sauvegarder tous les 1 000 éléments

Logique de saut : Sauter si la sortie a moins de 7 jours et le script est inchangé

Voir : Intégration des données sources

Étape 1 : Récupération des requêtes

Incrémental : Les appels API récupèrent uniquement les nouvelles données (depuis la dernière exécution)

Logique de saut : Sauter si la sortie a moins de 1 jour

Voir : Récupération des requêtes

Étape 3b : Intégration des requêtes

Incrémental : Intégrer uniquement les nouvelles requêtes

Points de contrôle : Sauvegarder tous les 1 000 requêtes

Logique de saut : Sauter si la sortie a moins de 7 jours et le script est inchangé

Voir : Intégration des requêtes

Étape 4 : Expansion de la correspondance d'expressions

Incrémental : Intégrer uniquement les nouvelles expressions

Points de contrôle : Sauvegarder tous les 1 000 expressions

Logique de saut : Sauter si la sortie a moins de 7 jours et le script est inchangé

Voir : Correspondance expression-filtre

Étape 6 : Appariement des produits

Incrémental : Apparier uniquement les nouvelles requêtes

Logique de saut : Sauter si la sortie a moins de 7 jours et le script est inchangé

Voir : Appariement des produits

Configuration

Le traitement incrémental est configuré par étape :

Seuil de fraîcheur

# Sauter si la sortie a moins de 7 jours (par défaut)
should_skip_step(output_path, script_path, days=7)

# Sauter si la sortie a moins de 1 jour (pour les données changeant fréquemment)
should_skip_step(output_path, script_path, days=1)

Fréquence des points de contrôle

# Sauvegarder tous les 1 000 éléments (par défaut)
incremental_embed_with_keys(..., checkpoint_every=1000)

# Sauvegarder tous les 5 000 éléments (traitement plus rapide, moins de sécurité)
incremental_embed_with_keys(..., checkpoint_every=5000)

Taille des lots

# Intégrer 32 éléments par lot (par défaut, équilibré)
incremental_embed_with_keys(..., batch_size=32)

# Intégrer 64 éléments par lot (plus rapide sur GPU, plus de mémoire)
incremental_embed_with_keys(..., batch_size=64)

Surveillance et débogage

Statistiques du cache

Chaque étape affiche les statistiques du cache :

✓ Cache existant trouvé, vérification des changements...
  Existant : 65 000 éléments
  Actuel :   65 300 éléments
  Réutilisation : 64 800 intégrations
  Nouveaux : 500 éléments à intégrer

Messages de saut

Lorsque des étapes sont sautées :

✓ Saut de 0_embed_source_data.py : La sortie est récente et le script inchangé.

Messages de point de contrôle

Pendant les opérations longues :

Intégration de 65 000 éléments (point de contrôle tous les 1 000)...
  Lot 0-1000...
    ✓ Point de contrôle sauvegardé (1 000 au total)
  Lot 1000-2000...
    ✓ Point de contrôle sauvegardé (2 000 au total)
  ...

Références

Concepts techniques

Articles connexes

Résumé

Le traitement incrémental rend le pipeline 90 à 180 fois plus rapide :

Stratégie à trois niveaux :

  • ✅ Saut d'étape (sauter des étapes entières si la sortie est récente)

  • ✅ Intégration incrémentale (intégrer uniquement les éléments nouveaux/modifiés)

  • ✅ Points de contrôle (sauvegarder la progression, reprendre en cas d'échec)

Performances :

  • ✅ Première exécution : ~2,5 heures (pipeline complet)

  • ✅ Exécution quotidienne : ~5 minutes (mises à jour incrémentales)

  • ✅ Taux de succès du cache : 99%+ après la première exécution

Avantages :

  • ✅ Mises à jour quotidiennes rapides (minutes au lieu d'heures)

  • ✅ Invalidation automatique (les modifications du script déclenchent une ré-exécution)

  • ✅ Récupération après plantage (reprise depuis le point de contrôle)

  • ✅ Efficacité mémoire (traitement par lots)

Cette stratégie permet des exécutions quotidiennes du pipeline sans gaspiller de ressources de calcul sur des données inchangées.

← Retour à l'index de la documentation