Orbit - Qiskit Function โดย Quantum Elements

Note

Qiskit Functions เป็นฟีเจอร์ทดลองที่มีให้ใช้งานเฉพาะผู้ใช้ IBM Quantum® Premium Plan, Flex Plan และ On-Prem (ผ่าน IBM Quantum Platform API) Plan เท่านั้น ฟีเจอร์นี้อยู่ในสถานะ preview release และอาจมีการเปลี่ยนแปลง

ภาพรวม

ฮาร์ดแวร์ควอนตัมยังคงพัฒนาต่อไปเรื่อยๆ แต่ noise และ decoherence ยังคงจำกัดความลึกและความน่าเชื่อถือของวงจรควอนตัมที่ใช้งานได้จริง ในบรรดาแนวทางที่มีอยู่ มีสามเทคนิคที่เสริมกันซึ่งสามารถบรรเทาข้อจำกัดเหล่านี้ได้อย่างมาก: dynamical decoupling (DD), การทำ transpilation ที่ปรับให้เหมาะสม และการบรรเทาความคลาดเคลื่อนในการวัด (MEM) การทำ transpilation ที่ปรับให้เหมาะสมช่วยลดความลึกของวงจรและปรับวงจรให้เข้ากับการเชื่อมต่อของฮาร์ดแวร์เป้าหมายได้ดีขึ้น DD ระงับ noise ในช่วงเวลาว่างผ่านลำดับการควบคุมที่ออกแบบมาอย่างรอบคอบ และ MEM ลดผลกระทบของความคลาดเคลื่อนในการอ่านค่าและสามารถนำไปใช้ระหว่างการประมวลผลภายหลังได้

การเลือกกลยุทธ์ DD ที่มีประสิทธิภาพนั้นไม่ใช่เรื่องง่าย เนื่องจากมีกลุ่มลำดับให้เลือกใช้มากมาย และลำดับที่ทำงานได้ดีสำหรับวงจรหรือสภาพแวดล้อม noise หนึ่งอาจทำงานได้ไม่ดีสำหรับอีกแบบหนึ่ง ประโยชน์ของ transpilation, DD และ MEM ขึ้นอยู่กับปัญหา ฮาร์ดแวร์ และภาระงาน เมื่อใช้แยกกันหรือร่วมกัน เทคนิคเหล่านี้สามารถปรับปรุงประสิทธิภาพได้ แต่ไม่ได้เป็นประโยชน์ในทุกการกำหนดค่าเสมอไป

Orbit ซึ่งเป็น Qiskit Function ที่พัฒนาโดย Quantum Elements ผสานทั้งสามองค์ประกอบเข้าเป็น workflow เดียวอย่างราบรื่น ทำให้ใช้งานได้ง่ายเพื่อปรับปรุงการรันวงจรบนฮาร์ดแวร์ IBM Quantum ในรูปแบบหลัก Orbit จะใช้กลยุทธ์การระงับความคลาดเคลื่อนเชิงรุก (active) โดยอัตโนมัติ ซึ่งปกป้องสถานะควอนตัมในช่วงเวลาว่าง โดยยังคงรักษาตรรกะของวงจรเดิมไว้ ที่น่าสังเกตคือ Orbit ทำเช่นนี้โดยไม่เพิ่มเวลาการประมวลผลก่อนหน้าทั้งแบบควอนตัมหรือแบบคลาสสิกเพิ่มเติม จึงหลีกเลี่ยงค่าใช้จ่ายหรือเวลารอเพิ่มเติมที่ไม่จำเป็นภายใน workflow

แทนที่จะทำงานเป็น black box Orbit ช่วยให้ผู้ใช้สามารถประเมินและปรับแต่งองค์ประกอบการปรับให้เหมาะสมสำหรับการทดลองเฉพาะได้ ผู้ใช้สามารถเปิดหรือปิด transpilation ที่ปรับให้เหมาะสม, DD และ MEM ได้อย่างอิสระ; เปรียบเทียบการเลือก DD แบบอัตโนมัติกับลำดับที่ผู้ใช้กำหนดเอง; และรันการกำหนดค่าหลายแบบภายใน workflow เดียวกัน โดยการเปรียบเทียบแต่ละการกำหนดค่ากับวงจรดิบ ผู้ใช้สามารถระบุได้ว่าเทคนิคใดให้ประโยชน์ที่วัดได้สำหรับวงจรและ backend ของตน ระบุปฏิสัมพันธ์ระหว่างวิธีการปรับให้เหมาะสมต่างๆ และเลือกการกำหนดค่าที่สนับสนุนเป้าหมายการทดลองของตนได้ดีที่สุด กระบวนการนี้ช่วยแนะนำผู้ใช้ในการทำความเข้าใจว่าประสิทธิภาพที่เพิ่มขึ้นมาจากที่ใด และในการตัดสินใจอย่างมีข้อมูลมากขึ้นเมื่อปรับวงจรควอนตัมให้เหมาะสมสำหรับภาระงานที่กำหนด

คำอธิบาย

Orbit ได้รับการออกแบบมาเพื่อเพิ่มประสิทธิภาพการรันวงจรควอนตัมบน IBM Quantum backend ในโหมดอัตโนมัติ ผู้ใช้สามารถใช้ลำดับ DD อันดับสูงที่มีความทนทานได้อย่างราบรื่นโดยไม่ต้องเลือกหรือกำหนดค่าเอง ผู้ใช้ขั้นสูงสามารถทดลองใช้ลำดับอันดับสูงกว่าที่มีอยู่แทน เพื่อระบุและปรับให้เหมาะสมกับแนวทางที่ให้ประสิทธิภาพดีที่สุดสำหรับวงจรที่เจาะจง

Orbit ยังมอบ MEM แบบทันทีโดยไม่ต้องส่ง job เพิ่มเติมที่มักจำเป็นสำหรับ workflow การสอบเทียบและการบรรเทาที่แยกต่างหาก สำหรับภาระงานที่การทำ transpilation ไม่ควรเปลี่ยนแปลงโครงสร้างของวงจร เช่น วงจรการแก้ไขข้อผิดพลาดควอนตัมที่มีการวัดกลางวงจรหรือวงจรแบบไดนามิก Orbit สามารถใช้ DD และ MEM ได้โดยไม่รบกวนกลยุทธ์การทำ transpilation ที่มีอยู่ของผู้ใช้ สำหรับผู้ใช้ที่ยังไม่มีแนวทางที่ต้องการ Orbit ยังมี transpiler ในตัวเพื่อปรับวงจรให้เหมาะสมกับฮาร์ดแวร์เป้าหมายก่อนที่จะใช้เทคนิคการระงับความคลาดเคลื่อนและการบรรเทาการอ่านค่า

ต่างจากแนวทางที่พึ่งพาการสุ่มตัวอย่างวงจรเพิ่มเติม การประมาณค่านอกช่วง หรือการประมวลผลภายหลังแบบคลาสสิกที่ครอบคลุม Orbit มุ่งเน้นการระงับความคลาดเคลื่อนระหว่างการรัน ฟังก์ชันนี้ได้รับการออกแบบให้มีค่าใช้จ่ายต่ำในขณะที่ยังคงรักษาตรรกะของวงจรเดิมไว้ ผู้ใช้สามารถตรวจสอบวงจรที่ได้และเปรียบเทียบการรันที่ปรับให้เหมาะสมด้วย Orbit กับการรันแบบมาตรฐานได้โดยตรง

workflow ของ Orbit ในทางปฏิบัติคือ:

กำหนดวงจรควอนตัมและเลือก Orbit ผ่าน Qiskit Functions Catalog
รวมวงจรโดยไม่มี Orbit โดยใช้โหมด 'Raw' เพื่อสร้างเส้นฐานของวงจรดิบ
เลือกกลยุทธ์การปรับให้เหมาะสมที่จะใช้ รวมถึงลำดับ DD แบบอัตโนมัติหรือที่ผู้ใช้เลือก, MEM และ transpilation ที่ปรับให้เหมาะสม
เปิดหรือปิดวิธีการแต่ละอย่าง หรือส่งการกำหนดค่าหลายแบบ เพื่อประเมินผลแยกและผลรวมของวิธีการเหล่านั้น

Orbit มีประโยชน์อย่างยิ่งสำหรับวงจรที่มีช่วงเวลาว่างหรือช่องว่างในการจัดตารางเวลาที่ qubit ไม่ได้มีส่วนร่วมในเกตอย่างจริงจัง Orbit รองรับทั้งวงจรแบบคงที่และแบบไดนามิก รวมถึง workflow ที่มีการวัดกลางวงจรและการทดลองการคำนวณควอนตัมแบบทนทานต่อข้อผิดพลาด การใช้งานทั่วไป ได้แก่ การแก้ไขข้อผิดพลาดควอนตัม การทดลอง surface-code บนแลตทิซแบบสี่เหลี่ยมและ heavy-hex อัลกอริทึม oracular เช่น Bernstein-Vazirani วงจรการแปลงฟูริเยร์ อัลกอริทึมควอนตัมแบบ variational, Hamiltonian simulation, การทดลองเปรียบเทียบประสิทธิภาพ และการปรับวงจรให้เหมาะสมโดยคำนึงถึงฮาร์ดแวร์

เมื่อมองไปข้างหน้าสู่ยุคของการทนทานต่อข้อผิดพลาด Orbit ยังเข้ากันได้กับ workflow การคำนวณควอนตัมแบบทนทานต่อข้อผิดพลาด เนื่องจากสามารถผสานเข้ากับการแก้ไขข้อผิดพลาดควอนตัมได้อย่างราบรื่น ในระยะยาว Orbit ชี้ไปที่ dynamical decoupling ระดับ logical [1] ในฐานะแนวทางสำหรับอนาคตในการปกป้อง logical qubit ในตัวอย่างด้านล่าง logical qubit สองตัวถูกทำให้พันกันเพื่อสร้าง logical Bell state ภายใต้การตรวจจับข้อผิดพลาดควอนตัม การตรวจจับข้อผิดพลาดควอนตัมเพียงอย่างเดียวทำให้ความเที่ยงตรงของ Bell state ลดลงเหลือประมาณ 44% ในช่วงเวลาหลายสิบไมโครวินาที ในขณะที่ QED ร่วมกับการป้องกันแบบ Orbit ทำให้ความเที่ยงตรงของ logical Bell state คงอยู่ใกล้จุดสูงสุดของสเกล โดยสูงถึงประมาณ 95.3% ตลอดช่วงเวลาเดียวกัน Orbit Quantum Circuit Development Platform

เกณฑ์เปรียบเทียบประสิทธิภาพ

ผลลัพธ์ต่อไปนี้สรุปการรัน Orbit ที่เป็นตัวแทนบนฮาร์ดแวร์ IBM Quantum เช่นเดียวกับการเปรียบเทียบประสิทธิภาพฮาร์ดแวร์อื่นๆ ผลลัพธ์ขึ้นอยู่กับอุปกรณ์ที่เลือก สถานะการสอบเทียบ วงจร และการตั้งค่าการรัน

Example	Metric	Qubits	QPU	Additional details	Orbit Improvement
Bernstein–Vazirani	Hidden-bitstring fidelity	26 60 70	Heron r3	Raw versus Full Orbit, Transpilation only versus Full Orbit, Full Orbit Only	75x 66x N/A
QFT (unitary)	Fidelity	10	Heron r2 Heron r3	Orbit versus raw: ~44% versus ~35% ~67% versus ~61%	1.26x 1.09x
QFT (dynamic circuits)	Fidelity	10 20	Heron r3	Orbit versus raw: ~55% versus ~2% ~10% versus ~0%	27.51x N/A
Long-range Bell state (dynamic circuits)	Fidelity	30 60	Heron r2	N/A	1.78x 1.11x
Surface code (square lattice)	Logical error probability	25	Nighthawk r1	1 round 5 rounds 10 rounds	1.01x 1.15x 1.12x
Surface code (heavy-hex)	Logical error probability	65	Heron r3	1 round 5 rounds 10 rounds	4.11x 2.04x 1.39x
VQE	Absolute error relative to the ideal energy	8	Heron r3	Orbit versus raw: 56mHa versus 1342 mHa	24x
QAOA	Success probability	5	Heron r2	N/A	1.46x
`[[4,2,2]]` code (logical-level error suppression)	Entangled Bell-state logical fidelity	4	Heron r2	Average fidelity over 55 μs	1.63x

คำนิยามของเมตริก

Bernstein–Vazirani hidden-bitstring fidelity: ความน่าจะเป็นในการวัด hidden bitstring ที่ถูกต้อง metric นี้บ่งบอกว่าอัลกอริทึมสามารถกู้คืนคำตอบที่ตั้งใจไว้ได้น่าเชื่อถือเพียงใดเมื่อขนาด Circuit เพิ่มขึ้น ตารางรายงาน hidden bitstring ที่ใหญ่ที่สุดสามค่าที่ประเมินสำเร็จภายใต้การตั้งค่าสามแบบที่แตกต่างกัน: (i) raw circuits ที่ไม่มี Orbit ซึ่งไปถึง 26 qubits; (ii) circuits ที่มีเพียง transpilation ซึ่งไปถึง 60 qubits; และ (iii) circuits ที่ใช้ Orbit workflow เต็มรูปแบบ ซึ่งไปถึง 70 qubits สำหรับ raw circuits (i) improvement factor แสดงถึงประสิทธิภาพที่เพิ่มขึ้นจาก DD และ MEM เมื่อเทียบกับ circuits ที่ไม่ได้ปรับเปลี่ยน สำหรับการตั้งค่าที่มีเพียง transpilation (ii) มันแสดงถึงการปรับปรุงที่ได้จากการเพิ่ม DD และ MEM เข้าไปใน circuits ที่ transpiled อย่างเหมาะสมที่สุด สำหรับการตั้งค่า Orbit เต็มรูปแบบ (iii) ไม่มีการรายงาน improvement factor พื้นฐาน เนื่องจากได้ความน่าจะเป็นความสำเร็จที่ไม่เป็นศูนย์ก็ต่อเมื่อเปิดใช้งานส่วนประกอบ Orbit ทั้งหมด (transpilation, DD และ MEM) ตัวอย่างประกอบมีให้ด้านล่าง
Quantum Fourier transform fidelity: สำหรับการทำ QFT ทั้งแบบ unitary และแบบ dynamic-circuit [2] fidelity วัดความสอดคล้องระหว่างการแปลงที่นำไปใช้จริงกับกระบวนการ QFT ในอุดมคติ จากสถานะอินพุตที่แตกต่างกัน 20 สถานะ dynamic circuits มีช่วงเวลาว่างมากเนื่องจากการวัดกลาง Circuit และ classical feedforward ซึ่งในระหว่างนั้น dynamical decoupling สามารถระงับ decoherence ได้ การปรับปรุงที่รายงานเปรียบเทียบ fidelity ที่ได้จาก Orbit กับ raw fidelity
Long-range Bell-state preparation: การสร้าง Bell state โดยใช้ dynamic circuits และการดำเนินการ feedforward ระหว่าง qubits สองตัวที่ห่างกันด้วย qubits ตรงกลางมากถึง 60 ตัว จึงแสดงให้เห็นถึงการพัวพันระยะไกลที่มีประสิทธิภาพบนฮาร์ดแวร์ควอนตัมที่เชื่อมต่อกันเฉพาะที่ [3] Orbit ระบุการจัดเส้นทาง qubit ที่ดีที่สุด รักษา qubits ไว้ระหว่างการวัด feedforward และใช้ MEM เพื่อบรรเทาความผิดพลาดจากการอ่านค่า
Surface-code logical error probability: สำหรับ heavy-hex surface code [4] และ square-lattice surface code [5] มีการทดลอง quantum-memory โดยรักษาสถานะ logical ที่เข้ารหัสไว้ตลอดรอบการแก้ไขข้อผิดพลาดที่ทำซ้ำหลายรอบ Logical error probability วัดความน่าจะเป็นที่ข้อผิดพลาดสะสมจะทำให้ข้อมูลที่เข้ารหัสถูกกู้คืนอย่างไม่ถูกต้อง (ค่าความผิดพลาดยิ่งต่ำยิ่งดี) การปรับปรุงที่รายงานเปรียบเทียบ logical error probability จาก raw circuits กับที่ได้จาก Orbit
VQE absolute error: การใช้ VQE ร่วมกับ optimized unitary coupled-cluster ansatz เพื่อประมาณค่าพลังงานสถานะพื้นของ LiH [6] พลังงานที่วัดได้จะถูกเปรียบเทียบกับพลังงานในอุดมคติที่สอดคล้องกันซึ่งได้จาก circuit ที่ไม่มี noise metric นี้คือผลต่างสัมบูรณ์ระหว่างพลังงานที่วัดได้กับพลังงานในอุดมคติ (ค่ายิ่งน้อยยิ่งดี) การปรับปรุงที่รายงานคือ:

\text{Improvement factor} = \frac{|E_{\mathrm{raw}}-E_{\mathrm{ideal}}|} {|E_{\mathrm{Orbit}}-E_{\mathrm{ideal}}|}.

ค่าที่มากกว่าหนึ่งบ่งบอกว่า Orbit ลดข้อผิดพลาดของพลังงานเมื่อเทียบกับการรันโดยไม่มี dynamical decoupling

QAOA success probability: ความน่าจะเป็นในการวัด bitstring ที่สอดคล้องกับคำตอบที่เหมาะสมที่สุดของปัญหาการหาค่าเหมาะสมที่ถูกกำหนดบน butterfly graph การปรับปรุงที่รายงานเปรียบเทียบความน่าจะเป็นความสำเร็จที่ได้จาก Orbit กับที่ได้จาก raw circuits
Logical fidelity: ในการทดลอง logical dynamical-decoupling แบบ [[4,2,2]] [1] logical qubits สองตัวถูกเข้ารหัสลงใน physical qubits สี่ตัวและเตรียมเป็น entangled logical Bell state Logical fidelity วัดความสอดคล้องระหว่างสถานะที่เข้ารหัสที่กู้คืนมากับ target logical Bell state การปรับปรุงที่รายงานเปรียบเทียบ logical fidelity เฉลี่ยที่ได้จาก Orbit และ error detection (ความสามารถของโค้ด) กับที่ได้เมื่อใช้เฉพาะโค้ดเพียงอย่างเดียว

เริ่มต้นใช้งาน

ยืนยันตัวตนโดยใช้ IBM Quantum Platform API key และเลือก Orbit function ดังนี้ ตัวอย่างโค้ดนี้สมมติว่าคุณได้ บันทึกบัญชี ไว้ในสภาพแวดล้อมเครื่องของคุณแล้ว

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

from qiskit_ibm_catalog import QiskitFunctionsCatalog
from qiskit import QuantumCircuit

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
# Verify that you have access to the function.
catalog.list()

[QiskitFunction(quantum-elements/orbit)]

# Load the function.
orbit = catalog.load("quantum-elements/orbit")

ตัวอย่าง

ตัวอย่างต่อไปนี้สร้าง Bernstein-Vazirani circuit และส่งไปยัง Orbit สองวิธีในหนึ่ง job: การรันแบบ raw และ Orbit defaults

ใช้รูปแบบนี้เมื่อคุณต้องการเปรียบเทียบระหว่าง raw กับ Orbit โดยตรง

สร้าง Bernstein-Vazirani circuit

เลือก hidden bitstring และสร้าง logical circuit qubit พิเศษคือ oracle target ในขณะที่ qubits อินพุตจะถูกวัด

def create_bv_circuit(hidden_bitstring: str) -> QuantumCircuit:
    width = len(hidden_bitstring)
    circuit = QuantumCircuit(width + 1, width)

    circuit.x(width)
    circuit.h(range(width + 1))

    for input_qubit, bit in enumerate(reversed(hidden_bitstring)):
        if bit == "1":
            circuit.cx(input_qubit, width)

    circuit.barrier()
    circuit.h(range(width + 1))
    circuit.measure(range(width), range(width))
    return circuit

circuit_width = 50
hidden_bitstring = "1" * circuit_width
shots = 4096

bv_circuit = create_bv_circuit(hidden_bitstring)
bv_circuit.count_ops()

OrderedDict([('h', 102),
             ('cx', 50),
             ('measure', 50),
             ('x', 1),
             ('barrier', 1)])

เตรียม Orbit workload

สร้าง Sampler PUB หนึ่งอัน แล้วทำสำเนาสำหรับโหมดเปรียบเทียบทั้งสอง Orbit รับ logical circuit และแมปไปยัง backend ที่เลือกในระหว่างการรัน

base_pub = (bv_circuit, None, shots)
comparison_labels = ["raw", "orbit"]
pubs = [base_pub] * len(comparison_labels)

รัน raw และ Orbit defaults

pub_options กำหนด PUB แรกให้เป็นโหมด raw ซึ่งข้ามการปรับให้เหมาะสมของ Orbit, DD และ MEM และกำหนด PUB ที่สองให้เป็น Orbit defaults ซึ่งรวมถึง optimized transpilation, การแทรก dynamical decoupling (DD) แบบอัตโนมัติ และการบรรเทาความผิดพลาดจากการวัด (MEM)

backend_name = "ibm_kingston"

job = orbit.run(
    primitive="sampler",
    pubs=pubs,
    backend_name=backend_name,
    options={
        "pub_options": [
            {"mode": "raw"},
            {"mode": "orbit"},
        ],
        "save_backend_info": True,
    },
)

# Check the job ID and status
print(job.job_id)
print(job.status())

c0f1b99c-8dfa-4ebb-9560-d9a37c990acc
QUEUED

ดึงผลลัพธ์และเปรียบเทียบ circuit แบบ raw กับ Orbit-enhanced โดยใช้ counts สำหรับผลลัพธ์ของ Sampler get_counts() บน classical register ที่ได้คืนมาจะให้ output histogram เมื่อ MEM สำเร็จสำหรับ Orbit PUB histogram นี้จะถูกแก้ไขด้วย MEM แล้ว ส่วน counts ที่ยังไม่ได้บรรเทาจะยังคงมีให้ใน Orbit metadata ภายใต้ measurementErrorMitigation["rawCounts"]

def extract_counts(pub_result) -> dict[str, int]:
    data = getattr(pub_result, "data", None)
    if data is None:
        raise TypeError("pub_result.data is missing")

    for name in dir(data):
        if name.startswith("_"):
            continue
        register = getattr(data, name)
        get_counts = getattr(register, "get_counts", None)
        if callable(get_counts):
            counts = get_counts()
            if counts:
                return counts

    raise TypeError(
        "No classical register with get_counts() found in pub_result.data"
    )

result = job.result()
if len(result) != len(comparison_labels):
    raise RuntimeError(
        f"Expected {len(comparison_labels)} PUB results, received {len(result)}."
    )

comparison_counts = {
    label: extract_counts(pub_result)
    for label, pub_result in zip(comparison_labels, result, strict=True)
}
correct_counts = {
    label: counts.get(hidden_bitstring, 0)
    for label, counts in comparison_counts.items()
}

print(
    {
        "hidden_bitstring": hidden_bitstring,
        "correct_counts": correct_counts,
        "shots": shots,
    }
)

{'hidden_bitstring': '11111111111111111111111111111111111111111111111111', 'correct_counts': {'raw': 0, 'orbit': 184}, 'shots': 4096}

เปรียบเทียบ circuit แบบ raw และ Orbit-enhanced ด้วยภาพ

import matplotlib.pyplot as plt

labels = list(correct_counts)
values = list(correct_counts.values())
fig, ax = plt.subplots(figsize=(7, 4))
bars = ax.bar(labels, values, width=0.55)
ax.bar_label(bars, labels=[f"{value:g}" for value in values], padding=3)
ax.set_xlabel("Circuit execution mode")
ax.set_ylabel("Correct hidden-bitstring count")
ax.set_title(f"{circuit_width}-qubit Bernstein-Vazirani on {backend_name}")
ax.set_ylim(0, max(1, 1.15 * max(values)))
ax.grid(axis="y", alpha=0.25)
fig.tight_layout()
plt.show()

Output of the previous code cell

ขอความช่วยเหลือ

ติดต่อฝ่ายสนับสนุนของ Quantum Elements: info@quantumelements.ai

โปรดระบุข้อมูลต่อไปนี้:

Qiskit Function Job ID (qiskit-ibm-catalog), job.job_id
ชื่อ Backend
Orbit pub_options ที่ใช้สำหรับโหมด raw และ Orbit
คำอธิบายปัญหาโดยละเอียด
ข้อความหรือรหัสข้อผิดพลาดที่เกี่ยวข้อง
ขั้นตอนในการทำให้เกิดปัญหาซ้ำ

ขั้นตอนถัดไป

คำแนะนำ

ลอง backend, จำนวน qubit หรือ hidden bitstring อื่น
อ่าน tutorial ของเรา เกี่ยวกับ quantum Fourier transform เพื่อเรียนรู้วิธีกำหนด custom DD strategies ที่รองรับ orbit รวมถึงการใช้ DD กับ dynamic circuits ที่มีการวัดกลาง circuit และการดำเนินการ feedforward
เยี่ยมชม API reference สำหรับคำอธิบายโดยละเอียดของตัวเลือก Orbit ทั้งหมด

ภาพรวม​

คำอธิบาย​

เกณฑ์เปรียบเทียบประสิทธิภาพ​

คำนิยามของเมตริก​

เริ่มต้นใช้งาน​

ตัวอย่าง​

สร้าง Bernstein-Vazirani circuit​

เตรียม Orbit workload​

รัน raw และ Orbit defaults​

ขอความช่วยเหลือ​

ขั้นตอนถัดไป​

เอกสารอ้างอิง​