वाढीव प्रक्रिया: जलद पाइपलाइन अद्यतने

हा लेख 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)
  ...

संदर्भ

तांत्रिक संकल्पना

संबंधित लेख

सारांश

वाढीव प्रक्रिया पाइपलाइन 90-180× जलद बनवते:

तीन-स्तर रणनीती:

  • ✅ चरण वगळणे (आउटपुट ताजे असल्यास संपूर्ण चरण वगळा)

  • ✅ वाढीव एम्बेडिंग (फक्त नवीन/बदललेल्या वस्तू एम्बेड करा)

  • ✅ चेकपॉइंटिंग (प्रगती जतन करा, अपयशावर पुन्हा सुरू करा)

कार्यक्षमता:

  • ✅ पहिला रन: ~2.5 तास (संपूर्ण पाइपलाइन)

  • ✅ दैनंदिन रन: ~5 मिनिटे (वाढीव अद्यतने)

  • ✅ कॅश हिट दर: पहिल्या रननंतर 99%+

फायदे:

  • ✅ जलद दैनंदिन अद्यतने (तासांऐवजी मिनिटे)

  • ✅ स्वयंचलित अवैधीकरण (स्क्रिप्ट बदल पुन्हा-रन ट्रिगर करतात)

  • ✅ क्रॅश पुनर्प्राप्ती (चेकपॉइंटवरून पुन्हा सुरू करा)

  • ✅ मेमरी कार्यक्षम (बॅच प्रक्रिया)

ही रणनीती अपरिवर्तित डेटावर कॉम्प्युट वाया न घालवता दैनंदिन पाइपलाइन रन सक्षम करते.

← दस्तऐवज निर्देशांकावर परत