Rychlý start: Odeslání okruhu pomocí Qiskitu do Azure Quantum
Poznámka
Příklady v tomto tématu používají sadu Microsoft Quantum Development Kit (Classic QDK) a zatím nejsou kompatibilní se sadou Azure Quantum Development Kit Preview (Moderní sada QDK). Další informace o moderní sadě QDK najdete na wikiwebu QSharp Na GitHubu.
Zjistěte, jak pomocí azure-quantum
Python balíčku odeslat kvantové obvody Qiskit do kvantových výpočtů target IonQ, Quantinuum nebo Rigetti prostřednictvím služby Azure Quantum. Další informace najdete v tématu Kvantové obvody.
Požadavky
Účet Azure s aktivním předplatným. Vytvořte si zdarma účet.
Vytvořte pracovní prostor Azure Quantum. Další informace najdete v tématu Vytvoření pracovního prostoru Azure Quantum.
Nainstalujte nejnovější
azure-quantum
Python balíček pomocí značky [qiskit].Poznámka
Před instalací nebo aktualizací balíčku azure-quantum odinstalujte na svém počítači všechny verze pyqir, pyqir-* a qiskit-qir, abyste se vyhnuli konfliktům závislostí.
Tip
Pokud používáte Miniconda nebo Anaconda, můžete volitelně vytvořit nové prostředí stažením souboru environment.yml a spuštěním následujícího příkazu:
conda env create -f environment.yml
Tím se vytvoří nové prostředí Conda, které můžete aktivovat pomocí následujícího příkazu:
conda activate azurequantum
Spusťte svůj oblíbený editor kódu nebo interaktivní Python nástroj, jako je VS Code, Jupyter nebo iPython.
Poznámka
Příklady v tomto rychlém startu používají prostředí Jupyter Notebook. Z prostředí Conda spusťte Jupyter Notebook
příkaz .
Načtení požadovaných importů
V aplikaci Jupyter Notebooks vytvořte nový poznámkový blok, který používá Python jádro 3 . V první buňce spusťte následující kód, který načte požadované importy:
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from azure.quantum.qiskit import AzureQuantumProvider
Připojení ke službě Azure Quantum
Pro připojení ke službě Azure Quantum bude váš program potřebovat ID prostředku a umístění pracovního prostoru Azure Quantum. Přihlaste se ke svému účtu Azure , https://portal.azure.compřejděte do svého pracovního prostoru Azure Quantum a zkopírujte hodnoty z hlavičky.
Vložte hodnoty do následujícího AzureQuantumProvider
konstruktoru a vytvořte provider
objekt, který se připojí k vašemu pracovnímu prostoru Azure Quantum.
provider = AzureQuantumProvider(
resource_id="",
location=""
)
Vypsat všechny back-endy
Teď můžete vytisknout všechny back-endy kvantových výpočtů, které jsou k dispozici ve vašem pracovním prostoru:
print("This workspace's targets:")
for backend in provider.backends():
print("- " + backend.name())
This workspace's targets:
- ionq.qpu
- ionq.qpu.aria-1
- ionq.simulator
- microsoft.estimator
- quantinuum.hqs-lt-s1
- quantinuum.hqs-lt-s1-apival
- quantinuum.hqs-lt-s2
- quantinuum.hqs-lt-s2-apival
- quantinuum.hqs-lt-s1-sim
- quantinuum.hqs-lt-s2-sim
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.qpu.h1-2
- quantinuum.sim.h1-2sc
- quantinuum.sim.h1-1e
- quantinuum.sim.h1-2e
- rigetti.sim.qvm
- rigetti.qpu.aspen-11
- rigetti.qpu.aspen-m-2
- rigetti.qpu.aspen-m-3
Spuštění jednoduchého okruhu
Nejprve vytvořte jednoduchý okruh Qiskit, který se má spustit.
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0,1,2], [0, 1, 2])
# Print out the circuit
circuit.draw()
┌───┐ ┌─┐
q_0: ┤ H ├──■───────┤M├──────
└───┘┌─┴─┐ └╥┘┌─┐
q_1: ─────┤ X ├──■───╫─┤M├───
└───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
└───┘ ║ ║ └╥┘
c: 3/════════════════╩══╩══╩═
0 1 2
Pokud chcete rychle získat výsledek zpět, pomocí příkazu provider.get_backend
vytvořte Backend
objekt pro připojení k back-endu simulátoru IonQ:
simulator_backend = provider.get_backend("ionq.simulator")
Back-endy IonQ podporují brány z definované sady bran, které se kompilují tak, aby běžely optimálně na hardwaru. Pokud váš okruh obsahuje brány, které nejsou v tomto seznamu, budete muset provést transpilování do podporované sady bran pomocí transpile
funkce poskytované službou Qiskit:
from qiskit import transpile
circuit = transpile(circuit, simulator_backend)
Tím se vrátí nový objekt okruhu, kde jsou brány rozloženy na brány, které jsou podporovány zadaným back-endem.
Teď můžete program spustit prostřednictvím služby Azure Quantum a získat výsledek. Následující buňka odešle úlohu, která spustí okruh se 100 snímky:
job = simulator_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)
Job id 00000000-0000-0000-0000-000000000000
Pokud chcete monitorovat průběh úlohy, můžete pomocí dříve importované sady Qiskit job_monitor
sledovat stav úlohy. Toto volání se zablokuje, dokud se úloha neskonví:
job_monitor(job)
Job Status: job has successfully run
Pokud chcete počkat na dokončení úlohy a vrátit výsledky, spusťte:
result = job.result()
Tím se vrátí qiskit.Result
objekt .
type(result)
qiskit.result.result.Result
print(result)
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 50, '111': 50}, probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(meas_map='[0, 1, 2]', name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
Vzhledem k tomu, že výsledek je objekt nativní pro balíček Qiskit, můžete k vizualizaci výsledků použít Qiskit result.get_counts
a plot_histogram
. Abyste měli jistotu, že jsou znázorněné všechny možné popisky bitových řetězců, přidejte je do counts
.
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}
Odhad nákladů na úlohu
Před spuštěním úlohy na QPU můžete odhadnout, kolik bude jeho spuštění stát. K odhadu nákladů na spuštění úlohy na QPU můžete použít metodu estimate_cost
:
backend = provider.get_backend("ionq.qpu")
cost = backend.estimate_cost(circuit, shots=1024)
print(f"Estimated cost: {cost.estimated_total}")
Tím se zobrazí odhadované náklady v USD.
Nejnovější podrobnosti o cenách najdete v tématu Ceny ionQ nebo vyhledejte svůj pracovní prostor a zobrazte cenové možnosti na kartě Poskytovatel vašeho pracovního prostoru prostřednictvím : aka.ms/aq/myworkspaces.
Spuštění na IonQ QPU
Pokud se chcete připojit ke skutečnému hardwaru ( QPU( Quantum Processor Unit ), jednoduše zadejte název target"ionq.qpu"
provider.get_backend
metody :
qpu_backend = provider.get_backend("ionq.qpu")
Odešlete okruh ke spuštění v Azure Quantum.
Poznámka
Doba potřebná ke spuštění okruhu na QPU se může lišit v závislosti na aktuální době fronty.
Stejně jako předtím použijte job_monitor
ke sledování stavu úlohy a plot_histogram
k vykreslení výsledků.
# Submit the circuit to run on Azure Quantum
qpu_job = qpu_backend.run(circuit, shots=1024)
job_id = qpu_job.id()
print("Job id", job_id)
# Monitor job progress and wait until complete:
job_monitor(qpu_job)
# Get the job results (this method also waits for the Job to complete):
result = qpu_job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}
Načtení požadovaných importů
V aplikaci Jupyter Notebooks vytvořte nový poznámkový blok, který používá Python jádro 3 . V první buňce spusťte následující kód, který načte požadované importy:
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from azure.quantum.qiskit import AzureQuantumProvider
Připojení ke službě Azure Quantum
Pro připojení ke službě Azure Quantum bude váš program potřebovat ID prostředku a umístění pracovního prostoru Azure Quantum. Přihlaste se ke svému účtu Azure , https://portal.azure.compřejděte do svého pracovního prostoru Azure Quantum a zkopírujte hodnoty z hlavičky.
Vložte hodnoty do následujícího AzureQuantumProvider
konstruktoru a vytvořte provider
objekt, který se připojí k vašemu pracovnímu prostoru Azure Quantum.
provider = AzureQuantumProvider(
resource_id="",
location=""
)
Vypsat všechny back-endy
Poznámka
Nedávno target se změnily názvy pro nástroje Quantinuum Syntax Checker, Emulators a QPU. Aktualizované názvy se používají v tomto tématu. Podrobnosti najdete v tématu o poskytovateli Quantinuum .
Teď můžete vytisknout všechny back-endy kvantových výpočtů, které jsou k dispozici ve vašem pracovním prostoru:
print("This workspace's targets:")
for backend in provider.backends():
print("- " + backend.name())
This workspace's targets:
- ionq.qpu
- ionq.qpu.aria-1
- ionq.simulator
- microsoft.estimator
- quantinuum.hqs-lt-s1
- quantinuum.hqs-lt-s1-apival
- quantinuum.hqs-lt-s2
- quantinuum.hqs-lt-s2-apival
- quantinuum.hqs-lt-s1-sim
- quantinuum.hqs-lt-s2-sim
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.qpu.h1-2
- quantinuum.sim.h1-2sc
- quantinuum.sim.h1-1e
- quantinuum.sim.h1-2e
- rigetti.sim.qvm
- rigetti.qpu.aspen-11
- rigetti.qpu.aspen-m-2
- rigetti.qpu.aspen-m-3
Spuštění v nástroji pro kontrolu syntaxe
Pokud chcete program před spuštěním na hardwaru otestovat, nejprve ho spusťte v nástroji pro kontrolu syntaxe Quantinuum.
Poznámka
Back-end kontroly syntaxe Quantinuum při měření vždy vrátí hodnotu 0.
# Get Quantinuum's syntax checker backend:
syntax_backend = provider.get_backend("quantinuum.sim.h1-1sc")
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0,1,2], [0, 1, 2])
# Print out the circuit
circuit.draw()
┌───┐ ┌─┐
q_0: ┤ H ├──■───────┤M├──────
└───┘┌─┴─┐ └╥┘┌─┐
q_1: ─────┤ X ├──■───╫─┤M├───
└───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
└───┘ ║ ║ └╥┘
c: 3/════════════════╩══╩══╩═
0 1 2
Teď můžete program spustit prostřednictvím služby Azure Quantum a získat výsledek. Následující buňka odešle úlohu, která spustí okruh se 1024 snímky:
# Submit the circuit to run on Azure Quantum
job = syntax_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)
# Monitor job progress and wait until complete:
job_monitor(job)
# Get the job results (this method also waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='quantinuum.qpu.h1-1sc', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 1024}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 1024, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}
Poznámka
Kontrola syntaxe sice zajišťuje úspěšné spuštění kódu na hardwaru Quantinuum, ale vrátí také hodnotu 0 pro každé kvantové měření. Pro skutečné kvantové měření je potřeba spustit okruh na kvantovém hardwaru.
Odhad nákladů na úlohu
Před spuštěním úlohy na QPU můžete odhadnout, kolik bude jeho spuštění stát. K odhadu nákladů na spuštění úlohy na QPU můžete použít metodu estimate_cost
:
qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")
cost = qpu_backend.estimate_cost(circuit, shots=1024)
print(f"Estimated cost: {cost.estimated_total}")
Tím se zobrazí odhadované náklady v kreditech H-System Quantum (HQC).
Nejnovější podrobnosti o cenách najdete v tématu Ceny služby Azure Quantum nebo vyhledejte svůj pracovní prostor a podívejte se na cenové možnosti na kartě Poskytovatel vašeho pracovního prostoru prostřednictvím : aka.ms/aq/myworkspaces.
Spuštění na QPU Quantinuum
Po úspěšném spuštění validátoru rozhraní API můžete úlohu spustit na jednom z hardwarových procesorů společnosti Quantinuum ( QPU )).
Poznámka
Doba potřebná ke spuštění okruhu na QPU se může lišit v závislosti na aktuální době fronty.
# Get Quantinuum's QPU backend:
qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")
# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)
# Monitor job progress and wait until complete:
job_monitor(job)
Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
# Get the job results (this method also waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
Result(backend_name='quantinuum.qpu.h1-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'011': 16, '010': 5, '001': 1, '000': 500, '111': 471, '101': 6, '100': 17, '110': 8}, probabilities={'011': 0.015625, '010': 0.0048828125, '001': 0.0009765625, '000': 0.48828125, '111': 0.4599609375, '101': 0.005859375, '100': 0.0166015625, '110': 0.0078125}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 500, '001': 1, '010': 5, '011': 16, '100': 17, '101': 6, '110': 8, '111': 471}
Načtení požadovaných importů
V aplikaci Jupyter Notebooks vytvořte nový poznámkový blok, který používá Python jádro 3 . V první buňce spusťte následující kód, který načte požadované importy:
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from azure.quantum.qiskit import AzureQuantumProvider
Připojení ke službě Azure Quantum
Pro připojení ke službě Azure Quantum bude váš program potřebovat ID prostředku a umístění pracovního prostoru Azure Quantum. Přihlaste se ke svému účtu Azure , https://portal.azure.compřejděte do svého pracovního prostoru Azure Quantum a zkopírujte hodnoty z hlavičky.
Vložte hodnoty do následujícího AzureQuantumProvider
konstruktoru a vytvořte provider
objekt, který se připojí k vašemu pracovnímu prostoru Azure Quantum.
provider = AzureQuantumProvider(
resource_id="",
location=""
)
Vypsat všechny back-endy
Teď můžete vytisknout všechny back-endy kvantových výpočtů, které jsou k dispozici ve vašem pracovním prostoru:
print("This workspace's targets:")
for backend in provider.backends():
print("- " + backend.name())
This workspace's targets:
- ionq.qpu
- ionq.qpu.aria-1
- ionq.simulator
- microsoft.estimator
- quantinuum.hqs-lt-s1
- quantinuum.hqs-lt-s1-apival
- quantinuum.hqs-lt-s2
- quantinuum.hqs-lt-s2-apival
- quantinuum.hqs-lt-s1-sim
- quantinuum.hqs-lt-s2-sim
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.qpu.h1-2
- quantinuum.sim.h1-2sc
- quantinuum.sim.h1-1e
- quantinuum.sim.h1-2e
- rigetti.sim.qvm
- rigetti.qpu.aspen-11
- rigetti.qpu.aspen-m-2
- rigetti.qpu.aspen-m-3
Spuštění na simulátoru QVM
Pokud chcete program před spuštěním na hardwaru otestovat, nejprve ho spusťte v simulátoru Rigetti QVM.
# Get Rigetti's QVM simulator backend:
qvm_backend = provider.get_backend("rigetti.sim.qvm")
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0,1,2], [0, 1, 2])
# Print out the circuit
circuit.draw()
┌───┐ ┌─┐
q_0: ┤ H ├──■───────┤M├──────
└───┘┌─┴─┐ └╥┘┌─┐
q_1: ─────┤ X ├──■───╫─┤M├───
└───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
└───┘ ║ ║ └╥┘
c: 3/════════════════╩══╩══╩═
0 1 2
Teď můžete program spustit prostřednictvím služby Azure Quantum a získat výsledek. Následující buňka odešle úlohu, která spustí okruh se 1024 snímky:
# Submit the circuit to run on Azure Quantum
job = qvm_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)
# Monitor job progress and wait until complete:
job_monitor(job)
# Get the job results (this method also waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='rigetti.sim.qvm"', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 1024}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 1024, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}
Spuštění na QPU Rigetti
Po úspěšném spuštění na simulátoru QVM můžete úlohu spustit na jednom z hardwarových procesorů společnosti Rigetti ( QPU )).
Poznámka
Doba potřebná ke spuštění okruhu na QPU se může lišit v závislosti na aktuální době fronty.
# Get Rigetti's QPU backend:
qpu_backend = provider.get_backend("rigetti.qpu.aspen-m-3")
# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=500)
job_id = job.id()
print("Job id", job_id)
# Monitor job progress and wait until complete:
job_monitor(job)
Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
# Get the job results (this method also waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
Result(backend_name='rigetti.qpu.aspen-m-3', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'011': 16, '010': 5, '001': 1, '000': 500, '111': 471, '101': 6, '100': 17, '110': 8}, probabilities={'011': 0.015625, '010': 0.0048828125, '001': 0.0009765625, '000': 0.48828125, '111': 0.4599609375, '101': 0.005859375, '100': 0.0166015625, '110': 0.0078125}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 500, '001': 1, '010': 5, '011': 16, '100': 17, '101': 6, '110': 8, '111': 471}
Důležité
Odesílání více okruhů v jedné úloze se v současné době nepodporuje. Jako alternativní řešení můžete volat metodu backend.run
, která asynchronně odešle každý okruh a pak načte výsledky jednotlivých úloh. Příklad:
jobs = []
for circuit in circuits:
jobs.append(backend.run(circuit, shots=N))
results = []
for job in jobs:
results.append(job.result())