Sari la conținutul principal
Acest proiect este în versiune beta. Ai găsit o eroare? Deschide un issue pe GitHub. Ai o întrebare sau o idee? Întreabă în Discussions — ne-ar plăcea să aflăm părerea ta!
Cum este calitatea traducerii pe această pagină?

Primii pași cu 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

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.

    Dacă lucrezi într-un mediu Python de încredere (cum ar fi pe un laptop sau o stație de lucru personală), folosește metoda save_account() pentru a-ți salva acreditările local. (Sari la pasul următor dacă nu folosești un mediu de încredere, cum ar fi un computer partajat sau public, pentru a te autentifica în 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")

Evită să execuți cod pe o mașină care nu este de încredere sau pe un mediu Python cloud extern, pentru a minimiza riscurile de securitate. Dacă trebuie să folosești un mediu care nu este de încredere (de exemplu, un computer public), schimbă-ți cheia API după fiecare utilizare, ștergând-o din pagina IBM Cloud API keys, pentru a reduce riscul. Află mai multe în subiectul Managing user API keys. Pentru a inițializa serviciul în această situație, folosește acest cod:

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 s-a finalizat și 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 își raportează joburile de 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 direct joburi de runtime.

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ă: Documentația IBM Quantum — 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