Skicka en krets med Cirq till Azure Quantum

Lär dig hur du skickar en Cirq-kvantkrets med hjälp av azure-quantumPython paketet. Du kan skicka Cirq-kretsar till Azure Quantum med hjälp av Notebook-filen Azure Quantum, som har ett inbyggt azure-quantumPython paket eller från din lokala dator.

Mer information finns i Kvantkretsar.

Förutsättningar

Installationsinformation finns i Konfigurera QDK-tillägget.

• En Azure Quantum-arbetsyta i din Azure-prenumeration. Information om hur du skapar en arbetsyta finns i Skapa en Azure Quantum-arbetsyta.

• En Python miljö med Python och Pip installerat.

• VS Code med Azure Quantum Development Kit- Pythonoch Jupyter-tillägg installerade.

• Azure Quantum-paketet azure-quantum med taggen [cirq] och paketen qsharpipykernel och .

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

  Kommentar

  Om Jupyter-kerneln Pythonipykernel inte identifieras uppmanar VS Code dig att installera den.

Skapa en ny Jupyter Notebook

1. I VS Code väljer du Visa > kommandopalett och väljer Skapa: Ny Jupyter Notebook.
2. Längst upp till höger identifierar och visar VS Code den version av Python och den virtuella Python miljö som har valts för notebook-filen. Om du har flera Python miljöer kan du behöva välja en kernel med hjälp av kernelväljaren längst upp till höger. Om ingen miljö har identifierats kan du läsa mer i Jupyter Notebooks i VS Code .

Läs in nödvändiga importer

I den första cellen i anteckningsboken kör du följande kod för att läsa in de importer som krävs:

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

Ansluta till Azure Quantum-tjänsten

För att ansluta till Azure Quantum-tjänsten behöver ditt program resurs-ID och platsen för din Azure Quantum-arbetsyta.

1. Logga in på ditt Azure-konto, https://portal.azure.com,

2. Välj din Azure Quantum-arbetsyta och gå till Översikt.

3. Kopiera parametrarna i fälten.

   

Lägg till en ny cell och använd din kontoinformation för att skapa Workspace och AzureQuantumService objekt för att ansluta till din Azure Quantum-arbetsyta.

workspace = Workspace(  
    resource_id = "", # Add the resourceID of your workspace
    location = "" # Add the location of your workspace (for example "westus")
    )

service = AzureQuantumService(workspace)

Visa en lista över alla targets

targets()Använd metoden för att lista alla targets i din arbetsyta som kan köra kretsen, inklusive aktuell kötid och tillgänglighet.

Kommentar

targets Alla i din arbetsyta kanske inte visas – endast de targets som kan acceptera en Cirq- eller OpenQASM-krets visas här.

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.simulator", avg. queue time=3 s, Available>,
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>]

Skapa en enkel krets

Skapa sedan en enkel Cirq-krets som ska köras. Den här kretsen använder kvadratroten av X-grinden, som är inbyggd i IonQ-maskinvarusystemet.

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────────

Välj en target för att köra programmet

IonQ

Kör på IonQ-simulator

Nu kan du köra programmet via Azure Quantum-tjänsten och få resultatet. Följande cell skickar ett jobb (till standardsimulatorn för IonQ) som kör kretsen med 100 skott, väntar tills jobbet är klart och returnerar resultatet.

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

Detta returnerar ett cirq.Result objekt.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Beräkna jobbkostnad

Innan du kör ett jobb på QPU:n bör du uppskatta hur mycket det kommer att kosta att köra.

Den senaste prisinformationen finns i IonQ-priser eller hitta din arbetsyta och visa prisalternativ på fliken "Provider" på arbetsytan via: aka.ms/aq/myworkspaces.

Kör på IonQ QPU

Det tidigare jobbet kördes på standardsimulatorn, "ionq.simulator". Du kan dock också köra den på IonQ:s maskinvaruprocessor (en kvantprocessorenhet (QPU)). Om du vill köra på IonQ QPU anger du "ionq.qpu.aria-1" som 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
)

Återigen returnerar detta ett cirq.Result objekt.

print(result)

b=0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111, 0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111

Asynkron modell med jobb

För långvariga kretsar kan det vara användbart att köra dem asynkront. Metoden service.create_job returnerar ett Job objekt som du kan använda för att hämta resultatet när jobbet har körts.

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

Om du vill kontrollera jobbstatusen använder du job.status():

print(job.status())

'completed'

Om du vill vänta tills jobbet har slutförts och sedan hämta resultaten använder du blockeringsanropet job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Observera att detta inte returnerar ett cirq.Result objekt. I stället returneras ett resultatobjekt som är specifikt för IonQ-simulatorn och använder tillståndsannolikheter i stället för skottdata.

type(result)

cirq_ionq.results.SimulatorResult

Om du vill konvertera detta till ett cirq.Result objekt använder du result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Quantinuum

Kör på Quantinuum-simulatorn

Nu kan du köra programmet via Azure Quantum-tjänsten och få resultatet. Följande cell skickar ett jobb som kör kretsen med 100 skott, väntar tills jobbet är klart och returnerar resultatet.

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

Detta returnerar ett cirq.Result objekt.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Du kan rita resultatet i ett histogram:

import pylab as pl

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

När du tittar på histogrammet kanske du märker att slumptalsgeneratorn returnerade 0 varje gång, vilket inte är särskilt slumpmässigt. Detta beror på att även om API Validator ser till att koden körs korrekt på Quantinuum-maskinvara, returnerar den också 0 för varje kvantmätning. För en verklig slumptalsgenerator måste du köra kretsen på kvantmaskinvara.

Beräkna jobbkostnad

Innan du kör ett jobb på QPU:n bör du uppskatta hur mycket det kommer att kosta att köra.

Den senaste prisinformationen finns i Priser för Azure Quantum eller hitta din arbetsyta och visa prisalternativ på fliken "Provider" på arbetsytan via: aka.ms/aq/myworkspaces.

Asynkront arbetsflöde med jobb

För långvariga kretsar kan det vara användbart att köra dem asynkront. Metoden service.create_job returnerar ett Job objekt som du kan använda för att hämta resultatet när jobbet har körts.

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

Om du vill kontrollera jobbstatusen använder du job.status():

print(job.status())

'Waiting'

Om du vill vänta tills jobbet har slutförts och sedan hämta resultaten använder du blockeringsanropet 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']}

Observera att detta inte returnerar ett cirq.Result objekt. I stället returneras en ordlista med bitsträngsmätningsresultat indexerade efter måttnyckel.

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration. Om du inte har något Azure-konto registrerar du dig kostnadsfritt och registrerar dig för en betala per användning-prenumeration.
• En Azure Quantum-arbetsyta. Mer information finns i Skapa en Azure Quantum-arbetsyta.

Skapa en ny notebook-fil på din arbetsyta

1. Logga in på Azure Portal och välj arbetsytan från föregående steg.
2. Välj Notebooks på det vänstra bladet.
3. Klicka på Mina anteckningsböcker och klicka på Lägg till ny.
4. Skriv ett namn på filen, till exempel Cirq.ipynb, och klicka på Skapa fil.

När den nya notebook-filen öppnas skapas automatiskt koden för den första cellen baserat på din prenumerations- och arbetsyteinformation.

from azure.quantum import Workspace
workspace = Workspace ( 
  resource_id = "", # Add your resource_id 
  location = ""  # Add your workspace location (for example, "westus") 
)

Kommentar

Om inget annat anges bör du köra varje cell i ordning när du skapar den för att undvika kompileringsproblem.

Klicka på den triangulära uppspelningsikonen till vänster om cellen för att köra koden.

Läs in nödvändiga importer

Först måste du importera ytterligare en modul.

Klicka på + Kod för att lägga till en ny cell och lägg sedan till och kör följande kod:

from azure.quantum.cirq import AzureQuantumService

Ansluta till Azure Quantum-tjänsten

Skapa sedan ett AzureQuantumService objekt med hjälp av workspace objektet från föregående cell för att ansluta till din Azure Quantum-arbetsyta. Lägg till en ny cell med följande kod:

provider = AzureQuantumService(workspace)

Definiera en enkel krets

Skapa sedan en enkel Cirq-krets som ska köras. Den här kretsen använder kvadratroten av X-grinden, som är inbyggd i IonQ-maskinvarusystemet.

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────────

Visa en lista över alla targets

targets()Använd metoden för att lista alla targets i din arbetsyta som kan köra kretsen, inklusive aktuell kötid och tillgänglighet.

Kommentar

targets Alla i din arbetsyta kanske inte visas – endast de targets som kan acceptera en Cirq- eller OpenQASM-krets visas här.

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.simulator", avg. queue time=3 s, Available>
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>

Kommentar

Den fullständiga listan över target kan vara annorlunda för din arbetsyta.

Välj en target för att köra programmet

IonQ

Kör på IonQ-simulatorn

Om du vill kontrollera kretsen innan du kör den på den faktiska kvantmaskinvaran kan du använda IonQ-simulatorn. ionq.simulator

Följande cell skickar ett jobb som kör kretsen med 100 skott, väntar tills jobbet är klart och returnerar resultatet.

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

Detta returnerar ett cirq.Result objekt.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Du kan rita resultatet i ett histogram:

import pylab as pl

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

Beräkna jobbkostnad

Innan du kör ett jobb på den faktiska kvantmaskinvaran eller en kvantbearbetningsenhet (QPU) bör du uppskatta hur mycket det kommer att kosta att köra.

Den senaste prisinformationen finns i IonQ-priser eller visa prisalternativ på bladet Providers på din arbetsyta. Om du vill se din aktuella kreditstatus och användning väljer du Krediter och kvoter.

Kör på IonQ QPU

Det tidigare jobbet kördes på standardsimulatorn, ionq.simulator. Men du kan också köra den på IonQ:s maskinvaruprocessor eller Quantum Processor Unit (QPU). Om du vill köra på IonQ QPU anger du ionq.qpu.aria-1 som 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
)

Kommentar

Den tid som krävs för att köra en krets på QPU:n beror på aktuella kötider. Du kan visa den genomsnittliga kötiden för en target genom att välja bladet Providers för din arbetsyta.

Återigen returnerar detta ett cirq.Result objekt.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Asynkron modell med jobb

För långvariga kretsar kan det vara användbart att köra dem asynkront. Metoden service.create_job returnerar ett Job objekt som du kan använda för att hämta resultatet när jobbet har körts.

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

Om du vill kontrollera jobbstatusen använder du job.status():

print(job.status())

'completed'

Om du vill vänta tills jobbet har slutförts och sedan hämta resultaten använder du blockeringsanropet job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Kommentar

Funktionen job.results() returnerar inte ett cirq.Result objekt. I stället returneras ett resultatobjekt som är specifikt för IonQ-simulatorn och använder tillståndsannolikheter i stället för skottdata.

type(result)

cirq_ionq.results.SimulatorResult

Om du vill konvertera detta till ett cirq.Result objekt använder du result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Quantinuum

Kör på API-validatorn

Om du vill kontrollera kretsen innan du kör den på den faktiska kvantmaskinvaran kan du använda Quantinuum API Validator, quantinuum.sim.h1-1sc.

Lägg till följande cell som skickar ett jobb för att köra kretsen med 100 skott, eller upprepningar, väntar tills jobbet är klart och returnerar resultatet:

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

Detta returnerar ett cirq.Result objekt.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Du kan rita resultatet i ett histogram:

import pylab as pl

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

När du tittar på histogrammet kanske du märker att slumptalsgeneratorn returnerade 0 varje gång, vilket inte är särskilt slumpmässigt. Detta beror på att även om API Validator ser till att koden körs korrekt på Quantinuum-maskinvara, returnerar den också 0 för varje kvantmätning. För en verklig slumptalsgenerator måste du köra kretsen på kvantmaskinvara.

Beräkna jobbkostnad

Innan du kör ett jobb på den faktiska kvantmaskinvaran eller en kvantbearbetningsenhet (QPU) bör du uppskatta hur mycket det kommer att kosta att köra.

Den senaste prisinformationen finns i Priser för Azure Quantum eller visa prisalternativ på bladet Providers på din arbetsyta. Om du vill se din aktuella kreditstatus och användning väljer du Krediter och kvoter.

Kör på en QPU för Quantinuum

När du har kört api-validatorn och beräknat kostnaden för QPU är det dags att köra kretsen på maskinvaran.

Kommentar

Den tid som krävs för att köra en krets på QPU:n beror på aktuella kötider. Du kan visa den genomsnittliga kötiden för en target genom att välja bladet Providers för din arbetsyta.

Använd samma run metod och åtgärder som du använde tidigare med API Validator för att skicka jobbet och visa resultatet:

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

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

Du kan se att resultatet nu är ungefär uppdelat mellan 0 och 1.

Asynkront arbetsflöde med jobb

För långvariga kretsar kan det vara användbart att köra dem asynkront. Metoden service.create_job returnerar ett Job objekt som du kan använda för att hämta resultatet när jobbet har körts.

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

Om du vill kontrollera jobbstatusen använder du job.status():

print(job.status())

'Waiting'

Om du vill vänta tills jobbet har slutförts och sedan hämta resultaten använder du blockeringsanropet job.results():

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']}

Kommentar

Funktionen job.results() returnerar inte ett cirq.Result objekt. I stället returneras en ordlista med bitsträngsmätningsresultat indexerade efter måttnyckel.

Viktigt!

Det går för närvarande inte att skicka flera kretsar på ett enda jobb. Som en lösning kan du anropa backend.run metoden för att skicka varje krets asynkront och sedan hämta resultatet av varje jobb. Till exempel:

jobs = []
for circuit in circuits:
    jobs.append(backend.run(circuit, shots=N))

results = []
for job in jobs:
    results.append(job.result())

Relaterat innehåll

• Snabbstart: Skicka en krets med Qiskit till Azure Quantum.
• Snabbstart: Skicka en krets med ett providerspecifikt format till Azure Quantum.