Dostawca Rigetti

Napiwek

Podczas tworzenia obszaru roboczego usługi Azure Quantum automatycznie otrzymujesz bezpłatną kwotę 500 USD środków na korzystanie z usługi Azure Quantum dla każdego dostawcy sprzętu kwantowego. Możesz użyć środków na korzystanie z usługi Azure Quantum, aby przesłać swoje pierwsze programy kwantowe do rzeczywistego sprzętu kwantowego.

Uwaga

Moduł QPU Ankaa-2 jest przestarzały z usługi Azure Quantum od 4 października 2024 r.

Procesory kwantowe Rigetti to uniwersalne maszyny modelu bramy oparte na dostrojeniach kubitów. Funkcje systemu i cechy urządzeń obejmują ulepszone możliwości odczytu, przyspieszenie w czasie przetwarzania kwantowego, szybkie bramy dla wielu rodzin bram splątania, szybkie próbkowanie za pośrednictwem aktywnego resetowania rejestru i sterowanie parametrowe.

• Wydawca: Rigetti
• Identyfikator dostawcy: rigetti

Dostawca Rigetti udostępnia następujące targets informacje:

Target nazwa	Target ID	Liczba kubitów	opis
Maszyna wirtualna kwantowa (QVM)	rigetti.sim.qvm	-	Symulator open source dla programów Quil, Q# i Qiskit. Wolne od kosztów.

Uwaga

Symulatory i sprzęt targets Rigetti nie obsługują programów Cirq.

Rigetti odpowiada targets profilowi QIR Base . Aby uzyskać więcej informacji na temat tego target profilu i jego ograniczeń, zobacz Opis target typów profilów w usłudze Azure Quantum.

Symulatory

Maszyna wirtualna Quantum (QVM) to symulator typu open source dla Quil. Element rigetti.sim.qvmtarget akceptuje program Quil jako tekst i uruchamia ten program na maszynie QVM hostowanej w chmurze, zwracając symulowane wyniki.

• Typ zadania: Simulation
• Formaty danych: rigetti.quil.v1, rigetti.qir.v1
• Target ID: rigetti.sim.qvm
• Target Profil wykonywania: QIR Base
• Cennik: Bezpłatna ($0)

Cennik

Aby wyświetlić plan rozliczeniowy usługi Rigetti, odwiedź stronę Cennik usługi Azure Quantum.

Format danych wejściowych

Wszystkie Rigetti targets obecnie akceptują dwa formaty:

• rigetti.quil.v1, czyli tekst programu Quil .
• rigetti.qir.v1, czyli kod bitowy QIR.

Wszystkie targets przyjmują również opcjonalny count parametr liczb całkowitych służący do definiowania liczby zdjęć do uruchomienia. W przypadku pominięcia program jest uruchamiany tylko raz.

Quil

Wszystkie Rigetti targets akceptują rigetti.quil.v1 format wejściowy, który jest tekstem programu Quil , który oznacza język instrukcji kwantowych. Domyślnie programy są kompilowane przy użyciu kołdry przed uruchomieniem. Jednak quilc nie obsługuje funkcji sterowania poziomem pulsu (Quil-T), więc jeśli chcesz użyć tych funkcji, musisz podać natywny program Quil (zawierający również Quil-T) jako dane wejściowe i określić parametr skipQuilc: truewejściowy .

Aby ułatwić konstruowanie programu Quil, możesz użyć pyQuil go wraz z pakietem pyquil-for-azure-quantum . Bez tego pakietu można użyć do konstruowania programów Quil, pyQuil ale nie do przesyłania ich do usługi Azure Quantum.

QIR

Cały sprzęt Rigetti obsługuje wykonywanie Quantum Intermediate Representation zgodnych zadań (QIR) z profilem QIR Base w wersji 1 jako rigetti.qir.v1. QIR udostępnia wspólny interfejs, który obsługuje wiele języków kwantowych i target platform na potrzeby obliczeń kwantowych i umożliwia komunikację między językami wysokiego poziomu i maszynami. Możesz na przykład przesłać zadania języka Q#, Quil lub Qiskit do sprzętu Rigetti, a usługa Azure Quantum automatycznie obsługuje dane wejściowe. Aby uzyskać więcej informacji, zobacz Quantum Intermediate Representation.

Wybieranie odpowiedniego formatu wejściowego

Czy należy używać Quil lub innego języka zgodnego z językiem QIR? Sprowadza się to do końcowego przypadku użycia. QIR jest bardziej dostępny dla wielu użytkowników, podczas gdy Quil jest obecnie bardziej zaawansowany.

Jeśli używasz zestawu Qiskit, Q# lub innego zestawu narzędzi obsługującego generowanie QIR, a aplikacja działa na platformie Rigetti targets za pośrednictwem usługi Azure Quantum, technologia QIR jest odpowiednia dla Ciebie! QIR ma szybko rozwijającą się specyfikację, a Rigetti nadal zwiększa obsługę bardziej zaawansowanych programów QIR w miarę upływu czasu - czego nie można skompilować dzisiaj może być dobrze skompilowany jutro.

Z drugiej strony programy Quil wyrażają pełny zestaw funkcji dostępnych dla użytkowników systemów Rigetti z dowolnej platformy, w tym Azure Quantum. Jeśli chcesz dostosować dekompozycję bram kwantowych lub pisać programy na poziomie impulsu, warto pracować w Quil, ponieważ te możliwości nie są jeszcze dostępne za pośrednictwem QIR.

Przykłady

Najprostszym sposobem przesyłania zadań Quil jest użycie pyquil-for-azure-quantum pakietu, ponieważ umożliwia korzystanie z narzędzi i dokumentacji pyQuil biblioteki.

Można również tworzyć programy Quil ręcznie i przesyłać je bezpośrednio przy użyciu azure-quantum pakietu.

Korzystanie z biblioteki 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}")

Korzystanie z zestawu 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}")