3

背景

我有一个函数，它接受多个参数并返回一个错误度量，然后我想最小化它（使用scipy.optimize.leastsq，但现在这不是重点）。

作为一个玩具示例，假设我的优化函数采用四个参数 a、b、c、d：

def f(a,b,c,d):
    err = a*b - c*d
    return err

然后，优化器需要一个带有参数向量的签名的func(x, *args)函数。x

也就是说，我的函数目前写成这样：

def f_opt(x, *args):
    a,b,c,d = x
    err = a*b - c*d
    return err

但是，现在我想做一些实验来修复一些参数，同时在优化步骤中保留一些参数。

我当然可以做类似的事情：

def f_ad_free(x, b, c):
    a, d = x
    return f(a,b,c,d)

但这会很麻烦，因为我有超过 10 个参数，这意味着不同数量的自由与固定参数的组合可能会非常大。

使用字典的第一种方法

我的一个解决方案是用关键字 args 而不是位置 args 编写我的内部函数f，然后像这样包装解决方案：

def generate(func, all_param, fixed_param):
    param_dict = {k : None for k in all_param}
    free_param = [param for param in all_param if param not in fixed_param]
    def wrapped(x, *args):
        param_dict.update({k : v for k, v in zip(fixed_param, args)})
        param_dict.update({k : v for k, v in zip(free_param, x)})
        return func(**param_dict)
    return wrapped

创建一个修复“b”和“c”的函数然后变成以下内容：

all_params = ['a','b','c']
f_bc_fixed = generate(f_inner, all_params, ['b', 'c'])
a = 1
b = 2
c = 3
d = 4
f_bc_fixed((a,d), b, c)

提问时间！

我的问题是是否有人能想出一种更巧妙的方法来解决这个问题。由于最终函数将在优化步骤中运行，因此我不能为每个函数调用接受太多开销。生成优化函数所需的时间无关紧要。

4

2 回答 2

1

您的generate功能与 基本相同functools.partial，这就是我将在这里使用的。

于 2013-09-11T08:30:10.930 回答
1

我可以想出几种方法来避免像上面那样使用闭包，尽管在做了一些测试之后，我不确定这两种方法中的任何一种都会更快。一种方法可能是跳过包装器，只编写一个接受的函数

  1. 一个向量
  2. 免费名称列表
  3. 将名称映射到值的字典。

然后做一些很像你上面做的事情，但是在函数本身：

def f(free_vals, free_names, params):
    params.update(zip(free_names, free_vals))
    err = params['a'] * params['b'] - params['c'] * params['d']
    return err

对于多次使用变量名的代码，请预先将 vars 设为本地，例如

a = params['a']
b = params['b']

等等。这可能看起来很麻烦，但它的优点是使所有内容都明确，避免了可能使闭包变慢的命名空间搜索。

然后通过args参数将自由名称列表和固定参数字典传递给optimize.leastsq. （请注意，params字典是可变的，这意味着理论上可能存在副作用；但在这种情况下，这无关紧要，因为只有自由参数被覆盖update，所以为了速度，我省略了复制步骤。 )

这种方法的主要缺点是它将一些复杂性转移到对 的调用中optimize.leastsq，并且它使您的代码的可重用性降低。第二种方法可以避免这些问题，尽管它可能不会那么快：使用可调用类。

class OptWrapper(object):
    def __init__(self, func, free_names, **fixed_params):
        self.func = func
        self.free_names = free_names
        self.params = fixed_params

    def __call__(self, x, *args):
        self.params.update(zip(self.free_names, x))
        return self.func(**self.params)

你可以看到我为__init__;简化了参数结构。free_names固定参数在此处作为关键字参数传递，用户必须确保fixed_params名称不重叠。我认为简单性值得权衡，但您可以轻松地将两者分开，就像您在包装器代码中所做的那样。

我最喜欢第二种方法；它具有基于闭包的方法的灵活性，但我发现它更具可读性。所有名称都在（或可以通过）本地命名空间中，我认为这会加快速度——但经过一些测试，我认为有理由相信闭包方法仍然会比这更快；每次调用该__call__方法似乎会增加大约 100 ns 的开销。我强烈建议测试性能是否是一个真正的问题。

于 2013-09-11T10:24:55.943 回答