Lumaktaw sa pangunahing nilalaman

Magsimula sa 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

Ang mga gumagamit ng Premium, Flex, at On-Prem (sa pamamagitan ng IBM Quantum Platform API) Plan ay maaaring magsimula sa IBM Qiskit Functions nang libre, o maaaring kumuha ng lisensya mula sa isa sa mga partner na nag-ambag ng function sa catalog.

Humiling ng libreng trial para sa third-party na Qiskit Functions​

Upang humiling ng libreng trial, pumunta sa Qiskit Functions Catalog, at galugarin ang details panel. I-click ang Request a free trial at punan ang impormasyong kinakailangan ng Functions partner, kabilang ang IBM Cloud AccessGroupId:

  1. Pumunta sa IBM Cloud IAM.

  2. Tiyakin ang eligibility.

    • I-switch ang iyong account sa menu bar sa header patungo sa isa na may sumusunod na format: XXXXXXX - [Organization Name]

    • Tiyakin na ang organisasyon ay pareho sa nauugnay sa iyong Premium account.

    • Kung makita mo ang "[Your Name]'s Account", ginagamit mo ang iyong personal na account, na hindi eligible para sa premium access.

  3. Hanapin ang iyong access group ID.

    • I-click ang isang group name.

    • I-click ang Details.

    • Kopyahin ang access group ID. Dapat itong magsimula sa AccessGroup-.

I-install ang Qiskit Functions Catalog client​

  1. Upang magsimulang gamitin ang Qiskit Functions, i-install ang IBM Qiskit Functions Catalog client:

    pip install qiskit-ibm-catalog

  2. Kunin ang iyong API key mula sa IBM Quantum Platform dashboard, at i-activate ang iyong Python virtual environment. Tingnan ang installation instructions kung wala ka pang naka-set up na virtual environment.

    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.)

    Ang instance kung saan ka nag-a-authenticate ay dapat may pinaganang access sa Qiskit Functions. Para i-configure ito sa isang umiiral nang instance, tingnan ang I-configure ang access sa Qiskit Functions sa isang instance.

    Upang gamitin ang save_account(), patakbuhin ang python sa iyong shell, pagkatapos ay ilagay ang sumusunod:

    from qiskit_ibm_catalog import QiskitFunctionsCatalog

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

    I-type ang exit(). Mula ngayon, sa tuwing kailangan mong mag-authenticate sa serbisyo, maaari mong i-load ang iyong mga credential gamit ang sumusunod:

    from qiskit_ibm_catalog import QiskitFunctionsCatalog
    catalog = QiskitFunctionsCatalog()

    Halimbawa:

# 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
Protektahan ang iyong API key

Huwag kailanman isama ang iyong key sa source code, Python scripts, o notebook files. Kapag nagbabahagi ng code sa iba, tiyakin na hindi naka-embed ang iyong API key nang direkta sa Python script. Sa halip, ibahagi ang script nang walang key at magbigay ng mga tagubilin para sa ligtas na pag-set up nito.

Kung aksidenteng naibahagi mo ang iyong key sa iba o naisama ito sa version control tulad ng Git, agad na i-revoke ang iyong key sa pamamagitan ng pagtanggal nito sa IBM Cloud API keys page upang mabawasan ang panganib. Alamin pa sa Managing user API keys topic.

Ilista ang mga function na maaari mong ma-access​

Pagkatapos mong mag-authenticate, maaari mong ilista ang mga function mula sa Qiskit Functions Catalog na maaari mong ma-access:

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)]

Patakbuhin ang mga naka-enable na function​

Matapos ma-instantiate ang isang catalog object, maaari kang pumili ng function gamit ang catalog.load("<provider/function-name>"):

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

Ang bawat Qiskit Function ay may custom na inputs, options, at outputs. Tingnan ang partikular na mga documentation page para sa function na gusto mong patakbuhin para sa karagdagang impormasyon. Bilang default, maaari lamang magpatakbo ang lahat ng gumagamit ng isang function job sa isang pagkakataon:

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'
tip

Tinitsek ng run() ang natitira mong capacity at backend access bago i-submit ang job. Kung wala nang capacity ang iyong instance, o hindi ma-access ang backend na pinangalanan mo, agad na magpapataas ang run() ng error sa halip na hayaang mabigo ang job sa queue. Kapag mababa ang capacity, maglalabas ang run() ng warning. Ipasa ang suppress_low_usage_warning=True upang patahimikin ito.

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
    # },
)

Tsekin ang status ng job​

Gamit ang iyong Qiskit Function na job_id, maaari mong tsekin ang status ng mga tumatakbong job. Kasama dito ang sumusunod na mga status:

  • QUEUED: Nasa queue ng Qiskit Function ang remote program. Ang priyoridad sa queue ay nakabatay sa kung gaano mo nagamit ang Qiskit Functions.

  • INITIALIZING: Nagsisimula ang remote program; kasama dito ang pag-set up ng remote environment at pag-install ng mga dependency.

  • RUNNING: Tumatakbo ang programa. Kasama rin dito ang ilang mas detalyadong status kung sinusuportahan ng mga partikular na function.

    • RUNNING: MAPPING: Kasalukuyang ino-mapa ng function ang iyong classical inputs patungo sa quantum inputs.

    • RUNNING: OPTIMIZING_FOR_HARDWARE: Ino-optimize ng function para sa napiling QPU. Maaaring kabilang dito ang circuit transpilation, QPU characterization, observable backpropagation, at iba pa.

    • RUNNING: WAITING_FOR_QPU: Nag-submit na ng job ang function sa IBM Quantum Compute Service, at naghihintay sa queue.

    • RUNNING: EXECUTING_QPU: May aktibong Quantum Compute job ang function.

    • RUNNING: POST_PROCESSING: Nagpo-post-process ng mga resulta ang function, na maaaring kabilang ang error mitigation, pag-mapa ng quantum results patungo sa classical, at iba pa.

  • DONE: Kumpleto na ang programa, at maaari mong kunin ang result data gamit ang job.result().

  • ERROR: Huminto sa pagtakbo ang programa dahil sa isang problema. Gamitin ang job.result() upang makuha ang error message.

  • CANCELED: Kinansela ang programa ng isang gumagamit, ng serbisyo, o ng server.

job.status()
'QUEUED'

Kunin ang mga resulta​

Matapos maging DONE ang isang programa, maaari mong gamitin ang job.result() upang kunin ang resulta. Nag-iiba ang output format na ito sa bawat function, kaya siguraduhing sundan ang partikular na dokumentasyon:

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})

Maaari mo ring kanselahin ang isang job anumang oras:

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

I-access ang mga kaugnay na Quantum Compute job​

Maaaring mag-submit ang isang Qiskit Function ng isa o higit pang Quantum Compute job sa isang QPU habang ito ay tumatakbo. Upang kunin ang mga ID ng mga runtime job na iyon, gamitin ang job.runtime_jobs(). Maaari mong gamitin ang mga ID na ito upang kunin ang mga runtime job object mula sa isang QiskitRuntimeService instance, o upang hanapin ang mga workload sa IBM Quantum® Platform dashboard.

runtime_job_ids = job.runtime_jobs()
runtime_job_ids

Kung pinagsasama-sama ng isang function ang mga runtime job nito sa mga session o batch, gamitin ang job.runtime_sessions() upang ilista ang mga session ID. Ipasa ang isang session ID sa job.runtime_jobs() upang ibalik lamang ang mga runtime job sa session na iyon:

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.")
tala

Maaaring walang laman ang naibalik na listahan. Iniuulat lang ng function ang mga runtime job nito kapag isinumite niya ang mga ito sa pamamagitan ng runtime service na natatanggap ng function sa run time, at may ilang function na hindi direktang nagsusumite ng mga runtime job.

Tingnan ang mga log ng job​

Gamitin ang job.logs() upang kunin ang log output na ginagawa ng isang function habang ito ay tumatakbo. Kapaki-pakinabang ang mga log para sa pagsubaybay ng progreso at pag-debug ng job na nagtatapos sa ERROR state.

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

Para sa mahabang tumatakbong job na gumagawa ng maraming log line, gamitin ang job.filtered_logs() upang ibalik lamang ang mga linyang gusto mo. Ipasa ang isang regular expression sa include upang panatilihin ang mga tumutugmang linya, o sa exclude upang tanggalin ang mga tumutugmang linya:

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

Ilista ang mga naunang tumakbong Qiskit Functions job​

Maaari mong gamitin ang jobs() upang ilista ang lahat ng job na na-submit sa 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>]

Upang paliitin ang mga resulta, magpasa ng mga filter. Mag-filter ayon sa function gamit ang function, ayon sa status gamit ang status, at ayon sa petsa ng pag-submit gamit ang created_after. Mag-page-through ng mga resulta gamit ang limit at offset:

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

Kung mayroon ka nang job ID para sa isang partikular na job, maaari mong kunin ang job gamit ang 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

Kunin ang mga error message​

Kung ang status ng isang programa ay ERROR, gamitin ang job.error_message() upang kunin ang error message tulad ng sumusunod:

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

Mga susunod na hakbang​

Mga Rekomendasyon
Pinagmulan: IBM Quantum docs — na-update noong Set 3, 2026
Bersyong Ingles sa doQumentation — na-update noong Set 3, 2026
Isyu sa site o pagsasalin?Isyu sa nilalaman? I-edit sa IBM Quantum docs