Como enviar Q# programas com Visual Studio Code

Enviar Q# trabalhos para Azure Quantum

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

Pré-requisitos

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

• Um Azure Quantum espaço de trabalho na sua Azure subscrição. Para criar um espaço de trabalho, consulte Criar um Azure Quantum espaço de trabalho.
• A última versão de Visual Studio Code ou abra VS Code na Web.
• A última versão da extensão Azure Quantum Development Kit.

Carregar um Q# programa de exemplo

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.

   

Executar um Q# programa

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 Azure Quantumo , clique em Depurar na lista de comandos ao lado da operação do ponto de entrada ou pressione F5. Use os controlos de depuração na parte superior para passar por cima, entrar e sair do código. Para obter mais informações sobre depuração de Q# programas, consulte Testes e depuração.

   

Visualize o histograma de frequência

O histograma de frequência representa a distribuição dos resultados obtidos ao executar um programa quântico várias vezes, ou "shots". 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 exibe o QDKcomando : Executar arquivo e mostrar histograma . Você também pode escolher Histograma na lista de comandos que precedem a operação do ponto de entrada. Selecione esta opção para abrir a janela de histograma Q#.

   Q# file in Visual Studio Code showing where to find the code lens with histogram command.

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

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. Neste caso, há dois resultados possíveis, 0 e 1, e a percentagem de cada resultado é próxima de 50%.

   

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 circuitos quânticos em Visual Studio Code.

1. Selecione View -> Command Palette e digite circuit, que exibe o QDKcomando : Show circuit . Você também pode selecionar Circuito na lista de comandos ao lado da operação do 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, 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.

   

Conecte-se a Azure Quantum e envie o seu trabalho

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

1. Selecione Exibir -> Paleta de comandos e digiteQDK: Conectar-se a um espaço de Azure Quantum trabalho. Prima Enter.

2. Selecione Azure conta 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 Azure Quantum espaço de trabalho. 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 o seu espaço de trabalho e expanda o provedor Rigetti.

   Nota

   Se houver um problema de conexão com o 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 target.

   

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

   

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 em VS Code.

    

Enviar trabalhos para Azure Quantum a partir 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 espaço de trabalho na sua Azure subscrição. Para criar um espaço de trabalho, consulte Criar um Azure Quantum espaço de trabalho.

• Um Python ambiente com Python e Pip instalados.

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

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

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

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, VS Code detetará 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 detetado, consulte Jupyter Notebooks in VS Code para obter informações de configuração.

3. Na primeira célula do bloco de anotações, 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 comando mágico %%qsharp que permite inserir Q# código diretamente numa cela.
   • O qdk.azure módulo proporciona conectividade ao seu Azure Quantum espaço de trabalho.

   Nota

   Se o JupyterPython kernel ipykernel não for detetado, então VS Code solicitará 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:

   Nota

   Observe que, assim que digitar o comando mágico %%qsharp, a célula do bloco de anotações mudará 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 a sua operação, pode utilizar o método eval, que pode chamar qualquer operação Q# previamente definida no bloco de notas:

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

Podes 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 circuitos quânticos 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

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

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

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

Conecte-se a Azure Quantum e envie o seu trabalho

Agora que tem o seu programa compilado no formato correto, crie um Workspace objeto para ligar a Azure Quantum. Usa o ID de recurso do teu Azure Quantum espaço de trabalho para te ligares. Copie o seu ID de recurso a partir do painel de Visão Geral no seu espaço de trabalho no Azure portal.

1. Numa nova célula, preencha o seu ID de recurso a partir do seu Azure Quantum espaço de trabalho:

   from qdk.azure import Workspace
   
   MyWorkspace = Workspace(resource_id="") # Fill in your resource ID
   

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 qdk.azure módulo inclui métodos adicionais para apresentar dados de trabalho mais detalhados.

• job.get_results_histogram: Este método retorna um dicionário dos resultados e número de tentativas para cada medida única. Por exemplo, os resultados para a função 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 a função 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# tarefas para Azure Quantum

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

Pré-requisitos

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

• Um Azure Quantum espaço de trabalho na sua Azure subscrição. Para criar um espaço de trabalho, consulte Criar um Azure Quantum espaço de trabalho.
• Um Python ambiente com Python e Pip instalados.
• VS Code com a extensão Azure Quantum Development Kit e Python instalada.
• A biblioteca qdkPython com o extra azure.
• Azure CLI com a extensão mais recente Azure Quantum instalada.

Crie e importe as suas Q# operações

Com o qdk.qsharp módulo, podes guardar as tuas funções e operações em Q# ficheiros e criar Q# projetos que te permitem aceder a qualquer um deles a partir do teu 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 /src arquivo no diretório do 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 (com o ficheiro qsharp.json), abra outro ficheiro 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 código para definir a pasta raiz do Q# projeto e teste executar 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 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 Python lista. 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 Q# programa. No entanto, Azure Quantum o hardware targets ainda não suporta todos os recursos necessários para executar todos os Q# programas. Para compilar e enviar Q# programas para o Azure Quantum, você precisa definir seu target perfil para dizer Q# quais recursos seu target hardware suporta. Atualmente, é o perfil Base ou 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)
   

   Nota

   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. 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 a Azure Quantum e envie o seu trabalho

Pode ligar-se a Azure Quantum e submeter o seu trabalho usando um objeto WorkspacePython, ou ligar-se e submeter o seu trabalho usando a Azure CLI. Usar Azure a CLI requer que você salve o programa compilado como um arquivo de texto e envie esse arquivo usando um comando da CLI.