transform(quantum_transform, expand_transform=None, classical_cotransform=None, is_informative=None, final_transform=False)¶
Generalizes a function that transforms tapes to work with additional circuit-like objects such as a
transformshould be applied to a function that transforms tapes. Once validated, the result will be an object that is able to transform PennyLane’s range of circuit-like objects:
QuantumTape, quantum function and
QNode. A circuit-like object can be transformed either via decoration or by passing it functionally through the created transform.
quantum_transform (Callable) –
The input quantum transform must be a function that satisfies the following requirements:
expand_transform (Callable) – An optional expand transform is applied directly before the input quantum transform. It must be a function that satisfies the same requirements as
classical_cotransform (Callable) – A classical co-transform is a function to post-process the classical jacobian and the quantum jacobian and has the signature:
my_cotransform(qjac, cjac, tape) -> tensor_like
is_informative (bool) – Whether or not a transform is informative. If true the transform is queued at the end of the transform program and the tapes or qnode aren’t executed.
final_transform (bool) – Whether or not the transform is terminal. If true the transform is queued at the end of the transform program.
Returns a transform dispatcher object that that can transform any circuit-like object in PennyLane.
- Return type
First define an input quantum transform with the necessary type hinting defined above. In this example we copy the tape and sum the results of the execution of the two tapes.
from typing import Sequence, Callable def my_quantum_transform(tape: qml.tape.QuantumTape) -> (Sequence[qml.tape.QuantumTape], Callable): tape1 = tape tape2 = tape.copy() def post_processing_fn(results): return qml.math.sum(results) return [tape1, tape2], post_processing_fn
We want to be able to apply this transform on both a
pennylane.QNodeand will use
transformto achieve this.
transformvalidates the signature of your input quantum transform and makes it capable of transforming
pennylane.QNodein addition to quantum tapes. Let’s define a circuit as a
dev = qml.device("default.qubit") @qml.qnode(device=dev) def qnode_circuit(a): qml.Hadamard(wires=0) qml.CNOT(wires=[0, 1]) qml.PauliX(wires=0) qml.RZ(a, wires=1) return qml.expval(qml.PauliZ(wires=0))
We first apply
>>> dispatched_transform = transform(my_quantum_transform)
Now you can use the dispatched transform directly on a
pennylane.QNode, the dispatched transform populates the
TransformProgramof your QNode. The transform and its processing function are applied in the execution.
>>> transformed_qnode = dispatched_transform(qnode_circuit) <QNode: wires=2, device='default.qubit', interface='auto', diff_method='best'>
>>> transformed_qnode.transform_program TransformProgram(my_quantum_transform)
If we apply
dispatched_transforma second time to the
pennylane.QNode, we would add it to the transform program again and therefore the transform would be applied twice before execution.
>>> transformed_qnode = dispatched_transform(transformed_qnode) >>> transformed_qnode.transform_program TransformProgram(my_quantum_transform, my_quantum_transform)
When a transformed QNode is executed, the QNode’s transform program is applied to the generated tape and creates a sequence of tapes to be executed. The execution results are then post-processed in the reverse order of the transform program to obtain the final results.
Signature of a transform
A dispatched transform is able to handle several PennyLane circuit-like objects:
For each object, the transform will be applied in a different way, but it always preserves the underlying tape-based quantum transform behaviour.
The return of a dispatched transform depends upon which of the above objects is passed as an input:
QNodeinput, the underlying transform is added to the QNode’s
TransformProgramand the return is the transformed
QNode. For each execution of the
pennylane.QNode, it first applies the transform program on the original captured circuit. Then the transformed circuits are executed by a device and finally the post-processing function is applied on the results.
For a quantum function (callable) input, the transform builds the tape when the quantum function is executed and then applies itself to the tape. The resulting tape is then converted back to a quantum function (callable). It therefore returns a transformed quantum function (Callable). The limitation is that the underlying transform can only return a sequence containing a single tape, because quantum functions only support a single circuit.
Device, the transform is added to the device’s transform program and a transformed
pennylane.devices.Deviceis returned. The transform is added to the end of the device program and will be last in the overall transform program.
- What is PennyLane?
- Quantum circuits
- Gradients and training
- Quantum operators
- Inspecting circuits
- Compiling circuits
- Quantum Chemistry
- Quantum Datasets
- QNode returns