Schnellstart für Executor

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen, diese Versionen oder neuere zu verwenden.

  qiskit[all]~=2.5.2
  qiskit-ibm-runtime~=0.47.0
  samplomatic~=0.21.0
  

Ähnlich wie die „Sampler “-Primitive liest der „Executor“ die Ausgaberegister von Quantenkreisausführungen aus, verfügt jedoch über keine integrierte Fehlerunterdrückung oder -minderung. Vielmehr ist es Teil des Modells der gesteuerten Ausführung, das die Voraussetzungen dafür schafft, Designabsichten auf der Client-Seite zu erfassen, und die aufwendige Generierung von Schaltungsvarianten auf die Server-Seite verlagert. Der Executor befolgt die in den Schaltkreis-Anmerkungen und -Optionen angegebenen Anweisungen, generiert und bindet Parameterwerte, führt die gebundenen Schaltkreise auf der Hardware aus und gibt die Ausführungsergebnisse sowie Metadaten zurück. Es trifft keine stillschweigenden Entscheidungen für Sie und bietet Ihnen volle Kontrolle und Transparenz.

Vorbereitende Schritte

Einige der Code-Beispiele auf dieser Seite verwenden samplex, das zum Samplomatic-Paket gehört. Bevor Sie diese Code-Blöcke ausführen, müssen Sie daher Samplomatic installieren, wie im folgenden Code-Block gezeigt. Weitere Informationen finden Sie in der Samplomatic-Dokumentation.

pip install samplomatic

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

Schritte zur Verwendung der Executor-Primitive

1. Das Konto einrichten

Da es sich bei „ IBM Quantum Compute Service“ um einen verwalteten Dienst handelt, müssen Sie zunächst Ihr Konto einrichten. Anschließend können Sie die QPU auswählen, die Sie zur Berechnung des Erwartungswerts verwenden möchten.

Befolgen Sie die Schritte unter „ IBM Cloud® -Konto einrichten “, falls Sie noch kein Konto haben.

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. Einen Schaltkreis erstellen und transpilieren

Sie benötigen mindestens einen Schaltkreis, um die Executor-Primitive nutzen zu können. Sie kann optional Parameter enthalten.

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

Die Schaltung muss so umgestaltet werden, dass sie ausschließlich Befehle verwendet, die von der QPU unterstützt werden (sogenannte ISA -Schaltungen, d. h. Schaltungen mit Befehlssatzarchitektur). Verwenden Sie dazu den Transpiler.

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

3. Initialisiere ein QuantumProgram

Initialisieren Sie ein QuantumProgram mit Ihrer Arbeitslast. A QuantumProgram besteht aus QuantumProgramItems. In der Regel besteht jedes Element aus einer Schaltung, einer Reihe von Parameterwerten und gegebenenfalls einer Funktion samplex zur Randomisierung des Schaltungsinhalts. Ausführliche Informationen finden Sie unter „Eingaben und Ausgaben des Executors “.

Die folgende Zelle initialisiert ein QuantumProgram und legt fest, dass 25 Schüsse ausgeführt werden sollen. Anschließend fügt es die transpilierte Zielschaltung an.

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

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

4. Optional: Gruppieren Sie Tore und Messungen in beschrifteten Rahmen

Das Zusammenfassen von Anweisungen in Blöcken und das Hinzufügen von Anmerkungen ist die wichtigste Methode, um Ihre Absicht zu verdeutlichen. Im folgenden Beispiel verwenden generate_boxing_pass_manager wir und seine Twirling-Parameter, um Zwei-Qubit-Gatter und Messungen in Kästchen zu gruppieren und eine Twirling-Annotation anzuwenden.

# 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. Optional: Erstelle eine Schaltungsvorlage und ein Samplex und füge sie dem Programm hinzu

Verwenden Sie anschließend die Samplomatic-Erstellungsmethode, um die Schaltungsvorlage und das Samplex -Paar zu generieren. Die Vorlagenschaltung entspricht strukturell der Originalschaltung. Allerdings werden die Einzel-Qubit-Gatter durch parametrisierte Gatter ersetzt, um die vorgegebenen Annotationen (in diesem Beispiel Gatter- und Messungs-Twirling) zu implementieren. Der Samplex enthält alle Informationen, die zur Erzeugung zufälliger Parameter für die Vorlagenschaltung erforderlich sind.

Nachdem Sie die Vorlagenschaltung und das Samplex-Paar erstellt haben, fügen Sie das Paar mithilfe der append_samplex_item Methode zum Programm hinzu.

Ausführliche Informationen zu und samplomatic.samplex.Samplex seinen Argumenten finden Sie in der Samplomatic-API-Dokumentation.

# 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. Executor aufrufen und Ergebnisse abrufen

Führen Sie das Programm QuantumProgram auf einem „ IBM® “-Backend aus, indem Sie die Executor Primitive mit den Standardoptionen verwenden. Weitere Informationen zu den verfügbaren Optionen finden Sie unter „Executor-Optionen “.

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

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

Output:

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

# Retrieve the result
result = job.result()

Das Ergebnis ist vom Typ QuantumProgramResult. Weitere Informationen zum Ergebnisobjekt finden Sie unter „Executor-Ein- und -Ausgabe “.

Nächste Schritte