(Memorandum als E-Qualifizierungsmaßnahme)
Erstellen Sie beispielsweise $ A = \ begin {pmatrix} 1 & 1 \\ 2 & 4 \\ 3 & 1 \ end {pmatrix} $ mit 3 Zeilen und 2 Spalten.
>>> A=np.array([[1,1],[2,4],[3,1]])
>>>
>>> A
array([[1, 1],
[2, 4],
[3, 1]])
Ermitteln Sie im folgenden Beispiel die Anzahl der Zeilen und Spalten mit Form und die Gesamtzahl der Elemente mit Größe.
>>> A=np.array([[1,2,3],[4,3,2]])
>>>
>>> A.shape ##Anzahl der Zeilen / Spalten
(2, 3)
>>>
>>> A.shape[0] ##Die Anzahl der Zeilen und Spalten kann separat ausgegeben werden.
2
>>>
>>> A.shape[1]
3
>>> row, col = A.shape ##Die Anzahl der Zeilen und Spalten kann so eingestellt werden, dass Variablen getrennt werden
>>>
>>> row
2
>>>
>>> col
3
Eine Matrix, in der die Anzahl der Zeilenelemente und die Anzahl der Spaltenelemente übereinstimmen. Die Größe beträgt n Zeilen und n Spalten und wird quadratisch
Im folgenden Beispiel ist $ A = \ begin {pmatrix} 1 & 2 & 3 \\ 4 & 3 & 2 \ end {pmatrix} $ und $ \ begin {pmatrix} 1 & 2 \\ 2 & 3 \ end {pmatrix } Ermitteln Sie die Anzahl der Zeilen $ .shape [0] $ und die Anzahl der Spalten $ .shape [1] $ mit den beiden $ und vergleichen Sie die Werte, um festzustellen, ob es sich um eine quadratische Matrix handelt. $ B $ ist True und eine quadratische Matrix.
>>> A=np.array([[1,2,3],[4,3,2]])
>>>
>>> np.array_equal(A.shape[0],A.shape[1])
False
>>>
>>> B=np.array([[1,1],[2,4]])
>>>
>>> np.array_equal(B.shape[0],B.shape[1])
True
Beispiel 1 erstellt eine 1-mal-3-Matrix unter Verwendung von Zufallszahlen Beispiel 2 erstellt eine 2-mal-3-Matrix mit zufälligen Ganzzahlen bis zu 3-6 (ohne 7).
>>> np.random.rand(3) ###Beispiel 1
array([0.4449089 , 0.70920233, 0.59915992])
>>> np.random.randint(3,7,size=(2,3)) ###Beispiel 2
array([[3, 6, 4],
[5, 3, 6]])
Erstellen Sie eine Matrix mit allen Elementen 0
Erstellen Sie als Beispiel eine 2-mal-2-Nullmatrix $ W = \ begin {pmatrix} 0 & 0 \\ 0 & 0 \ end {pmatrix} $
>>> W=np.zeros((2,2,))
>>>
>>> W
array([[0., 0.],
[0., 0.]])
Erstellen Sie beispielsweise $ W = \ begin {pmatrix} 1 & 1 \\ 1 & 1 \ end {pmatrix} $, wobei alle Elemente in 2 Zeilen und 2 Spalten 1 sind.
>>> W=np.ones((2,2,))
>>>
>>> W
array([[1., 1.],
[1., 1.]])
Alle Elemente in der Hauptdiagonale sind 1 und alle anderen sind 0. Das Symbol wird als $ E $ angezeigt.
Erstellen Sie beispielsweise $ E = \ begin {pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \ end {pmatrix} $ in 3 Zeilen und 3 Spalten.
>>> E = np.eye(3)
>>>
>>> E
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
Eine Matrix aus $ n $ Zeilen und $ m $ Spalten, die durch Vertauschen der Elemente der $ m $ Zeile $ n $ Spaltenmatrix erstellt wurde. Die transponierte Matrix wird als $ A ^ {T} $ für die Matrix $ A $ angezeigt
Zum Beispiel $ \ begin {pmatrix} 2 & 3 & 1 \\ 5 & 7 & 0 \ end {pmatrix} $ Translokationsmatrix $ \ begin {pmatrix} 2 & 5 \\ 3 & 7 \\ 1 & Finde 0 \ end {pmatrix} $
>>> A=np.array([[2,3,1],[5,7,0]])
>>>
>>> A
array([[2, 3, 1],
[5, 7, 0]])
>>>
>>> AT=A.T
>>>
>>> AT
array([[2, 5],
[3, 7],
[1, 0]])
Eine quadratische Matrix, die mit ihrer eigenen Translokationsmatrix übereinstimmt Für die Matrix $ A $ ist $ A = A ^ {T} $.
Das folgende Beispiel findet und vergleicht $ \ begin {pmatrix} 1 & 7 & 3 \\ 7 & 4 & 5 \\ 3 & 5 & 6 \ end {pmatrix} $ und seine Translokationsmatrix. Das Ergebnis ist True, also eine symmetrische Matrix
>>> A=np.array([[1,7,3],[7,4,5],[3,5,6]])
>>>
>>> A
array([[1, 7, 3],
[7, 4, 5],
[3, 5, 6]])
>>>
>>> AT=A.T
>>>
>>> np.array_equal(A,AT)
True
Das Produkt der Spalten $ A $ und $ B $ wird durch $ AB $ dargestellt und kann nur dann mit np.dot berechnet werden, wenn die Anzahl der Spalten von $ A $ und die Anzahl der Zeilen von $ B $ übereinstimmen. Die Lösung des Matrixprodukts ist unterschiedlich, wenn es von rechts und von links aufgetragen wird.
Im folgenden Beispiel ist $ A = \ begin {pmatrix} 2 & 1 \\ 1 & 3 \ end {pmatrix} $ und $ B = \ begin {pmatrix} 2 & 1 \\ 1 & 2 \ end {pmatrix} Finden Sie das Produkt $ AB $ von $.
>>> A=np.array([[2,1],[1,3]])
>>>
>>> B=np.array([[2,1],[1,2]])
>>>
>>> AB=np.dot(A,B)
>>>
>>> AB
array([[5, 4],
[5, 7]])
>>>
>>> BA=np.dot(B,A)
>>>
>>> BA
array([[5, 5],
[4, 7]])
In np.dot werden die in 1 Zeile und n Spalten gezeigten Matrizen $ A $ und $ B $ als n-dimensionale horizontale Vektoren betrachtet und das innere Produkt der Vektoren wird zurückgegeben. Das innere Produkt ist der Skalarwert, der durch Multiplizieren jedes $ n $ -ten Elements und Summieren der Ergebnisse für alle Elemente erhalten wird. Wenn der Zeilenvektor auf der rechten Seite in die Form eines vertikalen Vektors konvertiert wird, wird der Wert des inneren Produkts als Matrix zurückgegeben.
Die folgende 1 ist ein 4-dimensionaler Zeilenvektor $ a = \ begin {pmatrix} \ 0 & 0 & 0 & 0 \ end {pmatrix} $ und $ b = \ begin {pmatrix} \ 0 & 0 & 0 & 0 \ Finden Sie das innere Produkt $ a \ cdot b $ von end {pmatrix} $. 2 ist das Produkt der Matrizen, weil $ b $ in einen Spaltenvektor konvertiert wurde
>>> a=np.array([2,2,2,3])
>>>
>>> b=np.array([1,2,3,4])
>>>
>>> np.dot(a,b) ###1 Das innere Produkt der Vektoren a und b wird skalar zurückgegeben
24
>>> np.dot(b,a) ###1 Da es sich um das innere Produkt der Vektoren a und b handelt, ist das Ergebnis unabhängig von der Reihenfolge der Multiplikation dasselbe.
24
>>>
>>> b_col=([[2],[2],[2],[3]]) ###2b ist eine eindimensionale 4-Spalten-Matrix
>>>
>>> np.dot(a,b_col) ###2 b wird als eindimensionale 4-Spalten-Matrix zurückgegeben
array([24])
>>>
Eine Matrix, in der die Einheitsmatrix $ E $ erhalten wird, unabhängig davon, ob die quadratische Matrix A von rechts oder links multipliziert wird. Wenn die inverse Matrix durch $ A ^ {-1} $ für die Matrix $ A $ angegeben wird $ AA ^ {-1} = A ^ {-1} A = E $ gilt
Erstellen Sie beispielsweise eine 2-mal-2-Matrix $ A = \ begin {pmatrix} 2 & 3 \\ 2 & 4 \ end {pmatrix} $ und suchen Sie die inverse Matrix $ A ^ {-1} $.
>>> A=np.array([[2,3],[2,4]])
>>>
>>> AI=np.linalg.inv(A)
>>>
>>> AI
array([[ 2. , -1.5],
[-1. , 1. ]])
Eine quadratische Matrix mit einer inversen Matrix. Nicht alle Matrizen haben eine inverse Matrix.
Im folgenden Beispiel kann $ AA ^ {-1} = A ^ {-1} A = E $ bestätigt werden, sodass sowohl $ A $ als auch $ AI $ reguläre Matrizen sind.
>>> A=np.array([[1,1],[2,4]])
>>>
>>> AI=np.linalg.inv(A)
>>>
>>> np.dot(A,AI)
array([[1., 0.],
[0., 1.]])
>>>
>>> np.dot(AI,A)
array([[1., 0.],
[0., 1.]])
Recommended Posts