Matrix fermannichfâldigje is in fûnemintele operaasje yn lineêre algebra.
Wy brûke it oer it algemien yn ferskate applikaasjes lykas ôfbyldingsferwurking, masine learen, en in protte mear. NumPy is in opmerklik Python-pakket foar wittenskiplike komputer.
Yn dit post sille wy lykwols sjen nei ferskate metoaden foar it dwaan fan matrixmultiplikaasje yn Python sûnder NumPy te brûken.
Wy sille brûke nestele loops, de ynboude map () funksje, en list begryp.
Derneist sille wy de foardielen en neidielen fan elke strategy besjen, lykas wannear't elk fan har tapast wurde moat. As jo binne nij foar lineêre algebra en wolle leare mear oer matrix fermannichfâldigjen; trochgean mei lêzen.
Wêr brûke wy matrixmultiplikaasje?
Matrix fermannichfâldigje wurdt brûkt yn kompjûter Grafiken om 2D- en 3D-fisuele te feroarjen. Jo kinne bygelyks objekten op it skerm draaie, skaalje en oersette. Matrixen wurde brûkt yn byldferwurking om foto's as arrays fan piksels foar te stellen. Derneist kinne matrixen wurde brûkt om operaasjes út te fieren lykas ôfbyldingsfiltering.
Wy meitsje ek gebrûk fan matriksen yn masine learen. Se kinne ús helpe om gegevens en modelparameters te fertsjintwurdigjen. Wy kinne ferskate operaasjes útfiere, lykas dotprodukten en matrix-vektorprodukten.
Wiswier, dizze operaasje is ek heul foardielich yn wittenskiplike operaasjes. Wy kinne it brûke yn natuerkunde en technyk om fysike hoemannichten te beskriuwen. Dêrtroch kinne wy operearje mei fektors en tensors.
Wêrom kinne wy net kieze om NumPy te brûken?
Wylst NumPy is in Python bibleteek, it is net altyd de ideale opsje foar matrixmultiplikaasje. Wy meie net kieze om NumPy te brûken om redenen lykas grutte en ôfhinklikens, learen en legacy-systemen.
It brûken fan Python's ynboude funksjes of it ûntwikkeljen fan oanpaste koade kin yn guon gefallen effisjinter wêze. It is lykwols krúsjaal om te notearjen dat NumPy in sterke bibleteek is. Derneist kinne jo it ek brûke foar matrixmultiplikaasje.
Litte wy no ris sjen hoe't wy matrixmultiplikaasje kinne berikke sûnder NumPy.
Nested loops metoade
De technyk fan geneste loops brûkt nestede loops om matrixmultiplikaasje út te fieren yn Python. De funksje iterearret oer elk matrix-elemint. En it fermannichfâldigje se mei in searje nestele loops. De funksje jout it resultaat werom, dat wurdt opslein yn in nije matrix.
Dizze oanpak is ienfâldich om te begripen. It kin lykwols net sa effisjint wêze as oare manieren, benammen foar gruttere matriks. Dochs is it in prachtige kar foar jo as jo nij binne foar lineêre algebra.
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])
# Stel de resultaatmatrix yn 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
Litte wy in foarbyld hawwe fan hoe't jo dit dwaan. Jo kinne gewoan dizze rigels koade hjirûnder tafoegje om dit foarbyld te 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]]
foardielen:
- Maklik te begripen.
- Geweldich foar newbies as dyjingen dy't in djipper begryp sykje fan matrixmultiplikaasje.
neidielen:
- Net sa effektyf as alternative techniken, benammen foar gruttere matriks.
- It is net sa lêsber as alternatyf oanpak.
map() funksje metoade
De map () funksje metoade jout in alternative oanpak foar it dwaan fan matrix fermannichfâldigjen yn Python. Yn dizze oanpak, wy brûke de ynboude map () funksje. Hjirtroch brûke wy in funksjoneel programmearynstrumint dat in levere funksje tapast op elk iterabel elemint (list, tuple, ensfh.). Ek, De map () funksje akseptearret twa parameters, in funksje en in iterable. En it jout in iterator werom dy't de funksje tapast op elk iterabel elemint.
Yn dizze oanpak, wy geane troch elk lid fan de matriks en doch de fermannichfâldigjen mei help fan de nested map () funksje.
De zip () funksje wurdt brûkt om te iterearjen troch elk elemint fan de matriks parallel.
Uteinlik wurdt de funksje som () brûkt om de resultaten op te tellen.
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
No, wer, kinne wy ús koade testen mei in foarbyld.
# 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]]
foardielen
- Effektiver dan de oanpak fan steapele loops
- It brûkt funksjonele programmearring om de koade ienfâldiger te meitsjen.
neidielen
- Guon minsken dy't net bekend binne mei funksjonele programmearring kinne it minder lêsber fine.
- It is minder begryplik as de technyk fan geneste loops.
List begryp metoade
Listbegryp lit jo in nije list generearje yn ien rigel koade. Hjirtroch is dit troch in útdrukking oan te passen op elk lid fan in besteande list.
Yn dizze oanpak wurdt fermannichfâldigje útfierd troch werhelle iterearjen troch elk matrixlid. Wy brûke layered list begryp.
# 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]]
foardielen
- Yn ferliking mei de map () funksje metoade, koarter en mear lêsber.
neidielen
- It kin wêze minder effektyf as it brûken fan de map () funksje, benammen foar grutte matriks.
- It is dreger as de oanpak fan nestede loops.
Konklúzje
Yn dizze post seagen wy nei alternativen foar it brûken fan NumPy by it fermannichfâldigjen fan matriksen yn Python. Wy útfierd matrix fermannichfâldigjen yn nestede loops, de ynboude map () funksje, en list begryp.
De bêste strategy sil fertrouwe op 'e bysûndere behoeften fan jo projekt.
Elk fan 'e strategyen hat syn eigen foar- en neidielen. Om te soargjen dat de funksje goed wurket, is it in goed idee om wat testgefallen ta te foegjen mei ferskate matriksdimensjes en wearden.
Jo moatte ek wat prestaasjestests opnimme om te fergelykjen hoe goed dizze metoaden útfiere.
Leave a Reply