# Source code for pennylane.templates.layers

```
# Copyright 2018 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"""
This module contains templates for trainable 'layers' of quantum gates.
In contrast to other templates such as embeddings, layers
do typically only take trainable parameters, and get repeated in the circuit -- just like the layers of a
neural network. This makes the layer 'learnable' within the limits of the architecture.
Most templates in this module have a 'Layer' version that implements a single layer, as well as a 'Layers'
version which calls the single layer multiple times, possibly using different hyperparameters for the
sequence in each call.
"""
#pylint: disable-msg=too-many-branches,too-many-arguments,protected-access
from collections.abc import Sequence
from pennylane.ops import CNOT, RX, RY, RZ, Rot, Squeezing, Displacement, Kerr, Beamsplitter, Rotation
from pennylane.qnode import QuantumFunctionError
from pennylane.variable import Variable
import numpy as np
[docs]def StronglyEntanglingLayers(weights, wires, ranges=None, imprimitive=CNOT):
r"""A sequence of layers of type :func:`StronglyEntanglingLayer()`, as specified in :cite:`schuld2018circuit`.
The number of layers :math:`L` is determined by the first dimension of ``weights``. The template is applied to
the qubits specified by the sequence ``wires``.
Args:
weights (array[float]): array of weights of shape ``(L, len(wires), 3)``
wires (Sequence[int]): sequence of qubit indices that the template acts on
Keyword Args:
ranges (Sequence[int]): sequence determining the range hyperparameter for each subsequent layer
imprimitive (pennylane.ops.Operation): two-qubit gate to use, defaults to :class:`~pennylane.ops.CNOT`
"""
if ranges is None:
ranges = [1]*len(weights)
for block_weights, block_range in zip(weights, ranges):
StronglyEntanglingLayer(block_weights, r=block_range, imprimitive=imprimitive, wires=wires)
[docs]def StronglyEntanglingLayer(weights, wires, r=1, imprimitive=CNOT):
r"""A layer applying rotations on each qubit followed by cascades of 2-qubit entangling gates.
The 2-qubit or imprimitive gates act on each qubit :math:`i` chronologically. The second qubit for
each gate is determined by :math:`(i+r)\mod n`, where :math:`n` is equal to `len(wires)`
and :math:`range` a layer hyperparameter called the range.
This is an example of two 4-qubit strongly entangling layers (ranges :math:`r=1` and :math:`r=2`, respectively) with
rotations :math:`R` and CNOTs as imprimitives:
.. figure:: ../_static/layer_sec.png
:align: center
:width: 60%
:target: javascript:void(0);
Args:
weights (array[float]): array of weights of shape ``(len(wires), 3)``
wires (Sequence[int]): sequence of qubit indices that the template acts on
Keyword Args:
r (int): range of the imprimitive gates of this layer, defaults to 1
imprimitive (pennylane.ops.Operation): two-qubit gate to use, defaults to :class:`~pennylane.ops.CNOT`
"""
if len(wires) < 2:
raise ValueError("StronglyEntanglingLayer requires at least two wires or subsystems to apply "
"the imprimitive gates.")
for i, wire in enumerate(wires):
Rot(weights[i, 0], weights[i, 1], weights[i, 2], wires=wire)
num_wires = len(wires)
for i in range(num_wires):
imprimitive(wires=[wires[i], wires[(i + r) % num_wires]])
[docs]def RandomLayers(weights, wires, ratio_imprim=0.3, imprimitive=CNOT, rotations=None, seed=42):
r"""A sequence of layers of type :func:`RandomLayer()`.
The number of layers :math:`L` and the number :math:`k` of rotations per layer is inferred from the first
and second dimension of ``weights``. The type of imprimitive (two-qubit) gate and rotations distributed
randomly in the circuit can be chosen explicitly.
See :func:`RandomLayer` for details on the randomised behaviour.
Args:
weights (array[float]): array of weights of shape ``(L, k)``,
wires (Sequence[int]): sequence of qubit indices that the template acts on
Keyword Args:
ratio_imprim (float): value between 0 and 1 that determines the ratio of imprimitive to rotation
gates (default 0.3)
imprimitive (pennylane.ops.Operation): two-qubit gate to use, defaults to :class:`~pennylane.ops.CNOT`
rotations (list[pennylane.ops.Operation]): List of Pauli-X, Pauli-Y and/or Pauli-Z gates. The frequency
determines how often a particular rotation type is used. Defaults to the use of all three
rotations with equal frequency.
seed (int): seed to generate random architecture
"""
if rotations is None:
rotations = [RX, RY, RZ]
for layer_weights in weights:
RandomLayer(layer_weights, wires=wires, ratio_imprim=ratio_imprim, imprimitive=imprimitive, rotations=rotations,
seed=seed)
[docs]def RandomLayer(weights, wires, ratio_imprim=0.3, imprimitive=CNOT, rotations=None, seed=42):
r"""A layer of randomly chosen single qubit rotations and 2-qubit entangling gates, acting
on randomly chosen qubits.
The number :math:`k` of single qubit rotations is inferred from the first dimension of ``weights``.
This is an example of two 4-qubit random layers with four Pauli-y/Pauli-z rotations :math:`R_y, R_z`,
controlled-Z gates as imprimitives, as well as ``ratio_imprim=0.3``:
.. figure:: ../_static/layer_rnd.png
:align: center
:width: 60%
:target: javascript:void(0);
.. note::
Using the default seed (or any other fixed integer seed) generates one and the same circuit in every
quantum node. To generate different circuit architectures, either use a different random seed, or use ``seed=None``
together with the ``cache=False`` option when creating a quantum node.
.. warning::
If you use a random number generator anywhere inside the quantum function without the ``cache=False`` option,
a new random circuit architecture will be created every time the quantum node is evaluated.
Args:
weights (array[float]): array of weights of shape ``(k,)``
wires (Sequence[int]): sequence of qubit indices that the template acts on
Keyword Args:
ratio_imprim (float): value between 0 and 1 that determines the ratio of imprimitive to rotation gates
imprimitive (pennylane.ops.Operation): two-qubit gate to use, defaults to :class:`~pennylane.ops.CNOT`
rotations (list[pennylane.ops.Operation]): List of Pauli-X, Pauli-Y and/or Pauli-Z gates. The frequency
determines how often a particular rotation type is used. Defaults to the use of all three
rotations with equal frequency.
seed (int): seed to generate random architecture
"""
if len(wires) < 2:
raise ValueError("RandomLayer requires at least two wires or subsystems to apply "
"the imprimitive gates.")
if seed is not None:
np.random.seed(seed)
if rotations is None:
rotations = [RX, RY, RZ]
i = 0
while i < len(weights):
if np.random.random() > ratio_imprim:
gate = np.random.choice(rotations)
wire = np.random.choice(wires)
gate(weights[i], wires=wire)
i += 1
else:
on_wires = np.random.permutation(wires)[:2]
on_wires = list(on_wires)
imprimitive(wires=on_wires)
[docs]def CVNeuralNetLayers(theta_1, phi_1, varphi_1, r, phi_r, theta_2, phi_2, varphi_2, a, phi_a, k, wires):
r"""A sequence of layers of type :func:`CVNeuralNetLayer()`, as specified in :cite:`killoran2018continuous`.
The number of layers :math:`L` is inferred from the first dimension of the eleven weight parameters. The layers
act on the :math:`M` modes given in ``wires``, and include interferometers of :math:`K=M(M-1)/2` beamsplitters.
.. note::
The CV neural network architecture includes :class:`~pennylane.ops.Kerr` operations.
Make sure to use a suitable device, such as the :code:`strawberryfields.fock`
device of the `PennyLane-SF <https://github.com/XanaduAI/pennylane-sf>`_ plugin.
Args:
theta_1 (array[float]): length :math:`(L, K)` array of transmittivity angles for first interferometer
phi_1 (array[float]): length :math:`(L, K)` array of phase angles for first interferometer
varphi_1 (array[float]): length :math:`(L, M)` array of rotation angles to apply after first interferometer
r (array[float]): length :math:`(L, M)` array of squeezing amounts for :class:`~pennylane.ops.Squeezing` operations
phi_r (array[float]): length :math:`(L, M)` array of squeezing angles for :class:`~pennylane.ops.Squeezing` operations
theta_2 (array[float]): length :math:`(L, K)` array of transmittivity angles for second interferometer
phi_2 (array[float]): length :math:`(L, K)` array of phase angles for second interferometer
varphi_2 (array[float]): length :math:`(L, M)` array of rotation angles to apply after second interferometer
a (array[float]): length :math:`(L, M)` array of displacement magnitudes for :class:`~pennylane.ops.Displacement` operations
phi_a (array[float]): length :math:`(L, M)` array of displacement angles for :class:`~pennylane.ops.Displacement` operations
k (array[float]): length :math:`(L, M)` array of kerr parameters for :class:`~pennylane.ops.Kerr` operations
wires (Sequence[int]): sequence of mode indices that the template acts on
"""
inferred_layers = [len(theta_1), len(phi_1), len(varphi_1), len(r), len(phi_r), len(theta_2), len(phi_2),
len(varphi_2), len(a), len(phi_a), len(k)]
if inferred_layers.count(inferred_layers[0]) != len(inferred_layers):
raise ValueError("All parameter arrays need to have the same first dimension, from which the number "
"of layers is inferred; got first dimensions {}.".format(inferred_layers))
n_layers = len(theta_1)
for l in range(n_layers):
CVNeuralNetLayer(theta_1[l], phi_1[l], varphi_1[l], r[l], phi_r[l],
theta_2[l], phi_2[l], varphi_2[l], a[l], phi_a[l], k[l], wires=wires)
[docs]def CVNeuralNetLayer(theta_1, phi_1, varphi_1, r, phi_r, theta_2, phi_2, varphi_2, a, phi_a, k, wires):
r"""A layer of interferometers, displacement and squeezing gates mimicking a neural network,
as well as a Kerr gate nonlinearity.
The layer acts on the :math:`M` wires modes specified in ``wires``, and includes interferometers
of :math:`K=M(M-1)/2` beamsplitters.
This example shows a 4-mode CVNeuralNet layer with squeezing gates :math:`S`, displacement gates :math:`D` and
Kerr gates :math:`K`. The two big blocks are interferometers of type
:mod:`pennylane.templates.layers.Interferometer`:
.. figure:: ../_static/layer_cvqnn.png
:align: center
:width: 60%
:target: javascript:void(0);
.. note::
The CV neural network architecture includes :class:`~pennylane.ops.Kerr` operations.
Make sure to use a suitable device, such as the :code:`strawberryfields.fock`
device of the `PennyLane-SF <https://github.com/XanaduAI/pennylane-sf>`_ plugin.
Args:
theta_1 (array[float]): length :math:`(K, )` array of transmittivity angles for first interferometer
phi_1 (array[float]): length :math:`(K, )` array of phase angles for first interferometer
varphi_1 (array[float]): length :math:`(M, )` array of rotation angles to apply after first interferometer
r (array[float]): length :math:`(M, )` array of squeezing amounts for :class:`~pennylane.ops.Squeezing` operations
phi_r (array[float]): length :math:`(M, )` array of squeezing angles for :class:`~pennylane.ops.Squeezing` operations
theta_2 (array[float]): length :math:`(K, )` array of transmittivity angles for second interferometer
phi_2 (array[float]): length :math:`(K, )` array of phase angles for second interferometer
varphi_2 (array[float]): length :math:`(M, )` array of rotation angles to apply after second interferometer
a (array[float]): length :math:`(M, )` array of displacement magnitudes for :class:`~pennylane.ops.Displacement` operations
phi_a (array[float]): length :math:`(M, )` array of displacement angles for :class:`~pennylane.ops.Displacement` operations
k (array[float]): length :math:`(M, )` array of kerr parameters for :class:`~pennylane.ops.Kerr` operations
wires (Sequence[int]): sequence of mode indices that the template acts on
"""
Interferometer(theta=theta_1, phi=phi_1, varphi=varphi_1, wires=wires)
for i, wire in enumerate(wires):
Squeezing(r[i], phi_r[i], wires=wire)
Interferometer(theta=theta_2, phi=phi_2, varphi=varphi_2, wires=wires)
for i, wire in enumerate(wires):
Displacement(a[i], phi_a[i], wires=wire)
for i, wire in enumerate(wires):
Kerr(k[i], wires=wire)
[docs]def Interferometer(theta, phi, varphi, wires, mesh='rectangular', beamsplitter='pennylane'):
r"""General linear interferometer, an array of beamsplitters and phase shifters.
For :math:`M` wires, the general interferometer is specified by
providing :math:`M(M-1)/2` transmittivity angles :math:`\theta` and the same number of
phase angles :math:`\phi`, as well as either :math:`M-1` or :math:`M` additional rotation
parameters :math:`\varphi`.
For the parametrization of a universal interferometer
:math:`M-1` such rotation parameters are sufficient. If :math:`M` rotation
parameters are given, the interferometer is over-parametrized, but the resulting
circuit is more symmetric, which can be advantageous.
By specifying the keyword argument ``mesh``, the scheme used to implement the interferometer
may be adjusted:
* ``mesh='rectangular'`` (default): uses the scheme described in
:cite:`clements2016optimal`, resulting in a *rectangular* array of
:math:`M(M-1)/2` beamsplitters arranged in :math:`M` slices and ordered from left
to right and top to bottom in each slice. The first beamsplitter acts on
wires :math:`0` and :math:`1`:
.. figure:: ../_static/clements.png
:align: center
:width: 30%
:target: javascript:void(0);
* ``mesh='triangular'``: uses the scheme described in :cite:`reck1994experimental`,
resulting in a *triangular* array of :math:`M(M-1)/2` beamsplitters arranged in
:math:`2M-3` slices and ordered from left to right and top to bottom. The
first and fourth beamsplitters act on wires :math:`M-1` and :math:`M`, the second
on :math:`M-2` and :math:`M-1`, and the third on :math:`M-3` and :math:`M-2`, and
so on.
.. figure:: ../_static/reck.png
:align: center
:width: 30%
:target: javascript:void(0);
In both schemes, the network of :class:`~pennylane.ops.Beamsplitter` operations is followed by
:math:`M` (or :math:`M-1`) local :class:`~pennylane.ops.Rotation` Operations. In the latter case, the
rotation on the last wire is left out.
The rectangular decomposition is generally advantageous, as it has a lower
circuit depth (:math:`M` vs :math:`2M-3`) and optical depth than the triangular
decomposition, resulting in reduced optical loss.
This is an example of a 4-mode interferometer with beamsplitters :math:`B` and rotations :math:`R`,
using ``mesh='rectangular'``:
.. figure:: ../_static/layer_interferometer.png
:align: center
:width: 60%
:target: javascript:void(0);
.. note::
The decomposition as formulated in :cite:`clements2016optimal` uses a different
convention for a beamsplitter :math:`T(\theta, \phi)` than PennyLane, namely:
.. math:: T(\theta, \phi) = BS(\theta, 0) R(\phi)
For the universality of the decomposition, the used convention is irrelevant, but
for a given set of angles the resulting interferometers will be different.
If an interferometer consistent with the convention from :cite:`clements2016optimal`
is needed, the optional keyword argument ``beamsplitter='clements'`` can be specified. This
will result in each :class:`~pennylane.ops.Beamsplitter` being preceded by a :class:`~pennylane.ops.Rotation` and
thus increase the number of elementary operations in the circuit.
Args:
theta (array): length :math:`M(M-1)/2` array of transmittivity angles :math:`\theta`
phi (array): length :math:`M(M-1)/2` array of phase angles :math:`\phi`
varphi (array): length :math:`M` or :math:`M-1` array of rotation angles :math:`\varphi`
wires (Sequence[int]): wires the interferometer should act on
Keyword Args:
mesh (string): the type of mesh to use
beamsplitter (str): if ``clements``, the beamsplitter convention from
Clements et al. 2016 (https://dx.doi.org/10.1364/OPTICA.3.001460) is used; if ``pennylane``, the
beamsplitter is implemented via PennyLane's ``Beamsplitter`` operation.
"""
if isinstance(beamsplitter, Variable):
raise QuantumFunctionError("The beamsplitter parameter influences the "
"circuit architecture and can not be passed as a QNode parameter.")
if isinstance(mesh, Variable):
raise QuantumFunctionError("The mesh parameter influences the circuit architecture "
"and can not be passed as a QNode parameter.")
if not isinstance(wires, Sequence):
w = [wires]
else:
w = wires
M = len(w)
if M == 1:
# the interferometer is a single rotation
Rotation(varphi[0], wires=w[0])
return
n = 0 # keep track of free parameters
if mesh == 'rectangular':
# Apply the Clements beamsplitter array
# The array depth is N
for l in range(M):
for k, (w1, w2) in enumerate(zip(w[:-1], w[1:])):
#skip even or odd pairs depending on layer
if (l+k)%2 != 1:
if beamsplitter == 'clements':
Rotation(phi[n], wires=[w1])
Beamsplitter(theta[n], 0, wires=[w1, w2])
else:
Beamsplitter(theta[n], phi[n], wires=[w1, w2])
n += 1
elif mesh == 'triangular':
# apply the Reck beamsplitter array
# The array depth is 2*N-3
for l in range(2*M-3):
for k in range(abs(l+1-(M-1)), M-1, 2):
if beamsplitter == 'clements':
Rotation(phi[n], wires=[w[k]])
Beamsplitter(theta[n], 0, wires=[w[k], w[k+1]])
else:
Beamsplitter(theta[n], phi[n], wires=[w[k], w[k+1]])
n += 1
# apply the final local phase shifts to all modes
for i, p in enumerate(varphi):
Rotation(p, wires=[w[i]])
```