الوراثة الديناميكية للفئات المدركة لوحدة المعالجة المركزية/وحدة معالجة الرسومات في بايثون

التعامل مع المصفوفات الديناميكية مع الوراثة الشرطية في بايثون

يوضح هذا الحل الوراثة الديناميكية في لغة Python باستخدام NumPy وCuPy لمعالجة المصفوفات غير المعتمدة على وحدة المعالجة المركزية (CPU)/وحدة معالجة الرسومات (GPU). يستخدم برمجة Python الموجهة للكائنات من أجل المرونة والنمطية.

from typing import Union
import numpy as np
import cupy as cp
# Base class for shared functionality
class BaseArray:
    def bar(self, x):
        # Example method: Add x to the array
        return self + x
# Numpy-specific class
class NumpyArray(BaseArray, np.ndarray):
    pass
# CuPy-specific class
class CuPyArray(BaseArray, cp.ndarray):
    pass
# Factory function to handle conditional inheritance
def create_array(foo: Union[np.ndarray, cp.ndarray]):
    if isinstance(foo, cp.ndarray):
        return foo.view(CuPyArray)
    return foo.view(NumpyArray)
# Example usage
if __name__ == "__main__":
    foo_np = np.array([1.0, 2.0, 3.0])
    foo_cp = cp.array([1.0, 2.0, 3.0])
    array_np = create_array(foo_np)
    array_cp = create_array(foo_cp)
    print(array_np.bar(2))  # [3.0, 4.0, 5.0]
    print(array_cp.bar(2))  # [3.0, 4.0, 5.0] (on GPU)

نهج بديل باستخدام التفاف الطبقة

يستخدم هذا الحل فئة مجمعة لتفويض سلوك وحدة المعالجة المركزية/وحدة معالجة الرسومات ديناميكيًا بناءً على نوع الإدخال. ينصب التركيز على الكود النظيف وفصل الاهتمامات.

from typing import Union
import numpy as np
import cupy as cp
# Wrapper class for CPU/GPU agnostic operations
class ArrayWrapper:
    def __init__(self, foo: Union[np.ndarray, cp.ndarray]):
        self.xp = cp.get_array_module(foo)
        self.array = foo
    def add(self, value):
        return self.xp.array(self.array + value)
# Example usage
if __name__ == "__main__":
    foo_np = np.array([1.0, 2.0, 3.0])
    foo_cp = cp.array([1.0, 2.0, 3.0])
    wrapper_np = ArrayWrapper(foo_np)
    wrapper_cp = ArrayWrapper(foo_cp)
    print(wrapper_np.add(2))  # [3.0, 4.0, 5.0]
    print(wrapper_cp.add(2))  # [3.0, 4.0, 5.0] (on GPU)

اختبارات الوحدة لكلا الحلين

اختبارات الوحدة للتأكد من أن الحلول تعمل كما هو متوقع عبر بيئات وحدة المعالجة المركزية ووحدة معالجة الرسومات.

import unittest
import numpy as np
import cupy as cp
class TestArrayInheritance(unittest.TestCase):
    def test_numpy_array(self):
        foo = np.array([1.0, 2.0, 3.0])
        array = create_array(foo)
        self.assertTrue(isinstance(array, NumpyArray))
        self.assertTrue(np.array_equal(array.bar(2), np.array([3.0, 4.0, 5.0])))
    def test_cupy_array(self):
        foo = cp.array([1.0, 2.0, 3.0])
        array = create_array(foo)
        self.assertTrue(isinstance(array, CuPyArray))
        self.assertTrue(cp.array_equal(array.bar(2), cp.array([3.0, 4.0, 5.0])))
if __name__ == "__main__":
    unittest.main()

أسئلة أساسية حول الوراثة الديناميكية في بايثون

1. ما هو الميراث الديناميكي؟
2. يسمح الميراث الديناميكي للفئة بتعديل سلوكها أو الفئة الأصلية في وقت التشغيل بناءً على المدخلات، مثل التبديل بين NumPy و CuPy.
3. كيف get_array_module عمل؟
4. تحدد وظيفة CuPy هذه ما إذا كان المصفوفة عبارة عن ملف أم لا NumPy أو CuPy على سبيل المثال، تمكين اختيار الواجهة الخلفية للعمليات.
5. ما هو دور view() في الميراث؟
6. ال view() تقوم الطريقة في كل من NumPy وCuPy بإنشاء مثيل صفيف جديد بنفس البيانات ولكنه يعينه فئة مختلفة.
7. كيف يعمل الميراث الديناميكي على تحسين الأداء؟
8. من خلال تحديد الواجهات الخلفية المحسنة وتجنب المنطق الزائد، يضمن الميراث الديناميكي استخدامًا فعالاً لوحدة المعالجة المركزية ووحدة معالجة الرسومات.
9. هل يمكنني إضافة واجهات خلفية إضافية في المستقبل؟
10. نعم، من خلال تصميم منطق الوراثة الديناميكي الخاص بك بشكل نمطي، يمكنك تضمين مكتبات مثل TensorFlow أو JAX دون إعادة كتابة التعليمات البرمجية الموجودة.

الوجبات السريعة الرئيسية للميراث الديناميكي الفعال

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

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