ఇన్‌క్రిమెంటల్ ప్రాసెసింగ్: ఫాస్ట్ పైప్‌లైన్ అప్‌డేట్స్

ఈ కథనం 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 రోజు కంటే తక్కువ ఉంటే దాటవేయండి

చూడండి: క్వెరీ ఫెచింగ్

దశ 3బి: క్వెరీ ఎంబెడ్డింగ్

ఇన్‌క్రిమెంటల్: కొత్త క్వెరీలను మాత్రమే ఎంబెడ్ చేయండి

చెక్‌పాయింటింగ్: ప్రతి 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%+

ప్రయోజనాలు:

  • ✅ వేగవంతమైన రోజువారీ నవీకరణలు (గంటలకు బదులు నిమిషాలు)

  • ✅ స్వయంచాలక చెల్లుబాటు రద్దు (స్క్రిప్ట్ మార్పులు తిరిగి అమలును ప్రేరేపిస్తాయి)

  • ✅ క్రాష్ రికవరీ (చెక్‌పాయింట్ నుండి కొనసాగించండి)

  • ✅ మెమరీ సామర్థ్యం (బ్యాచ్ ప్రాసెసింగ్)

ఈ వ్యూహం మారని డేటాపై కంప్యూట్ వృథా చేయకుండా రోజువారీ పైప్‌లైన్ రన్‌లను అనుమతిస్తుంది.

← డాక్యుమెంటేషన్ ఇండెక్స్‌కు తిరిగి వెళ్ళండి