Provider Di rigetti

Articolo
03/04/2023
6 minuti per la lettura

Suggerimento

Gli utenti per la prima volta ottengono automaticamente $ 500 (USD)Crediti Quantistici di Azure per l'uso con ogni provider hardware quantistico partecipante. Se sono stati utilizzati tutti i crediti e sono necessari crediti aggiuntivi, è possibile candidarsi al programma Azure Quantum Credits.

I processori quantistici di Rigetti sono macchine universali , gate-model basate su qubit superconduttori tonnibili. Il processore di famiglia Aspen-M più recente di Rigetti si basa sulla tecnologia multi-chip scalabile proprietaria. Le funzionalità di sistema e le caratteristiche del dispositivo includono funzionalità di lettura avanzate, una velocità in tempi di elaborazione quantistica, tempi di gate rapidi per più famiglie di gate intangling, campionamento rapido tramite la reimpostazione del registro attivo e il controllo parametrico.

La topologia del chip Aspen è ottagonale con connettività a 3 volte (2 volte per i bordi). È dotato sia di porte CPHASE che XY che consentono agli sviluppatori di ottimizzare i programmi per le prestazioni e ridurre al minimo la profondità del circuito. L'ottimizzazione del compilatore quilc trasforma gli algoritmi quantistici astratti in un set di cancelli nativi e produce implementazioni ottimali del circuito da eseguire in una QPU Rigetti. Questi cancelli offrono tempi di esecuzione rapidi (40 ns e 180 ns) 1Q e 2Q gate time e programmi entro tempi di coerenza qubit che misurano ~20 μs.

Editore: Rigetti
ID provider: rigetti

Il provider Di rigetti rende disponibili le destinazioni seguenti:

Nome di destinazione	ID di destinazione	Numero di qubit	Descrizione
Macchina virtuale quantistica (QVM)	rigetti.sim.qvm	-	Simulatore open source per i programmi Quil, Q#e Qiskit. Costo gratuito.
Aspen-M-2	rigetti.qpu.aspen-m-2	80 qubit	Processore quantistico multi chip di Rigetti.
Aspen-M-3	rigetti.qpu.aspen-m-3	80 qubit	Processore quantistico multi chip di Rigetti.

Nota

Il simulatore QVM non supporta i programmi Cirq.
La QPU Aspen-11 è stata deprecata.

Le destinazioni di Rigetti corrispondono a un profilo Nessun flusso di controllo . Per altre informazioni su questo profilo di destinazione e sulle relative limitazioni, vedere Informazioni sui tipi di profilo di destinazione in Azure Quantum.

Simulatori

La macchina virtuale quantistica (QVM) è un simulatore open source per Quil. La rigetti.sim.qvm destinazione accetta un programma Quil come testo ed esegue tale programma in QVM ospitato nel cloud, restituendo risultati simulati.

Tipo di processo: Simulation
Formati di dati: rigetti.quil.v1, rigetti.qir.v1
ID destinazione: rigetti.sim.qvm
Profilo di esecuzione di destinazione: nessun flusso di controllo
Prezzi: gratuito ($0)

Computer quantistici

Tutte le QPUS disponibili pubblicamente di Rigetti sono disponibili tramite Azure Quantum. Questo elenco è soggetto a modifiche senza preavviso.

Aspen-M-2

Processore multi-chip 80-qubit.

Tipo di processo: Quantum Program
Formati di dati: rigetti.quil.v1, rigetti.qir.v1
ID destinazione: rigetti.qpu.aspen-m-2
Profilo di esecuzione di destinazione: nessun flusso di controllo

Aspen-M-3

Un processore multi-chip 80-qubit che offre prestazioni migliorate per le porte CZ e XY.

Tipo di processo: Quantum Program
Formato dati: rigetti.quil.v1, rigetti.qir.v1
ID destinazione: rigetti.qpu.aspen-m-3
Profilo di esecuzione di destinazione: nessun flusso di controllo

Prezzi

Per visualizzare il piano di fatturazione di Rigetti, visitare i prezzi di Azure Quantum.

Formato di input

Tutte le destinazioni Di rigetto attualmente accettano due formati:

rigetti.quil.v1, che è il testo di un programma Quil .
rigetti.qir.v1, che è il codice di bit QIR.

Tutte le destinazioni accettano anche il parametro integer facoltativo count per definire il numero di colpi da eseguire. Se omesso, il programma viene eseguito una sola volta.

Quil

Tutte le destinazioni di Rigetti accettano il formato di input, ovvero il testo di un programma Quil, che rappresenta il rigetti.quil.v1 linguaggio di istruzione quantistico. Per impostazione predefinita, i programmi vengono compilati usando quilc prima di eseguire. Tuttavia, quilc non supporta le funzionalità di controllo a livello di impulso (Quil-T), quindi se si desidera usare queste funzionalità è necessario fornire un programma Native Quil (che contiene anche Quil-T) come input e specificare il parametro skipQuilc: truedi input .

Per semplificare la costruzione di un programma Quil, è possibile usare pyQuil insieme al pyquil-for-azure-quantum pacchetto. Senza questo pacchetto, pyQuil può essere usato per costruire programmi Quil ma non per inviarli ad Azure Quantum.

QIR

Tutti gli hardware Rigetti supportano l'esecuzione di processi conformi alla rappresentazione quantistica (QIR) con il profilo di base QIR, v1 come rigetti.qir.v1. QIR offre un'interfaccia comune che supporta molti linguaggi quantistici e piattaforme di destinazione per il calcolo quantistico e consente la comunicazione tra linguaggi e computer di alto livello. Ad esempio, è possibile inviare processi Q#, Quil o Qiskit all'hardware Rigetti e Azure Quantum gestisce automaticamente l'input. Per altre informazioni, vedere Rappresentazione intermedia quantistica.

Selezione del formato di input corretto

È consigliabile usare Quil o un altro linguaggio conforme a QIR? Si tratta del caso d'uso finale. QIR è più accessibile per molti utenti, mentre Quil è più potente oggi.

Se si usa Qiskit, Q#o un altro toolkit che supporta la generazione di QIR e l'applicazione funziona sulle destinazioni di Rigetti tramite Azure Quantum, QIR è ideale per l'utente. QIR ha una specifica in rapida evoluzione e Rigetti continua ad aumentare il supporto per i programmi QIR più avanzati man mano che passa il tempo. Ciò che non può essere compilato oggi può essere compilato correttamente domani.

D'altra parte, i programmi Quil esprimono il set completo di funzionalità disponibili per gli utenti di sistemi Rigetti da qualsiasi piattaforma, tra cui Azure Quantum. Se si vuole personalizzare la scomposizione dei cancelli quantistici o scrivere programmi a livello di impulso, si vuole lavorare in Quil, perché queste funzionalità non sono ancora disponibili tramite QIR.

Esempio

Il modo più semplice per inviare processi Quil usa il pyquil-for-azure-quantum pacchetto, perché consente di usare gli strumenti e la documentazione della pyQuil libreria.

È anche possibile costruire programmi Quil manualmente e inviarli usando direttamente il azure-quantum pacchetto.

Usare pyquil-for-azure-quantum
Usare azure-quantum Python SDK

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("Aspen-M-2")  or qc = get_qpu("Aspen-M-3") 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
    subscription_id="",
    resource_group="",
    name="",
    location=""
)

target = Rigetti(
    workspace=workspace,
    name=RigettiTarget.ASPEN_11,  # 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", 
    input_params=InputParams(count=num_shots, 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}")