מאַטריץ קייפל איז אַ פונדאַמענטאַל אָפּעראַציע אין לינעאַר אַלגעבראַ.
מיר בכלל נוצן עס אין פילע אַפּלאַקיישאַנז אַזאַ ווי בילד פּראַסעסינג, מאַשין לערנען און פילע מער. NumPy איז אַ נאָוטאַבאַל פּיטהאָן פּעקל פֿאַר וויסנשאפטלעכע קאַמפּיוטינג.
אָבער, אין דעם פּאָסטן, מיר וועלן קוקן אין פאַרשידן מעטהאָדס פֿאַר מאַטריץ קייפל אין פּיטהאָן אָן ניצן NumPy.
מיר וועלן נוצן נעסטעד לופּס, די געבויט-אין מאַפּע () פֿונקציע, און רשימה קאַמפּרעשאַן.
אין אַדישאַן, מיר וועלן קוקן אין די בענעפיץ און דיסאַדוואַנטידזשיז פון יעדער סטראַטעגיע, ווי געזונט ווי ווען צו צולייגן יעדער פון זיי. אויב איר זענט נייַ מיט לינעאַר אַלגעבראַ און איר ווילן צו לערנען מער וועגן מאַטריץ קייפל; האַלטן אויף לייענען.
ווו טאָן מיר נוצן מאַטריץ מולטיפּליקאַטיאָן?
מאַטריץ קייפל איז געניצט אין קאָמפּיוטער גראַפיקס צו טוישן 2D און 3D וויזשוואַלז. פֿאַר בייַשפּיל, איר קענען דרייען, וואָג און איבערזעצן אַבדזשעקץ אויף דעם עקראַן. מאַטריץ זענען געניצט אין בילד פּראַסעסינג צו פאָרשטעלן בילדער ווי ערייז פון בילדצעלן. חוץ, מאַטריץ קענען זיין געוויינט צו דורכפירן אַפּעריישאַנז ווי בילד פֿילטרירונג.
מיר אויך נוצן מאַטריץ אין מאַשין וויסן. זיי קענען העלפֿן אונדז צו פאָרשטעלן דאַטן און מאָדעל פּאַראַמעטערס. מיר קענען אָנפירן פילע אַפּעריישאַנז, אַזאַ ווי קאַמפּיוטינג פּונקט פּראָדוקטן און מאַטריץ-וועקטאָר פּראָדוקטן.
שורלי, די אָפּעראַציע איז אויך זייער אַדוואַנטיידזשאַס אין וויסנשאפטלעכע אַפּעריישאַנז. מיר קענען נוצן עס אין פיזיק און ינזשעניעריע צו באַשרייַבן גשמיות קוואַנטאַטיז. דעריבער, מיר קענען אַרבעטן מיט וועקטאָרס און טענסאָרס.
פארוואס מיר קען נישט קלייַבן צו נוצן NumPy?
בשעת NumPy איז אַ פּיטהאָן ביבליאָטעק, עס איז ניט שטענדיק די ידעאַל אָפּציע פֿאַר מאַטריץ קייפל. מיר קען נישט קלייַבן צו נוצן NumPy פֿאַר סיבות ווי גרייס און דעפּענדענסי, לערנען און לעגאַט סיסטעמען.
ניצן Python ס געבויט-אין פאַנגקשאַנז אָדער דעוועלאָפּינג מנהג קאָד קען זיין מער עפעקטיוו אין עטלעכע ינסטאַנסיז. אָבער, עס איז קריטיש צו טאָן אַז NumPy איז אַ שטאַרק ביבליאָטעק. חוץ, איר קענען אויך נוצן עס פֿאַר מאַטריץ קייפל.
איצט, לאָמיר נעמען אַ קוק אין ווי קענען מיר דערגרייכן מאַטריץ קייפל אָן NumPy.
נעסטעד לופּס אופֿן
די נעסטעד לופּס טעכניק ניצט נעסטעד לופּס צו ויספירן מאַטריץ קייפל אין פּיטהאָן. די פֿונקציע יטערייץ איבער יעדער מאַטריץ עלעמענט. און, עס מאַלטאַפּלייז זיי מיט אַ סעריע פון נעסטעד לופּס. די פֿונקציע קערט דער רעזולטאַט, וואָס איז סטאָרד אין אַ נייַע מאַטריץ.
דעם צוגאַנג איז פּשוט צו פֿאַרשטיין. אָבער, עס קען נישט זיין ווי עפעקטיוו ווי אנדערע וועגן, ספּעציעל פֿאַר ביגער מאַטריץ. אָבער, עס איז אַ ווונדערלעך ברירה פֿאַר איר אויב איר זענט נייַ מיט לינעאַר אַלגעבראַ.
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]]
בענעפיץ:
- גרינג צו פֿאַרשטיין.
- גרויס פֿאַר נעווביעס אָדער יענע וואָס זוכן אַ דיפּער קאַמפּריכענשאַן פון מאַטריץ קייפל.
דיסאַדוואַנטידזשיז:
- ניט ווי עפעקטיוו ווי אָלטערנאַטיוו טעקניקס, ספּעציעל פֿאַר ביגער מאַטריץ.
- עס איז נישט אַזוי ליינעוודיק ווי אַלטערנאַטיווע אַפּראָוטשיז.
מאַפּע () פֿונקציע אופֿן
די מאַפּע () פֿונקציע אופֿן גיט אַן אַלטערנאַטיווע צוגאַנג פֿאַר מאַטריץ קייפל אין פּיטהאָן. אין דעם צוגאַנג, מיר נוצן די געבויט-אין מאַפּע () פֿונקציע. דעריבער, מיר נוצן אַ פאַנגקשאַנאַל פּראָגראַממינג געצייַג וואָס אַפּלייז אַ צוגעשטעלט פונקציע צו יעדער יטעראַבלע עלעמענט (רשימה, טופּלע, אאז"ו ו). אויך, די מאַפּע () פֿונקציע אַקסעפּץ צוויי פּאַראַמעטערס, אַ פֿונקציע און אַ יטעראַבלע. און, עס קערט אַן יטעראַטאָר וואָס אַפּלייז די פֿונקציע צו יעדער יטעראַבלע עלעמענט.
אין דעם צוגאַנג, מיר גיין דורך יעדער מיטגליד פון דער מאַטריץ און טאָן די קייפל מיט די נעסטעד מאַפּע () פֿונקציע.
די זיפּ () פֿונקציע איז געניצט צו יטערייט דורך יעדער עלעמענט פון די מאַטריץ אין פּאַראַלעל.
צום סוף, די סומע () פֿונקציע איז געניצט צו לייגן די רעזולטאַטן.
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]]
בענעפיץ
- קאַמפּערד צו די מאַפּע () פונקציע אופֿן, קירצער און מער ליינעוודיק.
דיסאַדוואַנטידזשיז
- עס קען זיין ווייניקער עפעקטיוו ווי ניצן די מאַפּע () פֿונקציע, ספּעציעל פֿאַר גרויס מאַטריץ.
- עס איז מער שווער ווי די נעסטעד לופּס צוגאַנג.
סאָף
אין דעם פּאָסטן, מיר געקוקט אויף אַלטערנאַטיוועס צו נוצן NumPy ווען מאַלטאַפּלייינג מאַטריסיז אין פּיטהאָן. מיר האָבן דורכגעקאָכט מאַטריץ קייפל אין נעסטעד לופּס, די געבויט-אין מאַפּע () פונקציע און רשימה קאַמפּרעשאַן.
דער בעסטער סטראַטעגיע וועט פאַרלאָזנ אויף די באַזונדער באדערפענישן פון דיין פּרויעקט.
יעדער פון די סטראַטעגיעס האט פּראָס און קאָנס פון זייַן אייגן. צו מאַכן זיכער אַז די פונקציע איז אַפּערייטינג רעכט, עס איז אַ גוטע געדאַנק צו לייגן עטלעכע פּראָבע קאַסעס מיט פאַרשידן מאַטריץ דימענשאַנז און וואַלועס.
איר זאָל אויך אַרייַננעמען עטלעכע פאָרשטעלונג טעסץ צו פאַרגלייַכן ווי געזונט די מעטהאָדס ויספירן.
לאָזן אַ ענטפֿערן