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

Artigo
05/25/2024

Neste artigo, você encontrará as etapas para usar o VC Code 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 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 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 do Azure Quantum.
A versão mais recente do Visual Studio Code ou abra o VS Code na Web.
A versão mais recente da extensão do Azure Quantum Development Kit .

Carregar um programa de exemplo Q#

No VS Code, selecione File > New Text File 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.

Nota

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 do programa localmente no simulador integrado, clique em Executar na lista de comandos abaixo @EntryPoint()ou pressione Ctrl+F5. Sua saída aparecerá no console de depuração.
Para depurar seu programa antes de enviá-lo para o Azure Quantum, clique em Depurar na lista de comandos abaixo @EntryPoint()ou pressione F5. Use os controles de depuração na parte superior para entrar, entrar e sair do código. Para obter mais informações sobre como depurar programas Q#, consulte Testando e depurando.

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 "disparos". 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.

Selecione View -> Command Palette e digite "histograma", que deve exibir a opção Q#: Executar arquivo e mostrar histograma . Você também pode clicar em Histograma na lista de comandos abaixo @EntryPoint(). Selecione esta opção para abrir a janela do histograma Q#.
Insira um número de tiros para executar o programa, por exemplo, 100 tiros e pressione Enter. O histograma será exibido na janela do histograma Q#.
Clique no ícone de configurações no canto superior esquerdo para exibir as opções.
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%.

Gorjeta

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

Selecione View -> Command Palette e digite "circuit" que deve exibir a opção Q#: Show circuit. Você também pode clicar em Circuito na lista de comandos abaixo @EntryPoint().
O circuito é exibido na janela do circuito Q#. 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 ao Azure Quantum e envie seu trabalho

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

Selecione Exibir -> Paleta de Comandos e digite Q#: Conectar-se a um espaço de trabalho do Azure Quantum. Prima Enter.
Selecione Conta do Azure 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 espaço de trabalho do Azure Quantum. Para obter mais informações, consulte Conectar-se a um espaço de trabalho Quantum usando uma cadeia de conexão.
Quando estiver conectado, no painel Explorer, expanda Espaços de trabalho quânticos.
Expanda seu espaço de trabalho e expanda o provedor Rigetti .

Nota

Se houver um problema ao se conectar ao 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.
Selecione rigetti.sim.qvm como seu targetarquivo .
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.
Adicione um nome para identificar o trabalho.
Adicione o número de disparos ou o número de vezes que o programa é executado.
Pressione Enter para enviar o trabalho. O status do trabalho será exibido na parte inferior da tela.
Expanda Trabalhos e passe o mouse sobre seu trabalho, que exibe os horários e o status do seu trabalho.
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 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 Blocos de Anotações do Jupyter em seu servidor Jupyter local ou aos blocos de anotações no portal do Azure Quantum.

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 do Azure Quantum.
Um ambiente Python com Python e Pip instalados.
VS Code com as extensões Azure Quantum Development Kit, Python e Jupyter instaladas.

O Azure Quantum qsharp, qsharp-widgetse azure-quantum pacotes, e o ipykernel pacote.

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

Execute e teste seu programa no simulador local

No VS Code, selecione View > Command palette e selecione Create: New Jupyter Notebook.
No canto superior direito, o VS Code detetará e exibirá a versão do Python e o ambiente Python virtual 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 detetado, consulte Jupyter Notebooks no VS Code para obter informações de configuração.
Na primeira célula do bloco de anotações, 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 magic que permite inserir o %%qsharp código Q# diretamente em uma célula.
- O azure-quantum módulo fornece conectividade ao seu espaço de trabalho do Azure Quantum.
Nota

Se o kernel ipykernel do Jupyter Python não for detetado, o VS Code solicitará que você o instale.

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

Nota

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
}

Para testar sua operação, você pode usar o eval método, que pode chamar qualquer operação Q# previamente definida no bloco de anotações:
```
qsharp.eval("RandomNBits(4)")
```
```
[Zero, One, One, Zero]
```

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

Compile seu trabalho usando o perfil Base

Quando você executa 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 suporta 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 ao Q# quais recursos seu target hardware suporta. Atualmente, esse é o perfil Base. Para obter mais informações, consulte Tipos de perfil no Azure Quantum.

Para reinicializar o interpretador Q# e compilar o 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, 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
}

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:
```
MyProgram = qsharp.compile("RandomNBits(4)")
```

Conecte-se ao Azure Quantum e envie seu trabalho

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

Em uma nova célula, preencha sua ID de recurso e local do seu espaço de trabalho 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 espaço de trabalho:
```
MyTargets = MyWorkspace.get_targets()
print("This workspace's targets:")
MyTargets
```

Selecione a rigetti.sim.qvmtargetopção :

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

Enviando Python com trabalhos 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 Python ou 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 do Azure Quantum.
Um ambiente Python com Python e Pip instalados.
VS Code com o Azure Quantum Development Kit e a extensão Python instalados.
O Azure Quantum qsharp e azure-quantum pacotes.
CLI do Azure com a extensão mais recente do Azure Quantum instalada.

Crie e importe 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 que você chame qualquer um deles a partir do seu 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 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.

Nota

Observe que esse código Q# não tem uma @EntryPoint função como um programa Q# (consulte Enviando trabalhos Q# para o Azure Quantum), mas requer um namespace, ao contrário de um Jupyter Notebook (consulte Enviando trabalhos do 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 pasta raiz do projeto (com o arquivo qsharp.json), abra outro arquivo e salve-o como randomNum.py.
Adicione o seguinte código para importar os qsharp módulos e azure.quantum .
```
import qsharp
import azure.quantum
```
Em seguida, adicione código para definir a pasta raiz do projeto Q# e teste 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 para retornar.
```
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 um parâmetro adicional shots e retorna os resultados em uma lista Python. No 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]]

Compile seu trabalho usando o perfil Base

Nota

Para programas somente 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 seu programa. O programa compilado pode então ser submetido a qualquer hardware quântico:
```
MyProgram = qsharp.compile("Sample.RandomNBits(4)")
```

Conecte-se ao Azure Quantum e envie 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. Usar a CLI do Azure requer que você salve o programa compilado como um arquivo de texto e envie esse arquivo usando um comando da CLI.

Utilizar o Python
Com a CLI do Azure

Adicione o seguinte código ao randomNum.py, preenchendo sua ID de recurso e local do seu espaço de trabalho 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 espaço de trabalho:

MyTargets = workspace.get_targets()
print("This workspace's targets:")
for x in MyTargets:
    print(x)

Selecione a rigetti.sim.qvmtargetopção :

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 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 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': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
Job name: MyPythonJob
Job status: Succeeded
Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f

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

Adicione ao seguinte código ao seu randomNum.py ficheiro. Isso abre um arquivo de texto e grava seu programa compilado no formato adequado.
```
file = open("compiled_output.txt", "w")
file.write(MyProgram._ll_str)
file.close()
```
Para enviar o trabalho para o Azure Quantum, faça logon com a CLI do Azure:
```
az login
```
Verifique se você está executando a versão mais recente da extensão CLI quantum do Azure:
```
az extension add --upgrade --name quantum
```
Especifique a assinatura que você deseja usar daquelas associadas à sua conta do Azure. Você também pode encontrar sua ID de assinatura na visão geral do seu espaço de trabalho no portal do Azure.
```
az account set -s <MySubscriptionID>
```
Veja os espaços de trabalho disponíveis com:
```
az quantum workspace list
```
Você pode 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
```
Exiba o disponível targets em seu espaço de trabalho com:
```
az quantum target list -o table
```
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 string.
- --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
```

Para verificar o status do trabalho, copie o 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

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

Partilhar via

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

Enviando trabalhos Q# para o Azure Quantum

Pré-requisitos

Carregar um programa de exemplo Q#

Executar um programa Q#

Visualize o histograma de frequência

Visualize o circuito quântico

Conecte-se ao Azure Quantum e envie seu trabalho

Enviando trabalhos do Jupyter Notebooks para o Azure Quantum

Pré-requisitos

Execute e teste seu programa no simulador local

Visualize o circuito quântico

Compile seu trabalho usando o perfil Base

Conecte-se ao Azure Quantum e envie seu trabalho

Enviando Python com trabalhos Q# para o Azure Quantum

Pré-requisitos

Crie e importe suas operações Q#

Compile seu trabalho usando o perfil Base

Conecte-se ao Azure Quantum e envie seu trabalho

Próximos passos

Comentários

Comentários

Recursos adicionais