numpy
numpy.dot

Syntax

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

parametrar

Anmärkningar

Matrisförökning

Matrismultiplikation kan göras på två ekvivalenta sätt med punktfunktionen. Ett sätt är att använda dot-medlemfunktionen för numpy.ndarray.

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

Det andra sättet att göra matrismultiplikation är med den numpy biblioteksfunktionen.

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

Vector dot-produkter

Punktfunktionen kan också användas för att beräkna vektorpunktsprodukter mellan två endimensionella numpy-arrayer.

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

Ut-parametern

Funktionen numpy dot har en valfri parameter ut = Ingen. Med denna parameter kan du ange en matris att skriva resultatet till. Denna matris måste ha exakt samma form och typ som den matris som skulle ha returnerats, eller så kommer ett undantag att kastas.

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

Låt oss försöka ändra dtypen för resultat till 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)

Och om vi försöker använda en annan underliggande minnesordning, säger Fortran-stil (så kolumner är sammanhängande istället för rader), resulterar också ett fel.

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

Matrisoperationer på matriser av vektorer

numpy.dot kan användas för att multiplicera en lista över vektorer med en matris men vektorernas orientering måste vara vertikal så att en lista med åtta tvåkomponentvektorer visas som två åtta komponentvektorer:

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

Om listan över vektorer läggs ut med sina axlar tvärtom (vilket ofta är fallet) måste matrisen transponeras före och sedan efter punktoperationen så här:

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

Även om punktfunktionen är väldigt snabb är det ibland bättre att använda einsum. Ekvivalentet med ovanstående skulle vara:

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

Vilket är lite långsammare men gör det möjligt att multiplicera en lista med vertikaler med en motsvarande matrislista. Detta skulle vara en mycket invecklad process med 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 kan användas för att hitta punktprodukten för varje vektor i en lista med en motsvarande vektor i en annan lista. Detta är ganska rörigt och långsamt jämfört med elementvis multiplikation och summering längs den sista axeln. Något som det här (som kräver en mycket större matris att beräknas men mest ignoreras)

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

Prickprodukt med elementvis multiplikation och summering

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

Att använda einsum skulle kunna uppnås med

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