qml.transforms.add_noise

add_noise(tape, noise_model, level=None)

Insert operations according to a provided noise model.

Circuits passed through this quantum transform will be updated to apply the insertion-based NoiseModel, which contains mappings {BooleanFn: Callable} from conditions to the corresponding noise gates for circuit operations and measurements respectively. First, each condition in the first mapping of a noise model will be evaluated on the operations contained within the given circuit. For conditions that evaluate to True, the noisy gates contained within the Callable will be inserted after the operation under consideration. Similar procedure will be followed for each measurement in the circuit, in case a second mapping is present in the noise model to indicate readout errors.

Parameters

• tape (QNode or QuantumTape or Callable or pennylane.devices.Device) – the input circuit or device to be transformed.

• noise_model (NoiseModel) – noise model according to which noise has to be inserted.

• level (None, str, int, slice) –

  An indication of which stage in the transform program the noise model should be applied to. Only relevant when transforming a QNode. More details on the following permissible values can be found in the get_transform_program() -

  • None: expands the tape to have no Adjoint and Templates.

  • str: acceptable keys are "top", "user", "device", and "gradient".

  • int: how many transforms to include, starting from the front of the program.

  • slice: a slice to select out components of the transform program.

Returns

Transformed circuit as described in qml.transform.

Return type

qnode (QNode) or quantum function (Callable) or tuple[List[QuantumTape], function] or device (pennylane.devices.Device)

Raises

ValueError – argument noise_model is not a valid noise model.

Note

For a given model_map and meas_map within a NoiseModel, if multiple conditionals in the given maps evaluate to True for an operation or measurement process, then the noise operations defined via their respective noisy quantum functions will be added in the same order in which the conditionals appear in them.

Example:

The following QNode can be transformed to add noise to the circuit:

from functools import partial

dev = qml.device("default.mixed", wires=2)

fcond1 = qml.noise.op_eq(qml.RX) & qml.noise.wires_in([0, 1])
noise1 = qml.noise.partial_wires(qml.PhaseDamping, 0.4)

fcond2 = qml.noise.op_in([qml.RX, qml.RZ])
def noise2(op, **kwargs):
    qml.ThermalRelaxationError(op.parameters[0] * 0.5, kwargs["t1"],  kwargs["t2"], 0.6, op.wires)

fcond3 = qml.noise.meas_eq(qml.expval) & qml.noise.wires_in([0, 1])
noise3 = qml.noise.partial_wires(qml.PhaseFlip, 0.2)

noise_model = qml.NoiseModel(
    {fcond1: noise1, fcond2: noise2}, {fcond3: noise3}, t1=2.0, t2=0.2
)

@partial(qml.transforms.add_noise, noise_model=noise_model)
@qml.qnode(dev)
def circuit(w, x, y, z):
    qml.RX(w, wires=0)
    qml.RY(x, wires=1)
    qml.CNOT(wires=[0, 1])
    qml.RY(y, wires=0)
    qml.RX(z, wires=1)
    return qml.expval(qml.Z(0) @ qml.Z(1))

Executions of this circuit will differ from the noise-free value:

>>> circuit(0.9, 0.4, 0.5, 0.6)
array(0.544053)
>>> print(qml.draw(circuit)(0.9, 0.4, 0.5, 0.6))
0: ──RX(0.90)──PhaseDamping(0.40)──ThermalRelaxationError(0.45,2.00,0.20,0.60)─╭●──RY(0.50)
1: ──RY(0.40)──────────────────────────────────────────────────────────────────╰X──RX(0.60)

────────────────────────────────────────────────────────────────────PhaseFlip(0.2)─┤ ╭<Z@Z>
───PhaseDamping(0.40)──ThermalRelaxationError(0.30,2.00,0.20,0.60)──PhaseFlip(0.2)─┤ ╰<Z@Z>

Tranform Levels

When transforming an already constructed QNode, the add_noise transform will be added at the end of the “user” transforms by default, i.e., after all the transforms that have been manually applied to the QNode up to that point.

dev = qml.device("default.mixed", wires=2)

@qml.metric_tensor
@qml.transforms.undo_swaps
@qml.transforms.merge_rotations
@qml.transforms.cancel_inverses
@qml.qnode(dev)
def circuit(w, x, y, z):
    qml.RX(w, wires=0)
    qml.RY(x, wires=1)
    qml.CNOT(wires=[0, 1])
    qml.RY(y, wires=0)
    qml.RX(z, wires=1)
    return qml.expval(qml.Z(0) @ qml.Z(1))

noisy_circuit = qml.transforms.add_noise(circuit, noise_model)

>>> qml.workflow.get_transform_program(circuit)
TransformProgram(cancel_inverses, merge_rotations, undo_swaps, _expand_metric_tensor, batch_transform, expand_fn, metric_tensor)

>>> qml.workflow.get_transform_program(noisy_circuit)
TransformProgram(cancel_inverses, merge_rotations, undo_swaps, _expand_metric_tensor, add_noise, batch_transform, expand_fn, metric_tensor)

However, one can request to insert the add_noise transform at any specific point in the transform program. By specifying the level keyword argument while transforming a QNode, this transform can be added at a designated level within the transform program, as determined using the get_transform_program. For example, specifying None will add it at the end, ensuring that the tape is expanded to have no Adjoint and Templates:

>>> qml.transforms.add_noise(circuit, noise_model, level=None).transform_program
TransformProgram(cancel_inverses, merge_rotations, undo_swaps, _expand_metric_tensor, batch_transform, expand_fn, add_noise, metric_tensor)

Other acceptable values for level are "top", "user", "device", and "gradient". Among these, “top” will allow addition to an empty transform program, “user” will allow addition at the end of user-specified transforms, “device” will allow addition at the end of device-specific transforms, and “gradient” will allow addition at the end of transforms that expand trainable operations. For example:

>>> qml.transforms.add_noise(circuit, noise_model, level="top").transform_program
TransformProgram(add_noise)

>>> qml.transforms.add_noise(circuit, noise_model, level="user").transform_program
TransformProgram(cancel_inverses, merge_rotations, undo_swaps, _expand_metric_tensor, add_noise, metric_tensor)

>>> qml.transforms.add_noise(circuit, noise_model, level="device").transform_program
TransformProgram(cancel_inverses, merge_rotations, undo_swaps, _expand_metric_tensor, batch_transform, expand_fn, add_noise, metric_tensor)

Finally, more precise control over the insertion of the transform can be achieved by specifying an integer or slice for indexing when extracting the transform program. For example, one can do:

>>> qml.transforms.add_noise(circuit, noise_model, level=2).transform_program
TransformProgram(cancel_inverses, merge_rotations, add_noise)

>>> qml.transforms.add_noise(circuit, noise_model, level=slice(1,3)).transform_program
TransformProgram(merge_rotations, undo_swaps, add_noise)

code/api/pennylane.transforms.add_noise

 

Download Python script

 

Download Notebook

 

View on GitHub