تحسين كود Python لإجراء عمليات حسابية أسرع باستخدام Numpy

تعزيز الأداء في حسابات بايثون

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

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

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

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

تحسين حسابات مصفوفة بايثون للحصول على أداء أفضل

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

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

استخدام الأوامر مثل np.prod و np.random.randint يلعب دورا رئيسيا في هذه النصوص. np.prod يحسب منتج عناصر المصفوفة على طول محور محدد، وهو أمر حيوي لدمج شرائح البيانات في حساباتنا. في أثناء، np.random.randint ينشئ المؤشرات العشوائية اللازمة لاختيار عناصر محددة منها ش. تضمن هذه الأوامر، جنبًا إلى جنب مع إستراتيجيات معالجة البيانات الفعالة، أن يظل كلا الحلين فعالين حسابيًا وسهل التنفيذ. يمكن رؤية مثل هذه الأساليب في سيناريوهات الحياة الواقعية، كما هو الحال في التعلم الآلي عند التعامل مع عمليات الموتر أو حسابات المصفوفة في مجموعات البيانات واسعة النطاق. 💡

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

import numpy as np
# Define parameters
N = 1000
M = 500
L = 4
O = 10
C = np.random.randn(M)
IDX = np.random.randint(L, size=(N, O))
U = np.random.randn(M, N, L, L)
# Initialize result matrix H
H = np.zeros((M, N, N))
# Optimized vectorized calculation
for o in range(O):
    idx1 = IDX[:, o][:, None]
    idx2 = IDX[:, o][None, :]
    H += np.prod(U[:, o, idx1, idx2], axis=-1)
print("Matrix H calculated efficiently!")

import numpy as np
from multiprocessing import Pool
# Function to calculate part of H
def compute_chunk(n1_range):
    local_H = np.zeros((M, len(n1_range), N))
    for i, n1 in enumerate(n1_range):
        idx1 = IDX[n1]
        for n2 in range(N):
            idx2 = IDX[n2]
            local_H[:, i, n2] = np.prod(U[:, range(O), idx1, idx2], axis=1)
    return local_H
# Divide tasks and calculate H in parallel
if __name__ == "__main__":
    N_splits = 10
    ranges = [range(i, i + N // N_splits) for i in range(0, N, N // N_splits)]
    with Pool(N_splits) as pool:
        results = pool.map(compute_chunk, ranges)
    H = np.concatenate(results, axis=1)
    print("Matrix H calculated using multiprocessing!")

import time
import numpy as np
def test_matrix_calculation():
    start_time = time.time()
    # Test vectorized solution
    calculate_H_vectorized()
    print(f"Vectorized calculation time: {time.time() - start_time:.2f}s")
    start_time = time.time()
    # Test multiprocessing solution
    calculate_H_multiprocessing()
    print(f"Multiprocessing calculation time: {time.time() - start_time:.2f}s")
def calculate_H_vectorized():
    # Placeholder for vectorized implementation
    pass
def calculate_H_multiprocessing():
    # Placeholder for multiprocessing implementation
    pass
if __name__ == "__main__":
    test_matrix_calculation()

إطلاق العنان لإمكانات الحوسبة المتوازية في بايثون

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

جانب آخر يستحق النظر فيه هو تحسين استخدام الذاكرة. يتضمن السلوك الافتراضي لبايثون إنشاء نسخ جديدة من البيانات لعمليات معينة، مما قد يؤدي إلى استهلاك مرتفع للذاكرة. ولمواجهة ذلك، يمكن أن يؤدي استخدام هياكل البيانات الموفرة للذاكرة مثل عمليات NumPy الموضعية إلى إحداث فرق كبير. على سبيل المثال، استبدال المهام القياسية بوظائف مثل np.add وتمكين out المعلمة للكتابة مباشرة في المصفوفات الموجودة يمكن أن توفر الوقت والمساحة أثناء العمليات الحسابية. 🧠

وأخيرًا، يمكن أن يؤدي ضبط بيئتك للبرامج النصية ذات العمليات الحسابية الثقيلة إلى تحسينات كبيرة في الأداء. أدوات مثل Numba، الذي يجمع كود بايثون في تعليمات على مستوى الجهاز، يمكن أن يوفر تعزيزًا للأداء مشابهًا لـ C أو Fortran. يتفوق Numba في الوظائف العددية ويسمح لك بدمج التخصيص JIT (في الوقت المناسب) تجميع في البرامج النصية الخاصة بك بسلاسة. معًا، يمكن لهذه الاستراتيجيات تحويل سير عمل Python الخاص بك إلى قوة حسابية عالية الأداء. 🚀