Compartir a través de

Envío de un circuito con Cirq to Azure Quantum

  • Artículo

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 Instalación del QDK en VS Code.

Crear un nuevo cuaderno de Jupyter Notebook

  1. En VS Code, seleccione Ver > Paleta de comandos y seleccione Crear: Nuevo Jupyter Notebook.
  2. 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 kernel mediante el selector de kernel en la parte superior derecha. Si no se detectó ningún entorno, consulte Jupyter Notebooks in VS Code (Cuadernos de Jupyter Notebook en VS Code ) para obtener información de 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.

  1. Inicie sesión en su cuenta de Azure, https://portal.azure.com,

  2. Seleccione el área de trabajo de Azure Quantum y vaya a Información general.

  3. Copie los parámetros en los campos.

    Captura de pantalla de Visual Studio Code en la que se muestra cómo expandir el panel de información general del área de trabajo de Quantum.

Agregue una nueva celda y use la información de la cuenta para crear Workspace objetos y AzureQuantumService conectarse al á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 targets

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

Nota:

Es posible que no aparezca todo en el targets área de trabajo; solo se mostrará aquí el targets circuito Cirq o OpenQASM que pueda aceptar.

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

Selección de para target ejecutar el programa

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, debe calcular cuánto costará ejecutarse.

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

Requisitos previos

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

  1. Inicie sesión en Azure Portal y seleccione el área de trabajo del paso anterior.
  2. En la hoja izquierda, seleccione Cuadernos.
  3. Haga clic en Mis cuadernos y, luego, en Agregar nuevo.
  4. 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, cree un AzureQuantumService objeto mediante el workspace objeto de la celda anterior para conectarse al área 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 targets

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

Nota:

Es posible que no aparezca todo en el targets área de trabajo; solo se mostrará aquí el targets circuito Cirq o OpenQASM que pueda aceptar.

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 puede ser diferente para el área de target trabajo.

Selección de para target ejecutar el programa

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. Para ver el estado actual de los créditos y su uso, seleccione Créditos y cuotas.

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

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

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

Contenido relacionado