qml.devices.default_qutrit_mixed.DefaultQutritMixed¶
-
class
DefaultQutritMixed
(wires=None, shots=None, seed='global', readout_relaxation_probs=None, readout_misclassification_probs=None)[source]¶ Bases:
pennylane.devices.device_api.Device
A PennyLane Python-based device for mixed-state qutrit simulation.
- Parameters
wires (int, Iterable[Number, str]) – Number of wires present on the device, or iterable that contains unique labels for the wires as numbers (i.e.,
[-1, 0, 2]
) or strings (['ancilla', 'q1', 'q2']
). DefaultNone
if not specified.shots (int, Sequence[int], Sequence[Union[int, Sequence[int]]]) – The default number of shots to use in executions involving this device.
seed (Union[str, None, int, array_like[int], SeedSequence, BitGenerator, Generator, jax.random.PRNGKey]) – A seed-like parameter matching that of
seed
fornumpy.random.default_rng
, or a request to seed from numpy’s global random number generator. The default,seed="global"
pulls a seed from NumPy’s global generator.seed=None
will pull a seed from the OS entropy. If ajax.random.PRNGKey
is passed as the seed, a JAX-specific sampling function usingjax.random.choice
and thePRNGKey
will be used for sampling rather thannumpy.random.default_rng
.readout_relaxation_probs (List[float]) – Input probabilities for relaxation errors implemented with the
QutritAmplitudeDamping
channel. The input defines the channel’s parameters \([\gamma_{10}, \gamma_{20}, \gamma_{21}]\).readout_misclassification_probs (List[float]) – Input probabilities for state readout misclassification events implemented with the
TritFlip
channel. The input defines the channel’s parameters \([p_{01}, p_{02}, p_{12}]\).
Example:
n_wires = 5 num_qscripts = 5 qscripts = [] for i in range(num_qscripts): unitary = scipy.stats.unitary_group(dim=3**n_wires, seed=(42 + i)).rvs() op = qml.QutritUnitary(unitary, wires=range(n_wires)) qs = qml.tape.QuantumScript([op], [qml.expval(qml.GellMann(0, 3))]) qscripts.append(qs)
>>> dev = DefaultQutritMixed() >>> program, execution_config = dev.preprocess() >>> new_batch, post_processing_fn = program(qscripts) >>> results = dev.execute(new_batch, execution_config=execution_config) >>> post_processing_fn(results) [0.08015701503959313, 0.04521414211599359, -0.0215232130089687, 0.062120285032425865, -0.0635052317625]
This device currently supports backpropagation derivatives:
>>> from pennylane.devices import ExecutionConfig >>> dev.supports_derivatives(ExecutionConfig(gradient_method="backprop")) True
For example, we can use jax to jit computing the derivative:
import jax @jax.jit def f(x): qs = qml.tape.QuantumScript([qml.TRX(x, 0)], [qml.expval(qml.GellMann(0, 3))]) program, execution_config = dev.preprocess() new_batch, post_processing_fn = program([qs]) results = dev.execute(new_batch, execution_config=execution_config) return post_processing_fn(results)[0]
>>> f(jax.numpy.array(1.2)) DeviceArray(0.36235774, dtype=float32) >>> jax.grad(f)(jax.numpy.array(1.2)) DeviceArray(-0.93203914, dtype=float32, weak_type=True)
Readout Error
DefaultQutritMixed
includes readout error support. Two input arguments control the parameters of error channels applied to each measured wire of the state after it has been diagonalized for measurement:readout_relaxation_probs
: Input parameters of aQutritAmplitudeDamping
channel. This error models state relaxation error that occurs during readout of transmon-based qutrits. The motivation for this readout error is described in [1] (Sec II.A).readout_misclassification_probs
: Input parameters of aTritFlip
channel. This error models misclassification events in readout. An example of this readout error can be seen in [2] (Fig 1a).
In the case that both parameters are defined, relaxation error is applied first then misclassification error is applied.
Note
The readout errors will be applied to the state after it has been diagonalized for each measurement. This may give different results depending on how the observable is defined. This is because diagonalizing gates for the same observable may return eigenvalues in different orders. For example, measuring
THermitian
with a non-diagonal GellMann matrix will result in a different measurement result then measuring the equivalentGellMann
observable, as the THermitian eigenvalues are returned in increasing order when explicitly diagonalized (i.e.,[-1, 0, 1]
), while non-diagonal GellManns provided in PennyLane have their eigenvalues hardcoded (i.e.,[1, -1, 0]
).Tracking
DefaultQutritMixed
tracks:executions
: the number of unique circuits that would be required on quantum hardwareshots
: the number of shotsresources
: theResources
for the executed circuit.simulations
: the number of simulations performed. One simulation can cover multiple QPU executions, such as for non-commuting measurements and batched parameters.batches
: The number of timesexecute()
is called.results
: The results of each call ofexecute()
Attributes
The name of the device.
Default shots for execution workflows containing this device.
A
Tracker
that can store information about device executions, shots, batches, intermediate results, or any additional device dependent information.The device wires.
-
name
¶ The name of the device.
-
shots
¶ Default shots for execution workflows containing this device.
Note that the device itself should always pull shots from the provided
QuantumTape
and itsshots
, not from this property. This property is used to provide a default at the start of a workflow.
-
tracker
: pennylane.tracker.Tracker = <pennylane.tracker.Tracker object>¶ A
Tracker
that can store information about device executions, shots, batches, intermediate results, or any additional device dependent information.A plugin developer can store information in the tracker by:
# querying if the tracker is active if self.tracker.active: # store any keyword: value pairs of information self.tracker.update(executions=1, shots=self._shots, results=results) # Calling a user-provided callback function self.tracker.record()
-
wires
¶ The device wires.
Note that wires are optional, and the default value of None means any wires can be used. If a device has wires defined, they will only be used for certain features. This includes:
Validation of tapes being executed on the device
Defining the wires used when evaluating a
state()
measurement
Methods
compute_derivatives
(circuits[, execution_config])Calculate the jacobian of either a single or a batch of circuits on the device.
compute_jvp
(circuits, tangents[, …])The jacobian vector product used in forward mode calculation of derivatives.
compute_vjp
(circuits, cotangents[, …])The vector jacobian product used in reverse-mode differentiation.
execute
(circuits[, execution_config])Execute a circuit or a batch of circuits and turn it into results.
execute_and_compute_derivatives
(circuits[, …])Compute the results and jacobians of circuits at the same time.
execute_and_compute_jvp
(circuits, tangents)Execute a batch of circuits and compute their jacobian vector products.
execute_and_compute_vjp
(circuits, cotangents)Calculate both the results and the vector jacobian product used in reverse-mode differentiation.
preprocess
([execution_config])This function defines the device transform program to be applied and an updated device configuration.
supports_derivatives
([execution_config, circuit])Check whether or not derivatives are available for a given configuration and circuit.
supports_jvp
([execution_config, circuit])Whether or not a given device defines a custom jacobian vector product.
supports_vjp
([execution_config, circuit])Whether or not a given device defines a custom vector jacobian product.
-
compute_derivatives
(circuits, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=None, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))¶ Calculate the jacobian of either a single or a batch of circuits on the device.
- Parameters
circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the circuits to calculate derivatives for
execution_config (ExecutionConfig) – a datastructure with all additional information required for execution
- Returns
The jacobian for each trainable parameter
- Return type
Tuple
See also
supports_derivatives()
andexecute_and_compute_derivatives()
.Execution Config:
The execution config has
gradient_method
andorder
property that describes the order of differentiation requested. If the requested method or order of gradient is not provided, the device should raise aNotImplementedError
. Thesupports_derivatives()
method can pre-validate supported orders and gradient methods.Return Shape:
If a batch of quantum scripts is provided, this method should return a tuple with each entry being the gradient of each individual quantum script. If the batch is of length 1, then the return tuple should still be of length 1, not squeezed.
-
compute_jvp
(circuits, tangents, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=None, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))¶ The jacobian vector product used in forward mode calculation of derivatives.
- Parameters
circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the circuit or batch of circuits
tangents (tensor-like) – Gradient vector for input parameters.
execution_config (ExecutionConfig) – a datastructure with all additional information required for execution
- Returns
A numeric result of computing the jacobian vector product
- Return type
Tuple
Definition of jvp:
If we have a function with jacobian:
\[\vec{y} = f(\vec{x}) \qquad J_{i,j} = \frac{\partial y_i}{\partial x_j}\]The Jacobian vector product is the inner product with the derivatives of \(x\), yielding only the derivatives of the output \(y\):
\[\text{d}y_i = \Sigma_{j} J_{i,j} \text{d}x_j\]Shape of tangents:
The
tangents
tuple should be the same length ascircuit.get_parameters()
and have a single number per parameter. If a number is zero, then the gradient with respect to that parameter does not need to be computed.
-
compute_vjp
(circuits, cotangents, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=None, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))¶ The vector jacobian product used in reverse-mode differentiation.
- Parameters
circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the circuit or batch of circuits
cotangents (Tuple[Number, Tuple[Number]]) – Gradient-output vector. Must have shape matching the output shape of the corresponding circuit. If the circuit has a single output, cotangents may be a single number, not an iterable of numbers.
execution_config (ExecutionConfig) – a datastructure with all additional information required for execution
- Returns
A numeric result of computing the vector jacobian product
- Return type
tensor-like
Definition of vjp:
If we have a function with jacobian:
\[\vec{y} = f(\vec{x}) \qquad J_{i,j} = \frac{\partial y_i}{\partial x_j}\]The vector jacobian product is the inner product of the derivatives of the output
y
with the Jacobian matrix. The derivatives of the output vector are sometimes called the cotangents.\[\text{d}x_i = \Sigma_{i} \text{d}y_i J_{i,j}\]Shape of cotangents:
The value provided to
cotangents
should match the output ofexecute()
.
-
execute
(circuits, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=None, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))[source]¶ Execute a circuit or a batch of circuits and turn it into results.
- Parameters
circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the quantum circuits to be executed
execution_config (ExecutionConfig) – a datastructure with additional information required for execution
- Returns
A numeric result of the computation.
- Return type
TensorLike, tuple[TensorLike], tuple[tuple[TensorLike]]
Interface parameters:
The provided
circuits
may contain interface specific data-types liketorch.Tensor
orjax.Array
whengradient_method
of"backprop"
is requested. If the gradient method is not backpropagation, then only vanilla numpy parameters or builtins will be present in the circuits.Return Shape
See Return Type Specification for more detailed information.
The result for each
QuantumTape
must match the shape specified byshape
.The level of priority for dimensions from outer dimension to inner dimension is:
Quantum Script in batch
Shot choice in a shot vector
Measurement in the quantum script
Parameter broadcasting
Measurement shape for array-valued measurements like probabilities
For a batch of quantum scripts with multiple measurements, a shot vector, and parameter broadcasting:
result[0]
: the results for the first scriptresult[0][0]
: the first shot number in the shot vectorresult[0][0][0]
: the first measurement in the quantum scriptresult[0][0][0][0]
: the first parameter broadcasting choiceresult[0][0][0][0][0]
: the first value for an array-valued measurement
With the exception of quantum script batches, dimensions with only a single component should be eliminated.
For example:
With a single script and a single measurement process, execute should return just the measurement value in a numpy array.
shape
currently accepts a device, as historically devices stored shot information. In the future, this method will accept anExecutionConfig
instead.>>> tape = qml.tape.QuantumTape(measurements=qml.expval(qml.Z(0))]) >>> tape.shape(dev) () >>> dev.execute(tape) array(1.0)
If execute recieves a batch of scripts, then it should return a tuple of results:
>>> dev.execute([tape, tape]) (array(1.0), array(1.0)) >>> dev.execute([tape]) (array(1.0),)
If the script has multiple measurments, then the device should return a tuple of measurements.
>>> tape = qml.tape.QuantumTape(measurements=[qml.expval(qml.Z(0)), qml.probs(wires=(0,1))]) >>> tape.shape(dev) ((), (4,)) >>> dev.execute(tape) (array(1.0), array([1., 0., 0., 0.]))
-
execute_and_compute_derivatives
(circuits, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=None, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))¶ Compute the results and jacobians of circuits at the same time.
- Parameters
circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the circuits or batch of circuits
execution_config (ExecutionConfig) – a datastructure with all additional information required for execution
- Returns
A numeric result of the computation and the gradient.
- Return type
tuple
See
execute()
andcompute_derivatives()
for more information about return shapes and behaviour. Ifcompute_derivatives()
is defined, this method should be as well.This method can be used when the result and execution need to be computed at the same time, such as during a forward mode calculation of gradients. For certain gradient methods, such as adjoint diff gradients, calculating the result and gradient at the same can save computational work.
-
execute_and_compute_jvp
(circuits, tangents, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=None, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))¶ Execute a batch of circuits and compute their jacobian vector products.
- Parameters
circuits (Union[QuantumTape, Sequence[QuantumTape]]) – circuit or batch of circuits
tangents (tensor-like) – Gradient vector for input parameters.
execution_config (ExecutionConfig) – a datastructure with all additional information required for execution
- Returns
A numeric result of execution and of computing the jacobian vector product
- Return type
Tuple, Tuple
See also
-
execute_and_compute_vjp
(circuits, cotangents, execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=None, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))¶ Calculate both the results and the vector jacobian product used in reverse-mode differentiation.
- Parameters
circuits (Union[QuantumTape, Sequence[QuantumTape]]) – the circuit or batch of circuits to be executed
cotangents (Tuple[Number, Tuple[Number]]) – Gradient-output vector. Must have shape matching the output shape of the corresponding circuit. If the circuit has a single output, cotangents may be a single number, not an iterable of numbers.
execution_config (ExecutionConfig) – a datastructure with all additional information required for execution
- Returns
the result of executing the scripts and the numeric result of computing the vector jacobian product
- Return type
Tuple, Tuple
See also
-
preprocess
(execution_config=ExecutionConfig(grad_on_execution=None, use_device_gradient=None, use_device_jacobian_product=None, gradient_method=None, gradient_keyword_arguments={}, device_options={}, interface=None, derivative_order=1, mcm_config=MCMConfig(mcm_method=None, postselect_mode=None)))[source]¶ This function defines the device transform program to be applied and an updated device configuration.
- Parameters
execution_config (Union[ExecutionConfig, Sequence[ExecutionConfig]]) – A data structure describing the parameters needed to fully describe the execution.
- Returns
A transform program that when called returns
QuantumTape
objects that the device can natively execute, as well as a postprocessing function to be called after execution, and a configuration with unset specifications filled in.- Return type
This device:
Supports any qutrit operations that provide a matrix
Supports any qutrit channel that provides Kraus matrices
-
supports_derivatives
(execution_config=None, circuit=None)[source]¶ Check whether or not derivatives are available for a given configuration and circuit.
DefaultQutritMixed
supports backpropagation derivatives with analytic results.- Parameters
execution_config (ExecutionConfig) – The configuration of the desired derivative calculation.
circuit (QuantumTape) – An optional circuit to check derivatives support for.
- Returns
Whether or not a derivative can be calculated provided the given information.
- Return type
bool
-
supports_jvp
(execution_config=None, circuit=None)¶ Whether or not a given device defines a custom jacobian vector product.
- Parameters
execution_config (ExecutionConfig) – A description of the hyperparameters for the desired computation.
circuit (None, QuantumTape) – A specific circuit to check differentation for.
Default behaviour assumes this to be
True
ifcompute_jvp()
is overridden.
-
supports_vjp
(execution_config=None, circuit=None)¶ Whether or not a given device defines a custom vector jacobian product.
- Parameters
execution_config (ExecutionConfig) – A description of the hyperparameters for the desired computation.
circuit (None, QuantumTape) – A specific circuit to check differentation for.
Default behaviour assumes this to be
True
ifcompute_vjp()
is overridden.