Compartilhar 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 de instalação, consulte Instalando o QDK no VS Code.

Carregar um programa de amostra de Q#

  1. No VS Code, selecione Arquivo > Novo Arquivo de Texto 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.

    Faça uma 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.

Observação

Você também pode abrir seu próprio arquivo Q#. Se você executar um programa Q# mais antigo e encontrar erros, consulte Teste e depuração.

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. A saída será exibida 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 de ponto de entrada ou pressione F5. Use os controles de depuração na parte superior para percorrer, entrar e sair do código. Para obter mais informações sobre como depurar programas Q#, consulte Teste e depuração.

    Faça uma captura de tela do arquivo Q# no Visual Studio Code mostrando onde encontrar a lente de código com os 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 "tiros". Cada barra no histograma corresponde a um resultado possível e 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 desses resultados.

  1. Selecione Exibir -> Paleta de Comandos e digite "histograma", que deve abrir 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 essa opção para abrir a janela do histograma Q#.

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

  2. Insira um número de fotos para executar o programa, por exemplo, 100 fotos 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.

    Faça uma 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. Nesse caso, existem dois resultados possíveis, 0 e 1, e a porcentagem de cada resultado é próxima a 50%.

    Faça uma captura de tela da janela do histograma Q# no Visual Studio Code.

Dica

Você pode ampliar o histograma usando a roda de rolagem do mouse ou um gesto do trackpad. Quando ampliado, você pode deslocar 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 as portas e as medições aplicadas a eles. Para obter mais informações, consulte Diagramas de circuito quântico no Visual Studio Code.

  1. Selecione Exibir -> Paleta de Comandos e digite "circuito" que deve abrir a opção Q#: Mostrar circuito . Você também pode clicar em Circuito na lista de comandos ao lado da operação do ponto de entrada.

    Faça uma captura de tela do arquivo Q# no Visual Studio Code mostrando onde encontrar o comando code lens circuit.

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

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

Conectar-se ao Azure Quantum e enviar seu trabalho

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

  1. Selecione Exibir –> Paleta de Comandos e digite Q#: Conectar-se a um workspace do Azure Quantum. Pressione Enter.

  2. Selecione Conta do Azure e siga os prompts para se conectar ao diretório, à assinatura e ao workspace de sua preferência.

    Observação

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

  3. Depois de conectado, no painel Explorer , expanda Workspaces do Quantum.

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

    Observação

    Se houver um problema de conexão com o Azure Quantum, um ícone de aviso será exibido ao lado do nome do workspace. Passe o mouse 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 fotos 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 exibirá os horários e o status do trabalho.

  11. Para exibir 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 Jupyter Notebook Q# para o Azure Quantum. As etapas neste artigo também se aplicam a Jupyter Notebooks em seu servidor Jupyter local ou notebooks no portal do Azure Quantum.

Pré-requisitos

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

Execute e teste seu programa no simulador local

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

  2. No canto superior direito, o VS Code detectará e exibirá a versão do Python e o ambiente virtual do Python 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 detectado, consulte Jupyter Notebooks no VS Code para obter informações de configuração.

  3. Na primeira célula do notebook, 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 mágico que permite inserir o %%qsharp código Q# diretamente em uma célula.
    • O azure-quantum módulo fornece conectividade com seu workspace do Azure Quantum.

    Observação

    Se o kernel ipykernel do Jupyter Python não for detectado, 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:

    Observação

    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# definida anteriormente no notebook:

    qsharp.eval("RandomNBits(4)")

    [Zero, One, One, Zero]

  6. Para executar seu programa no simulador local, use o run método. Especifique o , ou o shotsnúmero de vezes para executar o programa, e o simulador retorna os resultados como uma lista do 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.

Compilar seu trabalho usando o perfil Base

Ao executar 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 dá suporte a 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 Q# quais recursos são compatíveis com seu target hardware. Atualmente, esse é o perfil Base. Para obter mais informações, consulte Tipos de perfil no Azure Quantum.

Para reinicializar o interpretador Q# e compilar seu 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 a qualquer hardware quântico:

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

Conectar-se ao Azure Quantum e enviar seu trabalho

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

  1. Em uma nova célula, preencha a ID do recurso e o local do workspace 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 o rigetti.sim.qvmtarget:

    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 podem ser acessadas 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

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 da contagem de tacadas para cada medição exclusiva. Por exemplo, os resultados do 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 do 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 trabalhos do Python com 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 do Python ou a CLI do Azure e enviar seu trabalho.

Pré-requisitos

Para obter detalhes de 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 no Azure Quantum.
  • Um ambiente Python com Python e Pip instalados.
  • VS Code com o Kit de Desenvolvimento do Azure Quantum e a extensão do Python instalados.
  • O Azure Quantum qsharp e azure-quantum os pacotes.
  • CLI do Azure com a extensão mais recente do Azure Quantum instalada.

Criar e importar 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 chamar qualquer um deles 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 código a seguir 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 por <namespace>.<operation_name( )> e, neste caso, você está passando o número de bits aleatórios a serem retornados.

    Observação

    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 do Python. Em 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]]

Compilar seu trabalho usando o perfil Base

Ao executar 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 dá suporte a 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 Q# quais recursos são compatíveis com seu target hardware. Atualmente, esse é o Base perfil ou Adpative_RI . Para obter mais informações, consulte Tipos de perfil no Azure Quantum.

Observação

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)

    Observação

    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. Isso também poderia 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)")

Conectar-se ao Azure Quantum e enviar seu trabalho

Você pode se conectar ao Azure Quantum e enviar seu trabalho usando um objeto criado Workspace pelo Python ou conectar e enviar seu trabalho usando a CLI do Azure. O uso da 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ê compilou seu programa no formato correto, crie um azure.quantum.Workspace objeto para se conectar ao Azure Quantum. Você usará a ID do recurso do workspace do Azure Quantum para se conectar. A ID do recurso e o local podem ser copiados da página de visão geral do workspace no portal do Azure.

  1. Adicione o seguinte código ao , preenchendo a ID do recurso e a randomNum.pylocalização do workspace 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 o rigetti.sim.qvmtarget:

    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 podem ser acessadas 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

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 da contagem de tacadas para cada medição exclusiva. Por exemplo, os resultados do 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 do 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údo relacionado