在返回向量的函数上使用 Numpy Vectorize

Question

numpy.vectorize 接受函数 f:a->b 并将其转换为 g:a[]->b[]。

当 a 和 b 是标量时，这可以正常工作，但我想不出为什么它不能将 b 作为 ndarray 使用的原因> 或列表，即 f:a->b[] 和 g:a[]->b[][]

例如：

import numpy as np
def f(x):
    return x * np.array([1,1,1,1,1], dtype=np.float32)
g = np.vectorize(f, otypes=[np.ndarray])
a = np.arange(4)
print(g(a))

这会产生：

array([[ 0.  0.  0.  0.  0.],
       [ 1.  1.  1.  1.  1.],
       [ 2.  2.  2.  2.  2.],
       [ 3.  3.  3.  3.  3.]], dtype=object)

好的，这样会给出正确的值，但给出错误的数据类型。更糟糕的是：

g(a).shape

产量：

(4,)

所以这个数组几乎没有用。我知道我可以将它转换为：

np.array(map(list, a), dtype=np.float32)

给我我想要的东西：

array([[ 0.,  0.,  0.,  0.,  0.],
       [ 1.,  1.,  1.,  1.,  1.],
       [ 2.,  2.,  2.,  2.,  2.],
       [ 3.,  3.,  3.,  3.,  3.]], dtype=float32)

但这既不高效也不Pythonic。你们中有人能找到一种更干净的方法来做到这一点吗？

Answer 1

np.vectorize 只是一个方便的函数。它实际上并没有使代码运行得更快。如果使用np.vectorize不方便，只需编写您自己的函数即可按照您的意愿工作。

np.vectorize 的目的是将不支持 numpy 的函数（例如，将浮点数作为输入并返回浮点数作为输出）转换为可以操作（并返回）numpy 数组的函数。

您的函数 f 已经支持 numpy - 它在定义中使用 numpy 数组并返回一个 numpy 数组。因此 np.vectorize 不太适合您的用例。

因此，解决方案就是推出您自己的函数 f ，使其按照您想要的方式工作。

Answer 2

1.12.0 中的新参数 signature 完全符合您的要求。

def f(x):
    return x * np.array([1,1,1,1,1], dtype=np.float32)

g = np.vectorize(f, signature='()->(n)')

然后 g(np.arange(4)).shape 将给出 (4L, 5L)。

这里指定了f的签名。 (n) 是返回值的形状，() 是标量参数的形状。并且参数也可以是数组。对于更复杂的签名，请参阅 广义通用函数API。

Answer 3

import numpy as np
def f(x):
    return x * np.array([1,1,1,1,1], dtype=np.float32)
g = np.vectorize(f, otypes=[np.ndarray])
a = np.arange(4)
b = g(a)
b = np.array(b.tolist())
print(b)#b.shape = (4,5)
c = np.ones((2,3,4))
d = g(c)
d = np.array(d.tolist())
print(d)#d.shape = (2,3,4,5)

这应该可以解决问题，并且无论您的输入大小如何，它都会起作用。 “地图”仅适用于一维输入。使用“.tolist()”并创建一个新的 ndarray 可以更完整、更好地解决问题（我相信）。希望这有帮助。

Answer 4

您想要对函数进行矢量化

import numpy as np
def f(x):
    return x * np.array([1,1,1,1,1], dtype=np.float32)

假设您想要获得单个np.float32数组作为结果，则必须将其指定为otype。然而，在您的问题中，您指定了otypes=[np.ndarray]，这意味着您希望每个元素都是np.ndarray。因此，您正确地得到了dtype=object的结果。

正确的调用是

np.vectorize(f, signature='()->(n)', otypes=[np.float32])

对于这样一个简单的函数，最好利用 numpy 的 ufunctions； np.vectorize 只是循环遍历它。因此，在您的情况下，只需重写您的函数即可，这样

def f(x):
    return np.multiply.outer(x, np.array([1,1,1,1,1], dtype=np.float32))

速度更快，产生的错误也更少（但请注意，如果您传递复数或四边形，结果dtype将取决于x精度数，结果也是如此）。

Answer 5

我写了一个函数，看起来很适合你的需要。

def amap(func, *args):
    '''array version of build-in map
    amap(function, sequence[, sequence, ...]) -> array
    Examples
    --------
    >>> amap(lambda x: x**2, 1)
    array(1)
    >>> amap(lambda x: x**2, [1, 2])
    array([1, 4])
    >>> amap(lambda x,y: y**2 + x**2, 1, [1, 2])
    array([2, 5])
    >>> amap(lambda x: (x, x), 1)
    array([1, 1])
    >>> amap(lambda x,y: [x**2, y**2], [1,2], [3,4])
    array([[1, 9], [4, 16]])
    '''
    args = np.broadcast(None, *args)
    res = np.array([func(*arg[1:]) for arg in args])
    shape = args.shape + res.shape[1:]
    return res.reshape(shape)

让我们尝试

def f(x):
        return x * np.array([1,1,1,1,1], dtype=np.float32)
amap(f, np.arange(4))

输出

array([[ 0.,  0.,  0.,  0.,  0.],
       [ 1.,  1.,  1.,  1.,  1.],
       [ 2.,  2.,  2.,  2.,  2.],
       [ 3.,  3.,  3.,  3.,  3.]], dtype=float32)

为了方便起见，您也可以用 lambda 或partial 包装它

g = lambda x:amap(f, x)
g(np.arange(4))

---

请注意 vectorize 的文档字符串说

提供vectorize函数主要是为了方便，而不是为了
表现。该实现本质上是一个 for 循环。

因此，我们期望此处的 amap 具有与 vectorize 类似的性能。我没有检查，欢迎任何性能测试。

如果性能确实很重要，您应该考虑其他方法，例如使用 reshape 和 broadcast 进行直接数组计算，以避免纯 python 中的循环（都是 vectorize > 和 amap 是后一种情况）。

Answer 6

解决这个问题的最佳方法是使用二维 NumPy 数组（在本例中为列数组）作为原始函数的输入，然后该函数将生成一个二维输出，其中结果我相信你已经预料到了。

代码如下：

import numpy as np
def f(x):
    return x*np.array([1, 1, 1, 1, 1], dtype=np.float32)

a = np.arange(4).reshape((4, 1))
b = f(a)
# b is a 2-D array with shape (4, 5)
print(b)

这是一种更简单、更不易出错的完成操作的方法。此方法不是尝试使用 numpy.vectorize 转换函数，而是依赖于 NumPy 广播数组的天然能力。诀窍是确保数组之间至少一个维度的长度相等。