Rigetti-Anbieter

Tipp

Wenn Sie einen Azure Quantum-Arbeitsbereich erstellen, erhalten Sie automatisch USD500 kostenlose Azure Quantum Credits für jeden Quantenhardwareanbieter. Sie können azure Quantum Credits verwenden, um Ihre ersten Quantenprogramme an echte Quantenhardware zu übermitteln.

Hinweis

Die Ankaa-2 QPU ist ab dem 4. Oktober 2024 vom Azure Quantum-Dienst veraltet.

Rigetti-Quantenprozessoren sind universelle Maschinen nach dem Gate-Modell, die auf abstimmbaren supraleitenden Qubits basieren. Zu den Systemmerkmalen und Geräteeigenschaften gehören verbesserte Auslesefähigkeiten, eine Beschleunigung der Quantenverarbeitungszeiten, schnelle Gate-Zeiten für mehrere verschränkte Gate-Familien, schnelles Abtasten über aktives Register-Reset und parametrische Steuerung.

• Herausgeber: Rigetti
• Anbieter-ID: rigetti

Der Rigetti-Anbieter stellt Folgendes targets zur Verfügung:

Target-Name	Target ID	Anzahl von Qubits	Beschreibung
Quantum Virtual Machine (QVM)	rigetti.sim.qvm	-	Open-Source-Simulator für Quil-, Q#- und Qiskit-Programme. Dafür fallen keine Kosten an.

Hinweis

Rigetti Simulatoren und Hardware targets unterstützen Cirq-Programme nicht.

Rigettis targets entspricht einem QIR Base Profil. Weitere Informationen zu diesem target Profil und seinen Einschränkungen finden Sie unter Grundlegendes target zu Profiltypen in Azure Quantum.

Simulatoren

Die Quantum Virtual Machine (QVM) ist ein Open-Source-Simulator für Quil. Das rigetti.sim.qvmtarget Akzeptiert ein Quil-Programm als Text und führt dieses Programm auf QVM aus, das in der Cloud gehostet wird und simulierte Ergebnisse zurückgibt.

• Auftragstyp: Simulation
• Datenformate: rigetti.quil.v1, rigetti.qir.v1
• Target ID: rigetti.sim.qvm
• Target Ausführungsprofil: QIR Base
• Preise (kostenlos)

Preise

Um den Abrechnungsplan von Rigetti anzuzeigen, besuchen Sie Azure Quantum-Preise.

Eingabeformat

Alle Rigetti targets akzeptieren derzeit zwei Formate:

• rigetti.quil.v1, der Text eines Quil-Programms.
• rigetti.qir.v1, was QIR-Bitcode ist.

Alle targets verwenden auch den optionalen ganzzahligen count Parameter zum Definieren der Anzahl der auszuführenden Aufnahmen. Wenn nicht angegeben, wird das Programm nur einmal ausgeführt.

Quil

Alle Rigetti targets akzeptieren das rigetti.quil.v1 Eingabeformat, das der Text eines Quil-Programms ist, das für Quantum Instruction Language steht. Standardmäßig werden Programme mithilfe von Quilc kompiliert, bevor sie ausgeführt werden. quilc unterstützt jedoch nicht die Funktionen der Pulsebenensteuerung (Quil-T), sodass Sie diese Features verwenden möchten, müssen Sie ein natives Quil-Programm (auch mit Quil-T) als Eingabe bereitstellen und den Eingabeparameter skipQuilc: trueangeben.

Um das Erstellen eines Quil-Programms zu vereinfachen, können Sie es zusammen mit dem pyQuil Paket verwendenpyquil-for-azure-quantum. Ohne dieses Paket können Sie Quil-Programme pyQuilerstellen, aber nicht an Azure Quantum übermitteln.

QIR

Alle Rigetti-Hardware unterstützt die Ausführung von Quantum Intermediate Representation (QIR)-konformen Aufträgen mit dem QIR Base Profile, v1 as rigetti.qir.v1. QIR bietet eine gemeinsame Schnittstelle, die viele Quantensprachen und target Plattformen für die Quantenberechnung unterstützt und die Kommunikation zwischen allgemeinen Sprachen und Maschinen ermöglicht. Sie können z. B. Q#-, Quil- oder Qiskit-Aufträge an Rigetti-Hardware übermitteln, und Azure Quantum verarbeitet die Eingabe automatisch für Sie. Weitere Informationen finden Sie unter Quantum Intermediate Representation.

Auswählen des richtigen Eingabeformats

Sollten Sie Quil oder eine andere QIR-kompatible Sprache verwenden? Es kommt auf Ihren Endanwendungsfall zurück. QIR ist für viele Benutzer zugänglicher, während Quil heute leistungsstärker ist.

Wenn Sie Qiskit, Q# oder ein anderes Toolkit verwenden, das die QIR-Generierung unterstützt, und Ihre Anwendung arbeitet über Azure Quantum auf Rigetti targets , dann ist QIR richtig für Sie! QIR hat eine sich schnell entwickelnde Spezifikation, und Rigetti erhöht weiterhin die Unterstützung für komplexere QIR-Programme als Zeitdurchgänge - was heute noch nicht kompiliert werden kann, kann morgen gut kompiliert werden.

Auf der anderen Seite ausdrücken Quil-Programme die vollständige Funktionalität, die Benutzern von Rigetti-Systemen von jeder Plattform wie Azure Quantum zur Verfügung steht. Wenn Sie die Zerlegung Ihrer Quantengater anpassen oder Programme auf Pulsebene schreiben möchten, sollten Sie in Quil arbeiten, da diese Funktionen noch nicht über QIR verfügbar sind.

Beispiele

Die einfachste Möglichkeit zum Übermitteln von Quil-Aufträgen ist die Verwendung des pyquil-for-azure-quantum Pakets, da es Ihnen ermöglicht, die Tools und Dokumentationen der pyQuil Bibliothek zu verwenden.

Sie können quil-Programme auch manuell erstellen und mithilfe des azure-quantum Pakets direkt übermitteln.

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

Verwenden des Azure-quantum Python SDK

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