我正在尝试在Python中找到以下方程组的最优解：
(x-x1)^2 + (y-y1)^2 - r1^2 = 0
(x-x2)^2 + (y-y2)^2 - r2^2 = 0
(x-x3)^2 + (y-y3)^2 - r3^2 = 0
给定一个点(x,y)和半径(r):
x1, y1, r1 = (0, 0, 0.88)
x2, y2, r2 = (2, 0, 1)
x3, y3, r3 = (0, 2, 0.75)
如果我正确理解了你的问题，我想这就是你所需要的：
from scipy.optimize import minimize
import numpy as np
def f(coord, x, y, r):
return np.sum(((coord[0] - x) ** 2) + ((coord[1] - y) ** 2) - (r ** 2))
x = np.array([0, 2, 0])
y = np.array([0, 0, 2])
r = np.array([.88, 1, .75])
# initial (bad) guess at (x,y) values
initial_guess = np.array([100, 100])
res = minimize(f, initial_guess, args=(x, y, r))
这会产生：
>>> print res.x
[0.66666665 0.66666665]
你还可以尝试最小二乘法，它期望一个返回向量的目标函数。它希望最小化该向量的平方和。使用最小二乘法，你的目标函数应该像这样：
def f2(coord, x, y, r):
# notice that we're returning a vector of dimension 3
return ((coord[0] - x) ** 2) + ((coord[1] - y) ** 2) - (r ** 2)
你可以像这样将其最小化：
from scipy.optimize import leastsq
res = leastsq(f2, initial_guess, args=(x, y, r))
这将产生：
>>> print res[0]
>>> [0.77958134 0.8580946 ]
这基本上与使用minimize并将原始目标函数重写为以下内容相同：
def f(coord, x, y, r):
vec = ((coord[0] - x) ** 2) + ((coord[1] - y) ** 2) - (r ** 2)
# return the sum of the squares of the vector
return np.sum(vec ** 2)
这将产生以下结果：
>>> print res.x
>>> [0.77958326 0.85809648]
leastsq在处理args时略有不同，并且这两个函数返回的数据结构也不同。请参阅scipy.optimize.minimize和scipy.optimize.leastsq的文档了解更多详细信息。
有关更多优化选项，请参阅scipy.optimize文档。
np.linalg.norm代替np.sum，看看它如何影响你的结果。 - John Vinyardminimize期望一个标量值函数，而leastsq期望一个向量值函数。leastsq希望最小化目标函数返回的向量的平方和，因此它几乎就像使用minimize的l2范数一样。实际上，我使用leastsq和minimize的l2范数得到的答案几乎相同：~`[.78,.86]`。 - John Vinyardscipy.optimize 改变了其接口。我可能是错的。但无论如何，我赞成使用 scipy.optimize 中的算法，并且被接受的答案确实演示了如何使用(如果接口未更改的话)。scipy.optimize 算法作为核心，但对于有约束优化更加强大的替代包，该包是 mystic。 其中一个重大改进就是 mystic 提供了约束全局优化。scipy.optimize.minimize 方法。from mystic import reduced
@reduced(lambda x,y: abs(x)+abs(y)) #choice changes answer
def objective(x, a, b, c):
x,y = x
eqns = (\
(x - a[0])**2 + (y - b[0])**2 - c[0]**2,
(x - a[1])**2 + (y - b[1])**2 - c[1]**2,
(x - a[2])**2 + (y - b[2])**2 - c[2]**2)
return eqns
bounds = [(None,None),(None,None)] #unnecessary
a = (0,2,0)
b = (0,0,2)
c = (.88,1,.75)
args = a,b,c
from mystic.solvers import diffev2
from mystic.monitors import VerboseMonitor
mon = VerboseMonitor(10)
result = diffev2(objective, args=args, x0=bounds, bounds=bounds, npop=40, \
ftol=1e-8, disp=False, full_output=True, itermon=mon)
print result[0]
print result[1]
当结果看起来像这样时：
Generation 0 has Chi-Squared: 38868.949133
Generation 10 has Chi-Squared: 2777.470642
Generation 20 has Chi-Squared: 12.808055
Generation 30 has Chi-Squared: 3.764840
Generation 40 has Chi-Squared: 2.996441
Generation 50 has Chi-Squared: 2.996441
Generation 60 has Chi-Squared: 2.996440
Generation 70 has Chi-Squared: 2.996433
Generation 80 has Chi-Squared: 2.996433
Generation 90 has Chi-Squared: 2.996433
STOP("VTRChangeOverGeneration with {'gtol': 1e-06, 'target': 0.0, 'generations': 30, 'ftol': 1e-08}")
[ 0.66667151 0.66666422]
2.99643333334
如前所述，在reduced中选择lambda会影响优化器找到的点，因为实际上没有解决方案。
mystic还提供了将符号方程转换为函数的能力，其中生成的函数可以用作目标或惩罚函数。这里是同样的问题，但使用方程作为惩罚而不是目标。
def objective(x):
return 0.0
equations = """
(x0 - 0)**2 + (x1 - 0)**2 - .88**2 == 0
(x0 - 2)**2 + (x1 - 0)**2 - 1**2 == 0
(x0 - 0)**2 + (x1 - 2)**2 - .75**2 == 0
"""
bounds = [(None,None),(None,None)] #unnecessary
from mystic.symbolic import generate_penalty, generate_conditions
from mystic.solvers import diffev2
pf = generate_penalty(generate_conditions(equations), k=1e12)
result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, \
npop=40, gtol=50, disp=False, full_output=True)
print result[0]
print result[1]
结果如下：
[ 0.77958328 0.8580965 ]
3.6473132399e+12
def objective(x):
return 0.0
equations = """
(x0 - 0)**2 + (x1 - 0)**2 - .88**2 == 0
(x0 - 2)**2 + (x1 - 0)**2 - 1**2 == 0
(x0 - 0)**2 + (x1 - 2)**2 - .75**2 == 0
"""
bounds = [(None,None),(None,None)] #unnecessary
from mystic.symbolic import generate_constraint, generate_solvers, simplify
from mystic.symbolic import generate_penalty, generate_conditions
from mystic.solvers import diffev2
cf = generate_constraint(generate_solvers(simplify(equations)))
result = diffev2(objective, x0=bounds, bounds=bounds, \
constraints=cf, \
npop=40, gtol=50, disp=False, full_output=True)
print result[0]
print result[1]
带有结果的情况：
[ nan 657.17740835]
0.0
其中nan实际上表示没有有效的解决方案。
顺便说一下，我是作者，所以有些偏见。但是，mystic已经存在了很长时间，几乎与scipy.optimize一样成熟，并且在这段时间内具有更加稳定的接口。我的观点是，如果您需要一个更加灵活和功能强大的约束非线性优化器，我建议使用mystic。
没有满足这个方程组的点。import numpy as np
import scipy as scp
import sympy as smp
from scipy.optimize import minimize
a,b = smp.symbols('a b')
x_ar, y_ar = np.random.random(3), np.random.random(3)
x = np.array(smp.symbols('x0:%d'%np.shape(x_ar)[0]))
y = np.array(smp.symbols('y0:%d'%np.shape(x_ar)[0]))
func = np.sum(a**2+b**2-x*(a+b)+2*y)
print func
my_func = smp.lambdify((x,y), func)
print 1.0/3*my_func(x_ar,y_ar)
ab = smp.lambdify((a,b),my_func(x_ar,x_ar))
print ab(1,2)
def ab_v(x):
return ab(*tuple(x))
print ab_v((1,2))
minimize(ab_v,(0.1,0.1))
输出结果为：
3*a**2 + 3*b**2 - x0*(a + b) - x1*(a + b) - x2*(a + b) + 2*y0 + 2*y1 + 2*y2
1.0*a**2 - 0.739792011558683*a + 1.0*b**2 - 0.739792011558683*b +0.67394435712335
12.7806239653
12.7806239653
Out[33]:
status: 0
success: True
njev: 3
nfev: 12
hess_inv: array([[1, 0],
[0, 1]])
fun: 3.6178137388030356
x: array([ 0.36989601, 0.36989601])
message: 'Optimization terminated successfully.'
jac: array([ 5.96046448e-08, 5.96046448e-08])
eqs中有未定义的变量（x和y）。能否提供你正在使用的实际代码？ - Warren Weckesser