Panimula sa mga primitive

Package versions

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

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

Bakit nagpakilala ng mga primitive ang Qiskit?

Katulad ng mga unang araw ng classical computers, nang kailangan pang manipulahin ng mga developer ang CPU registers nang direkta, ang unang interface sa mga QPU ay nagbabalik lang ng raw data mula sa control electronics. Hindi ito malaking problema noong nasa mga laboratoryo pa lang ang mga QPU at direktang access lang ang ibinibigay sa mga mananaliksik. Kinikilala na karamihan sa mga developer ay hindi kailangang maging pamilyar sa pag-distill ng ganoong raw data sa 0s at 1s, ipinakilala ng Qiskit ang backend.run, isang unang abstraction para sa pag-access sa mga QPU sa cloud. Nagbigay-daan ito sa mga developer na gumana sa isang pamilyar na format ng data at mas mapagtuunan ang mas malaking larawan.

Habang lumalawak ang access sa mga QPU, at habang mas maraming quantum algorithm ang binubuo, lumitaw muli ang pangangailangan para sa mas mataas na antas ng abstraction. Bilang tugon, ipinakilala ng Qiskit ang primitives interface, na na-optimize para sa dalawang pangunahing gawain sa pagbuo ng quantum algorithm: pagtatantya ng expectation value (Estimator) at pag-sample ng circuit (Sampler). Ang layunin ay muli na tulungan ang mga developer na mas mapagtuunan ang inobasyon at hindi ang conversion ng data. Pinapalitan ng primitives interface ang backend.run interface, dahil nagbibigay ang Sampler ng parehong direktang hardware access na inaalok noon ng backend.run.

Ano ang isang primitive?

Ang mga computing system ay binubuo ng maraming layer ng abstraction. Ang mga abstraction ay nagbibigay-daan sa iyo na magfocus sa isang partikular na antas ng detalye na may kaugnayan sa gawain. Habang lalapit ka sa hardware, mas mababang antas ng abstraction ang kailangan mo (halimbawa, maaaring kailangang ilipat o manipulahin ang data sa antas ng CPU instruction). Habang mas kumplikado ang gawain na nais mong gawin, mas mataas ang antas ng mga abstraction (halimbawa, maaaring gumagamit ka ng programming library para magsagawa ng algebraic calculations).

Sa kontekstong ito, ang isang primitive ay ang pinakamaliit na processing instruction, ang pinakasimpleng building block mula sa kung saan maaaring lumikha ng isang bagay na kapaki-pakinabang para sa isang partikular na antas ng abstraction.

Ang kamakailang pag-unlad sa quantum computing ay nagpataas ng pangangailangan na magtrabaho sa mas mataas na antas ng abstraction. Habang ang larangan ay gumagalaw patungo sa mas malalaking quantum processing units (QPU) at mas kumplikadong mga workflow, lumilipat ang pokus mula sa pakikipag-ugnayan sa mga indibidwal na qubit signal patungo sa pagtingin sa mga quantum device bilang mga sistema na nagsasagawa ng mga kinakailangang gawain.

Ang dalawang pinakakaraniwang gawain para sa mga quantum computer ay ang pag-sample ng mga quantum state at pagkalkula ng mga expectation value. Ang mga gawaing ito ang nagbigay-inspirasyon sa disenyo ng mga Qiskit primitive: Estimator at Sampler.

• Kinakalkula ng Estimator ang mga expectation value ng mga observable kaugnay ng mga state na inihanda ng mga quantum circuit.
• Sino-sample ng Sampler ang output register mula sa pagpapatupad ng quantum circuit.

Sa madaling salita, ang computational model na ipinakilala ng mga Qiskit primitive ay nagdadala sa quantum programming ng isang hakbang na mas malapit sa kinaroroonan ng classical programming ngayon, kung saan ang pokus ay mas kaunti sa mga detalye ng hardware at mas marami sa mga resulta na nais mong makamit.

Kahulugan at mga implementasyon ng primitive

Mayroong dalawang uri ng Qiskit primitive: ang mga base class, at ang kanilang mga implementasyon. Ang mga Estimator at Sampler primitive ay tinukoy ng mga open-source primitive base class na nasa Qiskit SDK (sa qiskit.primitives module). Ang mga provider (tulad ng Qiskit Runtime) ay maaaring gumamit ng mga base class na ito para makuha ang kanilang sariling mga implementasyon ng Sampler at Estimator. Karamihan sa mga user ay makikipag-ugnayan sa mga implementasyon ng provider, hindi sa mga base primitive.

Mga base class

Ang mga Base primitive ay mga abstract class na nagtatakda ng karaniwang interface para sa pagpapatupad ng mga primitive. Lahat ng iba pang klase sa qiskit.primitives module ay nagmumula sa mga base class na ito. Dapat gamitin ng mga developer ang mga ito kung interesado silang lumikha ng sarili nilang primitives-based execution model para sa isang partikular na provider. Ang mga klase na ito ay maaari ring maging kapaki-pakinabang para sa mga gustong gumawa ng lubos na customized na pagpoproseso at natuklasan na ang mga kasalukuyang implementasyon ng primitive ay masimple para sa kanilang mga pangangailangan. Ang mga pangkalahatang user ay hindi direktang gagamit ng mga base class.

BaseEstimatorV1 at BaseSamplerV1 - Bagama't magagamit pa rin ang mga V1 primitive, ang mga gabay na ito ay nakatuon sa mga V2 primitive dahil ang mga ito ang pinakabago at mas karaniwang ginagamit.

BaseEstimatorV2 at BaseSamplerV2 - Sinusunod ng mga Qiskit reference primitive ang mga interface specification na ito.

Mga implementasyon

Lahat ng primitive ay nilikha mula sa mga base class; samakatuwid, mayroon silang parehong pangkalahatang istraktura at paggamit. Halimbawa, ang format ng input para sa lahat ng Estimator primitive ay pareho. Gayunpaman, may mga pagkakaiba sa mga implementasyon na nagpapakaiba sa kanila.

Ito ang mga implementasyon ng mga primitives base class:

• Ang mga Qiskit Runtime primitive, EstimatorV2 at SamplerV2, ay nagbibigay ng mas sopistikadong implementasyon (halimbawa, sa pamamagitan ng pagsasama ng error mitigation) bilang isang cloud-based na serbisyo. Ang implementasyong ito ng mga base primitive ay ginagamit para ma-access ang IBM Quantum® hardware.

• StatevectorEstimator at StatevectorSampler - Mga reference implementation ng mga primitive na gumagamit ng simulator na built-in sa Qiskit. Ginawa ang mga ito gamit ang Qiskit quantum_info module, na gumagawa ng mga resulta batay sa ideal statevector simulations. Ina-access ang mga ito sa pamamagitan ng Qiskit. Tingnan ang Exact simulation with Qiskit primitives para sa mga detalye ng paggamit.

• BackendEstimatorV2 at BackendSamplerV2 - Magagamit mo ang mga klase na ito para "i-wrap" ang anumang quantum computing resource sa isang primitive. Nagbibigay-daan ito sa iyo na sumulat ng primitive-style na code para sa mga provider na wala pang primitives-based na interface. Ang mga klase na ito ay magagamit tulad ng regular na Sampler at Estimator, maliban na dapat silang simulan na may karagdagang backend na argument para sa pagpili kung aling quantum computer ang pagtatakbuhin. Ina-access ang mga ito sa pamamagitan ng paggamit ng Qiskit. Tingnan ang gabay ng backend primitives para sa karagdagang impormasyon.

Mga opsyon

Maaari kang magpasa ng mga opsyon sa mga primitive para i-customize ang mga ito ayon sa iyong mga pangangailangan. Bagama't ang interface ng run() na pamamaraan ng mga primitive ay karaniwan sa lahat ng implementasyon, ang kanilang mga opsyon ay hindi. Kumonsulta sa mga API reference para sa isang partikular na implementasyon ng primitive para malaman ang mga opsyon na sinusuportahan nito.

Halimbawa, sumangguni sa mga paksa na Estimator options at Sampler options para malaman ang mga opsyon para sa mga Qiskit Runtime primitive, o tingnan ang Qiskit Aer API references para sa mga opsyon ng Qiskit Aer primitive.

Mga benepisyo ng mga Qiskit primitive

Sa mga primitive, ang mga Qiskit user ay maaaring sumulat ng quantum code para sa isang partikular na QPU nang hindi kailangang tahasang pamahalaan ang bawat detalye. Gayundin, dahil sa karagdagang layer ng abstraction, maaari kang mas madaling ma-access ang mga advanced na kakayahan ng hardware ng isang partikular na provider. Halimbawa, sa mga Qiskit Runtime primitive, maaari kang makinabang mula sa mga pinakabagong pagsulong sa error mitigation at suppression sa pamamagitan ng pag-toggle ng mga opsyon tulad ng resilience_level ng primitive, sa halip na bumuo ng sariling implementasyon ng mga pamamaraang ito.

Para sa mga hardware provider, ang katutubong pagpapatupad ng mga primitive ay nangangahulugang maaari mong bigyan ang iyong mga user ng mas "out-of-the-box" na paraan para ma-access ang iyong mga hardware feature tulad ng mga advanced na post-processing technique. Kaya naman, mas madali para sa iyong mga user na makinabang mula sa pinakamahusay na kakayahan ng iyong hardware.

Mga susunod na hakbang

Mga rekomendasyon

• Unawain ang primitive input at output.
• Suriin ang mga detalyadong halimbawa.
• Mag-practice sa mga primitive sa pamamagitan ng pagtratrabaho sa Cost function lesson sa IBM Quantum Learning.
• Suriin ang Create a provider para malaman kung paano ipapatupad ang iyong sariling Sampler at Estimator primitive.
• Tingnan ang mga API reference.
• Basahin ang Migrate to V2 primitives.
• Alamin ang tungkol sa Qiskit Runtime primitives, na ginagamit para sa pagpapatakbo ng mga circuit sa IBM QPU.