ವರ್ಧಾತ್ಮಕ ಪ್ರಕ್ರಿಯೆ: ವೇಗದ ಪೈಪ್ಲೈನ್ ನವೀಕರಣಗಳು

ಈ ಲೇಖನವು 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%+

ಪ್ರಯೋಜನಗಳು:

  • ✅ ವೇಗದ ದೈನಂದಿನ ನವೀಕರಣಗಳು (ಗಂಟೆಗಳ ಬದಲಿಗೆ ನಿಮಿಷಗಳು)

  • ✅ ಸ್ವಯಂಚಾಲಿತ ಅಮಾನ್ಯೀಕರಣ (ಸ್ಕ್ರಿಪ್ಟ್ ಬದಲಾವಣೆಗಳು ಮರು-ರನ್ ಅನ್ನು ಪ್ರಚೋದಿಸುತ್ತವೆ)

  • ✅ ಕ್ರ್ಯಾಶ್ ಚೇತರಿಕೆ (ಚೆಕ್ಪಾಯಿಂಟ್‌ನಿಂದ ಪುನರಾರಂಭಿಸಿ)

  • ✅ ಮೆಮೊರಿ ದಕ್ಷ (ಬ್ಯಾಚ್ ಪ್ರಕ್ರಿಯೆ)

ಈ ತಂತ್ರವು ಬದಲಾಗದ ಡೇಟಾದ ಮೇಲೆ ಕಂಪ್ಯೂಟ್ ಅನ್ನು ವ್ಯರ್ಥ ಮಾಡದೆ ದೈನಂದಿನ ಪೈಪ್ಲೈನ್ ರನ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.

← ದಸ್ತಾವೇಜನ್ನು ಸೂಚಿಕೆಗೆ ಹಿಂತಿರುಗಿ