Passaggi del transpiler basato sull'intelligenza artificiale

I passaggi del transpiler basati sull'intelligenza artificiale sostituiscono direttamente i passaggi "tradizionali" di Qiskit in alcune operazioni di transpilazione. Spesso producono risultati migliori rispetto agli algoritmi euristici esistenti (come una profondità inferiore e un numero ridotto di operazioni CNOT), ma sono anche molto più veloci degli algoritmi di ottimizzazione, come i risolutori di soddisfacibilità booleana. Il transpiler AI viene eseguito sul tuo ambiente locale.

Attualmente sono disponibili i seguenti pass:

Passaggi di instradamento

• AIRouting: Selezione del layout e instradamento dei circuiti

La sintesi del circuito passa

• AICliffordSynthesis: Sintesi dei circuiti Clifford
• AILinearFunctionSynthesis: Sintesi di circuiti a funzioni lineari
• AIPermutationSynthesis: Sintesi dei circuiti di permutazione

Per utilizzare le fasi di transpilazione basate sull'intelligenza artificiale, installa innanzitutto il qiskit-ibm-transpiler pacchetto. Consulta la documentazione dell'API di qiskit-ibm-transpiler per ulteriori informazioni sulle diverse opzioni disponibili.

pip install qiskit-ibm-transpiler

Passaggio di instradamento AI

Il passaggio AIRouting funge sia da stadio di layout che da stadio di routing. Può essere utilizzato all'interno di un sito PassManager come segue:

from qiskit.transpiler import PassManager
from qiskit.circuit.library import efficient_su2
from qiskit_ibm_transpiler.ai.routing import AIRouting
from qiskit_ibm_runtime import QiskitRuntimeService
import logging

backend = QiskitRuntimeService().backend("ibm_fez")
ai_passmanager = PassManager(
    [
        AIRouting(
            backend=backend,
            optimization_level=2,
            layout_mode="optimize",
        )
    ]
)


circuit = efficient_su2(101, entanglement="circular", reps=1)
logging.getLogger(
    "qiskit_ibm_transpiler.wrappers.ai_local_synthesis"
).setLevel(logging.WARNING)
transpiled_circuit = ai_passmanager.run(circuit)

In questo caso, backend determina la mappa di accoppiamento da instradare, optimization_level (1, 2 o 3) determina lo sforzo computazionale da dedicare al processo (un valore più alto di solito dà risultati migliori ma richiede più tempo) e layout_mode specifica come gestire la selezione del layout. Il sito layout_mode comprende le seguenti opzioni:

• keep: Rispetta il layout impostato dai precedenti passaggi del transpiler (o usa il layout banale se non è stato impostato). In genere viene utilizzato solo quando il circuito deve essere eseguito su qubit specifici del dispositivo. Spesso produce risultati peggiori perché ha meno spazio per l'ottimizzazione.
• improve: Utilizza il layout impostato dai precedenti passaggi del transpiler come punto di partenza. È utile quando si dispone di una buona ipotesi iniziale per il layout; ad esempio, per i circuiti costruiti in modo da seguire approssimativamente la mappa di accoppiamento del dispositivo. È utile anche se si desidera provare altri passaggi di layout specifici combinati con il passaggio AIRouting .
• optimize: È la modalità predefinita. Funziona meglio per i circuiti generici in cui non si possono fare buone ipotesi di layout. Questa modalità ignora le selezioni di layout precedenti.

La sintesi dei circuiti AI passa

I passaggi di sintesi dei circuiti AI consentono di ottimizzare pezzi di diversi tipi di circuito (Clifford, Funzione lineare, Permutazione, Rete Pauli) risintetizzandoli. Un modo tipico di utilizzare il passaggio di sintesi è il seguente:

from qiskit.transpiler import PassManager

from qiskit_ibm_transpiler.ai.routing import AIRouting
from qiskit_ibm_transpiler.ai.synthesis import AILinearFunctionSynthesis
from qiskit_ibm_transpiler.ai.collection import CollectLinearFunctions
from qiskit.circuit.library import efficient_su2

ibm_kingston = QiskitRuntimeService().backend("ibm_kingston")
ai_passmanager = PassManager(
    [
        AIRouting(
            backend=ibm_kingston,
            optimization_level=3,
            layout_mode="optimize",
            local_mode=True,
        ),  # Route circuit
        CollectLinearFunctions(),  # Collect Linear Function blocks
        AILinearFunctionSynthesis(
            backend=ibm_kingston, local_mode=True
        ),  # Re-synthesize Linear Function blocks
    ]
)

circuit = efficient_su2(10, entanglement="full", reps=1)

transpiled_circuit = ai_passmanager.run(circuit)

La sintesi rispetta la mappa di accoppiamento del dispositivo: può essere eseguita tranquillamente dopo altri passaggi di routing senza disturbare il circuito, in modo che il circuito complessivo continui a seguire le restrizioni del dispositivo. Per impostazione predefinita, la sintesi sostituisce il sottocircuito originale solo se il sottocircuito sintetizzato migliora l'originale (attualmente controlla solo il conteggio di CNOT), ma è possibile forzare la sostituzione del circuito impostando replace_only_if_better=False.

I seguenti passaggi di sintesi sono disponibili su qiskit_ibm_transpiler.ai.synthesis:

• AICliffordSynthesis : Sintesi per circuiti Clifford (blocchi di porte H, S e CX ). Attualmente fino a nove blocchi di qubit.
• AILinearFunctionSynthesis : Sintesi per circuiti a funzione lineare (blocchi di porte CX e SWAP ). Attualmente fino a nove blocchi di qubit.
• AIPermutationSynthesis : Sintesi per circuiti di permutazione (blocchi di porte SWAP ). Attualmente disponibile per blocchi da 65, 33 e 27 qubit.
• AIPauliNetworkSynthesis : Sintesi per i circuiti della Rete Pauli (blocchi di porte H, S, SX, CX, RX, RY e RZ ). Attualmente fino a sei blocchi di qubit.

Prevediamo di aumentare gradualmente le dimensioni dei blocchi supportati.

Tutti i passaggi utilizzano un pool di thread per inviare diverse richieste in parallelo. Per impostazione predefinita, il numero di thread massimi è il numero di core più quattro (valori predefiniti per l'oggetto ThreadPoolExecutor Python ). Tuttavia, è possibile impostare il proprio valore con l'argomento max_threads all'istanziazione del passaggio. Ad esempio, la riga seguente istanzia il passaggio AILinearFunctionSynthesis , che consente di utilizzare un massimo di 20 thread.

AILinearFunctionSynthesis(backend=ibm_torino, max_threads=20)  # Re-synthesize Linear Function blocks using 20 threads max

È anche possibile impostare la variabile d'ambiente AI_TRANSPILER_MAX_THREADS sul numero massimo di thread desiderato e tutti i passaggi di sintesi istanziati successivamente utilizzeranno tale valore.

Affinché i passaggi di sintesi dell'IA sintetizzino un sottocircuito, questo deve trovarsi su un sottografo connesso della mappa di accoppiamento (un modo per farlo è un passaggio di instradamento prima di raccogliere i blocchi, ma non è l'unico modo per farlo). I passaggi di sintesi controllano automaticamente che il sottografo specifico sia supportato e, in caso contrario, emettono un avviso e lasciano invariato il sottocircuito originale.

I seguenti passaggi di raccolta personalizzati per Cliffords, Funzioni lineari e Permutazioni, che possono essere importati da qiskit_ibm_transpiler.ai.collection , integrano anche i passaggi di sintesi:

• RaccogliClifford : Raccoglie i blocchi Clifford come oggetti Instruction e memorizza il sottocircuito originale per confrontarlo dopo la sintesi.
• RaccogliFunzioniLineari : Raccoglie i blocchi di SWAP e CX come oggetti LinearFunction e memorizza il sottocircuito originale per confrontarlo dopo la sintesi.
• RaccogliPermutazioni : Raccoglie blocchi di circuiti SWAP come Permutations.
• RaccogliPauliReti : Raccoglie i blocchi della rete Pauli e memorizza il sottocircuito originale per confrontarlo dopo la sintesi.

Questi passaggi di raccolta personalizzati limitano le dimensioni dei sottocircuiti raccolti in modo che siano supportati dai passaggi di sintesi AI. Pertanto, si consiglia di utilizzarli dopo i passaggi di instradamento e prima di quelli di sintesi per una migliore ottimizzazione complessiva.

Trasposizione ibrida di circuiti euristici-AI

Il sito qiskit-ibm-transpiler consente di configurare un gestore di passaggi ibrido che combina il meglio dell'euristica di Qiskit e dei passaggi del transpiler alimentati dall'intelligenza artificiale. Questa funzione si comporta in modo simile al metodo Qiskit generate_pass_manager . Un modo tipico di utilizzare generate_ai_pass_manager è il seguente:

from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit.circuit.library import efficient_su2
from qiskit_ibm_runtime import QiskitRuntimeService


backend = QiskitRuntimeService().backend("ibm_kingston")
kingston_coupling_map = backend.coupling_map


su2_circuit = efficient_su2(101, entanglement="circular", reps=1)

ai_transpiler_pass_manager = generate_ai_pass_manager(
    coupling_map=kingston_coupling_map,
    ai_optimization_level=3,
    optimization_level=3,
    ai_layout_mode="optimize",
)

ai_su2_transpiled_circuit = ai_transpiler_pass_manager.run(su2_circuit)

In questo esempio vengono utilizzate le seguenti opzioni:

• coupling_map - Specifica la mappa di accoppiamento da utilizzare per la trasposizione.
• ai_optimization_level - Specifica il livello di ottimizzazione (1-3) da utilizzare per i componenti AI di PassManager.
• optimization_level - Specifica la quantità di ottimizzazione da eseguire sul circuito per le componenti euristiche di PassManager.
• ai_layout_mode - Specifica come la parte di routing AI di PassManager gestisce il layout. Consultare la sezione AI routing pass per esaminare le opzioni di configurazione di questo parametro ai_layout_mode .

Citazione

Citazione Se nella vostra ricerca utilizzate una qualsiasi funzionalità basata sull'intelligenza artificiale del qiskit-ibm-transpiler pacchetto, utilizzate la seguente citazione raccomandata:

@misc{2405.13196,
Author = {David Kremer and Victor Villar and Hanhee Paik and Ivan Duran and Ismael Faro and Juan Cruz-Benito},
Title = {Practical and efficient quantum circuit synthesis and transpiling with Reinforcement Learning},
Year = {2024},
Eprint = {arXiv:2405.13196},
}