Transpilare con i pass manager

Versioni dei pacchetti

Il codice in questa pagina è stato sviluppato usando i seguenti requisiti. Si raccomanda di usare queste versioni o versioni più recenti.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

Il modo consigliato per transpilare un circuito è creare un staged pass manager e poi eseguire il suo metodo run con il circuito come input. Questa pagina spiega come transpilare circuiti quantistici in questo modo.

Cos'è un (staged) pass manager?

Nel contesto di Qiskit SDK, la transpilazione si riferisce al processo di trasformazione di un circuito in input in una forma adatta all'esecuzione su un dispositivo quantistico. La transpilazione avviene tipicamente in una sequenza di passaggi chiamati transpiler pass. Il circuito viene elaborato da ogni transpiler pass in sequenza, con l'output di un pass che diventa l'input del successivo. Per esempio, un pass potrebbe scorrere il circuito e unire tutte le sequenze consecutive di gate a singolo qubit, e il pass successivo potrebbe sintetizzare questi gate nel set di base del dispositivo target. I transpiler pass inclusi in Qiskit si trovano nel modulo qiskit.transpiler.passes.

Un pass manager è un oggetto che memorizza un elenco di transpiler pass e può eseguirli su un circuito. Per creare un pass manager, inizializza un PassManager con un elenco di transpiler pass. Per eseguire la transpilazione su un circuito, chiama il metodo run con un circuito come input.

Uno staged pass manager è un tipo speciale di pass manager che rappresenta un livello di astrazione superiore rispetto a un pass manager normale. Mentre un pass manager normale è composto da diversi transpiler pass, uno staged pass manager è composto da diversi pass manager. Si tratta di un'astrazione utile perché la transpilazione avviene tipicamente in fasi discrete, come descritto in Stadi del transpiler, dove ogni fase è rappresentata da un pass manager. Gli staged pass manager sono rappresentati dalla classe StagedPassManager. Il resto di questa pagina descrive come creare e personalizzare (staged) pass manager.

Generare uno staged pass manager preimpostato

Per creare uno staged pass manager preimpostato con impostazioni predefinite ragionevoli, usa la funzione generate_preset_pass_manager:

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-ibm-runtime

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend("ibm_fez")
pass_manager = generate_preset_pass_manager(
    optimization_level=3, backend=backend
)

Per transpilare un circuito o un elenco di circuiti con un pass manager, passa il circuito o l'elenco di circuiti al metodo run. Proviamolo su un circuito a due qubit composto da un gate di Hadamard seguito da due gate CX adiacenti:

from qiskit import QuantumRegister, QuantumCircuit

# Create a circuit
qubits = QuantumRegister(2, name="q")
circuit = QuantumCircuit(qubits)
a, b = qubits
circuit.h(a)
circuit.cx(a, b)
circuit.cx(b, a)

# Transpile it by calling the run method of the pass manager
transpiled = pass_manager.run(circuit)

# Draw it, excluding idle qubits from the diagram
transpiled.draw("mpl", idle_wires=False)

Consulta Impostazioni predefinite e opzioni di configurazione della transpilazione per una descrizione degli argomenti possibili della funzione generate_preset_pass_manager. Gli argomenti di generate_preset_pass_manager corrispondono agli argomenti della funzione transpile.

Hai difficoltà a ricordare i dettagli del pass manager? Prova a chiedere a Qiskit Code Assistant.

Se i pass manager preimpostati non soddisfano le tue esigenze, personalizza la transpilazione creando (staged) pass manager o persino transpiler pass personalizzati. Il resto di questa pagina descrive come creare pass manager. Per le istruzioni su come creare transpiler pass personalizzati, consulta Scrivi il tuo transpiler pass.

Creare il tuo pass manager

Il modulo qiskit.transpiler.passes include molti transpiler pass che possono essere utilizzati per creare pass manager. Per creare un pass manager, inizializza un PassManager con un elenco di pass. Per esempio, il codice seguente crea un transpiler pass che unisce gate adiacenti a due qubit e poi li sintetizza in una base di gate $R_y$, $R_z$ e $R_{xx}$.

from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import (
    Collect2qBlocks,
    ConsolidateBlocks,
    UnitarySynthesis,
)

basis_gates = ["rx", "ry", "rxx"]
translate = PassManager(
    [
        Collect2qBlocks(),
        ConsolidateBlocks(basis_gates=basis_gates),
        UnitarySynthesis(basis_gates),
    ]
)

Per dimostrare questo pass manager in azione, testalo su un circuito a due qubit composto da un gate di Hadamard seguito da due gate CX adiacenti:

from qiskit import QuantumRegister, QuantumCircuit

qubits = QuantumRegister(2, name="q")
circuit = QuantumCircuit(qubits)

a, b = qubits
circuit.h(a)
circuit.cx(a, b)
circuit.cx(b, a)

circuit.draw("mpl")

Per eseguire il pass manager sul circuito, chiama il metodo run.

translated = translate.run(circuit)
translated.draw("mpl")

Per un esempio più avanzato che mostra come creare un pass manager per implementare la tecnica di soppressione degli errori nota come dynamical decoupling, consulta Creare un pass manager per il dynamical decoupling.

Creare uno staged pass manager

Un StagedPassManager è un pass manager composto da singole fasi, dove ogni fase è definita da un'istanza di PassManager. Puoi creare un StagedPassManager specificando le fasi desiderate. Per esempio, il codice seguente crea uno staged pass manager con due fasi, init e translation. La fase translation è definita dal pass manager creato in precedenza.

from qiskit.transpiler import PassManager, StagedPassManager
from qiskit.transpiler.passes import UnitarySynthesis, Unroll3qOrMore

basis_gates = ["rx", "ry", "rxx"]
init = PassManager(
    [UnitarySynthesis(basis_gates, min_qubits=3), Unroll3qOrMore()]
)
staged_pm = StagedPassManager(
    stages=["init", "translation"], init=init, translation=translate
)

Non c'è limite al numero di fasi che puoi inserire in uno staged pass manager.

Un altro modo utile per creare uno staged pass manager è partire da uno staged pass manager preimpostato e poi sostituire alcune delle fasi. Per esempio, il codice seguente genera un pass manager preimpostato con livello di ottimizzazione 3 e poi specifica una fase pre_layout personalizzata.

import numpy as np
from qiskit.circuit.library import HGate, PhaseGate, RXGate, TdgGate, TGate
from qiskit.transpiler.passes import InverseCancellation

pass_manager = generate_preset_pass_manager(3, backend)
inverse_gate_list = [
    HGate(),
    (RXGate(np.pi / 4), RXGate(-np.pi / 4)),
    (PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4)),
    (TGate(), TdgGate()),
]
logical_opt = PassManager(
    [
        InverseCancellation(inverse_gate_list),
    ]
)

# Add pre-layout stage to run extra logical optimization
pass_manager.pre_layout = logical_opt

Le funzioni generatrici di stage possono essere utili per costruire pass manager personalizzati. Generano fasi che forniscono funzionalità comuni usate in molti pass manager. Per esempio, generate_embed_passmanager può essere usata per generare una fase che "incorpora" un Layout iniziale selezionato da un layout pass nel dispositivo target specificato.

Passi successivi

Raccomandazioni

• Scrivi un transpiler pass personalizzato.
• Crea un pass manager per il dynamical decoupling.
• Per saperne di più sulla funzione generate_preset_passmanager, consulta l'argomento Impostazioni predefinite e opzioni di configurazione della transpilazione.
• Prova la guida Confrontare le impostazioni del transpiler.
• Consulta la documentazione API del transpiler.