如何在Mystic中应用不等式约束

Question

我正在尝试使用Mystic最大化一个受不平等约束的目标，但我正在努力了解如何应用惩罚约束。这个问题是非凸的，涉及最大化目标，其中只有一个变量将发生变化(x)。我正在尝试Mystic，因为我听说它对大规模优化很好，而x是一个包含数百万项(大小为N)的一维数组。

有三个由数字a、b和c组成的一维数组，每个数组都有N个值(a和b中的值在0-1之间)。X中的每个项目都将大于>= %0

def objective(x, a, b, c):   # maximise
    d = 1 / (1 + np.exp(-a * (x)))
    return np.sum(d * (b * c - x))

def constraint(x, f=1000):   # must be >=0
    return f - x.sum()

bounds = [(0, None)]

我见过使用generate_penalty和generate_constraint函数的示例，并认为我可以使用以下方法实现约束，但没有成功：

equations = """
1000 - np.sum(x) >= 0
"""

一般来说，任何关于如何应用惩罚约束的建议或使用Mystic的建议都将不胜感激。在Github上有很多例子，但很难看出哪一个是合适的。我使用SLSQP使用Scipy minimise实现了一个解决方案，但在所需的规模上它太慢了。

Answer 1

我认为你问的问题看起来像下面这样……虽然它没有太多的不平等约束--只有一个。我不是在使用数百万个项目...因为这将花费大量的时间，并且可能需要很好的参数调整...但我在下面使用了N=100。

import numpy as np
import mystic as my
N = 100 #1000 # N=len(x)
M = 1e10 # max of c_i
K = 1000 # max of sum(x)
Q = 4 # 40 # npop = N*Q
G = 200 # gtol

# arrays of fixed values
a = np.random.rand(N)
b = np.random.rand(N)
c = np.random.rand(N) * M

# build objective
def cost_factory(a, b, c, max=False):
    i = -1 if max else 1
    def cost(x):
        d = 1. / (1 + np.exp(-a * x))
        return i * np.sum(d * (b * c - x))
    return cost

objective = cost_factory(a, b, c, max=True)
bounds = [(0., K)] * N

def penalty_norm(x): # < 0
    return np.sum(x) - K

# build penalty: sum(x) <= K
@my.penalty.linear_inequality(penalty_norm, k=1e12)
def penalty(x):
    return 0.0

# uncomment if want hard constraint of sum(x) == K
#@my.constraints.normalized(mass=1000)
def constraints(x):
    return x

然后在中运行脚本...

if __name__ == '__main__':
    mon = my.monitors.VerboseMonitor(10)
    #from pathos.pools import ThreadPool as Pool
    #from pathos.pools import ProcessPool as Pool
    #p = Pool()
    #Powell = my.solvers.PowellDirectionalSolver

    # use class-based solver interface
    """
    solver = my.solvers.DifferentialEvolutionSolver2(len(bounds), N*Q)
    solver.SetGenerationMonitor(mon)
    solver.SetPenalty(penalty)
    solver.SetConstraints(constraints)
    solver.SetStrictRanges(*my.tools.unpair(bounds))
    solver.SetRandomInitialPoints(*my.tools.unpair(bounds))
    solver.SetTermination(my.termination.ChangeOverGeneration(1e-8,G))
    solver.Solve(objective, CrossProbability=.9, ScalingFactor=.8)
    result = [solver.bestSolution]
    print('cost: %s' % solver.bestEnergy)
    """

    # use one-line interface
    result = my.solvers.diffev2(objective, x0=bounds, bounds=bounds, penalty=penalty, constraints=constraints, npop=N*Q, ftol=1e-8, gtol=G, disp=True, full_output=True, cross=.9, scale=.8, itermon=mon)#, map=p.map)

    # use ensemble of fast local solvers
    #result = my.solvers.lattice(objective, len(bounds), N*Q, bounds=bounds, penalty=penalty, constraints=constraints, ftol=1e-8, gtol=G, disp=True, full_output=True, itermon=mon)#, map=p.map)#, solver=Powell)

    #p.close(); p.join(); p.clear()
    print(np.sum(result[0]))

我还注释掉了并行计算的一些用法，但很容易取消注释。

我认为您可能需要非常努力地调整求解器，以使其找到此特定问题的全局最大值。它还需要有足够的并行元素...由于N.

然而，如果你想使用符号约束作为输入，你可以这样做：

eqn = ' + '.join("x{i}".format(i=i) for i in range(N)) + ' <= {K}'.format(K=K)
constraint = my.symbolic.generate_constraint(my.symbolic.generate_solvers(my.symbolic.simplify(eqn)))

或者，对于软约束(即惩罚)：

penalty = my.symbolic.generate_penalty(my.symbolic.generate_conditions(eqn))