32

python中约束非线性优化的推荐包是什么？

我要解决的具体问题是：

我有一个未知数X(Nx1)，我有M(Nx1)个u向量和M(NxN)个s矩阵。

max [5th percentile of (ui_T*X), i in 1 to M]
st 
0<=X<=1 and
[95th percentile of (X_T*si*X), i in 1 to M]<= constant

当我开始这个问题时，我只有一个点估计，u并且s我能够用 解决上述问题cvxpy。

我意识到，我没有对u和进行一个估计s，而是拥有整个值的分布，所以我想改变我的目标函数，以便我可以使用整个分布。上面的问题描述是我试图以一种有意义的方式包含这些信息。

cvxpy不能用来解决这个问题，我试过了scipy.optimize.anneal，但我似乎无法为未知值设置界限。我也看过，pulp但它不允许非线性约束。

4

4 回答 4

27

虽然SLSQP算法scipy.optimize.minimize很好，但它有很多限制。第一个是它是一个QP求解器，因此它适用于非常适合二次编程范式的方程。但是如果你有功能限制会发生什么？另外，scipy.optimize.minimize它不是全局优化器，因此您通常需要在非常接近最终结果的情况下开始。

有一个约束非线性优化包（mystic称为scipy.optimize

例如，如果我理解您的伪代码，您的问题看起来像这样：

import numpy as np

M = 10
N = 3
Q = 10
C = 10

# let's be lazy, and generate s and u randomly...
s = np.random.randint(-Q,Q, size=(M,N,N))
u = np.random.randint(-Q,Q, size=(M,N))

def percentile(p, x):
    x = np.sort(x)
    p = 0.01 * p * len(x)
    if int(p) != p:
        return x[int(np.floor(p))]
    p = int(p)
    return x[p:p+2].mean()

def objective(x, p=5): # inverted objective, to find the max
    return -1*percentile(p, [np.dot(np.atleast_2d(u[i]), x)[0] for i in range(0,M-1)])


def constraint(x, p=95, v=C): # 95%(xTsx) - v <= 0
    x = np.atleast_2d(x)
    return percentile(p, [np.dot(np.dot(x,s[i]),x.T)[0,0] for i in range(0,M-1)]) - v

bounds = [(0,1) for i in range(0,N)]

因此，要在 中处理您的问题mystic，您只需要指定边界和约束。 

from mystic.penalty import quadratic_inequality
@quadratic_inequality(constraint, k=1e4)
def penalty(x):
  return 0.0

from mystic.solvers import diffev2
from mystic.monitors import VerboseMonitor
mon = VerboseMonitor(10)

result = diffev2(objective, x0=bounds, penalty=penalty, npop=10, gtol=200, \
                 disp=False, full_output=True, itermon=mon, maxiter=M*N*100)

print result[0]
print result[1]

结果如下所示：

Generation 0 has Chi-Squared: -0.434718
Generation 10 has Chi-Squared: -1.733787
Generation 20 has Chi-Squared: -1.859787
Generation 30 has Chi-Squared: -1.860533
Generation 40 has Chi-Squared: -1.860533
Generation 50 has Chi-Squared: -1.860533
Generation 60 has Chi-Squared: -1.860533
Generation 70 has Chi-Squared: -1.860533
Generation 80 has Chi-Squared: -1.860533
Generation 90 has Chi-Squared: -1.860533
Generation 100 has Chi-Squared: -1.860533
Generation 110 has Chi-Squared: -1.860533
Generation 120 has Chi-Squared: -1.860533
Generation 130 has Chi-Squared: -1.860533
Generation 140 has Chi-Squared: -1.860533
Generation 150 has Chi-Squared: -1.860533
Generation 160 has Chi-Squared: -1.860533
Generation 170 has Chi-Squared: -1.860533
Generation 180 has Chi-Squared: -1.860533
Generation 190 has Chi-Squared: -1.860533
Generation 200 has Chi-Squared: -1.860533
Generation 210 has Chi-Squared: -1.860533
STOP("ChangeOverGeneration with {'tolerance': 0.005, 'generations': 200}")
[-0.17207128  0.73183465 -0.28218955]
-1.86053344078

mystic非常灵活，可以处理任何类型的约束（例如等式、不等式），包括符号和功能约束。我在上面将约束指定为“惩罚”，这是传统方式，因为当违反约束时，它们会对目标施加惩罚。 mystic还提供非线性核变换，通过减少有效解的空间（即通过空间映射或核变换）来限制解空间。

举个例子，这里mystic解决的问题会破坏很多 QP 求解器，因为约束不是约束矩阵的形式。它正在优化压力容器的设计。

"Pressure Vessel Design"

def objective(x):
    x0,x1,x2,x3 = x
    return 0.6224*x0*x2*x3 + 1.7781*x1*x2**2 + 3.1661*x0**2*x3 + 19.84*x0**2*x2

bounds = [(0,1e6)]*4
# with penalty='penalty' applied, solution is:
xs = [0.72759093, 0.35964857, 37.69901188, 240.0]
ys = 5804.3762083

from mystic.symbolic import generate_constraint, generate_solvers, simplify
from mystic.symbolic import generate_penalty, generate_conditions

equations = """
-x0 + 0.0193*x2 <= 0.0
-x1 + 0.00954*x2 <= 0.0
-pi*x2**2*x3 - (4/3.)*pi*x2**3 + 1296000.0 <= 0.0
x3 - 240.0 <= 0.0
"""
cf = generate_constraint(generate_solvers(simplify(equations)))
pf = generate_penalty(generate_conditions(equations), k=1e12)


if __name__ == '__main__':

    from mystic.solvers import diffev2
    from mystic.math import almostEqual
    from mystic.monitors import VerboseMonitor
    mon = VerboseMonitor(10)

    result = diffev2(objective, x0=bounds, bounds=bounds, constraints=cf, penalty=pf, \ 
                     npop=40, gtol=50, disp=False, full_output=True, itermon=mon)

    assert almostEqual(result[0], xs, rel=1e-2)
    assert almostEqual(result[1], ys, rel=1e-2)

在这里找到这个，以及大约 100 个类似的例子：https ://github.com/uqfoundation/mystic 。

我是作者，所以有点偏见。但是，偏差非常轻微。mystic它既成熟又得到很好的支持，在解决硬约束非线性优化问题的能力上无与伦比。

于 2017-04-01T21:05:57.343 回答
16

scipy有一个壮观的约束非线性优化包。

您可以通过阅读optimize 文档开始，但这里有一个 SLSQP 示例：

minimize(func, [-1.0,1.0], args=(-1.0,), jac=func_deriv, constraints=cons, method='SLSQP', options={'disp': True})
于 2014-02-13T21:27:16.837 回答
12

正如其他人所评论的那样，SciPy 最小化包是一个很好的起点。我们还回顾了Python Gekko 论文中的许多其他优化包（参见第 4 节）。我在下面包含了一个示例（Hock Schittkowski #71 基准测试），其中包括目标函数、等式约束和不等式约束Scipy.optimize.minimize。

import numpy as np
from scipy.optimize import minimize

def objective(x):
    return x[0]*x[3]*(x[0]+x[1]+x[2])+x[2]

def constraint1(x):
    return x[0]*x[1]*x[2]*x[3]-25.0

def constraint2(x):
    sum_eq = 40.0
    for i in range(4):
        sum_eq = sum_eq - x[i]**2
    return sum_eq

# initial guesses
n = 4
x0 = np.zeros(n)
x0[0] = 1.0
x0[1] = 5.0
x0[2] = 5.0
x0[3] = 1.0

# show initial objective
print('Initial SSE Objective: ' + str(objective(x0)))

# optimize
b = (1.0,5.0)
bnds = (b, b, b, b)
con1 = {'type': 'ineq', 'fun': constraint1} 
con2 = {'type': 'eq', 'fun': constraint2}
cons = ([con1,con2])
solution = minimize(objective,x0,method='SLSQP',\
                    bounds=bnds,constraints=cons)
x = solution.x

# show final objective
print('Final SSE Objective: ' + str(objective(x)))

# print solution
print('Solution')
print('x1 = ' + str(x[0]))
print('x2 = ' + str(x[1]))
print('x3 = ' + str(x[2]))
print('x4 = ' + str(x[3]))

这是 Python Gekko 的相同问题：

from gekko import GEKKO
m = GEKKO()
x1,x2,x3,x4 = m.Array(m.Var,4,lb=1,ub=5)
x1.value = 1; x2.value = 5; x3.value = 5; x4.value = 1

m.Equation(x1*x2*x3*x4>=25)
m.Equation(x1**2+x2**2+x3**2+x4**2==40)
m.Minimize(x1*x4*(x1+x2+x3)+x3)

m.solve(disp=False)
print(x1.value,x2.value,x3.value,x4.value)

如果 SLSQP 无法解决您的问题，还有一个关于 Python 非线性规划求解器的更全面的讨论线程。如果您需要有关求解器方法的更多信息，可以使用我的工程设计优化课程材料。

于 2016-12-23T05:56:38.180 回答
3

通常为了拟合，您可以使用scipy.optimize函数，或者lmfit简单地扩展 scipy.optimize 包以使其更容易传递边界之类的东西。就个人而言，我喜欢使用kmpfitkapteyn 库的一部分，它基于 MPFIT 的 C 实现。

scipy.optimize.minimize()可能是最容易获得并且常用的。

于 2014-02-13T21:29:56.360 回答