Een circuit met Cirq verzenden naar Azure Quantum

Meer informatie over het verzenden van een Cirq-kwantumcircuit met behulp van het azure-quantumPython pakket. U kunt Cirq-circuits verzenden naar Azure Quantum met behulp van de Azure Quantum-notebook, die een ingebouwd azure-quantumPython pakket hebben of vanaf uw lokale computer.

Zie Quantum-circuits voor meer informatie.

Vereisten

Zie De QDK-extensie instellenvoor installatiedetails.

• Een Azure Quantum-werkruimte in uw Azure-abonnement. Zie Een Azure Quantum-werkruimte maken om een werkruimte te maken.

• Een Python omgeving waarop Python Pip is geïnstalleerd.

• VS Code met de Azure Quantum Development KitPython en Jupyter-extensies geïnstalleerd.

• Het Azure Quantum-pakket azure-quantum met de tag [cirq] en de qsharpipykernel pakketten.

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

  Notitie

  Als de Jupyter-kernel Pythonipykernel niet wordt gedetecteerd, wordt u door VS Code gevraagd deze te installeren.

Een nieuw Jupyter-notebook maken

1. Selecteer in VS Code het > Weergeven en selecteer Maken: Nieuw Jupyter Notebook.
2. In de rechterbovenhoek detecteert en geeft VS Code de versie van Python en de virtuele Python omgeving weer die is geselecteerd voor het notebook. Als u meerdere Python omgevingen hebt, moet u mogelijk een kernel selecteren met behulp van de kernelkiezer in de rechterbovenhoek. Als er geen omgeving is gedetecteerd, raadpleegt u Jupyter Notebooks in VS Code voor informatie over de installatie.

De vereiste importbewerkingen laden

Voer in de eerste cel van uw notebook de volgende code uit om de vereiste importbewerkingen te laden:

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

Verbinding maken met de Azure Quantum-service

Als u verbinding wilt maken met de Azure Quantum-service, heeft uw programma de resource-id en de locatie van uw Azure Quantum-werkruimte nodig.

1. Meld u aan bij uw Azure-account, https://portal.azure.com

2. Selecteer uw Azure Quantum-werkruimte en navigeer naar Overzicht.

3. Kopieer de parameters in de velden.

   

Voeg een nieuwe cel toe en gebruik uw accountgegevens om objecten te maken Workspace en AzureQuantumService objecten om verbinding te maken met uw Azure Quantum-werkruimte.

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

service = AzureQuantumService(workspace)

Alles weergeven targets

Gebruik de targets()methode om alle targets in uw werkruimte weer te geven die uw circuit kan uitvoeren, inclusief de huidige wachtrijtijd en beschikbaarheid.

Notitie

targets Alle in uw werkruimte worden mogelijk niet vermeld. Alleen de targets die een Cirq- of OpenQASM-circuit kan accepteren, wordt hier vermeld.

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

Een eenvoudig circuit maken

Maak vervolgens een eenvoudig Cirq-circuit dat moet worden uitgevoerd. Dit circuit maakt gebruik van de vierkantswortel van X-poort, systeemeigen voor het IonQ-hardwaresysteem.

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

Selecteer een target om uw programma uit te voeren

IonQ

Uitvoeren op IonQ-simulator

U kunt het programma nu uitvoeren via de Azure Quantum-service en het resultaat ophalen. De volgende cel verzendt een taak (naar de standaard IonQ-simulator) die het circuit met 100 shots uitvoert, wacht totdat de taak is voltooid en retourneert de resultaten.

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

Hiermee wordt een cirq.Result object geretourneerd.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Taakkosten schatten

Voordat u een taak uitvoert op de QPU, moet u schatten hoeveel het kost om uit te voeren.

Zie IonQ-prijzen voor de meest recente prijsinformatie of zoek uw werkruimte en bekijk prijsopties op het tabblad Provider van uw werkruimte via: aka.ms/aq/myworkspaces.

Uitvoeren op IonQ QPU

De vorige taak is uitgevoerd op de standaardsimulator. "ionq.simulator" U kunt deze echter ook uitvoeren op de hardwareprocessor van IonQ (een Quantum Processor Unit (QPU)). Als u wilt uitvoeren op de IonQ QPU, geeft u "ionq.qpu.aria-1" het target volgende op:

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

Nogmaals, hiermee wordt een cirq.Result object geretourneerd.

print(result)

b=0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111, 0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111

Asynchroon model met behulp van taken

Voor langlopende circuits kan het handig zijn om ze asynchroon uit te voeren. De service.create_job methode retourneert een Job object, dat u kunt gebruiken om de resultaten te verkrijgen nadat de taak is uitgevoerd.

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

Als u de taakstatus wilt controleren, gebruikt u job.status():

print(job.status())

'completed'

Als u wilt wachten tot de taak is voltooid en vervolgens de resultaten wilt ophalen, gebruikt u de blokkeringsoproep job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Houd er rekening mee dat hiermee geen object wordt geretourneerd cirq.Result . In plaats daarvan wordt een resultaatobject geretourneerd dat specifiek is voor de IonQ-simulator en statuskansen gebruikt in plaats van schotgegevens.

type(result)

cirq_ionq.results.SimulatorResult

Als u dit wilt converteren naar een cirq.Result object, gebruikt u result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Quantinuum

Uitvoeren op Quantinuum-simulator

U kunt het programma nu uitvoeren via de Azure Quantum-service en het resultaat ophalen. De volgende cel verzendt een taak die het circuit met 100 shots uitvoert, wacht totdat de taak is voltooid en retourneert de resultaten.

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

Hiermee wordt een cirq.Result object geretourneerd.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

U kunt de resultaten in een histogram uitzetten:

import pylab as pl

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

Als u naar het histogram kijkt, ziet u mogelijk dat de generator voor willekeurige getallen elke keer 0 heeft geretourneerd, wat niet erg willekeurig is. Dit komt doordat de API Validator ervoor zorgt dat uw code correct wordt uitgevoerd op Quantinuum-hardware, maar ook 0 retourneert voor elke kwantummeting. Voor een echte generator voor willekeurige getallen moet u uw circuit uitvoeren op kwantumhardware.

Taakkosten schatten

Voordat u een taak uitvoert op de QPU, moet u schatten hoeveel het kost om uit te voeren.

Zie Azure Quantum-prijzen voor de meest recente prijsinformatie of zoek uw werkruimte en bekijk de prijsopties op het tabblad Provider van uw werkruimte via: aka.ms/aq/myworkspaces.

Asynchrone werkstroom met taken

Voor langlopende circuits kan het handig zijn om ze asynchroon uit te voeren. De service.create_job methode retourneert een Job object, dat u kunt gebruiken om de resultaten te verkrijgen nadat de taak is uitgevoerd.

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

Als u de taakstatus wilt controleren, gebruikt u job.status():

print(job.status())

'Waiting'

Als u wilt wachten tot de taak is voltooid en vervolgens de resultaten wilt ophalen, gebruikt u de blokkeringsoproep 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']}

Houd er rekening mee dat hiermee geen object wordt geretourneerd cirq.Result . In plaats daarvan wordt een woordenlijst geretourneerd met resultaten van bittekenreeksmetingen geïndexeerd op maatsleutel.

Vereisten

• Een Azure-account met een actief abonnement. Als u geen Azure-account hebt, registreert u zich gratis en registreert u zich voor een abonnement op basis van betalen per gebruik.
• Een Azure Quantum-werkruimte. Zie Een Azure Quantum-werkruimte maken voor meer informatie.

Een nieuw notitieblok maken in uw werkruimte

1. Meld u aan bij Azure Portal en selecteer de werkruimte in de vorige stap.
2. Selecteer Notitieblokken op de linkerblade.
3. Klik op Mijn notitieblokken en klik op Nieuw toevoegen.
4. Typ een naam voor het bestand, bijvoorbeeld Cirq.ipynb, en klik op Bestand maken.

Wanneer uw nieuwe notitieblok wordt geopend, wordt automatisch de code voor de eerste cel gemaakt op basis van uw abonnement en werkruimtegegevens.

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

Notitie

Tenzij anders vermeld, moet u elke cel in de gewenste volgorde uitvoeren terwijl u deze maakt om compilatieproblemen te voorkomen.

Klik op het driehoekige afspeelpictogram links van de cel om de code uit te voeren.

De vereiste importbewerkingen laden

Eerst moet u een extra module importeren.

Klik op + Code om een nieuwe cel toe te voegen en voeg de volgende code toe en voer deze uit:

from azure.quantum.cirq import AzureQuantumService

Verbinding maken met de Azure Quantum-service

Maak vervolgens een AzureQuantumService object met behulp van het workspace object uit de vorige cel om verbinding te maken met uw Azure Quantum-werkruimte. Voeg een nieuwe cel toe met de volgende code:

provider = AzureQuantumService(workspace)

Een eenvoudig circuit definiëren

Maak vervolgens een eenvoudig Cirq-circuit dat moet worden uitgevoerd. Dit circuit maakt gebruik van de vierkantswortel van X-poort, systeemeigen voor het IonQ-hardwaresysteem.

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

Alles weergeven targets

Gebruik de targets()methode om alle targets in uw werkruimte weer te geven die uw circuit kan uitvoeren, inclusief de huidige wachtrijtijd en beschikbaarheid.

Notitie

targets Alle in uw werkruimte worden mogelijk niet vermeld. Alleen de targets die een Cirq- of OpenQASM-circuit kan accepteren, wordt hier vermeld.

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>

Notitie

De volledige lijst met target werkruimten kan afwijken.

Selecteer een target om uw programma uit te voeren

IonQ

Uitvoeren op de IonQ-simulator

Als u uw circuit wilt controleren voordat u het uitvoert op de daadwerkelijke kwantumhardware, kunt u de IonQ-simulator gebruiken. ionq.simulator

De volgende cel verzendt een taak die het circuit met 100 shots uitvoert, wacht totdat de taak is voltooid en retourneert de resultaten.

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

Hiermee wordt een cirq.Result object geretourneerd.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

U kunt de resultaten in een histogram uitzetten:

import pylab as pl

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

Taakkosten schatten

Voordat u een taak uitvoert op werkelijke kwantumhardware of een QPU (Kwantumverwerkingseenheid ), moet u schatten hoeveel het kost om uit te voeren.

Zie IonQ-prijzen voor de meest recente prijsinformatie of bekijk prijsopties op de blade Providers van uw werkruimte. Als u de huidige kredietstatus en het huidige gebruik wilt zien, selecteert u Tegoeden en quota.

Uitvoeren op IonQ QPU

De vorige taak is uitgevoerd op de standaardsimulator. ionq.simulator U kunt deze echter ook uitvoeren op de hardwareprocessor van IonQ of QPU (Quantum Processor Unit ). Als u wilt uitvoeren op de IonQ QPU, geeft u ionq.qpu.aria-1 het target volgende op:

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

Notitie

De tijd die nodig is om een circuit uit te voeren op de QPU, is afhankelijk van de huidige wachtrijtijden. U kunt de gemiddelde wachtrijtijd voor een target weergeven door de blade Providers van uw werkruimte te selecteren.

Nogmaals, hiermee wordt een cirq.Result object geretourneerd.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Asynchroon model met behulp van taken

Voor langlopende circuits kan het handig zijn om ze asynchroon uit te voeren. De service.create_job methode retourneert een Job object, dat u kunt gebruiken om de resultaten te verkrijgen nadat de taak is uitgevoerd.

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

Als u de taakstatus wilt controleren, gebruikt u job.status():

print(job.status())

'completed'

Als u wilt wachten tot de taak is voltooid en vervolgens de resultaten wilt ophalen, gebruikt u de blokkeringsoproep job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Notitie

De job.results() functie retourneert cirq.Result geen object. In plaats daarvan wordt een resultaatobject geretourneerd dat specifiek is voor de IonQ-simulator en statuskansen gebruikt in plaats van schotgegevens.

type(result)

cirq_ionq.results.SimulatorResult

Als u dit wilt converteren naar een cirq.Result object, gebruikt u result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Quantinuum

Uitvoeren op de API Validator

Als u uw circuit wilt controleren voordat u het uitvoert op daadwerkelijke kwantumhardware, kunt u de Quantinuum API Validator gebruiken. quantinuum.sim.h1-1sc

Voeg de volgende cel toe waarmee een taak wordt verzonden om het circuit uit te voeren met 100 shots of herhalingen, wacht totdat de taak is voltooid en retourneert de resultaten:

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

Hiermee wordt een cirq.Result object geretourneerd.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

U kunt de resultaten in een histogram uitzetten:

import pylab as pl

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

Als u naar het histogram kijkt, ziet u mogelijk dat de generator voor willekeurige getallen elke keer 0 heeft geretourneerd, wat niet erg willekeurig is. Dit komt doordat de API Validator ervoor zorgt dat uw code correct wordt uitgevoerd op Quantinuum-hardware, maar ook 0 retourneert voor elke kwantummeting. Voor een echte generator voor willekeurige getallen moet u uw circuit uitvoeren op kwantumhardware.

Taakkosten schatten

Voordat u een taak uitvoert op werkelijke kwantumhardware of een QPU (Kwantumverwerkingseenheid ), moet u schatten hoeveel het kost om uit te voeren.

Zie Azure Quantum-prijzen of bekijk de prijsopties op de blade Providers van uw werkruimte voor de meest recente prijsinformatie. Als u de huidige kredietstatus en het huidige gebruik wilt zien, selecteert u Tegoeden en quota.

Uitvoeren op een Quantinuum QPU

Nadat de API-validator is uitgevoerd en de QPU-kosten zijn geschat, is het tijd om uw circuit uit te voeren op de hardware.

Notitie

De tijd die nodig is om een circuit uit te voeren op de QPU, is afhankelijk van de huidige wachtrijtijden. U kunt de gemiddelde wachtrijtijd voor een target weergeven door de blade Providers van uw werkruimte te selecteren.

Gebruik dezelfde run methode en bewerkingen die u eerder met de API Validator hebt gebruikt om uw taak in te dienen en de resultaten weer te geven:

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

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

U kunt zien dat de resultaten nu ongeveer zijn verdeeld tussen 0 en 1.

Asynchrone werkstroom met taken

Voor langlopende circuits kan het handig zijn om ze asynchroon uit te voeren. De service.create_job methode retourneert een Job object, dat u kunt gebruiken om de resultaten te verkrijgen nadat de taak is uitgevoerd.

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

Als u de taakstatus wilt controleren, gebruikt u job.status():

print(job.status())

'Waiting'

Als u wilt wachten tot de taak is voltooid en vervolgens de resultaten wilt ophalen, gebruikt u de blokkeringsoproep 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']}

Notitie

De job.results() functie retourneert cirq.Result geen object. In plaats daarvan retourneert het een woordenlijst met bitstringmetingsresultaten die zijn geïndexeerd met de meetsleutel.

Belangrijk

Het verzenden van meerdere circuits op één taak wordt momenteel niet ondersteund. Als tijdelijke oplossing kunt u de backend.run methode aanroepen om elk circuit asynchroon te verzenden en vervolgens de resultaten van elke taak op te halen. Voorbeeld:

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

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

Gerelateerde inhoud

• Quickstart: Een circuit met Qiskit verzenden naar Azure Quantum.
• Quickstart: Een circuit met een providerspecifieke indeling verzenden naar Azure Quantum.