def impose_reweighted_variance(v, samples, weights=None, solver=None):
"""impose a variance on a list of points by reweighting weights"""
ndim = len(samples)
if weights is None:
weights = [1.0 / ndim] * ndim
if solver is None or solver == 'fmin':
from mystic.solvers import fmin as solver
elif solver == 'fmin_powell':
from mystic.solvers import fmin_powell as solver
elif solver == 'diffev':
from mystic.solvers import diffev as solver
elif solver == 'diffev2':
from mystic.solvers import diffev2 as solver
norm = sum(weights)
m = mean(samples, weights)
inequality = ""
equality = ""
equality2 = ""
equality3 = ""
for i in range(ndim):
inequality += "x%s >= 0.0\n" % (i) # positive
equality += "x%s + " % (i) # normalized
equality2 += "%s * x%s + " % (float(samples[i]), (i)) # mean
equality3 += "x%s*(%s-%s)**2 + " % ((i), float(samples[i]), m) # var
equality += "0.0 = %s\n" % float(norm)
equality += equality2 + "0.0 = %s*%s\n" % (float(norm), m)
equality += equality3 + "0.0 = %s*%s\n" % (float(norm), v)
penalties = generate_penalty(generate_conditions(inequality))
constrain = generate_constraint(generate_solvers(solve(equality)))
def cost(x):
return sum(x)
results = solver(cost, weights, constraints=constrain, \
penalty=penalties, disp=False, full_output=True)
wts = list(results[0])
_norm = results[1] # should have _norm == norm
warn = results[4] # nonzero if didn't converge
#XXX: better to fail immediately if xlo < m < xhi... or the below?
if warn or not almostEqual(_norm, norm):
print "Warning: could not impose mean through reweighting"
return None #impose_variance(v, samples, weights), weights
return wts #samples, wts # "mean-preserving"
def impose_reweighted_variance(v, samples, weights=None, solver=None):
"""impose a variance on a list of points by reweighting weights"""
ndim = len(samples)
if weights is None:
weights = [1.0/ndim] * ndim
if solver is None or solver == 'fmin':
from mystic.solvers import fmin as solver
elif solver == 'fmin_powell':
from mystic.solvers import fmin_powell as solver
elif solver == 'diffev':
from mystic.solvers import diffev as solver
elif solver == 'diffev2':
from mystic.solvers import diffev2 as solver
norm = sum(weights)
m = mean(samples, weights)
inequality = ""
equality = ""; equality2 = ""; equality3 = ""
for i in range(ndim):
inequality += "x%s >= 0.0\n" % (i) # positive
equality += "x%s + " % (i) # normalized
equality2 += "%s * x%s + " % (float(samples[i]),(i)) # mean
equality3 += "x%s*(%s-%s)**2 + " % ((i),float(samples[i]),m) # var
equality += "0.0 = %s\n" % float(norm)
equality += equality2 + "0.0 = %s*%s\n" % (float(norm),m)
equality += equality3 + "0.0 = %s*%s\n" % (float(norm),v)
penalties = generate_penalty(generate_conditions(inequality))
constrain = generate_constraint(generate_solvers(solve(equality)))
def cost(x): return sum(x)
results = solver(cost, weights, constraints=constrain, \
penalty=penalties, disp=False, full_output=True)
wts = list(results[0])
_norm = results[1] # should have _norm == norm
warn = results[4] # nonzero if didn't converge
#XXX: better to fail immediately if xlo < m < xhi... or the below?
if warn or not almostEqual(_norm, norm):
print "Warning: could not impose mean through reweighting"
return None #impose_variance(v, samples, weights), weights
return wts #samples, wts # "mean-preserving"
Q = KernelMatrix(XX) # Q_ij = K(x_i, x_j)
b = -ones(nx) # b_i = 1 (in dual)
# build the constraints (y.T * x = 0.0)
# 1.0*x0 + 1.0*x1 + ... - 1.0*xN = 0.0
Aeq = y
Beq = array([0.])
# set the bounds
lb = zeros(nx)
ub = 99999 * ones(nx)
# build the constraints operator
from mystic.symbolic import linear_symbolic, solve, \
generate_solvers as solvers, generate_constraint as constraint
constrain = linear_symbolic(Aeq, Beq)
constrain = constraint(solvers(solve(constrain, target=['x0'])))
from mystic import suppressed
@suppressed(1e-5)
def conserve(x):
return constrain(x)
#from mystic.monitors import VerboseMonitor
#mon = VerboseMonitor(10)
# solve the dual for alpha
from mystic.solvers import diffev
alpha = diffev(objective, list(zip(lb,ub)), args=(Q,b), npop=nx*3, gtol=200, \
return 2 * x0**2 + x1**2 + x0 * x1 + x0 + x1
equations = """
x0 + x1 - 1.0 == 0.0
"""
bounds = [(0.0, None), (0.0, None)]
# with penalty='penalty' applied, solution is:
xs = [0.25, 0.75]
ys = 1.875
from mystic.symbolic import generate_conditions, generate_penalty
pf = generate_penalty(generate_conditions(equations), k=1e4)
from mystic.symbolic import generate_constraint, generate_solvers, solve
cf = generate_constraint(generate_solvers(solve(equations)))
if __name__ == '__main__':
from mystic.solvers import diffev2, fmin_powell
from mystic.math import almostEqual
result = diffev2(objective,
x0=bounds,
bounds=bounds,
constraint=cf,
penalty=pf,
npop=40,
disp=False,
full_output=True)
assert almostEqual(result[0], xs, rel=2e-2)
def cf(len=3):
return generate_constraint(generate_solvers(solve(equations(len))))
svr_epsilon = 3
b = Y + svr_epsilon * ones(Y.size)
# build the constraints (y.T * x = 0.0)
# 1.0*x0 + 1.0*x1 + ... - 1.0*xN = 0.0
Aeq = concatenate([ones(nx), -ones(nx)]).reshape(1,N)
Beq = array([0.])
# set the bounds
lb = zeros(N)
ub = zeros(N) + 0.5
# build the constraints operator
from mystic.symbolic import linear_symbolic, solve, \
generate_solvers as solvers, generate_constraint as constraint
constrain = linear_symbolic(Aeq,Beq)
constrain = constraint(solvers(solve(constrain,target=['x0'])))
from mystic import suppressed
@suppressed(1e-5)
def conserve(x):
return constrain(x)
from mystic.monitors import VerboseMonitor
mon = VerboseMonitor(10)
# solve for alpha
from mystic.solvers import diffev
alpha = diffev(objective, list(zip(lb,.1*ub)), args=(Q,b), npop=N*3, gtol=200, \
itermon=mon, \
ftol=1e-5, bounds=list(zip(lb,ub)), constraints=conserve, disp=1)
x0, x1 = x
return x0**2 + (x1 - 1)**2
bounds = [(-1, 1)] * 2
# with penalty='penalty' applied, solution is:
xs, xs_ = [(0.5)**.5, 0.5], [-(0.5)**.5, 0.5]
ys = 0.75
from mystic.symbolic import generate_constraint, generate_solvers, solve
from mystic.symbolic import generate_penalty, generate_conditions
equations = """
x1 - x0**2 = 0.0
"""
cf = generate_constraint(generate_solvers(solve(equations, target='x1')))
pf = generate_penalty(generate_conditions(equations), k=1e12)
if __name__ == '__main__':
from mystic.solvers import diffev2
from mystic.math import almostEqual
result = diffev2(objective,
x0=bounds,
bounds=bounds,
constraints=cf,
npop=40,
disp=False,
full_output=True)
def cf(len=3):
return generate_constraint(generate_solvers(solve(equations(len))))
def objective(x):
x0,x1 = x
return x0**2 + (x1 - 1)**2
bounds = [(-1,1)]*2
# with penalty='penalty' applied, solution is:
xs, xs_ = [(0.5)**.5, 0.5], [-(0.5)**.5, 0.5]
ys = 0.75
from mystic.symbolic import generate_constraint, generate_solvers, solve
from mystic.symbolic import generate_penalty, generate_conditions
equations = """
x1 - x0**2 = 0.0
"""
cf = generate_constraint(generate_solvers(solve(equations, target='x1')))
pf = generate_penalty(generate_conditions(equations), k=1e12)
if __name__ == '__main__':
from mystic.solvers import diffev2
from mystic.math import almostEqual
result = diffev2(objective, x0=bounds, bounds=bounds, constraints=cf, npop=40, disp=False, full_output=True)
assert almostEqual(result[0], xs, tol=1e-2) \
or almostEqual(result[0], xs_, tol=1e-2)
assert almostEqual(result[1], ys, rel=1e-2)
98527*x0 + 34588*x1 + 5872*x2 + 59422*x4 + 65159*x6 - 1547604 - 30704*x3 - 29649*x5 == 0.0
98957*x1 + 83634*x2 + 69966*x3 + 62038*x4 + 37164*x5 + 85413*x6 - 1823553 - 93989*x0 == 0.0
900032 + 10949*x0 + 77761*x1 + 67052*x4 - 80197*x2 - 61944*x3 - 92964*x5 - 44550*x6 == 0.0
73947*x0 + 84391*x2 + 81310*x4 - 1164380 - 96253*x1 - 44247*x3 - 70582*x5 - 33054*x6 == 0.0
13057*x2 + 42253*x3 + 77527*x4 + 96552*x6 - 1185471 - 60152*x0 - 21103*x1 - 97932*x5 == 0.0
1394152 + 66920*x0 + 55679*x3 - 64234*x1 - 65337*x2 - 45581*x4 - 67707*x5 - 98038*x6 == 0.0
68550*x0 + 27886*x1 + 31716*x2 + 73597*x3 + 38835*x6 - 279091 - 88963*x4 - 76391*x5 == 0.0
76132*x1 + 71860*x2 + 22770*x3 + 68211*x4 + 78587*x5 - 480923 - 48224*x0 - 82817*x6 == 0.0
519878 + 94198*x1 + 87234*x2 + 37498*x3 - 71583*x0 - 25728*x4 - 25495*x5 - 70023*x6 == 0.0
361921 + 78693*x0 + 38592*x4 + 38478*x5 - 94129*x1 - 43188*x2 - 82528*x3 - 69025*x6 == 0.0
"""
from mystic.symbolic import generate_penalty, generate_conditions
pf = generate_penalty(generate_conditions(equations))
from mystic.symbolic import generate_constraint, generate_solvers, solve
cf = generate_constraint(generate_solvers(solve(equations)))
from numpy import round as npround
if __name__ == '__main__':
from mystic.solvers import diffev2
from mystic.math import almostEqual
#result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, npop=20, gtol=50, disp=True, full_output=True)
#result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, constraints=npround, npop=40, gtol=50, disp=True, full_output=True)
result = diffev2(objective, x0=bounds, bounds=bounds, constraints=cf, npop=4, gtol=1, disp=True, full_output=True)
print(result[0])
assert almostEqual(result[0], xs, tol=1e-8) #XXX: fails b/c rel & zero?
svr_epsilon = 4
b = Y + svr_epsilon * ones(Y.size)
# build the constraints (y.T * x = 0.0)
# 1.0*x0 + 1.0*x1 + ... - 1.0*xN = 0.0
Aeq = concatenate([ones(nx), -ones(nx)]).reshape(1, N)
Beq = array([0.0])
# set the bounds
lb = zeros(N)
ub = zeros(N) + 0.5
# build the constraints operator
from mystic.symbolic import linear_symbolic, solve, generate_solvers as solvers, generate_constraint as constraint
constrain = linear_symbolic(Aeq, Beq)
constrain = constraint(solvers(solve(constrain, target=["x0"])))
from mystic import suppressed
@suppressed(1e-5)
def conserve(x):
return constrain(x)
from mystic.monitors import VerboseMonitor
mon = VerboseMonitor(10)
# solve for alpha
from mystic.solvers import diffev
