class_docstr: Encodes :math:`N` features into :math:`n>N` qubits, using a layered, trainable quantum
  circuit that is inspired by the QAOA ansatz.
  
  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 qml
  
          dev = qml.device('default.qubit', wires=2)
  
          @qml.qnode(dev)
          def circuit(weights, f=None):
              qml.QAOAEmbedding(features=f, weights=weights, wires=range(2))
              return qml.expval(qml.PauliZ(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 = qml.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 = qml.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
  
          @qml.qnode(dev)
          def circuit2(weights, features):
              qml.QAOAEmbedding(features=features, weights=weights, wires=range(2))
              return qml.expval(qml.PauliZ(0))
  
  
          features = [1., 2.]
          weights = [[0.1, -0.3, 1.5], [3.1, 0.2, -2.8]]
  
          opt = qml.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
  
          @qml.qnode(dev)
          def circuit(weights, f=None):
              qml.QAOAEmbedding(features=f, weights=weights, wires=range(2), local_field='Z')
              return qml.expval(qml.PauliZ(0))
  
      Choosing ``'Z'`` fields implements a QAOAEmbedding where the second Hamiltonian is a
      1-dimensional Ising model.
docstr: 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
code: 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
  
file_path: pennylane/pennylane/templates/embeddings/qaoaembedding.py
imports: import pennylane
  from pennylane.operation import Operation, AnyWires
label_desc: Use image node_id 5 for calling the QAOAEmbedding obj's underlying member method code with example usage: obj.shape(n_layers, n_wires, n_broadcast) and returns: n_layers,  wire_dim, n_broadcast,  n_layers,  wire_dim