Source code for pennylane.templates.embeddings.qaoaembedding

# Copyright 2018-2021 Xanadu Quantum Technologies Inc.

# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at

#     http://www.apache.org/licenses/LICENSE-2.0

# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
r"""
Contains the QAOAEmbedding template.
"""

from collections import defaultdict

from jax import numpy as jnp

from pennylane import capture, math
from pennylane.control_flow import for_loop
from pennylane.core.operator import Operation, abstractify
from pennylane.decomposition import add_decomps, register_resources
from pennylane.ops import RX, RY, RZ, H, MultiRZ, cond
from pennylane.typing import Float, Wire


[docs] class QAOAEmbedding(Operation): r""" Encodes :math:`N` features into :math:`n>N` qubits, using a layered, trainable quantum circuit that is inspired by the QAOA ansatz proposed by `Killoran et al. (2020) <https://arxiv.org/abs/2001.03622>`_. A single layer applies two circuits or "Hamiltonians": The first encodes the features, and the second is a variational ansatz inspired by a 1-dimensional Ising model. The feature-encoding circuit associates features with the angles of :class:`RX` rotations. The Ising ansatz consists of trainable two-qubit ZZ interactions :math:`e^{-i \frac{\alpha}{2} \sigma_z \otimes \sigma_z}` (in PennyLane represented by the :class:`~.MultiRZ` gate), and trainable local fields :math:`e^{-i \frac{\beta}{2} \sigma_{\mu}}`, where :math:`\sigma_{\mu}` can be chosen to be :math:`\sigma_{x}`, :math:`\sigma_{y}` or :math:`\sigma_{z}` (default choice is :math:`\sigma_{y}` or the ``RY`` gate), and :math:`\alpha, \beta` are adjustable gate parameters. The number of features has to be smaller or equal to the number of qubits. If there are fewer features than qubits, the feature-encoding rotation is replaced by a Hadamard gate. The argument ``weights`` contains an array of the :math:`\alpha, \beta` parameters for each layer. The number of layers :math:`L` is derived from the first dimension of ``weights``, which has the following shape: * :math:`(L, 1)`, if the embedding acts on a single wire, * :math:`(L, 3)`, if the embedding acts on two wires, * :math:`(L, 2n)` else. After the :math:`L` th layer, another set of feature-encoding :class:`RX` gates is applied. This is an example for the full embedding circuit using 2 layers, 3 features, 4 wires, and ``RY`` local fields: | .. figure:: ../../_static/qaoa_layers.png :align: center :width: 60% :target: javascript:void(0); | .. note:: ``QAOAEmbedding`` supports gradient computations with respect to both the ``features`` and the ``weights`` arguments. Note that trainable parameters need to be passed to the quantum node as positional arguments. Args: features (tensor_like): tensor of features to encode weights (tensor_like): tensor of weights wires (Iterable): wires that the template acts on local_field (str, type): type of local field used, either one of ``'X'``, ``'Y'``, or ``'Z'`` or :class:`~.RX`, :class:`~.RY`, or :class:`~.RZ`. Raises: ValueError: if inputs do not have the correct format .. details:: :title: Usage Details The QAOA embedding encodes an :math:`n`-dimensional feature vector into at most :math:`n` qubits. The embedding applies layers of a circuit, and each layer is defined by a set of weight parameters. .. code-block:: python import pennylane as qp dev = qp.device('default.qubit', wires=2) @qp.qnode(dev) def circuit(weights, f=None): qp.QAOAEmbedding(features=f, weights=weights, wires=range(2)) return qp.expval(qp.Z(0)) features = [1., 2.] layer1 = [0.1, -0.3, 1.5] layer2 = [3.1, 0.2, -2.8] weights = [layer1, layer2] print(circuit(weights, f=features)) **Parameter shape** The shape of the weights argument can be computed by the static method :meth:`~.QAOAEmbedding.shape` and used when creating randomly initialised weight tensors: .. code-block:: python shape = qp.QAOAEmbedding.shape(n_layers=2, n_wires=2) weights = np.random.random(shape) **Training the embedding** The embedding is typically trained with respect to a given cost. For example, one can train it to minimize the PauliZ expectation of the first qubit: .. code-block:: python opt = qp.GradientDescentOptimizer() for i in range(10): weights = opt.step(lambda w : circuit(w, f=features), weights) print("Step ", i, " weights = ", weights) **Training the features** In principle, also the features are trainable, which means that gradients with respect to feature values can be computed. To train both weights and features, they need to be passed to the qnode as positional arguments. If the built-in optimizer is used, they have to be merged to one input: .. code-block:: python @qp.qnode(dev) def circuit2(weights, features): qp.QAOAEmbedding(features=features, weights=weights, wires=range(2)) return qp.expval(qp.Z(0)) features = qp.numpy.array([1., 2.]) weights = qp.numpy.array([[0.1, -0.3, 1.5], [3.1, 0.2, -2.8]]) opt = qp.GradientDescentOptimizer() for i in range(10): weights, features = opt.step(circuit2, weights, features) print("Step ", i, "\n weights = ", weights, "\n features = ", features,"\n") **Local Fields** While by default, ``RY`` gates are used as local fields, one may also choose ``local_field='Z'`` or ``local_field='X'`` as hyperparameters of the embedding. .. code-block:: python @qp.qnode(dev) def circuit(weights, f=None): qp.QAOAEmbedding(features=f, weights=weights, wires=range(2), local_field='Z') return qp.expval(qp.Z(0)) Choosing ``'Z'`` fields implements a QAOAEmbedding where the second Hamiltonian is a 1-dimensional Ising model. """ grad_method = None resource_keys = {"repeat", "n_features", "num_wires", "local_field"} def __init__(self, features, weights, wires, local_field="Y"): if local_field == "Z": local_field = RZ elif local_field == "X": local_field = RX elif local_field == "Y": local_field = RY elif not (isinstance(local_field, type) and issubclass(local_field, (RX, RY, RZ))): raise ValueError(f"did not recognize local field {local_field}") shape = math.shape(features) if len(shape) not in {1, 2}: raise ValueError( "Features must be a one-dimensional tensor or two-dimensional with broadcasting;" f" got shape {shape}." ) n_features = shape[-1] if n_features > len(wires): raise ValueError( f"Features must be of length {len(wires)} or less; got length {n_features}." ) shape = math.shape(weights) if len(shape) not in {2, 3}: raise ValueError( "Weights must be a two-dimensional tensor or three-dimensional with broadcasting;" f" got shape {shape}." ) # Either the first or the second axis (with broadcasting) gives the number of repetitions repeat = shape[-2] if len(wires) == 1: exp_shape = (repeat, 1) elif len(wires) == 2: exp_shape = (repeat, 3) else: exp_shape = (repeat, 2 * len(wires)) if shape[-2:] != exp_shape: raise ValueError(f"Weights tensor must be of shape {exp_shape}; got {shape}") self._hyperparameters = {"local_field": local_field} super().__init__(features, weights, wires=wires) @property def num_params(self): return 2 @property def ndim_params(self): # The feature vector has one dimension, the weights tensor has two. return (1, 2) @property def resource_params(self) -> dict: return { "repeat": math.shape(self.parameters[1])[-2], "n_features": math.shape(self.parameters[0])[-1], "num_wires": len(self.wires), "local_field": self.hyperparameters["local_field"], }
[docs] @staticmethod def shape(n_layers, n_wires, n_broadcast=None): r"""Returns the shape of the weight tensor required for this template. Args: n_layers (int): number of layers n_wires (int): number of qubits Returns: tuple[int]: shape """ if n_wires == 1: wire_dim = 1 elif n_wires == 2: wire_dim = 3 else: wire_dim = 2 * n_wires if n_broadcast: return n_broadcast, n_layers, wire_dim return n_layers, wire_dim
def _qaoa_embedding_standard_resources(repeat, n_features, num_wires, local_field): multi_rz_count = num_wires * repeat if num_wires > 2 else repeat resources = defaultdict( int, { RX: n_features * (repeat + 1), H: (num_wires - n_features) * (repeat + 1), MultiRZ(Float, Wire[2]): multi_rz_count, }, ) resources[abstractify(local_field)] += num_wires * repeat return resources @register_resources(_qaoa_embedding_standard_resources, name="feature_and_ansatz_layers") def _qaoa_embedding_standard(features, weights, wires, local_field): # pylint: disable=no-value-for-parameter if capture.enabled(): weights, wires, features = jnp.array(weights), jnp.array(wires), jnp.array(features) repeat = math.shape(weights)[-2] n_features = math.shape(features)[-1] if math.ndim(features) > 1: features = math.T(features) if math.ndim(weights) > 2: weights = math.moveaxis(weights, 0, -1) @for_loop(repeat) def repeat_loop(l): @for_loop(n_features) def features_loop(i): RX(features[i], wires=wires[i]) features_loop() @for_loop(n_features, len(wires)) def hadamard_loop(i): H(wires=wires[i]) hadamard_loop() def true_body(): local_field(weights[l][0], wires=wires) def false_body(): @for_loop(len(wires)) def multi_rz_loop(i): MultiRZ(weights[l][i], wires=[wires[i], wires[(i + 1) % len(wires)]]) multi_rz_loop() @for_loop(len(wires)) def local_field_loop(i): local_field(weights[l][len(wires) + i], wires=wires[i]) local_field_loop() def elif_body(): MultiRZ(weights[l][0], wires=[wires[0], wires[1]]) local_field(weights[l][1], wires=wires[0:1]) local_field(weights[l][2], wires=wires[1:2]) cond(len(wires) == 1, true_body, false_body, ((len(wires) == 2, elif_body),))() repeat_loop() @for_loop(n_features) def final_rx_loop(i): RX(features[i], wires=wires[i]) final_rx_loop() @for_loop(n_features, len(wires)) def final_hadamard_loop(i): H(wires=wires[i]) final_hadamard_loop() add_decomps(QAOAEmbedding, _qaoa_embedding_standard)