这是一个 Python/Numpy 错误还是一个微妙的陷阱？

Question

考虑同一段代码的以下两个实现。我本以为它们是相同的，但它们不是。

这是一个 Python/Numpy 错误还是一个微妙的陷阱？如果是后者，什么规则可以说明为什么它没有按预期工作？

我正在处理多个数据数组，必须逐项处理每个数组，每个数组由 table 操作，具体取决于它的元数据。

在现实世界的例子中 'n' 是多个因素和偏移量，但下面的代码仍然演示了我在除一种情况外的所有情况下都得到错误结果的问题。

import numpy as np

# Change the following line to True to show different behaviour
NEEDS_BUGS = False  # Changeme

# Create some data
data = np.linspace(0, 1, 10)
print(data)

# Create an array of vector functions each of which does a different operation on a set of data
vfuncd = dict()

# Two implementations
if NEEDS_BUGS:
    # Lets do this in a loop because we like loops - However WARNING this does not work!!
    for n in range(10):
        vfuncd[n] = np.vectorize(lambda x: x * n)
else:
    # Unwrap the loop - NOTE: Spoiler - this works
    vfuncd[0] = np.vectorize(lambda x: x * 0)
    vfuncd[1] = np.vectorize(lambda x: x * 1)
    vfuncd[2] = np.vectorize(lambda x: x * 2)
    vfuncd[3] = np.vectorize(lambda x: x * 3)
    vfuncd[4] = np.vectorize(lambda x: x * 4)
    vfuncd[5] = np.vectorize(lambda x: x * 5)
    vfuncd[6] = np.vectorize(lambda x: x * 6)
    vfuncd[7] = np.vectorize(lambda x: x * 7)
    vfuncd[8] = np.vectorize(lambda x: x * 8)
    vfuncd[9] = np.vectorize(lambda x: x * 9)

# Prove we have multiple different vectorised functions
for k, vfunc in vfuncd.items():
    print(k, vfunc)

# Do the work
res = {k: vfuncd[k](data) for k in vfuncd.keys()}

# Show the result
for k, r in res.items():
    print(k, r)

Answer 1

我不知道你到底想达到什么目的，也不知道这是否是个坏主意（就 np.vectorize 而言），但你面临的问题是因为 the way python makes closures.引用链接问题的答案：

Scoping in Python is lexical. A closure will always remember the name and scope of the variable, not the object it's pointing to. Since all the functions in your example are created in the same scope and use the same variable name, they always refer to the same variable.

换句话说，当您关闭 n 时，您实际上并没有关闭 n 的状态，只是名称。所以当 n 改变时，闭包中的值也会改变。这让我很意外，但是 others find it natural.

这是一个使用 partial 的修复方法：

from functools import partial
.
.
.

def func(x, n):
    return x * n

for n in range(10):
    vfuncd[n] = np.vectorize(partial(func, n=n))

或者另一个使用工厂方法

def func_factory(n):
    return lambda x: x * n

for n in range(10):
    vfuncd[n] = np.vectorize(func_factory(n))

Answer 2

似乎 python 变量 n 绑定到向量化表达式：

for n in range(10):
    vfuncd[n] = np.vectorize(lambda x: x * n)

这修复了它，因为它创建了一个要绑定的新对象：

for n in range(10):
    vfuncd[n] = np.vectorize(lambda x: x * np.scalar(n))

事实上，这对性能有影响，因为我假设必须重复获取 python 变量的值。

Answer 3

In [13]: data = np.linspace(0,1,11)

因为 data 数组可以乘以一个简单的：

In [14]: data*3                                                                         
Out[14]: array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1, 2.4, 2.7, 3. ])

我们不需要 np.vectorize 的复杂性来查看关闭问题。一个简单的lambda就够了。

In [15]: vfuncd = {} 
    ...: for n in range(3): 
    ...:     vfuncd[n] = lambda x:x*n 
    ...:                                                                                
In [16]: vfuncd                                                                         
Out[16]: 
{0: <function __main__.<lambda>(x)>,
 1: <function __main__.<lambda>(x)>,
 2: <function __main__.<lambda>(x)>}
In [17]: {k:v(data) for k,v in vfuncd.items()}                                          
Out[17]: 
{0: array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ]),
 1: array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ]),
 2: array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ])}

如果我们使用适当的 numpy “矢量化”，我们将不会遇到闭包问题：

In [18]: data * np.arange(3)[:,None]                                                    
Out[18]: 
array([[0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ],
       [0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ],
       [0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ]])

或者一个简单的迭代是我们需要一个字典：

In [20]: {k:data*k for k in range(3)}                                                   
Out[20]: 
{0: array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
 1: array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ]),
 2: array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ])}

np.vectorize 有速度免责声明。但是函数只接受标量输入是合理的，我们想要 numpy 广播的灵活性——即 2 个或更多参数。

创建多个 vectorize 显然是一个 'anti-pattern'。我宁愿看到一个带有适当参数的 vectorize：

In [25]: f = np.vectorize(lambda x,n: x*n)                                              
In [26]: {n: f(data,n) for n in range(3)}                                               
Out[26]: 
{0: array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),
 1: array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ]),
 2: array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ])}

那f也可以生成数组Out[18]（但速度较慢）：

In [27]: f(data, np.arange(3)[:,None])                                                  
Out[27]: 
array([[0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ],
       [0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ],
       [0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ]])

这是一个 Python/Numpy 错误还是一个微妙的陷阱？

Is this a Python/Numpy bug or a subtle gotcha?

python

closures

numpy

vectorization