كيف تعمل einsum في مكتبة numpy؟

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

A = np.array([0, 1, 2])

B = np.array([[ 0,  1,  2,  3],
              [ 4,  5,  6,  7],
              [ 8,  9, 10, 11]])

سنضرب A و B من ناحية العناصر ثم نجمعها على طول صفوف المصفوفة الجديدة. في NumPy وبدون استخدام einsum نستخدم الطريقة التالية

(A[:, np.newaxis] * B).sum(axis=1)

//output
array([ 0, 22, 76])

هنا ، تبدأ عملية الفهرسة على المحاور الأولى من المصفوفتين بحيث يمكن بدأ عملية الضرب. يتم بعد ذلك تبدأ عملية جمع الصفوف , الآن إذا أردنا استخدام einsum بدلا من ذلك ، فيمكننا كتابة

np.einsum('i,ij->i', A, B)
//output
array([ 0, 22, 76])

سلسلة الحروف 'i، ij-> i' هي المفتاح هنا وتحتاج إلى القليل من الشرح. يمكنك التفكير في الأمر على انه نصفين. على الجانب الأيسر (يسار <-) قمنا بتسمية مصفوفتي الإدخال. إلى يمين -> ، قمنا بتسمية المصفوفة الناتجة, يحتوي A على محور واحد , لقد أطلقنا عليه اسم i , و B لها محورين , قمنا بتسمية المحور 0 على أنه i والمحور 1 على أنه j , بتكرار تسمية i في كلا مصفوفتي الإدخال ، فإننا نخبر einsum أنه يجب ضرب هذين المحورين معا. بعبارة أخرى ، نقوم بضرب المصفوفة A في كل عمود من المصفوفة B ، تماما مثل 

A [:، np.newaxis] * B

لاحظ أن j لا تظهر في اسم المصفوفة الناتجة , لقد استخدمنا i أي أننا نريد أن ينتهي بنا الأمر بمصفوفة 1D. بحذف التسمية ، فإننا نخبر einsum بالجمع على طول هذا المحور. بعبارة أخرى ، نحن نجمع صفوف المصفوفات، تماما كما يفعل

.sum(axis=1)

 إذا تركنا كلتا التسميتين في الإخراج ، "i، ij-> ij" ، فإننا نستعيد مصفوفة ثنائية الأبعاد من العناصر مثل

A [:، np.newaxis] * B

إذا قلنا لا توجد تسميات إخراج ، 'i، ij-> ، فسنسترجع رقمًا واحدا مثل 

(A [:، np.newaxis] * B) .sum ())

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

A = array([[1, 1, 1],
           [2, 2, 2],
           [5, 5, 5]])

B = array([[0, 1, 0],
           [1, 1, 0],
           [1, 1, 1]])

سنحسب الضرب النقطي باستخدام

np.einsum ('ij، jk-> ik'، A، B).

إليك صورة توضح وضع العلامات على A و B ومصفوفة الإخراج التي نحصل عليها 

يمكنك أن ترى أن التسمية j مكررة وهذا يعني أننا نضرب صفوف A في أعمدة B. وأيضا التسمية j غير مضمنة في الإخراج , نحن نجمع هذه العناصر. يتم الاحتفاظ بالتسميات i و k للإخراج ، لذلك نعود إلى مصفوفة ثنائية الأبعاد, لو استخدمنا j في التسمية كالتالي

np.einsum('ij,jk->ijk', A, B)

سوف تكون النتيجة كالتالي

هي طريقة أسرع وأكثر كفاءة ولاسيما في توفير الذاكرة للتعامل مع المصفوفات. ولاستخدام numpy.einsum، كل ما عليك فعله هو تمرير "subscript string" أو ما يسمى بالسلسلة المنخفضة كوسيطة أولى، حيث أن ال subscripts تشير إلى أبعاد المصفوفة بحيث كل بعد سيقابل label (مثلاً i أو j)، ثم مصفوفات الإدخال الخاصة بك كوسيط ثاني. لنفترض أن لديك مصفوفتان ثنائيتا الأبعاد ، A و B ، وتريد القيام بضرب المصفوفة. وبالتالي يكون الحل:

np.einsum("ij, jk -> ik", A, B)

ال subscripts (السلسلة المنخفضة) ij تتوافق مع المصفوفة A بينما تتوافق jk مع المصفوفة B. أيضاً، أهم شيء يجب ملاحظته هنا هو أن عدد الأحرف في كل subscript يجب أن يتطابق مع أبعاد المصفوفة. (على سبيل المثال ، حرفان للمصفوفات ثنائية الأبعاد ، وثلاثة أحرف للمصفوفات ثلاثية الأبعاد ، وهكذا..) وإذا كررت الأحرف بين السلاسل المنخفضة (j في حالتنا) ، فهذا يعني أنك تريد أن يحدث einsum على طول تلك الأبعاد. وبالتالي ، سيتم تخفيضها. (أي أن هذا البعد سوف يختفي).
ستكون السلسلة الموجودة بعد -> هي المصفوفة الناتجة. إذا تركتها فارغة، فسيتم جمع كل شيء وإرجاع قيمة عددية كنتيجة لذلك. عدا ذلك ، سيكون للمصفوفة الناتجة أبعاداً وفقاً للسلسلة المنخفضة. في مثالنا ، سيكون ik. هذا أمر بديهي لأننا نعلم أنه بالنسبة لضرب المصفوفة، يجب أن يتطابق عدد الأعمدة في المصفوفة A مع عدد الصفوف في المصفوفة B وهو ما يحدث هنا (على سبيل المثال ، نقوم بترميز هذه المعرفة عن طريق تكرار الحرف j في السلسلة المنخفضة).
فيما يلي بعض الأمثلة الأخرى التي توضح استخدام  np.einsum وقوتها في تنفيذ بعض عمليات الموتر "tensor array" أو المصفوفات متعددة الأبعاد:

# شعاع
vec
#array([0, 1, 2, 3])

# مصفوفة
A
"""
array([[11, 12, 13, 14],
       [21, 22, 23, 24],
       [31, 32, 33, 34],
       [41, 42, 43, 44]])
"""
# مصفوفة أخرى
B
"""
array([[1, 1, 1, 1],
       [2, 2, 2, 2],
       [3, 3, 3, 3],
       [4, 4, 4, 4]])
"""

1. ضرب المصفوفات:

np.einsum("ij, jk -> ik", A, B)
""" 
array([[130, 130, 130, 130],
       [230, 230, 230, 230],
       [330, 330, 330, 330],
       [430, 430, 430, 430]])
"""

2. استخراج العناصر على طول القطر الرئيسي:

np.einsum("ii -> i", A)
#array([11, 22, 33, 44])

3. ضرب العناصر المتقابلة في مصفوفين:

np.einsum("ij, ij -> ij", A, B)
"""
array([[ 11,  12,  13,  14],
       [ 42,  44,  46,  48],
       [ 93,  96,  99, 102],
       [164, 168, 172, 176]])
"""

4.التربيع:

np.einsum("ij, ij -> ij", B, B)
"""
array([[ 1,  1,  1,  1],
       [ 4,  4,  4,  4],
       [ 9,  9,  9,  9],
       [16, 16, 16, 16]])
"""

5.مجموع العناصر القطرية الرئيسية:

np.einsum("ii -> ", A)
# 110

6. منقول مصفوفة:

np.einsum("ij -> ji", A)
"""
array([[11, 21, 31, 41],
       [12, 22, 32, 42],
       [13, 23, 33, 43],
       [14, 24, 34, 44]])
"""

7. الضرب الخارجي للأشعة Outer Product :

np.einsum("i, j -> ij", vec, vec)
"""
array([[0, 0, 0, 0],
       [0, 1, 2, 3],
       [0, 2, 4, 6],
       [0, 3, 6, 9]])
"""

8. الضرب الداخلي inner:

np.einsum("i, i -> ", vec, vec) #14

9. الجمع على طول المحور  0 أو 1 أي الأسطر أو الأعمدة:

# المحور 0
np.einsum("ij -> j", B) #array([10, 10, 10, 10])
# المحور 1
np.einsum("ij -> j", B) #array([10, 10, 10, 10])

10. مجموع كل العناصر في مصفوفة:

np.einsum("ijk -> ", BM) # 480