Feladatok elküldése ide: Azure Quantum a QDKPython csomaggal

A Microsoft Quantum Development Kit (QDK) Python csomag használatával küldje be a Q#, OpenQASM, Qiskit, PennyLane és Cirq programokat a Azure Quantum részére.

Ez a cikk példákat tartalmaz a feladatok beküldésével kapcsolatban minden támogatott kvantumnyelvhez vagy -keretrendszerhez. Olyan interaktív Q# vagy OpenQASM munkafolyamat esetén, amely nem igényel Python kódot, olvassa el a Feladatok elküldése a QDK bővítményrel című témakört VS Code.

Prerequisites

• Egy Azure-fiók, aktív előfizetéssel.

• Egy Azure Quantum munkaterület. A munkaterület létrehozásához lásd a Munkaterület létrehozása című témakörtAzure Quantum.

• Python 3.10 vagy újabb.

• Ha Jupyter-jegyzetfüzetet használ, egy Jupyter-környezetet, például a Jupyter-bővítményt VS Code, illetve a ipykernel csomagot.

• Telepítse az Azure CLI-t a quantum bővítménnyel.

  az extension add --upgrade --name quantum
  

• Telepítse a qdkPython csomag legújabb verzióját a azure és jupyter extrákkal.

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

  Ha be szeretne küldeni egy Qiskit programot vagy Cirq programot, telepítse az és qiskit az cirq extrákat.

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

Csatlakozzon a Azure Quantum munkaterülethez

Warning

2027 Azure Quantum . január 11-től a Kvantum-munkaterület felhasználóinak kvantum-munkaterületi adatolvasó vagy Kvantum-munkaterület adatszolgáltatói szerepkörrel kell rendelkezniük a feladatok eredményeinek eléréséhez. A feladatok elküldéséhez a Quantum Workspace adat-közreműködői szerepköre szükséges. A munkafolyamatok megszakításainak Azure Quantum elkerülése érdekében a határidő előtt rendelje hozzá ezeket a szerepköröket a megfelelő felhasználókhoz. További információ: Adathozzáférési szerepkörök hozzárendelése a munkaterület felhasználói számára.

A feladat elküldése előtt csatlakoznia kell egy Azure Quantum munkaterülethez. A qdk.azure modul egy Workspace objektumot biztosít a Azure Quantum munkaterületekhez való csatlakozáshoz. A munkaterülethez való csatlakozáshoz kövesse az alábbi lépéseket.

Bejelentkezés az Azure CLI használatával

Ha még nem tette meg, jelentkezzen be Azure egy terminálból, mielőtt megnyit egy Jupyter-jegyzetfüzetet.

az login

Ha nem jelentkezik be a terminálról, minden alkalommal hitelesítenie kell magát, amikor a Kvantum-munkaterülethez csatlakozik Python. Ha a fiókja több előfizetéshez is hozzáfér, válassza ki azt az előfizetést, amely a Azure Quantum munkaterületét tartalmazza.

az account set --subscription <subscription-id>

Futtassa az login újra a munkamenet lejártakor, vagy ha másik Azure fiókot szeretne használni.

A munkaterület erőforrás-azonosítójának lekérése

1. Jelentkezzen be a Azure portalra.
2. Lépjen arra a Quantum-munkaterületre, ahová be szeretné küldeni a feladatát.
3. Az Áttekintés lapon keresse meg és másolja az erőforrás-azonosítót.

Csatlakozás a munkaterülethez

1. A Kvantum-munkaterülethez való csatlakozáshoz hozzon létre egy Workspace objektumot a másolt erőforrás-azonosítóval.

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

   Note

   Y

2. Ellenőrizze a kapcsolatot, és tekintse meg a munkaterületen elérhető targets elemeket.

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

Egyéb kapcsolati és hitelesítési lehetőségekért lásd: Csatlakozás a Azure Quantum munkaterülethez.

Note

Az alábbi példák feladatokat küldenek a szimulátorba targets. A targets munkaterületen elérhető szolgáltatások a konfigurált szolgáltatóktól függenek.

A program előkészítése és elküldése

Válassza ki a kvantumnyelv vagy -keretrendszer lapját.

Q#

A qdk.qsharp modul használatával meghatározhatja vagy betöltheti a(z) Q# kódot, lefordíthat egy belépési pontot QIR formátumra, és elküldheti a(z) QIR elemet egy Azure Quantumtarget számára.

A Q# program definiálása és lefordítása

1. Inicializálja a Q# elemet a Azure Quantumtarget által támogatott targetQIR profillal.

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

   A QIRtarget profilokkal kapcsolatos további információkért lásd a(z) QDKAzure QuantumQIRtarget profilok című részt.

2. Adjon meg egy Q# műveletet. Használja például a következő RandomBit műveletet.

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

3. Tesztelje a műveletet a helyi szimulátoron.

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

4. Fordítsa le a műveletet ide: QIR.

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

A Q# feladat elküldése

1. Válasszon ki egy kompatibilist target a munkaterületről.

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

2. Küldje el a lefordított programot.

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

3. Várja meg, amíg a feladat befejeződik, majd kérje le az eredményeket.

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

OpenQASM

A(z) qdk.openqasm modul használatával fordítsa le a(z) OpenQASM 3 forráskódot QIR formátumra, majd küldje be a(z) QIR elemet egy Azure Quantumtarget számára.

A OpenQASM program definiálása és lefordítása

1. Definiáljon egy OpenQASM áramkört Python sztringként.

   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. A program fordítása a következőre QIR: .

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

A OpenQASM feladat elküldése

1. Válasszon ki egy target elemet, amely fogadja a lefordított programot.

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

2. Küldje el a lefordított programot.

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

3. Várja meg, amíg a feladat befejeződik, majd kérje le az eredményeket.

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

Paraméteres OpenQASM programok esetén a feladat elküldése előtt kösse össze a bemeneti értékeket. A(z) QDKOpenQASM elemével kapcsolatos további információkért lásd: OpenQASM programok fejlesztése a(z) QDK környezetben.

Qiskit

Használja a(z) qdk.azure modul AzureQuantumProvider elemét Qiskit feladatok egy Azure Quantum szolgáltatónak történő elküldésére. A szolgáltatóobjektum felsorolja a kompatibilis Azure Quantumtargets elemeket, és visszaadja a Qiskit feladatokat és eredményeket.

Qiskit Áramkör létrehozása

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

A Qiskit feladat elküldése

1. Hozzon létre egy Azure Quantum szolgáltatóobjektumot a munkaterületről.

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

2. Sorolja fel azokat a háttérrendszereket, amelyek elfogadják a Qiskit áramköröket.

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

3. Válasszon egy háttérrendszert, és küldje el az áramkört.

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

4. Várja meg, amíg a feladat befejeződik, majd kérje le az Qiskit eredményeket.

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

Az Qiskit adapter kezeli a Azure Quantum bemeneti formátumot, és eredményké alakítja a szolgáltatói választ Qiskit .

Qiskit qubitveszteséggel rendelkező programok feladateredménye

Bizonyos kvantumhardverek qubitveszteséget tapasztalhatnak egy program futtatásakor. Ha a qubitvesztés egy program lövése Qiskit során bármikor bekövetkezik, akkor a rendszer eltávolítja a lövést a Azure Quantum feladat eredményeiből. Ha például a qubitveszteség 200 felvételből 10-ben fordul elő, akkor a feladat eredményei összesen 190 mérési számot mutatnak.

Az összes felvétel nyers eredményei, beleértve azokat a felvételeket is, amelyekben qubitveszteség történt, továbbra is elérhetők az results objektumban. Az alábbi kód mindkét találatkészletet lekéri.

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

A qubitveszteséggel nem rendelkező feladatok targets esetében az alapértelmezett eredmények és a nyers eredmények azonosak.

Note

A memory feladateredmények Qiskit attribútuma az egyes lövések mérési eredményeinek listája.

Cirq

Használja a(z) qdk.azure modul AzureQuantumService elemét Cirq feladatok egy Azure Quantum szolgáltatónak történő elküldésére. A szolgáltatásobjektum a kompatibilis Azure Quantumtargets eredményeket listázza, és natív vagy szolgáltatói natív eredményeket ad Cirqvissza.

Cirq Áramkör létrehozása

import cirq

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

A Cirq feladat elküldése

1. Hozza létre a Azure Quantum szolgáltatásobjektumot.

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

2. Listázhatja az targets elfogadó Cirq áramköröket.

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

3. Aszinkron feladat létrehozása.

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

4. Várja meg, amíg a feladat befejeződik, majd kérje le az eredményeket.

   result = job.results()
   print(result)
   

Az eredmények formátuma a szolgáltatótól és target függ. Egyes szolgáltatói eredményobjektumok átalakíthatók objektummá cirq.Result .

PennyLane

Konvertáljon egy PennyLane kvantumcsomópontot OpenQASM formátumba, fordítsa le a OpenQASM elemet QIR formátumba, és küldje be a QIR elemet egy Azure Quantumtarget számára.

PennyLane Áramkör létrehozása

Az alábbi áramkör egy paraméterezett áramkör. A kapu hatása a RY szögtől thetafügg .

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

Az áramkör átalakítása erre: QIR

1. Alakítsa át a paraméterezett áramkört OpenQASM egy adott paraméterértékhez.

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

2. Fordítsa le a OpenQASM elemet QIR célra egy kompatibilis target profillal.

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

A PennyLane feladat elküldése

1. Válasszon ki egy kompatibilist target , és küldje el a QIR.

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

2. Várja meg, amíg a feladat befejeződik, majd kérje le az eredményeket.

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

Az eredmények formátuma a szolgáltatótól és target függ. Azure Quantum nem szolgáltat PennyLane kvantumcsomópont-eredményeket a beküldött QIR.

Kapcsolódó tartalom

• Feladatok beküldése Azure Quantum
• Feladatok elküldése a QDK következő kiterjesztéssel: VS Code
• Feladatok elküldése ide: Azure Quantum az Azure CLI használatával
• Feladatok kezelése Azure Quantum
• A kvantumprogramozási nyelv támogatása a QDK
• Azure Quantum számítástechnikai szolgáltató targets