IBM Quantum Compute (anciennement « Qiskit Runtime ») Client

qiskit_ibm_runtime

Modules liés au client « IBM Quantum Compute » (anciennement « Qiskit Runtime »).

IBM Quantum Compute (anciennement « Qiskit Runtime ») est une nouvelle architecture qui optimise les calculs nécessitant de nombreuses itérations. Ces expériences s'exécuteront nettement plus rapidement grâce à ce processus hybride quantique/classique amélioré.

Primitives et sessions

IBM Quantum Compute dispose de deux primitives prédéfinies : Sampler et Estimator. Ces primitives offrent une interface simplifiée permettant d'effectuer des tâches fondamentales en informatique quantique, tout en tenant compte des dernières avancées en matière de matériel et de logiciels quantiques.

IBM Quantum Compute intègre également la notion de session. Les tâches soumises au cours d'une même session sont classées par ordre de priorité par le planificateur. Une session vous permet d'effectuer plus efficacement des appels itératifs vers l'ordinateur quantique.

Voici un exemple d'utilisation de primitives au sein d'une session :

from qiskit_ibm_runtime import QiskitRuntimeService, Session
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit.circuit.library import real_amplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Initialize account.
service = QiskitRuntimeService()

# Prepare inputs.
psi = real_amplitudes(num_qubits=2, reps=2)
H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)])
theta = [0, 1, 1, 2, 3, 5]
# Bell Circuit
qr = QuantumRegister(2, name="qr")
cr = ClassicalRegister(2, name="cr")
qc = QuantumCircuit(qr, cr, name="bell")
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.measure(qr, cr)

backend = service.least_busy(operational=True, simulator=False)
pm = generate_preset_pass_manager(target=backend.target, optimization_level=1)

bell_isa_circuit = pm.run(qc)
psi_isa_circuit = pm.run(psi)
isa_observables = H1.apply_layout(psi_isa_circuit.layout)

with Session(backend=backend) as session:
    # Submit a request to the Sampler primitive within the session.
    sampler = Sampler(mode=session)
    job = sampler.run([bell_isa_circuit])
    pub_result = job.result()[0]
    print(f"Counts: {pub_result.data.cr.get_counts()}")

    # Submit a request to the Estimator primitive within the session.
    estimator = Estimator(mode=session)
    estimator.options.resilience_level = 1  # Set options.
    job = estimator.run(
        [(psi_isa_circuit, isa_observables, theta)]
    )
    pub_result = job.result()[0]
    print(f"Expectation values: {pub_result.data.evs}")

Mode de test local

Vous pouvez valider vos programmes quantiques avant de les envoyer dans un système physique en utilisant le mode de test local. Le mode de test local est activé si l'un des faux backends de qiskit_ibm_runtime.fake_provider ou une instance de backend Qiskit Aer est utilisée lors de l'instanciation d'une primitive ou d'une session. Par exemple :

from qiskit_aer import AerSimulator
from qiskit.circuit.library import real_amplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

from qiskit_ibm_runtime import Session
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the sampler job locally using FakeManilaV2
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(backend=fake_manila)
result = sampler.run([isa_qc]).result()

# Run the sampler job locally using AerSimulator.
# Session syntax is supported but ignored.
aer_sim = AerSimulator()
pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
with Session(backend=aer_sim) as session:
    sampler = Sampler(mode=session)
    result = sampler.run([isa_qc]).result()

Données backend

QiskitRuntimeService dispose également de méthodes, telles que backend(), backends(), et least_busy(), qui vous permettent de rechercher un backend cible à utiliser. Ces méthodes renvoient une ou plusieurs IBMBackend instances contenant des méthodes et des attributs décrivant le backend.

Informations complémentaires

Initialisation du compte

Vous devez initialiser votre compte avant de pouvoir commencer à utiliser le service IBM Quantum Compute. Pour ce faire, il suffit d'initialiser une instance QiskitRuntimeService avec les identifiants de votre compte. Si vous ne souhaitez pas saisir vos identifiants à chaque fois, vous pouvez utiliser la méthode QiskitRuntimeService.save_account() pour les enregistrer sur le disque.

IBM Quantum Compute est disponible sur IBM Cloud, et vous pouvez indiquer la chaîne à l'aide de ou channel="ibm_cloud" channel="ibm_quantum_platform".

IBM Quantum Compute Offres d'emploi

Lorsque vous utilisez la run() méthode de ou Estimator pour appeler la primitive, une RuntimeJobV2 instance de Sampler est renvoyée. Cette classe dispose de toutes les méthodes de base, telles que RuntimeJobV2.status(), RuntimeJobV2.result(), et RuntimeJobV2.cancel().

Journalisation

qiskit-ibm-runtime utilise l'enregistreur qiskit_ibm_runtime .

Deux variables d'environnement peuvent être utilisées pour contrôler la journalisation :

• QISKIT_IBM_RUNTIME_LOG_LEVEL: Spécifie le niveau de journalisation à utiliser.

  Si un niveau non valide est défini, le niveau d'enregistrement est par défaut WARNING. Les niveaux d'enregistrement valides sont DEBUG, INFO, WARNING, ERROR, et CRITICAL (insensible à la casse). Si la variable d'environnement n'est pas définie, c'est le niveau de l'enregistreur parent qui est utilisé, qui est également par défaut WARNING.

• QISKIT_IBM_RUNTIME_LOG_FILE: Spécifie le nom du fichier journal à utiliser. Si spécifié,

  sont enregistrés dans le fichier uniquement. Dans le cas contraire, les messages seront consignés dans l'erreur standard (généralement à l'écran).

Pour une utilisation plus avancée, vous pouvez modifier l'enregistreur lui-même. Par exemple, pour régler manuellement le niveau sur WARNING:

import logging
logging.getLogger('qiskit_ibm_runtime').setLevel(logging.WARNING)

Cours