Lumaktaw sa pangunahing nilalaman

Mga AI transpiler pass

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

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 maaaring tumakbo sa iyong lokal na environment o sa cloud gamit ang Qiskit Transpiler Service kung ikaw ay bahagi ng IBM Quantum® Premium Plan, Flex Plan, o On-Prem (sa pamamagitan ng IBM Quantum Platform API) Plan.

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
  • AIPauliNetworkSynthesis: Pauli Network 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.

Patakbuhin ang mga AI transpiler pass nang lokal o sa cloud​

Kung nais mong gamitin ang mga AI-powered transpiler pass sa iyong lokal na environment nang libre, i-install ang qiskit-ibm-transpiler na may dagdag na dependencies tulad ng sumusunod:

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

Kung walang mga dagdag na dependencies na ito, ang mga AI-powered transpiler pass ay tatakbo sa cloud sa pamamagitan ng Qiskit Transpiler Service (available lamang para sa mga gumagamit ng IBM Quantum Premium Plan, Flex Plan, o On-Prem (sa pamamagitan ng IBM Quantum Platform API) Plan). Pagkatapos i-install ang mga karagdagang dependencies, ang default na paraan para patakbuhin ang mga AI-powered transpiler pass ay ang gamitin ang iyong lokal na makina.

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

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)

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.
  • local_mode: Tinutukoy ng flag na ito kung saan tatakbo ang AIRouting pass. Kung False, ang AIRouting ay tatakbo nang remote sa pamamagitan ng Qiskit Transpiler Service. Kung True, susubukan ng package na patakbuhin ang pass sa iyong lokal na environment na may fallback sa cloud mode kung hindi mahanap ang mga kinakailangang dependencies.

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_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)

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 kasama ang 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 circuit transpilation​

Ang qiskit-ibm-transpiler ay nagbibigay-daan sa iyo na mag-configure ng hybrid pass manager na pinagsasama ang pinakamahusay na bahagi ng Qiskit's heuristic at ng 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_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)

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.

Mga Limitasyon​

Sumangguni sa dokumentasyon ng Qiskit Transpiler Service para sa higit pang impormasyon tungkol sa mga limitasyon na naaangkop sa mga AI-powered transpiler pass.

Citation​

Kung gumagamit ka ng anumang AI-powered na feature mula sa Qiskit Transpiler Service sa iyong pananaliksik, gamitin ang inirerekomendang citation.