def test_validation(self):
""" Validation Test """
num_var = 3
# validate an object type of the input.
with self.assertRaises(AquaError):
docplex._validate_input_model("Model")
# validate the types of the variables are binary or not
with self.assertRaises(AquaError):
mdl = Model(name='Error_integer_variables')
x = {
i: mdl.integer_var(name='x_{0}'.format(i))
for i in range(num_var)
}
obj_func = mdl.sum(x[i] for i in range(num_var))
mdl.maximize(obj_func)
docplex.get_operator(mdl)
# validate types of constraints are equality constraints or not.
with self.assertRaises(AquaError):
mdl = Model(name='Error_inequality_constraints')
x = {
i: mdl.binary_var(name='x_{0}'.format(i))
for i in range(num_var)
}
obj_func = mdl.sum(x[i] for i in range(num_var))
mdl.maximize(obj_func)
mdl.add_constraint(mdl.sum(x[i] for i in range(num_var)) <= 1)
docplex.get_operator(mdl)
def test_docplex_constant_and_quadratic_terms_in_object_function(self):
""" Docplex Constant and Quadratic terms in Object function test """
# Create an Ising Hamiltonian with docplex
laplacian = np.array([[-3., 1., 1., 1.], [1., -2., 1., -0.],
[1., 1., -3., 1.], [1., -0., 1., -2.]])
mdl = Model()
# pylint: disable=unsubscriptable-object
n = laplacian.shape[0]
bias = [0] * 4
x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}
couplers_func = mdl.sum(2 * laplacian[i, j] * (2 * x[i] - 1) *
(2 * x[j] - 1) for i in range(n - 1)
for j in range(i, n))
bias_func = mdl.sum(float(bias[i]) * x[i] for i in range(n))
ising_func = couplers_func + bias_func
mdl.minimize(ising_func)
qubit_op, offset = docplex.get_operator(mdl)
e_e = ExactEigensolver(qubit_op, k=1)
result = e_e.run()
expected_result = -22
# Compare objective
self.assertEqual(result['energy'] + offset, expected_result)
def test_docplex_tsp(self):
""" Docplex tsp test """
# Generating a graph of 3 nodes
n = 3
ins = tsp.random_tsp(n)
graph = nx.Graph()
graph.add_nodes_from(np.arange(0, n, 1))
num_node = ins.dim
# Create an Ising Hamiltonian with docplex.
mdl = Model(name='tsp')
x = {(i, p): mdl.binary_var(name='x_{0}_{1}'.format(i, p))
for i in range(num_node) for p in range(num_node)}
tsp_func = mdl.sum(ins.w[i, j] * x[(i, p)] * x[(j, (p + 1) % num_node)]
for i in range(num_node) for j in range(num_node)
for p in range(num_node))
mdl.minimize(tsp_func)
for i in range(num_node):
mdl.add_constraint(
mdl.sum(x[(i, p)] for p in range(num_node)) == 1)
for j in range(num_node):
mdl.add_constraint(
mdl.sum(x[(i, j)] for i in range(num_node)) == 1)
qubit_op, offset = docplex.get_operator(mdl)
e_e = ExactEigensolver(qubit_op, k=1)
result = e_e.run()
ee_expected = ExactEigensolver(QUBIT_OP_TSP, k=1)
expected_result = ee_expected.run()
# Compare objective
self.assertEqual(result['energy'] + offset,
expected_result['energy'] + OFFSET_TSP)
def test_docplex_maxcut(self):
""" Docplex maxcut test """
# Generating 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)
# Computing the weight matrix from the random graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = graph.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp['weight']
# Create an Ising Hamiltonian with docplex.
mdl = Model(name='max_cut')
mdl.node_vars = mdl.binary_var_list(list(range(4)), name='node')
maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] *
(1 - mdl.node_vars[j]) for i in range(n)
for j in range(n))
mdl.maximize(maxcut_func)
qubit_op, offset = docplex.get_operator(mdl)
e_e = ExactEigensolver(qubit_op, k=1)
result = e_e.run()
ee_expected = ExactEigensolver(QUBIT_OP_MAXCUT, k=1)
expected_result = ee_expected.run()
# Compare objective
self.assertEqual(result['energy'] + offset,
expected_result['energy'] + OFFSET_MAXCUT)
def run_simulation(self, backend):
#
# Random 3-regular graph with 12 nodes
#
n = int(os.environ.get("N", "4"))
graph = nx.random_regular_graph(3, n)
for e in graph.edges():
graph[e[0]][e[1]]['weight'] = 1.0
# Compute the weight matrix from the graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = graph.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp["weight"]
# Create an Ising Hamiltonian with docplex.
mdl = Model(name="max_cut")
mdl.node_vars = mdl.binary_var_list(list(range(n)), name="node")
maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] *
(1 - mdl.node_vars[j]) for i in range(n)
for j in range(n))
mdl.maximize(maxcut_func)
qubit_op, offset = docplex.get_operator(mdl)
# Run quantum algorithm QAOA on qasm simulator
seed = int(os.environ.get("SEED", "40598"))
aqua_globals.random_seed = seed
spsa = SPSA(max_trials=250)
qaoa = QAOA(qubit_op, spsa, p=5, max_evals_grouped=4)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=0)
result = qaoa.run(quantum_instance)
x = sample_most_likely(result["eigvecs"][0])
result["solution"] = max_cut.get_graph_solution(x)
result["solution_objective"] = max_cut.max_cut_value(x, w)
result["maxcut_objective"] = result["energy"] + offset
"""
print("energy:", result["energy"])
print("time:", result["eval_time"])
print("max-cut objective:", result["energy"] + offset)
print("solution:", max_cut.get_graph_solution(x))
print("solution objective:", max_cut.max_cut_value(x, w))
"""
return result
def test_docplex_integer_constraints(self):
""" Docplex Integer Constraints test """
# Create an Ising Hamiltonian with docplex
mdl = Model(name='integer_constraints')
x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(1, 5)}
max_vars_func = mdl.sum(x[i] for i in range(1, 5))
mdl.maximize(max_vars_func)
mdl.add_constraint(mdl.sum(i * x[i] for i in range(1, 5)) == 3)
qubit_op, offset = docplex.get_operator(mdl)
e_e = ExactEigensolver(qubit_op, k=1)
result = e_e.run()
expected_result = -2
# Compare objective
self.assertEqual(result['energy'] + offset, expected_result)
def test_constants_in_left_side_and_variables_in_right_side(self):
""" Test Constant values on the left-hand side of constraints and
variables on the right-hand side of constraints for the DOcplex translator"""
mdl = Model('left_constants_and_right_variables')
x = mdl.binary_var(name='x')
y = mdl.binary_var(name='y')
mdl.maximize(mdl.sum(x + y))
mdl.add_constraint(x == y)
qubit_op, offset = docplex.get_operator(mdl)
print(qubit_op.print_details())
e_e = NumPyMinimumEigensolver(qubit_op)
result = e_e.run()
self.assertEqual(result['eigenvalue'] + offset, -2)
actual_sol = result['eigenstate'].tolist()
self.assertListEqual(actual_sol, [0, 0, 0, 1])
def test_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel,redefined-builtin
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 docplex.mp.model import Model
from qiskit import BasicAer
from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.algorithms import QAOA
from qiskit.aqua.components.optimizers import SPSA
from qiskit.optimization.ising import docplex, max_cut
from qiskit.optimization.ising.common import sample_most_likely
# 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 = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = graph.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp['weight']
# Create an Ising Hamiltonian with docplex.
mdl = Model(name='max_cut')
mdl.node_vars = mdl.binary_var_list(list(range(n)), name='node')
maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] * (1 - mdl.node_vars[j])
for i in range(n) for j in range(n))
mdl.maximize(maxcut_func)
qubit_op, offset = docplex.get_operator(mdl)
# Run quantum algorithm QAOA on qasm simulator
seed = 40598
aqua_globals.random_seed = seed
spsa = SPSA(max_trials=250)
qaoa = QAOA(qubit_op, spsa, p=5)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed,
seed_transpiler=seed)
result = qaoa.run(quantum_instance)
x = sample_most_likely(result.eigenstate)
print('energy:', result.eigenvalue.real)
print('time:', result.optimizer_time)
print('max-cut objective:', result.eigenvalue.real + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
# ----------------------------------------------------------------------
self.assertListEqual(max_cut.get_graph_solution(x).tolist(), [1, 0, 1, 0])
self.assertAlmostEqual(max_cut.max_cut_value(x, w), 4.0)
graph.add_weighted_edges_from(elist)
# Compute the weight matrix from the graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = graph.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp['weight']
# Create an Ising Hamiltonian with docplex.
mdl = Model(name='max_cut')
mdl.node_vars = mdl.binary_var_list(list(range(n)), name='node')
maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] * (1 - mdl.node_vars[j])
for i in range(n) for j in range(n))
mdl.maximize(maxcut_func)
qubit_op, offset = docplex.get_operator(mdl)
# Run quantum algorithm QAOA on qasm simulator
seed = 40598
aqua_globals.random_seed = seed
spsa = SPSA(max_trials=250)
qaoa = QAOA(qubit_op, spsa, p=2)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed,
seed_transpiler=seed)
result = qaoa.run(quantum_instance)
parameters=qaoa.optimal_params
x = sample_most_likely(result['eigvecs'][0])
print('energy:', result['energy'])
