Question

代码如下：

import numpy as np
X = np.array(range(15)).reshape(5,3)  # X's element value is meaningless
flag = np.random.randn(5,4)
y = np.array([0, 1, 2, 3, 0])  # Y's element value in range(flag.shape[1]) and Y.shape[0] equals X.shape[0]
dW = np.zeros((3, 4))  # dW.shape equals (X.shape[1], flag.shape[1])
for i in xrange(5):
    for j in xrange(4):
        if flag[i,j] > 0:
            dW[:,j] += X[i,:].T
            dW[:,y[i]] -= X[i,:].T

为了更有效地计算dW，如何对此循环进行矢量化？

Answer 1

我是这样做的：

# has shape (x.shape[1],) + flag.shape
masked = np.where(flag > 0, X.T[...,np.newaxis], 0)

# sum over the i index
dW = masked.sum(axis=1)

# sum over the j index
np.subtract.at(dW, np.s_[:,y], masked.sum(axis=2))

# dW[:,y] -= masked.sum(axis=2) does not work here

请参阅ufunc.at的文档，了解对最后一条评论的解释

Answer 2

这是基于np.add.reduceat -

的矢量化方法

# --------------------- Setup output array ----------------------------------
dWOut = np.zeros((X.shape[1], flag.shape[1]))

# ------ STAGE #1 : Vectorize calculations for "dW[:,j] += X[i,:].T" --------
# Get indices where flag's transposed version has > 0
idx1 = np.argwhere(flag.T > 0)

# Row-extended version of X using idx1's col2 that corresponds to i-iterator
X_ext1 = X[idx1[:,1]]

# Get the indices at which we need to columns change
shift_idx1 = np.append(0,np.where(np.diff(idx1[:,0])>0)[0]+1)

# Use the changing indices as boundaries for add.reduceat to add 
# groups of rows from extended version of X
dWOut[:,np.unique(idx1[:,0])] += np.add.reduceat(X_ext1,shift_idx1,axis=0).T

# ------ STAGE #2 : Vectorize calculations for "dW[:,y[i]] -= X[i,:].T" -------
# Repeat same philsophy for this second stage, except we need to index into y.
# So, that would involve sorting and also the iterator involved is just "i".
idx2 = idx1[idx1[:,1].argsort()]
cols_idx1 = y[idx2[:,1]]
X_ext2 = X[idx2[:,1]]
sort_idx = (y[idx2[:,1]]).argsort()
X_ext2 = X_ext2[sort_idx]
shift_idx2 = np.append(0,np.where(np.diff(cols_idx1[sort_idx])>0)[0]+1)
dWOut[:,np.unique(cols_idx1)] -= np.add.reduceat(X_ext2,shift_idx2,axis=0).T

Answer 3

你可以这样做：

ff = (flag > 0) * 1
ff = ff.reshape((5, 4, 1, 1))
XX = ff * X
[ii, jj] = np.meshgrid(np.arange(5), np.arange(4))
dW[:, jj] += XX[ii, jj, ii, :].transpose((2, 0, 1))
dW[:, y[ii]] -= XX[ii, jj, ii, :].transpose((2, 0, 1))

您可以进一步合并和折叠这些表达式以获得单行，但它不会再添加任何性能。

更新＃1：是的，抱歉这不能给出正确的结果，我的支票上有拼写错误

如何在numpy中将此for循环向量化？

3 个答案: