Envío de un circuito con Cirq to Azure Quantum

  • Artículo

Obtenga información sobre cómo 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.

Nota

El Kit de desarrollo de Microsoft Quantum (QDK clásico) ya no se admitirá después del 30 de junio de 2024. Si es un desarrollador de QDK existente, se recomienda realizar la transición al nuevo kit de desarrollo de Azure Quantum (QDK moderno) para seguir desarrollando soluciones cuánticas. Para obtener más información, consulte Migración del código de Q# al QDK moderno.

Requisitos previos

Para obtener más información sobre la instalación, consulte Instalación del QDK moderno en VS Code.

  • 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 Python entorno con Python y Pip instalado.

  • VS Code con el Kit de desarrollo de Azure Quantum, Pythony las extensiones de Jupyter instaladas.

  • Paquete de Azure Quantum azure-quantum con la etiqueta [cirq] y los qsharp paquetes y ipykernel .

    python -m pip install --upgrade azure-quantum[cirq] qsharp ipykernel

    Nota

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

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. Inicie sesión en su cuenta de Azure, https://portal.azure.com, vaya al área de trabajo de Azure Quantum y copie los valores del encabezado.

Cómo recuperar el identificador de recurso y la ubicación de un área de trabajo de Azure 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 todo el targets área de trabajo no aparezca, solo el targets que puede aceptar un circuito Cirq o OpenQASM se mostrará aquí.

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.qpu", avg. queue time=229 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────────

Seleccione un target para ejecutar el programa.

Ejecutar 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, puede calcular cuánto cuesta ejecutarse. Para calcular el costo de ejecutar un trabajo en la QPU, puede usar el método estimate_cost.

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="ionq.qpu"
)

print(f"Estimated cost: {cost.estimated_total}")

El costo estimado se muestra en USD.

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" como argumento target:

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu",
    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 de la 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 todo el targets área de trabajo no aparezca, solo se mostrará aquí el targets que puede aceptar un circuito 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.qpu", avg. queue time=229 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.

Seleccione un target para 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), puede calcular cuánto cuesta la ejecución. Para calcular el costo de ejecutar un trabajo en la QPU, puede usar el método estimate_cost.

cost = service.estimate_cost(
    program=circuit,
    repetitions=100,
    target="ionq.qpu"
)

print(f"Estimated cost: {cost.estimated_total}")

Estimated cost: 1

El costo estimado se muestra en USD.

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 como argumento target:

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

Pasos siguientes