Use o Microsoft Quantum Development Kit pacote (QDK) Python para enviar Q#, OpenQASM, Qiskit, Cirqe PennyLane programas para Azure Quantum.
Este artigo fornece exemplos de envio de trabalho para cada linguagem quântica ou estrutura com suporte. Para um fluxo de trabalho interativo Q# ou Python que não exija código QDK, consulte OpenQASM.
Pré-requisitos
Uma conta do Azure com uma assinatura ativa.
Um Azure Quantum espaço de trabalho. Para criar um, consulte Criar um Azure Quantum espaço de trabalho.
Python 3.10 ou posterior.
Se você usa um notebook Jupyter, um ambiente Jupyter, como a extensão Jupyter para VS Code e o pacote ipykernel.
Instale CLI do Azure com a quantum extensão.
az extension add --upgrade --name quantum
Instale a versão mais recente do pacote qdkPython com os extras azure e jupyter.
pip install --upgrade "qdk[azure,jupyter]"
Se você quiser enviar um programa Qiskit ou Cirq, instale os extras cirq e qiskit.
pip install --upgrade "qdk[qiskit,cirq]"
Conectar-se ao seu Azure Quantum espaço de trabalho
Antes de enviar um trabalho, você precisa se conectar a um Azure Quantum workspace. O módulo qdk.azure fornece o objeto Workspace para se conectar aos espaços de trabalho Azure Quantum. Para se conectar ao workspace, siga estas etapas.
Entre com CLI do Azure
Se você ainda não fez isso, faça login no Azure em um terminal antes de abrir um Jupyter Notebook.
az login
Se você não fizer login pelo terminal, precisará se autenticar toda vez que se conectar a um espaço de trabalho do Quantum por meio de Python. Se sua conta tiver acesso a várias assinaturas, defina a assinatura que contém seu Azure Quantum espaço de trabalho.
az account set --subscription <subscription-id>
Execute az login novamente quando a sessão expirar ou quando você quiser usar uma conta de Azure diferente.
Obtenha o identificador do recurso do seu espaço de trabalho
- Entre no portal do Azure.
- Vá para o workspace do Quantum onde você deseja enviar seu trabalho.
- Na página Visão geral , localize e copie a ID do recurso.
Conectar-se ao espaço de trabalho
Para se conectar ao workspace do Quantum, crie um Workspace objeto com a ID do recurso copiado.
from qdk.azure import Workspace
workspace = Workspace(resource_id="") # Add your resource ID
Verifique a conexão e veja os targets disponíveis no espaço de trabalho.
for target in workspace.get_targets():
print(target.name)
Para obter outras opções de conexão e autenticação, consulte Conectar-se ao seu Azure Quantum workspace.
Note
Os exemplos a seguir enviam trabalhos para o simulador targets. Os targets disponíveis em seu espaço de trabalho dependem de seus provedores configurados.
Preparar e enviar seu programa
Escolha a guia correspondente à sua linguagem quântica ou framework.
Use o módulo qdk.qsharp para definir ou carregar código Q#, compilar um ponto de entrada para QIR e enviar o QIR para um Azure Quantumtarget.
Definir e compilar o Q# programa
Inicializar Q# com um perfil QIRtarget que o/a Azure Quantumtarget suporta.
from qdk import qsharp, TargetProfile
qsharp.init(target_profile=TargetProfile.Base)
Para obter mais informações sobre os perfis QIRtarget, consulte os perfis Azure QuantumQIRtarget no QDK.
Defina uma operação Q#. Por exemplo, use a operação a seguir RandomBit .
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()")
Enviar a Q# tarefa
Selecione um(a) target compatível do seu espaço de trabalho.
target = workspace.get_targets("rigetti.sim.qvm")
Envie o programa compilado.
job = target.submit(program, "qsharp-job", shots=100)
print("Job ID:", job.id)
Aguarde até que o trabalho seja concluído e recupere 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 em QIR e, em seguida, envie o QIR para um Azure Quantumtarget.
Definir e compilar o OpenQASM programa
Defina um OpenQASM circuito como uma cadeia de Python caracteres.
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 o OpenQASM trabalho
Selecione um target que aceite o programa compilado.
target = workspace.get_targets("ionq.simulator")
Envie o programa compilado.
job = target.submit(program, "openqasm-job", shots=100)
print("Job ID:", job.id)
Aguarde até que o trabalho seja concluído e recupere seus resultados.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Para OpenQASM programas parametrizados, vincule os valores de entrada antes de enviar uma tarefa. Para obter mais informações sobre OpenQASM no QDK, consulte Desenvolva programas OpenQASM no QDK.
Use AzureQuantumProvider do módulo qdk.azure para enviar tarefas Qiskit a um provedor Azure Quantum. O objeto do provedor lista QiskitAzure Quantum compatíveis e retorna targets tarefas 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 o Qiskit trabalho
Crie um objeto de provedor Azure Quantum a partir do espaço de trabalho.
from qdk.azure.qiskit import AzureQuantumProvider
provider = AzureQuantumProvider(workspace)
Liste os backends que aceitam circuitos Qiskit.
for backend in provider.backends():
print(backend.name)
Selecione um back-end e envie 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 até que o trabalho seja concluído e recupere os Qiskit resultados.
result = job.result()
counts = result.get_counts(circuit)
print(counts)
O adaptador Qiskit lida com o formato de entrada Azure Quantum e converte a resposta do provedor em um resultado Qiskit.
Qiskit resultados de execução para programas com perda de qubits
Alguns hardwares quânticos podem sofrer perda de qubit quando um programa está em execução. Se ocorrer perda de qubit em qualquer ponto durante um shot de um programa Qiskit, então esse shot será removido dos resultados do trabalho Azure Quantum. Por exemplo, se a perda de qubit ocorrer em 10 de 200 capturas, os resultados do trabalho terão 190 contagens de medidas totais.
Os resultados brutos de todas as capturas, incluindo as capturas em que ocorreu a perda de qubit, ainda estão disponíveis no results objeto. O código a seguir obtém os dois 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 tarefas ou targets que não têm perda de qubit, os resultados padrão e os resultados brutos são idênticos.
Note
O memory atributo para Qiskit resultados do trabalho é uma lista do resultado da medida para cada captura.
Use AzureQuantumService do módulo qdk.azure para enviar tarefas Cirq para um provedor Azure Quantum. O objeto de serviço lista resultados compatíveis Azure Quantumtargets e retorna Cirqresultados nativos ou nativos do provedor.
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 o Cirq trabalho
Crie o objeto de serviço Azure Quantum.
from qdk.azure.cirq import AzureQuantumService
service = AzureQuantumService(workspace)
Liste os targets que aceitam circuitos Cirq.
for target in service.targets():
print(target.name)
Crie um trabalho assíncrono.
job = service.create_job(
program=circuit,
repetitions=100,
target="ionq.simulator",
)
print("Status:", job.status())
Aguarde até que o trabalho seja concluído e recupere seus resultados.
result = job.results()
print(result)
O formato dos resultados depende do provedor e target. Alguns objetos de resultado do provedor podem ser convertidos em um cirq.Result objeto.
Converta um nó quântico PennyLane em OpenQASM, compile OpenQASM para QIR e submeta QIR a um Azure Quantumtarget.
Criar um PennyLane circuito
O circuito a seguir é um circuito parametrizado. O efeito do RY portão 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 em OpenQASM para um valor específico do parâmetro.
theta = 0.3
qasm_source = qml.to_openqasm(circuit)(theta)
Compile o OpenQASM para QIR com um perfil compatível target .
from qdk import TargetProfile
from qdk.openqasm import compile
program = compile(qasm_source, TargetProfile.Base)
Enviar o PennyLane trabalho
Selecione um compatível target e envie o QIR.
target = workspace.get_targets("rigetti.sim.qvm")
job = target.submit(program, "pennylane-job", shots=100)
print("Job ID:", job.id)
Aguarde até que o trabalho seja concluído e recupere seus resultados.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
O formato dos resultados depende do provedor e target.
Azure Quantum não retorna PennyLane os resultados do nó quântico do QIR enviado.
Conteúdo relacionado