Sari la conținutul principal

Începe cu 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

Utilizatorii planurilor Premium, Flex și On-Prem (prin IBM Quantum Platform API) pot începe să folosească IBM Qiskit Functions gratuit sau pot achiziționa o licență de la unul dintre partenerii care au contribuit cu o funcție la catalog.

Solicită o perioadă de probă gratuită pentru Qiskit Functions de la terți​

Pentru a solicita o perioadă de probă gratuită, navighează la Qiskit Functions Catalog și explorează panoul de detalii. Fă clic pe Request a free trial și completează informațiile solicitate de partenerul Functions, inclusiv AccessGroupId din IBM Cloud:

  1. Navighează la IBM Cloud IAM.

  2. Verifică eligibilitatea.

    • Comută contul din bara de meniu din antet la unul cu următorul format: XXXXXXX - [Organization Name]

    • Asigură-te că organizația este aceeași cu cea asociată contului tău Premium.

    • Dacă vezi "[Your Name]'s Account", folosești contul tău personal, care nu este eligibil pentru acces premium.

  3. Găsește ID-ul grupului tău de acces.

    • Fă clic pe un nume de grup.

    • Fă clic pe Details.

    • Copiază ID-ul grupului de acces. Ar trebui să înceapă cu AccessGroup-.

Instalează clientul Qiskit Functions Catalog​

  1. Pentru a începe să folosești Qiskit Functions, instalează clientul IBM Qiskit Functions Catalog:

    pip install qiskit-ibm-catalog

  2. Preia cheia ta API din IBM Quantum Platform dashboard și activează mediul tău virtual Python. Consultă instrucțiunile de instalare dacă nu ai deja configurat un mediu virtual.

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

    Instanța cu care te autentifici trebuie să aibă activat accesul la Qiskit Functions. Pentru a-l configura pe o instanță existentă, consultă Configurarea accesului la Qiskit Functions pe o instanță.

    Pentru a folosi save_account(), rulează python în shell-ul tău, apoi introdu următoarele:

    from qiskit_ibm_catalog import QiskitFunctionsCatalog

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

    Tastează exit(). De acum înainte, ori de câte ori trebuie să te autentifici la serviciu, poți încărca credențialele cu următoarele:

    from qiskit_ibm_catalog import QiskitFunctionsCatalog
    catalog = QiskitFunctionsCatalog()

    De exemplu:

# 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
Protejează-ți cheia API

Nu include niciodată cheia în codul sursă, scripturile Python sau fișierele notebook. Când distribui cod altora, asigură-te că cheia ta API nu este inclusă direct în scriptul Python. În schimb, distribuie scriptul fără cheie și oferă instrucțiuni pentru configurarea ei în siguranță.

Dacă distribui accidental cheia ta cuiva sau o incluzi într-un sistem de control al versiunilor precum Git, revocă imediat cheia ștergând-o pe pagina IBM Cloud API keys pentru a reduce riscul. Află mai multe în subiectul Managing user API keys.

Listează funcțiile la care ai acces​

După ce te autentifici, poți lista funcțiile din Qiskit Functions Catalog la care ai acces:

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

Rulează funcțiile activate​

După ce un obiect catalog a fost instanțiat, poți selecta o funcție folosind catalog.load("<provider/function-name>"):

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

Fiecare Qiskit Function are intrări, opțiuni și ieșiri personalizate. Consultă paginile de documentație specifice pentru funcția pe care vrei să o rulezi pentru mai multe informații. În mod implicit, toți utilizatorii pot rula doar un job de funcție la un moment dat:

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

run() verifică capacitatea rămasă și accesul la backend înainte de a trimite jobul. Dacă instanța ta nu mai are capacitate sau backend-ul pe care l-ai numit nu este accesibil, run() generează imediat o eroare, în loc să lase jobul să eșueze în coadă. Când capacitatea este scăzută, run() emite un avertisment. Transmite suppress_low_usage_warning=True pentru a-l dezactiva.

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

Verifică starea jobului​

Cu job_id-ul funcției tale Qiskit, poți verifica starea joburilor care rulează. Aceasta include următoarele stări:

  • QUEUED: Programul de la distanță se află în coada Qiskit Function. Prioritatea în coadă se bazează pe cât de mult ai folosit Qiskit Functions.

  • INITIALIZING: Programul de la distanță pornește; aceasta include configurarea mediului de la distanță și instalarea dependențelor.

  • RUNNING: Programul rulează. Aceasta include, de asemenea, mai multe stări detaliate, dacă sunt acceptate de funcții specifice.

    • RUNNING: MAPPING: Funcția mapează în prezent intrările tale clasice la intrări cuantice.

    • RUNNING: OPTIMIZING_FOR_HARDWARE: Funcția optimizează pentru QPU-ul selectat. Aceasta poate include transpilarea circuitului, caracterizarea QPU-ului, retropropagarea observabilelor și așa mai departe.

    • RUNNING: WAITING_FOR_QPU: Funcția a trimis un job către IBM Quantum Compute Service și așteaptă în coadă.

    • RUNNING: EXECUTING_QPU: Funcția are un job Quantum Compute activ.

    • RUNNING: POST_PROCESSING: Funcția post-procesează rezultatele, ceea ce poate include atenuarea erorilor, maparea rezultatelor cuantice la cele clasice și așa mai departe.

  • DONE: Programul este finalizat, iar tu poți prelua datele rezultatului cu job.result().

  • ERROR: Programul s-a oprit din cauza unei probleme. Folosește job.result() pentru a obține mesajul de eroare.

  • CANCELED: Programul a fost anulat de un utilizator, de serviciu sau de server.

job.status()
'QUEUED'

Preia rezultatele​

După ce un program este DONE, poți folosi job.result() pentru a prelua rezultatul. Acest format de ieșire variază în funcție de fiecare funcție, așa că asigură-te că urmezi documentația specifică:

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

De asemenea, poți anula un job în orice moment:

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

Accesează joburile Quantum Compute asociate​

O Qiskit Function poate trimite unul sau mai multe joburi Quantum Compute către un QPU în timp ce rulează. Pentru a prelua ID-urile acelor joburi de runtime, folosește job.runtime_jobs(). Poți folosi aceste ID-uri pentru a prelua obiectele joburilor de runtime dintr-o instanță QiskitRuntimeService, sau pentru a găsi sarcinile pe dashboard-ul IBM Quantum® Platform.

runtime_job_ids = job.runtime_jobs()
runtime_job_ids

Dacă o funcție își grupează joburile de runtime în sesiuni sau loturi, folosește job.runtime_sessions() pentru a lista ID-urile sesiunilor. Transmite un ID de sesiune către job.runtime_jobs() pentru a returna doar joburile de runtime din acea sesiune:

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.")
notă

Lista returnată poate fi goală. O funcție raportează job-urile sale runtime doar atunci când le trimite prin serviciul runtime pe care funcția îl primește în timpul execuției, iar unele funcții nu trimit job-uri runtime direct.

Vizualizează jurnalele jobului​

Folosește job.logs() pentru a prelua ieșirea jurnalului pe care o produce o funcție în timp ce rulează. Jurnalele sunt utile pentru urmărirea progresului și pentru depanarea unui job care se termină într-o stare ERROR.

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

Pentru un job de lungă durată care produce multe linii de jurnal, folosește job.filtered_logs() pentru a returna doar liniile dorite. Transmite o expresie regulată către include pentru a păstra liniile care se potrivesc sau către exclude pentru a elimina liniile care se potrivesc:

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

Listează joburile Qiskit Functions rulate anterior​

Poți folosi jobs() pentru a lista toate joburile trimise către 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>]

Pentru a restrânge rezultatele, transmite filtre. Filtrează după funcție cu function, după stare cu status și după data trimiterii cu created_after. Parcurge rezultatele cu limit și offset:

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

Dacă ai deja ID-ul jobului pentru un anumit job, poți prelua jobul cu 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

Preia mesajele de eroare​

Dacă starea unui program este ERROR, folosește job.error_message() pentru a prelua mesajul de eroare astfel:

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

Pași următori​

Recomandări
Sursă: IBM Quantum docs — actualizat 3 sept. 2026
Versiunea în engleză pe doQumentation — actualizată 3 sept. 2026
Problemă cu site-ul sau cu traducerea?Problemă de conținut? Editează pe IBM Quantum docs