Provedor Rigetti

Artigo
04/10/2024

Dica

Os usuários iniciantes recebem automaticamente US$ 500 (USD)Créditos do Azure Quantum para uso com cada provedor de hardware quântico participante. Se você tiver consumido todos os créditos e precisar de mais, poderá se inscrever no programa de créditos do Azure Quantum.

Os processadores quânticos do Rigetti são computadores universais do modelo de portão com base em qubits de supercondutores ajustáveis. Os recursos do sistema e as características do dispositivo incluem recursos de leitura aprimorados, uma aceleração nos tempos de processamento quântico, tempos de porta rápidos para várias famílias de portas emaranhadas, amostragem rápida por meio de redefinição de registro ativo e controle paramétrico.

Publicador: Rigetti
ID do provedor: rigetti

O provedor Rigetti disponibiliza o seguinte targets :

Nome de destino	ID de destino	Número de qubits	Descrição
Máquina Virtual Quântica (QVM)	rigetti.sim.qvm	-	Simulador de software livre para programas Quil, Q#e Qiskit. Sem custo.
Ankaa-2	rigetti.qpu.ankaa-2	84 qubits	O processador quântico mais poderoso disponível de Rigetti.

Observação

Simuladores de rigetti e hardware targets não dão suporte a programas Cirq.

O de targets Rigetti corresponde a um No Control Flow perfil. Para obter mais informações sobre esse target perfil e suas limitações, consulte Noções básicas sobre target tipos de perfil no Azure Quantum.

Simuladores

A Máquina Virtual Quântica (QVM) é um simulador de software livre para Quil. O rigetti.sim.qvmtarget aceita um programa Quil como texto e executa esse programa na QVM hospedada na nuvem, retornando resultados simulados.

Tipo de trabalho: Simulation
Formatos de dados: rigetti.quil.v1, rigetti.qir.v1
ID de destino: rigetti.sim.qvm
Perfil de execução de destino: No Control Flow
Preço: gratuito (US$ 0,00)

Computadores quânticos

Todas as QPUs da Rigetti disponíveis publicamente estão disponíveis por meio do Azure Quantum. Essa lista está sujeita a alterações sem aviso prévio.

Ankaa-2

Um processador multi-chip de 84 qubits que oferece uma melhoria de desempenho de 2,5X em relação a outras QPUs rigetti.

Tipo de trabalho: Quantum Program
Formato de dados: rigetti.quil.v1, rigetti.qir.v1
ID de destino: rigetti.qpu.ankaa-2
Perfil de execução de destino: No Control Flow

Preços

Para ver o plano de cobrança da Rigetti, visite os preços do Azure Quantum.

Formato de entrada

Atualmente, todos os Rigetti targets aceitam dois formatos:

rigetti.quil.v1, que é o texto de um programa Quil.
rigetti.qir.v1, que é o bitcode QIR.

Todos targets também assumem o parâmetro inteiro opcional count para definir o número de capturas a serem executadas. Se omitido, o programa só será executado uma vez.

Quil

Todo Rigetti targets aceita o rigetti.quil.v1 formato de entrada, que é o texto de um programa Quil , que significa Linguagem de Instrução Quântica. Por padrão, os programas são compilados usando quilc antes de serem executados. No entanto, o quilc não dá suporte aos recursos de controle de nível de pulso (Quil-T), portanto, se você quiser usar esses recursos, deverá fornecer um programa Quil nativo (contendo também Quil-T) como entrada e especificar o parâmetro de entrada skipQuilc: true.

Para facilitar a construção de um programa Quil, você pode usar pyQuil junto com o pacote pyquil-for-azure-quantum. Sem esse pacote, pyQuil pode ser usado para construir programas Quil, mas não para enviá-los ao Azure Quantum.

QIR

Todo o hardware rigetti dá suporte à execução de Quantum Intermediate Representation trabalhos em conformidade com o QIR com o Perfil Base do QIR, v1 como rigetti.qir.v1. O QIR fornece uma interface comum que dá suporte a várias linguagens quânticas e target plataformas para computação quântica e permite a comunicação entre computadores e linguagens de alto nível. Por exemplo, você pode enviar trabalhos Q#, Quil ou Qiskit para hardware Rigetti e o Azure Quantum manipula automaticamente a entrada para você. Para obter mais informações, consulte Quantum Intermediate Representation.

Selecionando o formato de entrada correto

Você deve usar Quil ou outra linguagem compatível com QIR? Tudo se resume ao seu caso de uso final. O QIR é mais acessível para muitos usuários, enquanto o Quil é mais poderoso atualmente.

Se você estiver usando Qiskit, Q#ou outro kit de ferramentas que dê suporte à geração de QIR e seu aplicativo funcionar no Rigetti targets por meio do Azure Quantum, o QIR será ideal para você! O QIR tem uma especificação em rápida evolução, e Rigetti continua a aumentar o suporte para programas QIR mais avançados à medida que o tempo passa - o que não pode ser compilado hoje pode muito bem ser compilado amanhã.

Por outro lado, os programas Quil expressam todo o conjunto de funcionalidades disponíveis para usuários de sistemas Rigetti de qualquer plataforma, incluindo o Azure Quantum. Se você deseja adaptar a decomposição de seus portões quânticos ou escrever programas no nível de pulso, convém trabalhar no Quil, porque esses recursos ainda não estão disponíveis por meio do QIR.

Exemplos

A maneira mais fácil de enviar trabalhos Quil é usando o pacote pyquil-for-azure-quantum, pois ele permite que você use as ferramentas e a documentação da biblioteca pyQuil.

Você também pode construir programas Quil manualmente e enviá-los usando diretamente o pacote azure-quantum.

Usar pyquil-for-azure-quantum
Usar o SDK do Phyton 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}")

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