QESEM: A Qiskit Function by Qedma

หมายเหตุ

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

ภาพรวม

แม้ว่า quantum processing units จะพัฒนาขึ้นอย่างมากในช่วงไม่กี่ปีที่ผ่านมา แต่ error จาก noise และความไม่สมบูรณ์ของ hardware ที่มีอยู่ยังคงเป็นความท้าทายหลักสำหรับนักพัฒนา quantum algorithm เมื่อสาขานี้เข้าใกล้การคำนวณควอนตัมระดับ utility-scale ที่ไม่สามารถตรวจสอบได้ด้วยคอมพิวเตอร์คลาสสิก การแก้ปัญหาสำหรับการยกเลิก noise ที่มีการรับประกันความแม่นยำกลายเป็นสิ่งสำคัญมากขึ้นเรื่อยๆ เพื่อเอาชนะความท้าทายนี้ Qedma ได้พัฒนา Quantum Error Suppression and Error Mitigation (QESEM) ที่ผสานรวมอย่างราบรื่นบน IBM Quantum Platform เป็น Qiskit Function

ด้วย QESEM ผู้ใช้สามารถรัน quantum circuits บน QPU ที่มี noise เพื่อรับผลลัพธ์ที่แม่นยำสูงและปราศจาก error พร้อม overhead ของเวลา QPU ที่มีประสิทธิภาพสูง ใกล้เคียงกับขอบเขตพื้นฐาน เพื่อให้บรรลุเป้าหมายนี้ QESEM ใช้ชุดวิธีการ proprietary ที่ Qedma พัฒนาขึ้นสำหรับการระบุลักษณะและลด error เทคนิคการลด error ได้แก่ gate optimization, noise-aware transpilation, error suppression (ES) และ unbiased error mitigation (EM) ด้วยการผสมผสานวิธีการที่อิงการระบุลักษณะเหล่านี้ ผู้ใช้สามารถได้ผลลัพธ์ที่เชื่อถือได้และปราศจาก error สำหรับ quantum circuits ปริมาณมากทั่วไป เปิดใช้งานแอปพลิเคชันที่ไม่สามารถทำได้อย่างอื่น

สำหรับคำอธิบายเต็มของ components พื้นฐานรวมถึงการสาธิตระดับ utility-scale ดูที่บทความ Reliable high-accuracy error mitigation for utility-scale quantum circuits.

คำอธิบาย

คุณสามารถใช้ฟังก์ชัน QESEM โดย Qedma เพื่อประเมินและรัน circuits ของคุณพร้อม error suppression และ mitigation ได้อย่างง่ายดาย ได้ circuit volumes ที่ใหญ่ขึ้นและความแม่นยำสูงขึ้น ในการใช้ QESEM คุณต้องให้ quantum circuit ชุด observables ที่จะวัด ความแม่นยำทางสถิติเป้าหมายสำหรับแต่ละ observable และ QPU ที่เลือก ก่อนรัน circuit ตามความแม่นยำเป้าหมาย คุณสามารถประเมินเวลา QPU ที่ต้องการโดยอิงการคำนวณเชิงวิเคราะห์ที่ไม่ต้องรัน circuit เมื่อพอใจกับการประเมินเวลา QPU แล้ว คุณก็สามารถรัน circuit ด้วย QESEM ได้

เมื่อคุณรัน circuit, QESEM จะรัน device characterization protocol ที่ปรับแต่งเฉพาะสำหรับ circuit ของคุณ ให้โมเดล noise ที่เชื่อถือได้สำหรับ error ที่เกิดขึ้นใน circuit จากการระบุลักษณะ QESEM จะ implement noise-aware transpilation ก่อน เพื่อ map input circuit ลงบน physical qubits และ gates ที่ลด noise ที่ส่งผลต่อ target observable ซึ่งรวมถึง gates ที่มีอยู่ native (CX/CZ บน IBM® devices) รวมถึง gates เพิ่มเติมที่ QESEM optimize ก่อตัวเป็น extended gate set ของ QESEM จากนั้น QESEM รันชุด ES และ EM circuits ที่อิงการระบุลักษณะบน QPU และเก็บผล measurement รูทีนเหล่านี้ถูก post-process แบบ classically เพื่อให้ค่า expectation value ที่ไม่มี bias และ error bar สำหรับแต่ละ observable ตามความแม่นยำที่ร้องขอ

QESEM ได้รับการสาธิตว่าให้ผลลัพธ์ที่มีความแม่นยำสูงสำหรับ quantum applications หลากหลายรูปแบบและบน circuit volumes ที่ใหญ่ที่สุดที่ทำได้ในปัจจุบัน QESEM มีฟีเจอร์ต่อไปนี้ที่แสดงในส่วน benchmarks ด้านล่าง:

• ความแม่นยำที่รับประกัน: QESEM ให้ผลลัพธ์ประมาณค่า expectation values ของ observables ที่ไม่มี bias วิธี EM มีการรับประกันทางทฤษฎี ซึ่งร่วมกับการระบุลักษณะระดับ cutting-edge ของ Qedma รับประกันว่า mitigation จะ converge ไปสู่ noiseless circuit output ในระดับความแม่นยำที่ผู้ใช้กำหนด ต่างจากวิธี EM แบบ heuristic หลายวิธีที่เสี่ยงต่อ systematic errors หรือ biases ความแม่นยำที่รับประกันของ QESEM เป็นสิ่งสำคัญสำหรับให้ผลลัพธ์ที่เชื่อถือได้ใน quantum circuits และ observables ทั่วไป
• ขยายได้สำหรับ QPU ขนาดใหญ่: เวลา QPU ของ QESEM ขึ้นอยู่กับ circuit volumes แต่เป็นอิสระจากจำนวน Qubit Qedma ได้สาธิต QESEM บน quantum devices ที่ใหญ่ที่สุดที่มีอยู่ในปัจจุบัน รวมถึง IBM Quantum Eagle 127-qubit และ Heron 133-qubit devices
• ไม่เฉพาะเจาะจงกับแอปพลิเคชัน: QESEM ได้รับการสาธิตในแอปพลิเคชันหลากหลาย รวมถึง Hamiltonian simulation, VQE, QAOA และ amplitude estimation ผู้ใช้สามารถป้อน quantum circuit และ observable ใดๆ ที่ต้องการวัดและได้ผลลัพธ์ที่แม่นยำและปราศจาก error ข้อจำกัดเดียวถูกกำหนดโดย hardware specifications และเวลา QPU ที่จัดสรรไว้ ซึ่งกำหนด circuit volumes และความแม่นยำของ output ที่เข้าถึงได้ ต่างจากโซลูชันลด error หลายตัวที่เฉพาะเจาะจงกับแอปพลิเคชันหรือใช้ heuristics ที่ไม่ควบคุม ทำให้ใช้ไม่ได้กับ quantum circuits และแอปพลิเคชันทั่วไป
• Extended gate set: QESEM รองรับ fractional-angle gates และมี Qedma-optimized fractional-angle $Rzz(\theta)$ gates บน IBM Quantum Eagle devices Extended gate set นี้ช่วยให้ compilation มีประสิทธิภาพมากขึ้นและเปิดล็อก circuit volumes ที่ใหญ่กว่าถึง 2 เท่าเมื่อเทียบกับ default CX/CZ compilation
• Multibase observables: QESEM รองรับ input observables ที่ประกอบด้วย Pauli strings ที่ไม่ commute กันหลายตัว เช่น generic Hamiltonians การเลือก measurement bases และการ optimize การจัดสรรทรัพยากร QPU (shots และ circuits) จะทำโดยอัตโนมัติโดย QESEM เพื่อลดเวลา QPU ที่ต้องการสำหรับความแม่นยำที่ร้องขอ การ optimize นี้ ซึ่งคำนึงถึง hardware fidelities และ execution rates ช่วยให้คุณรัน circuits ที่ลึกขึ้นและได้ความแม่นยำสูงขึ้น

Benchmarks

QESEM ได้รับการทดสอบกับ use cases และแอปพลิเคชันหลากหลาย ตัวอย่างต่อไปนี้ช่วยให้คุณประเมินได้ว่า workloads ประเภทใดที่คุณสามารถรันกับ QESEM ได้

ตัวชี้วัดสำคัญสำหรับการวัดความยากของทั้ง error mitigation และ classical simulation สำหรับ circuit และ observable ที่กำหนดคือ active volume: จำนวน CNOT gates ที่ส่งผลต่อ observable ใน circuit active volume ขึ้นอยู่กับความลึกและความกว้างของ circuit, น้ำหนักของ observable และโครงสร้างของ circuit ซึ่งกำหนด light cone ของ observable สำหรับรายละเอียดเพิ่มเติม ดูการบรรยายจาก 2024 IBM Quantum Summit QESEM มีประโยชน์อย่างมากในระดับ high-volume โดยให้ผลลัพธ์ที่เชื่อถือได้สำหรับ circuits และ observables ทั่วไป

แอปพลิเคชัน	จำนวน Qubit	Device	คำอธิบาย Circuit	ความแม่นยำ	เวลาทั้งหมด	การใช้งาน Runtime
VQE circuit	8	Eagle (r3)	21 layers ทั้งหมด, 9 measurement bases, 1D chain	98%	35 นาที	14 นาที
Kicked Ising	28	Eagle (r3)	3 unique layers x 3 steps, 2D heavy-hex topology	97%	22 นาที	4 นาที
Kicked Ising	28	Eagle (r3)	3 unique layers x 8 steps, 2D heavy-hex topology	97%	116 นาที	23 นาที
Trotterized Hamiltonian simulation	40	Eagle (r3)	2 unique layers x 10 Trotter steps, 1D chain	97%	3 ชั่วโมง	25 นาที
Trotterized Hamiltonian simulation	119	Eagle (r3)	3 unique layers x 9 Trotter steps, 2D heavy-hex topology	95%	6.5 ชั่วโมง	45 นาที
Kicked Ising	136	Heron (r2)	3 unique layers x 15 steps, 2D heavy-hex topology	99%	52 นาที	9 นาที

ความแม่นยำวัดที่นี่เทียบกับค่า ideal ของ observable: $\frac{\langle O \rangle_{ideal} - \epsilon}{\langle O \rangle_{ideal}}$ โดยที่ '$\epsilon$' คือความแม่นยำสัมบูรณ์ของ mitigation (กำหนดโดย user input) และ $\langle O \rangle_{ideal}$ คือ observable บน noiseless circuit 'Runtime usage' วัดการใช้งาน benchmark ในโหมด batch (ผลรวมการใช้งานของแต่ละ job) ในขณะที่ 'total time' วัดการใช้งานในโหมด session (experiment wall time) ซึ่งรวมเวลา classical และ communication เพิ่มเติม QESEM พร้อมใช้งานในทั้งสองโหมด เพื่อให้ผู้ใช้ใช้ทรัพยากรที่มีอยู่ได้อย่างดีที่สุด

28-qubit Kicked Ising circuits จำลอง Discrete Time Quasicrystal ที่ศึกษาโดย Shinjo et al. (ดู arXiv 2403.16718 และ Q2B24 Tokyo) บน three connected loops ของ ibm_kawasaki พารามิเตอร์ circuit ที่ใช้คือ $(\theta_x, \theta_z) = (0.9 \pi, 0)$ พร้อม ferromagnetic initial state $| \psi_0 \rangle = | 0 \rangle ^{\otimes n}$ observable ที่วัดคือค่าสัมบูรณ์ของ magnetization $M = |\frac{1}{28} \sum_{i=0}^{27} \langle Z_i \rangle|$ การทดลอง utility-scale Kicked Ising รันบน 136 qubits ที่ดีที่สุดของ ibm_fez benchmark เฉพาะนี้รันที่ Clifford angle $(\theta_x, \theta_z) = (\pi, 0)$ ซึ่ง active volume โตช้าตาม circuit depth ซึ่งร่วมกับ device fidelities สูงทำให้ได้ความแม่นยำสูงใน runtime สั้น

Trotterized Hamiltonian simulation circuits สำหรับ Transverse-Field Ising model ที่ fractional angles: $(\theta_{zz}, \theta_x) = (\pi / 4, \pi /8)$ และ $(\theta_{zz}, \theta_x) = (\pi / 6, \pi / 8)$ ตามลำดับ (ดู Q2B24 Tokyo) utility-scale circuit รันบน 119 qubits ที่ดีที่สุดของ ibm_brisbane ในขณะที่การทดลอง 40-qubit รันบน chain ที่ดีที่สุดที่มีอยู่ ความแม่นยำรายงานสำหรับ magnetization ผลลัพธ์ความแม่นยำสูงได้รับสำหรับ observables ที่มีน้ำหนักสูงกว่าด้วย

VQE circuit ถูกพัฒนาร่วมกับนักวิจัยจาก Center for Quantum Technology and Applications ที่ Deutsches Elektronen-Synchrotron (DESY) target observable ที่นี่คือ Hamiltonian ที่ประกอบด้วย Pauli strings ที่ไม่ commute กันจำนวนมาก เน้นประสิทธิภาพที่ optimize ของ QESEM สำหรับ multi-basis observables Mitigation ถูกนำไปใช้กับ classically-optimized ansatz แม้ว่าผลลัพธ์เหล่านี้ยังไม่ได้ตีพิมพ์ ผลลัพธ์คุณภาพเดียวกันจะได้รับสำหรับ circuits ต่างๆ ที่มีคุณสมบัติโครงสร้างคล้ายกัน

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

ยืนยันตัวตนโดยใช้ IBM Quantum Platform API key และเลือก QESEM Qiskit Function ดังนี้ (snippet นี้สมมติว่าคุณได้ บันทึกบัญชีของคุณ ไว้ใน local environment แล้ว)

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

import qiskit

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

qesem_function = catalog.load("qedma/qesem")

ตัวอย่าง

เพื่อเริ่มต้น ลองตัวอย่างพื้นฐานนี้ในการประเมินเวลา QPU ที่ต้องการในการรัน QESEM สำหรับ pub ที่กำหนด:

# This cell is hidden from users
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend_name = service.least_busy().name

circ = qiskit.QuantumCircuit(5)
circ.cx(0, 1)
circ.cx(2, 3)
circ.cx(1, 2)
circ.cx(3, 4)

avg_magnetization = qiskit.quantum_info.SparsePauliOp.from_sparse_list(
    [("Z", [q], 1 / 5) for q in range(5)], num_qubits=5
)
other_observable = qiskit.quantum_info.SparsePauliOp.from_sparse_list(
    [("ZZ", [0, 1], 1.0), ("XZ", [1, 4], 0.5)], num_qubits=5
)

time_estimation_job = qesem_function.run(
    pubs=[(circ, [avg_magnetization, other_observable])],
    options={
        "estimate_time_only": "analytical",
    },
    backend_name=backend_name,  # E.g. "ibm_fez"
)

time_estimate_result = time_estimation_job.result()

ตัวอย่างต่อไปนี้รัน QESEM job:

sample_job = qesem_function.run(
    pubs=[(circ, [avg_magnetization, other_observable])],
    backend_name=backend_name,  # E.g. "ibm_fez"
)

คุณสามารถใช้ Qiskit Serverless APIs ที่คุ้นเคยเพื่อตรวจสอบสถานะหรือดึงผลลัพธ์ของ Qiskit Function workload:

print(sample_job.status())
result = sample_job.result()

พารามิเตอร์ของฟังก์ชัน

ชื่อ	ประเภท	คำอธิบาย	จำเป็น	ค่าเริ่มต้น	ตัวอย่าง
pubs	EstimatorPubLike	นี่คือ input หลัก Pub ประกอบด้วย 2-4 elements: circuit, observables หนึ่งหรือมากกว่า, 0 หรือชุด parameter values เดียว และ precision ที่ไม่บังคับ หากไม่ได้ระบุ precision จะใช้ default_precision จาก options	ใช่	N/A	[(circuit, [obs1,obs2,obs3], parameter_values, 0.03)]
backend_name	string	ชื่อของ Backend ที่ต้องการใช้	ไม่	QESEM จะได้ device ที่ว่างที่สุดจาก IBM	"ibm_fez"
instance	string	cloud resource name ของ instance ที่ต้องการใช้ในรูปแบบนั้น	ไม่	N/A	"CRN"
options	dictionary	Input options ดูส่วน Options สำหรับรายละเอียดเพิ่มเติม	ไม่	ดูส่วน Options สำหรับรายละเอียด	{ default_precision = 0.03, "max_execution_time" = 3600, "transpilation_level" = 0}

Options

Option	ตัวเลือก	คำอธิบาย	ค่าเริ่มต้น
estimate_time_only	"analytical" / "empirical" / None	เมื่อตั้งค่า QESEM job จะคำนวณเฉพาะการประเมินเวลา QPU ดูคำอธิบายต่อไปนี้สำหรับรายละเอียดเพิ่มเติม เมื่อตั้งเป็น None circuit จะถูกรันด้วย QESEM	None
default_precision	0 < float	จะนำไปใช้กับ pubs ที่ไม่มี precision precision หมายถึง error ที่ยอมรับได้ของค่า expectation values ของ observables ในค่าสัมบูรณ์ กล่าวคือ QPU runtime สำหรับ mitigation จะถูกกำหนดให้ให้ค่า output สำหรับ observables ทั้งหมดที่อยู่ใน 1σ confidence interval ของ target precision หากมี observables หลายตัว mitigation จะรันจนกว่าจะถึง target precision สำหรับแต่ละ observable	0.02
max_execution_time	0 < integer < 28,800 (8 ชั่วโมง)	ช่วยให้คุณจำกัดเวลา QPU ที่ระบุเป็นวินาที สำหรับกระบวนการ QESEM ทั้งหมด ดูรายละเอียดเพิ่มเติมด้านล่าง	3,600 (หนึ่งชั่วโมง)
transpilation_level	0 / 1	ดูคำอธิบายด้านล่าง	1
execution_mode	"session" / "batch"	ดูคำอธิบายต่อไปนี้	"batch"

ข้อควรระวัง

การประเมินเวลา QPU เปลี่ยนแปลงตาม backend แต่ละตัว ดังนั้น เมื่อรัน QESEM function ให้แน่ใจว่ารันบน backend เดียวกับที่เลือกไว้เมื่อได้การประเมินเวลา QPU

หมายเหตุ

QESEM จะสิ้นสุดการรันเมื่อถึง target precision หรือถึง max_execution_time แล้วแต่อะไรจะมาถึงก่อน

• estimate_time_only - flag นี้ให้ผู้ใช้รับการประเมินเวลา QPU ที่ต้องใช้ในการรัน circuit ด้วย QESEM

  • หากตั้งเป็น "analytical" จะคำนวณ upper bound ของเวลา QPU โดยไม่ใช้ QPU usage การประเมินนี้มีความละเอียด 30 นาที (เช่น 30 นาที, 60 นาที, 90 นาที เป็นต้น) โดยทั่วไปค่อนข้าง pessimistic และสามารถรับได้เฉพาะสำหรับ Pauli observables เดียวหรือผลรวม Paulis ที่ไม่มี supports ตัดกัน (เช่น Z0+Z1) มีประโยชน์หลักในการเปรียบเทียบระดับความซับซ้อนของพารามิเตอร์ต่างๆ ที่ผู้ใช้ให้ (circuit, accuracy เป็นต้น)
  • เพื่อรับการประเมินเวลา QPU ที่แม่นยำมากขึ้น ตั้ง flag นี้เป็น "empirical" แม้ว่าตัวเลือกนี้ต้องรัน circuits จำนวนน้อย แต่ให้การประเมินเวลา QPU ที่แม่นยำกว่ามาก การประเมินนี้มีความละเอียด 5 นาที (เช่น 20 นาที, 25 นาที, 30 นาที เป็นต้น) ผู้ใช้สามารถเลือกรัน empirical time estimation ในโหมด batch หรือ session สำหรับรายละเอียดเพิ่มเติม ดูคำอธิบาย execution_mode ตัวอย่างเช่น ในโหมด batch empirical time estimation จะใช้เวลา QPU น้อยกว่า 10 นาที

• max_execution_time: ช่วยให้คุณจำกัดเวลา QPU ที่ระบุเป็นวินาที สำหรับกระบวนการ QESEM ทั้งหมด เนื่องจากเวลา QPU สุดท้ายที่ต้องการเพื่อถึง target accuracy ถูกกำหนดแบบ dynamic ระหว่าง QESEM job พารามิเตอร์นี้ช่วยให้คุณจำกัดต้นทุนของการทดลอง หาก dynamically-determined QPU time สั้นกว่าเวลาที่ผู้ใช้จัดสรร พารามิเตอร์นี้จะไม่ส่งผลต่อการทดลอง พารามิเตอร์ max_execution_time มีประโยชน์อย่างยิ่งในกรณีที่การประมาณ analytical time ที่ QESEM ให้ก่อนเริ่ม job นั้น pessimistic เกินไปและผู้ใช้ต้องการเริ่ม mitigation job อยู่ดี หลังจากถึงขีดจำกัดเวลา QESEM หยุดส่ง circuits ใหม่ circuits ที่ส่งไปแล้วยังคงรันต่อ (ดังนั้นเวลาทั้งหมดอาจเกินขีดจำกัดได้ถึง 30 นาที) และผู้ใช้จะได้ผลลัพธ์ที่ประมวลผลแล้วจาก circuits ที่รันจนถึงจุดนั้น หากต้องการใช้ขีดจำกัดเวลา QPU ที่สั้นกว่าการประมาณ analytical time ให้ปรึกษา Qedma เพื่อรับการประมาณความแม่นยำที่ทำได้ภายในขีดจำกัดเวลา

• transpilation_level: หลังจาก circuit ถูกส่งไปยัง QESEM ระบบจะเตรียม alternative circuit transpilations หลายตัวโดยอัตโนมัติและเลือกตัวที่ลดเวลา QPU ให้น้อยที่สุด ตัวอย่างเช่น alternative transpilations อาจใช้ Qedma-optimized fractional RZZ gates เพื่อลด circuit depth แน่นอน transpilations ทั้งหมดเทียบเท่ากับ input circuit ในแง่ของ ideal output เพื่อควบคุม circuit transpilation มากขึ้น ตั้ง transpilation level ใน options ในขณะที่ "transpilation_level": 1 สอดคล้องกับพฤติกรรมเริ่มต้นที่อธิบายข้างต้น "transpilation_level": 0 รวมเฉพาะการปรับเปลี่ยนขั้นต่ำที่จำเป็นต่อ original circuit ตัวอย่างเช่น 'layerification' - การจัดระเบียบ circuit operations เป็น 'layers' ของ two-qubit gates พร้อมกัน หมายเหตุ: automatic hardware-mapping ลงบน high-fidelity qubits จะถูกนำไปใช้ไม่ว่าจะอย่างไร

transpilation_level	คำอธิบาย
1	Default QESEM transpilation เตรียม alternative transpilations หลายตัวและเลือกตัวที่ลดเวลา QPU Barriers อาจถูกปรับเปลี่ยนในขั้นตอน layerification
0	Minimal transpilation: mitigated circuit จะมีโครงสร้างใกล้เคียงกับ input circuit Circuits ที่ให้ในระดับ 0 ควร match device connectivity และควรระบุในรูปของ gates ต่อไปนี้: CX, Rzz(α) และ standard single-qubit gates (U, x, sx, rz เป็นต้น) Barriers จะได้รับการเคารพในขั้นตอน layerification

• execution_mode - ผู้ใช้สามารถเลือกรัน QESEM job ใน dedicated IBM session หรือข้าม IBM batches หลายตัว:
  • Session Mode: Sessions มีราคาแพงกว่าแต่ทำให้ time-to-result สั้นลง เมื่อ session เริ่มต้น QPU จะถูกสำรองเฉพาะสำหรับ QESEM job การคำนวณการใช้งานรวมทั้งเวลาที่ใช้ใน QPU execution และการคำนวณ classical ที่เกี่ยวข้อง (ดำเนินการโดย QESEM และ IBM) QESEM Qiskit Function ดูแลการสร้างและปิด session โดยอัตโนมัติ สำหรับผู้ใช้ที่มีสิทธิ์เข้าถึง QPU ไม่จำกัด (เช่น on-premises setups) แนะนำให้ใช้ session mode สำหรับการรัน QESEM ที่เร็วขึ้น
  • Batch Mode: ในโหมด batch QPU จะถูกปล่อยระหว่างการคำนวณ classical ทำให้ใช้ QPU น้อยลง เนื่องจาก batch jobs โดยทั่วไปครอบคลุมระยะเวลาที่ยาวกว่า มีความเสี่ยงมากขึ้นต่อ hardware drifts QESEM รวมมาตรการในการตรวจจับและชดเชย drifts รักษาความน่าเชื่อถือในช่วงการรันที่ยาวนาน

หมายเหตุ

Barrier operations โดยทั่วไปใช้เพื่อระบุ layers ของ two-qubit gates ใน quantum circuits ในระดับ 0 QESEM จะเก็บ layers ที่ระบุโดย barriers ในระดับ 1 layers ที่ระบุโดย barriers จะถูกพิจารณาเป็น transpilation alternative หนึ่งเมื่อลดเวลา QPU

Outputs

Output ของ Circuit function คือ PrimitiveResult ซึ่งประกอบด้วยสองฟิลด์:

• หนึ่ง PubResult object สามารถ index ได้โดยตรงจาก PrimitiveResult

• Job-level metadata

แต่ละ PubResult ประกอบด้วยฟิลด์ data และ metadata

• ฟิลด์ data ประกอบด้วยอย่างน้อย array ของ expectation values (PubResult.data.evs) และ array ของ standard errors (PubResult.data.stds) อาจมีข้อมูลเพิ่มเติมขึ้นอยู่กับ options ที่ใช้

• ฟิลด์ metadata ประกอบด้วย PUB-level metadata (PubResult.metadata)

code snippet ต่อไปนี้อธิบายวิธีดึงการประเมินเวลา QPU (เมื่อตั้ง estimate_time_only):

print(
    f"The estimated QPU time for this PUB is: \n{time_estimate_result[0].metadata}"
)

code snippet ต่อไปนี้แสดงวิธีดึงผลลัพธ์ mitigation (เมื่อไม่ได้ตั้ง estimate_time_only) และ execution metrics ซึ่งประกอบด้วยข้อมูลสำคัญที่ช่วยให้เข้าใจได้ลึกขึ้นว่าพารามิเตอร์ต่างๆ ส่งผลต่อการรัน QESEM อย่างไร อาจมีความเกี่ยวข้องเมื่อเขียนบทความโดยอิงงานวิจัยของคุณด้วย

results = result[0]
print(f"Mitigated expectation values: \n{results.data.evs}")
print(f"Mitigated error-bar: \n{results.data.stds}")
noisy_results = results.metadata["noisy_results"]
print(f"Noisy expectation values: \n{noisy_results.evs}")
print(f"Noisy error-bar: \n{noisy_results.stds}")
print(f"Total QPU time: \n {results.metadata['total_qpu_time']}")
print(
    f"Gates fidelity measured during the experiment: \n {results.metadata['gate_fidelities']}"
)
print(
    f"Total shots / mitigation shots: \n {results.metadata['total_shots']} / {results.metadata['mitigation_shots']}"
)
print("Transpiled circuits:")
for i, circuit in enumerate(results.metadata["transpiled_circs"]):
    print(f"Circuit {i}:")
    print(f"  Circuit: \n {circuit['circuit']}")
    print(f"  Qubit mapping: \n {circuit['qubit_map']}")
    print(f"  Measurement bases: \n {circuit['num_measurement_bases']}")

ดึงข้อความ error

หาก workload status เป็น ERROR ให้ใช้ job.result() เพื่อดึงข้อความ error ดังนี้:

print(sample_job.result())

PrimitiveResult([PubResult(data=DataBin(), metadata={'time_estimation_sec': 12600})], metadata={})

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

ทีม support ของ Qedma พร้อมช่วยเหลือ หากเจอปัญหาหรือมีคำถามเกี่ยวกับการใช้ QESEM Qiskit Function โปรดอย่าลังเลที่จะติดต่อ เจ้าหน้าที่ support ที่มีความรู้และเป็นมิตรพร้อมช่วยเหลือกับข้อกังวลทางเทคนิคหรือคำถามที่คุณอาจมี

ส่ง email มาที่ support@qedma.com เพื่อขอความช่วยเหลือ โปรดรวมรายละเอียดให้มากที่สุดเท่าที่เป็นไปได้เกี่ยวกับปัญหาที่คุณประสบเพื่อช่วยให้เราตอบสนองได้รวดเร็วและแม่นยำ คุณยังติดต่อตัวแทน Qedma POC ที่ดูแลของคุณทาง email หรือโทรศัพท์ได้ด้วย

เพื่อช่วยให้เราช่วยเหลือได้มีประสิทธิภาพมากขึ้น โปรดให้ข้อมูลต่อไปนี้เมื่อติดต่อ:

• คำอธิบายโดยละเอียดของปัญหา
• Job ID
• ข้อความ error หรือ codes ที่เกี่ยวข้อง

เรามุ่งมั่นให้ support ที่รวดเร็วและมีประสิทธิภาพเพื่อให้แน่ใจว่าคุณจะมีประสบการณ์ที่ดีที่สุดกับ Qiskit Function ของเรา

เรามองหาวิธีปรับปรุงผลิตภัณฑ์อยู่เสมอและยินดีรับข้อเสนอแนะของคุณ หากมีแนวคิดว่าเราจะปรับปรุงบริการหรือฟีเจอร์ที่ต้องการเห็นได้อย่างไร โปรดส่งความคิดของคุณมาที่ support@qedma.com

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

คำแนะนำ

• ขอสิทธิ์เข้าถึง Qedma QESEM
• ทบทวน Bauman, N. P., et al. (2025). Coupled Cluster Downfolding Theory in Simulations of Chemical Systems on Quantum Hardware. arXiv preprint arXiv:2507.01199.
• ทบทวน Aharonov, D., et al. (2025). Reliable high-accuracy error mitigation for utility-scale quantum circuits. arXiv preprint arXiv:2508.10997.