Jak przesłać obwód za pomocą platformy Cirq do usługi Azure Quantum

Dowiedz się, jak przesłać obwód kwantowy Cirq przy użyciu azure-quantumPython pakietu. Obwody Cirq 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.

Aby uzyskać więcej informacji, zobacz Quantum circuits (Obwody kwantowe).

Uwaga

Zestaw Microsoft Quantum Development Kit (klasyczny zestaw QDK) nie będzie już obsługiwany po 30 czerwca 2024 r. Jeśli jesteś istniejącym deweloperem zestawu QDK, zalecamy przejście do nowego zestawu Azure Quantum Development Kit (Modern QDK), aby kontynuować opracowywanie rozwiązań kwantowych. Aby uzyskać więcej informacji, zobacz Migrowanie kodu Q# do nowoczesnego zestawu QDK.

Wymagania wstępne

Aby uzyskać szczegółowe informacje na temat instalacji, zobacz Instalowanie nowoczesnego 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 Pip .

• Program VS Code z zainstalowanym zestawem Azure Quantum Development Kit i Pythonrozszerzeniami Jupyter.

• Pakiet Azure Quantum azure-quantum z tagiem [cirq] oraz pakietami qsharp i ipykernel .

  python -m pip install --upgrade azure-quantum[cirq] qsharp ipykernel 
  

  Uwaga

  Jeśli nie wykryto jądra ipykernel JupyterPython, program VS Code wyświetli monit o jego zainstalowanie.

Tworzenie nowego notesu Jupyter

1. W programie VS Code wybierz pozycję Wyświetl paletę poleceń i wybierz pozycję Utwórz: nowy notes Jupyter.>
2. W prawym górnym rogu program VS Code wykryje i wyświetli wersję środowiska wirtualnego PythonPython 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.cirq import AzureQuantumService

Połączenie do usługi Azure Quantum

Aby nawiązać połączenie z usługą Azure Quantum, program będzie potrzebować identyfikatora zasobu i lokalizacji obszaru roboczego usługi Azure Quantum.

1. Zaloguj się do konta platformy Azure, https://portal.azure.com,

2. Wybierz obszar roboczy usługi Azure Quantum i przejdź do obszaru Przegląd.

3. Skopiuj parametry w polach.

   

Dodaj nową komórkę i użyj informacji o koncie, aby utworzyć Workspace obiekty i AzureQuantumService 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")
    )

service = AzureQuantumService(workspace)

Wyświetl listę wszystkich targets

targets()Użyj metody , aby wyświetlić listę wszystkich targets elementów w obszarze roboczym, które mogą uruchamiać obwód, w tym bieżący czas kolejki i dostępność.

Uwaga

targets Wszystkie elementy w obszarze roboczym mogą nie być wyświetlane — tylko targets te, które mogą akceptować obwód Cirq lub OpenQASM, zostaną wymienione tutaj.

print(service.targets())

[<Target name="quantinuum.qpu.h1-1", avg. queue time=0 s, Degraded>,
<Target name="quantinuum.sim.h1-1sc", avg. queue time=1 s, Available>,
<Target name="quantinuum.sim.h1-1e", avg. queue time=40 s, Available>,
<Target name="ionq.qpu", avg. queue time=229 s, Available>,
<Target name="ionq.simulator", avg. queue time=3 s, Available>,
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>]

Tworzenie prostego obwodu

Następnie utwórz prosty obwód Cirq do uruchomienia. Ten obwód używa pierwiastek kwadratowy bramy X natywny dla systemu sprzętowego IonQ.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0)**0.5,             # Square root of X
    cirq.CX(q0, q1),              # CNOT
    cirq.measure(q0, q1, key='b') # Measure both qubits
)
print(circuit)

0: ───X^0.5───@───M────────
              │   │
1: ───────────X───M────────

Wybierz element target , aby uruchomić program

IonQ

Uruchamianie w symulatorze IonQ

Teraz możesz uruchomić program za pośrednictwem usługi Azure Quantum i uzyskać wynik. Poniższa komórka przesyła zadanie (do domyślnego symulatora IonQ), które uruchamia obwód z 100 strzałami, czeka na zakończenie zadania i zwraca wyniki.

result = service.run(program=circuit, repetitions=100, target="ionq.simulator")

Spowoduje to zwrócenie cirq.Result obiektu.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Szacowanie kosztu zadania

Przed uruchomieniem zadania w QPU można oszacować, ile będzie kosztować uruchomienie. Aby oszacować koszt uruchamiania zadania w QPU, możesz użyć estimate_cost metody :

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="ionq.qpu"
)

print(f"Estimated cost: {cost.estimated_total}")

Spowoduje to wyświetlenie szacowanych kosztów w USD.

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

Poprzednie zadanie zostało uruchomione w symulatorze domyślnym. "ionq.simulator" Można jednak również uruchomić go na procesorze sprzętowym IonQ (jednostka procesora kwantowego (QPU)). Aby uruchomić na QPU IonQ, podaj "ionq.qpu" jako target argument:

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu",
    timeout_seconds=500 # Set timeout to accommodate queue time on QPU
)

Ponownie zwraca cirq.Result to obiekt.

print(result)

b=0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111, 0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111

Model asynchroniczny przy użyciu zadań

W przypadku długotrwałych obwodów może być przydatne ich asynchroniczne uruchamianie. Metoda service.create_job zwraca Job obiekt, którego można użyć, aby uzyskać wyniki po pomyślnym uruchomieniu zadania.

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="ionq.simulator"
)

Aby sprawdzić stan zadania, użyj polecenia job.status():

print(job.status())

'completed'

Aby poczekać na ukończenie zadania, a następnie uzyskać wyniki, użyj wywołania job.results()blokującego :

result = job.results()
print(result)

00: 0.5
11: 0.5

Należy pamiętać, że nie zwraca cirq.Result to obiektu. Zamiast tego zwraca obiekt wynikowy specyficzny dla symulatora IonQ i używa prawdopodobieństwa stanu zamiast danych strzałów.

type(result)

cirq_ionq.results.SimulatorResult

Aby przekonwertować to na cirq.Result obiekt, użyj polecenia result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Quantinuum

Uruchamianie w symulatorze Quantinuum

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, czeka na zakończenie zadania i zwraca wyniki.

result = service.run(program=circuit, repetitions=100, target="quantinuum.sim.h1-1sc")

Spowoduje to zwrócenie cirq.Result obiektu.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Wyniki można wykreślić na histogramie:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Patrząc na histogram, można zauważyć, że generator liczb losowych zwrócił 0 za każdym razem, co nie jest bardzo losowe. Jest to spowodowane tym, że podczas gdy moduł sprawdzania poprawności interfejsu API gwarantuje, że kod zostanie pomyślnie uruchomiony na sprzęcie Quantinuum, zwraca również wartość 0 dla każdego pomiaru kwantowego. W przypadku rzeczywistego generatora liczb losowych należy uruchomić obwód na sprzęcie kwantowym.

Szacowanie kosztu zadania

Przed uruchomieniem zadania w QPU można oszacować, ile będzie kosztować uruchomienie. Aby oszacować koszt uruchamiania zadania w QPU, możesz użyć estimate_cost metody .

Uwaga

Aby uruchomić oszacowanie kosztów względem kwantuum target, należy najpierw ponownie załadować pakiet azure-quantumPython za pomocą parametru [qiskit] i upewnić się, że masz najnowszą wersję zestawu Qiskit. Aby uzyskać więcej informacji, zobacz Aktualizowanie pakietu azure-quantumPython.

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

print(f"Estimated cost: {cost.estimated_total}")

Spowoduje to wydrukowanie szacowanych kosztów w systemach H-System Credit (HQCs).

Aby uzyskać najbardziej aktualne szczegóły cennika, zobacz Cennik usługi Azure Quantum lub znajdź obszar roboczy i wyświetl opcje cennika na karcie "Dostawca" obszaru roboczego za pośrednictwem: aka.ms/aq/myworkspaces.

Asynchroniczny przepływ pracy przy użyciu zadań

W przypadku długotrwałych obwodów może być przydatne ich asynchroniczne uruchamianie. Metoda service.create_job zwraca Job obiekt, którego można użyć, aby uzyskać wyniki po pomyślnym uruchomieniu zadania.

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h1-1sc"
)

Aby sprawdzić stan zadania, użyj polecenia job.status():

print(job.status())

'Waiting'

Aby poczekać na ukończenie zadania, a następnie uzyskać wyniki, użyj wywołania job.results()blokującego :

result = job.results()
print(result)

    {'m_b': ['00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00']}

Należy pamiętać, że nie zwraca cirq.Result to obiektu. Zamiast tego zwraca słownik wyników pomiaru ciągu bitowego indeksowany przez klucz miary.

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

1. Zaloguj się do witryny Azure Portal i wybierz obszar roboczy z poprzedniego kroku.
2. W bloku po lewej stronie wybierz pozycję Notesy.
3. Kliknij pozycję Moje notesy i kliknij pozycję Dodaj nowy.
4. Wpisz nazwę pliku, na przykład Cirq.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ć dodatkowy moduł.

Kliknij pozycję + Kod , aby dodać nową komórkę, a następnie dodaj i uruchom następujący kod:

from azure.quantum.cirq import AzureQuantumService

Połączenie do usługi Azure Quantum

Następnie utwórz AzureQuantumService 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 = AzureQuantumService(workspace)

Definiowanie prostego obwodu

Następnie utwórz prosty obwód Cirq do uruchomienia. Ten obwód używa pierwiastek kwadratowy bramy X natywny dla systemu sprzętowego IonQ.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0)**0.5,             # Square root of X
    cirq.CX(q0, q1),              # CNOT
    cirq.measure(q0, q1, key='b') # Measure both qubits
)
print(circuit)

0: ───X^0.5───@───M────────
              │   │
1: ───────────X───M────────

Wyświetl listę wszystkich targets

targets()Użyj metody , aby wyświetlić listę wszystkich targets elementów w obszarze roboczym, które mogą uruchamiać obwód, w tym bieżący czas kolejki i dostępność.

Uwaga

targets Wszystkie elementy w obszarze roboczym mogą nie być wyświetlane — tylko targets te, które mogą akceptować obwód Cirq lub OpenQASM, zostaną wymienione tutaj.

print("This workspace's targets:")
for target in service.targets():
     print(target)

This workspace's targets:
<Target name="quantinuum.qpu.h1-1", avg. queue time=0 s, Degraded>
<Target name="quantinuum.sim.h1-1sc", avg. queue time=1 s, Available>
<Target name="quantinuum.sim.h1-1e", avg. queue time=40 s, Available>
<Target name="ionq.qpu", avg. queue time=229 s, Available>
<Target name="ionq.simulator", avg. queue time=3 s, Available>
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>

Uwaga

Pełna lista target może być inna dla obszaru roboczego.

Wybierz element target , aby uruchomić program

IonQ

Uruchamianie w symulatorze IonQ

Aby sprawdzić obwód przed uruchomieniem go na rzeczywistym sprzęcie kwantowym, możesz użyć symulatora IonQ, ionq.simulator.

Poniższa komórka przesyła zadanie, które uruchamia obwód z 100 strzałami, czeka na zakończenie zadania i zwraca wyniki.

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.simulator"
)

Spowoduje to zwrócenie cirq.Result obiektu.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Wyniki można wykreślić na histogramie:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Szacowanie kosztu zadania

Przed uruchomieniem zadania na rzeczywistym sprzęcie kwantowym lub jednostce przetwarzania kwantowego (QPU) można oszacować, ile będzie kosztować uruchomienie. Aby oszacować koszt uruchamiania zadania w QPU, możesz użyć estimate_cost metody :

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="ionq.qpu"
)

print(f"Estimated cost: {cost.estimated_total}")

Estimated cost: 1

Spowoduje to wyświetlenie szacowanych kosztów w USD.

Aby uzyskać najbardziej aktualne szczegóły cennika, zobacz Cennik IonQ lub wyświetl opcje cennika w bloku Dostawcy obszaru roboczego. Aby wyświetlić bieżący stan i użycie środków, wybierz pozycję Środki i limity przydziału.

Uruchamianie na QPU IonQ

Poprzednie zadanie zostało uruchomione w symulatorze domyślnym. ionq.simulator Można jednak również uruchomić go na procesorze sprzętowym IonQ lub jednostce procesora kwantowego (QPU). Aby uruchomić na QPU IonQ, podaj ionq.qpu jako target argument:

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu",
    timeout_seconds=500 # Set timeout to accommodate queue time on QPU
)

Uwaga

Czas wymagany do uruchomienia obwodu na QPU zależy od bieżących czasów kolejki. Średni czas kolejki dla elementu target można wyświetlić, wybierając blok Dostawcy obszaru roboczego.

Ponownie zwraca cirq.Result to obiekt.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Model asynchroniczny przy użyciu zadań

W przypadku długotrwałych obwodów może być przydatne ich asynchroniczne uruchamianie. Metoda service.create_job zwraca Job obiekt, którego można użyć, aby uzyskać wyniki po pomyślnym uruchomieniu zadania.

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="ionq.simulator"
)

Aby sprawdzić stan zadania, użyj polecenia job.status():

print(job.status())

'completed'

Aby poczekać na ukończenie zadania, a następnie uzyskać wyniki, użyj wywołania job.results()blokującego :

result = job.results()
print(result)

00: 0.5
11: 0.5

Uwaga

Funkcja job.results() nie zwraca cirq.Result obiektu. Zamiast tego zwraca obiekt wynikowy specyficzny dla symulatora IonQ i używa prawdopodobieństwa stanu zamiast danych strzałów.

type(result)

cirq_ionq.results.SimulatorResult

Aby przekonwertować to na cirq.Result obiekt, użyj polecenia result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Quantinuum

Uruchamianie w modułze sprawdzania poprawności interfejsu API

Aby sprawdzić obwód przed uruchomieniem go na rzeczywistym sprzęcie kwantowym, możesz użyć modułu sprawdzania poprawności interfejsu API Quantinuum, quantinuum.sim.h1-1sc.

Dodaj następującą komórkę, która przesyła zadanie do uruchomienia obwodu z 100 strzałami lub powtórzeniami, czeka na zakończenie zadania i zwraca wyniki:

result = service.run(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h1-1sc"
)

Spowoduje to zwrócenie cirq.Result obiektu.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Wyniki można wykreślić na histogramie:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Patrząc na histogram, można zauważyć, że generator liczb losowych zwrócił 0 za każdym razem, co nie jest bardzo losowe. Jest to spowodowane tym, że podczas gdy moduł sprawdzania poprawności interfejsu API gwarantuje, że kod zostanie pomyślnie uruchomiony na sprzęcie Quantinuum, zwraca również wartość 0 dla każdego pomiaru kwantowego. W przypadku rzeczywistego generatora liczb losowych należy uruchomić obwód na sprzęcie kwantowym.

Szacowanie kosztu zadania

Przed uruchomieniem zadania na rzeczywistym sprzęcie kwantowym lub jednostce przetwarzania kwantowego (QPU) można oszacować, ile będzie kosztować uruchomienie. Aby oszacować koszt uruchamiania zadania w QPU, możesz użyć estimate_cost metody :

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

print(f"Estimated cost: {cost.estimated_total}")

Estimated cost: 5.42

Spowoduje to wyświetlenie szacowanych kosztów w H-System Quantum Credit (HQCs).

Aby uzyskać najbardziej aktualne szczegóły cennika, zobacz Cennik usługi Azure Quantum lub wyświetl opcje cennika w bloku Dostawcy obszaru roboczego. Aby wyświetlić bieżący stan i użycie środków, wybierz pozycję Środki i limity przydziału.

Uruchamianie na kwantinuum QPU

Po pomyślnym uruchomieniu modułu sprawdzania poprawności interfejsu API i oszacowaniu kosztu QPU nadszedł czas na uruchomienie obwodu na sprzęcie.

Uwaga

Czas wymagany do uruchomienia obwodu na QPU zależy 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ć zadanie i wyświetlić wyniki:

result = service.run(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Widać, że wyniki są teraz podzielone z grubsza między 0 i 1.

Asynchroniczny przepływ pracy przy użyciu zadań

W przypadku długotrwałych obwodów może być przydatne ich asynchroniczne uruchamianie. Metoda service.create_job zwraca Job obiekt, którego można użyć, aby uzyskać wyniki po pomyślnym uruchomieniu zadania.

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

Aby sprawdzić stan zadania, użyj polecenia job.status():

print(job.status())

'Waiting'

Aby poczekać na ukończenie zadania, a następnie uzyskać wyniki, użyj wywołania job.results()blokującego :

result = job.results()
print(result)

{'m_b': ['11', '11', '00', '11', '00', '00', '00', '00', '11', '00', '00', '11', '00', '00', '00', '00', '11', '11', '11', '00', '11', '00', '00', '11', '11', '11', '11', '00', '00', '00', '00', '00', '00', '11', '11', '00', '11', '00', '11', '11', '00', '00', '00', '11', '11', '00', '00', '11', '11', '11', '00', '00', '11', '11', '11', '11', '00', '00', '11', '11', '00', '11', '11', '00', '00', '00', '11', '11', '11', '11', '11', '00', '00', '11', '00', '11', '11', '11', '11', '00', '11', '00', '00', '00', '01', '11', '11', '00', '00', '11', '11', '11', '11', '00', '00', '00', '11', '00', '11', '00']}

Uwaga

Funkcja job.results() nie zwraca cirq.Result obiektu. Zamiast tego zwraca słownik wyników pomiaru bitów indeksowanych przez klucz miary.

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())

Następne kroki

• Szybki start: przesyłanie obwodu za pomocą zestawu Qiskit do usługi Azure Quantum.
• Szybki start: przesyłanie obwodu z formatem specyficznym dla dostawcy do usługi Azure Quantum.