Avvio rapido con Executor

Versioni dei pacchetti

Il codice in questa pagina è stato sviluppato con i seguenti requisiti. Ti consigliamo di utilizzare queste versioni o versioni più recenti.

qiskit[all]~=2.6.1
qiskit-ibm-runtime~=0.50.0
samplomatic~=0.21.0

Analogamente alla primitiva Sampler, Executor campiona i registri di output dalle esecuzioni di Circuit quantistici, ma non dispone di alcuna soppressione o mitigazione degli errori integrata. È invece parte del modello di esecuzione guidato che fornisce gli ingredienti per catturare gli intenti di progettazione sul lato client e spostare la costosa generazione di varianti di Circuit sul lato server. Executor segue le direttive fornite nelle annotazioni e nelle opzioni del circuito, genera e assegna i valori dei parametri, esegue sull'hardware i circuiti con i parametri assegnati e restituisce i risultati dell'esecuzione e i metadati. Non prende alcuna decisione implicita per te e ti offre pieno controllo e trasparenza.

nota

Il pacchetto Qiskit non dispone ancora di una classe base per la primitiva Executor.

Prima di iniziare

Alcuni degli esempi di codice in questa pagina utilizzano samplex, che fa parte del pacchetto Samplomatic. Pertanto, prima di eseguire quei blocchi di codice, devi installare Samplomatic, come mostrato nel seguente blocco di codice. Per ulteriori informazioni, consulta la documentazione di Samplomatic.

pip install samplomatic

# For visualization support, include the visualization dependencies.
# pip install samplomatic[vis]

Passaggi per utilizzare la primitiva Executor

1. Inizializza l'account

Poiché IBM Quantum Compute Service è un servizio gestito, devi prima inizializzare il tuo account. Puoi quindi selezionare la QPU che desideri utilizzare per calcolare il valore di aspettazione.

Segui i passaggi in Configura il tuo account IBM Cloud® se non hai già un account.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime", "samplomatic": "samplomatic"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_runtime import QiskitRuntimeService, Executor
from qiskit_ibm_runtime.quantum_program import QuantumProgram
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from samplomatic.transpiler import generate_boxing_pass_manager
from samplomatic import build

# Initialize the service and choose a backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

print(backend)

<IBMBackend('ibm_marrakesh')>

2. Crea e transpila un circuito

Hai bisogno di almeno un circuito per utilizzare la primitiva Executor. Può facoltativamente avere parametri.

# Generate the circuit
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.h(1)
circuit.cz(0, 1)
circuit.h(1)

# Using `measure_all` automatically creates the necessary
# classical registers.
circuit.measure_all()

Il circuito deve essere trasformato per usare solo le istruzioni supportate dalla QPU (i cosiddetti circuiti instruction set architecture (ISA)). Usa il Transpiler per farlo.

# Transpile the circuit
preset_pass_manager = generate_preset_pass_manager(
    backend=backend, optimization_level=0
)
isa_circuit = preset_pass_manager.run(circuit)

3. Inizializza un QuantumProgram

Inizializza un QuantumProgram con il tuo carico di lavoro. Un QuantumProgram è composto da QuantumProgramItems. Tipicamente, ogni elemento è composto da un circuito, un insieme di valori dei parametri ed eventualmente un samplex per randomizzare il contenuto del circuito. Per i dettagli completi, consulta Input e output di Executor.

La seguente cella inizializza un QuantumProgram e specifica di eseguire 25 shot. Poi aggiunge il circuito target transpilato.

# Initialize an empty program
program = QuantumProgram(shots=25)

# Append the circuit to the program
program.append_circuit_item(isa_circuit)

4. Opzionale: Raggruppa gate e misurazioni in box annotati

Raggruppare le istruzioni in box e annotarle è il modo principale per specificare il tuo intento. Nell'esempio seguente, usiamo generate_boxing_pass_manager e i suoi parametri di twirling per raggruppare i gate a due qubit e le misurazioni in box e applicare l'annotazione di twirling.

# Generate a boxing pass manager to group gates
# and measurements into boxes and add
# a`Twirl` annotation.
boxes_pm = generate_boxing_pass_manager(
    # Add gate twirling
    enable_gates=True,
    # Add measurement twirling
    enable_measures=True,
)

boxed_circuit = boxes_pm.run(isa_circuit)
boxed_circuit.draw("mpl", idle_wires=False)

5. Opzionale: Costruisci un circuito template e un samplex e aggiungili al programma

Poi, usa il metodo build di Samplomatic per generare la coppia circuito template e samplex. Il circuito template è strutturalmente equivalente al circuito originale. Tuttavia, i suoi gate a singolo qubit vengono sostituiti da gate parametrizzati per implementare le annotazioni prescritte (twirling di gate e misurazioni, in questo esempio). Il samplex codifica tutte le informazioni necessarie per generare parametri randomizzati per il circuito template.

Dopo aver generato la coppia circuito template e samplex, usa il metodo append_samplex_item per aggiungere la coppia al programma.

Consulta la documentazione dell'API di Samplomatic per i dettagli completi su samplomatic.samplex.Samplex e i suoi argomenti.

# Build the template circuit and the samplex
template_circuit, samplex = build(boxed_circuit)

# Append the template circuit and samplex as a `samplex_item`
program.append_samplex_item(
    template_circuit,
    samplex=samplex,
    shape=(num_randomizations := 20,),
)

6. Invoca Executor e ottieni i risultati

Esegui il QuantumProgram su un backend IBM® utilizzando la primitiva Executor con le opzioni predefinite. Consulta le opzioni di Executor per informazioni sulle opzioni disponibili.

# Initialize an Executor with the default options
executor = Executor(mode=backend)

# Submit the job
job = executor.run(program)
job

<RuntimeJobV2('dbjeahhkdqps7390ervg', 'executor')>

# Retrieve the result
result = job.result()

Il risultato è di tipo QuantumProgramResult. Consulta Input e output di Executor per informazioni sull'oggetto risultato.

Passi successivi

Raccomandazioni

• Prova alcuni esempi di Executor.
• Comprendi l'input e output di Executor.
• Scopri le semantiche di broadcasting di Executor.