Como enviar Q# programas com Visual Studio Code

Enviando Q# trabalhos para Azure Quantum

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

Pré-requisitos

Para obter detalhes da instalação, consulte Configurar a QDK extensão.

• Um Azure Quantum workspace em sua Azure assinatura. Para criar um workspace, consulte Criar um Azure Quantum workspace.
• A versão mais recente de Visual Studio Code ou abra VS Code na Web.
• A mais recente versão da Azure Quantum Development Kit extensão.

Carregar um Q# programa de exemplo

1. Em 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.

   

Executar um programa Q#

1. Para testar a execução do programa localmente no simulador interno, clique em Executar na lista de comandos ao lado da operação de 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 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 programas de depuração Q# , consulte Teste e depuração.

   

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 "capturas". 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, o que trará o comando QDK: Executar arquivo e mostrar histograma. Você também pode escolher Histograma na lista de comandos que precedem a operação de ponto de entrada. Selecione essa opção para abrir a janela do histograma Q# .

   

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.

   

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%.

   Visual Studio Code

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 em Visual Studio Code.

1. Selecione Exibir –> Paleta de Comandos e digite circuito, que apresenta o comando QDK: Mostrar circuito. Você também pode selecionar Circuito na lista de comandos ao lado da operação de ponto de entrada.

   

2. O circuito é exibido na janela do 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.

   

Azure Quantum Conectar-se e enviar seu trabalho

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

1. Selecione Exibição –> Paleta de Comandos e insiraQDK: Conectar-se a um Azure Quantum espaço de trabalho. Pressione Enter.

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

   Observação

   Se você tiver uma cadeia de conexão, selecione Cadeia de conexão e cole a cadeia correspondente ao seu espaço de trabalho 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. Amplie seu espaço de trabalho e expanda o provedor Rigetti.

   Observação

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

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

   

6. Selecione o ícone de reprodução à direita do nome para começar a target enviar o programa atual Q# .

   

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 workspace e exibi-los em VS Code.

    

Enviar trabalhos para Azure Quantum de Jupyter Notebook

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

Pré-requisitos

Para obter detalhes da instalação, consulte Configurar a QDK extensão.

• Um Azure Quantum workspace em sua Azure assinatura. Para criar um workspace, consulte Criar um Azure Quantum workspace.

• Um ambiente Python com Python e Pip instalado.

• VS Code com as extensões Azure Quantum Development Kit, Python, e Jupyter instaladas.

• A biblioteca qdkPython com os extras azure e jupyter, e o pacote ipykernel.

  python -m pip install --upgrade "qdk[azure,jupyter]" ipykernel
  

Execute e teste seu programa no simulador local

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

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

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

   from qdk import qsharp
   import qdk.azure
   

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

   Observação

   Se o JupyterPython kernel ipykernel não for detectado, solicitará VS Code que você o instale.

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

   Observação

   Observe que, assim que você digitar o comando mágico %%qsharp, a célula do bloco de anotações 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();
           results += [r];
       }
       return results
   }
   

5. Para testar sua operação, você pode usar o método eval, 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. Defina o shots, ou número de vezes para executar o programa, e o simulador retorna os resultados como uma Python lista.

   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 qdk.widgets módulo. Este módulo 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 Notebook.

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

from qdk.qsharp import circuit
from qdk.widgets import Circuit

Circuit(circuit("RandomNBits(4)"))

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

Compile seu trabalho usando o perfil Base

Ao executar programas no simulador quântico local, você pode enviar qualquer tipo de Q# programa. No entanto, Azure Quantum o hardware targets ainda não dá suporte aos recursos completos necessários para executar todos os Q# programas. Para compilar e enviar Q# programas para Azure Quantum, você precisa definir seu target perfil para informar Q# sobre quais recursos seu target hardware suporta. Esse é o perfil Base atualmente. Para obter mais informações, consulte tipos de perfil em Azure Quantum.

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

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

   from qdk import init, TargetProfile
   
   init(target_profile=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();
           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:

   from qdk.qsharp import compile
   
   MyProgram = compile("RandomNBits(4)")
   

Azure Quantum Conectar-se e enviar seu trabalho

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

1. Em uma nova célula, preencha a ID do recurso e a localização do seu Azure Quantum workspace:

   from qdk.azure import Workspace
   
   MyWorkspace = 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 qdk.azure módulo 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 capturas 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], ...]
  

Enviar Python com Q# trabalhos para Azure Quantum

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

Pré-requisitos

Para obter detalhes da instalação, consulte Configurar a QDK extensão.

• Um Azure Quantum workspace em sua Azure assinatura. Para criar um workspace, consulte Criar um Azure Quantum workspace.
• Um ambiente Python com Python e Pip instalado.
• VS Code com a extensão Azure Quantum Development Kit e Python instaladas.
• A qdkPython biblioteca com o azure extra.
• Azure CLI com a extensão mais recente Azure Quantum instalada.

Crie e importe suas Q# operações

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

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

2. Abra um novo arquivo de texto, adicione o código a seguir Q# que retorna um número especificado pelo usuário de bits aleatórios e salve o arquivo /src no diretório 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();
           results += [r];
       }
       return results
   }
   

3. Na pasta raiz do projeto (qsharp.json), abra outro arquivo e salve-o como randomNum.py.

4. Adicione o seguinte código para carregar as importações necessárias:

   from qdk import qsharp
   from qdk.azure import Workspace
   

5. Em seguida, adicione o código para definir a pasta raiz do Q# projeto e testar 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 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 por um parâmetro adicional shots e retorna os resultados em uma Python lista. 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]]
   

Compile seu trabalho usando o perfil Base

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

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 qsharp estado, 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)")
   

Azure Quantum Conectar-se e enviar seu trabalho

Você pode se conectar a Azure Quantum e enviar seu trabalho usando um objeto WorkspacePython, ou conectar e enviar seu trabalho usando Azure CLI. O uso Azure da CLI requer que você salve o programa compilado como um arquivo de texto e envie esse arquivo usando um comando da CLI.