将多个函数应用于数组的每一行

Question

我有一个 numpy 数组，它只有几个非零条目，可以是正数或负数。例如。像这样：

myArray = np.array([[ 0.        ,  0.        ,  0.        ],
       [ 0.32, -6.79,  0.        ],
       [ 0.        ,  0.        ,  0.        ],
       [ 0.        ,  1.5        ,  0.        ],
       [ 0.        ,  0.        , -1.71]])

最后，我想收到一个列表，其中该列表的每个条目对应于 myArray 的一行，并且是函数输出的累积乘积，函数输出取决于 myArray 的相应行和另一个列表的条目（在下面的例子称为 l)。 各个术语取决于 myArray 条目的符号：当它为正时，我应用“funPos”，当它为负时，我应用“funNeg”，如果条目为 0，则术语将为 1。所以在示例中上面的数组将是：

output = [1*1*1 , 
         funPos(0.32, l[0])*funNeg(-6.79,l[1])*1, 
         1*1*1, 
         1*funPos(1.5, l[1])*1, 
         1*1*funNeg(-1.71, l[2])]

我实现了这个，如下所示，它给了我想要的输出（注意：这只是一个高度简化的玩具示例；实际的矩阵要大得多，函数也更复杂）。我遍历数组的每一行，如果行的和为0，我不需要做任何计算，输出只是1。如果不等于0，我遍历这一行，检查符号每个值并应用适当的函数。

import numpy as np
def doCalcOnArray(Array1, myList):

    output = np.ones(Array1.shape[0]) #initialize output

    for indRow,row in enumerate(Array1):

    if sum(row) != 0: #only then calculations are needed
        tempProd = 1. #initialize the product that corresponds to the row
        for indCol, valCol in enumerate(row):

        if valCol > 0:
            tempVal = funPos(valCol, myList[indCol])

        elif valCol < 0:
            tempVal = funNeg(valCol, myList[indCol])

        elif valCol == 0:
            tempVal = 1

        tempProd = tempProd*tempVal

        output[indRow] = tempProd

    return output 

def funPos(val1,val2):
    return val1*val2

def funNeg(val1,val2):
    return val1*(val2+1)

myArray = np.array([[ 0.        ,  0.        ,  0.        ],
       [ 0.32, -6.79,  0.        ],
       [ 0.        ,  0.        ,  0.        ],
       [ 0.        ,  1.5        ,  0.        ],
       [ 0.        ,  0.        , -1.71]])     

l = [1.1, 2., 3.4]

op = doCalcOnArray(myArray,l)
print op

输出是

[ 1.      -7.17024  1.       3.      -7.524  ]

这是想要的。
我的问题是是否有更有效的方法来做到这一点，因为这对于大型阵列来说非常“昂贵”。

编辑： 我接受了 gabhijit 的回答，因为他提出的纯 numpy 解决方案似乎是我正在处理的数组中最快的解决方案。请注意，RaJa 还提供了一个不错的工作解决方案，它需要 panda，并且 dave 的解决方案也可以正常工作，可以作为如何使用生成器和 numpy 的“apply_along_axis”的一个很好的例子。

Answer 1

这是我尝试过的 - 使用 reduce、map。我不确定这有多快 - 但这是你想要做的吗？

编辑 4：最简单且最具可读性 - 将 l 设为 numpy 数组，然后大大简化 where。

import numpy as np
import time

l = np.array([1.0, 2.0, 3.0])

def posFunc(x,y):
    return x*y

def negFunc(x,y):
    return x*(y+1)

def myFunc(x, y):
    if x > 0:
        return posFunc(x, y)
    if x < 0:
        return negFunc(x, y)
    else:
        return 1.0

myArray = np.array([
        [ 0.,0.,0.],
        [ 0.32, -6.79,  0.],
        [ 0.,0.,0.],
        [ 0.,1.5,0.],
        [ 0.,0., -1.71]])

t1 = time.time()
a = np.array([reduce(lambda x, (y,z): x*myFunc(z,l[y]), enumerate(x), 1) for x in myArray])
t2 = time.time()
print (t2-t1)*1000000
print a

基本上让我们看一下它在enumerate(xx) 中的最后一行，它表示从 1 开始（reduce 的最后一个参数）。 myFunc 只取 myArray(row) 中的元素和l 中的元素@index row 并根据需要将它们相乘。

我的输出与你的不同 - 所以我不确定这是否正是你想要的，但也许你可以遵循逻辑。

另外，我不太确定这对于大型数组来说有多快。

编辑：以下是执行此操作的“纯 numpy 方式”。

my = myArray # just for brevity

t1 = time.time() 
# First set the positive and negative values
# complicated - [my.itemset((x,y), posFunc(my.item(x,y), l[y])) for (x,y) in zip(*np.where(my > 0))]
# changed to 
my = np.where(my > 0, my*l, my)
# complicated - [my.itemset((x,y), negFunc(my.item(x,y), l[y])) for (x,y) in zip(*np.where(my < 0))]
# changed to 
my = np.where(my < 0, my*(l+1), my)
# print my - commented out to time it.

# Now set the zeroes to 1.0s
my = np.where(my == 0.0, 1.0, my)
# print my  - commented out to time it

a = np.prod(my, axis=1)
t2 = time.time()
print (t2-t1)*1000000

print a

让我尽量解释zip(*np.where(my != 0)) 部分。 np.where 只返回两个 numpy 数组，第一个数组是行索引，第二个数组是匹配条件 (my != 0) 在这种情况下的列索引。我们获取这些索引的元组，然后使用array.itemset 和array.item，谢天谢地，列索引对我们是免费的，所以我们可以在列表l 中获取该索引的元素@。这应该比以前更快（并且可读的数量级！！）。需要timeit 来查明是否确实如此。

编辑2：不必单独调用正面和负面可以通过一个电话np.where(my != 0)来完成。

Answer 2

那么，让我们看看我是否理解你的问题。

1. 您希望将矩阵的元素映射到一个新矩阵，这样：
   • 0 映射到 1
   • x>0 映射到 funPos(x)
   • x<0 映射到 funNeg(x)
2. 您想要计算此新矩阵中行中所有元素的乘积。

所以，我会这样做：

1：

def myFun(a):
    if a==0:
        return 1
    if a>0:
        return funPos(a)
    if a<0:
        return funNeg(a)

newFun = np.vectorize(myFun)
newArray = newFun(myArray)

对于 2：

np.prod(newArray, axis = 1)

---

编辑：要将索引传递给 funPos、funNeg，您可能可以这样做：

# Python 2.7
r,c = myArray.shape
ctr = -1       # I don't understand why this should be -1 instead of 0
def myFun(a):
    global ctr
    global c
    ind = ctr % c
    ctr += 1
    if a==0:
        return 1
    if a>0:
        return funPos(a,l[ind])
    if a<0:
        return funNeg(a,l[ind])

Answer 3

我认为这个 numpy 函数会对你有所帮助

numpy.apply_along_axis

这是一种实现。此外，我会警告不要检查数组的总和是否为 0。由于机器精度限制，将浮点数与 0 进行比较可能会产生意外行为。此外，如果您有 -5 和 5，则总和为零，我不确定这就是您想要的。我使用 numpy 的 any() 函数来查看是否有任何非零值。为简单起见，我还将您的列表 (my_list) 拉入了全局范围。

import numpy as np


my_list = 1.1, 2., 3.4

def func_pos(val1, val2):
    return val1 * val2

def func_neg(val1, val2):
    return val1 *(val2 + 1)


def my_generator(row):
    for i, a in enumerate(row):
        if a > 0:
            yield func_pos(a, my_list[i])
        elif a < 0:
            yield func_neg(a, my_list[i])
        else:
            yield 1


def reduce_row(row):
    if not row.any():
        return 1.0
    else:
        return np.prod(np.fromiter(my_generator(row), dtype=float))


def main():
    myArray = np.array([
            [ 0.        ,  0.        ,  0.        ],
            [ 0.32, -6.79,  0.        ],
            [ 0.        ,  0.        ,  0.        ],
            [ 0.        ,  1.5        ,  0.        ],
            [ 0.        ,  0.        , -1.71]])
    return np.apply_along_axis(reduce_row, axis=1, arr=myArray)

可能有更快的实现，我认为 apply_along_axis 实际上只是一个隐藏的循环。

我没有测试，但我敢打赌这比你开始的更快，并且应该更节省内存。

Answer 4

我已经使用 numpy 数组的屏蔽功能尝试了您的示例。但是，我找不到将数组中的值替换为 funPos 或 funNeg 的解决方案。

所以我的建议是尝试使用 pandas 来代替它，因为它在屏蔽时会保存索引。

看我的例子：

import numpy as np
import pandas as pd

def funPos(a, b):
    return a * b
def funNeg(a, b):
    return a * (b + 1)

myPosFunc = np.vectorize(funPos) #vectorized form of funPos
myNegFunc = np.vectorize(funNeg) #vectorized form of funNeg

#Input
I = [1.0, 2.0, 3.0]    
x = pd.DataFrame([
    [ 0.,0.,0.],
    [ 0.32, -6.79,  0.],
    [ 0.,0.,0.],
    [ 0.,1.5,0.],
    [ 0.,0., -1.71]])

b = pd.DataFrame(myPosFunc(x[x>0], I)) #calculate all positive values
c = pd.DataFrame(myNegFunc(x[x<0], I)) #calculate all negative values   
b = b.combineMult(c) #put values of c in b
b = b.fillna(1) #replace all missing values that were '0' in the raw array
y = b.product() #multiply all elements in one row

#Output
print ('final result')
print (y)
print (y.tolist())