Δυναμική κληρονομικότητα για κλάσεις CPU/GPU-Aware στην Python

Χειρισμός δυναμικού πίνακα με κληρονομικότητα υπό όρους στην Python

Αυτή η λύση επιδεικνύει δυναμική κληρονομικότητα στην 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)

Εναλλακτική προσέγγιση με χρήση της αναδίπλωσης τάξης

Αυτή η λύση χρησιμοποιεί μια κλάση περιτυλίγματος για να εκχωρήσει δυναμικά τη συμπεριφορά 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)

Δοκιμές μονάδων και για τις δύο λύσεις

Δοκιμές μονάδας για να διασφαλιστεί ότι οι λύσεις λειτουργούν όπως αναμένεται σε περιβάλλοντα CPU και 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()

Βασικές ερωτήσεις σχετικά με τη δυναμική κληρονομικότητα στην Python

1. Τι είναι η δυναμική κληρονομικότητα;
2. Η δυναμική κληρονομικότητα επιτρέπει σε μια κλάση να προσαρμόζει τη συμπεριφορά της ή τη γονική της τάξη κατά το χρόνο εκτέλεσης με βάση την είσοδο, όπως η εναλλαγή μεταξύ NumPy και CuPy.
3. Πώς κάνει get_array_module εργασία;
4. Αυτή η συνάρτηση CuPy καθορίζει εάν ένας πίνακας είναι α NumPy ή CuPy για παράδειγμα, ενεργοποιώντας την επιλογή backend για λειτουργίες.
5. Ποιος είναι ο ρόλος του view() στην κληρονομιά;
6. Ο view() Η μέθοδος τόσο στο NumPy όσο και στο CuPy δημιουργεί μια νέα παρουσία πίνακα με τα ίδια δεδομένα, αλλά της εκχωρεί διαφορετική κλάση.
7. Πώς η δυναμική κληρονομικότητα βελτιώνει την απόδοση;
8. Επιλέγοντας βελτιστοποιημένα backend και αποφεύγοντας την περιττή λογική, η δυναμική κληρονομικότητα εξασφαλίζει αποτελεσματική χρήση της CPU και της GPU.
9. Μπορώ να προσθέσω επιπλέον backend στο μέλλον;
10. Ναι, σχεδιάζοντας τη λογική δυναμικής κληρονομικότητας σπονδυλωτά, μπορείτε να συμπεριλάβετε βιβλιοθήκες όπως το TensorFlow ή το JAX χωρίς να ξαναγράψετε τον υπάρχοντα κώδικα.

Βασικά σημεία για την αποτελεσματική δυναμική κληρονομικότητα

Η δυναμική κληρονομικότητα στην Python παρέχει έναν ισχυρό τρόπο δημιουργίας ευέλικτων και αγνωστικών κλάσεων υλικού. Επιλέγοντας αρθρωτά και αποτελεσματικά σχέδια, διασφαλίζετε ότι ο κώδικάς σας παραμένει διατηρήσιμος ενώ προσαρμόζεται σε διαφορετικά backends όπως το NumPy και το CuPy. Αυτή η ευελιξία ωφελεί έργα που απαιτούν επεκτασιμότητα και απόδοση.

Η ενσωμάτωση λύσεων όπως αυτές που παρουσιάζονται σε αυτό το άρθρο επιτρέπει στους προγραμματιστές να επικεντρωθούν στην επίλυση προκλήσεων για συγκεκριμένους τομείς. Παραδείγματα πραγματικού κόσμου, όπως η μετάβαση από πρωτότυπα CPU σε βαρύ φόρτο εργασίας GPU, τονίζουν τη σημασία του προσαρμόσιμου κώδικα. Με αυτές τις αρχές, η δυναμική κληρονομικότητα γίνεται ο ακρογωνιαίος λίθος του ισχυρού προγραμματισμού Python. 💡