0

I'm trying to vectorize the following function using numpy and am completely lost.

A = ndarray: Z x 3

B = ndarray: Z x 3

C = integer

D = ndarray: C x 3

Pseudocode:

entries = []
means = []
For i in range(C):
    for p in range(len(B)):
        if B[p] == D[i]:
            entries.append(A[p])
    means.append(columnwise_means(entries))
return means

an example would be :

A = [[1,2,3],[1,2,3],[4,5,6],[4,5,6]]
B = [[9,8,7],[7,6,5],[1,2,3],[3,4,5]]
C = 2
D = [[1,2,3],[4,5,6]]

Returns:

[average([9,8,7],[7,6,5]), average(([1,2,3],[3,4,5])] = [[8,7,6],[2,3,4]]

I've tried using np.where, np.argwhere, np.mean, etc but can't seem to get the desired effect. Any help would be greatly appreciated.

Thanks!

Improve this question
7
  • I think you invert A and B ? Commented Mar 28, 2016 at 16:25
  • Not sure exactly what you mean..... Commented Mar 28, 2016 at 16:29
  • Could you explain how did you get to [average([9,8,7],[7,6,5]), average(([1,2,3],[3,4,5])]? It's not really evident from the Pseudocode. Commented Mar 28, 2016 at 16:29
  • Sorry. The last step is to take a columnwise average of all of the arrays in "entries", so for i=0, entries would be [9,8,7],[7,6,5] and for i = 1, entries would be [1,2,3],[3,4,5]. Then, taking the columnwise mean of these would give me [[8,7,6],[2,3,4]] Commented Mar 28, 2016 at 16:33
  • Real Python code, even if iterative, would be easier to work with. Commented Mar 28, 2016 at 16:34

2 Answers 2

Reset to default
1

Going by the expected output of the question, I am assuming that in the actual code, you would have :

  • IF conditional statement as : if A[p] == D[i], and

  • Entries would be appended from B : entries.append(B[p]).

So, here's one vectorized approach with NumPy broadcasting and dot-product -

mask = (D[:,None,:] == A).all(-1)
out = mask.dot(B)/(mask.sum(1)[:,None])

If the input arrays are integer arrays, then you can save on memory and boost up performance, considering the arrays as indices of a n-dimensional array and thus create the 2D mask without going 3D like so - 

dims = np.maximum(A.max(0),D.max(0))+1
mask = np.ravel_multi_index(D.T,dims)[:,None] == np.ravel_multi_index(A.T,dims)

Sample run -

In [107]: A
Out[107]: 
array([[1, 2, 3],
       [1, 2, 3],
       [4, 5, 6],
       [4, 5, 6]])

In [108]: B
Out[108]: 
array([[9, 8, 7],
       [7, 6, 5],
       [1, 2, 3],
       [3, 4, 5]])

In [109]: mask = (D[:,None,:] == A).all(-1)
     ...: out = mask.dot(B)/(mask.sum(1)[:,None])
     ...: 

In [110]: out
Out[110]: 
array([[8, 7, 6],
       [2, 3, 4]])
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

very fine ! I don't imagine a complete vectorisation in this case.
@B.M. Broadcasting always makes it possible! That dot product struck as a late thought :)
@user2069641 Could you edit the pseudocode of the question to incorporate the two changes suggested at the start of the answer? Or else the posted answers won't match up with the question.
1

I see two hints :

First, comparing array by rows. A way to do that is to simplify you index system in 1D : 

def indexer(M,base=256):
    return (M*base**arange(3)).sum(axis=1)

base is an integer > A.max() . Then the selection can be done like that : 

indices=np.equal.outer(indexer(D),indexer(A))

for : 

array([[ True,  True, False, False],
       [False, False,  True,  True]], dtype=bool)

Second, each group can have different length, so vectorisation is difficult for the last step. Here a way to do achieve the job. 

B=array(B)
means=[B[i].mean(axis=0) for  i in indices]
Improve this answer

2 Comments

So, that indexer assumes inputs as integer arrays I suppose?
It seems to be the case. I don' t find vectorisable other solution for the moment.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.