def DisplacementEmbedding(features, wires, method="amplitude", c=0.1):
r"""Encodes :math:`N` features into the displacement amplitudes :math:`r` or phases :math:`\phi` of :math:`M` modes,
where :math:`N\leq M`.
The mathematical definition of the displacement gate is given by the operator
.. math::
D(\alpha) = \exp(r (e^{i\phi}\ad -e^{-i\phi}\a)),
where :math:`\a` and :math:`\ad` are the bosonic creation and annihilation operators.
``features`` has to be an array of at most ``len(wires)`` floats. If there are fewer entries in
``features`` than wires, the circuit does not apply the remaining displacement gates.
Args:
features (array): Array of features of size (N,)
wires (Sequence[int]): sequence of mode indices that the template acts on
method (str): ``'phase'`` encodes the input into the phase of single-mode displacement, while
``'amplitude'`` uses the amplitude
c (float): value of the phase of all displacement gates if ``execution='amplitude'``, or
the amplitude of all displacement gates if ``execution='phase'``
Raises:
ValueError: if inputs do not have the correct format
"""
#############
# Input checks
_check_no_variable(method, msg="'method' cannot be differentiable")
_check_no_variable(c, msg="'c' cannot be differentiable")
wires = _check_wires(wires)
expected_shape = (len(wires), )
_check_shape(
features,
expected_shape,
bound="max",
msg="'features' must be of shape {} or smaller; got {}."
"".format(expected_shape, _get_shape(features)),
)
_check_is_in_options(
method,
["amplitude", "phase"],
msg="did not recognize option {} for 'method'"
"".format(method),
)
#############
for idx, f in enumerate(features):
if method == "amplitude":
Displacement(f, c, wires=wires[idx])
elif method == "phase":
Displacement(c, f, wires=wires[idx])
def cv_neural_net_layer(theta_1, phi_1, varphi_1, r, phi_r, theta_2, phi_2, varphi_2, a, phi_a, k, wires):
r"""A single continuous-variable neural network layer.
The layer acts on the :math:`M` wires modes specified in ``wires``, and includes interferometers
of :math:`K=M(M-1)/2` beamsplitters.
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)
def DisplacementEmbedding(features, wires, method='amplitude', c=0.1):
r"""Encodes :math:`N` features into the displacement amplitudes :math:`r` or phases :math:`\phi` of :math:`M` modes,
where :math:`N\leq M`.
The mathematical definition of the displacement gate is given by the operator
.. math::
D(\alpha) = \exp(r (e^{i\phi}\ad -e^{-i\phi}\a)),
where :math:`\a` and :math:`\ad` are the bosonic creation and annihilation operators.
``features`` has to be an array of at most ``len(wires)`` floats. If there are fewer entries in
``features`` than wires, the circuit does not apply the remaining displacement gates.
Args:
features (array): Array of features of size (N,)
wires (Sequence[int]): sequence of mode indices that the template acts on
Keyword Args:
method (str): ``'phase'`` encodes the input into the phase of single-mode displacement, while
``'amplitude'`` uses the amplitude
c (float): value of the phase of all displacement gates if ``execution='amplitude'``, or
the amplitude of all displacement gates if ``execution='phase'``
Raises:
ValueError: if ``features`` or ``wires`` is invalid or if ``method`` is unknown
"""
if not isinstance(wires, Iterable):
raise ValueError(
"Wires must be passed as a list of integers; got {}.".format(
wires))
if len(wires) < len(features):
raise ValueError(
"Number of features to embed cannot be larger than number of wires, which is {}; "
"got {}.".format(len(wires), len(features)))
for idx, f in enumerate(features):
if method == 'amplitude':
Displacement(f, c, wires=wires[idx])
elif method == 'phase':
Displacement(c, f, wires=wires[idx])
else:
raise ValueError(
"Execution method '{}' not known. Has to be 'phase' or 'amplitude'."
.format(method))
def DisplacementEmbedding(features, wires, method='amplitude', c=0.1):
r"""Encodes :math:`N` features into the displacement amplitudes :math:`r` or phases :math:`\phi` of :math:`M` modes,
where :math:`N\leq M`.
The mathematical definition of the displacement gate is given by the operator
.. math::
D(\alpha) = \exp(r (e^{i\phi}\ad -e^{-i\phi}\a)),
where :math:`\a` and :math:`\ad` are the bosonic creation and annihilation operators.
``features`` has to be an array of at most ``len(wires)`` floats. If there are fewer entries in
``features`` than wires, the circuit does not apply the remaining displacement gates.
Args:
features (array): Array of features of size (N,)
wires (Sequence[int]): sequence of mode indices that the template acts on
method (str): ``'phase'`` encodes the input into the phase of single-mode displacement, while
``'amplitude'`` uses the amplitude
c (float): value of the phase of all displacement gates if ``execution='amplitude'``, or
the amplitude of all displacement gates if ``execution='phase'``
Raises:
ValueError: if inputs do not have the correct format
"""
#############
# Input checks
_check_no_variable([method, c], ['method', 'c'])
wires, n_wires = _check_wires(wires)
msg = "DisplacementEmbedding cannot process more features than number of wires {};" \
"got {}.".format(n_wires, len(features))
_check_shape(features, (n_wires,), bound='max', msg=msg)
msg = "Did not recognise parameter encoding method {}.".format(method)
_check_hyperp_is_in_options(method, ['amplitude', 'phase'], msg=msg)
#############
for idx, f in enumerate(features):
if method == 'amplitude':
Displacement(f, c, wires=wires[idx])
elif method == 'phase':
Displacement(c, f, wires=wires[idx])
def quantum_circ(params, x=None):
# Encode input x into quantum state
Displacement(x[0], 0.0, wires=0)
Displacement(x[1], 0.0, wires=1)
CVNeuralNetLayersHomeMade(
params[0],
params[1],
params[2],
params[3],
params[4],
params[5],
params[6],
params[7],
params[8],
params[9],
params[10],
[0,1])
return expval(X(0))
def CVNeuralNetLayer(theta_1,
phi_1,
varphi_1,
r,
phi_r,
theta_2,
phi_2,
varphi_2,
a,
phi_a,
k,
wires=None):
"""pennylane.template.CVNeuralNetLayer(theta_1, phi_1, varphi_1, r, phi_r, theta_2, phi_2, varphi_2, a, phi_a, k, wires)
A single layer of a CV Quantum Neural Network
Implements a single layer from the the CV Quantum Neural Network (CVQNN)
architecture of :cite:`killoran2018continuous` over :math:`N` wires.
.. note::
The CV neural network architecture includes :class:`~.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:`N(N-1)/2` array of transmittivity angles for first interferometer
phi_1 (array[float]): length :math:`N(N-1)/2` array of phase angles for first interferometer
varphi_1 (array[float]): length :math:`N` array of final rotation angles for first interferometer
r (array[float]): length :math:`N` arrays of squeezing amounts for :class:`~.Squeezing` operations
phi_r (array[float]): length :math:`N` arrays of squeezing angles for :class:`~.Squeezing` operations
theta_2 (array[float]): length :math:`N(N-1)/2` array of transmittivity angles for second interferometer
phi_2 (array[float]): length :math:`N(N-1)/2` array of phase angles for second interferometer
varphi_2 (array[float]): length :math:`N` array of final rotation angles for second interferometer
a (array[float]): length :math:`N` arrays of displacement magnitudes for :class:`~.Displacement` operations
phi_a (array[float]): length :math:`N` arrays of displacement angles for :class:`~.Displacement` operations
k (array[float]): length :math:`N` arrays of kerr parameters for :class:`~.Kerr` operations
Keyword Args:
wires (Sequence[int]): wires the layer should act 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)
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:`~.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:`~.Squeezing` operations
phi_r (array[float]): length :math:`(M, )` array of squeezing angles for :class:`~.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:`~.Displacement` operations
phi_a (array[float]): length :math:`(M, )` array of displacement angles for :class:`~.Displacement` operations
k (array[float]): length :math:`(M, )` array of kerr parameters for :class:`~.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)
