Compartilhar via

Tutorial: Enviar um programa QIR para o Avaliador de Recursos do Azure Quantum

  • Artigo

O Avaliador de Recursos do Azure Quantum é baseado em Quantum Intermediate Representation (QIR), uma especificação totalmente interoperável para programas quânticos. O QIR serve como uma interface comum entre linguagens e estruturas de programação quântica e plataformas de computação quântica direcionadas. Como o Avaliador de Recursos usa um programa QIR como entrada, ele dá suporte a qualquer linguagem que se traduza em QIR. Por exemplo, ele pode ser usado por SDKs quânticos populares e linguagens como Q# e Qiskit. Neste tutorial, você escreverá e enviará um programa QIR para o Avaliador de Recursos. Este tutorial usa o PyQIR para gerar QIR, no entanto, você pode usar qualquer outra fonte de QIR.

Neste tutorial, você aprenderá como:

  • Conecte-se ao serviço do Azure Quantum.
  • Definir uma função para criar um trabalho de estimativa de recursos a partir do bitcode QIR
  • Crie um bitcode QIR usando o gerador PyQIR
  • Enviar um trabalho QIR para o Avaliador de Recursos

Inscreva-se para uma assinatura de avaliação gratuita do Azure por 30 dias.

Pré-requisitos

  • Uma conta do Azure com uma assinatura ativa. Se você não tiver uma conta do Azure, registre-se gratuitamente e inscreva-se para uma assinatura paga conforme o uso.
  • Um workspace do Azure Quantum. Para obter mais informações, confira Criar um workspace do Azure Quantum.
  • O provedor de Computação Quântica da Microsoft adicionado ao seu workspace.

Criar um notebook em seu workspace

  1. Entre no portal do Azure e selecione seu workspace do Azure Quantum.
  2. Em Operações, selecione Blocos de Anotações
  3. Clique em Meus blocos de anotações e clique em Adicionar Novo
  4. Em Tipo de Kernel, selecione IPython.
  5. Digite um nome para o arquivo e clique em Criar arquivo.

Quando o novo notebook é aberto, ele cria automaticamente o código da primeira célula com base na assinatura e nas informações do workspace.

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

Observação

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

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

Carregar as importações necessárias

Primeiro, você precisa importar algumas classes e funções do Python de azure.quantum, qiskit, e pyqir. Você não usará o Qiskit para construir circuitos quânticos diretamente, mas usará AzureQuantumJobo , que é construído sobre o ecossistema Qiskit. Certifique-se de estar usando a versão mais recente do Qiskit. Para obter mais informações, consulte Atualizar o pacote Python azure-quantum.

from azure.quantum.qiskit import AzureQuantumProvider
from azure.quantum.qiskit.job import AzureQuantumJob
from pyqir.generator import BasicQisBuilder, SimpleModule

Conectar ao serviço do Azure Quantum

Em seguida, crie um AzureQuantumProvider objeto usando o workspace objeto da célula anterior para se conectar ao workspace do Azure Quantum.

provider = AzureQuantumProvider(workspace)

Definir uma função para criar um trabalho de estimativa de recursos a partir do QIR

O Avaliador de Recursos é um target provedor de Computação Quântica da Microsoft. Usar o Avaliador de Recursos é exatamente o mesmo que enviar um trabalho em outro provedor de targets software e hardware no Azure Quantum – defina seu programa, defina um targete envie seu trabalho para computação.

Ao enviar uma solicitação de estimativa de recursos para seu programa, você pode especificar alguns target parâmetros.

  • errorBudget - o orçamento geral de erros permitidos
  • qecScheme - o esquema de correção de erro quântico (QEC)
  • qubitParams - os parâmetros físicos do qubit
  • constraints – As restrições no nível do componente

Para obter mais informações sobre os parâmetros de entrada, consulte Target parâmetros do Avaliador de Recursos.

Para este exemplo, você implementará uma função genérica que usa como entrada o provider objeto que se conecta ao workspace do Azure Quantum e o código de bits QIR do programa quântico. Ele retorna como resultado um trabalho do Azure Quantum. Os parâmetros do Avaliador target de Recursos podem ser passados por meio de argumentos de palavra-chave para a função.

def resource_estimation_job_from_qir(provider: AzureQuantumProvider, bitcode: bytes, **kwargs):
    """A generic function to create a resource estimation job from QIR bitcode"""

    # Find the Resource Estimator target from the provider
    backend = provider.get_backend('microsoft.estimator')

    # You can provide a name for the job via keyword arguments; if not,
    # use QIR job as a default name
    name = kwargs.pop("name", "QIR job")

    # Wxtract some job specific arguments from the backend's configuration
    config = backend.configuration()
    blob_name = config.azure["blob_name"]
    content_type = config.azure["content_type"]
    provider_id = config.azure["provider_id"]
    output_data_format = config.azure["output_data_format"]

    # Finally, create the Azure Quantum jon object and return it
    return AzureQuantumJob(
        backend=backend,
        target=backend.name(),
        name=name,
        input_data=bitcode,
        blob_name=blob_name,
        content_type=content_type,
        provider_id=provider_id,
        input_data_format="qir.v1",
        output_data_format=output_data_format,
        input_params = kwargs,
        metadata={}
    )

Executar um programa quântico de exemplo

Em seguida, crie algum código de bits QIR usando o gerador PyQIR. Este exemplo cria uma porta S controlada usando três portas T e duas portas CNOT.

module = SimpleModule("Controlled S", num_qubits=2, num_results=0)
qis = BasicQisBuilder(module.builder)

[a, b] = module.qubits[0:2]
qis.t(a)
qis.t(b)
qis.cx(a, b)
qis.t_adj(b)
qis.cx(a, b)

Você pode usar a função definida acima junto com a bitcode() função do PyQIR para gerar um trabalho de estimativa de recursos. Você também pode passar argumentos específicos do Avaliador de Recursos. Este exemplo usa errorBudget para definir a taxa de erro como 5%. Para obter mais informações sobre os target parâmetros, consulte Target parâmetros do Avaliador de Recursos.

job = resource_estimation_job_from_qir(provider, module.bitcode(), errorBudget=0.05)
result = job.result()
result

Essa função cria uma tabela que mostra as contagens gerais de recursos físicos. Você pode inspecionar ainda mais os detalhes de custo recolhendo os grupos que têm mais informações. Por exemplo, se você recolher o grupo Parâmetros de qubit lógico, poderá ver mais facilmente que a distância do código de correção de erros é 15.

Parâmetro de qubit lógico Valor
Esquema de QEC surface_code
Distância de código 5
Qubits físicos 50
Tempo de ciclo lógico 2nós
Taxa de erro de qubit lógico 3.00E-5
Cruzamento de pré-fatores 0.03
Limite de correção de erro 0,01
Fórmula do tempo de ciclo lógico (4 x twoQubitGateTime + 2 x oneQubitMeasurementTime) x codeDistance
Fórmula de qubits físicos 2 x codeDistance * codeDistance

No grupo de Parâmetros de qubit físico, é possível ver as propriedades de qubit físicos que foram assumidas para essa avaliação. Por exemplo, o tempo para realizar uma medição de qubit único e uma porta de qubit único é considerado 100 ns e 50 ns, respectivamente.

Parâmetro de qubit físico Valor
Nome do qubit qubit_gate_ns_e3
Conjunto de instruções Baseado em portão
Tempo de medição de qubit único 100 ns
Tempo de porta T 50 ns
Taxa de erro da porta T 0,001
Taxa de erro de medição de qubit único 0,001
Tempo de porta de qubit único 50 ns
Taxa de erro de qubit único 0,001
Tempo de porta de dois qubits 50 ns
Taxa de erro de dois qubits 0,001

Para obter mais informações, consulte a lista completa de dados de saída do Avaliador de Recursos.

Conteúdo relacionado

Continue a explorar outros algoritmos e técnicas quânticos:

  • O tutorial Implementar o algoritmo de pesquisa de Grover mostra como escrever um programa Q# que usa o algoritmo de pesquisa de Grover para resolver um problema de coloração de grafo.
  • O tutorial Explorar o emaranhamento quântico com Q# mostra como operar em qubits com Q# para alterar seu estado e demonstra os efeitos da superposição e do emaranhamento.
  • Os Katas Quânticos são tutoriais individualizados baseados no Jupyter Notebook e exercícios de programação destinados a ensinar os elementos da computação quântica e da programação Q# ao mesmo tempo.