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)