Utilice el paquete Microsoft Quantum Development Kit (QDK) Python para enviar programas Q#, OpenQASM, Qiskit, Cirq y PennyLane en Azure Quantum.
En este artículo se proporcionan ejemplos de envío de trabajos para cada lenguaje cuántico o marco de trabajo compatible. Para un flujo de trabajo interactivo Q# o Python que no requiera código QDK, consulte OpenQASM.
Prerequisites
Una cuenta de Azure con una suscripción activa.
Un área de Azure Quantum trabajo. Para crear una, consulte Creación de un Azure Quantum área de trabajo.
Python 3.10 o posterior.
Si usa un cuaderno de Jupyter, un entorno de Jupyter como la extensión de Jupyter para VS Code y el paquete ipykernel.
Instale CLI de Azure con la quantum extensión .
az extension add --upgrade --name quantum
Instale la versión más reciente del paquete qdkPython con los extras azure y jupyter.
pip install --upgrade "qdk[azure,jupyter]"
Si desea enviar un programa Qiskit o Cirq, instale los complementos cirq y qiskit.
pip install --upgrade "qdk[qiskit,cirq]"
Conéctate a tu Azure Quantum área de trabajo
Antes de enviar un trabajo, debe conectarse a un Azure Quantum área de trabajo. El módulo qdk.azure proporciona el objeto Workspace para conectarse a espacios de trabajo Azure Quantum. Para conectarse al área de trabajo, siga estos pasos.
Inicio de sesión con CLI de Azure
Si aún no lo ha hecho, inicie sesión en Azure desde un terminal antes de abrir un cuaderno de Jupyter Notebook.
az login
Si no inicia sesión desde la terminal, debe autenticarse cada vez que se conecte a un área de trabajo de Quantum a través de Python. Si su cuenta tiene acceso a varias suscripciones, establezca la suscripción que incluye su Azure Quantum espacio de trabajo.
az account set --subscription <subscription-id>
Vuelva a ejecutar az login cuando expire la sesión o cuando desee usar una cuenta de Azure diferente.
Obtención del identificador de recurso del área de trabajo
- Inicie sesión en Azure Portal.
- Vaya al área de trabajo de Quantum en la que desea enviar el trabajo.
- En la página Información general , busque y copie el identificador de recurso.
Conexión a un área de trabajo
Para conectarse al área de trabajo de Quantum, cree un Workspace objeto con el identificador de recurso que copió.
from qdk.azure import Workspace
workspace = Workspace(resource_id="") # Add your resource ID
Compruebe la conexión y consulte la targets disponible en el espacio de trabajo.
for target in workspace.get_targets():
print(target.name)
Para ver otras opciones de conexión y autenticación, consulte Conexión al Azure Quantum área de trabajo.
Note
En los ejemplos siguientes se envían trabajos al simulador targets. El targets disponible en el área de trabajo depende de los proveedores configurados.
Preparación y envío del programa
Elija la pestaña del lenguaje cuántico o del marco de trabajo.
Utilice el módulo qdk.qsharp para definir o cargar código Q#, compilar un punto de entrada a QIR y enviar QIR a un Azure Quantumtarget.
Definición y compilación del Q# programa
Inicialice Q# con un QIRtarget perfil que Azure Quantumtarget admita.
from qdk import qsharp, TargetProfile
qsharp.init(target_profile=TargetProfile.Base)
Para obtener más información sobre los perfiles QIRtarget, consulte los perfiles Azure QuantumQIRtarget en QDK.
Defina una Q# operación. Por ejemplo, use la siguiente RandomBit operación.
qsharp.eval("""
operation RandomBit() : Result {
use q = Qubit();
H(q);
return MResetZ(q);
}
""")
Pruebe la operación en el simulador local.
print(qsharp.run("RandomBit()", shots=10))
Compile la operación a QIR.
from qdk.qsharp import compile
program = compile("RandomBit()")
Enviar la Q# tarea
Seleccione una opción compatible target en el área de trabajo.
target = workspace.get_targets("rigetti.sim.qvm")
Envíe el programa compilado.
job = target.submit(program, "qsharp-job", shots=100)
print("Job ID:", job.id)
Espere a que el trabajo se complete y recupere sus resultados.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Use el módulo qdk.openqasm para compilar código fuente de OpenQASM 3 a QIR, y luego envíe el QIR a un Azure Quantumtarget.
Definición y compilación del OpenQASM programa
Defina un OpenQASM circuito como una Python cadena.
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;
"""
Compile el programa en QIR.
from qdk.openqasm import compile
program = compile(qasm_source)
Enviar la OpenQASM tarea
Seleccione un target que acepte el programa compilado.
target = workspace.get_targets("ionq.simulator")
Envíe el programa compilado.
job = target.submit(program, "openqasm-job", shots=100)
print("Job ID:", job.id)
Espere a que el trabajo se complete y recupere sus resultados.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Para los programas con parámetros OpenQASM , enlace los valores de entrada antes de enviar un trabajo. Para obtener más información sobre OpenQASM en QDK, consulte Desarrollo de programas OpenQASM en QDK.
Utilice AzureQuantumProvider del módulo qdk.azure para enviar trabajos Qiskit a un proveedor Azure Quantum. El objeto proveedor enumera los QiskitAzure Quantum compatibles y devuelve los trabajos y resultados de targets.
Creación de 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])
Enviar la Qiskit tarea
Cree un objeto de proveedor Azure Quantum a partir del área de trabajo.
from qdk.azure.qiskit import AzureQuantumProvider
provider = AzureQuantumProvider(workspace)
Enumere los backends que aceptan circuitos Qiskit.
for backend in provider.backends():
print(backend.name)
Seleccione un backend y envíe el circuito.
backend = provider.get_backend("rigetti.sim.qvm")
job = backend.run(circuit, shots=100)
print("Job ID:", job.job_id())
print("Status:", job.status())
Espere a que el trabajo se complete y recupere los Qiskit resultados.
result = job.result()
counts = result.get_counts(circuit)
print(counts)
El Qiskit adaptador controla el Azure Quantum formato de entrada y convierte la respuesta del proveedor en un Qiskit resultado.
Qiskit resultados de trabajos para programas con pérdida de cúbits
Algunos hardware cuánticos pueden experimentar pérdida de cúbits cuando se ejecuta un programa. Si se produce la pérdida de cúbits en algún momento durante un shot para un programa Qiskit, ese shot se elimina de los resultados del trabajo Azure Quantum. Por ejemplo, si se produce la pérdida de cúbits en 10 de 200 ejecuciones, los resultados del trabajo contienen 190 recuentos de medición en total.
Los resultados sin procesar de todas las capturas, incluidas las capturas en las que se produjo la pérdida de cúbits, siguen estando disponibles en el results objeto . El código siguiente obtiene ambos conjuntos de resultados.
# 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)
En el caso de los trabajos o targets que no tienen pérdida de cúbits, los resultados predeterminados y los resultados sin procesar son idénticos.
Note
El atributo memory de los resultados del trabajo Qiskit es una lista de los resultados de medición de cada disparo.
Utiliza AzureQuantumService del módulo qdk.azure para enviar trabajos Cirq a un proveedor Azure Quantum. El objeto de servicio muestra resultados compatibles Azure Quantumtargets y devuelve Cirqresultados nativos o nativos del proveedor.
Creación de 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"),
)
Enviar la Cirq tarea
Cree el objeto de Azure Quantum servicio.
from qdk.azure.cirq import AzureQuantumService
service = AzureQuantumService(workspace)
Liste los targets que aceptan circuitos Cirq.
for target in service.targets():
print(target.name)
Cree una tarea asíncrona.
job = service.create_job(
program=circuit,
repetitions=100,
target="ionq.simulator",
)
print("Status:", job.status())
Espere a que el trabajo se complete y recupere sus resultados.
result = job.results()
print(result)
El formato de los resultados depende del proveedor y target. Algunos objetos de resultado del proveedor se pueden convertir en un objeto cirq.Result.
Convierta un PennyLane nodo cuántico en OpenQASM, compile el QIR a OpenQASM y envíe el QIR a un Azure Quantumtarget.
Creación de un PennyLane circuito
El siguiente circuito es un circuito con parámetros. El efecto de la RY puerta depende del ángulo 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))
Convierta el circuito a QIR
Convierta el circuito parametrizado en OpenQASM para un valor de parámetro específico.
theta = 0.3
qasm_source = qml.to_openqasm(circuit)(theta)
Compile OpenQASM a QIR con un perfil target compatible.
from qdk import TargetProfile
from qdk.openqasm import compile
program = compile(qasm_source, TargetProfile.Base)
Enviar la PennyLane tarea
Seleccione un elemento compatible target y envíe el QIR.
target = workspace.get_targets("rigetti.sim.qvm")
job = target.submit(program, "pennylane-job", shots=100)
print("Job ID:", job.id)
Espere a que el trabajo se complete y recupere sus resultados.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
El formato de los resultados depende del proveedor y target.
Azure Quantum no devuelve PennyLane los resultados de nodos cuánticos del QIR enviado.
Contenido relacionado