Compartilhar via

Como depurar e testar seu código quântico

Testes e depuração são tão importantes na programação quântica quanto na programação clássica. Este artigo discute como depurar e testar seus programas quânticos com o QDK (Azure Quantum Development Kit ) no Visual Studio Code (VS Code) e no Jupyter Notebook.

Debugar seu código quântico

O QDK fornece várias ferramentas para depurar seu código. Se você escrever programas em Q# ou OpenQASM no VS Code, poderá usar o depurador do VS Code para definir pontos de interrupção em seus programas e analisar seu código. O QDK também fornece um conjunto de funções de despejo que você pode usar para obter informações em diferentes pontos em seu programa.

Como usar o depurador do VS Code

Com a extensão QDK no VS Code, você pode usar o depurador para percorrer seu código e em cada função ou operação, acompanhar os valores das variáveis locais e seguir os estados quânticos dos qubits.

O exemplo a seguir demonstra como usar o depurador com um Q# programa. Para obter informações completas sobre depuradores do VS Code, consulte Depuração no site do VS Code.

  1. No VS Code, crie e salve um novo .qs arquivo com o seguinte código:

    import Std.Arrays.*;
import Std.Convert.*;

operation Main() : Result {
    use qubit = Qubit();
    H(qubit);
    let result = M(qubit);
    Reset(qubit);
    return result;
}

  2. Na linha 6, H(qubit)clique à esquerda do número de linha para definir um ponto de interrupção. Um círculo vermelho é exibido.

  3. Na Barra Lateral Primária, escolha o ícone do depurador para abrir o painel do depurador e escolha Executar e Depurar. A barra de controle do depurador é exibida.

  4. Pressione F5 para iniciar o depurador e continuar até o ponto de interrupção. No menu Variáveis do painel de depurador, expanda a lista suspensa Estado Quântico para ver se o qubit foi inicializado no estado $\ket{0}$.

  5. Pressione F11 para entrar na H operação. O código-fonte da H operação é exibido. Observe que o Estado Quântico muda para uma superposição à medida que você percorre a H operação.

  6. Pressione F10 para avançar sobre a M operação. Observe que o Estado Quântico colapsa para $\ket{0}$ ou $\ket{1}$ após a medida. A result variável também aparece em Locais.

  7. Pressione F10 novamente para passar por a Reset operação. Observe que o Estado Quântico é redefinido para $\ket{0}$.

Quando terminar de explorar o depurador, pressione *Ctrl + F5 para sair do depurador.

Observação

O depurador do VS Code funciona apenas com Q# (.qs) e arquivos OpenQASM (.qasm). Você não pode usar o depurador do VS Code nas células Q# no Jupyter Notebook.

Como depurar com funções de despejo de memória do QDK

O QDK fornece várias funções Q# e Python que despejam informações sobre o estado atual do seu programa quando você chama essas funções. Use informações dessas funções de despejo para verificar se o programa se comporta conforme o esperado.

A Q#DumpMachine função

DumpMachine é uma Q# função que permite despejar informações sobre o estado atual do sistema qubit no console à medida que o programa é executado. DumpMachine não para ou interrompe o programa durante o tempo de execução.

O exemplo a seguir faz chamadas para DumpMachine em dois pontos de um programa Q# e analisa o resultado.

  1. No VS Code, crie e salve um novo .qs arquivo com o seguinte código:

    import Std.Diagnostics.*;

operation Main() : Unit {
    use qubits = Qubit[2];
    X(qubits[1]);
    H(qubits[1]);
    DumpMachine();

    R1Frac(1, 2, qubits[0]);
    R1Frac(1, 3, qubits[1]);
    DumpMachine();

    ResetAll(qubits);
}

  2. Pressione Ctrl + Shift + Y para abrir o Console de Depuração.

  3. Pressione Ctrl + F5 para executar seu programa. A seguinte saída de DumpMachine aparece no Console de Depuração:

    Basis | Amplitude      | Probability | Phase
-----------------------------------------------
 |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |01⟩ | −0.7071+0.0000𝑖 |    50.0000% |  -3.1416

Basis | Amplitude      | Probability | Phase
-----------------------------------------------
 |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |01⟩ | −0.6533−0.2706𝑖 |    50.0000% |  -2.7489

A saída de DumpMachine mostra como o estado dos sistemas de qubits muda após cada conjunto de portas.

Observação

A saída de DumpMachine usa a ordenação big-endian.

A função Python dump_machine

A dump_machine função é uma função do pacote python qsharp . Essa função retorna a contagem de qubits alocada atualmente e um dicionário que contém as amplitudes de estado esparsas do sistema qubit.

O exemplo a seguir executa o mesmo programa do exemplo anterior DumpMachine, mas em um notebook Jupyter em vez de um .qs arquivo.

  1. No VS Code, pressione Ctrl + Shift + P para abrir a Paleta de Comandos.

  2. Insira Criar: Novo Jupyter Notebook e pressione Enter. Uma nova aba do Jupyter Notebook é aberta.

  3. Na primeira célula, copie e execute o seguinte código:

    from qdk import qsharp

  4. Crie uma nova célula de código e copie e execute o seguinte Q# código:

    %%qsharp

use qubits = Qubit[2];
X(qubits[0]);
H(qubits[1]);

  5. Crie uma célula de código. Copie e execute o seguinte código Python para exibir o estado do qubit neste ponto do programa:

    dump = qsharp.dump_machine()
dump

    A dump_machine função exibe a seguinte saída:

    Basis State
(|𝜓₁…𝜓ₙ⟩)  Amplitude       Measurement Probability  Phase
|10⟩       0.7071+0.0000𝑖   50.0000%                 ↑  0.0000
|11⟩       0.7071+0.0000𝑖   50.0000%                 ↑  0.0000

  6. Crie uma nova célula de código e copie e execute o seguinte Q# código:

    %%qsharp

R1Frac(1, 2, qubits[0]);
R1Frac(1, 3, qubits[1]);

  7. Crie uma célula de código. Copie e execute o seguinte código Python para exibir o estado do qubit neste ponto do programa:

    dump = qsharp.dump_machine()
dump

    A dump_machine função exibe a seguinte saída:

    Basis State
(|𝜓₁…𝜓ₙ⟩)  Amplitude      Measurement Probability  Phase
|10⟩       0.5000+0.5000𝑖  50.0000%                 ↗  0.7854
|11⟩       0.2706+0.6533𝑖  50.0000%                 ↗  1.1781

  8. Para imprimir uma versão abreviada da dump_machine saída, crie uma nova célula e execute o seguinte código Python:

    print(dump)

  9. Para obter o número total de qubits no sistema, crie uma nova célula de código e execute o seguinte código Python:

    dump.qubit_count

  10. Você pode acessar as amplitudes de estados de qubits individuais que têm amplitude diferente de zero. Por exemplo, crie uma nova célula de código e execute o seguinte código Python para obter as amplitudes individuais para os estados $\ket{10}$ e $\ket{11}$:

    print(dump[2])
print(dump[3])

A função dump_operation

A dump_operation função é uma função do pacote python qsharp.utils . Essa função aceita duas entradas: uma Q# definição de operação ou operação como uma cadeia de caracteres e o número de qubits usados na operação. A saída de dump_operation é uma lista aninhada que representa a matriz quadrada de números complexos correspondente à operação quântica fornecida. Os valores de matriz estão na base computacional e cada sublist representa uma linha da matriz.

O exemplo a seguir usa dump_operation para exibir informações para um sistema de 1 qubit e 2 qubits.

  1. No VS Code, pressione Ctrl + Shift + P para abrir a Paleta de Comandos.

  2. Insira Criar: Novo Jupyter Notebook e pressione Enter. Uma nova aba do Jupyter Notebook é aberta.

  3. Na primeira célula, copie e execute o seguinte código:

    from qdk import qsharp
from qsharp.utils import dump_operation

  4. Para exibir os elementos de matriz de um portão de qubit único, chame dump_operation e passe 1 para o número de qubits. Por exemplo, copie e execute o seguinte código Python em uma nova célula de código para obter os elementos de matriz para um portão de identidade e um portão do Hadamard:

    res = dump_operation("qs => ()", 1)
print("Single-qubit identity gate:\n", res)
print()

res = dump_operation("qs => H(qs[0])", 1)
print("Single-qubit Hadamard gate:\n", res)

  5. Você também pode chamar a função qsharp.eval e referenciar a operação Q# no dump_operation para obter o mesmo resultado. Por exemplo, crie uma nova célula de código e, em seguida, copie e execute o seguinte código Python para imprimir os elementos de matriz para um portão Hadamard de qubit único:

    qsharp.eval("operation SingleH(qs : Qubit[]) : Unit { H(qs[0]) }")

res = dump_operation("SingleH", 1)
print("Single-qubit Hadamard gate:\n", res)

  6. Para exibir os elementos de matriz de um portão de dois qubits, chame dump_operation e passe 2 para o número de qubits. Por exemplo, copie e execute o seguinte código Python em uma nova célula de código para obter os elementos de matriz para uma operação Ry Controlada em que o segundo qubit é o target qubit:

    qsharp.eval ("operation ControlRy(qs : Qubit[]) : Unit { Controlled Ry([qs[0]], (0.5, qs[1])); }")

res = dump_operation("ControlRy", 2)
print("Controlled Ry rotation gate:\n", res)

Para obter mais exemplos de como testar e depurar seu código, dump_operationconsulte Operações de teste dos exemplos do QDK.

Testar seu código quântico

O QDK fornece várias Q# funções e operações que você pode usar para testar seu código conforme ele é executado. Você também pode escrever testes de unidade para Q# programas.

A expressão fail

A fail expressão termina imediatamente seu programa. Para incorporar testes em seu código, use expressões fail dentro de instruções condicionais.

O exemplo a seguir usa uma fail instrução para testar se uma matriz de qubit contém exatamente 3 qubits. O programa termina com uma mensagem de erro quando o teste não é aprovado.

  1. No VS Code, crie e salve um novo .qs arquivo com o seguinte código:

    operation Main() : Unit {
    use qs = Qubit[6];
    let n_qubits = Length(qs);

    if n_qubits != 3 {
        fail $"The system should have 3 qubits, not {n_qubits}.";
    }  
}

  2. Pressione Ctrl + F5 para executar o programa. O programa falha e a seguinte saída aparece no Console de Depuração:

    Error: program failed: The system should have 3 qubits, not 6.

  3. Edite seu código de Qubit[6] para Qubit[3], salve o arquivo e pressione Ctrl + F5 para executar o programa novamente. O programa é executado sem um erro porque o teste é aprovado.

A função Fact

Você também pode usar a Q#Fact função no Std.Diagnostics namespace para testar seu código. A Fact função usa uma expressão booliana e uma cadeia de caracteres de mensagem de erro en. Se a expressão booliana for verdadeira, o teste será aprovado e seu programa continuará sendo executado. Se a expressão booliana for falsa, encerre Fact o programa e exiba a mensagem de erro.

Para executar o mesmo teste de comprimento de matriz no código anterior, mas com a função Fact, siga estas etapas:

  1. No VS Code, crie e salve um novo .qs arquivo com o seguinte código:

    import Std.Diagnostics.Fact;

operation Main() : Unit {
    use qs = Qubit[6];
    let n_qubits = Length(qs);

    Fact(n_qubits == 3,  $"The system should have 3 qubits, not {n_qubits}.")
}

  2. Pressione Ctrl + F5 para executar o programa. A condição de teste em Fact não é satisfeita e a mensagem de erro aparece no Console de Depuração.

  3. Edite seu código de Qubit[6] para Qubit[3], salve o arquivo e pressione Ctrl + F5 para executar o programa novamente. A condição de teste em Fact passa e seu programa é executado sem erros.

Escrever Q# testes de unidade com a @Test() anotação

Em Q# programas, você pode aplicar a anotação @Test() a uma função ou operação para transformar essa função ou operação em um teste de unidade. Esses testes de unidades aparecem no menu Teste no VS Code para que você possa aproveitar esse recurso do VS Code. Você pode transformar um callable em um teste de unidade somente quando o callable não usa parâmetros de entrada.

O exemplo a seguir encapsula o código de teste de comprimento da matriz em uma operação e transforma essa operação em um teste de unidade:

  1. No VS Code, crie e salve um novo .qs arquivo com o seguinte código:

    import Std.Diagnostics.Fact;

@Test()
operation TestCase() : Unit {
    use qs = Qubit[3];
    let n_qubits = Length(qs);

    Fact(n_qubits == 3, $"The system should have 3 qubits, not {n_qubits}.");
}

    A anotação @Test() na linha antes da definição da operação TestCase transforma a operação em um teste de unidade do VS Code. Uma seta verde aparece na linha de definição da operação.

  2. Escolha a seta verde para executar TestCase e relatar os resultados do teste.

  3. Para interagir com os testes de unidade no Gerenciador de Testes do VS Code, escolha o ícone Testing na Barra Lateral Primária.

  4. Edite seu código de Qubit[3] para Qubit[6] e execute o teste de unidade novamente para ver como as informações do teste mudam.

Você pode escrever e executar Q# testes de unidade no VS Code sem uma operação de ponto de entrada em seu programa.

Observação

Os callables do namespace não são compatíveis com a Std.Diagnostics geração de QIR, portanto, inclua somente testes de unidade no Q# código executado em simuladores. Se você quiser gerar QIR do código Q# , não inclua testes de unidade em seu código.

As operações CheckZero e CheckAllZero

A operação CheckZero e a operação CheckAllZeroQ# verificam se o estado atual de um qubit ou de uma matriz de qubits é $\ket{0}$. A CheckZero operação usa um único qubit e retorna true somente quando o qubit está no estado $\ket{0}$. As CheckAllZero operações pegam uma matriz de qubits e retornam true somente quando todos os qubits na matriz estiverem no estado $\ket{0}$. Para usá-los, CheckZero e CheckAllZero, importá-los do namespace Std.Diagnostics.

O exemplo a seguir usa ambas as operações. Os testes de `CheckZero` verificam se a operação `X` inverte o primeiro qubit do estado $\ket{0}$ para o estado $\ket{1}$, e a operação `CheckAllZero` verifica se ambos os qubits são redefinidos para o estado $\ket{0}$.

No VS Code, crie e salve um novo .qs arquivo com o código a seguir, execute o programa e examine a saída no Console de Depuração.

import Std.Diagnostics.*;

operation Main() : Unit {
    use qs = Qubit[2];
    X(qs[0]); 

    if CheckZero(qs[0]) {
        Message("X operation failed");
    }
    else {
        Message("X operation succeeded");
    }

    ResetAll(qs);

    if CheckAllZero(qs) {
        Message("Reset operation succeeded");
    }
    else {
        Message("Reset operation failed");
    }
}
  • Last updated on