def setUp(self):
     super().setUp()
     try:
         self.resource_path = './test/optimization/resources/'
         self.cplex_optimizer = CplexOptimizer(disp=False)
     except NameError as ex:
         self.skipTest(str(ex))
Example #2
0
    def test_recursive_min_eigen_optimizer(self):
        """Test the recursive minimum eigen optimizer."""
        try:
            filename = 'op_ip1.lp'
            # get minimum eigen solver
            min_eigen_solver = NumPyMinimumEigensolver()

            # construct minimum eigen optimizer
            min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
            recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
                                                                           min_num_vars=4)

            # load optimization problem
            problem = QuadraticProgram()
            problem.read_from_lp_file(self.resource_path + filename)

            # solve problem with cplex
            cplex = CplexOptimizer()
            cplex_result = cplex.solve(problem)

            # solve problem
            result = recursive_min_eigen_optimizer.solve(problem)

            # analyze results
            self.assertAlmostEqual(cplex_result.fval, result.fval)
        except RuntimeError as ex:
            msg = str(ex)
            if 'CPLEX' in msg:
                self.skipTest(msg)
            else:
                self.fail(msg)
Example #3
0
    def test_min_eigen_optimizer(self, config):
        """ Min Eigen Optimizer Test """

        # unpack configuration
        min_eigen_solver_name, backend, filename = config

        # get minimum eigen solver
        min_eigen_solver = self.min_eigen_solvers[min_eigen_solver_name]
        if backend:
            min_eigen_solver.quantum_instance = BasicAer.get_backend(backend)

        # construct minimum eigen optimizer
        min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)

        # load optimization problem
        problem = OptimizationProblem()
        problem.read(self.resource_path + filename)

        # solve problem with cplex
        cplex = CplexOptimizer()
        cplex_result = cplex.solve(problem)

        # solve problem
        result = min_eigen_optimizer.solve(problem)

        # analyze results
        self.assertAlmostEqual(cplex_result.fval, result.fval)
Example #4
0
    def test_recursive_min_eigen_optimizer(self):
        """Test the recursive minimum eigen optimizer."""
        try:
            filename = 'op_ip1.lp'
            # get minimum eigen solver
            min_eigen_solver = NumPyMinimumEigensolver()

            # construct minimum eigen optimizer
            min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
            recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
                                                                           min_num_vars=4)

            # load optimization problem
            problem = QuadraticProgram()
            lp_file = self.get_resource_path(path.join('resources', filename))
            problem.read_from_lp_file(lp_file)

            # solve problem with cplex
            cplex = CplexOptimizer()
            cplex_result = cplex.solve(problem)

            # solve problem
            result = recursive_min_eigen_optimizer.solve(problem)

            # analyze results
            self.assertAlmostEqual(cplex_result.fval, result.fval)
        except MissingOptionalLibraryError as ex:
            self.skipTest(str(ex))
Example #5
0
    def test_min_eigen_optimizer(self, config):
        """ Min Eigen Optimizer Test """
        try:
            # unpack configuration
            min_eigen_solver_name, backend, filename = config

            # get minimum eigen solver
            min_eigen_solver = self.min_eigen_solvers[min_eigen_solver_name]
            if backend:
                min_eigen_solver.quantum_instance = BasicAer.get_backend(backend)

            # construct minimum eigen optimizer
            min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)

            # load optimization problem
            problem = QuadraticProgram()
            problem.read_from_lp_file(self.resource_path + filename)

            # solve problem with cplex
            cplex = CplexOptimizer()
            cplex_result = cplex.solve(problem)

            # solve problem
            result = min_eigen_optimizer.solve(problem)

            # analyze results
            self.assertAlmostEqual(cplex_result.fval, result.fval)
        except RuntimeError as ex:
            msg = str(ex)
            if 'CPLEX' in msg:
                self.skipTest(msg)
            else:
                self.fail(msg)
Example #6
0
    def test_admm_ex4_no_bin_var_in_objective(self):
        """Modified Example 4 as a unit test. See the description of the previous test.
        This test differs from the previous in the objective: one binary variable
        is omitted in objective to test a problem when a binary variable defined but is used only
        in constraints.
        """
        try:
            mdl = Model('ex4')

            v = mdl.binary_var(name='v')
            w = mdl.binary_var(name='w')
            # pylint:disable=invalid-name
            t = mdl.binary_var(name='t')

            # b = 1
            b = 2

            mdl.minimize(v + t)
            mdl.add_constraint(2 * v + 10 * w + t <= 3, "cons1")
            mdl.add_constraint(v + w + t >= b, "cons2")

            op = QuadraticProgram()
            op.from_docplex(mdl)

            # qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
            qubo_optimizer = CplexOptimizer()
            continuous_optimizer = CplexOptimizer()

            admm_params = ADMMParameters(rho_initial=1001,
                                         beta=1000,
                                         factor_c=900,
                                         max_iter=100,
                                         three_block=False)

            solver = ADMMOptimizer(
                params=admm_params,
                qubo_optimizer=qubo_optimizer,
                continuous_optimizer=continuous_optimizer,
            )
            solution = solver.solve(op)
            self.assertIsNotNone(solution)
            self.assertIsInstance(solution, ADMMOptimizationResult)
            self.assertIsNotNone(solution.x)
            np.testing.assert_almost_equal([1., 0., 1.], solution.x, 3)
            self.assertIsNotNone(solution.fval)
            np.testing.assert_almost_equal(2., solution.fval, 3)
            self.assertIsNotNone(solution.state)
            self.assertIsInstance(solution.state, ADMMState)

        except NameError as ex:
            self.skipTest(str(ex))
Example #7
0
    def test_admm_ex4(self):
        """Example 4 as a unit test. Example 4 is reported in:
        Gambella, C., & Simonetto, A. (2020).
        Multi-block ADMM Heuristics for Mixed-Binary Optimization on Classical
        and Quantum Computers.
        arXiv preprint arXiv:2001.02069."""
        try:
            mdl = Model('ex4')

            v = mdl.binary_var(name='v')
            w = mdl.binary_var(name='w')
            # pylint:disable=invalid-name
            t = mdl.binary_var(name='t')

            # b = 1
            b = 2

            mdl.minimize(v + w + t)
            mdl.add_constraint(2 * v + 10 * w + t <= 3, "cons1")
            mdl.add_constraint(v + w + t >= b, "cons2")

            op = QuadraticProgram()
            op.from_docplex(mdl)

            # qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
            qubo_optimizer = CplexOptimizer()
            continuous_optimizer = CplexOptimizer()

            admm_params = ADMMParameters(rho_initial=1001,
                                         beta=1000,
                                         factor_c=900,
                                         max_iter=100,
                                         three_block=False)

            solver = ADMMOptimizer(
                params=admm_params,
                qubo_optimizer=qubo_optimizer,
                continuous_optimizer=continuous_optimizer,
            )
            solution = solver.solve(op)
            self.assertIsNotNone(solution)
            self.assertIsInstance(solution, ADMMOptimizationResult)
            self.assertIsNotNone(solution.x)
            np.testing.assert_almost_equal([1., 0., 1.], solution.x, 3)
            self.assertIsNotNone(solution.fval)
            np.testing.assert_almost_equal(2., solution.fval, 3)
            self.assertIsNotNone(solution.state)
            self.assertIsInstance(solution.state, ADMMState)

        except NameError as ex:
            self.skipTest(str(ex))
Example #8
0
    def test_admm_ex6(self):
        """Example 6 as a unit test. Example 6 is reported in:
        Gambella, C., & Simonetto, A. (2020).
        Multi-block ADMM Heuristics for Mixed-Binary Optimization on Classical
        and Quantum Computers.
        arXiv preprint arXiv:2001.02069."""
        try:
            mdl = Model('ex6')

            # pylint:disable=invalid-name
            v = mdl.binary_var(name='v')
            w = mdl.binary_var(name='w')
            t = mdl.binary_var(name='t')
            u = mdl.continuous_var(name='u')

            mdl.minimize(v + w + t + 5 * (u - 2)**2)
            mdl.add_constraint(v + 2 * w + t + u <= 3, "cons1")
            mdl.add_constraint(v + w + t >= 1, "cons2")
            mdl.add_constraint(v + w == 1, "cons3")

            op = QuadraticProgram()
            op.from_docplex(mdl)

            qubo_optimizer = CplexOptimizer()
            continuous_optimizer = CplexOptimizer()

            admm_params = ADMMParameters(rho_initial=1001,
                                         beta=1000,
                                         factor_c=900,
                                         max_iter=100,
                                         three_block=True,
                                         tol=1.e-6)

            solver = ADMMOptimizer(params=admm_params,
                                   qubo_optimizer=qubo_optimizer,
                                   continuous_optimizer=continuous_optimizer)
            solution = solver.solve(op)

            self.assertIsNotNone(solution)
            self.assertIsInstance(solution, ADMMOptimizationResult)
            self.assertIsNotNone(solution.x)
            np.testing.assert_almost_equal([1., 0., 0., 2.], solution.x, 3)
            self.assertIsNotNone(solution.fval)
            np.testing.assert_almost_equal(1., solution.fval, 3)
            self.assertIsNotNone(solution.state)
            self.assertIsInstance(solution.state, ADMMState)
        except NameError as ex:
            self.skipTest(str(ex))
Example #9
0
class TestCplexOptimizer(QiskitOptimizationTestCase):
    """Cplex Optimizer Tests."""
    def setUp(self):
        super().setUp()
        try:
            self.cplex_optimizer = CplexOptimizer(disp=False)
        except MissingOptionalLibraryError as ex:
            self.skipTest(str(ex))

    @data(('op_ip1.lp', [0, 2], 6), ('op_mip1.lp', [1, 1, 0], 6),
          ('op_lp1.lp', [0.25, 1.75], 5.8750))
    def test_cplex_optimizer(self, config):
        """ Cplex Optimizer Test """
        # unpack configuration
        filename, x, fval = config

        # load optimization problem
        problem = QuadraticProgram()
        lp_file = self.get_resource_path(path.join('resources', filename))
        problem.read_from_lp_file(lp_file)

        # solve problem with cplex
        result = self.cplex_optimizer.solve(problem)

        # analyze results
        self.assertAlmostEqual(result.fval, fval)
        for i in range(problem.get_num_vars()):
            self.assertAlmostEqual(result.x[i], x[i])
Example #10
0
    def test_admm_maximization(self):
        """Tests a simple maximization problem using ADMM optimizer"""
        mdl = Model('test')
        c = mdl.continuous_var(lb=0, ub=10, name='c')
        x = mdl.binary_var(name='x')
        mdl.maximize(c + x * x)
        op = OptimizationProblem()
        op.from_docplex(mdl)
        self.assertIsNotNone(op)

        admm_params = ADMMParameters()

        qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
        continuous_optimizer = CplexOptimizer()

        solver = ADMMOptimizer(qubo_optimizer=qubo_optimizer,
                               continuous_optimizer=continuous_optimizer,
                               params=admm_params)
        solution: ADMMOptimizerResult = solver.solve(op)
        self.assertIsNotNone(solution)
        self.assertIsInstance(solution, ADMMOptimizerResult)

        self.assertIsNotNone(solution.x)
        np.testing.assert_almost_equal([10, 0], solution.x, 3)
        self.assertIsNotNone(solution.fval)
        np.testing.assert_almost_equal(10, solution.fval, 3)
        self.assertIsNotNone(solution.state)
        self.assertIsInstance(solution.state, ADMMState)
Example #11
0
    def test_admm_miskp_eigen(self):
        """ADMM Optimizer Test based on Mixed-Integer Setup Knapsack Problem
        using NumPy eigen optimizer"""
        miskp = Miskp(*self._get_miskp_problem_params())
        op: OptimizationProblem = miskp.create_problem()
        self.assertIsNotNone(op)

        admm_params = ADMMParameters()

        # use numpy exact diagonalization
        qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
        continuous_optimizer = CplexOptimizer()

        solver = ADMMOptimizer(qubo_optimizer=qubo_optimizer,
                               continuous_optimizer=continuous_optimizer,
                               params=admm_params)
        solution: ADMMOptimizerResult = solver.solve(op)
        self.assertIsNotNone(solution)
        self.assertIsInstance(solution, ADMMOptimizerResult)

        correct_solution = [
            0.009127, 0.009127, 0.009127, 0.009127, 0.009127, 0.009127,
            0.009127, 0.009127, 0.009127, 0.009127, 0.006151, 0.006151,
            0.006151, 0.006151, 0.006151, 0.006151, 0.006151, 0.006151,
            0.006151, 0.006151, 0., 0.
        ]
        correct_objective = -1.2113693

        self.assertIsNotNone(solution.x)
        np.testing.assert_almost_equal(correct_solution, solution.x, 3)
        self.assertIsNotNone(solution.fval)
        np.testing.assert_almost_equal(correct_objective, solution.fval, 3)
        self.assertIsNotNone(solution.state)
        self.assertIsInstance(solution.state, ADMMState)
 def test_continuous_variable_decode(self):
     """ Test decode func of IntegerToBinaryConverter for continuous variables"""
     try:
         mdl = Model('test_continuous_varable_decode')
         c = mdl.continuous_var(lb=0, ub=10.9, name='c')
         x = mdl.binary_var(name='x')
         mdl.maximize(c + x * x)
         op = QuadraticProgram()
         op.from_docplex(mdl)
         converter = IntegerToBinary()
         op = converter.convert(op)
         admm_params = ADMMParameters()
         qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
         continuous_optimizer = CplexOptimizer()
         solver = ADMMOptimizer(
             qubo_optimizer=qubo_optimizer,
             continuous_optimizer=continuous_optimizer,
             params=admm_params,
         )
         result = solver.solve(op)
         result = converter.interpret(result)
         self.assertEqual(result.x[0], 10.9)
         self.assertListEqual(result.variable_names, ['c', 'x'])
         self.assertDictEqual(result.variables_dict, {'c': 10.9, 'x': 0})
     except NameError as ex:
         self.skipTest(str(ex))
Example #13
0
class TestCplexOptimizer(QiskitOptimizationTestCase):
    """Cplex Optimizer Tests."""
    def setUp(self):
        super().setUp()

        self.resource_path = './test/optimization/resources/'
        self.cplex_optimizer = CplexOptimizer()

    @data(('op_ip1.lp', [0, 2], 6), ('op_mip1.lp', [1, 1, 0], 6),
          ('op_lp1.lp', [0.25, 1.75], 5.8750))
    def test_cplex_optimizer(self, config):
        """ Cplex Optimizer Test """

        # unpack configuration
        filename, x, fval = config

        # load optimization problem
        problem = OptimizationProblem()
        problem.read(self.resource_path + filename)

        # solve problem with cplex
        result = self.cplex_optimizer.solve(problem)

        # analyze results
        self.assertAlmostEqual(result.fval, fval)
        self.assertAlmostEqual(result.x, x)
Example #14
0
    def test_admm_maximization(self):
        """Tests a simple maximization problem using ADMM optimizer"""
        try:
            mdl = Model('simple-max')
            c = mdl.continuous_var(lb=0, ub=10, name='c')
            x = mdl.binary_var(name='x')
            mdl.maximize(c + x * x)
            op = QuadraticProgram()
            op.from_docplex(mdl)

            admm_params = ADMMParameters()

            qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
            # qubo_optimizer = CplexOptimizer()
            continuous_optimizer = CplexOptimizer()

            solver = ADMMOptimizer(qubo_optimizer=qubo_optimizer,
                                   continuous_optimizer=continuous_optimizer,
                                   params=admm_params)
            solution = solver.solve(op)
            self.assertIsNotNone(solution)
            self.assertIsInstance(solution, ADMMOptimizationResult)

            self.assertIsNotNone(solution.x)
            np.testing.assert_almost_equal([10, 0], solution.x, 3)
            self.assertIsNotNone(solution.fval)
            np.testing.assert_almost_equal(10, solution.fval, 3)
            self.assertIsNotNone(solution.state)
            self.assertIsInstance(solution.state, ADMMState)
        except NameError as ex:
            self.skipTest(str(ex))
Example #15
0
    def test_quad_constraints(self):
        """Simple example to test quadratic constraints."""

        try:
            mdl = Model('quad-constraints')

            v = mdl.binary_var(name='v')
            w = mdl.continuous_var(name='w', lb=0.)

            mdl.minimize(v + w)
            mdl.add_constraint(v + w >= 1, "cons2")
            mdl.add_constraint(v**2 + w**2 <= 1, "cons2")

            op = QuadraticProgram()
            op.from_docplex(mdl)

            # qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
            qubo_optimizer = CplexOptimizer()

            continuous_optimizer = CplexOptimizer()

            admm_params = ADMMParameters(
                rho_initial=1001,
                beta=1000,
                factor_c=900,
                max_iter=100,
                three_block=True,
            )

            solver = ADMMOptimizer(
                params=admm_params,
                qubo_optimizer=qubo_optimizer,
                continuous_optimizer=continuous_optimizer,
            )
            solution = solver.solve(op)

            self.assertIsNotNone(solution)
            self.assertIsInstance(solution, ADMMOptimizationResult)
            self.assertIsNotNone(solution.x)
            np.testing.assert_almost_equal([0., 1.], solution.x, 3)
            self.assertIsNotNone(solution.fval)
            np.testing.assert_almost_equal(1., solution.fval, 3)
            self.assertIsNotNone(solution.state)
            self.assertIsInstance(solution.state, ADMMState)

        except NameError as ex:
            self.skipTest(str(ex))
Example #16
0
    def test_equality_constraints_with_continuous_variables(self):
        """Simple example to test equality constraints with continuous variables."""
        try:
            mdl = Model("eq-constraints-cts-vars")

            # pylint:disable=invalid-name
            v = mdl.binary_var(name='v')
            w = mdl.continuous_var(name='w', lb=0.)
            t = mdl.continuous_var(name='t', lb=0.)

            mdl.minimize(v + w + t)
            mdl.add_constraint(2 * v + w >= 2, "cons1")
            mdl.add_constraint(w + t == 1, "cons2")

            op = QuadraticProgram()
            op.from_docplex(mdl)

            # qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
            qubo_optimizer = CplexOptimizer()

            continuous_optimizer = CplexOptimizer()

            admm_params = ADMMParameters(
                rho_initial=1001,
                beta=1000,
                factor_c=900,
                max_iter=100,
                three_block=True,
            )

            solver = ADMMOptimizer(
                params=admm_params,
                qubo_optimizer=qubo_optimizer,
                continuous_optimizer=continuous_optimizer,
            )
            solution = solver.solve(op)

            self.assertIsNotNone(solution)
            self.assertIsInstance(solution, ADMMOptimizationResult)
            self.assertIsNotNone(solution.x)
            np.testing.assert_almost_equal([0., 1., 0.], solution.x, 3)
            self.assertIsNotNone(solution.fval)
            np.testing.assert_almost_equal(1., solution.fval, 3)
            self.assertIsNotNone(solution.state)
            self.assertIsInstance(solution.state, ADMMState)
        except NameError as ex:
            self.skipTest(str(ex))
Example #17
0
    def test_admm_ex6_max(self):
        """Example 6 as maximization"""
        try:
            mdl = Model('ex6-max')

            # pylint:disable=invalid-name
            v = mdl.binary_var(name='v')
            w = mdl.binary_var(name='w')
            t = mdl.binary_var(name='t')
            u = mdl.continuous_var(name='u')

            # mdl.minimize(v + w + t + 5 * (u - 2) ** 2)
            mdl.maximize(-v - w - t - 5 * (u - 2)**2)
            mdl.add_constraint(v + 2 * w + t + u <= 3, "cons1")
            mdl.add_constraint(v + w + t >= 1, "cons2")
            mdl.add_constraint(v + w == 1, "cons3")

            op = QuadraticProgram()
            op.from_docplex(mdl)

            qubo_optimizer = CplexOptimizer()
            continuous_optimizer = CplexOptimizer()

            admm_params = ADMMParameters(rho_initial=1001,
                                         beta=1000,
                                         factor_c=900,
                                         max_iter=100,
                                         three_block=True,
                                         tol=1.e-6)

            solver = ADMMOptimizer(params=admm_params,
                                   qubo_optimizer=qubo_optimizer,
                                   continuous_optimizer=continuous_optimizer)
            solution = solver.solve(op)

            self.assertIsNotNone(solution)
            self.assertIsInstance(solution, ADMMOptimizationResult)
            self.assertIsNotNone(solution.x)
            np.testing.assert_almost_equal([1., 0., 0., 2.], solution.x, 3)
            self.assertIsNotNone(solution.fval)
            np.testing.assert_almost_equal(-1., solution.fval, 3)
            self.assertIsNotNone(solution.state)
            self.assertIsInstance(solution.state, ADMMState)
        except NameError as ex:
            self.skipTest(str(ex))
Example #18
0
    def test_min_eigen_optimizer(self, config):
        """ Min Eigen Optimizer Test """
        try:
            # unpack configuration
            min_eigen_solver_name, backend, filename = config

            # get minimum eigen solver
            min_eigen_solver = self.min_eigen_solvers[min_eigen_solver_name]
            if backend:
                min_eigen_solver.quantum_instance = BasicAer.get_backend(
                    backend)

            # construct minimum eigen optimizer
            min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)

            # load optimization problem
            problem = QuadraticProgram()
            lp_file = self.get_resource_path(path.join('resources', filename))
            problem.read_from_lp_file(lp_file)

            # solve problem with cplex
            cplex = CplexOptimizer()
            cplex_result = cplex.solve(problem)

            # solve problem
            result = min_eigen_optimizer.solve(problem)
            self.assertIsNotNone(result)

            # analyze results
            self.assertAlmostEqual(cplex_result.fval, result.fval)

            # check that eigensolver result is present
            self.assertIsNotNone(result.min_eigen_solver_result)
        except MissingOptionalLibraryError as ex:
            self.skipTest(str(ex))
        except RuntimeError as ex:
            self.fail(str(ex))
Example #19
0
 def test_continuous_variable_decode(self):
     """ Test decode func of IntegerToBinaryConverter for continuous variables"""
     try:
         mdl = Model('test_continuous_varable_decode')
         c = mdl.continuous_var(lb=0, ub=10.9, name='c')
         x = mdl.binary_var(name='x')
         mdl.maximize(c + x * x)
         op = QuadraticProgram()
         op.from_docplex(mdl)
         converter = IntegerToBinary()
         op = converter.encode(op)
         admm_params = ADMMParameters()
         qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
         continuous_optimizer = CplexOptimizer()
         solver = ADMMOptimizer(
             qubo_optimizer=qubo_optimizer,
             continuous_optimizer=continuous_optimizer,
             params=admm_params,
         )
         solution = solver.solve(op)
         solution = converter.decode(solution)
         self.assertEqual(solution.x[0], 10.9)
     except NameError as ex:
         self.skipTest(str(ex))
 def setUp(self):
     super().setUp()
     try:
         self.cplex_optimizer = CplexOptimizer(disp=False)
     except NameError as ex:
         self.skipTest(str(ex))
Example #21
0
 def setUp(self):
     super().setUp()
     try:
         self.cplex_optimizer = CplexOptimizer(disp=False)
     except MissingOptionalLibraryError as ex:
         self.skipTest(str(ex))
Example #22
0
    def setUp(self):
        super().setUp()

        self.resource_path = './test/optimization/resources/'
        self.cplex_optimizer = CplexOptimizer()