Lumaktaw sa pangunahing nilalaman

Panimula sa Qiskit Functions

Mga Tala
  • Ang Qiskit Functions ay isang experimental na feature na available lamang sa mga gumagamit ng IBM Quantum® Premium Plan, Flex Plan, at On-Prem (sa pamamagitan ng IBM Quantum Platform API) Plan. Nasa preview release status pa ito at maaaring magbago.
Mga bersyon ng package

Ang code sa pahinang ito ay ginawa gamit ang mga sumusunod na requirements. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago pa.

qiskit[all]~=1.4.1
qiskit-ibm-runtime~=0.37.0
qiskit-ibm-catalog~=0.4

Pinapasimple at pinepabilis ng Qiskit Functions ang pag-discover ng algorithm at pagbuo ng aplikasyon sa utility-scale, sa pamamagitan ng pag-abstract ng mga bahagi ng quantum software development workflow. Sa ganitong paraan, nililigtas ng Qiskit Functions ang oras na karaniwang ginagastos sa pagsulat ng code nang manu-mano at pag-aayos ng mga eksperimento.

Pangkalahatang-ideya ng Qiskit Functions Dalawang uri ang functions:

UriAno ang ginagawa nito?Halimbawa ng inputs at outputsPara kanino ito?
Circuit functionPinasimpleng interface para sa pagpapatakbo ng mga circuit. Nag-a-abstract ng transpilation, error suppression, at error mitigationInput: Abstract na PUB objects
Output: Mitigated expectation values		Mga mananaliksik na gumagamit ng Qiskit para matuklasan ang mga bagong algorithm at aplikasyon, nang hindi na kailangang mag-focus sa pag-optimize para sa hardware o pag-handle ng error. Maaaring gamitin ang mga circuit function para bumuo ng custom na application functions.
Application functionSumasaklaw sa mga higher-level na gawain, tulad ng pag-explore ng mga algorithm at domain-specific na use case. Nag-a-abstract ng quantum workflow para malutas ang mga gawain, na may classical na inputs at outputsInput: Mga molekula, mga graph
Output: Ground + excited state energy, optimal na values para sa cost function		Mga mananaliksik sa mga hindi quantum na larangan, na nag-iintegrate ng quantum sa mga umiiral na large-scale classical na workflow, nang hindi na kailangang mag-map ng classical na data sa mga quantum circuit.
# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-ibm-catalog qiskit-ibm-runtime

Ang mga function ay ibinibigay ng IBM® at mga third-party na partner. Ang bawat isa ay performant para sa mga partikular na katangian ng workload at may natatanging mga opsyon sa performance-tuning.

Pangkalahatang-ideya ng mga available na function​

Mga Circuit function​

PangalanProviderInirerekomendang paggamitNatatanging benepisyo
Tensor-Network Error MitigationAlgorithmiqMga workload na may low-weight observable at loop-free na circuit.Binabawasan ang measurement overhead at variance, na mas mahusay kaysa sa standard na error mitigation baseline tulad ng Zero Noise Extrapolation (ZNE) at Probabilistic Error Cancellation (PEC) para sa mga kaugnay na klase ng circuit.
QESEM: Error Suppression and Error MitigationQedmaMga workload na may circuit na may fractional o parameterized na gate, high-weight observable, at mga workflow na nangangailangan ng unbiased expectation values at tumpak na runtime estimate.Nagpo-produce ng unbiased expectation values na may mas mababang variance at resource overhead, na mas mahusay kaysa sa ZNE at PEC para sa mga kaugnay na klase ng circuit.
Performance ManagementQ-CTRLMga workload na may parametric circuit, malalim na circuit, o nangangailangan ng maraming circuit execution.Awtomatikong naglalapat ng AI-driven error suppression sa mga quantum algorithm, na ini-maximize ang performance ng mga IBM device para makakuha ng tumpak na resulta habang binabawasan ang bilang ng shots, oras ng compute, at gastos.

Zero-overhead na paraan na nagpapabuti ng katumpakan ng execution para sa Sampler at Estimator primitives, compatible sa anumang weight ng observable.

Mga Application function​

PangalanProviderInirerekomendang paggamitNatatanging benepisyo
QUICK-PDEColibriTDGamitin ang quantum computation para sa multi-physics PDE.

Maghanda ng mga simulation workflow para sa quantum hardware, habang pinapanatili ang buong kontrol sa parehong quantum at physical modeling parameter.		Nag-aalok ng matibay na hybrid VQA framework na naghahatid ng tumpak at scalable na PDE solution sa pamamagitan ng advanced na solution encoding at spectral method, na ginagawa itong ideal na entry point para sa mga team na nagtatangkang bumuo ng quantum-ready na simulation capability.
Quantum Portfolio OptimizerGlobal Data QuantumMga workload para sa financial optimization, na naghahanap ng optimal na portfolio strategy sa paglipas ng panahon habang binabawasan ang panganib at pinalaki ang kita, na nagbibigay-daan sa back-testing ng trading strategy.Nilulutas ang mga combinatorial optimization problem sa pamamagitan ng highly specialized na adaptation ng VQE quantum algorithm para sa financial use case na ito, gamit ang optimized na execution strategy at optimizer, kasama ang noise-aware na error mitigation technique na iniakma para sa portfolio optimization.
HI-VQE ChemistryQunova ComputingMga workload sa computational chemistry, molecular simulation, materials science, o anumang Hamiltonian simulation na nangangailangan ng paglutas ng many-body electronic structure problem.Nilulutas ang mga molecular electronic structure sa pamamagitan ng paggamit ng enhanced SQD na nakakamit ng chemical accuracy (1 kcal/mol, 1.6 mHa) para sa mga problemang naka-model na may 40 hanggang 60 qubit, na mas mahusay kaysa sa ilang classical na solusyon sa mga supercomputer o standard SQD sa bilis ng convergence o katumpakan, ayon sa pagkakasunod, nang ilang order of magnitude.
Iskay Quantum OptimizerKipu QuantumMga optimization workload tulad ng scheduling, logistics, routing, at mga QUBO/HUBO problem.

Integrated na tunable classical pre- at post-processing method para sa quantum optimization routine.

Naghahatid ng runtime advantage laban sa mga classical solver (CPLEX, simulated annealing, at tabu search) sa mga napiling HUBO benchmark.

Market Split ms_5_100, isang mahirap na hamon, nalutas sa loob ng ilang oras (tingnan ang tutorial na ito).
Singularity Machine LearningMultiverse ComputingMga classical machine learning classification workflow na maaaring makinabang mula sa pinahusay na katumpakan o computational efficiency sa pamamagitan ng paggamit ng quantum optimization na isinasagawa sa IBM hardware.Naghahatid ng katumpakang kapantay o mas mataas kaysa sa mga classical na modelo tulad ng Random Forest o XGBoost, habang nag-ooperate na may mas kaunting learner at mas compact na ensemble.

Pinapagana ng quantum-optimized voting, pinipili nito ang pinaka-informative na learner at pinipino ang mga decision boundary, na nagreresulta sa mas mataas na kahusayan, nabawasang complexity ng modelo, at mas matibay na performance.
Optimization SolverQ-CTRLMga binary optimization problem o anumang combinatorial problem na maaaring ma-map sa isang binary cost function.

Sinusuportahan ang mga cost function ng anumang order at mga sukat ng problem hanggang sa maximum device scale.		Noise-aware, end-to-end quantum optimization solution na nagbibigay-daan sa mga input ng high-level na kahulugan ng problema at awtomatikong nakakahanap ng tumpak na solusyon sa mga classically challenging na combinatorial problem sa utility-scale quantum hardware.

Nag-a-abstract ng complexity sa pamamagitan ng pag-handle ng error suppression, efficient mapping, at hybrid quantum-classical optimization para malutas ang mga optimization task sa buong device scale nang walang malalim na kaalaman sa quantum.

Magsimula sa Qiskit Functions​

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 mga third-party na Qiskit Function​

Para humiling ng bagong libreng trial, pumunta sa Qiskit Functions Catalog, at i-explore ang details panel. I-click ang Request a free trial at punan ang impormasyong kinakailangan ng Functions partner, kasama ang IBM Cloud AccessGroupId:

  1. Pumunta sa IBM Cloud IAM.
  2. I-verify ang pagiging karapat-dapat.
    • Palitan ang iyong account sa itaas na bar ng isa na may sumusunod na format: XXXXXXX - [Organization Name]
    • Siguraduhin na ang organisasyon ay kapareho ng nakakonekta sa iyong Premium account.
    • Kung makikita mo ang "[Your Name]'s Account", gumagamit ka ng iyong personal na account, na hindi karapat-dapat para sa premium access.
  3. Hanapin ang iyong access group ID.
    • I-click ang pangalan ng grupo.
    • I-click ang Details.
    • Kopyahin ang access group ID. Dapat magsimula ito sa AccessGroup-.

I-install ang Qiskit Functions Catalog client​

  1. Para magsimulang gumamit ng 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 mga tagubilin sa pag-install kung wala ka pang naka-set up na virtual environment.

    Kung nagtatrabaho ka sa isang pinagkakatiwalaang Python environment (tulad ng sa personal na laptop o workstation), gamitin ang save_account() na paraan para i-save ang iyong mga kredensyal nang lokal. (Laktawan ang susunod na hakbang kung hindi ka gumagamit ng pinagkakatiwalaang environment, tulad ng shared o pampublikong computer, para ma-authenticate sa IBM Quantum Platform.)

    Para gamitin ang save_account(), patakbuhin ang python sa iyong shell, pagkatapos ay ipasok 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, tuwing kailangan mong mag-authenticate sa service, maaari mong i-load ang iyong mga kredensyal gamit ang

    from qiskit_ibm_catalog import QiskitFunctionsCatalog
    catalog = QiskitFunctionsCatalog()
# Load saved credentials
from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

  1. Iwasang mag-execute ng code sa isang hindi pinagkakatiwalaang makina o external na cloud Python environment para mabawasan ang mga panganib sa seguridad. Kung kailangan mong gumamit ng hindi pinagkakatiwalaang environment (sa, halimbawa, isang pampublikong computer), palitan ang iyong API key pagkatapos ng bawat paggamit sa pamamagitan ng pagbubura nito sa pahinang IBM Cloud API keys para mabawasan ang panganib. Matuto nang higit pa sa paksa ng Managing user API keys. Para simulan ang service sa sitwasyong ito, palawakin ang sumusunod na seksyon para makita ang code na maaari mong gamitin:

    Simulan ang service sa isang hindi pinagkakatiwalaang environment
    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
    babala

    Protektahan ang iyong API key! Huwag isama ang iyong key sa source code, Python script, o notebook file. Kapag nagbabahagi ng code sa iba, siguraduhing hindi direktang naka-embed ang iyong API key sa loob ng Python script. Sa halip, ibahagi ang script nang walang key at magbigay ng mga tagubilin para itakda ito nang ligtas.

    Kung aksidente mong naibahagi ang iyong key sa iba o nasama ito sa version control tulad ng Git, agad na bawiin ang iyong key sa pamamagitan ng pagbubura nito sa pahinang IBM Cloud API keys para mabawasan ang panganib. Matuto nang higit pa sa paksa ng Managing user API keys.

  2. Pagkatapos ma-authenticate, maaari mong ilista ang mga function mula sa Qiskit Functions Catalog na may access ka:

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 enabled na function​

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

ibm_cf = catalog.load("ibm/circuit-function")

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

# 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

service = QiskitRuntimeService()
instance = service.active_account()["instance"]
backend_name = service.least_busy().name

circuit = random_circuit(num_qubits=2, depth=2, seed=42)
observable = "Z" * circuit.num_qubits
job = ibm_cf.run(
    pubs=[(circuit, observable)],
    instance=instance,
    backend_name=backend_name,  # E.g. "ibm_fez"
)

job.job_id
'7f08c9d5-471b-4da2-92e7-4f2cb94c23a8'

Tingnan ang status ng job​

tip

Sa kasalukuyan, ang IBM Quantum workloads table ay nagpapakita lamang ng mga Qiskit Runtime workload. Gamitin ang job.status() para makita ang kasalukuyang status ng iyong Qiskit Function workload.

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

  • QUEUED: Ang remote program ay nasa Qiskit Function queue. Ang priority ng queue ay batay sa gaano karami mong nagamit na Qiskit Functions.
  • INITIALIZING: Nagsisimula na ang remote program; kasama dito ang pag-set up ng remote environment at pag-install ng mga dependency.
  • RUNNING: Tumatakbo ang program. Kasama rin dito ang ilang mas detalyadong status kung sinusuportahan ng mga partikular na function
    • RUNNING: MAPPING": Kasalukuyang ino-map ng function ang iyong classical inputs sa quantum inputs
    • RUNNING: OPTIMIZING_FOR_HARDWARE": Ino-optimize ng function para sa napiling QPU. Maaaring kasama dito ang circuit transpilation, QPU characterization, observable backpropagation, at iba pa
    • RUNNING: WAITING_FOR_QPU: Nagsumite na ang function ng job sa Qiskit Runtime, at naghihintay sa queue
    • RUNNING: EXECUTING_QPU: Ang function ay may aktibong Qiskit Runtime job
    • RUNNING: POST_PROCESSING: Nagpo-post-process ng mga resulta ang function. Maaaring kasama dito ang error mitigation, pag-map ng quantum results sa classical, at iba pa
  • DONE: Tapos na ang program, at maaari kang kunin ang result data gamit ang job.results().
  • ERROR: Huminto ang program dahil sa isang problema. Gamitin ang job.result() para makuha ang mensahe ng error.
  • CANCELED: Kinansela ang program; maaaring ng isang gumagamit, ng service, o ng server.
job.status()
'QUEUED'

Kunin ang mga resulta​

Pagkatapos maging DONE ang isang program, maaari mong gamitin ang job.results() para kunin ang resulta. Nag-iiba ang format ng output na ito sa bawat function, kaya siguraduhing sundin 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 ka ring mag-cancel ng job kahit kailan:

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

Ilista ang mga dating pinatakbong job sa Qiskit Functions​

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

Kung mayroon ka nang job ID para sa isang partikular na job, maaari mong kunin ang job gamit ang catalog.get_job_by_id():

# First, get the most recent job that has been executed.
latest_job = old_jobs[0]

# We can also get that same job with get_job_by_id
job_by_id = catalog.get_job_by_id(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 mensahe ng error​

Kung ang status ng program ay ERROR, gamitin ang job.error_message() para kunin ang mensahe ng error 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