المعالجة التدريجية: تحديثات خط الأنابيب السريعة

تشرح هذه المقالة كيف يستخدم خط أنابيب تحسين محركات البحث (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):
    # تحقق مما إذا كان الناتج موجودًا
    if not os.path.exists(output_path):
# ... (تفاصيل التنفيذ محذوفة)

الاستخدام

يتحقق كل نص برمجي عند بدء التشغيل:

from seo_common import should_skip_step

if should_skip_step(SEO_SOURCE_EMBEDDINGS_PATH, __file__):
    print("✓ تم التخطي: الناتج حديث والنص البرمجي لم يتغير")
    return

الفوائد

تشغيل يومي سريع: يتم تخطي معظم الخطوات إذا لم تتغير البيانات

إبطال تلقائي: تغييرات النص البرمجي تؤدي إلى إعادة التشغيل

قابلية ضبط الحداثة: اضبط المعلمة days لكل خطوة

استراتيجية التضمين التدريجي

كيف تعمل

عند تضمين العناصر (منتجات، استعلامات، عبارات):

تحميل ذاكرة التخزين المؤقت: اقرأ العناصر المضمنة مسبقًا ومفاتيحها

مقارنة المفاتيح: تحديد العناصر الجديدة والمتغيرة والمحذوفة

تضمين الجديد فقط: قم بتضمين العناصر غير الموجودة في ذاكرة التخزين المؤقت فقط

الدمج: اجمع التضمينات المخزنة مؤقتًا مع التضمينات الجديدة بالترتيب الصحيح

الحفظ: اكتب ذاكرة التخزين المؤقت المحدثة

التنفيذ

تتعامل الدالة incremental_embed_with_keys مع هذا:

def incremental_embed_with_keys(
    items,           # العناصر الحالية المراد تضمينها
    keys,            # مفاتيح فريدة للعناصر
# ... (تفاصيل التنفيذ محذوفة)

معدلات نجاح ذاكرة التخزين المؤقت

معدلات النجاح النموذجية لذواكر التخزين المؤقت بعد التشغيل الأول:

بيانات المصدر (منتجات، أجزاء، مقالات):

  • التشغيل الأول: 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 استعلام)

  • تضمين العبارات: دقيقتان (5,000 عبارة)

التشغيل اليومي (ذاكرة تخزين مؤقت دافئة):

  • تضمين المصدر: 10 ثوانٍ (300 عنصر، معدل نجاح 99.5%)

  • تضمين الاستعلامات: 5 ثوانٍ (500 استعلام، معدل نجاح 99.2%)

  • تضمين العبارات: ثانية واحدة (10 عبارات، معدل نجاح 99.8%)

التسريع: أسرع بـ 90-180 مرة

استراتيجية نقاط التفتيش

كيف تعمل

للعمليات طويلة الأمد (تضمين 65,000 عنصر):

المعالجة الدفعية: معالجة العناصر على دفعات (مثل 1,000 عنصر)

حفظ نقطة التفتيش: بعد كل دفعة، احفظ النتائج المتراكمة

الاستئناف عند الفشل: إذا تعطلت العملية، استأنف من آخر نقطة تفتيش

الحفظ النهائي: بعد كل الدفعات، احفظ النتائج الكاملة

التنفيذ

نقاط التفتيش مدمجة في incremental_embed_with_keys:

checkpoint_every = 1000  # احفظ كل 1,000 عنصر

embeddings_list = []
# ... (تفاصيل التنفيذ محذوفة)

الفوائد

استعادة بعد التعطل: استئناف من آخر نقطة تفتيش بدلاً من البدء من جديد

رؤية التقدم: رؤية التقدم كل 1,000 عنصر

كفاءة الذاكرة: المعالجة على دفعات، لا تحمل كل شيء في وقت واحد

التكامل عبر خط الأنابيب

تُستخدم المعالجة التدريجية في خطوات متعددة:

الخطوة 0: تضمين بيانات المصدر

تدريجي: قم بتضمين المنتجات والأجزاء والمقالات الجديدة/المتغيرة فقط

نقاط التفتيش: احفظ كل 1,000 عنصر

منطق التخطي: تخطى إذا كان عمر الناتج أقل من 7 أيام ولم يتغير النص البرمجي

انظر: تضمين بيانات المصدر

الخطوة 1: جلب الاستعلامات

تدريجي: مكالمات API تجلب البيانات الجديدة فقط (منذ آخر تشغيل)

منطق التخطي: تخطى إذا كان عمر الناتج أقل من يوم واحد

انظر: جلب الاستعلامات

الخطوة 3ب: تضمين الاستعلامات

تدريجي: قم بتضمين الاستعلامات الجديدة فقط

نقاط التفتيش: احفظ كل 1,000 استعلام

منطق التخطي: تخطى إذا كان عمر الناتج أقل من 7 أيام ولم يتغير النص البرمجي

انظر: تضمين الاستعلامات

الخطوة 4: توسيع تعيين العبارات

تدريجي: قم بتضمين العبارات الجديدة فقط

نقاط التفتيش: احفظ كل 1,000 عبارة

منطق التخطي: تخطى إذا كان عمر الناتج أقل من 7 أيام ولم يتغير النص البرمجي

انظر: تعيين العبارات على الفلاتر

الخطوة 6: مطابقة المنتجات

تدريجي: قم بمطابقة الاستعلامات الجديدة فقط

منطق التخطي: تخطى إذا كان عمر الناتج أقل من 7 أيام ولم يتغير النص البرمجي

انظر: مطابقة المنتجات

التكوين

يتم تكوين المعالجة التدريجية لكل خطوة:

حد الحداثة

# تخطى إذا كان عمر الناتج أقل من 7 أيام (افتراضي)
should_skip_step(output_path, script_path, days=7)

# تخطى إذا كان عمر الناتج أقل من يوم واحد (للبيانات المتغيرة بشكل متكرر)
should_skip_step(output_path, script_path, days=1)

تكرار نقاط التفتيش

# احفظ كل 1,000 عنصر (افتراضي)
incremental_embed_with_keys(..., checkpoint_every=1000)

# احفظ كل 5,000 عنصر (للمعالجة الأسرع، أمان أقل)
incremental_embed_with_keys(..., checkpoint_every=5000)

حجم الدفعة

# تضمين 32 عنصرًا لكل دفعة (افتراضي، متوازن)
incremental_embed_with_keys(..., batch_size=32)

# تضمين 64 عنصرًا لكل دفعة (أسرع على GPU، ذاكرة أكثر)
incremental_embed_with_keys(..., batch_size=64)

المراقبة والتصحيح

إحصائيات ذاكرة التخزين المؤقت

تطبع كل خطوة إحصائيات ذاكرة التخزين المؤقت:

✓ تم العثور على ذاكرة تخزين مؤقت موجودة، التحقق من التغييرات...
  الموجود: 65,000 عنصر
  الحالي:  65,300 عنصر
  إعادة الاستخدام: 64,800 تضمين
  الجديد:     500 عنصر للتضمين

رسائل التخطي

عند تخطي الخطوات:

✓ تخطي 0_embed_source_data.py: الناتج حديث والنص البرمجي لم يتغير.

رسائل نقاط التفتيش

أثناء العمليات الطويلة:

تضمين 65,000 عنصر (نقاط تفتيش كل 1,000)...
  الدفعة 0-1000...
    ✓ تم حفظ نقطة التفتيش (1,000 إجمالي)
  الدفعة 1000-2000...
    ✓ تم حفظ نقطة التفتيش (2,000 إجمالي)
  ...

المراجع

المفاهيم التقنية

مقالات ذات صلة

الملخص

تجعل المعالجة التدريجية خط الأنابيب أسرع بـ 90-180 مرة:

استراتيجية من ثلاث طبقات:

  • ✅ تخطي الخطوات (تخطي خطوات كاملة إذا كان الناتج حديثًا)

  • ✅ التضمين التدريجي (تضمين العناصر الجديدة/المتغيرة فقط)

  • ✅ نقاط التفتيش (حفظ التقدم، الاستئناف عند الفشل)

الأداء:

  • ✅ التشغيل الأول: ~2.5 ساعة (خط الأنابيب الكامل)

  • ✅ التشغيل اليومي: ~5 دقائق (تحديثات تدريجية)

  • ✅ معدلات نجاح ذاكرة التخزين المؤقت: 99%+ بعد التشغيل الأول

الفوائد:

  • ✅ تحديثات يومية سريعة (دقائق بدلاً من ساعات)

  • ✅ إبطال تلقائي (تغييرات النص البرمجي تؤدي إلى إعادة التشغيل)

  • ✅ استعادة بعد التعطل (الاستئناف من نقطة التفتيش)

  • ✅ كفاءة في الذاكرة (المعالجة على دفعات)

تمكن هذه الاستراتيجية من تشغيل خط الأنابيب يوميًا دون إهدار الحوسبة على البيانات غير المتغيرة.

← العودة إلى فهرس الوثائق