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. Okruhy můžete otestovat také pomocí místního řídkého simulátoru.

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

Požadavky

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

• Pracovní prostor Azure Quantum ve vašem předplatném Azure Pokud chcete vytvořit pracovní prostor, přečtěte si téma Vytvoření pracovního prostoru Azure Quantum.

• Prostředí Python s nainstalovaným Python nástrojem Pip .

• VS Code s nainstalovanou sadou Azure Quantum Development KitPython a rozšířeními Jupyter.

• Balíček Azure Quantum azure-quantumPython se značkou [qiskit].

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

  Důležité

  Ujistěte se, že máte nejnovější verzi Qiskitu. Další informace najdete v tématu Aktualizace balíčku azure-quantumPython.

  Poznámka:

  Pokud se nerozpoznalo jádro ipykernel JupyterPython, nástroj VS Code vás vyzve k jeho instalaci.

Vytvoření nového poznámkového bloku Jupyter

1. Ve VS Code vyberte paletu Zobrazit > příkaz a vyberte Vytvořit: Nový poznámkový blok Jupyter.
2. V pravém horním rohu nástroj VS Code rozpozná a zobrazí verzi Python 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 nebylo zjištěno žádné prostředí, informace o nastavení najdete v poznámkových blocích Jupyter v editoru 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 azure.quantum import Workspace 
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Připojení ke službě Azure Quantum

Pokud se chcete připojit ke službě Azure Quantum, potřebujete ID prostředku a umístění pracovního prostoru Azure Quantum.

1. Přihlaste se ke svému účtu Azure, https://portal.azure.com

2. Vyberte pracovní prostor Azure Quantum a přejděte na Přehled.

3. Zkopírujte parametry v polích.

   

Přidejte do poznámkového bloku novou buňku a pomocí informací o účtu vytvořte Workspace a AzureQuantumProvider objekty pro připojení 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)

Výpis všech back-endů

Teď můžete vytisknout všechny back-endy kvantových výpočtů, které jsou dostupné 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

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 program, který target chcete spustit.

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 převést do podporované gateset transpile funkce poskytované Qiskitem:

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

Funkce transpile vrátí nový objekt okruhu, kde jsou brány rozloženy do bran podporovaných v zadaném back-endu.

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

job = simulator_backend.run(circuit, shots=8)
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=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)

Vzhledem k tomu, že výsledek je objekt nativní pro balíček Qiskit, můžete použít Qiskit result.get_counts a plot_histogram vizualizovat výsledky. Chcete-li zajistit, aby byly 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': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

Pomocí funkce můžete také get_memory() zobrazit jednotlivá zastřelená data z úlohy.

result.get_memory(circuit)

['000', '000', '000', '000', '111', '111', '111', '111']

Poznámka:

Pokud na IonQ targetsodešlete úlohu s lichým počtem snímků, výsledky se zaokrouhlí dolů na další sudé číslo. Pokud například zadáte 9 snímků, výsledky zobrazí data pro 8 snímků.

Odhad nákladů na úlohu

Před spuštěním úlohy v QPU byste měli odhadnout, kolik stojí na spuštění.

Nejaktuálně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í v QPU IonQ

Pokud se chcete připojit k skutečnému hardwaru (QPU ), jednoduše zadejte název target"ionq.qpu.aria-1" get_backend metody:

qpu_backend = provider.get_backend("ionq.qpu.aria-1")

Odešlete okruh ke spuštění v Azure Quantum, získejte výsledky a spusťte plot_histogram ho, abyste výsledky vykreslili.

Poznámka:

Doba potřebná ke spuštění okruhu v 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=100)
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.qpu.aria-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={'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

Program před spuštěním na hardwaru otestujete tak, že ho nejprve spustíte v nástroji kontrola syntaxe Quantinuum. get_backend Pomocí metody vytvořte Backend objekt pro připojení k back-endu kontroly syntaxe Quantinuum:

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

Program teď můžete spustit prostřednictvím služby Azure Quantum a získat výsledek. Následující buňka odešle úlohu, která spouští okruh s osmi snímky:

# Submit the circuit to run on Azure Quantum
job = syntax_backend.run(circuit, shots=8)
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.sim.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=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 8}, memory=['000', '000', '000', '000', '000', '000', '000', '000'], probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
{'000': 8, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

Poznámka:

Zatímco kontrola syntaxe Quantinuum 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é kvantové měření je potřeba spustit okruh na kvantovém hardwaru.

Pomocí funkce můžete také get_memory() zobrazit jednotlivá zastřelená data z úlohy.

result.get_memory(circuit)

['000', '000', '000', '000', '000', '000', '000', '000']

Odhad nákladů na úlohu

Před spuštěním úlohy v QPU byste měli odhadnout, kolik bude stát spuštění.

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

Spuštění na QPU Quantinuum

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

Poznámka:

Doba potřebná ke spuštění okruhu v 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=100)
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

Poznámka:

V současné době nabízí Rigetti pouze svůj kvantový simulátor prostřednictvím rigetti.sim.qvmslužby Azure Quantum.

Spuštění v simulátoru QVM

provider.get_backend Pomocí metody vytvořte Backend objekt pro připojení k back-endu simulátoru Rigetti QVM:

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

Program teď můžete spustit prostřednictvím služby Azure Quantum a získat výsledek. Následující buňka odešle úlohu, která spouští okruh s osmi snímky:

# Submit the circuit to run on Azure Quantum
job = qvm_backend.run(circuit, shots=8)
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.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=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '111', '111', '000', '000', '000', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

Pomocí funkce můžete také get_memory() zobrazit jednotlivá zastřelená data z úlohy.

result.get_memory(circuit)

['000', '111', '111', '000', '000', '000', '111', '111']

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 pro asynchronní odeslání každého okruhu a pak načíst výsledky každé úlohy. 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ým 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 webu 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 klikněte 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 při vytváření spustit každou buňku, abyste se vyhnuli problémům s kompilací.

Kliknutím na trojúhlou ikonu "přehrát" vlevo 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 vytvořte AzureQuantumProvider objekt pomocí objektu Workspace z předchozí buňky 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 

Zobrazit seznam všech targets

Teď můžete zobrazit všechny kvantové výpočty targetsnebo back-endy, které jsou dostupné 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.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm

Vyberte program, který target chcete spustit.

IonQ

Pokud chcete zkontrolovat kód 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 představující 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 spustit okruh v simulátoru, přidejte následující kód. Tento příklad používá run metodu target odeslání úlohy a pak monitoruje stav úlohy.

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=8)
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='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)

Vzhledem k tomu, že tento result typ je objekt nativní pro balíček Qiskit, můžete použít Qiskit result.get_counts a plot_histogram vizualizovat výsledky. Chcete-li zajistit, aby byly 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': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

Pomocí funkce můžete také get_memory() zobrazit jednotlivá zastřelená data z úlohy.

result.get_memory(circuit)

['000', '000', '000', '000', '111', '111', '111', '111']

Poznámka:

Pokud na IonQ targetsodešlete úlohu s lichým počtem snímků, výsledky se zaokrouhlí dolů na další sudé číslo. Pokud například zadáte 9 snímků, výsledky zobrazí data pro 8 snímků.

Odhad nákladů na úlohu

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

Nejaktuálnější podrobnosti o cenách najdete v tématu Ceny IonQ nebo vyhledejte pracovní prostor a v okně Poskytovatelé vašeho pracovního prostoru si prohlédněte cenové možnosti.

Spuštění v QPU IonQ

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 v QPU se liší v závislosti na aktuálních časech fronty. Průměrnou dobu target fronty můžete zobrazit výběrem okna Poskytovatelé vašeho pracovního prostoru.

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

# 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 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 zkontrolovat kód před jeho spuštěním na skutečném kvantovém hardwaru, můžete použít jeden z kontrolních rutin syntaxe Quantinuum, quantinuum.sim.h1-1sc.

Přidejte novou buňku a vytvořte objekt představující kontrolu targetsyntaxe Quantinuum:

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

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

Pokud chcete spustit okruh v nástroji Kontrola syntaxe, přidejte následující kód, který používá run metodu target 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='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 8}, memory=['000', '000', '000', '000', '000', '000', '000', '000'], probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
{'000': 8, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

Vzhledem k tomu, že tento result typ je objekt nativní pro balíček Qiskit, můžete použít Qiskit result.get_counts a plot_histogram vizualizovat výsledky. Chcete-li zajistit, aby byly 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': 8, '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 vrátil 0 pokaždé, což není příliš náhodné. Důvodem je to, že zatímco nástroj Pro kontrolu 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 musíte spustit okruh na kvantovém hardwaru.

Pomocí funkce můžete také get_memory() zobrazit jednotlivá zastřelená data z úlohy.

result.get_memory(circuit)

['000', '000', '000', '000', '000', '000', '000', '000']

Odhad nákladů na úlohu

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

Nejnovější podrobnosti o cenách najdete v části Ceny azure Quantum nebo si prohlédněte možnosti cen 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 na nástroji Kontrola syntaxe a odhadu nákladů na QPU je čas ho spustit 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 target fronty můžete zobrazit výběrem okna Poskytovatelé vašeho pracovního prostoru.

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

# 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

Poznámka:

V současné době nabízí Rigetti pouze svůj kvantový simulátor prostřednictvím rigetti.sim.qvmslužby Azure Quantum.

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 spustit okruh v simulátoru, přidejte následující kód. Tento příklad používá run metodu target odeslání úlohy a pak monitoruje stav úlohy.

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=8)
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='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '111', '111', '000', '000', '000', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

Vzhledem k tomu, že tento result typ je objekt nativní pro balíček Qiskit, můžete použít Qiskit result.get_counts a plot_histogram vizualizovat výsledky. Chcete-li zajistit, aby byly 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': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

Pomocí funkce můžete také get_memory() zobrazit jednotlivá zastřelená data z úlohy.

result.get_memory(circuit)

['000', '111', '111', '000', '000', '000', '111', '111']

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 pro asynchronní odeslání každého okruhu a pak načíst výsledky každé úlohy. 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

Podrobnosti o instalaci najdete v tématu Instalace sady Quantum Development Kit ve VS Code.

• Prostředí Python s nainstalovaným Python nástrojem Pip .

• VS Code s nainstalovanou sadou Azure Quantum Development Kit a Python rozšířeními

• Balíček Azure Quantum qsharpPython se značkami a widget značkamiqiskit.

  python pip install "qsharp[qiskit,widgets]>=1.9" 
  

  Důležité

  Ujistěte se, že máte nejnovější verzi Qiskitu. Další informace najdete v tématu Aktualizace balíčku azure-quantumPython.

Spuštění základního okruhu

Ve VS Code otevřete nový Python soubor, který definuje a spustí základní okruh pomocí integrovaného řídkého simulátoru v balíčku Qsharp.

# load the required imports 
from qiskit.circuit.random import random_circuit
from qsharp.interop.qiskit import QSharpBackend

# define and display the circuit
circuit = random_circuit(2, 2, measure=True)
print(circuit)

# run the circuit using the built-in sparse simulator
backend = QSharpBackend()
job = backend.run(circuit)
counts = job.result().get_counts()

print(counts)

Pokud chcete program spustit, vyberte ikonu Spustit v pravém horním rohu a vyberte Spustit Python soubor. Výstup se zobrazí v novém okně terminálu.

                  ┌─────────────────────────┐┌─┐
q_0: ─■───────────┤0                        ├┤M├───
      │P(0.79983) │  (XX-YY)(1.9337,1.7385) │└╥┘┌─┐
q_1: ─■───────────┤1                        ├─╫─┤M├
                  └─────────────────────────┘ ║ └╥┘
c: 2/═════════════════════════════════════════╩══╩═
                                              0  1
{'11': 680, '00': 344}

Další kroky

• Rychlý start: Odeslání okruhu pomocí Cirqu do Azure Quantum
• Rychlý start: Odeslání okruhu s formátem specifickým pro zprostředkovatele do Azure Quantum