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#
No VS Code, selecione Arquivo > Novo Arquivo de Texto e salve o arquivo como RandomNum.qs.
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#
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.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.
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#.Insira várias capturas para executar o programa, por exemplo, 100 capturas e pressione Enter. O histograma será exibido na janela de histograma Q#.
Clique no ícone de configurações superior esquerda para exibir opções.
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.
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()
.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.
Selecione Exibir –> Paleta de Comandos e digite Q#: Conectar-se a um workspace do Azure Quantum. Pressione Enter.
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.
Depois de conectado, no painel Explorer, expanda Workspaces Quânticos.
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.
Selecione rigetti.sim.qvm como seu target.
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.
Adicione um nome para identificar o trabalho.
Adicione o número de capturas ou o número de vezes que o programa é executado.
Pressione Enter para enviar o trabalho. O trabalho status será exibido na parte inferior da tela.
Expanda Trabalhos e passe o mouse sobre seu trabalho, que exibe os horários e status do trabalho.
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-widgets
e eazure-quantum
do Azure Quantumqsharp
e oipykernel
pacote.python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
Executar e testar seu programa no simulador local
No VS Code, selecione Exibir > Paleta de comandos e selecione Create: Novo Jupyter Notebook.
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.
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.- O
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
%%qsharp
magic , 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 }
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]
Para executar seu programa no simulador local, use o
run
método . Especifique o ou oshots
nú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:
Use o
init
método para definir o perfil:qsharp.init(target_profile=qsharp.TargetProfile.Base)
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 }
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.
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" )
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
Selecione o
rigetti.sim.qvm
target:MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")
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]}
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
eazure-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.
Siga as etapas para criar um projeto Q#.
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 } }
Na mesma pasta, abra outro arquivo e salve-o como
randomNum.py
.Adicione o código a seguir para importar os
qsharp
módulos eazure.quantum
.import qsharp import azure.quantum
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]
Você também pode testar a operação com o
run
método , que passa por um parâmetro adicionalshots
e retorna os resultados em uma lista do Python. EmrandomNum.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.
Use o
init
método para definir o perfil:qsharp.init(target_profile=qsharp.TargetProfile.Base)
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.
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.
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" )
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)
Selecione o
rigetti.sim.qvm
target:MyTarget = workspace.get_targets("rigetti.sim.qvm")
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)
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
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
Próximas etapas
Comentários
https://aka.ms/ContentUserFeedback.
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulteEnviar e exibir comentários de