כפל מטריצה היא פעולה בסיסית באלגברה לינארית.
בדרך כלל אנו משתמשים בו ביישומים רבים כגון עיבוד תמונה, למידת מכונה ורבים נוספים. NumPy היא חבילת Python בולטת עבור מחשוב מדעי.
עם זאת, בפוסט זה, נבחן שיטות שונות לביצוע כפל מטריצה ב-Python מבלי להשתמש ב-NumPy.
אנחנו ננצל לולאות מקוננות, הפונקציה המובנית map() והבנת רשימה.
בנוסף, נבחן את היתרונות והחסרונות של כל אסטרטגיה, וכן מתי ליישם כל אחת מהן. אם אתה חדש באלגברה לינארית ורוצה ללמוד עוד על כפל מטריצה; להמשיך לקרוא.
היכן אנו משתמשים בכפל מטריצה?
מכפלת מטריצה משמשת ב גרפיקה ממוחשבת כדי לשנות חזותיים דו-ממדיים ותלת-ממדיים. לדוגמה, ניתן לסובב, לשנות קנה מידה ולתרגם אובייקטים על המסך. מטריצות משמשות בעיבוד תמונה כדי לייצג תמונות כמערכים של פיקסלים. חוץ מזה, מטריצות עשויות לשמש לביצוע פעולות כמו סינון תמונות.
אנחנו גם עושים שימוש במטריצות ב למידת מכונה. הם יכולים לעזור לנו לייצג נתונים ופרמטרים של מודל. אנו יכולים לבצע מספר רב של פעולות, כגון מחשוב מוצרי נקודות ומוצרי מטריצה-וקטור.
בוודאי, פעולה זו היא גם בעלת יתרון רב בפעולות מדעיות. אנחנו יכולים להשתמש בו בפיזיקה ובהנדסה כדי לתאר כמויות פיזיקליות. לפיכך, אנו יכולים לפעול עם וקטורים וטנזורים.
מדוע ייתכן שלא נבחר להשתמש ב-NumPy?
בעוד NumPy הוא א ספריית פייתון, זו לא תמיד האפשרות האידיאלית לכפל מטריצה. ייתכן שלא נבחר להשתמש ב-NumPy מסיבות כמו גודל ותלות, למידה ומערכות מדור קודם.
שימוש בפונקציות המובנות של Python או פיתוח קוד מותאם אישית עשוי להיות יעיל יותר במקרים מסוימים. עם זאת, חשוב לציין ש-NumPy היא ספרייה חזקה. חוץ מזה, אתה יכול גם להשתמש בו עבור כפל מטריצה.
כעת, בואו נסתכל כיצד נוכל להשיג כפל מטריצה ללא NumPy.
שיטת לולאות מקוננות
טכניקת הלולאות המקוננות משתמשת בלולאות מקוננות כדי לבצע כפל מטריצה ב- Python. הפונקציה חוזרת על כל אלמנט מטריצה. וזה מכפיל אותם באמצעות סדרה של לולאות מקוננות. הפונקציה מחזירה את התוצאה, שנשמרת במטריצה חדשה.
גישה זו היא פשוטה לתפיסה. עם זאת, ייתכן שהוא לא יהיה יעיל כמו דרכים אחרות, במיוחד עבור מטריצות גדולות יותר. עם זאת, זו בחירה נפלאה עבורך אם אתה חדש באלגברה ליניארית.
def matrix_multiplication(A, B):
# Determine the matrices' dimensions.
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# הגדר את מטריצת התוצאה לאפסים.
result = [[0 for row in range(cols_B)] for col in
range(rows_A)]
# Iterate through rows of A
for s in range(rows_A):
# Iterate through columns of B
for j in range(cols_B):
# Iterate through rows of B
for k in range(cols_A):
result[s][j] += A[s][k] * B[k][j]
return result
בואו נביא דוגמה כיצד לעשות זאת. אתה יכול פשוט להוסיף שורות קוד אלה למטה כדי לבדוק את הדוגמה הזו.
# Sample matrices
A = [[1, 4, 3], [4, 9, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Perform matrix multiplication
result = matrix_multiplication(A, B)
# Print the result
print(result)
# Output: [[76, 84], [175, 194]]
יתרונות:
- קל להבנה.
- מצוין למתחילים או למי שמחפש הבנה מעמיקה יותר של כפל מטריצה.
חסרונות:
- לא יעיל כמו טכניקות חלופיות, במיוחד עבור מטריצות גדולות יותר.
- זה לא קריא כמו גישות חלופיות.
שיטת הפונקציה map()
שיטת הפונקציה map() מספקת גישה חלופית לביצוע כפל מטריצה ב-Python. בגישה זו אנו משתמשים בפונקציית map() המובנית. לפיכך, אנו משתמשים בכלי תכנות פונקציונלי המחיל פונקציה מסופקת על כל רכיב שניתן לחזור עליו (רשימה, tuple וכו'). כמו כן, הפונקציה map() מקבלת שני פרמטרים, פונקציה ו-Iterable. וזה מחזיר איטרטור שמחיל את הפונקציה על כל אלמנט שניתן לחזור עליו.
בגישה זו, אנו עוברים על כל איבר במטריצה ועושים את הכפל באמצעות הפונקציה () map Nested.
הפונקציה zip() משמשת כדי לחזור על כל רכיב של המטריצות במקביל.
לבסוף, הפונקציה sum() משמשת לחיבור התוצאות.
def matrix_multiplication(A, B):
# To get the dimensions of the matrices
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# We use map() function for multiplication.
result = [[sum(a * b for a, b in zip(row_a, col_b)) for
col_b in zip(*B)] for row_a in A]
return result
עכשיו, שוב, אנחנו יכולים לבדוק את הקוד שלנו עם דוגמה.
# Example matrices
A = [[3, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Use map() function to perform matrix multiplication
result = list(map(lambda x: list(map(lambda y: sum(i*j
for i,j in zip(x,y)), zip(*B))), A))
# Print the result
print(result)
# Output: [[72, 80], [139, 154]]
יתרונות
- יעיל יותר מגישת הלולאות המוערמות
- הוא משתמש בתכנות פונקציונלי כדי להפוך את הקוד לפשוט יותר.
חסרונות
- אנשים מסוימים שאינם בקיאים בתכנות פונקציונליות עשויים למצוא אותו פחות קריא.
- זה פחות מובן מטכניקת הלולאות המקוננות.
שיטת הבנת הרשימה
הבנת רשימה מאפשרת לך ליצור רשימה חדשה בשורת קוד אחת. לפיכך, זאת על ידי החלת ביטוי על כל חבר ברשימה קיימת.
בגישה זו, הכפל מתבצע על ידי איטרציה חוזרת ונשנית דרך כל איבר מטריצה. אנו משתמשים בהבנת רשימות שכבות.
# Sample matrices
A = [[1, 12, 3], [14, 5, 6]]
B = [[7, 8], [9, 10], [12, 12]]
# Matrix multiplication using list comprehension
result = [[sum(A[i][k] * B[k][j] for k in range(len(A[0])))
for j in range(len(B[0]))] for i in range(len(A))]
# Print the result
print(result)
[[151, 164], [215, 234]]
הטבות
- בהשוואה לשיטת הפונקציה map(), קצרה וקריאה יותר.
חסרונות
- זה עשוי להיות פחות יעיל משימוש בפונקציה map(), במיוחד עבור מטריצות גדולות.
- זה קשה יותר מגישת הלולאות המקוננות.
סיכום
בפוסט זה, בדקנו חלופות לשימוש ב-NumPy בעת הכפלת מטריצות ב-Python. ביצענו כפל מטריצה בלולאות מקוננות, פונקציית map() המובנית והבנת רשימה.
האסטרטגיה הטובה ביותר תסתמך על הצרכים המיוחדים של הפרויקט שלך.
לכל אחת מהאסטרטגיות יש יתרונות וחסרונות משלה. כדי לוודא שהפונקציה פועלת כראוי, מומלץ להוסיף כמה מקרי בדיקה עם מימדים וערכים מטריצות שונים.
עליך לכלול גם כמה מבחני ביצועים כדי להשוות את מידת הביצוע של שיטות אלה.
השאירו תגובה