ઇન્ક્રિમેન્ટલ પ્રોસેસિંગ: ઝડપી પાઇપલાઇન અપડેટ્સ

આ લેખ સમજાવે છે કે કેવી રીતે 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%+

લાભો:

  • ✅ ઝડપી દૈનિક અપડેટ્સ (કલાકોને બદલે મિનિટો)

  • ✅ આપોઆપ અમાન્યકરણ (સ્ક્રિપ્ટ ફેરફારો ફરી ચલાવવાનું ટ્રિગર કરે છે)

  • ✅ ક્રેશ પુનઃપ્રાપ્તિ (ચેકપોઇન્ટથી ફરી શરૂ કરો)

  • ✅ મેમરી કાર્યક્ષમ (બેચ પ્રોસેસિંગ)

આ વ્યૂહરચના યથાવત ડેટા પર કમ્પ્યુટ સંસાધનો બગાડ્યા વિના દૈનિક પાઇપલાઇન રનને સક્ષમ બનાવે છે.

← ડોક્યુમેન્ટેશન ઇન્ડેક્સ પર પાછા