Qiskit is an open-source SDK for working with quantum computers at the level of circuits, algorithms, and application modules.
Qiskit Runtime is a new architecture offered by IBM Quantum that streamlines quantum computations. It is designed to use classical compute resources to execute quantum circuits with more efficiency on quantum processors.
Using Qiskit Runtime, for example, a research team at IBM Quantum was able to achieve 120x speed up in their lithium hydride simulation. For more information, see the IBM Research blog.
This module provides the interface to access Qiskit Runtime.
You can install this package using pip:
pip install qiskit-ibm-runtimeQiskit Runtime is now part of the IBM Quantum Services on IBM Cloud. To use this service, you'll need to create an IBM Cloud account and a quantum service instance. This guide contains step-by-step instructions on setting this up, including directions to find your IBM Cloud API key and Cloud Resource Name (CRN), which you will need for authentication.
Prior to becoming an IBM Cloud service, Qiskit Runtime was offered on IBM Quantum. If you have an existing IBM Quantum account, you can continue using Qiskit Runtime on IBM Quantum.
You will need your IBM Quantum API token to authenticate with the Qiskit Runtime service:
-
Create an IBM Quantum account or log in to your existing account by visiting the IBM Quantum login page.
-
Copy (and optionally regenerate) your API token from your IBM Quantum account page.
Once you have the account credentials, you can save them on disk, so you won't have to input
them each time. The credentials are saved in the $HOME/.qiskit/qiskit-ibm.json file, where $HOME is your home directory.
from qiskit_ibm_runtime import QiskitRuntimeService
# Save an IBM Cloud account.
QiskitRuntimeService.save_account(channel="ibm_cloud", token="MY_IBM_CLOUD_API_KEY", instance="MY_IBM_CLOUD_CRN")
# Save an IBM Quantum account.
QiskitRuntimeService.save_account(channel="ibm_quantum", token="MY_IBM_QUANTUM_TOKEN")Once the account is saved on disk, you can instantiate the service without any arguments:
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()Alternatively, the service can discover credentials from environment variables:
export QISKIT_IBM_TOKEN="MY_IBM_CLOUD_API_KEY"
export QISKIT_IBM_INSTANCE="MY_IBM_CLOUD_CRN"
export QISKIT_IBM_CHANNEL="ibm_cloud"Then instantiate the service without any arguments:
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()As another alternative, you can also enable an account just for the current session by instantiating the service with your credentials.
from qiskit_ibm_runtime import QiskitRuntimeService
# For an IBM Cloud account.
ibm_cloud_service = QiskitRuntimeService(channel="ibm_cloud", token="MY_IBM_CLOUD_API_KEY", instance="MY_IBM_CLOUD_CRN")
# For an IBM Quantum account.
ibm_quantum_service = QiskitRuntimeService(channel="ibm_quantum", token="MY_IBM_QUANTUM_TOKEN")A Qiskit Runtime session allows a collection of jobs to be grouped and jointly scheduled by the Qiskit Runtime service, facilitating iterative use of quantum computers without incurring queuing delays on each iteration. A session is started when the first job within the session is started, and subsequent jobs within the session are prioritized by the scheduler.
You can use the qiskit_ibm_runtime.Session class to start a
session. There are some examples in the sections below.
Primitives are base level operations that serve as building blocks for many quantum algorithms and applications. The primitive interfaces are defined in Qiskit Terra, and many Qiskit algorithms use the primitives natively. This abstraction allows you to write the same code, using Qiskit algorithms or otherwise, that can run on different quantum hardware or simulators without having to explicitly manage some of the finer details.
There are currently two primitives defined in Qiskit: Estimator and Sampler. Qiskit Runtime service offers these primitives with additional features, such as built-in error suppression and mitigation.
There are several different options you can specify when calling the primitives. See qiskit_ibm_runtime.Options class for more information.
This is a primitive that takes a list of user circuits as an input and generates an error-mitigated readout of quasi-probabilities. This provides users a way to better evaluate shot results using error mitigation and enables them to more efficiently evaluate the possibility of multiple relevant data points in the context of destructive interference.
To invoke the Sampler primitive within a session:
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Options, Sampler
from qiskit import QuantumCircuit
service = QiskitRuntimeService()
options = Options(optimization_level=1)
options.execution.shots = 1024 # Options can be set using auto-complete.
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
with Session(service=service, backend="ibmq_qasm_simulator") as session:
sampler = Sampler(session=session, options=options)
job = sampler.run(circuits=bell)
print(f"Job ID is {job.job_id()}")
print(f"Job result is {job.result()}")
# You can make additional calls to Sampler and/or Estimator.This is a primitive that takes circuits and observables to evaluate expectation values and variances for a given parameter input. This primitive allows users to efficiently calculate and interpret expectation values of quantum operators required for many algorithms.
To invoke the Estimator primitive within a session:
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Options, Estimator
from qiskit import QuantumCircuit
from qiskit.circuit.library import RealAmplitudes
from qiskit.quantum_info import SparsePauliOp
service = QiskitRuntimeService()
options = Options(optimization_level=1)
options.execution.shots = 1024 # Options can be set using auto-complete.
psi1 = RealAmplitudes(num_qubits=2, reps=2)
H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)])
theta1 = [0, 1, 1, 2, 3, 5]
with Session(service=service, backend="ibmq_qasm_simulator") as session:
estimator = Estimator(session=session, options=options)
# calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
job = estimator.run(circuits=[psi1], observables=[H1], parameter_values=[theta1])
print(f"Job ID is {job.job_id()}")
print(f"Job result is {job.result()}")
# You can make additional calls to Sampler and/or Estimator.A backend is a quantum device or simulator capable of running quantum circuits or pulse schedules.
You can query for the backends you have access to. Attributes and methods of the returned instances provide information, such as qubit counts, error rates, and statuses, of the backends.
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
# Display all backends you have access.
print(service.backends())
# Get a specific backend.
backend = service.backend('ibmq_qasm_simulator')
# Print backend coupling map.
print(backend.coupling_map)Now you're set up and ready to check out some of the tutorials.
If you'd like to contribute to qiskit-ibm-runtime, please take a look at our contribution guidelines. This project adheres to Qiskit's code of conduct. By participating, you are expected to uphold to this code.
We use GitHub issues for tracking requests and bugs. Please use our slack
for discussion and simple questions. To join our Slack community use the
invite link at Qiskit.org. For questions that are more suited for a forum we
use the Qiskit tag in Stack Exchange.