数据优化答案

【问题标题】：Optimization of Data数据优化
【发布时间】：2019-04-25 17:48:40
【问题描述】：

我有一些猜测的输入数据 (X0)，我想在多个函数中优化它们，如下所述。

X0 = [A, B, C, D, E, F, G, H, I, J, K] #每个元素都是一个浮点值

功能：

F1 = A + B + C + D - 200 = 0

F2 = C + D + E - 50 = 0

F3 = C + D + E + F + G - 45 = 0

F4 = E + F + G + H + I + J + K - 67 = 0

F5 = H + I + J + K - 64 = 0

我不确定 scipy 如何优化多个函数中的输入数据。我在下面准备了一个脚本；我不确定它是否响应。

from scipy.optimize import minimize    

x0 = np.array([1. for i in range(11)])    
def my_function(A, B, C, D, E, F, G, H, I, J, K):
    F1 = A + B + C + D - 200
    F2 = C + D + E - 50
    F3 = C + D + E + F + G - 45
    F4 = E + F + G + H + I + J + K - 67
    F5 = H + I + J + K - 64
    return F1 + F2 +F3 +F4 + F5

cons = ({'type': 'ineq', 'my_function': lambda A, B, C, D:  A + B + C + D - 200},
    {'type': 'ineq', 'my_function': lambda C, D, E: C + D + E - 50},
    {'type': 'ineq', 'my_function': lambda C, D, E, F, G: C + D + E + F + G - 45},
    {'type': 'ineq', 'my_function': lambda E, F, G, H, I, J, K: E + F + G + H + I + J + K - 67},
    {'type': 'ineq', 'my_function': lambda H, I, J, K: H + I + J + K - 64})

res = minimize(my_function, x0, method='BFGS', constraints=cons )

【问题讨论】：

创建一个函数def my_function，其中函数的参数将是A、B、C、...K。然后，将F 的所有值相加，即此函数将返回F1+F2+....+F5。这是你现在的目标功能。然后在此函数上使用scipy.optmize.minimize，将具有任意值的N元素数组作为初始值传递，然后就完成了。唯一的细节是传递约束。约束是 5 个 lambda 函数，也就是你的五个 Fs
我在上面准备了一个脚本；但我不确定它是否正确。
你很亲密。刚刚发布了对您的代码的修复，看看：}
感谢您的帮助。有用。一个问题：我可以只在约束中导入函数吗？因为当我从 my_function(X) 中排除函数并且只保留“A、B、C、D、E、F、G、H、I、J、K = X”并将其返回到任何标量时，它可以工作并且我得到了相同的结果。
当然，我只是凭直觉来最小化你的函数之间的关系。如果他们的关系是非线性的，这可能更必要。但是你所有的函数都是线性函数，所以你可以只返回它们的值之和并将其最小化。我只是确保说明您能够推广到非线性情况的一般想法；}

标签： python numpy scipy

【解决方案1】：

你很接近。使用类型eq（平等）而不是不平等。此外，您的约束应该只接收一个参数，即值数组，您只需访问它们的位置。

检查以下内容：

from scipy.optimize import minimize    

x0 = np.random.random(size=[11])
def my_function(X):
    A, B, C, D, E, F, G, H, I, J, K = X
    F1 = A + B + C + D - 200
    F2 = C + D + E - 50
    F3 = C + D + E + F + G - 45
    F4 = E + F + G + H + I + J + K - 67
    F5 = H + I + J + K - 64
    return F1 + F2 +F3 +F4 + F5

cons = ({'type': 'eq', 'fun': lambda X: X[0] + X[1] + X[2] + X[3] - 200},
    {'type': 'eq', 'fun': lambda X: X[2] + X[3] + X[4] - 50},
    {'type': 'eq', 'fun': lambda X: X[2] + X[3] + X[4] + X[5] + X[6] - 45},
    {'type': 'eq', 'fun': lambda X: X[4] + X[5] + X[6] + X[7] + X[8] + X[9] + X[10] - 67},
    {'type': 'eq', 'fun': lambda X: X[7] + X[8] + X[9] + X[10] - 64})

res = minimize(my_function, x0, constraints=cons)

success: True
x: array([79.27328348, 78.72671652, 21.16500123, 20.83499877,  8.        ,
       -2.5794818 , -2.4205182 , 15.7738023 , 16.59847106, 15.92703282,
       15.70069382])

【讨论】：

【解决方案2】：

在下面的脚本中，我想在整个循环形式 (cons2) 中生成约束，但循环输出的结果与我使用非循环 (cons2) 形式的结果不同。我希望两者都能得到相同的结果。

from scipy.optimize import minimize

import numpy as np

np.random.seed(15)

x0 = np.random.random(size=[11])


def my_function(X):
    A, B, C, D, E, F, G, H, I, J, K = X
    F1 = A + B + C + D - 200
    F2 = C + D + E - 50
    F3 = C + D + E + F + G - 45
    F4 = E + F + G + H + I + J + K - 67
    F5 = H + I + J + K - 64
    return F1 + F2 +F3 +F4 + F5

#the constraints without loop
cons1 = ({'type': 'eq', 'fun': lambda X: X[0] + X[1] + X[2] + X[3] - 200},
    {'type': 'eq', 'fun': lambda X: X[2] + X[3] + X[4] - 50},
    {'type': 'eq', 'fun': lambda X: X[2] + X[3] + X[4] + X[5] + X[6] - 45},
    {'type': 'eq', 'fun': lambda X: X[4] + X[5] + X[6] + X[7] + X[8] + X[9] + X[10] - 67},
    {'type': 'eq', 'fun': lambda X: X[7] + X[8] + X[9] + X[10] - 64})

data = [200, 50, 45, 67, 64]
ran = [[0,3], [2,4], [2,6], [4,10], [7,10]]
_tmp= []

#the constraints with loop
for hh in range(5):    
     _tmp.append({'type': 'eq', 'fun': lambda X: sum([X[i] for i in range(ran[hh][0], ran[hh][1]+1)]) - data[hh]})

cons2 = tuple(_tmp)

#the outputs below must be the same, but it's not.

res1 = minimize(my_function, x0, constraints=cons1)
res2 = minimize(my_function, x0, constraints=cons2)
print res1.x
print res2.x

【讨论】：