Skicka en krets med Qiskit till Azure Quantum

  • Artikel

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

Mer information finns i Kvantkretsar.

Kommentar

Microsoft Quantum Development Kit (klassisk QDK) stöds inte längre efter den 30 juni 2024. Om du är en befintlig QDK-utvecklare rekommenderar vi att du övergår till det nya Azure Quantum Development Kit (Modern QDK) för att fortsätta utveckla kvantlösningar. Mer information finns i Migrera Q#-koden till modern QDK.

Förutsättningar

Installationsinformation finns i Installera modern QDK på VS Code.

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 qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Anslut till Azure Quantum-tjänsten

Om du vill ansluta till Azure Quantum-tjänsten behöver du resurs-ID:t och platsen för din Azure Quantum-arbetsyta. Logga in på ditt Azure-konto, https://portal.azure.comnavigera till din Azure Quantum-arbetsyta och kopiera värdena från rubriken.

Hämta resurs-ID och plats från en Azure Quantum-arbetsyta

Lägg till en ny cell och använd din kontoinformation för att skapa Workspace och AzureQuantumProvider 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")
    )

provider = AzureQuantumProvider(workspace)

Visa en lista över alla serverdelar

Nu kan du skriva ut alla serverdelar för kvantberäkning som är tillgängliga på din arbetsyta:

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

Köra en enkel krets

Skapa först en enkel Qiskit-krets som ska köras.

# 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

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

Kör på IonQ-simulatorn

Innan vi kör på riktig maskinvara ska vi testa kretsen i simulatorn. Använd get_backend för att skapa ett Backend objekt för att ansluta till IonQ Simulator-serverdelen:

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

IonQ-serverdelar stöder portar från en definierad gateset som kompileras för att köras optimalt på maskinvaran. Om kretsen innehåller portar som inte finns i den här listan måste du gå vidare till den som stöds gateset med hjälp av funktionen transpile som tillhandahålls av Qiskit:

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

Transpile-funktionen returnerar ett nytt kretsobjekt där portar delas upp i portar som stöds på den angivna serverdelen.

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:

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

Job id 00000000-0000-0000-0000-000000000000

Om du vill vänta tills jobbet har slutförts och returnera resultatet kör du:

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

Eftersom resultatet är ett objekt som är inbyggt i Qiskit-paketet kan du använda Qiskits result.get_counts och plot_histogram visualisera resultatet. För att se till att alla möjliga bitsträngsetiketter representeras lägger du till dem i 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}

Qiskit-kretsresultat på IonQ-simulator

Beräkna jobbkostnad

Innan du kör ett jobb på QPU:n kan du uppskatta hur mycket det kostar att köra. Om du vill beräkna kostnaden för att köra ett jobb på QPU:n kan du använda estimate_cost metoden:

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

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

Detta skriver ut den uppskattade kostnaden i USD.

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

Om du vill ansluta till verklig maskinvara (en kvantprocessorenhet (QPU)) anger du bara namnet target"ionq.qpu" på get_backend metoden:

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

Skicka kretsen för att köra på Azure Quantum, hämta resultaten och kör plot_histogram för att rita resultatet.

Kommentar

Tiden som krävs för att köra en krets på QPU:n kan variera beroende på aktuella kötider.

# 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}

Qiskit-kretsresultat på IonQ QPU

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

Förutsättningar

Skapa en ny notebook-fil på din arbetsyta

  1. Logga in på Azure-portalen och välj den arbetsyta som du skapade i 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 Qiskit.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 några ytterligare moduler.

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

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

Anslut till Azure Quantum-tjänsten

Skapa sedan ett AzureQuantumProvider 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 = AzureQuantumProvider(workspace)

Definiera en enkel krets

Skapa ett circuit objekt i en ny cell. Det här exemplet är en enkel slumpmässig kvantbitgenerator. Lägg till följande kod för att definiera och visa kretsen:

# 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

Visa en lista över alla targets

Nu kan du visa alla kvantberäkning targets, eller serverdelar, som är tillgängliga på din arbetsyta. Lägg till en ny cell och kör följande rad:

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

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

Om du vill kontrollera koden innan du kör den på den faktiska kvantmaskinvaran kan du använda kvantsimulatorn IonQ, ionq.simulator.

Lägg till en ny cell och skapa ett objekt som representerar IonQ-kvantsimulatorn target:

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

Kör på IonQ-simulatorn

Om du vill köra kretsen i simulatorn lägger du till följande kod. I det run här exemplet används metoden target för att skicka jobbet och övervakar sedan jobbstatusen.

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

När jobbet har körts hämtar du jobbresultatet och visar dem:

# 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'))])

Eftersom den här result typen är ett objekt som är inbyggt i Qiskit-paketet kan du använda Qiskits result.get_counts och plot_histogram visualisera resultaten. För att se till att alla möjliga bitsträngsetiketter representeras lägger du till dem i 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}

Qiskit-kretsresultat på IonQ-simulator

Beräkna jobbkostnad

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

Hämta först listan över tillgängliga leverantörer igen:

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

Skapa sedan ett objekt som representerar IonQ-kvantdatorn:

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

Om du vill beräkna kostnaden för att köra ett jobb på QPU:n lägger du till och kör en ny cell med hjälp estimate_cost av targetmetoden :

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

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

Detta visar den uppskattade kostnaden i USD.

Den senaste prisinformationen finns i IonQ-priser eller hitta din arbetsyta och visa prisalternativ på bladet Providers på din arbetsyta.

Kör på IonQ QPU

När du har kört jobbet på IonQ-simulatorn och beräknat QPU-kostnaden är det dags att köra kretsen på maskinvaran.

Kommentar

Tiden som krävs för att köra en krets på QPU:n varierar beroende 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 och övervaka ditt jobb:

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

När jobbet är klart hämtar du jobbresultatet som tidigare och visar dem i ett diagram:

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}

Qiskit-kretsresultat på IonQ QPU

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

Nästa steg