ഇൻക്രിമെന്റൽ പ്രോസസ്സിംഗ്: വേഗത്തിലുള്ള പൈപ്പ്ലൈൻ അപ്ഡേറ്റുകൾ

ഈ ലേഖനം 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 ഇനങ്ങളിലും പുരോഗതി കാണുക

മെമ്മറി കാര്യക്ഷമത: ബാച്ചുകളായി പ്രോസസ്സ് ചെയ്യുക, എല്ലാം ഒരുമിച്ച് ലോഡ് ചെയ്യരുത്

പൈപ്പ്ലൈനിലുടനീളം സംയോജനം

ഇൻക്രിമെന്റൽ പ്ര