Vectorizing an equation using numpy

Question

I am trying to implement the above formula as a vectorized form. K=3here Xis a 150x4numpy array. mu- a 3x4numpy array . Gamma- a 150x3numpy array . Sigma- a kx4x4numpy array . Therefore, it Sigma[k]is a 4x4numpy array .N=150

N_k = np.sum(Gamma, axis=0)
for k in range(K): # Correct
         x_new = X - mu[k] #Correct
         a = np.dot(x_new.T, x_new) #Incorrect from here I feel
         for i in range(len(data)):
             sigma[k] = Gamma[i][k] * a
         sigma[k]=sigma[k]/N_k #totally incorrect

How to fix it?

Answer 1

Amount of products? sounds like work for np.einsum :

import numpy as np
N = 150
K = 3
M = 4
x = np.random.random((N,M))
mu = np.random.random((K,M))
gamma = np.random.random((N,K))

xbar = x-mu[:,None,:] # shape (3, 150, 4)
sigma = np.einsum('nk,knm,kno->kmo', gamma, xbar, xbar)
sigma /= gamma.sum(axis=0)[:,None,None]

---

Decoding'nk,knm,kno->kmo' :

(->), .

gamma, xbar xbar, np.einsum.

gamma nk, , . xbar (3, 150, 4). knm, k n , , m - , 4, , , -, .

kno. o , o , m, m. , , m o , . .

, n (nk, knm, kno), ( kmo). np.einsum n.

k . np.einsum, k , ( ) k.

kmo , . , sigma (K,M,M) (.. (3,4,4)).

Answer 2

, unubtu.

np.einsum . , , :

def unubtu():
    xbar = x-mu[:,None,:] # shape (3, 150, 4)
    sigma = np.einsum('nk,knm,kno->kmo', gamma, xbar, xbar)
    sigma /= gamma.sum(axis=0)[:,None,None]
    return sigma

def faster():
    xbar = x-mu[:,None,:] # shape (3, 150, 4)
    sigma = np.einsum('knm,kno->kmo', gamma.T[..., None] * xbar, xbar)
    sigma /= gamma.sum(axis=0)[:,None,None]
    return sigma

In [50]: %timeit unubtu()
10000 loops, best of 3: 147 µs per loop

In [51]: %timeit faster()
10000 loops, best of 3: 129 µs per loop

12% , .

, , np.einsum , , , np.dot, numpy . , , K , np.dot Python :

def even_faster():
    sigma = np.empty((K, M, M))
    for k in xrange(K):
        x_ = x - mu[k]
        sigma[k] = np.dot((x_ * gamma[:, k, None]).T, x_)
    sigma /= gamma.sum(axis=0)[:,None,None]
    return sigma

In [52]: %timeit even_faster()
10000 loops, best of 3: 101 µs per loop