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

ఈ వ్యాసం 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: ఫ్రేజ్ మ్యాపింగ్ విస్తరణ

ఇంక్రిమెంటల్: కేవలం కొత్త పద