Question

我有以下优化代码，该优化代码由变量n参数化。

from symfit import parameters, Eq, Ge, Fit
import numpy as np
n = 3
xdata = np.sort(np.random.choice(range(1, 4*n), n)) # Make fake data
print(xdata)
p1, p2, p3 = parameters('p1, p2, p3')
model = p1*p2*p3
constraints = [
    Eq(xdata[0]*p1+(xdata[1]-xdata[0])*p2+(xdata[2]-xdata[1])*p3, 1),
    Ge(p1, p2),
    Ge(p2, p3),
    Ge(p3, 0)
    ]

fit = Fit(- model, constraints=constraints)
fit_result = fit.execute()
print(fit_result)

我想将它用于更大的n值，但我不知道如何更改行数

 p1, p2, p3 = parameters('p1, p2, p3')
 model = p1*p2*p3

和constraints来应付任意大的n。

代码正在使用symfit库。该链接显示了如何使用parameters的示例以及指向文档的链接。

这怎么办？

Answer 1

Numpy与symfit库确实互动良好。使用它时，您要概括的所有操作都非常简单。

设置

n = 3
_data = np.sort(np.random.choice(np.arange(1, 4 * n), n))

字符串格式

您可以使用简单的迭代器和tuple动态创建str.join参数，然后将其传递到parameters构造函数中以获取tuple参数

params = parameters(', '.join(f'p{i}' for i in range(1, n+1)))
                ^^
# p1, p2, p3 = parameters('p1, p2, p3')

np.prod

此操作非常简单。 np.prod计算：

给定轴上数组元素的乘积

当应用于tuple个参数中的symfit时，会产生所需的p1*p2*...pn

model = np.prod(params)
        ^^
# model = p1*p2*p3

np.concatenate + np.diff

大概是最复杂的一行，但仍然不太难理解。您想将数据数组中连续元素的差乘以您的参数，然后对结果求和。由于第一个元素与前一个元素没有区别，因此可以使用np.concatenate将其重新添加。

u = np.concatenate((_data[:1], np.diff(_data)))
c1 = Eq(np.sum(params * u), 1)
              ^^
# Eq(xdata[0]*p1+(xdata[1]-xdata[0])*p2+(xdata[2]-xdata[1])*p3, 1)

np.column_stack

您希望滚动查看参数作为约束：p1-p2，p2-p3，... pn, 0。这只是堆叠一个一次性元组，并用原始的tuple参数填充零，然后使用列表推导将其分解为您的Ge构造函数。

ges = [Ge(*group) for group in np.column_stack((params, params[1:] + (0,)))]

适合！

我在这里什么都没改变！

constraints = [c1, *ges]
fit = Fit(- model, constraints=constraints)
fit_result = fit.execute()

Answer 2

需要以动态方式从n

计算参数字符串

paramstr = ', '.join(['p{}'.format(i) for i in range(1, n)])
# when n=1, paramstr = 'p1, p2, p3'

使用paramstr作为parameters函数的参数。

paramvals = parameters(paramstr)

model可以通过在其产品上减少paramvals来重构。


from functools import reduce

model = reduce(lambda x, y: x * y, paramvals, 1)

现在有意思了！ constraints可以重构为：

eqs = xdata[0] * paramvals[0] + sum(
    (xdata[i] - xdata[i-1]) * paramvals[i]
    for i in range(1, n)
)

ges = [
    Ge(paramvals[i-1], paramvals[i])
    for i in range(1, n)
]

ges.append(
    Ge(paramvals[-1], 0)
)

constraints = [
    Eq(eqs, 1),
    *ges
]

Answer 3

我对Symfit一无所知，但是如果您只是想将上述代码推广为任意N，那么：

您可以为任意N任意生成一个类似于"p1, p2, p3"的字符串，并将其解析为参数列表：

params_string = ", ".join("p{}".format(i + 1) for i in range(n))
params = parameters(params_string)

解析字符串以获取参数列表的概念对我来说听起来很奇怪，我敢肯定，有一种更好的方法可以以编程方式声明一堆参数，但这将尽可能地接近原始代码在做。

编辑：查看Symfit文档，看来parameters(s)只是一个快捷方式，您实际上可以这样做：

params = [Parameter("p{}".format(i + 1)) for i in range(n)]

这不需要您为所有参数名称构建自己的连接字符串，因此Symfit可以将它们拆分回各个参数名称。这也将允许您为参数定义其他属性，例如其初始值或最小/最大范围。

您可以概括Eq约束：

coeffs = [xdata[0]] + [(xdata[i+1] - xdata[i]) for i in range(n-1)]
eq_constraint = Eq(sum(param * coeff for param, coeff in zip(params, coeffs), 1)

或者，作为另一个答案，使用numpy操作：

coeffs = np.concat(xdata[:1], np.diff(xdata))
eq_constraint = Eq(np.sum(params * coeffs), 1)

您可以概括Ge约束：

ge_constraints = [Ge(params[i + 1], params[i]) for i in range(n - 1)] + [Ge(params[-1], 0]

constraints = [eq_constraint] + ge_constraints

同样可以使用numpy操作完成此操作，但我将其留给@ user3483203回答。

您可以使用reduce将所有参数相乘：

model = reduce(lambda x, y: x * y, params, 1)

或使用numpy.prod：

model = np.prod(params)

这足以将以上内容推广到任意N。

如何在Python中任意扩展Symfit参数的数量

3 个答案: