Matrixvermenigvuldiging is een fundamentele bewerking in lineaire algebra.
We gebruiken het over het algemeen in tal van toepassingen, zoals beeldverwerking, machine learning en nog veel meer. NumPy is een opmerkelijk Python-pakket voor wetenschappelijk computergebruik.
In dit bericht zullen we echter verschillende methoden bekijken om matrixvermenigvuldiging in Python uit te voeren zonder NumPy te gebruiken.
We zullen gebruiken Geneste lussen, de ingebouwde functie map() en lijstbegrip.
Daarnaast zullen we kijken naar de voor- en nadelen van elke strategie, evenals wanneer ze moeten worden toegepast. Als lineaire algebra nieuw voor je is en je meer wilt weten over matrixvermenigvuldiging; blijf lezen.
Waar gebruiken we matrixvermenigvuldiging?
Matrixvermenigvuldiging wordt gebruikt in computer beelden om 2D- en 3D-beelden te veranderen. U kunt bijvoorbeeld objecten op het scherm roteren, schalen en vertalen. Matrixen worden bij beeldverwerking gebruikt om afbeeldingen weer te geven als arrays van pixels. Bovendien kunnen matrices worden gebruikt om bewerkingen zoals beeldfiltering uit te voeren.
Ook maken we gebruik van matrixen in machine learning. Ze kunnen ons helpen om gegevens en modelparameters weer te geven. We kunnen tal van bewerkingen uitvoeren, zoals het berekenen van puntproducten en matrix-vectorproducten.
Zeker, deze operatie is ook zeer voordelig in wetenschappelijke operaties. We kunnen het in de natuurkunde en techniek gebruiken om fysieke grootheden te beschrijven. Daarom kunnen we werken met vectoren en tensoren.
Waarom kiezen we er misschien niet voor om NumPy te gebruiken?
Terwijl NumPy een Python-bibliotheek, is het niet altijd de ideale optie voor matrixvermenigvuldiging. We kiezen er mogelijk niet voor om NumPy te gebruiken om redenen zoals omvang en afhankelijkheid, leren en verouderde systemen.
Het gebruik van de ingebouwde functies van Python of het ontwikkelen van aangepaste code kan in sommige gevallen efficiënter zijn. Het is echter cruciaal op te merken dat NumPy een sterke bibliotheek is. Trouwens, je kunt het ook gebruiken voor matrixvermenigvuldiging.
Laten we nu eens kijken hoe we matrixvermenigvuldiging kunnen bereiken zonder NumPy.
Methode met geneste lussen
De techniek van geneste lussen gebruikt geneste lussen om matrixvermenigvuldiging in Python uit te voeren. De functie itereert over elk matrixelement. En het vermenigvuldigt ze met behulp van een reeks geneste lussen. De functie retourneert het resultaat, dat wordt opgeslagen in een nieuwe matrix.
Deze benadering is eenvoudig te begrijpen. Het is echter mogelijk niet zo efficiënt als andere manieren, met name voor grotere matrices. Toch is het een geweldige keuze voor jou als lineaire algebra nieuw voor je is.
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 in 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
Laten we een voorbeeld nemen van hoe dit te doen. U kunt deze coderegels hieronder gewoon toevoegen om dit voorbeeld 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]]
Voordelen:
- Gemakkelijk te begrijpen.
- Geweldig voor nieuwkomers of mensen die een dieper begrip van matrixvermenigvuldiging zoeken.
nadelen:
- Niet zo effectief als alternatieve technieken, vooral voor grotere matrices.
- Het is niet zo leesbaar als alternatieve benaderingen.
map() functie methode
De functiemethode map() biedt een alternatieve benadering voor matrixvermenigvuldiging in Python. In deze benadering gebruiken we de ingebouwde functie map(). Daarom gebruiken we een functionele programmeertool die een gegeven functie toepast op elk itereerbaar element (lijst, tuple, enz.). Ook accepteert de functie map() twee parameters, een functie en een iterable. En het retourneert een iterator die de functie toepast op elk itereerbaar element.
Bij deze benadering gaan we door elk lid van de matrix en doen we de vermenigvuldiging met behulp van de geneste map()-functie.
De functie zip() wordt gebruikt om parallel door elk element van de matrices te itereren.
Ten slotte wordt de functie sum() gebruikt 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
Nu kunnen we onze code opnieuw testen met een voorbeeld.
# 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]]
voordelen
- Effectiever dan de benadering met gestapelde lussen
- Het maakt gebruik van functionele programmering om de code eenvoudiger te maken.
Nadelen
- Sommige mensen die niet bekend zijn met functioneel programmeren, vinden het misschien minder leesbaar.
- Het is minder begrijpelijk dan de techniek van geneste lussen.
Lijst begrip methode
Met lijstbegrip kunt u een nieuwe lijst genereren in een enkele regel code. Dit gebeurt dus door een uitdrukking toe te passen op elk lid van een bestaande lijst.
Bij deze benadering wordt vermenigvuldiging uitgevoerd door herhaaldelijk door elk matrixlid te itereren. We gebruiken gelaagd lijstbegrip.
# 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]]
Voordelen
- Vergeleken met de map() functiemethode, korter en leesbaarder.
Nadelen
- Het kan minder effectief zijn dan het gebruik van de map() functie, vooral voor grote matrices.
- Het is moeilijker dan de benadering met geneste lussen.
Conclusie
In dit bericht hebben we gekeken naar alternatieven voor het gebruik van NumPy bij het vermenigvuldigen van matrices in Python. We hebben matrixvermenigvuldiging uitgevoerd in geneste lussen, de ingebouwde functie map() en lijstbegrip.
De beste strategie hangt af van de specifieke behoeften van uw project.
Elk van de strategieën heeft zijn eigen voor- en nadelen. Om er zeker van te zijn dat de functie goed werkt, is het een goed idee om enkele testgevallen met verschillende matrixdimensies en -waarden toe te voegen.
U moet ook enkele prestatietests opnemen om te vergelijken hoe goed deze methoden worden uitgevoerd.
Laat een reactie achter