Cómo enviar un circuito con Cirq a Azure Quantum

2025-04-21

Aprenda a enviar un circuito cuántico cirq mediante el azure-quantumPython paquete. Puede enviar circuitos Cirq a Azure Quantum mediante el cuaderno de Azure Quantum, que tiene un paquete integrado azure-quantumPython o 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 la etiqueta [cirq] y los paquetes qsharp y ipykernel.
```
python -m pip install --upgrade azure-quantum[cirq] qsharp 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, seleccione Ver > Paleta de comandos y seleccione Crear: Nuevo Jupyter Notebook.
En la parte superior derecha, VS Code detectará y mostrará 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 núcleo mediante el selector de núcleo ubicado en la parte 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.h1-1", avg. queue time=0 s, Degraded>,
<Target name="quantinuum.sim.h1-1sc", avg. queue time=1 s, Available>,
<Target name="quantinuum.sim.h1-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.h1-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.h1-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.

Requisitos previos

Una cuenta de Azure con una suscripción activa. Si no tiene una cuenta de Azure, regístrese gratuitamente y regístrese para obtener una suscripción de pago por uso.
Un área de trabajo de Azure Quantum. Para más información, consulte Creación de un área de trabajo de Azure Quantum.

Creación de un cuaderno en el área de trabajo

Inicie sesión en Azure Portal y seleccione el área de trabajo del paso anterior.
En la hoja de la izquierda, seleccione Cuadernos.
Haga clic en Mis cuadernos y, luego, en Agregar nuevo.
Escriba un nombre para el archivo, por ejemplo Cirq.ipynb, y haga clic en Crear archivo.

Cuando se abre el cuaderno nuevo, este crea automáticamente el código de la primera celda, en función de la información de la suscripción y del área de trabajo.

from azure.quantum import Workspace
workspace = Workspace ( 
  resource_id = "", # Add your resource_id 
  location = ""  # Add your workspace location (for example, "westus") 
)

Nota:

A menos que se indique lo contrario, debe ejecutar cada celda en orden a medida que se cree para evitar problemas de compilación.

Haga clic en el icono triangular "reproducir" situado a la izquierda de la celda para ejecutar el código.

Carga de las importaciones necesarias

En primer lugar, tendrá que importar un módulo adicional.

Haga clic en + Código para agregar una nueva celda y, a continuación, agregue y ejecute el código siguiente:

from azure.quantum.cirq import AzureQuantumService

Conexión al servicio Azure Quantum

A continuación, utilice el objeto AzureQuantumService de la celda anterior para crear un objeto workspace y conectarse a su espacio de trabajo de Azure Quantum. Agregue una nueva celda con el código siguiente:

provider = AzureQuantumService(workspace)

Definició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────────

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("This workspace's targets:")
for target in service.targets():
     print(target)

This workspace's targets:
<Target name="quantinuum.qpu.h1-1", avg. queue time=0 s, Degraded>
<Target name="quantinuum.sim.h1-1sc", avg. queue time=1 s, Available>
<Target name="quantinuum.sim.h1-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>

Nota:

La lista completa de target puede ser diferente para el área de trabajo.

Selecciona un target para ejecutar tu programa

IonQ
Quantinuum

Ejecución en el simulador de IonQ

Para comprobar el circuito antes de ejecutarlo en hardware cuántico real, puede usar el simulador de IonQ, ionq.simulator.

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="ionq.simulator"
)

Esto devuelve un objeto cirq.Result.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Puede trazar los resultados en un histograma:

import pylab as pl

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

Estimación del costo del trabajo

Antes de ejecutar un trabajo en hardware cuántico real o en una unidad de procesamiento cuántico (QPU), debe calcular cuánto costará ejecutar.

Para ver la información sobre precios más actual, consulte Precios de IonQ o consulte las opciones de precios en la hoja Proveedores de su área de trabajo.

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

Nota:

El tiempo necesario para ejecutar un circuito en la QPU puede variar en función de los tiempos de cola actuales. Para ver el tiempo medio de cola de un elemento target, seleccione la hoja Proveedores del área de trabajo.

De nuevo, esto devuelve un objeto cirq.Result.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Modelo asincrónico con trabajos

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

Nota:

La función job.results() no devuelve ningún 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 validador de API

Para comprobar el circuito antes de ejecutarlo en hardware cuántico real, puede usar el validador de API de Quantinuum, quantinuum.sim.h1-1sc.

Agregue la celda siguiente que envía un trabajo para ejecutar el circuito con 100 tomas, o repeticiones, espera hasta que se complete el trabajo y devuelve los resultados:

result = service.run(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h1-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")

Estimación del costo del trabajo

Antes de ejecutar un trabajo en hardware cuántico real o en una unidad de procesamiento cuántico (QPU), debe calcular cuánto costará ejecutar.

Para obtener los detalles de precios más actuales, consulte Precios de Azure Quantum o vea las opciones de precios en la hoja Proveedores del área de trabajo.

Ejecución en una QPU de Quantinuum

Después de que la ejecución se realice correctamente en el validador de API y de calcular el costo de la QPU, es el momento de ejecutar el circuito en el hardware.

Nota:

Use el mismo método run y las mismas operaciones que usó anteriormente con el validador de API para enviar el trabajo y mostrar los resultados:

result = service.run(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

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

Puede ver que los resultados ahora se dividen aproximadamente entre 0 y 1.

Resultado del circuito Cirq en Quantinuum QPU

Flujo de trabajo asincrónico mediante trabajos

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

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': ['11', '11', '00', '11', '00', '00', '00', '00', '11', '00', '00', '11', '00', '00', '00', '00', '11', '11', '11', '00', '11', '00', '00', '11', '11', '11', '11', '00', '00', '00', '00', '00', '00', '11', '11', '00', '11', '00', '11', '11', '00', '00', '00', '11', '11', '00', '00', '11', '11', '11', '00', '00', '11', '11', '11', '11', '00', '00', '11', '11', '00', '11', '11', '00', '00', '00', '11', '11', '11', '11', '11', '00', '00', '11', '00', '11', '11', '11', '11', '00', '11', '00', '00', '00', '01', '11', '11', '00', '00', '11', '11', '11', '11', '00', '00', '00', '11', '00', '11', '00']}

Nota:

La función job.results() no devuelve ningún objeto cirq.Result. En su lugar, devuelve un diccionario de resultados de medición en formato de cadena de bits, indexados por clave de medición.

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

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

Requisitos previos

Creación de un cuaderno en el área de trabajo

Carga de las importaciones necesarias

Conexión al servicio Azure Quantum

Definición de un circuito simple

Enumerar todos los elementos targets

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

Contenido relacionado

Comentarios

Recursos adicionales