Matrixmultiplikatioun ass eng fundamental Operatioun an der linearer Algebra.
Mir benotzen et allgemeng a villen Uwendungen wéi Bildveraarbechtung, Maschinnléieren, a vill méi. NumPy ass e Notabele Python Package fir wëssenschaftlech Informatik.
Wéi och ëmmer, an dësem Post wäerte mir verschidde Methoden kucken fir Matrixmultiplikatioun am Python ze maachen ouni NumPy ze benotzen.
Mir wäerte benotzen nestéiert Schlëff, der gebaut-an Kaart () Funktioun, a Lëscht Versteesdemech.
Zousätzlech wäerte mir d'Virdeeler an Nodeeler vun all Strategie kucken, wéi och wéini jidderee vun hinnen applizéiert. Wann Dir nei an der linearer Algebra sidd a méi iwwer Matrixmultiplikatioun léiere wëllt; weider liesen.
Wou benotze mir Matrixmultiplikatioun?
Matrixmultiplikatioun gëtt benotzt an Computer Grafiken fir 2D an 3D Visuals z'änneren. Zum Beispill kënnt Dir Objeten um Écran rotéieren, skaléieren an iwwersetzen. Matrixen ginn an der Bildveraarbechtung benotzt fir Biller als Arrays vu Pixelen ze representéieren. Donieft kënne Matrixen benotzt ginn fir Operatiounen wéi Bildfilter ze maachen.
Mir benotzen och Matrixen an Maschinn léieren. Si kënnen eis hëllefen Daten a Modellparameter ze representéieren. Mir kënne vill Operatiounen ausféieren, sou wéi Rechenpunktprodukter a Matrix-Vektorprodukter.
Sécherlech ass dës Operatioun och ganz avantagéis fir wëssenschaftlech Operatiounen. Mir kënnen et an der Physik an der Ingenieur benotzen fir kierperlech Quantitéiten ze beschreiwen. Dofir kënne mir mat Vektoren an Tensoren operéieren.
Firwat kënne mir net wielen NumPy ze benotzen?
Wärend NumPy ass eng Python Bibliothéik, et ass net ëmmer déi ideal Optioun fir Matrixmultiplikatioun. Mir kënnen net wielen NumPy ze benotzen aus Grënn wéi Gréisst an Ofhängegkeet, Léieren a Legacy Systemer.
D'Benotzung vu Python agebaute Funktiounen oder d'Entwécklung vu personaliséierte Code kann an e puer Fäll méi effizient sinn. Et ass awer entscheedend ze bemierken datt NumPy eng staark Bibliothéik ass. Ausserdeem kënnt Dir et och fir Matrixmultiplikatioun benotzen.
Loosst eis elo kucken wéi kënne mir Matrixmultiplikatioun ouni NumPy erreechen.
Nested Loops Method
Déi nested Loops Technik benotzt nested Loops fir Matrixmultiplikatioun am Python auszeféieren. D'Funktioun iteréiert iwwer all Matrixelement. An, et multiplizéiert se mat enger Serie vu nestet Schleifen. D'Funktioun gëtt d'Resultat zréck, dat an enger neier Matrix gespäichert ass.
Dës Approche ass einfach ze begräifen. Wéi och ëmmer, et ass vläicht net sou effizient wéi aner Weeër, besonnesch fir méi grouss Matrixen. Wéi och ëmmer, et ass eng wonnerbar Wiel fir Iech wann Dir nei an der linearer Algebra sidd.
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])
# Setzt d'Resultatmatrix op Nullen.
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
Loosst eis e Beispill hunn wéi dëst ze maachen. Dir kënnt just dës Zeilen vum Code hei ënnen addéieren fir dëst Beispill ze testen.
# 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]]
Virdeeler:
- Einfach ze verstoen.
- Super fir Newbies oder déi, déi e méi déif Verständnis vun der Matrixmultiplikatioun sichen.
Nodeeler:
- Net sou effektiv wéi alternativ Techniken, besonnesch fir méi grouss Matrixen.
- Et ass net sou liesbar wéi alternativ Approche.
map () Funktioun Method
D'Kaart () Funktiounsmethod bitt eng alternativ Approche fir Matrixmultiplikatioun am Python ze maachen. An dëser Approche benotze mir déi agebaute Kaart () -Funktioun. Dofir benotze mir e funktionellt Programméierungsinstrument dat eng geliwwert Funktioun op all iterabel Element applizéiert (Lëscht, Tupel, etc.). Och d'Kaart () Funktioun akzeptéiert zwee Parameteren, eng Funktioun an eng iterabel. An, et gëtt en Iterator zréck deen d'Funktioun op all iterabel Element applizéiert.
An dëser Approche ginn mir duerch all Member vun der Matrixentgasung a maachen d'Multiplikatioun mat der nestéierter Kaart () Funktioun.
D'Zip () Funktioun gëtt benotzt fir duerch all Element vun de Matrizen parallel ze iteréieren.
Schlussendlech gëtt d'Zomm () Funktioun benotzt fir d'Resultater opzezielen.
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
Elo, erëm, kënne mir eise Code mat engem Beispill testen.
# 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]]
Virdeeler
- Méi effektiv wéi d'Stacked Loop Approche
- Et benotzt funktionell Programméierung fir de Code méi einfach ze maachen.
Nodeeler
- E puer Leit, déi net mat funktionell Programméierung vertraut sinn, kënnen et manner liesbar fannen.
- Et ass manner verständlech wéi d'nested Loops Technik.
Lëscht Versteesdemech Method
Lëscht Verständnis erlaabt Iech eng nei Lëscht an enger eenzeger Zeil vum Code ze generéieren. Dofir ass dëst andeems en Ausdrock op all Member vun enger existéierender Lëscht applizéiert gëtt.
An dëser Approche gëtt d'Multiplikatioun duerch widderholl Iteratioun duerch all Matrixmember duerchgefouert. Mir benotzen Layer Lëscht Versteesdemech.
# 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]]
Virdeeler
- Am Verglach mat der Kaart () Funktioun Method, méi kuerz a méi liesbar.
Nodeeler
- Et kann manner effektiv sinn wéi d'Kaart () Funktioun ze benotzen, besonnesch fir grouss Matrizen.
- Et ass méi schwéier wéi d'Nested Loop Approche.
Konklusioun
An dësem Post hu mir Alternativen gekuckt fir NumPy ze benotzen wann Dir Matrizen am Python multiplizéiert. Mir hunn Matrixmultiplikatioun an nestet Schleifen gemaach, déi agebauter Kaart () Funktioun, a Lëschteverständnis.
Déi bescht Strategie wäert op déi speziell Bedierfnesser vun Ärem Projet vertrauen.
Jiddereng vun den Strategien huet seng eegen Virdeeler an Nodeeler. Fir sécherzestellen datt d'Funktioun richteg funktionnéiert, ass et eng gutt Iddi e puer Testfäll mat verschiddene Matrixdimensioune a Wäerter ze addéieren.
Dir sollt och e puer Performance Tester enthalen fir ze vergläichen wéi gutt dës Methoden ausféieren.
Hannerlooss eng Äntwert