مشاركة المصفوفات الكبيرة Numpy بكفاءة بين العمليات في Python

إتقان الذاكرة المشتركة لعمليات نقل البيانات الكبيرة في بايثون

غالبًا ما يمثل العمل مع مجموعات البيانات الكبيرة في بايثون تحديات، خاصة عندما يكون هناك تدخل في المعالجة المتعددة. تقاسم ضخمة صفائف numpy بين العمليات الفرعية والعملية الأم دون النسخ غير الضروري هي إحدى هذه العقبات.

تخيل أنك تقوم بمعالجة البيانات العلمية أو النماذج المالية أو مدخلات التعلم الآلي، وكل مجموعة بيانات تشغل ذاكرة كبيرة. 🧠 على الرغم من أن وحدة المعالجة المتعددة في Python توفر طريقة لنشر العمليات الفرعية وإدارتها، إلا أن مشاركة البيانات بكفاءة مثل المصفوفات numpy قد يكون أمرًا صعبًا.

يصبح هذا الموضوع أكثر أهمية عندما تفكر في كتابة مجموعات البيانات الكبيرة هذه إلى ملف HDF5، وهو تنسيق معروف بقوته في التعامل مع كميات هائلة من البيانات المنظمة. بدون إدارة مناسبة للذاكرة، فإنك تخاطر بالتعرض لتسرب الذاكرة أو أخطاء "لم يتم العثور على الذاكرة"، مما يؤدي إلى تعطيل سير عملك.

في هذا الدليل، سنستكشف مفهوم الذاكرة المشتركة للمصفوفات numpy، باستخدام مسألة عملية كمرساة لدينا. باستخدام الأمثلة والنصائح الواقعية، ستتعلم كيفية التعامل بكفاءة مع البيانات الكبيرة مع تجنب الأخطاء الشائعة. دعونا نتعمق! 🚀

تحسين مشاركة المصفوفة Numpy بين العمليات

تركز النصوص المقدمة أعلاه على حل التحدي المتمثل في المشاركة الكبيرة صفائف numpy بين العمليات في بايثون دون تكرار البيانات. الهدف الأساسي هو استخدام الذاكرة المشتركة بشكل فعال، وضمان الاتصال الفعال والحد الأدنى من استخدام الموارد. من خلال الاستفادة من بايثون معالجة متعددة ووحدات الذاكرة المشتركة، يسمح الحل للعمليات الفرعية بتحميل المصفوفات numpy ومعالجتها ومشاركتها مرة أخرى إلى العملية الأصلية بسلاسة.

في البرنامج النصي الأول، تستخدم العملية الفرعية الذاكرة المشتركة فئة لتخصيص الذاكرة ومشاركة البيانات. يلغي هذا الأسلوب الحاجة إلى النسخ، وهو أمر ضروري للتعامل مع مجموعات البيانات الكبيرة. تتم إعادة بناء المصفوفة numpy في مساحة الذاكرة المشتركة، مما يسمح للعملية الأصلية بالوصول إلى المصفوفة مباشرة. يضمن استخدام قوائم الانتظار التواصل المناسب بين العمليات الأصلية والتابعة، مثل الإعلام عندما يمكن إلغاء ربط الذاكرة لتجنب التسريبات.

يعمل البرنامج النصي البديل على تبسيط إدارة العملية من خلال استخدام Pool.map وظيفة، والتي تعمل على أتمتة إنشاء العمليات والانضمام إليها. تقوم كل عملية فرعية بتحميل الملف الخاص بها وتستخدم الذاكرة المشتركة لإرجاع تفاصيل المصفوفة إلى العملية الأصلية. يعتبر هذا الأسلوب أنظف وأكثر قابلية للصيانة، خاصة عند العمل مع ملفات متعددة. إنه حل عملي لمهام مثل معالجة البيانات العلمية أو تحليل الصور، حيث يجب مشاركة مجموعات البيانات الكبيرة بكفاءة.

فكر في سيناريو من العالم الحقيقي حيث يقوم فريق بحث بمعالجة البيانات الجينومية المخزنة في ملفات نصية كبيرة. يحتوي كل ملف على ملايين الصفوف، مما يجعل النسخ غير عملي بسبب قيود الذاكرة. باستخدام هذه البرامج النصية، تقوم كل عملية فرعية بتحميل ملف، ويقوم الأصل بكتابة البيانات في ملف HDF5 واحد لمزيد من التحليل. باستخدام الذاكرة المشتركة، يتجنب الفريق استخدام الذاكرة الزائدة عن الحاجة، مما يضمن عمليات أكثر سلاسة. 🚀 لا تعمل هذه الطريقة على تحسين الأداء فحسب، بل تقلل أيضًا من الأخطاء مثل "لم يتم العثور على الذاكرة" أو تسرب الذاكرة، وهي أخطاء شائعة عند التعامل مع مثل هذه المهام. 🧠

from multiprocessing import Process, Queue
from multiprocessing.shared_memory import SharedMemory
import numpy as np
from pathlib import Path
def loadtxt_worker(out_queue, in_queue, filepath):
    dtype = [('chr', 'S10'), ('pos', '<i4'), ('pct', '<f4'), ('c', '<i4'), ('t', '<i4')]
    data = np.loadtxt(filepath, dtype=dtype)
    shm = SharedMemory(create=True, size=data.nbytes)
    shared_array = np.ndarray(data.shape, dtype=dtype, buffer=shm.buf)
    shared_array[:] = data
    out_queue.put({"name": shm.name, "shape": data.shape, "dtype": dtype})
    while True:
        msg = in_queue.get()
        if msg == "done":
            shm.close()
            shm.unlink()
            break
def main():
    filenames = ["data1.txt", "data2.txt"]
    out_queue = Queue()
    in_queue = Queue()
    processes = []
    for file in filenames:
        p = Process(target=loadtxt_worker, args=(out_queue, in_queue, file))
        p.start()
        processes.append(p)
    for _ in filenames:
        msg = out_queue.get()
        shm = SharedMemory(name=msg["name"])
        array = np.ndarray(msg["shape"], dtype=msg["dtype"], buffer=shm.buf)
        print("Array from child:", array)
        in_queue.put("done")
    for p in processes:
        p.join()
if __name__ == "__main__":
    main()

from multiprocessing import Pool, shared_memory
import numpy as np
from pathlib import Path
def load_and_share(file_info):
    filepath, dtype = file_info
    data = np.loadtxt(filepath, dtype=dtype)
    shm = shared_memory.SharedMemory(create=True, size=data.nbytes)
    shared_array = np.ndarray(data.shape, dtype=dtype, buffer=shm.buf)
    shared_array[:] = data
    return {"name": shm.name, "shape": data.shape, "dtype": dtype}
def main():
    dtype = [('chr', 'S10'), ('pos', '<i4'), ('pct', '<f4'), ('c', '<i4'), ('t', '<i4')]
    filenames = ["data1.txt", "data2.txt"]
    file_info = [(file, dtype) for file in filenames]
    with Pool(processes=2) as pool:
        results = pool.map(load_and_share, file_info)
        for res in results:
            shm = shared_memory.SharedMemory(name=res["name"])
            array = np.ndarray(res["shape"], dtype=res["dtype"], buffer=shm.buf)
            print("Shared Array:", array)
            shm.close()
            shm.unlink()
if __name__ == "__main__":
    main()

تعزيز مشاركة البيانات في بيئات المعالجة المتعددة

أحد الجوانب الحاسمة للعمل مع صفائف numpy كبيرة في المعالجة المتعددة هو ضمان المزامنة الفعالة وإدارة الموارد المشتركة. على الرغم من أن الذاكرة المشتركة تعد أداة قوية، إلا أنها تتطلب معالجة دقيقة لمنع التعارضات وتسرب الذاكرة. يضمن التصميم المناسب أن العمليات الفرعية يمكنها مشاركة المصفوفات مع العملية الأصلية دون تكرار البيانات أو الأخطاء غير الضرورية.

هناك عامل رئيسي آخر وهو التعامل مع أنواع البيانات والأشكال بشكل متسق. عندما تقوم عملية فرعية بتحميل البيانات باستخدام numpy.loadtxt، يجب أن تتم مشاركتها في نفس البنية عبر العمليات. وهذا مهم بشكل خاص عند الكتابة بتنسيقات مثل HDF5، حيث يمكن أن تؤدي البنية غير الصحيحة للبيانات إلى نتائج غير متوقعة أو ملفات تالفة. ولتحقيق ذلك، يعد تخزين البيانات التعريفية حول المصفوفة - مثل شكلها ونوعها واسم الذاكرة المشتركة - أمرًا ضروريًا لإعادة البناء بسلاسة في العملية الأصلية.

وفي تطبيقات العالم الحقيقي، مثل معالجة مجموعات البيانات المناخية الكبيرة أو ملفات تسلسل الجينوم، تتيح هذه التقنيات للباحثين العمل بكفاءة أكبر. من خلال الجمع بين الذاكرة المشتركة وقوائم الانتظار للاتصال، يمكن معالجة مجموعات البيانات الكبيرة بشكل متزامن دون التحميل الزائد على ذاكرة النظام. على سبيل المثال، تخيل معالجة بيانات الأقمار الصناعية حيث يمثل كل ملف درجة حرارة المنطقة مع مرور الوقت. 🚀 يجب أن يدير النظام هذه المصفوفات الضخمة دون اختناقات، مما يضمن أداءً سلسًا وقابلاً للتطوير للمهام التحليلية. 🌍