def test_qp_maximization_reduction_path_qp_solver(self):
qp_maximization = Problem(Maximize(QuadForm(self.x, -self.Q)),
[self.x <= -1])
path = PathFinder().reduction_path(ProblemType(qp_maximization),
[QpSolver])
self.assertEquals(3, len(path))
self.assertEquals(path[1], QpMatrixStuffing)
self.assertEquals(path[2], FlipObjective)
def quad_form_bound(self, solver):
P = np.array([[13, 12, -2], [12, 17, 6], [-2, 6, 12]])
q = np.array([[-22], [-14.5], [13]])
r = 1
y_star = np.array([[1], [0.5], [-1]])
p = Problem(Minimize(0.5 * QuadForm(self.y, P) + q.T * self.y + r),
[self.y >= -1, self.y <= 1])
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(y_star, var.value, places=4)
def quad_form_coeff(self, solver):
np.random.seed(0)
A = np.random.randn(5, 5)
z = np.random.randn(5)
P = A.T.dot(A)
q = -2 * P.dot(z)
p = Problem(Minimize(QuadForm(self.w, P) + q.T * self.w))
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(z, var.value, places=4)
def quad_form_bound(self, solver):
P = numpy.matrix([[13, 12, -2], [12, 17, 6], [-2, 6, 12]])
q = numpy.matrix([[-22], [-14.5], [13]])
r = 1
y_star = numpy.matrix([[1], [0.5], [-1]])
p = Problem(Minimize(0.5 * QuadForm(self.y, P) + q.T * self.y + r),
[self.y >= -1, self.y <= 1])
s = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(y_star, s.primal_vars[var.id])
def quad_form_coeff(self, solver):
numpy.random.seed(0)
A = numpy.random.randn(5, 5)
z = numpy.random.randn(5, 1)
P = A.T.dot(A)
q = -2 * P.dot(z)
p = Problem(Minimize(QuadForm(self.w, P) + q.T * self.w))
qp_solution = self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(z, qp_solution.primal_vars[var.id])
def stuffed_objective(self, problem, extractor):
# extract to x.T * P * x + q.T * x + r
expr = problem.objective.expr.copy()
P, q, r = extractor.quad_form(expr)
# concatenate all variables in one vector
boolean, integer = extract_mip_idx(problem.variables())
x = Variable(extractor.x_length, boolean=boolean, integer=integer)
new_obj = QuadForm(x, P) + q.T @ x
return new_obj, x, r
def stuffed_objective(self, problem, extractor):
# extract to x.T * P * x + q.T * x + r
# TODO need to copy objective?
P, q, r = extractor.quad_form(problem.objective.expr)
# concatenate all variables in one vector
boolean, integer = extract_mip_idx(problem.variables())
x = Variable(extractor.N, boolean=boolean, integer=integer)
new_obj = QuadForm(x, P) + q.T*x
return new_obj, x, r
def rep_quad_form(self, solver) -> None:
"""A problem where the quad_form term is used multiple times.
"""
np.random.seed(0)
A = np.random.randn(5, 5)
z = np.random.randn(5)
P = A.T.dot(A)
q = -2 * P.dot(z)
qf = QuadForm(self.w, P)
p = Problem(Minimize(0.5 * qf + 0.5 * qf + q.T @ self.w))
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(z, var.value, places=4)
def stuffed_objective(self, problem, inverse_data):
# We need to copy the problem because we are changing atoms in the
# expression tree
problem_copy = problems.problem.Problem(
Minimize(problem.objective.expr.tree_copy()),
[con.tree_copy() for con in problem.constraints])
inverse_data_of_copy = InverseData(problem_copy)
extractor = CoeffExtractor(inverse_data_of_copy)
# extract to x.T * P * x + q.T * x, store r
P, q, r = extractor.quad_form(problem_copy.objective.expr)
# concatenate all variables in one vector
boolean, integer = extract_mip_idx(problem.variables())
x = Variable(inverse_data.x_length, boolean=boolean, integer=integer)
new_obj = QuadForm(x, P) + q.T * x
inverse_data.r = r
return new_obj, x
def equivalent_forms_2(self, solver):
m = 100
n = 80
r = 70
np.random.seed(1)
A = np.random.randn(m, n)
b = np.random.randn(m)
G = np.random.randn(r, n)
h = np.random.randn(r)
# ||Ax-b||^2 = x^T (A^T A) x - 2(A^T b)^T x + ||b||^2
P = np.dot(A.T, A)
q = -2 * np.dot(A.T, b)
r = np.dot(b.T, b)
obj2 = .1 * (QuadForm(self.xef, P) + q.T * self.xef + r)
cons = [G * self.xef == h]
p2 = Problem(Minimize(obj2), cons)
self.solve_QP(p2, solver)
self.assertAlmostEqual(p2.value, 68.1119420108, places=4)
def equivalent_forms_2(self, solver):
m = 100
n = 80
r = 70
numpy.random.seed(1)
A = numpy.random.randn(m, n)
b = numpy.random.randn(m, 1)
G = numpy.random.randn(r, n)
h = numpy.random.randn(r, 1)
# ||Ax-b||^2 = x^T (A^T A) x - 2(A^T b)^T x + ||b||^2
P = numpy.dot(A.T, A)
q = -2 * numpy.dot(A.T, b)
r = numpy.dot(b.T, b)
obj2 = QuadForm(self.xef, P) + q.T * self.xef + r
cons = [G * self.xef == h]
p2 = Problem(Minimize(obj2), cons)
s = self.solve_QP(p2, solver)
self.assertAlmostEqual(s.opt_val, 681.119420108)
def setUp(self):
self.x = Variable(2, name='x')
self.Q = np.eye(2)
self.c = np.array([1, 0.5])
self.qp = Problem(Minimize(QuadForm(self.x, self.Q)), [self.x <= -1])
self.cp = Problem(Minimize(self.c.T * self.x + 1), [self.x >= 0])