אלגברה ליניארית למדעי הנתונים

פעולות ב-NumPy ותרגילי Boyd

אותן פעולות מתמטיות מן החלק התאורטי — עכשיו בקוד קצר, וקטורי וניתן לבדיקה.

מתחילים לתרגילי הספר

X + Y

a * X

dot product

חיבור וחיסור

ב-NumPy הפעולות מתבצעות איבר־איבר.

NumPyaddition / subtraction

import numpy as np

X = np.array([1, 2, 3])
Y = np.array([10, 20, 30])

print(X + Y)   # [11 22 33]
print(X - Y)   # [ -9 -18 -27]

כפל בסקלר והוספת סקלר

שתי פעולות שונות עם אותו מספר.

כפלa * X

X = np.array([1, 2, 3])
a = 5

print(a * X)
# [ 5 10 15]

הוספה לכל איברX + a

X = np.array([1, 2, 3])
a = 5

print(X + a)
# [6 7 8]

Broadcasting: NumPy מחיל את אותו סקלר על כל איברי הווקטור.

פעולות איבר־איבר

הפעולות מן השקופית: X*Y, X/Y, X**Y.

Elementwise operationsכפל, חילוק וחזקה

X = np.array([2, 4, 8])
Y = np.array([1, 2, 3])

print(X * Y)    # [ 2  8 24]
print(X / Y)    # [2. 2. 2.666...]
print(X ** Y)   # [  2  16 512]

קומבינציה ליניארית בקוד

מקרה פשוט ופונקציה כללית.

שני וקטוריםa*X + b*Y

X = np.array([1, 0, 2])
Y = np.array([0, 3, 1])

a = 2
b = -1

Z = a * X + b * Y
print(Z)
# [ 2 -3  3]

פונקציה כלליתcoefficients @ matrix

def linear_combination(vectors, coefficients):
    matrix = np.vstack(vectors)
    coefficients = np.asarray(coefficients)
    return coefficients @ matrix

מעבדת פעולות

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

X₁ X₂ Y₁ Y₂

X + Y[5, 6]

X * Y[6, 8]

X / Y[0.667, 2]

X @ Y14

בדיקת חוק הפילוג

הקוד בודק שהצד השמאלי שווה לצד הימני.

\[ a(X+Y)=aX+aY \]

X = np.array([1, 2, 3])
Y = np.array([4, 5, 6])
a = 3

left  = a * (X + Y)
right = a * X + a * Y

תוצאת הבדיקה

np.array_equal(left, right)

True

זו אינה הוכחה מתמטית כללית, אלא בדיקה מספרית לדוגמה מסוימת.

מכפלה פנימית

האופרטור @ או הפונקציה np.dot.

Inner productscalar output

X = np.array([1, 2, 3])
Y = np.array([4, 5, 6])

print(X @ Y)          # 32
print(np.dot(X, Y))  # 32

לא להתבלבל: X * Y מחזיר וקטור; X @ Y מחזיר סקלר.

זמן עבודה של קוד

מדידה מעשית של פעולה וקטורית.

timeitהשוואה חוזרת

import timeit
import numpy as np

n = 1_000_000
X = np.ones(n)
Y = np.ones(n)

elapsed = timeit.timeit(
    lambda: X @ Y,
    number=20
)

print(elapsed)

תרגילים מן הספר

רשימת התרגילים המקורית נשמרה ללא החלפה.

Exercise1.11

Exercise1.13

Exercise1.16

Exercise1.20

כלל הקורס: הדוגמאות והתרגילים הנוספים בעמוד מרחיבים את תרגילי Boyd, אך אינם מחליפים אותם.

תרגול קצר נוסף

הכנה לפני תרגילי הספר.

משימה 1

\[X=(2,4),\qquad Y=(3,2)\]

חשבו את X*Y ואת X@Y.

\[X\odot Y=(6,8),\qquad X^TY=14\]

משימה 2

מה מחזיר הקוד?

X = np.array([1, 2, 3])
Y = np.array([4, 5, 6])
2 * X + Y

[ 6  9 12]

Take-home message

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

1+ ו-- פועלים איבר־איבר.

2a*X הוא כפל בסקלר; X+a הוא broadcasting.

3X*Y, X/Y, X**Y הן פעולות איבר־איבר.

4קומבינציה ליניארית נכתבת ישירות כ-a*X+b*Y.

5@ מחשב מכפלה פנימית.

6בדיקת קוד אינה מחליפה הוכחה מתמטית.

✓

מפת כיסוי

סעיפים 1.8–1.9 נשמרו והורחבו.

חומר המקור	המיקום החדש
כותרת 1.8 — פייתון חלק 2	Hero
חיבור וחיסור	חיבור וחיסור ב-NumPy
כפל וקטור בסקלר	`a * X`
הוספת אותו סקלר לכל איבר	`X + a` ו-broadcasting
פעולות איבר־איבר `XY`, `X/Y`, `X*Y`	Elementwise operations
קומבינציה ליניארית `aX+bY`	דוגמה ופונקציה כללית
בדיקת חוק הפילוג	בדיקת `array_equal`
מכפלה פנימית	`@` ו-`np.dot`
זמן עבודה של קוד	`timeit`
תרגילים 1.11, 1.13, 1.16, 1.20	רשימת תרגילי Boyd