Treceri de Transpiler AI

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

Trecerile de Transpiler alimentate de AI sunt treceri care funcționează ca înlocuitor direct al trecerilor Qiskit „tradiționale" pentru unele sarcini de transpilare. Acestea produc adesea rezultate mai bune decât algoritmii heuristici existenți (cum ar fi adâncime mai mică și număr mai mic de CNOT), dar sunt și mult mai rapide decât algoritmii de optimizare precum rezolvatorii de satisfiabilitate booleană. Trecerile de Transpiler AI pot rula în mediul tău local sau în cloud folosind Qiskit Transpiler Service, dacă faci parte din Planul Premium IBM Quantum®, Planul Flex sau Planul On-Prem (prin IBM Quantum Platform API).

notă

Trecerile de Transpiler alimentate de AI se află în stadiu de lansare beta și pot fi modificate. Dacă ai feedback sau dorești să contactezi echipa de dezvoltare, te rog să folosești acest canal Qiskit Slack Workspace.

Următoarele treceri sunt disponibile în prezent:

Treceri de rutare

• AIRouting: Selectarea layout-ului și rutarea Circuit-ului

Treceri de sinteză a Circuit-ului

• AICliffordSynthesis: Sinteza Circuit-ului Clifford
• AILinearFunctionSynthesis: Sinteza Circuit-ului de funcție liniară
• AIPermutationSynthesis: Sinteza Circuit-ului de permutare
• AIPauliNetworkSynthesis: Sinteza Circuit-ului de rețea Pauli

Pentru a utiliza trecerile de Transpiler AI, mai întâi instalează pachetul qiskit-ibm-transpiler. Vizitează documentația API qiskit-ibm-transpiler pentru mai multe informații despre diferitele opțiuni disponibile.

Rulează trecerile de Transpiler AI local sau în cloud

Dacă vrei să folosești trecerile de Transpiler alimentate de AI în mediul tău local gratuit, instalează qiskit-ibm-transpiler cu câteva dependențe suplimentare, astfel:

pip install qiskit-ibm-transpiler[ai-local-mode]

Fără aceste dependențe suplimentare, trecerile de Transpiler alimentate de AI rulează în cloud prin Qiskit Transpiler Service (disponibil doar pentru utilizatorii Planului Premium IBM Quantum, Planului Flex sau Planului On-Prem (prin IBM Quantum Platform API)). După instalarea dependențelor suplimentare, modul implicit de rulare a trecerilor de Transpiler alimentate de AI este să folosești mașina ta locală.

Trecerea de rutare AI

Trecerea AIRouting acționează atât ca etapă de layout, cât și ca etapă de rutare. Poate fi folosită într-un PassManager astfel:

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

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

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

transpiled_circuit = ai_passmanager.run(circuit)

Aici, backend determină harta de cuplare pentru care se face rutarea, optimization_level (1, 2 sau 3) determină efortul de calcul depus în proces (o valoare mai mare produce de obicei rezultate mai bune, dar durează mai mult), iar layout_mode specifică modul de gestionare a selecției layout-ului. layout_mode include următoarele opțiuni:

• keep: Aceasta respectă layout-ul setat de trecerile anterioare ale Transpiler-ului (sau folosește layout-ul trivial dacă nu este setat). Este utilizat de obicei doar atunci când Circuit-ul trebuie rulat pe Qubiți specifici ai dispozitivului. Produce adesea rezultate mai slabe deoarece are mai puțin spațiu pentru optimizare.
• improve: Aceasta folosește layout-ul setat de trecerile anterioare ale Transpiler-ului ca punct de plecare. Este utilă atunci când ai o estimare inițială bună pentru layout; de exemplu, pentru Circuit-uri construite într-un mod care urmează aproximativ harta de cuplare a dispozitivului. Este de asemenea utilă dacă vrei să încerci alte treceri de layout specifice combinate cu trecerea AIRouting.
• optimize: Acesta este modul implicit. Funcționează cel mai bine pentru Circuit-uri generale unde s-ar putea să nu ai estimări bune de layout. Acest mod ignoră selecțiile anterioare de layout.
• local_mode: Acest indicator determină unde rulează trecerea AIRouting. Dacă este False, AIRouting rulează de la distanță prin Qiskit Transpiler Service. Dacă este True, pachetul încearcă să ruleze trecerea în mediul tău local, cu o rezervă la modul cloud dacă dependențele necesare nu sunt găsite.

Treceri de sinteză a Circuit-ului AI

Trecerile de sinteză a Circuit-ului AI îți permit să optimizezi bucăți din diferite tipuri de Circuit-uri (Clifford, Funcție Liniară, Permutare, Rețea Pauli) prin re-sintetizarea lor. Un mod tipic de a folosi trecerea de sinteză este următorul:

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_ibm_transpiler.ai.synthesis import AIPauliNetworkSynthesis
from qiskit_ibm_transpiler.ai.collection import CollectPauliNetworks
from qiskit.circuit.library import efficient_su2

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

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

transpiled_circuit = ai_passmanager.run(circuit)

Sinteza respectă harta de cuplare a dispozitivului: poate fi rulată în siguranță după alte treceri de rutare fără a perturba Circuit-ul, deci Circuit-ul general va respecta în continuare restricțiile dispozitivului. În mod implicit, sinteza va înlocui sub-Circuit-ul original doar dacă sub-Circuit-ul sintetizat îmbunătățește originalul (verificând în prezent doar numărul de CNOT), dar aceasta poate fi forțată să înlocuiască întotdeauna Circuit-ul prin setarea replace_only_if_better=False.

Următoarele treceri de sinteză sunt disponibile din qiskit_ibm_transpiler.ai.synthesis:

• AICliffordSynthesis: Sinteză pentru Circuit-uri Clifford (blocuri de Gate-uri H, S și CX). În prezent până la blocuri de nouă Qubiți.
• AILinearFunctionSynthesis: Sinteză pentru Circuit-uri de Funcție Liniară (blocuri de Gate-uri CX și SWAP). În prezent până la blocuri de nouă Qubiți.
• AIPermutationSynthesis: Sinteză pentru Circuit-uri de Permutare (blocuri de Gate-uri SWAP). Disponibil în prezent pentru blocuri de 65, 33 și 27 de Qubiți.
• AIPauliNetworkSynthesis: Sinteză pentru Circuit-uri de rețea Pauli (blocuri de Gate-uri H, S, SX, CX, RX, RY și RZ). În prezent până la blocuri de șase Qubiți.

Ne așteptăm să creștem treptat dimensiunea blocurilor suportate.

Toate trecerile folosesc un pool de fire de execuție pentru a trimite mai multe cereri în paralel. În mod implicit, numărul maxim de fire de execuție este numărul de nuclee plus patru (valorile implicite pentru obiectul Python ThreadPoolExecutor). Cu toate acestea, poți seta propria valoare cu argumentul max_threads la instanțierea trecerii. De exemplu, următoarea linie instanțiază trecerea AILinearFunctionSynthesis, permițându-i să utilizeze un maxim de 20 de fire de execuție.

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

Poți de asemenea să setezi variabila de mediu AI_TRANSPILER_MAX_THREADS la numărul dorit de fire de execuție maxime, iar toate trecerile de sinteză instanțiate după aceea vor folosi acea valoare.

Pentru ca trecerile de sinteză AI să sintetizeze un sub-Circuit, acesta trebuie să se afle pe un subgraf conex al hărții de cuplare (un mod de a face acest lucru este cu o trecere de rutare înainte de colectarea blocurilor, dar aceasta nu este singura modalitate). Trecerile de sinteză vor verifica automat că subgraful specific este suportat și, dacă nu este, va emite un avertisment și va lăsa sub-Circuit-ul original nemodificat.

Următoarele treceri de colecție personalizate pentru Clifford-uri, Funcții Liniare și Permutări, care pot fi importate din qiskit_ibm_transpiler.ai.collection, completează de asemenea trecerile de sinteză:

• CollectCliffords: Colectează blocuri Clifford ca obiecte Instruction și stochează sub-Circuit-ul original pentru a-l compara după sinteză.
• CollectLinearFunctions: Colectează blocuri de SWAP și CX ca obiecte LinearFunction și stochează sub-Circuit-ul original pentru a-l compara după sinteză.
• CollectPermutations: Colectează blocuri de Circuit-uri SWAP ca Permutations.
• CollectPauliNetworks: Colectează blocuri de rețele Pauli și stochează sub-Circuit-ul original pentru a-l compara după sinteză.

Aceste treceri de colecție personalizate limitează dimensiunile sub-Circuit-urilor colectate astfel încât să fie suportate de trecerile de sinteză alimentate de AI. Prin urmare, este recomandat să le folosești după trecerile de rutare și înainte de trecerile de sinteză pentru o optimizare globală mai bună.

Transpilarea hibridă heuristic-AI a Circuit-ului

qiskit-ibm-transpiler îți permite să configurezi un manager de treceri hibrid care combină ce este mai bun din heuristicile Qiskit și trecerile de Transpiler alimentate de AI. Această funcționalitate se comportă similar cu metoda Qiskit generate_pass_manager. Un mod tipic de a folosi generate_ai_pass_manager este următorul:

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_torino")
torino_coupling_map = backend.coupling_map

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

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

ai_su2_transpiled_circuit = ai_transpiler_pass_manager.run(su2_circuit)

Următoarele opțiuni sunt folosite în acest exemplu:

• coupling_map - Specifică ce hartă de cuplare să se folosească pentru transpilare.
• ai_optimization_level - Specifică nivelul de optimizare (1-3) de utilizat pentru componentele AI ale PassManager-ului.
• optimization_level - Specifică cât de multă optimizare să se efectueze pe Circuit pentru componentele heuristice ale PassManager-ului.
• ai_layout_mode - Specifică modul în care partea de rutare AI a PassManager-ului gestionează layout-ul. Consultă secțiunea Trecerea de rutare AI pentru a revizui opțiunile de configurare pentru acest parametru ai_layout_mode.

Limite

Consultă documentația Qiskit Transpiler Service pentru mai multe informații despre limitele care se aplică trecerilor de Transpiler alimentate de AI.

Citare

Dacă folosești orice funcționalitate alimentată de AI din Qiskit Transpiler Service în cercetarea ta, folosește citarea recomandată.