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 zestawu Azure Quantum Development Kit (QDK) i notesu Jupyter w programie Visual Studio Code (VS Code) z komputera lokalnego.

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

Wymagania wstępne

Aby uzyskać szczegółowe informacje na temat instalacji, zobacz Konfigurowanie rozszerzenia zestawu QDK.

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 Python i Pip.
Program VS Code z zainstalowanym zestawem Azure Quantum Development Kit i Python rozszerzeniami Jupyter.
Pakiet Azure Quantum azure-quantum z elementem dodatkowym cirq, oraz pakietami qdk i ipykernel.
```
python -m pip install --upgrade "azure-quantum[cirq]" qdk ipykernel 
```
Uwaga

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

Utwórz nowy notatnik Jupyter

W programie VS Code otwórz menu Widok i wybierz pozycję Paleta poleceń.
Wprowadź i wybierz Utwórz: Nowy Jupyter Notebook.
Program VS Code wykrywa i wyświetla wersję Python oraz wybrane dla notesu środowisko wirtualne Python. 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, aby uzyskać informacje dotyczące konfiguracji.

Załaduj wymagane importy

W pierwszej komórce notesu uruchom następujący kod, aby załadować wymagane importy:

import azure.quantum
from azure.quantum.cirq import AzureQuantumService

Nawiązywanie połączenia z usługą 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.

Zaloguj się do konta platformy Azure, https://portal.azure.com,
Wybierz obszar roboczy usługi Azure Quantum i przejdź do Przegląd.
Skopiuj parametry w polach.

Dodaj nową komórkę i użyj informacji o koncie, aby utworzyć obiekty Workspace i AzureQuantumService, które będą połączone 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

Użyj metody targets(), aby wyświetlić listę wszystkich targets zasobów w obszarze roboczym, które mogą uruchomić Twój obwód, w tym aktualny czas oczekiwania i dostępność.

Uwaga

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

print(service.targets())

[<Target name="quantinuum.qpu.h2-1", avg. queue time=0 s, Degraded>,
<Target name="quantinuum.sim.h2-1sc", avg. queue time=1 s, Available>,
<Target name="quantinuum.sim.h2-1e", avg. queue time=40 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 w celu uruchomienia. Ten obwód używa pierwiastka kwadratowego z bramy X, natywnego 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 opcję target, aby uruchomić program

JonQ powiedział:
Quantinuum (Kwantowo-Liczbowy)

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

Zwraca obiekt cirq.Result.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Szacowanie kosztu zadania

Przed uruchomieniem zadania w QPU należy oszacować, ile będzie kosztować 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.

Uruchom 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)). Do uruchomienia na QPU IonQ, podaj "ionq.qpu.aria-1" jako target argument:

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

Ponownie zwraca obiekt cirq.Result.

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 i następnie uzyskać wyniki, użyj blokującego wywołania job.results().

result = job.results()
print(result)

00: 0.5
11: 0.5

Należy pamiętać, że to nie zwraca obiektu cirq.Result. 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

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.h2-1sc")

Zwraca obiekt cirq.Result.

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 należy oszacować, ile będzie kosztować uruchomienie.

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ń

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

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

print(job.status())

'Waiting'

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

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 to nie zwraca obiektu cirq.Result. Zamiast tego zwraca słownik wyników pomiaru ciągu bitowego indeksowany przez klucz miary.

Ważne

Przesyłanie wielu obwodów w jednym zadaniu nie jest obecnie obsługiwane. W celu obejścia problemu, możesz wywołać metodę backend.run , aby przesłać każdy obwód asynchronicznie, a następnie uzyskać 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())

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-10-17

Udostępnij przez

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

Wymagania wstępne

Utwórz nowy notatnik Jupyter

Załaduj wymagane importy

Nawiązywanie połączenia z usługą Azure Quantum

Wyświetl listę wszystkich targets

Tworzenie prostego obwodu

Wybierz opcję target, aby uruchomić program

Uruchamianie w symulatorze IonQ

Szacowanie kosztu zadania

Uruchom na QPU IonQ

Model asynchroniczny przy użyciu zadań

Sprzężenie zwrotne

Dodatkowe źródła