コード例 #1
0
    def test_all_cuts(self):
        """Basic test of the Goemans-Williamson optimizer."""
        try:
            graph = np.array([[0., 1., 2., 0.], [1., 0., 1., 0.],
                              [2., 1., 0., 1.], [0., 0., 1., 0.]])

            optimizer = GoemansWilliamsonOptimizer(num_cuts=10, seed=0)

            problem = Maxcut(graph).to_quadratic_program()
            self.assertIsNotNone(problem)

            results = optimizer.solve(problem)
            self.assertIsNotNone(results)
            self.assertIsInstance(results, GoemansWilliamsonOptimizationResult)

            self.assertIsNotNone(results.x)
            np.testing.assert_almost_equal([0, 1, 1, 0], results.x, 3)

            self.assertIsNotNone(results.fval)
            np.testing.assert_almost_equal(4, results.fval, 3)

            self.assertIsNotNone(results.samples)
            self.assertEqual(3, len(results.samples))
        except MissingOptionalLibraryError as ex:
            self.skipTest(str(ex))
    def test_all_cuts(self):
        """Basic test of the Goemans-Williamson optimizer."""
        graph = np.array([
            [0.0, 1.0, 2.0, 0.0],
            [1.0, 0.0, 1.0, 0.0],
            [2.0, 1.0, 0.0, 1.0],
            [0.0, 0.0, 1.0, 0.0],
        ])

        optimizer = GoemansWilliamsonOptimizer(num_cuts=10, seed=0)

        problem = Maxcut(graph).to_quadratic_program()
        self.assertIsNotNone(problem)

        results = optimizer.solve(problem)
        self.assertIsNotNone(results)
        self.assertIsInstance(results, GoemansWilliamsonOptimizationResult)

        self.assertIsNotNone(results.x)
        np.testing.assert_almost_equal([0, 1, 1, 0], results.x, 3)

        self.assertIsNotNone(results.fval)
        np.testing.assert_almost_equal(4, results.fval, 3)

        self.assertIsNotNone(results.samples)
        self.assertEqual(3, len(results.samples))
コード例 #3
0
    def test_minimization_problem(self):
        """Tests the optimizer with a minimization problem"""
        optimizer = GoemansWilliamsonOptimizer(num_cuts=10, seed=0)

        problem = Maxcut(self.graph).to_quadratic_program()

        # artificially convert to minimization
        max2min = MaximizeToMinimize()
        problem = max2min.convert(problem)

        results = optimizer.solve(problem)

        np.testing.assert_almost_equal([0, 1, 1, 0], results.x, 3)
        np.testing.assert_almost_equal(4, results.fval, 3)
コード例 #4
0
    def test_max_cut(self):
        """Basic test on the max cut problem."""
        graph = np.array([
            [0.0, 1.0, 2.0, 0.0],
            [1.0, 0.0, 1.0, 0.0],
            [2.0, 1.0, 0.0, 1.0],
            [0.0, 0.0, 1.0, 0.0],
        ])

        presolver = GoemansWilliamsonOptimizer(num_cuts=10)
        problem = Maxcut(graph).to_quadratic_program()

        backend = BasicAer.get_backend("statevector_simulator")
        qaoa = QAOA(quantum_instance=backend, reps=1)
        aggregator = MeanAggregator()
        optimizer = WarmStartQAOAOptimizer(
            pre_solver=presolver,
            relax_for_pre_solver=False,
            qaoa=qaoa,
            epsilon=0.25,
            num_initial_solutions=10,
            aggregator=aggregator,
            converters=[],
        )
        result_warm = optimizer.solve(problem)

        self.assertIsNotNone(result_warm)
        self.assertIsNotNone(result_warm.x)
        np.testing.assert_almost_equal([0, 0, 1, 0], result_warm.x, 3)
        self.assertIsNotNone(result_warm.fval)
        np.testing.assert_almost_equal(4, result_warm.fval, 3)
コード例 #5
0
    def test_max_cut(self):
        """Basic test on the max cut problem."""
        try:
            graph = np.array([[0., 1., 2., 0.], [1., 0., 1., 0.],
                              [2., 1., 0., 1.], [0., 0., 1., 0.]])

            presolver = GoemansWilliamsonOptimizer(num_cuts=10)
            problem = max_cut_qp(graph)

            backend = BasicAer.get_backend("statevector_simulator")
            qaoa = QAOA(quantum_instance=backend, reps=1)
            aggregator = MeanAggregator()
            optimizer = WarmStartQAOAOptimizer(pre_solver=presolver,
                                               relax_for_pre_solver=False,
                                               qaoa=qaoa,
                                               epsilon=0.25,
                                               num_initial_solutions=10,
                                               aggregator=aggregator)
            result_warm = optimizer.solve(problem)

            self.assertIsNotNone(result_warm)
            self.assertIsNotNone(result_warm.x)
            np.testing.assert_almost_equal([0, 0, 1, 0], result_warm.x, 3)
            self.assertIsNotNone(result_warm.fval)
            np.testing.assert_almost_equal(4, result_warm.fval, 3)
        except MissingOptionalLibraryError as ex:
            self.skipTest(str(ex))