Transpiler alimenté par l'IA passe

Les passes de transcompilation basées sur l'IA permettent de remplacer directement les passes « traditionnelles » de Qiskit pour certaines tâches de transcompilation. Ils donnent souvent de meilleurs résultats que les algorithmes heuristiques existants (notamment en termes de profondeur et de nombre de CNOT), mais sont également bien plus rapides que les algorithmes d'optimisation tels que les solveurs de satisfiabilité booléenne. Le transpileur IA s'exécute sur votre environnement local.

Les laissez-passer suivants sont actuellement disponibles :

Passes d'acheminement

• AIRouting: Sélection de l'agencement et routage des circuits

Passes de synthèse de circuits

• AICliffordSynthesis: Synthèse de circuits de Clifford
• AILinearFunctionSynthesis: Synthèse de circuits à fonction linéaire
• AIPermutationSynthesis: Synthèse de circuits de permutation

Pour utiliser les passes du transcompilateur IA, commencez par installer le qiskit-ibm-transpiler paquet. Consultez la documentation de l'API qiskit-ibm-transpiler pour en savoir plus sur les différentes options disponibles.

pip install qiskit-ibm-transpiler

Passe de routage IA

La passe AIRouting sert à la fois d'étape de mise en page et d'étape de routage. Il peut être utilisé à l'intérieur d'un site PassManager de la manière suivante :

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)

Ici, le paramètre backend détermine la carte de couplage à utiliser, le paramètre optimization_level (1, 2 ou 3) détermine l'effort de calcul à consacrer au processus (une valeur plus élevée donne généralement de meilleurs résultats mais prend plus de temps) et le paramètre layout_mode spécifie la manière de gérer la sélection de la disposition. Le site layout_mode comprend les options suivantes :

• keep: Cette méthode respecte la disposition définie par les passes de transposition précédentes (ou utilise la disposition triviale si elle n'a pas été définie). Il n'est généralement utilisé que lorsque le circuit doit être exécuté sur des qubits spécifiques du dispositif. Elle produit souvent de moins bons résultats parce qu'elle laisse moins de place à l'optimisation.
• improve: Cette opération utilise comme point de départ la disposition définie par les passages précédents du transpondeur. Elle est utile lorsque vous avez une bonne idée initiale de la disposition; par exemple, pour les circuits qui sont construits d'une manière qui suit approximativement la carte de couplage de l'appareil. Il est également utile si vous souhaitez essayer d'autres passes de mise en page spécifiques combinées à la passe AIRouting .
• optimize: C'est le mode par défaut. Il fonctionne mieux pour les circuits généraux pour lesquels vous n'avez pas de bonnes idées de tracé. Ce mode ignore les sélections précédentes.

Synthèse de circuits IA réussie

Les passes de synthèse de circuits AI vous permettent d'optimiser les pièces de différents types de circuits (Clifford, fonction linéaire, permutation, réseau de Pauli) en les resynthétisant. L'utilisation de la passe de synthèse se fait généralement de la manière suivante :

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 synthèse respecte la carte de couplage du dispositif : elle peut être exécutée en toute sécurité après d'autres routages sans perturber le circuit, de sorte que le circuit global respecte toujours les restrictions du dispositif. Par défaut, la synthèse ne remplacera le sous-circuit original que si le sous-circuit synthétisé améliore l'original (actuellement en vérifiant uniquement le nombre de CNOT), mais il est possible de forcer le remplacement systématique du circuit en définissant replace_only_if_better=False.

Les cartes de synthèse suivantes sont disponibles sur le site qiskit_ibm_transpiler.ai.synthesis:

• AICliffordSynthesis : Synthèse de circuits Clifford (blocs de portes H, S, et CX ). Actuellement, jusqu'à neuf blocs de qubits.
• AILinearFunctionSynthesis : Synthèse de circuits à fonction linéaire (blocs de portes CX et SWAP ). Actuellement, jusqu'à neuf blocs de qubits.
• AIPermutationSynthesis : Synthèse de circuits de permutation (blocs de portes SWAP ). Actuellement disponible pour les blocs de 65, 33 et 27 qubits.
• AIPauliNetworkSynthesis : Synthèse des circuits du réseau de Pauli (blocs de portes H, S, SX, CX, RX, RY et RZ ). Actuellement, jusqu'à six blocs de qubits.

Nous prévoyons d'augmenter progressivement la taille des blocs pris en charge.

Toutes les passes utilisent un pool de threads pour envoyer plusieurs demandes en parallèle. Par défaut, le nombre de threads maximum est le nombre de cœurs plus quatre (valeurs par défaut de l'objet ThreadPoolExecutor Python ). Cependant, vous pouvez définir votre propre valeur avec l'argument max_threads lors de l'instanciation de la passe. Par exemple, la ligne suivante instancie la passe AILinearFunctionSynthesis , ce qui lui permet d'utiliser un maximum de 20 threads.

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

Vous pouvez également fixer la variable d'environnement AI_TRANSPILER_MAX_THREADS au nombre maximum de threads souhaité, et toutes les passes de synthèse instanciées par la suite utiliseront cette valeur.

Pour que les passes de synthèse de l'IA puissent synthétiser un sous-circuit, celui-ci doit se trouver sur un sous-graphe connecté de la carte de couplage (une façon d'y parvenir est d'effectuer une passe de routage avant de rassembler les blocs, mais ce n'est pas la seule façon de procéder). Les passes de synthèse vérifieront automatiquement que le sous-graphe spécifique est pris en charge et, si ce n'est pas le cas, elles émettront un avertissement et laisseront le sous-circuit d'origine inchangé.

Les passes de collection personnalisées suivantes pour les cliffords, les fonctions linéaires et les permutations, qui peuvent être importées de qiskit_ibm_transpiler.ai.collection , complètent également les passes de synthèse :

• CollectCliffords : Collecte les blocs de Clifford sous forme d'objets Instruction et stocke le sous-circuit d'origine pour le comparer après la synthèse.
• CollectLinearFunctions : Rassemble les blocs de SWAP et CX en tant qu'objets LinearFunction et stocke le sous-circuit original pour le comparer après la synthèse.
• CollectPermutations : Collecte des blocs de circuits SWAP comme Permutations.
• CollectPauliNetworks : Collecte les blocs du réseau de Pauli et stocke le sous-circuit d'origine pour le comparer après la synthèse.

Ces passes de collecte personnalisées limitent la taille des sous-circuits collectés afin qu'ils soient pris en charge par les passes de synthèse alimentées par l'IA. Il est donc recommandé de les utiliser après les passes de routage et avant les passes de synthèse pour une meilleure optimisation globale.

Transpilation hybride de circuits heuristiques et d'IA

Le site qiskit-ibm-transpiler vous permet de configurer un gestionnaire de passes hybride qui combine le meilleur des passes heuristiques de Qiskit et des passes du transpondeur alimentées par l'IA. Cette fonction se comporte de manière similaire à la méthode Qiskit generate_pass_manager . L'utilisation typique de generate_ai_pass_manager est la suivante :

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)

Les options suivantes sont utilisées dans cet exemple :

• coupling_map - Spécifie la carte de couplage à utiliser pour la transpilation.
• ai_optimization_level - Spécifie le niveau d'optimisation (1-3) à utiliser pour les composants AI du site PassManager.
• optimization_level - Spécifie le degré d'optimisation à effectuer sur le circuit pour les composants heuristiques de PassManager.
• ai_layout_mode - Spécifie comment la partie routage AI du site PassManager gère la mise en page. Reportez-vous à la section " AI routing pass" pour passer en revue les options de configuration de ce paramètre ai_layout_mode .

Citation

Référence Si vous utilisez une fonctionnalité basée sur l'IA issue du qiskit-ibm-transpiler package dans le cadre de vos travaux de recherche, veuillez utiliser la référence recommandée suivante :

@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},
}