IBM Quantum Compute (precedentemente Qiskit Runtime ) Cliente

qiskit_ibm_runtime

Moduli relativi al client IBM Quantum Compute (precedentemente Qiskit Runtime ).

IBM Quantum Compute (precedentemente denominata “ Qiskit Runtime ”) è una nuova architettura che ottimizza i calcoli che richiedono numerose iterazioni. Questi esperimenti verranno eseguiti in modo significativamente più veloce grazie al processo ibrido quantistico-classico ottimizzato.

Primitive e sessioni

IBM Quantum Compute dispone di due primitive predefinite: Sampler e Estimator. Queste primitive offrono un'interfaccia semplificata per l'esecuzione di operazioni fondamentali nell'ambito del calcolo quantistico, tenendo conto al contempo degli ultimi sviluppi nell'ambito dell'hardware e del software quantistico.

IBM Quantum Compute prevede anche il concetto di sessione. I lavori inviati durante una sessione vengono ordinati per priorità dallo scheduler. Una sessione consente di effettuare chiamate iterative al computer quantistico in modo più efficiente.

Di seguito è riportato un esempio di utilizzo delle primitive all'interno di una sessione:

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}")

Modalità di test locale

È possibile convalidare i programmi quantistici prima di inviarli a un sistema fisico utilizzando la modalità di test locale. La modalità di test locale viene attivata se, durante l'istanziazione di una primitiva o di una sessione, viene utilizzato uno dei falsi backend di qiskit_ibm_runtime.fake_provider o un'istanza di Qiskit Aer backend. Ad esempio:

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()

Dati di backend

QiskitRuntimeService dispone inoltre di metodi, quali backend(), backends(), e least_busy(), che consentono di individuare il backend da utilizzare. Questi metodi restituiscono una o più IBMBackend istanze contenenti metodi e attributi che descrivono il backend.

Informazioni supplementari

Inizializzazione dell'account

È necessario inizializzare il proprio account prima di poter iniziare a utilizzare il servizio IBM Quantum Compute. Per farlo, è necessario inizializzare un'istanza QiskitRuntimeService con le credenziali del proprio account. Se non vuoi inserire le credenziali ogni volta, puoi utilizzare il metodo QiskitRuntimeService.save_account() per salvarle su disco.

IBM Quantum Compute è disponibile su IBM Cloud, ed è possibile specificare il canale con channel="ibm_cloud" o channel="ibm_quantum_platform".

IBM Quantum Compute Offerte di lavoro

Quando si utilizza il run() metodo di o Estimator per richiamare la primitiva, viene restituita un’istanza RuntimeJobV2 di Sampler . Questa classe dispone di tutti i metodi di lavoro di base, quali RuntimeJobV2.status(), RuntimeJobV2.result(), e RuntimeJobV2.cancel().

Registrazione

qiskit-ibm-runtime utilizza il logger qiskit_ibm_runtime .

È possibile utilizzare due variabili d'ambiente per controllare la registrazione:

• QISKIT_IBM_RUNTIME_LOG_LEVEL: Specifica il livello di log da utilizzare.

  Se viene impostato un livello non valido, il livello di log viene impostato come predefinito su WARNING. I livelli di registro validi sono DEBUG, INFO, WARNING, ERROR e CRITICAL (senza distinzione tra maiuscole e minuscole). Se la variabile d'ambiente non è impostata, viene utilizzato il livello del logger padre, anch'esso predefinito a WARNING.

• QISKIT_IBM_RUNTIME_LOG_FILE: Specifica il nome del file di registro da utilizzare. Se specificato,

  i messaggi saranno registrati solo nel file. Altrimenti i messaggi saranno registrati nello standard error (di solito sullo schermo).

Per un uso più avanzato, è possibile modificare il logger stesso. Ad esempio, per impostare manualmente il livello su WARNING:

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

Classi