דלג לתוכן הראשי

התחלת עבודה עם Qiskit Functions

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-catalog qiskit-ibm-runtime
# This cell is hidden from users
# It gets these details programmatically so we can test this notebook
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.circuit.random import random_circuit
from qiskit_ibm_catalog import QiskitFunctionsCatalog

service = QiskitRuntimeService()
instance = service.active_account()["instance"]
backend_name = service.least_busy().name
catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
qesem_function = catalog.load("qedma/qesem")
circuit = random_circuit(num_qubits=2, depth=2, seed=42)
observable = "Z" * circuit.num_qubits

משתמשי תוכנית Premium, Flex, ו-On-Prem (דרך IBM Quantum Platform API) יכולים להתחיל להשתמש ב-IBM Qiskit Functions בחינם, או לרכוש רישיון מאחד מהשותפים שתרמו פונקציה לקטלוג.

בקש ניסיון חינם עבור Qiskit Functions של צד שלישי​

כדי לבקש ניסיון חינם, נווט אל קטלוג Qiskit Functions, ועיין בפאנל הפרטים. לחץ על Request a free trial ומלא את המידע הנדרש על ידי שותף ה-Functions, כולל ה-AccessGroupId של IBM Cloud:

  1. נווט אל IBM Cloud IAM.

  2. אמת זכאות.

    • החלף את החשבון שלך בסרגל התפריט בכותרת לחשבון בפורמט הבא: XXXXXXX - [Organization Name]

    • ודא שהארגון זהה לזה המשויך לחשבון ה-Premium שלך.

    • אם אתה רואה "[Your Name]'s Account", אתה משתמש בחשבון ה_אישי_ שלך, שאינו זכאי לגישת Premium.

  3. מצא את מזהה קבוצת הגישה שלך.

    • לחץ על שם קבוצה.

    • לחץ על Details.

    • העתק את מזהה קבוצת הגישה. הוא צריך להתחיל ב-AccessGroup-.

התקן את לקוח קטלוג Qiskit Functions​

  1. כדי להתחיל להשתמש ב-Qiskit Functions, התקן את לקוח קטלוג IBM Qiskit Functions:

    pip install qiskit-ibm-catalog

  2. שלוף את מפתח ה-API שלך מלוח הבקרה של IBM Quantum Platform, והפעל את סביבת ה-Python הווירטואלית שלך. ראה את הוראות ההתקנה אם עדיין אין לך סביבה וירטואלית מוגדרת.

    If you are working in a trusted Python environment (such as on a personal laptop or workstation), use the save_account() method to save your credentials locally. (Skip to the next step if you are not using a trusted environment, such as a shared or public computer, to authenticate to IBM Quantum Platform.)

    המופע (instance) שאיתו אתה מזדהה חייב לתמוך בגישת Qiskit Functions מופעלת. כדי להגדיר זאת במופע קיים, ראה הגדרת גישת Qiskit Functions במופע.

    כדי להשתמש ב-save_account(), הרץ python במעטפת שלך, ואז הזן את הבא:

    from qiskit_ibm_catalog import QiskitFunctionsCatalog

    QiskitFunctionsCatalog.save_account(channel="ibm_quantum_platform", token="<your-token>", instance="<instance-crn>")

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

    from qiskit_ibm_catalog import QiskitFunctionsCatalog
    catalog = QiskitFunctionsCatalog()

    לדוגמה:

# Load saved credentials
from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

Avoid executing code on an untrusted machine or an external cloud Python environment to minimize security risks. If you must use an untrusted environment (on, for example, a public computer), change your API key after each use by deleting it on the IBM Cloud API keys page to reduce risk. Learn more in the Managing user API keys topic. To initialize the service in this situation, use this code:

from qiskit_ibm_catalog import QiskitFunctionsCatalog

# After using the following code, delete your API key on the
# IBM Quantum Platform home dashboard
catalog = QiskitFunctionsCatalog(token="<YOUR_API_KEY>") # Use the 44-character
# API_KEY you created and saved from the IBM Quantum Platform Home dashboard
הגן על מפתח ה-API שלך

לעולם אל תכלול את המפתח שלך בקוד מקור, בסקריפטים של Python, או בקבצי מחברת. כאשר משתפים קוד עם אחרים, ודא שמפתח ה-API שלך אינו מוטמע ישירות בתוך סקריפט ה-Python. במקום זאת, שתף את הסקריפט ללא המפתח וספק הוראות להגדרתו בצורה מאובטחת.

אם בטעות שיתפת את המפתח שלך עם מישהו או כללת אותו במערכת בקרת גרסאות כמו Git, בטל מיד את המפתח שלך על ידי מחיקתו בדף מפתחות API של IBM Cloud כדי להפחית סיכון. למד עוד בנושא ניהול מפתחות API של משתמש.

רשום את הפונקציות שיש לך גישה אליהן​

לאחר האימות, תוכל לרשום את הפונקציות מקטלוג Qiskit Functions שיש לך גישה אליהן:

catalog.list()
[QiskitFunction(qunova/hivqe-chemistry),
 QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),
 QiskitFunction(algorithmiq/tem),
 QiskitFunction(qedma/qesem),
 QiskitFunction(multiverse/singularity),
 QiskitFunction(ibm/circuit-function),
 QiskitFunction(q-ctrl/optimization-solver),
 QiskitFunction(colibritd/quick-pde),
 QiskitFunction(q-ctrl/performance-management),
 QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]

הרץ פונקציות מופעלות​

לאחר יצירת מופע של אובייקט קטלוג, תוכל לבחור פונקציה באמצעות catalog.load("<provider/function-name>"):

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

לכל Qiskit Function יש קלטים, אפשרויות, ופלטים מותאמים אישית. בדוק את דפי התיעוד הספציפיים עבור הפונקציה שברצונך להריץ למידע נוסף. כברירת מחדל, כל המשתמשים יכולים להריץ רק משימת פונקציה אחת בכל פעם:

from qiskit.quantum_info import SparsePauliOp

avg_magnetization = SparsePauliOp.from_sparse_list(
    [("Z", [q], 1 / 5) for q in range(5)], num_qubits=5
)

job = qesem_function.run(
    pubs=[(circuit, [avg_magnetization, observable])],
    backend_name=backend_name,  # example: "ibm_fez"
    # options = {
    #     "estimate_time_only": "empirical",
    #     "default_precision": 0.2,  # Default precision is applied to all pubs that don't have a precision specified, see API reference for more details
    #     "max_execution_time": 3600,  # You can specify a maximum QPU time in seconds, see API reference for more details
    #     "transpilation_level": "standard",  # "minimal_with_layout_opt" for minimal transpilation, see API reference for more details
    #     "parallel_execution": True,  # True for parallel execution, see API reference for more details
    # },
)
job.job_id
'7f08c9d5-471b-4da2-92e7-4f2cb94c23a8'
טיפ

run() בודק את הקיבולת הנותרת שלך ואת הגישה ל-Backend לפני שהוא שולח את המשימה. אם למופע שלך נגמרה הקיבולת, או שה-Backend שציינת אינו נגיש, run() מעלה שגיאה מיד במקום להשאיר את המשימה להיכשל בתור. כאשר הקיבולת נמוכה, run() מפיק אזהרה. העבר suppress_low_usage_warning=True כדי להשתיק אותה.

job = qesem_function.run(
    pubs=[(circuit, [avg_magnetization, observable])],
    backend_name=backend_name,  # example: "ibm_fez"
    suppress_low_usage_warning=True,
    # options = {
    #     "estimate_time_only": "empirical",
    #     "default_precision": 0.2,  # Default precision is applied to all pubs that don't have a precision specified, see API reference for more details
    #     "max_execution_time": 3600,  # You can specify a maximum QPU time in seconds, see API reference for more details
    #     "transpilation_level": "standard",  # "minimal_with_layout_opt" for minimal transpilation, see API reference for more details
    #     "parallel_execution": True,  # True for parallel execution, see API reference for more details
    # },
)

בדוק סטטוס משימה​

עם ה-job_id של Qiskit Function שלך, תוכל לבדוק את הסטטוס של משימות רצות. זה כולל את הסטטוסים הבאים:

  • QUEUED: התוכנית המרוחקת נמצאת בתור של Qiskit Function. עדיפות התור מבוססת על כמה השתמשת ב-Qiskit Functions.

  • INITIALIZING: התוכנית המרוחקת מתחילה; זה כולל הקמת סביבה מרוחקת והתקנת תלויות.

  • RUNNING: התוכנית רצה. זה כולל גם מספר סטטוסים מפורטים יותר אם נתמכים על ידי פונקציות ספציפיות.

    • RUNNING: MAPPING: הפונקציה כרגע ממפה את הקלטים הקלאסיים שלך לקלטים קוונטיים.

    • RUNNING: OPTIMIZING_FOR_HARDWARE: הפונקציה מבצעת אופטימיזציה עבור ה-QPU שנבחר. זה יכול לכלול תרגום מעגלים, אפיון QPU, backpropagation של אופרטורים נצפים (observables), וכן הלאה.

    • RUNNING: WAITING_FOR_QPU: הפונקציה שלחה משימה ל-IBM Quantum Compute Service, וממתינה בתור.

    • RUNNING: EXECUTING_QPU: לפונקציה יש משימת Quantum Compute פעילה.

    • RUNNING: POST_PROCESSING: הפונקציה מבצעת עיבוד־לאחר (post-processing) של התוצאות, שיכול לכלול הפחתת שגיאות, מיפוי תוצאות קוונטיות לקלאסיות, וכן הלאה.

  • DONE: התוכנית הושלמה, ותוכל לשלוף נתוני תוצאה עם job.result().

  • ERROR: התוכנית הפסיקה לרוץ עקב בעיה. השתמש ב-job.result() כדי לקבל את הודעת השגיאה.

  • CANCELED: התוכנית בוטלה על ידי משתמש, השירות, או השרת.

job.status()
'QUEUED'

שלוף תוצאות​

לאחר שתוכנית היא DONE, תוכל להשתמש ב-job.result() כדי לשלוף את התוצאה. פורמט הפלט הזה משתנה בכל פונקציה, אז הקפד לעקוב אחר התיעוד הספציפי:

result = job.result()
print(result)
PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(), dtype=float64>), stds=np.ndarray(<shape=(), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(), dtype=float64>)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': True, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})

אתה יכול גם לבטל משימה בכל זמן:

job.cancel()
'Job has been stopped.'

גישה למשימות Quantum Compute המשויכות​

Qiskit Function יכולה לשלוח משימת Quantum Compute אחת או יותר ל-QPU בזמן ריצתה. כדי לשלוף את המזהים של משימות ה-runtime האלה, השתמש ב-job.runtime_jobs(). תוכל להשתמש במזהים האלה כדי לשלוף את אובייקטי משימת ה-runtime ממופע QiskitRuntimeService, או כדי למצוא את עומסי העבודה בלוח הבקרה של IBM Quantum® Platform.

runtime_job_ids = job.runtime_jobs()
runtime_job_ids

אם פונקציה מקבצת את משימות ה-runtime שלה ל-sessions או batches, השתמש ב-job.runtime_sessions() כדי לרשום את מזהי ה-session. העבר מזהה session אחד ל-job.runtime_jobs() כדי להחזיר רק את משימות ה-runtime באותו session:

sessions = job.runtime_sessions()
if sessions:
    session_runtime_jobs = job.runtime_jobs(runtime_session=sessions[0])
    print(session_runtime_jobs)
else:
    print("No runtime sessions for this job.")
הערה

הרשימה המוחזרת יכולה להיות ריקה. פונקציה מדווחת על ה-jobs שלה ב-runtime רק כאשר היא שולחת אותם דרך שירות ה-runtime שהפונקציה מקבלת בזמן ריצה, וחלק מהפונקציות לא שולחות jobs של runtime באופן ישיר.

צפה ביומני משימה​

השתמש ב-job.logs() כדי לשלוף את פלט היומן שפונקציה מפיקה בזמן ריצתה. יומנים שימושיים למעקב אחר התקדמות ולאיתור באגים במשימה שמסתיימת במצב ERROR.

print(job.logs().splitlines())

עבור משימה ארוכת ריצה שמפיקה הרבה שורות יומן, השתמש ב-job.filtered_logs() כדי להחזיר רק את השורות שאתה רוצה. העבר ביטוי רגולרי ל-include כדי לשמור שורות תואמות, או ל-exclude כדי להשמיט שורות תואמות:

print(job.filtered_logs(include="iteration"))

רשום משימות Qiskit Functions שהורצו בעבר​

תוכל להשתמש ב-jobs() כדי לרשום את כל המשימות שנשלחו ל-Qiskit Functions:

old_jobs = catalog.jobs()
old_jobs
[<Job | f6c29f49-4d5f-4fff-aca6-2e9a115b9763>,
 <Job | 7f08c9d5-471b-4da2-92e7-4f2cb94c23a8>,
 <Job | 62fe9176-d1e5-467e-b2bd-7a3f3c7be4e5>,
 <Job | af525b2e-16b1-45a1-80bb-dbd94ce30258>,
 <Job | b95a7a57-c1ad-4958-b7ac-953e4e1ee824>,
 <Job | 7bfa33da-0f17-4e67-84b6-f556f7eeb436>,
 <Job | ca46c191-9eb9-4de6-bfa7-b60d7eb29b5e>,
 <Job | 6ac0ba93-3831-43fb-9fb9-760da2225e06>,
 <Job | f0e38071-060d-47e8-988d-9cc1f69358e3>,
 <Job | 629cf110-e490-4675-8a07-f6d298d166b0>]

כדי לצמצם את התוצאות, העבר מסננים. סנן לפי פונקציה עם function, לפי סטטוס עם status, ולפי תאריך שליחה עם created_after. דפדף בין תוצאות עם limit ו-offset:

recent_errors = catalog.jobs(
    function=qesem_function,
    status="ERROR",
    created_after="2024-01-01T00:00:00Z",
    limit=5,
)
recent_errors

אם כבר יש לך את מזהה המשימה עבור משימה מסוימת, תוכל לשלוף את המשימה עם catalog.job():

# First, get the most recent job that has been executed.
latest_job = old_jobs[0]

# We can also get that same job with `catalog.job`
job_by_id = catalog.job(latest_job.job_id)

# Verify that the job is the same using both retrieval methods.
assert job_by_id.job_id == latest_job.job_id

# Print the job_id for this job.
print(job_by_id.job_id)
f6c29f49-4d5f-4fff-aca6-2e9a115b9763

שלוף הודעות שגיאה​

אם סטטוס תוכנית הוא ERROR, השתמש ב-job.error_message() כדי לשלוף את הודעת השגיאה כך:

job.error_message()
qiskit.exceptions.QiskitError: 'Workflow execution failed -- https://docs.quantum.ibm.com/errors#9999'

צעדים הבאים​

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