Partilhar via

Como enviar programas Q# com o Visual Studio Code

  • Artigo

Saiba como usar o Visual Studio Code para criar e enviar programas Q# para hardware quântico real. Você pode enviar trabalhos de computação quântica para o Azure Quantum como um programa Q# autônomo, combinar Q# com Python em um projeto Q# e executar um Jupyter Notebook.

Enviando trabalhos Q# para o Azure Quantum

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

Pré-requisitos

Para obter detalhes da instalação, consulte Instalando o QDK no VS Code.

Carregar um programa de exemplo Q#

  1. No VS Code, selecione File > New Text File e salve o arquivo como RandomNum.qs.

  2. Abra RandomNum.qs e digite sample, selecione Amostra de bit aleatório na lista de opções e salve o arquivo.

    Captura de tela do arquivo Q# no Visual Studio Code mostrando a lista de exemplos de código ao escrever o exemplo de palavra no arquivo.

Nota

Você também pode abrir seu próprio arquivo Q#. Se você executar um programa Q# mais antigo e encontrar erros, consulte Testando e depurando.

Executar um programa Q#

  1. Para testar a execução do programa localmente no simulador integrado, clique em Executar na lista de comandos ao lado da operação do ponto de entrada ou pressione Ctrl+F5. Sua saída aparecerá no console de depuração.

  2. Para depurar seu programa antes de enviá-lo para o Azure Quantum, clique em Depurar na lista de comandos ao lado da operação do ponto de entrada ou pressione F5. Use os controles de depuração na parte superior para entrar, entrar e sair do código. Para obter mais informações sobre como depurar programas Q#, consulte Testando e depurando.

    Captura de tela do arquivo Q# no Visual Studio Code mostrando onde encontrar a lente de código com comandos run e debug.

Visualize o histograma de frequência

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

  1. Selecione View -> Command Palette e digite "histograma", que deve exibir a opção Q#: Executar arquivo e mostrar histograma . Você também pode clicar em Histograma na lista de comandos ao lado da operação do ponto de entrada. Selecione esta opção para abrir a janela do histograma Q#.

    Captura de tela do arquivo Q# no Visual Studio Code mostrando onde encontrar a lente de código com o comando histograma.

  2. Insira um número de tiros para executar o programa, por exemplo, 100 tiros e pressione Enter. O histograma será exibido na janela do histograma Q#.

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

    Captura de tela da janela do histograma Q# no Visual Studio Code mostrando como exibir as configurações.

  4. Clique em uma barra para exibir a porcentagem desse resultado. Neste caso, há dois resultados possíveis, 0 e 1, e a percentagem de cada resultado é próxima de 50%.

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

Gorjeta

Você pode ampliar o histograma usando a roda de rolagem do mouse ou um gesto do trackpad. Quando ampliado, você pode mover o gráfico pressionando 'Alt' enquanto rola.

Visualize o circuito quântico

Os diagramas de circuitos quânticos são uma representação visual das operações quânticas. Eles mostram o fluxo de qubits através do programa quântico, incluindo os portões e medidas aplicadas a eles. Para obter mais informações, consulte Diagramas de circuito quântico no Visual Studio Code.

  1. Selecione View -> Command Palette e digite "circuit" que deve exibir a opção Q#: Show circuit. Você também pode clicar em Circuito na lista de comandos ao lado da operação do ponto de entrada.

    Captura de tela do arquivo Q# no Visual Studio Code mostrando onde encontrar o comando code lens circuit.

  2. O circuito é exibido na janela do circuito Q#. O diagrama de circuito mostra um registro de qubit que é inicializado para o estado |0⟩. Em seguida, um portão de Hadamard, H, é aplicado ao qubit, seguido por uma operação de medição, que é representada por um símbolo de metro. Para obter mais informações, consulte Convenções de circuitos quânticos.

    Captura de tela da janela do circuito Q# mostrando o diagrama de circuito resultante para a operação de bit aleatório.

Conecte-se ao Azure Quantum e envie seu trabalho

Você pode se conectar e enviar trabalhos diretamente do VS Code. Neste exemplo, você enviará um trabalho para o simulador Rigetti.

  1. Selecione Exibir -> Paleta de Comandos e digite Q#: Conectar-se a um espaço de trabalho do Azure Quantum. Prima Enter.

  2. Selecione Conta do Azure e siga as instruções para se conectar ao seu diretório, assinatura e espaço de trabalho preferidos.

    Nota

    Se você tiver uma cadeia de conexão, poderá selecionar Cadeia de conexão e colar a cadeia de conexão correspondente ao seu espaço de trabalho do Azure Quantum. Para obter mais informações, consulte Conectar-se a um espaço de trabalho Quantum usando uma cadeia de conexão.

  3. Quando estiver conectado, no painel Explorer, expanda Espaços de trabalho quânticos.

  4. Expanda seu espaço de trabalho e expanda o provedor Rigetti .

    Nota

    Se houver um problema ao se conectar ao Azure Quantum, um ícone de aviso será exibido ao lado do nome do espaço de trabalho. Passe o cursor sobre o nome do espaço de trabalho para exibir informações de erro.

  5. Selecione rigetti.sim.qvm como seu targetarquivo .

    Captura de tela do Visual Studio Code mostrando como selecionar o simulador Rigetti como target.

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

    Captura de tela do Visual Studio Code mostrando como executar o simulador Rigetti como target.

  7. Adicione um nome para identificar o trabalho.

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

  9. Pressione Enter para enviar o trabalho. O status do trabalho será exibido na parte inferior da tela.

  10. Expanda Trabalhos e passe o mouse sobre seu trabalho, que exibe os horários e o status do seu trabalho.

  11. Para visualizar os resultados, selecione o ícone de nuvem ao lado do nome do trabalho para baixar os resultados do armazenamento do espaço de trabalho e exibi-los no VS Code.

    Captura de tela do Visual Studio Code mostrando como baixar e exibir os resultados do seu trabalho quântico.

Enviando trabalhos do Jupyter Notebooks para o Azure Quantum

Saiba como usar o VS Code para executar, depurar e enviar um Q# Jupyter Notebook para o Azure Quantum. As etapas neste artigo também se aplicam aos Blocos de Anotações do Jupyter em seu servidor Jupyter local ou aos blocos de anotações no portal do Azure Quantum.

Pré-requisitos

Para obter detalhes da instalação, consulte Instalando o QDK no VS Code.

Execute e teste seu programa no simulador local

  1. No VS Code, selecione View > Command palette e selecione Create: New Jupyter Notebook.

  2. No canto superior direito, o VS Code detetará e exibirá a versão do Python e o ambiente Python virtual que foi selecionado para o notebook. Se você tiver vários ambientes Python, talvez seja necessário selecionar um kernel usando o seletor de kernel no canto superior direito. Se nenhum ambiente foi detetado, consulte Jupyter Notebooks no VS Code para obter informações de configuração.

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

    import qsharp
import azure.quantum
    • O qsharp módulo ativa o comando magic que permite inserir o %%qsharp código Q# diretamente em uma célula.
    • O azure-quantum módulo fornece conectividade ao seu espaço de trabalho do Azure Quantum.

    Nota

    Se o kernel ipykernel do Jupyter Python não for detetado, o VS Code solicitará que você o instale.

  4. Adicione outra célula e insira este código Q# que retorna um número especificado pelo usuário de bits aleatórios:

    Nota

    Observe que, assim que você digita o comando %%qsharpmagic, a célula do notebook muda de tipo 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 sua operação, você pode usar o eval método, que pode chamar qualquer operação Q# previamente definida no bloco de anotações:

    qsharp.eval("RandomNBits(4)")

    [Zero, One, One, Zero]

  6. Para executar o programa no simulador local, use o run método. Especifique o shots, ou o número de vezes para executar o programa, e o simulador retorna 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]]

Visualize o circuito quântico

Você pode visualizar circuitos quânticos usando o qsharp-widgets pacote. Este pacote fornece um widget que renderiza um diagrama de circuito quântico como uma imagem SVG. Para obter mais informações, consulte Diagramas de circuitos quânticos com 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 tela do Jupyter Notebook mostrando como visualizar o circuito para uma operação Q#.

Para obter mais informações, consulte Convenções de circuitos quânticos.

Compile seu trabalho usando o perfil Base

Quando você executa programas no simulador quântico local, você pode enviar qualquer tipo de programa Q#. No entanto, o hardware targets do Azure Quantum ainda não suporta todos os recursos necessários para executar todos os programas Q#. Para compilar e enviar programas Q# para o Azure Quantum, você precisa definir seu target perfil para informar ao Q# quais recursos seu target hardware suporta. Atualmente, esse é o perfil Base. Para obter mais informações, consulte Tipos de perfil no Azure Quantum.

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

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

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

  2. Como você reinicializou o interpretador, você precisa executar seu 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, use o compile método para especificar a operação ou função que é o ponto de entrada para o seu programa. Isso compila seu código no formato QIR, que pode ser enviado para qualquer hardware quântico:

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

Conecte-se ao Azure Quantum e envie seu trabalho

Agora que você tem seu programa compilado no formato correto, crie um azure.quantum.Workspace objeto para se conectar ao Azure Quantum. Você usará a ID do recurso do seu espaço de trabalho do Azure Quantum para se conectar. A ID do recurso e o local podem ser copiados da página de visão geral do espaço de trabalho no portal do Azure.

  1. Em uma nova célula, preencha sua ID de recurso e local do seu espaço de trabalho do Azure Quantum:

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

  2. Use o get_targets método para ver o hardware targets disponível em seu espaço de trabalho:

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

  3. Selecione a rigetti.sim.qvmtargetopção :

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

  4. Por fim, use o submit método para enviar seu programa com seus parâmetros e exibir os resultados:

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

    {'[0, 1, 1, 1]': 0.08,
 '[1, 1, 0, 0]': 0.1,
 '[0, 0, 1, 0]': 0.04,
 '[0, 1, 0, 0]': 0.05,
 '[1, 0, 1, 0]': 0.05,
 '[1, 0, 0, 0]': 0.07,
 '[0, 1, 0, 1]': 0.07,
 '[1, 0, 1, 1]': 0.07,
 '[0, 0, 0, 0]': 0.08,
 '[1, 1, 1, 0]': 0.05,
 '[0, 0, 0, 1]': 0.1,
 '[0, 0, 1, 1]': 0.04,
 '[0, 1, 1, 0]': 0.09,
 '[1, 0, 0, 1]': 0.04,
 '[1, 1, 1, 1]': 0.05,
 '[1, 1, 0, 1]': 0.02}

  5. Todas as propriedades do trabalho estão acessíveis em 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

Detalhes adicionais do trabalho

O azure.quantum pacote Python inclui métodos adicionais para exibir dados de trabalho mais detalhados.

  • job.get_results_histogram(): Este método retorna um dicionário dos resultados e contagem de tiros para cada medição exclusiva. Por exemplo, os resultados para o trabalho anterior seriam

    print(job.get_results_histogram()) 

    {   
    '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 8},  
    '[1, 1, 0, 0]' : {'Outcome' : [1, 1, 0, 0], 'Count' : 10},
    '[0, 0, 1, 0]' : {'Outcome' : [0, 0, 1, 0], 'Count' : 4},
    '[0, 1, 0, 0]' : {'Outcome' : [0, 1, 0, 0], 'Count' : 5},
    '[1, 0, 1, 0]' : {'Outcome' : [1, 0, 1, 0], 'Count' : 5},  
    '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 7},
    '[0, 1, 0, 1]' : {'Outcome' : [0, 1, 0, 1], 'Count' : 7},
    '[1, 0, 1, 1]' : {'Outcome' : [1, 0, 1, 1], 'Count' : 7},
    '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 8},  
    '[1, 1, 1, 0]' : {'Outcome' : [1, 1, 1, 0], 'Count' : 5},
    '[0, 0, 0, 1]' : {'Outcome' : [0, 0, 0, 1], 'Count' : 10},
    '[0, 0, 1, 1]' : {'Outcome' : [0, 0, 1, 1], 'Count' : 4},
    '[0, 1, 1, 0]' : {'Outcome' : [0, 1, 1, 0], 'Count' : 9},  
    '[1, 0, 0, 1]' : {'Outcome' : [1, 0, 0, 1], 'Count' : 4},
    '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 5},
    '[1, 1, 0, 1]' : {'Outcome' : [1, 1, 0, 1], 'Count' : 2}
}

  • job.get_results_shots() : Este método retorna uma lista de cada resultado de disparo. Por exemplo, os resultados para o trabalho anterior seriam

    print(job.get_results_shots()) 

    [ [0, 1, 1, 1], [1, 0, 1, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 0, 0], [1, 0, 1, 1], [1, 1, 0, 1], ...]

Enviando Python com trabalhos Q# para o Azure Quantum

Saiba como usar o VS Code para escrever um programa Python que chama operações Q#, conectar-se ao Azure usando os comandos Python ou CLI do Azure e enviar seu trabalho.

Pré-requisitos

Para obter detalhes da instalação, consulte Instalando o QDK no VS Code.

  • Um espaço de trabalho do Azure Quantum em sua assinatura do Azure. Para criar um espaço de trabalho, consulte Criar um espaço de trabalho do Azure Quantum.
  • Um ambiente Python com Python e Pip instalados.
  • VS Code com o Azure Quantum Development Kit e a extensão Python instalados.
  • O Azure Quantum qsharp e azure-quantum pacotes.
  • CLI do Azure com a extensão mais recente do Azure Quantum instalada.

Crie e importe suas operações Q#

Com o qsharp pacote, você pode armazenar suas funções e operações em arquivos Q# e criar projetos Q# que permitem que você chame qualquer um deles a partir do seu código Python. Isso é especialmente útil quando você precisa iniciar um programa que usa parâmetros de entrada.

  1. Siga as etapas para criar um projeto Q#.

  2. Abra um novo arquivo de texto, adicione o seguinte código Q# que retorna um número especificado pelo usuário de bits aleatórios e salve o arquivo no diretório /src em seu projeto como Source.qs.

    
    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 pasta raiz do projeto (com o arquivo qsharp.json), abra outro arquivo e salve-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 execução da target operação no simulador local. A operação é chamada por <namespace>.<operation_name( )>, e neste caso, você está passando o número de bits aleatórios para retornar.

    Nota

    Como nenhum namespace foi especificado no Source.qs, o compilador usa o nome do arquivo como o namespace padrão - Source.RandomNBits(). Para obter mais informações, consulte Projetos e namespaces implícitos.

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

    [Zero, One, One, Zero]

  6. Você também pode testar a operação com o run método, que passa um parâmetro adicional shots e retorna os resultados em uma lista Python. No randomNum.py, substitua a instrução de impressão anterior pelo seguinte:

    result = qsharp.run("Source.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]]

Compile seu trabalho usando o perfil Base

Quando você executa programas no simulador quântico local, você pode enviar qualquer tipo de programa Q#. No entanto, o hardware targets do Azure Quantum ainda não suporta todos os recursos necessários para executar todos os programas Q#. Para compilar e enviar programas Q# para o Azure Quantum, você precisa definir seu target perfil para informar ao Q# quais recursos seu target hardware suporta. Atualmente, esse é o ou Adpative_RI perfilBase. Para obter mais informações, consulte Tipos de perfil no Azure Quantum.

Nota

Para programas somente Q# no VS Code, o VS Code define o Base perfil automaticamente.

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

    qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)

    Nota

    Como você está reinicializando seu estado qsharp, você precisa definir o project_root parâmetro novamente para que o compilador saiba onde encontrar a RandomNBits operação. Tal poderia também ter sido feito na etapa 5 do procedimento anterior.

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

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

Conecte-se ao Azure Quantum e envie seu trabalho

Você pode se conectar ao Azure Quantum e enviar seu trabalho usando um objeto criado pelo Workspace Python ou conectar e enviar seu trabalho usando a CLI do Azure. Usar a CLI do Azure requer que você salve o programa compilado como um arquivo de texto e envie esse arquivo usando um comando da CLI.

Agora que você tem seu programa compilado no formato correto, crie um azure.quantum.Workspace objeto para se conectar ao Azure Quantum. Você usará a ID do recurso do seu espaço de trabalho do Azure Quantum para se conectar. A ID do recurso e o local podem ser copiados da página de visão geral do espaço de trabalho no portal do Azure.

  1. Adicione o seguinte código ao randomNum.py, preenchendo sua ID de recurso e local do seu espaço de trabalho do Azure Quantum:

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

  2. Use o get_targets método para exibir o hardware targets disponível em seu espaço de trabalho:

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

  3. Selecione a rigetti.sim.qvmtargetopção :

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

  4. Por fim, use o submit método para enviar seu programa com seus parâmetros. Os resultados do trabalho são retornados 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 exibi-los:

    for x in results:
    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 do trabalho estão acessíveis em 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

Detalhes adicionais do trabalho

O azure.quantum pacote Python inclui métodos adicionais para exibir dados de trabalho mais detalhados.

  • job.get_results_histogram(): Este método retorna um dicionário dos resultados e contagem de tiros para cada medição exclusiva. Por exemplo, os resultados para o trabalho anterior seriam

    results = job.get_results_histogram()
for x in results.items():
    print(x)

    {   
    '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 30},  
    '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 10},
    '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 30},
    '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 30}
}

  • job.get_results_shots() : Este método retorna uma lista de cada resultado de disparo. Por exemplo, os resultados para o trabalho anterior seriam

    print(job.get_results_shots()) 

    [ [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1], [1, 0, 0, 0], [0, 1, 1, 1], [0, 0, 0, 0], ...]

Conteúdos relacionados