דלג לתוכן הראשי
פרויקט זה בשלב בטא. מצאת באג? פתח issue ב-GitHub. יש שאלה או רעיון? שאל ב-Discussions — נשמח לשמוע ממך!
מה איכות התרגום בדף זה?

מצב בדיקה מקומי

Package versions

הקוד בדף זה פותח תוך שימוש בדרישות הבאות. אנחנו ממליצים להשתמש בגרסאות אלו או בגרסאות חדשות יותר.

qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0
qiskit-aer~=0.17

השתמש במצב בדיקה מקומי (זמין עם qiskit-ibm-runtime גרסה v0.22.0 ומעלה) כדי לבדוק תוכניות לפני כיוונון עדין שלהן ושליחתן לחומרה קוונטית אמיתית. לאחר שתאמת את התוכנית שלך במצב בדיקה מקומי, כל מה שעליך לשנות הוא שם ה-Backend כדי להריץ אותה על QPU.

הערה

תמיכה במצב מקומי עבור הפרימיטיב Executor נוספה ב-qiskit-ibm-runtime v0.50.0.

כדי להשתמש במצב בדיקה מקומי, ציין אחד מה-fake backends מ-qiskit_ibm_runtime.fake_provider או ציין Qiskit Aer backend בעת יצירת IBM Quantum® primitive או session.

  • Fake backends: ה-fake backends ב-qiskit_ibm_runtime.fake_provider מחקים את ההתנהגות של QPUs של IBM® באמצעות תמונות מצב של QPU. תמונות המצב מכילות מידע חשוב על ה-QPU, כגון מפת הצימוד, שערי הבסיס ומאפייני הקיוביטים, שהם שימושיים לבדיקת ה-Transpiler וביצוע סימולציות עם רעש של ה-QPU. מודל הרעש מתמונת המצב מיושם אוטומטית במהלך הסימולציה.

  • סימולטור Aer: סימולטורים מ-Qiskit Aer מספקים סימולציה בעלת ביצועים גבוהים יותר שיכולה לטפל ב-Circuit גדולים יותר ו-מודלי רעש מותאמים אישית. מגוון אפשרויות של שיטות סימולציה זמינות כאשר אתה משתמש ב-AerSimulator במצב בדיקה מקומי. ראה את דוגמת מצב סימולציית Clifford, המדגימה כיצד לסמלץ ביעילות Circuit מסוג Clifford עם מספר גדול של קיוביטים.

    רשימת שיטות הסימולציה הזמינות מ-Qiskit Aer

    ראה את תיעוד AerSimulator למידע נוסף.

    • "automatic": שיטת הסימולציה המוגדרת כברירת מחדל. בחירה אוטומטית של שיטת הסימולציה בהתאם ל-Circuit ומודל הרעש.

    • "statevector": סימולציה צפופה של וקטור מצב שיכולה לדגום תוצאות מדידה מ-Circuit אידיאליים עם כל המדידות בסוף ה-Circuit. עבור סימולציות עם רעש, כל shot דוגמת Circuit עם רעש נבחר אקראית ממודל הרעש.

    • "density_matrix": סימולציה של מטריצת צפיפות שיכולה לדגום תוצאות מדידה מ-Circuit עם רעש עם כל המדידות בסוף ה-Circuit.

    • "stabilizer": סימולטור יעיל של מצב stabilizer מסוג Clifford שיכול לסמלץ Circuit מסוג Clifford עם רעש אם כל השגיאות במודל הרעש הן גם שגיאות Clifford.

    • "extended_stabilizer": סימולטור קירובי ל-Circuit מסוג Clifford + T המבוסס על פירוק המצב למצב stabilizer מדורג. מספר האיברים גדל עם מספר השערים שאינם Clifford (שערי T).

    • "matrix_product_state": סימולטור וקטור מצב מבוסס-רשת-טנסורים המשתמש בייצוג Matrix Product State (MPS) עבור המצב. ניתן לבצע זאת עם או בלי קיצוץ ממדי קשר MPS, בהתאם לאפשרויות הסימולטור. ברירת המחדל היא ללא קיצוץ.

    • "unitary": סימולציה צפופה של מטריצה יוניטרית של Circuit אידיאלי. שיטה זו מסמלצת את המטריצה היוניטרית של ה-Circuit עצמו, ולא את האבולוציה של מצב קוונטי התחלתי. שיטה זו יכולה לסמלץ שערים בלבד; היא אינה תומכת במדידה, איפוס או רעש.

    • "superop": סימולציה צפופה של מטריצת superoperator של Circuit אידיאלי או עם רעש. שיטה זו מסמלצת את מטריצת ה-superoperator של ה-Circuit עצמו, ולא את האבולוציה של מצב קוונטי התחלתי. שיטה זו יכולה לסמלץ שערים ואיפוסים אידיאליים ועם רעש, אך אינה תומכת במדידות.

    • "tensor_network": סימולציה מבוססת-רשת-טנסורים התומכת גם בוקטור מצב וגם במטריצת צפיפות. כרגע זמינה רק עבור GPU ומואצת באמצעות ממשקי ה-API של cuQuantum cuTensorNet.

הערות
  • אפשר לציין את כל אפשרויות IBM Quantum Compute במצב בדיקה מקומי. עם ה-Sampler וה-Estimator בצד הלקוח (שהוצגו ב-qiskit-ibm-runtime v0.50.0), אפשרויות דיכוי והקלה על שגיאות ממומשות באופן מקומי, כך שאפשר לבדוק שיטות הקלה שונות באופן מקומי לפני שמקדישים זמן QPU. ראו בדיקת הקלה על שגיאות באופן מקומי לדוגמה.

בעבר, סימולטורים מקומיים התעלמו מכל האפשרויות מלבד shots עם הפרימיטיבים הישנים (בצד השרת), כי העיבוד הזה התבצע רק בשרת.

  • מומלץ להתקין את Qiskit Aer לפני השימוש ב-fake backends או סימולטורי Aer על-ידי הרצת pip install qiskit-aer. ה-fake backends משתמשים בסימולטורי Aer מאחורי הקלעים, אם הם זמינים, כדי לנצל את ביצועיהם.

דוגמת Fake backends​

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

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_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")
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using FakeManilaV2
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)

# You can use a fixed seed to get fixed results.
options = {"simulator": {"seed_simulator": 42}}
sampler = Sampler(mode=fake_manila, options=options)

result = sampler.run([isa_qc]).result()

דוגמאות AerSimulator​

דוגמה עם sessions, ללא רעש:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import Session

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the Sampler job locally using AerSimulator.
# Session syntax is supported but ignored because local mode doesn't support sessions.
aer_sim = AerSimulator()
pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
with Session(backend=aer_sim) as session:
    sampler = Sampler(mode=session)
    result = sampler.run([isa_qc]).result()

לסימולציה עם רעש, ציין QPU (חומרה קוונטית) והגש אותו ל-Aer. Aer בונה מודל רעש המבוסס על נתוני הכיול של אותו QPU, ויוצר Aer backend עם מודל זה. אם תרצה, תוכל לבנות מודל רעש.

זהירות

QPU יכול להיות מושפע מסוגים שונים של רעש. מודל הרעש של Qiskit Aer המשמש כאן מסמלץ רק חלק מהם ולכן סביר שיהיה פחות חמור מהרעש ב-QPU אמיתי.

לפרטים על אילו שגיאות נכללות בעת אתחול מודל רעש מ-QPU, ראה את הפניית ה-API של Aer ל-NoiseModel.

דוגמה עם רעש:

from qiskit_aer import AerSimulator
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

service = QiskitRuntimeService()

# Specify a QPU to use for the noise model
real_backend = service.least_busy(operational=True, simulator=False)
aer = AerSimulator.from_backend(real_backend)

# Run the Sampler job locally using AerSimulator.
pm = generate_preset_pass_manager(backend=aer, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer)
result = sampler.run([isa_qc]).result()

סימולציית Clifford​

מכיוון ש-Circuit מסוג Clifford ניתן לסמלץ ביעילות עם תוצאות שניתן לאמת, סימולציית Clifford היא כלי שימושי מאוד. לדוגמה מעמיקה, ראה סימולציה יעילה של Circuit מסוג stabilizer עם Qiskit Aer primitives.

דוגמה:

import numpy as np
from qiskit.circuit.library import efficient_su2

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler

n_qubits = 500  # <---- note this uses 500 qubits!
circuit = efficient_su2(n_qubits)
circuit.measure_all()

rng = np.random.default_rng(1234)
params = rng.choice(
    [0, np.pi / 2, np.pi, 3 * np.pi / 2],
    size=circuit.num_parameters,
)

# Tell Aer to use the stabilizer (Clifford) simulation method
aer_sim = AerSimulator(method="stabilizer")

pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(mode=aer_sim)
result = sampler.run([isa_qc]).result()

בדיקת הקלה על שגיאות באופן מקומי​

עם ה-Sampler וה-Estimator בצד הלקוח (שהוצגו ב-qiskit-ibm-runtime v0.50.0), דיכוי והקלה על שגיאות מתבצעים בצד הלקוח ולא בצד השרת. כתוצאה מכך, האפשרויות האלה נכנסות כעת לתוקף במצב בדיקה מקומי, כך שאפשר להתנסות בשיטות הקלה שונות על fake backend לפני שמקדישים זמן QPU.

הערה

עם הפרימיטיבים הישנים בצד השרת, הגדרת אפשרות כמו resilience.measure_mitigation על סימולטור מקומי לא השפיעה, כי עיבוד ההקלה התבצע רק בשרת. הפרימיטיבים בצד הלקוח מיישמים את העיבוד הזה באופן מקומי.

שיקולי תקורה של זיכרון וזמן ריצה

עלות הסימולציה המקומית עם רעש גדלה אקספוננציאלית עם מספר הקיוביטים, ורוב המחשבים הניידים אינם יכולים לסמלץ יותר מכ-32 קיוביטים. מכיוון ששיטות דיכוי והקלה על שגיאות רצות כעת באופן מקומי, הן מוסיפות תקורה נוספת של זיכרון וזמן ריצה מעבר לסימולציית הבסיס. כדי לשמור על בדיקה מקומית ברת-ביצוע, השתמשו באחת מהאפשרויות הבאות:

  • fake backend קטן (כגון FakeManilaV2, שבו נשתמש להלן).

  • סימולטור ללא רעש.

  • סימולציית Clifford, שניתנת להרחבה למספר גדול של Qubit-ים.

הדוגמה הבאה מפעילה הקלה על שגיאות מדידה עם Estimator ומריצה אותה על fake backend. האפשרות measure_mitigation = True מיושמת כעת על ה-Circuit-ים שלכם באופן מקומי.

from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager

# Legacy server-side primitive before qiskit-ibm-runtime v0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime v0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

observable = SparsePauliOp("ZZ")

# Transpile the circuit and observable for the fake backend
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)
isa_observable = observable.apply_layout(isa_qc.layout)

# Run the Estimator job locally using FakeManilaV2
estimator = Estimator(mode=fake_manila)

# With the client-side Estimator, this option takes effect locally
estimator.options.resilience.measure_mitigation = True

result = estimator.run([(isa_qc, isa_observable)]).result()

השלבים הבאים​

המלצות
מקור: תיעוד IBM Quantum — עודכן בתאריך 30 בספט׳ 2026
גרסה באנגלית ב-doQumentation — עודכן בתאריך 30 בספט׳ 2026
בעיה באתר או בתרגום?בעיה בתוכן? ערוך ב-IBM Quantum docs