qml.devices.DefaultQutritMixed¶

class DefaultQutritMixed(wires=None, shots=None, seed='global')[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']). Default None 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 for numpy.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 a jax.random.PRNGKey is passed as the seed, a JAX-specific sampling function using jax.random.choice and the PRNGKey will be used for sampling rather than numpy.random.default_rng.

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)

Tracking

DefaultQutritMixed tracks:

executions: the number of unique circuits that would be required on quantum hardware
shots: the number of shots
resources: the Resources 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 times execute() is called.
results: The results of each call of execute()

Attributes

`name`	The name of the device.
`shots`	Default shots for execution workflows containing this device.
`tracker`	A `Tracker` that can store information about device executions, shots, batches, intermediate results, or any additional device dependent information.
`wires`	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 its shots, 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))¶

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

Return Shape

See Return Type Specification for more detailed information.

The result for each QuantumTape must match the shape specified by shape.

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 script
result[0][0]: the first shot number in the shot vector
result[0][0][0]: the first measurement in the quantum script
result[0][0][0][0]: the first parameter broadcasting choice
result[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 an ExecutionConfig 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))¶

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() and compute_derivatives() for more information about return shapes and behaviour. If compute_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))¶

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

qml.devices.DefaultQutritMixed¶

Tracking

Attributes

Methods

Return Shape

Contents

Downloads

qml.devices.DefaultQutritMixed¶

Tracking

Attributes

Methods

Return Shape

Contents

Downloads

Related