Transpilare con gestori di passaggi

• Versioni del pacchetto

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

  qiskit[all]~=2.5.1
  qiskit-ibm-runtime~=0.47.0
  

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

Che cos'è un gestore di pass (a più livelli)?

Nel contesto del Qiskit SDK, la transpilazione si riferisce al processo di trasformazione di un circuito di input in una forma adatta all'esecuzione su un dispositivo quantistico. La trasposizione avviene tipicamente in una sequenza di passaggi chiamati passaggi di trasposizione. Il circuito viene elaborato da ciascun passaggio del transpiler in sequenza, con l'uscita di un passaggio che diventa l'ingresso del successivo. Ad esempio, un passaggio potrebbe passare attraverso il circuito e unire tutte le sequenze consecutive di porte a singolo qubit, e poi il passaggio successivo potrebbe sintetizzare queste porte nell'insieme di basi del dispositivo di destinazione. I passaggi del transpiler inclusi in Qiskit si trovano nel modulo qiskit.transpiler.passes modulo.

Un gestore di passaggi è un oggetto che memorizza un elenco di passaggi del transpiler e può eseguirli su un circuito. Crea un gestore di passaggi inizializzando un file PassManager con un elenco di passaggi del transpiler. Per eseguire la transpilazione su un circuito, richiamare il metodo run con un circuito in ingresso.

Un gestore di passaggi staged è un tipo speciale di gestore di passaggi che rappresenta un livello di astrazione superiore a quello di un normale gestore di passaggi. Mentre un normale pass manager è composto da diversi pass transpiler, uno staged pass manager è composto da diversi pass manager. Si tratta di un'astrazione utile perché la transpilazione avviene tipicamente in stadi discreti, come descritto in Stadi del transpiler, e ogni stadio è rappresentato da un gestore di passaggi. I gestori di passaggi a tappe sono rappresentati dalla classe StagedPassManager classe. Il resto di questa pagina descrive come creare e personalizzare i gestori di passaggi (staged).

Genera un gestore di passaggi preimpostato

Per creare un gestore di passaggi predefinito con impostazioni predefinite adeguate, utilizzare la generate_preset_pass_manager funzione.

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()
pass_manager = generate_preset_pass_manager(
    optimization_level=3, backend=backend
)

Per transpilare un circuito o un elenco di circuiti con un pass manager, passare il circuito o l'elenco di circuiti al metodo run . Eseguiamo questa operazione su un circuito a due equbit costituito da un Hadamard seguito da due porte 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)

Output:

Per una descrizione dei possibili argomenti della funzione generate_preset_pass_manager , vedere Valori predefiniti e opzioni di configurazione della transpilazione. Gli argomenti di generate_preset_pass_manager corrispondono agli argomenti della funzione transpile funzione.

Se i gestori di passaggi preimpostati non soddisfano le vostre esigenze, potete personalizzare la transpilazione creando gestori di passaggi (a stadi) o addirittura passaggi di transpilazione. Il resto di questa pagina descrive come creare i gestori di pass. Per istruzioni su come creare passaggi di transpilazione, vedere Scrivere il proprio passaggio di transpiler.

Crea il tuo gestore di pass

Il modulo qiskit.transpiler.passes include molti passaggi di transpiler che possono essere usati per creare gestori di passaggi. Per creare un gestore di pass, inizializzare un PassManager con un elenco di pass. Ad esempio, il codice seguente crea un passaggio di transpiler che unisce porte adiacenti a due qubit e poi le sintetizza in una base di $R_y$, $R_z$, e $R_{xx}$, porte.

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 l'azione di questo pass manager, testatelo su un circuito a due equbit costituito da un Hadamard seguito da due porte 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")

Output:

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

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

Output:

Per un esempio più avanzato che mostra come creare un gestore di passaggi per implementare la tecnica di soppressione degli errori nota come disaccoppiamento dinamico, vedere Creare un gestore di passaggi per il disaccoppiamento dinamico.

Creare un gestore di passaggi graduali

Un StagedPassManager è un gestore di passaggi composto da singoli stadi, dove ogni stadio è definito da un'istanza PassManager . È possibile creare un sito StagedPassManager specificando le fasi desiderate. Ad esempio, il codice seguente crea uno staged pass manager con due stadi, init e translation. Lo stadio translation è definito dal gestore dei passaggi 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 tappe che si possono inserire in un gestore di staged pass.

Un altro modo utile per creare uno staged pass manager è quello di iniziare con uno staged pass manager preimpostato e poi scambiare alcuni degli stadi. Ad esempio, il codice seguente genera un gestore di passaggi preimpostato con livello di ottimizzazione 3 e specifica uno stadio pre_layout personalizzato.

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 del generatore di fasi potrebbero essere utili per creare gestori di passaggi personalizzati. Generano stadi che forniscono funzionalità comuni utilizzate in molti gestori di passaggi. Ad esempio, generate_embed_passmanager può essere usato per generare uno stage per "incorporare" un Layout iniziale selezionato da un passaggio di layout nel dispositivo di destinazione specificato.

Passi successivi