Die Matrixmultiplikation ist eine grundlegende Operation in der linearen Algebra.
Wir verwenden es im Allgemeinen in zahlreichen Anwendungen wie Bildverarbeitung, maschinellem Lernen und vielen mehr. NumPy ist ein bemerkenswertes Python-Paket für wissenschaftliches Rechnen.
In diesem Beitrag werden wir uns jedoch verschiedene Methoden zur Matrixmultiplikation in Python ansehen, ohne NumPy zu verwenden.
Wir werden nutzen verschachtelte Schleifen, die eingebaute Funktion map() und Listenverständnis.
Darüber hinaus werden wir die Vor- und Nachteile jeder Strategie sowie den Zeitpunkt ihrer Anwendung betrachten. Wenn Sie neu in der linearen Algebra sind und mehr über die Matrizenmultiplikation erfahren möchten; lies weiter.
Wo verwenden wir die Matrixmultiplikation?
Matrixmultiplikation wird verwendet in Computergrafik um 2D- und 3D-Visualisierungen zu ändern. Sie können beispielsweise Objekte auf dem Bildschirm drehen, skalieren und verschieben. Matrizen werden in der Bildverarbeitung verwendet, um Bilder als Arrays von Pixeln darzustellen. Außerdem können Matrizen verwendet werden, um Operationen wie Bildfilterung durchzuführen.
Wir verwenden auch Matrizen in Maschinelles Lernen. Sie können uns helfen, Daten und Modellparameter darzustellen. Wir können zahlreiche Operationen durchführen, wie z. B. die Berechnung von Punktprodukten und Matrix-Vektor-Produkten.
Sicherlich ist diese Operation auch im wissenschaftlichen Betrieb von großem Vorteil. Wir können es in der Physik und Technik verwenden, um physikalische Größen zu beschreiben. Daher können wir mit Vektoren und Tensoren operieren.
Warum wir uns möglicherweise nicht für die Verwendung von NumPy entscheiden?
Während NumPy ein Python-Bibliothek, ist es nicht immer die ideale Option für die Matrixmultiplikation. Möglicherweise entscheiden wir uns aus Gründen wie Größe und Abhängigkeit, Lernen und Legacy-Systemen nicht für die Verwendung von NumPy.
In einigen Fällen kann es effizienter sein, die integrierten Funktionen von Python zu verwenden oder benutzerdefinierten Code zu entwickeln. Es ist jedoch wichtig zu beachten, dass NumPy eine starke Bibliothek ist. Außerdem können Sie es auch für die Matrixmultiplikation verwenden.
Schauen wir uns nun an, wie wir eine Matrixmultiplikation ohne NumPy erreichen können.
Methode der verschachtelten Schleifen
Die Technik der verschachtelten Schleifen verwendet verschachtelte Schleifen, um die Matrixmultiplikation in Python auszuführen. Die Funktion iteriert über jedes Matrixelement. Und es multipliziert sie mit einer Reihe von verschachtelten Schleifen. Die Funktion gibt das Ergebnis zurück, das in einer neuen Matrix gespeichert wird.
Dieser Ansatz ist einfach zu verstehen. Es ist jedoch möglicherweise nicht so effizient wie andere Methoden, insbesondere bei größeren Matrizen. Dennoch ist es eine wunderbare Wahl für Sie, wenn Sie neu in der linearen Algebra sind.
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])
# Setze die Ergebnismatrix auf 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
Lassen Sie uns ein Beispiel dafür haben, wie das geht. Sie können einfach diese Codezeilen unten hinzufügen, um dieses Beispiel zu 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]]
Vorteile:
- Einfach zu verstehen.
- Großartig für Neulinge oder diejenigen, die ein tieferes Verständnis der Matrixmultiplikation suchen.
Nachteile:
- Nicht so effektiv wie alternative Techniken, insbesondere bei größeren Matrizen.
- Es ist nicht so lesbar wie alternative Ansätze.
map()-Funktionsmethode
Die map()-Funktionsmethode bietet einen alternativen Ansatz für die Matrixmultiplikation in Python. Bei diesem Ansatz verwenden wir die eingebaute Funktion map(). Daher verwenden wir ein funktionales Programmierwerkzeug, das eine bereitgestellte Funktion auf jedes iterierbare Element (Liste, Tupel usw.) anwendet. Außerdem akzeptiert die Funktion map() zwei Parameter, eine Funktion und eine Iterable. Und es gibt einen Iterator zurück, der die Funktion auf jedes iterierbare Element anwendet.
Bei diesem Ansatz gehen wir jedes Mitglied der Matrix durch und führen die Multiplikation mit der verschachtelten Funktion map() durch.
Die Funktion zip() wird verwendet, um jedes Element der Matrizen parallel zu durchlaufen.
Schließlich wird die Funktion sum() verwendet, um die Ergebnisse zu addieren.
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
Jetzt können wir unseren Code wieder mit einem Beispiel 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]]
Vorteile
- Effektiver als der Ansatz mit gestapelten Schleifen
- Es verwendet funktionale Programmierung, um den Code einfacher zu machen.
Nachteile
- Einige Leute, die mit funktionaler Programmierung nicht vertraut sind, finden es möglicherweise weniger lesbar.
- Es ist weniger verständlich als die Technik der verschachtelten Schleifen.
Listenverständnismethode
List Comprehension ermöglicht es Ihnen, eine neue Liste in einer einzigen Codezeile zu generieren. Dies geschieht also durch Anwenden eines Ausdrucks auf jedes Mitglied einer vorhandenen Liste.
Bei diesem Ansatz wird die Multiplikation durch wiederholtes Iterieren durch jedes Matrixelement ausgeführt. Wir verwenden ein mehrschichtiges Listenverständnis.
# 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]]
Benefits
- Im Vergleich zur map()-Funktionsmethode kürzer und besser lesbar.
Nachteile
- Dies ist möglicherweise weniger effektiv als die Verwendung der Funktion map(), insbesondere bei großen Matrizen.
- Es ist schwieriger als der Ansatz mit verschachtelten Schleifen.
Zusammenfassung
In diesem Beitrag haben wir Alternativen zur Verwendung von NumPy beim Multiplizieren von Matrizen in Python untersucht. Wir haben die Matrixmultiplikation in verschachtelten Schleifen, die eingebaute map()-Funktion und das Listenverständnis durchgeführt.
Die beste Strategie hängt von den besonderen Anforderungen Ihres Projekts ab.
Jede der Strategien hat ihre eigenen Vor- und Nachteile. Um sicherzustellen, dass die Funktion ordnungsgemäß funktioniert, empfiehlt es sich, einige Testfälle mit verschiedenen Matrixdimensionen und -werten hinzuzufügen.
Sie sollten auch einige Leistungstests einbeziehen, um zu vergleichen, wie gut diese Methoden ausgeführt werden.
Hinterlassen Sie uns einen Kommentar