Usare il pacchetto Microsoft Quantum Development Kit (QDK) Python per inviare i programmi Q#, Qiskit, OpenQASM, Cirq e PennyLane a Azure Quantum.
Questo articolo fornisce esempi di invio di processi per ogni linguaggio quantistico o framework supportato. Per un flusso di lavoro interattivo Q# o OpenQASM che non richiede codice Python, vedere Inviare processi tramite l'estensione QDK per VS Code.
Prerequisiti
Un account Azure con una sottoscrizione attiva.
Un'area Azure Quantum di lavoro. Per crearne uno, vedere Creare un'area Azure Quantum di lavoro.
Python 3.10 o versione successiva.
Se si utilizza un notebook Jupyter, un ambiente Jupyter come l'estensione Jupyter per VS Code e il pacchetto ipykernel.
Installare interfaccia della riga di comando di Azure con l'estensione quantum .
az extension add --upgrade --name quantum
Installare la versione più recente del pacchetto qdkPython con i componenti aggiuntivi azure e jupyter.
pip install --upgrade "qdk[azure,jupyter]"
Se si desidera inviare un programma Qiskit o Cirq, installare i componenti aggiuntivi cirq e qiskit.
pip install --upgrade "qdk[qiskit,cirq]"
Connettersi all'area Azure Quantum di lavoro
Prima di inviare un'attività, devi connetterti a un'area di lavoro Azure Quantum. Il qdk.azure modulo fornisce l'oggetto Workspace per connettersi alle Azure Quantum aree di lavoro. Per connettersi all'area di lavoro, seguire questa procedura.
Accedere con interfaccia della riga di comando di Azure
Se non è già stato fatto, accedere a Azure da un terminale prima di aprire un notebook di Jupyter.
az login
Se non si accede dal terminale, è necessario eseguire l'autenticazione ogni volta che ci si connette a un'area di lavoro Quantum tramite Python. Se il tuo account ha accesso a più sottoscrizioni, seleziona la sottoscrizione che contiene la tua area di lavoro Azure Quantum.
az account set --subscription <subscription-id>
Eseguire az login di nuovo quando la sessione scade o quando si vuole usare un account di Azure diverso.
Ottieni l'ID della risorsa dell'area di lavoro
- Accedi al portale di Azure.
- Vai al workspace Quantum in cui vuoi inviare il job.
- Nella pagina Panoramica trovare e copiare l'ID risorsa.
Connettersi all'area di lavoro
Per connettersi all'area di lavoro Quantum, creare un Workspace oggetto con l'ID risorsa copiato.
from qdk.azure import Workspace
workspace = Workspace(resource_id="") # Add your resource ID
Verificare la connessione e visualizzare l'oggetto targets disponibile nell'area di lavoro.
for target in workspace.get_targets():
print(target.name)
Per altre opzioni di connessione e autenticazione, vedere Connettersi all'area Azure Quantum di lavoro.
Note
Gli esempi seguenti inviano processi al simulatore targets. Le targets disponibili nella tua area di lavoro dipendono dai provider configurati.
Preparare e inviare il programma
Scegliere la scheda per il linguaggio quantistico o il framework.
Utilizzare il modulo qdk.qsharp per definire o caricare il codice Q#, compilare un punto d’ingresso in QIR e inviare il QIR a un oggetto Azure Quantumtarget.
Definire e compilare il Q# programma
Inizializzare Q# con un profilo QIRtarget supportato da Azure Quantumtarget.
from qdk import qsharp, TargetProfile
qsharp.init(target_profile=TargetProfile.Base)
Per ulteriori informazioni sui profili QIRtarget, vedere Azure QuantumQIRtarget profili nel QDK.
Definire un'operazione Q#. Ad esempio, usare l'operazione seguente RandomBit .
qsharp.eval("""
operation RandomBit() : Result {
use q = Qubit();
H(q);
return MResetZ(q);
}
""")
Testare l'operazione nel simulatore locale.
print(qsharp.run("RandomBit()", shots=10))
Compila l'operazione in QIR.
from qdk.qsharp import compile
program = compile("RandomBit()")
Invia il Q# processo
Seleziona un elemento compatibile target dal tuo spazio di lavoro.
target = workspace.get_targets("rigetti.sim.qvm")
Inviare il programma compilato.
job = target.submit(program, "qsharp-job", shots=100)
print("Job ID:", job.id)
Attendere il completamento del processo e recuperarne i risultati.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Utilizzare il modulo qdk.openqasm per compilare il codice sorgente OpenQASM 3 in QIR, e quindi inviare il QIR a un Azure Quantumtarget.
Definire e compilare il OpenQASM programma
Definire un circuito OpenQASM come una stringa Python.
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;
"""
Compilare il programma in QIR.
from qdk.openqasm import compile
program = compile(qasm_source)
Invia il OpenQASM processo
Selezionare un target che accetta il programma compilato.
target = workspace.get_targets("ionq.simulator")
Inviare il programma compilato.
job = target.submit(program, "openqasm-job", shots=100)
print("Job ID:", job.id)
Attendere il completamento del processo e recuperarne i risultati.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Per i programmi parametrizzati con OpenQASM, associare i valori di input prima di inviare un'attività. Per altre informazioni su OpenQASM in QDK, vedere Sviluppare OpenQASM programmi in QDK.
Usa AzureQuantumProvider dal modulo qdk.azure per inviare job Qiskit a un provider Azure Quantum. L'oggetto provider elenca i processi e i risultati compatibili Azure Quantumtargets e restituisce Qiskit .
Creare un Qiskit circuito
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])
Invia il Qiskit job
Creare un Azure Quantum oggetto provider dall'area di lavoro.
from qdk.azure.qiskit import AzureQuantumProvider
provider = AzureQuantumProvider(workspace)
Elencare i back-end che accettano Qiskit circuiti.
for backend in provider.backends():
print(backend.name)
Selezionare un back-end e inviare il circuito.
backend = provider.get_backend("rigetti.sim.qvm")
job = backend.run(circuit, shots=100)
print("Job ID:", job.job_id())
print("Status:", job.status())
Attendere il completamento del processo e recuperare i Qiskit risultati.
result = job.result()
counts = result.get_counts(circuit)
print(counts)
L'adattatore Qiskit gestisce il Azure Quantum formato di input e converte la risposta del provider in un Qiskit risultato.
Qiskit risultati dei processi per programmi con perdita di qubit
Alcuni hardware quantistici possono riscontrare perdite di qubit quando un programma è in esecuzione. Se si verifica una perdita di qubit in qualsiasi momento durante uno shot in un programma Qiskit, allora quello shot viene rimosso dai risultati del job Azure Quantum. Ad esempio, se si verifica una perdita di qubit in 10 scatti su 200, i risultati del processo hanno 190 conteggi totali di misurazioni.
I risultati non elaborati per tutti gli scatti, inclusi gli scatti in cui si è verificata la perdita di qubit, sono ancora disponibili nell'oggetto results . Il codice seguente ottiene entrambi i set di risultati.
# 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)
Per i processi o targets che non hanno perdita di qubit, i risultati predefiniti e i risultati grezzi sono identici.
Note
L'attributo memory dei risultati del processo Qiskit è un elenco dei risultati di misurazione per ciascun colpo.
Utilizzare AzureQuantumService dal modulo qdk.azure per inviare job Cirq a un fornitore Azure Quantum. L'oggetto di servizio elenca Azure Quantumtargets compatibili e restituisce risultati nativi di Cirq o del provider.
Creare un Cirq circuito
import cirq
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.H(q0),
cirq.CX(q0, q1),
cirq.measure(q0, q1, key="result"),
)
Invia il Cirq job
Creare l'oggetto servizio Azure Quantum.
from qdk.azure.cirq import AzureQuantumService
service = AzureQuantumService(workspace)
Elenca i targets che accettano circuiti Cirq.
for target in service.targets():
print(target.name)
Crea un processo asincrono.
job = service.create_job(
program=circuit,
repetitions=100,
target="ionq.simulator",
)
print("Status:", job.status())
Attendere il completamento del processo e recuperarne i risultati.
result = job.results()
print(result)
Il formato dei risultati dipende dal provider e target. Alcuni oggetti risultato del provider possono essere convertiti in un oggetto cirq.Result.
Converti un PennyLane nodo quantistico in OpenQASM, compila il OpenQASM in QIR e invia il QIR a un Azure Quantumtarget.
Creare un PennyLane circuito
Il circuito seguente è un circuito con parametri. L'effetto del RY cancello dipende dall'angolo 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))
Convertire il circuito in QIR
Convertire il circuito con parametri in OpenQASM per un valore di parametro specifico.
theta = 0.3
qasm_source = qml.to_openqasm(circuit)(theta)
Compilare da OpenQASM a QIR con un profilo target compatibile.
from qdk import TargetProfile
from qdk.openqasm import compile
program = compile(qasm_source, TargetProfile.Base)
Invia il PennyLane job
Selezionare un elemento compatibile target e inviare il QIR.
target = workspace.get_targets("rigetti.sim.qvm")
job = target.submit(program, "pennylane-job", shots=100)
print("Job ID:", job.id)
Attendere il completamento del processo e recuperarne i risultati.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Il formato dei risultati dipende dal fornitore e target.
Azure Quantum non restituisce PennyLane i risultati del nodo quantistico dal QIR inviato.
Contenuti correlati