Odeslání okruhu pomocí qiskitu do Azure Quantum

Zjistěte, jak odeslat kvantový okruh Qiskit pomocí azure-quantumPython balíčku . Okruhy Qiskit můžete odeslat do Azure Quantum pomocí poznámkového bloku Azure Quantum, který má integrovaný azure-quantumPython balíček, nebo z místního počítače.

Další informace najdete v tématu Kvantové obvody.

Poznámka

Sada Microsoft Quantum Development Kit (Classic QDK) už nebude po 30. červnu 2024 podporována. Pokud jste stávající vývojář sady QDK, doporučujeme přejít na novou sadu Azure Quantum Development Kit (Moderní QDK) a pokračovat ve vývoji kvantových řešení. Další informace najdete v tématu Migrace kódu Q# do moderní sady QDK.

Požadavky

Podrobnosti o instalaci najdete v tématu Instalace moderní sady QDK ve VS Code.

• Pracovní prostor Azure Quantum ve vašem předplatném Azure. Informace o vytvoření pracovního prostoru najdete v tématu Vytvoření pracovního prostoru Azure Quantum.

• Prostředí Python s nainstalovanými Python nástroji a Pip .

• VS Code s nainstalovanou sadou Azure Quantum Development Kit, Pythona rozšířeními Jupyter .

• Balíček Azure Quantum azure-quantum se značkou [qiskit] a qsharp balíčky a ipykernel .

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

  Poznámka

  Pokud se jádro ipykernel Jupyter Python nerozpozná, VS Code vás vyzve k jeho instalaci.

Vytvoření nového Jupyter Notebook

1. Ve VS Code vyberte Zobrazit > paletu příkazů a vyberte Vytvořit: Nový Jupyter Notebook.
2. V pravém horním rohu nástroj VS Code rozpozná a zobrazí verzi Python nástroje a virtuální Python prostředí vybrané pro poznámkový blok. Pokud máte více Python prostředí, možná budete muset vybrat jádro pomocí nástroje pro výběr jádra v pravém horním rohu. Pokud se žádné prostředí nezjistilo, informace o nastavení najdete v tématu Poznámkové bloky Jupyter ve VS Code .

Načtení požadovaných importů

V první buňce poznámkového bloku spusťte následující kód, který načte požadované importy:

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

Připojení ke službě Azure Quantum

Pro připojení ke službě Azure Quantum potřebujete ID prostředku a umístění pracovního prostoru Azure Quantum. Přihlaste se ke svému účtu Azure , https://portal.azure.compřejděte do svého pracovního prostoru Azure Quantum a zkopírujte hodnoty z hlavičky.

Přidejte novou buňku a pomocí informací o účtu vytvořte Workspace objekty a AzureQuantumProvider připojte se k pracovnímu prostoru Azure Quantum.

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

provider = AzureQuantumProvider(workspace)

Vypsat všechny back-endy

Teď můžete vytisknout všechny back-endy kvantových výpočtů, které jsou k dispozici ve vašem pracovním prostoru:

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

Spuštění jednoduchého okruhu

Nejprve vytvořte jednoduchý okruh Qiskit, který se má spustit.

# 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 

Vyberte a target spusťte program.

IonQ

Spuštění na simulátoru IonQ

Před spuštěním na skutečném hardwaru otestujeme okruh v simulátoru. Slouží get_backend k vytvoření objektu Backend pro připojení k back-endu simulátoru IonQ:

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

Back-endy IonQ podporují brány z definované sady bran, které se kompilují tak, aby běžely optimálně na hardwaru. Pokud váš okruh obsahuje brány, které nejsou v tomto seznamu, musíte pomocí funkce poskytované Qiskit transpilovat do podporovaného gatesettranspile objektu:

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

Funkce transpile vrátí objekt nového okruhu, kde jsou brány rozloženy na brány, které jsou podporovány na zadaném back-endu.

Teď můžete program spustit prostřednictvím služby Azure Quantum a získat výsledek. Následující buňka odešle úlohu, která spustí okruh se 100 snímky:

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

Job id 00000000-0000-0000-0000-000000000000

Pokud chcete počkat na dokončení úlohy a vrátit výsledky, spusťte:

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

Vzhledem k tomu, že výsledek je objekt nativní pro balíček Qiskit, můžete k vizualizaci výsledků použít Qiskit result.get_counts a plot_histogram . Abyste měli jistotu, že jsou znázorněné všechny možné popisky bitových řetězců, přidejte je do 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}

Odhad nákladů na úlohu

Před spuštěním úlohy na QPU můžete odhadnout, kolik stojí spuštění. K odhadu nákladů na spuštění úlohy na QPU můžete použít metodu estimate_cost :

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

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

Tím se zobrazí odhadované náklady v USD.

Nejnovější podrobnosti o cenách najdete v tématu Ceny ionQ nebo vyhledejte svůj pracovní prostor a zobrazte cenové možnosti na kartě Poskytovatel vašeho pracovního prostoru prostřednictvím : aka.ms/aq/myworkspaces.

Spuštění na IonQ QPU

Pokud se chcete připojit ke skutečnému hardwaru ( QPU( Quantum Processor Unit ), jednoduše zadejte název target"ionq.qpu"get_backend metody :

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

Odešlete okruh ke spuštění v Azure Quantum, získejte výsledky a spuštěním vykreslíte plot_histogram výsledky.

Poznámka

Doba potřebná ke spuštění okruhu na QPU se může lišit v závislosti na aktuální době fronty.

# 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

Spuštění v nástroji pro kontrolu syntaxe

Pokud chcete program před spuštěním na hardwaru otestovat, nejprve ho spusťte v nástroji Quantinuum Syntax Checker. get_backend Pomocí metody vytvořte objekt pro Backend připojení k Quantinuum Syntax Checkerbackend:

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

Teď můžete program spustit prostřednictvím služby Azure Quantum a získat výsledek. Následující buňka odešle úlohu, která spustí okruh se 1024 snímky:

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

Poznámka

Kontrola syntaxe Quantinuum sice zajišťuje úspěšné spuštění kódu na hardwaru Quantinuum, ale vrátí také hodnotu 0 pro každé kvantové měření. Pro skutečné kvantové měření je potřeba spustit okruh na kvantovém hardwaru.

Odhad nákladů na úlohu

Před spuštěním úlohy na QPU můžete odhadnout, kolik bude jeho spuštění stát. K odhadu nákladů na spuštění úlohy na QPU můžete použít metodu estimate_cost :

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

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

Tím se zobrazí odhadované náklady v kreditech H-System Quantum (HQC).

Nejnovější podrobnosti o cenách najdete v tématu Ceny služby Azure Quantum nebo vyhledejte svůj pracovní prostor a podívejte se na cenové možnosti na kartě Poskytovatel vašeho pracovního prostoru prostřednictvím : aka.ms/aq/myworkspaces.

Spuštění na QPU Quantinuum

Po úspěšném spuštění validátoru rozhraní API můžete úlohu spustit na jednom z hardwarových procesorů společnosti Quantinuum ( QPU )).

Poznámka

Doba potřebná ke spuštění okruhu na QPU se může lišit v závislosti na aktuální době fronty.

# 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

Spuštění na simulátoru QVM

Pokud chcete program před spuštěním na hardwaru otestovat, nejprve ho spusťte v simulátoru Rigetti QVM. provider.get_backend Pomocí metody vytvořte objekt pro Backend připojení k back-endu simulátoru Rigetti QVM:

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

Teď můžete program spustit prostřednictvím služby Azure Quantum a získat výsledek. Následující buňka odešle úlohu, která spustí okruh se 1024 snímky:

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

Spuštění na QPU Rigetti

Po úspěšném spuštění na simulátoru QVM můžete úlohu spustit na jednom z hardwarových procesorů společnosti Rigetti ( QPU )).

Poznámka

Doba potřebná ke spuštění okruhu na QPU se může lišit v závislosti na aktuální době fronty.

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

Důležité

Odesílání více okruhů v jedné úloze se v současné době nepodporuje. Jako alternativní řešení můžete volat metodu backend.run , která asynchronně odešle každý okruh a pak načte výsledky jednotlivých úloh. Příklad:

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

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

Požadavky

• Účet Azure s aktivním předplatným. Pokud nemáte účet Azure, zaregistrujte se zdarma a zaregistrujte si předplatné s průběžnými platbou.
• Pracovní prostor Azure Quantum. Další informace najdete v tématu Vytvoření pracovního prostoru Azure Quantum.

Vytvoření nového poznámkového bloku v pracovním prostoru

1. Přihlaste se k Azure Portal a vyberte pracovní prostor, který jste vytvořili v předchozím kroku.
2. V levém okně vyberte Poznámkové bloky.
3. Klikněte na Moje poznámkové bloky a pak na Přidat nový.
4. Zadejte název souboru, například Qiskit.ipynb, a klikněte na Vytvořit soubor.

Když se nový poznámkový blok otevře, automaticky vytvoří kód pro první buňku na základě informací o vašem předplatném a pracovním prostoru.

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

Poznámka

Pokud není uvedeno jinak, měli byste každou buňku spouštět v pořadí, v jakém ji vytváříte, abyste se vyhnuli problémům s kompilací.

Kliknutím na trojúhelníkové ikony "přehrát" nalevo od buňky spusťte kód.

Načtení požadovaných importů

Nejprve budete muset importovat některé další moduly.

Kliknutím na + Kód přidejte novou buňku a pak přidejte a spusťte následující kód:

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

Připojení ke službě Azure Quantum

Dále pomocí AzureQuantumProvider objektu Workspace z předchozí buňky vytvořte objekt pro připojení k pracovnímu prostoru Azure Quantum. Přidejte novou buňku s následujícím kódem:

provider = AzureQuantumProvider(workspace)

Definování jednoduchého okruhu

V nové buňce vytvořte circuit objekt. Tento příklad je jednoduchý kvantový generátor náhodných bitů. Přidejte následující kód pro definování a zobrazení okruhu:

# 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 

Vypsat vše targets

Teď můžete zobrazit všechny kvantové výpočty targetsnebo back-endy, které jsou k dispozici ve vašem pracovním prostoru. Přidejte novou buňku a spusťte následující řádek:

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

Vyberte a spusťte target program.

IonQ

Pokud chcete kód zkontrolovat před jeho spuštěním na skutečném kvantovém hardwaru, můžete použít kvantový simulátor IonQ. ionq.simulator

Přidejte novou buňku a vytvořte objekt, který bude představovat kvantový simulátor targetIonQ:

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

Spuštění na simulátoru IonQ

Pokud chcete okruh spustit na simulátoru, přidejte následující kód. V tomto příkladu run použijeme metodu target k odeslání úlohy a pak monitoruje stav úlohy.

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

Po úspěšném spuštění úlohy získejte výsledky úlohy a zobrazte je:

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

Vzhledem k tomu, že tento result typ je objekt nativní pro balíček Qiskit, můžete k vizualizaci výsledků použít Qiskit result.get_counts a plot_histogram . Abyste měli jistotu, že jsou reprezentovány všechny možné popisky bitstringu, přidejte je do 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}

Odhad nákladů na úlohu

Před spuštěním úlohy na skutečném kvantovém hardwaru nebo na jednotce kvantového zpracování (QPU) můžete odhadnout, kolik stojí spuštění.

Nejprve znovu získejte seznam dostupných poskytovatelů:

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

Dále vytvořte objekt, který bude představovat kvantový počítač IonQ:

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

Pokud chcete odhadnout náklady na spuštění úlohy na QPU, přidejte a spusťte novou buňku estimate_cost pomocí metody target:

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

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

Zobrazí se odhadované náklady v USD.

Nejnovější podrobnosti o cenách najdete v tématu Ceny IonQ nebo vyhledejte svůj pracovní prostor a zobrazte cenové možnosti v okně Poskytovatelé vašeho pracovního prostoru.

Spuštění na IonQ QPU

Po úspěšném spuštění úlohy na simulátoru IonQ a odhadu nákladů na QPU je čas spustit okruh na hardwaru.

Poznámka

Doba potřebná ke spuštění okruhu na QPU se liší v závislosti na aktuálních časech fronty. Průměrnou dobu fronty můžete zobrazit tak, target že v pracovním prostoru vyberete okno Poskytovatelé .

K odeslání a monitorování úlohy použijte stejnou run metodu a operace, které jste dříve použili s validátorem rozhraní API:

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

Po dokončení úlohy získejte výsledky úlohy jako předtím a zobrazte je v grafu:

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

Pokud chcete kód zkontrolovat před jeho spuštěním na skutečném kvantovém hardwaru, můžete použít jeden z Quantinuum Syntax Checker, quantinuum.sim.h1-1sc.

Přidejte novou buňku a vytvořte objekt, který bude představovat kontrolu targetsyntaxe Quantinuum:

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

Spuštění v nástroji Kontrola syntaxe

Pokud chcete okruh spustit v nástroji Kontrola syntaxe, přidejte následující kód, který použije metodu runtarget nástroje k odeslání úlohy, a pak monitoruje stav úlohy.

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

Po úspěšném spuštění úlohy získejte výsledky úlohy a zobrazte je:

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

Vzhledem k tomu, že tento result typ je objekt nativní pro balíček Qiskit, můžete k vizualizaci výsledků použít Qiskit result.get_counts a plot_histogram . Abyste měli jistotu, že jsou reprezentovány všechny možné popisky bitstringu, přidejte je do 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}

Při pohledu na histogram si můžete všimnout, že generátor náhodných čísel pokaždé vrátil hodnotu 0, což není příliš náhodné. Důvodem je to, že zatímco kontrola syntaxe zajišťuje úspěšné spuštění kódu na hardwaru Quantinuum, vrátí také hodnotu 0 pro každé kvantové měření. Pro skutečný generátor náhodných čísel je nutné spustit okruh na kvantovém hardwaru.

Odhad nákladů na úlohu

Před spuštěním úlohy na skutečném kvantovém hardwaru nebo na jednotce kvantového zpracování (QPU) můžete odhadnout, kolik bude jeho spuštění stát.

Nejprve znovu získejte seznam dostupných poskytovatelů:

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

Dále vytvořte objekt představující model systému Quantinuum H1:

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

Pokud chcete odhadnout náklady na spuštění úlohy na QPU, přidejte a spusťte novou buňku estimate_cost pomocí metody target:

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

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

Estimated cost: 5.72

Výstup zobrazí odhadované náklady v H-System Quantum Credits (HQC).

Nejnovější podrobnosti o cenách najdete v tématu Ceny služby Azure Quantum nebo si prohlédněte cenové možnosti v okně Poskytovatelé vašeho pracovního prostoru. Pokud chcete zobrazit aktuální stav kreditu a využití, vyberte Kredity a kvóty.

Spuštění na QPU Quantinuum

Po úspěšném spuštění okruhu v nástroji Kontrola syntaxe a odhadu nákladů na QPU je čas spustit ho na hardwaru.

Poznámka

Doba potřebná ke spuštění okruhu na QPU závisí na aktuálních časech fronty. Průměrnou dobu fronty můžete zobrazit tak, target že v pracovním prostoru vyberete okno Poskytovatelé .

K odeslání a monitorování úlohy použijte stejnou run metodu a operace, které jste použili dříve s nástrojem Kontrola syntaxe:

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

Po úspěšném spuštění úlohy získejte výsledky úlohy jako předtím a zobrazte je v histogramu:

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)

Vidíte, že výsledky jsou teď zhruba rozdělené mezi 0 a 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

Ke kontrole kódu před jeho spuštěním na skutečném kvantovém hardwaru můžete použít kvantový simulátor rigetti.sim.qvmRigetti.

Přidejte novou buňku a vytvořte objekt představující kvantový simulátor targetRigetti:

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

Spuštění na simulátoru Rigetti

Pokud chcete okruh spustit na simulátoru, přidejte následující kód. Tento příklad používá metodu runtarget k odeslání úlohy a pak monitoruje stav úlohy.

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

Po úspěšném spuštění úlohy získejte výsledky úlohy a zobrazte je:

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

Vzhledem k tomu, že tento result typ je objekt nativní pro balíček Qiskit, můžete k vizualizaci výsledků použít Qiskit result.get_counts a plot_histogram . Abyste měli jistotu, že jsou reprezentovány všechny možné popisky bitstringu, přidejte je do 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}

Spustit na Rigetti QPU

Po úspěšném spuštění okruhu na simulátoru Rigetti je čas spustit okruh na hardwaru.

Poznámka

Doba potřebná ke spuštění okruhu na QPU se liší v závislosti na aktuálních časech fronty. Průměrnou dobu fronty můžete zobrazit tak, target že v pracovním prostoru vyberete okno Poskytovatelé .

Nejprve znovu získejte seznam dostupných poskytovatelů:

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

Dále vytvořte objekt, který bude představovat kvantový počítač Rigetti:

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

K odeslání a monitorování úlohy použijte stejnou run metodu a operace, které jste použili dříve s kvantovým simulátorem Rigetti:

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

Po úspěšném spuštění úlohy získejte výsledky úlohy jako předtím a zobrazte je v grafu:

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}

Důležité

Odesílání více okruhů v jedné úloze se v současné době nepodporuje. Jako alternativní řešení můžete volat metodu backend.run , která asynchronně odešle každý okruh a pak načte výsledky jednotlivých úloh. Příklad:

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

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

Další kroky

• Rychlý start: Odeslání okruhu pomocí Cirq do Azure Quantum
• Rychlý start: Odeslání okruhu s formátem specifickým pro poskytovatele do Azure Quantum