Reprezentarea calculatoarelor cuantice pentru transpiler

Versiunile pachetelor

Codul de pe această pagină a fost dezvoltat folosind cerințele de mai jos. Recomandăm utilizarea acestor versiuni sau a unora mai noi.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

Pentru a converti un Circuit abstract într-un Circuit ISA care poate rula pe un QPU specific (unitate de procesare cuantică), transpiler-ul are nevoie de anumite informații despre QPU. Aceste informații se găsesc în două locuri: obiectul BackendV2 (sau moștenitorul BackendV1) la care intenționezi să trimiți joburi, și atributul Target al backend-ului.

• Target conține toate constrângerile relevante ale unui dispozitiv, cum ar fi Gate-urile de bază native, conectivitatea Qubit-urilor și informațiile de puls sau sincronizare.
• Backend deține un Target implicit, conține informații suplimentare -- cum ar fi InstructionScheduleMap, și oferă interfața pentru trimiterea joburilor cu Circuit-uri cuantice.

Poți, de asemenea, să furnizezi explicit informații pe care transpiler-ul să le folosească, de exemplu, dacă ai un caz de utilizare specific sau dacă crezi că aceste informații vor ajuta transpiler-ul să genereze un Circuit mai optimizat.

Precizia cu care transpiler-ul produce cel mai potrivit Circuit pentru hardware specific depinde de câte informații are Target-ul sau Backend-ul despre constrângerile sale.

notă

Deoarece multe dintre algoritmii de transpilare subiacentă sunt stocastici, nu există nicio garanție că va fi găsit un Circuit mai bun.

Această pagină prezintă mai multe exemple de transmitere a informațiilor despre QPU către transpiler. Aceste exemple folosesc target-ul din backend-ul simulat FakeSherbrooke.

Configurația implicită

Cea mai simplă utilizare a transpiler-ului este să furnizezi toate informațiile despre QPU prin furnizarea Backend-ului sau Target-ului. Pentru a înțelege mai bine cum funcționează transpiler-ul, construiește un Circuit și transpilează-l cu informații diferite, după cum urmează.

Importă bibliotecile necesare și instanțiază QPU-ul: Pentru a converti un Circuit abstract într-un Circuit ISA care poate rula pe un procesor specific, transpiler-ul are nevoie de anumite informații despre procesor. De obicei, aceste informații sunt stocate în Backend sau Target furnizat transpiler-ului și nu mai sunt necesare informații suplimentare. Cu toate acestea, poți furniza explicit informații pe care transpiler-ul să le folosească, de exemplu, dacă ai un caz de utilizare specific sau dacă crezi că aceste informații vor ajuta transpiler-ul să genereze un Circuit mai optimizat.

Acest subiect prezintă mai multe exemple de transmitere a informațiilor către transpiler. Aceste exemple folosesc target-ul din backend-ul simulat FakeSherbrooke.

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

from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()
target = backend.target

Circuit-ul exemplu folosește o instanță a efficient_su2 din biblioteca de Circuit-uri Qiskit.

from qiskit.circuit.library import efficient_su2

qc = efficient_su2(12, entanglement="circular", reps=1)

qc.draw("mpl")

Acest exemplu folosește setările implicite pentru a transpila la target-ul backend-ului, care furnizează toate informațiile necesare pentru a converti Circuit-ul în unul care va rula pe backend.

from qiskit.transpiler import generate_preset_pass_manager

pass_manager = generate_preset_pass_manager(
    optimization_level=1, target=target, seed_transpiler=12345
)
qc_t_target = pass_manager.run(qc)
qc_t_target.draw("mpl", idle_wires=False, fold=-1)

Acest exemplu este folosit în secțiunile ulterioare ale acestui subiect pentru a ilustra că harta de cuplare și Gate-urile de bază sunt elementele esențiale de informații de transmis transpiler-ului pentru construcția optimă a Circuit-ului. QPU-ul poate de obicei să selecteze setări implicite pentru alte informații care nu sunt transmise, cum ar fi sincronizarea și planificarea.

Harta de cuplare

Harta de cuplare este un graf care arată care Qubit-uri sunt conectate și, prin urmare, au Gate-uri cu două Qubit-uri între ele. Uneori acest graf este direcțional, ceea ce înseamnă că Gate-urile cu două Qubit-uri pot merge doar într-o singură direcție. Cu toate acestea, transpiler-ul poate întotdeauna să inverseze direcția unui Gate adăugând Gate-uri suplimentare cu un singur Qubit. Un Circuit cuantic abstract poate fi întotdeauna reprezentat pe acest graf, chiar dacă conectivitatea sa este limitată, prin introducerea de Gate-uri SWAP pentru a muta informațiile cuantice.

Qubit-urile din Circuit-urile noastre abstracte se numesc Qubit-uri virtuale, iar cele de pe harta de cuplare sunt Qubit-uri fizice. Transpiler-ul oferă o mapare între Qubit-urile virtuale și cele fizice. Unul dintre primii pași în transpilare, etapa layout, efectuează această mapare.

notă

Deși etapa de rutare este împletită cu etapa layout — care selectează Qubit-urile efective — în mod implicit, acest subiect le tratează ca etape separate pentru simplitate. Combinația de rutare și layout se numește maparea Qubit-urilor. Află mai multe despre aceste etape în subiectul Etapele Transpiler-ului.

Transmite argumentul cheie coupling_map pentru a vedea efectul său asupra transpiler-ului:

coupling_map = target.build_coupling_map()

pass_manager = generate_preset_pass_manager(
    optimization_level=0, coupling_map=coupling_map, seed_transpiler=12345
)
qc_t_cm_lv0 = pass_manager.run(qc)
qc_t_cm_lv0.draw("mpl", idle_wires=False, fold=-1)

Așa cum se arată mai sus, au fost inserate mai multe Gate-uri SWAP (fiecare constând din trei Gate-uri CX), ceea ce va cauza multe erori pe dispozitivele actuale. Pentru a vedea ce Qubit-uri sunt selectate pe topologia efectivă a Qubit-urilor, folosește plot_circuit_layout din Vizualizările Qiskit:

from qiskit.visualization import plot_circuit_layout

plot_circuit_layout(qc_t_cm_lv0, backend, view="physical")

Aceasta arată că Qubit-urile noastre virtuale 0-11 au fost mapate trivial la linia de Qubit-uri fizice 0-11. Să revenim la setarea implicită (optimization_level=1), care folosește VF2Layout dacă este necesară rutare.

pass_manager = generate_preset_pass_manager(
    optimization_level=1, coupling_map=coupling_map, seed_transpiler=12345
)
qc_t_cm_lv1 = pass_manager.run(qc)
qc_t_cm_lv1.draw("mpl", idle_wires=False, fold=-1)

Acum nu mai sunt inserate Gate-uri SWAP, iar Qubit-urile fizice selectate sunt aceleași ca atunci când se folosește clasa target.

from qiskit.visualization import plot_circuit_layout

plot_circuit_layout(qc_t_cm_lv1, backend, view="physical")

Acum layout-ul este într-un inel. Deoarece acest layout respectă conectivitatea Circuit-ului, nu există Gate-uri SWAP, oferind un Circuit mult mai bun pentru execuție.

Gate-uri de bază

Fiecare calculator cuantic acceptă un set limitat de instrucțiuni, numit Gate-urile sale de bază. Fiecare Gate din Circuit trebuie tradus în elementele acestui set. Acest set ar trebui să fie alcătuit din Gate-uri cu un singur Qubit și Gate-uri cu două Qubit-uri care furnizează un set universal de Gate-uri, ceea ce înseamnă că orice operație cuantică poate fi descompusă în acele Gate-uri. Aceasta este realizată de BasisTranslator, iar Gate-urile de bază pot fi specificate ca argument cheie pentru transpiler pentru a furniza aceste informații.

basis_gates = list(target.operation_names)
print(basis_gates)

['sx', 'switch_case', 'x', 'if_else', 'measure', 'for_loop', 'delay', 'ecr', 'id', 'reset', 'rz']

Gate-urile implicite cu un singur Qubit pe ibm_sherbrooke sunt rz, x și sx, iar Gate-ul implicit cu două Qubit-uri este ecr (rezonanță încrucișată ecouată). Gate-urile CX sunt construite din Gate-uri ecr, astfel că pe unele QPU-uri ecr este specificat ca Gate de bază cu două Qubit-uri, în timp ce pe altele cx este cel implicit. Gate-ul ecr este partea de împletire a Gate-ului cx. Pe lângă Gate-urile de control, există și instrucțiuni de delay și measurement.

notă

QPU-urile au Gate-uri de bază implicite, dar poți alege orice Gate-uri dorești, atât timp cât furnizezi instrucțiunea sau adaugi Gate-uri de puls (vezi Crearea de pase pentru transpiler.) Gate-urile de bază implicite sunt cele pentru care au fost efectuate calibrări pe QPU, deci nu mai trebuie furnizate instrucțiuni/Gate-uri de puls suplimentare. De exemplu, pe unele QPU-uri cx este Gate-ul implicit cu două Qubit-uri, iar pe altele ecr. Vezi lista gate-urilor și operațiunilor native posibile pentru mai multe detalii.

pass_manager = generate_preset_pass_manager(
    optimization_level=1,
    coupling_map=coupling_map,
    basis_gates=basis_gates,
    seed_transpiler=12345,
)
qc_t_cm_bg = pass_manager.run(qc)
qc_t_cm_bg.draw("mpl", idle_wires=False, fold=-1)

Rețineți că obiectele CXGate au fost descompuse în Gate-uri ecr și Gate-uri de bază cu un singur Qubit.

Ratele de eroare ale dispozitivului

Clasa Target poate conține informații despre ratele de eroare pentru operațiunile de pe dispozitiv. De exemplu, următorul cod preia proprietățile pentru Gate-ul de rezonanță încrucișată ecouată (ECR) dintre Qubit-ul 1 și 0 (rețineți că Gate-ul ECR este direcțional):

target["ecr"][(1, 0)]

InstructionProperties(duration=5.333333333333332e-07, error=0.007494257741828603)

Rezultatul afișează durata Gate-ului (în secunde) și rata sa de eroare. Pentru a dezvălui informații despre erori transpiler-ului, construiește un model target cu basis_gates și coupling_map de mai sus și populează-l cu valori de eroare din backend-ul FakeSherbrooke.

from qiskit.transpiler import Target
from qiskit.circuit.controlflow import IfElseOp, SwitchCaseOp, ForLoopOp

err_targ = Target.from_configuration(
    basis_gates=basis_gates,
    coupling_map=coupling_map,
    num_qubits=target.num_qubits,
    custom_name_mapping={
        "if_else": IfElseOp,
        "switch_case": SwitchCaseOp,
        "for_loop": ForLoopOp,
    },
)

for i, (op, qargs) in enumerate(target.instructions):
    if op.name in basis_gates:
        err_targ[op.name][qargs] = target.instruction_properties(i)

Transpilează cu noul nostru target err_targ ca target:

pass_manager = generate_preset_pass_manager(
    optimization_level=1, target=err_targ, seed_transpiler=12345
)
qc_t_cm_bg_et = pass_manager.run(qc)
qc_t_cm_bg_et.draw("mpl", idle_wires=False, fold=-1)

Deoarece target-ul include informații despre erori, pasul VF2PostLayout încearcă să găsească Qubit-urile optime de utilizat, rezultând același Circuit care a fost inițial găsit cu aceleași Qubit-uri fizice.

Pași următori

Recomandări

• Înțelege Setările implicite și opțiunile de configurare pentru transpilare.
• Consultă subiectul Parametrii frecvent utilizați pentru transpilare.
• Încearcă ghidul Compararea setărilor transpiler-ului.
• Vezi Documentația API pentru transpilare.