Desenvolver programas OpenQASM no Microsoft Quantum Development Kit

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

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

Ferramentas para desenvolvedores como CodeLends, IntelliSense, conclusão de código e depuração de ponto de interrupção estão disponíveis apenas na extensão do VS Code. Outros recursos estão disponíveis apenas no pacote Python. Por exemplo, você pode passar chamáveis Q# e OpenQASM como objetos Python e compilar programas OpenQASM que levam entradas para o QIR.

Pré-requisitos

  • Instalar a versão mais recente do VS Code

  • Para trabalhar diretamente com arquivos OpenQASM, instale a versão mais recente da extensão do QDK no VS Code.

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

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

    pip install --upgrade "qdk[jupyter]"

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

Para escrever código OpenQASM no VS Code, abra um projeto Q# e crie um arquivo OpenQASM com uma extensão do .qasm. O QDK reconhece automaticamente o arquivo .qasm como OpenQASM, e, enquanto você escreve seu código, os recursos para QDKOpenQASM estão disponíveis.

Os seguintes recursos QDK estão disponíveis para programas OpenQASM no VS Code:

  • Preenchimento 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 ao verificar arquivos OpenQASM de origem
  • Depuração de ponto de interrupção e execução de script para arquivos de origem do OpenQASM
  • Depuração com geração de circuito em tempo real
  • Integração com Azure Quantum para envio de trabalho quântico

Para executar seu programa OpenQASM de VS Code, você pode usar o simulador local do QDK ou enviar o código como um trabalho para Azure Quantum.

Executar seu código no QDK simulador local

Para executar seu código OpenQASM no simulador quântico esparso local em VS Code, abra um arquivo .qasm e, em seguida, selecione o comando Executar no CodeLens no início do arquivo. A saída do programa é exibida no VS Code terminal.

Observação

O QDK tenta automaticamente definir um perfil QIR target que dê suporte ao seu programa. Se o perfil QIR target não der suporte a operações em seu programa, você receberá erros do compilador ao executar seu OpenQASM código. Para obter mais informações sobre perfis target, consulte Diferentes tipos de perfis target em Azure Quantum.

Programas de exemplo integrados

QDK vem com vários exemplos de algoritmos quânticos integrados para OpenQASM. Para experimentar os algoritmos de exemplo, insira sample em um arquivo .qasm vazio. Uma lista de conclusão é exibida que contém os algoritmos de exemplo. Escolha um exemplo e execute o código gerado.

Depurar localmente em VS Code

QDK inclui um depurador para OpenQASM. O depurador dá suporte à depuração de ponto de interrupção e pode renderizar o estado do programa.

Para iniciar o depurador, selecione o comando Depurar na 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 programa é exibido no painel EXECUTAR E DEPURAR . Por exemplo, você pode exibir seus estados de variável local e estados qubit.

Execute seu código em Azure Quantum

Para executar programas OpenQASM em Azure Quantumtargets, você precisa ter um espaço de trabalho Azure Quantum. Para criar um Azure Quantum workspace, consulte Criar um Azure Quantum workspace.

Para enviar tarefas OpenQASM para Azure Quantum de VS Code, você precisa se conectar ao seu espaço de trabalho Azure Quantum. Para se conectar ao seu espaço de trabalho a partir de VS Code, veja Conectar com uma cadeia de conexão.

Para enviar um OpenQASM job para Azure Quantum a partir de VS Code, siga estas etapas:

  1. Abra o arquivo qasm que contém seu programa em VS Code.
  2. Selecione o ícone Microsoft Quantum para abrir o painel Microsoft Quantum.
  3. Expanda o menu suspenso WORKSPACES DO QUANTUM e selecione seu workspace.
  4. Expanda o menu suspenso Provedores e escolha um provedor, em seguida, escolha o target no qual você deseja executar seu trabalho. Por exemplo, envie sua tarefa ao rigetti.svm.simtarget para executar seu programa no simulador de backend da Rigetti. Para obter mais informações sobre provedor e target disponibilidade, consulte Adicionar ou remover um provedor em um workspace existente.
  5. Selecione o ícone de reprodução ao lado do nome de target.
  6. Para enviar o trabalho, insira valores para o prompt Nome do trabalho e o prompt Número de tentativas.

Para exibir os horários e o status de um trabalho, expanda a lista suspensa Trabalhos e passe o mouse sobre o nome do trabalho. Para baixar os resultados do trabalho, selecione os ícones de histograma ou texto ao lado do nome do trabalho.

Trabalhar com OpenQASM em Python e Jupyter Notebook

Com o QDK pacote Python, você pode executar OpenQASM o código diretamente e passar OpenQASM circuitos como operações para programas Q#. Escreva seu código OpenQASM como uma cadeia de caracteres Python e use essa cadeia de caracteres para executar, importar ou compilar seu código OpenQASM no ambiente Python.

Executar OpenQASM diretamente no Python

Para executar código OpenQASM diretamente, use a função run do módulo qdk.openqasm. Por exemplo, o código a seguir executa 10 tentativas no simulador local de um programa OpenQASM simples 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)

Chamar um OpenQASM programa em Q#

Você pode usar a função import_openqasm para armazenar um programa OpenQASM como um objeto Python e, em seguida, chamar esse objeto mais tarde em seu código Python. Por exemplo, a célula a seguir armazena um circuito OpenQASM em um 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, você pode executá-lo diretamente de uma célula Q#:

%%qsharp

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

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

Programas OpenQASM parametrizados

A célula a seguir cria um circuito OpenQASM que usa um ângulo theta como entrada e, em seguida, 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 o Q#

Com o QDK pacote Python, você pode passar diretamente um OpenQASM programa para um programa Q#. Por exemplo, o código a seguir cria um OpenQASM programa chamado Entangle e, em seguida, usa Entangle como uma operação em um 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 você importa programas Q# e OpenQASM em um ambiente Python usando qsharp.eval e import_openqasm, esses programas se tornam objetos Python que podem ser chamados em seu código Python. Por exemplo, o código a seguir 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 programas OpenQASM para QIR

Você pode compilar o código OpenQASM em Representação Intermediária Quântica (QIR) com a função compile.

Por exemplo, a célula a seguir compila o código OpenQASM para um circuito parametrizado no 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 levam variáveis de entrada para QIR, você precisa usar o QDK pacote Python. Você não pode compilar programas parametrizados OpenQASM no QIR usando a extensão QDK no VS Code.

Enviar OpenQASM programas para Azure Quantum

Para enviar um programa OpenQASM para ser executado em um Azure Quantumtarget, compile o código OpenQASM em QIR e depois envie o QIR para ser executado em Azure Quantum.

Por exemplo, compile um circuito de emaranhamento simples no 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 em Azure Quantum, conecte-se ao seu espaço de trabalho quântico e submeta o trabalho para um dos targets disponíveis no seu espaço de trabalho. Por exemplo, envie o QIR de emaranhamento para execução no simulador de back-end 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 no QDK

O suporte para OpenQASM no QDK está em andamento.

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

  • Last updated on