Utilize o pacote Python (QDK) Microsoft Quantum Development Kit para submeter programas Q#, OpenQASM, Qiskit, Cirq e PennyLane a Azure Quantum.
Este artigo fornece exemplos de submissão de trabalhos para cada linguagem ou framework quântico suportado. Para um fluxo de trabalho interativo com Q# ou OpenQASM que não exija código Python, consulte Submeter trabalhos com a extensão QDK para VS Code.
Pré-requisitos
Uma conta do Azure com uma assinatura ativa.
Um Azure Quantum espaço de trabalho. Para criar um, veja Criar um Azure Quantum espaço de trabalho.
Python 3.10 ou mais tarde.
Se usares um notebook do Jupyter, um ambiente Jupyter, como a extensão Jupyter para VS Code e o pacote ipykernel.
Instala o CLI do Azure com a quantum extensão.
az extension add --upgrade --name quantum
Instala a versão mais recente do pacote qdkPython com os extras azure e jupyter.
pip install --upgrade "qdk[azure,jupyter]"
Se quiseres submeter um programa Qiskit ou Cirq, instala os extras cirq e qiskit
pip install --upgrade "qdk[qiskit,cirq]"
Liga-te ao teu Azure Quantum espaço de trabalho
Antes de submeter uma tarefa, tem de se ligar a um espaço de trabalho Azure Quantum. O módulo qdk.azure fornece o objeto Workspace para ligar a espaços de trabalho Azure Quantum. Para se ligar ao seu espaço de trabalho, siga estes passos.
Iniciar sessão com CLI do Azure
Se ainda não o fizeste, inicia sessão no Azure a partir de um terminal antes de abrires um notebook Jupyter.
az login
Se não iniciar sessão a partir do terminal, tem de se autenticar sempre que se ligar a um espaço de trabalho do Quantum através de Python. Se a sua conta tiver acesso a várias subscrições, defina a subscrição que contém o seu Azure Quantum espaço de trabalho.
az account set --subscription <subscription-id>
Executa az login novamente quando a sessão expirar ou quando quiseres usar uma conta Azure diferente.
Obtenha o ID de recurso do seu espaço de trabalho
- Inicie sessão no portal Azure.
- Vai ao espaço de trabalho da Quantum onde queres submeter o teu trabalho.
- Na página de Visão Geral , encontre e copie o ID do Recurso.
Conectar-se ao espaço de trabalho
Para te ligares ao teu espaço de trabalho Quantum, cria um Workspace objeto com o ID de recurso que copiaste.
from qdk.azure import Workspace
workspace = Workspace(resource_id="") # Add your resource ID
Verifique a ligação e veja os targets disponíveis no espaço de trabalho.
for target in workspace.get_targets():
print(target.name)
Para outras opções de ligação e autenticação, consulte Ligar ao seu Azure Quantum espaço de trabalho.
Observação
Os exemplos seguintes submetem trabalhos ao simulador targets. Os targets disponíveis no seu espaço de trabalho dependem dos fornecedores configurados.
Prepare e submeta o seu programa
Escolha o separador correspondente à sua linguagem quântica ou framework.
Use o qdk.qsharp módulo para definir ou carregar Q# código, compile um ponto de entrada para QIR, e submeta o QIR para um Azure Quantumtarget.
Definir e compilar o Q# programa
Inicialize Q# com um perfil targetQIR que o Azure Quantumtarget suporte.
from qdk import qsharp, TargetProfile
qsharp.init(target_profile=TargetProfile.Base)
Para mais informações sobre os perfis QIRtarget, consulte os perfis Azure QuantumQIRtarget no QDK.
Defina uma Q# operação. Por exemplo, use a seguinte RandomBit operação.
qsharp.eval("""
operation RandomBit() : Result {
use q = Qubit();
H(q);
return MResetZ(q);
}
""")
Teste a operação no simulador local.
print(qsharp.run("RandomBit()", shots=10))
Compile a operação para QIR.
from qdk.qsharp import compile
program = compile("RandomBit()")
Submeter a Q# tarefa
Selecione um target compatível do seu espaço de trabalho.
target = workspace.get_targets("rigetti.sim.qvm")
Submeter o programa compilado.
job = target.submit(program, "qsharp-job", shots=100)
print("Job ID:", job.id)
Espere que o trabalho seja concluído e recupere os seus resultados.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Use o módulo qdk.openqasm para compilar o código-fonte OpenQASM 3 para QIR e, em seguida, submeta o QIR a um Azure Quantumtarget.
Definir e compilar o OpenQASM programa
Defina um OpenQASM circuito como uma Python cadeia.
qasm_source = """
OPENQASM 3.0;
include "stdgates.inc";
bit[2] c;
qubit[2] q;
h q[0];
cx q[0], q[1];
c = measure q;
"""
Compile o programa para QIR.
from qdk.openqasm import compile
program = compile(qasm_source)
Enviar a OpenQASM tarefa
Selecione um target que aceite o programa compilado.
target = workspace.get_targets("ionq.simulator")
Submeter o programa compilado.
job = target.submit(program, "openqasm-job", shots=100)
print("Job ID:", job.id)
Espere que o trabalho seja concluído e recupere os seus resultados.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Para programas OpenQASM parametrizados, atribuir os valores de entrada antes de submeter uma tarefa. Para mais informações sobre OpenQASM no QDK, consulte Desenvolver programas OpenQASM no QDK.
Utilize AzureQuantumProvider do módulo qdk.azure para submeter tarefas Qiskit a um fornecedor Azure Quantum. O objeto fornecedor lista compatíveis Azure Quantumtargets e devolve Qiskit trabalhos e resultados.
Criar um Qiskit circuito
from qiskit import QuantumCircuit
circuit = QuantumCircuit(3, 3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])
Enviar a Qiskit tarefa
Crie um Azure Quantum objeto fornecedor a partir do espaço de trabalho.
from qdk.azure.qiskit import AzureQuantumProvider
provider = AzureQuantumProvider(workspace)
Lista os backends que aceitam Qiskit circuitos.
for backend in provider.backends():
print(backend.name)
Selecione um backend e submeta o circuito.
backend = provider.get_backend("rigetti.sim.qvm")
job = backend.run(circuit, shots=100)
print("Job ID:", job.job_id())
print("Status:", job.status())
Aguarde que a tarefa esteja concluída e obtenha os Qiskit resultados.
result = job.result()
counts = result.get_counts(circuit)
print(counts)
O adaptador Qiskit processa o formato de entrada Azure Quantum e converte a resposta do provedor num resultado Qiskit.
Qiskit resultados de tarefas para programas com perda de qubits
Algum hardware quântico pode sofrer perda de qubits quando um programa está a correr. Se ocorrer perda de qubits em qualquer altura durante uma execução num programa Qiskit, essa execução é removida dos resultados da tarefa Azure Quantum. Por exemplo, se a perda de qubits ocorrer em 10 em 200 disparos, então os resultados do trabalho têm 190 contagens totais de medições.
Os resultados brutos de todos os disparos, incluindo os que houve perda de qubits, continuam disponíveis no results objeto. O código seguinte obtém ambos os conjuntos de resultados.
# Get results only for shots without qubit loss
print('Counts:', result.results[0].data.counts)
print('Probabilities:', result.results[0].data.probabilities)
print('Memory:', result.results[0].data.memory)
# Get the raw total shot results
print('Raw counts:', result.results[0].data.raw_counts)
print('Raw probabilities:', result.results[0].data.raw_probabilities)
print('Raw memory:', result.results[0].data.raw_memory)
Para trabalhos ou targets que não têm perda de qubits, os resultados padrão e brutos são idênticos.
Observação
O memory atributo para Qiskit os resultados do trabalho é uma lista dos resultados de medição para cada disparo.
Utilize AzureQuantumService do módulo qdk.azure para submeter tarefas Cirq a um fornecedor Azure Quantum. O objeto de serviço lista os Azure Quantumtargets compatíveis e retorna resultados nativos de Cirq ou do fornecedor.
Criar um Cirq circuito
import cirq
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.H(q0),
cirq.CX(q0, q1),
cirq.measure(q0, q1, key="result"),
)
Enviar a Cirq tarefa
Crie o Azure Quantum objeto de serviço.
from qdk.azure.cirq import AzureQuantumService
service = AzureQuantumService(workspace)
Liste os targets que aceitam circuitos Cirq.
for target in service.targets():
print(target.name)
Cria um trabalho assíncrono.
job = service.create_job(
program=circuit,
repetitions=100,
target="ionq.simulator",
)
print("Status:", job.status())
Espere que o trabalho seja concluído e recupere os seus resultados.
result = job.results()
print(result)
O formato dos resultados depende do fornecedor e target. Alguns objetos de resultados do fornecedor podem ser convertidos num objeto cirq.Result.
Converta um nó quântico PennyLane em OpenQASM, compile o OpenQASM para QIR e submeta o QIR a um Azure Quantumtarget.
Criar um PennyLane circuito
O circuito seguinte é um circuito parametrizado. O efeito da RY porta depende do ângulo theta.
import pennylane as qml
device = qml.device("default.qubit", wires=2)
@qml.qnode(device)
def circuit(theta):
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
qml.RY(theta, wires=1)
return qml.expval(qml.PauliZ(1))
Converta o circuito para QIR
Converta o circuito parametrizado para OpenQASM para um valor de parâmetro específico.
theta = 0.3
qasm_source = qml.to_openqasm(circuit)(theta)
Compile de OpenQASM para QIR com um perfil target compatível.
from qdk import TargetProfile
from qdk.openqasm import compile
program = compile(qasm_source, TargetProfile.Base)
Enviar a PennyLane tarefa
Selecione um target compatível e submeta o QIR ficheiro.
target = workspace.get_targets("rigetti.sim.qvm")
job = target.submit(program, "pennylane-job", shots=100)
print("Job ID:", job.id)
Espere que o trabalho seja concluído e recupere os seus resultados.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
O formato dos resultados depende do prestador e target.
Azure Quantum não devolve PennyLane os resultados dos nós quânticos do QIR submetido.
Conteúdo relacionado