Odeslat úlohy do Azure Quantum pomocí balíčku QDKPython

K odeslání Q#, OpenQASM, Qiskit, Cirq a PennyLane programů do Azure Quantum použijte balíček Microsoft Quantum Development Kit (QDK) Python.

Tento článek obsahuje příklady odeslání úloh pro každý podporovaný kvantový jazyk nebo architekturu. Informace o interaktivním pracovním postupu Q# nebo OpenQASM, který nevyžaduje kód Python, najdete v článku Odesílání úloh pomocí rozšíření QDK pro VS Code.

Předpoklady

• Účet Azure s aktivním předplatným.

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

• Python 3.10 nebo novější.

• Pokud používáte poznámkový blok Jupyter, prostředí Jupyter, například rozšíření Jupyter pro VS Code a balíček ipykernel.

• Nainstalujte Azure CLI s rozšířenímquantum.

  az extension add --upgrade --name quantum
  

• Nainstalujte nejnovější verzi balíčku qdkPython s doplňky azure a jupyter.

  pip install --upgrade "qdk[azure,jupyter]"
  

  Pokud chcete odeslat program v Qiskit nebo Cirq, nainstalujte doplňky qiskit a cirq.

  pip install --upgrade "qdk[qiskit,cirq]"
  

Připojte se ke svému Azure Quantum pracovnímu prostoru

Před odesláním úlohy se musíte připojit k pracovnímu Azure Quantum prostoru. Modul qdk.azure poskytuje Workspace objekt pro připojení k Azure Quantum pracovním prostorům. Pokud se chcete připojit ke svému pracovnímu prostoru, postupujte takto.

Přihlášení pomocí Azure CLI

Pokud jste to ještě neudělali, přihlaste se k Azure z terminálu předtím, než otevřete poznámkový blok Jupyter.

az login

Pokud se z terminálu nepřihlásíte, musíte se ověřit při každém připojení k pracovnímu prostoru Quantum prostřednictvím Python. Pokud má váš účet přístup k více předplatným, nastavte předplatné, které obsahuje váš Azure Quantum pracovní prostor.

az account set --subscription <subscription-id>

Znovu spusťteaz login, když vyprší platnost relace nebo když chcete použít jiný účet Azure.

Získejte ID prostředku svého pracovního prostoru

1. Přihlaste se do Azure Portalu.
2. Přejděte do pracovního prostoru Quantum, do kterého chcete úlohu odeslat.
3. Na stránce Přehled vyhledejte a zkopírujte ID prostředku.

Připojení k pracovnímu prostoru

1. Pokud se chcete připojit k pracovnímu prostoru Quantum, vytvořte Workspace objekt s ID prostředku, které jste zkopírovali.

   from qdk.azure import Workspace
   
   workspace = Workspace(resource_id="") # Add your resource ID
   

   Note

   Y

2. Ověřte připojení a zobrazte targets, které je dostupné v pracovním prostoru.

   for target in workspace.get_targets():
       print(target.name)
   

Další možnosti připojení a ověřování najdete v tématu Připojení k pracovnímu Azure Quantum prostoru.

Note

Následující příklady odesílaly úlohy do simulátoru targets. Dostupnost targets ve vašem pracovním prostoru závisí na nakonfigurovaných poskytovatelích.

Příprava a odeslání programu

Zvolte kartu pro váš kvantový jazyk nebo architekturu.

Q#

Modul qdk.qsharp použijte k definování nebo načtení kódu Q#, zkompilování vstupního bodu do QIR a odeslání QIR do Azure Quantumtarget.

Definování a kompilace Q# programu

1. Inicializujte Q# pomocí profilu QIRtarget, který Azure Quantumtarget podporuje.

   from qdk import qsharp, TargetProfile
   
   qsharp.init(target_profile=TargetProfile.Base)
   

   Další informace o profilech QIRtarget naleznete v části Azure QuantumQIRtarget profily v nástroji QDK.

2. Definujte operaci Q#. Použijte například následující RandomBit operaci.

   qsharp.eval("""
       operation RandomBit() : Result {
           use q = Qubit();
           H(q);
           return MResetZ(q);
       }
   """)
   

3. Otestujte operaci na místním simulátoru.

   print(qsharp.run("RandomBit()", shots=10))
   

4. Zkompilujte operaci na QIR.

   from qdk.qsharp import compile
   
   program = compile("RandomBit()")
   

Odešlete úlohu Q#

1. Vyberte kompatibilní target z vašeho pracovního prostoru.

   target = workspace.get_targets("rigetti.sim.qvm")
   

2. Odešle zkompilovaný program.

   job = target.submit(program, "qsharp-job", shots=100)
   print("Job ID:", job.id)
   

3. Počkejte, až se úloha dokončí, a získejte její výsledky.

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

OpenQASM

Použijte modul qdk.openqasm ke kompilaci zdrojového kódu OpenQASM 3 do QIR a poté odešlete QIR do Azure Quantumtarget.

Definování a kompilace OpenQASM programu

1. Definujte OpenQASM obvod jako Python řetězec.

   qasm_source = """
   OPENQASM 3.0;
   include "stdgates.inc";
   
   bit[2] c;
   qubit[2] q;
   
   h q[0];
   cx q[0], q[1];
   c = measure q;
   """
   

2. Zkompilujte program do QIR.

   from qdk.openqasm import compile
   
   program = compile(qasm_source)
   

Odešlete úlohu OpenQASM

1. Vyberte target, který přijímá zkompilovaný program.

   target = workspace.get_targets("ionq.simulator")
   

2. Odešle zkompilovaný program.

   job = target.submit(program, "openqasm-job", shots=100)
   print("Job ID:", job.id)
   

3. Počkejte, až se úloha dokončí, a získejte její výsledky.

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

U parametrizovaných OpenQASM programů vytvořte vazbu vstupních hodnot před odesláním úlohy. Další informace o OpenQASM v QDK naleznete v tématu Vývoj OpenQASM programů v QDK.

Qiskit

Pomocí AzureQuantumProvider z modulu Qiskit odešlete úlohy Azure Quantum zprostředkovateli qdk.azure. Objekt zprostředkovatele obsahuje seznam kompatibilních Azure Quantumtargets a vrací Qiskit úlohy a výsledky.

Vytvořte okruh Qiskit

from qiskit import QuantumCircuit

circuit = QuantumCircuit(3, 3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])

Odešlete úlohu Qiskit

1. Vytvořte z pracovního prostoru objekt poskytovatele Azure Quantum.

   from qdk.azure.qiskit import AzureQuantumProvider
   
   provider = AzureQuantumProvider(workspace)
   

2. Vypište backendy, které přijímají Qiskit obvody.

   for backend in provider.backends():
       print(backend.name)
   

3. Vyberte back-end a odešlete okruh.

   backend = provider.get_backend("rigetti.sim.qvm")
   job = backend.run(circuit, shots=100)
   
   print("Job ID:", job.job_id())
   print("Status:", job.status())
   

4. Počkejte, až se úloha dokončí, a získejte Qiskit výsledky.

   result = job.result()
   counts = result.get_counts(circuit)
   print(counts)
   

Adaptér Qiskit zpracovává Azure Quantum vstupní formát a převede odpověď zprostředkovatele na Qiskit výsledek.

Qiskit výsledky úloh pro programy se ztrátou qubitu

Při spuštění programu může dojít ke ztrátě qubitu některým kvantovým hardwarem. Pokud během měření programu Qiskit dojde v kterémkoli okamžiku ke ztrátě qubitu, pak se toto měření odstraní z výsledků úlohy Azure Quantum. Pokud například dojde ke ztrátě qubitu při 10 z 200 snímků, výsledky úlohy mají 190 celkového počtu měření.

Nezpracované výsledky pro všechny snímky, včetně snímků, ve kterých došlo ke ztrátě qubitu, jsou v objektu results stále dostupné. Následující kód získá obě sady výsledků.

# Get results only for shots without qubit loss
print('Counts:', result.results[0].data.counts)
print('Probabilities:', result.results[0].data.probabilities)
print('Memory:', result.results[0].data.memory)

# Get the raw total shot results
print('Raw counts:', result.results[0].data.raw_counts)
print('Raw probabilities:', result.results[0].data.raw_probabilities)
print('Raw memory:', result.results[0].data.raw_memory)

U úloh nebo targets, které nemají ztrátu qubitu, jsou výchozí výsledky a surové výsledky identické.

Note

Atributem memory pro Qiskit výsledky úlohy je seznam výsledků měření pro každý snímek.

Cirq

Pomocí AzureQuantumService z modulu Cirq odešlete úlohy Azure Quantum poskytovateli qdk.azure. Objekt služby uvádí kompatibilní Azure Quantumtargets a vrací výsledky nativní pro Cirq nebo pro poskytovatele.

Vytvořte okruh Cirq

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.H(q0),
    cirq.CX(q0, q1),
    cirq.measure(q0, q1, key="result"),
)

Odešlete úlohu Cirq

1. Azure Quantum Vytvořte objekt služby.

   from qdk.azure.cirq import AzureQuantumService
   
   service = AzureQuantumService(workspace)
   

2. Uveďte seznam targets , který přijímá Cirq okruhy.

   for target in service.targets():
       print(target.name)
   

3. Vytvořte asynchronní úlohu.

   job = service.create_job(
       program=circuit,
       repetitions=100,
       target="ionq.simulator",
   )
   
   print("Status:", job.status())
   

4. Počkejte, až se úloha dokončí, a získejte její výsledky.

   result = job.results()
   print(result)
   

Formát výsledků závisí na poskytovateli a target. Některé objekty výsledků zprostředkovatele lze převést na cirq.Result objekt.

PennyLane

PennyLane Převeďte kvantový uzel na OpenQASM, zkompilujte QIR do OpenQASM a odešlete QIR do Azure Quantumtarget

Vytvořte okruh PennyLane

Následující okruh je parametrizovaný okruh. Účinek RY brány závisí na úhlu theta.

import pennylane as qml

device = qml.device("default.qubit", wires=2)

@qml.qnode(device)
def circuit(theta):
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    qml.RY(theta, wires=1)
    return qml.expval(qml.PauliZ(1))

Převeďte obvod na QIR

1. Převeďte parametrizovaný obvod na OpenQASM pro konkrétní hodnotu parametru.

   theta = 0.3
   qasm_source = qml.to_openqasm(circuit)(theta)
   

2. Zkompilujte OpenQASM až do QIR s kompatibilním profilem target.

   from qdk import TargetProfile
   from qdk.openqasm import compile
   
   program = compile(qasm_source, TargetProfile.Base)
   

Odešlete úlohu PennyLane

1. Vyberte kompatibilní target a odešlete soubor QIR.

   target = workspace.get_targets("rigetti.sim.qvm")
   job = target.submit(program, "pennylane-job", shots=100)
   
   print("Job ID:", job.id)
   

2. Počkejte, až se úloha dokončí, a získejte její výsledky.

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

Formát výsledků závisí na poskytovateli a target. Azure Quantum nevrací PennyLane výsledky z kvantového uzlu z odeslaného QIR.

Související obsah

• Jak odesílat úlohy do Azure Quantum
• Odeslání úloh s rozšířením QDK pro VS Code
• Odeslání úloh do Azure Quantum Azure CLI
• Práce s úlohami Azure Quantum
• Podpora kvantového programovacího jazyka v QDK
• Azure Quantum poskytovatel výpočetních služeb targets