Submeta tarefas para Azure Quantum com o pacote QDKPython

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

1. Inicie sessão no portal Azure.
2. Vai ao espaço de trabalho da Quantum onde queres submeter o teu trabalho.
3. Na página de Visão Geral , encontre e copie o ID do Recurso.

Conectar-se ao espaço de trabalho

1. 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
   

   Observação

   Y

2. 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.

Q#

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

1. 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.

2. 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);
       }
   """)
   

3. Teste a operação no simulador local.

   print(qsharp.run("RandomBit()", shots=10))
   

4. Compile a operação para QIR.

   from qdk.qsharp import compile
   
   program = compile("RandomBit()")
   

Submeter a Q# tarefa

1. Selecione um target compatível do seu espaço de trabalho.

   target = workspace.get_targets("rigetti.sim.qvm")
   

2. Submeter o programa compilado.

   job = target.submit(program, "qsharp-job", shots=100)
   print("Job ID:", job.id)
   

3. 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)
   

OpenQASM

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

1. 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;
   """
   

2. Compile o programa para QIR.

   from qdk.openqasm import compile
   
   program = compile(qasm_source)
   

Enviar a OpenQASM tarefa

1. Selecione um target que aceite o programa compilado.

   target = workspace.get_targets("ionq.simulator")
   

2. Submeter o programa compilado.

   job = target.submit(program, "openqasm-job", shots=100)
   print("Job ID:", job.id)
   

3. 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.

Qiskit

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

1. Crie um Azure Quantum objeto fornecedor a partir do espaço de trabalho.

   from qdk.azure.qiskit import AzureQuantumProvider
   
   provider = AzureQuantumProvider(workspace)
   

2. Lista os backends que aceitam Qiskit circuitos.

   for backend in provider.backends():
       print(backend.name)
   

3. 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())
   

4. 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.

Cirq

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

1. Crie o Azure Quantum objeto de serviço.

   from qdk.azure.cirq import AzureQuantumService
   
   service = AzureQuantumService(workspace)
   

2. Liste os targets que aceitam circuitos Cirq.

   for target in service.targets():
       print(target.name)
   

3. Cria um trabalho assíncrono.

   job = service.create_job(
       program=circuit,
       repetitions=100,
       target="ionq.simulator",
   )
   
   print("Status:", job.status())
   

4. 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.

PennyLane

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

1. Converta o circuito parametrizado para OpenQASM para um valor de parâmetro específico.

   theta = 0.3
   qasm_source = qml.to_openqasm(circuit)(theta)
   

2. 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

1. 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)
   

2. 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

• Como submeter empregos para Azure Quantum
• Submeter tarefas com a extensão QDK para VS Code
• Submeter tarefas para Azure Quantum com CLI do Azure
• Trabalhar com Azure Quantum tarefas
• Suporte à linguagem de programação quântica no QDK
• Azure Quantum Fornecedor de computação targets