使用Python优化（scipy.optimize）

Question

我正在尝试使用Python的scipy.optimize最大化以下功能。然而，经过大量尝试后，它似乎无法奏效。该函数和我的代码粘贴在下面。谢谢你的帮助！

问题

Maximize [sum (x_i / y_i)**gamma]**(1/gamma)
subject to the constraint sum x_i = 1; x_i is in the interval (0,1). 

x是一个选择变量的向量; y是参数的向量; gamma是一个参数。 x必须加1。并且每个x必须在区间（0,1）中。

代码

def objective_function(x, y):
    sum_contributions = 0
    gamma = 0.2

    for count in xrange(len(x)):
        sum_contributions += (x[count] / y[count]) ** gamma
    value = math.pow(sum_contributions, 1 / gamma)
    return -value

cons = ({'type': 'eq', 'fun': lambda x: np.array([sum(x) - 1])})

y = [0.5, 0.3, 0.2]
initial_x = [0.2, 0.3, 0.5]

opt = minimize(objective_function, initial_x, args=(y,), method='SLSQP',  
constraints=cons,bounds=[(0, 1)] * len(x))

Answer 1

有时，数值优化器无论出于何种原因都不起作用。我们可以将问题的参数化略有不同，它只会起作用。 （并且可能会更快地工作）

例如，对于resources :concerts get '/concerts/location_list/:id' => 'concerts#locations_list', as: :concert_location patch '/concerts/add_location/:id' => 'concerts#add_location', as: :add_location 的边界，我们可以使用转换函数，以便(0,1)中的值在转换后最终会显示在(-inf, +inf)

中

我们可以用等式约束做类似的技巧。例如，我们可以将维度从3减少到2，因为(0,1)中的最后一个元素必须是x。

如果它还没有成功，我们可以切换到不需要派生信息的优化器，例如1-sum(x)。

还有Lagrange multiplier。

Nelder Mead

结果是：

In [111]:

def trans_x(x):
    x1 = x**2/(1+x**2)
    z  = np.hstack((x1, 1-sum(x1)))
    return z

def F(x, y, gamma = 0.2):
    z = trans_x(x)
    return -(((z/y)**gamma).sum())**(1./gamma)
In [112]:

opt = minimize(F, np.array([0., 1.]), args=(np.array(y),),
               method='Nelder-Mead')
opt
Out[112]:
  status: 0
    nfev: 96
 success: True
     fun: -265.27701747828007
       x: array([ 0.6463264,  0.7094782])
 message: 'Optimization terminated successfully.'
     nit: 52

我们可以通过以下方式对其进行可视化：

In [113]:

trans_x(opt.x)
Out[113]:
array([ 0.29465097,  0.33482303,  0.37052601])

Answer 2

即使这个问题有点过时，我也想添加一个替代解决方案，这可能对将来绊倒这个问题的其他人有用。

这使我们的问题可以通过分析解决。您可以从写下（等式约束）优化问题的拉格朗日开始：

L = \sum_i (x_i/y_i)^\gamma - \lambda (\sum x_i - 1)

通过将此拉格朗日的一阶导数设置为零来找到最优解：

0 = \partial L / \partial x_i = \gamma x_i^{\gamma-1}/\y_i - \lambda
=> x_i \propto y_i^{\gamma/(\gamma - 1)}

使用这种洞察力，可以通过以下方式简单有效地解决优化问题：

In [4]:
def analytical(y, gamma=0.2):
    x = y**(gamma/(gamma-1.0))
    x /= np.sum(x)
    return x
xanalytical = analytical(y)
xanalytical, objective_function(xanalytical, y)
Out [4]:
(array([ 0.29466774,  0.33480719,  0.37052507]), -265.27701765929692)

CT朱的解决方案很优雅，但可能会违反第三个坐标上的积极性约束。对于gamma = 0.2而言，这在实践中似乎不是问题，但对于不同的游戏，您很容易遇到麻烦：

In [5]:
y = [0.2, 0.1, 0.8]
opt = minimize(F, np.array([0., 1.]), args=(np.array(y), 2.0),
               method='Nelder-Mead')
trans_x(opt.x), opt.fun
Out [5]:
(array([ 1.,  1., -1.]), -11.249999999999998)

对于与问题具有相同概率单纯形约束的其他优化问题，但是没有解析解，可能值得研究投影梯度方法或类似问题。这些方法利用了这样一个事实：有一个快速算法可以将任意点投影到这个集合上，参见https://en.wikipedia.org/wiki/Simplex#Projection_onto_the_standard_simplex。

（要查看完整代码并更好地渲染方程式，请查看Jupyter笔记本http://nbviewer.jupyter.org/github/andim/pysnippets/blob/master/optimization-simplex-constraints.ipynb）