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

  • Artigo

O Avaliador de Recursos do Azure Quantum é criado no Quantum Intermediate Representation (QIR), uma especificação totalmente interoperável para programas quânticos. A QIR serve como uma interface comum entre linguagens e estruturas de programação quântica e targetplataformas de computação quântica ed. Como o Avaliador de Recursos usa um programa QIR como entrada, ele dá suporte a qualquer idioma 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 com base no bitcode qir
  • Criar um bitcode QIR usando o gerador PyQIR
  • Enviar um trabalho de QIR para o Avaliador de Recursos

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

Pré-requisitos

Criar um notebook em seu workspace

  1. Entre no portal do Azure e selecione seu workspace do Azure Quantum.
  2. Em Operações, selecione Notebooks
  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, qiskite pyqir. Você não usará o Qiskit para criar circuitos quânticos diretamente, mas usará AzureQuantumJob, que é criado com base no ecossistema do Qiskit. Verifique se você está 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 da QIR

O Avaliador de Recursos é um target do provedor de Computação Quântica da Microsoft. Usar o Avaliador de Recursos é exatamente o mesmo que enviar um trabalho em relação a outro provedor targets de 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 permitido
  • qecScheme – o esquema de correção de erros quânticos (QEC)
  • qubitParams – os parâmetros de qubit físico
  • constraints – As restrições no nível do componente

Para obter mais informações sobre os parâmetros de entrada, consulte Parâmetros de destino 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 ao bitcode 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 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 um bitcode QIR usando o gerador PyQIR. Este exemplo cria um portão S controlado usando três portões T e dois portões 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 que definiu acima junto com a bitcode() função de 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 Parâmetros de destino 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 com mais facilidade que a distância do código de correção de erro é 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 2us
Taxa de erro de qubit lógico 3.00E-5
Pré-refatoração de cruzamento 0.03
Limite de correção de erro 0,01
Fórmula de tempo do ciclo lógico (4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
Fórmula de qubits físicos 2 * 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 GateBased
Tempo de medição de qubit único 100 ns
Hora do portão T 50 ns
Taxa de erros do portão T 0,001
Taxa de erro de medição de qubit único 0,001
Hora do portão de qubit único 50 ns
Taxa de erro de qubit único 0,001
Hora do portão 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 para o 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.
  • As Katas Quânticas são tutoriais baseados em Jupyter Notebook e exercícios de programação baseados em Jupyter Notebook com o objetivo de ensinar os elementos da computação quântica e da programação Q# ao mesmo tempo.