Rigetti-provider

Tip

Nieuwe gebruikers krijgen automatisch gratis $ 500 (USD)Azure Quantum-tegoed voor gebruik met elke deelnemende kwantumhardwareprovider. Als u alle tegoeden hebt verbruikt en u meer nodig hebt, kunt u zich aanmelden voor het Azure Quantum-tegoedprogramma.

Rigetti-kwantumprocessors zijn universele, poortmodelmachines op basis van afstelbare supergeleidende qubits. Systeemfuncties en apparaatkenmerken omvatten verbeterde leesmogelijkheden, een versnelling in kwantumverwerkingstijden, snelle poorttijden voor meerdere verstrengelingspoortfamilies, snelle steekproeven via actief registerherstel en parametrische controle.

• Uitgever: Rigetti
• Provider-id: rigetti

De Rigetti-provider stelt het volgende targets beschikbaar:

Doelnaam	Doel-id	Aantal qubits	Description
Quantum Virtual Machine (QVM)	rigetti.sim.qvm	-	Opensource-simulator voor Quil-, Q#- en Qiskit-programma's. Gratis.
Ankaa-2	rigetti.qpu.ankaa-2	84 qubits	Rigetti's krachtigste beschikbare kwantumprocessor.

Notitie

Rigetti-simulators en hardware targets bieden geen ondersteuning voor Cirq-programma's.

Rigetti's targets komen overeen met een No Control Flow profiel. Zie Inzicht target in profieltypen in Azure Quantum voor meer informatie over dit target profiel en de bijbehorende beperkingen.

Simulatoren

De Quantum Virtual Machine (QVM) is een opensource-simulator voor Quil. De rigetti.sim.qvmtarget accepteert een Quil-programma als tekst en voert dat programma uit op QVM gehost in de cloud, waarbij gesimuleerde resultaten worden geretourneerd.

• Taaktype: Simulation
• Gegevensindelingen: rigetti.quil.v1, rigetti.qir.v1
• Doel-id: rigetti.sim.qvm
• Doeluitvoeringsprofiel: No Control Flow
• Prijzen: gratis ($ 0)

Kwantumcomputers

Alle openbaar beschikbare QPU's van Rigetti zijn beschikbaar via Azure Quantum. Deze lijst kan zonder voorafgaande kennisgeving worden gewijzigd.

Ankaa-2

Een multi-chip 84-qubit processor met een 2,5x prestatieverbetering ten opzichte van andere Rigetti QPU's.

• Taaktype: Quantum Program
• Gegevensindeling: rigetti.quil.v1, rigetti.qir.v1
• Doel-id: rigetti.qpu.ankaa-2
• Doeluitvoeringsprofiel: No Control Flow

Prijzen

Als u het factureringsplan van Rigetti wilt bekijken, gaat u naar Prijzen van Azure Quantum.

Invoerindeling

Alle Rigetti targets accepteren momenteel twee indelingen:

• rigetti.quil.v1, de tekst van een Quil-programma .
• rigetti.qir.v1, wat QIR-bitcode is.

Alle targets gebruiken ook de optionele count parameter geheel getal voor het definiëren van het aantal opnamen dat moet worden uitgevoerd. Als u dit weglaat, wordt het programma slechts eenmaal uitgevoerd.

Quil

Alle Rigetti targets accepteren de rigetti.quil.v1 invoerindeling, wat de tekst is van een Quil-programma , wat staat voor Quantum Instruction Language. Standaard worden programma's gecompileerd met quilc voordat ze worden uitgevoerd. Quilc biedt echter geen ondersteuning voor de pulsniveaubesturingsfuncties (Quil-T), dus als u deze functies wilt gebruiken, moet u een Systeemeigen Quil-programma (ook met Quil-T) opgeven als invoer en de invoerparameter skipQuilc: trueopgeven.

Om het bouwen van een Quil-programma gemakkelijker te maken, kunt u samen met het pyquil-for-azure-quantum pakket gebruikenpyQuil. Zonder dit pakket kan worden gebruikt om Quil-programma's te maken, pyQuil maar niet om ze naar Azure Quantum te verzenden.

QIR

Alle Rigetti-hardware ondersteunt de uitvoering van Quantum Intermediate Representation (QIR) compatibele taken met het QIR-basisprofiel, v1 als rigetti.qir.v1. QIR biedt een algemene interface die ondersteuning biedt voor veel kwantumtalen en target -platforms voor kwantumberekeningen en communicatie tussen talen en machines op hoog niveau mogelijk maakt. U kunt bijvoorbeeld Q#-, Quil- of Qiskit-taken verzenden naar Rigetti-hardware en Azure Quantum verwerkt de invoer automatisch voor u. Voor meer informatie raadpleegt u Quantum Intermediate Representation.

De juiste invoerindeling selecteren

Moet u Quil of een andere QIR-compatibele taal gebruiken? Het komt neer op uw eindgebruiksvoorbeeld. QIR is toegankelijker voor veel gebruikers, terwijl Quil tegenwoordig krachtiger is.

Als u Qiskit, Q# of een andere toolkit gebruikt die QIR-generatie ondersteunt en uw toepassing werkt op Rigetti targets via Azure Quantum, is QIR de juiste optie voor u. QIR heeft een snel veranderende specificatie en Rigetti blijft de ondersteuning voor meer geavanceerde QIR-programma's verhogen naarmate de tijd verstrijkt - wat vandaag niet kan worden gecompileerd, kan morgen goed worden gecompileerd.

Aan de andere kant geven Quil-programma's de volledige set functionaliteit weer die beschikbaar is voor gebruikers van Rigetti-systemen vanaf elk platform, waaronder Azure Quantum. Als u de ontleding van uw kwantumpoorten wilt aanpassen of programma's wilt schrijven op pulsniveau, kunt u beter in Quil werken, omdat deze mogelijkheden nog niet beschikbaar zijn via QIR.

Voorbeelden

De eenvoudigste manier om Quil-taken te verzenden, is met behulp van het pyquil-for-azure-quantum pakket, omdat u hiermee de hulpprogramma's en documentatie van de pyQuil bibliotheek kunt gebruiken.

U kunt Quil-programma's ook handmatig samenstellen en deze rechtstreeks verzenden met behulp van het azure-quantum pakket.

pyquil-for-azure-quantum gebruiken

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

Azure-quantum Python SDK gebruiken

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