取第一个和第二个中间条目，第二个和第二个中间条目的点积，直到中间1和最后一个条目python / numpy

Question

Sorry for the vague sounding question, I really couldn't think of a better way to describe what I am trying to do

I have a 81x990000x3 array and for each of the 81 entries; I need to sum the dot product of the first entry with the 495000th entry (the middle), the second with the 495001st entry and so on until the 494999th entry with the last entry.

Right now I have it being done in a loop like this:

import numpy as np
summed = 0

Nt = 990000
i = Nt/2

for k in xrange(81):
  for j in xrange(Nt-i-1):
    vec1 = array[k][j]
    vec2 = array[k][j+i]

    summed += np.dot(vec1,vec2)

This is obviously quite slow, however, since it is going through 81x990000 = 80190000 entries.

Is there a more numpythonic way to do this?

Answer 1

NB reading your question, I think you want your second nested loop to be for j in xrange(Nt-i): since xrange excludes the upper limit.

I think you can what you want with einsum :

import numpy as np
summed = 0

dim1 = 2  # this is 81 in your case
dim2 = 4  # this is 990000 in your case
array = np.random.random(size=(dim1, dim2, 3))

Nt = dim2
i = Nt // 2

for k in xrange(dim1):
    summed = 0
    for j in xrange(dim2-i):
        vec1 = array[k][j]
        vec2 = array[k][j+i]
        summed += np.dot(vec1,vec2)
    print summed

print '='*70

for k in xrange(dim1):
    summed = np.einsum('ij,ij', array[k][:Nt//2], array[k][Nt//2:])
    print summed

eg

2.0480375425
1.89065215839
======================================================================
2.0480375425
1.89065215839

Doubtless you can even remove the outer loop as well (though in your case it probably won't speed things up much):

np.einsum('kij,kij->k', array[:,:Nt//2,:], array[:,Nt//2:,:])

gives

[ 2.0480375425  1.89065215839]

Answer 2

Since you want to go from 0 until the 494999th entry, I think the code needs a slight edit for the jth iterations and has to be for j in xrange(Nt-i) instead. Now, back to the problem at hand, you are basically cutting each 3D slice into two halves and doing elementwise multiplication between them and thereafter summing all elements. Here, by slice I mean a 2D array formed by axis =(1,2) .

To solve our case, you can simulate -

• Cutting into two halves with : .reshape() .
• Elementwise multiplication betwen correspondng elements with : .prod() .
• Summing all elements with : .sum() .

Thus, the implementation would look something like this -

m,n,r = array.shape
out = array.reshape(m,2,-1,r).prod(1).sum()

Runtime tests and verify output -

Define functions :

def vectorized_app(array):
    m,n,r = array.shape
    return array.reshape(m,2,-1,r).prod(1).sum()

def org_app(array):
    m,n,r = array.shape
    Nt = n
    i = Nt/2
    summed = 0
    for k in xrange(m):
      for j in xrange(Nt-i):
        vec1 = array[k][j]
        vec2 = array[k][j+i]
        summed += np.dot(vec1,vec2)
    return summed

Runtimes :

In [94]: array = np.random.rand(81,9900,3)

In [95]: org_app(array)
Out[95]: 300450.24128635536

In [96]: vectorized_app(array)
Out[96]: 300450.24128635362

In [97]: %timeit org_app(array)
1 loops, best of 3: 1.29 s per loop

In [98]: %timeit vectorized_app(array)
100 loops, best of 3: 16.1 ms per loop