Fournisseur Rigetti

Conseil

Lorsque vous créez un espace de travail Azure Quantum, vous obtenez automatiquement des crédits Azure Quantum gratuits USD500 pour chaque fournisseur de matériel quantique. Vous pouvez utiliser les crédits Azure Quantum pour soumettre vos premiers programmes quantiques à du matériel quantique réel.

Remarque

Le QPU Ankaa-2 est déconseillé du service Azure Quantum à compter du 4 octobre 2024.

Les processeurs quantum Rigetti sont des machines universelles fondées sur un modèle de porte basées sur des qubits superconducteurs paramétrables. Les caractéristiques système et les caractéristiques des appareils incluent des fonctionnalités de lecture améliorées, une accélération dans les temps de traitement quantum, des temps de porte rapides pour plusieurs familles de portes d’intrication, l’échantillonnage rapide via la réinitialisation de registre active et le contrôle paramétrique.

• Éditeur : Rigetti
• ID du fournisseur : rigetti

Le fournisseur Rigetti met à disposition les éléments suivants targets :

Nom Target	Target ID	Nombre de qubits	Description
Machine virtuelle quantique (QVM)	rigetti.sim.qvm	-	Simulateur open source pour les programmes Quil, Q# et Qiskit. Gratuit.

Remarque

Les simulateurs rigetti et le matériel targets ne prennent pas en charge les programmes Cirq.

Rigetti targets correspond à un QIR Base profil. Pour plus d’informations sur ce target profil et ses limitations, consultez Présentation des target types de profils dans Azure Quantum.

Simulateurs

La machine virtuelle quantique (QVM) est un simulateur open source pour Quil. Il rigetti.sim.qvmtarget accepte un programme Quil en tant que texte et exécute ce programme sur QVM hébergé dans le cloud, en retournant des résultats simulés.

• Type de tâche : Simulation
• Formats de données : rigetti.quil.v1, rigetti.qir.v1
• Target ID: rigetti.sim.qvm
• Target Profil d’exécution : QIR Base
• Tarification : gratuit (0 $)

Tarification

Pour voir le plan de facturation de Rigetti, consultez la tarification d’Azure Quantum.

Format d’entrée

Tous les Rigetti targets acceptent actuellement deux formats :

• rigetti.quil.v1, qui est le texte d’un programme Quil.
• rigetti.qir.v1, qui est le bitcode QIR.

Tous targets prennent également le paramètre entier facultatif count pour définir le nombre de captures à exécuter. S’il est omis, le programme s’exécute une seule fois.

Quil

Tous les Rigetti targets acceptent le rigetti.quil.v1 format d’entrée, qui est le texte d’un programme Quil , qui représente le langage d’instruction quantique. Par défaut, les programmes sont compilés à l’aide de quilc avant l’exécution. Toutefois, quilc ne prend pas en charge les fonctionnalités de contrôle au niveau de l’impulsion (Quil-T), donc si vous souhaitez utiliser ces fonctionnalités, vous devez fournir un programme Quil natif (contenant également Quil-T) comme entrée et spécifier le paramètre d’entrée skipQuilc: true.

Pour faciliter la construction d’un programme Quil, vous pouvez utiliser pyQuil avec le package pyquil-for-azure-quantum. Sans ce package, pyQuil peut être utilisé pour construire des programmes Quil, mais pas pour les soumettre à Azure Quantum.

QIR

Tout le matériel Rigetti prend en charge l’exécution de Quantum Intermediate Representation travaux conformes (QIR) avec le QIR Base profil, v1 en tant que rigetti.qir.v1. QIR fournit une interface commune qui prend en charge de nombreux langages et target plateformes quantiques pour le calcul quantique et permet la communication entre les langages de haut niveau et les machines. Par exemple, vous pouvez envoyer des travaux Q#, Quil ou Qiskit au matériel Rigetti, et Azure Quantum gère automatiquement l’entrée pour vous. Pour plus d’informations, consultez Quantum Intermediate Representation.

Sélection du format d’entrée approprié

Devez-vous utiliser Quil ou un autre langage conforme QIR ? Il s’agit de votre cas d’usage final. QIR est plus accessible pour de nombreux utilisateurs, tandis que Quil est plus puissant aujourd’hui.

Si vous utilisez Qiskit, Q# ou un autre kit de ressources qui prend en charge la génération QIR, et que votre application fonctionne sur Rigetti targets via Azure Quantum, QIR est adapté à vous ! QIR a une spécification en évolution rapide, et Rigetti continue d’augmenter la prise en charge des programmes QIR plus avancés à mesure que le temps passe - ce qui ne peut pas être compilé aujourd’hui peut bien compiler demain.

En revanche, les programmes Quil expriment l’ensemble complet des fonctionnalités disponibles pour les utilisateurs de systèmes Rigetti à partir de n’importe quelle plateforme, y compris Azure Quantum. Si vous souhaitez adapter la décomposition de vos portes quantiques ou écrire des programmes au niveau de l’impulsion, vous voudrez travailler dans Quil, car ces fonctionnalités ne sont pas encore disponibles via QIR.

Exemples

Le moyen le plus simple d’envoyer des travaux Quil consiste à utiliser le package pyquil-for-azure-quantum, car il vous permet d’utiliser les outils et la documentation de la bibliothèque pyQuil.

Vous pouvez également construire manuellement des programmes Quil et les envoyer directement à l’aide du package azure-quantum.

Utiliser pyquil-for-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

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}")

Utiliser le Kit de développement logiciel (SDK) Python azure-quantum

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}")