3 Möglichkeiten, Matrizen in Python zu multiplizieren

In diesem Tutorial erfahren Sie, wie es geht zwei Matrizen multiplizieren bei Python.

Sie lernen zunächst die Bedingung für eine gültige Matrizenmultiplikation und schreiben eine benutzerdefinierte Python-Funktion zum Multiplizieren von Matrizen. Als Nächstes werden Sie sehen, wie Sie dasselbe Ergebnis mit verschachtelten Listenverständnissen erzielen können.

Schließlich fahren Sie mit der Verwendung fort NumPy und seine eingebauten Funktionen, um die Matrixmultiplikation effizienter durchzuführen.

So prüfen Sie, ob die Matrixmultiplikation gültig ist

Bevor wir Python-Code für die Matrizenmultiplikation schreiben, wollen wir uns noch einmal mit den Grundlagen der Matrizenmultiplikation befassen.

Matrixmultiplikation zwischen zwei Matrizen A und B ist nur gültig, wenn die Anzahl der Spalten in Matrix A is gleich zu den Reihenanzahl in Matrix B.

Wahrscheinlich sind Sie dieser Bedingung für die Matrixmultiplikation schon einmal begegnet. Haben Sie sich jedoch jemals gefragt, warum dies so ist?

Nun, das liegt an der Art und Weise, wie die Matrixmultiplikation funktioniert. Schauen Sie sich das Bild unten an.

In unserem allgemeinen Beispiel hat Matrix A m Zeilen und n Säulen. Und Matrix B hat n Zeilen und p Säulen.

Welche Form hat die Produktmatrix?

Das Element am Index (i, j) in der resultierenden Matrix C ist das Skalarprodukt der Zeile i der Matrix A und der Spalte j der Matrix B.

Um also ein Element an einem bestimmten Index in der resultierenden Matrix C zu erhalten, müssen Sie das Skalarprodukt der entsprechenden Zeile und Spalte in den Matrizen A bzw. B berechnen.

Wenn Sie den obigen Vorgang wiederholen, erhalten Sie die Produktmatrix C der Form mxp-mit m Zeilen und p Spalten, wie unten gezeigt.

Und das Skalarprodukt oder das Skalarprodukt zwischen zwei Vektoren a funktioniert b ist durch die folgende Gleichung gegeben.

Fassen wir jetzt zusammen:

Es ist offensichtlich, dass das Skalarprodukt nur zwischen Vektoren gleicher Länge definiert ist.
Damit also das Skalarprodukt zwischen einer Zeile und einer Spalte gültig ist – wenn Sie zwei Matrizen multiplizieren – müssten beide die gleiche Anzahl von Elementen haben.
Im obigen allgemeinen Beispiel hat jede Zeile in Matrix A n Elemente. Und jede Spalte in Matrix B hat n Elemente auch.

Schaut man genauer hin, n ist die Anzahl der Spalten in Matrix A, und es ist auch die Anzahl der Zeilen in Matrix B. Und genau aus diesem Grund brauchen Sie die Anzahl der Spalten in Matrix A sein gleich zu den Reihenanzahl in Matrix B.

Ich hoffe, Sie verstehen, dass die Bedingung für die Matrixmultiplikation gültig ist und wie Sie jedes Element in der Produktmatrix erhalten.

Lassen Sie uns damit fortfahren, Python-Code zu schreiben, um zwei Matrizen zu multiplizieren.

Write a Custom Python Function to Multiply Matrices

Lassen Sie uns als ersten Schritt eine benutzerdefinierte Funktion schreiben, um Matrizen zu multiplizieren.

Diese Funktion sollte Folgendes tun:

Akzeptieren Sie zwei Matrizen, A und B, als Eingaben.
Prüfen Sie, ob die Matrixmultiplikation zwischen A und B gültig ist.
Falls gültig, multiplizieren Sie die beiden Matrizen A und B und geben Sie die Produktmatrix C zurück.
Anderenfalls wird eine Fehlermeldung zurückgegeben, dass die Matrizen A und B nicht multipliziert werden können.

Schritt 1: Generieren Sie zwei Matrizen von ganzen Zahlen mit NumPy random.randint() Funktion. Sie können Matrizen auch als verschachtelte Python-Listen deklarieren.

import numpy as np
np.random.seed(27)
A = np.random.randint(1,10,size = (3,3))
B = np.random.randint(1,10,size = (3,2))
print(f"Matrix A:\n {A}\n")
print(f"Matrix B:\n {B}\n")

# Output
Matrix A:
 [[4 9 9]
 [9 1 6]
 [9 2 3]]

Matrix B:
 [[2 2]
 [5 7]
 [4 4]]

Schritt 2: Gehen Sie voran und definieren Sie die Funktion multiply_matrix(A,B). Diese Funktion übernimmt zwei Matrizen A funktioniert B als Eingaben und gibt die Produktmatrix zurück C wenn die Matrixmultiplikation gültig ist.

def multiply_matrix(A,B):
  global C
  if  A.shape[1] == B.shape[0]:
    C = np.zeros((A.shape[0],B.shape[1]),dtype = int)
    for row in range(rows): 
        for col in range(cols):
            for elt in range(len(B)):
              C[row, col] += A[row, elt] * B[elt, col]
    return C
  else:
    return "Sorry, cannot multiply A and B."

Analysieren der Funktionsdefinition

Lassen Sie uns mit dem Analysieren der Funktionsdefinition fortfahren.

Deklarieren Sie C als globale Variable: Standardmäßig haben alle Variablen innerhalb einer Python-Funktion einen lokalen Geltungsbereich. Und Sie können von außerhalb der Funktion nicht darauf zugreifen. Um die Produktmatrix C von außen zugänglich zu machen, müssen wir sie als globale Variable deklarieren. Fügen Sie einfach die hinzu global Qualifizierer vor dem Variablennamen.

Überprüfen Sie, ob die Matrixmultiplikation gültig ist: Verwenden Sie das shape Attribut, um zu prüfen, ob A und B multipliziert werden können. Für jedes Array arr, arr.shape[0] funktioniert arr.shape[1] gib die Nummer an Reihen funktioniert Säulen, bzw. So if A.shape[1] == B.shape[0] prüft, ob die Matrixmultiplikation gültig ist. Nur wenn dieser Zustand vorliegt True, wird die Produktmatrix berechnet. Andernfalls gibt die Funktion eine Fehlermeldung zurück.

Verwenden Sie verschachtelte Schleifen, um Werte zu berechnen: Um die Elemente der resultierenden Matrix zu berechnen, müssen wir die Zeilen der Matrix A und die äußeren durchlaufen for Schleife tut dies. Das Innere for Schleife hilft uns, die Spalte von Matrix B zu durchlaufen. Und die innerste for Schleife hilft beim Zugriff auf jedes Element in der ausgewählten Spalte.

▶️ Nachdem wir nun gelernt haben, wie die Python-Funktion zum Multiplizieren von Matrizen funktioniert, rufen wir die Funktion mit den zuvor generierten Matrizen A und B auf.

multiply_matrix(A,B)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Als Matrixmultiplikation zwischen A und B gilt die Funktion multiply_matrix() gibt die Produktmatrix C zurück.

Use Python Nested List Comprehension to Multiply Matrices

Im vorherigen Abschnitt haben Sie eine Python-Funktion zum Multiplizieren von Matrizen geschrieben. Jetzt werden Sie sehen, wie Sie verschachtelte Listenverständnisse verwenden können, um dasselbe zu tun.

Hier ist das Verständnis der verschachtelten Liste zum Multiplizieren von Matrizen.

Verschachtelte-Liste-Verstehen-Matrix-multiplizieren

Das mag zunächst kompliziert aussehen. Aber wir werden das Verständnis der verschachtelten Liste Schritt für Schritt analysieren.

Konzentrieren wir uns jeweils auf ein Listenverständnis und identifizieren, was es bewirkt.

Wir verwenden die folgende allgemeine Vorlage für das Listenverständnis:

[<do-this> for <item> in <iterable>]

where,
<do-this>: what you'd like to do—expression or operation
<item>: each item you'd like to perform the operation on
<iterable>: the iterable (list, tuple, etc.) that you're looping through

▶️ Schau dir unseren Ratgeber an Listenverständnis in Python – mit Beispielen um ein tiefes Verständnis zu erlangen.

Bevor Sie fortfahren, beachten Sie bitte, dass wir die resultierende Matrix C erstellen möchten eine Reihe zu einem Zeitpunkt.

Verschachteltes Listenverständnis erklärt

Schritt 1: Berechnen Sie einen einzelnen Wert in der Matrix C

Bei gegebener Zeile i von Matrix A und Spalte j von Matrix B ergibt der folgende Ausdruck den Eintrag am Index (i, j) in Matrix C.

sum(a*b for a,b in zip(A_row, B_col)

# zip(A_row, B_col) returns an iterator of tuples
# If A_row = [a1, a2, a3] & B_col = [b1, b2, b3]
# zip(A_row, B_col) returns (a1, b1), (a2, b2), and so on

If i = j = 1, gibt der Ausdruck den Eintrag zurück c_11 der Matrix C. Auf diese Weise können Sie also ein Element in einer Zeile erhalten.

Schritt 2: Bilden Sie eine Zeile in der Matrix C

Unser nächstes Ziel ist es, eine ganze Reihe zu bauen.

Für Zeile 1 in Matrix A müssen Sie alle Spalten in Matrix B durchlaufen, um eine vollständige Zeile in Matrix C zu erhalten.

Gehen Sie zurück zur Listenverständnisvorlage.

Ersetzen <do-this> mit dem Ausdruck aus Schritt 1, denn das möchten Sie tun.
Als nächstes ersetzen <item> mit B_col– jede Spalte in Matrix B.
Zum Schluss ersetzen <iterable> mit zip(*B)— die Liste, die alle Spalten in Matrix B enthält.

Und hier ist das erste Listenverständnis.

[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 

# zip(*B): * is the unzipping operator
# zip(*B) returns a list of columns in matrix B

Schritt 3: Bilden Sie alle Zeilen und erhalten Sie die Matrix C

Als nächstes müssen Sie die Produktmatrix C füllen, indem Sie die restlichen Zeilen berechnen.

Und dafür müssen Sie alle Zeilen in Matrix A durchlaufen.

Gehen Sie noch einmal zurück zum Listenverständnis und gehen Sie wie folgt vor.

Ersetzen <do-this> mit dem Listenverständnis aus Schritt 2. Erinnern Sie sich daran, dass wir im vorherigen Schritt eine ganze Zeile berechnet haben.
Jetzt ersetzen <item> mit A_row– jede Zeile in Matrix A.
Und dein <iterable> ist die Matrix A selbst, während Sie ihre Zeilen durchlaufen.

Und hier ist unser letztes Verständnis der verschachtelten Liste.🎊

[[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 
    for A_row in A]

Es ist Zeit, das Ergebnis zu überprüfen! ✔

# cast into <a href="https://geekflare.com/numpy-reshape-arrays-in-python/">NumPy array</a> using np.array()
C = np.array([[sum(a*b for a,b in zip(A_row, B_col)) for B_col in zip(*B)] 
    for A_row in A])

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

Wenn Sie genauer hinsehen, entspricht dies den verschachtelten for-Schleifen, die wir zuvor hatten – nur dass es prägnanter ist.

Sie können dies auch noch effizienter tun, indem Sie einige eingebaute Funktionen verwenden. Lassen Sie uns im nächsten Abschnitt mehr über sie erfahren.

Use NumPy matmul() to Multiply Matrices in Python

Das np.matmul() nimmt zwei Matrizen als Eingabe und gibt das Produkt zurück, wenn eine Matrixmultiplikation zwischen den Eingabematrizen erfolgt gültig.

C = np.matmul(A,B)
print(C)

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

Beachten Sie, dass diese Methode einfacher ist als die beiden zuvor erlernten Methoden. Eigentlich statt np.matmul(), können Sie einen äquivalenten @-Operator verwenden, und wir werden das gleich sehen.

So verwenden Sie den @-Operator in Python, um Matrizen zu multiplizieren

In Python @ ist ein binärer Operator, der für die Matrixmultiplikation verwendet wird.

Es arbeitet mit zwei Matrizen und im Allgemeinen N-dimensionalen NumPy-Arrays und gibt die Produktmatrix zurück.

Hinweis: Sie benötigen Python 3.5 und höher, um die verwenden zu können @ Betreiber.

Hier erfahren Sie, wie Sie es verwenden können.

C = A@B
print(C)

# Output
array([[ 89, 107],
       [ 47,  49],
       [ 40,  44]])

Beachten Sie, dass die Produktmatrix C die gleiche ist wie die, die wir zuvor erhalten haben.

Können Sie np.dot() verwenden, um Matrizen zu multiplizieren?

Wenn Sie jemals auf Code gestoßen sind, der verwendet np.dot() Um zwei Matrizen zu multiplizieren, funktioniert es so.

C = np.dot(A,B)
print(C)

# Output:
[[ 89 107]
 [ 47  49]
 [ 40  44]]

Das wirst du sehen np.dot(A, B) gibt auch die erwartete Produktmatrix zurück.

Jedoch gemäß NumPy-Dokumente, du solltest benutzen np.dot() nur zur Berechnung des Skalarprodukts zweier eindimensionaler Vektoren und nicht zur Matrixmultiplikation.

Erinnern Sie sich an den vorherigen Abschnitt, das Element am Index (i, j) der Produktmatrix C ist das Skalarprodukt der Zeile i der Matrix A und der Spalte j der Matrix B.

Da NumPy diese Punktproduktoperation implizit an alle Zeilen und alle Spalten sendet, erhalten Sie die resultierende Produktmatrix. Aber um Ihren Code lesbar zu halten und Mehrdeutigkeiten zu vermeiden, verwenden Sie np.matmul() oder im @ Betreiber statt.

Fazit

🎯 In diesem Tutorial haben Sie Folgendes gelernt.

Bedingung für eine gültige Matrixmultiplikation: Anzahl von Spalten in Matrix A = Anzahl von Reihen in Matrix B.
So schreiben Sie eine benutzerdefinierte Python-Funktion, die prüft, ob die Matrixmultiplikation gültig ist, und die Produktmatrix zurückgibt. Der Hauptteil der Funktion verwendet verschachtelte for-Schleifen.
Als Nächstes haben Sie gelernt, wie Sie verschachtelte Listen verwenden, um Matrizen zu multiplizieren. Sie sind prägnanter als for-Schleifen, neigen aber zu Lesbarkeitsproblemen.
Schließlich haben Sie gelernt, die in NumPy integrierte Funktion np.matmul() zu verwenden, um Matrizen zu multiplizieren, und wie dies in Bezug auf die Geschwindigkeit am effizientesten ist.
Sie haben auch etwas über die gelernt @ Operator zum Multiplizieren zweier Matrizen in Python.

Und damit endet unsere Diskussion über die Matrixmultiplikation in Python. Als nächsten Schritt erfahren Sie, wie Sie prüfen, ob a Zahl ist in Python eine Primzahl. Oder interessant lösen Probleme mit Python-Strings.

Viel Spaß beim Lernen!🎉