numpy
numpy.dot

Syntaxis

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

parameters

Opmerkingen

Matrix vermenigvuldiging

Matrixvermenigvuldiging kan op twee equivalente manieren worden gedaan met de puntfunctie. Een manier is om de puntlidfunctie van numpy.ndarray te gebruiken.

>>> 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.]])

De tweede manier om matrixvermenigvuldiging uit te voeren is met de numpy bibliotheekfunctie.

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

Vector dot-producten

De puntfunctie kan ook worden gebruikt om vectorpuntproducten te berekenen tussen twee eendimensionale numpy arrays.

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

De parameter out

De numpy dot-functie heeft een optionele parameter out = None. Met deze parameter kunt u een array opgeven waarnaar het resultaat moet worden geschreven. Deze array moet exact dezelfde vorm en type hebben als de array die zou zijn geretourneerd, anders wordt een uitzondering gegenereerd.

>>> 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.]])

Laten we proberen het dtype van het resultaat te wijzigen in int.

>>> 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)

En als we proberen een andere onderliggende geheugenvolgorde te gebruiken, bijvoorbeeld in Fortran-stijl (zodat kolommen aaneengesloten zijn in plaats van rijen), ontstaat er ook een fout.

>>> 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)

Matrixbewerkingen op arrays van vectoren

numpy.dot kan worden gebruikt om een lijst met vectoren met een matrix te vermenigvuldigen, maar de oriëntatie van de vectoren moet verticaal zijn zodat een lijst met acht twee componentvectoren eruit ziet als twee acht componentenvectoren:

>>> 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.]])

Als de lijst met vectoren andersom is opgesteld met de assen (wat vaak het geval is), moet de array vóór en vervolgens na de puntbewerking als volgt worden omgezet:

>>> 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.]])

Hoewel de dot-functie erg snel is, is het soms beter om einsum te gebruiken. Het equivalent van het bovenstaande zou zijn:

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

Dat is iets langzamer, maar maakt het mogelijk om een lijst met hoekpunten te vermenigvuldigen met een overeenkomstige lijst met matrices. Dit zou een heel ingewikkeld proces zijn met punt:

>>> 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 kan worden gebruikt om het puntproduct van elke vector in een lijst te vinden met een overeenkomstige vector in een andere lijst. Dit is nogal rommelig en traag in vergelijking met elementgewijze vermenigvuldiging en optelling langs de laatste as. Zoiets als dit (waarvoor een veel grotere array moet worden berekend, maar meestal genegeerd)

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

Punt het product met behulp van elementaire vermenigvuldiging en optelling

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

Het gebruik van einsum kan worden bereikt met

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