Vektorisierte Methode zur Berechnung von zeilenweisen Skalarprodukten zwei Matrizen mit Scipy

Question

Ich möchte das zeilenweise Skalarprodukt zweier Matrizen der gleichen Dimension so schnell wie möglich berechnen. Dies ist die Art, wie ich es tue:

import numpy as np 
a = np.array([[1,2,3], [3,4,5]]) 
b = np.array([[1,2,3], [1,2,3]]) 
result = np.array([]) 
for row1, row2 in a, b: 
    result = np.append(result, np.dot(row1, row2)) 
print result 

und natürlich die Ausgabe lautet:

[ 26. 14.] 

Answer 1

Check out numpy.einsum für eine andere Methode:

In [52]: a 
Out[52]: 
array([[1, 2, 3], 
     [3, 4, 5]]) 

In [53]: b 
Out[53]: 
array([[1, 2, 3], 
     [1, 2, 3]]) 

In [54]: einsum('ij,ij->i', a, b) 
Out[54]: array([14, 26]) 

wie einsum Sieht ein bisschen schneller als inner1d:

In [94]: %timeit inner1d(a,b) 
1000000 loops, best of 3: 1.8 us per loop 

In [95]: %timeit einsum('ij,ij->i', a, b) 
1000000 loops, best of 3: 1.6 us per loop 

In [96]: a = random.randn(10, 100) 

In [97]: b = random.randn(10, 100) 

In [98]: %timeit inner1d(a,b) 
100000 loops, best of 3: 2.89 us per loop 

In [99]: %timeit einsum('ij,ij->i', a, b) 
100000 loops, best of 3: 2.03 us per loop 

Answer 2

Sie werden besser tun, um die append zu vermeiden, aber ich kann so nicht denken um die Pythonschleife zu vermeiden. Eine benutzerdefinierte Ufunc vielleicht? Ich denke numpy.vectorize wird dir hier nicht helfen.

import numpy as np 
a=np.array([[1,2,3],[3,4,5]]) 
b=np.array([[1,2,3],[1,2,3]]) 
result=np.empty((2,)) 
for i in range(2): 
    result[i] = np.dot(a[i],b[i])) 
print result 

EDIT

Basierend auf this answer, sieht es aus wie inner1d funktionieren kann, wenn die Vektoren in der realen Welt Problem 1D sind.

from numpy.core.umath_tests import inner1d 
inner1d(a,b) # array([14, 26]) 

Answer 3

einfache Art und Weise zu tun, ist:

import numpy as np 
a=np.array([[1,2,3],[3,4,5]]) 
b=np.array([[1,2,3],[1,2,3]]) 
np.sum(a*b, axis=1) 

, die die Python-Schleife und ist schneller in solchen Fällen vermeidet:

def npsumdot(x, y): 
    return np.sum(x*y, axis=1) 

def loopdot(x, y): 
    result = np.empty((x.shape[0])) 
    for i in range(x.shape[0]): 
     result[i] = np.dot(x[i], y[i]) 
    return result 

timeit npsumdot(np.random.rand(500000,50),np.random.rand(500000,50)) 
# 1 loops, best of 3: 861 ms per loop 
timeit loopdot(np.random.rand(500000,50),np.random.rand(500000,50)) 
# 1 loops, best of 3: 1.58 s per loop 

Answer 4

rumgespielt mit diesem und gefunden inner1d die schnellste:

Das Grundstück erstellt wurde mit perfplot (ein kleines Projekt Mine)

import numpy 
from numpy.core.umath_tests import inner1d 
import perfplot 

perfplot.show(
     setup=lambda n: (numpy.random.rand(n, 3), numpy.random.rand(n, 3)), 
     n_range=[2**k for k in range(1, 17)], 
     kernels=[ 
      lambda data: numpy.sum(data[0] * data[1], axis=1), 
      lambda data: numpy.einsum('ij, ij->i', data[0], data[1]), 
      lambda data: inner1d(data[0], data[1]) 
      ], 
     labels=['np.sum(a*b, axis=1)', 'einsum', 'inner1d'], 
     logx=True, 
     logy=True, 
     xlabel='len(a), len(b)' 
     )