Pagpapatakbo ng mga quantum circuit

Panoorin ang video tungkol sa mga quantum circuit at primitives mula kay Olivia Lanes, o buksan ang video sa hiwalay na window sa YouTube.

Pangkalahatang-ideya ng aralin

Ang araling ito ay magiging isang mataas na antas na tingin sa mga pangunahing kaalaman sa pagpapatakbo ng utility-scale na quantum computation — mula sa quantum hardware na ginagamit hanggang sa mga prinsipyong dapat isaalang-alang kapag nagdidisenyo ng quantum circuit. Sa katapusan ng araling ito, sana'y malalaman mo na:

1. Kung ano talaga ang mga quantum computer ng IBM®. Kailangan mong malaman ang mga pangunahing katangian ng hardware para makapagdisenyo ng mga quantum circuit na magiging optimal para sa pagpapatakbo nito.

2. Kung ano ang Qiskit, kung ano ang mga primitive, at kung paano natin magagamit ang mga ito para lumikha at magpatakbo ng mga quantum circuit.

3. Ang karaniwang workflow na sinusunod namin para magpatakbo ng mga eksperimento sa malaking sukat. Kasama rito ang pagpili ng pinakamainam na mga primitive para sa iyong use case, ang pagma-map ng problema sa isang quantum circuit, at ang pag-apply ng error mitigation at suppression, na nagpapahintulot sa atin na makuha ang pinakamataas na kapangyarihan mula sa mga makina.

Hardware – mga IBM quantum processor

Para maunawaan kung paano tayo makakagawa ng mga optimal na desisyon sa pagdidisenyo ng malalaking quantum circuit, kailangan nating malaman nang kaunti ang tungkol sa aktwal na hardware na magpapatakbo ng mga circuit na ito. Kaya't pag-usapan natin nang maikli ang mga physical qubit at IBM quantum processor.

Ang mga IBM quantum processor ay ginawa gamit ang superconducting transmon qubit, na mga electrical circuit na binubuo ng isang Josephson junction at isang capacitor na nakakonekta nang parallel. Ang Josephson junction ay isang nonlinear inductor na ginawa mula sa dalawang magkapatong na layer ng superconducting metal na may insulating barrier sa pagitan ng mga ito. Sa napakababang temperatura, ang mga elektron sa mga superconductor ay nagpapares para bumuo ng tinatawag na cooper pair. Ang mga cooper pair ay maaaring spontaneously mag-tunnel sa pamamagitan ng insulating barrier mula sa isang panig ng junction patungo sa kabila. Ang ganitong gawi ng pag-tunnel ang nagbibigay ng nonlinear na katangian na lumilikha ng ating qubit.

Ang mga microwave transmission line ay ginagawa sa chip para maihatid ang mga microwave signal sa mga qubit. Kapag nag-apply tayo ng napakatumpak na mga microwave pulse — na may tiyak na frequency, amplitude, hugis, at tagal — sa mga linya, maaari nating pagawin ang mga qubit ng mga tiyak na bagay. Ito ang pundasyon ng ating mga quantum gate. Ginagawa namin ang chip para ang mga katabing qubit ay nakakonekta sa isang tiyak na lattice structure na tinatawag na heavy-hex lattice. Ang koneksyon — ang tinatawag na topology — ng ating mga processor ay isang mahalagang salik na dapat isaalang-alang kapag nagdidisenyo ng circuit, tulad ng tatalakayin natin mamaya sa aralin.

Ang mga tagubilin para sa microwave pulse ay nagmumula sa iyong computer, dumadaan sa cloud, at napupunta sa room-temperature na control electronics, na nag-i-interpret ng mga tagubilin at pisikal na nagge-generate ng mga pulse. Matapos gawin ng mga room-temperature na control box ang mga pulse, naglalakbay ang mga ito sa pamamagitan ng mga kable patungo sa isang dilution refrigerator at sa huli ay napupunta sa quantum chip. Ang signal ay pumapasok sa mga resonator, dumadaan sa isang wirebond, at pagkatapos ay dumadaloy sa transmission line patungo sa ating mga qubit.

Mayroon ang IBM ng dose-dosenang quantum computer sa buong mundo, at kamakailan ay na-upgrade namin ang aming fleet para exclusively magkaroon ng mga processor na mas malaki kaysa sa 100 qubit. Ang ilan sa mga ito ay matatagpuan sa isang IBM quantum data center sa upstate New York at ini-deploy sa pamamagitan ng cloud para sa lahat — at ang ilan sa mga ito ay dedicated na on-premises na sistema na sumusuporta sa mga kasosyo sa IBM Quantum® Network. Maaari kang mag-log in sa quantum.cloud.ibm.com para makita kung aling mga processor ang maa-access mo.

Bawat processor ay naglilista ng tatlong sukatan ng performance, na tinalakay natin sa nakaraang aralin, ngunit bilang paalala, ang mga ito ay: bilang ng qubit, EPLG, at CLOPS.

• Bilang ng qubit. Ito ay nagpapaliwanag sa sarili: ito ang kabuuang bilang ng mga qubit na magagamit sa isang quantum processor. Para sa isang medyo malaki at utility-scale na problema, kailangan mong tiyakin na gumagamit ka ng processor na may sapat na mga qubit para matackle ang problema. Ngunit ang bilang ng qubit lamang ay hindi ang tanging bagay na mahalaga.

• EPLG, o "errors per layered gate." Ito ay isang sukatan ng kalidad ng mga qubit at quantum gate. Sinusukat nito ang average na error na idinudulot ng bawat gate sa isang circuit na nag-e-entangle ng mga katabing qubit sa isang chain ng 100 qubit. Gusto mong maging maliit ito hangga't maaari.

• CLOPS, o "circuit layer operations per second." Sinusukat nito ang bilis ng processor. Sinusukat nito kung gaano karaming layer ng isang tiyak na benchmarking circuit na tinatawag na quantum volume circuit ang maaaring i-execute ng isang quantum processing unit (QPU) sa bawat yunit ng oras. Habang mas mataas ang numero, mas mabilis tayong makakapagsagawa ng computation.

Ang kahalagahan ng bawat isa sa mga sukatan na ito ay nagbabago depende sa tiyak na application, at sa mga susunod na aralin, titingnan natin ang mga tunay na halimbawa para makita kung paano maaaring makaapekto ang bawat isa sa mga salik na ito sa resulta ng isang kalkulasyon.

Software: Qiskit at Qiskit Runtime

Para gawing mga tagubilin para sa isang quantum computer ang iyong quantum na problema, gagamit ka ng Qiskit, ang open-source software development kit na idinisenyo para sa trabaho sa mga quantum computer na binuo ng IBM. Mayroon ding Qiskit Ecosystem — isang koleksyon ng mga software tutorial at function na nagtatayo o nagpapalawak sa mga core na functionality ng Qiskit — at Qiskit Runtime — isang quantum computing service at programming model na nagpapahintulot sa mga gumagamit na magdisenyo at mag-optimize ng kanilang mga quantum workload at mabisang i-execute ang mga ito sa pamamagitan ng paggamit ng Qiskit Runtime Primitives.

Ang isang primitive ay isang maliit na building block na maaari mong gamitin para magdisenyo ng mas malaking circuit o job. Ang dalawang primitive na pinakamahalaga para sa atin ay ang sampler at ang estimator, na tatalakayin natin nang mas malalim sa lalong madaling panahon.

Sa kamakailan na paglabas ng Qiskit v1.0, naging mas performative at stable ang Qiskit kaysa dati. Kaya, para sa inyong mga nagsisimula pa lamang, perpekto ang inyong timing! Para sa inyong mga pamilyar na sa Qiskit, kailangan ninyong i-download at muling i-install ang pinakabagong bersyon. Para sa kumpletong gabay sa pag-install, bisitahin ang gabay sa Pag-install ng Qiskit.

Mga Quantum Circuit

Handa na tayong talakayin ang pundasyon ng mga quantum program: mga quantum circuit. Ang seksyong ito ay magsisilbing refresher lamang — kung hindi ka pamilyar sa mga quantum circuit, inirerekomenda namin na matuto nang mas malalim tungkol sa mga ito sa pamamagitan ng pagbisita sa aralin na Quantum Circuits sa kursong "Basics of quantum information" bago magpatuloy.

Ang isang quantum circuit ay isang network ng mga quantum gate at sukatan na naka-link ng mga wire na kumakatawan sa mga qubit, tulad ng ipinapakita sa ibaba. Ang mga quantum circuit ay maaaring basahin tulad ng sheet music, mula kaliwa patungo sa kanan, simula sa oras 0 sa kaliwa. Ang mga virtual qubit — ang mga hindi pa itinalaga sa isang physical qubit sa isang processor — ay nakalista sa pataas na pagkakasunud-sunod mula itaas hanggang ibaba.

Ang mga gate ay kinakatawan ng iba't ibang simbolo sa mga wire ng mga kasangkot na qubit. Ang mga single-qubit gate — tulad ng Hadamard gate, na ipinapakita sa ibaba (ang kahon na may H) — ay nakakaapekto lamang sa qubit na ang wire ay nakalagay ito. Ang mga multi-qubit gate — tulad ng CNOT gate, na ipinapakita rin sa ibaba (ang plus sign sa loob ng bilog na may linya na nakakonekta sa q0) — ay nakakaapekto sa dalawa o higit pang qubit. Sa ipinapakitang CNOT gate, ang estado ng q1 ay nagbabago ayon sa estado ng q0. Pagkatapos maisagawa ang lahat ng gate, maaari na nating sukatin ang mga qubit, na ipinapakita ng mga itim na gate na may simbolo ng pagsukat. Ang mga resulta ng mga pagsukat ay isinusulat sa mga classical register, ang double-lined na "meas" bus sa ibaba.

Ang isang mahalagang katangian ng isang circuit ay ang depth nito. Ang depth ng isang quantum circuit ay ang pinakamababang bilang ng mga "layer" ng mga quantum gate, na isinasagawa nang sabay-sabay, na kinakailangan para makumpleto ang circuit. Ang mga quantum gate ay maaaring isagawa nang sabay-sabay (sa parehong oras) kung saan hindi sila magkasamang gumagamit ng anumang qubit. Ngunit kung dalawa o higit pang gate ang kumikilos sa parehong qubit, hindi natin maaaring isagawa ang mga ito nang sabay-sabay — kailangan silang isagawa sa dalawang hiwalay na layer, isa pagkatapos ng isa.

May isa pang, hindi gaanong halata, na paraan para matukoy ang depth ng isang circuit, sa pamamagitan ng paglalaro ng isang uri ng laro. Simple ang mga panuntunan: simula sa anumang qubit wire sa kaliwa, kailangan mong maglakbay papunta sa kanan at bilangin ang bilang ng mga gate na mararaanan mo sa iyong landas. Maaari kang lumundag sa katabing wire lamang kapag ito ay nakakonekta sa iyong kasalukuyang wire sa pamamagitan ng isang multi-qubit gate. Ang layunin ay i-maximize ang bilang ng mga gate na mararaanan mo sa iyong landas. Ang pinakamataas na bilang na ito ay kapareho ng depth ng circuit.

Dahil ang mga quantum gate ay nangangailangan ng oras para ipatupad, ang depth ng isang circuit ay humigit-kumulang na katumbas ng dami ng oras na kailangan ng isang quantum computer para i-execute ang circuit. Ang ilang makina ay mas angkop para sa malalim na circuit kaysa sa iba dahil sa mga decoherence time ng mga qubit sa processor. Kaya, kailangan nating malaman ang depth ng isang circuit para malaman kung maaari itong patakbuhin sa isang partikular na device.

Pagdidisenyo ng quantum circuit: mga Qiskit pattern

Paano tayo magdidisenyo at magpapatakbo ng quantum circuit? Ang pinakamadaling paraan para maunawaan ang karaniwang quantum computing workflow ay sa pamamagitan ng mga Qiskit pattern. Ang mga Qiskit pattern ay isang conceptual framework na nagpapahintulot sa mga gumagamit na magpatakbo ng mga quantum workload sa pamamagitan ng pagpapatupad ng ilang mga hakbang gamit ang modular na tooling. Nagbibigay-daan ito sa mga quantum computing task na maisakatuparan ng isang makapangyarihang heterogenous (CPU/GPU/QPU) na computing infrastructure. Ang mga hakbang ay maaaring isagawa bilang serbisyo at maaaring isama ang pamamahala ng resources, na nagbibigay-daan sa seamless na composability ng mga bagong kakayahan habang ito'y nalilikha.

Narito ang mga pangunahing hakbang, na malamang ay marikilala ng mga bihasang gumagamit ng Qiskit.

1. Map. Ang hakbang na ito ay nagpormal kung paano natin kinukuha ang isang pangkalahatang problema na interesado tayo at nalalaman kung paano ito ima-map sa isang quantum computer sa anyo ng isang quantum circuit.

2. Optimize. Sa hakbang na ito ginagamit natin ang transpiler ng Qiskit para i-route at i-lay out ang circuit sa aktwal na physical qubit hardware. Kasama rito ang pagsasalin ng mga indibidwal na quantum gate sa mga sequence ng mga operasyon na isinasagawa sa hardware pati na rin ang pag-optimize sa layout ng mga gate.

3. Execute. Ang mga Qiskit Runtime primitive ay nagbibigay ng interface sa IBM Quantum hardware na nagpapahintulot sa mga transpiled na circuit na mapatakbo. Kasama rin sa hakbang na ito ang paggamit ng mga teknik ng error suppression at mitigation, na halos maaaring i-abstract mula sa gumagamit.

4. Post-process. Sa hakbang na ito ang data mula sa quantum processor mismo ay pinoproseso, nagbibigay sa gumagamit ng mga kapaki-pakinabang na resulta sa orihinal na problema. Essentially, sinasangkot nito ang anumang karagdagang pagsusuri ng data na nakuha.

Map

Ang hakbang na Map ay essentially ay nagtatanong: "Paano ko isasalin ang aking problema sa isang quantum circuit na makatwirang maaaring patakbuhin sa quantum hardware?" Walang duda: ang mapping ay isang mahirap na problema at isang aktibong larangan ng pananaliksik. Walang foolproof na paraan na garantisadong magiging matagumpay, ngunit may mga inirerekomendang alituntunin at mga halimbawa ng mga problema na alam na nating paano ima-map.

Ang unang alituntunin ay hayaan ang mga classical computer na gumawa ng anumang trabaho na mas mahusay sila. Ang mga gawain na madali para sa mga classical computer ay malamang na hindi mabibigyang-benepisyo ng isang quantum computer. Ang mga quantum computer ay para sa mga problemang classically hard. Siyempre, kung ito ang iyong unang pagkakataon gamit ang Qiskit o isang quantum computer, huwag mag-alala sa paghanap ng problema na computationally complex. Hatiin ito sa mas maliliit, bite-sized na mga problema na maaari mong matutunan na harapin bago direktang pumunta sa isang utility-scale na proyekto.

Susunod, isalin ang mga resulta para sa iyong problema na gusto mong sukatin o maunawaan sa isang expectation value o cost function. Ang cost function ay isang problem-specific na function na nagtatukoy ng layunin ng problema bilang isang bagay na ie-minimize o ie-maximize. Maaari itong gamitin para makita kung gaano kahusay ang isang trial state o solusyon na gumagawa kaugnay ng layuning iyon. Ang notion na ito ay maaaring ilapat sa iba't ibang aplikasyon sa kimika, machine learning, pananalapi, optimization, at iba pa — hindi talaga mahalaga kung anong paksa ang iyong pinaglalapitan ng problema.

Isaalang-alang din na ang hardware na gagamitin mo ay may tiyak na topology, tulad ng tinalakay natin sa seksyon ng hardware. Ang ilang qubit ay nakakonekta, at ang ilan ay hindi — kailangan mong ima-map ang iyong problema sa isang circuit na iginagalang ang heavy-hex topology ng mga IBM quantum processor.

Sa ngayon, ang pinakamahalagang bagay na dapat tandaan ay ang stage na ito ay nangangailangan ng pagsasanay. Kailangan mong magkaroon ng mabuting pag-unawa hindi lamang sa iyong problema, kundi pati na rin sa mga kakayahan ng hardware — at daraanan natin ang mga tiyak na halimbawa at use case sa mga susunod na aralin para makita kung paano balansehin ang lahat ng mga konsiderasyon na ito.

Optimize

Susunod, kailangan nating pumili ng isang quantum processor na may sapat na mga qubit ng sapat na kalidad para mapatakbo natin ang ating quantum circuit. Gumawa ng mga desisyong ito ayon sa tatlong sukatan na tinalakay natin sa seksyon ng hardware: bilang ng qubit, EPLG, at CLOPS.

Pagkatapos ay ino-optimize natin ang ating circuit para sa napiling hardware. Una, kailangan nating i-lay out at i-route ang ating circuit nang mahusay. Ang layout ay tumutukoy sa pag-map ng mga virtual qubit sa circuit sa mga physical qubit sa processor. Ang routing ay tumutukoy sa pag-tweak ng circuit para ang koneksyon sa pagitan ng mga virtual qubit sa circuit ay tumutugma sa koneksyon ng mga physical qubit sa processor. May ilang bagay na dapat tandaan sa panahon ng layout at routing stage.

1. Hindi lahat ng qubit ay nakakonekta. Ang ilan ay napakalayo mula sa isa't isa sa chip, at kailangan nating bawasan o alisin ang mga long-distance na interaksyon saan maaari. Maaari kang mag-apply ng isang sequence ng mga SWAP gate sa pagitan ng mga katabing qubit para ilipat ang impormasyon ng mga qubit, ngunit ang mga SWAP gate ay mahal at madaling magkamali, kaya maaaring may mas mahusay na paraan para gawin ito. Subukang iwasan ang masyadong maraming mamahaling SWAP gate.

2. Ang layout at routing ay mga iterative na proseso. Maaari mo itong gawin nang mano-mano, ngunit mayroon ding isang Qiskit tool na tinatawag na mapomatic, na maaaring gumawa ng mga rekomendasyon para sa isang physical qubit layout batay sa approximate na mga error rate. Ang transpiler (na tatalakayin natin sa lalong madaling panahon) ay maaari ring gumawa ng isang impormadong mungkahi.

Susunod, maaari nating pagsamahin ang mga sequence ng one-qubit gate na kumikilos sa parehong qubit sa mga single gate — at kung minsan ay maaari rin tayong magtanggal ng mga hindi kinakailangang gate o kombinasyon ng mga gate. Halimbawa, ang ilang kombinasyon ng mga gate ay maaaring mabawasan sa mas simpleng mga kombinasyon — at sa katunayan, kung minsan ang isang kombinasyon ng mga gate ay maaaring katumbas ng identity operation, kaya maaari na nating alisin ang mga ito. Maaari mong gawin ito awtomatiko gamit ang Qiskit transpiler — ngunit maaari mo rin itong gawin nang mano-mano sa bawat gate kung gusto mo ng mas maraming kontrol.

Kapag napabuti na natin ang circuit layout, routing at bilang ng gate — alinman sa pamamagitan ng kamay o gamit ang transpiler — karaniwang gusto nating i-visualize ang ating circuit para matiyak na ang timing ng lahat ng gate ay makatwiran. Mayroon kang argument na maaaring i-flag sa transpiler para ma-visualize ang timeline ng iyong circuit, at tiyakin na ang lahat ay nakahanay sa paraang inaasahan mo.

Qiskit Transpiler

Tulad ng nabanggit kanina, ang Qiskit Transpiler ay maaaring gamitin para tumulong sa mga maagang yugto ng patterns workflow. Ngayon ay ating pag-aralan nang mas detalyado ang mga kakayahan nito. Maaari nitong isulat muli ang isang ibinigay na input circuit para tumugma sa topology ng isang tiyak na quantum device at i-optimize ang circuit para sa execution at katatagan laban sa ingay. Isinusulat din nito ang isang ibinigay na circuit sa mga basis gate ng tiyak na quantum processor na iyong pinili na gamitin.

Ang Qiskit ay may apat na built-in na transpilation pipeline na naaayon sa iba't ibang antas ng optimization, at maliban kung pamilyar ka na sa quantum circuit optimization, inirerekomenda naming gumamit ng isa sa mga ito. Bilang default, ang proseso ng transpilation ay kinabibilangan ng anim na hakbang na ito:

1. Initialization. Ang stage na ito ay nagpapatakbo ng anumang mga initial pass na kinakailangan bago natin simulan ang pag-embed ng circuit sa backend. Karaniwang kasangkot dito ang pag-unroll ng mga custom na tagubilin at pag-convert ng circuit sa mga single- at two-qubit gate lamang.

2. Layout. Ang stage na ito ay nagma-map ng mga virtual qubit sa circuit sa mga physical qubit sa isang backend. Tingnan ang Layout Stage para sa karagdagang detalye.

3. Routing. Ang stage na ito ay nagpapatakbo pagkatapos mailapat ang isang layout at nag-i-inject ng mga gate (tulad ng mga swap gate) sa orihinal na circuit para gawing compatible ito sa koneksyon ng backend. Tingnan ang Routing Stage para sa karagdagang detalye.

4. Translation. Ang stage na ito ay nagsasalin ng mga gate sa circuit sa target na basis set ng backend. Tingnan ang Translation Stage para sa karagdagang detalye.

5. Optimization. Ang stage na ito ay nagpapatakbo ng pangunahing optimization loop nang paulit-ulit hanggang maabot ang isang kondisyon (tulad ng pagkamit ng isang tiyak na target na depth). Mayroon kaming apat na iba't ibang antas ng optimization na maaaring piliin, na inilarawan sa ibaba.

6. Scheduling. Ang stage na ito ay para sa anumang hardware-aware scheduling pass. Sa mataas na antas, ang scheduling ay maaaring isipin bilang pagpasok ng mga pagkaantala sa circuit para matugunan ang idle time sa mga qubit sa pagitan ng pagpapatupad ng mga tagubilin.

Mayroon apat na antas ng optimization mula 0 hanggang 3, kung saan ang mas mataas na mga antas ng optimization ay nangangailangan ng mas maraming oras at computational na pagsisikap ngunit maaaring makagawa ng mas magandang circuit. Ang optimization level 0 ay inilaan para sa mga eksperimento sa device characterization at, bilang ganyan, nagma-map lamang ng input circuit sa mga hadlang ng target backend, nang hindi nagsasagawa ng anumang pag-optimize. Ang optimization level 3 ay naglalaan ng pinakamaraming pagsisikap para i-optimize ang circuit. Gayunpaman, dahil marami sa mga teknik ng pag-optimize sa transpiler ay batay sa mga heuristics, ang paglalaan ng mas maraming computational na pagsisikap ay hindi palaging nagreresulta sa pagpapabuti ng kalidad ng output circuit. Kung ito ay karagdagang interes, tingnan ang transpiler documentation sa Qiskit documentation.

Error suppression

Ang unang hakbang sa pagbabawas ng mga error sa isang circuit ay ang pag-optimize ng layout, routing, at pagbabawas ng bilang ng gate, na nagawa na natin, alinman gamit ang transpiler o sa ating sarili. Ngayon ay pag-usapan natin ang ilang mas sopistikadong paraan ng error suppression.

Ang error suppression ay tumutukoy sa isang klase ng mga teknik na nagbabago ng circuit sa panahon ng compilation para mabawasan ang mga error. Ito ay naiiba mula sa error mitigation, na tatalakayin natin mamaya sa seksyong "Execute" sa ibaba. Ang dalawang pinakakaraniwang anyo ng error suppression na ginagamit namin ay dynamical decoupling at Pauli twirling:

1. Ang dynamical decoupling ay ginagamit para epektibong kanselahin ang ilang environmental noise na ipinakilala kapag ang isang qubit ay nananatiling idle. Sa pamamagitan ng pag-apply ng isang serye ng mga gate sa mga tiyak na oras, maaari mong gawin na ang noise na naipon sa isang bahagi ng idle period ay humigit-kumulang na nagkakansela ng noise sa kabilang bahagi.
2. Ang Pauli twirling ay isang paraan ng pagpasok ng mga random na gate hindi para kanselahin ang noise, tulad ng sa dynamical decoupling, kundi para pasimplehin ang noise. Sa pamamagitan ng pagpasok ng mga random na gate, pinipigilan nito ang mga epekto ng iba't ibang error na mag-accumulate nang mabilis, at ginagawang mas madaling i-characterize ang noise, dahil ngayon ito ay may stochastic na katangian. Ang pamamaraang ito ay nagsisilbi ring pundasyon ng isang makapangyarihang teknik ng error mitigation, na tatalakayin natin sa ibaba.

Execute

Handa na tayong i-execute ang quantum program. Ang mga Qiskit Runtime primitive ay nagbibigay ng interface sa IBM Quantum hardware, at inaabstract din nila ang error suppression at mitigation mula sa gumagamit. Mayroon dalawang primitive na mapagpipilian: ang Sampler at ang Estimator.

Ang Qiskit Runtime's Sampler ay nagpapatakbo ng circuit nang maraming beses sa isang quantum device, nagsasagawa ng mga pagsukat sa bawat run, at nagtatayo muli ng probability distribution mula sa mga nakuhing bit string. Habang mas maraming run (o shot) ang isinasagawa nito, mas tumpak ang mga resulta, ngunit nangangailangan ito ng mas maraming oras at quantum resources. Specifically, kinakalkula nito ang posibilidad ng pagkuha ng bawat posibleng standard basis state sa pamamagitan ng pagsukat ng estado na inihanda ng circuit.

Ang Qiskit Runtime's Estimator ay gumagamit ng isang kumplikadong algebraic na proseso para tantiyahin ang expectation value sa isang tunay na quantum device sa pamamagitan ng paghahati ng observable sa isang kombinasyon ng iba pang mga observable na may kilalang eigenbases.

Ang hakbang na Execute ay din kapag maaari tayong pumili ng estratehiya ng error mitigation. Ang error mitigation ay tumutukoy sa mga teknik na nagpapahintulot sa mga gumagamit na bawasan ang mga error sa circuit sa pamamagitan ng pag-model ng device noise na naroroon sa oras ng execution. Karaniwang nagreresulta ito sa quantum pre-processing overhead na may kaugnayan sa model training at classical post-processing overhead para mabawasan ang mga error sa mga raw na resulta sa pamamagitan ng paggamit ng nabuong modelo. Kapalit ng overhead na ito, nagagawa nating makakuha ng mas tumpak na mga resulta.

Mayroon maraming teknik na maaari nating ipatupad para sa error mitigation. Tatalakayin natin ang tatlo, sa pataas na pagkakasunud-sunod ng katatagan laban sa mga error, ngunit din, dahil dito, sa pataas na pagkakasunud-sunod ng computational na gastos. Gayunpaman, alamin na ito ay isang aktibong larangan ng pananaliksik — kaya malamang na patuloy tayong magiimbento ng mga bago at magpapabuti sa mga luma.

Sa resilience level 0, ang transpiler ay hindi gumagawa ng anuman sa iyong circuit.

Sa level 1, nagpapakilala ito ng isang pamamaraan na tinatawag na Twirled Readout Error eXtinction (T-REX). Ang T-REX ay gumagamit ng Pauli twirling, tulad ng tinalakay sa seksyon ng error suppression. Tulad ng nabanggit, ang pagpasok ng mga random na gate sa circuit ay maaaring gawing stochastic ang kahit na napaka-kumplikado at mahirap i-model na noise, at mas madaling itama o ibawas sa post-processing.

Sa resilience level 2, idinaragdag ang Zero Noise Extrapolation (ZNE). Ito ay isang popular na teknik na nagkaroon tayo ng maraming kamakailang tagumpay. Ang ideya sa likod ng ZNE ay medyo nakakagulat — talagang nagdadagdag tayo ng noise sa ibabaw ng nasa doon na! Ngunit nagpapahintulot ito sa atin na mag-extrapolate sa kabaligtarang direksyon, para hulaan kung ano ang magiging hitsura ng mga resulta kung may mas kaunti at kaunting noise.

Ang pagdaragdag ng noise ay maaaring maisakatuparan sa ilang iba't ibang paraan. Halimbawa, maaari nating palawakin ang mga gate para gawing mas mahaba ang mga ito at sa gayon, mas madaling magkamali, o magpatakbo ng mas maraming gate na sa huli ay nagresulta sa isang identity operation, kaya ang circuit ay hindi nagbabago sa functional na paraan ngunit sadya tayong nagsa-sample ng mas maraming noise. Kailangan mo itong gawin para sa bawat circuit at bawat expectation value na gusto mong subaybayan, gayunpaman — kaya makikita mo kung paano ito maaaring maging computationally mahal.

Ang isang tiyak na uri ng ZNE ay tinatawag na Probabilistic Error Amplification (PEA). Kapag natuto na tayo ng noise model para sa isang gate, ang PEA ay gumagana sa pamamagitan ng pag-sample ng mga error mula sa noise model na iyon at sadyang naglalagay ng mga ito sa circuit. Hindi ito available sa Qiskit pa, ngunit ito ay magagamit sa susunod na taon.

Ang panghuling anyo ng error mitigation na tatalakayin natin ay Probabilistic Error Cancellation (PEC). Sa halip na nasa 3rd resilience level, ang PEC ay isang espesyal na kakayahan na kailangan mong i-turn on nang mano-mano sa Qiskit, dahil ang mga kinakailangang computational resources ay hindi nagsca-scale nang maayos kumpara sa iba pang mga teknik ng error mitigation. Nagsisimula ka sa pag-aaral tungkol sa noise na nakakaapekto sa iyong circuit — magpatakbo ng mga noise-learning o noise-characterization circuit para sa bawat natatanging layer ng dalawang-qubit na gate sa iyong circuit. Ang mga resultang ito ay nagpapahintulot sa iyo na ilarawan ang noise sa mga tuntunin ng mga Pauli operator. Kapag alam mo na ang mga noise term na ito, maaari mong baguhin ang iyong mga circuit para epektibo nilang itago ang kabaligtarang mga Pauli gate para kanselahin ang mga noise channel na ito. Sa ilang paraan, ang proseso ay katulad ng paraan ng pagtatrabaho ng noise-cancelling headphone. Gayunpaman, ang ganitong paraan ng pag-undo ng noise ay napaka-mahal, na may oras para patakbuhin na lumalaki nang mabilis at exponentially sa bilang ng mga gate, kaya maaaring hindi ito ang pinakamainam na pagpipilian para sa isang napakalaking circuit.

Post-process

Ang post-process stage ay kung saan natin vina-visualize at sinusuri ang output ng ating quantum circuit. Mayroong maraming Qiskit tool na available para gawin ito, tulad ng mga visualization at quantum-info module. Hindi natin ito sasaklawin dito, ngunit makikita natin ang mga module na ito sa aksyon habang sumisid tayo sa ilang halimbawa ng aplikasyon sa mga susunod na aralin.

Konklusyon

Sana ang araling ito ay nagbigay sa iyo ng mabilis na pagtingin sa mga pangunahing konsiderasyon at workflow na ginagamit namin kapag gusto nating magpatakbo ng utility-scale na quantum computation. Puno ito ng impormasyon, at marami dito ay hindi magiging malinaw hanggang makita natin ang ilang aktwal na halimbawa kung saan ang mga theoretical na konsepto na ito ay inilalapat sa pagsasanay. Kaya, iyon ang magiging nilalaman ng natitirang bahagi ng kurso. Pagkatapos ng lahat, hindi walang dahilan ang tawag sa kursong ito na Quantum Computing in Practice!

Sa susunod na pagkakataon, titingnan natin ang isang tiyak na halimbawa ng paggamit ng Qiskit patterns workflow para magdisenyo at magpatakbo ng isang quantum circuit na naglulutas ng klasikong problema mula sa graph theory na tinatawag na MaxCut.