Matrismultiplikation är en grundläggande operation i linjär algebra.
Vi använder det i allmänhet i många applikationer som bildbehandling, maskininlärning och många fler. NumPy är ett anmärkningsvärt Python-paket för vetenskaplig beräkning.
Men i det här inlägget kommer vi att titta på olika metoder för att göra matrismultiplikation i Python utan att använda NumPy.
Vi kommer att använda kapslade öglor, den inbyggda map()-funktionen och listförståelse.
Dessutom kommer vi att titta på fördelarna och nackdelarna med varje strategi, samt när vi ska tillämpa var och en av dem. Om du är ny på linjär algebra och vill lära dig mer om matrismultiplikation; fortsätt läsa.
Var använder vi matrismultiplikation?
Matrismultiplikation används i Datorgrafik för att ändra 2D- och 3D-bilder. Du kan till exempel rotera, skala och översätta objekt på skärmen. Matriser används i bildbehandling för att representera bilder som arrayer av pixlar. Dessutom kan matriser användas för att utföra operationer som bildfiltrering.
Vi använder oss även av matriser i maskininlärning. De kan hjälpa oss att representera data och modellparametrar. Vi kan utföra många operationer, såsom datorprickprodukter och matrisvektorprodukter.
Säkert är denna operation också mycket fördelaktig i vetenskapliga operationer. Vi kan använda det inom fysik och teknik för att beskriva fysiska storheter. Därför kan vi arbeta med vektorer och tensorer.
Varför kan vi inte välja att använda NumPy?
Medan NumPy är en Python bibliotek, är det inte alltid det ideala alternativet för matrismultiplikation. Vi kanske inte väljer att använda NumPy av skäl som storlek och beroende, inlärning och äldre system.
Att använda Pythons inbyggda funktioner eller utveckla anpassad kod kan vara mer effektivt i vissa fall. Det är dock viktigt att notera att NumPy är ett starkt bibliotek. Dessutom kan du också använda den för matrismultiplikation.
Låt oss nu ta en titt på hur vi kan uppnå matrismultiplikation utan NumPy.
Kapslade loopar metod
Tekniken med kapslade loopar använder kapslade loopar för att utföra matrismultiplikation i Python. Funktionen itererar över varje matriselement. Och det multiplicerar dem med en serie kapslade slingor. Funktionen returnerar resultatet, som lagras i en ny matris.
Detta tillvägagångssätt är enkelt att förstå. Men det kanske inte är lika effektivt som andra sätt, särskilt för större matriser. Ändå är det ett underbart val för dig om du är ny på linjä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])
# Ställ in resultatmatrisen på nollor.
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
Låt oss ta ett exempel på hur man gör detta. Du kan bara lägga till dessa kodrader nedan för att testa detta exempel.
# 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]]
Fördelar:
- Lätt att förstå.
- Perfekt för nybörjare eller de som söker en djupare förståelse av matrismultiplikation.
Nackdelar:
- Inte lika effektiva som alternativa tekniker, särskilt för större matriser.
- Den är inte lika läsbar som alternativa tillvägagångssätt.
map() funktionsmetod
Funktionsmetoden map() tillhandahåller en alternativ metod för att göra matrismultiplikation i Python. I detta tillvägagångssätt använder vi den inbyggda map()-funktionen. Därför använder vi ett funktionellt programmeringsverktyg som tillämpar en tillhandahållen funktion på varje itererbart element (lista, tuppel, etc.). Dessutom accepterar funktionen map() två parametrar, en funktion och en iterabel. Och den returnerar en iterator som tillämpar funktionen på varje itererbart element.
I det här tillvägagångssättet går vi igenom varje medlem av matrisen och gör multiplikationen med hjälp av den kapslade map()-funktionen.
Zip()-funktionen används för att iterera genom varje element i matriserna parallellt.
Slutligen används sum()-funktionen för att summera resultaten.
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, igen, kan vi testa vår kod med ett exempel.
# 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]]
Fördelar
- Effektivare än tillvägagångssättet med staplade loopar
- Den använder funktionell programmering för att göra koden enklare.
Nackdelar
- Vissa människor som inte är bekanta med funktionell programmering kan tycka att det är mindre läsbart.
- Det är mindre förståeligt än tekniken med kapslade loopar.
Listförståelsemetod
Listförståelse gör att du kan skapa en ny lista på en enda kodrad. Detta är alltså genom att tillämpa ett uttryck på varje medlem i en befintlig lista.
I detta tillvägagångssätt utförs multiplikation genom att upprepade gånger iterera genom varje matrismedlem. Vi använder skiktad listförstå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]]
Fördelar
- Jämfört med funktionsmetoden map() är kortare och mer läsbar.
Nackdelar
- Det kan vara mindre effektivt än att använda map()-funktionen, särskilt för stora matriser.
- Det är svårare än de kapslade slingorna.
Slutsats
I det här inlägget tittade vi på alternativ till att använda NumPy när man multiplicerar matriser i Python. Vi utförde matrismultiplikation i kapslade loopar, den inbyggda map()-funktionen och listförståelse.
Den bästa strategin kommer att förlita sig på de särskilda behoven i ditt projekt.
Var och en av strategierna har sina egna för- och nackdelar. För att säkerställa att funktionen fungerar korrekt är det en bra idé att lägga till några testfall med olika matrisdimensioner och -värden.
Du bör också inkludera några prestandatester för att jämföra hur väl dessa metoder fungerar.
Kommentera uppropet