Rigetti-Anbieter

Tipp

Erstbenutzer erhalten automatisch kostenlose Azure Quantum-Guthabenin Höhe von 500 USD für die Verwendung mit jedem teilnehmenden Quantenhardwareanbieter. Wenn Sie das gesamte Guthaben verbraucht haben und mehr benötigen, können Sie sich für das Azure Quantum Credits-Programm bewerben.

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:

Zielname	Ziel-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.
Ankaa-2	rigetti.qpu.ankaa-2	84 Qubits	Rigettis leistungsstärkster verfügbarer Quantenprozessor.

Hinweis

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

Rigettis targets entsprechen einem No Control Flow Profil. Weitere Informationen zu diesem target Profil und seinen Einschränkungen finden Sie unter Grundlegendes zu target 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 gibt simulierte Ergebnisse zurück.

• Auftragstyp: Simulation
• Datenformate: rigetti.quil.v1, rigetti.qir.v1
• Ziel-ID: rigetti.sim.qvm
• Zielausführungsprofil: No Control Flow
• Preise (kostenlos)

Quantencomputing

Alle öffentlich verfügbaren QPUs von Rigetti sind über Azure Quantum verfügbar. Diese Liste kann ohne vorherige Ankündigung geändert werden.

Ankaa-2

Ein Multi-Chip-84-Qubit-Prozessor, der eine 2,5-fache Leistungsverbesserung gegenüber anderen Rigetti-QPUs bietet.

• Auftragstyp: Quantum Program
• Datenformat: rigetti.quil.v1, rigetti.qir.v1
• Ziel-ID: rigetti.qpu.ankaa-2
• Zielausführungsprofil: No Control Flow

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 count ganzzahligen Parameter, um die Anzahl der auszuführenden Aufnahmen zu definieren. Wenn es nicht angegeben wird, wird das Programm nur einmal ausgeführt.

Quil

Alle Rigetti targets akzeptieren das rigetti.quil.v1 Eingabeformat, das den Text eines Quil-Programms ist, was für Quantum Instruction Language steht. Programme werden standardmäßig mit 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-Basisprofil v1 als rigetti.qir.v1. QIR bietet eine gemeinsame Schnittstelle, die viele Quantensprachen und target -plattformen für die Quantenberechnung unterstützt und die Kommunikation zwischen Übergeordneten Sprachen und Computern ermöglicht. Beispielsweise können Sie 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 über Azure Quantum auf Rigetti targets funktioniert, ist QIR genau das Richtige für Sie! QIR hat eine sich schnell weiterentwickelnde Spezifikation, und Rigetti erhöht die Unterstützung für fortschrittlichere QIR-Programme im Laufe der Zeit - was heute nicht kompiliert werden kann, kann morgen wohl 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
# 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}")

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