Migrar o código Q# para o QDK Moderno

O Azure Quantum Development Kit (QDK Moderno), lançado em janeiro de 2024, é o kit de desenvolvimento predefinido Q# utilizado no Visual Studio Code e no portal do Azure Quantum. Para obter mais informações sobre as novas funcionalidades e melhorias, veja Novidades no QDK Moderno.

Se tiver programas existentes escritos para o Microsoft Quantum Development Kit (QDK Clássico), pelo menos alguns elementos terão de ser modificados para as novas APIs, processos e ferramentas. Além disso, existem melhorias na sintaxe do Q# idioma para tornar a codificação mais fácil e flexível.

Este artigo orienta-o através dos cenários mais comuns para colocar o código em execução no novo QDK. S

Preterir o Visual Studio como uma plataforma de desenvolvimento

O QDK Moderno remove o suporte para o Visual Studio e as bibliotecas quânticas .NET associadas. Se tiver projetos existentes do Visual Studio, recomendamos vivamente que os migre para o QDK Moderno com a documentação de orientação neste artigo. Para continuar a utilizar o QDK Clássico para os seus projetos, consulte Continuar a trabalhar no QDK Clássico.

Importar módulos de um Q# ficheiro

Para programas Python que utilizam Q# ficheiros (*.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 a partir do ficheiro source.qs:

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

utilizaria a sintaxe de importação padrão do Python:

from Sample import Random

print(Random.simulate())

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

Para importar a mesma operação com o QDK Moderno, defina um Q# projeto, que lhe permite organizar os ficheiros e bibliotecas de origem de uma forma mais eficiente e lógica. Para obter passos detalhados para definir um Q# projeto, veja Trabalhar com Q# projetos.

Depois de configurar as pastas do projeto e criar um ficheiro de manifesto simples, utilize qsharp.init para apontar para a raiz do projeto e qsharp.eval para aceder aos ficheiros de origem e importar o <espaço de nomes>.<>operation_name.

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

Se a operação ou função que está a importar utilizar valores de entrada, estes também podem ser transmitidos:

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

Executar o programa no simulador local

A maioria dos simuladores dentro da memória do QDK Clássico foram preteridos, deixando o simulador disperso como simulador local predefinido no VS Code e no portal do Azure Quantum.

Simuladores preteridos:

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

Para executar o simulador disperso predefinido:

Scenario	Método
Num Q# programa no VS Code	Selecionar Executar Q# ficheiro
Numa célula do bloco de notas python	result=qsharp.eval("EntryPointOperation()") ou result=qsharp.run("EntryPointOperation()", shots=##)
Numa célula do bloco de %%qsharp notas	EntryPointOperation()

Versão de qubit imposta

O QDK Moderno impõe o requisito de que os qubits estejam no solo ou no estado |0⟩ antes de serem lançados no final do âmbito. Isto é para impedir que os qubits sejam reutilizados num estado inesperado ao executar programas em hardware quântico.

Por exemplo, o código seguinte aciona um erro de runtime:

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

e teria de ser modificado para repor o qubit antes de devolver a medição:

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

ou utilize uma operação que repõe 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 suportam todas as capacidades necessárias para executar todos os Q# programas. Se estiver a submeter uma tarefa para o Azure Quantum, antes de compilar o programa, tem de definir o seu perfil de destino para saber Q# quais as capacidades suportadas pelo hardware de destino. Atualmente, apenas os programas em conformidade com o Perfil Base qir podem ser submetidos para o Azure Quantum. Tenha em atenção que, para executar código no simulador local, qualquer configuração de perfil pode ser utilizada.

Código VS

O VS Code apresenta o modo de perfil na barra de estado na parte inferior para Q# ficheiros, QIR: Base ou Sem Restrições. O modo sem restrições é mais útil para executar código no simulador. Se estiver a submeter uma tarefa para o Azure Quantum e receber um aviso de que um programa não está definido para o perfil Base, selecione Sem restrições na barra de estado e selecione QIR: Base como o perfil.

Jupyter Notebooks e Python

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

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

Nota

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

Compilar um Q# programa para submeter ao Azure Quantum

Com o QDK Moderno, o programa tem de ser compilado antes de submeter a tarefa para o Azure Quantum.

Nota

Para cenários passo a passo para submeter tarefas para o Azure Quantum com Q# programas, programas Python ou Jupyter Notebooks, veja Submeter tarefas para o Azure Quantum.

Código VS

Q#os programas no VS Code compilam automaticamente o seu programa quando seleciona um destino de fornecedor na área de trabalho e seleciona Submeter programa atualQ#. Se existirem erros de compilador, pode depurar o ficheiro premindo F5. Para obter mais informações, veja Submeter tarefas para o Azure Quantum.

Jupyter Notebooks e Python

Para Jupyter Notebook e programas Python que utilizam a Workspace classe para ligar ao Azure Quantum, tem de compilar o programa e, em seguida, enviá-lo para o Azure Quantum com a submissão de tarefas.

1. Execute o Q# código que importou ou escreveu numa %%qsharp célula.

2. Utilize a qsharp.compile função, transmitindo a Q# operação ou função para utilizar como 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;
   }
   

   passaria a MyOperation() operação como:

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

3. Em seguida, o resultado MyProgram compilado é transmitido para o Azure Quantum com a target.submit função:

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

CLI do Azure

Também pode utilizar a CLI do Azure para ligar e submeter Python e Q# tarefas para o Azure Quantum. Para este cenário, tem de guardar o programa compilado como um ficheiro de texto. Para obter o procedimento passo a passo, veja Submeter tarefas para o Azure Quantum.

Ligar ao Azure Quantum

Para Q# programas no VS Code, pode ligar-se à sua área de trabalho do Azure Quantum e submeter tarefas no VS Code.

Para os programas Python e Jupyter Notebook, o método de ligação predefinido é a azure.quantum.Workspace classe, que substitui os comandos mágicos IQ#%azure preteridos e o qsharp.azure módulo. Para obter exemplos de todos estes comandos, veja Submeter tarefas para o Azure Quantum.

Comando mágico preterido ou API	Utilização
%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
%depuração	Preterido
%experimental.build_info	Preterido
%kata	Preterido
%lsmagic	Preterido
%lsopen	Preterido
%noise_model	Preterido
%package	Preterido
%performance	Preterido
%project	Preterido
%who	Preterido
%workspace	Preterido