Přeskočit na hlavní obsah

Začínáme s 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

Uživatelé plánů Premium, Flex a On-Prem (přes IBM Quantum Platform API) mohou začít s IBM Qiskit Functions zdarma, nebo si mohou pořídit licenci od jednoho z partnerů, kteří do katalogu přispěli funkcí.

Žádost o bezplatnou zkušební verzi funkcí Qiskit Functions třetích stran​

Chceš-li požádat o bezplatnou zkušební verzi, přejdi do katalogu Qiskit Functions a prozkoumej panel s podrobnostmi. Klikni na Request a free trial a vyplň informace požadované partnerem pro Functions, včetně AccessGroupId z IBM Cloud:

  1. Přejdi na IBM Cloud IAM.

  2. Ověř způsobilost.

    • Přepni svůj účet v nabídce v záhlaví na účet s následujícím formátem: XXXXXXX - [Organization Name]

    • Ujisti se, že organizace je stejná jako ta, která je spojena s tvým účtem Premium.

    • Pokud vidíš „Účet uživatele [Your Name]“, používáš svůj osobní účet, který není způsobilý pro přístup Premium.

  3. Najdi ID své přístupové skupiny.

    • Klikni na název skupiny.

    • Klikni na Podrobnosti.

    • Zkopíruj ID přístupové skupiny. Mělo by začínat na AccessGroup-.

Instalace klienta katalogu Qiskit Functions​

  1. Chceš-li začít používat Qiskit Functions, nainstaluj klienta IBM Qiskit Functions Catalog:

    pip install qiskit-ibm-catalog

  2. Získej svůj API klíč z dashboardu IBM Quantum Platform a aktivuj svoje virtuální prostředí Pythonu. Pokud ještě nemáš nastavené virtuální prostředí, podívej se na pokyny k instalaci.

    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, se kterou se autentizuješ, musí mít povolený přístup k Qiskit Functions. Pro jeho konfiguraci u existující instance viz Konfigurace přístupu Qiskit Functions u instance.

    Pro použití save_account() spusť python ve svém shellu a poté zadej následující:

    from qiskit_ibm_catalog import QiskitFunctionsCatalog

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

    Zadej exit(). Od této chvíle, kdykoli se budeš potřebovat ověřit vůči službě, můžeš načíst své přihlašovací údaje pomocí následujícího:

    from qiskit_ibm_catalog import QiskitFunctionsCatalog
    catalog = QiskitFunctionsCatalog()

    Například:

# 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
Chraň svůj API klíč

Nikdy nezahrnuj svůj klíč do zdrojového kódu, Python skriptů nebo souborů notebooků. Při sdílení kódu s ostatními zajisti, aby tvůj API klíč nebyl vložen přímo do Python skriptu. Místo toho sdílej skript bez klíče a poskytni instrukce pro jeho bezpečné nastavení.

Pokud svůj klíč omylem s někým sdílíš nebo ho zahrneš do verzovacího systému jako Git, okamžitě klíč zruš tím, že ho smažeš na stránce IBM Cloud API keys, abys snížil riziko. Více se dozvíš v tématu Managing user API keys.

Seznam funkcí, ke kterým máš přístup​

Po ověření můžeš vypsat funkce z Qiskit Functions Catalog, ke kterým máš přístup:

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

Spouštění povolených funkcí​

Po vytvoření instance objektu katalogu můžeš vybrat funkci pomocí catalog.load("<provider/function-name>"):

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

Každá Qiskit Function má vlastní vstupy, možnosti a výstupy. Pro více informací zkontroluj konkrétní dokumentační stránky funkce, kterou chceš spustit. Ve výchozím nastavení mohou všichni uživatelé spustit pouze jednu úlohu funkce najednou:

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

run() zkontroluje tvoji zbývající kapacitu a přístup k backendu před odesláním úlohy. Pokud tvé instanci dochází kapacita nebo pokud pojmenovaný backend není dostupný, run() okamžitě vyvolá chybu, místo aby nechal úlohu selhat ve frontě. Když je kapacita nízká, run() vydá varování. Předej suppress_low_usage_warning=True, abys ho ztlumil.

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

Kontrola stavu úlohy​

S job_id tvé Qiskit Function můžeš zkontrolovat stav běžících úloh. To zahrnuje následující stavy:

  • QUEUED: Vzdálený program je ve frontě Qiskit Functions. Priorita fronty je založena na tom, jak moc jsi Qiskit Functions využíval.

  • INITIALIZING: Vzdálený program se spouští; to zahrnuje nastavení vzdáleného prostředí a instalaci závislostí.

  • RUNNING: Program běží. To také zahrnuje několik podrobnějších stavů, pokud jsou podporovány konkrétními funkcemi.

    • RUNNING: MAPPING: Funkce právě mapuje tvé klasické vstupy na kvantové vstupy.

    • RUNNING: OPTIMIZING_FOR_HARDWARE: Funkce optimalizuje pro vybrané QPU. To může zahrnovat transpilaci obvodu, charakterizaci QPU, zpětné šíření pozorovatelných veličin a podobně.

    • RUNNING: WAITING_FOR_QPU: Funkce odeslala úlohu do IBM Quantum Compute Service a čeká ve frontě.

    • RUNNING: EXECUTING_QPU: Funkce má aktivní úlohu Quantum Compute.

    • RUNNING: POST_PROCESSING: Funkce zpracovává výsledky, což může zahrnovat zmírnění chyb, mapování kvantových výsledků na klasické a podobně.

  • DONE: Program je dokončen a data výsledků můžeš získat pomocí job.result().

  • ERROR: Program se zastavil kvůli problému. Použij job.result() pro získání chybové zprávy.

  • CANCELED: Program byl zrušen uživatelem, službou nebo serverem.

job.status()
'QUEUED'

Získání výsledků​

Poté, co je program DONE, můžeš použít job.result() k získání výsledku. Tento formát výstupu se liší podle jednotlivých funkcí, takže se řiď konkrétní dokumentací:

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

Úlohu můžeš také kdykoli zrušit:

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

Přístup k souvisejícím úlohám Quantum Compute​

Qiskit Function může během běhu odeslat jednu nebo více úloh Quantum Compute do QPU. Pro získání ID těchto runtime úloh použij job.runtime_jobs(). Tato ID můžeš použít k získání objektů runtime úloh z instance QiskitRuntimeService, nebo k nalezení workloadů na dashboardu IBM Quantum® Platform.

runtime_job_ids = job.runtime_jobs()
runtime_job_ids

Pokud funkce seskupuje své runtime úlohy do sessions nebo batchů, použij job.runtime_sessions() k výpisu ID sessions. Předej jedno ID session funkci job.runtime_jobs(), aby vrátila pouze runtime úlohy v dané 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.")
poznámka

Vrácený seznam může být prázdný. Funkce hlásí své runtime úlohy pouze tehdy, když je odešle prostřednictvím runtime služby, kterou funkce obdrží za běhu, a některé funkce runtime úlohy neodesílají přímo.

Zobrazení logů úlohy​

Použij job.logs() k získání výstupu logů, které funkce produkuje během svého běhu. Logy jsou užitečné pro sledování průběhu a ladění úlohy, která skončí ve stavu ERROR.

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

Pro dlouho běžící úlohu, která produkuje mnoho řádků logů, použij job.filtered_logs() k vrácení pouze těch řádků, které chceš. Předej regulární výraz do include pro zachování odpovídajících řádků, nebo do exclude pro jejich vynechání:

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

Výpis dříve spuštěných úloh Qiskit Functions​

Můžeš použít jobs() k výpisu všech úloh odeslaných do 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>]

Pro zúžení výsledků předej filtry. Filtruj podle funkce pomocí function, podle stavu pomocí status a podle data odeslání pomocí created_after. Procházej výsledky pomocí limit a offset:

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

Pokud už máš ID úlohy pro konkrétní úlohu, můžeš úlohu získat pomocí 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

Získání chybových zpráv​

Pokud je stav programu ERROR, použij job.error_message() k získání chybové zprávy následovně:

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

Další kroky​

Doporučení
Zdroj: IBM Quantum docs — aktualizováno 3. 9. 2026
Anglická verze na doQumentation — aktualizováno 3. 9. 2026
Problém s webem nebo překladem?Problém v obsahu? Upravit v IBM Quantum docs