Python میں CPU/GPU-Aware کلاسز کے لیے متحرک وراثت

Python میں مشروط وراثت کے ساتھ ڈائنامک ارے ہینڈلنگ

یہ حل CPU/GPU-agnostic array ہینڈلنگ کے لیے NumPy اور CuPy کا استعمال کرتے ہوئے 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)

کلاس ریپنگ کا استعمال کرتے ہوئے متبادل نقطہ نظر

یہ حل ان پٹ قسم کی بنیاد پر CPU/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 فنکشن تعین کرتا ہے کہ آیا ایک صف a ہے۔ NumPy یا CuPy مثال کے طور پر، آپریشنز کے لیے بیک اینڈ سلیکشن کو فعال کرنا۔
5. کا کردار کیا ہے۔ view() وراثت میں؟
6. دی view() NumPy اور CuPy دونوں میں طریقہ ایک ہی ڈیٹا کے ساتھ ایک نئی صف کی مثال بناتا ہے لیکن اسے ایک مختلف کلاس تفویض کرتا ہے۔
7. متحرک وراثت کارکردگی کو کیسے بہتر بناتی ہے؟
8. آپٹمائزڈ بیک اینڈز کو منتخب کرکے اور فالتو منطق سے بچ کر، متحرک وراثت CPU اور GPU کے موثر استعمال کو یقینی بناتی ہے۔
9. کیا میں مستقبل میں اضافی بیک اینڈز شامل کر سکتا ہوں؟
10. ہاں، اپنی متحرک وراثت کی منطق کو ماڈیولر انداز میں ڈیزائن کرکے، آپ موجودہ کوڈ کو دوبارہ لکھے بغیر TensorFlow یا JAX جیسی لائبریریوں کو شامل کر سکتے ہیں۔

موثر متحرک وراثت کے لیے کلیدی راستہ

Python میں متحرک وراثت لچکدار اور ہارڈویئر-ایگنوسٹک کلاسز بنانے کا ایک طاقتور طریقہ فراہم کرتی ہے۔ ماڈیولر اور کارآمد ڈیزائنوں کا انتخاب کرکے، آپ اس بات کو یقینی بناتے ہیں کہ آپ کا کوڈ برقرار رہے گا جبکہ NumPy اور CuPy جیسے مختلف بیک اینڈز کو اپناتے ہیں۔ اس استقامت سے ان پروجیکٹوں کو فائدہ ہوتا ہے جن میں اسکیل ایبلٹی اور کارکردگی کی ضرورت ہوتی ہے۔

اس مضمون میں دکھائے گئے حلوں کو شامل کرنا ڈویلپرز کو ڈومین کے لیے مخصوص چیلنجوں کو حل کرنے پر توجہ مرکوز کرنے کی اجازت دیتا ہے۔ حقیقی دنیا کی مثالیں، جیسے کہ CPU پروٹو ٹائپس سے GPU- بھاری کام کے بوجھ میں منتقلی، قابل اطلاق کوڈ کی اہمیت کو اجاگر کرتی ہے۔ ان اصولوں کے ساتھ، متحرک وراثت مضبوط Python پروگرامنگ کا سنگ بنیاد بن جاتی ہے۔ 💡