इंक्रीमेंटल प्रोसेसिंग: तेज़ पाइपलाइन अपडेट

यह लेख बताता है कि SEO पाइपलाइन घंटों के बजाय सेकंडों में चलने के लिए इंक्रीमेंटल प्रोसेसिंग का उपयोग कैसे करती है।

समस्या: पूर्ण पुनर्प्रसंस्करण धीमा है

शुरू से पूरी पाइपलाइन चलाने में घंटे लगते हैं:

  • चरण 0 (स्रोत एम्बेडिंग): 15 मिनट (65,000 उत्पाद)

  • चरण 1 (क्वेरी फ़ेचिंग): 10 मिनट (API कॉल)

  • चरण 2 (क्वेरी क्लस्टरिंग): 30 मिनट (65K×65K समानता)

  • चरण 3 (वाक्यांश मैपिंग): 20 मिनट (एम्बेडिंग + मिलान)

  • चरण 4 (उत्पाद मिलान): 45 मिनट (क्वेरी × उत्पाद)

  • चरण 5 (संबंधित खोज): 25 मिनट (क्वेरी × क्वेरी समानता)

कुल: पूरी पाइपलाइन के लिए ~2.5 घंटे

समस्या: दैनिक अपडेट अपरिवर्तित डेटा की पुनर्गणना में 2.5 घंटे बर्बाद कर देते।

समाधान: तीन-परत इंक्रीमेंटल रणनीति

हम अनावश्यक कार्य को छोड़ने के लिए तीन तकनीकों का उपयोग करते हैं:

1. चरण छोड़ना (मोटे-दाने वाला)

पूरे चरणों को छोड़ दें यदि आउटपुट ताजा है और स्क्रिप्ट अपरिवर्तित है।

2. इंक्रीमेंटल एम्बेडिंग (मध्यम-दाने वाला)

केवल नए/बदले हुए आइटम एम्बेड करें, कैश्ड एम्बेडिंग का पुन: उपयोग करें।

3. चेकपॉइंटिंग (बारीक-दाने वाला)

लंबे ऑपरेशन के दौरान प्रगति सहेजें, विफलता पर चेकपॉइंट से फिर से शुरू करें।

चरण छोड़ने की रणनीति

यह कैसे काम करती है

प्रत्येक चरण से पहले, जाँचें:

आउटपुट मौजूद है? यदि नहीं, तो चरण चलाएँ।

आउटपुट की आयु: यदि 7 दिन से पुराना है, तो चरण चलाएँ।

स्क्रिप्ट बदली है? यदि आउटपुट जनरेट होने के बाद से स्क्रिप्ट संशोधित हुई है, तो चरण चलाएँ।

सभी जाँच पास? चरण छोड़ दें।

कार्यान्वयन

def should_skip_step(output_path, script_path, days=7):
    # Check if output exists
    if not os.path.exists(output_path):
# ... (implementation details omitted)

उपयोग

प्रत्येक स्क्रिप्ट शुरुआत में जाँच करती है:

from seo_common import should_skip_step

if should_skip_step(SEO_SOURCE_EMBEDDINGS_PATH, __file__):
    print("✓ Skipping: Output is fresh and script unchanged")
    return

लाभ

तेज़ दैनिक रन: यदि डेटा अपरिवर्तित है तो अधिकांश चरण छोड़ दिए जाते हैं

स्वचालित अमान्यीकरण: स्क्रिप्ट परिवर्तन पुन: रन को ट्रिगर करते हैं

कॉन्फ़िगर करने योग्य ताजगी: प्रति चरण days पैरामीटर समायोजित करें

इंक्रीमेंटल एम्बेडिंग रणनीति

यह कैसे काम करती है

जब आइटम (उत्पाद, क्वेरी, वाक्यांश) एम्बेड कर रहे हों:

कैश लोड करें: पहले से एम्बेड किए गए आइटम और उनकी कुंजियाँ पढ़ें

कुंजियों की तुलना करें: नए, बदले हुए और हटाए गए आइटम पहचानें

केवल नए एम्बेड करें: केवल उन आइटम को एम्बेड करें जो कैश में नहीं हैं

मर्ज करें: कैश्ड एम्बेडिंग को नई एम्बेडिंग के साथ सही क्रम में मिलाएं

सहेजें: अपडेटेड कैश लिखें

कार्यान्वयन

incremental_embed_with_keys फ़ंक्शन इसे संभालता है:

def incremental_embed_with_keys(
    items,           # Current items to embed
    keys,            # Unique keys for items
# ... (implementation details omitted)

कैश हिट दरें

पहले रन के बाद विशिष्ट कैश हिट दरें:

स्रोत डेटा (उत्पाद, पार्ट्स, लेख):

  • पहला रन: 0% (सभी 65,000 आइटम एम्बेड करें)

  • दैनिक रन: 99.5% (केवल ~300 नए/बदले हुए आइटम)

क्वेरी (GSC, Ads, लाइव से):

  • पहला रन: 0% (सभी 65,000 क्वेरी एम्बेड करें)

  • दैनिक रन: 99.2% (केवल ~500 नई क्वेरी)

वाक्यांश मैपिंग:

  • पहला रन: 0% (सभी 5,000 वाक्यांश एम्बेड करें)

  • दैनिक रन: 99.8% (केवल ~10 नए वाक्यांश)

प्रदर्शन प्रभाव

पहला रन (कोल्ड कैश):

  • स्रोत एम्बेडिंग: 15 मिनट (65,000 आइटम)

  • क्वेरी एम्बेडिंग: 10 मिनट (65,000 क्वेरी)

  • वाक्यांश एम्बेडिंग: 2 मिनट (5,000 वाक्यांश)

दैनिक रन (वार्म कैश):

  • स्रोत एम्बेडिंग: 10 सेकंड (300 आइटम, 99.5% हिट दर)

  • क्वेरी एम्बेडिंग: 5 सेकंड (500 क्वेरी, 99.2% हिट दर)

  • वाक्यांश एम्बेडिंग: 1 सेकंड (10 वाक्यांश, 99.8% हिट दर)

गति वृद्धि: 90-180× तेज़

चेकपॉइंटिंग रणनीति

यह कैसे काम करती है

लंबे समय तक चलने वाले ऑपरेशन (65,000 आइटम एम्बेड करना) के लिए:

बैच प्रसंस्करण: आइटम को बैच में प्रोसेस करें (जैसे, 1,000 आइटम)

चेकपॉइंट सहेजें: प्रत्येक बैच के बाद, संचित परिणाम सहेजें

विफलता पर फिर से शुरू करें: यदि प्रक्रिया क्रैश हो जाती है, तो अंतिम चेकपॉइंट से फिर से शुरू करें

अंतिम सहेजें: सभी बैच के बाद, पूर्ण परिणाम सहेजें

कार्यान्वयन

चेकपॉइंटिंग incremental_embed_with_keys में बिल्ट-इन है:

checkpoint_every = 1000  # Save every 1,000 items

embeddings_list = []
# ... (implementation details omitted)

लाभ

क्रैश रिकवरी: शुरुआत से फिर से शुरू करने के बजाय अंतिम चेकपॉइंट से फिर से शुरू करें

प्रगति दृश्यता: प्रत्येक 1,000 आइटम पर प्रगति देखें

मेमोरी दक्षता: बैच में प्रोसेस करें, सभी को एक साथ लोड न करें

पाइपलाइन में एकीकरण

इंक्रीमेंटल प्रोसेसिंग का उपयोग कई चरणों में किया जाता है:

चरण 0: स्रोत डेटा एम्बेडिंग

इंक्रीमेंटल: केवल नए/बदले हुए उत्पाद, पार्ट्स, लेख एम्बेड करें

चेकपॉइंटिंग: प्रत्येक 1,000 आइटम पर सहेजें

स्किप लॉजिक: छोड़ दें यदि आउटपुट 7 दिन से कम पुराना है और स्क्रिप्ट अपरिवर्तित है

देखें: स्रोत डेटा एम्बेडिंग

चरण 1: क्वेरी फ़ेचिंग

इंक्रीमेंटल: API कॉल केवल नया डेटा (अंतिम रन के बाद से) फ़ेच करती हैं

स्किप लॉजिक: छोड़ दें यदि आउटपुट 1 दिन से कम पुराना है

देखें: क्वेरी फ़ेचिंग

चरण 3b: क्वेरी एम्बेडिंग

इंक्रीमेंटल: केवल नई क्वेरी एम्बेड करें

चेकपॉइंटिंग: प्रत्येक 1,000 क्वेरी पर सहेजें

स्किप लॉजिक: छोड़ दें यदि आउटपुट 7 दिन से कम पुराना है और स्क्रिप्ट अपरिवर्तित है

देखें: क्वेरी एम्बेडिंग

चरण 4: वाक्यांश मैपिंग विस्तार

इंक्रीमेंटल: केवल नए वाक्यांश एम्बेड करें

चेकपॉइंटिंग: प्रत्येक 1,000 वाक्यांश पर सहेजें

स्किप लॉजिक: छोड़ दें यदि आउटपुट 7 दिन से कम पुराना है और स्क्रिप्ट अपरिवर्तित है

देखें: वाक्यांश-से-फ़िल्टर मैपिंग

चरण 6: उत्पाद मिलान

इंक्रीमेंटल: केवल नई क्वेरी से मिलान करें

स्किप लॉजिक: छोड़ दें यदि आउटपुट 7 दिन से कम पुराना है और स्क्रिप्ट अपरिवर्तित है

देखें: उत्पाद मिलान

कॉन्फ़िगरेशन

इंक्रीमेंटल प्रोसेसिंग प्रति चरण कॉन्फ़िगर की जाती है:

ताजगी सीमा

# Skip if output < 7 days old (default)
should_skip_step(output_path, script_path, days=7)

# Skip if output < 1 day old (for frequently changing data)
should_skip_step(output_path, script_path, days=1)

चेकपॉइंट आवृत्ति

# Save every 1,000 items (default)
incremental_embed_with_keys(..., checkpoint_every=1000)

# Save every 5,000 items (for faster processing, less safety)
incremental_embed_with_keys(..., checkpoint_every=5000)

बैच आकार

# Embed 32 items per batch (default, balanced)
incremental_embed_with_keys(..., batch_size=32)

# Embed 64 items per batch (faster on GPU, more memory)
incremental_embed_with_keys(..., batch_size=64)

निगरानी और डीबगिंग

कैश सांख्यिकी

प्रत्येक चरण कैश सांख्यिकी प्रिंट करता है:

✓ Found existing cache, checking for changes...
  Existing: 65,000 items
  Current:  65,300 items
  Reusing: 64,800 embeddings
  New:     500 items to embed

स्किप संदेश

जब चरण छोड़े जाते हैं:

✓ Skipping 0_embed_source_data.py: Output is fresh and script unchanged.

चेकपॉइंट संदेश

लंबे ऑपरेशन के दौरान:

Embedding 65,000 items (checkpointing every 1,000)...
  Batch 0-1000...
    ✓ Checkpoint saved (1,000 total)
  Batch 1000-2000...
    ✓ Checkpoint saved (2,000 total)
  ...

संदर्भ

तकनीकी अवधारणाएँ

संबंधित लेख

सारांश

इंक्रीमेंटल प्र