ಇನ್ಕ್ರಿಮೆಂಟಲ್ ಪ್ರೊಸೆಸಿಂಗ್: ವೇಗದ ಪೈಪ್ಲೈನ್ ಅಪ್ಡೇಟ್ಗಳು

ಈ ಲೇಖನವು 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: ಉತ್ಪನ್ನ ಹೊಂದಾಣಿಕೆ

ಇನ್ಕ್ರಿಮೆಂಟಲ್: ಹೊಸ ಪ್ರಶ್ನೆಗಳನ್ನು ಮಾತ್ರ ಹೊಂದಿಸಿ