Skicka jobb till Azure Quantum med QDKPython paketet

Microsoft Quantum Development Kit Använd paketet (QDK) Python för att skicka Q#, OpenQASM, Qiskit, Cirqoch PennyLane program till Azure Quantum.

Den här artikeln innehåller exempel på jobbinskickning för varje kvantspråk eller ramverk som stöds. För ett interaktivt Q#- eller OpenQASM-arbetsflöde som inte kräver Python-kod, se Skicka jobb med tillägget QDK för VS Code.

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration.

• En Azure Quantum arbetsyta. Information om hur du skapar en finns i Skapa en Azure Quantum arbetsyta.

• Python 3.10 eller senare.

• Om du använder en Jupyter-anteckningsbok, en Jupyter-miljö som tillägget Jupyter för VS Code och paketet ipykernel.

• Installera Azure CLI med quantum tillägget.

  az extension add --upgrade --name quantum
  

• Installera den senaste versionen av qdkPython paketet med azure och jupyter extrafunktionerna.

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

  Om du vill skicka in ett Qiskit- eller Cirq-program, installera tilläggen cirq och qiskit.

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

Ansluta till din Azure Quantum arbetsyta

Innan du skickar ett jobb måste du ansluta till en Azure Quantum arbetsyta. Modulen qdk.azure innehåller objektet Workspace för att ansluta till Azure Quantum arbetsytor. Följ dessa steg för att ansluta till din arbetsyta.

Logga in med Azure CLI

Om du inte redan har gjort det loggar du in på Azure från en terminal innan du öppnar en Jupyter-anteckningsbok.

az login

Om du inte loggar in från terminalen måste du autentisera varje gång du ansluter till en Quantum-arbetsyta via Python. Om ditt konto har åtkomst till flera prenumerationer anger du den prenumeration som innehåller din Azure Quantum arbetsyta.

az account set --subscription <subscription-id>

Kör az login igen när sessionen upphör att gälla eller när du vill använda ett annat Azure konto.

Hämta resurs-ID för din arbetsyta

1. Logga in på Azure-portalen.
2. Gå till Quantum-arbetsytan där du vill skicka in jobbet.
3. På sidan Översikt letar du upp och kopierar resurs-ID.

Anslut till arbetsytan

1. Om du vill ansluta till din Quantum-arbetsyta skapar du ett Workspace objekt med det resurs-ID som du kopierade.

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

   Note

   Y

2. Kontrollera anslutningen och visa de targets som är tillgängliga på arbetsytan.

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

Andra alternativ för anslutning och autentisering finns i Ansluta till din Azure Quantum arbetsyta.

Note

I följande exempel skickas jobb till simulatorn targets. Vilka targets som är tillgängliga på din arbetsyta beror på dina konfigurerade leverantörer.

Förbereda och skicka in ditt program

Välj fliken för ditt kvantspråk eller ramverk.

Q#

Använd modulen qdk.qsharp för att definiera eller läsa in Q# kod, kompilera en startpunkt till QIRoch skicka QIR till en Azure Quantumtarget.

Definiera och kompilera Q# programmet

1. Initiera Q# med en QIRtarget-profil som Azure Quantumtarget stöder.

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

   Mer information om QIRtarget-profiler finns i Azure QuantumQIRtarget profiler i QDK.

2. Definiera en Q# åtgärd. Använd till exempel följande RandomBit åtgärd.

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

3. Testa åtgärden på den lokala simulatorn.

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

4. Kompilera åtgärden till QIR.

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

Skicka jobbet Q#

1. Välj en kompatibel target från din arbetsyta.

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

2. Skicka det kompilerade programmet.

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

3. Vänta tills jobbet har slutförts och hämta dess resultat.

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

OpenQASM

Använd modulen qdk.openqasm för att kompilera OpenQASM 3 källkod till QIRoch skicka QIR sedan till en Azure Quantumtarget.

Definiera och kompilera OpenQASM programmet

1. Definiera en OpenQASM krets som en Python sträng.

   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. Kompilera programmet till QIR.

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

Skicka jobbet OpenQASM

1. Välj en target som accepterar det kompilerade programmet.

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

2. Skicka det kompilerade programmet.

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

3. Vänta tills jobbet har slutförts och hämta dess resultat.

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

För parametriserade OpenQASM program binder du indatavärdena innan du skickar ett jobb. Mer information om OpenQASM i QDK finns i Utveckla OpenQASM-program i QDK.

Qiskit

Använd AzureQuantumProvider från modulen qdk.azure för att skicka Qiskit jobb till en Azure Quantum provider. Providerobjektet listar kompatibla Azure Quantumtargets och returnerar Qiskit jobb och resultat.

Skapa en Qiskit krets

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

Skicka jobbet Qiskit

1. Skapa ett Azure Quantum providerobjekt från arbetsytan.

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

2. Visa en lista över de serverdelar som accepterar Qiskit kretsar.

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

3. Välj en backend och skicka in kretsen.

   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änta tills jobbet har slutförts och hämta resultatet Qiskit .

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

Adaptern Qiskit hanterar Azure Quantum indataformatet och konverterar providersvaret till ett Qiskit resultat.

Qiskit jobbresultat för program med qubitförlust

En del kvantmaskinvara kan uppleva kvantbitsförlust när ett program körs. Om qubitförlust uppstår vid någon tidpunkt under ett skott för ett Qiskit-program tas detta skott bort från jobbresultaten för Azure Quantum. Om qubitförlust till exempel inträffar i 10 av 200 skott har jobbresultatet 190 totala måttantal.

De råa resultaten för alla skott, inklusive skott där qubitförlust inträffade, är fortfarande tillgängliga i results objektet. Följande kod hämtar båda uppsättningarna med resultat.

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

För jobb eller targets som inte har qubitförlust är standardresultaten och råresultaten identiska.

Note

Attributet memory för Qiskit jobbresultaten är en lista över mätresultaten för varje skott.

Cirq

Använd AzureQuantumService från modulen qdk.azure för att skicka Cirq jobb till en Azure Quantum provider. Serviceobjektet listar kompatibla Azure Quantumtargets och returnerar Cirq-baserade eller leverantörsbaserade resultat.

Skapa en Cirq krets

import cirq

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

Skicka jobbet Cirq

1. Azure Quantum Skapa tjänstobjektet.

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

2. Visa en lista över vilka targets som accepterar Cirq kretsar.

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

3. Skapa ett asynkront jobb.

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

4. Vänta tills jobbet har slutförts och hämta dess resultat.

   result = job.results()
   print(result)
   

Resultatets format beror på providern och target. Vissa providerresultatobjekt kan konverteras till ett cirq.Result objekt.

PennyLane

Konvertera en PennyLane kvantnod till OpenQASM, kompilera OpenQASM till QIRoch skicka QIR till en Azure Quantumtarget.

Skapa en PennyLane krets

Följande krets är en parametriserad krets. Effekten av grinden RY beror på vinkeln 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))

Konvertera kretsen till QIR

1. Konvertera den parametriserade kretsen till OpenQASM för ett specifikt parametervärde.

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

2. Kompilera OpenQASM till QIR med en kompatibel target profil.

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

Skicka jobbet PennyLane

1. Välj en kompatibel target och skicka QIR.

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

2. Vänta tills jobbet har slutförts och hämta dess resultat.

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

Resultatets format beror på providern och target. Azure Quantum returnerar inte PennyLane resultat från kvantnoder från den skickade QIR.

Relaterat innehåll

• Skicka jobb till Azure Quantum
• Skicka jobb med QDK tillägget för VS Code
• Skicka jobb till Azure Quantum med Azure CLI
• Arbeta med Azure Quantum jobb
• Stöd för kvantprogrammeringsspråk i QDK
• Azure Quantum databehandlingsprovider targets