Cómo enviar un circuito con Cirq a Azure Quantum

Aprenda a enviar un circuito cuántico cirq mediante el azure-quantumPython paquete. Puede enviar circuitos Cirq a Azure Quantum mediante el Kit de desarrollo de Azure Quantum (QDK) y Jupyter Notebook en Visual Studio Code (VS Code) desde la máquina local.

Para más información, consulte Circuitos cuánticos.

Requisitos previos

Para obtener más información sobre la instalación, consulte Configuración de la extensión QDK.

Un área de trabajo de Azure Quantum en la suscripción de Azure. Para crear un área de trabajo, consulte Creación de un área de trabajo de Azure Quantum.
Un entorno Python con Python y Pip instalado.
VS Code con las extensiones de Azure Quantum Development Kit, Pythony Jupyter instaladas.
El paquete de Azure Quantum azure-quantum con el cirq adicional y los paquetes qdk y ipykernel.
```
python -m pip install --upgrade "azure-quantum[cirq]" qdk ipykernel 
```
Nota:

Si no se detecta el kernel Python de Jupyteripykernel, VS Code le pedirá que lo instale.

Crear un nuevo cuaderno de Jupyter Notebook

En VS Code, abra el menú Ver y elija Paleta de comandos.
Introduzca y seleccione Crear: Nuevo Jupyter Notebook.
VS Code detecta y muestra la versión de Python y el entorno virtual Python seleccionado para el cuaderno. Si tiene varios Python entornos, es posible que tenga que seleccionar un kernel usando el selector de kernel ubicado en la esquina superior derecha. Si no se detectó ningún entorno, consulte Cuadernos de Jupyter en VS Code para más información sobre la configuración.

Carga de las importaciones necesarias

En la primera celda del cuaderno, ejecute el código siguiente para cargar las importaciones necesarias:

import azure.quantum
from azure.quantum.cirq import AzureQuantumService

Conexión al servicio Azure Quantum

Para conectarse al servicio Azure Quantum, el programa necesitará el identificador de recurso y la ubicación del área de trabajo de Azure Quantum.

Inicie sesión en su cuenta de Azure, https://portal.azure.com,
Seleccione el área de trabajo de Azure Quantum y vaya a Información general.
Copie los parámetros en los campos.

Agregue una nueva celda y use la información de su cuenta para crear objetos Workspace y AzureQuantumService para conectarse a su área de trabajo de Azure Quantum.

workspace = Workspace(  
    resource_id = "", # Add the resourceID of your workspace
    location = "" # Add the location of your workspace (for example "westus")
    )

service = AzureQuantumService(workspace)

Enumerar todos los elementos targets

Usa el método targets() para enumerar todos los targets de tu área de trabajo que pueden ejecutar tu circuito, incluido el tiempo de cola actual y la disponibilidad.

Nota:

Es posible que no aparezcan todos los targets en su área de trabajo; aquí solo se mostrarán los targets que puedan aceptar un circuito de Cirq o OpenQASM.

print(service.targets())

[<Target name="quantinuum.qpu.h2-1", avg. queue time=0 s, Degraded>,
<Target name="quantinuum.sim.h2-1sc", avg. queue time=1 s, Available>,
<Target name="quantinuum.sim.h2-1e", avg. queue time=40 s, Available>,
<Target name="ionq.simulator", avg. queue time=3 s, Available>,
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>]

Creación de un circuito simple

A continuación, cree un circuito de Cirq simple para ejecutarlo. Este circuito usa la raíz cuadrada de la puerta X, nativa del sistema de hardware de IonQ.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0)**0.5,             # Square root of X
    cirq.CX(q0, q1),              # CNOT
    cirq.measure(q0, q1, key='b') # Measure both qubits
)
print(circuit)

0: ───X^0.5───@───M────────
              │   │
1: ───────────X───M────────

Selecciona un target para ejecutar tu programa

IonQ
Quantinuum

Ejecución en el simulador de IonQ

Ahora puede ejecutar el programa a través del servicio Azure Quantum y obtener el resultado. La celda siguiente envía un trabajo (al simulador de IonQ predeterminado) que ejecuta el circuito con 100 tomas, espera hasta que se complete el trabajo y devuelve los resultados.

result = service.run(program=circuit, repetitions=100, target="ionq.simulator")

Esto devuelve un objeto cirq.Result.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Estimación del costo del trabajo

Antes de ejecutar un trabajo en la QPU, debería calcular cuánto costará ejecutarlo.

Para obtener los precios más actuales, consulte los precios de IonQ o vaya a su área de trabajo y consulte las opciones de precios en la hoja "Proveedores" en: aka.ms/aq/myworkspaces.

Ejecución en la QPU de IonQ

El trabajo anterior se ejecutó en el simulador predeterminado, "ionq.simulator". Sin embargo, también puede ejecutarlo en el procesador de hardware de IonQ, una unidad de procesador cuántico (QPU). Para ejecutarlo en la QPU de IonQ, proporcione "ionq.qpu.aria-1" como argumento target:

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu.aria-1",
    timeout_seconds=500 # Set timeout to accommodate queue time on QPU
)

De nuevo, esto devuelve un objeto cirq.Result.

print(result)

b=0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111, 0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111

Modelo asincrónico con trabajos

En el caso de los circuitos de ejecución prolongada, puede ser útil ejecutarlos de forma asincrónica. El método service.create_job devuelve un objeto Job, que puede usar para obtener los resultados después de que el trabajo se haya ejecutado correctamente.

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

Para comprobar el estado del trabajo, use job.status():

print(job.status())

'completed'

Para esperar a que se complete el trabajo y, a continuación, obtener los resultados, use la llamada de bloqueo job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Tenga en cuenta que no devuelve un objeto cirq.Result. En su lugar, devuelve un objeto de resultado específico del simulador de IonQ y usa probabilidades de estado en lugar de datos de toma.

type(result)

cirq_ionq.results.SimulatorResult

Para convertirlo en un objeto cirq.Result, use result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Ejecución en el simulador de Quantinuum

Ahora puede ejecutar el programa a través del servicio Azure Quantum y obtener el resultado. La celda siguiente envía un trabajo que ejecuta el circuito con 100 tomas, espera hasta que se complete el trabajo y devuelve los resultados.

result = service.run(program=circuit, repetitions=100, target="quantinuum.sim.h2-1sc")

Esto devuelve un objeto cirq.Result.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Puede trazar los resultados en un histograma:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Si observa el histograma, puede observar que el generador de números aleatorios devuelve 0 cada vez, lo que no es muy aleatorio. Esto se debe a que, aunque el validador de API garantiza que el código se ejecutará correctamente en el hardware de Quantinuum, también devuelve 0 para cada medida cuántica. Para que el generador de números aleatorios sea verdadero, debe ejecutar el circuito en hardware cuántico.

Estimación del costo del trabajo

Antes de ejecutar un trabajo en la QPU, debería calcular cuánto costará ejecutarlo.

Para obtener los detalles de precios más actuales, consulte Precios de Azure Quantum o busque el área de trabajo y vea las opciones de precios en la pestaña "Proveedor" del área de trabajo a través de: aka.ms/aq/myworkspaces.

Flujo de trabajo asincrónico mediante trabajos

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h2-1sc"
)

Para comprobar el estado del trabajo, use job.status():

print(job.status())

'Waiting'

Para esperar a que se complete el trabajo y, a continuación, obtener los resultados, use la llamada de bloqueo job.results():

result = job.results()
print(result)

    {'m_b': ['00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00']}

Tenga en cuenta que no devuelve un objeto cirq.Result. En su lugar, devuelve un diccionario de resultados de medida de cadena de bits indexados por clave de medida.

Importante

Actualmente, no se admite el envío de varios circuitos en un solo trabajo. Como solución alternativa, puede llamar al método backend.run para enviar cada circuito de forma asincrónica y, a continuación, capturar los resultados de cada trabajo. Por ejemplo:

jobs = []
for circuit in circuits:
    jobs.append(backend.run(circuit, shots=N))

results = []
for job in jobs:
    results.append(job.result())

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-10-17

Compartir a través de

Cómo enviar un circuito con Cirq a Azure Quantum

Requisitos previos

Crear un nuevo cuaderno de Jupyter Notebook

Carga de las importaciones necesarias

Conexión al servicio Azure Quantum

Enumerar todos los elementos targets

Creación de un circuito simple

Selecciona un target para ejecutar tu programa

Ejecución en el simulador de IonQ

Estimación del costo del trabajo

Ejecución en la QPU de IonQ

Modelo asincrónico con trabajos

Comentarios

Recursos adicionales