Como enviar circuitos formatados específicos para o Azure Quantum

Artigo
10/18/2024

Saiba como usar o azure-quantumPython pacote para enviar circuitos em formatos específicos para o serviço Azure Quantum. Este artigo mostra como enviar circuitos nos seguintes formatos:

Enviar circuitos QIR
Enviar circuitos específicos do provedor

Para obter mais informações, consulte Circuitos quânticos.

Pré-requisitos

Para executar seus circuitos em um Bloco de Anotações no portal do Azure, você precisa:

Uma conta do Azure com uma subscrição ativa. Se não tiver uma conta do Azure, registe-se gratuitamente e inscreva-se numa subscrição pré-paga.
Um espaço de trabalho do Azure Quantum. Para obter mais informações, consulte Criar um espaço de trabalho do Azure Quantum.

Para desenvolver e executar seus circuitos no Visual Studio Code, você também precisa:

Um Python ambiente com Python e Pip instalado.
VS Code com o Azure Quantum Development Kit Python e as extensões Jupyter instaladas.

O Azure Quantum qsharp, azure-quantume ipykernel pacotes.

python -m pip install --upgrade qsharp azure-quantum ipykernel

Criar um novo Jupyter Notebook

Você pode criar um bloco de anotações no VS Code ou diretamente no portal do Azure Quantum.

Portal do Azure Quantum
Visual Studio Code

Faça logon no portal do Azure e selecione o espaço de trabalho na etapa anterior.
Na folha esquerda, selecione Blocos de Notas.
Clique em Meus Blocos de Anotações e clique em Adicionar Novo.
Em Tipo de kernel, selecione IPython.
Digite um nome para o arquivo e clique em Criar arquivo.

Quando o novo Bloco de Anotações é aberto, ele cria automaticamente o código para a primeira célula, com base nas informações da assinatura e do espaço de trabalho.

from azure.quantum import Workspace
workspace = Workspace ( 
    resource_id = "", # Your resource_id 
    location = ""  # Your workspace location (for example, "westus") 
)

No VS Code, selecione View > Command palette e selecione Create: New Jupyter Notebook.
Para se conectar ao serviço Azure Quantum, seu programa precisará da ID do recurso e do local do seu espaço de trabalho do Azure Quantum.
1. Inicie sessão na sua conta do Azure, https://portal.azure.com,
2. Selecione seu espaço de trabalho do Azure Quantum e navegue até Visão geral.
3. Copie os parâmetros nos campos.

Na primeira célula do seu bloco de anotações, cole os valores no construtor a seguir Workspace para criar um workspace objeto que se conecte ao seu espaço de trabalho do Azure Quantum.

from azure.quantum import Workspace
workspace = Workspace ( 
    resource_id = "", # Add your resource_id 
    location = ""  # Add your workspace location (for example, "westus") 
)

Enviar circuitos formatados em QIR

Quantum Intermediate Representation (QIR) é uma representação intermediária que serve como uma interface comum entre linguagens/frameworks de programação quântica e plataformas de computação quântica direcionadas. Para obter mais informações, consulte Representação intermediária quântica.

Crie o circuito QIR. Por exemplo, o código a seguir cria um circuito de emaranhamento simples.

QIR_routine = """%Result = type opaque
%Qubit = type opaque

define void @ENTRYPOINT__main() #0 {
  call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 0 to %Qubit*))
  call void @__quantum__qis__cx__body(%Qubit* inttoptr (i64 0 to %Qubit*), %Qubit* inttoptr (i64 1 to %Qubit*))
  call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 2 to %Qubit*))
  call void @__quantum__qis__cz__body(%Qubit* inttoptr (i64 2 to %Qubit*), %Qubit* inttoptr (i64 0 to %Qubit*))
  call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 2 to %Qubit*))
  call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 3 to %Qubit*))
  call void @__quantum__qis__cz__body(%Qubit* inttoptr (i64 3 to %Qubit*), %Qubit* inttoptr (i64 1 to %Qubit*))
  call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 3 to %Qubit*))
  call void @__quantum__qis__mz__body(%Qubit* inttoptr (i64 2 to %Qubit*), %Result* inttoptr (i64 0 to %Result*)) #1
  call void @__quantum__qis__mz__body(%Qubit* inttoptr (i64 3 to %Qubit*), %Result* inttoptr (i64 1 to %Result*)) #1
  call void @__quantum__rt__tuple_record_output(i64 2, i8* null)
  call void @__quantum__rt__result_record_output(%Result* inttoptr (i64 0 to %Result*), i8* null)
  call void @__quantum__rt__result_record_output(%Result* inttoptr (i64 1 to %Result*), i8* null)
  ret void
}

declare void @__quantum__qis__ccx__body(%Qubit*, %Qubit*, %Qubit*)
declare void @__quantum__qis__cx__body(%Qubit*, %Qubit*)
declare void @__quantum__qis__cy__body(%Qubit*, %Qubit*)
declare void @__quantum__qis__cz__body(%Qubit*, %Qubit*)
declare void @__quantum__qis__rx__body(double, %Qubit*)
declare void @__quantum__qis__rxx__body(double, %Qubit*, %Qubit*)
declare void @__quantum__qis__ry__body(double, %Qubit*)
declare void @__quantum__qis__ryy__body(double, %Qubit*, %Qubit*)
declare void @__quantum__qis__rz__body(double, %Qubit*)
declare void @__quantum__qis__rzz__body(double, %Qubit*, %Qubit*)
declare void @__quantum__qis__h__body(%Qubit*)
declare void @__quantum__qis__s__body(%Qubit*)
declare void @__quantum__qis__s__adj(%Qubit*)
declare void @__quantum__qis__t__body(%Qubit*)
declare void @__quantum__qis__t__adj(%Qubit*)
declare void @__quantum__qis__x__body(%Qubit*)
declare void @__quantum__qis__y__body(%Qubit*)
declare void @__quantum__qis__z__body(%Qubit*)
declare void @__quantum__qis__swap__body(%Qubit*, %Qubit*)
declare void @__quantum__qis__mz__body(%Qubit*, %Result* writeonly) #1
declare void @__quantum__rt__result_record_output(%Result*, i8*)
declare void @__quantum__rt__array_record_output(i64, i8*)
declare void @__quantum__rt__tuple_record_output(i64, i8*)

attributes #0 = { "entry_point" "output_labeling_schema" "qir_profiles"="base_profile" "required_num_qubits"="4" "required_num_results"="2" }
attributes #1 = { "irreversible" }

; module flags

!llvm.module.flags = !{!0, !1, !2, !3}

!0 = !{i32 1, !"qir_major_version", i32 1}
!1 = !{i32 7, !"qir_minor_version", i32 0}
!2 = !{i32 1, !"dynamic_qubit_management", i1 false}
!3 = !{i32 1, !"dynamic_result_management", i1 false}
"""

Crie uma submit_qir_job função auxiliar para submeter o circuito QIR a um target. Observe que os formatos de dados de entrada e saída são especificados como qir.v1 e microsoft.quantum-results.v1, respectivamente.

# Submit the job with proper input and output data formats
def submit_qir_job(target, input, name, count=100):
    job = target.submit(
        input_data=input, 
        input_data_format="qir.v1",
        output_data_format="microsoft.quantum-results.v1",
        name=name,
        input_params = {
            "entryPoint": "ENTRYPOINT__main",
            "arguments": [],
            "count": count
            }
    )

    print(f"Queued job: {job.id}")
    job.wait_until_completed()
    print(f"Job completed with state: {job.details.status}")
    #if job.details.status == "Succeeded":
    result = job.get_results()

    return result

Selecione um target e envie o circuito QIR para o Azure Quantum. Por exemplo, para submeter o circuito QIR ao simulador targetIonQ:

target = workspace.get_targets(name="ionq.simulator") 
result = submit_qir_job(target, QIR_routine, "QIR routine")
result

{'Histogram': ['(0, 0)', 0.5, '(1, 1)', 0.5]}

Enviar um circuito com um formato específico do provedor para o Azure Quantum

Além das linguagens QIR, como Q# ou Qiskit, você pode enviar circuitos quânticos em formatos específicos do provedor para o Azure Quantum. Cada provedor tem seu próprio formato para representar circuitos quânticos.

IonQ
PASQAL
Quantinuum
Rigetti

Enviar um circuito para IonQ usando o formato JSON

Crie um circuito quântico usando o formato JSON independente de linguagem suportado pelo IonQtargets, conforme descrito na documentação da API IonQ. Por exemplo, o exemplo a seguir cria uma superposição entre três qubits:

circuit = {
    "qubits": 3,
    "circuit": [
        {
        "gate": "h",
        "target": 0
        },
        {
        "gate": "cnot",
        "control": 0,
        "target": 1
        },
        {
        "gate": "cnot",
        "control": 0,
        "target": 2
        },
    ]
}

Submeta o circuito ao IonQ target. O exemplo a seguir usa o simulador IonQ, que retorna um Job objeto.
```
target = workspace.get_targets(name="ionq.simulator")
job = target.submit(circuit)
```

Aguarde até que o trabalho seja concluído e, em seguida, obtenha os resultados.

results = job.get_results()
print(results)

.....
{'duration': 8240356, 'histogram': {'0': 0.5, '7': 0.5}}

Em seguida, você pode visualizar os resultados usando Matplotlib.

import pylab as pl
pl.rcParams["font.size"] = 16
hist = {format(n, "03b"): 0 for n in range(8)}
hist.update({format(int(k), "03b"): v for k, v in results["histogram"].items()})
pl.bar(hist.keys(), hist.values())
pl.ylabel("Probabilities")

Saída de trabalho IonQ

Antes de executar um trabalho na QPU, você deve estimar quanto custará para ser executado.

Nota

Para obter os detalhes de preços mais atuais, consulte Preços IonQ ou encontre seu espaço de trabalho e veja as opções de preços na guia "Provedor" do seu espaço de trabalho via: aka.ms/aq/myworkspaces.

Enviar um circuito para PASQAL usando o SDK do Pulser

Para enviar um circuito para o PASQAL, você pode usar o SDK do Pulser para criar sequências de pulso e enviá-las para o PASQAL target.

Instalar o SDK do Pulser

Pulser é uma estrutura para compor, simular e executar sequências de pulso para dispositivos quânticos de átomos neutros. Ele foi projetado pela PASQAL como uma passagem para submeter experimentos quânticos aos seus processadores quânticos. Para obter mais informações, consulte a documentação do Pulser.

Para enviar as sequências de pulso, primeiro instale os pacotes SDK do Pulser:

try:
    import pulser
except ImportError:
    !pip -q install pulser

Criar um registo quântico

Primeiro, você cria um objeto 'devices' para importar o computador targetquântico PASQAL, Fresnel. O Fresnel QPU fornece layouts de trap predefinidos que você pode utilizar para criar seu registro quântico. Para configurar seus registros quânticos, você organiza uma matriz de qubits.
```
from pulser_pasqal import PasqalCloud

devices = PasqalCloud().fetch_available_devices()
QPU = devices["FRESNEL"]

# List all available calibrated register layouts
for calibrated_register_layout in QPU.calibrated_register_layouts.keys():
    print(calibrated_register_layout)
```
Em seguida, você define o layout para seu registro de qubit. Neste exemplo, você usa a TriangularLatticeLayout(61, 5.0µm) como o layout de trap.
```
layout = QPU.calibrated_register_layouts[
    "TriangularLatticeLayout(61, 5.0µm)"
]
layout.draw()
```
A imagem a seguir mostra a exibição do layout escolhido.
Em seguida, você define o registro de qubit selecionando um conjunto de traps do layout. Neste exemplo, o layout tem 60 traps e você seleciona 7 traps usando suas ids para definir um registro quântico de 7 qubits.
```
reg = layout.define_register(*[30, 21, 26, 35, 39, 34, 25])
reg.draw()
```
A imagem a seguir mostra a exibição final do registro de qubit.

Escrever uma sequência de pulsos

Os átomos neutros são controlados com pulsos de laser. O SDK do Pulser permite criar sequências de pulso para aplicar ao registro quântico.

Primeiro, você define os atributos da sequência de pulsos declarando os canais que serão usados para controlar os átomos. Para criar um Sequence, você precisa fornecer uma Register instância junto com o dispositivo onde a sequência será executada. Por exemplo, o código a seguir declara um canal: ch0.

Nota

Você pode usar o QPU = devices["FRESNEL"] dispositivo ou importar um dispositivo virtual do Pulser para obter mais flexibilidade. O uso de um VirtualDevice permite a criação de seqüência que é menos restrita pelas especificações do dispositivo, tornando-o adequado para execução em um emulador. Para obter mais informações, consulte a documentação do Pulser.
```
from pulser import Sequence

seq = Sequence(reg, QPU)
# print the available channels for your sequence
print(seq.available_channels)
# Declare a channel. In this example we will be using `rydberg_global`
seq.declare_channel("ch0", "rydberg_global")
```

Adicione pulsos à sua sequência. Para fazer isso, você cria e adiciona pulsos aos canais que você declarou. Por exemplo, o código a seguir cria um pulso e o adiciona ao canal ch0.

from pulser import Pulse
from pulser.waveforms import RampWaveform, BlackmanWaveform
import numpy as np

amp_wf = BlackmanWaveform(1000, np.pi)
det_wf = RampWaveform(1000, -5, 5)
pulse = Pulse(amp_wf, det_wf, 0)
seq.add(pulse, "ch0")

seq.draw()

A imagem a seguir mostra a sequência de pulsos.

Converter a sequência em uma cadeia de caracteres JSON

Para enviar as sequências de pulso, você precisa converter os objetos Pulser em uma cadeia de caracteres JSON que pode ser usada como dados de entrada.

import json

# Convert the sequence to a JSON string
def prepare_input_data(seq):
    input_data = {}
    input_data["sequence_builder"] = json.loads(seq.to_abstract_repr())
    to_send = json.dumps(input_data)
    return to_send

Submeter a sequência de pulsos ao PASQAL target

Primeiro, você precisa definir os formatos de dados de entrada e saída adequados. Por exemplo, o código a seguir define o formato de dados de entrada como pasqal.pulser.v1 e o formato de dados de saída como pasqal.pulser-results.v1.

# Submit the job with proper input and output data formats
def submit_job(target, seq, shots):
    job = target.submit(
        input_data=prepare_input_data(seq), # Take the JSON string previously defined as input data
        input_data_format="pasqal.pulser.v1",
        output_data_format="pasqal.pulser-results.v1",
        name="PASQAL sequence",
        shots=shots # Number of shots
    )

    print(f"Queued job: {job.id}")
    return job

Nota

O tempo necessário para executar um trabalho na QPU depende dos tempos de fila atuais. Você pode exibir o tempo médio de fila para um target selecionando a folha Provedores do seu espaço de trabalho.

Submeta o programa ao PASQAL. Antes de enviar seu código para hardware quântico real, você pode testar seu código usando o emulador pasqal.sim.emu-tn como um targetarquivo .

target = workspace.get_targets(name="pasqal.sim.emu-tn") # Change to "pasqal.qpu.fresnel" to use Fresnel QPU
job = submit_job(target, seq, 10)

job.wait_until_completed()
print(f"Job completed with state: {job.details.status}")
result = job.get_results()
print(result)

{
    "1000000": 3, 
    "0010000": 1, 
    "0010101": 1
}

Explore os recursos avançados do emulador

O emulador do PASQAL oferece recursos avançados que ainda não são suportados pelo Fresnel QPU. Pode organizar o seu registo de forma personalizada, sem quaisquer limitações a partir dos layouts pré-calibrados. Por exemplo, o código a seguir cria uma rede quadrada 4x4 de qubits:

import numpy as np
from pulser import Register, Sequence

L = 4
square = np.array([[i, j] for i in range(L) for j in range(L)], dtype=float)
square -= np.mean(square, axis=0)
square *= 5

qubits = dict(enumerate(square))
custom_reg = Register(qubits)
custom_reg.draw()

seq = Sequence(custom_reg, QPU)

Lote de uma rede quadrada 4x4 com 16 qubits.

Depois de definir um registro personalizado, você pode seguir exatamente as mesmas etapas descritas na seção anterior para enviar uma sequência especificada em nosso emulador.

Nota

A funcionalidade de registo personalizado estará brevemente disponível na FRESNEL.

Envie um circuito para a Quantinuum usando o OpenQASM

Crie um circuito quântico na representação OpenQASM. Por exemplo, o exemplo a seguir cria um circuito de Teletransporte:

circuit = """OPENQASM 2.0;
include "qelib1.inc";
qreg q[3];
creg c0[3];
h q[0];
cx q[0], q[1];
cx q[1], q[2];
measure q[0] -> c0[0];
measure q[1] -> c0[1];
measure q[2] -> c0[2];
"""

Opcionalmente, você pode carregar o circuito de um arquivo:

with open("my_teleport.qasm", "r") as f:
    circuit = f.read()

Submeta o circuito ao Quantinuum target. O exemplo a seguir usa o validador de API Quantinuum, que retorna um Job objeto.
```
target = workspace.get_targets(name="quantinuum.sim.h1-1sc")
job = target.submit(circuit, shots=500)
```

Aguarde até que o trabalho seja concluído e, em seguida, obtenha os resultados.

results = job.get_results()
print(results)

........
{'c0': ['000',
'000',
'000',
'000',
'000',
'000',
'000',
...
]}

Em seguida, você pode visualizar os resultados usando Matplotlib.
```
import pylab as pl
pl.hist(results["c0"])
pl.ylabel("Counts")
pl.xlabel("Bitstring")
```
Olhando para o histograma, você pode notar que o gerador de números aleatórios retornou 0 todas as vezes, o que não é muito aleatório. Isso ocorre porque, embora o validador de API garanta que seu código será executado com êxito no hardware Quantinuum, ele também retorna 0 para cada medição quântica. Para um verdadeiro gerador de números aleatórios, você precisa executar seu circuito em hardware quântico.
Antes de executar um trabalho na QPU, você deve estimar quanto custará para ser executado.

Nota

Para obter os detalhes de preços mais atuais, consulte Preços do Azure Quantum ou encontre seu espaço de trabalho e exiba as opções de preços na guia "Provedor" do seu espaço de trabalho via: aka.ms/aq/myworkspaces.

Envie um circuito para Rigetti usando Quil

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 . Sem esse pacote, o pyQuil pode ser usado para construir programas Quil, mas não para enviá-los ao Azure Quantum.

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

Use pyquil-for-azure-quantum
Usar azure-quantum Python SDK

Primeiro, carregue as importações necessárias.

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

Use a get_qvm função ou get_qpu para obter uma conexão com a QVM ou QPU.

qc = get_qvm()  # For simulation
# qc = get_qpu("Ankaa-9Q-3") for submitting to a QPU

Crie um programa Quil. Qualquer programa Quil válido é aceito, mas a leitura deve ser nomeada.ro

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"]

Aqui, data_per_shot é uma numpy matriz, para que você possa usar numpy métodos.

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

Imprima todos os dados.

print("Data from 'ro' register:")
for i, shot in enumerate(data_per_shot):
    print(f"Shot {i}: {shot}")

Primeiro, carregue as importações necessárias.

from azure.quantum import Workspace
from azure.quantum.target.rigetti import Result, Rigetti, RigettiTarget, InputParams

Crie um target objeto e selecione o nome do Rigetti's target. Por exemplo, o código a seguir seleciona o QVMtargetarquivo .
```
target = Rigetti(
    workspace=workspace,
    name=RigettiTarget.QVM,
)
```

Crie um programa Quil. Qualquer programa Quil válido é aceito, mas a leitura deve ser nomeada.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"Job completed with state: {job.details.status}")
result = Result(job)  # This throws an exception if the job failed

Você pode indexar um Resultado com o nome da leitura. Neste caso, ro. Aqui, data_per_shot é uma lista de comprimento num_shots, cada entrada é uma lista contendo os dados para o registro para essa foto.
```
data_per_shot = result[readout]

ro_data_first_shot = data_per_shot[0]
```
Nesse caso, como o tipo do registro é BIT, o tipo será inteiro e o valor 0 ou 1.
```
assert isinstance(ro_data_first_shot[0], int)
assert ro_data_first_shot[0] == 1 or ro_data_first_shot[0] == 0
```

Imprimir todos os dados

print(f"Data from '{readout}' register:")
for i, shot in enumerate(data_per_shot):
    print(f"Shot {i}: {shot}")

Importante

Atualmente, não há suporte para o envio de vários circuitos em um único trabalho. Como solução alternativa, você pode chamar o método para enviar cada circuito de forma assíncrona backend.run e, em seguida, buscar os resultados de cada trabalho. Por exemplo:

jobs = []
for circuit in circuits:
    jobs.append(backend.run(circuit, shots=N))

results = []
for job in jobs:
    results.append(job.result())

Partilhar via

Como enviar circuitos formatados específicos para o Azure Quantum

Pré-requisitos

Criar um novo Jupyter Notebook

Enviar circuitos formatados em QIR

Enviar um circuito com um formato específico do provedor para o Azure Quantum

Enviar um circuito para IonQ usando o formato JSON

Enviar um circuito para PASQAL usando o SDK do Pulser

Instalar o SDK do Pulser

Criar um registo quântico

Escrever uma sequência de pulsos

Converter a sequência em uma cadeia de caracteres JSON

Submeter a sequência de pulsos ao PASQAL target

Explore os recursos avançados do emulador

Envie um circuito para a Quantinuum usando o OpenQASM

Envie um circuito para Rigetti usando Quil

Comentários

Recursos adicionais

Partilhar via

Como enviar circuitos formatados específicos para o Azure Quantum

Pré-requisitos

Criar um novo Jupyter Notebook

Enviar circuitos formatados em QIR

Enviar um circuito com um formato específico do provedor para o Azure Quantum

Enviar um circuito para IonQ usando o formato JSON

Enviar um circuito para PASQAL usando o SDK do Pulser

Instalar o SDK do Pulser

Criar um registo quântico

Escrever uma sequência de pulsos

Converter a sequência em uma cadeia de caracteres JSON

Submeter a sequência de pulsos ao PASQAL target

Explore os recursos avançados do emulador

Envie um circuito para a Quantinuum usando o OpenQASM

Envie um circuito para Rigetti usando Quil

Conteúdos relacionados

Comentários

Recursos adicionais