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 het Azure Quantum-notebook, dat een ingebouwd azure-quantumPython pakket heeft, of vanaf uw lokale computer.

Zie Kwantumcircuits voor meer informatie.

Notitie

De Microsoft Quantum Development Kit (klassieke QDK) wordt na 30 juni 2024 niet meer ondersteund. Als u een bestaande QDK-ontwikkelaar bent, raden we u aan over te stappen op de nieuwe Azure Quantum Development Kit (Moderne QDK) om door te gaan met het ontwikkelen van kwantumoplossingen. Zie Uw Q#-code migreren naar de moderne QDK voor meer informatie.

Vereisten

Zie Installing the Modern QDK on VS Code (De moderne QDK installeren in VS Code) voor installatiedetails.

• Een Azure Quantum-werkruimte in uw Azure-abonnement. Zie Een Azure Quantum-werkruimte maken als u een werkruimte wilt maken.

• Een Python omgeving met Python en Pip geïnstalleerd.

• VS Code met de Azure Quantum Development Kit- Pythonen Jupyter-extensies geïnstalleerd.

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

  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 nieuwe Jupyter Notebook maken

1. Selecteer in VS Code opdrachtpalet weergeven > en selecteer Maken: Nieuwe Jupyter Notebook.
2. Rechtsboven detecteert VS Code de versie van Python en de virtuele Python omgeving die is geselecteerd voor het notebook en geeft deze weer. 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 installatie-informatie.

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. Meld u aan bij uw Azure-account, https://portal.azure.comnavigeer naar uw Azure Quantum-werkruimte en kopieer de waarden uit de header.

Voeg een nieuwe cel toe en gebruik uw accountgegevens om en objecten te maken WorkspaceAzureQuantumService 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 items in uw werkruimte weer te geven die uw circuit kunnen 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 kunnen accepteren, worden 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.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>]

Een eenvoudig circuit maken

Maak vervolgens een eenvoudig Cirq-circuit om uit te voeren. Dit circuit maakt gebruik van de vierkantswortel van de X-poort, eigen aan 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 opnamen 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, kunt u schatten hoeveel het uitvoeren ervan kost. Als u de kosten van het uitvoeren van een taak op de QPU wilt schatten, kunt u de estimate_cost methode gebruiken:

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

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

Hiermee worden de geschatte kosten in USD afgedrukt.

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 het 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" op als het target argument:

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

Ook hiermee wordt een cirq.Result -object geretourneerd.

print(result)

b=0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111, 0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111

Asynchroon model 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 op te halen 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 retourneert het een resultaatobject dat specifiek is voor de IonQ-simulator en dat statuskansen gebruikt in plaats van opgenomen gegevens.

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 uitvoert met 100 opnamen, wacht tot 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 tekenen in een histogram:

import pylab as pl

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

Als u het histogram bekijkt, ziet u mogelijk dat de generator voor willekeurige getallen elke keer 0 heeft geretourneerd, wat niet erg willekeurig is. Dit komt omdat, terwijl de API Validator ervoor zorgt dat uw code correct wordt uitgevoerd op Quantinuum-hardware, deze 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, kunt u schatten hoeveel het uitvoeren ervan kost. Als u de kosten van het uitvoeren van een taak op de QPU wilt schatten, kunt u de estimate_cost methode gebruiken.

Notitie

Als u een kostenraming wilt uitvoeren voor een Quantinuum target, moet u eerst het azure-quantum-pakketPython opnieuw laden met de parameter [qiskit] en ervoor zorgen dat u de nieuwste Qiskit-versie hebt. Zie Het azure-quantum-pakket Python bijwerken voor meer informatie.

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

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

Hiermee worden de geschatte kosten in H-System Credits (HQCs) afgedrukt.

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

Asynchrone werkstroom 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 op te halen 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 de resultaten van bittekenreeksmetingen die zijn geïndexeerd op basis van de meetsleutel.

Vereisten

• Een Azure-account met een actief abonnement. Als u geen Azure-account hebt, registreert u zich gratis en meldt u zich aan 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 de Azure Portal en selecteer de werkruimte uit de vorige stap.
2. Selecteer Notitieblokken in de linkerblade.
3. Klik op Mijn notitieblokken en klik op Nieuwe 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 tijdens het maken in de juiste volgorde uitvoeren 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 vervolgens 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 de X-poort, die afkomstig is van 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 kunnen 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 kunnen accepteren, worden 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.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>

Notitie

De volledige lijst met target kan afwijken voor uw werkruimte.

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 daadwerkelijke kwantumhardware, kunt u de IonQ-simulator, ionq.simulatorgebruiken.

De volgende cel verzendt een taak die het circuit uitvoert met 100 opnamen, wacht tot 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 kwantumverwerkingseenheid (QPU), kunt u schatten hoeveel het uitvoeren ervan kost. Als u een schatting wilt maken van de kosten voor het uitvoeren van een taak op de QPU, kunt u de estimate_cost methode gebruiken:

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

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

Estimated cost: 1

Hiermee worden de geschatte kosten in USD afgedrukt.

Zie IonQ-prijzen voor de meest recente prijsinformatie of bekijk prijsopties op de blade Providers van uw werkruimte. Als u de huidige tegoedstatus 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 op de Quantum Processor Unit (QPU). Als u wilt uitvoeren op de IonQ QPU, geeft u ionq.qpu op als het target argument:

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

Notitie

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

Ook hiermee wordt een cirq.Result -object geretourneerd.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Asynchroon model met taken

Voor langlopende circuits kan het handig zijn om deze asynchroon uit te voeren. De service.create_job methode retourneert een Job -object, dat u kunt gebruiken om de resultaten op te halen 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 opgenomen gegevens.

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 het wordt uitgevoerd op de daadwerkelijke kwantumhardware, kunt u de Quantinuum API Validator, quantinuum.sim.h1-1scgebruiken.

Voeg de volgende cel toe die een taak verzendt om het circuit uit te voeren met 100 schoten, of herhalingen, wacht tot 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 het histogram bekijkt, ziet u mogelijk dat de generator voor willekeurige getallen elke keer 0 heeft geretourneerd, wat niet erg willekeurig is. Dit komt omdat de API Validator ervoor zorgt dat uw code correct wordt uitgevoerd op Quantinuum-hardware, maar dat deze 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 kwantumverwerkingseenheid (QPU), kunt u schatten hoeveel het uitvoeren ervan kost. Als u een schatting wilt maken van de kosten voor het uitvoeren van een taak op de QPU, kunt u de estimate_cost methode gebruiken:

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

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

Estimated cost: 5.42

Hiermee worden de geschatte kosten in H-System Quantum Credits (HQC's) afgedrukt.

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

Uitvoeren op een Quantinuum QPU

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

Notitie

De tijd die nodig is om een circuit op de QPU uit te voeren, 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 hebt gebruikt met de API Validator om uw taak te verzenden 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 ziet dat de resultaten nu grofweg zijn verdeeld tussen 0 en 1.

Asynchrone werkstroom met behulp van taken

Voor langlopende circuits kan het handig zijn om deze asynchroon uit te voeren. De service.create_job methode retourneert een Job -object, dat u kunt gebruiken om de resultaten op te halen 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 wordt een woordenlijst geretourneerd met de resultaten van bitstringmetingen die zijn geïndexeerd op basis van de meetsleutel.

Belangrijk

Het verzenden van meerdere circuits voor éé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. Bijvoorbeeld:

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

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

Volgende stappen

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