Fournisseur Rigetti

  • Article

Conseil

Les utilisateurs pour la première fois obtiennent automatiquement des crédits Azure Quantumgratuits de 500 $ (USD) à utiliser avec chaque fournisseur de matériel quantique participant. Si vous avez consommé tous les crédits et voulez en obtenir davantage, vous pouvez vous inscrire au programme de crédits Azure Quantum.

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 de la cible ID de la cible Nombre de qubits Description
Machine virtuelle quantique (QVM) rigetti.sim.qvm - Simulateur open source pour les programmes Quil, Q# et Qiskit. Gratuit.
Ankaa-2 rigetti.qpu.ankaa-2 84 qubits Processeur quantique le plus puissant disponible de Rigetti.

Notes

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

Rigetti correspond targets à un No Control Flow 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. accepte rigetti.sim.qvmtarget 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
  • ID cible : rigetti.sim.qvm
  • Profil d’exécution cible : No Control Flow
  • Tarification : gratuit (0 $)

Ordinateurs Quantum

Tous les QPU disponibles publiquement de Rigetti sont disponibles via Azure Quantum. Cette liste est susceptible de changer sans préavis.

Ankaa-2

Un processeur multi-puce de 84 qubits offrant une amélioration des performances de 2,5 fois par rapport aux autres QPU Rigetti.

  • Type de tâche : Quantum Program
  • Format de données : rigetti.quil.v1, rigetti.qir.v1
  • ID cible : rigetti.qpu.ankaa-2
  • Profil d’exécution cible : No Control Flow

Tarifs

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. En cas d’omission, le programme ne s’exécute qu’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 signifie Quantum Instruction Language. Par défaut, les programmes sont compilés à l’aide de quilc avant de s’exécuter. 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 profil de base QIR, 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 et les machines de haut niveau. 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 au 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 fait pour vous ! QIR a une spécification en évolution rapide, et Rigetti continue d’augmenter la prise en charge des programmes QIR plus avancés au fil du temps - ce qui ne peut pas être compilé aujourd’hui pourrait bien être compilé 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.

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