Proveedor Rigetti

Artículo
04/10/2024

Sugerencia

La primera vez que los usuarios obtienen automáticamente 500 USD (USD)créditos de Azure Quantum para su uso con cada proveedor de hardware cuántico participante. Si ha consumido todos los créditos y necesita más, puede solicitar participar en el programa Créditos de Azure Quantum.

Los procesadores cuánticos Rigetti son máquinas universales de modelo de puerta basadas en cúbits superconductores ajustables. Las características del sistema y las características del dispositivo incluyen funcionalidades de lectura mejoradas, una aceleración en los tiempos de procesamiento cuánticos, tiempos de puerta rápidos para varias familias de puertas entrelazadas, muestreo rápido a través del restablecimiento de registro activo y control paramétrico.

Publicador: Rigetti
Identificador de proveedor: rigetti

El proveedor Rigetti pone a disposición lo siguiente targets :

Nombre de destino	Id. de destino	Número de cúbits	Descripción
Máquina virtual cuántica (QVM)	rigetti.sim.qvm	-	Simulador de código abierto para programas Quil, Q# y Qiskit. Sin costo.
Ankaa-2	rigetti.qpu.ankaa-2	84 cúbits	Procesador cuántico más eficaz disponible de Rigetti.

Nota

Los simuladores y hardware targets de Rigetti no admiten programas Cirq.

Los de targets Rigetti corresponden a un No Control Flow perfil. Para más información sobre este target perfil y sus limitaciones, consulte Descripción target de los tipos de perfil en Azure Quantum.

Simuladores

La máquina virtual cuántica (QVM) es un simulador de código abierto para Quil. rigetti.sim.qvmtarget acepta un programa Quil como texto y ejecuta ese programa en QVM hospedado en la nube y devuelve resultados simulados.

Tipo de trabajo: Simulation
Formatos de datos: rigetti.quil.v1, rigetti.qir.v1
Id. de destino: rigetti.sim.qvm
Perfil de ejecución de destino: No Control Flow
Precios: gratis (0 USD)

Equipos de Quantum

Todas las QPU disponibles públicamente de Rigetti están disponibles a través de Azure Quantum. Esta lista está sujeta a cambios sin previo aviso.

Ankaa-2

Un procesador de 84 cúbits de varios chip que ofrece una mejora del rendimiento de 2,5X con respecto a otras QPU de Rigetti.

Tipo de trabajo: Quantum Program
Formato de datos: rigetti.quil.v1, rigetti.qir.v1
Id. de destino: rigetti.qpu.ankaa-2
Perfil de ejecución de destino: No Control Flow

Precios

Para ver el plan de facturación de Rigetti, consulte Precios de Azure Quantum.

Formato de entrada

Todos Rigetti targets actualmente aceptan dos formatos:

rigetti.quil.v1, que es el texto de un programa de Quil.
rigetti.qir.v1, que es el bitcode de QIR.

También targets toman el parámetro entero opcional count para definir el número de tomas que se van a ejecutar. Si se omite, el programa solo se ejecuta una vez.

Quil

All Rigetti targets acepta el rigetti.quil.v1 formato de entrada, que es el texto de un programa Quil , que representa el lenguaje de instrucción cuántica. De forma predeterminada, los programas se compilan mediante quilc antes de ejecutarse. Sin embargo, quilc no admite las características de control de nivel de pulso (Quil-T), por lo que, si desea usar esas características, debe proporcionar un programa de native Quil (que también contiene Quil-T) como entrada y especificar el parámetro de entrada skipQuilc: true.

Para facilitar la construcción de un programa de Quil, puede usar pyQuil junto con el paquete pyquil-for-azure-quantum. Sin este paquete, pyQuil se puede usar para construir programas de Quil, pero no para enviarlos a Azure Quantum.

QIR

Todo el hardware rigetti admite la ejecución de Quantum Intermediate Representation trabajos compatibles (QIR) con el perfil base de QIR, v1 como rigetti.qir.v1. QIR proporciona una interfaz común que admite muchos lenguajes cuánticos y target plataformas para el cálculo cuántico y permite la comunicación entre equipos y lenguajes de alto nivel. Por ejemplo, puede enviar trabajos de Q#, Quil o Qiskit al hardware rigetti y Azure Quantum controla automáticamente la entrada automáticamente. Para obtener más información, vea Quantum Intermediate Representation.

Selección del formato de entrada correcto

¿Debe usar Quil u otro lenguaje compatible con QIR? Todo depende del caso de uso final. QIR es más accesible para muchos usuarios, mientras que Quil es más eficaz hoy en día.

Si usa Qiskit, Q# u otro kit de herramientas que admita la generación qiR, y la aplicación funciona en Rigetti targets a través de Azure Quantum, entonces QIR es adecuado para usted. QIR tiene una especificación en constante evolución, y Rigetti sigue aumentando el soporte para programas QIR más avanzados a medida que pasa el tiempo, lo que no se puede compilar hoy puede bien compilar mañana.

Por otro lado, los programas de Quil expresan el conjunto completo de funcionalidades disponibles para los usuarios de sistemas Rigetti desde cualquier plataforma, incluido Azure Quantum. Si desea adaptar la descomposición de las puertas cuánticas o escribir programas en el nivel de pulso, querrá trabajar en Quil, ya que esas funcionalidades aún no están disponibles a través de QIR.

Ejemplos

La manera más fácil de enviar trabajos de Quil es usar el paquete pyquil-for-azure-quantum, ya que permite usar las herramientas y la documentación de la biblioteca pyQuil.

También puede construir programas de Quil manualmente y enviarlos directamente mediante el paquete azure-quantum.

Uso de pyquil-for-azure-quantum
Uso del SDK de Python azure-quantum

from pyquil.gates import CNOT, MEASURE, H
from pyquil.quil import Program
from pyquil.quilbase import Declare
from pyquil_for_azure_quantum import get_qpu, get_qvm

# Note that some environment variables must be set to authenticate with Azure Quantum
qc = get_qvm()  # For simulation
# qc = get_qpu("Ankaa-2") for submitting to a QPU

program = Program(
    Declare("ro", "BIT", 2),
    H(0),
    CNOT(0, 1),
    MEASURE(0, ("ro", 0)),
    MEASURE(1, ("ro", 1)),
).wrap_in_numshots_loop(5)

# Optionally pass to_native_gates=False to .compile() to skip the compilation stage
result = qc.run(qc.compile(program))
data_per_shot = result.readout_data["ro"]
# Here, data_per_shot is a numpy array, so you can use numpy methods
assert data_per_shot.shape == (5, 2)
ro_data_first_shot = data_per_shot[0]
assert ro_data_first_shot[0] == 1 or ro_data_first_shot[0] == 0

# Let's print out all the data
print("Data from 'ro' register:")
for i, shot in enumerate(data_per_shot):
    print(f"Shot {i}: {shot}")

from azure.quantum import Workspace
from azure.quantum.target.rigetti import Result, Rigetti, RigettiTarget, InputParams

workspace = Workspace(
    # TODO: Fill in your details here
    resource_id="",
    location=""
)

target = Rigetti(
    workspace=workspace,
    name=RigettiTarget.ANKAA_2,  # Defaults to RigettiTarget.QVM for simulation
)

# Any valid Quil program is accepted, but the readout must be named `ro`
readout = "ro"
bell_state_quil = f"""
DECLARE {readout} BIT[2]

H 0
CNOT 0 1

MEASURE 0 {readout}[0]
MEASURE 1 {readout}[1]
"""

num_shots = 5
job = target.submit(
    input_data=bell_state_quil, 
    name="bell state", 
    shots=100, 
    input_params=InputParams(skip_quilc=False)
)

print(f"Queued job: {job.id}")
job.wait_until_completed()

print(f"Job completed with state: {job.details.status}")
result = Result(job)  # This throws an exception if the job failed
# You can index a Result with the name of the readout. In this case, `ro`
data_per_shot = result[readout]
# Here, data_per_shot is a list of length num_shots, each entry is a list containing the data for the register for that shot
ro_data_first_shot = data_per_shot[0]
# In this case, because the type of the register is BIT, the type will be integer and the value either 0 or 1
assert isinstance(ro_data_first_shot[0], int)
assert ro_data_first_shot[0] == 1 or ro_data_first_shot[0] == 0

# Let's print out all the data
print(f"Data from '{readout}' register:")
for i, shot in enumerate(data_per_shot):
    print(f"Shot {i}: {shot}")