numpy
numpy.dot

Sintassi

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

Parametri

Osservazioni

Moltiplicazione della matrice

La moltiplicazione della matrice può essere eseguita in due modi equivalenti con la funzione punto. Un modo è usare la funzione membro del punto di 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.]])

Il secondo modo per fare la moltiplicazione della matrice è con la funzione di libreria numpy.

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

Prodotti punto vettoriale

La funzione punto può anche essere utilizzata per calcolare prodotti a punti vettoriali tra due array numpy monodimensionali.

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

Il parametro out

La funzione numpy dot ha un parametro opzionale out = None. Questo parametro consente di specificare una matrice in cui scrivere il risultato. Questo array deve essere esattamente della stessa forma e tipo della matrice che sarebbe stata restituita, oppure verrà generata un'eccezione.

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

Proviamo a cambiare il dtype di risultato 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)

E se proviamo a utilizzare un diverso ordine di memoria sottostante, ad esempio in stile Fortran (quindi le colonne sono contigue anziché righe), si verifica anche un errore.

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

Operazioni con matrici su array di vettori

numpy.dot può essere usato per moltiplicare una lista di vettori per una matrice, ma l'orientamento dei vettori deve essere verticale in modo che una lista di otto vettori a due componenti appaia come due vettori di otto componenti:

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

Se l'elenco dei vettori è disposto con i suoi assi al contrario (che è spesso il caso), allora l'array deve essere trasposto prima e dopo l'operazione punto in questo modo:

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

Sebbene la funzione punto sia molto veloce, a volte è meglio usare einsum. L'equivalente di quanto sopra sarebbe:

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

Che è un po 'più lento ma consente di moltiplicare un elenco di vertici per un corrispondente elenco di matrici. Questo sarebbe un processo molto contorto usando il punto:

>>> 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 può essere usato per trovare il prodotto punto di ogni vettore in una lista con un vettore corrispondente in un'altra lista, questo è abbastanza disordinato e lento rispetto alla moltiplicazione e alla somma elemento-saggio lungo l'ultimo asse. Qualcosa di simile (che richiede una matrice molto più grande per essere calcolata ma per lo più ignorata)

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

Dot prodotto utilizzando la moltiplicazione e la somma di elementi

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

L'utilizzo di einsum potrebbe essere raggiunto con

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