8 דברים שאתה חייב לדעת כשאתה עובד עם ספריית Numpy של Python

מחבר:
בתאריך:

ספריית Numpy של Python מאפשרת לעבוד עם מערכים רב-מימדיים, ומספקת פונקציות מתמטיות לעבודה עם המערכים.

מערכים של Python דומים לרשימות בזה שהם מורכבים מרשימה של פריטים. ההבדל העיקרי הוא שכל פריטי המערך חייבים להיות מאותו סוג נתונים (int, float, string).

כיצד לייבא את numpy?

import numpy as np

 

2. כיצד כותבים מערך רב-מימדי?

a = np.array([[1, 2, 3] , [4, 5, 6]])
  • מערך זה מכיל 2 שורות ו- 3 עמודות, ואם נדפיס אותו נקבל ב-Jupyter notebook:
    array([[1, 2, 3],
           [4, 5, 6]])
  • ממש טבלה עם שורות ועמודות, ומכאן החובה להקפיד על מספר פריטים זהה בכל השורות.
  • חובה להקפיד על סוג נתונים אחיד בכל הפריטים (כולם int בדוגמה שלנו).
  • זה יעבוד גם עם float

ניתן לכתוב מערכים רב-מימדיים בדרגות מורכבות שונות, לדוגמה, מערך המכיל שורת נתונים אחת:

b = np.array([[1, 2, 3]])

שתי שורות:

c = np.array([[0, 1, 2], [3, 4, 5]])

שלוש שורות:

d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

וכיו"ב, כמה שורות שצריך.

 

3. כיצד לסקור את המערכים?

a.shape
(2, 3)
  • מציג tuple עם מספר השורות והעמודות.

בדיקה של סוג הנתונים של המערך:

type(a)

תיתן את התוצאה:

numpy.ndarray

שמשמעותה מערך רב-מימדי של numpy.

 

4. מהם וקטורים, מטריקסים וטנסורים?

וקטור הוא אובייקט שניתן לכתוב באמצעות מערך חד-מימדי בשורה אחת:

v = np.array([1, 2, 3])

מטריקס הוא אובייקט שניתן לכתוב באמצעות מערך רב-ממדי בשתי שורות או יותר:

מטריקס של שתי שורות:

m = np.array([[2, 3, 4], [5, 6, 7]])

אפשר לראות שהמטריקס מורכב משני וקטורים. כשנדפיס אותו נקבל את התוצאה הבאה:

array([[2, 3, 4],
       [5, 6, 7]])

המטריקס יכול להכיל יותר משני וקטורים, לדוגמה שלושה וקטורים:

m = np.array([[2, 3, 4], [5, 6, 7],[-1, 4, 6]])
array([[ 2,  3,  4],
       [ 5,  6,  7],
       [-1,  4,  6]])

טנסורים הם מערכים רב-ממדיים מסדר גבוה.

בואו נדגים את זה:

נוסיף מטריקס m1 שיהיה באותה הצורה של המטריקס m:

m1 = np.array([[4, -2, 5],  [2, 3, -1]])

נייצר משני המטריקסים טנסור באופן הבא:

t = np.array([m, m1])

נדפיס את הטנסור, ונקבל:

array([[[ 2,  3,  4],
        [ 5,  6,  7]],

       [[ 4, -2,  5],
        [ 2,  3, -1]]])

לסיכום, טנסור הוא אוסף של מטריקסים.

 

5. כיצד לגשת לפריטים בתוך המערך?

לדוגמה, רוצים לגשת לפריט השני בשורה הראשונה:

a[0, 1] // 2

זכרו! מחשבים מתחילים לספור מאפס.

כדי לשנות את ערכו של פריט ניתן להציב לתוכו את הערך החדש:

a[0, 1] = 7

נדפיס את המערך לאחר השינוי:

array([[1, 7, 3],
       [4, 5, 6]])

כיצד לגשת לכל הפריטים של שורה מסויימת (לדוגמה, כל הפריטים בשורה הראשונה)?

a[0]
array([1, 7, 3])

וניתן לגשת לכל הפריטים של עמודה מסוימת. לדוגמה, כיצד לגשת לכל הפריטים בעמודה השנייה בכל אחת מהשורות של המערך?

a[: , 1]
array([7, 5])

 

6. כיצד לבצע פעולות חשבוניות על מערכים?

ניתן לבצע פעולות חשבוניות על מערכים.

הכפלה של מערך:

2 * a
array([[ 2, 14,  6],
       [ 8, 10, 12]])

יכפיל את הערך של כל אחד מהפריטים במערך פי - 2.

חיבור של מערכים:

a + b
array([[2, 9, 6],
       [5, 7, 9]])

יחבר כל אחד מהפריטים במערך a עם כל אחד מהפריטים המקבילים במערך השני (לדוגמה, הפריט הראשון בשורה הראשונה של a יחובר עם הפריט הראשון בשורה הראשונה של b, כנ"ל הפריט השני בשורה הראשונה, וכיו"ב כמספר הפריטים).

באותו אופן, ניתן לכפול בין מערכים:

a * b
array([[ 1, 14,  9],
       [ 4, 10, 18]])

וגם לחלק:

a / b
array([[ 1. ,  3.5,  1. ],
       [ 4. ,  2.5,  2. ]])

מכיוון שפעולות החשבון מתבצעות על פריטים מקבילים המבנה של המערכים חייב להיות זהה (מספר זהה של שורות ושל עמודות) .

 

7. טרנספוזיציה

וקטורים מתחלקים לשני סוגים, וקטורים של שורה או וקטורים של עמודה. וטרנספוזיציה היא פעולה שהופעת וקטור של שורה לוקטור של עמודה, והפוך.

כדי שפייתון יבצע טרנספוזיציה צריך להשתמש בתחביר הבא:

vector.T

אבל אם ננסה לעשות טרנספוזיציה סתם ככה על וקטור נגלה שזה לא עובד:

v = np.array([1, 2, 3])
v.T
array([1, 2, 3])

הסיבה היא שפייתון דורש שקודם נהפוך את הוקטור למערך רב-ממדי:

v_reshaped = v.reshape(1,3)
v_reshaped

ורק על המערך הרב ממדי נוכל לעשות את הטרנספוזיציה:

v_reshaped_transposed = v_reshaped.T
v_reshaped_transposed
array([[1],
       [2],
       [3]])

כפי שאפשר לראות, הערכים נשארים אבל המיקום שלהם משתנה.

באותה מידה שאפשר להפוך וקטור של שורה לוקטור של עמודה, אפשר גם הפוך:

v_reshaped_transposed_twice = v_reshaped_transposed.T
v_reshaped_transposed_twice
array([1, 2, 3])

טרנספוזיציה אפשר לעשות גם על מטריקסים:

m = np.array([[1, 2], [2, 4], [5, 6]])
m
array([[1, 2],
       [2, 4],
       [5, 6]])

נעשה טרנספוזיציה למטריקס:

m_transposed = m.T
m_transposed
array([[1, 2, 5],
       [2, 4, 6]])

 

8. כיצד לבצע מכפלות של מערכים בעלי מבנה שונה?

בתנאים מסוימים ניתן לבצע מכפלות בין מערכים בעלי ממדים שונים באמצעות הפונקציה dot של numpy.

לדוגמה, נכפיל את הוקטור v במטריקס m:

v = np.array([1, 2, 3])

m = np.array([[2, 3, 4], [5, 6, 7], [1, 5, 8]])

np.dot(v, m)
array([20, 38, 35])

התנאי להכפלה של מערכים היא שמספר העמודות במערך הראשון יהיה שווה למספר השורות במערך השני מכיוון שהמכפלה מתבצעת בין וקטורי השורה שמהם מורכב המערך הראשון ווקטורי העמודה של המערך השני.

התנאי להכפלה של מערכים היא שמספר העמודות במערך הראשון יהיה שווה למספר השורות במערך השני

בהתחשב בכך שתפקיד פעולת הטרנספוזיציה הוא להפוך וקטורים של שורה לוקטורים של עמודה והפוך, לפעמים נוכל להשתמש בטרנספוזיציה כתנאי מקדים לביצוע מכפלות. דרך נוספת היא שימוש בפעולת reshape של python:

לדוגמה:

m1 = np.array([[-5, 8], [2,1], [-7, 3]])
m2 = np.array([[2, 3], [6, -4], [7, 42]])

np.dot(m1,m2)

יגרום להודעת השגיאה הבאה:

ValueError                                Traceback (most recent call last)
 in ()
      2 m2 = np.array([[2, 3], [6, -4], [7, 42]])
      3 
----> 4 np.dot(m1,m2)

ValueError: shapes (3,2) and (3,2) not aligned: 2 (dim 1) != 3 (dim 0)

כיוון שמספר השורות במטריקס הראשון אינו שווה למספר העמודות במטריקס השני.

הפתרון במקרה זה הוא לשנות את הצורה של המטריקס הראשון כדי שיכיל 2 וקטורים של שורה שבכל אחד 3 ערכים, ורק אז לבצע את המכפלה:

m1 = np.array([[-5, 8], [2,1], [-7, 3]])
m1_reshape = m1.reshape(2,3)
m2 = np.array([[2, 3], [6, -4], [7, 42]])

np.dot(m1_reshape, m2)
array([[ 52,  37],
       [-19, 157]])

לכל המדריכים בנושא של למידת מכונה

 

אהבתם? לא אהבתם? דרגו!

0 הצבעות, ממוצע 0 מתוך 5 כוכבים

 

הוסף תגובה חדשה

 

= 6 + 2