def test_cost_graph_error(self):
"""Tests that the cost Hamiltonians throw the correct error"""
graph = [(0, 1), (1, 2)]
with pytest.raises(ValueError, match=r"Input graph must be a nx\.Graph"):
qaoa.maxcut(graph)
with pytest.raises(ValueError, match=r"Input graph must be a nx\.Graph"):
qaoa.max_independent_set(graph)
with pytest.raises(ValueError, match=r"Input graph must be a nx\.Graph"):
qaoa.min_vertex_cover(graph)
with pytest.raises(ValueError, match=r"Input graph must be a nx\.Graph"):
qaoa.max_clique(graph)
def test_mvc_output(self, graph, constrained, cost_hamiltonian, mixer_hamiltonian):
"""Tests that the output of the Min Vertex Cover method is correct"""
cost_h, mixer_h = qaoa.min_vertex_cover(graph, constrained=constrained)
assert decompose_hamiltonian(cost_hamiltonian) == decompose_hamiltonian(cost_h)
assert decompose_hamiltonian(mixer_hamiltonian) == decompose_hamiltonian(mixer_h)
def benchmark_qaoa(hyperparams={}):
"""
Performs QAOA optimizations.
Args:
hyperparams (dict): hyperparameters to configure this benchmark
* 'graph': Graph represented as a NetworkX Graph class
* 'n_layers': Number of layers in the QAOA circuit
* 'params': Numpy array of trainable parameters that is fed into the circuit
* 'device': Device on which the circuit is run
* 'interface': Name of the interface to use
* 'diff_method': Name of differentiation method
"""
graph, n_layers, params, device, options_dict = _qaoa_defaults(hyperparams)
H_cost, H_mixer = qaoa.min_vertex_cover(graph, constrained=False)
n_wires = len(graph.nodes)
def qaoa_layer(gamma, alpha):
qaoa.cost_layer(gamma, H_cost)
qaoa.mixer_layer(alpha, H_mixer)
@qml.qnode(device)
def circuit(params):
for w in range(n_wires):
qml.Hadamard(wires=w)
qml.layer(qaoa_layer, n_layers, params[0], params[1])
return [qml.sample(qml.PauliZ(i)) for i in range(n_wires)]
circuit(params)
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
import pennylane as qml
import pennylane.qaoa as qaoa
# start with a graph
edges = [(0, 1), (1, 2), (2, 0), (2, 3)]
graph = nx.Graph(edges)
#nx.draw(graph, with_labels=True)
#plt.show()
# cost and mixer is given from pennylane
cost_h, mixer_h = qaoa.min_vertex_cover(graph, constrained=False)
print('Cost Hamiltonian', cost_h)
print('Mixer Hamiltonian', mixer_h)
# QAOA with two parameters
def qaoa_layer(gamma, alpha):
qaoa.cost_layer(gamma, cost_h)
qaoa.mixer_layer(alpha, mixer_h)
# full circuit
wires = range(4)
depth = 2
# initial state and QAOA
def benchmark_power(dev_name, s3=None):
"""A substantial QAOA workflow
Args:
dev_name (str): Either "local", "sv1", "tn1", or "ionq"
s3 (tuple): A tuple of (bucket, prefix) to specify the s3 storage location
"""
if dev_name == "local":
n_wires = 15
device = qml.device("braket.local.qubit", wires=n_wires, shots=None)
elif dev_name == "sv1":
n_wires = 15
device = qml.device(
"braket.aws.qubit",
device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
s3_destination_folder=s3,
wires=n_wires,
shots=None,
)
elif dev_name == "tn1":
shots = 1000
n_wires = 15
device = qml.device(
"braket.aws.qubit",
device_arn="arn:aws:braket:::device/quantum-simulator/amazon/tn1",
s3_destination_folder=s3,
wires=n_wires,
shots=shots,
)
elif dev_name == "ionq":
shots = 100
n_wires = 11
device = qml.device(
"braket.aws.qubit",
device_arn="arn:aws:braket:::device/qpu/ionq/ionQdevice",
s3_destination_folder=s3,
wires=n_wires,
shots=shots,
)
else:
raise ValueError("dev_name not 'local', 'sv1','tn1', or 'ionq'")
n_layers = 1
graph = nx.complete_graph(n_wires)
params = 0.5 * pnp.ones((2, n_layers))
interface = "autograd"
diff_method = "best"
n_wires = len(graph.nodes)
H_cost, H_mixer = qaoa.min_vertex_cover(graph, constrained=False)
def qaoa_layer(gamma, alpha):
qaoa.cost_layer(gamma, H_cost)
qaoa.mixer_layer(alpha, H_mixer)
@qml.qnode(device, interface=interface, diff_method=diff_method)
def circuit(params):
for w in range(n_wires):
qml.Hadamard(wires=w)
qml.layer(qaoa_layer, n_layers, params[0], params[1])
return [qml.sample(qml.PauliZ(i)) for i in range(n_wires)]
circuit(params)