Pennylane support for PEC

[hametar0u]

I'm trying to use PEC in pennylane, but it seems like it is not supported.

Here is a basic demo:

from pennylane import numpy as np
from mitiq import pec, Executor
from mitiq.pec.representations.depolarizing import represent_operations_in_circuit_with_local_depolarizing_noise

n_wires = 4
n_layers = 1
template = qml.SimplifiedTwoDesign
weights_shape = template.shape(n_layers, n_wires)
w1, w2 = [2 * np.pi * np.random.random(s) for s in weights_shape]

# def circuit(w1, w2):
#     """This circuit runs an identity transformation, so our expectation value should be 1 in a noiseless setting"""
#     template(w1, w2, wires=range(n_wires))
#     qml.adjoint(template)(w1, w2, wires=range(n_wires))
#     return qml.expval(qml.PauliZ(0))

# The above circuit cannot be directly plugged into the mitiq thing, so we use this quantumTape version instead
circuit = qml.tape.QuantumTape([
    template(w1, w2, wires=range(n_wires)),
    qml.adjoint(template(w1, w2, wires=range(n_wires)))
])

noise_level = 0.01
reps = represent_operations_in_circuit_with_local_depolarizing_noise(circuit, noise_level)
print(f"{len(reps)} OperationRepresentation objects produced, assuming {100 * noise_level}% depolarizing noise.")

executable = Executor(circuit) # crashes on this line

pec_value = pec.execute_with_pec(circuit, executable, representations=reps)```

Error:

{
"name": "TypeError",
"message": "unsupported callable",
"stack": "---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
File ~/.pyenv/versions/3.11-dev/lib/python3.11/inspect.py:1369, in getfullargspec(func)
1352 try:
1353 # Re: skip_bound_arg=False
1354 #
(...)
1366 # getfullargspec() historically ignored wrapped attributes,
1367 # so we ensure that remains the case in 3.3+
-> 1369 sig = _signature_from_callable(func,
1370 follow_wrapper_chains=False,
1371 skip_bound_arg=False,
1372 sigcls=Signature,
1373 eval_str=False)
1374 except Exception as ex:
1375 # Most of the times 'signature' will raise ValueError.
1376 # But, it can also raise AttributeError, and, maybe something
1377 # else. So to be fully backwards compatible, we catch all
1378 # possible exceptions here, and reraise a TypeError.

File ~/.pyenv/versions/3.11-dev/lib/python3.11/inspect.py:2449, in _signature_from_callable(obj, follow_wrapper_chains, skip_bound_arg, globals, locals, eval_str, sigcls)
2448 if not callable(obj):
-> 2449 raise TypeError('{!r} is not a callable object'.format(obj))
2451 if isinstance(obj, types.MethodType):
2452 # In this case we skip the first parameter of the underlying
2453 # function (usually self or cls).

TypeError: <QuantumTape: wires=[0, 1, 2, 3], params=4> is not a callable object

The above exception was the direct cause of the following exception:

TypeError Traceback (most recent call last)
/Users/bigsad/Downloads/Algorithm-Research/Student-Hub/Indy-Ng/tests/pec_2.ipynb セル 1 line 2
25 reps = represent_operations_in_circuit_with_local_depolarizing_noise(circuit, noise_level)
26 print(f"{len(reps)} OperationRepresentation objects produced, assuming {100 * noise_level}% depolarizing noise.")
---> 28 executable = Executor(circuit)
30 pec_value = pec.execute_with_pec(circuit, executable, representations=reps)

File ~/Downloads/Algorithm-Research/Student-Hub/Indy-Ng/.venv/lib/python3.11/site-packages/mitiq/executor/executor.py:78, in Executor.init(self, executor, max_batch_size)
67 """Initializes an Executor.
68
69 Args:
(...)
74 single batch (if the executor is batched).
75 """
76 self._executor = executor
---> 78 executor_annotation = inspect.getfullargspec(executor).annotations
79 self._executor_return_type = executor_annotation.get("return")
80 self._max_batch_size = max_batch_size

File ~/.pyenv/versions/3.11-dev/lib/python3.11/inspect.py:1379, in getfullargspec(func)
1369 sig = _signature_from_callable(func,
1370 follow_wrapper_chains=False,
1371 skip_bound_arg=False,
1372 sigcls=Signature,
1373 eval_str=False)
1374 except Exception as ex:
1375 # Most of the times 'signature' will raise ValueError.
1376 # But, it can also raise AttributeError, and, maybe something
1377 # else. So to be fully backwards compatible, we catch all
1378 # possible exceptions here, and reraise a TypeError.
-> 1379 raise TypeError('unsupported callable') from ex
1381 args = []
1382 varargs = None

TypeError: unsupported callable"
}

From what I see in the documentation, `QuantumTape` objects should be a valid input for the `Executor` class, but it's crashing for some reason. Maybe it is a version issue?

Here are my versions:

Name: PennyLane
Version: 0.33.1
Summary: PennyLane is a Python quantum machine learning library by Xanadu Inc.
Home-page: https://github.com/PennyLaneAI/pennylane
Author:
Author-email:
License: Apache License 2.0
Location: /Users/bigsad/Downloads/Algorithm-Research/Student-Hub/Indy-Ng/.venv/lib/python3.11/site-packages
Requires: appdirs, autograd, autoray, cachetools, networkx, numpy, pennylane-lightning, requests, rustworkx, scipy, semantic-version, toml, typing-extensions
Required-by: PennyLane-Lightning, PennyLane-qiskit

Platform info: macOS-12.6-x86_64-i386-64bit
Python version: 3.11.6
Numpy version: 1.23.5
Scipy version: 1.10.1
Installed devices:

• default.gaussian (PennyLane-0.33.1)
• default.mixed (PennyLane-0.33.1)
• default.qubit (PennyLane-0.33.1)
• default.qubit.autograd (PennyLane-0.33.1)
• default.qubit.jax (PennyLane-0.33.1)
• default.qubit.legacy (PennyLane-0.33.1)
• default.qubit.tf (PennyLane-0.33.1)
• default.qubit.torch (PennyLane-0.33.1)
• default.qutrit (PennyLane-0.33.1)
• null.qubit (PennyLane-0.33.1)
• lightning.qubit (PennyLane-Lightning-0.33.1)
• qiskit.aer (PennyLane-qiskit-0.33.1)
• qiskit.basicaer (PennyLane-qiskit-0.33.1)
• qiskit.ibmq (PennyLane-qiskit-0.33.1)
• qiskit.ibmq.circuit_runner (PennyLane-qiskit-0.33.1)
• qiskit.ibmq.sampler (PennyLane-qiskit-0.33.1)
• qiskit.remote (PennyLane-qiskit-0.33.1)

[Misty-W]

The executable function should take in your circuit which PennyLane happens to call a QuantumTape and return a result, generally in the form of a number, a bitstring, or an array of numbers.

Then call Executor(executable) to turn it into the function into an Executor and you can use the methods that belong to Executor.

[Misty-W]

Yes, append measurements to the end of your tape inside your executor function.

[hametar0u]

After consulting the folks at Pennylane, the best way to do this is to create a new tape with the measurements in the circuit:

def executor(tape, dev):
    new_tape = qml.tape.QuantumTape(
        tape.operations,
        tape.measurements + measurements,
        shots=tape.shots,
    )
    return qml.execute([new_tape], dev)[0]

This code works! However, I'm not getting very good results. Here is the full code again:

import pennylane as qml
from pennylane import numpy as np
from mitiq import pec, Executor
from mitiq.pec.representations.depolarizing import represent_operations_in_circuit_with_local_depolarizing_noise

n_wires = 3
n_layers = 1
template = qml.SimplifiedTwoDesign
weights_shape = template.shape(n_layers, n_wires)
w1, w2 = [2 * np.pi * np.random.random(s) for s in weights_shape]

# Describe noise
noise_strength = 0.04

#Ideal device
dev_ideal = qml.device('default.mixed', wires=n_wires)
#noisy device
dev_noisy = qml.transforms.insert(
    dev_ideal,
    qml.DepolarizingChannel,
    noise_strength
)

# The above circuit cannot be directly plugged into the mitiq thing, so we use this quantumTape version instead
ops = [
    template(w1, w2, wires=range(n_wires)),
    qml.adjoint(template(w1, w2, wires=range(n_wires))),
]
measurements = [qml.expval(qml.PauliZ(0))]
circuit = qml.tape.QuantumTape(ops)

# run mitiq PEC
def executor(tape, dev):
    new_tape = qml.tape.QuantumTape(
        tape.operations,
        tape.measurements + measurements,
        shots=tape.shots,
    )
    return qml.execute([new_tape], dev)[0]

executable = Executor(lambda tape: executor(tape, dev_noisy))

noise_level = 0.01
reps = represent_operations_in_circuit_with_local_depolarizing_noise(circuit, noise_level)
print(f"{len(reps)} OperationRepresentation objects produced, assuming {100 * noise_level}% depolarizing noise.")

# compare the circuits performance
ideal_value = executor(circuit, dev_ideal)
print(ideal_value)

noisy_value = executor(circuit, dev_noisy)
print(noisy_value)

pec_value = pec.execute_with_pec(circuit, executable, representations=reps)
print(pec_value)

Here is my output:

16 OperationRepresentation objects produced, assuming 1.0% depolarizing noise.
1.0000000000000004
0.5065292087857487
0.5818160682592852

As you can see, PEC only improved results by ~20%. How can I do better?

[hametar0u]

Hi @Misty-W , just following up on this post.

[Misty-W]

hi @hametar0u, one thing to try is to make the noise strength of the representations closer to your actual noise strength.
Or, since this is a simulated example, you could try reducing the strength of the depolarizing noise, since the noisy result is far from the ideal result.
Given the large difference between noisy and ideal, it's also worth checking that you are comparing results of the same circuit.

[hametar0u]

Hey @Misty-W , after following your suggestions, I turned down the depolarizing noise strength to 0.01, and separately tried simulating the noise model of the IBM Manila quantum computer, and it's giving me good results! However I want to note that the runtime for the latter case (simulating a real device) increase by around 4.5x (around 100 seconds -> 450 seconds). What is causing this discrepancy?

[Misty-W]

@hametar0u great that it worked! I'm assuming both cases (100 seconds and 450 seconds) were with PEC applied? I'm curious to know what it was for the unmitigated case.

[hametar0u]

@Misty-W quite a lot less, at 0.04 seconds.

[Misty-W]

Sorry for the delay in my response. To clarify, each of the noise models (without migitation) had a runtime of 0.04 seconds?
How many samples did you use for the PEC runs?