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

Neste artigo, você encontrará as etapas para usar o Código de VC para criar e enviar trabalhos de computação quântica Q#, Jupyter Notebook ou Python para o Azure Quantum usando o VS Code.

Enviando trabalhos de 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 moderno 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.
• A versão mais recente do Visual Studio Code ou abrir o VS Code na Web.
• A versão mais recente da extensão do Kit de Desenvolvimento do Azure Quantum .

Carregar um programa de exemplo 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.

   

Observação

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 ou Migrando seus programas para o QDK Moderno.

Executar um programa Q#

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

2. Para depurar seu programa antes de enviá-lo ao Azure Quantum, clique em Depurar na lista de comandos abaixo @EntryPoint()ou pressione F5. Use os controles de depuração na parte superior para percorrer, inserir e sair do código. Para obter mais informações sobre a depuração de programas Q#, consulte Teste e depuração.

   

Visualizar o histograma de frequência

O histograma de frequência representa a distribuição dos resultados obtidos da execução de um programa quântico várias vezes ou "capturas". Cada barra no histograma corresponde a um possível resultado 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 Exibir –> Paleta de Comandos e digite "histograma", que deve abrir o arquivo Q#: Executar e mostrar a opção de histograma . Você também pode clicar em Histograma na lista de comandos abaixo @EntryPoint(). Selecione esta opção para abrir a janela de histograma Q#.

   

2. Insira várias capturas para executar o programa, por exemplo, 100 capturas e pressione Enter. O histograma será exibido na janela de histograma Q#.

3. Clique no ícone de configurações superior esquerda para exibir opções.

   

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

   

Dica

Você pode ampliar o histograma usando a roda de rolagem do mouse ou um gesto de trackpad. Quando ampliado, você pode fazer a panorâmica do gráfico pressionando 'Alt' durante a rolagem.

Visualizar o circuito quântico

Diagramas de circuito quântico são uma representação visual de operações quânticas. Eles mostram o fluxo de qubits por meio do programa quântico, incluindo as portas e medidas aplicadas a eles. Para obter mais informações, consulte Diagramas de circuito quântico em 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 abaixo @EntryPoint().

   

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

   

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 workspace preferidos.

   Observação

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

3. Depois de conectado, no painel Explorer, expanda Workspaces Quânticos.

4. Expanda seu workspace e expanda o provedor Rigetti .

   Observação

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

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

   

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

   

7. Adicione um nome para identificar o trabalho.

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

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

10. Expanda Trabalhos e passe o mouse sobre seu trabalho, que exibe os horários e 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 workspace e exibi-los no VS Code.

    

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 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 moderno 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 as extensões do Kit de Desenvolvimento do Azure Quantum, Python e Jupyter instaladas.

• Os pacotes , qsharp-widgetse e azure-quantum do Azure Quantum qsharpe o ipykernel pacote.

  python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
  

Executar e testar seu programa no simulador local

1. No VS Code, selecione Exibir > Paleta de comandos e selecione Create: 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 do 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 instalaçã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 %%qsharp comando magic que permite inserir 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 altera o 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]]
   

Visualizar o circuito quântico

Você pode visualizar circuitos quânticos usando o qsharp-widgets pacote . Esse pacote fornece um widget que renderiza um diagrama de circuito quântico como uma imagem SVG. Para obter mais informações, consulte Diagramas de circuito quântico 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)"))

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 aos recursos completos necessários para executar todos os programas em 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 dá suporte. Atualmente, esse é o perfil base. Para obter mais informações, consulte Tipos de perfil no Azure Quantum.

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

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

Conectar-se ao Azure Quantum e enviar seu trabalho

Agora que seu programa foi compilado 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 a localização podem ser copiadas 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 a localização 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 workspace:

   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()
   

   {'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 do trabalho sã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
   

Enviando o Python com trabalhos do Q# para o Azure Quantum

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

Pré-requisitos

Para obter detalhes da instalação, consulte Instalando o QDK moderno 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 python instalados.
• O Azure Quantum qsharp e azure-quantum os pacotes.
• CLI do Azure com a extensão mais recente do Azure Quantum instalada.

Create e importar suas operações de 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 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 código Q# a seguir que retorna um número especificado pelo usuário de bits aleatórios e salve o arquivo em seu projeto como source.qs.

   Observação

   Observe que esse código Q# não tem uma @EntryPoint função como um programa Q# (consulte Enviando trabalhos em Q# para o Azure Quantum), mas requer um namespace, ao contrário de um Jupyter Notebook (consulte Enviando trabalhos Jupyter Notebook 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 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 testar a execução da target operação no simulador local. A operação é chamada pelo <namespace> .<operation_name( )>e, nesse caso, você está passando o número de bits aleatórios a serem retornados.

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

   [Zero, One, One, Zero]
   

6. Você também pode testar a operação com o run método , que passa por 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("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 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 aos recursos completos necessários para executar todos os programas em 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 dá suporte. Atualmente, esse é o perfil base. Para obter mais informações, consulte Tipos de perfil no Azure Quantum.

Observação

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

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

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

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

   MyProgram = qsharp.compile("Sample.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 pelo Workspace Python ou conectar e enviar seu trabalho usando a CLI do Azure. O uso da CLI do Azure exige que você salve o programa compilado como um arquivo de texto e envie esse arquivo usando um comando da CLI.

Usando Python

Agora que seu programa foi compilado 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 a localização podem ser copiadas da página de visão geral do workspace no portal do Azure.

1. Adicione o seguinte código a randomNum.py, preenchendo sua ID de recurso e a localizaçã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 workspace:

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

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

5. Para extrair apenas os valores e exibi-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 do trabalho sã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
   

Usando a CLI do Azure

Para enviar um trabalho ao Azure Quantum com a CLI do Azure, você precisa enviar um arquivo físico do programa que acabou de compilar.

1. Adicione ao código a seguir ao arquivo randomNum.py . Isso abre um arquivo de texto e grava o programa compilado no formato adequado.

   file = open("compiled_output.txt", "w")
   file.write(MyProgram._ll_str)
   file.close()
   

2. Para enviar o trabalho ao Azure Quantum, faça logon com a CLI do Azure:

   az login
   

3. Verifique se você está executando a versão mais recente da extensão da CLI quantum do Azure:

   az extension add --upgrade --name quantum
   

4. Especifique a assinatura que você deseja usar entre as associadas à sua conta do Azure. Você também pode encontrar sua ID de assinatura na visão geral do seu workspace no portal do Azure.

   az account set -s <MySubscriptionID>
   

5. Exiba seus workspaces disponíveis com:

   az quantum workspace list
   

6. É possível usar quantum workspace set para selecionar um espaço de trabalho padrão que deseja usar para listar e enviar trabalhos.

   az quantum workspace set \
      -g <MyResourceGroup> \
      -w <MyWorkspace> \
      -l <MyLocation> \
      -o table
   

7. Exiba o disponível targets em seu workspace com:

   az quantum target list -o table
   

8. Envie seu trabalho usando o job submit comando .

   • --target-id pode ser qualquer target. Para este exemplo, use o rigetti.sim.qvmtarget.
   • --job-name pode ser qualquer cadeia de caracteres.
   • --job-input-format é sempre qir.v1.
   • --job-input-file é o nome do arquivo de texto que você criou na etapa 1.
   • --entry-point é sempre ENTRYPOINT__main

   az quantum job submit \
       --target-id rigetti.sim.qvm \
       --job-name MyQuantumJob \
       --job-input-format qir.v1 \
       --job-input-file compiled_output.txt \
       --entry-point ENTRYPOINT__main
   

9. Para marcar o status do trabalho, copie a ID da saída da última etapa e use o job show comando :

   az quantum job show --job-id b0012975-744a-4405-970e-3d8dc4afb2c0 -o table
   

   Name      Id                                    Status     Target           Submission time                   Completion time                  
   --------  ------------------------------------  ---------  ---------------  --------------------------------  -------------------------------- 
   MyQuantumJob  b2f07cc4-b49b-40b0-b63b-9a4885e5fef5  Succeeded  rigetti.sim.qvm  2023-12-11T05:33:23.187773+00:00  2023-12-11T05:33:29.252742+00:00 
   

10. Para exibir a saída do trabalho, use o job output comando :

    az quantum job output --job-id b0012975-744a-4405-970e-3d8dc4afb2c0 -o table
    

    Result        Frequency
    ------------  -----------  ----------------------
    [0, 1, 1, 1]  1.00000000   |████████████████████|
    

Próximas etapas

• Lidar com trabalhos no Azure Quantum
• Provedores de computação quântica