Een circuit met Qiskit verzenden naar Azure Quantum

Meer informatie over het verzenden van een Qiskit-kwantumcircuit met behulp van het azure-quantumPython pakket. U kunt Qiskit-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 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 [qiskit] en de qsharp pakketten en ipykernel .

  python -m pip install --upgrade azure-quantum[qiskit] 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 qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Verbinding maken met de Azure Quantum-service

Als u verbinding wilt maken met de Azure Quantum-service, hebt u 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 WorkspaceAzureQuantumProvider 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")
    )

provider = AzureQuantumProvider(workspace)

Alle back-ends weergeven

U kunt nu alle back-enden voor kwantumcomputing afdrukken die beschikbaar zijn in uw werkruimte:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.qpu.aria-1
- ionq.simulator
- microsoft.estimator
- quantinuum.hqs-lt-s1
- quantinuum.hqs-lt-s1-apival
- quantinuum.hqs-lt-s2
- quantinuum.hqs-lt-s2-apival
- quantinuum.hqs-lt-s1-sim
- quantinuum.hqs-lt-s2-sim
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Een eenvoudig circuit uitvoeren

Maak eerst een eenvoudig Qiskit-circuit om uit te voeren.

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0,1,2], [0, 1, 2])

# Print out the circuit
circuit.draw()

     ┌───┐          ┌─┐      
q_0: ┤ H ├──■───────┤M├──────
     └───┘┌─┴─┐     └╥┘┌─┐   
q_1: ─────┤ X ├──■───╫─┤M├───
          └───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
               └───┘ ║  ║ └╥┘
c: 3/════════════════╩══╩══╩═
                     0  1  2 

Selecteer een target om uw programma uit te voeren

IonQ

Uitvoeren op de IonQ-simulator

Voordat we op echte hardware worden uitgevoerd, gaan we het circuit testen in de simulator. Gebruik get_backend om een Backend -object te maken om verbinding te maken met de back-end van IonQ Simulator:

simulator_backend = provider.get_backend("ionq.simulator")

IonQ-back-ends ondersteunen poorten van een gedefinieerde gateset, die zijn gecompileerd om optimaal op de hardware te worden uitgevoerd. Als uw circuit poorten bevat die niet in deze lijst staan, moet u transpileren in de ondersteunde gateset met behulp van de transpile functie van Qiskit:

from qiskit import transpile
circuit = transpile(circuit, simulator_backend)

De transpile-functie retourneert een nieuw circuitobject waarbij poorten worden opgesplitst in poorten die worden ondersteund op de opgegeven back-end.

U kunt het programma nu uitvoeren via de Azure Quantum-service en het resultaat ophalen. In de volgende cel wordt een taak verzonden waarmee het circuit wordt uitgevoerd met 100 opnamen:

job = simulator_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Job id 00000000-0000-0000-0000-000000000000

Als u wilt wachten tot de taak is voltooid en de resultaten wilt retourneren, voert u het volgende uit:

result = job.result()
print(result)

Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 50, '111': 50}, probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(meas_map='[0, 1, 2]', name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])

Omdat het resultaat een object is dat eigen is aan het Qiskit-pakket, kunt u qiskit's result.get_counts en plot_histogram gebruiken om de resultaten te visualiseren. Als u ervoor wilt zorgen dat alle mogelijke bitstringlabels worden weergegeven, voegt u deze toe aan counts.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}

Taakkosten schatten

Voordat u een taak uitvoert op de QPU, kunt u inschatten 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:

backend = provider.get_backend("ionq.qpu")
cost = backend.estimate_cost(circuit, shots=1024)

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

Als u verbinding wilt maken met echte hardware (een Quantum Processor Unit (QPU)), geeft u de naam van de target"ionq.qpu" op voor de get_backend methode:

qpu_backend = provider.get_backend("ionq.qpu")

Verzend het circuit dat moet worden uitgevoerd op Azure Quantum, haal de resultaten op en voer uit plot_histogram om de resultaten uit te tekenen.

Notitie

De tijd die nodig is om een circuit op de QPU uit te voeren, kan variëren, afhankelijk van de huidige wachtrijtijden.

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}

Quantinuum

Uitvoeren op de syntaxiscontrole

Als u het programma wilt testen voordat u het uitvoert op de hardware, voert u het eerst uit op de Quantinuum Syntax Checker. Gebruik de get_backend methode om een Backend object te maken om verbinding te maken met de Quantinuum Syntax Checkerbackend:

# Get Quantinuum's syntax checker backend:
syntax_backend = provider.get_backend("quantinuum.sim.h1-1sc")

U kunt het programma nu uitvoeren via de Azure Quantum-service en het resultaat ophalen. In de volgende cel wordt een taak verzonden waarmee het circuit wordt uitgevoerd met 1024 opnamen:

# Submit the circuit to run on Azure Quantum
job = syntax_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='quantinuum.qpu.h1-1sc', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 1024}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 1024, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

Notitie

Hoewel de syntaxiscontrole van Quantinuum ervoor zorgt dat uw code correct wordt uitgevoerd op Quantinuum-hardware, retourneert deze ook 0 voor elke kwantummeting. Voor een echte kwantummeting 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:

qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")
cost = qpu_backend.estimate_cost(circuit, shots=1024)

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

Hiermee worden de geschatte kosten in H-System Quantum 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.

Uitvoeren op een Quantinuum QPU

Nadat u de API-validator hebt uitgevoerd, kunt u uw taak uitvoeren op een van de hardwareprocessors van Quantinuum (een Quantum Processor Unit (QPU)).

Notitie

De tijd die nodig is om een circuit op de QPU uit te voeren, kan variëren, afhankelijk van de huidige wachtrijtijden.

# Get Quantinuum's QPU backend:
qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Result(backend_name='quantinuum.qpu.h1-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'011': 16, '010': 5, '001': 1, '000': 500, '111': 471, '101': 6, '100': 17, '110': 8}, probabilities={'011': 0.015625, '010': 0.0048828125, '001': 0.0009765625, '000': 0.48828125, '111': 0.4599609375, '101': 0.005859375, '100': 0.0166015625, '110': 0.0078125}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 500, '001': 1, '010': 5, '011': 16, '100': 17, '101': 6, '110': 8, '111': 471}

Rigetti

Uitvoeren op de QVM-simulator

Als u het programma wilt testen voordat u het uitvoert op de hardware, voert u het eerst uit op de Rigetti QVM-simulator. Gebruik de provider.get_backend methode om een Backend object te maken om verbinding te maken met de back-end van de Rigetti QVM-simulator:

# Get Rigetti's QVM simulator backend:
qvm_backend = provider.get_backend("rigetti.sim.qvm")

U kunt het programma nu uitvoeren via de Azure Quantum-service en het resultaat ophalen. In de volgende cel wordt een taak verzonden waarmee het circuit wordt uitgevoerd met 1024 opnamen:

# Submit the circuit to run on Azure Quantum
job = qvm_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='rigetti.sim.qvm"', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 1024}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 1024, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

Uitvoeren op een Rigetti QPU

Nadat u de QVM-simulator hebt uitgevoerd, kunt u uw taak uitvoeren op een van de hardwareprocessors van Rigetti (een Quantum Processor Unit (QPU)).

Notitie

De tijd die nodig is om een circuit op de QPU uit te voeren, kan variëren, afhankelijk van de huidige wachtrijtijden.

# Get Rigetti's QPU backend:
qpu_backend = provider.get_backend("rigetti.qpu.ankaa-2")

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=500)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Result(backend_name='rigetti.qpu.ankaa-2', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'011': 16, '010': 5, '001': 1, '000': 500, '111': 471, '101': 6, '100': 17, '110': 8}, probabilities={'011': 0.015625, '010': 0.0048828125, '001': 0.0009765625, '000': 0.48828125, '111': 0.4599609375, '101': 0.005859375, '100': 0.0166015625, '110': 0.0078125}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 500, '001': 1, '010': 5, '011': 16, '100': 17, '101': 6, '110': 8, '111': 471}

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

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 die u in de vorige stap hebt gemaakt.
2. Selecteer Notitieblokken in de linkerblade.
3. Klik op Mijn notitieblokken en klik op Nieuwe toevoegen.
4. Typ een naam voor het bestand, bijvoorbeeld Qiskit.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 pictogram 'afspelen' links van de cel om de code uit te voeren.

De vereiste importbewerkingen laden

Eerst moet u enkele extra modules importeren.

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

from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Verbinding maken met de Azure Quantum-service

Maak vervolgens een AzureQuantumProvider -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 = AzureQuantumProvider(workspace)

Een eenvoudig circuit definiëren

Maak een object in een circuit nieuwe cel. Dit voorbeeld is een eenvoudige kwantumgenerator voor willekeurige bits. Voeg de volgende code toe om het circuit te definiëren en weer te geven:

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])

# Print out the circuit
circuit.draw()

     ┌───┐          ┌─┐      
q_0: ┤ H ├──■───────┤M├──────
     └───┘┌─┴─┐     └╥┘┌─┐   
q_1: ─────┤ X ├──■───╫─┤M├───
          └───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
               └───┘ ║  ║ └╥┘
c: 3/════════════════╩══╩══╩═
                     0  1  2 

Alles weergeven targets

U kunt nu alle kwantumcomputing targetsof back-ends weergeven die beschikbaar zijn in uw werkruimte. Voeg een nieuwe cel toe en voer de volgende regel uit:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Selecteer een target om uw programma uit te voeren

IonQ

Als u uw code wilt controleren voordat u deze uitvoert op daadwerkelijke kwantumhardware, kunt u de IonQ-kwantumsimulator gebruiken, ionq.simulator.

Voeg een nieuwe cel toe en maak een -object om de IonQ-kwantumsimulator weer te geven target:

# Get IonQ quantum simulator target:
simulator_backend = provider.get_backend("ionq.simulator")

Uitvoeren op de IonQ-simulator

Voeg de volgende code toe om uw circuit op de simulator uit te voeren. In dit voorbeeld wordt de run methode van de target gebruikt om uw taak te verzenden en wordt vervolgens de taakstatus gecontroleerd.

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Wanneer de taak is uitgevoerd, haalt u de taakresultaten op en geeft u deze weer:

# Get the job results:
result = job.result()
print(result)

Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='7d909574-98d4-11ec-b382-00155d957f5d', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts=defaultdict(<class 'int'>, {'000': 50, '111': 50}), probabilities=defaultdict(<class 'int'>, {'000': 0.5, '111': 0.5})), header=QobjExperimentHeader(meas_map='[0, 1, 2]', name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])

Omdat dit result type een object is dat eigen is aan het Qiskit-pakket, kunt u qiskit's result.get_counts en plot_histogram gebruiken om de resultaten te visualiseren. Als u ervoor wilt zorgen dat alle mogelijke bitstringlabels worden weergegeven, voegt u deze toe aan counts.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}

Taakkosten schatten

Voordat u een taak uitvoert op werkelijke kwantumhardware of een kwantumverwerkingseenheid (QPU), kunt u inschatten hoeveel het kost om uit te voeren.

Haal eerst de lijst met beschikbare providers opnieuw op:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Maak vervolgens een -object dat de IonQ-kwantumcomputer vertegenwoordigt:

qpu_backend = provider.get_backend("ionq.qpu")

Als u de kosten van het uitvoeren van een taak op de QPU wilt schatten, voegt u een nieuwe cel toe en voert u deze uit met behulp van de estimate_cost methode van :target

cost = qpu_backend.estimate_cost(circuit, shots=100)

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

Hiermee worden de geschatte kosten weergegeven in USD.

Zie IonQ-prijzen voor de meest recente prijsinformatie of zoek uw werkruimte en bekijk prijsopties op de blade Providers van uw werkruimte.

Uitvoeren op IonQ QPU

Nadat u uw taak hebt uitgevoerd op de IonQ-simulator 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 te controleren:

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

Wanneer de taak is voltooid, haalt u de taakresultaten op zoals voorheen en geeft u deze weer in een grafiek:

result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 910b5ac8-98cd-11ec-b3ba-00155d5528cf
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='Job id 54e8c740-98d9-11ec-b382-00155d957f5d', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}

Quantinuum

Als u uw code wilt controleren voordat u deze uitvoert op de werkelijke kwantumhardware, kunt u een van de Quantinuum SyntaxIs checkers, quantinuum.sim.h1-1scgebruiken.

Voeg een nieuwe cel toe en maak een -object om de quantinuum-syntaxiscontrole weer targette geven:

# Get Quantinuum's Syntax Checker target:
apival_backend = provider.get_backend("quantinuum.sim.h1-1sc")

Uitvoeren op de syntaxiscontrole

Als u uw circuit wilt uitvoeren op de syntaxiscontrole, voegt u de volgende code toe, die de run methode van de target gebruikt om uw taak te verzenden, en controleert u vervolgens de taakstatus.

# Submit the circuit to run on Azure Quantum
job = apival_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Wanneer de taak is uitgevoerd, haalt u de taakresultaten op en geeft u deze weer:

# Get the job results:
result = job.result()
print(result)

Result(backend_name='quantinuum.sim.h1-1sc', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='89511b08-9691-11ec-be32-00155d00ae89', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 100}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])

Omdat dit result type een object is dat eigen is aan het Qiskit-pakket, kunt u qiskit's result.get_counts en plot_histogram gebruiken om de resultaten te visualiseren. Als u ervoor wilt zorgen dat alle mogelijke bitstringlabels worden weergegeven, voegt u deze toe aan counts.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 100, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

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 syntaxiscontrole 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 daadwerkelijke kwantumhardware of een kwantumverwerkingseenheid (QPU), kunt u inschatten hoeveel het uitvoeren ervan kost.

Haal eerst de lijst met beschikbare providers opnieuw op:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Maak vervolgens een -object dat het Quantinuum-systeemmodel H1 vertegenwoordigt:

qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")

Als u de kosten van het uitvoeren van een taak op de QPU wilt schatten, voegt u een nieuwe cel toe en voert u deze uit met behulp van de estimate_cost methode van :target

cost = qpu_backend.estimate_cost(circuit, shots=100)

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

Estimated cost: 5.72

In de uitvoer worden de geschatte kosten in H-System Quantum Credits (HQCs) weergegeven.

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 het circuit is uitgevoerd op de syntaxiscontrole en het schatten van de QPU-kosten, is het tijd om het uit te voeren op de hardware.

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 syntaxiscontrole om uw taak te verzenden en te controleren:

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Wanneer de taak is uitgevoerd, haalt u de taakresultaten op zoals voorheen en geeft u deze weer in een histogram:

result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

U ziet dat de resultaten nu grofweg zijn verdeeld tussen 0 en 1.

Result(backend_name='quantinuum.qpu.h1-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='48282d18-9c15-11ec-bfbd-00155d6373ba', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'111': 53, '101': 1, '000': 46}, probabilities={'111': 0.53, '101': 0.01, '000': 0.46}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 46, '001': 0, '010': 0, '011': 0, '100': 0, '101': 1, '110': 0, '111': 53}

Rigetti

Als u uw code wilt controleren voordat u deze uitvoert op daadwerkelijke kwantumhardware, kunt u de Rigetti-kwantumsimulator gebruiken, rigetti.sim.qvm.

Voeg een nieuwe cel toe en maak een -object voor de Rigetti-kwantumsimulator target:

# Get Rigetti quantum simulator target:
simulator_backend = provider.get_backend("rigetti.sim.qvm")

Uitvoeren op de Rigetti-simulator

Voeg de volgende code toe om uw circuit op de simulator uit te voeren. In dit voorbeeld wordt de run methode van de target gebruikt om uw taak te verzenden en wordt vervolgens de taakstatus gecontroleerd.

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Wanneer de taak is uitgevoerd, haalt u de taakresultaten op en geeft u deze weer:

# Get the job results:
result = job.result()
print(result)

Result(backend_name='rigetti.sim.qvm', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='5de5e2a0-39e3-11ed-bd56-00155d76e336', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'[0, 0, 0]': 54, '[1, 1, 1]': 46}, probabilities={'[0, 0, 0]': 0.59, '[1, 1, 1]': 0.41}), header=QobjExperimentHeader(metadata=None, name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])

Omdat dit result type een object is dat eigen is aan het Qiskit-pakket, kunt u qiskit's result.get_counts en plot_histogram gebruiken om de resultaten te visualiseren. Als u ervoor wilt zorgen dat alle mogelijke bitstringlabels worden weergegeven, voegt u deze toe aan counts.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}

Uitvoeren op Rigetti QPU

Nadat u uw circuit hebt uitgevoerd op de Rigetti-simulator, 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.

Haal eerst de lijst met beschikbare providers opnieuw op:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Maak vervolgens een -object dat de Rigetti-kwantumcomputer vertegenwoordigt:

qpu_backend = provider.get_backend("rigetti.qpu.ankaa-2")

Gebruik dezelfde run methode en bewerkingen die u eerder hebt gebruikt met de Rigetti-kwantumsimulator om uw taak te verzenden en te bewaken:

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

Wanneer de taak is uitgevoerd, haalt u de taakresultaten op zoals voorheen en geeft u deze weer in een grafiek:

result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id cd4800f4-39e5-11ed-bd56-00155d76e336
Job Status: job has successfully run
Result(backend_name='rigetti.qpu.ankaa-2', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='cd4800f4-39e5-11ed-bd56-00155d76e336', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'[0, 0, 0]': 415.0, '[1, 1, 1]': 280.0, '[1, 1, 0]': 103.0, '[0, 1, 1]': 83.0, '[1, 0, 1]': 8.0, '[0, 1, 0]': 36.0, '[1, 0, 0]': 74.0, '[0, 0, 1]': 25.0}, probabilities={'[0, 0, 0]': 0.4052734375, '[1, 1, 1]': 0.2734375, '[1, 1, 0]': 0.1005859375, '[0, 1, 1]': 0.0810546875, '[1, 0, 1]': 0.0078125, '[0, 1, 0]': 0.03515625, '[1, 0, 0]': 0.072265625, '[0, 0, 1]': 0.0244140625}), header=QobjExperimentHeader(metadata=None, name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 0, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0, '[0, 0, 0]': 415.0, '[1, 1, 1]': 280.0, '[1, 1, 0]': 103.0, '[0, 1, 1]': 83.0, '[1, 0, 1]': 8.0, '[0, 1, 0]': 36.0, '[1, 0, 0]': 74.0, '[0, 0, 1]': 25.0}

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 Cirq verzenden naar Azure Quantum.
• Quickstart: Een circuit met een providerspecifieke indeling verzenden naar Azure Quantum.