numpy
numpy.dot

Syntax

• numpy.dot (a, b, out = keine)

Parameter

Bemerkungen

Matrix-Multiplikation

Die Matrixmultiplikation kann mit der Punktfunktion auf zwei gleichwertige Arten erfolgen. Eine Möglichkeit besteht darin, die Punktelementfunktion von numpy.ndarray zu verwenden.

>>> import numpy as np
>>> A = np.ones((4,4))
>>> A
array([[ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.]])
>>> B = np.ones((4,2))
>>> B
array([[ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]])
>>> A.dot(B)
array([[ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.]])

Die zweite Möglichkeit, eine Matrixmultiplikation durchzuführen, ist die Bibliotheksfunktion numpy.

>>> np.dot(A,B)
array([[ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.],
       [ 4.,  4.]])

Vektor-Punktprodukte

Mit der Punktfunktion können auch Vektorpunktprodukte zwischen zwei eindimensionalen numpy-Arrays berechnet werden.

>>> v = np.array([1,2])
>>> w = np.array([1,2])
>>> v.dot(w)
5
>>> np.dot(w,v)
5
>>> np.dot(v,w)
5

Der Out-Parameter

Die numpy-Punktfunktion hat einen optionalen Parameter out = None. Mit diesem Parameter können Sie ein Array angeben, in das das Ergebnis geschrieben werden soll. Dieses Array muss genau dieselbe Form und denselben Typ haben wie das Array, das zurückgegeben worden wäre. Andernfalls wird eine Ausnahme ausgelöst.

>>> I = np.eye(2)
>>> I
array([[ 1.,  0.],
       [ 0.,  1.]])
>>> result = np.zeros((2,2))
>>> result
array([[ 0.,  0.],
       [ 0.,  0.]])
>>> np.dot(I, I, out=result)
array([[ 1.,  0.],
       [ 0.,  1.]])
>>> result
array([[ 1.,  0.],
       [ 0.,  1.]])

Versuchen wir, den dtype des Ergebnisses in int zu ändern.

>>> np.dot(I, I, out=result)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: output array is not acceptable (must have the right type, nr dimensions, and be a C-Array)

Wenn wir versuchen, eine andere zugrunde liegende Speicherreihenfolge zu verwenden, beispielsweise Fortran-Stil (Spalten sind also zusammenhängend statt Zeilen), führt dies ebenfalls zu einem Fehler.

>>> result = np.zeros((2,2), order='F')
>>> np.dot(I, I, out=result)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: output array is not acceptable (must have the right type, nr dimensions, and be a C-Array)

Matrixoperationen auf Arrays von Vektoren

numpy.dot kann verwendet werden, um eine Liste von Vektoren mit einer Matrix zu multiplizieren. Die Ausrichtung der Vektoren muss jedoch vertikal sein, damit eine Liste von acht zwei Komponentenvektoren wie zwei acht Komponentenvektoren erscheint:

>>> a
array([[ 1.,  2.],
       [ 3.,  1.]])
>>> b
array([[  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.],
       [  9.,  10.,  11.,  12.,  13.,  14.,  15.,  16.]])
>>> np.dot(a, b)
array([[ 19.,  22.,  25.,  28.,  31.,  34.,  37.,  40.],
       [ 12.,  16.,  20.,  24.,  28.,  32.,  36.,  40.]])

Wenn die Liste der Vektoren mit ihren Achsen umgekehrt angeordnet ist (was häufig der Fall ist), muss das Array vor und dann nach der Punktoperation wie folgt verschoben werden:

>>> b
array([[  1.,   9.],
       [  2.,  10.],
       [  3.,  11.],
       [  4.,  12.],
       [  5.,  13.],
       [  6.,  14.],
       [  7.,  15.],
       [  8.,  16.]])
>>> np.dot(a, b.T).T
array([[ 19.,  12.],
       [ 22.,  16.],
       [ 25.,  20.],
       [ 28.,  24.],
       [ 31.,  28.],
       [ 34.,  32.],
       [ 37.,  36.],
       [ 40.,  40.]])

Obwohl die Punktfunktion sehr schnell ist, ist es manchmal besser, einsum zu verwenden. Das Äquivalent des Vorstehenden wäre:

>>> np.einsum('...ij,...j', a, b)

Dies ist etwas langsamer, ermöglicht jedoch die Multiplikation einer Liste von Scheitelpunkten mit einer entsprechenden Liste von Matrizen. Dies wäre ein sehr komplizierter Prozess mit Punkt:

>>> a
array([[[ 0,  1],
        [ 2,  3]],
       [[ 4,  5],
        [ 6,  7]],
       [[ 8,  9],
        [10, 11]],
       [[12, 13],
        [14, 15]],
       [[16, 17],
        [18, 19]],
       [[20, 21],
        [22, 23]],
       [[24, 25],
        [26, 27]],
       [[28, 29],
        [30, 31]]])
>>> np.einsum('...ij,...j', a, b)
array([[   9.,   29.],
       [  58.,   82.],
       [ 123.,  151.],
       [ 204.,  236.],
       [ 301.,  337.],
       [ 414.,  454.],
       [ 543.,  587.],
       [ 688.,  736.]])

numpy.dot kann verwendet werden, um das Punktprodukt jedes Vektors in einer Liste mit einem entsprechenden Vektor in einer anderen Liste zu finden. Dies ist ziemlich chaotisch und langsam, verglichen mit der elementweisen Multiplikation und dem Summieren entlang der letzten Achse. So etwas (das erfordert, dass ein viel größeres Array berechnet wird, aber meist ignoriert wird)

>>> np.diag(np.dot(b,b.T))
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])

Produkt mit elementweiser Multiplikation und Summierung punktieren

>>> (b * b).sum(axis=-1)
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])

Mit einsum konnte man mit erreichen

>>> np.einsum('...j,...j', b, b)
array([  82.,  104.,  130.,  160.,  194.,  232.,  274.,  320.])