Como enviar um circuito com o Qiskit para o Azure Quantum

Saiba como enviar um circuito quântico Qiskit usando o azure-quantumPython pacote. Você pode enviar circuitos Qiskit para o Azure Quantum usando o bloco de azure-quantumPython anotações do Azure Quantum, que tem pacote interno, ou de sua máquina local.

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

Nota

O Microsoft Quantum Development Kit (Classic QDK) não será mais suportado após 30 de junho de 2024. Se você for um desenvolvedor QDK existente, recomendamos que faça a transição para o novo Kit de Desenvolvimento Quântico do Azure (QDK Moderno) para continuar desenvolvendo soluções quânticas. Para obter mais informações, consulte Migrar seu código Q# para o QDK moderno.

Pré-requisitos

Para obter detalhes da instalação, consulte Instalando o QDK moderno no VS Code.

• Um espaço de trabalho do Azure Quantum em sua assinatura do Azure. Para criar um espaço de trabalho, consulte Criar um espaço de trabalho do Azure Quantum.

• Um Python ambiente com Python e Pip instalado.

• VS Code com o Azure Quantum Development Kit Pythone as extensões Jupyter instaladas.

• O pacote Azure Quantum azure-quantumPython com a tag [qiskit]. Certifique-se de ter a versão mais recente do Qiskit. Para obter mais informações, consulte Atualizar o pacote azure-quantumPython.

• A versão mais recente do pacote Azure Quantum azure-quantumPython com a tag [qiskit].

  Nota

  Certifique-se de ter a versão mais recente do Qiskit. Para obter mais informações, consulte Atualizar o pacote azure-quantumPython.

  python -m pip install --upgrade azure-quantum[qiskit] qsharp ipykernel 
  

  Nota

  Se o kernel ipykernel do Jupyter Python não for detetado, o VS Code solicitará que você o instale.

Criar um novo Jupyter Notebook

1. No VS Code, selecione View > Command palette e selecione Create: New Jupyter Notebook.
2. No canto superior direito, o VS Code detetará e exibirá a versão e Python o ambiente virtual Python que foi selecionado para o notebook. Se você tiver vários Python ambientes, talvez seja necessário selecionar um kernel usando o seletor de kernel no canto superior direito. Se nenhum ambiente foi detetado, consulte Jupyter Notebooks no VS Code para obter informações de configuração.

Carregue as importações necessárias

Na primeira célula do seu bloco de notas, execute o seguinte código para carregar as importações necessárias:

import azure.quantum
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Conectar-se ao serviço Azure Quantum

Para se conectar ao serviço Azure Quantum, você precisa 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.

   

Adicione uma nova célula em seu bloco de anotações e use as informações da sua conta para criar Workspace e AzureQuantumProvider objetos para se conectar ao seu espaço de trabalho do Azure Quantum.

workspace = Workspace(  
    resource_id = "", # Add the resourceID of your workspace
    location = "" # Add the location of your workspace (for example "westus")
    )

provider = AzureQuantumProvider(workspace)

Listar todos os back-ends

Agora você pode imprimir todos os back-ends de computação quântica disponíveis em seu espaço de trabalho:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.qpu.aria-1
- ionq.simulator
- microsoft.estimator
- quantinuum.hqs-lt-s1
- quantinuum.hqs-lt-s1-apival
- quantinuum.hqs-lt-s2
- quantinuum.hqs-lt-s2-apival
- quantinuum.hqs-lt-s1-sim
- quantinuum.hqs-lt-s2-sim
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Execute um circuito simples

Primeiro, crie um circuito Qiskit simples para executar.

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0,1,2], [0, 1, 2])

# Print out the circuit
circuit.draw()

     ┌───┐          ┌─┐      
q_0: ┤ H ├──■───────┤M├──────
     └───┘┌─┴─┐     └╥┘┌─┐   
q_1: ─────┤ X ├──■───╫─┤M├───
          └───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
               └───┘ ║  ║ └╥┘
c: 3/════════════════╩══╩══╩═
                     0  1  2 

Selecione um target para executar o programa

IonQ

Executar no simulador IonQ

Antes de correr em hardware real, vamos testar o circuito no simulador. Use get_backend para criar um Backend objeto para se conectar ao back-end do IonQ Simulator:

simulator_backend = provider.get_backend("ionq.simulator")

Os back-ends IonQ suportam portas de um conjunto de portas definido, que são compiladas para serem executadas de forma otimizada no hardware. Se o seu circuito contém portões que não estão nesta lista, você precisa transpilar para o suportado gateset usando a transpile função fornecida pelo Qiskit:

from qiskit import transpile
circuit = transpile(circuit, simulator_backend)

A função transpile retorna um novo objeto de circuito onde os portões são decompostos em portões que são suportados no back-end especificado.

Agora você pode executar o programa por meio do serviço Azure Quantum e obter o resultado. A célula a seguir envia um trabalho que executa o circuito com 100 disparos:

job = simulator_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Job id 00000000-0000-0000-0000-000000000000

Para aguardar até que o trabalho seja concluído e retornar os resultados, execute:

result = job.result()
print(result)

Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 50, '111': 50}, probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(meas_map='[0, 1, 2]', name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])

Como o resultado é um objeto nativo do pacote Qiskit, você pode usar o Qiskit result.get_counts e plot_histogram visualizar os resultados. Para certificar-se de que todos os rótulos de cadeia de bits possíveis estão representados, adicione-os ao counts.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}

Estimar o custo do trabalho

Antes de executar um trabalho na QPU, você pode estimar quanto custa executar. Para estimar o custo de execução de um trabalho na QPU, você pode usar o estimate_cost método:

backend = provider.get_backend("ionq.qpu")
cost = backend.estimate_cost(circuit, shots=1024)

print(f"Estimated cost: {cost.estimated_total}")

Isso imprime o custo estimado em USD.

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.

Executar em IonQ QPU

Para se conectar ao hardware real (uma unidade de processador quântico target"ionq.qpu"get_backend (QPU)), basta fornecer o nome do método:

qpu_backend = provider.get_backend("ionq.qpu")

Envie o circuito para ser executado no Azure Quantum, obtenha os resultados e execute plot_histogram para plotar os resultados.

Nota

O tempo necessário para executar um circuito na QPU pode variar dependendo dos tempos de fila atuais.

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}

Quantinuum

Executar no verificador de sintaxe

Para testar o programa antes de executá-lo no hardware, primeiro execute-o no Verificador de Sintaxe Quantinuum. Use o get_backend método para criar um Backend objeto para se conectar ao Quantinuum Syntax Checkerbackend:

# Get Quantinuum's syntax checker backend:
syntax_backend = provider.get_backend("quantinuum.sim.h1-1sc")

Agora você pode executar o programa por meio do serviço Azure Quantum e obter o resultado. A célula a seguir envia um trabalho que executa o circuito com 1024 disparos:

# Submit the circuit to run on Azure Quantum
job = syntax_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='quantinuum.qpu.h1-1sc', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 1024}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 1024, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

Nota

Embora o verificador de sintaxe Quantinuum garanta que seu código será executado com êxito no hardware Quantinuum, ele também retorna 0 para cada medição quântica. Para uma verdadeira medição quântica, você precisa executar seu circuito em hardware quântico.

Estimar o custo do trabalho

Antes de executar um trabalho na QPU, você pode estimar quanto custará para ser executado. Para estimar o custo de execução de um trabalho na QPU, você pode usar o estimate_cost método:

qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")
cost = qpu_backend.estimate_cost(circuit, shots=1024)

print(f"Estimated cost: {cost.estimated_total}")

Isso imprime o custo estimado em Créditos Quânticos do Sistema H (HQCs).

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 em: aka.ms/aq/myworkspaces.

Executar em um QPU Quantinuum

Depois de executar com sucesso no validador de API, você pode executar seu trabalho em um dos processadores de hardware da Quantinuum (uma unidade de processador quântico (QPU)).

Nota

O tempo necessário para executar um circuito na QPU pode variar dependendo dos tempos de fila atuais.

# Get Quantinuum's QPU backend:
qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Result(backend_name='quantinuum.qpu.h1-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'011': 16, '010': 5, '001': 1, '000': 500, '111': 471, '101': 6, '100': 17, '110': 8}, probabilities={'011': 0.015625, '010': 0.0048828125, '001': 0.0009765625, '000': 0.48828125, '111': 0.4599609375, '101': 0.005859375, '100': 0.0166015625, '110': 0.0078125}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 500, '001': 1, '010': 5, '011': 16, '100': 17, '101': 6, '110': 8, '111': 471}

Rigetti

Executar no simulador QVM

Para testar o programa antes de executá-lo no hardware, primeiro execute-o no simulador Rigetti QVM. Use o provider.get_backend método para criar um Backend objeto para se conectar ao back-end do simulador Rigetti QVM:

# Get Rigetti's QVM simulator backend:
qvm_backend = provider.get_backend("rigetti.sim.qvm")

Agora você pode executar o programa por meio do serviço Azure Quantum e obter o resultado. A célula a seguir envia um trabalho que executa o circuito com 1024 disparos:

# Submit the circuit to run on Azure Quantum
job = qvm_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='rigetti.sim.qvm"', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 1024}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 1024, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

Executar em um Rigetti QPU

Depois de executar com sucesso no simulador de QVM, você pode executar seu trabalho em um dos processadores de hardware da Rigetti (uma Unidade de Processador Quântico (QPU)).

Nota

O tempo necessário para executar um circuito na QPU pode variar dependendo dos tempos de fila atuais.

# Get Rigetti's QPU backend:
qpu_backend = provider.get_backend("rigetti.qpu.ankaa-2")

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=500)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Result(backend_name='rigetti.qpu.ankaa-2', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'011': 16, '010': 5, '001': 1, '000': 500, '111': 471, '101': 6, '100': 17, '110': 8}, probabilities={'011': 0.015625, '010': 0.0048828125, '001': 0.0009765625, '000': 0.48828125, '111': 0.4599609375, '101': 0.005859375, '100': 0.0166015625, '110': 0.0078125}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 500, '001': 1, '010': 5, '011': 16, '100': 17, '101': 6, '110': 8, '111': 471}

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

Pré-requisitos

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

Criar um novo bloco de notas na sua área de trabalho

1. Faça logon no portal do Azure e selecione o espaço de trabalho criado na etapa anterior.
2. Na folha esquerda, selecione Blocos de Notas.
3. Clique em Meus Blocos de Anotações e clique em Adicionar Novo.
4. Digite um nome para o arquivo, por exemplo Qiskit.ipynb, e clique em Criar arquivo.

Quando o novo bloco de notas é aberto, cria automaticamente o código para a primeira célula, com base na sua subscrição e nas informações da área de trabalho.

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

Nota

Salvo indicação em contrário, deve executar cada célula em ordem à medida que a cria para evitar quaisquer problemas de compilação.

Clique no ícone triangular "play" à esquerda da célula para executar o código.

Carregue as importações necessárias

Primeiro, você precisará importar alguns módulos adicionais.

Clique em + Código para adicionar uma nova célula e, em seguida, adicione e execute o seguinte código:

from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Conectar-se ao serviço Azure Quantum

Em seguida, crie um AzureQuantumProvider objeto usando o Workspace objeto da célula anterior para se conectar ao seu espaço de trabalho do Azure Quantum. Adicione uma nova célula com o seguinte código:

provider = AzureQuantumProvider(workspace)

Definir um circuito simples

Em uma nova célula, crie um circuit objeto. Este exemplo é um gerador de bits aleatórios quânticos simples. Adicione o seguinte código para definir e exibir o circuito:

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])

# Print out the circuit
circuit.draw()

     ┌───┐          ┌─┐      
q_0: ┤ H ├──■───────┤M├──────
     └───┘┌─┴─┐     └╥┘┌─┐   
q_1: ─────┤ X ├──■───╫─┤M├───
          └───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
               └───┘ ║  ║ └╥┘
c: 3/════════════════╩══╩══╩═
                     0  1  2 

Listar tudo targets

Agora você pode exibir toda a computação targetsquântica, ou back-ends, que estão disponíveis em seu espaço de trabalho. Adicione uma nova célula e execute a seguinte linha:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Selecione um target para executar o programa

IonQ

Para verificar seu código antes de executá-lo em hardware quântico real, você pode usar o simulador quântico IonQ, ionq.simulator.

Adicione uma nova célula e crie um objeto para representar o simulador targetquântico IonQ:

# Get IonQ quantum simulator target:
simulator_backend = provider.get_backend("ionq.simulator")

Executar no simulador IonQ

Para executar o seu circuito no simulador, adicione o seguinte código. Este exemplo usa o run método do para enviar seu trabalho e, em seguida, monitora o status do target trabalho.

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Quando o trabalho for executado com êxito, obtenha os resultados do trabalho e exiba-os:

# Get the job results:
result = job.result()
print(result)

Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='7d909574-98d4-11ec-b382-00155d957f5d', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts=defaultdict(<class 'int'>, {'000': 50, '111': 50}), probabilities=defaultdict(<class 'int'>, {'000': 0.5, '111': 0.5})), header=QobjExperimentHeader(meas_map='[0, 1, 2]', name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])

Como esse result tipo é um objeto nativo do pacote Qiskit, você pode usar o Qiskit result.get_counts e plot_histogram visualizar os resultados. Para certificar-se de que todos os rótulos de cadeia de bits possíveis estão representados, adicione-os ao counts.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}

Estimar o custo do trabalho

Antes de executar um trabalho em hardware quântico real, ou uma unidade de processamento quântico (QPU), você pode estimar quanto custa executar.

Primeiro, obtenha a lista de provedores disponíveis novamente:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Em seguida, crie um objeto para representar o computador quântico IonQ:

qpu_backend = provider.get_backend("ionq.qpu")

Para estimar o custo de execução de um trabalho na QPU, adicione e execute uma nova célula usando o estimate_cost método do target:

cost = qpu_backend.estimate_cost(circuit, shots=100)

print(f"Estimated cost: {cost.estimated_total}")

Isso exibe o custo estimado em USD.

Para obter os detalhes de preços mais atuais, consulte Preços IonQ ou localize seu espaço de trabalho e visualize as opções de preços na folha Provedores do seu espaço de trabalho.

Executar em IonQ QPU

Depois de executar seu trabalho com sucesso no simulador IonQ e estimar o custo QPU, é hora de executar seu circuito no hardware.

Nota

O tempo necessário para executar um circuito na QPU varia dependendo 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.

Use o mesmo run método e operações que você usou anteriormente com o Validador de API para enviar e monitorar seu trabalho:

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

Quando o trabalho terminar, obtenha os resultados do trabalho como antes e exiba-os em um gráfico:

result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 910b5ac8-98cd-11ec-b3ba-00155d5528cf
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='Job id 54e8c740-98d9-11ec-b382-00155d957f5d', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}

Quantinuum

Para verificar seu código antes de executá-lo em hardware quântico real, você pode usar um dos Quantinuum Syntax Checkers, quantinuum.sim.h1-1sc.

Adicione uma nova célula e crie um objeto para representar o Verificador targetde Sintaxe Quantinuum :

# Get Quantinuum's Syntax Checker target:
apival_backend = provider.get_backend("quantinuum.sim.h1-1sc")

Executar no Verificador de Sintaxe

Para executar seu circuito no Verificador de Sintaxe, adicione o código a seguir, que usa o run método do para enviar seu trabalho e, em seguida, monitora o status do target trabalho.

# Submit the circuit to run on Azure Quantum
job = apival_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Quando o trabalho tiver sido executado com êxito, obtenha os resultados do trabalho e exiba-os:

# Get the job results:
result = job.result()
print(result)

Result(backend_name='quantinuum.sim.h1-1sc', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='89511b08-9691-11ec-be32-00155d00ae89', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 100}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])

Como esse result tipo é um objeto nativo do pacote Qiskit, você pode usar o Qiskit result.get_counts e plot_histogram visualizar os resultados. Para certificar-se de que todos os rótulos de cadeia de bits possíveis estão representados, adicione-os ao counts.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 100, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

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 Verificador de Sintaxe 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.

Estimar o custo do trabalho

Antes de executar um trabalho em hardware quântico real, ou uma unidade de processamento quântico (QPU), você pode estimar quanto custará para ser executado.

Primeiro, obtenha a lista de provedores disponíveis novamente:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Em seguida, crie um objeto para representar o Quantinuum System Model H1:

qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")

Para estimar o custo de execução de um trabalho na QPU, adicione e execute uma nova célula usando o estimate_cost método do target:

cost = qpu_backend.estimate_cost(circuit, shots=100)

print(f"Estimated cost: {cost.estimated_total}")

Estimated cost: 5.72

A saída exibe o custo estimado em H-System Quantum Credits (HQCs).

Para obter os detalhes de preços mais atuais, consulte Preços do Azure Quantum ou exiba opções de preços na folha Provedores do seu espaço de trabalho. Para ver o seu estado de crédito atual e utilização, selecione Créditos e quotas.

Executar em um QPU Quantinuum

Depois de executar seu circuito com sucesso no Verificador de Sintaxe e estimar o custo da QPU, é hora de executá-lo no hardware.

Nota

O tempo necessário para executar um circuito 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.

Use o mesmo run método e operações que você usou anteriormente com o Verificador de sintaxe para enviar e monitorar seu trabalho:

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Quando o trabalho tiver sido executado com êxito, obtenha os resultados do trabalho como antes e exiba-os em um histograma:

result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Você pode ver que os resultados agora estão divididos aproximadamente entre 0 e 1.

Result(backend_name='quantinuum.qpu.h1-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='48282d18-9c15-11ec-bfbd-00155d6373ba', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'111': 53, '101': 1, '000': 46}, probabilities={'111': 0.53, '101': 0.01, '000': 0.46}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 46, '001': 0, '010': 0, '011': 0, '100': 0, '101': 1, '110': 0, '111': 53}

Rigetti

Para verificar seu código antes de executá-lo em hardware quântico real, você pode usar o simulador quântico Rigetti, rigetti.sim.qvm.

Adicione uma nova célula e crie um objeto para representar o simulador targetquântico Rigetti :

# Get Rigetti quantum simulator target:
simulator_backend = provider.get_backend("rigetti.sim.qvm")

Executar no simulador Rigetti

Para executar o seu circuito no simulador, adicione o seguinte código. Este exemplo usa o run método do para enviar seu trabalho e, em seguida, monitora o status do target trabalho.

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Quando o trabalho for executado com êxito, obtenha os resultados do trabalho e exiba-os:

# Get the job results:
result = job.result()
print(result)

Result(backend_name='rigetti.sim.qvm', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='5de5e2a0-39e3-11ed-bd56-00155d76e336', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'[0, 0, 0]': 54, '[1, 1, 1]': 46}, probabilities={'[0, 0, 0]': 0.59, '[1, 1, 1]': 0.41}), header=QobjExperimentHeader(metadata=None, name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])

Como esse result tipo é um objeto nativo do pacote Qiskit, você pode usar o Qiskit result.get_counts e plot_histogram visualizar os resultados. Para certificar-se de que todos os rótulos de cadeia de bits possíveis estão representados, adicione-os ao counts.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}

Executar em Rigetti QPU

Depois de executar seu circuito com sucesso no simulador Rigetti, é hora de executar seu circuito no hardware.

Nota

O tempo necessário para executar um circuito na QPU varia dependendo 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.

Primeiro, obtenha a lista de provedores disponíveis novamente:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Em seguida, crie um objeto para representar o computador quântico Rigetti:

qpu_backend = provider.get_backend("rigetti.qpu.ankaa-2")

Use o mesmo run método e operações que você usou anteriormente com o simulador quântico Rigetti para enviar e monitorar seu trabalho:

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

Quando o trabalho tiver sido executado com êxito, obtenha os resultados do trabalho como antes e exiba-os em um gráfico:

result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id cd4800f4-39e5-11ed-bd56-00155d76e336
Job Status: job has successfully run
Result(backend_name='rigetti.qpu.ankaa-2', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='cd4800f4-39e5-11ed-bd56-00155d76e336', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'[0, 0, 0]': 415.0, '[1, 1, 1]': 280.0, '[1, 1, 0]': 103.0, '[0, 1, 1]': 83.0, '[1, 0, 1]': 8.0, '[0, 1, 0]': 36.0, '[1, 0, 0]': 74.0, '[0, 0, 1]': 25.0}, probabilities={'[0, 0, 0]': 0.4052734375, '[1, 1, 1]': 0.2734375, '[1, 1, 0]': 0.1005859375, '[0, 1, 1]': 0.0810546875, '[1, 0, 1]': 0.0078125, '[0, 1, 0]': 0.03515625, '[1, 0, 0]': 0.072265625, '[0, 0, 1]': 0.0244140625}), header=QobjExperimentHeader(metadata=None, name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 0, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0, '[0, 0, 0]': 415.0, '[1, 1, 1]': 280.0, '[1, 1, 0]': 103.0, '[0, 1, 1]': 83.0, '[1, 0, 1]': 8.0, '[0, 1, 0]': 36.0, '[1, 0, 0]': 74.0, '[0, 0, 1]': 25.0}

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

Próximos passos

• Guia de início rápido: envie um circuito com o Cirq para o Azure Quantum.
• Guia de início rápido: envie um circuito com um formato específico do provedor para o Azure Quantum.