def loglikelyhood_cvxopt(xxf,extra_args,to_CVXOPT=False):
if not to_CVXOPT:
return mw.fitter_s.loglikelyhood(np.array(xxf).flatten(),*extra_args)
case,sin,sout,selfs,M,nvarx,nvary,inds_selfs = extra_args[:8]
x = xxf[:nvarx]
y = xxf[nvarx:]
xl = cvxopt.log(x)
yl = cvxopt.log(y)
if case == 'W':
aux = 1.-np.einsum('ik,jk',x,y)
elif case == 'B':
aux = 1./(1.+np.einsum('ik,jk',x,y))
else:
aux = np.einsum('ik,jk',x,y)
if not selfs:
aa = aux.flatten()
if case == 'ME':
aa[inds_selfs] = 0.
else:
aa[inds_selfs] = 1.
aux = aa.reshape(nvarx,nvary)
L1 = np.einsum('ik,ik',sin,yl)
L2 = np.einsum('ik,ik',sout,xl)
if case == 'ME':
L4 = np.einsum('ij->',-aux)
else:
L4 = np.einsum('ij->',np.log(aux))
L = -(M*L4+L1+L2)
return -(M*L4+L1+L2)
def F(x=None, z=None): if x is None: return 0, matrix(1.0, (n,1)) if min(x) <= 0: return None f = x.T*log(x) grad = 1.0 + log(x) if z is None: return f, grad.T H = spdiag(z[0] * x**-1) return f, grad.T, H
def F(x=None, z=None):
if x is None: return 0, matrix(1.0 / p, (p, 1))
if min(x) < 0: return None
f = x.T * log(x) - x.T * logv
Df = (log(x) + 1 - logv).T
if z is None: return f, Df
H = spmatrix(div(1, x), range(p), range(p))
return f, Df, H
def F(x=None, z=None):
if x is None: return 0, matrix(1.0, (n, 1))
if min(x) <= 0: return None
f = x.T * log(x)
grad = 1.0 + log(x)
if z is None: return f, grad.T
H = spdiag(z[0] * x**-1)
return f, grad.T, H
def I_X_YZ(p):
# Mutual information I( X ; YZ )
p_x = marginal_x(p)
p_yz = marginal_yz(p)
mysum = 0
for xyz,t in p.items():
x,y,z = xyz
if t>0: mysum += t * log( t / ( p_x[x]*p_yz[(y,z)] ) )
return mysum/log(2)
def I_X_YZ(p):
# Mutual information I( X ; YZ )
p_x = marginal_x(p)
p_yz = marginal_yz(p)
mysum = 0
for xyz, t in p.items():
x, y, z = xyz
if t > 0: mysum += t * log(t / (p_x[x] * p_yz[(y, z)]))
return mysum / log(2)
def solve(self, p, ZERO=1.e-1000):
p_yz = marginal_yz_with_cutoff(p, ZERO)
if self.first_time:
self.first_time = False
for x in self.cui.X:
for y in self.cui.Y:
for z in self.cui.Z:
xyz = x, y, z
if xyz in p.keys() and p[xyz] > ZERO:
# equation
p_xyz = p[xyz]
rhs = -log(p_xyz / p_yz[y, z]) # >= 0
self.constr_geq[xyz].setAttr("rhs", rhs)
self.constr_leq[xyz].setAttr("rhs", rhs)
else:
# inequality
if xyz in self.constr_leq.keys():
self.model.remove(self.constr_leq[xyz])
del self.constr_leq[xyz]
if (y, z) in p_yz.keys() and p_yz[y, z] > 0:
rhs = 1.e400 # don't need ZERO here, marginal_yz_w_cutoff()
else:
rhs = 0.
self.constr_geq[xyz].setAttr("rhs", rhs)
# if
#^ for z
#^ for y
#^ for x
else: # same, but different loop
for xyz in p.keys():
x, y, z = xyz
if p[xyz] > ZERO:
# equation
p_xyz = p[xyz]
rhs = -log(p_xyz / p_yz[y, z]) # >= 0
self.constr_leq[xyz].setAttr("rhs", rhs)
self.constr_geq[xyz].setAttr("rhs", rhs)
else:
# inequality
if xyz in self.constr_leq.keys():
self.model.remove(self.constr_leq[xyz])
del self.constr_leq[xyz]
if (y, z) in p_yz.keys() and p_yz[y, z] > 0:
rhs = 1.e400 # don't need ZERO here, marginal_yz_w_cutoff()
else:
rhs = 0.
self.constr_geq[xyz].setAttr("rhs", rhs)
# if
#^ for xyz
#^ if/else first time
self.model.update()
self.model.optimize()
if self.model.status == Compute_UI.KKT_System.gurobi.GRB.Status.OPTIMAL:
t = self.t_var.getAttr("x")
return t
else:
return None
def I_X_Y(p):
# Mutual information I( X ; Y )
p_x = marginal_x(p)
p_y = marginal_y(p)
p_xy = marginal_xy(p)
mysum = 0
for xy,t in p_xy.items():
x,y = xy
if t>0: mysum += t * log( t / ( p_x[x]*p_y[y] ) )
return mysum/log(2)
def I_X_Y(p):
# Mutual information I( X ; Y )
p_x = marginal_x(p)
p_y = marginal_y(p)
p_xy = marginal_xy(p)
mysum = 0
for xy, t in p_xy.items():
x, y = xy
if t > 0: mysum += t * log(t / (p_x[x] * p_y[y]))
return mysum / log(2)
def cond_I_X_Y__Z(p):
# Conditional mutual information I( X ; Y | Z )
p_z = marginal_z(p)
p_xz = marginal_xz(p)
p_yz = marginal_yz(p)
mysum = 0
for xyz,t in p.items():
x,y,z = xyz
if t>0: mysum += t * log( ( t * p_z[z] )/( p_xz[(x,z)]*p_yz[(y,z)] ) )
return mysum/log(2)
def F(self, x=None, z=None):
if (x is None):
return 0, matrix(1., (len(self.validTours), 1))
if (min(x) < 0.0):
return None
f = (x.T * log(x))
Df = (1. + log(x)).T
if (z is None):
return f, Df
H = spdiag(z * x**(-1))
return f, Df, H
def cond_I_X_Z__Y(p):
# Conditional mutual information I( X ; Y | Z )
p_y = marginal_y(p)
p_xy = marginal_xy(p)
p_yz = marginal_yz(p)
mysum = 0
for xyz, t in p.items():
x, y, z = xyz
if t > 0:
mysum += t * log((t * p_y[y]) / (p_xy[(x, y)] * p_yz[(y, z)]))
return mysum / log(2)
def cond_I_X_Y__Z(p):
# Conditional mutual information I( X ; Y | Z )
p_z = marginal_z(p)
p_xz = marginal_xz(p)
p_yz = marginal_yz(p)
mysum = 0
for xyz, t in p.items():
x, y, z = xyz
if t > 0:
mysum += t * log((t * p_z[z]) / (p_xz[(x, z)] * p_yz[(y, z)]))
return mysum / log(2)
def solve(self, p, ZERO=1.e-1000):
p_yz = marginal_yz_with_cutoff(p,ZERO)
if self.first_time:
self.first_time = False
for x in self.cui.X:
for y in self.cui.Y:
for z in self.cui.Z:
xyz=x,y,z
if xyz in p.keys() and p[xyz] > ZERO:
# equation
p_xyz = p[xyz]
rhs = -log(p_xyz/p_yz[y,z]) # >= 0
self.constr_geq[ xyz ].setAttr("rhs", rhs)
self.constr_leq[ xyz ].setAttr("rhs", rhs)
else:
# inequality
if xyz in self.constr_leq.keys():
self.model.remove(self.constr_leq[xyz])
del self.constr_leq[ xyz ]
if (y,z) in p_yz.keys() and p_yz[y,z] > 0: rhs = 1.e400 # don't need ZERO here, marginal_yz_w_cutoff()
else: rhs = 0.
self.constr_geq[ xyz ].setAttr("rhs", rhs)
# if
#^ for z
#^ for y
#^ for x
else: # same, but different loop
for xyz in p.keys():
x,y,z=xyz
if p[xyz] > ZERO:
# equation
p_xyz = p[xyz]
rhs = -log(p_xyz/p_yz[y,z]) # >= 0
self.constr_leq[ xyz ].setAttr("rhs", rhs)
self.constr_geq[ xyz ].setAttr("rhs", rhs)
else:
# inequality
if xyz in self.constr_leq.keys():
self.model.remove(self.constr_leq[xyz])
del self.constr_leq[ xyz ]
if (y,z) in p_yz.keys() and p_yz[y,z] > 0: rhs = 1.e400 # don't need ZERO here, marginal_yz_w_cutoff()
else: rhs = 0.
self.constr_geq[ xyz ].setAttr("rhs", rhs)
# if
#^ for xyz
#^ if/else first time
self.model.update()
self.model.optimize();
if self.model.status == Compute_UI.KKT_System.gurobi.GRB.Status.OPTIMAL:
t = self.t_var.getAttr("x")
return t
else:
return None
def F(x=None, z=None):
if x is None: return 0, matrix(1.0, (n,1))
X = V * spdiag(x) * V.T
L = +X
try:
lapack.potrf(L)
except ArithmeticError: return None
f = - 2.0 * (log(L[0,0]) + log(L[1,1]))
W = +V
blas.trsm(L, W)
gradf = matrix(-1.0, (1,2)) * W**2
if z is None: return f, gradf
H = matrix(0.0, (n,n))
blas.syrk(W, H, trans='T')
return f, gradf, z[0] * H**2
def cvxoptimize(c, A, k, *args, **kwargs):
"""Interface to the CVXOPT solver
Definitions
-----------
"[a,b] array of floats" indicates array-like data with shape [a,b]
n is the number of monomials in the gp
m is the number of variables in the gp
p is the number of posynomials in the gp
Arguments
---------
c : floats array of shape n
Coefficients of each monomial
A : floats array of shape (m,n)
Exponents of the various free variables for each monomial.
k : ints array of shape n
number of monomials (columns of F) present in each constraint
Returns
-------
dict
Contains the following keys
"success": bool
"objective_sol" float
Optimal value of the objective
"primal_sol": floats array of size m
Optimal value of free variables. Note: not in logspace.
"dual_sol": floats array of size p
Optimal value of the dual variables, in logspace.
"""
g = log(matrix(c))
F = spmatrix(A.data, A.row, A.col, tc="d")
solution = gpsolver(k, F, g)
return dict(status=solution["status"], primal=solution["x"], la=solution["znl"])
def F(x=None, z=None):
# The cvxopt matrix slicing does not include the last number.
# x[0:d] is beta; x[d] is const; x[d+1:2*d+1] is t ; x[2*d+1:] is zeta
if x is None: return 2 * d + 2*absN, matrix(0.0, (2*d+1+absN, 1))
absS = absA * x[:d + 1] # 0 - d contains the constant. Absolute label scores.
cmpE = cmpA * x[:d + 1]
cmpW = exp(cmpE)
f = matrix(0.0,(2*d+1+2*absN,1))
f[0] = absWeight*sum(x[2*d+1:])+ cmpWeight*(-sum(cmpE) + sum(log(1+cmpW))) + lamda * sum(x[d+1:2*d+1])
f[1: d + 1] = x[:d] - x[d+1:2*d+1] # beta - t <= 0
f[d + 1: 2*d+1] = -x[:d] - x[d+1:2*d+1] # -beta - t <= 0
f[2*d+1:2*d+1+absN] = -absS-x[2*d+1:]+1 # -y_i(beta.T*x_i)-zeta_i+1 <=0
f[2*d+1+absN:] = -x[2*d+1:]
Df = matrix(0.0, (2*d+1+2*absN, 2*d+1+absN))
Df[0, 0:d+1] = cmpWeight * (matrix(cmpA.T * (div(cmpW, 1 + cmpW) - 1.0))).T
Df[0, d+1 : 2*d+1] = lamda
Df[0, 2*d+1:] = absWeight
Df[1 : d+1, 0:d] = spdiag(matrix(1.0, (d, 1)))
Df[d+1: 2*d+1, 0:d] = spdiag(matrix(-1.0, (d, 1)))
Df[1 : d+1, d+1 : 2*d+1] = spdiag(matrix(-1.0, (d, 1)))
Df[d+1 : 2*d+1, d+1 : 2*d+1] = spdiag(matrix(-1.0, (d, 1)))
Df[2*d+1:2*d+1+absN, 0:d+1] = -absA
Df[2*d+1:2*d+1+absN , 2*d+1:] = spdiag(matrix(-1.0,(absN,1)))
Df[2*d+1+absN:,2*d+1:] = spdiag(matrix(-1.0,(absN,1)))
if z is None: return f, Df
H = matrix(0.0, (2*d+1+absN, 2*d+1+absN))
H[0:d + 1, 0:d + 1] = cmpWeight * (cmpA.T * spdiag(div(cmpW, (1 + cmpW) ** 2)) * cmpA)
return f, Df, z[0] * H
def F(x=None, z=None):
if x is None:
return 0, matrix(0.0, (n, 1))
if max(abs(x)) >= 1.0:
return None
r = -b
blas.gemv(A, x, r, beta=-1.0)
w = x**2
f = 0.5 * blas.nrm2(r)**2 - sum(log(1 - w))
gradf = div(x, 1.0 - w)
blas.gemv(A, r, gradf, trans='T', beta=2.0)
if z is None:
return f, gradf.T
else:
def Hf(u, v, alpha=1.0, beta=0.0):
"""
v := alpha * (A'*A*u + 2*((1+w)./(1-w)).*u + beta *v
"""
v *= beta
v += 2.0 * alpha * mul(div(1.0 + w, (1.0 - w)**2), u)
blas.gemv(A, u, r)
blas.gemv(A, r, v, alpha=alpha, beta=1.0, trans='T')
return f, gradf.T, Hf
def func(x):
z = numpy.reshape(x, (I, J))
u = utility(z)
f = -sum(log(sum(z[i][j] for j in range(J)))
for i in range(I)) + q * sum(
math.exp(u[l]) for l in range(L))
return f
def init1(self, dae):
self.system.rmgen(self.gen)
p0 = mul(self.u, self.system.Bus.Pg[self.a], self.gammap)
q0 = mul(self.u, self.system.Bus.Qg[self.a], self.gammaq)
v0 = mul(self.u, dae.y[self.v])
theta0 = dae.y[self.a]
v = polar(v0, theta0)
S = p0 - q0 * 1j
I = div(S, conj(v))
E = v + mul(self.ra + self.xd1 * 1j, I)
dae.y[self.p] = p0
dae.y[self.q] = q0
delta = log(div(E, abs(E) + 0j))
dae.x[self.delta] = mul(self.u, delta.imag())
dae.x[self.omega] = matrix(1.0, (self.n, 1), 'd')
# d- and q-axis voltages and currents
vdq = mul(self.u, mul(v, exp(jpi2 - delta)))
idq = mul(self.u, mul(I, exp(jpi2 - delta)))
vd = dae.y[self.vd] = vdq.real()
vq = dae.y[self.vq] = vdq.imag()
Id = dae.y[self.Id] = idq.real()
Iq = dae.y[self.Iq] = idq.imag()
# electro-mechanical torques / powers
self.pm0 = mul(vq + mul(self.ra, Iq), Iq) + mul(
vd + mul(self.ra, Id), Id)
dae.y[self.pm] = self.pm0
def testgp(opts):
Aflr = 1000.0
Awall = 100.0
alpha = 0.5
beta = 2.0
gamma = 0.5
delta = 2.0
F = matrix( [[-1., 1., 1., 0., -1., 1., 0., 0.],
[-1., 1., 0., 1., 1., -1., 1., -1.],
[-1., 0., 1., 1., 0., 0., -1., 1.]])
g = log( matrix( [1.0, 2/Awall, 2/Awall, 1/Aflr, alpha, 1/beta, gamma,
1/delta]) )
K = [1, 2, 1, 1, 1, 1, 1]
solvers.options.update(opts)
sol = solvers.gp(K, F, g)
#localcvx.options.update(opts)
#sol = localcvx.gp(K, F, g, kktsolver='chol')
if sol['status'] == 'optimal':
x = sol['x']
print "x=\n", helpers.strSpe(x, "%.17f")
h, w, d = exp(x)
print("\n h = %f, w = %f, d = %f.\n" %(h,w,d))
print "\n *** running GO test ***"
helpers.run_go_test("../testgp", {'x': x})
def F(x=None, z=None): if x is None: return 0, matrix(0.0, (2,1)) w = exp(A*x) f = c.T*x + sum(log(1+w)) grad = c + A.T * div(w, 1+w) if z is None: return f, grad.T H = A.T * spdiag(div(w,(1+w)**2)) * A return f, grad.T, z[0]*H
def F(x=None, z=None): if x is None: return 0, matrix(0.0, (n+1,1)) w = exp(A*x) f = dot(c,x) + sum(log(1+w)) grad = c + A.T * div(w, 1+w) if z is None: return matrix(f), grad.T H = A.T * spdiag(div(w,(1+w)**2)) * A return matrix(f), grad.T, z[0]*H
def F(x=None, z=None):
if x is None: return 0, matrix(1.0, (n, 1))
if min(x) <= 0.0: return None
f = -sum(log(x))
Df = -(x**-1).T
if z is None: return matrix(f), Df
H = spdiag(z[0] * x**-2)
return f, Df, H
def F(x=None, z=None):
if x is None: return 0, matrix(1.0, (n,1))
if min(x) <= 0.0: return None
f = -sum(log(x))
Df = -(x**-1).T
if z is None: return matrix(f), Df
H = spdiag(z[0] * x**-2)
return f, Df, H
def F(x=None, z=None):
if x is None: return 0, cvxopt.matrix(1.0, (n,1))
if min(x) <= 0.0: return None
f = -sum(cvxopt.log(x))
Df = -(x**-1).T
if z is None: return f, Df
H = cvxopt.spdiag(z[0] * x**-2)
return f, Df, H
def F(x=None, z=None):
if x is None: return 0, cvxopt.matrix(1.0, (n, 1))
if min(x) <= 0.0: return None
f = -sum(cvxopt.log(x))
Df = -(x**-1).T
if z is None: return f, Df
H = cvxopt.spdiag(z[0] * x**-2)
return f, Df, H
def func(self, x): # {{{
z = numpy.reshape(x, (self.I, self.J))
u = self.utility(z)
f = -sum(
self.endhost_weight[i] * log(sum(z[i][j] for j in range(self.J)))
for i in range(self.I)) + self.q * sum(
math.exp(u[l]) for l in range(self.L))
return f # }}}
def F(x=None, z=None):
if x is None: return 0, matrix(0.0, (2, 1))
w = exp(A * x)
f = c.T * x + sum(log(1 + w))
grad = c + A.T * div(w, 1 + w)
if z is None: return f, grad.T
H = A.T * spdiag(div(w, (1 + w)**2)) * A
return f, grad.T, z[0] * H
def solve_KKT_system(self, p, ZERO=1.e-1000):
import gurobipy as gurobi
model = gurobi.Model("kkt")
model.params.logToConsole = 0
# Add the variables:
t_var = None
lambda_vars = dict()
mu_vars = dict()
t_var = model.addVar(obj=1., name="t")
for x in self.X:
for y in self.Y:
lambda_vars[x, y] = model.addVar(name='lambda(%s,%s)' % (x, y))
for x in self.X:
for z in self.Y:
mu_vars[x, z] = model.addVar(name='mu(%s,%s)' % (x, z))
model.update()
# Add the constraints:
p_yz = marginal_yz_with_cutoff(p, ZERO)
for x in self.X:
for y in self.Y:
for z in self.Z:
if (x, y, z) in p.keys() and p[x, y, z] > ZERO:
# equation
p_xyz = p[x, y, z]
rhs = -log(p_xyz / p_yz[y, z]) # >= 0
model.addConstr(
lambda_vars[x, y] + mu_vars[x, z] - rhs <= t_var,
name='eqn+(%s,%s,%s)' % (x, y, z))
model.addConstr(
lambda_vars[x, y] + mu_vars[x, z] - rhs >= -t_var,
name='eqn-(%s,%s,%s)' % (x, y, z))
else:
# inequality
if (y, z) in p_yz.keys() and p_yz[y, z] > 0:
rhs = 1.e400 # don't need ZERO here, marginal_yz_w_cutoff()
else:
rhs = 0.
model.addConstr(
lambda_vars[x, y] + mu_vars[x, z] - rhs >= -t_var,
name='ieq(%s,%s,%s)' % (x, y, z))
# if
#^ for z
#^ for y
#^ for x
# Run Gurobi:
model.optimize()
if model.status == gurobi.GRB.Status.OPTIMAL:
t = t_var.getAttr("x")
return t
else:
return None
def F(x=None, z=None):
if x is None: return 0, matrix(0.0,(n,1))
y = A*x+b
if max(abs(y)) >= 1.0: return None
f = -sum(log(1.0 - y**2))
gradf = 2.0 * A.T * div(y, 1-y**2)
if z is None: return f, gradf.T
H = A.T * spdiag(2.0*z[0]*div(1.0+y**2,(1.0-y**2)**2))*A
return f,gradf.T,H
def gradient(p):
grad = dict()
p_yz = marginal_yz(p)
for xyz,t in p.items():
x,y,z = xyz
if p[xyz] > 0: grad[xyz] = log(p_yz[y,z] / p[x,y,z])
elif p_yz[y,z] > 0: grad[xyz] = 1.e400
else: grad[xyz] = 0.
return grad
def gradient(p):
grad = dict()
p_yz = marginal_yz(p)
for xyz, t in p.items():
x, y, z = xyz
if p[xyz] > 0: grad[xyz] = log(p_yz[y, z] / p[x, y, z])
elif p_yz[y, z] > 0: grad[xyz] = 1.e400
else: grad[xyz] = 0.
return grad
def F(x=None, z=None):
if x is None: return 0, x0
if min(x) <= 0.0: return None
f = -sum(log(x)) + e * np.random.normal()
Df = -(x**-1).T + e * matrix(np.random.normal(n), (1, n))
if z is None: return f, Df
H = matrix(np.eye(n).astype(np.float))
return f, Df, H
def F(x=None, z=None):
if x is None: return 0, matrix(0.0, (n, 1))
y = A * x + b
if max(abs(y)) >= 1.0: return None
f = -sum(log(1.0 - y**2))
gradf = 2.0 * A.T * div(y, 1 - y**2)
if z is None: return f, gradf.T
H = A.T * spdiag(2.0 * z[0] * div(1.0 + y**2, (1.0 - y**2)**2)) * A
return f, gradf.T, H
def F(x = None, z = None):
if x is None: return 0, matrix(0.0, (3,1))
if max(abs(x)) >= 1.0: return None
u = 1 - x**2
val = -sum(log(u))
Df = div(2*x, u).T
if z is None: return val, Df
H = spdiag(2 * z[0] * div(1 + u**2, u**2))
return val, Df, H
def try_to_improve_by_LP(self, p):
import gurobipy as gurobi
model = gurobi.Model("improve")
model.params.logToConsole = 0
p_yz = marginal_yz(p)
# Add the variables:
p_xyz_vars = dict()
for x in self.X:
for y in self.Y:
for z in self.Z:
if (x, y, z) in p.keys() and p[x, y, z] > 0:
# equation
p_xyz = p[x, y, z]
obj = -log(p_xyz / p_yz[y, z]) # >= 0
else:
# inequality
if (y, z) in p_yz.keys() and p_yz[y, z] > 0:
obj = 1.e100
else:
obj = 0.
p_xyz_vars[x, y, z] = model.addVar(obj=rhs,
lb=0.,
name='p(%s,%s,%s)' %
(x, y, z))
# if
#^ for z
#^ for y
#^ for x
model.update()
# Add constraints:
for x in self.X:
for y in self.Y:
lambda_vars[x, y] = model.addVar(name='lambda(%s,%s)' % (x, y))
for x in self.X:
for z in self.Y:
mu_vars[x, z] = model.addVar(name='mu(%s,%s)' % (x, z))
model.update()
# Add the constraints:
p_yz = marginal_yz(p)
# Run Gurobi:
model.optimize()
if model.status == gurobi.GRB.Status.OPTIMAL:
t = t_var.getAttr("x")
return t
else:
print("There has been a terrible mistake! [try_to_improve_LP()]")
return 1.e400
def F(x=None, z=None):
if x is None: return 0, matrix(1.0, (n,1))
if min(x) <= 0.0: return None
print(x)
f = -sum(log(x))
Df = -(x**-1).T
if z is None: return f, Df
print("H.size=", (z[0] * x**-2).size)
H = spdiag(z[0] * x**-2)
return f, Df, H
def F(x=None, z=None):
if x is None:
return (0, cvx.matrix(min(np.linalg.eigvals(Sig)), (lenI, 1)))
mat = ((nsko + 1) / nsko) * Sig - I_PI @ np.diag(
list(x)) @ I_PI.transpose()
f = -cvx.log(np.linalg.det(mat)) - nsko * cvx.sum(cvx.log(x))
mat_inv = cvx.matrix(np.linalg.inv(mat))
Df = mat_inv[cvx.matrix(I) * p + cvx.matrix(I)] - cvx.div(nsko, x)
if z is None: return f, Df.T
Matrix_list = []
for i in range(lenI):
I0 = cvx.matrix(0, (p, p))
I0[I[i], I[i]] = 1
A = -mat_inv * I0 * mat_inv
Matrix_list.append(
cvx.matrix(A[cvx.matrix(I) * p + cvx.matrix(I)], (1, lenI)))
DDf = -cvx.matrix(Matrix_list, (lenI, lenI))
H = cvx.sparse(DDf + cvx.spdiag(cvx.div(nsko, x**2)))
return f, Df.T, z[0] * H
def F(x=None, z=None):
if x is None: return 0, matrix(x0)
y = h - G * x
# we are assuming here that the center can sit on an edge
if min(y) <= 0: return None
# pretty standard log barrier
f = -sum(log(y))
Df = (y**-1).T * G
if z is None: return matrix(f), Df
H = G.T * spdiag(y**-2) * G
return matrix(f), Df, z[0] * H
def logWeighting(self, x):
"""
Log re-weighting function used in sparse optimization.
Parameters
----------
x: np.ndarray
Array of parameters for weighting.
"""
ncoeff = x.size[0]
return log(div(blas.asum(x) + ncoeff * self.eps, abs(x) + self.eps))
def F(x=None, z=None):
# x = (t1, t2)
# t1 - log(t2) <= 0
if x is None: return m, cvxopt.matrix(m*[0.0] + m*[1.0])
if min(x[m:]) <= 0.0: return None
f = x[0:m] - cvxopt.log(x[m:])
Df = cvxopt.sparse([[cvxopt.spdiag(cvxopt.matrix(1.0, (m,1)))], [cvxopt.spdiag(-(x[m:]**-1))]])
if z is None: return f, Df
ret = cvxopt.mul(z, x[m:]**-2)
# TODO: add regularization for the Hessian?
H = cvxopt.spdiag(cvxopt.matrix([cvxopt.matrix(0, (m,1)), ret]))
return f, Df, H
def make_KKT_lp(self, p, filename):
x_idx = dict()
for x in self.X:
x_idx[x] = len(x_idx)
y_idx = dict()
for y in self.Y:
y_idx[y] = len(y_idx)
z_idx = dict()
for z in self.Z:
z_idx[z] = len(z_idx)
p_yz = marginal_yz(p)
filecontent = ""
filecontent += "Minimize\n"
filecontent += "Obj: t\n"
filecontent += "Subject To\n"
for x in self.X:
for y in self.Y:
for z in self.Z:
lhs = ""
lhs += " lambda" + str(x_idx[x]) + "_" + str(y_idx[y])
lhs += " + "
lhs += " mu" + str(x_idx[x]) + "_" + str(z_idx[z])
if (x, y, z) in p.keys() and p[x, y, z] > 0:
# equation
p_xzy = p[x, y, z]
rhs = -1000 * log(p_xzy / p_yz[y, z]) # >= 0
filecontent += "p(" + str(x_idx[x]) + "," + str(
y_idx[y]) + "," + str(
z_idx[z]) + "): " + lhs + " -t <= " + str(
rhs) + "\n"
filecontent += "p(" + str(x_idx[x]) + "," + str(
y_idx[y]) + "," + str(
z_idx[z]) + "): " + lhs + " +t >= " + str(
rhs) + "\n"
else:
# inequality
if (y, z) in p_yz.keys() and p_yz[y, z] > 0:
rhs = 1.e100
else:
rhs = 0
filecontent += "p(" + str(x_idx[x]) + "," + str(
y_idx[y]) + "," + str(
z_idx[z]) + "): " + lhs + " +t >= " + str(
rhs) + "\n"
#^ for
#^ for
#^ for
filecontent += "END\n"
print("Writing KKT system to file ", filename)
with open(filename, 'w') as thefile:
thefile.write(filecontent)
def try_to_improve_by_LP(self, p):
import gurobipy as gurobi
model = gurobi.Model("improve")
model.params.logToConsole = 0
p_yz = marginal_yz(p)
# Add the variables:
p_xyz_vars = dict()
for x in self.X:
for y in self.Y:
for z in self.Z:
if (x,y,z) in p.keys() and p[x,y,z] > 0:
# equation
p_xyz = p[x,y,z]
obj = -log(p_xyz/p_yz[y,z]) # >= 0
else:
# inequality
if (y,z) in p_yz.keys() and p_yz[y,z] > 0: obj = 1.e100
else: obj = 0.
p_xyz_vars[x,y,z] = model.addVar( obj=rhs, lb=0., name='p(%s,%s,%s)' % (x,y,z))
# if
#^ for z
#^ for y
#^ for x
model.update()
# Add constraints:
for x in self.X:
for y in self.Y:
lambda_vars[x,y] = model.addVar(name='lambda(%s,%s)' % (x,y))
for x in self.X:
for z in self.Y:
mu_vars[x,z] = model.addVar(name='mu(%s,%s)' % (x,z))
model.update()
# Add the constraints:
p_yz = marginal_yz(p)
# Run Gurobi:
model.optimize();
if model.status == gurobi.GRB.Status.OPTIMAL:
t = t_var.getAttr("x")
return t
else:
print("There has been a terrible mistake! [try_to_improve_LP()]")
return 1.e400
def kl_divergence(Of,From): # KL-divergence of Q from P
Q=Of
P=From
thesum = 0.
for x,q in Q.items():
if q>0:
if x in P.keys():
p = P[x]
if p>0: thesum += q*log(q/p)
else: thesum = 1.e+400
else:
thesum = 1.e+400
return thesum;
def solve_KKT_system(self, p, ZERO=1.e-1000):
import gurobipy as gurobi
model = gurobi.Model("kkt")
model.params.logToConsole = 0
# Add the variables:
t_var = None
lambda_vars = dict()
mu_vars = dict()
t_var = model.addVar(obj=1., name="t")
for x in self.X:
for y in self.Y:
lambda_vars[x,y] = model.addVar(name='lambda(%s,%s)' % (x,y))
for x in self.X:
for z in self.Y:
mu_vars[x,z] = model.addVar(name='mu(%s,%s)' % (x,z))
model.update()
# Add the constraints:
p_yz = marginal_yz_with_cutoff(p,ZERO)
for x in self.X:
for y in self.Y:
for z in self.Z:
if (x,y,z) in p.keys() and p[x,y,z] > ZERO:
# equation
p_xyz = p[x,y,z]
rhs = -log(p_xyz/p_yz[y,z]) # >= 0
model.addConstr( lambda_vars[x,y] + mu_vars[x,z] - rhs <= t_var , name='eqn+(%s,%s,%s)' % (x,y,z))
model.addConstr( lambda_vars[x,y] + mu_vars[x,z] - rhs >= -t_var , name='eqn-(%s,%s,%s)' % (x,y,z))
else:
# inequality
if (y,z) in p_yz.keys() and p_yz[y,z] > 0: rhs = 1.e400 # don't need ZERO here, marginal_yz_w_cutoff()
else: rhs = 0.
model.addConstr( lambda_vars[x,y] + mu_vars[x,z] - rhs >= -t_var , name='ieq(%s,%s,%s)' % (x,y,z))
# if
#^ for z
#^ for y
#^ for x
# Run Gurobi:
model.optimize();
if model.status == gurobi.GRB.Status.OPTIMAL:
t = t_var.getAttr("x")
return t
else:
return None
def acent(A, b):
"""
Computes analytic center of A*x <= b with A m by n of rank n.
We assume that b > 0 and the feasible set is bounded.
"""
MAXITERS = 100
ALPHA = 0.01
BETA = 0.5
TOL = 1e-8
ntdecrs = []
m, n = A.size
x = matrix(0.0, (n, 1))
H = matrix(0.0, (n, n))
for iter in range(MAXITERS):
# Gradient is g = A^T * (1./(b-A*x)).
d = (b - A * x) ** -1
g = A.T * d
# Hessian is H = A^T * diag(1./(b-A*x))^2 * A.
Asc = mul(d[:, n * [0]], A)
blas.syrk(Asc, H, trans="T")
# Newton step is v = H^-1 * g.
v = -g
lapack.posv(H, v)
# Directional derivative and Newton decrement.
lam = blas.dot(g, v)
ntdecrs += [sqrt(-lam)]
print("%2d. Newton decr. = %3.3e" % (iter, ntdecrs[-1]))
if ntdecrs[-1] < TOL:
return x, ntdecrs
# Backtracking line search.
y = mul(A * v, d)
step = 1.0
while 1 - step * max(y) < 0:
step *= BETA
while True:
if -sum(log(1 - step * y)) < ALPHA * step * lam:
break
step *= BETA
x += step * v
def test_problem_expdesign(self):
# test problem needs review
print 'skipping, needs review'
return
from cvxpy import (matrix, variable, program, minimize,
log, det_rootn, diag, sum, geq, eq, zeros)
tol_exp = 6
V = matrix(self.V)
n = V.shape[1]
x = variable(n)
# Use cvxpy to solve the problem above
p = program(minimize(-log(det_rootn(V*diag(x)*V.T))),
[geq(x, 0.0), eq(sum(x), 1.0)])
p.solve(True)
np.testing.assert_array_almost_equal(
x.value, self.xd, tol_exp)
def test_problem_penalty(self):
"""
Compare cvxpy solutions to cvxopt ground truth
"""
from cvxpy import (matrix,variable,program,minimize,
sum,abs,norm2,log,square,zeros,max,
hstack,vstack)
m, n = self.m, self.n
A = matrix(self.A)
b = matrix(self.b)
# set tolerance to 5 significant digits
tol_exp = 5
# l1 approximation
x = variable(n)
p = program(minimize(sum(abs(A*x + b))))
p.solve(True)
np.testing.assert_array_almost_equal(x.value,self.x1,tol_exp)
# l2 approximation
x = variable(n)
p = program(minimize(norm2(A*x + b)))
p.solve(True)
np.testing.assert_array_almost_equal(x.value,self.x2,tol_exp)
# Deadzone approximation - implementation is currently ugly (need max along axis)
x = variable(n)
Axbm = abs(A*x+b)-0.5
Axbm_deadzone = vstack([max(hstack((Axbm[i,0],0.0))) for i in range(m)])
p = program(minimize(sum(Axbm_deadzone)))
p.solve(True)
obj_dz_cvxpy = np.sum(np.max([np.abs(A*x.value+b)-0.5,np.zeros((m,1))],axis=0))
np.testing.assert_array_almost_equal(obj_dz_cvxpy,self.obj_dz,tol_exp)
# Log barrier
x = variable(n)
p = program(minimize(-sum(log(1.0-square(A*x + b)))))
p.solve(True)
np.testing.assert_array_almost_equal(x.value,self.cxlb,tol_exp)
def make_KKT_lp(self,p,filename):
x_idx = dict()
for x in self.X:
x_idx[x] = len(x_idx)
y_idx = dict()
for y in self.Y:
y_idx[y] = len(y_idx)
z_idx = dict()
for z in self.Z:
z_idx[z] = len(z_idx)
p_yz = marginal_yz(p)
filecontent = ""
filecontent += "Minimize\n"
filecontent += "Obj: t\n"
filecontent += "Subject To\n"
for x in self.X:
for y in self.Y:
for z in self.Z:
lhs = ""
lhs += " lambda"+str(x_idx[x])+"_"+str(y_idx[y])
lhs += " + "
lhs += " mu"+str(x_idx[x])+"_"+str(z_idx[z])
if (x,y,z) in p.keys() and p[x,y,z] > 0:
# equation
p_xzy = p[x,y,z]
rhs = -1000*log(p_xzy/p_yz[y,z]) # >= 0
filecontent += "p("+str(x_idx[x])+","+str(y_idx[y])+","+str(z_idx[z])+"): "+lhs+" -t <= "+str(rhs)+"\n"
filecontent += "p("+str(x_idx[x])+","+str(y_idx[y])+","+str(z_idx[z])+"): "+lhs+" +t >= "+str(rhs)+"\n"
else:
# inequality
if (y,z) in p_yz.keys() and p_yz[y,z] > 0: rhs = 1.e100
else: rhs = 0
filecontent += "p("+str(x_idx[x])+","+str(y_idx[y])+","+str(z_idx[z])+"): "+lhs+" +t >= "+str(rhs)+"\n"
#^ for
#^ for
#^ for
filecontent += "END\n"
print("Writing KKT system to file ",filename)
with open(filename, 'w') as thefile:
thefile.write(filecontent)
def cvxoptimize(c, A, k, *args, **kwargs):
"""Interface to the CVXOPT solver
Definitions
-----------
"[a,b] array of floats" indicates array-like data with shape [a,b]
n is the number of monomials in the gp
m is the number of variables in the gp
p is the number of posynomials in the gp
Arguments
---------
c : floats array of shape n
Coefficients of each monomial
A : floats array of shape (m,n)
Exponents of the various free variables for each monomial.
k : ints array of shape n
number of monomials (columns of F) present in each constraint
Returns
-------
dict
Contains the following keys
"success": bool
"objective_sol" float
Optimal value of the objective
"primal_sol": floats array of size m
Optimal value of free variables. Note: not in logspace.
"dual_sol": floats array of size p
Optimal value of the dual variables, in logspace.
"""
gpsolver = gp if cvxopt_version >= "1.1.8" else gp118
# above use of gp118 is a local hack for windows
# until Python (x,y) updates their cvxopt version
g = log(matrix(c))
F = spmatrix(A.data, A.row, A.col, tc='d')
solution = gpsolver(k, F, g, *args, **kwargs)
return dict(status=solution['status'],
primal=solution['x'],
la=solution['znl'])
def check_KKT_sol(self,p,why):
p_yz = marginal_yz(p)
viol = -1.
for x in self.X:
for y in self.Y:
for z in self.Z:
try: idx_xy = self.marg_of_idx.index((x,y,None))
except ValueError: idx_xy = None
try: idx_xz = self.marg_of_idx.index((x,None,z))
except ValueError: idx_xz = None
if idx_xy == None: lambda_xy = None
else: lambda_xy = why[idx_xy]
if idx_xz == None: mu_xz = None
else: mu_xz = why[idx_xz]
if (x,y,z) in p.keys() and p[x,y,z] > 0:
# equation
p_xzy = p[x,y,z]
rhs = -log(p_xzy/p_yz[y,z]) # >= 0
viol = max(viol, abs( lambda_xy + mu_xz - rhs ) )
else:
# inequality
if (y,z) in p_yz.keys() and p_yz[y,z] > 0:
if lambda_xy==None or mu_xz==None:
pass
else:
rhs = 1.e400
viol = max(viol, rhs - (lambda_xy + mu_xz) )
else:
rhs = 0.
viol = max(viol, rhs - (lambda_xy + mu_xz) )
# if
#^ for z
#^ for y
#^ for x
return viol
def F(x = None, z = None):
if x is None:
return 0, matrix(0.0, (n,1))
if max(abs(x)) >= 1.0:
return None
r = - b
blas.gemv(A, x, r, beta = -1.0)
w = x**2
f = 0.5 * blas.nrm2(r)**2 - sum(log(1-w))
gradf = div(x, 1.0 - w)
blas.gemv(A, r, gradf, trans = 'T', beta = 2.0)
if z is None:
return f, gradf.T
else:
def Hf(u, v, alpha = 1.0, beta = 0.0):
"""
v := alpha * (A'*A*u + 2*((1+w)./(1-w)).*u + beta *v
"""
v *= beta
v += 2.0 * alpha * mul(div(1.0+w, (1.0-w)**2), u)
blas.gemv(A, u, r)
blas.gemv(A, r, v, alpha = alpha, beta = 1.0, trans = 'T')
return f, gradf.T, Hf
#A = matrix([[1, 2, 3]]) n = 1000 A = matrix(linspace(1,n,num=n)) #print A n = A.size[0] print n eps = 1.0 F = matrix(np.vstack([matlib.eye(n)*(-2), matlib.eye(n)])) #print F #print type(F) g = log(matrix(np.vstack([A, matlib.ones((n,1))*eps/n]) )) #print g #print type(g) K = [n, n] #x1, x2, x3 = exp( solvers.gp(K, F, g)['x'] ) #print "Solution (x1,x2,x3) =", x1, x2, x3 start_time = time.clock() x = exp( solvers.gp(K, F, g)['x'] ) #print "Solution (x1,x2,x3) =", x print "time elapsed ",time.clock() - start_time
# The small GP of section 9.3 (Geometric programming).
from cvxopt import matrix, log, exp, solvers
Aflr = 1000.0
Awall = 100.0
alpha = 0.5
beta = 2.0
gamma = 0.5
delta = 2.0
F = matrix( [[-1., 1., 1., 0., -1., 1., 0., 0.],
[-1., 1., 0., 1., 1., -1., 1., -1.],
[-1., 0., 1., 1., 0., 0., -1., 1.]])
g = log( matrix( [1.0, 2/Awall, 2/Awall, 1/Aflr, alpha, 1/beta, gamma,
1/delta]) )
K = [1, 2, 1, 1, 1, 1, 1]
h, w, d = exp( solvers.gp(K, F, g)['x'] )
print("\n h = %f, w = %f, d = %f.\n" %(h,w,d))
pylab.ylabel('Deadzone')
pylab.axis([-1.5, 1.5, 0, 20])
# Log barrier
#
# minimize -sum (log ( 1.0 - A*x+b)**2)
def F(x=None, z=None):
if x is None: return 0, matrix(0.0, (n,1))
y = A*x+b
if max(abs(y)) >= 1.0: return None
f = -sum(log(1.0 - y**2))
gradf = 2.0 * A.T * div(y, 1-y**2)
if z is None: return f, gradf.T
H = A.T * spdiag(2.0 * z[0] * div( 1.0+y**2, (1.0 - y**2)**2 )) * A
return f, gradf.T, H
xlb = solvers.cp(F)['x']
if pylab_installed:
pylab.subplot(414)
pylab.hist(A*xlb+b, numpy.array(bins))
nopts = 200
pylab.plot(xs, (8.0/1.5**2) * xs**2, 'g--')
xs2 = -0.99999 + (2*0.99999 /(nopts-1)) * matrix(list(range(nopts)))
pylab.plot(xs2, -3.0 * log(1.0 - abs(xs2)**2), 'g-')
pylab.ylabel('Log barrier')
pylab.xlabel('residual')
pylab.axis([-1.5, 1.5, 0, 10])
pylab.show()
