Jak przesłać obwód za pomocą zestawu Qiskit do usługi Azure Quantum
Dowiedz się, jak przesłać obwód kwantowy Qiskit przy użyciu azure-quantumPython pakietu. Obwody Qiskit można przesyłać do usługi Azure Quantum przy użyciu notesu usługi Azure Quantum, który ma wbudowany azure-quantumPython pakiet lub z komputera lokalnego. Możesz również przetestować obwody przy użyciu lokalnego symulatora rozrzedzego.
Aby uzyskać więcej informacji, zobacz Quantum circuits (Obwody kwantowe).
Wymagania wstępne
Aby uzyskać szczegółowe informacje na temat instalacji, zobacz Instalowanie zestawu QDK w programie VS Code.
Obszar roboczy usługi Azure Quantum w ramach subskrypcji platformy Azure. Aby utworzyć obszar roboczy, zobacz Tworzenie obszaru roboczego usługi Azure Quantum.
Środowisko Python z zainstalowanym programem Python i programem .
Program VS Code z zainstalowanym zestawem Azure Quantum Development Kit i Pythonrozszerzeniami Jupyter.
Pakiet Azure Quantum
azure-quantumPython z tagiem [qiskit].python -m pip install --upgrade azure-quantum[qiskit] qsharp ipykernelWażne
Upewnij się, że masz najnowszą wersję zestawu Qiskit. Aby uzyskać więcej informacji, zobacz Aktualizowanie pakietu azure-quantumPython.
Uwaga
Jeśli nie wykryto jądra
ipykernelJupyterPython, program VS Code wyświetli monit o jego zainstalowanie.
Tworzenie nowego notesu Jupyter
- W programie VS Code wybierz pozycję Wyświetl paletę poleceń i wybierz pozycję Utwórz: nowy notes Jupyter.>
- W prawym górnym rogu program VS Code wykryje i wyświetli wersję środowiska wirtualnego Python Python wybranego dla notesu. Jeśli masz wiele Python środowisk, może być konieczne wybranie jądra przy użyciu selektora jądra w prawym górnym rogu. Jeśli środowisko nie zostało wykryte, zobacz Jupyter Notebooks in VS Code (Notesy Jupyter Notebooks w programie VS Code ), aby uzyskać informacje o konfiguracji.
Ładowanie wymaganych importów
W pierwszej komórce notesu uruchom następujący kod, aby załadować wymagane importy:
import azure.quantum
from azure.quantum import Workspace
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider
Nawiązywanie połączenia z usługą Azure Quantum
Aby nawiązać połączenie z usługą Azure Quantum, potrzebny jest identyfikator zasobu i lokalizacja obszaru roboczego usługi Azure Quantum.
Zaloguj się do konta platformy Azure, https://portal.azure.com,
Wybierz obszar roboczy usługi Azure Quantum i przejdź do obszaru Przegląd.
Skopiuj parametry w polach.
Dodaj nową komórkę w notesie i użyj informacji o koncie, aby utworzyć Workspace obiekty i AzureQuantumProvider połączyć się z obszarem roboczym usługi Azure Quantum.
workspace = Workspace(
resource_id = "", # Add the resourceID of your workspace
location = "" # Add the location of your workspace (for example "westus")
)
provider = AzureQuantumProvider(workspace)
Wyświetlanie listy wszystkich zapleczy
Teraz możesz wydrukować wszystkie zaplecza obliczeń kwantowych, które są dostępne w obszarze roboczym:
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.sim.h1-1e
- rigetti.sim.qvm
Uruchamianie prostego obwodu
Najpierw utwórz prosty obwód Qiskit do uruchomienia.
# 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
Wybierz element target , aby uruchomić program
Uruchamianie w symulatorze IonQ
Przed uruchomieniem rzeczywistego sprzętu przetestujmy obwód w symulatorze. Użyj get_backend polecenia , aby utworzyć obiekt w celu nawiązania połączenia z zapleczem Backend symulatora IonQ:
simulator_backend = provider.get_backend("ionq.simulator")
Zaplecza IonQ obsługują bramy ze zdefiniowanego zestawu bram, które są kompilowane w celu optymalnego działania na sprzęcie. Jeśli obwód zawiera bramy, które nie znajdują się na tej liście, należy przeprowadzić transpilowanie do obsługiwanej gateset funkcji udostępnionej transpile przez zestaw Qiskit:
from qiskit import transpile
circuit = transpile(circuit, simulator_backend)
Funkcja transpilu zwraca nowy obiekt obwodu, w którym bramy są rozłożone na bramy obsługiwane w określonym zapleczu.
Teraz możesz uruchomić program za pośrednictwem usługi Azure Quantum i uzyskać wynik. Poniższa komórka przesyła zadanie, które uruchamia obwód z 100 strzałami:
job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)
Job id 00000000-0000-0000-0000-000000000000
Aby poczekać na ukończenie zadania i zwrócić wyniki, uruchom polecenie:
result = job.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=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
Ponieważ wynik jest obiektem natywnym dla pakietu Qiskit, możesz użyć zestawu Qiskit result.get_counts i plot_histogram zwizualizować wyniki. Aby upewnić się, że wszystkie możliwe etykiety bitów są reprezentowane, dodaj je do elementu counts.
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}
Możesz również użyć funkcji do wyświetlania get_memory() pojedynczych danych zdjęć z zadania
result.get_memory(circuit)
['000', '000', '000', '000', '111', '111', '111', '111']
Uwaga
Na IonQ targets, jeśli prześlesz zadanie z nieparzystą liczbą zdjęć, wyniki zostaną zaokrąglone w dół do następnej liczby parzystej. Jeśli na przykład określisz 9 zdjęć, wyniki będą wyświetlać dane dla 8 zdjęć.
Szacowanie kosztu zadania
Przed uruchomieniem zadania w QPU należy oszacować, ile kosztuje jego uruchomienie.
Aby uzyskać najbardziej aktualne szczegóły cennika, zobacz Cennik IonQ lub znajdź obszar roboczy i wyświetl opcje cennika na karcie "Dostawca" obszaru roboczego za pośrednictwem: aka.ms/aq/myworkspaces.
Uruchamianie na QPU IonQ
Aby nawiązać połączenie z rzeczywistym sprzętem (jednostka procesora kwantowego (QPU)), wystarczy podać nazwę target"ionq.qpu.aria-1" get_backend metody :
qpu_backend = provider.get_backend("ionq.qpu.aria-1")
Prześlij obwód do uruchomienia w usłudze Azure Quantum, pobierz wyniki i uruchom polecenie plot_histogram , aby wykreślić wyniki.
Uwaga
Czas wymagany do uruchomienia obwodu na QPU może się różnić w zależności od bieżących czasów kolejki.
# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)
# Get the job results (this method 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='ionq.qpu.aria-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={'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}
Ważne
Przesyłanie wielu obwodów w jednym zadaniu nie jest obecnie obsługiwane. Aby obejść ten problem, możesz wywołać backend.run metodę , aby przesłać każdy obwód asynchronicznie, a następnie pobrać wyniki każdego zadania. Na przykład:
jobs = []
for circuit in circuits:
jobs.append(backend.run(circuit, shots=N))
results = []
for job in jobs:
results.append(job.result())
Wymagania wstępne
- Konto platformy Azure z aktywną subskrypcją. Jeśli nie masz konta platformy Azure, zarejestruj się bezpłatnie i zarejestruj się w celu korzystania z subskrypcji z płatnością zgodnie z rzeczywistym użyciem.
- Obszar roboczy usługi Azure Quantum. Aby uzyskać więcej informacji, zobacz Tworzenie obszaru roboczego usługi Azure Quantum.
Tworzenie nowego notesu w obszarze roboczym
- Zaloguj się do witryny Azure Portal i wybierz obszar roboczy utworzony w poprzednim kroku.
- W bloku po lewej stronie wybierz pozycję Notesy.
- Kliknij pozycję Moje notesy i kliknij pozycję Dodaj nowy.
- Wpisz nazwę pliku, na przykład Qiskit.ipynb, a następnie kliknij przycisk Utwórz plik.
Po otwarciu nowego notesu automatycznie tworzy kod dla pierwszej komórki na podstawie informacji o subskrypcji i obszarze roboczym.
from azure.quantum import Workspace
workspace = Workspace (
resource_id = "", # Add your resource_id
location = "" # Add your workspace location (for example, "westus")
)
Uwaga
O ile nie określono inaczej, należy uruchomić każdą komórkę w kolejności tworzenia, aby uniknąć problemów z kompilacją.
Kliknij trójkątną ikonę "odtwórz" po lewej stronie komórki, aby uruchomić kod.
Ładowanie wymaganych importów
Najpierw należy zaimportować kilka dodatkowych modułów.
Kliknij pozycję + Kod , aby dodać nową komórkę, a następnie dodaj i uruchom następujący kod:
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider
Nawiązywanie połączenia z usługą Azure Quantum
Następnie utwórz AzureQuantumProvider obiekt przy użyciu Workspace obiektu z poprzedniej komórki, aby nawiązać połączenie z obszarem roboczym usługi Azure Quantum. Dodaj nową komórkę z następującym kodem:
provider = AzureQuantumProvider(workspace)
Definiowanie prostego obwodu
W nowej komórce utwórz circuit obiekt. Ten przykład to prosty kwantowy generator bitów losowych. Dodaj następujący kod, aby zdefiniować i wyświetlić obwód:
# 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
Wyświetl listę wszystkich targets
Teraz możesz wyświetlić wszystkie obliczenia targetskwantowe lub zaplecza, które są dostępne w obszarze roboczym. Dodaj nową komórkę i uruchom następujący wiersz:
print("This workspace's targets:")
for backend in provider.backends():
print("- " + backend.name())
This workspace's targets:
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
Wybierz element target , aby uruchomić program
Aby sprawdzić kod przed uruchomieniem go na rzeczywistym sprzęcie kwantowym, możesz użyć symulatora kwantowego IonQ, ionq.simulator.
Dodaj nową komórkę i utwórz obiekt reprezentujący symulator targetkwantowy IonQ :
# Get IonQ quantum simulator target:
simulator_backend = provider.get_backend("ionq.simulator")
Uruchamianie w symulatorze IonQ
Aby uruchomić obwód w symulatorze, dodaj następujący kod. W tym przykładzie użyto run metody target , aby przesłać zadanie, a następnie monitoruje stan zadania.
# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)
Po pomyślnym uruchomieniu zadania pobierz wyniki zadania i wyświetl je:
# Get the job results:
result = job.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=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
Ponieważ ten result typ jest obiektem natywnym dla pakietu Qiskit, możesz użyć zestawów Qiskit result.get_counts i plot_histogram zwizualizować wyniki. Aby upewnić się, że wszystkie możliwe etykiety bitów są reprezentowane, dodaj je do elementu counts.
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}
Możesz również użyć funkcji do wyświetlania get_memory() pojedynczych danych zdjęć z zadania
result.get_memory(circuit)
['000', '000', '000', '000', '111', '111', '111', '111']
Uwaga
Na IonQ targets, jeśli prześlesz zadanie z nieparzystą liczbą zdjęć, wyniki zostaną zaokrąglone w dół do następnej liczby parzystej. Jeśli na przykład określisz 9 zdjęć, wyniki będą wyświetlać dane dla 8 zdjęć.
Szacowanie kosztu zadania
Przed uruchomieniem zadania na rzeczywistym sprzęcie kwantowym lub jednostce przetwarzania kwantowego (QPU) należy oszacować, ile kosztuje jego uruchomienie.
Aby uzyskać najbardziej aktualne szczegóły cennika, zobacz Cennik IonQ lub znajdź obszar roboczy i wyświetl opcje cennika w bloku Dostawcy obszaru roboczego.
Uruchamianie na QPU IonQ
Po pomyślnym uruchomieniu zadania w symulatorze IonQ i oszacowaniu kosztu QPU nadszedł czas na uruchomienie obwodu na sprzęcie.
Uwaga
Czas wymagany do uruchomienia obwodu na QPU różni się w zależności od bieżących czasów kolejki. Średni czas kolejki dla elementu target można wyświetlić, wybierając blok Dostawcy obszaru roboczego.
Użyj tej samej run metody i operacji, które były wcześniej używane z modułem sprawdzania poprawności interfejsu API, aby przesłać i monitorować zadanie:
# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)
Po zakończeniu zadania pobierz wyniki zadania tak jak poprzednio i wyświetl je na wykresie:
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 910b5ac8-98cd-11ec-b3ba-00155d5528cf
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='Job id 54e8c740-98d9-11ec-b382-00155d957f5d', 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}
Ważne
Przesyłanie wielu obwodów w jednym zadaniu nie jest obecnie obsługiwane. Aby obejść ten problem, możesz wywołać backend.run metodę , aby przesłać każdy obwód asynchronicznie, a następnie pobrać wyniki każdego zadania. Na przykład:
jobs = []
for circuit in circuits:
jobs.append(backend.run(circuit, shots=N))
results = []
for job in jobs:
results.append(job.result())
Wymagania wstępne
Aby uzyskać szczegółowe informacje na temat instalacji, zobacz Instalowanie zestawu Quantum Development Kit w programie VS Code.
Środowisko Python z zainstalowanym programem Python i programem .
Program VS Code z zainstalowanym zestawem Azure Quantum Development Kit i Python rozszerzeniami.
Pakiet Azure Quantum
qsharpPython z tagamiqiskitiwidget.python pip install "qsharp[qiskit,widgets]>=1.9"Ważne
Upewnij się, że masz najnowszą wersję zestawu Qiskit. Aby uzyskać więcej informacji, zobacz Aktualizowanie pakietu azure-quantumPython.
Uruchamianie obwodu podstawowego
W programie VS Code otwórz nowy Python plik, aby zdefiniować i uruchomić obwód podstawowy przy użyciu wbudowanego symulatora rozrzedzeniowego w pakiecie Qsharp.
# load the required imports
from qiskit.circuit.random import random_circuit
from qsharp.interop.qiskit import QSharpBackend
# define and display the circuit
circuit = random_circuit(2, 2, measure=True)
print(circuit)
# run the circuit using the built-in sparse simulator
backend = QSharpBackend()
job = backend.run(circuit)
counts = job.result().get_counts()
print(counts)
Aby uruchomić program, wybierz ikonę Uruchom w prawym górnym rogu i wybierz pozycję Uruchom Python plik. Dane wyjściowe zostaną wyświetlone w nowym oknie terminalu.
┌─────────────────────────┐┌─┐
q_0: ─■───────────┤0 ├┤M├───
│P(0.79983) │ (XX-YY)(1.9337,1.7385) │└╥┘┌─┐
q_1: ─■───────────┤1 ├─╫─┤M├
└─────────────────────────┘ ║ └╥┘
c: 2/═════════════════════════════════════════╩══╩═
0 1
{'11': 680, '00': 344}