Pennylane-Qiskit Session Error

PennyLane Plugins PennyLane Qiskit
1

I am having trouble trying to make a QML model that is within a Qiskit runtime session. The motivation for trying to do it in a session is because with a real QML example (not the toy case below) it was estimated to take 9 days for one iteration with queue times. And with the version of pennylane-qiskit I am using I cannot use this for some reason: from pennylane_qiskit import qiskit_session. Any suggestions on what to do would be greatly appreciated.

#!/usr/bin/env python
# coding: utf-8
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import numpy as np
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import joblib
import click
import json
import time
import os
import itertools
import collections.abc
import pandas as pd
import pennylane as qml
from tqdm import tqdm
from qiskit_ibm_runtime import QiskitRuntimeService, Session

os.environ["OMP_NUM_THREADS"] = "12"

# Set random seed for reproducibility
np.random.seed(42)
torch.manual_seed(42)
generator = np.random.default_rng(12958234)

# Synthetic data
X=generator.uniform(-1, 1, (100,5))
y=generator.uniform(-1, 1, (100,))
X_train, X_test, y_train, y_test = X[:80,:],X[80:,:],y[:80],y[80:]
print(X_train.shape,X_test.shape)



# Define custom Dataset
class RegressionDataset(Dataset):
    def __init__(self, features, targets):
        self.X = torch.from_numpy(features).float()
        self.y = torch.from_numpy(targets).float()
    
    def __len__(self):
        return len(self.X)
    
    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

# Create DataLoaders
batch_size = 32 * 8
train_dataset = RegressionDataset(X_train, y_train)
test_dataset = RegressionDataset(X_test, y_test)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)




# Initial ize device and circuit
num_qubits=5
re_upload_depth=1
n_layers=1

service = QiskitRuntimeService(channel="ibm_quantum", instance='totally_real_instance')
_backend = service.least_busy(operational=True, simulator=False, min_num_qubits=num_qubits)
dev = qml.device("qiskit.remote", wires=num_qubits, backend=_backend,shots=1024,session=Session(backend=_backend))

# Qulacs simulator
# dev = qml.device("qulacs.simulator", wires=num_qubits)

# Simple circuit
@qml.qnode(dev, interface="torch")
def circuit(inputs, weights):
    for i in range(re_upload_depth):
        qml.AngleEmbedding(inputs, wires=range(num_qubits))
        qml.BasicEntanglerLayers(weights, wires=range(num_qubits))
    return qml.expval(qml.PauliZ(0))

# Initialize pytorch model
weight_shapes = {"weights": (n_layers, num_qubits)}
print(weight_shapes)
qlayer = qml.qnn.TorchLayer(circuit, weight_shapes)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = torch.nn.Sequential(*[qlayer]).to(device)
print(model)


# Define loss and optimizer
criterion = nn.MSELoss()
learning_rate = 0.001
optimizer = optim.Adam(qlayer.parameters(), lr=learning_rate)

# Training loop
epochs = 10
train_losses = []
test_losses = []
for epoch in tqdm(range(epochs)):
    model.train()
    running_loss = 0.0
    for batch_X, batch_y in train_loader:
        optimizer.zero_grad()
        batch_X=batch_X.to(device)
        batch_y=batch_y.to(device)
        outputs = model(batch_X)
        loss = criterion(outputs, batch_y)
        loss.backward()
        optimizer.step()
        running_loss += loss.item() * batch_X.size(0)
    
    epoch_loss = running_loss / len(train_loader.dataset)
    train_losses.append(epoch_loss)
    
    # Evaluation on test set
    model.eval()
    test_running_loss = 0.0
    with torch.no_grad():
        for batch_X, batch_y in test_loader:
            outputs = model(batch_X)
            loss = criterion(outputs, batch_y)
            test_running_loss += loss.item() * batch_X.size(0)
    test_epoch_loss = test_running_loss / len(test_loader.dataset)
    test_losses.append(test_epoch_loss)
    
    if (epoch+1) % 1 == 0 or epoch == 0:
        print(f"Epoch [{epoch+1}/{epochs}] - Train Loss: {epoch_loss:.4f} - Test Loss: {test_epoch_loss:.4f}")





# Evaluation
model.eval()
predictions = []
actuals = []

with torch.no_grad():
    for batch_X, batch_y in train_loader:
        outputs = model(batch_X)
        predictions.extend(outputs.squeeze().tolist())
        actuals.extend(batch_y.squeeze().tolist())

mse = mean_squared_error(actuals, predictions)
mae = mean_absolute_error(actuals, predictions)
r2 = r2_score(actuals, predictions)
print(f"\nTest MSE: {mse:.4f}")
print(f"Test MAE: {mae:.4f}")
print(f"Test R$^2$: {r2:.4f}")

Here is the error message:

  File "$HOME/BSE5_real/min_ex.py", line 146, in <module>
    outputs = model(batch_X)
              ^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/nn/modules/module.py", line 1553, in _wrapped_call_impl
    return self._call_impl(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/nn/modules/module.py", line 1562, in _call_impl
    return forward_call(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/nn/modules/container.py", line 219, in forward
    input = module(input)
            ^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/nn/modules/module.py", line 1553, in _wrapped_call_impl
    return self._call_impl(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/nn/modules/module.py", line 1562, in _call_impl
    return forward_call(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/qnn/torch.py", line 404, in forward
    results = self._evaluate_qnode(inputs)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/qnn/torch.py", line 430, in _evaluate_qnode
    res = self.qnode(**kwargs)
          ^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/qnode.py", line 1020, in __call__
    return self._impl_call(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/qnode.py", line 1008, in _impl_call
    res = self._execution_component(args, kwargs, override_shots=override_shots)
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/qnode.py", line 957, in _execution_component
    res = qml.execute(
          ^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/execution.py", line 771, in execute
    results = ml_boundary_execute(tapes, execute_fn, jpc, device=device)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/interfaces/torch.py", line 236, in execute
    return ExecuteTapes.apply(kwargs, *parameters)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/interfaces/torch.py", line 89, in new_apply
    flat_out = orig_apply(out_struct_holder, *inp)
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/autograd/function.py", line 574, in apply
    return super().apply(*args, **kwargs)  # type: ignore[misc]
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/interfaces/torch.py", line 93, in new_forward
    out = orig_fw(ctx, *inp)
          ^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/interfaces/torch.py", line 158, in forward
    res = tuple(kwargs["execute_fn"](ctx.tapes))
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/execution.py", line 212, in inner_execute
    results = device.execute(transformed_tapes, execution_config=execution_config)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py", line 66, in execute
    results = tracked_execute(self, circuits, execution_config)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/devices/modifiers/simulator_tracking.py", line 30, in execute
    results = untracked_execute(self, circuits, execution_config)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py", line 590, in execute
    with execute_circuits(session) as results:
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/contextlib.py", line 137, in __enter__
    return next(self.gen)
           ^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py", line 585, in execute_circuits
    results.append(execute_fn(circ, session))
                   ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py", line 656, in _execute_estimator
    result = estimator.run(
             ^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit_ibm_runtime/estimator.py", line 191, in run
    coerced_pubs = [EstimatorPub.coerce(pub, precision) for pub in pubs]
                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit/primitives/containers/estimator_pub.py", line 162, in coerce
    return cls(
           ^^^^
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit/primitives/containers/estimator_pub.py", line 85, in __init__
    self.validate()
  File "$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit/primitives/containers/estimator_pub.py", line 188, in validate
    raise ValueError(
ValueError: The number of qubits of the circuit (127) does not match the number of qubits of the (0,)-th observable (5).

Here is the qml.about() information:

Name: PennyLane
Version: 0.38.0
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/miniconda3/envs/qml_min/lib/python3.12/site-packages
Requires: appdirs, autograd, autoray, cachetools, networkx, numpy, packaging, pennylane-lightning, requests, rustworkx, scipy, toml, typing-extensions
Required-by: PennyLane-qiskit, pennylane-qulacs, PennyLane_Lightning

Platform info:           Linux-6.10.12-amd64-x86_64-with-glibc2.40
Python version:          3.12.4
Numpy version:           1.26.4
Scipy version:           1.14.1
Installed devices:
- qulacs.simulator (pennylane-qulacs-0.36.0.post0)
- default.clifford (PennyLane-0.38.0)
- default.gaussian (PennyLane-0.38.0)
- default.mixed (PennyLane-0.38.0)
- default.qubit (PennyLane-0.38.0)
- default.qubit.autograd (PennyLane-0.38.0)
- default.qubit.jax (PennyLane-0.38.0)
- default.qubit.legacy (PennyLane-0.38.0)
- default.qubit.tf (PennyLane-0.38.0)
- default.qubit.torch (PennyLane-0.38.0)
- default.qutrit (PennyLane-0.38.0)
- default.qutrit.mixed (PennyLane-0.38.0)
- default.tensor (PennyLane-0.38.0)
- null.qubit (PennyLane-0.38.0)
- lightning.qubit (PennyLane_Lightning-0.38.0)
- qiskit.aer (PennyLane-qiskit-0.38.1)
- qiskit.basicaer (PennyLane-qiskit-0.38.1)
- qiskit.basicsim (PennyLane-qiskit-0.38.1)
- qiskit.remote (PennyLane-qiskit-0.38.1)
2

I found and fixed the issue.

In the example [Using PennyLane with IBM’s quantum devices and Qiskit](https://pennylane.ai/qml/demos/ibm_pennylane/), it uses the following:

with qiskit_session(dev) as session:

Where as I had to do the following:

with qiskit_device.qiskit_session(dev) as session:

And lastly, I should have “read the manual” more thoroughly since I was initializing with the minimal number of qubits required but I needed to do the following: " # Although we only need 4 qubits, our device has 127 qubits, therefore we initialize with wires=127".

3

Hi @grier_jones , welcome to the Forum :tada:

I’m glad to see you found the answer! Let us know if you have any further questions.

1 Like
4

@CatalinaAlbornoz if I have another question related to the same issue but with a problem to this error: qiskit_ibm_runtime.exceptions.IBMRuntimeError: 'The session is closed.' Should I start a new thread or is it find to ask about that here?

5

Hi @grier_jones ,
Does your previous solution work under certain circumstance but not others?

If so, can you post the details here?

Qiskit has some restrictions on using sessions with the Open Plan.

The Qiskit docs even says it’s not supported:

Session execution mode is not supported in the Open Plan. Jobs will run in job mode instead.

A few weeks ago I found something in their docs saying that for open plan the sessions were allowed but shorter. My experience is that sessions are allowed but with complications.

If you post your code examples which worked vs didn’t work we can try to investigate if there’s anything we can do.

6

@CatalinaAlbornoz so it doesn’t run at all and this is with a premium plan. The session will open and then after the first sweep of iterations, it closes the session. I will post an example once IBM Quebec is back up.

7

It sounds like the session is timing out @grier_jones . You can set the timeout time up to a maximum determined by IBM. You can learn more details about these maximum times here. The criteria for closing jobs early is a bit unclear though if you look at the section on QPU maximum execution time.

For example, if you specify max_execution_time=5000 (approximately 83 minutes), but the QPU determines it should not take more than 5 minutes (300 seconds) to execute the job, then the job is canceled after 5 minutes.

My random guess would be that this is what’s causing the issue, but it could be something totally different.

8

After increasing the maximum time the session still times out.

Using this example here:

with qiskit_device.qiskit_session(dev,max_time='2h') as session:
    print(session.details())
    # Training loop
    epochs = 10
    train_losses = []
    test_losses = []
    for epoch in tqdm(range(epochs)):
        model.train()
        running_loss = 0.0
        for batch_X, batch_y in tqdm(train_loader, desc="Train"):
            optimizer.zero_grad()
            batch_X=batch_X.to(device)
            batch_y=batch_y.to(device)
            outputs = model(batch_X)
            loss = criterion(outputs, batch_y)
            loss.backward()
            optimizer.step()
            running_loss += loss.item() * batch_X.size(0)
        
        epoch_loss = running_loss / len(train_loader.dataset)
        train_losses.append(epoch_loss)
        
        # Evaluation on test set
        model.eval()
        test_running_loss = 0.0
        with torch.no_grad():
            for batch_X, batch_y in tqdm(test_loader, desc="Test"):
                outputs = model(batch_X)
                loss = criterion(outputs, batch_y)
                test_running_loss += loss.item() * batch_X.size(0)
        test_epoch_loss = test_running_loss / len(test_loader.dataset)
        test_losses.append(test_epoch_loss)
        
        if (epoch+1) % 1 == 0 or epoch == 0:
            print(f"Epoch [{epoch+1}/{epochs}] - Train Loss: {epoch_loss:.4f} - Test Loss: {test_epoch_loss:.4f}")
    
    
    
    
    
    # Evaluation
    model.eval()
    predictions = []
    actuals = []
    
    with torch.no_grad():
        for batch_X, batch_y in train_loader:
            outputs = model(batch_X)
            predictions.extend(outputs.squeeze().tolist())
            actuals.extend(batch_y.squeeze().tolist())

I get the following error:

{'id': 'REMOVED', 'backend_name': 'ibm_quebec', 'interactive_timeout': 60, 'max_time': 7200, 'active_timeout': 7200, 'state': 'open', 'accepting_jobs': True, 'last_job_started': None, 'last_job_completed': None, 'started_at': None, 'closed_at': None, 'activated_at': None, 'mode': 'dedicated', 'usage_time': None}
  0%|                                                                                                                                                                                       | 0/10 [00:00<?, ?it/s]
Train:   0%|                                                                                                                                                                              | 0/80 [1:22:49<?, ?it/s]
  0%|                                                                                                                                                                                     | 0/10 [1:22:49<?, ?it/s]
---------------------------------------------------------------------------
IBMRuntimeError                           Traceback (most recent call last)
Cell In[5], line 16
     14 outputs = model(batch_X)
     15 loss = criterion(outputs, batch_y)
---> 16 loss.backward()
     17 optimizer.step()
     18 running_loss += loss.item() * batch_X.size(0)

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/_tensor.py:521, in Tensor.backward(self, gradient, retain_graph, create_graph, inputs)
    511 if has_torch_function_unary(self):
    512     return handle_torch_function(
    513         Tensor.backward,
    514         (self,),
   (...)
    519         inputs=inputs,
    520     )
--> 521 torch.autograd.backward(
    522     self, gradient, retain_graph, create_graph, inputs=inputs
    523 )

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/autograd/__init__.py:289, in backward(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)
    284     retain_graph = create_graph
    286 # The reason we repeat the same comment below is that
    287 # some Python versions print out the first line of a multi-line function
    288 # calls in the traceback and some print out the last line
--> 289 _engine_run_backward(
    290     tensors,
    291     grad_tensors_,
    292     retain_graph,
    293     create_graph,
    294     inputs,
    295     allow_unreachable=True,
    296     accumulate_grad=True,
    297 )

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/autograd/graph.py:769, in _engine_run_backward(t_outputs, *args, **kwargs)
    767     unregister_hooks = _register_logging_hooks_on_whole_graph(t_outputs)
    768 try:
--> 769     return Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass
    770         t_outputs, *args, **kwargs
    771     )  # Calls into the C++ engine to run the backward pass
    772 finally:
    773     if attach_logging_hooks:

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/torch/autograd/function.py:306, in BackwardCFunction.apply(self, *args)
    300     raise RuntimeError(
    301         "Implementing both 'backward' and 'vjp' for a custom "
    302         "Function is not allowed. You should only implement one "
    303         "of them."
    304     )
    305 user_fn = vjp_fn if vjp_fn is not Function.vjp else backward_fn
--> 306 return user_fn(self, *args)

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/interfaces/torch.py:101, in pytreeify.<locals>.new_backward(ctx, *flat_grad_outputs)
     99 def new_backward(ctx, *flat_grad_outputs):
    100     grad_outputs = pytree.tree_unflatten(flat_grad_outputs, ctx._out_struct)
--> 101     grad_inputs = orig_bw(ctx, *grad_outputs)
    102     # None corresponds to the diff of out_struct_holder
    103     return (None,) + tuple(grad_inputs)

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/interfaces/torch.py:186, in ExecuteTapes.backward(ctx, *dy)
    183 # Torch obeys the dL/dz_conj convention instead of the
    184 # dL/dz convention of PennyLane, autograd and jax. This converts between the formats
    185 dy = _recursive_conj(dy)
--> 186 vjps = ctx.jpc.compute_vjp(ctx.tapes, dy)
    187 # split tensor into separate entries
    188 unpacked_vjps = []

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/jacobian_products.py:304, in TransformJacobianProducts.compute_vjp(self, tapes, dy)
    298     return _compute_vjps(jacs, dy, tapes)
    300 vjp_tapes, processing_fn = qml.gradients.batch_vjp(
    301     tapes, dy, self._gradient_transform, gradient_kwargs=self._gradient_kwargs
    302 )
--> 304 vjp_results = self._inner_execute(tuple(vjp_tapes))
    305 return tuple(processing_fn(vjp_results))

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/execution.py:212, in _make_inner_execute.<locals>.inner_execute(tapes, **_)
    209 transformed_tapes, transform_post_processing = transform_program(tapes)
    211 if transformed_tapes:
--> 212     results = device.execute(transformed_tapes, execution_config=execution_config)
    213 else:
    214     results = ()

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py:66, in custom_simulator_tracking.<locals>.execute(self, circuits, execution_config)
     64 @wraps(tracked_execute)
     65 def execute(self, circuits, execution_config=DefaultExecutionConfig):
---> 66     results = tracked_execute(self, circuits, execution_config)
     67     if self.tracker.active:
     68         res = []

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/devices/modifiers/simulator_tracking.py:30, in _track_execute.<locals>.execute(self, circuits, execution_config)
     28 @wraps(untracked_execute)
     29 def execute(self, circuits, execution_config=DefaultExecutionConfig):
---> 30     results = untracked_execute(self, circuits, execution_config)
     31     if isinstance(circuits, QuantumScript):
     32         batch = (circuits,)

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py:590, in QiskitDevice.execute(self, circuits, execution_config)
    587     finally:
    588         session.close()
--> 590 with execute_circuits(session) as results:
    591     return results

File ~/miniconda3/envs/qml_min/lib/python3.12/contextlib.py:137, in _GeneratorContextManager.__enter__(self)
    135 del self.args, self.kwds, self.func
    136 try:
--> 137     return next(self.gen)
    138 except StopIteration:
    139     raise RuntimeError("generator didn't yield") from None

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py:585, in QiskitDevice.execute.<locals>.execute_circuits(session)
    583         else:
    584             execute_fn = self._execute_sampler
--> 585         results.append(execute_fn(circ, session))
    586     yield results
    587 finally:

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py:655, in QiskitDevice._execute_estimator(self, circuit, session)
    650 # split into one call per measurement
    651 # could technically be more efficient if there are some observables where we ask
    652 # for expectation value and variance on the same observable, but spending time on
    653 # that right now feels excessive
    654 circ_and_obs = [(compiled_circuits[0], pauli_observables)]
--> 655 result = estimator.run(
    656     circ_and_obs,
    657     precision=np.sqrt(1 / circuit.shots.total_shots) if circuit.shots else None,
    658 ).result()
    659 self._current_job = result
    660 result = self._process_estimator_job(circuit.measurements, result)

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit_ibm_runtime/estimator.py:193, in EstimatorV2.run(self, pubs, precision)
    191 coerced_pubs = [EstimatorPub.coerce(pub, precision) for pub in pubs]
    192 validate_estimator_pubs(coerced_pubs)
--> 193 return self._run(coerced_pubs)

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit_ibm_runtime/base_primitive.py:187, in BasePrimitiveV2._run(self, pubs)
    185 # Batch or Session
    186 if self._mode:
--> 187     return self._mode.run(
    188         program_id=self._program_id(),
    189         inputs=primitive_inputs,
    190         options=runtime_options,
    191         callback=options_dict.get("environment", {}).get("callback", None),
    192         result_decoder=DEFAULT_DECODERS.get(self._program_id()),
    193     )
    195 if self._backend:
    196     runtime_options["backend"] = self._backend

File ~/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit_ibm_runtime/session.py:41, in _active_session.<locals>._wrapper(self, *args, **kwargs)
     38 @wraps(func)
     39 def _wrapper(self, *args, **kwargs):  # type: ignore
     40     if not self._active:
---> 41         raise IBMRuntimeError("The session is closed.")
     42     return func(self, *args, **kwargs)

IBMRuntimeError: 'The session is closed.'
9

hi @grier_jones , i am trying to recreate your issue and i wasn’t so sure what “qiskit_device” was, below is my code and the error

import pennylane as qml
from pennylane import numpy as pnp
from qiskit_ibm_runtime import QiskitRuntimeService
QiskitRuntimeService.save_account('my_account_info')
service = QiskitRuntimeService()
backend = service.backend(name= 'ibm_brussels')
qiskit_device = qml.device(
    "qiskit.remote",
    wires=127,
    backend=backend,
    resilience_level=1,
    optimization_level=1,
    seed_transpiler=42
)

with qiskit_device.qiskit_session(dev,max_time='2h') as session:
    print(session.details())

and i got the following error

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[11], line 1
----> 1 with qiskit_device.qiskit_session(dev,max_time='2h') as session:
      2     print(session.details())

File ~/miniconda3/envs/ml/lib/python3.10/site-packages/pennylane/devices/device_api.py:175, in Device.__getattr__(self, key)
    174 def __getattr__(self, key):
--> 175     raise AttributeError(
    176         f"{type(self).__name__} has no attribute '{key}'."
    177         " You may be looking for a property or method present in the legacy device interface."
    178         f" Please consult the {type(self).__name__} documentation for an updated list of public"
    179         " properties and methods."
    180     )

AttributeError: RemoteDevice has no attribute 'qiskit_session'. You may be looking for a property or method present in the legacy device interface. Please consult the RemoteDevice documentation for an updated list of public properties and methods.

i suppose your ‘qiskit_device’ was something different to mine.
Would you mind letting me know what it was so i can try to recreate this issue?
Thanks,
Hoon

qml.about

Name: PennyLane
Version: 0.38.0
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: /root/miniconda3/envs/ml/lib/python3.10/site-packages
Requires: appdirs, autograd, autoray, cachetools, networkx, numpy, packaging, pennylane-lightning, requests, rustworkx, scipy, toml, typing-extensions
Required-by: PennyLane-qiskit, PennyLane_Lightning

Platform info:           Linux-6.8.0-47-generic-x86_64-with-glibc2.31
Python version:          3.10.14
Numpy version:           1.26.4
Scipy version:           1.14.1
Installed devices:
- lightning.qubit (PennyLane_Lightning-0.38.0)
- default.clifford (PennyLane-0.38.0)
- default.gaussian (PennyLane-0.38.0)
- default.mixed (PennyLane-0.38.0)
- default.qubit (PennyLane-0.38.0)
- default.qubit.autograd (PennyLane-0.38.0)
- default.qubit.jax (PennyLane-0.38.0)
- default.qubit.legacy (PennyLane-0.38.0)
- default.qubit.tf (PennyLane-0.38.0)
- default.qubit.torch (PennyLane-0.38.0)
- default.qutrit (PennyLane-0.38.0)
- default.qutrit.mixed (PennyLane-0.38.0)
- default.tensor (PennyLane-0.38.0)
- null.qubit (PennyLane-0.38.0)
- qiskit.aer (PennyLane-qiskit-0.38.1)
- qiskit.basicaer (PennyLane-qiskit-0.38.1)
- qiskit.basicsim (PennyLane-qiskit-0.38.1)
- qiskit.remote (PennyLane-qiskit-0.38.1)```
10

The way i managed to create a session with IBM is described below

from pprint import pprint
from qiskit_ibm_runtime import Session
with Session(backend=backend) as session:
    pprint(session.details())

which gave the following output:

{'accepting_jobs': True,
 'activated_at': None,
 'active_timeout': 14400,
 'backend_name': 'ibm_brussels',
 'closed_at': None,
 'id': 'cwgcena31we00087sy00',
 'interactive_timeout': 60,
 'last_job_completed': None,
 'last_job_started': None,
 'max_time': 57600,
 'mode': 'dedicated',
 'started_at': None,
 'state': 'open',
 'usage_time': None}

I think we can still submit pennylane quantum circuits via this.
I executed the example from the turorial (Using PennyLane with IBM’s quantum devices and Qiskit | PennyLane Demos) and jobs are shown on my ibm-quanutm personal page.
Still I doubt the sessions are open long enough for us to perform machine learning task, especially if your dataset is large (mine is). I reckon we have to keep a detailed log before sessions are closed. Not entirely sure how to do it yet…

1 Like
11

Hi @grier_jones and @hoonjkim ,

It looks like there was an import missing in the plugin which is why this was failing. My colleague Austin found the issue and fixed it in record time! :tada:

You can use it with the development version of the plugin, and install it as follows:

python -m pip install git+https://github.com/PennyLaneAI/pennylane-qiskit.git#egg=pennylane-qiskit

You can then use something like the code below.

import pennylane as qml
from pennylane import numpy as pnp
from qiskit_ibm_runtime import QiskitRuntimeService
from pennylane_qiskit.qiskit_device import qiskit_session
QiskitRuntimeService.save_account(channel="ibm_quantum", token=token, overwrite=True)
# To access saved credentials for the IBM quantum channel and select an instance
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.backend(name= 'ibm_sherbrooke')
dev = qml.device(
    "qiskit.remote",
    wires=127,
    backend=backend,
    resilience_level=1,
    optimization_level=1,
    seed_transpiler=42
)

with qiskit_session(dev,max_time='2h') as session:
    print(session.details())

    # Add your code here
    
    @qml.qnode(dev)
    def circuit(theta):
      qml.RX(theta,wires=0)
      return qml.expval(qml.PauliZ(0))
    
    opt = qml.GradientDescentOptimizer(stepsize=0.3)
    
    theta = pnp.array(0.5)
    for i in range(10):
      theta = opt.step(circuit,theta)
      print('theta: ', theta, 'circuit: ', circuit(theta))

Note that resilience_level is only available in Qiskit’s Estimator but not in Sampler so if you’re using qml.expval() or qml.probs() this will work for you, but if you’re using other measurements you’ll need to remove this argument.

Thanks both for making us aware of this issue.

Let us know if the fix works for you.

1 Like
12

I uninstalled the old version of pennylane-qiskit and ran the example you provided and I ran into this error:

{'id': 'removed_id', 'backend_name': 'ibm_quebec', 'interactive_timeout': 60, 'max_time': 7200, 'active_timeout': 7200, 'state': 'open', 'accepting_jobs': True, 'last_job_started': None, 'last_job_completed': None, 'started_at': None, 'closed_at': None, 'activated_at': None, 'mode': 'dedicated', 'usage_time': None}
Traceback (most recent call last):
  File "/home/$HOME/qregress/debug/example.py", line 34, in <module>
    theta = opt.step(circuit,theta)
            ^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/optimize/gradient_descent.py", line 93, in step
    g, _ = self.compute_grad(objective_fn, args, kwargs, grad_fn=grad_fn)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/optimize/gradient_descent.py", line 122, in compute_grad
    grad = g(*args, **kwargs)
           ^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/_grad.py", line 166, in __call__
    grad_value, ans = grad_fn(*args, **kwargs)  # pylint: disable=not-callable
                      ^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/autograd/wrap_util.py", line 20, in nary_f
    return unary_operator(unary_f, x, *nary_op_args, **nary_op_kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/_grad.py", line 192, in _grad_with_forward
    grad_value = vjp(vspace(ans).ones())
                 ^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/autograd/core.py", line 14, in vjp
    def vjp(g): return backward_pass(g, end_node)
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/autograd/core.py", line 21, in backward_pass
    ingrads = node.vjp(outgrad[0])
              ^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/autograd/core.py", line 67, in <lambda>
    return lambda g: (vjp(g),)
                      ^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/interfaces/autograd.py", line 199, in grad_fn
    vjps = jpc.compute_vjp(tapes, dy)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/jacobian_products.py", line 297, in compute_vjp
    jacs = self.compute_jacobian(tapes)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/jacobian_products.py", line 328, in compute_jacobian
    results = self._inner_execute(jac_tapes)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/workflow/execution.py", line 212, in inner_execute
    results = device.execute(transformed_tapes, execution_config=execution_config)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py", line 66, in execute
    results = tracked_execute(self, circuits, execution_config)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane/devices/modifiers/simulator_tracking.py", line 30, in execute
    results = untracked_execute(self, circuits, execution_config)
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py", line 590, in execute
    with execute_circuits(session) as results:
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/contextlib.py", line 137, in __enter__
    return next(self.gen)
           ^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py", line 585, in execute_circuits
    results.append(execute_fn(circ, session))
                   ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/pennylane_qiskit/qiskit_device.py", line 656, in _execute_estimator
    result = estimator.run(
             ^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit_ibm_runtime/estimator.py", line 193, in run
    return self._run(coerced_pubs)  # type: ignore[arg-type]
           ^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit_ibm_runtime/base_primitive.py", line 187, in _run
    return self._mode.run(
           ^^^^^^^^^^^^^^^
  File "/home/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages/qiskit_ibm_runtime/session.py", line 41, in _wrapper
    raise IBMRuntimeError("The session is closed.")
qiskit_ibm_runtime.exceptions.IBMRuntimeError: 'The session is closed.'

Also here is the qml.about() information:

Name: PennyLane
Version: 0.38.0
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/$HOME/miniconda3/envs/qml_min/lib/python3.12/site-packages
Requires: appdirs, autograd, autoray, cachetools, networkx, numpy, packaging, pennylane-lightning, requests, rustworkx, scipy, toml, typing-extensions
Required-by: PennyLane-qiskit, pennylane-qulacs, PennyLane_Lightning

Platform info:           Linux-6.11.4-amd64-x86_64-with-glibc2.40
Python version:          3.12.4
Numpy version:           1.26.4
Scipy version:           1.14.1
Installed devices:
- qulacs.simulator (pennylane-qulacs-0.36.0.post0)
- default.clifford (PennyLane-0.38.0)
- default.gaussian (PennyLane-0.38.0)
- default.mixed (PennyLane-0.38.0)
- default.qubit (PennyLane-0.38.0)
- default.qubit.autograd (PennyLane-0.38.0)
- default.qubit.jax (PennyLane-0.38.0)
- default.qubit.legacy (PennyLane-0.38.0)
- default.qubit.tf (PennyLane-0.38.0)
- default.qubit.torch (PennyLane-0.38.0)
- default.qutrit (PennyLane-0.38.0)
- default.qutrit.mixed (PennyLane-0.38.0)
- default.tensor (PennyLane-0.38.0)
- null.qubit (PennyLane-0.38.0)
- lightning.qubit (PennyLane_Lightning-0.38.0)
- qiskit.aer (PennyLane-qiskit-0.39.0.dev0)
- qiskit.basicaer (PennyLane-qiskit-0.39.0.dev0)
- qiskit.basicsim (PennyLane-qiskit-0.39.0.dev0)
- qiskit.remote (PennyLane-qiskit-0.39.0.dev0)
13

Hi @grier_jones , thank you for reporting this.

I can replicate your error and we’re investigating what’s going on.

Do you have an example with Qiskit-only code that works for you? I coded up one example and the session still didn’t run perfectly (it kept hanging after running a couple of jobs).

I’m not a Qiskit expert so I’m adding my code here below in case you notice I did something wrong. If we can get a simple Qiskit-only version to work then we can have a baseline to keep testing and improving the plugin.

from qiskit_ibm_runtime import QiskitRuntimeService, Session, EstimatorV2 as Estimator
from qiskit.primitives import StatevectorEstimator
from scipy.optimize import minimize
from qiskit.quantum_info import Pauli
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
import numpy as np

QiskitRuntimeService.save_account(channel="ibm_quantum", token=token, overwrite=True)
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.backend(name= 'ibm_sherbrooke')

def cost_func(params, ansatz, hamiltonian, estimator):
    pub = (ansatz, hamiltonian, params)
    job = estimator.run([pub])
    print(f">>> Job ID: {job.job_id()}")
    results = job.result()[0]
    cost = results.data.evs
    objective_func_vals.append(cost)
    return cost
    
circuit = QuantumCircuit(1)
theta = Parameter("θ")
circuit.rx(theta, 0)
circuit.measure_all()
theta0 = np.ones(1)

z=np.ndarray((127,),buffer=np.zeros(127))
z[0]=1
x=np.ndarray((127,),buffer=np.zeros(127))
observable = Pauli((z, x))

# Create pass manager for transpilation
pm = generate_preset_pass_manager(optimization_level=1,
                                    backend=backend)

candidate_circuit = pm.run(circuit)

print(circuit.draw())
print(candidate_circuit.draw())

# Optimization
objective_func_vals = [] # Global variable

with Session(backend=backend) as session:

    estimator = Estimator(mode=session)
    estimator.options.default_shots = 1000
    
    result = minimize(cost_func, theta0, args=(candidate_circuit, observable, estimator), method="SLSQP", options={maxiter:5})
    
    
    print(result)
14

@CatalinaAlbornoz I don’t have a working Qiskit example currently. How many iterations did this run for you? I ran the code above and it returned this:

 message: Iteration limit reached
 success: False
  status: 9
     fun: 0.8499496475327291
       x: [-4.273e+03]
     nit: 5
     jac: [ 3.247e+06]
    nfev: 50
    njev: 5
15

Hi @grier_jones,

I’m not sure how many iterations it ran because it just created 4 jobs and then kept hanging. I’m afraid that there might be an issue with Qiskit itself and how it’s handling the sessions because if Qiskit-only code is failing then I don’t know how we can avoid this via the PennyLane-Qiskit plugin.

This is why I was asking if you have any code that works with sessions on Qiskit directly. If we can test this then we can figure out if this is an issue with Qiskit itself or if it’s an issue of how we’re using sessions.

16

@CatalinaAlbornoz I will reach out to the IBM Quantum people I know and if there is a working solution, I will update you. Thanks for your help!

17

Thanks @grier_jones !

18

@CatalinaAlbornoz I haven’t reached out to the IBM people yet because I successfully ran one of Qiskit’s QAOA examples on IBM Quebec using Sessions. After that example, I realized what was going wrong with the Qiskit example above (for me at least). All I had to do was add more max iterations and it ran perfectly:

result = minimize(cost_func, theta0, args=(candidate_circuit, observable, estimator), method="SLSQP", options={'maxiter':1000})
19

Oh nice! Thanks for letting me know @grier_jones . This helps a lot. I’ll let you know if I make any progress on my side testing this with the plugin.