Přeskočit na hlavní obsah
Tento projekt je v betě. Našel jsi chybu? Otevřít issue na GitHubu. Máš otázku nebo nápad? Zeptej se v Discussions — rádi si poslechneme tvou zpětnou vazbu!
Jaká je kvalita překladu na této stránce?

Začínáme s Qiskit Functions

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

_needed = {"qiskit": "qiskit", "qiskit_ibm_catalog": "qiskit-ibm-catalog", "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")
# 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íš „[Your Name]'s Account“, 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.

    Pokud pracuješ v důvěryhodném prostředí Pythonu (například na osobním notebooku nebo pracovní stanici), použij metodu save_account() k lokálnímu uložení přihlašovacích údajů. (Přejít na další krok, pokud k ověření v IBM Quantum Platform nepoužíváš důvěryhodné prostředí, jako je sdílený nebo veřejný počítač.)

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

Abys minimalizoval bezpečnostní rizika, vyhýbej se spouštění kódu na nedůvěryhodném počítači nebo v externím cloudovém prostředí Pythonu. Pokud musíš použít nedůvěryhodné prostředí (například veřejný počítač), sniž riziko tím, že po každém použití změníš svůj API klíč jeho smazáním na stránce IBM Cloud API keys. Více se dozvíš v tématu Managing user API keys. Pro inicializaci služby v této situaci použij tento kód:

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 nevkládej svůj klíč do zdrojového kódu, skriptů v Pythonu ani do notebooků. Při sdílení kódu s ostatními zajisti, aby tvůj API klíč nebyl vložen přímo do skriptu v Pythonu. 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 došla kapacita nebo pokud zadaný 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 relací (sessions) nebo dávek (batches), použij job.runtime_sessions() k výpisu ID relací. Předej jedno ID relace funkci job.runtime_jobs(), aby vrátila pouze runtime úlohy v dané relaci:

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: Dokumentace IBM Quantum — 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