def test_samples_numpy_eigen_solver(self): """Test samples for NumPyMinimumEigensolver""" # test minimize min_eigen_solver = NumPyMinimumEigensolver() min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) result = min_eigen_optimizer.solve(self.op_minimize) opt_sol = 1 success = OptimizationResultStatus.SUCCESS self.assertEqual(result.fval, opt_sol) self.assertEqual(len(result.samples), 1) np.testing.assert_array_almost_equal(result.samples[0].x, [1, 0]) self.assertAlmostEqual(result.samples[0].fval, opt_sol) self.assertAlmostEqual(result.samples[0].probability, 1.0) self.assertEqual(result.samples[0].status, success) self.assertEqual(len(result.raw_samples), 1) np.testing.assert_array_almost_equal(result.raw_samples[0].x, [1, 0, 0, 0, 0]) self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol) self.assertAlmostEqual(result.raw_samples[0].probability, 1.0) self.assertEqual(result.raw_samples[0].status, success) # test maximize min_eigen_solver = NumPyMinimumEigensolver() min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) result = min_eigen_optimizer.solve(self.op_maximize) opt_sol = 2 self.assertEqual(result.fval, opt_sol) self.assertEqual(len(result.samples), 1) np.testing.assert_array_almost_equal(result.samples[0].x, [0, 1]) self.assertAlmostEqual(result.samples[0].fval, opt_sol) self.assertAlmostEqual(result.samples[0].probability, 1.0) self.assertEqual(result.samples[0].status, success) self.assertEqual(len(result.raw_samples), 1) np.testing.assert_array_almost_equal(result.raw_samples[0].x, [0, 0, 1, 0]) self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol) self.assertAlmostEqual(result.raw_samples[0].probability, 1.0) self.assertEqual(result.raw_samples[0].status, success)
def test_converter_list(self): """Test converter list""" op = QuadraticProgram() op.integer_var(0, 3, "x") op.binary_var('y') op.maximize(linear={'x': 1, 'y': 2}) op.linear_constraint(linear={'x': 1, 'y': 1}, sense='LE', rhs=3, name='xy_leq') min_eigen_solver = NumPyMinimumEigensolver() # a single converter qp2qubo = QuadraticProgramToQubo() min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver, converters=qp2qubo) result = min_eigen_optimizer.solve(op) self.assertEqual(result.fval, 4) # a list of converters ineq2eq = InequalityToEquality() int2bin = IntegerToBinary() penalize = LinearEqualityToPenalty() converters = [ineq2eq, int2bin, penalize] min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver, converters=converters) result = min_eigen_optimizer.solve(op) self.assertEqual(result.fval, 4) with self.assertRaises(TypeError): invalid = [qp2qubo, "invalid converter"] MinimumEigenOptimizer(min_eigen_solver, converters=invalid)
def test_recursive_min_eigen_optimizer(self): """Test the recursive minimum eigen optimizer.""" 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(filename, "algorithms/resources") 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 np.testing.assert_array_almost_equal(cplex_result.x, result.x, 4) self.assertAlmostEqual(cplex_result.fval, result.fval)
def test_auto_penalty(self): """Test auto penalty function""" op = QuadraticProgram() op.binary_var("x") op.binary_var("y") op.binary_var("z") op.minimize(constant=3, linear={"x": 1}, quadratic={("x", "y"): 2}) op.linear_constraint(linear={ "x": 1, "y": 1, "z": 1 }, sense="EQ", rhs=2, name="xyz_eq") lineq2penalty = LinearEqualityToPenalty(penalty=1e5) lineq2penalty_auto = LinearEqualityToPenalty() qubo = lineq2penalty.convert(op) qubo_auto = lineq2penalty_auto.convert(op) exact_mes = NumPyMinimumEigensolver() exact = MinimumEigenOptimizer(exact_mes) result = exact.solve(qubo) result_auto = exact.solve(qubo_auto) self.assertEqual(result.fval, result_auto.fval) np.testing.assert_array_almost_equal(result.x, result_auto.x)
def test_linear_equality_to_penalty_decode(self): """Test decode func of LinearEqualityToPenalty""" qprog = QuadraticProgram() qprog.binary_var("x") qprog.binary_var("y") qprog.binary_var("z") qprog.maximize(linear={"x": 3, "y": 1, "z": 1}) qprog.linear_constraint(linear={ "x": 1, "y": 1, "z": 1 }, sense="EQ", rhs=2, name="xyz_eq") lineq2penalty = LinearEqualityToPenalty() qubo = lineq2penalty.convert(qprog) exact_mes = NumPyMinimumEigensolver() exact = MinimumEigenOptimizer(exact_mes) result = exact.solve(qubo) new_x = lineq2penalty.interpret(result.x) np.testing.assert_array_almost_equal(new_x, [1, 1, 0]) infeasible_x = lineq2penalty.interpret([1, 1, 1]) np.testing.assert_array_almost_equal(infeasible_x, [1, 1, 1])
def qaoa(G): n = G.numberOfNodes() G = nw.nxadapter.nk2nx(G) w = nx.adjacency_matrix(G) problem = QuadraticProgram() _ = [problem.binary_var(f"x{i}") for i in range(n)] linear = w.dot(np.ones(n)) quadratic = -w problem.maximize(linear=linear, quadratic=quadratic) c = [1] for _ in range(n - 1): c.append(0) problem.linear_constraint(c, '==', 1) cobyla = COBYLA() backend = BasicAer.get_backend('qasm_simulator') qaoa = QAOA(optimizer=cobyla, reps=3, quantum_instance=backend) algorithm = MinimumEigenOptimizer(qaoa) result = algorithm.solve(problem) L = result.x i = 0 res = {} for x in L: res[i] = x i += 1 return res
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(filename, "algorithms/resources") 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 RuntimeError as ex: self.fail(str(ex))
def test_samples_vqe(self, simulator): """Test samples for VQE""" # test minimize algorithm_globals.random_seed = 1 quantum_instance = self.sv_simulator if simulator == "sv" else self.qasm_simulator opt_sol = -2 success = OptimizationResultStatus.SUCCESS optimizer = SPSA(maxiter=100) ry_ansatz = TwoLocal(5, "ry", "cz", reps=3, entanglement="full") vqe_mes = VQE(ry_ansatz, optimizer=optimizer, quantum_instance=quantum_instance) vqe = MinimumEigenOptimizer(vqe_mes) results = vqe.solve(self.op_ordering) self.assertEqual(results.fval, opt_sol) np.testing.assert_array_almost_equal(results.x, [0, 1]) self.assertEqual(results.status, success) results.raw_samples.sort(key=lambda x: x.probability, reverse=True) np.testing.assert_array_almost_equal(results.x, results.raw_samples[0].x) self.assertAlmostEqual(sum(s.probability for s in results.samples), 1, delta=1e-5) self.assertAlmostEqual(sum(s.probability for s in results.raw_samples), 1, delta=1e-5) self.assertAlmostEqual(min(s.fval for s in results.samples), -2) self.assertAlmostEqual(min(s.fval for s in results.samples if s.status == success), opt_sol) self.assertAlmostEqual(min(s.fval for s in results.raw_samples), opt_sol) for sample in results.raw_samples: self.assertEqual(sample.status, success) np.testing.assert_array_almost_equal(results.samples[0].x, [0, 1]) self.assertAlmostEqual(results.samples[0].fval, opt_sol) self.assertEqual(results.samples[0].status, success) np.testing.assert_array_almost_equal(results.raw_samples[0].x, [0, 1]) self.assertAlmostEqual(results.raw_samples[0].fval, opt_sol) self.assertEqual(results.raw_samples[0].status, success)
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))
def test_runtime(self, subroutine): """Test vqe and qaoa runtime""" optimizer = {"name": "SPSA", "maxiter": 100} backend = QasmSimulatorPy() if subroutine == "vqe": ry_ansatz = TwoLocal(5, "ry", "cz", reps=3, entanglement="full") initial_point = np.random.default_rng(42).random( ry_ansatz.num_parameters) solver = VQEProgram( ansatz=ry_ansatz, optimizer=optimizer, initial_point=initial_point, backend=backend, provider=FakeVQERuntimeProvider(), ) else: reps = 2 initial_point = np.random.default_rng(42).random(2 * reps) solver = QAOAProgram( optimizer=optimizer, reps=reps, initial_point=initial_point, backend=backend, provider=FakeQAOARuntimeProvider(), ) opt = MinimumEigenOptimizer(solver) result = opt.solve(self.op_ordering) self.assertIsInstance(result, MinimumEigenOptimizationResult)
def validate_results(self, problem, results): """Validate the results object returned by GroverOptimizer.""" # Get expected value. solver = MinimumEigenOptimizer(NumPyMinimumEigensolver()) comp_result = solver.solve(problem) # Validate results. np.testing.assert_array_almost_equal(comp_result.x, results.x) self.assertEqual(comp_result.fval, results.fval) self.assertAlmostEqual(results.fval, results.intermediate_fval)
def test_min_eigen_optimizer_history(self): """Tests different options for history.""" try: filename = 'op_ip1.lp' # load optimization problem problem = QuadraticProgram() lp_file = self.get_resource_path(path.join('resources', filename)) problem.read_from_lp_file(lp_file) # get minimum eigen solver min_eigen_solver = NumPyMinimumEigensolver() # construct minimum eigen optimizer min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) # no history recursive_min_eigen_optimizer = \ RecursiveMinimumEigenOptimizer(min_eigen_optimizer, min_num_vars=4, history=IntermediateResult.NO_ITERATIONS) result = recursive_min_eigen_optimizer.solve(problem) self.assertIsNotNone(result.replacements) self.assertIsNotNone(result.history) self.assertIsNotNone(result.history[0]) self.assertEqual(len(result.history[0]), 0) self.assertIsNone(result.history[1]) # only last iteration in the history recursive_min_eigen_optimizer = \ RecursiveMinimumEigenOptimizer(min_eigen_optimizer, min_num_vars=4, history=IntermediateResult.LAST_ITERATION) result = recursive_min_eigen_optimizer.solve(problem) self.assertIsNotNone(result.replacements) self.assertIsNotNone(result.history) self.assertIsNotNone(result.history[0]) self.assertEqual(len(result.history[0]), 0) self.assertIsNotNone(result.history[1]) # full history recursive_min_eigen_optimizer = \ RecursiveMinimumEigenOptimizer(min_eigen_optimizer, min_num_vars=4, history=IntermediateResult.ALL_ITERATIONS) result = recursive_min_eigen_optimizer.solve(problem) self.assertIsNotNone(result.replacements) self.assertIsNotNone(result.history) self.assertIsNotNone(result.history[0]) self.assertGreater(len(result.history[0]), 1) self.assertIsNotNone(result.history[1]) except MissingOptionalLibraryError as ex: self.skipTest(str(ex))
def test_recursive_history(self): """Tests different options for history.""" filename = "op_ip1.lp" # load optimization problem problem = QuadraticProgram() lp_file = self.get_resource_path(filename, "algorithms/resources") problem.read_from_lp_file(lp_file) # get minimum eigen solver min_eigen_solver = NumPyMinimumEigensolver() # construct minimum eigen optimizer min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) # no history recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer( min_eigen_optimizer, min_num_vars=4, history=IntermediateResult.NO_ITERATIONS, ) result = recursive_min_eigen_optimizer.solve(problem) self.assertIsNotNone(result.replacements) self.assertIsNotNone(result.history) self.assertIsNotNone(result.history[0]) self.assertEqual(len(result.history[0]), 0) self.assertIsNone(result.history[1]) # only last iteration in the history recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer( min_eigen_optimizer, min_num_vars=4, history=IntermediateResult.LAST_ITERATION, ) result = recursive_min_eigen_optimizer.solve(problem) self.assertIsNotNone(result.replacements) self.assertIsNotNone(result.history) self.assertIsNotNone(result.history[0]) self.assertEqual(len(result.history[0]), 0) self.assertIsNotNone(result.history[1]) # full history recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer( min_eigen_optimizer, min_num_vars=4, history=IntermediateResult.ALL_ITERATIONS, ) result = recursive_min_eigen_optimizer.solve(problem) self.assertIsNotNone(result.replacements) self.assertIsNotNone(result.history) self.assertIsNotNone(result.history[0]) self.assertGreater(len(result.history[0]), 1) self.assertIsNotNone(result.history[1])
def _sample_code(self): def print(*args): """ overloads print to log values """ if args: self.log.debug(args[0], *args[1:]) # --- Exact copy of sample code ---------------------------------------- import networkx as nx import numpy as np from qiskit_optimization import QuadraticProgram from qiskit_optimization.algorithms import MinimumEigenOptimizer from qiskit import BasicAer from qiskit.algorithms import QAOA from qiskit.algorithms.optimizers import SPSA # Generate a graph of 4 nodes n = 4 graph = nx.Graph() graph.add_nodes_from(np.arange(0, n, 1)) elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)] graph.add_weighted_edges_from(elist) # Compute the weight matrix from the graph w = nx.adjacency_matrix(graph) # Formulate the problem as quadratic program problem = QuadraticProgram() _ = [problem.binary_var('x{}'.format(i)) for i in range(n)] # create n binary variables linear = w.dot(np.ones(n)) quadratic = -w problem.maximize(linear=linear, quadratic=quadratic) # Fix node 0 to be 1 to break the symmetry of the max-cut solution problem.linear_constraint([1, 0, 0, 0], '==', 1) # Run quantum algorithm QAOA on qasm simulator spsa = SPSA(maxiter=250) backend = BasicAer.get_backend('qasm_simulator') qaoa = QAOA(optimizer=spsa, p=5, quantum_instance=backend) algorithm = MinimumEigenOptimizer(qaoa) result = algorithm.solve(problem) print(result) # prints solution, x=[1, 0, 1, 0], the cost, fval=4 # ---------------------------------------------------------------------- return result
def solve_classically(qubo): """[summary] Args: qubo ([type]): [description] Returns: [type]: [description] """ from copy import deepcopy from qiskit_optimization.problems.quadratic_objective import ObjSense exact_mes = NumPyMinimumEigensolver() exact = MinimumEigenOptimizer(exact_mes) exact_result = exact.solve(qubo) qubo_2 = deepcopy(qubo) qubo_2.objective.sense = ObjSense.MAXIMIZE worst_result = exact.solve(qubo_2) return exact_result, worst_result
def test_continuous_variable_decode(self): """Test decode func of IntegerToBinaryConverter for continuous variables""" 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 = from_docplex_mp(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) new_x = converter.interpret(result.x) self.assertEqual(new_x[0], 10.9)
def get_quantum_solution_for(quadprog: QuadraticProgram, quantumInstance: QuantumInstance, optimizer=None): _eval_count = 0 def callback(eval_count, parameters, mean, std): nonlocal _eval_count _eval_count = eval_count # Create solver and optimizer solver = QAOA( optimizer=optimizer, quantum_instance=quantumInstance, callback=callback, max_evals_grouped=3, ) # Create optimizer for solver optimizer = MinimumEigenOptimizer(solver) # Get result from optimizer result = optimizer.solve(quadprog) return result, _eval_count
def test_converter_list(self): """Test converter list""" op = QuadraticProgram() op.integer_var(0, 3, "x") op.binary_var("y") op.maximize(linear={"x": 1, "y": 2}) op.linear_constraint(linear={ "y": 1, "x": 1 }, sense="LE", rhs=3, name="xy_leq") # construct minimum eigen optimizer min_eigen_solver = NumPyMinimumEigensolver() min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) # a single converter qp2qubo = QuadraticProgramToQubo() recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer( min_eigen_optimizer, min_num_vars=2, converters=qp2qubo) result = recursive_min_eigen_optimizer.solve(op) self.assertEqual(result.fval, 4) # a list of converters ineq2eq = InequalityToEquality() int2bin = IntegerToBinary() penalize = LinearEqualityToPenalty() converters = [ineq2eq, int2bin, penalize] recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer( min_eigen_optimizer, min_num_vars=2, converters=converters) result = recursive_min_eigen_optimizer.solve(op) self.assertEqual(result.fval, 4) # invalid converters with self.assertRaises(TypeError): invalid = [qp2qubo, "invalid converter"] RecursiveMinimumEigenOptimizer(min_eigen_optimizer, min_num_vars=2, converters=invalid)
def test_min_eigen_optimizer_with_filter(self, config): """ Min Eigen Optimizer Test """ try: # unpack configuration filename, lowerbound, fval, status = config # get minimum eigen solver min_eigen_solver = NumPyMinimumEigensolver() # set filter # pylint: disable=unused-argument def filter_criterion(x, v, aux): return v > lowerbound min_eigen_solver.filter_criterion = filter_criterion # construct minimum eigen optimizer min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) # load optimization problem problem = QuadraticProgram() lp_file = self.get_resource_path(filename, 'algorithms/resources') problem.read_from_lp_file(lp_file) # solve problem result = min_eigen_optimizer.solve(problem) self.assertIsNotNone(result) # analyze results self.assertAlmostEqual(fval, result.fval) self.assertEqual(status, result.status) # 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))
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) new_x = converter.interpret(result.x) self.assertEqual(new_x[0], 10.9) except MissingOptionalLibraryError as ex: self.skipTest(str(ex))
def test_samples(self): """Test samples""" SUCCESS = OptimizationResultStatus.SUCCESS # pylint: disable=invalid-name algorithm_globals.random_seed = 123 quantum_instance = QuantumInstance(backend=BasicAer.get_backend('qasm_simulator'), seed_simulator=123, seed_transpiler=123, shots=1000) # test minimize op = QuadraticProgram() op.integer_var(0, 3, 'x') op.binary_var('y') op.minimize(linear={'x': 1, 'y': 2}) op.linear_constraint(linear={'x': 1, 'y': 1}, sense='>=', rhs=1, name='xy') min_eigen_solver = NumPyMinimumEigensolver() min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) result = min_eigen_optimizer.solve(op) opt_sol = 1 self.assertEqual(result.fval, opt_sol) self.assertEqual(len(result.samples), 1) np.testing.assert_array_almost_equal(result.samples[0].x, [1, 0]) self.assertAlmostEqual(result.samples[0].fval, opt_sol) self.assertAlmostEqual(result.samples[0].probability, 1.0) self.assertEqual(result.samples[0].status, SUCCESS) self.assertEqual(len(result.raw_samples), 1) np.testing.assert_array_almost_equal(result.raw_samples[0].x, [1, 0, 0, 0, 0]) self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol) self.assertAlmostEqual(result.raw_samples[0].probability, 1.0) self.assertEqual(result.raw_samples[0].status, SUCCESS) qaoa = QAOA(quantum_instance=quantum_instance) min_eigen_optimizer = MinimumEigenOptimizer(qaoa) result = min_eigen_optimizer.solve(op) self.assertEqual(len(result.samples), 8) self.assertEqual(len(result.raw_samples), 32) self.assertAlmostEqual(sum(s.probability for s in result.samples), 1) self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1) self.assertAlmostEqual(min(s.fval for s in result.samples), 0) self.assertAlmostEqual(min(s.fval for s in result.samples if s.status == SUCCESS), opt_sol) self.assertAlmostEqual(min(s.fval for s in result.raw_samples), opt_sol) for sample in result.raw_samples: self.assertEqual(sample.status, SUCCESS) np.testing.assert_array_almost_equal(result.x, result.samples[0].x) self.assertAlmostEqual(result.fval, result.samples[0].fval) self.assertEqual(result.status, result.samples[0].status) # test maximize op = QuadraticProgram() op.integer_var(0, 3, 'x') op.binary_var('y') op.maximize(linear={'x': 1, 'y': 2}) op.linear_constraint(linear={'x': 1, 'y': 1}, sense='<=', rhs=1, name='xy') min_eigen_solver = NumPyMinimumEigensolver() min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver) result = min_eigen_optimizer.solve(op) opt_sol = 2 self.assertEqual(result.fval, opt_sol) self.assertEqual(len(result.samples), 1) np.testing.assert_array_almost_equal(result.samples[0].x, [0, 1]) self.assertAlmostEqual(result.samples[0].fval, opt_sol) self.assertAlmostEqual(result.samples[0].probability, 1.0) self.assertEqual(result.samples[0].status, SUCCESS) self.assertEqual(len(result.raw_samples), 1) np.testing.assert_array_almost_equal(result.raw_samples[0].x, [0, 0, 1, 0]) self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol) self.assertAlmostEqual(result.raw_samples[0].probability, 1.0) self.assertEqual(result.raw_samples[0].status, SUCCESS) qaoa = QAOA(quantum_instance=quantum_instance) min_eigen_optimizer = MinimumEigenOptimizer(qaoa) result = min_eigen_optimizer.solve(op) self.assertEqual(len(result.samples), 8) self.assertEqual(len(result.raw_samples), 16) self.assertAlmostEqual(sum(s.probability for s in result.samples), 1) self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1) self.assertAlmostEqual(max(s.fval for s in result.samples), 5) self.assertAlmostEqual(max(s.fval for s in result.samples if s.status == SUCCESS), opt_sol) self.assertAlmostEqual(max(s.fval for s in result.raw_samples), opt_sol) for sample in result.raw_samples: self.assertEqual(sample.status, SUCCESS) np.testing.assert_array_almost_equal(result.x, result.samples[0].x) self.assertAlmostEqual(result.fval, result.samples[0].fval) self.assertEqual(result.status, result.samples[0].status)
def test_samples_qaoa(self, simulator): """Test samples for QAOA""" # test minimize algorithm_globals.random_seed = 1 quantum_instance = self.sv_simulator if simulator == "sv" else self.qasm_simulator qaoa = QAOA(quantum_instance=quantum_instance, reps=2) min_eigen_optimizer = MinimumEigenOptimizer(qaoa) result = min_eigen_optimizer.solve(self.op_minimize) success = OptimizationResultStatus.SUCCESS opt_sol = 1 self.assertEqual(len(result.samples), 8) self.assertEqual(len(result.raw_samples), 32) self.assertAlmostEqual(sum(s.probability for s in result.samples), 1) self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1) self.assertAlmostEqual(min(s.fval for s in result.samples), 0) self.assertAlmostEqual(min(s.fval for s in result.samples if s.status == success), opt_sol) self.assertAlmostEqual(min(s.fval for s in result.raw_samples), opt_sol) for sample in result.raw_samples: self.assertEqual(sample.status, success) np.testing.assert_array_almost_equal(result.x, [1, 0]) self.assertAlmostEqual(result.fval, result.samples[0].fval) self.assertEqual(result.status, result.samples[0].status) self.assertAlmostEqual(result.samples[0].fval, opt_sol) self.assertEqual(result.samples[0].status, success) np.testing.assert_array_almost_equal(result.raw_samples[0].x, [1, 0, 0, 0, 0]) self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol) self.assertEqual(result.raw_samples[0].status, success) # test maximize opt_sol = 2 qaoa = QAOA(quantum_instance=quantum_instance, reps=2) min_eigen_optimizer = MinimumEigenOptimizer(qaoa) result = min_eigen_optimizer.solve(self.op_maximize) self.assertEqual(len(result.samples), 8) self.assertEqual(len(result.raw_samples), 16) self.assertAlmostEqual(sum(s.probability for s in result.samples), 1) self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1) self.assertAlmostEqual(max(s.fval for s in result.samples), 5) self.assertAlmostEqual(max(s.fval for s in result.samples if s.status == success), opt_sol) self.assertAlmostEqual(max(s.fval for s in result.raw_samples), opt_sol) for sample in result.raw_samples: self.assertEqual(sample.status, success) np.testing.assert_array_almost_equal(result.x, [0, 1]) self.assertEqual(result.fval, opt_sol) self.assertEqual(result.status, success) np.testing.assert_array_almost_equal(result.samples[0].x, [0, 1]) self.assertAlmostEqual(result.samples[0].fval, opt_sol) self.assertEqual(result.samples[0].status, success) np.testing.assert_array_almost_equal(result.raw_samples[0].x, [0, 0, 1, 0]) self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol) self.assertEqual(result.raw_samples[0].status, success) # test bit ordering opt_sol = -2 qaoa = QAOA(quantum_instance=quantum_instance, reps=2) min_eigen_optimizer = MinimumEigenOptimizer(qaoa) result = min_eigen_optimizer.solve(self.op_ordering) self.assertEqual(result.fval, opt_sol) np.testing.assert_array_almost_equal(result.x, [0, 1]) self.assertEqual(result.status, success) result.raw_samples.sort(key=lambda x: x.probability, reverse=True) np.testing.assert_array_almost_equal(result.x, result.raw_samples[0].x) self.assertAlmostEqual(sum(s.probability for s in result.samples), 1, delta=1e-5) self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1, delta=1e-5) self.assertAlmostEqual(min(s.fval for s in result.samples), -2) self.assertAlmostEqual(min(s.fval for s in result.samples if s.status == success), opt_sol) self.assertAlmostEqual(min(s.fval for s in result.raw_samples), opt_sol) for sample in result.raw_samples: self.assertEqual(sample.status, success) np.testing.assert_array_almost_equal(result.samples[0].x, [0, 1]) self.assertAlmostEqual(result.samples[0].fval, opt_sol) self.assertEqual(result.samples[0].status, success) np.testing.assert_array_almost_equal(result.raw_samples[0].x, [0, 1]) self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol) self.assertEqual(result.raw_samples[0].status, success)