Matrixmultiplikation er en grundlæggende operation i lineær algebra.
Vi bruger det generelt i adskillige applikationer såsom billedbehandling, maskinlæring og mange flere. NumPy er en bemærkelsesværdig Python-pakke til videnskabelig databehandling.
Men i dette indlæg vil vi se på forskellige metoder til at lave matrixmultiplikation i Python uden at bruge NumPy.
vi vil bruge indlejrede løkker, den indbyggede map()-funktion og listeforståelse.
Derudover vil vi se på fordele og ulemper ved hver strategi, samt hvornår vi skal anvende hver af dem. Hvis du er ny til lineær algebra og ønsker at lære mere om matrix multiplikation; fortsæt med at læse.
Hvor bruger vi matrixmultiplikation?
Matrix multiplikation bruges i computer grafik for at ændre 2D- og 3D-billeder. For eksempel kan du rotere, skalere og oversætte objekter på skærmen. Matrixer bruges i billedbehandling til at repræsentere billeder som arrays af pixels. Derudover kan matrixer bruges til at udføre operationer som billedfiltrering.
Vi gør også brug af matricer i machine learning. De kan hjælpe os med at repræsentere data og modelparametre. Vi kan udføre adskillige operationer, såsom databehandling af punktprodukter og matrix-vektorprodukter.
Denne operation er helt sikkert også yderst fordelagtig i videnskabelige operationer. Vi kan bruge det i fysik og teknik til at beskrive fysiske størrelser. Derfor kan vi operere med vektorer og tensorer.
Hvorfor vælger vi måske ikke at bruge NumPy?
Mens NumPy er en Python bibliotek, er det ikke altid den ideelle mulighed for matrixmultiplikation. Vi vælger muligvis ikke at bruge NumPy af årsager som størrelse og afhængighed, læring og ældre systemer.
Brug af Pythons indbyggede funktioner eller udvikling af brugerdefineret kode kan være mere effektivt i nogle tilfælde. Det er dog afgørende at bemærke, at NumPy er et stærkt bibliotek. Desuden kan du også bruge det til matrix multiplikation.
Lad os nu tage et kig på, hvordan vi kan opnå matrixmultiplikation uden NumPy.
Indlejrede loops metode
Teknikken med indlejrede sløjfer bruger indlejrede sløjfer til at udføre matrixmultiplikation i Python. Funktionen itererer over hvert matrixelement. Og det multiplicerer dem ved hjælp af en række indlejrede løkker. Funktionen returnerer resultatet, som er gemt i en ny matrix.
Denne tilgang er ligetil at forstå. Det er dog muligvis ikke så effektivt som andre måder, især for større matricer. Alligevel er det et vidunderligt valg for dig, hvis du er ny til lineær 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])
# Indstil resultatmatrixen til nul.
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
Lad os få et eksempel på, hvordan man gør dette. Du kan blot tilføje disse kodelinjer nedenfor for at teste dette eksempel.
# 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]]
Fordele:
- Let at forstå.
- Fantastisk til nybegyndere eller dem, der søger en dybere forståelse af matrixmultiplikation.
Ulemper:
- Ikke så effektive som alternative teknikker, især for større matricer.
- Det er ikke så læseligt som alternative tilgange.
map() funktionsmetode
Funktionsmetoden map() giver en alternativ tilgang til at udføre matrixmultiplikation i Python. I denne tilgang bruger vi den indbyggede map() funktion. Derfor bruger vi et funktionelt programmeringsværktøj, der anvender en forudsat funktion til hvert iterable element (liste, tuple, osv.). Funktionen map() accepterer også to parametre, en funktion og en iterabel. Og det returnerer en iterator, der anvender funktionen på hvert iterable element.
I denne tilgang gennemgår vi hvert medlem af matricen og udfører multiplikationen ved hjælp af den indlejrede map()-funktion.
Zip()-funktionen bruges til at iterere gennem hvert element i matricerne parallelt.
Til sidst bruges sum()-funktionen til at lægge resultaterne sammen.
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
Nu kan vi igen teste vores kode med et eksempel.
# 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]]
Fordele
- Mere effektiv end tilgangen med stablede loops
- Den bruger funktionel programmering for at gøre koden enklere.
Ulemper
- Nogle mennesker, der ikke er fortrolige med funktionel programmering, kan finde det mindre læsbart.
- Det er mindre forståeligt end teknikken med indlejrede løkker.
Listeforståelsesmetode
Listeforståelse giver dig mulighed for at generere en ny liste i en enkelt kodelinje. Derfor er dette ved at anvende et udtryk på hvert medlem af en eksisterende liste.
I denne fremgangsmåde udføres multiplikation ved gentagne gange at iterere gennem hvert matrixelement. Vi bruger lagdelt listeforståelse.
# 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]]
Fordele
- Sammenlignet med map() funktionsmetoden, kortere og mere læsbar.
Ulemper
- Det kan være mindre effektivt end at bruge map()-funktionen, især for store matricer.
- Det er sværere end den indlejrede sløjfer tilgang.
Konklusion
I dette indlæg så vi på alternativer til at bruge NumPy, når man multiplicerer matricer i Python. Vi udførte matrixmultiplikation i indlejrede loops, den indbyggede map()-funktion og listeforståelse.
Den bedste strategi afhænger af dit projekts særlige behov.
Hver af strategierne har sine egne fordele og ulemper. For at sikre, at funktionen fungerer korrekt, er det en god idé at tilføje nogle testcases med forskellige matrixdimensioner og værdier.
Du bør også inkludere nogle præstationstests for at sammenligne, hvor godt disse metoder udføres.
Giv en kommentar