Mga AI-powered transpiler pass

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime", "qiskit_ibm_transpiler": "qiskit-ibm-transpiler"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

Ang mga AI-powered transpiler pass ay mga pass na gumagana bilang kapalit ng mga "tradisyonal" na Qiskit pass para sa ilang gawain sa transpiling. Kadalasan, mas maganda ang kanilang mga resulta kumpara sa mga umiiral na heuristic na algorithm (tulad ng mas mababang depth at CNOT count), at mas mabilis pa rin sila kaysa sa mga optimization algorithm tulad ng Boolean satisfiability solver. Ang mga AI transpiler pass ay tumatakbo sa iyong lokal na environment.

tala

Ang mga AI-powered transpiler pass ay nasa beta release status pa, at maaaring magbago. Kung mayroon kang feedback o nais makipag-ugnayan sa development team, gamitin ang Qiskit Slack Workspace channel na ito.

Ang mga sumusunod na pass ay kasalukuyang available:

Mga Routing pass

• AIRouting: Pagpili ng layout at pag-route ng circuit

Mga circuit synthesis pass

• AICliffordSynthesis: Clifford circuit synthesis
• AILinearFunctionSynthesis: Linear function circuit synthesis
• AIPermutationSynthesis: Permutation circuit synthesis

Para gamitin ang mga AI transpiler pass, i-install muna ang qiskit-ibm-transpiler package. Bisitahin ang qiskit-ibm-transpiler API documentation para sa mas detalyadong impormasyon tungkol sa iba't ibang available na opsyon.

pip install qiskit-ibm-transpiler

AI routing pass

Ang AIRouting pass ay gumaganap bilang layout stage at routing stage. Maaari itong gamitin sa loob ng isang PassManager tulad ng sumusunod:

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)

Dito, tinutukoy ng backend kung aling coupling map ang gagamitin para sa routing, tinutukoy ng optimization_level (1, 2, o 3) kung gaano karaming computational effort ang gagamitin sa proseso (mas mataas ay karaniwang nagbibigay ng mas magandang resulta ngunit mas matagal), at tinutukoy ng layout_mode kung paano hawakan ang pagpili ng layout. Kasama sa layout_mode ang mga sumusunod na opsyon:

• keep: Iginagalang nito ang layout na itinakda ng mga nakaraang transpiler pass (o gumagamit ng trivial layout kung hindi pa naitakda). Karaniwang ginagamit lamang ito kapag kailangang patakbuhin ang circuit sa mga partikular na qubit ng device. Kadalasan, nagbibigay ito ng mas masamang resulta dahil mas limitado ang pagkakataon para sa optimization.

• improve: Ginagamit nito ang layout na itinakda ng mga nakaraang transpiler pass bilang panimula. Kapaki-pakinabang ito kapag mayroon kang magandang paunang hulà para sa layout; halimbawa, para sa mga circuit na ginawa sa paraang halos sumusunod sa coupling map ng device. Kapaki-pakinabang din ito kung nais mong subukan ang iba pang partikular na layout pass kasama ang AIRouting pass.

• optimize: Ito ang default na mode. Pinakaepektibo ito para sa mga pangkalahatang circuit kung saan maaaring wala kang magandang hulà sa layout. Binabalewala ng mode na ito ang mga nakaraang pagpili ng layout.

Mga AI circuit synthesis pass

Ang mga AI circuit synthesis pass ay nagbibigay-daan sa iyo na i-optimize ang mga bahagi ng iba't ibang uri ng circuit (Clifford, Linear Function, Permutation, Pauli Network) sa pamamagitan ng muling pag-synthesize sa kanila. Ang isang tipikal na paraan para gamitin ang synthesis pass ay tulad ng sumusunod:

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)

Iginagalang ng synthesis ang coupling map ng device: maaari itong patakbuhin nang ligtas pagkatapos ng iba pang routing pass nang hindi naaabala ang circuit, kaya ang pangkalahatang circuit ay susunod pa rin sa mga paghihigpit ng device. Sa default, papalitan ng synthesis ang orihinal na sub-circuit lamang kung mas maganda ang synthesized sub-circuit kaysa sa orihinal (kasalukuyang tinitingnan lamang ang CNOT count), ngunit maaari itong pilitin na palaging palitan ang circuit sa pamamagitan ng pagtatakda ng replace_only_if_better=False.

Ang mga sumusunod na synthesis pass ay available mula sa qiskit_ibm_transpiler.ai.synthesis:

• AICliffordSynthesis: Synthesis para sa mga Clifford circuit (mga bloke ng H, S, at CX gate). Kasalukuyang hanggang siyam na qubit block.

• AILinearFunctionSynthesis: Synthesis para sa mga Linear Function circuit (mga bloke ng CX at SWAP gate). Kasalukuyang hanggang siyam na qubit block.

• AIPermutationSynthesis: Synthesis para sa mga Permutation circuit (mga bloke ng SWAP gate). Kasalukuyang available para sa 65, 33, at 27 na qubit block.

• AIPauliNetworkSynthesis: Synthesis para sa mga Pauli Network circuit (mga bloke ng H, S, SX, CX, RX, RY at RZ gate). Kasalukuyang hanggang anim na qubit block.

Inaasahan naming unti-unting palakihin ang suportadong laki ng mga bloke.

Lahat ng pass ay gumagamit ng thread pool para magpadala ng ilang kahilingan nang sabay-sabay. Sa default, ang bilang ng maximum na thread ay katumbas ng bilang ng mga core na dinagdagan ng apat (default na halaga para sa ThreadPoolExecutor Python object). Gayunpaman, maaari kang magtakda ng sariling halaga gamit ang max_threads na argumento sa instantiation ng pass. Halimbawa, ang sumusunod na linya ay nag-instantiate ng AILinearFunctionSynthesis pass, na nagpapahintulot dito na gumamit ng maximum na 20 thread.

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

Maaari ka ring magtakda ng environment variable na AI_TRANSPILER_MAX_THREADS sa nais na bilang ng maximum na thread, at lahat ng synthesis pass na ma-instantiate pagkatapos nito ay gagamit ng halagang iyon.

Para ma-synthesize ng mga AI synthesis pass ang isang sub-circuit, kailangan nitong nasa isang connected subgraph ng coupling map (isang paraan para magawa ito ay sa pamamagitan ng routing pass bago mangolekta ng mga bloke, ngunit hindi ito ang tanging paraan). Awtomatikong susuriin ng mga synthesis pass kung ang partikular na subgraph ay sinusuportahan, at kung hindi, maglalabas ito ng babala at iiwanan ang orihinal na sub-circuit nang hindi binabago.

Ang mga sumusunod na custom na collection pass para sa Clifford, Linear Function, at Permutation na maaaring i-import mula sa qiskit_ibm_transpiler.ai.collection ay nagdadagdag din sa mga synthesis pass:

• CollectCliffords: Nangongolekta ng Clifford block bilang mga Instruction object at iniimbak ang orihinal na sub-circuit para ihambing pagkatapos ng synthesis.

• CollectLinearFunctions: Nangongolekta ng mga bloke ng SWAP at CX bilang mga LinearFunction object at iniimbak ang orihinal na sub-circuit para ihambing pagkatapos ng synthesis.

• CollectPermutations: Nangongolekta ng mga bloke ng SWAP circuit bilang mga Permutations.

• CollectPauliNetworks: Nangongolekta ng mga Pauli Network block at iniimbak ang orihinal na sub-circuit para ihambing pagkatapos ng synthesis.

Nililimitahan ng mga custom na collection pass na ito ang laki ng mga nakolektang sub-circuit para masigurado na sinusuportahan ng mga AI-powered synthesis pass. Kaya, inirerekomenda na gamitin ang mga ito pagkatapos ng mga routing pass at bago ang mga synthesis pass para sa mas magandang pangkalahatang optimization.

Hybrid heuristic-AI na circuit transpilation

Ang qiskit-ibm-transpiler ay nagbibigay-daan sa iyo na mag-configure ng hybrid pass manager na pinagsasama ang pinakamahusay sa mga heuristic pass ng Qiskit at sa mga AI-powered transpiler pass. Ang feature na ito ay katulad ng gawi ng Qiskit generate_pass_manager method. Ang isang tipikal na paraan para gamitin ang generate_ai_pass_manager ay tulad ng sumusunod:

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)

Ang mga sumusunod na opsyon ay ginagamit sa halimbawang ito:

• coupling_map - Tinutukoy kung aling coupling map ang gagamitin para sa transpilation.
• ai_optimization_level - Tinutukoy ang antas ng optimization (1-3) na gagamitin para sa mga AI component ng PassManager.
• optimization_level - Tinutukoy kung gaano karaming optimization ang isasagawa sa circuit para sa mga heuristic na component ng PassManager.
• ai_layout_mode - Tinutukoy kung paano hawakan ng AI routing na bahagi ng PassManager ang layout. Sumangguni sa seksyon ng AI routing pass para suriin ang mga opsyon sa configuration para sa ai_layout_mode parameter na ito.

Citation

Citation Kung gumagamit ka ng anumang AI-powered na feature mula sa qiskit-ibm-transpiler package sa iyong pananaliksik, gamitin ang sumusunod na inirerekomendang citation:

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