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 purestate 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 parametershift 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 endtoend 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 ‘whitebox’, 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.2526717e01 1.0086454e+00 1.3877788e17], 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.5471588e01 1.5882589e+00 3.4694470e17], 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 inNone
.
If you wish to use a different machinelearning interface, or prefer to calculate quantum gradients using the
parametershift
orfinitediff
differentiation methods, consider using thedefault.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 bysample
.analytic (bool) – indicates if the device should calculate expectations and variances analytically
Attributes
The hash of the circuit upon the last execution.
The observables to be measured and returned.
The operation queue to be applied.
Mapping from free parameter index to the list of
Operations
in the device queue that depend on it.Number of circuit evaluations/random samples used to estimate expectation values of observables
Returns the state vector of the circuit prior to measurement.

C_DTYPE
= tf.complex128¶

R_DTYPE
= tf.float64¶

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'¶
Methods
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.
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.
The device execution context used during calls to
execute()
.expval
(observable)Returns the expectation value of observable on specified wires.
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 nonspecified wires.
Called during
execute()
after the individual operations have been executed.Called during
execute()
after the individual observables have been measured.Called during
execute()
before the individual operations are executed.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 includename
,wires
, andparameters
, andinverse
:>>> 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 premeasurement 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 haveoperation.inverse == True
."tensor_observables" (*bool*): ``True
if the device supports expectation values/variance/samples ofTensor
observables.
The qubit device class has builtin 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 theQNode
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()
andexpval()
) are then evaluated within the context of this context manager (see the source ofDevice.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_{N1}\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 nonspecified 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]

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
Contents
Using PennyLane
Development
API
Downloads