Desenvolver programas OpenQASM no Microsoft Quantum Development Kit

O Microsoft Quantum Development Kit (QDK) fornece diferentes ambientes de desenvolvimento para programas OpenQASM com integração Azure Quantum. Neste artigo, aprende a desenvolver e executar OpenQASM código em:

  • A extensão QDK em Visual Studio Code (VS Code)
  • O QDK pacote Python no Jupyter Notebook.

Ferramentas de desenvolvimento como CodeLends, IntelliSense, depuração por ponto de interrupção e completação automática de código estão disponíveis apenas na extensão VS Code. Outras funcionalidades estão disponíveis apenas no pacote Python. Por exemplo, podes passar Q# e OpenQASM chamáveis como objetos Python, e compilar OpenQASM programas que recebem entradas para QIR.

Pré-requisitos

  • Instale a versão mais recente do VS Code

  • Para trabalhar com ficheiros diretamente, instale a extensão mais recente em .

  • Para trabalhar com OpenQASM em Python e Jupyter Notebook, instale a versão mais recente da extensão Python e a extensão Jupyter em VS Code.

  • Instale a versão mais recente do pacote Python qdk com o extra jupyter:

    pip install --upgrade "qdk[jupyter]"

Trabalhar com OpenQASM no VS Code usando a extensão QDK

Para escrever OpenQASM código em VS Code, abra um projeto Q# e crie um OpenQASM ficheiro com uma .qasm extensão. O QDK reconhece automaticamente o ficheiro .qasm como OpenQASM, e as funcionalidades QDK para OpenQASM estão disponíveis à medida que escrever o código.

As seguintes QDK funcionalidades estão disponíveis para os programas OpenQASM em VS Code:

  • Conclusão de código
  • Lentes de código (Executar, Histograma, Estimar, Depurar e Circuito)
  • Realce de sintaxe e recursos básicos de sintaxe, como pareamento de chaves
  • Erro de verificação em OpenQASM ficheiros de origem
  • Depuração de ponto de interrupção e execução de scripts para OpenQASM arquivos de origem
  • Depuração com geração de circuito em tempo real
  • Integração com Azure Quantum para submissão de tarefas quânticas

Para correr o teu programa OpenQASM a partir de VS Code, podes usar o simulador local do QDK ou podes submeter o código como trabalho para Azure Quantum.

Executa o teu código no QDK simulador local

Para executar o código OpenQASM no simulador quântico esparso local em VS Code, abra um ficheiro .qasm e, em seguida, selecione a opção Run na CodeLens no início desse ficheiro. A saída do teu programa é exibida no VS Code terminal.

Observação

O QDK tenta automaticamente definir um perfil QIR target que seja compatível com o seu programa. Se o perfil QIR target não suportar operações no seu programa, obterá erros de compilação quando executar o seu código OpenQASM. Para mais informações sobre perfis target, consulte Diferentes tipos de perfis target em Azure Quantum.

Programas de exemplo integrados

O QDK vem com várias amostras de algoritmo quântico incorporado para OpenQASM. Para experimentar os algoritmos de exemplo, insira sample num ficheiro vazio .qasm. É apresentada uma lista de conclusão que contém os algoritmos de exemplo. Escolha um exemplo e, em seguida, execute o código gerado.

Depurar localmente em VS Code

O QDK inclui um depurador para OpenQASM. O depurador suporta depuração ao estilo breakpoint e pode renderizar o estado do programa.

Para iniciar o depurador, selecione o comando Debug da lente de código.

No modo de depuração, você pode definir pontos de interrupção em seu código para ajudá-lo a depurar. O estado do seu programa é mostrado no painel RUN AND DEBUG . Por exemplo, você pode exibir seus estados variáveis locais e estados qubit.

Executa o teu código em Azure Quantum

Para executar programas OpenQASM em Azure Quantumtargets, é necessário ter um espaço de trabalho Azure Quantum. Para criar um Azure Quantum espaço de trabalho, veja Criar um Azure Quantum espaço de trabalho.

Para submeter OpenQASM tarefas de Azure Quantum para VS Code, tem de se ligar à sua Azure Quantum área de trabalho. Para estabelecer ligação ao seu espaço de trabalho a partir de VS Code, veja Estabelecer ligação com uma cadeia de ligação.

Para submeter um OpenQASM trabalho a Azure Quantum partir de VS Code, siga estes passos:

  1. Abra o ficheiro qasm que contém o seu programa em VS Code.
  2. Selecione o ícone da Microsoft Quantum para abrir o painel da Microsoft Quantum.
  3. Expanda a lista pendente QUANTUM WORKSPACES e selecione o seu espaço de trabalho.
  4. Expanda a lista pendente Fornecedores e escolha um fornecedor; em seguida, escolha o target no qual pretende executar a sua tarefa. Por exemplo, submeta a sua tarefa para o/a rigetti.svm.simtarget executar o seu programa no simulador do backend da Rigetti. Para mais informações sobre o fornecedor e target disponibilidade, consulte Adicionar ou remover um fornecedor num espaço de trabalho existente.
  5. Selecione o ícone de jogo ao lado do target nome.
  6. Para submeter o trabalho, introduza valores nos campos Nome do trabalho e Número de shots.

Para ver as horas e o estado de uma tarefa, expanda o menu pendente Tarefas e passe o rato sobre o nome da tarefa. Para descarregar os resultados do trabalho, selecione o histograma ou os ícones de texto ao lado do nome do trabalho.

Trabalhe com OpenQASM em Python e Jupyter Notebook

Com o pacote Python QDK, pode executar código OpenQASM diretamente e passar circuitos OpenQASM como operações a programas em Q#. Escreve o teu código OpenQASM como uma string Python e depois usa essa string para executar, importar ou compilar o teu código OpenQASM no ambiente Python.

Executa OpenQASM diretamente no Python

Para executar OpenQASM código diretamente, use a run função do qdk.openqasm módulo. Por exemplo, o seguinte código executa 10 execuções no simulador local de um programa simples OpenQASM com ruído.

from qdk import BitFlipNoise
from qdk.openqasm import run

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

results = run(qasm_code, shots=10, noise=BitFlipNoise(0.1))
print(results)

Chame um programa OpenQASM em Q#

Podes usar a função import_openqasm para armazenar um programa OpenQASM como um objeto Python e depois chamar esse objeto mais tarde no teu código Python. Por exemplo, a célula seguinte armazena um circuito OpenQASM num objeto Python chamado bell:

from qdk import qsharp
from qdk.openqasm import import_openqasm

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

import_openqasm(qasm_code, name="bell")

Quando bell faz parte do seu ambiente, pode executá-lo diretamente a partir de uma célula Q#:

%%qsharp

use qs = Qubit[2];
bell(qs)

Também pode usar a funcionalidade do pacote QDK com bell, como simulação com ruído, renderização de circuitos e geração de código.

Programas parametrizados OpenQASM

A célula seguinte cria um circuito OpenQASM que recebe um ângulo theta como entrada, e depois chama o circuito como uma função Python:

from qdk.openqasm import import_openqasm, ProgramType

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qdk.code.qasm_import import parameterized_circuit

parameterized_circuit(1.57)

Passar um programa OpenQASM para Q#

Com o QDK pacote Python, podes passar diretamente um OpenQASM programa para um programa Q#. Por exemplo, o seguinte código cria um OpenQASM programa chamado Entangle e depois é usado Entangle como operação num programa Q#:

from qdk.openqasm import import_openqasm
from qdk import qsharp

qasm_code = """
    include "stdgates.inc";
    qubit[2] qs;
    h qs[0];
    cx qs[0], qs[1];
    """

import_openqasm(qasm_code, name="Entangle")

qsharp.eval("{ use qs = Qubit[2]; Entangle(qs); MResetEachZ(qs) }")

Quando se importa Q# e programas OpenQASM num ambiente Python com qsharp.eval e import_openqasm, estes programas tornam-se objetos Python que pode chamar no seu código Python. Por exemplo, o seguinte código cria um programa Q# chamado TestAntiCorrelation e passa o EntangleOpenQASM programa para TestAntiCorrelation:

qsharp.eval("""
    operation TestAntiCorrelation(entangler : Qubit[] => Unit) : Result[] {
        use qs = Qubit[2];
        X(qs[1]);
        entangler(qs);
        MResetEachZ(qs)
    }
    """)

from qdk.code import Entangle, TestAntiCorrelation

TestAntiCorrelation(Entangle)

Compilar OpenQASM programas em QIR

Você pode compilar o código OpenQASM para Quantum Intermediate Representation (QIR) utilizando a função compile.

Por exemplo, a célula a seguir compila o OpenQASM código de um circuito parametrizado em QIR:

from qdk import TargetProfile
from qdk.openqasm import import_openqasm, ProgramType
from qdk import qsharp

qsharp.init(target_profile=TargetProfile.Base)

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qdk.code.qasm_import import parameterized_circuit

bound_compilation = qsharp.compile(parameterized_circuit, 1.57)
print(bound_compilation)

Observação

Para compilar OpenQASM programas que aceitam variáveis de entrada para QIR, precisas de usar o QDK pacote Python. Não se pode compilar programas parametrizados OpenQASM para QIR com a extensão QDK em VS Code.

Enviar OpenQASM programas para Azure Quantum

Para submeter um programa OpenQASM para ser executado num Azure Quantumtarget, compile o código OpenQASM em QIR e, em seguida, submeta o QIR para execução em Azure Quantum.

Por exemplo, compile um circuito simples de emaranhamento em QIR.

from qdk.openqasm import compile

qasm_code = """
    include "stdgates.inc";
    bit[2] c;
    qubit[2] q;
    h q[0];
    cx q[0], q[1];
    c = measure q;
"""

qir_compilation = compile(qasm_code)

Para executar um trabalho QIR para Azure Quantum, ligue-se ao seu espaço de trabalho quântico e submeta o trabalho a um dos targets disponíveis no seu espaço de trabalho. Por exemplo, submeta o QIR de emaranhamento para executar no simulador do backend da IonQ.

from qdk.azure import Workspace 

workspace = Workspace(resource_id="") # Add the resource ID of your workspace

target = workspace.get_targets('ionq.simulator')
job = target.submit(qir_compilation, shots=100)

print("Job submitted. Waiting for results...")

results = job.get_results()
print(results)

Desenvolvimento contínuo OpenQASM na QDK

O apoio para OpenQASM no QDK está em curso.

Para uma lista de funcionalidades OpenQASM que estão em desenvolvimento no QDK, veja Limitações e problemas conhecidos na wiki do repositório QDK GitHub.

  • Last updated on