Poskytovatel Rigetti

Tip

První uživatelé automaticky získají bezplatné kredity Azure Quantumve výši 500 USD pro použití u každého zúčastněného poskytovatele kvantového hardwaru. Pokud jste spotřebovali všechny kredity a potřebujete víc, můžete se přihlásit k programu Azure Quantum Credits.

Kvantové procesory Rigetti jsou univerzální počítače s hradlovým modelem založené na přizpůsobitelných supervodicích qubitech. Mezi systémové funkce a charakteristiky zařízení patří vylepšené možnosti čtení, zrychlení doby kvantového zpracování, rychlé doby hradlů pro více rodin bran propletení, rychlé vzorkování prostřednictvím aktivního resetování registru a parametrické řízení.

• Vydavatel: Rigetti
• ID zprostředkovatele: rigetti

Poskytovatel Rigetti zpřístupňuje následující targets :

Název cíle	ID cíle	Počet qubitů	Description
Kvantový virtuální počítač (QVM)	rigetti.sim.qvm	-	Opensourcový simulátor pro programy Quil, Q# a Qiskit Zdarma.
Ankaa-2	rigetti.qpu.ankaa-2	84 qubitů	Nejvýkonnější dostupný kvantový procesor Rigetti.

Poznámka

Simulátory a hardware targets Rigetti nepodporují programy Cirq.

Rigetti odpovídá targetsNo Control Flow profilu. Další informace o tomto target profilu a jeho omezeních najdete v tématu Principy target typů profilů v Azure Quantum.

Simulátory

Kvantový virtuální počítač (QVM) je opensourcový simulátor pro Quil. Akceptuje rigetti.sim.qvmtargetprogram Quil jako text a spustí ho na QVM hostovaném v cloudu a vrátí simulované výsledky.

• Typ úlohy: Simulation
• Formáty dat: rigetti.quil.v1, rigetti.qir.v1
• ID cíle: rigetti.sim.qvm
• Cílový profil spuštění: No Control Flow
• Ceny: Zdarma (0 USD)

Kvantové počítače

Všechny veřejně dostupné QPU od společnosti Rigetti jsou k dispozici prostřednictvím služby Azure Quantum. Tento seznam se může změnit bez předchozího upozornění.

Ankaa-2

Vícečipový 84 qubitový procesor nabízející 2,5násobné zlepšení výkonu oproti ostatním QPU Rigetti.

• Typ úlohy: Quantum Program
• Formát dat: rigetti.quil.v1, rigetti.qir.v1
• ID cíle: rigetti.qpu.ankaa-2
• Cílový profil spuštění: No Control Flow

Ceny

Pokud chcete zobrazit fakturační plán společnosti Rigetti, přejděte na ceny Azure Quantum.

Formát vstupu

Všechny Rigetti targets aktuálně přijímají dva formáty:

• rigetti.quil.v1, což je text programu Quil .
• rigetti.qir.v1, což je QIR bitcode.

Všichni targets také používají volitelný count celočíselný parametr pro definování počtu spuštěných snímků. Pokud tento parametr vynecháte, spustí se program jenom jednou.

Quil

Všechny Rigetti targets přijímají rigetti.quil.v1 vstupní formát, což je text programu Quil , což je zkratka pro Quantum Instruction Language. Ve výchozím nastavení se programy před spuštěním kompilují pomocí nástroje quilc . quilc však nepodporuje funkce řízení úrovně impulsů (Quil-T), takže pokud chcete tyto funkce použít, musíte jako vstup zadat nativní program Quil (obsahující také Quil-T) a zadat vstupní parametr skipQuilc: true.

Pro usnadnění vytváření programu Quil můžete použít pyQuil společně s balíčkem pyquil-for-azure-quantum . Bez tohoto balíčku se dá použít k vytváření programů Quil, pyQuil ale ne k jejich odesílání do Azure Quantum.

QIR

Veškerý hardware Rigetti podporuje spouštění úloh kompatibilních s QIR pomocí základního Quantum Intermediate Representationprofilu QIR verze 1 jako rigetti.qir.v1. QIR poskytuje společné rozhraní, které podporuje mnoho kvantových jazyků a target platforem pro kvantové výpočty a umožňuje komunikaci mezi jazyky a počítači vysoké úrovně. Můžete například odesílat úlohy Q#, Quil nebo Qiskit do hardwaru Rigetti a Azure Quantum automaticky zpracuje vstup za vás. Další informace naleznete v tématu Quantum Intermediate Representation.

Výběr správného vstupního formátu

Měli byste použít jazyk Quil nebo jiný jazyk kompatibilní se standardem QIR? Jedná se o případ vašeho koncového použití. QIR je přístupnější pro mnoho uživatelů, zatímco Quil je dnes výkonnější.

Pokud používáte Qiskit, Q# nebo jinou sadu nástrojů, která podporuje generování QIR, a vaše aplikace funguje na Rigetti targets prostřednictvím Azure Quantum, pak je QIR pro vás to pravé! Specifikace QIR se rychle vyvíjí a Rigetti s běhu času neustále zvyšuje podporu pokročilejších programů QIR – to, co se dnes nedá zkompilovat, se může zkompilovat i zítra.

Na druhou stranu programy Quil vyjadřují úplnou sadu funkcí dostupných uživatelům systémů Rigetti z libovolné platformy, včetně Azure Quantum. Pokud chcete přizpůsobit rozklad kvantových bran nebo psát programy na úrovni pulzu, budete chtít pracovat v Quilu, protože tyto možnosti ještě nejsou dostupné prostřednictvím QIR.

Příklady

Nejjednodušším způsobem, jak odesílat úlohy Quil, je použít pyquil-for-azure-quantum balíček , který umožňuje používat nástroje a dokumentaci knihovny pyQuil .

Programy Quil můžete také vytvořit ručně a odeslat je přímo pomocí azure-quantum balíčku.

Použití příkazu 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}")

Použití sady 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}")