Migrar seu Q# código para o QDK Moderno

O Azure Quantum Development Kit (QDK Moderno), lançado em janeiro de 2024, é o kit de desenvolvimento padrão Q# usado no Visual Studio Code e no portal do Azure Quantum. Para obter mais informações sobre os novos recursos e aprimoramentos, consulte Novidades no QDK Moderno.

Se você tiver programas existentes escritos para o Microsoft Quantum Development Kit (QDK clássico), pelo menos alguns elementos precisarão ser modificados para as novas APIs, processos e ferramentas. Além disso, há melhorias na sintaxe da Q# linguagem para tornar a codificação mais fácil e flexível.

Este artigo orienta você nos cenários mais comuns para colocar seu código em funcionamento no novo QDK. S

Preterindo o Visual Studio como uma plataforma de desenvolvimento

O QDK Moderno remove o suporte para o Visual Studio e as bibliotecas quânticas do .NET associadas. Se você tiver projetos existentes do Visual Studio, é altamente recomendável migrá-los para o QDK Moderno usando as diretrizes neste artigo. Para continuar a usar o QDK clássico para seus projetos, confira Continuar trabalhando no QDK clássico.

Importando módulos de um Q# arquivo

Para programas python que usam Q# arquivos (*.qs) para importar Q# funções e operações como módulos, a sintaxe de importação foi alterada.

No QDK Clássico, para importar e executar a Random() operação do arquivo source.qs:

namespace Sample {
    operation Random() : Result {
        use q = Qubit();
        H(q);
        let result = M(q);
        Reset(q);
        return result
    }
}

você usaria a sintaxe de importação padrão do Python:

from Sample import Random

print(Random.simulate())

com o requisito de que source.qs e seu programa Python estavam na mesma pasta.

Para importar a mesma operação com o QDK Moderno, você define um Q# projeto, que permite organizar seus arquivos e bibliotecas de origem de maneira mais eficiente e lógica. Para obter etapas detalhadas para definir um Q# projeto, consulte Trabalhando com Q# projetos.

Depois de configurar suas pastas de projeto e criar um arquivo de manifesto simples, use qsharp.init para apontar para a raiz do projeto e qsharp.eval para acessar os arquivos de origem e importar o <namespace>.<>operation_name.

qsharp.init(project_root = '/MyProjectFolder')
print(qsharp.eval("Sample.Random()"))

Se a operação ou a função que você está importando receber valores de entrada, eles também poderão ser passados:

print(qsharp.eval("Sample.Random(4)"))

Executando seu programa no simulador local

A maioria dos simuladores na memória do QDK Clássico foi preterida, deixando o simulador esparso como o simulador local padrão no VS Code e no portal do Azure Quantum.

Simuladores preteridos:

• Simulador de estado completo
• Simulador de ruído
• Simulador de rastreamento
• Simulador do Toffoli

Para executar o simulador esparso padrão:

Cenário	Método
Em um Q# programa no VS Code	Selecione Executar Q# arquivo
Em uma célula do notebook Python	result=qsharp.eval("EntryPointOperation()") ou result=qsharp.run("EntryPointOperation()", shots=##)
Em uma célula do %%qsharp notebook	EntryPointOperation()

Versão do qubit imposta

O QDK Moderno impõe o requisito de que os qubits estejam no solo ou no estado |0⟩ antes de serem liberados no final de seu escopo. Isso é para impedir que qubits possivelmente sejam reutilizados em um estado inesperado ao executar programas em hardware quântico.

Por exemplo, o código a seguir dispara um erro de runtime:

operation MyOperation() : Result {
    use q = Qubit();
        X(q);
        return M(q);
}

e precisaria ser modificado para redefinir o qubit antes de retornar a medida:

operation MyOperation() : Result {
    use q = Qubit();
        X(q);
        let r = M(q);
        Reset(q);
        return r;
}

ou use uma operação que redefine o qubit como parte da medição:

open Microsoft.Quantum.Measurement;
operation MyOperation() : Result {
    use q = Qubit();
    X(q);
    return MResetZ(q);
}

Configurar o perfil base

Ao contrário do simulador local, os destinos de hardware do Azure Quantum ainda não dão suporte aos recursos completos necessários para executar todos os Q# programas. Se você estiver enviando um trabalho para o Azure Quantum, antes de compilar o programa, precisará definir seu perfil de destino para informar Q# quais recursos o hardware de destino dá suporte. Atualmente, somente programas compatíveis com o Perfil Base do QIR podem ser enviados para o Azure Quantum. Observe que, para executar o código no simulador local, qualquer configuração de perfil pode ser usada.

Código VS

O VS Code exibe o modo de perfil na barra de status na parte inferior dos Q# arquivos, QIR: Base ou Irrestrito. O modo irrestrito é mais útil para executar o código no simulador. Se você estiver enviando um trabalho para o Azure Quantum e receber um aviso de que um programa não está definido para o perfil Base, selecione Irrestrito na barra de status e selecione QIR: Base como o perfil.

Jupyter Notebooks e Python

Para definir o perfil Base, use a qsharp.init função :

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

Observação

• A qsharp.init função substitui o comando magic %azure.target-capability .
• Se você redefinir o perfil de destino, precisará executar novamente suas Q# células ou importações antes de compilar.

Compilando um Q# programa para enviar ao Azure Quantum

Com o QDK moderno, seu programa precisa ser compilado antes de enviar o trabalho para o Azure Quantum.

Observação

Para cenários passo a passo para enviar trabalhos ao Azure Quantum usando Q# programas, programas Python ou Jupyter Notebooks, consulte Enviar trabalhos para o Azure Quantum.

Código VS

Q#os programas no VS Code compilam seu programa automaticamente quando você seleciona um destino de provedor em seu workspace e seleciona Enviar programa atualQ#. Se houver erros do compilador, você poderá depurar o arquivo pressionando F5. Para obter mais informações, consulte Enviar trabalhos para o Azure Quantum.

Jupyter Notebooks e Python

Para programas Jupyter Notebook e Python que usam a Workspace classe para se conectar ao Azure Quantum, você precisa compilar seu programa e enviá-lo para o Azure Quantum com o envio do trabalho.

1. Execute o Q# código que você importou ou escreveu em uma %%qsharp célula.

2. Use a qsharp.compile função , passando a Q# operação ou a função a ser usada como o ponto de entrada. Por exemplo, para este Q# programa:

   operation MyOperation() : Result {
       use q = Qubit();
           H(q);
           let r = M(q);
           Reset(q);
           return r;
   }
   

   você passaria a MyOperation() operação como:

   MyProgram = qsharp.compile("MyOperation()")
   

3. O resultado MyProgram compilado é então passado para o Azure Quantum com a target.submit função :

   job = target.submit(MyProgram, "job name", ...)
   

CLI do Azure

Você também pode usar a CLI do Azure para se conectar e enviar Trabalhos e Q# Python ao Azure Quantum. Para esse cenário, você deve salvar seu programa compilado como um arquivo de texto. Para obter o procedimento passo a passo, consulte Enviar trabalhos para o Azure Quantum.

Conectando-se ao Azure Quantum

Para Q# programas no VS Code, você pode se conectar ao workspace do Azure Quantum e enviar trabalhos dentro do VS Code.

Para programas python e Jupyter Notebook, o método de conexão padrão é a azure.quantum.Workspace classe , que substitui os comandos magic IQ#%azure preteridos e o qsharp.azure módulo . Para obter exemplos de todos esses comandos, consulte Enviar trabalhos para o Azure Quantum.

Comando magic preterido ou API	Uso
%azure.connect qsharp.azure.connect()	wksp = azure.quantum.Workspace( resource_id="", location="")
%azure.target qsharp.azure.target()	target = wksp.get_targets("<target_name>")
%azure.execute qsharp.azure.execute()	job = target.submit(...) E/S sem bloqueio
%azure.submit qsharp.azure.submit()	job = target.submit(<QirInputData>, <jobName>, input_params={"count: <##>"})
%azure.jobs qsharp.azure.jobs()	wksp.list_jobs()
%azure.output qsharp.azure.output()	job.get_results()
%azure. status qsharp.azure. status()	job.details. status
%azure.quotas	wksp.get_quotas()

Outros comandos mágicos preteridos

Comando magic preterido
%check_kata	Preterido
%chemistry.broombridge	Preterido
%chemistry.encode	Preterido
%chemistry.fh.add_terms	Preterido
%chemistry.fh.load	Preterido
%chemistry.inputstate.load	Preterido
%config	Preterido
%debug	Preterido
%experimental.build_info	Preterido
%kata	Preterido
%lsmagic	Preterido
%lsopen	Preterido
%noise_model	Preterido
%package	Preterido
%performance	Preterido
%project	Preterido
%who	Preterido
%workspace	Preterido