qml.plugins.default_qubit_tf.DefaultQubitTF

class DefaultQubitTF(wires, *, shots=1000, analytic=True)[source]

Bases: pennylane.plugins.default_qubit.DefaultQubit

Simulator plugin based on "default.qubit", written using TensorFlow.

Short name: default.qubit.tf

This device provides a pure-state qubit simulator written using TensorFlow. As a result, it supports classical backpropagation as a means to compute the Jacobian. This can be faster than the parameter-shift rule for analytic quantum gradients when the number of parameters to be optimized is large.

To use this device, you will need to install TensorFlow:

pip install tensorflow>=2.0

Example

The default.qubit.tf is designed to be used with end-to-end classical backpropagation (diff_method="backprop") with the TensorFlow interface. This is the default method of differentiation when creating a QNode with this device.

Using this method, the created QNode is a ‘white-box’, and is tightly integrated with your TensorFlow computation:

>>> dev = qml.device("default.qubit.tf", wires=1)
>>> @qml.qnode(dev, interface="tf", diff_method="backprop")
... def circuit(x):
...     qml.RX(x[1], wires=0)
...     qml.Rot(x[0], x[1], x[2], wires=0)
...     return qml.expval(qml.PauliZ(0))
>>> weights = tf.Variable([0.2, 0.5, 0.1])
>>> with tf.GradientTape() as tape:
...     res = circuit(weights)
>>> print(tape.gradient(res, weights))
tf.Tensor([-2.2526717e-01 -1.0086454e+00  1.3877788e-17], shape=(3,), dtype=float32)

Autograph mode will also work when using classical backpropagation:

>>> @tf.function
... def cost(weights):
...     return tf.reduce_sum(circuit(weights)**3) - 1
>>> with tf.GradientTape() as tape:
...     res = cost(weights)
>>> print(tape.gradient(res, weights))
tf.Tensor([-3.5471588e-01 -1.5882589e+00  3.4694470e-17], shape=(3,), dtype=float32)

There are a couple of things to keep in mind when using the "backprop" differentiation method for QNodes:

  • You must use the "tf" interface for classical backpropagation, as TensorFlow is used as the device backend.

  • Only exact expectation values, variances, and probabilities are differentiable. When instantiating the device with analytic=False, differentiating QNode outputs will result in None.

If you wish to use a different machine-learning interface, or prefer to calculate quantum gradients using the parameter-shift or finite-diff differentiation methods, consider using the default.qubit device instead.

Parameters
  • wires (int) – the number of wires to initialize the device with

  • shots (int) – How many times the circuit should be evaluated (or sampled) to estimate the expectation values. Defaults to 1000 if not specified. If analytic == True, then the number of shots is ignored in the calculation of expectation values and variances, and only controls the number of samples returned by sample.

  • analytic (bool) – indicates if the device should calculate expectations and variances analytically

C_DTYPE

R_DTYPE

author

circuit_hash

The hash of the circuit upon the last execution.

name

obs_queue

The observables to be measured and returned.

observables

op_queue

The operation queue to be applied.

operations

parameters

Mapping from free parameter index to the list of Operations in the device queue that depend on it.

parametric_ops

pennylane_requires

short_name

shots

Number of circuit evaluations/random samples used to estimate expectation values of observables

state

Returns the state vector of the circuit prior to measurement.

version

C_DTYPE = tf.complex128
R_DTYPE = tf.float64
author = 'Xanadu Inc.'
circuit_hash

The hash of the circuit upon the last execution.

This can be used by devices in apply() for parametric compilation.

name = 'Default qubit (TensorFlow) PennyLane plugin'
obs_queue

The observables to be measured and returned.

Note that this property can only be accessed within the execution context of execute().

Raises

ValueError – if outside of the execution context

Returns

list[~.operation.Observable]

observables = {'Hadamard', 'Hermitian', 'Identity', 'PauliX', 'PauliY', 'PauliZ'}
op_queue

The operation queue to be applied.

Note that this property can only be accessed within the execution context of execute().

Raises

ValueError – if outside of the execution context

Returns

list[~.operation.Operation]

operations = {'BasisState', 'CNOT', 'CRX', 'CRY', 'CRZ', 'CRot', 'CSWAP', 'CZ', 'DiagonalQubitUnitary', 'Hadamard', 'MultiRZ', 'PauliX', 'PauliY', 'PauliZ', 'PhaseShift', 'QubitStateVector', 'QubitUnitary', 'RX', 'RY', 'RZ', 'Rot', 'S', 'SWAP', 'T', 'Toffoli'}
parameters

Mapping from free parameter index to the list of Operations in the device queue that depend on it.

Note that this property can only be accessed within the execution context of execute().

Raises

ValueError – if outside of the execution context

Returns

the mapping

Return type

dict[int->list[ParameterDependency]]

parametric_ops = {'CRX': <function CRX>, 'CRY': <function CRY>, 'CRZ': <function CRZ>, 'PhaseShift': <function PhaseShift>, 'RX': <function RX>, 'RY': <function RY>, 'RZ': <function RZ>, 'Rot': <function Rot>}
pennylane_requires = '0.10'
short_name = 'default.qubit.tf'
shots

Number of circuit evaluations/random samples used to estimate expectation values of observables

state

Returns the state vector of the circuit prior to measurement.

Note

Only state vector simulators support this property. Please see the plugin documentation for more details.

version = '0.10.0'

active_wires(operators)

Returns the wires acted on by a set of operators.

analytic_probability([wires])

Return the (marginal) analytic probability of each computational basis state.

apply(operations[, rotations])

Apply quantum operations, rotate the circuit into the measurement basis, and compile and execute the quantum circuit.

capabilities()

Get the capabilities of the plugin.

check_validity(queue, observables)

Checks whether the operations and observables in queue are all supported by the device.

estimate_probability([wires])

Return the estimated probability of each computational basis state using the generated samples.

execute(circuit, **kwargs)

Execute a queue of quantum operations on the device and then measure the given observables.

execution_context()

The device execution context used during calls to execute().

expval(observable)

Returns the expectation value of observable on specified wires.

generate_samples()

Returns the computational basis samples generated for all wires.

marginal_prob(prob[, wires])

Return the marginal probability of the computational basis states by summing the probabiliites on the non-specified wires.

post_apply()

Called during execute() after the individual operations have been executed.

post_measure()

Called during execute() after the individual observables have been measured.

pre_apply()

Called during execute() before the individual operations are executed.

pre_measure()

Called during execute() before the individual observables are measured.

probability([wires])

Return either the analytic probability or estimated probability of each computational basis state.

reset()

Reset the device

sample(observable)

Return a sample of an observable.

sample_basis_states(number_of_states, …)

Sample from the computational basis states based on the state probability.

states_to_binary(samples, num_wires)

Convert basis states from base 10 to binary representation.

statistics(observables)

Process measurement results from circuit execution and return statistics.

supports_observable(observable)

Checks if an observable is supported by this device. Raises a ValueError,

supports_operation(operation)

Checks if an operation is supported by this device.

var(observable)

Returns the variance of observable on specified wires.

static active_wires(operators)

Returns the wires acted on by a set of operators.

Parameters

operators (list[Operation]) – operators for which we are gathering the active wires

Returns

the set of wires activated by the specified operators

Return type

set[int]

analytic_probability(wires=None)

Return the (marginal) analytic probability of each computational basis state.

apply(operations, rotations=None, **kwargs)

Apply quantum operations, rotate the circuit into the measurement basis, and compile and execute the quantum circuit.

This method receives a list of quantum operations queued by the QNode, and should be responsible for:

  • Constructing the quantum program

  • (Optional) Rotating the quantum circuit using the rotation operations provided. This diagonalizes the circuit so that arbitrary observables can be measured in the computational basis.

  • Compile the circuit

  • Execute the quantum circuit

Both arguments are provided as lists of PennyLane Operation instances. Useful properties include name, wires, and parameters, and inverse:

>>> op = qml.RX(0.2, wires=[0])
>>> op.name # returns the operation name
"RX"
>>> op.wires # wires that the operation acts on
[0]
>>> op.parameters # returns a list of parameters
[0.2]
>>> op.inverse # check if the operation should be inverted
False
>>> op = qml.RX(0.2, wires=[0]).inv
>>> op.inverse
True
Parameters

operations (list[Operation]) – operations to apply to the device

Keyword Arguments
  • rotations (list[Operation]) – operations that rotate the circuit pre-measurement into the eigenbasis of the observables.

  • hash (int) – the hash value of the circuit constructed by CircuitGraph.hash

classmethod capabilities()

Get the capabilities of the plugin.

Capabilities include:

  • "model" (str): either "qubit" or "CV".

  • "inverse_operations" (bool): True if the device supports applying the inverse of operations. Operations which should be inverted have operation.inverse == True.

  • "tensor_observables" (*bool*): ``True if the device supports expectation values/variance/samples of Tensor observables.

The qubit device class has built-in support for tensor observables. As a result, devices that inherit from this class automatically have the following items in their capabilities dictionary:

  • "model": "qubit"

  • "tensor_observables": True

Returns

results

Return type

dict[str->*]

check_validity(queue, observables)

Checks whether the operations and observables in queue are all supported by the device. Includes checks for inverse operations.

Parameters
  • queue (Iterable[Operation]) – quantum operation objects which are intended to be applied on the device

  • observables (Iterable[Observable]) – observables which are intended to be evaluated on the device

Raises

DeviceError – if there are operations in the queue or observables that the device does not support

estimate_probability(wires=None)

Return the estimated probability of each computational basis state using the generated samples.

Parameters

wires (Sequence[int]) – Sequence of wires to return marginal probabilities for. Wires not provided are traced out of the system.

Returns

list of the probabilities

Return type

List[float]

execute(circuit, **kwargs)

Execute a queue of quantum operations on the device and then measure the given observables.

For plugin developers: instead of overwriting this, consider implementing a suitable subset of

Additional keyword arguments may be passed to the this method that can be utilised by apply(). An example would be passing the QNode hash that can be used later for parametric compilation.

Parameters

circuit (CircuitGraph) – circuit to execute on the device

Raises

QuantumFunctionError – if the value of return_type is not supported

Returns

measured value(s)

Return type

array[float]

execution_context()

The device execution context used during calls to execute().

You can overwrite this function to return a context manager in case your quantum library requires that; all operations and method calls (including apply() and expval()) are then evaluated within the context of this context manager (see the source of Device.execute() for more details).

expval(observable)

Returns the expectation value of observable on specified wires.

Note: all arguments accept _lists_, which indicate a tensor product of observables.

Parameters
  • observable (str or list[str]) – name of the observable(s)

  • wires (List[int] or List[List[int]]) – subsystems the observable(s) is to be measured on

  • par (tuple or list[tuple]]) – parameters for the observable(s)

Returns

expectation value \(\expect{A} = \bra{\psi}A\ket{\psi}\)

Return type

float

generate_samples()

Returns the computational basis samples generated for all wires.

Note that PennyLane uses the convention \(|q_0,q_1,\dots,q_{N-1}\rangle\) where \(q_0\) is the most significant bit.

Warning

This method should be overwritten on devices that generate their own computational basis samples, with the resulting computational basis samples stored as self._samples.

Returns

array of samples in the shape (dev.shots, dev.num_wires)

Return type

array[complex]

marginal_prob(prob, wires=None)

Return the marginal probability of the computational basis states by summing the probabiliites on the non-specified wires.

If no wires are specified, then all the basis states representable by the device are considered and no marginalization takes place.

Note

If the provided wires are not strictly increasing, the returned marginal probabilities take this permuation into account.

For example, if wires=[2, 0], then the returned marginal probability vector will take this ‘reversal’ of the two wires into account:

\[\mathbb{P}^{(2, 0)} = \left[ |00\rangle, |10\rangle, |01\rangle, |11\rangle \right]\]
Parameters
  • prob – The probabilities to return the marginal probabilities for

  • wires (Sequence[int]) – Sequence of wires to return marginal probabilities for. Wires not provided are traced out of the system.

Returns

array of the resulting marginal probabilities.

Return type

array[float]

post_apply()

Called during execute() after the individual operations have been executed.

post_measure()

Called during execute() after the individual observables have been measured.

pre_apply()

Called during execute() before the individual operations are executed.

pre_measure()

Called during execute() before the individual observables are measured.

probability(wires=None)

Return either the analytic probability or estimated probability of each computational basis state.

If no analytic attributes exists for the device, then return the estimated probability.

Parameters

wires (Sequence[int]) – Sequence of wires to return marginal probabilities for. Wires not provided are traced out of the system.

Returns

list of the probabilities

Return type

List[float]

reset()

Reset the device

sample(observable)

Return a sample of an observable.

The number of samples is determined by the value of Device.shots, which can be directly modified.

Note: all arguments support _lists_, which indicate a tensor product of observables.

Parameters
  • observable (str or list[str]) – name of the observable(s)

  • wires (List[int] or List[List[int]]) – subsystems the observable(s) is to be measured on

  • par (tuple or list[tuple]]) – parameters for the observable(s)

Raises

NotImplementedError – if the device does not support sampling

Returns

samples in an array of dimension (n, num_wires)

Return type

array[float]

sample_basis_states(number_of_states, state_probability)

Sample from the computational basis states based on the state probability.

This is an auxiliary method to the generate_samples method.

Parameters

number_of_states (int) – the number of basis states to sample from

Returns

the sampled basis states

Return type

List[int]

static states_to_binary(samples, num_wires)

Convert basis states from base 10 to binary representation.

This is an auxiliary method to the generate_samples method.

Parameters
  • samples (List[int]) – samples of basis states in base 10 representation

  • number_of_states (int) – the number of basis states to sample from

Returns

basis states in binary representation

Return type

List[int]

statistics(observables)

Process measurement results from circuit execution and return statistics.

This includes returning expectation values, variance, samples and probabilities.

Parameters

observables (List[Observable]) – the observables to be measured

Raises

QuantumFunctionError – if the value of return_type is not supported

Returns

the corresponding statistics

Return type

Union[float, List[float]]

supports_observable(observable)
Checks if an observable is supported by this device. Raises a ValueError,

if not a subclass or string of an Observable was passed.

Parameters

observable (type or str) – observable to be checked

Raises

ValueError – if observable is not a Observable class or string

Returns

True iff supplied observable is supported

Return type

bool

supports_operation(operation)

Checks if an operation is supported by this device.

Parameters

operation (type or str) – operation to be checked

Raises

ValueError – if operation is not a Operation class or string

Returns

True iff supplied operation is supported

Return type

bool

var(observable)

Returns the variance of observable on specified wires.

Note: all arguments support _lists_, which indicate a tensor product of observables.

Parameters
  • observable (str or list[str]) – name of the observable(s)

  • wires (List[int] or List[List[int]]) – subsystems the observable(s) is to be measured on

  • par (tuple or list[tuple]]) – parameters for the observable(s)

Raises

NotImplementedError – if the device does not support variance computation

Returns

variance \(\mathrm{var}(A) = \bra{\psi}A^2\ket{\psi} - \bra{\psi}A\ket{\psi}^2\)

Return type

float