Share via

Introdução aos programas Q# e ao Visual Studio Code

  • Artigo

Neste artigo, encontrará os passos para utilizar o Código VC para criar e submeter tarefas de computação quântica Q#, Jupyter Notebook ou Python para o Azure Quantum com o VS Code.

Submeter tarefas Q# para o Azure Quantum

Saiba como utilizar o VS Code para executar, depurar e submeter um programa Q# para o Azure Quantum.

Pré-requisitos

Para obter detalhes sobre a instalação, veja Installing the Modern QDK on VS Code (Instalar o QDK Moderno no VS Code).

Carregar um programa de exemplo Q#

  1. No VS Code, selecione Ficheiro > Novo Ficheiro de Texto e guarde o ficheiro como RandomNum.qs.

  2. Abra RandomNum.qs e escreva samplee, em seguida, selecione Random Bit sample (Exemplo de Bit Aleatório) na lista de opções e guarde o ficheiro.

    Captura de ecrã do ficheiro Q# no Visual Studio Code a mostrar a lista de exemplos de código ao escrever a palavra exemplo no ficheiro.

Nota

Também pode abrir o seu próprio ficheiro Q#. Se executar um programa Q# mais antigo e encontrar erros, veja Testing and debugging (Testar e depurar) ou Migrating your programs to the Modern QDK (Migrar os programas para o QDK Moderno).

Executar um programa Q#

  1. Para testar a execução local do programa no simulador incorporado, clique em Executar a partir da lista de comandos abaixo @EntryPoint()ou prima Ctrl+F5. A saída será apresentada na consola de depuração.

  2. Para depurar o programa antes de o submeter para o Azure Quantum, clique em Depurar na lista de comandos abaixo @EntryPoint()ou prima F5. Utilize os controlos de depuração na parte superior para avançar, entrar e sair do código. Para obter mais informações sobre a depuração de programas Q#, veja Testing and debugging (Testar e depurar).

    Captura de ecrã do ficheiro Q# no Visual Studio Code a mostrar onde encontrar a lente de código com comandos de execução e depuração.

Visualizar o histograma de frequência

O histograma de frequência representa a distribuição dos resultados obtidos a partir da execução de um programa quântico várias vezes ou "capturas". Cada barra no histograma corresponde a um resultado possível e a sua altura representa o número de vezes que esse resultado é observado. O histograma de frequência ajuda a visualizar a distribuição de probabilidade destes resultados.

  1. Selecione Ver -> Paleta de Comandos e escreva "histograma", que deverá apresentar a opção Q#: Executar ficheiro e mostrar histograma . Também pode clicar em Histograma na lista de comandos abaixo @EntryPoint(). Selecione esta opção para abrir a janela do histograma Q#.

    Captura de ecrã do ficheiro Q# no Visual Studio Code a mostrar onde encontrar a lente de código com o comando histograma.

  2. Introduza várias capturas para executar o programa, por exemplo, 100 capturas e prima Enter. O histograma será apresentado na janela histograma Q#.

  3. Clique no ícone de definições no canto superior esquerdo para apresentar as opções.

    Captura de ecrã da janela histograma Q# no Visual Studio Code a mostrar como apresentar as definições.

  4. Clique numa barra para apresentar a percentagem desse resultado. Neste caso, existem dois resultados possíveis, 0 e 1, e a percentagem de cada resultado é próxima de 50%.

    Captura de ecrã da janela histograma Q# no Visual Studio Code.

Dica

Pode ampliar o histograma com a roda do rato ou um gesto de trackpad. Quando ampliado, pode deslocar o gráfico ao premir "Alt" enquanto se desloca.

Visualizar o circuito quântico

Os diagramas do circuito quântico são uma representação visual das operações quânticas. Mostram o fluxo de qubits através do programa quântico, incluindo as portas e as medidas aplicadas aos mesmos. Para obter mais informações, veja Quantum circuit diagrams in Visual Studio Code (Diagramas do circuito quântico no Visual Studio Code).

  1. Selecione Ver -> Paleta de Comandos e escreva "circuito", que deverá apresentar a opção Q#: Mostrar circuito . Também pode clicar em Circuito a partir da lista de comandos abaixo @EntryPoint().

    Captura de ecrã do ficheiro Q# no Visual Studio Code a mostrar onde encontrar o comando do circuito de lente de código.

  2. O circuito é apresentado na janela do circuito Q#. O diagrama de circuito mostra um registo de qubit que é inicializado para o estado |0⟩. Em seguida, uma porta Hadamard, H, é aplicada ao qubit, seguida de uma operação de medição, que é representada por um símbolo de medidor. Para obter mais informações, veja Quantum circuits conventions (Convenções de circuitos quânticos).

    Captura de ecrã a mostrar a janela do circuito Q# com o diagrama de circuito resultante para a operação de bits aleatórios.

Ligar ao Azure Quantum e submeter a tarefa

Pode ligar e submeter tarefas diretamente a partir do VS Code. Neste exemplo, irá submeter uma tarefa ao simulador Rigetti.

  1. Selecione Ver -> Paleta de Comandos e escreva Q#: Ligar a uma área de trabalho do Azure Quantum. Prima Enter.

  2. Selecione Conta do Azure e siga as instruções para ligar ao seu diretório, subscrição e área de trabalho preferidos.

    Nota

    Se tiver uma cadeia de ligação, pode selecionar Cadeia de ligação e colar o cadeia de ligação correspondente à área de trabalho do Azure Quantum. Para obter mais informações, veja Connect to a Quantum workspace using a cadeia de ligação (Ligar a uma área de trabalho do Quantum com um cadeia de ligação).

  3. Assim que estiver ligado, no painel Explorador , expanda Áreas de Trabalho Quânticas.

  4. Expanda a área de trabalho e expanda o fornecedor do Rigetti .

    Nota

    Se existir um problema ao ligar ao Azure Quantum, é apresentado um ícone de aviso junto ao nome da área de trabalho. Paire o cursor sobre o nome da área de trabalho para apresentar informações de erro.

  5. Selecione rigetti.sim.qvm como o seu target.

    Captura de ecrã do Visual Studio Code a mostrar como selecionar simulador Rigetti como target.

  6. Selecione o ícone de reprodução à direita do target nome para começar a submeter o programa Q# atual. Se receber um pop-up, selecione Alterar o perfil QIR target e continue.

    Captura de ecrã do Visual Studio Code a mostrar como executar o simulador Rigetti como target.

  7. Adicione um nome para identificar a tarefa.

  8. Adicione o número de capturas ou o número de vezes que o programa é executado.

  9. Prima Enter para submeter a tarefa. O estado da tarefa será apresentado na parte inferior do ecrã.

  10. Expanda Tarefas e paire o cursor sobre a tarefa, que apresenta as horas e o estado da sua tarefa.

  11. Para ver os resultados, selecione o ícone de nuvem junto ao nome da tarefa para transferir os resultados do armazenamento da área de trabalho e apresentá-los no VS Code.

    Captura de ecrã do Visual Studio Code a mostrar como transferir e ver os resultados da tarefa quântica.

Submeter tarefas do Jupyter Notebooks para o Azure Quantum

Saiba como utilizar o VS Code para executar, depurar e submeter um Jupyter Notebook Q# para o Azure Quantum. Os passos neste artigo também se aplicam aos Jupyter Notebooks no seu servidor jupyter local ou blocos de notas no portal do Azure Quantum.

Pré-requisitos

Para obter detalhes sobre a instalação, veja Installing the Modern QDK on VS Code (Instalar o QDK Moderno no VS Code).

Executar e testar o programa no simulador local

  1. No VS Code, selecione Ver > Paleta de comandos e selecione Create: Novo Jupyter Notebook.

  2. No canto superior direito, o VS Code irá detetar e apresentar a versão do Python e o ambiente virtual do Python que foi selecionado para o bloco de notas. Se tiver vários ambientes Python, poderá ter de selecionar um kernel com o seletor de kernel no canto superior direito. Se não tiver sido detetado nenhum ambiente, consulte Jupyter Notebooks no VS Code para obter informações de configuração.

  3. Na primeira célula do bloco de notas, execute o seguinte código Python para importar os módulos necessários:

    import qsharp
import azure.quantum
    • O qsharp módulo ativa o %%qsharp comando magic que lhe permite introduzir código Q# diretamente numa célula.
    • O azure-quantum módulo fornece conectividade à área de trabalho do Azure Quantum.

    Nota

    Se o kernel ipykernel do Jupyter Python não for detetado, o VS Code irá pedir-lhe para o instalar.

  4. Adicione outra célula e introduza este código Q# que devolve um número especificado pelo utilizador de bits aleatórios:

    Nota

    Repare que assim que escrever o comando %%qsharpmágico, a célula do bloco de notas muda de Python para Q#.

    %%qsharp

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

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  5. Para testar a operação, pode utilizar o eval método, que pode chamar qualquer operação Q# anteriormente definida no bloco de notas:

    qsharp.eval("RandomNBits(4)")

    [Zero, One, One, Zero]

  6. Para executar o programa no simulador local, utilize o run método . Especifique o shotsou número de vezes para executar o programa e o simulador devolve os resultados como uma lista python.

    qsharp.run("RandomNBits(4)", shots=10)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Visualizar o circuito quântico

Pode visualizar circuitos quânticos com o qsharp-widgets pacote. Este pacote fornece um widget que compõe um diagrama de circuito quântico como uma imagem SVG. Para obter mais informações, veja Quantum circuit diagrams with Jupyter Notebooks (Diagramas do circuito quântico com o Jupyter Notebooks).

Adicione o seguinte código a uma nova célula para visualizar o circuito:

from qsharp_widgets import Circuit

Circuit(qsharp.circuit("RandomNBits(4)"))

Captura de ecrã a mostrar Jupyter Notebook a mostrar como visualizar o circuito para uma operação Q#.

Para obter mais informações, veja Quantum circuits conventions (Convenções de circuitos quânticos).

Compilar a tarefa com o perfil Base

Quando executa programas no simulador quântico local, pode submeter qualquer tipo de programa Q#. No entanto, o hardware targets do Azure Quantum ainda não suporta todas as capacidades necessárias para executar todos os programas Q#. Para compilar e submeter programas Q# para o Azure Quantum, tem de definir o seu target perfil para indicar ao Q# quais as capacidades suportadas pelo hardware target . Atualmente, este é o perfil Base. Para obter mais informações, veja Tipos de perfil no Azure Quantum.

Para reinstalar o interpretador Q# e compilar o programa com o perfil base:

  1. Utilize o init método para definir o perfil:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)

  2. Uma vez que reinitializou o interpretador, tem de executar o código novamente com o novo perfil:

    %%qsharp

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

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  3. Em seguida, utilize o compile método para especificar a operação ou função que é o ponto de entrada do programa. Isto compila o seu código no formato QIR, que pode ser submetido a qualquer hardware quântico:

    MyProgram = qsharp.compile("RandomNBits(4)")

Ligar ao Azure Quantum e submeter a tarefa

Agora que compilou o programa no formato correto, crie um azure.quantum.Workspace objeto para ligar ao Azure Quantum. Irá utilizar o ID de Recurso da área de trabalho do Azure Quantum para se ligar. O ID do Recurso e a localização podem ser copiados da página de descrição geral da área de trabalho no portal do Azure.

  1. Numa nova célula, preencha o ID do recurso e a localização da área de trabalho do Azure Quantum:

    MyWorkspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. Utilize o get_targets método para ver o hardware targets disponível na área de trabalho:

    MyTargets = MyWorkspace.get_targets()
print("This workspace's targets:")
MyTargets

  3. Selecione o rigetti.sim.qvmtarget:

    MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")

  4. Por fim, utilize o método para submeter o submit programa com os respetivos parâmetros e apresentar os resultados:

    job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100)
job.get_results()

    {'Histogram': ['[0, 0, 0, 0]',
  0.3,
  '[1, 0, 0, 0]',
  0.1,
  '[1, 1, 1, 1]',
  0.3,
  '[0, 1, 1, 1]',
  0.3]}

  5. Todas as propriedades da tarefa estão acessíveis no job.details, por exemplo:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0150202e-9638-11ee-be2f-b16153380354', 'name': 'MyQuantumJob', 'provider_id': 'rigetti'...}
Job name: MyQuantumJob
Job status: Succeeded
Job ID: 0150202e-9638-11ee-be2f-b16153380354

Submeter o Python com tarefas Q# para o Azure Quantum

Saiba como utilizar o VS Code para escrever um programa Python que chama operações Q#, ligar ao Azure com os comandos python ou a CLI do Azure e submeter a sua tarefa.

Pré-requisitos

Para obter detalhes sobre a instalação, veja Instalar o QDK Moderno no VS Code.

Create e importe as suas operações Q#

Com o qsharp pacote, pode armazenar as suas funções e operações em ficheiros Q# e criar projetos Q# que lhe permitem ligar para qualquer um deles a partir do seu código Python. Isto é especialmente útil quando precisa de iniciar um programa que utiliza parâmetros de entrada.

  1. Siga os passos para criar um projeto Q#.

  2. Abra um novo ficheiro de texto, adicione o seguinte código Q# que devolve um número especificado pelo utilizador de bits aleatórios e guarde o ficheiro no seu projeto como source.qs.

    Nota

    Tenha em atenção que este código Q# não tem uma função @EntryPoint como um programa Q# (veja Submeter tarefas Q# para o Azure Quantum), mas requer um espaço de nomes, ao contrário de um Jupyter Notebook (veja Submeter Jupyter Notebook tarefas para o Azure Quantum).

    namespace Sample {

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

  operation RandomNBits(N: Int): Result[] {
        mutable results = [];
        for i in 0 .. N - 1 {
           let r = Random();
           set results += [r];
        }
        return results
  }
}

  3. Na mesma pasta, abra outro ficheiro e guarde-o como randomNum.py.

  4. Adicione o seguinte código para importar os qsharp módulos e azure.quantum .

    import qsharp
import azure.quantum

  5. Em seguida, adicione código para definir a pasta raiz do projeto Q# e teste a target operação no simulador local. A operação é chamada pelo <espaço de nomes>.<operation_name( )> e, neste caso, está a transmitir o número de bits aleatórios a devolver.

    qsharp.init(project_root = '/MyProjectRootFolder')
print(qsharp.eval("Sample.RandomNBits(4)"))

    [Zero, One, One, Zero]

  6. Também pode testar a operação com o run método, que transmite um parâmetro adicional shots e devolve os resultados numa lista python. Em randomNum.py, substitua a instrução de impressão anterior pelo seguinte:

    result = qsharp.run("Sample.RandomNBits(4)", shots=10)
for x in result:
    print(x)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Compilar a tarefa com o perfil Base

Quando executa programas no simulador quântico local, pode submeter qualquer tipo de programa Q#. No entanto, o hardware targets do Azure Quantum ainda não suporta todas as capacidades necessárias para executar todos os programas Q#. Para compilar e submeter programas Q# para o Azure Quantum, tem de definir o seu target perfil para indicar a Q# as capacidades suportadas pelo hardware target . Atualmente, este é o perfil Base. Para obter mais informações, veja Tipos de perfil no Azure Quantum.

Nota

Apenas para programas Q# no VS Code, o VS Code define automaticamente o perfil Base.

  1. Utilize o init método para definir o perfil:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)

  2. Em seguida, utilize o compile método para especificar a operação ou função que é o ponto de entrada do programa. Em seguida, o programa compilado pode ser submetido para qualquer hardware quântico:

    MyProgram = qsharp.compile("Sample.RandomNBits(4)")

Ligar ao Azure Quantum e submeter a tarefa

Pode ligar-se ao Azure Quantum e submeter a sua tarefa com um objeto criado por Workspace Python ou ligar e submeter a sua tarefa com a CLI do Azure. A utilização da CLI do Azure requer que guarde o programa compilado como um ficheiro de texto e submeta esse ficheiro com um comando da CLI.

Agora que compilou o programa no formato correto, crie um azure.quantum.Workspace objeto para ligar ao Azure Quantum. Irá utilizar o ID de Recurso da área de trabalho do Azure Quantum para se ligar. O ID do Recurso e a localização podem ser copiados da página de descrição geral da área de trabalho no portal do Azure.

  1. Adicione o seguinte código ao randomNum.py, preenchendo o ID do recurso e a localização da área de trabalho do Azure Quantum:

    workspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. Utilize o get_targets método para apresentar o hardware targets disponível na área de trabalho:

    MyTargets = workspace.get_targets()
print("This workspace's targets:")
for x in MyTargets:
    print(x)

  3. Selecione o rigetti.sim.qvmtarget:

    MyTarget = workspace.get_targets("rigetti.sim.qvm")

  4. Por fim, utilize o método para submeter o submit programa com os respetivos parâmetros. Os resultados da tarefa são devolvidos como um dicionário Python.

    job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
results = job.get_results()
print("\nResults: ", results)

  5. Para extrair apenas os valores e apresentá-los:

    resultList = results.get("Histogram")
for x in resultList:
    print(x)

    [0, 0, 0, 0]
0.3
[1, 0, 0, 0]
0.1
[1, 1, 1, 1]
0.3
[0, 1, 1, 1]
0.3

  6. Todas as propriedades da tarefa estão acessíveis no job.details, por exemplo:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
Job name: MyPythonJob
Job status: Succeeded
Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f

Passos seguintes