Como instalar e executar os QDK simuladores quânticos

O Microsoft Quantum Development Kit (QDK) inclui um conjunto de simuladores quânticos aos quais pode aceder a partir da extensão Visual Studio Code (VS Code) e da biblioteca QDKPython. Estes simuladores permitem-lhe testar como os seus programas quânticos correm em hardware quântico real. Este artigo explica como instalar os simuladores e como executar simulações básicas em Jupyter Notebook e VS Code.

Inclui QDK quatro simuladores quânticos:

• Simulador esparso
• Simulador Clifford
• Simulador de GPU
• Simulador de CPU

Para mais informações sobre os QDK simuladores quânticos, veja Visão Geral dos simuladores quânticos no QDK.

Pré-requisitos

Para seguir os passos deste artigo, precisa de instalar as seguintes ferramentas:

• Um ambiente Python (versão 3.10 ou superior), com Python e Pip
• A versão mais recente de Visual Studio Code (VS Code)
• As versões mais recentes da Python extensão e da Jupyter extensão em VS Code

Instalar os simuladores

Os quatro simuladores estão disponíveis na biblioteca QDKPython, mas apenas o simulador esparso está disponível na extensão QDKVS Code.

Para usar o simulador esparso na extensão VS Code, instale a extensão QDK para VS Code.

Para usar os simuladores quânticos em Python e Jupyter Notebook, instale a versão mais recente da biblioteca qdkPython com o extra jupyter:

pip install --upgrade "qdk[jupyter]"

O jupyter extra não é necessário para usar os simuladores, mas instala o qdk.widgets módulo. O módulo widgets permite-lhe criar visualizações a partir dos seus resultados de simulação em Jupyter Notebook.

Executar simulações usando a QDK extensão para VS Code

A extensão QDK para VS Code disponibiliza apenas o simulador esparso. Para executar o seu programa no simulador esparso em VS Code, abra um programa Q# (.qs) ou OpenQASM (.qasm) em VS Code e execute o ficheiro.

Por exemplo, siga estes passos para executar um dos programas de exemplo Q# que vêm com a QDK extensão:

1. Em VS Code, abra o menu Ficheiro e selecione Novo Ficheiro de Texto.
2. Dá ao ficheiro um nome que termine com a .qs extensão.
3. No ficheiro vazio, introduza a amostra. Abre-se uma lista de exemplos de código incluídos.
4. Escolha um exemplo de código, por exemplo exemplo Bell Pair.
5. Para executar o programa no simulador esparso, selecione o comando Run na CodeLens acima da operação Main.

O VS Code terminal mostra a saída da simulação.

Executa simulações usando a biblioteca QDKPython

A biblioteca QDKPython oferece os quatro simuladores. Como chamar os simuladores depende do simulador e do quadro de programação quântica.

Chame o simulador esparso

Pode invocar o simulador esparso para programas Q#, OpenQASM e Qiskit. A tabela seguinte mostra como chamar o simulador esparso a partir da biblioteca qdk para 10 execuções em cada framework de programação quântica suportado.

Por exemplo, siga estes passos para executar o programa Bell pair Q# num Jupyter caderno em VS Code:

1. Em VS Code, abra o menu Visualizar e selecione Paleta de Comandos.

2. Inserir Criar: Novo Jupyter Notebook. Um ficheiro vazio do caderno abre numa nova aba.

3. Na primeira célula, importa o qsharp módulo da qdk biblioteca.

   from qdk import qsharp
   

4. Numa célula nova, usa o %%qsharp comando mágico para escrever o código Q#.

   %%qsharp
   
   operation Main() : (Result, Result) {
       use (q1, q2) = (Qubit(), Qubit());
       PrepareBellPair(q1, q2);
       (MResetZ(q1), MResetZ(q2))
   }
   
   operation PrepareBellPair(q1 : Qubit, q2 : Qubit) : Unit {
       H(q1);
       CNOT(q1, q2);
   }
   

5. Criar uma nova célula. Para executar o programa Q# no simulador esparso, chama a run função do qsharp módulo e especifica o número de disparos.

   qsharp.run("Main()", shots=10)
   

Invocar o simulador Clifford

Pode chamar o simulador Clifford para programas Q#, OpenQASM, Qiskit e QIR. A tabela seguinte mostra como chamar o simulador Clifford a partir da biblioteca qdk para 10 execuções em cada um dos frameworks de programação quântica suportados.

Por exemplo, o seguinte código Python cria um programa OpenQASM simples e executa-o no simulador Clifford:

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];
    """

run(qasm_code, type='clifford', shots=10)

Chamar os simuladores da GPU e do CPU

Pode invocar os simuladores de GPU e CPU para programas em Qiskit e QIR. A tabela seguinte mostra como chamar o simulador de GPU a partir da biblioteca qdk para 10 execuções em cada uma das estruturas de programação quântica suportadas. Para chamar o simulador de CPU, substitua 'gpu' por 'cpu' para os parâmetros do tipo de simulador.

Por exemplo, o seguinte código Python converte um programa OpenQASM simples em QIR e executa o QIR no simulador da GPU:

from qdk.openqasm import compile#, ProgramType
from qdk.simulation import run_qir

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

qir = compile(qasm_code)
run_qir(qir, type='gpu', shots=10)