Guida rapida per gli amministratori

• Versioni del pacchetto

  Il codice presente in questa pagina è stato sviluppato sulla base dei seguenti requisiti. Si consiglia di utilizzare queste versioni o quelle più recenti.

  qiskit[all]~=2.4.0
  qiskit-ibm-runtime~=0.46.1
  samplomatic~=0.18.0
  

Analogamente alla primitiva Sampler, Executor campiona i registri di uscita delle esecuzioni dei circuiti quantistici, ma non dispone di alcuna funzione integrata di soppressione o mitigazione degli errori. Fa invece parte del modello di esecuzione guidata, che fornisce gli elementi necessari per cogliere le intenzioni progettuali sul lato client e sposta la costosa generazione delle varianti dei circuiti sul lato server. L'esecutore segue le direttive fornite nelle annotazioni e nelle opzioni dei circuiti, genera e associa i valori dei parametri, esegue i circuiti associati sull'hardware e restituisce i risultati dell'esecuzione e i metadati. Non prende alcuna decisione al posto tuo e ti garantisce pieno controllo e trasparenza.

Prima di iniziare

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

pip install samplomatic

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

Istruzioni per l'uso della primitiva Executor

1. Inizializzare l'account

Poiché il servizio di elaborazione IBM Quantum è un servizio gestito, è necessario innanzitutto inizializzare il proprio account. È quindi possibile selezionare la QPU che si desidera utilizzare per calcolare il valore atteso.

Se non disponi ancora di un account, segui la procedura descrit ta nella guida "Configurazione dell'account IBM Cloud® ".

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)

Output:

<IBMBackend('ibm_fez')>

2. Creare e compilare un circuito

Per utilizzare la primitiva Executor è necessario disporre di almeno un circuito. Può avere dei parametri facoltativi.

# 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 modificato in modo da utilizzare esclusivamente istruzioni supportate dalla QPU (circuiti denominati "architecture del set di istruzioni" o ISA ). Per farlo, usa il transpiler.

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

3. Inizializzare un oggetto QuantumProgram

Inizializza un QuantumProgram con il tuo carico di lavoro. A QuantumProgram è costituito da QuantumProgramItems. In genere, ogni elemento è costituito da un circuito, un insieme di valori dei parametri ed eventualmente un meccanismo samplex per randomizzare il contenuto del circuito. Per ulteriori dettagli, consultare la sezione "Input e output di Executor".

La cella seguente inizializza una variabile QuantumProgram e specifica di eseguire 25 prove. Successivamente, aggiunge il circuito di destinazione transpilato.

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

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

4. Facoltativo: raggruppare i cancelli e le misurazioni in riquadri annotati

Raggruppare le istruzioni in riquadri e annotarle è il modo principale per specificare ciò che si intende fare. Nell'esempio seguente, utilizziamo generate_boxing_pass_manager e i suoi parametri di rotazione per raggruppare porte a due qubit e misurazioni in riquadri e applicare l'annotazione di rotazione.

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

Output:

5. Facoltativo: creare un circuito modello e un samplex, quindi aggiungerli al programma

Successivamente, utilizza il metodo di compilazione Samplomatic per generare il circuito modello e la coppia di samplex. Il circuito modello è strutturalmente equivalente al circuito originale. Tuttavia, i suoi gate a singolo qubit vengono sostituiti da gate parametrizzati al fine di implementare le operazioni prescritte (in questo esempio, la rotazione dei gate e delle misurazioni). Il samplex codifica tutte le informazioni necessarie per generare parametri casuali per il circuito modello.

Dopo aver generato il circuito modello e la coppia di campioni, usa il append_samplex_item metodo per aggiungere la coppia al programma.

Per ulteriori dettagli su samplomatic.samplex.Samplex e sui suoi argomenti, consultare la documentazione dell'API di Samplomatic.

# 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. Eseguire Executor e ottenere i risultati

Esegui il programma QuantumProgram su un backend IBM®, utilizzando la Executor funzione con le opzioni predefinite. Consulta la sezione "Opzioni di Executor" per scoprire le opzioni disponibili.

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

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

Output:

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

# Retrieve the result
result = job.result()

Il risultato è di tipo QuantumProgramResult. Per ulteriori informazioni sull'oggetto risultato, consultare la sezione "Input e output di Executor".

Passi successivi