python - example - diferencia entre numpy dot() e inner()

numpy matrix multiplication

Question

Cuál es la diferencia entre

import numpy as np
np.dot(a,b)

y

import numpy as np
np.inner(a,b)

todos los ejemplos que intenté devolvieron el mismo resultado. Wikipedia tiene el mismo artículo para ambos ?! En la descripción de inner() dice que su comportamiento es diferente en dimensiones superiores, pero no pude producir ningún resultado diferente. ¿Cuál debería usar?

Answer 1

Hay una gran diferencia entre el producto interno y el producto punto en el espacio dimensional superior. a continuación se muestra un ejemplo de una matriz de 2x2 y una matriz de 3x2 x = [[a1, b1], [c1, d1]] y = [[a2, b2]. [c2, d2], [e2, f2]

np.inner (x, y)

salida = [[a1xa2 + b1xb2, a1xc2 + b1xd2, a1xe2 + b1f2], [c1xa2 + d1xb2, c1xc2 + d1xd2, c1xe2 + d1xf2]]

Pero en el caso del producto punto, el resultado muestra el siguiente error ya que no se puede multiplicar una matriz de 2x2 con un 3x2.

ValueError: formas (2,2) y (3,2) no alineadas: 2 (dim 1)! = 3 (dim 0)

Answer 2

Para matrices de 1 y 2 dimensiones numpy.inner funciona como transponer la segunda matriz y luego multiplicar. Entonces para:

A = [[a1,b1],[c1,d1]]
B = [[a2,b2],[c2,d2]]
numpy.inner(A,B)
array([[a1*a2 + b1*b2, a1*c2 + b1*d2],
       [c1*a2 + d1*b2, c1*c2 + d1*d2])

Lo resolví usando ejemplos como:

A=[[1  ,10], [100,1000]]
B=[[1,2], [3,4]]
numpy.inner(A,B)
array([[  21,   43],
       [2100, 4300]])

Esto también explica el comportamiento en una dimensión, numpy.inner([a,b],[c,b]) = ac+bd y numpy.inner([[a],[b]], [[c],[d]]) = [[ac,ad],[bc,bd]] . Este es el grado de mi conocimiento, no tengo idea de lo que hace para las dimensiones más altas.

Answer 3

Simplemente hablando, np.dot da la multiplicación de la matriz ( ) wheras np.inner da el producto tensor ( )

Answer 4

inner no funciona correctamente con arrays 2D complejos, intenta multiplicar

y su transposición

array([[ 1.+1.j,  4.+4.j,  7.+7.j],
       [ 2.+2.j,  5.+5.j,  8.+8.j],
       [ 3.+3.j,  6.+6.j,  9.+9.j]])

conseguirás

array([[ 0. +60.j,  0. +72.j,  0. +84.j],
       [ 0.+132.j,  0.+162.j,  0.+192.j],
       [ 0.+204.j,  0.+252.j,  0.+300.j]])

efectivamente multiplicando las filas por filas en lugar de filas por columnas

Answer 5

numpy.dot :

Para las matrices en 2-D es equivalente a la multiplicación de matrices, y para las matrices de 1-D al producto interno de los vectores (sin conjugación compleja). Para N dimensiones, es un producto de suma sobre el último eje de ay el penúltimo de b:

numpy.inner :

Producto interno ordinario de vectores para matrices en 1-D (sin conjugación compleja), en dimensiones superiores un producto de suma sobre los últimos ejes .

(Énfasis mío)

Como ejemplo, considere este ejemplo con matrices 2D:

>>> a=np.array([[1,2],[3,4]])
>>> b=np.array([[11,12],[13,14]])
>>> np.dot(a,b)
array([[37, 40],
       [85, 92]])
>>> np.inner(a,b)
array([[35, 41],
       [81, 95]])

Por lo tanto, la que debe usar es la que proporciona el comportamiento correcto para su aplicación.

Pruebas de rendimiento

(Tenga en cuenta que estoy probando solo el caso 1D, ya que esa es la única situación donde .dot y .inner dan el mismo resultado).

>>> import timeit
>>> setup = ''import numpy as np; a=np.random.random(1000); b = np.random.random(1000)''

>>> [timeit.timeit(''np.dot(a,b)'',setup,number=1000000) for _ in range(3)]
[2.6920320987701416, 2.676928997039795, 2.633111000061035]

>>> [timeit.timeit(''np.inner(a,b)'',setup,number=1000000) for _ in range(3)]
[2.588860034942627, 2.5845699310302734, 2.6556360721588135]

Así que tal vez .inner es más rápido, pero mi máquina está bastante cargada en este momento, por lo que los tiempos no son consistentes ni son necesariamente muy precisos.

Answer 6

np.dot y np.inner son idénticos para las matrices de 1 dimensión, por lo que es probable que por eso no note ninguna diferencia. Para arreglos de dimensión N, corresponden a operaciones de tensor comunes.

np.inner veces se llama un "producto vectorial" entre un tensor de orden superior e inferior, particularmente un tensor multiplicado por un vector, y a menudo conduce a una "contracción de tensor". Incluye la multiplicación matriz-vector.

np.dot corresponde a un "producto tensorial" e incluye el caso mencionado en la parte inferior de la página de Wikipedia. Generalmente se usa para la multiplicación de dos tensores similares para producir un nuevo tensor. Incluye la multiplicación matriz-matriz.

Si no está usando tensores, entonces no necesita preocuparse por estos casos y se comportan de manera idéntica.