def individual_smart_charge(start,
end,
energy,
version,
interval=1,
vehicleID=''):
t = end - start
if version == 'national':
b = copy.copy(baseLoad[start:end])
elif version == 'household':
b = households[vehicleID][start:end]
q = matrix(b)
A = matrix(1.0 / (2 * t_int), (1, t))
b = matrix([energy]) # amount of energy needed in.... kWh?
A3 = spdiag([-1] * t)
A4 = spdiag([1] * t)
G = sparse([A3, A4])
h = matrix([0.0] * t + [pMax] * t)
P = spdiag([1] * t)
sol = solvers.qp(P, q, G, h, A, b)
X = sol['x']
del b
return X
def _arrange_kernel(self):
Y = [2 * int(y == self.classes_[1]) - 1 for y in self.Y]
n_sample = len(self.Y)
ker_matrix = matrix(summation(self.KL))
YY = spdiag(Y)
solvers.options['show_progress'] = False
solvers.options['maxiters'] = self.max_iter
sol = solvers.qp(
2 * ((1.0 - self.lam) * YY * ker_matrix * YY +
spdiag([self.lam] * n_sample)), matrix([0.0] * n_sample),
-spdiag([1.0] * n_sample), matrix([0.0] * n_sample, (n_sample, 1)),
matrix([[float(y == +1) for y in Y],
[float(y == -1) for y in Y]]).T, matrix([[1.0] * 2],
(2, 1)))
if self.verbose:
print('[EasyMKL]')
print('optimization finished, #iter = %d' % sol['iterations'])
print('status of the solution: %s' % sol['status'])
print('objval: %.5f' % sol['primal objective'])
yg = sol['x'].T * YY
weights = [(yg * matrix(K) * yg.T)[0] for K in self.KL]
norm2 = sum(weights)
self.weights = np.array([w / norm2 for w in weights])
self.ker_matrix = summation(self.KL, self.weights)
return self.ker_matrix
def _arrange_kernel(self):
Y = [1 if y==self.classes_[1] else -1 for y in self.Y]
n_sample = len(self.Y)
ker_matrix = matrix(summation(self.KL))
YY = spdiag(Y)
KLL = (1.0-self.lam)*YY*ker_matrix*YY
LID = spdiag([self.lam]*n_sample)
Q = 2*(KLL+LID)
p = matrix([0.0]*n_sample)
G = -spdiag([1.0]*n_sample)
h = matrix([0.0]*n_sample,(n_sample,1))
A = matrix([[1.0 if lab==+1 else 0 for lab in Y],[1.0 if lab2==-1 else 0 for lab2 in Y]]).T
b = matrix([[1.0],[1.0]],(2,1))
solvers.options['show_progress'] = False
solvers.options['maxiters'] = self.max_iter
sol = solvers.qp(Q,p,G,h,A,b)
gamma = sol['x']
if self.verbose:
print ('[EasyMKL]')
print ('optimization finished, #iter = %d' % sol['iterations'])
print ('status of the solution: %s' % sol['status'])
print ('objval: %.5f' % sol['primal objective'])
yg = gamma.T * YY
weights = [(yg*matrix(K)*yg.T)[0] for K in self.KL]
norm2 = sum([w for w in weights])
self.weights = np.array([w / norm2 for w in weights])
ker_matrix = summation(self.KL, self.weights)
self.ker_matrix = ker_matrix
return ker_matrix
def _fit(self):
ker_matrix = matrix(self.arrange_kernel(self.X, self.Y, check=False))
self.ker_matrix = ker_matrix
n_sample = len(self.Y)
YY = spdiag(self.Y)
KLL = (1.0 - self.lam) * YY * ker_matrix * YY
LID = spdiag([self.lam] * n_sample)
Q = 2 * (KLL + LID)
p = matrix([0.0] * n_sample)
G = -spdiag([1.0] * n_sample)
h = matrix([0.0] * n_sample, (n_sample, 1))
A = matrix([[1.0 if lab == +1 else 0 for lab in self.Y],
[1.0 if lab2 == -1 else 0 for lab2 in self.Y]]).T
b = matrix([[1.0], [1.0]], (2, 1))
solvers.options['show_progress'] = False
solvers.options['maxiters'] = self.max_iter
sol = solvers.qp(Q, p, G, h, A, b)
self.gamma = sol['x']
if self.verbose:
print('[EasyMKL] - second step')
print('optimization finished, #iter = ', sol['iterations'])
print('status of the solution: ', sol['status'])
print('objval: ', sol['primal objective'])
self.is_fitted = True
bias = 0.5 * self.gamma.T * ker_matrix * YY * self.gamma
self.bias = bias
return self
def margin(K,Y):
"""evaluate the margin in a classification problem of examples in feature space.
If the classes are not linearly separable in feature space, then the
margin obtained is 0.
Note that it works only for binary tasks.
Parameters
----------
K : (n,n) ndarray,
the kernel that represents the data.
Y : (n) array_like,
the labels vector.
"""
check_K_Y(K,Y)
n = Y.shape[0]
YY = spdiag(list(Y))
P = 2*(YY*matrix(K)*YY)
p = matrix([0.0]*n)
G = -spdiag([1.0]*n)
h = matrix([0.0]*n)
A = matrix([[1.0 if Y[i]==+1 else 0 for i in range(n)],
[1.0 if Y[j]==-1 else 0 for j in range(n)]]).T
b = matrix([[1.0],[1.0]],(2,1))
solvers.options['show_progress']=False
sol = solvers.qp(P,p,G,h,A,b)
return np.sqrt(sol['primal objective'])/2.0#prendo la distanza dall'iperpiano
def F(W):
"""
Return a function f(x,y,z) that solves
[P , G' W^-1] [ux] [bx]
[G , -W ] [uy] = [bz]
"""
#d = spdiag(matrix(numpy.array(W['d'])))
#dinv= spdiag(matrix(numpy.array(W['di'])))
d = spdiag(W['d'])
dinv = spdiag(W['di'])
#KKT1 = d*( P * d + dinv )
KKT1 = d * P * d + spdiag(matrix(1.0, (2 * dim, 1)))
lapack.potrf(KKT1)
#raw_input('inputpppp')
def f(x, y, z):
uz = -d * (x + P * z)
#uz = matrix(numpy.linalg.solve(KKT1, uz)) # slow version
#lapack.gesv(KKT1,uz) # JZ: gesv have cond issue
lapack.potrs(KKT1, uz)
x[:] = matrix(-z - d * uz)
blas.copy(uz, z)
return f
def train(self, test_users=None):
self.model = {}
iset = set(range(self.n_items))
if test_users is None:
test_users = range(self.n_users)
for i, u in enumerate(test_users):
#if (i+1) % 100 == 0:
print "%d/%d" % (i + 1, len(test_users))
Xp_set = self.data.get_items(u)
Xn_set = iset - Xp_set
Z = co.spdiag([1.0 if i in Xp_set else -1.0 for i in iset])
K = 2 * (Z * self.X.T * self.X * Z)
I = co.spdiag([
self.lambda_p if i in Xp_set else self.lambda_n for i in iset
])
P = K + I
o = utc.zeroes_vec(self.n_items)
G = -utc.identity(self.n_items)
A = co.matrix([[1.0 if i in Xp_set else 0.0 for i in iset],
[1.0 if j in Xn_set else 0.0 for j in iset]]).T
b = co.matrix([1.0, 1.0])
P = co.sparse(P)
solver.options['show_progress'] = False
sol = solver.qp(P, o, G, o, A, b)
self.sol[u] = sol
self.model[u] = self.X.T * self.X * Z * sol['x']
# endfor
return self
def _fit(self, K, Y):
Ks = arrange_kernel(K, Y)
Ks = matrix(Ks)
K1 = (1.0 - self.D) * YY * Ks * YY + spdiag([self.D] * n)
#K2 = self.C * Ks * self.D
K2 = (1.0 - self.D) * self.C * Ks * self.D + spdiag(
[self.D] * n) * self.C
P = 2 * matrix([[
K1[i, j] if i < n and j < n else
K2[i - n, j - n] if i >= n and j >= n else 0.0
for i in range(2 * n)
] for j in range(2 * n)])
q = matrix([0.0 for i in range(2 * n)])
h = matrix([0.0] * (2 * n), (2 * n, 1))
G = -spdiag([1 for i in range(2 * n)])
A = matrix(
[[1.0 if i < n and Y[i] == +1 else 0.0 for i in range(2 * n)],
[1.0 if i < n and Y[i] == -1 else 0.0 for i in range(2 * n)],
[1.0 if i >= n else 0 for i in range(2 * n)]]).T
b = matrix([1.0, 1.0, 1.0])
solvers.options['show_progress'] = False
solvers.options['maxiters'] = 200
sol = solvers.qp(P, q, G, h, A, b)
x = sol['x']
self.gamma = matrix(x[:n])
self.alpha = matrix(x[n:2 * n])
self.Y = Y
return self
def solve(self):
'''
"Solves" minimization problem using epigraph linear program
formulation.
'''
A, y, x_dim, y_dim = self.A, self.y, self.x_dim, self.y_dim
A = cvxopt.sparse(cvxopt.matrix(A))
I_t = cvxopt.spdiag(cvxopt.matrix(ones(y_dim)))
I_x = cvxopt.spdiag(cvxopt.matrix(ones(x_dim)))
Z = cvxopt.spmatrix([], [], [], size=(x_dim, y_dim))
A = cvxopt.sparse([
[A, -A, -I_x],
[-I_t, -I_t, Z]
]) # Sparse block matrix in COLUMN major order...for some reason
y = cvxopt.matrix(y)
z = cvxopt.matrix(zeros((x_dim, 1)))
one = cvxopt.matrix(ones((y_dim, 1)))
y = cvxopt.matrix([y, -y, z])
c = cvxopt.matrix([z, one])
result = cvxopt.solvers.lp(c, A, y, solver='glpk')
self.result = result
return result['status']
def _arrange_kernel(self):
Y = [1 if y == self.classes_[1] else -1 for y in self.Y]
n_sample = len(self.Y)
ker_matrix = matrix(summation(self.KL))
YY = spdiag(Y)
KLL = (1.0 - self.lam) * YY * ker_matrix * YY
LID = spdiag([self.lam] * n_sample)
Q = 2 * (KLL + LID)
p = matrix([0.0] * n_sample)
G = -spdiag([1.0] * n_sample)
h = matrix([0.0] * n_sample, (n_sample, 1))
A = matrix([[1.0 if lab == +1 else 0 for lab in Y],
[1.0 if lab2 == -1 else 0 for lab2 in Y]]).T
b = matrix([[1.0], [1.0]], (2, 1))
solvers.options['show_progress'] = False
solvers.options['maxiters'] = self.max_iter
sol = solvers.qp(Q, p, G, h, A, b)
gamma = sol['x']
if self.verbose:
print('[EasyMKL]')
print('optimization finished, #iter = {}', sol['iterations'])
print('status of the solution: {}', sol['status'])
print('objval: {}', sol['primal objective'])
yg = gamma.T * YY
weights = [(yg * matrix(K) * yg.T)[0] for K in self.KL]
norm2 = sum([w for w in weights])
self.weights = np.array([w / norm2 for w in weights])
ker_matrix = summation(self.KL, self.weights)
self.ker_matrix = ker_matrix
return ker_matrix
def margin(K,Y):
"""evaluate the margin in a classification problem of examples in feature space.
If the classes are not linearly separable in feature space, then the
margin obtained is 0.
Note that it works only for binary tasks.
Parameters
----------
K : (n,n) ndarray,
the kernel that represents the data.
Y : (n) array_like,
the labels vector.
"""
K, Y = check_K_Y(K,Y,binary=True)
n = Y.shape[0]
Y = [1 if y==Y[0] else -1 for y in Y]
YY = spdiag(Y)
P = 2*(YY*matrix(K)*YY)
p = matrix([0.0]*n)
G = -spdiag([1.0]*n)
h = matrix([0.0]*n)
A = matrix([[1.0 if Y[i]==+1 else 0 for i in range(n)],
[1.0 if Y[j]==-1 else 0 for j in range(n)]]).T
b = matrix([[1.0],[1.0]],(2,1))
solvers.options['show_progress']=False
sol = solvers.qp(P,p,G,h,A,b)
return np.sqrt(sol['primal objective'])
def _combine_kernels(self):
assert len(np.unique(self.Y)) == 2
Y = [1 if y == self.classes_[1] else -1 for y in self.Y]
n_sample = len(self.Y)
ker_matrix = matrix(self.func_form(self.KL))
YY = spdiag(Y)
#KLL = (1.0-self.lam)*YY*ker_matrix*YY
#LID = spdiag([self.lam]*n_sample)
#Q = 2*(KLL+LID)
Q = 2 * ((1.0 - self.lam) * YY * ker_matrix * YY +
spdiag([self.lam] * n_sample))
p = matrix([0.0] * n_sample)
G = -spdiag([1.0] * n_sample)
h = matrix([0.0] * n_sample, (n_sample, 1))
A = matrix([[1.0 if lab == +1 else 0 for lab in Y],
[1.0 if lab2 == -1 else 0 for lab2 in Y]]).T
b = matrix([[1.0], [1.0]], (2, 1))
solvers.options['show_progress'] = False
solvers.options['maxiters'] = 200
sol = solvers.qp(Q, p, G, h, A, b)
gamma = sol['x']
yg = gamma.T * YY
weights = [(yg * matrix(K) * yg.T)[0] for K in self.KL]
norm2 = sum([w for w in weights])
weights = np.array([w / norm2 for w in weights])
ker_matrix = self.func_form(self.KL, weights)
return Solution(
weights=weights,
objective=None,
ker_matrix=ker_matrix,
)
def train(self, test_users=None):
self.model = {}
iset = set(range(self.n_items))
if test_users is None:
test_users = range(self.n_users)
for i, u in enumerate(test_users):
#if (i+1) % 100 == 0:
print "%d/%d" %(i+1, len(test_users))
Xp_set = self.data.get_items(u)
Xn_set = iset - Xp_set
Z = co.spdiag([1.0 if i in Xp_set else -1.0 for i in iset])
K = 2 * (Z * self.X.T * self.X * Z)
I = co.spdiag([self.lambda_p if i in Xp_set else self.lambda_n for i in iset])
P = K + I
o = utc.zeroes_vec(self.n_items)
G = -utc.identity(self.n_items)
A = co.matrix([[1.0 if i in Xp_set else 0.0 for i in iset],
[1.0 if j in Xn_set else 0.0 for j in iset]]).T
b = co.matrix([1.0, 1.0])
P = co.sparse(P)
solver.options['show_progress'] = False
sol = solver.qp(P, o, G, o, A, b)
self.sol[u] = sol
self.model[u] = self.X.T * self.X * Z * sol['x']
# endfor
return self
def build_gy(self, dae):
"""Build line Jacobian matrix"""
if not self.n:
idx = range(dae.m)
dae.set_jac(Gy, 1e-6, idx, idx)
return
Vn = polar(1.0, dae.y[self.a])
Vc = mul(dae.y[self.v], Vn)
Ic = self.Y * Vc
diagVn = spdiag(Vn)
diagVc = spdiag(Vc)
diagIc = spdiag(Ic)
dS = self.Y * diagVn
dS = diagVc * conj(dS)
dS += conj(diagIc) * diagVn
dR = diagIc
dR -= self.Y * diagVc
dR = diagVc.H.T * dR
self.gy_store = sparse([[dR.imag(), dR.real()], [dS.real(),
dS.imag()]])
# rebuild = False
return sparse(self.gy_store)
def optimize(obj):
# constraints
# The equality constraint ensures the required amount of energy is delivered
A1 = matrix(0.0, (n, t * n))
A2 = matrix(0.0, (n, t * n))
b = matrix(0.0, (2 * n, 1))
for j in range(0, n):
b[j] = float(results[j][1])
for i in range(0, t):
A1[n * (t * j + i) + j] = float(timeInterval) / 60 # kWh -> kW
if i < results[j][0] or i > results[j][2]:
A2[n * (t * j + i) + j] = 1.0
A = sparse([A1, A2])
A3 = spdiag([-1] * (t * n))
A4 = spdiag([1] * (t * n))
# The inequality constraint ensures powers are positive and below a maximum
G = sparse([A3, A4])
h = []
for i in range(0, 2 * t * n):
if i < t * n:
h.append(0.0)
else:
h.append(pMax)
h = matrix(h)
# objective
if obj == 1:
q = []
for i in range(0, n):
for j in range(0, len(baseLoad)):
q.append(baseLoad[j])
q = matrix(q)
elif obj == 2:
q = matrix([0.0] * (t * n))
if obj == 3:
q = []
for i in range(0, n):
for j in range(0, len(baseLoad)):
q.append(baseLoad[j] - pv[j])
q = matrix(q)
if obj == 1 or obj == 2 or obj == 3:
I = spdiag([1] * t)
P = sparse([[I] * n] * n)
sol = solvers.qp(P, q, G, h, A, b)
X = sol['x']
return X
def arrange_kernel(self, X, Y, check=True):
if check:
self._input_checks(X, Y)
#if len(self.classes_) != 2:
# raise ValueError("The number of classes has to be 2; got ", len(self.classes_))
self.Y = [1 if y == self.classes_[1] else -1 for y in self.Y]
n_sample = len(self.Y)
ker_matrix = matrix(summation(self.K))
YY = spdiag(self.Y)
KLL = (1.0 - self.lam) * YY * ker_matrix * YY
#LID = matrix(np.diag([self.lam]*n_sample))
LID = spdiag([self.lam] * n_sample)
Q = 2 * (KLL + LID)
p = matrix([0.0] * n_sample)
G = -spdiag([1.0] * n_sample)
h = matrix([0.0] * n_sample, (n_sample, 1))
A = matrix([[1.0 if lab == +1 else 0 for lab in self.Y],
[1.0 if lab2 == -1 else 0 for lab2 in self.Y]]).T
b = matrix([[1.0], [1.0]], (2, 1))
solvers.options['show_progress'] = False
solvers.options['maxiters'] = self.max_iter
sol = solvers.qp(Q, p, G, h, A, b)
self.gamma = sol['x']
if self.verbose:
print('[EasyMKL] - first step')
print('optimization finished, #iter = ', sol['iterations'])
print('status of the solution: ', sol['status'])
print('objval: ', sol['primal objective'])
# Bias for classification:
#bias = 0.5 * self.gamma.T * ker_matrix * YY * self.gamma
#self.bias = bias
# Weights evaluation:
#yg = mul(self.gamma.T,matrix(self.Y).T)
yg = self.gamma.T * YY
self.weights = []
for kermat in self.K:
b = yg * matrix(kermat) * yg.T
self.weights.append(b[0])
norm2 = sum([w for w in self.weights])
#norm2 = sum(self.weights)
self.weights = [w / norm2 for w in self.weights]
if self.tracenorm:
for idx, val in enumerate(self.traces):
self.weights[idx] = self.weights[idx] / val
ker_matrix = summation(self.K, self.weights)
self.ker_matrix = ker_matrix
return ker_matrix
def compute_p(self, mu_r, mu_psi):
"""
min { 1/2 c.T * P * c + q * c }
Build P matrix
"""
p = []
polynomial_r = np.ones(self.order + 1)
for i in range(0, self.k_r):
polynomial_r = np.polyder(polynomial_r)
polynomial_psi = np.ones(self.order + 1)
for i in range(0, self.k_psi):
polynomial_psi = np.polyder(polynomial_psi)
for i in range(0, self.m):
p_x = np.zeros((self.order + 1, self.order + 1))
p_y = np.zeros((self.order + 1, self.order + 1))
p_z = np.zeros((self.order + 1, self.order + 1))
p_psi = np.zeros((self.order + 1, self.order + 1))
for j in range(0, self.order + 1):
for k in range(j, self.order + 1):
# position
if j <= len(polynomial_r) - 1 and k <= len(polynomial_r) - 1:
order_t_r = ((self.order - self.k_r - j) + (self.order - self.k_r - k))
if j == k:
p_x[j, k] = np.power(polynomial_r[j], 2) / (order_t_r + 1)
p_y[j, k] = np.power(polynomial_r[j], 2) / (order_t_r + 1)
p_z[j, k] = np.power(polynomial_r[j], 2) / (order_t_r + 1)
else:
p_x[j, k] = 2 * polynomial_r[j] * polynomial_r[k] / (order_t_r + 1)
p_y[j, k] = 2 * polynomial_r[j] * polynomial_r[k] / (order_t_r + 1)
p_z[j, k] = 2 * polynomial_r[j] * polynomial_r[k] / (order_t_r + 1)
# yaw
if j <= len(polynomial_psi) - 1 and k <= len(polynomial_psi) - 1:
order_t_psi = ((self.order - self.k_psi - j) + (self.order - self.k_psi - k))
if j == k:
p_psi[j, k] = np.power(polynomial_psi[j], 2) / (order_t_psi + 1)
else:
p_psi[j, k] = 2 * polynomial_psi[j] * polynomial_psi[k] / (order_t_psi + 1)
p_x = matrix(p_x) * mu_r
p_y = matrix(p_y) * mu_r
p_z = matrix(p_z) * mu_r
p_psi = matrix(p_psi) * mu_psi
if i == 0:
p = spdiag([p_x, p_y, p_z, p_psi])
else:
p = spdiag([p, p_x, p_y, p_z, p_psi])
p = matrix(p)
p = p + matrix(np.transpose(p))
p = p * 0.5
return p
def d2Ibr_dV2(Ybr, V, lam):
""" Computes 2nd derivatives of complex branch current w.r.t. voltage.
"""
nb = len(V)
diaginvVm = spdiag(div(matrix(1.0, (nb, 1)), abs(V)))
Haa = spdiag(mul(-(Ybr.T * lam), V))
Hva = -1j * Haa * diaginvVm
Hav = Hva
Hvv = spmatrix([], [], [], (nb, nb))
return Haa, Hav, Hva, Hvv
def d2Ibr_dV2(Ybr, V, lam):
""" Computes 2nd derivatives of complex branch current w.r.t. voltage.
"""
nb = len(V)
diaginvVm = spdiag(div(matrix(1.0, (nb, 1)), abs(V)))
Haa = spdiag(mul(-(Ybr.T * lam), V))
Hva = -1j * Haa * diaginvVm
Hav = Hva
Hvv = spmatrix([], [], [], (nb, nb))
return Haa, Hav, Hva, Hvv
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 margin(K,Y):
n = Y.shape[0]
YY = spdiag(list(Y))
P = 2*(YY*matrix(K)*YY)
p = matrix([0.0]*n)
G = -spdiag([1.0]*n)
h = matrix([0.0]*n)
A = matrix([[1.0 if Y[i]==+1 else 0 for i in range(n)],
[1.0 if Y[j]==-1 else 0 for j in range(n)]]).T
b = matrix([[1.0],[1.0]],(2,1))
solvers.options['show_progress']=False
sol = solvers.qp(P,p,G,h,A,b)
return np.sqrt(sol['primal objective'])/2.0#prendo la distanza dall'iperpiano
def radius(K, lam=0, init_sol=None):
n = K.shape[0]
K = matrix(K)
P = 2 * ((1 - lam) * K + spdiag([lam] * n))
p = -matrix([K[i, i] for i in range(n)])
G = -spdiag([1.0] * n)
h = matrix([0.0] * n)
A = matrix([1.0] * n).T
b = matrix([1.0])
solvers.options['show_progress'] = False
sol = solvers.qp(P, p, G, h, A, b, initvals=init_sol)
radius2 = (-p.T * sol['x'])[0] - (sol['x'].T * K * sol['x'])[0]
return sol, radius2
def d2ASbr_dV2(dSbr_dVa, dSbr_dVm, Sbr, Cbr, Ybr, V, lam):
""" Computes 2nd derivatives of |complex power flow|**2 w.r.t. V.
"""
diaglam = spdiag(lam)
diagSbr_conj = spdiag(conj(Sbr))
Saa, Sav, Sva, Svv = d2Sbr_dV2(Cbr, Ybr, V, diagSbr_conj * lam)
Haa = 2 * ( Saa + dSbr_dVa.T * diaglam * conj(dSbr_dVa) ).real()
Hva = 2 * ( Sva + dSbr_dVm.T * diaglam * conj(dSbr_dVa) ).real()
Hav = 2 * ( Sav + dSbr_dVa.T * diaglam * conj(dSbr_dVm) ).real()
Hvv = 2 * ( Svv + dSbr_dVm.T * diaglam * conj(dSbr_dVm) ).real()
return Haa, Hav, Hva, Hvv
def d2AIbr_dV2(dIbr_dVa, dIbr_dVm, Ibr, Ybr, V, lam):
""" Computes 2nd derivatives of |complex current|**2 w.r.t. V.
"""
diaglam = spdiag(lam)
diagIbr_conj = spdiag(conj(Ibr))
Iaa, Iav, Iva, Ivv = d2Ibr_dV2(Ybr, V, diagIbr_conj * lam)
Haa = 2 * ( Iaa + dIbr_dVa.T * diaglam * conj(dIbr_dVa) ).real()
Hva = 2 * ( Iva + dIbr_dVm.T * diaglam * conj(dIbr_dVa) ).real()
Hav = 2 * ( Iav + dIbr_dVa.T * diaglam * conj(dIbr_dVm) ).real()
Hvv = 2 * ( Ivv + dIbr_dVm.T * diaglam * conj(dIbr_dVm) ).real()
return Haa, Hav, Hva, Hvv
def d2AIbr_dV2(dIbr_dVa, dIbr_dVm, Ibr, Ybr, V, lam):
""" Computes 2nd derivatives of |complex current|**2 w.r.t. V.
"""
diaglam = spdiag(lam)
diagIbr_conj = spdiag(conj(Ibr))
Iaa, Iav, Iva, Ivv = d2Ibr_dV2(Ybr, V, diagIbr_conj * lam)
Haa = 2 * (Iaa + dIbr_dVa.T * diaglam * conj(dIbr_dVa)).real()
Hva = 2 * (Iva + dIbr_dVm.T * diaglam * conj(dIbr_dVa)).real()
Hav = 2 * (Iav + dIbr_dVa.T * diaglam * conj(dIbr_dVm)).real()
Hvv = 2 * (Ivv + dIbr_dVm.T * diaglam * conj(dIbr_dVm)).real()
return Haa, Hav, Hva, Hvv
def d2ASbr_dV2(dSbr_dVa, dSbr_dVm, Sbr, Cbr, Ybr, V, lam):
""" Computes 2nd derivatives of |complex power flow|**2 w.r.t. V.
"""
diaglam = spdiag(lam)
diagSbr_conj = spdiag(conj(Sbr))
Saa, Sav, Sva, Svv = d2Sbr_dV2(Cbr, Ybr, V, diagSbr_conj * lam)
Haa = 2 * (Saa + dSbr_dVa.T * diaglam * conj(dSbr_dVa)).real()
Hva = 2 * (Sva + dSbr_dVm.T * diaglam * conj(dSbr_dVa)).real()
Hav = 2 * (Sav + dSbr_dVa.T * diaglam * conj(dSbr_dVm)).real()
Hvv = 2 * (Svv + dSbr_dVm.T * diaglam * conj(dSbr_dVm)).real()
return Haa, Hav, Hva, Hvv
def margin(K, Y, init_sol=None):
n = len(Y)
YY = spdiag(list(Y))
P = 2 * (YY * matrix(K) * YY)
p = matrix([0.0] * n)
G = -spdiag([1.0] * n)
h = matrix([0.0] * n)
A = matrix([[1.0 if Y[i] == +1 else 0 for i in range(n)],
[1.0 if Y[j] == -1 else 0 for j in range(n)]]).T
b = matrix([[1.0], [1.0]], (2, 1))
solvers.options['show_progress'] = False
sol = solvers.qp(P, p, G, h, A, b, initval=init_sol,
solver='glpk') if init_sol else solvers.qp(
P, p, G, h, A, b)
return np.sqrt(sol['primal objective']), sol['x']
def penaltyQuadraticModel():
Q = P.T + Z.T * Z + C.T * C
p = U - 2 * Z.T * z - 2 * C.T * c
#Variables are between zero and one
G = sparse([
spdiag([-1 for r in range(D.numVars)]),
spdiag([1 for r in range(D.numVars)])
])
h = matrix([[0.0] * D.numVars, [1.0] * D.numVars], (2 * D.numVars, 1), 'd')
A = None
b = None
return (Q, p, G, h, A, b)
def build_path_qp(self, s, mode=DELAY_MIN):
q = [self.wire_cap / (self.gate_res * s[i]) + self.wire_res * self.gate_cap * s[i+1] \
for i in xrange(self.n - 1)]
q = cvx.matrix(q)
p = [0.5 * self.wire_res * self.wire_cap for i in xrange(self.n - 1)]
P = cvx.spdiag(p)
G = -cvx.spdiag([1. for i in xrange(self.n - 1)])
h = cvx.matrix([0. for i in xrange(self.n - 1)])
A = cvx.matrix([1. for i in xrange(self.n - 1)]).T
b = cvx.matrix([self.length])
return P, q, G, h, A, b
def margin(K, YY, lam=0, init_sol=None):
n = K.shape[0]
K = matrix(K)
lambdaDiag = spdiag([lam] * n)
P = 2 * ((1 - lam) * (YY * K * YY) + lambdaDiag)
p = matrix([0.0] * n)
G = -spdiag([1.0] * n)
h = matrix([0.0] * n)
A = matrix([[1.0 if YY[i, i] == +1 else 0 for i in range(n)],
[1.0 if YY[j, j] == -1 else 0 for j in range(n)]]).T
b = matrix([[1.0], [1.0]], (2, 1))
solvers.options['show_progress'] = False
sol = solvers.qp(P, p, G, h, A, b, initvals=init_sol)
margin2 = sol['dual objective'] - (sol['x'].T * lambdaDiag * sol['x'])[0]
return sol, margin2
def constrainedQuadraticModel():
Q = P.T
p = U
#Variables are between zero and one
G = sparse([
spdiag([-1 for r in range(D.numVars)]),
spdiag([1 for r in range(D.numVars)])
])
h = matrix([[0.0] * D.numVars, [1.0] * D.numVars], (2 * D.numVars, 1), 'd')
A = extendSparse(Z, C, D.numVars)
b = extendMatrix(z, c)
return (Q, p, G, h, A, b)
def kkt_solver(W):
# Returns a function f(x, y, z) that solves
#
# [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]
# [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]
# [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]
# [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]
#
# On entry bx, bz are stored in x, z.
# On exit x, z contain the solution, with z scaled (W['di'] .* z is
# returned instead of z).
d1, d2 = W['d'][:m], W['d'][m:]
D = 4*(d1**2 + d2**2)**-1
A = P.T * cvxopt.spdiag(D) * P
cvxopt.lapack.potrf(A)
def func(x, y_unused, z):
#Ok, that y is not used
x[:n] += P.T * (cvxopt.mul(cvxopt.div(d2**2 - d1**2, d1**2 + d2**2), x[n:])
+ cvxopt.mul(.5*D, z[:m]-z[m:]))
cvxopt.lapack.potrs(A, x)
u = P*x[:n]
x[n:] = cvxopt.div(x[n:] - cvxopt.div(z[:m], d1**2) - cvxopt.div(z[m:], d2**2) +
cvxopt.mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2)
z[:m] = cvxopt.div(u-x[n:]-z[:m], d1)
z[m:] = cvxopt.div(-u-x[n:]-z[m:], d2)
return func
def radius(K):
"""evaluate the radius of the MEB (Minimum Enclosing Ball) of examples in
feature space.
Parameters
----------
K : (n,n) ndarray,
the kernel that represents the data.
Returns
-------
r : np.float64,
the radius of the minimum enclosing ball of examples in feature space.
"""
check_squared(K)
n = K.shape[0]
P = 2 * matrix(K)
p = -matrix([K[i,i] for i in range(n)])
G = -spdiag([1.0] * n)
h = matrix([0.0] * n)
A = matrix([1.0] * n).T
b = matrix([1.0])
solvers.options['show_progress']=False
sol = solvers.qp(P,p,G,h,A,b)
return np.sqrt(abs(sol['primal objective']))
def construct_const_matrix(x_dim, D):
# --------------------------
#| 0 0
#| 0 I
#| D-eps_I 0
#| 0 D^{-1}
#| I 0
#| 0 I
#| 0
# --------------------------
# Construct B1
H1 = zeros((2 * x_dim, 2 * x_dim))
H1[x_dim:, x_dim:] = eye(x_dim)
H1 = matrix(H1)
# Construct B2
eps = 1e-4
H2 = zeros((2 * x_dim, 2 * x_dim))
H2[:x_dim, :x_dim] = D - eps * D
H2[x_dim:, x_dim:] = pinv(D)
H2 = matrix(H2)
# Construct B3
H3 = eye(2 * x_dim)
H3 = matrix(H3)
# Construct B5
H4 = zeros((x_dim, x_dim))
H4 = matrix(H4)
# Construct Block matrix
H = spdiag([H1, H2, H3, H4])
hs = [H]
return hs
def make_initial_solution(self, orig_q_0=None):
# make initial solution q_0
self.p_0 = dict()
if orig_q_0==None: # no initial solution provided. I'm gonna get some "minimum entropy" thing
if self.expensive_initial_solution:
# initial solution is the one minimizing || p ||^2
N = len(self.var_idx)
Q = 2*spdiag( matrix( 1., (N,1), 'd' ) )
q = matrix( 0., (N,1), 'd' )
qp_solver = solvers.qp(Q, q, self.G, self.h, self.A, self.b)
# for xyz,i in self.var_idx.items():
# self.p_0[xyz] = max(0, qp_solver['x'][i] )
print("Min 2-norm: ",list( qp_solver['x'] ))
else:
for xyz in self.var_idx.keys():
self.p_0[xyz] = 1.
else:
for xyz in self.var_idx.keys():
if xyz in orig_q_0:
self.p_0[xyz] = orig_q_0[xyz]
else:
self.p_0[xyz] = 0.
def constraints(self):
# construct the constraints for the attack routing problem
N = self.N
u = np.tile(range(N), N)
v = np.repeat(range(N),N)
w = np.array(range(N*N))
# build constraint matrix
A1 = spmatrix(np.repeat(self.nu, N), u, w, (N, N*N))
A2 = -spmatrix(np.repeat(self.nu + self.phi, N), v, w, (N, N*N))
I = np.array(range(N))
J = I + np.array(range(N)) * N
A3 = spmatrix(self.phi, I, J, (N, N*N))
tmp = np.dot(np.diag(self.phi), self.delta).transpose()
A4 = matrix(np.repeat(tmp, N, axis=1))
A5 = -spmatrix(tmp.flatten(), v, np.tile(J, N), (N, N*N))
A6 = A1 + A2 + A3 + A4 + A5
I = np.array([0]*(N-1))
J = np.array(range(self.k)+range((self.k+1),N)) + N * self.k
A7 = spmatrix(1., I, J, (1, N*N))
A = sparse([[A6, -A6, A7, -A7, -spdiag([1.]*(N*N))]])
tmp = np.zeros(2*N + 2 + N*N)
tmp[2*N] = 1.
tmp[2*N + 1] = -1.
b = matrix(tmp)
return b, A
def solver(graph=None, update=False, full=False, data=None, SO=False):
"""Find the UE link flow
Parameters
----------
graph: graph object
update: if update==True: update link flows and link,path delays in graph
full: if full=True, also return x (link flows per OD pair)
data: (Aeq, beq, ffdelays, parameters, type) from get_data(graph)
"""
if data is None: data = get_data(graph)
Aeq, beq, ffdelays, pm, type = data
n = len(ffdelays)
p = Aeq.size[1]/n
A, b = spmatrix(-1.0, range(p*n), range(p*n)), matrix(0.0, (p*n,1))
if type == 'Polynomial':
if not SO: pm = pm * spdiag([1.0/(j+2) for j in range(pm.size[1])])
def F(x=None, z=None): return objective_poly(x, z, matrix([[ffdelays], [pm]]), p)
if type == 'Hyperbolic':
if SO:
def F(x=None, z=None): return objective_hyper_SO(x, z, matrix([[ffdelays-div(pm[:,0],pm[:,1])], [pm]]), p)
else:
def F(x=None, z=None): return objective_hyper(x, z, matrix([[ffdelays-div(pm[:,0],pm[:,1])], [pm]]), p)
dims = {'l': p*n, 'q': [], 's': []}
x = solvers.cp(F, G=A, h=b, A=Aeq, b=beq, kktsolver=get_kktsolver(A, dims, Aeq, F))['x']
linkflows = matrix(0.0, (n,1))
for k in range(p): linkflows += x[k*n:(k+1)*n]
if update:
logging.debug('Update link flows, delays in Graph.'); graph.update_linkflows_linkdelays(linkflows)
logging.debug('Update path delays in Graph.'); graph.update_pathdelays()
if full: return linkflows, x
return linkflows
def inv_solver(xs, ps, xmax):
"""Optimization w.r.t. (Q,r)
Parameters
----------
xs: list of (optimal) demand vectors
ps: list of price vectors
xmax: maximum demand vector (for each product)
"""
n, N = len(xs[0]), len(xs)
# constraint Q <= 0
G, h = conic_constraint(n)
# constraint Q*xmax + r >= 0
A = -linear_constraint(xmax)
b = matrix(0., (n,1))
# constraints Q*x^j + r <= p^j
for j in range(N):
A = matrix([A, linear_constraint(xs[j])])
b = matrix([b, matrix(ps[j])])
# constraint r >= 0
tmp = matrix([[matrix(0., (n, (n*(n+1))/2))], [-spdiag([1.]*n)]])
A = matrix([A, tmp])
b = matrix([b, matrix(0., (n,1))])
# linear objective
c = linear_objective(xs)
x = solvers.sdp(c, A, b, G, h)['x']
Q, r = matrix(0., (n,n)), matrix(0., (n,1))
for i in range(n):
Q[i,i] = x[(n+1)*i-(i*(i+1))/2]
r[i] = x[(n*(n+1))/2+i]
for j in range(i+1,n):
Q[i,j] = x[n*i+j-(i*(i+1))/2]; Q[j,i] = Q[i,j]
return Q, r
def constraints(self):
# construct the constraints for the attack routing problem
N = self.N
u = np.tile(range(N), N)
v = np.repeat(range(N), N)
w = np.array(range(N * N))
# build constraint matrix
A1 = spmatrix(np.repeat(self.nu, N), u, w, (N, N * N))
A2 = -spmatrix(np.repeat(self.nu + self.phi, N), v, w, (N, N * N))
I = np.array(range(N))
J = I + np.array(range(N)) * N
A3 = spmatrix(self.phi, I, J, (N, N * N))
tmp = np.dot(np.diag(self.phi), self.delta).transpose()
A4 = matrix(np.repeat(tmp, N, axis=1))
A5 = -spmatrix(tmp.flatten(), v, np.tile(J, N), (N, N * N))
A6 = A1 + A2 + A3 + A4 + A5
I = np.array([0] * (N - 1))
J = np.array(range(self.k) + range((self.k + 1), N)) + N * self.k
A7 = spmatrix(1., I, J, (1, N * N))
A = sparse([[A6, -A6, A7, -A7, -spdiag([1.] * (N * N))]])
tmp = np.zeros(2 * N + 2 + N * N)
tmp[2 * N] = 1.
tmp[2 * N + 1] = -1.
b = matrix(tmp)
return b, A
def F(x = None, z = None):
# Case 1
if x is None and z is None:
return (0, x_0)
# Case 2 and 3
else:
w = x[:n]
s = x[n:]
abs_w = abs(w)
f = scale * (sum(abs_w**q) / q + C * sum(s))
Df_w = sign(w) * abs_w**(q - 1.0)
Df_s = C * ones((m, 1))
Df = scale * vstack((Df_w, Df_s))
Df = matrix(Df.reshape((1, n + m)))
# Case 2 only
if z is None:
return (f, Df)
# Case 3 only
else:
try:
H_w = scale * z * (q - 1.0) * abs_w**(q - 2.0)
except (ValueError, RuntimeWarning):
#print 'abs_w:', abs_w
#print 'power:', (q - 2.0)
H_w = scale * z * (q - 1.0) * (abs_w + 1e-20)**(q - 2.0)
H_s = zeros((m, 1))
diag_H = matrix(vstack((H_w, H_s)))
H = spdiag(diag_H)
return (f, Df, H)
def solve_fw_tap(A, b, times, caps, I, K, maxiter=100, tol = 0.001):
h = matrix(0., (I*K, 1))
G = spdiag([-1.]*I*K)
block = build_block_matrix(I, K)
reverse_block = reverse_block_matrix(I, K)
#start iteration
#flows = matrix(0.0, (I*K,1))
#start with a normal lp
times_expanded = reverse_block * times
print 'computing first feasible flow'
flows = solvers.lp(times_expanded, G, h, A = A, b = b, solver='mosek', options={"mosek":{iparam.log:0}})['x']
for k in range(maxiter):
print 'iter', k
#compute gradient
sum_flows = block * flows
print 'flows', max(sum_flows),min(sum_flows),max(flows), min(flows)
Df = vdf_derivative(times, caps, sum_flows)
Df = reverse_block * Df
print 'Df', max(Df), min(Df)
#solve affineminimization subproblem -> xd
lpsol = solvers.lp(Df, G, h, A = A, b = b, solver='mosek', options={"mosek":{iparam.log:0}})
xd = lpsol['x']
print lpsol['status']
if lpsol['status'] != 'optimal':
return {'flows':flows, 'grad':Df, 'G':G, 'h':h}
#update
bound = (Df.T * (flows - xd))[0]
step = (2. / (k + 2.)) * (xd - flows)
print 'diff', np.sqrt(step.T * step)[0], bound
if abs(bound) < tol:
print "finished after " + str(k) + " iterations"
break
flows = flows + step
return flows
def ty_solver(data, l, w_toll, full=False):
"""Solves the block (t,y) of the toll pricing model
Parameters
----------
data: Aeq, beq, ffdelays, coefs
l: linkflows
w_toll: weight on the toll collected
full: if True, return the whole solution
"""
Aeq, beq, ffdelays, coefs = data
delays = compute_delays(l, ffdelays, coefs)
n = len(l)
p = Aeq.size[1]/n
m = Aeq.size[0]/p
c = matrix([(1.0+w_toll)*l, -beq])
I = spdiag([1.0]*n)
G1 = matrix([-I]*(p+1))
G2 = matrix([Aeq.T, matrix(0.0, (n,p*m))])
G = matrix([[G1],[G2]])
h = [delays]*p
h.append(matrix(0.0, (n,1)))
h = matrix(h)
if full: return solvers.lp(c,G,h)['x']
return solvers.lp(c,G,h)['x'][range(n)]
def Fkkt(W):
# Returns a function f(x, y, z) that solves
#
# [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]
# [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]
# [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]
# [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]
#
# On entry bx, bz are stored in x, z.
# On exit x, z contain the solution, with z scaled (W['di'] .* z is
# returned instead of z).
d1, d2 = W['d'][:m], W['d'][m:]
D = 4*(d1**2 + d2**2)**-1
A = P.T * spdiag(D) * P
lapack.potrf(A)
def f(x, y, z):
x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:])
+ mul( .5*D, z[:m]-z[m:] ) )
lapack.potrs(A, x)
u = P*x[:n]
x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) +
mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )
z[:m] = div(u-x[n:]-z[:m], d1)
z[m:] = div(-u-x[n:]-z[m:], d2)
return f
def compute_global_min_portfolio(mu_vec, sigma_mat, shorts=True):
solvers.options['show_progress'] = False
P = 2 * matrix(sigma_mat.values)
q = matrix(0., (len(sigma_mat), 1))
G = spdiag([-1. for i in range(len(sigma_mat))])
A = matrix(1., (1, len(sigma_mat)))
b = matrix(1.0)
if shorts == True:
h = matrix(1., (len(sigma_mat), 1))
else:
h = matrix(0., (len(sigma_mat), 1))
# print ('\nP\n\n{}\n\nq\n\n{}\n\nG\n\n{}\n\nh\n\n{}\n\nA\n\n{}\n\nb\n\n{}\n\n'.format(P,q,G,h,A,b))
# weights_vec = pd.DataFrame(np.array(solvers.qp(P, q, G, h, A, b)['x']),\
# index=sigma_mat.columns)
weights_vec = pd.Series(list(solvers.qp(P, q, G, h, A, b)['x']), index=sigma_mat.columns)
#
# compute portfolio expected returns and variance
#
# print ('*** Debug ***\n_Global Min Portfolio:\nmu_vec:\n', mu_vec, '\nsigma_mat:\n',
# sigma_mat, '\nweights:\n', weights_vec)
mu_p = compute_portfolio_mu(mu_vec, weights_vec)
sigma_p = compute_portfolio_sigma(sigma_mat, weights_vec)
return weights_vec, mu_p, sigma_p
def calc_state_matrix(self):
r"""
Return state matrix and store to ``self.As``.
Notes
-----
For systems with the form
.. math ::
T \dot{x} = f(x, y) \\
0 = g(x, y)
The state matrix is calculated from
.. math ::
A_s = T^{-1} (f_x - f_y * g_y^{-1} * g_x)
Returns
-------
cvxopt.matrix
state matrix
"""
system = self.system
gyx = matrix(system.dae.gx)
self.solver.linsolve(system.dae.gy, gyx)
Tfnz = system.dae.Tf + np.ones_like(system.dae.Tf) * np.equal(
system.dae.Tf, 0.0)
iTf = spdiag((1 / Tfnz).tolist())
self.As = matrix(iTf * (system.dae.fx - system.dae.fy * gyx))
return self.As
def Fkkt(W):
# Returns a function f(x, y, z) that solves
#
# [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]
# [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]
# [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]
# [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]
#
# On entry bx, bz are stored in x, z.
# On exit x, z contain the solution, with z scaled (W['di'] .* z is
# returned instead of z).
d1, d2 = W['d'][:m], W['d'][m:]
D = 4 * (d1**2 + d2**2)**-1
A = P.T * spdiag(D) * P
lapack.potrf(A)
def f(x, y, z):
x[:n] += P.T * (mul(div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) +
mul(.5 * D, z[:m] - z[m:]))
lapack.potrs(A, x)
u = P * x[:n]
x[n:] = div(
x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) +
mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2)
z[:m] = div(u - x[n:] - z[:m], d1)
z[m:] = div(-u - x[n:] - z[m:], d2)
return f
def radius(K):
"""evaluate the radius of the MEB (Minimum Enclosing Ball) of examples in
feature space.
Parameters
----------
K : (n,n) ndarray,
the kernel that represents the data.
Returns
-------
r : np.float64,
the radius of the minimum enclosing ball of examples in feature space.
"""
check_squared(K)
n = K.shape[0]
P = 2 * matrix(K)
p = -matrix([K[i,i] for i in range(n)])
G = -spdiag([1.0] * n)
h = matrix([0.0] * n)
A = matrix([1.0] * n).T
b = matrix([1.0])
solvers.options['show_progress']=False
sol = solvers.qp(P,p,G,h,A,b)
return np.sqrt(abs(sol['primal objective']))
def reset_Ac(self):
"""
Reset ``dae.Ac`` sparse matrix for disabled equations
due to hard_limit and anti_windup limiters.
:return: None
"""
if self.ac_reset is False:
return
mn = self.m + self.n
x = index(aandb(self.zxmin, self.zxmax), 0.)
y = [i + self.n for i in index(aandb(self.zymin, self.zymax), 0.)]
xy = list(x) + y
eye = spdiag([1.0] * mn)
H = spmatrix(1.0, xy, xy, (mn, mn), 'd')
# Modifying ``eye`` is more efficient than ``eye = eye - H``.
# CVXOPT modifies eye in place because all the accessed elements exist.
for idx in xy:
eye[idx, idx] = 0
if len(xy) > 0:
self.Ac = eye * (self.Ac * eye) - H
self.q[x] = 0
self.ac_reset = False
self.factorize = True
def objective_hyper(x, z, ks, p):
"""Objective function of UE program with hyperbolic delay functions
f(x) = sum_i f_i(v_i) with v = sum_w x_w
f_i(u) = ks[i,0]*u - ks[i,1]*log(ks[i,2]-u)
Parameters
----------
x,z: variables for the F(x,z) function for cvxopt.solvers.cp
ks: matrix of size (n,3)
p: number of destinations
(we use multiple-sources single-sink node-arc formulation)
"""
n = ks.size[0]
if x is None: return 0, matrix(1.0/p, (p*n,1))
l = matrix(0.0, (n,1))
for k in range(p): l += x[k*n:(k+1)*n]
f, Df, H = 0.0, matrix(0.0, (1,n)), matrix(0.0, (n,1))
for i in range(n):
tmp = 1.0/(ks[i,2]-l[i])
f += ks[i,0]*l[i] - ks[i,1]*np.log(max(ks[i,2]-l[i], 1e-13))
Df[i] = ks[i,0] + ks[i,1]*tmp
H[i] = ks[i,1]*tmp**2
Df = matrix([[Df]]*p)
if z is None: return f, Df
return f, Df, sparse([[spdiag(z[0] * H)]*p]*p)
def objective_hyper_SO(x, z, ks, p):
"""Objective function of SO program with hyperbolic delay functions
f(x) = \sum_i f_i(v_i) with v = sum_w x_w
f_i(u) = ks[i,0]*u + ks[i,1]*u/(ks[i,2]-u)
Parameters
----------
x,z: variables for the F(x,z) function for cvxopt.solvers.cp
ks: matrix of size (n,3) where ks[i,j] is the j-th parameter of the delay on link i
p: number of destinations
(we use multiple-sources single-sink node-arc formulation)
"""
n = ks.size[0]
if x is None: return 0, matrix(1.0/p, (p*n,1))
l = matrix(0.0, (n,1))
for k in range(p): l += x[k*n:(k+1)*n]
f, Df, H = 0.0, matrix(0.0, (1,n)), matrix(0.0, (n,1))
for i in range(n):
tmp = 1.0/(ks[i,2]-l[i])
f += ks[i,0]*l[i] + ks[i,1]*l[i]*tmp
Df[i] = ks[i,0] + ks[i,1]*tmp + ks[i,1]*l[i]*tmp**2
H[i] = 2.0*ks[i,1]*tmp**2 + 2.0*ks[i,1]*l[i]*tmp**3
Df = matrix([[Df]]*p)
if z is None: return f, Df
return f, Df, matrix([[spdiag(z[0] * H)]*p]*p)
def build_new_weights(ini_pop_desc,
future_pop_desc,
characteristics,
ini_weights,
ismosek=True):
'''optimize new weights to match current households and new population description'''
t_tilde = cvxopt.matrix(
(future_pop_desc.values - ini_pop_desc.values).astype(np.float,
copy=False))
aa = cvxopt.matrix(characteristics.values.astype(np.float, copy=False))
w1 = 1 / (ini_weights.values)**2
n = len(w1)
P = cvxopt.spdiag(cvxopt.matrix(w1))
G = -cvxopt.matrix(np.identity(n))
h = cvxopt.matrix(ini_weights.values.astype(np.float, copy=False))
q = cvxopt.matrix(0.0, (n, 1))
if ismosek:
result = qp(P, q, G, h, aa.T, t_tilde.T, solver='mosek')['x']
else:
result = qp(P, q, G, h, aa.T, t_tilde.T)['x']
if result is None:
new_weights = 0 * ini_weights
else:
new_weights = ini_weights + list(result)
return new_weights
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(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, 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, 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 optimalWeightsMultipleModelsFixedProfile(losses, averageWeights, eta, rowSums=None, initWeights=None):
"Min. W'L s.t. each row w_j of W is a distribution with sum rowSums[j], and the mean of all rows is averageWeights."
k, n = losses.shape
rowSums = ones(k) if rowSums is None else rowSums
if initWeights is not None:
initvals = {'x': matrix(initWeights.flatten()), 's': matrix(initWeights.flatten())}
else:
initvals = None
q = losses.flatten() * tile(eta, (n, 1)).T.flatten()
Aparts = [[sparseRowJofK(k, n, j), spdiag(list(ones(n) * eta[j]))] for j in range(k)]
A = sparse(Aparts)
b = hstack((rowSums, averageWeights))
G = spdiag(list(-ones(k * n)))
h = zeros(k * n)
"Min. q'x s.t. Gx <= h and Ax=b"
resDict = lp(matrix(q), G=G, h=matrix(h), A=A, b=matrix(b), solver='glpk')
return array(resDict['x']).reshape((k, n))
def sqrt_utility(A, b, x):
"""Square root utility function: U(x) = 1'sqrt(Ax+b)"""
tmp1 = np.sqrt(A*x + b)
f = sum(tmp1)[0]
tmp2 = matrix([.5/a[0] for a in tmp1])
Df = tmp2.T*A
tmp3 = spdiag([-2.*a**3 for a in tmp2])
return f, Df, A.T*tmp3*A
def test_sparse_quad_form(self):
"""Test quad form with a sparse matrix.
"""
Q = cvxopt.spdiag([1,1])
x = cvxpy.Variable(2,1)
cost = cvxpy.quad_form(x,Q)
prob = cvxpy.Problem(cvxpy.Minimize(cost), [x == [1,2]])
self.assertAlmostEqual(prob.solve(), 5)
def dSbus_dV(Y, V):
""" Computes the partial derivative of power injection w.r.t. voltage.
References:
Ray Zimmerman, "dSbus_dV.m", MATPOWER, version 3.2,
PSERC (Cornell), http://www.pserc.cornell.edu/matpower/
"""
I = Y * V
diagV = spdiag(V)
diagIbus = spdiag(I)
diagVnorm = spdiag(div(V, abs(V))) # Element-wise division.
dS_dVm = diagV * conj(Y * diagVnorm) + conj(diagIbus) * diagVnorm
dS_dVa = 1j * diagV * conj(diagIbus - Y * diagV)
return dS_dVm, dS_dVa
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
