numpy
numpy.dot

Sintaxis

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

Parámetros

Observaciones

Multiplicación de matrices

La multiplicación de matrices se puede hacer de dos maneras equivalentes con la función de punto. Una forma es usar la función miembro de punto de 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.]])

La segunda forma de hacer la multiplicación de matrices es con la función de biblioteca numpy.

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

Productos vectoriales punto

La función de puntos también se puede usar para calcular productos de puntos vectoriales entre dos matrices numpy unidimensionales.

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

El parametro de salida

La función de punto numpy tiene un parámetro opcional out = None. Este parámetro le permite especificar una matriz para escribir el resultado. Esta matriz debe ser exactamente la misma forma y tipo que la matriz que se habría devuelto, o se lanzará una excepción.

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

Intentemos cambiar el dtype del resultado a 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)

Y si intentamos usar un orden de memoria subyacente diferente, digamos estilo Fortran (por lo que las columnas son contiguas en lugar de filas), también se produce un error.

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

Operaciones matriciales sobre matrices de vectores.

numpy.dot se puede utilizar para multiplicar una lista de vectores por una matriz, pero la orientación de los vectores debe ser vertical, de modo que una lista de ocho vectores de dos componentes aparezca como dos vectores de ocho componentes:

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

Si la lista de vectores se presenta con sus ejes al revés (lo que suele ser el caso), la matriz debe transponerse antes y después de la operación de puntos como esta:

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

Aunque la función de punto es muy rápida, a veces es mejor usar einsum. El equivalente de lo anterior sería:

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

Es un poco más lento pero permite multiplicar una lista de vértices por una lista correspondiente de matrices. Este sería un proceso muy complicado usando el 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 se puede usar para encontrar el producto de puntos de cada vector en una lista con un vector correspondiente en otra lista. Esto es bastante complicado y lento en comparación con la multiplicación y suma de elementos a lo largo del último eje. Algo como esto (que requiere que se calcule una matriz mucho más grande pero que se ignore en su mayoría)

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

Producto de puntos utilizando la multiplicación y la suma de elementos.

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

Usando einsum se podría lograr con

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