IBMBackendValueError: number of circuits exceeds the maximum for this backend, 300

PennyLane Plugins PennyLane Qiskit
1

Hi, I am trying to run the QAOA on the IBMQ device. The QAOA circuit consists of 6 qubits, two layers. The number of total trainable parameters for the QAOA circuit is 14. The toy code is as below:

dev = qml.device('qiskit.ibmq', wires=args.dataset.n_node, backend='ibm_kyoto', ibmqx_token=token)
circuit = QAOA(dev)
opt_b = qml.AdamOptimizer(args.lr_qaoa)
param_b, loss = opt_b.step_and_cost(lambda param_b: circuit(param_b, circuit.param_c), circuit.param_b)

After running the code, it successfully run on the IBMQ backend in the beginning by checking the IBMQ dashboard of my account. However, it soon raised the error qiskit_ibm_provider.exceptions.IBMBackendValueError: Number of circuits, 418 exceeds the maximum for this backend, 300).
The detailed pennylane version information is listed in the following:

Name: PennyLane
Version: 0.35.1
Summary: PennyLane is a cross-platform Python library for quantum computing, quantum machine learning, and quantum chemistry. Train a quantum computer the same way as a neural network.
Home-page: https://github.com/PennyLaneAI/pennylane
Author:
Author-email:
License: Apache License 2.0
Location: /home/yqia7342/qml/lib/python3.10/site-packages
Requires: appdirs, autograd, autoray, cachetools, networkx, numpy, pennylane-lightning, requests, rustworkx, scipy, semantic-version, toml, typing-extensions
Required-by: PennyLane-qiskit, PennyLane_Lightning

Platform info:           Linux-5.15.0-58-generic-x86_64-with-glibc2.35
Python version:          3.10.12
Numpy version:           1.26.4
Scipy version:           1.12.0
Installed devices:
- default.clifford (PennyLane-0.35.1)
- default.gaussian (PennyLane-0.35.1)
- default.mixed (PennyLane-0.35.1)
- default.qubit (PennyLane-0.35.1)
- default.qubit.autograd (PennyLane-0.35.1)
- default.qubit.jax (PennyLane-0.35.1)
- default.qubit.legacy (PennyLane-0.35.1)
- default.qubit.tf (PennyLane-0.35.1)
- default.qubit.torch (PennyLane-0.35.1)
- default.qutrit (PennyLane-0.35.1)
- null.qubit (PennyLane-0.35.1)
- lightning.qubit (PennyLane_Lightning-0.35.1)
- qiskit.aer (PennyLane-qiskit-0.35.1)
- qiskit.basicaer (PennyLane-qiskit-0.35.1)
- qiskit.ibmq (PennyLane-qiskit-0.35.1)
- qiskit.ibmq.circuit_runner (PennyLane-qiskit-0.35.1)
- qiskit.ibmq.sampler (PennyLane-qiskit-0.35.1)
- qiskit.remote (PennyLane-qiskit-0.35.1)

Could you please provide some advice to solve this issue? Thanks !

2

Hey @Yang,

Based on the error you’re getting, tt seems like you’re asking too much from the backend. Are you able to accomplish what you want to accomplish with a less demanding calculation?

3

Hi @isaacdevlugt ,

Thank you for the advice. I cannot recognize which part of the code requires a larger number of circuits and how to control the demanding resource. Could you please explain it?

4

Can you attach the code that you’re running? It’s hard to tell why this is happening without it :sweat_smile:

5

Thanks for your reply. The following is the simplified version of my code.

def encode_layer(nr_qubits):
    for i in range(nr_qubits):
        qml.Hadamard(wires=i)

def U_C(gamma, weights=None, edges=None):
    for i, edge in enumerate(edges):
        qml.CNOT(wires=[int(edge[0]), int(edge[1])])
        qml.RZ(gamma*weights[i], wires=int(edge[1]))
        qml.CNOT(wires=[int(edge[0]), int(edge[1])])

def U_B(beta, n_qubits=None):
    for i in range(n_qubits):
        qml.RX(beta[i], wires=i)

def circuit(param_b, param_c, edges, weights, n_qubits, n_layer):
    encode_layer(n_qubits)
    for j in range(n_layers):
        U_C(param_c[j], weights, edges)
        U_B(param_b[j], n_qubits)
    return qml.expval(A)

n_node = 6
n_layer =2
degree = 3
edges = nx.random_regular_graph(degree, n_node)
edges = list(edges..edges().keys())
weights = np.random.uniform(0, 1, len(edges)).tolist()
dev = qml.device('qiskit.ibmq', wires=n_node, backend='ibm_kyoto')
circuit_dev = qml.qnode(dev)(circuit)

lr = 0.15
opt_b = qml.AdamOptimizer(lr)
param_b = np.random.uniform(0, np.pi * 2, (n_layer, n_node))
param_c = np.random.uniform(0, np.pi * 2, (n_layer))
param_b, loss = opt_b.step_and_cost(lambda param: circuit_dev(param, param_c, edges, weights, n_node, n_layer), param_b)
6

Interesting… I wasn’t able to replicate the behaviour with this code:

import pennylane as qml
import pennylane.numpy as np
import networkx as nx

n_node = 6
n_layer =2
degree = 3
edges = nx.random_regular_graph(degree, n_node)
edges = list(edges.edges().keys())
weights = np.random.uniform(0, 1, len(edges)).tolist()

def encode_layer(nr_qubits):
    for i in range(nr_qubits):
        qml.Hadamard(wires=i)

def U_C(gamma, weights=None, edges=None):
    for i, edge in enumerate(edges):
        qml.CNOT(wires=[int(edge[0]), int(edge[1])])
        qml.RZ(gamma*weights[i], wires=int(edge[1]))
        qml.CNOT(wires=[int(edge[0]), int(edge[1])])

def U_B(beta, n_qubits=None):
    for i in range(n_qubits):
        qml.RX(beta[i], wires=i)

def circuit(param_b, param_c, edges, weights, n_qubits, n_layer):
    encode_layer(n_qubits)
    for j in range(n_layer):
        U_C(param_c[j], weights, edges)
        U_B(param_b[j], n_qubits)
    return qml.expval(qml.Z(0))

dev = qml.device('qiskit.ibmq', wires=n_node, backend='ibm_kyoto', ibmqx_token="~~~~")
circuit_dev = qml.qnode(dev)(circuit)

with qml.Tracker(dev) as tracker:

    print(circuit_dev.get_best_method(dev, interface="numpy"))
    lr = 0.15
    opt_b = qml.AdamOptimizer(lr)
    param_b = np.random.uniform(0, np.pi * 2, (n_layer, n_node))
    param_c = np.random.uniform(0, np.pi * 2, (n_layer))
    param_b, loss = opt_b.step_and_cost(lambda param: circuit_dev(param, param_c, edges, weights, n_node, n_layer), param_b)

print(tracker.latest)

(<transform: param_shift>, {}, <IBMQDevice device (wires=6, shots=1024) at 0x3109f6290>)
...
{'job_time': {'queued': 0.886248, 'running': 35.419}}

I tried using our tracker (qml.Tracker — PennyLane 0.35.1 documentation) to see what was going on, but everything seems fine! Let me know if you’re able to replicate this. For reference:

Name: PennyLane
Version: 0.35.1
Summary: PennyLane is a cross-platform Python library for quantum computing, quantum machine learning, and quantum chemistry. Train a quantum computer the same way as a neural network.
Home-page: https://github.com/PennyLaneAI/pennylane
Author: 
Author-email: 
License: Apache License 2.0
Location: /Users/isaac/.virtualenvs/pennylane-qiskit/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-qiskit, PennyLane_Lightning

Platform info:           macOS-14.4.1-arm64-arm-64bit
Python version:          3.11.8
Numpy version:           1.26.4
Scipy version:           1.12.0
Installed devices:
- default.clifford (PennyLane-0.35.1)
- default.gaussian (PennyLane-0.35.1)
- default.mixed (PennyLane-0.35.1)
- default.qubit (PennyLane-0.35.1)
- default.qubit.autograd (PennyLane-0.35.1)
- default.qubit.jax (PennyLane-0.35.1)
- default.qubit.legacy (PennyLane-0.35.1)
- default.qubit.tf (PennyLane-0.35.1)
- default.qubit.torch (PennyLane-0.35.1)
- default.qutrit (PennyLane-0.35.1)
- null.qubit (PennyLane-0.35.1)
- lightning.qubit (PennyLane_Lightning-0.35.1)
- qiskit.aer (PennyLane-qiskit-0.35.1)
- qiskit.basicaer (PennyLane-qiskit-0.35.1)
- qiskit.ibmq (PennyLane-qiskit-0.35.1)
- qiskit.ibmq.circuit_runner (PennyLane-qiskit-0.35.1)
- qiskit.ibmq.sampler (PennyLane-qiskit-0.35.1)
- qiskit.remote (PennyLane-qiskit-0.35.1)
7

Your discussion is very interesting. Recently, I have also encountered the same problem. It seems that in my understanding, I only submitted one quantum circuit, but IBM prompted me to submit 1044 quantum circuits. I don’t understand why this is happening.
Here is my example code:

args.n_qubits = 4
args.n_layers = 3
        QiskitRuntimeService.save_account(channel="ibm_quantum", token="<YOUR_IBMQ_TOKEN>", overwrite=True)

        # To access saved credentials for the IBM quantum channel and select an instance
        service = QiskitRuntimeService(channel="ibm_quantum")
        backend = service.least_busy(operational=True, simulator=False, min_num_qubits=args.n_qubits)

        args.device = qml.device('qiskit.remote', wires=args.n_qubits, backend=backend)
args.device2 = qml.device("qiskit.aer", wires=args.n_qubits, shots=8000)

    control_targets = ind.clayers
    max_iterations = 40
    opt = qml.GradientDescentOptimizer(stepsize=0.4)
    [dataset] = qml.data.load("qchem", molname="H2", bondlength=0.742, basis="STO-3G")
    H = dataset.hamiltonian
    args.n_qubits = dataset.hf_state.shape[0]
    theta = pnp.random.random((args.n_layers, args.n_qubits, 3), requires_grad=True)

    def apply_produced_circuit(qml, control_ops):
        for op in control_ops:
            if op[0] == "TFG":
                if op[1] in [CX, CNOT]:
                    qml.CNOT(wires=[op[2], op[3]])
                else:
                    print("Problem in to_qiskit_circuit:", op[1])

    @qml.qnode(args.device)
    def cost_fn_1(theta):
        circuit(theta)
        return qml.expval(H)

    @qml.qnode(args.device2)
    def cost_fn_2(theta):
        circuit(theta)
        return qml.expval(H)

    def circuit(param):
        qml.BasisState(dataset.hf_state, wires=range(args.n_qubits))
        for layer in range(args.n_layers):
            for i in range(args.n_qubits):
                qml.RZ(param[layer, i, 0], wires=i)
                qml.RY(param[layer, i, 1], wires=i)
                qml.RZ(param[layer, i, 2], wires=i)
            apply_produced_circuit(qml, control_targets[layer])

    theta_1 = pnp.random.random((args.n_layers, args.n_qubits, 3), requires_grad=True)
    energies_1 = []
    for n in range(max_iterations):
        theta_1, prev_energy_1 = opt.step_and_cost(cost_fn_1, theta_1)
        energies_1.append(prev_energy_1)

    plt.plot(energies_1, color="r", label="default.qubit")

    min_energy = min(qml.eigvals(H))
    z = [min_energy] * max_iterations

    plt.plot(z, "--", color="k", label="Exact answer")
    plt.xlabel("VQE iterations")
    plt.ylabel("Energy (Ha)")
    plt.legend()
    # plt.show()
8

Hi @yulianhui , welcome to the Forum!

Note that calculating the gradient of a QNode takes three evaluations: one forward pass and one batch of length two for the derivative of the gates in the circuit. For every iteration in your optimization loop you’ll need to calculate the gradient so if you have 40 iterations you’ll need 120 evaluations in total.

You can use qml.Tracker to check how many evaluations it takes. Below is a code example showing this with qiskit.aer.

import pennylane as qml
from pennylane import numpy as pnp

# Use a simulator
dev = qml.device("qiskit.aer", wires=2, shots=1024)

# Activate the device resource tracker
dev.tracker.active = True

# Create your QNode
@qml.qnode(dev)
def circuit(theta):
  qml.RX(theta,wires=0)
  qml.CNOT(wires=[0,1])
  return qml.expval(qml.PauliZ(0))

theta_1 = pnp.array(1.0)

max_iterations = 40
opt = qml.GradientDescentOptimizer(stepsize=0.4)

for n in range(max_iterations):
  theta_1, prev_energy_1 = opt.step_and_cost(circuit, theta_1)


# Print the summary of job time per step
print('Summary: \n',dev.tracker.totals)

# Draw the circuit and print the output
qml.draw_mpl(circuit)(theta_1)
print(circuit(theta_1))

If you still have mysterious evaluations, I would recommend that you simplify your code as much as possible (you can start with my code) and slowly add complexity until you can find the source of the issue.

I hope this helps!

9

Thank you very much for your reply. I will adopt your suggestions to improve my code.
I would like to ask you a question off topic. Has pennylane-qiskit released version 0.39.0? I run pip install pennylane-qiskit=0.39.0 and it says there is no such version.

10

In addition, I have tried to reduce the scale of the circuit. For a 4-qubit circuit, about 24 rotation gates will reach the scale of 390 quantum circuits, not including the basic CNOT gate. This scale of circuit is not practical for simple quantum machine learning tasks. I load the rot quantum gate for each bit in the circuit, and the back propagation time will be as high as 55-57 seconds, which is also a large resource consumption for real quantum computers. Is this normal, or is there a better solution? :slight_smile:

11

Hi @yulianhui , the latest stable version of the plugin is v0.38.0. If you always want to stay in the latest stable version you can always run python -m pip install pennylane-qiskit --upgrade. You can do the same with pennylane.

For your code I don’t think the issue is the number of qubits or gates, I think it’s more due to the nested loops and the number of iterations that you’re using. So I would recommend simplifying your code to try avoiding those nested for loops for example.

I hope this helps.