Introduction to Qiskit Runtime

Qiskit Runtime is a cloud-based quantum computing service developed by IBM. It offers computational primitives to perform foundational quantum computing tasks that use built-in error suppression and mitigation techniques. Primitives can be executed inside of sessions, so that collections of circuits can jointly run on a quantum computer without being interrupted by other users’ jobs. The combination of primitives, error suppression / mitigation, and sessions paves the way to efficiently build and execute scalable quantum applications, as shown in the code examples.

The following figure illustrates how one can use Qiskit Runtime sessions and primitives. The first session request (job) waits through the regular fair-share queue. When it starts to run, the session is started. After the first session job is finished processing, the next job in the session is run. This process continues until the session is paused (due to a lack of queued session jobs) or closed.

Benefits of using Qiskit Runtime:

• Simplify algorithm design and optimization.
• Run circuits faster by using sessions - a context manager designed to efficiently manage iterative workloads and minimize artificial latency between quantum and classical sub-components.
• Access our most powerful quantum systems with our latest performance and hardware optimization, including capabilities like error suppression and mitigation.
• Easily integrate Qiskit Runtime with your cloud or on-premise classical compute resources by using the Quantum serverless (opens in a new tab) toolkit.

Simplified interface:

Use primitive programs to write code more efficiently. For details, see the Migration examples topic.

def get_evaluate_energy_vqe(
    self,
    ansatz: QuantumCircuit,
    operator: OperatorBase,
    return_expectation: bool = False,
) -> Callable[[np.ndarray], np.ndarray | float]:
 
    num_parameters = ansatz.num_parameters
    ansatz_params = ansatz.parameters
 
    expect_op, expectation = self.construct_expectation(
        ansatz_params, operator, return_expectation=True
    )
 
    def evaluate_energy(parameters: np.ndarray):
 
        parameter_sets = np.reshape(parameters, (-1, num_parameters))
        # Create dict associating each parameter with the lists of parameterization values for it
        param_bindings = dict(zip(ansatz_params, parameter_sets.transpose().tolist()))
 
        sampled_expect_op = self._circuit_sampler.convert(expect_op, params=param_bindings)
        means = np.real(sampled_expect_op.eval())
 
        return means if len(means) > 1 else means[0]
 
    if return_expectation:
        return evaluate_energy, expectation
 
    return evaluate_energy

def _get_evaluate_energy_vqe_primitives(
    self,
    ansatz: QuantumCircuit,
    operator: BaseOperator | PauliSumOp,
) -> Callable[[np.ndarray], np.ndarray | float]:
 
    num_parameters = ansatz.num_parameters
 
    def evaluate_energy(parameters: np.ndarray):
 
        parameters = np.reshape(parameters, (-1, num_parameters)).tolist()
        batch_size = len(parameters)
 
        job = self.estimator.run(batch_size * [ansatz], batch_size * [operator], parameters)
        estimator_result = job.result()
        values = estimator_result.values
 
        return values[0] if len(values) == 1 else values
 
    return evaluate_energy

Primitives

Primitives are base level operations that serve as building blocks for many quantum algorithms and applications. Through these primitives, users can obtain high-fidelity results without needing detailed hardware knowledge. This abstraction allows you to write code, using Qiskit algorithms or otherwise, that can run on various quantum hardware or simulators without having to explicitly manage aspects such as compilation, optimization, and error suppression / mitigation. The primitives offered by qiskit_ibm_runtime add additional options specific to IBM services. See Introduction to primitives for further details. There are currently two primitives defined in Qiskit: Estimator and Sampler.

Estimator

The Estimator primitive allows you to efficiently calculate and interpret expectation values of quantum operators, which are the values of interest for many near-term quantum algorithms. You specify circuits that prepare quantum states and then Pauli-basis observables to measure on those states. Estimator can use advanced error suppression and mitigation capabilities to improve the accuracy of the returned expectation values. Get started with the Estimator primitive here.

Sampler

This primitive takes circuits as input and returns a quasi-probability distribution over the measurement outcomes. This generalizes histograms from quantum circuits, allowing for mitigation of readout errors. Get started with the Sampler primitive tutorial here.

Sessions

Runtime sessions can be used in conjunction with Qiskit Runtime primitives. A 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. This eliminates artificial delays caused by other users’ jobs running on the same quantum device during the session. See the sessions topic for more information.

Error suppression / mitigation

While building a fault-tolerant quantum computation is the ultimate goal, at present, calculations performed on near-term quantum computers are susceptible to noise. Qiskit Runtime offers a number of methods for preventing errors before they occur (error suppression techniques) and dealing with those that do occur (error mitigation techniques). See Configure error suppression and Configure error mitigation for details.

Runtime FAQs

Next steps